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,46 @@
+#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,27 @@
+#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 };

lib/ss-hystart.c

@@ -0,0 +1,72 @@
+#include "quicly/ss.h"
+#include <stdint.h>
+
+#define QUICLY_HYSTART_MIN_SAMPLES (8)
+#define QUICLY_HYSTART_MIN_SSTHRESH (16)
+#define QUICLY_HYSTART_ACK_DELTA_MS (2)
+#define QUICLY_HYSTART_DELAY_MIN (4)
+#define QUICLY_HYSTART_DELAY_MAX (16)
+#define QUICLY_HYSTART_LOW_WINDOW (16)
+
+
+static void ss_hystart_reset(quicly_cc_t *cc, int64_t now, uint64_t next_pn) {
+	cc->ss_state.hystart.round_start = cc->ss_state.hystart.last_ack = now; // we only have ms resolution
+	cc->ss_state.hystart.end_seq = next_pn; // next packet we will send
+	cc->ss_state.hystart.min_round_rtt = ~0U; // max uint32_t
+	cc->ss_state.hystart.samples = 0;
+}
+
+// This code is heavily based on Linux's CUBIC/HyStart implementation with several functional differences to make it
+// work with the constraints we've been given by Quicly. 
+void ss_hystart(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)
+{
+	// RTT available at loss->rtt.latest
+	// dMin (min observed RTT) available at loss->rtt.minimum
+	// this isn't exactly sequence number comparison, but it also ain't exactly NOT sequence number comparison...
+	if (largest_acked > cc->ss_state.hystart.end_seq) {
+		ss_hystart_reset(cc, now, next_pn);
+	}
+
+
+	// check for ACK train
+	// Linux does this in usec, but we aren't so lucky
+	if (now - cc->ss_state.hystart.last_ack <= QUICLY_HYSTART_ACK_DELTA_MS) {
+		cc->ss_state.hystart.last_ack = now;
+
+		// Kernel defines threshold as `ca->delay_min + hystart_ack_delay(sk);`
+		// hystart_ack_delay(sk) maxes at 1ms if there is packet spacing happening
+		// but we don't have usec so i dont know how much it matters
+		uint32_t threshold = loss->rtt.minimum >> 1;
+
+		if (now - cc->ss_state.hystart.round_start > threshold) {
+			cc->ss_state.hystart.found = 1;
+			cc->ssthresh = cc->cwnd;
+		}
+	}
+
+	// HyStart Delay exit point
+	if (cc->ss_state.hystart.min_round_rtt > loss->rtt.latest) {
+		cc->ss_state.hystart.min_round_rtt = loss->rtt.latest;
+	}
+	if (cc->ss_state.hystart.samples < QUICLY_HYSTART_MIN_SAMPLES) {
+		cc->ss_state.hystart.samples += 1;
+	}
+	else {
+		uint32_t threshold = loss->rtt.minimum + MIN(QUICLY_HYSTART_DELAY_MAX, MAX(QUICLY_HYSTART_DELAY_MIN, loss->rtt.minimum >> 3));
+
+		if (cc->ss_state.hystart.min_round_rtt > threshold) {
+			cc->ss_state.hystart.found = 1;
+			cc->ssthresh = cc->cwnd;
+		}
+	}
+
+	if (cc->ss_state.hystart.found == 0) {
+		cc->cwnd += bytes;
+		if (cc->cwnd_maximum < cc->cwnd)
+			cc->cwnd_maximum = cc->cwnd;
+	}
+}
+
+quicly_ss_type_t quicly_ss_type_hystart = { "hystart", ss_hystart };
+