[jumpstart] use packets as the unit for consistency with IW

Author: kazuho

include/quicly.h

@@ -330,12 +330,12 @@ struct st_quicly_context_t {
      * Jumpstart CWND to be used when there is no previous information. If set to zero, slow start is used. Note jumpstart is
      * possible only when the use_pacing flag is set.
      */
-    uint32_t default_jumpstart_cwnd_bytes;
+    uint32_t default_jumpstart_cwnd_packets;
     /**
      * Maximum jumpstart CWND to be used for connections with previous delivery rate information (i.e., resuming connections). If
      * set to zero, slow start is used.
      */
-    uint32_t max_jumpstart_cwnd_bytes;
+    uint32_t max_jumpstart_cwnd_packets;
     /**
      * expand client hello so that it does not fit into one datagram
      */

lib/cc-reno.c

@@ -162,5 +162,6 @@ uint32_t quicly_cc_calc_initial_cwnd(uint32_t max_packets, uint16_t max_udp_payl
     if (max_udp_payload_size > mtu_max)
         max_udp_payload_size = mtu_max;
 
-    return max_packets * max_udp_payload_size;
+    uint64_t cwnd_bytes = (uint64_t)max_packets * max_udp_payload_size;
+    return cwnd_bytes <= UINT32_MAX ? (uint32_t)cwnd_bytes : UINT32_MAX;
 }

lib/quicly.c

@@ -2276,7 +2276,7 @@ static quicly_conn_t *create_connection(quicly_context_t *ctx, uint32_t protocol
     quicly_linklist_init(&conn->egress.pending_streams.control);
     quicly_ratemeter_init(&conn->egress.ratemeter);
     if (server_name == NULL && conn->super.ctx->use_pacing && conn->egress.cc.type->cc_jumpstart != NULL &&
-        (conn->super.ctx->default_jumpstart_cwnd_bytes != 0 || conn->super.ctx->max_jumpstart_cwnd_bytes != 0))
+        (conn->super.ctx->default_jumpstart_cwnd_packets != 0 || conn->super.ctx->max_jumpstart_cwnd_packets != 0))
         conn->egress.try_jumpstart = 1;
     conn->crypto.tls = tls;
     if (handshake_properties != NULL) {
@@ -4201,8 +4201,10 @@ static uint32_t derive_jumpstart_cwnd(quicly_context_t *ctx, uint32_t new_rtt, u
         cwnd = cwnd * new_rtt / prev_rtt;
 
     /* cap to the configured value */
-    if (cwnd > ctx->max_jumpstart_cwnd_bytes)
-        cwnd = ctx->max_jumpstart_cwnd_bytes;
+    size_t jumpstart_cwnd =
+        quicly_cc_calc_initial_cwnd(ctx->max_jumpstart_cwnd_packets, ctx->transport_params.max_udp_payload_size);
+    if (cwnd > jumpstart_cwnd)
+        cwnd = jumpstart_cwnd;
 
     return (uint32_t)cwnd;
 }
@@ -5017,14 +5019,15 @@ static int do_send(quicly_conn_t *conn, quicly_send_context_t *s)
             conn->egress.try_jumpstart = 0;
             uint32_t jumpstart_cwnd = 0;
             conn->super.stats.jumpstart.new_rtt = conn->egress.loss.rtt.minimum;
-            if (conn->super.ctx->max_jumpstart_cwnd_bytes != 0 && conn->super.stats.jumpstart.prev_rate != 0 &&
+            if (conn->super.ctx->max_jumpstart_cwnd_packets != 0 && conn->super.stats.jumpstart.prev_rate != 0 &&
                 conn->super.stats.jumpstart.prev_rtt != 0) {
                 /* Careful Resume */
                 jumpstart_cwnd = derive_jumpstart_cwnd(conn->super.ctx, conn->super.stats.jumpstart.new_rtt,
                                                        conn->super.stats.jumpstart.prev_rate, conn->super.stats.jumpstart.prev_rtt);
-            } else if (conn->super.ctx->default_jumpstart_cwnd_bytes != 0) {
+            } else if (conn->super.ctx->default_jumpstart_cwnd_packets != 0) {
                 /* jumpstart without previous information */
-                jumpstart_cwnd = conn->super.ctx->default_jumpstart_cwnd_bytes;
+                jumpstart_cwnd = quicly_cc_calc_initial_cwnd(conn->super.ctx->default_jumpstart_cwnd_packets,
+                                                             conn->super.ctx->transport_params.max_udp_payload_size);
             }
             /* Jumpstart if the flow rate would be higher. Comparison target is CWND + inflight bytes in 1/2 RTT, as that is the
              * amount that can be sent at most, with pacer controlling the send rate. */

src/cli.c

@@ -1126,7 +1126,7 @@ static void usage(const char *cmd)
            "                            fraction of CWND (default: 0)\n"
            "  -G                        enable UDP generic segmentation offload\n"
            "  -i interval               interval to reissue requests (in milliseconds)\n"
-           "  --jumpstart-default <wnd> jumpstart CWND size for new connections, in bytes\n"
+           "  --jumpstart-default <wnd> jumpstart CWND size for new connections, in packets\n"
            "  --jumpstart-max <wnd>     maximum jumpstart CWND size for resuming connections\n"
            "  -I timeout                idle timeout (in milliseconds; default: 600,000)\n"
            "  -K num-packets            perform key update every num-packets packets\n"
@@ -1228,12 +1228,12 @@ int main(int argc, char **argv)
             } else if (strcmp(longopts[opt_index].name, "disregard-app-limited") == 0) {
                 ctx.cc_recognize_app_limited = 0;
             } else if (strcmp(longopts[opt_index].name, "jumpstart-default") == 0) {
-                if (sscanf(optarg, "%" SCNu32, &ctx.default_jumpstart_cwnd_bytes) != 1) {
+                if (sscanf(optarg, "%" SCNu32, &ctx.default_jumpstart_cwnd_packets) != 1) {
                     fprintf(stderr, "failed to parse default jumpstart size: %s\n", optarg);
                     exit(1);
                 }
             } else if (strcmp(longopts[opt_index].name, "jumpstart-max") == 0) {
-                if (sscanf(optarg, "%" SCNu32, &ctx.max_jumpstart_cwnd_bytes) != 1) {
+                if (sscanf(optarg, "%" SCNu32, &ctx.max_jumpstart_cwnd_packets) != 1) {
                     fprintf(stderr, "failed to parse max jumpstart size: %s\n", optarg);
                     exit(1);
                 }

t/test.c

@@ -726,12 +726,18 @@ void test_ecn_index_from_bits(void)
 /* at the moment only derivation is tested */
 static void test_jumpstart(void)
 {
-    quicly_context_t unbounded_max = {.max_jumpstart_cwnd_bytes = UINT32_MAX};
+    quicly_context_t unbounded_max = {
+        .max_jumpstart_cwnd_packets = UINT32_MAX,
+        .transport_params.max_udp_payload_size = 1200,
+    };
     ok(derive_jumpstart_cwnd(&unbounded_max, 250, 1000000, 250) == 250000);
     ok(derive_jumpstart_cwnd(&unbounded_max, 250, 1000000, 400) == 250000); /* if RTT increases, CWND stays same */
     ok(derive_jumpstart_cwnd(&unbounded_max, 250, 1000000, 125) == 125000); /* if RTT decreses, CWND is reduced proportionally */
 
-    quicly_context_t bounded_max = {.max_jumpstart_cwnd_bytes = 80000};
+    quicly_context_t bounded_max = {
+        .max_jumpstart_cwnd_packets = 64,
+        .transport_params.max_udp_payload_size = 1250,
+    };
     ok(derive_jumpstart_cwnd(&bounded_max, 250, 1000000, 250) == 80000);
 }