High priority bypass CC

Author: huitema

picoquic/picoquic.h

@@ -1486,6 +1486,22 @@ void picoquic_set_default_wifi_shadow_rtt(picoquic_quic_t* quic, uint64_t wifi_s
 */
 void picoquic_set_default_bbr_quantum_ratio(picoquic_quic_t* quic, double quantum_ratio);
 
+/* The experimental API 'picoquic_set_priority_limit_for_bypass' 
+* instruct the stack to send the high priority streams or datagrams
+* immediately, even if congestion control would normally prevent it.
+* 
+* The "priority_limit" parameter indicates the lowest priority that will
+* not be bypassed. For example, if the priority limit is set to 3, streams
+* or datagrams with priority 0, 1 or 2 will be sent without waiting for
+* congestion control credits, but streams will priority 3 or more will
+* not. By default, the limit is set to 0, meaning no stream or datagram
+* will bypass congestion control.
+* 
+* This experimental feature will not be activated in a multipath
+* environment, i.e., if more that 1 path is activated.
+ */
+void picoquic_set_priority_limit_for_bypass(picoquic_cnx_t* cnx, uint8_t priority_limit);
+
 /* The experimental API `picoquic_set_feedback_loss_notification` allow applications
 * to turn on the "feedback lost" event notification. These events are
 * passed to the congestion control algorithm, allowing it to react

picoquic/picoquic_internal.h

@@ -1448,6 +1448,7 @@ typedef struct st_picoquic_cnx_t {
     picoquic_stream_head_t * last_output_stream;
     uint64_t high_priority_stream_id;
     uint64_t next_stream_id[4];
+    uint64_t priority_limit_for_bypass; /* Bypass CC if dtagram or stream priority lower than this, 0 means never */
 
     /* Repeat queue contains packets with data frames that should be
      * sent according to priority when congestion window opens. */

picoquic/quicctx.c

@@ -4782,6 +4782,11 @@ void picoquic_set_default_bbr_quantum_ratio(picoquic_quic_t* quic, double quantu
     quic->bbr_quantum_ratio = quantum_ratio;
 }
 
+void picoquic_set_priority_limit_for_bypass(picoquic_cnx_t* cnx, uint8_t priority_limit)
+{
+    cnx->priority_limit_for_bypass = priority_limit;
+}
+
 void picoquic_set_feedback_loss_notification(picoquic_cnx_t* cnx, unsigned int should_notify)
 {
     cnx->is_lost_feedback_notification_required = should_notify;

picoquic/sender.c

@@ -3150,6 +3150,7 @@ static uint8_t* picoquic_prepare_datagram_ready(picoquic_cnx_t* cnx, picoquic_pa
 */
 
 static uint8_t* picoquic_prepare_stream_and_datagrams(picoquic_cnx_t* cnx, picoquic_path_t* path_x, uint8_t* bytes_next, uint8_t* bytes_max,
+    uint64_t max_priority_allowed,
     int* more_data, int* is_pure_ack, int* no_data_to_send, int* ret)
 {
     int datagram_sent = 0;
@@ -3187,7 +3188,7 @@ static uint8_t* picoquic_prepare_stream_and_datagrams(picoquic_cnx_t* cnx, picoq
             current_priority = stream_priority;
         }
 
-        if (current_priority == UINT64_MAX) {
+        if (current_priority == UINT64_MAX || current_priority >= max_priority_allowed) {
             /* Nothing to send! */
             if (is_first_round) {
                 *no_data_to_send = 1;
@@ -3392,13 +3393,25 @@ int picoquic_prepare_packet_almost_ready(picoquic_cnx_t* cnx, picoquic_path_t* p
 
                 length = bytes_next - bytes;
                 if (path_x->cwin < path_x->bytes_in_transit) {
-                    picoquic_per_ack_state_t ack_state = { 0 };
-                    cnx->cwin_blocked = 1;
-                    path_x->last_cwin_blocked_time = current_time;
-                    if (cnx->congestion_alg != NULL) {
-                        cnx->congestion_alg->alg_notify(cnx, path_x,
-                            picoquic_congestion_notification_cwin_blocked,
-                            &ack_state, current_time);
+                    /* Implementation of experimental API, picoquic_set_priority_limit_for_bypass */
+                    uint8_t* bytes_next_before_bypass = bytes_next;
+                    if (cnx->priority_limit_for_bypass > 0 && cnx->nb_paths == 1) {
+                        bytes_next = picoquic_prepare_stream_and_datagrams(cnx, path_x, bytes_next, bytes_max,
+                            cnx->priority_limit_for_bypass,
+                            &more_data, &is_pure_ack, &no_data_to_send, &ret);
+                    }
+                    if (bytes_next != bytes_next_before_bypass) {
+                        length = bytes_next - bytes;
+                    }
+                    else {
+                        picoquic_per_ack_state_t ack_state = { 0 };
+                        cnx->cwin_blocked = 1;
+                        path_x->last_cwin_blocked_time = current_time;
+                        if (cnx->congestion_alg != NULL) {
+                            cnx->congestion_alg->alg_notify(cnx, path_x,
+                                picoquic_congestion_notification_cwin_blocked,
+                                &ack_state, current_time);
+                        }
                     }
                 }
                 else {
@@ -3440,6 +3453,7 @@ int picoquic_prepare_packet_almost_ready(picoquic_cnx_t* cnx, picoquic_path_t* p
                             }
                             if (ret == 0) {
                                 bytes_next = picoquic_prepare_stream_and_datagrams(cnx, path_x, bytes_next, bytes_max,
+                                    UINT64_MAX,
                                     &more_data, &is_pure_ack, &no_data_to_send, &ret);
                             }
                             /* TODO: replace this by posting of frame when CWIN estimated */
@@ -3774,7 +3788,7 @@ int picoquic_prepare_packet_ready(picoquic_cnx_t* cnx, picoquic_path_t* path_x,
                             bytes_next = picoquic_format_ack_frequency_frame(cnx, bytes_next, bytes_max, &more_data);
                         }
                         if (ret == 0) {
-                            bytes_next = picoquic_prepare_stream_and_datagrams(cnx, path_x, bytes_next, bytes_max,
+                            bytes_next = picoquic_prepare_stream_and_datagrams(cnx, path_x, bytes_next, bytes_max, UINT64_MAX,
                                 &more_data, &is_pure_ack, &no_data_to_send, &ret);
                         }
 

picoquictest/mediatest.c

@@ -175,6 +175,7 @@ typedef struct st_mediatest_spec_t {
     double bandwidth;
     uint64_t latency_average;
     uint64_t latency_max;
+    uint8_t priority_limit_for_bypass;
     int do_not_check_video2;
 } mediatest_spec_t;
 
@@ -1149,6 +1150,10 @@ mediatest_ctx_t * mediatest_configure(int media_test_id,  mediatest_spec_t * spe
                 if (spec->datagram_data_size > 0 && ret == 0) {
                     mt_ctx->datagram_data_requested = spec->datagram_data_size;
                 }
+                if (spec->priority_limit_for_bypass > 0) {
+                    picoquic_set_priority_limit_for_bypass(mt_ctx->client_cnx->cnx, spec->priority_limit_for_bypass);
+                }
+
 
                 for (int i = 0; i < media_test_nb_types; i++) {
                     mt_ctx->media_stats[i].min_delay = UINT64_MAX;
@@ -1436,6 +1441,7 @@ int mediatest_wifi_test()
     spec.data_size = 0;
     spec.latency_average = 60000;
     spec.latency_max = 350000;
+    spec.priority_limit_for_bypass = 5;
     spec.do_not_check_video2 = 1;
     ret = mediatest_one(mediatest_wifi, &spec);