* Kevin Webb 2007/2008
*/
+#include <assert.h>
+
/** The size of the buffer we use to hold tc commands. */
#define CMD_BUFFER_SIZE 200
}
/* Convert weight into a rate - add in our new local weight */
- total_weight = ident->localweight + peer_weights;
+ ident->total_weight = total_weight = ident->localweight + peer_weights;
/* compute local allocation:
if there is traffic elsewhere, use the weights
dropprob = 0.0;
}
- //printf("local rate: %d, aggregate demand: %.3f, drop prob: %.3f\n",
- // ident->common.rate, aggdemand, dropprob);
+ printf("local rate: %d, aggregate demand: %.3f, drop prob: %.3f\n",
+ ident->common.rate, aggdemand, dropprob);
return dropprob;
}
double comm_val = 0;
/* Read comm_val from comm layer. */
- read_comm(&ident->comm, &comm_val);
+ if (limiter->policy == POLICY_FPS) {
+ read_comm(&ident->comm, &comm_val,
+ ident->total_weight / (double) (ident->comm.remote_node_count + 1));
+ } else {
+ read_comm(&ident->comm, &comm_val,
+ (double) (ident->limit / (double) (ident->comm.remote_node_count + 1)));
+ }
printlog(LOG_DEBUG, "%.3f Aggregate weight/rate (FPS/GRD)\n", comm_val);
/* Experimental printing. */
(double) ident->common.rate / (double) 128, ident->id);
ident->avg_bytes += ident->common.rate;
- if (limiter->policynum == POLICY_FPS) {
+ if (limiter->policy == POLICY_FPS) {
ident->locallimit = allocate_fps(ident, comm_val);
ident->last_localweight = ident->localweight;
write_local_value(&ident->comm, ident->localweight);
} else {
ident->locallimit = 0; /* Unused with GRD. */
- ident->last_localdropprob = ident->localdropprob;
- ident->localdropprob = allocate_grd(ident, comm_val);
+ ident->last_drop_prob = ident->drop_prob;
+ ident->drop_prob = allocate_grd(ident, comm_val);
/* Update other limiters with our rate by writing to comm layer. */
write_local_value(&ident->comm, ident->common.rate);
ident->common.last_rate = ident->common.rate;
}
+/**
+ * Traces all of the parent pointers of a leaf all the way to the root in
+ * order to find the maximum drop probability in the chain.
+ */
+static double find_leaf_drop_prob(leaf_t *leaf) {
+ identity_t *current = leaf->parent;
+ double result = 0;
+
+ assert(current);
+
+ while (current != NULL) {
+ if (current->drop_prob > result) {
+ result = current->drop_prob;
+ }
+ current = current->parent;
+ }
+
+ return result;
+}
+
/**
* This is called once per estimate interval to enforce the rate that allocate
* has decided upon. It makes calls to tc using system().
static void enforce(limiter_t *limiter, identity_t *ident) {
char cmd[CMD_BUFFER_SIZE];
int ret = 0;
+ int i = 0;
- switch (limiter->policynum) {
+ switch (limiter->policy) {
case POLICY_FPS:
/* TC treats limits of 0 (8bit) as unlimited, which causes the
break;
case POLICY_GRD:
-/* FIXME: Figure out where to enforce GRD. */
-#if 0
- for (i = 0; i < ident->num_slices; i++){
-
- sprintf(cmd, "/sbin/tc qdisc change dev eth0 parent 1:1%x handle 1%x netem loss %.4f delay 40ms",
- ident->xids[i],ident->xids[i], (100*ident->localdropprob));
-
+ for (i = 0; i < ident->leaf_count; ++i) {
+ if (ident->drop_prob >= ident->leaves[i]->drop_prob) {
+ /* The new drop probability for this identity is greater
+ * than or equal to the leaf's current drop probability.
+ * We can safely use the larger value at this leaf
+ * immediately. */
+ ident->leaves[i]->drop_prob = ident->drop_prob;
+ } else if (ident->last_drop_prob < ident->leaves[i]->drop_prob) {
+ /* The old drop probability for this identity is less than
+ * the leaf's current drop probability. This means that
+ * this identity couldn't have been the limiting ident,
+ * so nothing needs to be done because the old limiting
+ * ident is still the limiting factor. */
+
+ /* Intentionally blank. */
+ } else {
+ /* If neither of the above are true, then...
+ * 1) The new drop probability for the identity is less
+ * than what it previously was, and
+ * 2) This ident may have had the maximum drop probability
+ * of all idents limiting this leaf, and therefore we need
+ * to follow the leaf's parents up to the root to find the
+ * new leaf drop probability safely. */
+ ident->leaves[i]->drop_prob =
+ find_leaf_drop_prob(ident->leaves[i]);
+ }
+
+ /* Make the call to tc. */
+#ifdef DELAY40MS
+ snprintf(cmd, CMD_BUFFER_SIZE,
+ "/sbin/tc qdisc change dev eth0 parent 1:1%x handle 1%x netem loss %.4f delay 40ms",
+ ident->leaves[i]->xid, ident->leaves[i]->xid,
+ (100 * ident->leaves[i]->drop_prob));
+#else
+ snprintf(cmd, CMD_BUFFER_SIZE,
+ "/sbin/tc qdisc change dev eth0 parent 1:1%x handle 1%x netem loss %.4f delay 0ms",
+ ident->leaves[i]->xid, ident->leaves[i]->xid,
+ (100 * ident->leaves[i]->drop_prob));
+#endif
ret = system(cmd);
- if (ret==-1)
- print_system_error(ret);
+ if (ret) {
+ /* FIXME: call failed. What to do? */
+ }
}
-#endif
+
break;
default:
- printlog(LOG_CRITICAL, "DRL enforce: unknown policy %d\n",limiter->policynum);
+ printlog(LOG_CRITICAL, "DRL enforce: unknown policy %d\n",limiter->policy);
break;
}
git://git.onelab.eu / distributedratelimiting.git / blobdiff