X-Git-Url: http://git.onelab.eu/?p=distributedratelimiting.git;a=blobdiff_plain;f=drl%2Festimate.c;h=ed08447b1b378413532acc2b5bf1427ae8f213d0;hp=f1dd142557caf0519aa15641315b7bac07cd58e1;hb=19bf89f36a91be2fdd4a0b6c7099f7515507e1e1;hpb=a3995c9ac407020dcdc5c471191b767bb1667d2e diff --git a/drl/estimate.c b/drl/estimate.c index f1dd142..ed08447 100644 --- a/drl/estimate.c +++ b/drl/estimate.c @@ -7,6 +7,8 @@ * Kevin Webb 2007/2008 */ +#include + /** The size of the buffer we use to hold tc commands. */ #define CMD_BUFFER_SIZE 200 @@ -204,7 +206,7 @@ static uint32_t allocate_fps(identity_t *ident, double total_weight) { } /* 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 @@ -258,8 +260,8 @@ static double allocate_grd(identity_t *ident, double aggdemand) { 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; } @@ -273,7 +275,13 @@ static void allocate(limiter_t *limiter, identity_t *ident) { 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. */ @@ -281,7 +289,7 @@ static void allocate(limiter_t *limiter, identity_t *ident) { (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; @@ -289,8 +297,8 @@ static void allocate(limiter_t *limiter, identity_t *ident) { 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); @@ -300,6 +308,26 @@ static void allocate(limiter_t *limiter, identity_t *ident) { 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(). @@ -307,8 +335,9 @@ static void allocate(limiter_t *limiter, identity_t *ident) { 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 @@ -344,23 +373,56 @@ static void enforce(limiter_t *limiter, identity_t *ident) { 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; }