Start re-refactoring the token bucket interface.

Begin by creating a lowest-level triple of the types needed to
implement a token bucket: a configuration, a timestamp, and the raw
bucket itself.

Note that for low-level buckets, the units of the timestamp and the
bucket itself are unspecified: each user can use a different type.

(This patch breaks check-spaces; a later patch will fix it)

1 files changed, 49 insertions, 50 deletions

diff --git a/src/test/test_bwmgt.c b/src/test/test_bwmgt.c
index 9e4748af7f..17914aeb97 100644
--- a/src/test/test_bwmgt.c
+++ b/src/test/test_bwmgt.c
@@ -25,19 +25,19 @@ test_bwmgt_token_buf_init(void *arg)
 
   token_bucket_rw_init(&b, 16*KB, 64*KB, START_TS);
   // Burst is correct
-  tt_uint_op(b.burst, OP_EQ, 64*KB);
+  tt_uint_op(b.cfg.burst, OP_EQ, 64*KB);
   // Rate is correct, within 1 percent.
   {
     uint32_t ticks_per_sec =
       (uint32_t) monotime_msec_to_approx_coarse_stamp_units(1000);
-    uint32_t rate_per_sec = (b.rate * ticks_per_sec / TICKS_PER_STEP);
+    uint32_t rate_per_sec = (b.cfg.rate * ticks_per_sec / TICKS_PER_STEP);
 
     tt_uint_op(rate_per_sec, OP_GT, 16*KB-160);
     tt_uint_op(rate_per_sec, OP_LT, 16*KB+160);
   }
   // Bucket starts out full:
-  tt_uint_op(b.last_refilled_at_ts, OP_EQ, START_TS);
-  tt_int_op(b.read_bucket, OP_EQ, 64*KB);
+  tt_uint_op(b.stamp.last_refilled_at, OP_EQ, START_TS);
+  tt_int_op(b.read_bucket.bucket, OP_EQ, 64*KB);
 
  done:
   ;
@@ -51,31 +51,31 @@ test_bwmgt_token_buf_adjust(void *arg)
 
   token_bucket_rw_init(&b, 16*KB, 64*KB, START_TS);
 
-  uint32_t rate_orig = b.rate;
+  uint32_t rate_orig = b.cfg.rate;
   // Increasing burst
   token_bucket_rw_adjust(&b, 16*KB, 128*KB);
-  tt_uint_op(b.rate, OP_EQ, rate_orig);
-  tt_uint_op(b.read_bucket, OP_EQ, 64*KB);
-  tt_uint_op(b.burst, OP_EQ, 128*KB);
+  tt_uint_op(b.cfg.rate, OP_EQ, rate_orig);
+  tt_uint_op(b.read_bucket.bucket, OP_EQ, 64*KB);
+  tt_uint_op(b.cfg.burst, OP_EQ, 128*KB);
 
   // Decreasing burst but staying above bucket
   token_bucket_rw_adjust(&b, 16*KB, 96*KB);
-  tt_uint_op(b.rate, OP_EQ, rate_orig);
-  tt_uint_op(b.read_bucket, OP_EQ, 64*KB);
-  tt_uint_op(b.burst, OP_EQ, 96*KB);
+  tt_uint_op(b.cfg.rate, OP_EQ, rate_orig);
+  tt_uint_op(b.read_bucket.bucket, OP_EQ, 64*KB);
+  tt_uint_op(b.cfg.burst, OP_EQ, 96*KB);
 
   // Decreasing burst below bucket,
   token_bucket_rw_adjust(&b, 16*KB, 48*KB);
-  tt_uint_op(b.rate, OP_EQ, rate_orig);
-  tt_uint_op(b.read_bucket, OP_EQ, 48*KB);
-  tt_uint_op(b.burst, OP_EQ, 48*KB);
+  tt_uint_op(b.cfg.rate, OP_EQ, rate_orig);
+  tt_uint_op(b.read_bucket.bucket, OP_EQ, 48*KB);
+  tt_uint_op(b.cfg.burst, OP_EQ, 48*KB);
 
   // Changing rate.
   token_bucket_rw_adjust(&b, 32*KB, 48*KB);
-  tt_uint_op(b.rate, OP_GE, rate_orig*2 - 10);
-  tt_uint_op(b.rate, OP_LE, rate_orig*2 + 10);
-  tt_uint_op(b.read_bucket, OP_EQ, 48*KB);
-  tt_uint_op(b.burst, OP_EQ, 48*KB);
+  tt_uint_op(b.cfg.rate, OP_GE, rate_orig*2 - 10);
+  tt_uint_op(b.cfg.rate, OP_LE, rate_orig*2 + 10);
+  tt_uint_op(b.read_bucket.bucket, OP_EQ, 48*KB);
+  tt_uint_op(b.cfg.burst, OP_EQ, 48*KB);
 
  done:
   ;
@@ -90,29 +90,29 @@ test_bwmgt_token_buf_dec(void *arg)
 
   // full-to-not-full.
   tt_int_op(0, OP_EQ, token_bucket_rw_dec_read(&b, KB));
-  tt_int_op(b.read_bucket, OP_EQ, 63*KB);
+  tt_int_op(b.read_bucket.bucket, OP_EQ, 63*KB);
 
   // Full to almost-not-full
   tt_int_op(0, OP_EQ, token_bucket_rw_dec_read(&b, 63*KB - 1));
-  tt_int_op(b.read_bucket, OP_EQ, 1);
+  tt_int_op(b.read_bucket.bucket, OP_EQ, 1);
 
   // almost-not-full to empty.
   tt_int_op(1, OP_EQ, token_bucket_rw_dec_read(&b, 1));
-  tt_int_op(b.read_bucket, OP_EQ, 0);
+  tt_int_op(b.read_bucket.bucket, OP_EQ, 0);
 
   // reset bucket, try full-to-empty
   token_bucket_rw_init(&b, 16*KB, 64*KB, START_TS);
   tt_int_op(1, OP_EQ, token_bucket_rw_dec_read(&b, 64*KB));
-  tt_int_op(b.read_bucket, OP_EQ, 0);
+  tt_int_op(b.read_bucket.bucket, OP_EQ, 0);
 
   // reset bucket, try underflow.
   token_bucket_rw_init(&b, 16*KB, 64*KB, START_TS);
   tt_int_op(1, OP_EQ, token_bucket_rw_dec_read(&b, 64*KB + 1));
-  tt_int_op(b.read_bucket, OP_EQ, -1);
+  tt_int_op(b.read_bucket.bucket, OP_EQ, -1);
 
   // A second underflow does not make the bucket empty.
   tt_int_op(0, OP_EQ, token_bucket_rw_dec_read(&b, 1000));
-  tt_int_op(b.read_bucket, OP_EQ, -1001);
+  tt_int_op(b.read_bucket.bucket, OP_EQ, -1001);
 
  done:
   ;
@@ -125,68 +125,67 @@ test_bwmgt_token_buf_refill(void *arg)
   token_bucket_rw_t b;
   const uint32_t SEC =
     (uint32_t)monotime_msec_to_approx_coarse_stamp_units(1000);
-  printf("%d\n", (int)SEC);
   token_bucket_rw_init(&b, 16*KB, 64*KB, START_TS);
 
   /* Make the buffer much emptier, then let one second elapse. */
   token_bucket_rw_dec_read(&b, 48*KB);
-  tt_int_op(b.read_bucket, OP_EQ, 16*KB);
+  tt_int_op(b.read_bucket.bucket, OP_EQ, 16*KB);
   tt_int_op(0, OP_EQ, token_bucket_rw_refill(&b, START_TS + SEC));
-  tt_int_op(b.read_bucket, OP_GT, 32*KB - 300);
-  tt_int_op(b.read_bucket, OP_LT, 32*KB + 300);
+  tt_int_op(b.read_bucket.bucket, OP_GT, 32*KB - 300);
+  tt_int_op(b.read_bucket.bucket, OP_LT, 32*KB + 300);
 
   /* Another half second. */
   tt_int_op(0, OP_EQ, token_bucket_rw_refill(&b, START_TS + SEC*3/2));
-  tt_int_op(b.read_bucket, OP_GT, 40*KB - 400);
-  tt_int_op(b.read_bucket, OP_LT, 40*KB + 400);
-  tt_uint_op(b.last_refilled_at_ts, OP_EQ, START_TS + SEC*3/2);
+  tt_int_op(b.read_bucket.bucket, OP_GT, 40*KB - 400);
+  tt_int_op(b.read_bucket.bucket, OP_LT, 40*KB + 400);
+  tt_uint_op(b.stamp.last_refilled_at, OP_EQ, START_TS + SEC*3/2);
 
   /* No time: nothing happens. */
   {
-    const uint32_t bucket_orig = b.read_bucket;
+    const uint32_t bucket_orig = b.read_bucket.bucket;
     tt_int_op(0, OP_EQ, token_bucket_rw_refill(&b, START_TS + SEC*3/2));
-    tt_int_op(b.read_bucket, OP_EQ, bucket_orig);
+    tt_int_op(b.read_bucket.bucket, OP_EQ, bucket_orig);
   }
 
   /* Another 30 seconds: fill the bucket. */
   tt_int_op(0, OP_EQ, token_bucket_rw_refill(&b, START_TS + SEC*3/2 + SEC*30));
-  tt_int_op(b.read_bucket, OP_EQ, b.burst);
-  tt_uint_op(b.last_refilled_at_ts, OP_EQ, START_TS + SEC*3/2 + SEC*30);
+  tt_int_op(b.read_bucket.bucket, OP_EQ, b.cfg.burst);
+  tt_uint_op(b.stamp.last_refilled_at, OP_EQ, START_TS + SEC*3/2 + SEC*30);
 
   /* Another 30 seconds: nothing happens. */
   tt_int_op(0, OP_EQ, token_bucket_rw_refill(&b, START_TS + SEC*3/2 + SEC*60));
-  tt_int_op(b.read_bucket, OP_EQ, b.burst);
-  tt_uint_op(b.last_refilled_at_ts, OP_EQ, START_TS + SEC*3/2 + SEC*60);
+  tt_int_op(b.read_bucket.bucket, OP_EQ, b.cfg.burst);
+  tt_uint_op(b.stamp.last_refilled_at, OP_EQ, START_TS + SEC*3/2 + SEC*60);
 
   /* Empty the bucket, let two seconds pass, and make sure that a refill is
    * noticed. */
-  tt_int_op(1, OP_EQ, token_bucket_rw_dec_read(&b, b.burst));
-  tt_int_op(0, OP_EQ, b.read_bucket);
+  tt_int_op(1, OP_EQ, token_bucket_rw_dec_read(&b, b.cfg.burst));
+  tt_int_op(0, OP_EQ, b.read_bucket.bucket);
   tt_int_op(1, OP_EQ, token_bucket_rw_refill(&b, START_TS + SEC*3/2 + SEC*61));
   tt_int_op(0, OP_EQ, token_bucket_rw_refill(&b, START_TS + SEC*3/2 + SEC*62));
-  tt_int_op(b.read_bucket, OP_GT, 32*KB-400);
-  tt_int_op(b.read_bucket, OP_LT, 32*KB+400);
+  tt_int_op(b.read_bucket.bucket, OP_GT, 32*KB-400);
+  tt_int_op(b.read_bucket.bucket, OP_LT, 32*KB+400);
 
   /* Underflow the bucket, make sure we detect when it has tokens again. */
-  tt_int_op(1, OP_EQ, token_bucket_rw_dec_read(&b, b.read_bucket+16*KB));
-  tt_int_op(-16*KB, OP_EQ, b.read_bucket);
+  tt_int_op(1, OP_EQ, token_bucket_rw_dec_read(&b, b.read_bucket.bucket+16*KB));
+  tt_int_op(-16*KB, OP_EQ, b.read_bucket.bucket);
   // half a second passes...
   tt_int_op(0, OP_EQ, token_bucket_rw_refill(&b, START_TS + SEC*64));
-  tt_int_op(b.read_bucket, OP_GT, -8*KB-300);
-  tt_int_op(b.read_bucket, OP_LT, -8*KB+300);
+  tt_int_op(b.read_bucket.bucket, OP_GT, -8*KB-300);
+  tt_int_op(b.read_bucket.bucket, OP_LT, -8*KB+300);
   // a second passes
   tt_int_op(1, OP_EQ, token_bucket_rw_refill(&b, START_TS + SEC*65));
-  tt_int_op(b.read_bucket, OP_GT, 8*KB-400);
-  tt_int_op(b.read_bucket, OP_LT, 8*KB+400);
+  tt_int_op(b.read_bucket.bucket, OP_GT, 8*KB-400);
+  tt_int_op(b.read_bucket.bucket, OP_LT, 8*KB+400);
 
   // We step a second backwards, and nothing happens.
   tt_int_op(0, OP_EQ, token_bucket_rw_refill(&b, START_TS + SEC*64));
-  tt_int_op(b.read_bucket, OP_GT, 8*KB-400);
-  tt_int_op(b.read_bucket, OP_LT, 8*KB+400);
+  tt_int_op(b.read_bucket.bucket, OP_GT, 8*KB-400);
+  tt_int_op(b.read_bucket.bucket, OP_LT, 8*KB+400);
 
   // A ridiculous amount of time passes.
   tt_int_op(0, OP_EQ, token_bucket_rw_refill(&b, INT32_MAX));
-  tt_int_op(b.read_bucket, OP_EQ, b.burst);
+  tt_int_op(b.read_bucket.bucket, OP_EQ, b.cfg.burst);
 
  done:
   ;