Merge Amber Cronin's changes into Project-Faster (viasat)

CMakeLists.txt

@@ -61,6 +61,10 @@ SET(QUICLY_LIBRARY_FILES
     lib/remote_cid.c
     lib/retire_cid.c
     lib/sendstate.c
+    lib/ss-rfc2001.c
+    lib/ss-hybla.c
+    lib/ss-hystart.c
+    lib/ss-search.c
     lib/sentmap.c
     lib/streambuf.c
     ${CMAKE_CURRENT_BINARY_DIR}/quicly-tracer.h)

include/quicly.h

@@ -38,6 +38,7 @@ extern "C" {
 #include "quicly/local_cid.h"
 #include "quicly/linklist.h"
 #include "quicly/loss.h"
+#include "quicly/ss.h"
 #include "quicly/cc.h"
 #include "quicly/rate.h"
 #include "quicly/recvstate.h"
@@ -392,6 +393,10 @@ struct st_quicly_context_t {
      * initializes a congestion controller for given connection.
      */
     quicly_init_cc_t *init_cc;
+    /**
+     * set the slowstart function for the connection
+     */
+    quicly_ss_type_t *cc_slowstart;
     /**
      * optional refcount callback
      */

include/quicly/cc.h

@@ -40,6 +40,16 @@ extern "C" {
 #define QUICLY_MIN_CWND 2
 #define QUICLY_RENO_BETA 0.7
 
+#define SEARCH20_DELV_BIN_COUNT 10
+#define SEARCH20_SENT_BIN_COUNT 25 // 10 + 15 extra bins
+#define SEARCH20_WINDOW_MULTIPLIER (3.5)
+#define SEARCH20_THRESH (0.35)
+
+#define QUICLY_HYBLA_RTT0 (25)
+#define QUICLY_HYBLA_RHO_LIM (16)
+
+// #define SEARCH_EXIT
+
 /**
  * Holds pointers to concrete congestion control implementation functions.
  */
@@ -58,6 +68,41 @@ typedef struct st_quicly_cc_t {
      * Current slow start threshold.
      */
     uint32_t ssthresh;
+    /**
+     * Slow-start specific data storage
+     */
+    union {
+        struct {
+            double rho;
+        } hybla;
+        struct {
+            uint8_t found;
+            int64_t round_start;
+            int64_t last_ack;
+            int64_t end_seq;
+            uint32_t min_round_rtt;
+            uint8_t samples;
+        } hystart;
+        struct {
+            /**
+             * Bins for the byte count sent and the byte count delivered (instantiated on init)
+             */
+            uint64_t delv_bins[SEARCH20_SENT_BIN_COUNT];
+            /**
+             * Maintains the end time of the current bin
+             */
+            int64_t bin_end;
+            /**
+             * Holds the size of each bin (based on the handshake RTT)
+             */
+            uint32_t bin_time;
+            /**
+             * Counts the number of times that the bin has been incremented, so we know when to
+             * start trying to watch for congestion
+             */
+            uint32_t bin_rounds;
+        } search;
+    } ss_state;
     /**
      * Packet number indicating end of recovery period, if in recovery.
      */
@@ -202,6 +247,10 @@ struct st_quicly_cc_type_t {
      * Switches the underlying algorithm of `cc` to that of `cc_switch`, returning a boolean if the operation was successful.
      */
     int (*cc_switch)(quicly_cc_t *cc);
+    /*
+     * Defines a variable slowstart callback
+     */
+    struct st_quicly_variable_ss *cc_slowstart;
     /**
      *
      */

include/quicly/defaults.h

@@ -59,6 +59,7 @@ extern quicly_crypto_engine_t quicly_default_crypto_engine;
 
 #define quicly_default_cc quicly_cc_type_reno
 #define quicly_default_init_cc quicly_cc_reno_init
+#define quicly_default_ss quicly_ss_type_rfc2001
 
 #ifdef __cplusplus
 }

include/quicly/ss.h

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2024 Viasat Inc.
+ * Authors:  Amber Cronin, Jae Won Chung, Mike Foxworthy, Feng Li, Mark Claypool
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#ifndef quicly_ss_h
+#define quicly_ss_h
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "quicly/cc.h"
+#include "quicly/constants.h"
+#include <stdint.h>
+#include <stdbool.h>
+
+extern bool search_exit;
+
+#define MIN(x,y) ((x > y) ? (y) : (x))
+#define MAX(x,y) ((x < y) ? (y) : (x))
+
+/**
+ * Holds pointers to concrete congestion control implementation functions.
+ */
+typedef const struct st_quicly_ss_type_t quicly_ss_type_t;
+
+struct st_quicly_ss_type_t {
+    const char* name;
+    void (*ss)(quicly_cc_t *cc, const quicly_loss_t *loss, uint32_t bytes, uint64_t largest_acked, uint32_t inflight,
+               uint64_t next_pn, int64_t now, uint32_t max_udp_payload_size);
+};
+
+extern quicly_ss_type_t quicly_ss_type_rfc2001, quicly_ss_type_hybla, quicly_ss_type_hystart, quicly_ss_type_search;
+
+extern quicly_ss_type_t* quicly_ss_all_types[];
+
+void ss_rfc2001(quicly_cc_t *cc, const quicly_loss_t *loss, uint32_t bytes, uint64_t largest_acked, uint32_t inflight,
+                        uint64_t next_pn, int64_t now, uint32_t max_udp_payload_size);
+
+struct st_quicly_variable_ss {
+    quicly_ss_type_t* slowstart;
+};
+
+extern struct st_quicly_variable_ss active_slowstart;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

lib/cc-cubic.c

@@ -22,8 +22,10 @@
  */
 #include <math.h>
 #include "quicly/cc.h"
+#include "quicly/defaults.h"
 #include "quicly.h"
 #include "quicly/pacer.h"
+#include "quicly/ss.h"
 
 #define QUICLY_MIN_CWND 2
 
@@ -73,13 +75,11 @@ static void cubic_on_acked(quicly_cc_t *cc, const quicly_loss_t *loss, uint32_t
 
     quicly_cc_jumpstart_on_acked(cc, 0, bytes, largest_acked, inflight, next_pn);
 
-    /* TODO: respect cc_limited */
-
     /* Slow start. */
     if (cc->cwnd < cc->ssthresh) {
-        cc->cwnd += bytes;
-        if (cc->cwnd_maximum < cc->cwnd)
-            cc->cwnd_maximum = cc->cwnd;
+        if (cc_limited) {
+            cc->type->cc_slowstart->slowstart->ss(cc, loss, bytes, largest_acked, inflight, next_pn, now, max_udp_payload_size);
+        }
         return;
     }
 
@@ -206,7 +206,9 @@ static void cubic_init(quicly_init_cc_t *self, quicly_cc_t *cc, uint32_t initcwn
     cubic_reset(cc, initcwnd);
 }
 
+struct st_quicly_variable_ss cubic_active_slowstart = {&quicly_default_ss};
+
 quicly_cc_type_t quicly_cc_type_cubic = {"cubic",         &quicly_cc_cubic_init,          cubic_on_acked,
                                          cubic_on_lost,   cubic_on_persistent_congestion, cubic_on_sent,
-                                         cubic_on_switch, quicly_cc_jumpstart_enter};
+                                         cubic_on_switch, &cubic_active_slowstart, quicly_cc_jumpstart_enter};
 quicly_init_cc_t quicly_cc_cubic_init = {cubic_init};

lib/cc-pico.c

@@ -194,5 +194,6 @@ static void pico_init(quicly_init_cc_t *self, quicly_cc_t *cc, uint32_t initcwnd
 
 quicly_cc_type_t quicly_cc_type_pico = {"pico",         &quicly_cc_pico_init,          pico_on_acked,
                                         pico_on_lost,   pico_on_persistent_congestion, pico_on_sent,
-                                        pico_on_switch, quicly_cc_jumpstart_enter};
+                                        pico_on_switch, NULL /* no slow start exists for this CCA*/, 
+                                        quicly_cc_jumpstart_enter};
 quicly_init_cc_t quicly_cc_pico_init = {pico_init};

lib/cc-reno.c

@@ -20,6 +20,7 @@
  * IN THE SOFTWARE.
  */
 #include "quicly/cc.h"
+#include "quicly/defaults.h"
 #include "quicly.h"
 
 /* TODO: Avoid increase if sender was application limited. */
@@ -39,9 +40,7 @@ static void reno_on_acked(quicly_cc_t *cc, const quicly_loss_t *loss, uint32_t b
     /* Slow start. */
     if (cc->cwnd < cc->ssthresh) {
         if (cc_limited) {
-            cc->cwnd += bytes;
-            if (cc->cwnd_maximum < cc->cwnd)
-                cc->cwnd_maximum = cc->cwnd;
+            cc->type->cc_slowstart->slowstart->ss(cc, loss, bytes, largest_acked, inflight, next_pn, now, max_udp_payload_size);
         }
         return;
     }
@@ -136,13 +135,16 @@ static void reno_init(quicly_init_cc_t *self, quicly_cc_t *cc, uint32_t initcwnd
     reno_reset(cc, initcwnd);
 }
 
+struct st_quicly_variable_ss reno_active_slowstart = {&quicly_default_ss};
+
 quicly_cc_type_t quicly_cc_type_reno = {"reno",
                                         &quicly_cc_reno_init,
                                         reno_on_acked,
                                         quicly_cc_reno_on_lost,
                                         quicly_cc_reno_on_persistent_congestion,
                                         quicly_cc_reno_on_sent,
                                         reno_on_switch,
+                                        &reno_active_slowstart,
                                         quicly_cc_jumpstart_enter};
 quicly_init_cc_t quicly_cc_reno_init = {reno_init};
 

lib/defaults.c

@@ -64,7 +64,8 @@ const quicly_context_t quicly_spec_context = {NULL,
                                               NULL,
                                               NULL,
                                               &quicly_default_crypto_engine,
-                                              &quicly_default_init_cc};
+                                              &quicly_default_init_cc,
+                                              &quicly_default_ss};
 
 /* profile with a focus on reducing latency for the HTTP use case */
 const quicly_context_t quicly_performant_context = {NULL,                                                 /* tls */
@@ -99,7 +100,8 @@ const quicly_context_t quicly_performant_context = {NULL,
                                                     NULL,
                                                     NULL,
                                                     &quicly_default_crypto_engine,
-                                                    &quicly_default_init_cc};
+                                                    &quicly_default_init_cc,
+                                                    &quicly_default_ss};
 
 /**
  * The context of the default CID encryptor.  All the contexts being used here are ECB ciphers and therefore stateless - they can be

lib/quicly.c

@@ -36,6 +36,7 @@
 #include "quicly/sentmap.h"
 #include "quicly/pacer.h"
 #include "quicly/frame.h"
+#include "quicly/ss.h"
 #include "quicly/streambuf.h"
 #include "quicly/cc.h"
 #if QUICLY_USE_DTRACE
@@ -2259,6 +2260,9 @@ static quicly_conn_t *create_connection(quicly_context_t *ctx, uint32_t protocol
     conn->egress.ack_frequency.update_at = INT64_MAX;
     conn->egress.send_ack_at = INT64_MAX;
     conn->super.ctx->init_cc->cb(conn->super.ctx->init_cc, &conn->egress.cc, initcwnd, conn->stash.now);
+    if (conn->egress.cc.type->cc_slowstart != NULL) {
+        conn->egress.cc.type->cc_slowstart->slowstart = conn->super.ctx->cc_slowstart;
+    }
     if (pacer != NULL) {
         conn->egress.pacer = pacer;
         quicly_pacer_reset(conn->egress.pacer);

lib/ss-hybla.c

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2024 Viasat Inc.
+ * Authors:  Amber Cronin, Jae Won Chung, Mike Foxworthy, Feng Li, Mark Claypool
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to
+ * deal in the Software without restriction, including without limitation the
+ * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+ * sell copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#include "quicly/ss.h"
+#include <stdint.h>
+#include <math.h>
+
+static void recalc_rho(quicly_cc_t *cc, const quicly_loss_t *loss) {
+	// RTT in msec
+	// Linux here uses us instead of ms for their rho calculations, which gives them more accurate information about
+	// the bandwidth of the connection. Here, we only have ms level measurements from loss, and so all of our
+	// measurements are only up to that level of precision. It cleans the code up a little bit though from the kernel. 
+	// we have changed this to use doubles for more accuracy and ease of writing code. 
+	double rho = (double) loss->rtt.minimum / QUICLY_HYBLA_RTT0;
+	// don't allow the ratio to be less than one for faster connections than reference. 
+	cc->ss_state.hybla.rho = MAX(rho, 1);
+}
+
+void ss_hybla(quicly_cc_t *cc, const quicly_loss_t *loss, uint32_t bytes, uint64_t largest_acked, uint32_t inflight,
+                        uint64_t next_pn, int64_t now, uint32_t max_udp_payload_size)
+{
+	recalc_rho(cc, loss);
+
+	cc->cwnd += (uint32_t)round(pow(2, MIN(cc->ss_state.hybla.rho, QUICLY_HYBLA_RHO_LIM)));
+
+	if (cc->cwnd_maximum < cc->cwnd)
+		cc->cwnd_maximum = cc->cwnd;
+}
+
+quicly_ss_type_t quicly_ss_type_hybla = { "hybla", ss_hybla };