Merge pull request #1679 from private-octopus/media_test_check_reset

Improve the quality reporting API

Author: huitema

CMakeLists.txt

@@ -8,7 +8,7 @@ else()
 endif()
 
 project(picoquic
-        VERSION 1.1.19.9
+        VERSION 1.1.19.10
         DESCRIPTION "picoquic library"
         LANGUAGES C CXX)
 

picoquic/frames.c

@@ -2427,9 +2427,9 @@ picoquic_packet_t* picoquic_check_spurious_retransmission(picoquic_cnx_t* cnx,
 
         if ( p->sequence_number <= end_of_range) {
 
-            uint64_t max_spurious_rtt = current_time - p->send_time;
-            uint64_t max_reorder_delay = pkt_ctx->latest_time_acknowledged - p->send_time;
-            uint64_t max_reorder_gap = pkt_ctx->highest_acknowledged - p->sequence_number;
+            uint64_t spurious_rtt = current_time - p->send_time;
+            uint64_t reorder_delay = pkt_ctx->latest_time_acknowledged - p->send_time;
+            uint64_t reorder_gap = pkt_ctx->highest_acknowledged - p->sequence_number;
             picoquic_path_t * old_path = p->send_path;
 
             /* If the packet contained an ACK frame, perform the ACK of ACK pruning logic.
@@ -2468,20 +2468,16 @@ picoquic_packet_t* picoquic_check_spurious_retransmission(picoquic_cnx_t* cnx,
                     old_path->mtu_probe_sent = 0; 
                 }
 
-                if (max_spurious_rtt > old_path->max_spurious_rtt) {
-                    old_path->max_spurious_rtt = max_spurious_rtt;
+                if (spurious_rtt > old_path->max_spurious_rtt) {
+                    old_path->max_spurious_rtt = spurious_rtt;
                 }
 
-                if (max_reorder_delay > old_path->max_reorder_delay) {
-                    old_path->max_reorder_delay = max_reorder_delay;
+                if (reorder_delay > old_path->max_reorder_delay) {
+                    old_path->max_reorder_delay = reorder_delay;
                 }
 
-                if (max_reorder_gap > old_path->max_reorder_gap) {
-                    old_path->max_reorder_gap = max_reorder_gap;
-                }
-
-                if (old_path->nb_losses_found > 0) {
-                    old_path->nb_losses_found--;
+                if (reorder_gap > old_path->max_reorder_gap) {
+                    old_path->max_reorder_gap = reorder_gap;
                 }
 
                 if (old_path->total_bytes_lost > p->length) {

picoquic/loss_recovery.c

@@ -944,6 +944,9 @@ static void picoquic_count_and_notify_loss(
 
     if (old_p->send_path != NULL) {
         old_p->send_path->nb_losses_found++;
+        if (timer_based_retransmit) {
+            old_p->send_path->nb_timer_losses++;
+        }
         if ((old_p->send_path->smoothed_rtt != PICOQUIC_INITIAL_RTT ||
             old_p->send_path->rtt_variant != 0) &&
             old_p->send_time > cnx->start_time + old_p->send_path->smoothed_rtt) {

picoquic/picoquic.h

@@ -40,7 +40,7 @@
 extern "C" {
 #endif
 
-#define PICOQUIC_VERSION "1.1.19.9"
+#define PICOQUIC_VERSION "1.1.19.10"
 #define PICOQUIC_ERROR_CLASS 0x400
 #define PICOQUIC_ERROR_DUPLICATE (PICOQUIC_ERROR_CLASS + 1)
 #define PICOQUIC_ERROR_AEAD_CHECK (PICOQUIC_ERROR_CLASS + 3)
@@ -900,7 +900,13 @@ typedef struct st_picoquic_path_quality_t {
     uint64_t rtt_max; /* maximum value of RTT, computed since path creation */
     uint64_t sent; /* number of packets sent on the path */
     uint64_t lost; /* number of packets considered lost among those sent */
+    uint64_t timer_losses; /* packet losses detected due to timer expiring */
+    uint64_t spurious_losses; /* number of packet lost that were later acked. */
+    uint64_t max_spurious_rtt; /* maximum RTT for spurious losses */
+    uint64_t max_reorder_delay; /* maximum time gap for out of order packets */
+    uint64_t max_reorder_gap; /* maximum number gap for out of order packets */
     uint64_t bytes_in_transit; /* number of bytes currently in transit */
+
 } picoquic_path_quality_t;
 
 int picoquic_get_path_quality(picoquic_cnx_t* cnx, uint64_t unique_path_id, picoquic_path_quality_t * quality);

picoquic/picoquic_internal.h

@@ -1091,7 +1091,8 @@ typedef struct st_picoquic_path_t {
     uint64_t nb_retransmit; /* Number of timeout retransmissions since last ACK */
     uint64_t total_bytes_lost; /* Sum of length of packet lost on this path */
     uint64_t nb_losses_found;
-    uint64_t nb_spurious; /* Number of spurious retransmissiosn for the path */
+    uint64_t nb_timer_losses;
+    uint64_t nb_spurious; /* Number of spurious retransmissions for the path */
     uint64_t path_packet_acked_number; /* path packet number of highest ack */
     uint64_t path_packet_acked_time_sent; /* path packet number of highest ack */
     uint64_t path_packet_acked_received; /* time at which the highest ack was received */

picoquic/quicctx.c

@@ -2257,6 +2257,11 @@ static void picoquic_get_path_quality_from_context(picoquic_path_t* path_x, pico
     quality->receive_rate_estimate = path_x->receive_rate_estimate;
     quality->sent = path_x->path_packet_number;
     quality->lost = path_x->nb_losses_found;
+    quality->timer_losses = path_x->nb_timer_losses;
+    quality->spurious_losses = path_x->nb_spurious;
+    quality->max_spurious_rtt = path_x->max_spurious_rtt;
+    quality->max_reorder_delay = path_x->max_reorder_delay;
+    quality->max_reorder_gap = path_x->max_reorder_gap;
     quality->bytes_in_transit = path_x->bytes_in_transit;
 }
 

picoquictest/mediatest.c

@@ -102,13 +102,16 @@ typedef struct st_mediatest_stream_ctx_t {
     unsigned int finished_sending : 1;
     unsigned int fin_received : 1;
     unsigned int is_fin_sent : 1;
+    unsigned int is_reset : 1;
 
     uint64_t frames_to_send;
     uint64_t frames_sent;
+    uint64_t frames_skipped;
     uint64_t frames_received;
     size_t bytes_sent;
     size_t bytes_received;
     uint64_t next_frame_time;
+    uint64_t next_iframe_time;
 
     mediatest_message_buffer_t message_sent;
     mediatest_message_buffer_t message_received;
@@ -446,11 +449,40 @@ int mediatest_receive_stream_data(mediatest_stream_ctx_t* stream_ctx, uint8_t* b
     return ret;
 }
 
+/* For the high speed video stream, check if the media is far behind. if
+ * it is, mark the current state as "skipping". If the state is marked
+ * "reset", abstain from sending any frame until the next I frame.
+ */
+void  mediatest_simulate_reset(mediatest_stream_ctx_t* stream_ctx, uint64_t current_time, uint64_t frame_duration, uint64_t cycle_length, uint64_t queue_limit)
+{
+    uint64_t frame_rank = stream_ctx->frames_sent % cycle_length;
+
+    if (frame_rank != 0){
+        if ((stream_ctx->frames_sent + queue_limit * frame_duration) > current_time) {
+            stream_ctx->is_reset = 1;
+        }
+        if (stream_ctx->is_reset) {
+            for (uint64_t i = frame_rank; i < cycle_length; i++) {
+                stream_ctx->next_frame_time += frame_duration;
+                stream_ctx->frames_sent++;
+                stream_ctx->frames_skipped++;
+            }
+        }
+    }
+    else {
+        stream_ctx->is_reset = 0;
+    }
+}
+
 /* Prepare next frame. Do this as soon as we know that a new frame can be sent. */
 int mediatest_prepare_new_frame(mediatest_stream_ctx_t* stream_ctx, uint64_t current_time)
 {
     int ret = 0;
-        /* Is this the right time? */
+    /* Is the high bandwidth stream reset? */
+    if (stream_ctx->stream_type == media_test_video2) {
+        mediatest_simulate_reset(stream_ctx, current_time, MEDIATEST_VIDEO_PERIOD, 100, 10);
+    }
+    /* Is this the right time? */
     if (stream_ctx->next_frame_time <= current_time) {
         if (stream_ctx->frames_sent == 0) {
             stream_ctx->next_frame_time = current_time;
@@ -470,8 +502,12 @@ int mediatest_prepare_new_frame(mediatest_stream_ctx_t* stream_ctx, uint64_t cur
         case media_test_video:
             stream_ctx->message_sent.message_size = ((stream_ctx->frames_sent % 100) == 0) ? 0x8000 : 0x800;
             stream_ctx->next_frame_time += MEDIATEST_VIDEO_PERIOD;
+             
             break;
         case media_test_video2:
+            if ((stream_ctx->frames_sent % 100) == 0) {
+                stream_ctx->next_iframe_time = stream_ctx->next_frame_time + 100 * MEDIATEST_VIDEO_PERIOD;
+            }
             stream_ctx->message_sent.message_size = ((stream_ctx->frames_sent % 100) == 0) ? 0x10000 : 0x1800;
             stream_ctx->next_frame_time += MEDIATEST_VIDEO_PERIOD;
             break;
@@ -1211,6 +1247,7 @@ int mediatest_one(mediatest_id_enum media_test_id, mediatest_spec_t * spec)
         uint64_t sim_time = 0;
         uint64_t blocked_sequence = 4;
         uint64_t unblocked_sequence = 1;
+
         for (int i=0; i<2; i++){
             mt_ctx->link[i]->picosec_per_byte = 160000; /* 160 nanosec per byte, i.e., 50Mbps*/
             mt_ctx->link[i]->microsec_latency = 2000; /* 2ms */
@@ -1270,6 +1307,14 @@ int mediatest_one(mediatest_id_enum media_test_id, mediatest_spec_t * spec)
             ret = mediatest_check_stats(mt_ctx, spec, media_test_video2);
         }
     }
+    if (ret == 0 && media_test_id == mediatest_wifi) {
+        picoquic_path_quality_t quality = { 0 };
+        picoquic_get_default_path_quality(mt_ctx->client_cnx->cnx, &quality);
+        if (quality.lost == 0 || quality.spurious_losses == 0 || quality.timer_losses == 0) {
+            /* Unexpected. the wifi tst should have triggered at least on spurious timer loss. */
+            ret = -1;
+        }
+    }
     if (mt_ctx != NULL) {
         mediatest_delete_ctx(mt_ctx);
     }