Add option string for CC algo

Author: huitema

picoquic/bbr.c

@@ -141,6 +141,22 @@ typedef enum {
 
 #define BBRExcessiveEcnCE 0.2
 
+/* Temporary code, do define a set of BBR flags that
+* turn on and off individual extensions. We want to use that
+* to do "before/after" measurements.
+ */
+#define BBRExperiment on
+#ifdef BBRExperiment
+ /* Control flags for BBR improvements */
+typedef struct st_bbr_exp {
+    unsigned int do_early_exit : 1;
+    unsigned int do_rapid_start : 1;
+    unsigned int do_handle_suspension : 1;
+    unsigned int do_control_lost : 1;
+    unsigned int do_exit_probeBW_up_on_delay : 1;
+    unsigned int do_enter_probeBW_after_limited : 1;
+} bbr_exp;
+#endif
 typedef struct st_picoquic_bbr_state_t {
     /* Algorithm state: */
     picoquic_bbr_alg_state_t state;
@@ -260,13 +276,13 @@ typedef struct st_picoquic_bbr_state_t {
     unsigned int probe_bdp_seed;
 
     /* Experimental extensions, may or maynot be a good idea. */
+    char const* option_string;
     uint64_t wifi_shadow_rtt; /* Shadow RTT used for wifi connections. */
     double quantum_ratio; /* allow application to use a different default than 0.1% of bandwidth (or 1ms of traffic) */
 #ifdef BBRExperiment
     /* Control flags for BBR improvements */
     bbr_exp exp_flags;
 #endif
-
 } picoquic_bbr_state_t;
 
 /* BBR v3 assumes that there is state associated with the acknowledgements.
@@ -422,13 +438,118 @@ static void BBRInitFullPipe(picoquic_bbr_state_t* bbr_state)
     bbr_state->full_bw_count = 0;
 }
 
+/* Initialization of optional variables defined in text string
+* Syntax:
+* - Single letter options, all optional:
+*   E: do_early_exit
+*   R: do_rapid_start
+*   H: do_handle_suspension
+*   L: do_control_lost
+*   D: do_exit_probeBW_up_on_delay
+*   A: do_enter_probeBW_after_limited
+* - Complex options, ends with ':'
+*   T999999999: wifi_shadow_rtt, microseconds
+*   Q99999.999: quantum_ratio, %
+* 
+*/
+static void BBRSetOptions(picoquic_bbr_state_t* bbr_state)
+{
+    const char* x = bbr_state->option_string;
+
+    if (x != NULL) {
+        char c;
+        while ((c = *x) != 0) {
+            x++;
+            switch (c) {
+#ifdef BBRExperiment
+            case 'E':
+                bbr_state->exp_flags.do_early_exit = 1;
+                break;
+            case 'R':
+                bbr_state->exp_flags.do_rapid_start = 1;
+                break;
+            case 'H':
+                bbr_state->exp_flags.do_handle_suspension = 1;
+                break;
+            case 'L':
+                bbr_state->exp_flags.do_control_lost = 1;
+                break;
+            case 'D':
+                bbr_state->exp_flags.do_exit_probeBW_up_on_delay = 1;
+                break;
+            case 'A':
+                bbr_state->exp_flags.do_enter_probeBW_after_limited = 1;
+                break;
+#endif
+            case 'T': {
+                /* Reading digits into an uint64_t  */
+                uint64_t u = 0;
+                while ((c = *x) != 0) {
+                    if (c >= '0' && c <= '9') {
+                        u *= 10;
+                        u += c - '0';
+                        x++;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                bbr_state->wifi_shadow_rtt = u;
+                break;
+            }
+            case 'Q': {
+                /* Reading digits ad one dot into a double  */
+                while ((c = *x) != 0) {
+                    double d = 0;
+                    double div = 1.0;
+                    int dotted = 0;
+                    while ((c = *x) != 0) {
+                        if (c >= '0' && c <= '9') {
+                            if (!dotted) {
+                                d *= 10;
+                                d += c - '0';
+                            }
+                            else {
+                                div /= 10.0;
+                                d += div * (c - '0');
+                            }
+                            x++;
+                        }
+                        else if (c == '.') {
+                            if (dotted) {
+                                break;
+                            }
+                            else {
+                                dotted = 1;
+                                x++;
+                            }
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                    bbr_state->quantum_ratio = d;
+                    break;
+                }
+            }
+            case ':':
+                /* Ignore */
+                break;
+            default:
+                break;
+            }
+        }
+    }
+}
+
 /* Initialization of the BBR state */
-static void BBROnInit(picoquic_bbr_state_t* bbr_state, picoquic_path_t* path_x, uint64_t current_time)
+static void BBROnInit(picoquic_bbr_state_t* bbr_state, picoquic_path_t* path_x, uint64_t current_time, char const * option_string)
 {
     /* TODO:
     init_windowed_max_filter(filter = BBR.MaxBwFilter, value = 0, time = 0)
     */
     memset(bbr_state, 0, sizeof(picoquic_bbr_state_t));
+    bbr_state->option_string = option_string;
     BBRInitRandom(bbr_state, path_x, current_time);
     /* If RTT was already sampled, use it, other wise set min RTT to infinity */
     if (path_x->smoothed_rtt == PICOQUIC_INITIAL_RTT
@@ -446,15 +567,8 @@ static void BBROnInit(picoquic_bbr_state_t* bbr_state, picoquic_path_t* path_x,
     bbr_state->min_rtt_stamp = current_time;
     bbr_state->extra_acked_interval_start = current_time;
     bbr_state->extra_acked_delivered = 0;
-    /* Support for the wifi_shadow_rtt hack */
-    bbr_state->wifi_shadow_rtt = path_x->cnx->quic->wifi_shadow_rtt;
-
-#ifdef BBRExperiment
-    /* Support for BBR Experiment */
-    bbr_state->exp_flags = path_x->cnx->quic->bbr_exp_flags;
-#endif
-    /* Support for experimenting with the send_quantum ratio */
-    bbr_state->quantum_ratio = path_x->cnx->quic->bbr_quantum_ratio;
+    /* Support for the experimental options */
+    BBRSetOptions(bbr_state);
     if (bbr_state->quantum_ratio == 0) {
         bbr_state->quantum_ratio = 0.001;
     }
@@ -469,17 +583,17 @@ static void BBROnInit(picoquic_bbr_state_t* bbr_state, picoquic_path_t* path_x,
 
 static void picoquic_bbr_reset(picoquic_bbr_state_t* bbr_state, picoquic_path_t* path_x, uint64_t current_time)
 {
-    BBROnInit(bbr_state, path_x, current_time);
+    BBROnInit(bbr_state, path_x, current_time, bbr_state->option_string);
 }
 
-static void picoquic_bbr_init(picoquic_cnx_t * cnx, picoquic_path_t* path_x, uint64_t current_time)
+static void picoquic_bbr_init(picoquic_cnx_t * cnx, picoquic_path_t* path_x, char const* option_string, uint64_t current_time)
 {
     /* Initialize the state of the congestion control algorithm */
     picoquic_bbr_state_t* bbr_state = (picoquic_bbr_state_t*)malloc(sizeof(picoquic_bbr_state_t));
 
     path_x->congestion_alg_state = (void*)bbr_state;
     if (bbr_state != NULL) {
-        BBROnInit(bbr_state, path_x, current_time);
+        BBROnInit(bbr_state, path_x, current_time, option_string);
     }
 }
 

picoquic/bbr1.c

@@ -278,6 +278,7 @@ typedef struct st_picoquic_bbr1_state_t {
     uint64_t congestion_sequence; /* sequence number after congestion notification */
     uint64_t cwin_before_suspension; /* So it can be restored if suspension stops. */
 
+    const char* option_string;
     uint64_t wifi_shadow_rtt; /* Shadow RTT used for wifi connections. */
     double quantum_ratio;
 
@@ -368,13 +369,89 @@ void BBR1UpdateTargetCwnd(picoquic_bbr1_state_t* bbr1_state)
     bbr1_state->target_cwnd = BBR1Inflight(bbr1_state, bbr1_state->cwnd_gain);
 }
 
-static void picoquic_bbr1_reset(picoquic_bbr1_state_t* bbr1_state, picoquic_path_t* path_x, uint64_t current_time, uint64_t wifi_shadow_rtt)
+
+/* Initialization of optional variables defined in text string
+* Syntax:
+*   T999999999: wifi_shadow_rtt, microseconds
+*   Q99999.999: quantum_ratio,
+*
+*/
+static void picoquic_bbr1_set_options(picoquic_bbr1_state_t* bbr1_state)
+{
+    const char* x = bbr1_state->option_string;
+
+    if (x != NULL) {
+        char c;
+        while ((c = *x) != 0) {
+            x++;
+            switch (c) {
+            case 'T': {
+                /* Reading digits into an uint64_t  */
+                uint64_t u = 0;
+                while ((c = *x) != 0) {
+                    if (c >= '0' && c <= '9') {
+                        u *= 10;
+                        u += c - '0';
+                        x++;
+                    }
+                    else {
+                        break;
+                    }
+                }
+                bbr1_state->wifi_shadow_rtt = u;
+                break;
+            }
+            case 'Q': {
+                /* Reading digits ad one dot into a double  */
+                while ((c = *x) != 0) {
+                    double d = 0;
+                    double div = 1.0;
+                    int dotted = 0;
+                    while ((c = *x) != 0) {
+                        if (c >= '0' && c <= '9') {
+                            if (!dotted) {
+                                d *= 10;
+                                d += c - '0';
+                            }
+                            else {
+                                div /= 10.0;
+                                d += div * (c - '0');
+                            }
+                            x++;
+                        }
+                        else if (c == '.') {
+                            if (dotted) {
+                                break;
+                            }
+                            else {
+                                dotted = 1;
+                                x++;
+                            }
+                        }
+                        else {
+                            break;
+                        }
+                    }
+                    bbr1_state->quantum_ratio = d;
+                    break;
+                }
+            }
+            case ':':
+                /* Ignore */
+                break;
+            default:
+                break;
+            }
+        }
+    }
+}
+
+static void picoquic_bbr1_reset(picoquic_bbr1_state_t* bbr1_state, picoquic_path_t* path_x, uint64_t current_time)
 {
     memset(bbr1_state, 0, sizeof(picoquic_bbr1_state_t));
     path_x->cwin = PICOQUIC_CWIN_INITIAL;
-    bbr1_state->rt_prop = UINT64_MAX;
-    bbr1_state->wifi_shadow_rtt = path_x->cnx->quic->wifi_shadow_rtt;
-    bbr1_state->quantum_ratio = path_x->cnx->quic->bbr_quantum_ratio;
+    bbr1_state->rt_prop = UINT64_MAX; 
+    picoquic_bbr1_set_options(bbr1_state);
     if (bbr1_state->quantum_ratio == 0) {
         bbr1_state->quantum_ratio = 0.001;
     }
@@ -389,14 +466,15 @@ static void picoquic_bbr1_reset(picoquic_bbr1_state_t* bbr1_state, picoquic_path
     BBR1UpdateTargetCwnd(bbr1_state);
 }
 
-static void picoquic_bbr1_init(picoquic_cnx_t * cnx, picoquic_path_t* path_x, uint64_t current_time)
+static void picoquic_bbr1_init(picoquic_cnx_t * cnx, picoquic_path_t* path_x, char const* option_string, uint64_t current_time)
 {
     /* Initialize the state of the congestion control algorithm */
     picoquic_bbr1_state_t* bbr1_state = (picoquic_bbr1_state_t*)malloc(sizeof(picoquic_bbr1_state_t));
 
     path_x->congestion_alg_state = (void*)bbr1_state;
     if (bbr1_state != NULL) {
-        picoquic_bbr1_reset(bbr1_state, path_x, current_time, cnx->quic->wifi_shadow_rtt);
+        bbr1_state->option_string = option_string;
+        picoquic_bbr1_reset(bbr1_state, path_x, current_time);
     }
 }
 
@@ -1210,7 +1288,7 @@ static void picoquic_bbr1_notify(
         case picoquic_congestion_notification_cwin_blocked:
             break;
         case picoquic_congestion_notification_reset:
-            picoquic_bbr1_reset(bbr1_state, path_x, current_time, cnx->quic->wifi_shadow_rtt);
+            picoquic_bbr1_reset(bbr1_state, path_x, current_time);
             break;
         case picoquic_congestion_notification_seed_cwin:
             if (bbr1_state->state == picoquic_bbr1_alg_startup_long_rtt) {

picoquic/config.c

@@ -66,6 +66,7 @@ static option_table_line_t option_table[] = {
     { picoquic_option_SOLUTION_DIR, 'S', "solution_dir", 1, "folder", "Set the path to the source files to find the default files" },
     { picoquic_option_CC_ALGO, 'G', "cc_algo", 1, "cc_algorithm",
     "Use the specified congestion control algorithm. Defaults to bbr. Supported values are:" },
+    { picoquic_option_CC_OPTION, 'H', "cco", 1, "option", "Set option string if required by congestion control algorithm."},
     { picoquic_option_SPINBIT, 'P', "spinbit", 1, "number", "Set the default spinbit policy" },
     { picoquic_option_LOSSBIT, 'O', "lossbit", 1, "number", "Set the default lossbit policy" },
     { picoquic_option_MULTIPATH, 'M', "multipath", 0, "", "Enable QUIC multipath extension" },
@@ -292,6 +293,9 @@ static int config_set_option(option_table_line_t* option_desc, option_param_t* p
     case picoquic_option_CC_ALGO:
         ret = config_set_string_param(&config->cc_algo_id, params, nb_params, 0);
         break;
+    case picoquic_option_CC_OPTION:
+        ret = config_set_string_param(&config->cc_algo_option_string, params, nb_params, 0);
+        break;
     case picoquic_option_SPINBIT: {
         int v = config_atoi(params, nb_params, 0, &ret);
         if (ret != 0 || v < 0 || v > (int)picoquic_spinbit_on) {
@@ -807,7 +811,7 @@ picoquic_quic_t* picoquic_create_and_configure(picoquic_quic_config_t* config,
             cc_algo = picoquic_bbr_algorithm;
         }
 
-        picoquic_set_default_congestion_algorithm(quic, cc_algo);
+        picoquic_set_default_congestion_algorithm_ex(quic, cc_algo, config->cc_algo_option_string);
 
         picoquic_set_default_spinbit_policy(quic, config->spinbit_policy);
         picoquic_set_default_lossbit_policy(quic, config->lossbit_policy);

picoquic/cubic.c

@@ -61,12 +61,13 @@ static void cubic_reset(picoquic_cubic_state_t* cubic_state, picoquic_path_t* pa
     path_x->cwin = PICOQUIC_CWIN_INITIAL;
 }
 
-static void cubic_init(picoquic_cnx_t * cnx, picoquic_path_t* path_x, uint64_t current_time)
+static void cubic_init(picoquic_cnx_t * cnx, picoquic_path_t* path_x, char const* option_string, uint64_t current_time)
 {
     /* Initialize the state of the congestion control algorithm */
     picoquic_cubic_state_t* cubic_state = (picoquic_cubic_state_t*)malloc(sizeof(picoquic_cubic_state_t));
 #ifdef _WINDOWS
     UNREFERENCED_PARAMETER(cnx);
+    UNREFERENCED_PARAMETER(option_string);
 #endif
     path_x->congestion_alg_state = (void*)cubic_state;
     if (cubic_state != NULL) {

picoquic/fastcc.c

@@ -91,12 +91,13 @@ void picoquic_fastcc_seed_cwin(picoquic_fastcc_state_t* fastcc_state, picoquic_p
     }
 }
 
-void picoquic_fastcc_init(picoquic_cnx_t * cnx, picoquic_path_t* path_x, uint64_t current_time)
+void picoquic_fastcc_init(picoquic_cnx_t * cnx, picoquic_path_t* path_x, char const* option_string, uint64_t current_time)
 {
     /* Initialize the state of the congestion control algorithm */
     picoquic_fastcc_state_t* fastcc_state = path_x->congestion_alg_state;
 #ifdef _WINDOWS
     UNREFERENCED_PARAMETER(cnx);
+    UNREFERENCED_PARAMETER(option_string);
 #endif
 
     if (fastcc_state == NULL) {

picoquic/newreno.c

@@ -186,12 +186,13 @@ static void picoquic_newreno_reset(picoquic_newreno_state_t* nr_state, picoquic_
     path_x->cwin = nr_state->nrss.cwin;
 }
 
-static void picoquic_newreno_init(picoquic_cnx_t * cnx, picoquic_path_t* path_x, uint64_t current_time)
+static void picoquic_newreno_init(picoquic_cnx_t * cnx, picoquic_path_t* path_x, char const *option_string, uint64_t current_time)
 {
     /* Initialize the state of the congestion control algorithm */
     picoquic_newreno_state_t* nr_state = (picoquic_newreno_state_t*)malloc(sizeof(picoquic_newreno_state_t));
 #ifdef _WINDOWS
     UNREFERENCED_PARAMETER(current_time);
+    UNREFERENCED_PARAMETER(option_string);
     UNREFERENCED_PARAMETER(cnx);
 #endif