Add unit tests for pacing.

Author: huitema

CMakeLists.txt

@@ -158,6 +158,7 @@ set(PICOQUIC_TEST_LIBRARY_FILES
     picoquictest/multipath_test.c
     picoquictest/netperf_test.c
     picoquictest/openssl_test.c
+    picoquictest/pacing_test.c
     picoquictest/parseheadertest.c
     picoquictest/picoquic_lb_test.c
     picoquictest/pn2pn64test.c

UnitTest1/unittest1.cpp

@@ -435,6 +435,13 @@ namespace UnitTest1
         {
             int ret = pacing_test();
 
+            Assert::AreEqual(ret, 0);
+        }
+
+        TEST_METHOD(pacing_repeat)
+        {
+            int ret = pacing_repeat_test();
+
             Assert::AreEqual(ret, 0);
         }
 

picoquic/pacing.c

@@ -23,6 +23,17 @@
 #include <stdlib.h>
 #include <string.h>
 
+
+/* Initialize pacing state to high speed default */
+void picoquic_pacing_init(picoquic_pacing_t* pacing, uint64_t current_time)
+{
+    pacing->evaluation_time = current_time;
+    pacing->bucket_nanosec = 16;
+    pacing->bucket_max = 16;
+    pacing->packet_time_nanosec = 1;
+    pacing->packet_time_microsec = 1;
+}
+
 /* Compute nanosec per packet */
 static uint64_t picoquic_pacing_time_nanosec(picoquic_pacing_t* pacing, size_t length)
 {
@@ -52,6 +63,14 @@ static void picoquic_update_pacing_bucket(picoquic_pacing_t* pacing, uint64_t cu
     }
 }
 
+/* Check whether pacing authorizes immediate transmission, 
+* no not send any state
+ */
+int picoquic_is_pacing_blocked(picoquic_pacing_t* pacing)
+{
+    return (pacing->bucket_nanosec < pacing->packet_time_nanosec);
+}
+
 /*
 * Check pacing to see whether the next transmission is authorized.
 * If if is not, update the next wait time to reflect pacing.
@@ -87,7 +106,9 @@ int picoquic_is_authorized_by_pacing(picoquic_pacing_t * pacing, uint64_t curren
         if (next_pacing_time < *next_time) {
             pacing->bandwidth_pause = 0;
             *next_time = next_pacing_time;
-            SET_LAST_WAKE(quic, PICOQUIC_SENDER);
+            if (quic != NULL) {
+                SET_LAST_WAKE(quic, PICOQUIC_SENDER);
+            }
         }
         ret = 0;
     }

picoquic/picoquic_internal.h

@@ -991,24 +991,25 @@ typedef struct st_picoquic_remote_cnxid_stash_t {
 * Pacing uses a set of per path variables:
 * - rate: bytes per second.
 * - evaluation_time: last time the path was evaluated.
-* - bucket_nanosec: number of nanoseconds of transmission time that are allowed.
 * - bucket_max: maximum value (capacity) of the leaky bucket.
-* - packet_time_nanosec: number of nanoseconds required to send a full size packet.
 * - packet_time_microsec: max of (packet_time_nano_sec/1024, 1) microsec.
+* Internal variables:
+* - bucket_nanosec: number of nanoseconds of transmission time that are allowed.
+* - packet_time_nanosec: number of nanoseconds required to send a full size packet.
 */
 typedef struct st_picoquic_pacing_t {
     uint64_t rate;
     uint64_t evaluation_time;
-    int64_t bucket_nanosec;
     int64_t bucket_max;
-    int64_t packet_time_nanosec;
     uint64_t packet_time_microsec;
     uint64_t quantum_max;
     uint64_t rate_max;
     int bandwidth_pause;
+    /* High precision variables should only be used inside pacing.c */
+    int64_t bucket_nanosec;
+    int64_t packet_time_nanosec;
 } picoquic_pacing_t;
 
-
 /*
 * Per path context.
 * Path contexts are created:
@@ -1177,30 +1178,7 @@ typedef struct st_picoquic_path_t {
     uint64_t last_cwin_blocked_time;
     uint64_t last_time_acked_data_frame_sent;
     void* congestion_alg_state;
-
-#if 1
     picoquic_pacing_t pacing;
-#else
-    /*
-    * Pacing uses a set of per path variables:
-    * - pacing_rate: bytes per second.
-    * - pacing_evaluation_time: last time the path was evaluated.
-    * - pacing_bucket_nanosec: number of nanoseconds of transmission time that are allowed.
-    * - pacing_bucket_max: maximum value (capacity) of the leaky bucket.
-    * - pacing_packet_time_nanosec: number of nanoseconds required to send a full size packet.
-    * - pacing_packet_time_microsec: max of (packet_time_nano_sec/1024, 1) microsec.
-    */
-
-    uint64_t pacing_rate;
-    uint64_t pacing_evaluation_time;
-    int64_t pacing_bucket_nanosec;
-    int64_t pacing_bucket_max;
-    int64_t pacing_packet_time_nanosec;
-    uint64_t pacing_packet_time_microsec;
-    uint64_t pacing_quantum_max;
-    uint64_t pacing_rate_max;
-    int pacing_bandwidth_pause;
-#endif
 
     /* MTU safety tracking */
     uint64_t nb_mtu_losses;
@@ -1639,6 +1617,8 @@ picoquic_cnx_t* picoquic_cnx_by_icid(picoquic_quic_t* quic, picoquic_connection_
 picoquic_cnx_t* picoquic_cnx_by_secret(picoquic_quic_t* quic, const uint8_t* reset_secret, const struct sockaddr* addr);
 
 /* Pacing implementation */
+void picoquic_pacing_init(picoquic_pacing_t* pacing, uint64_t current_time);
+int picoquic_is_pacing_blocked(picoquic_pacing_t* pacing);
 int picoquic_is_authorized_by_pacing(picoquic_pacing_t* pacing, uint64_t current_time, uint64_t* next_time, unsigned int packet_train_mode, picoquic_quic_t * quic);
 void picoquic_update_pacing_parameters(picoquic_pacing_t* pacing, double pacing_rate, uint64_t quantum, size_t send_mtu, uint64_t smoothed_rtt,
     picoquic_path_t* signalled_path);

picoquic/quicctx.c

@@ -1535,11 +1535,7 @@ int picoquic_create_path(picoquic_cnx_t* cnx, uint64_t start_time, const struct
             path_x->congestion_alg_state = NULL;
 
             /* Initialize per path pacing state */
-            path_x->pacing.evaluation_time = start_time;
-            path_x->pacing.bucket_nanosec = 16;
-            path_x->pacing.bucket_max = 16;
-            path_x->pacing.packet_time_nanosec = 1;
-            path_x->pacing.packet_time_microsec = 1;
+            picoquic_pacing_init(&path_x->pacing, start_time);
 
             /* Initialize the MTU */
             path_x->send_mtu = (peer_addr == NULL || peer_addr->sa_family == AF_INET) ? PICOQUIC_INITIAL_MTU_IPV4 : PICOQUIC_INITIAL_MTU_IPV6;

picoquic/sender.c

@@ -913,228 +913,6 @@ static size_t picoquic_protect_packet(picoquic_cnx_t* cnx,
     return send_length;
 }
 
-#if 0
-/* Compute nanosec per packet */
-uint64_t picoquic_packet_time_nanosec(picoquic_path_t* path_x, size_t length)
-{
-    const uint64_t nanosec_per_sec = 1000000000ull;
-    uint64_t packet_time_nanosec = (nanosec_per_sec * length + (path_x->pacing_rate - 1)) / path_x->pacing_rate;
-
-    return packet_time_nanosec;
-}
-
-/* Update the leaky bucket used for pacing.
- */
-static void picoquic_update_pacing_bucket(picoquic_path_t * path_x, uint64_t current_time)
-{
-    if (path_x->pacing.bucket_nanosec < -path_x->pacing_packet_time_nanosec) {
-        path_x->pacing.bucket_nanosec = -path_x->pacing_packet_time_nanosec;
-    }
-
-    if (current_time > path_x->pacing_evaluation_time) {
-        path_x->pacing.bucket_nanosec += (current_time - path_x->pacing_evaluation_time) * 1000;
-        path_x->pacing_evaluation_time = current_time;
-        if (path_x->pacing.bucket_nanosec > path_x->pacing_bucket_max) {
-            path_x->pacing.bucket_nanosec = path_x->pacing_bucket_max;
-        }
-    }
-}
-
-/*
- * Check pacing to see whether the next transmission is authorized.
- * If if is not, update the next wait time to reflect pacing.
- * 
- * In packet train mode, the wait will last until the bucket is completely full, or
- * if at least N packets are received.
- */
-int picoquic_is_sending_authorized_by_pacing(picoquic_cnx_t * cnx, picoquic_path_t * path_x, uint64_t current_time, uint64_t * next_time)
-{
-    int ret = 1;
-
-    picoquic_update_pacing_bucket(path_x, current_time);
-
-    if (path_x->pacing.bucket_nanosec < path_x->pacing_packet_time_nanosec) {
-        uint64_t next_pacing_time;
-        int64_t bucket_required;
-        
-        if (cnx->quic->packet_train_mode || path_x->pacing_bandwidth_pause) {
-            bucket_required = path_x->pacing_bucket_max;
-
-            if (bucket_required > 10 * path_x->pacing_packet_time_nanosec) {
-                bucket_required = 10 * path_x->pacing_packet_time_nanosec;
-            }
-            
-            bucket_required -= path_x->pacing.bucket_nanosec;
-        }
-        else {
-            bucket_required = path_x->pacing_packet_time_nanosec - path_x->pacing_bucket_nanosec;
-        }
-
-        next_pacing_time = current_time + 1 + bucket_required / 1000;
-        if (next_pacing_time < *next_time) {
-            path_x->pacing_bandwidth_pause = 0;
-            *next_time = next_pacing_time;
-            SET_LAST_WAKE(cnx->quic, PICOQUIC_SENDER);
-        }
-        ret = 0;
-    }
-
-    return ret;
-}
-
-/* Handle reporting of parameter updates if path is specified.
- */
-
-/* Reset the pacing data after recomputing the pacing rate
- */
-void picoquic_update_pacing_rate(picoquic_cnx_t * cnx, picoquic_path_t* path_x, double pacing_rate, uint64_t quantum)
-{
-#if 0
-    const uint64_t nanosec_per_sec = 1000000000ull;
-
-    path_x->pacing_rate = (uint64_t)pacing_rate;
-
-    if (quantum > path_x->pacing_quantum_max) {
-        path_x->pacing_quantum_max = quantum;
-    }
-    if (path_x->pacing_rate > path_x->pacing_rate_max) {
-        path_x->pacing_rate_max = path_x->pacing_rate;
-    }
-
-    path_x->pacing_packet_time_nanosec = picoquic_packet_time_nanosec(path_x, path_x->send_mtu);
-
-    path_x->pacing_bucket_max = (nanosec_per_sec * quantum) / path_x->pacing_rate;
-    if (path_x->pacing_bucket_max <= 0) {
-        path_x->pacing_bucket_max = 16 * path_x->pacing_packet_time_nanosec;
-    }
-
-#else
-    double packet_time = (double)path_x->send_mtu / pacing_rate;
-    double quantum_time = (double)quantum / pacing_rate;
-    uint64_t rtt_nanosec = path_x->smoothed_rtt * 1000;
-
-    path_x->pacing_rate = (uint64_t)pacing_rate;
-
-    if (quantum > path_x->pacing_quantum_max) {
-        path_x->pacing_quantum_max = quantum;
-    }
-    if (path_x->pacing_rate > path_x->pacing_rate_max) {
-        path_x->pacing_rate_max = path_x->pacing_rate;
-    }
-
-    path_x->pacing_packet_time_nanosec = (uint64_t)(packet_time * 1000000000.0);
-
-    if (path_x->pacing_packet_time_nanosec <= 0) {
-        path_x->pacing_packet_time_nanosec = 1;
-        path_x->pacing_packet_time_microsec = 1;
-    }
-    else {
-        if ((uint64_t)path_x->pacing_packet_time_nanosec > rtt_nanosec) {
-            path_x->pacing_packet_time_nanosec = rtt_nanosec;
-        }
-        path_x->pacing_packet_time_microsec = (path_x->pacing_packet_time_nanosec + 999ull) / 1000;
-    }
-
-    path_x->pacing_bucket_max = (uint64_t)(quantum_time * 1000000000.0);
-    if (path_x->pacing_bucket_max <= 0) {
-        path_x->pacing_bucket_max = 16 * path_x->pacing_packet_time_nanosec;
-    }
-#endif
-
-    if (path_x->pacing_bucket_nanosec > path_x->pacing_bucket_max) {
-        path_x->pacing_bucket_nanosec = path_x->pacing_bucket_max;
-    }
-
-    if (cnx->is_pacing_update_requested && path_x == cnx->path[0] &&
-        cnx->callback_fn != NULL) {
-        if ((path_x->pacing_rate > cnx->pacing_rate_signalled &&
-            (path_x->pacing_rate - cnx->pacing_rate_signalled >= cnx->pacing_increase_threshold)) ||
-            (path_x->pacing_rate < cnx->pacing_rate_signalled &&
-            (cnx->pacing_rate_signalled - path_x->pacing_rate > cnx->pacing_decrease_threshold))){
-            (void)cnx->callback_fn(cnx, path_x->pacing_rate, NULL, 0, picoquic_callback_pacing_changed, cnx->callback_ctx, NULL);
-            cnx->pacing_rate_signalled = path_x->pacing_rate;
-        }
-    }
-    if (cnx->is_path_quality_update_requested &&
-        cnx->callback_fn != NULL) {
-        /* TODO: add a function "export path quality" */
-        /* TODO: remember previous signalled value for change tests */
-        if (path_x->smoothed_rtt < path_x->rtt_threshold_low ||
-            path_x->smoothed_rtt > path_x->rtt_threshold_high ||
-            path_x->pacing_rate < path_x->pacing_rate_threshold_low ||
-            path_x->pacing_rate > path_x->pacing_rate_threshold_high) {
-            (void)cnx->callback_fn(cnx, path_x->unique_path_id, NULL, 0, picoquic_callback_path_quality_changed, cnx->callback_ctx, path_x->app_path_ctx);
-            picoquic_refresh_path_quality_thresholds(path_x);
-        }
-    }
-}
-
-/*
- * Reset the pacing data after CWIN is updated.
- * The max bucket is set to contain at least 2 packets more than 1/8th of the congestion window.
- */
-
-void picoquic_update_pacing_data(picoquic_cnx_t* cnx, picoquic_path_t * path_x, int slow_start)
-{
-    uint64_t rtt_nanosec = path_x->smoothed_rtt * 1000;
-
-    if ((path_x->cwin < ((uint64_t)path_x->send_mtu) * 8) || rtt_nanosec <= 1000) {
-        /* Small windows, should only relie on ACK clocking */
-        path_x->pacing_bucket_max = rtt_nanosec;
-        path_x->pacing_packet_time_nanosec = 1;
-        path_x->pacing_packet_time_microsec = 1;
-
-        if (path_x->pacing_bucket_nanosec > path_x->pacing_bucket_max) {
-            path_x->pacing_bucket_nanosec = path_x->pacing_bucket_max;
-        }
-    }
-    else {
-        double pacing_rate = ((double)path_x->cwin / (double)rtt_nanosec) * 1000000000.0;
-        uint64_t quantum = path_x->cwin / 4;
-
-        if (quantum < 2ull * path_x->send_mtu) {
-            quantum = 2ull * path_x->send_mtu;
-        }
-        else {
-            if (slow_start && path_x->smoothed_rtt > 4*PICOQUIC_MAX_BANDWIDTH_TIME_INTERVAL_MAX) {
-                const uint64_t quantum_min = 0x8000;
-                if (quantum  < quantum_min){
-                    quantum = quantum_min;
-                }
-                else {
-                    uint64_t quantum2 = (uint64_t)((pacing_rate * PICOQUIC_MAX_BANDWIDTH_TIME_INTERVAL_MAX) / 1000000.0);
-                    if (quantum2 > quantum) {
-                        quantum = quantum2;
-                    }
-                }
-            }
-            else if (quantum > 16ull * path_x->send_mtu) {
-                quantum = 16ull * path_x->send_mtu;
-            }
-
-        }
-
-        if (slow_start) {
-            pacing_rate *= 1.25;
-        }
-
-        picoquic_update_pacing_rate(cnx, path_x, pacing_rate, quantum);
-    }
-}
-
-/* 
- * Update the pacing data after sending a packet.
- */
-void picoquic_update_pacing_after_send(picoquic_path_t * path_x, size_t length, uint64_t current_time)
-{
-    uint64_t packet_time_nanosec;
-
-    picoquic_update_pacing_bucket(path_x, current_time);
-
-    packet_time_nanosec = ((path_x->pacing_packet_time_nanosec * (uint64_t)length) + (path_x->send_mtu - 1)) / path_x->send_mtu;
-    path_x->pacing_bucket_nanosec -= packet_time_nanosec;
-}
-#endif
 /*
  * Final steps in packet transmission: queue for retransmission, etc
  */
@@ -4678,7 +4456,7 @@ int picoquic_prepare_packet_ex(picoquic_cnx_t* cnx,
                         if (cnx->path[path_id]->cwin <= cnx->path[path_id]->bytes_in_transit) {
                             cnx->nb_trains_blocked_cwin++;
                         }
-                        else if (cnx->path[path_id]->pacing.bucket_nanosec < cnx->path[path_id]->pacing.packet_time_nanosec){
+                        else if (picoquic_is_pacing_blocked(&cnx->path[path_id]->pacing)) {
                             cnx->nb_trains_blocked_pacing++;
                         }
                         else {

picoquic_t/picoquic_t.c

@@ -105,6 +105,7 @@ static const picoquic_test_def_t test_table[] = {
     { "new_cnxid_stash", cnxid_stash_test },
     { "new_cnxid", new_cnxid_test },
     { "pacing", pacing_test },
+    { "pacing_repeat", pacing_repeat_test },
 #if 0
     /* The TLS API connect test is only useful when debugging issues step by step */
     { "tls_api_connect", tls_api_connect_test },