Updated ACK_FREQUENCY according to draft-ietf-quic-ack-frequency-10

src/core/ack_tracker.c

@@ -182,10 +182,10 @@ QuicAckTrackerAckPacket(
     //   1. The packet included an IMMEDIATE_ACK frame.
     //   2. ACK delay is disabled (MaxAckDelayMs == 0).
     //   3. We have received 'PacketTolerance' ACK eliciting packets.
-    //   4. We received an ACK eliciting packet that doesn't directly follow the
-    //      previously received packet number. So we assume there might have
-    //      been loss and should indicate this info to the peer. This logic is
-    //      disabled if 'IgnoreReordering' is TRUE.
+    //   4. We had received an ACK eliciting packet that is out of order and the
+    //      gap between the smallest Unreported Missing packet and the Largest
+    //      Unacked is greater than or equal to the Reordering Threshold value. This logic is
+    //      disabled if 'IgnoreReordering' is TRUE or the Reordering Threshold is 0.
     //   5. The delayed ACK timer fires after the configured time.
     //
     // If we don't queue an immediate ACK and this is the first ACK eliciting
@@ -196,11 +196,12 @@ QuicAckTrackerAckPacket(
         Connection->Settings.MaxAckDelayMs == 0 ||
         (Tracker->AckElicitingPacketsToAcknowledge >= (uint16_t)Connection->PacketTolerance) ||
         (!Connection->State.IgnoreReordering &&
+         Connection->ReorderingThreshold > 0 &&
          (NewLargestPacketNumber &&
           QuicRangeSize(&Tracker->PacketNumbersToAck) > 1 && // There are more than two ranges, i.e. a gap somewhere.
             QuicRangeGet(
             &Tracker->PacketNumbersToAck,
-          QuicRangeSize(&Tracker->PacketNumbersToAck) - 1)->Count == 1))) { // The gap is right before the last packet number.
+          QuicRangeSize(&Tracker->PacketNumbersToAck) - 1)->Count == Connection->ReorderingThreshold))) {
         //
         // Send the ACK immediately.
         //

src/core/connection.c

@@ -118,6 +118,8 @@ QuicConnAlloc(
     Connection->AckDelayExponent = QUIC_ACK_DELAY_EXPONENT;
     Connection->PacketTolerance = QUIC_MIN_ACK_SEND_NUMBER;
     Connection->PeerPacketTolerance = QUIC_MIN_ACK_SEND_NUMBER;
+    Connection->ReorderingThreshold = QUIC_MIN_REORDERING_THRESHOLD;
+    Connection->PeerReorderingThreshold = QUIC_MIN_REORDERING_THRESHOLD;
     Connection->PeerTransportParams.AckDelayExponent = QUIC_TP_ACK_DELAY_EXPONENT_DEFAULT;
     Connection->ReceiveQueueTail = &Connection->ReceiveQueue;
     QuicSettingsCopy(&Connection->Settings, &MsQuicLib.Settings);
@@ -5245,6 +5247,11 @@ QuicConnRecvFrames(
             } else {
                 Connection->PacketTolerance = UINT8_MAX; // Cap to 0xFF for space savings.
             }
+            if (Frame.ReorderingThreshold < UINT8_MAX) {
+                Connection->ReorderingThreshold = (uint8_t)Frame.ReorderingThreshold;
+            } else {
+                Connection->ReorderingThreshold = UINT8_MAX; // Cap to 0xFF for space savings.
+            }
             QuicTraceLogConnInfo(
                 UpdatePacketTolerance,
                 Connection,

src/core/connection.h

@@ -452,6 +452,21 @@ typedef struct QUIC_CONNECTION {
     // be able to send to the peer.
     //
     uint8_t PeerPacketTolerance;
+
+    //
+    // The maximum number of packets that can be out of order before an immediate
+    // acknowledgment (ACK) is triggered. If no specific instructions (ACK_FREQUENCY
+    // frames) are received from the peer, the receiver will immediately acknowledge
+    // any out-of-order packets, which means the default value is 1. A value of 0
+    // means out-of-order packets do not trigger an immediate ACK.
+    //
+    uint8_t ReorderingThreshold;
+
+    //
+    // The maximum number of packets that the peer can be out of order before an immediate
+    // acknowledgment (ACK) is triggered.
+    //
+    uint8_t PeerReorderingThreshold;
 
     //
     // The ACK frequency sequence number we are currently using to send.

src/core/frame.c

@@ -1261,6 +1261,7 @@ QuicAckFrequencyFrameEncode(
         QuicVarIntSize(Frame->SequenceNumber) +
         QuicVarIntSize(Frame->PacketTolerance) +
         QuicVarIntSize(Frame->UpdateMaxAckDelay) +
+        QuicVarIntSize(Frame->ReorderingThreshold) +
         sizeof(QUIC_ACK_FREQUENCY_EXTRAS);
 
     if (BufferLength < *Offset + RequiredLength) {
@@ -1279,6 +1280,7 @@ QuicAckFrequencyFrameEncode(
     Buffer = QuicVarIntEncode(Frame->SequenceNumber, Buffer);
     Buffer = QuicVarIntEncode(Frame->PacketTolerance, Buffer);
     Buffer = QuicVarIntEncode(Frame->UpdateMaxAckDelay, Buffer);
+    Buffer = QuicVarIntEncode(Frame->ReorderingThreshold, Buffer);
     QuicUint8Encode(Extras.Value, Buffer);
     *Offset += RequiredLength;
 
@@ -1299,6 +1301,7 @@ QuicAckFrequencyFrameDecode(
     if (!QuicVarIntDecode(BufferLength, Buffer, Offset, &Frame->SequenceNumber) ||
         !QuicVarIntDecode(BufferLength, Buffer, Offset, &Frame->PacketTolerance) ||
         !QuicVarIntDecode(BufferLength, Buffer, Offset, &Frame->UpdateMaxAckDelay) ||
+        !QuicVarIntDecode(BufferLength, Buffer, Offset, &Frame->ReorderingThreshold) ||
         !QuicUint8tDecode(BufferLength, Buffer, Offset, &Extras.Value)) {
         return FALSE;
     }
@@ -1963,13 +1966,14 @@ QuicFrameLog(
 
         QuicTraceLogVerbose(
             FrameLogAckFrequency,
-            "[%c][%cX][%llu]   ACK_FREQUENCY SeqNum:%llu PktTolerance:%llu MaxAckDelay:%llu IgnoreOrder:%hhu IgnoreCE:%hhu",
+            "[%c][%cX][%llu]   ACK_FREQUENCY SeqNum:%llu PktTolerance:%llu MaxAckDelay:%llu ReorderThreshold: %llu IgnoreOrder:%hhu IgnoreCE:%hhu",
             PtkConnPre(Connection),
             PktRxPre(Rx),
             PacketNumber,
             Frame.SequenceNumber,
             Frame.PacketTolerance,
             Frame.UpdateMaxAckDelay,
+            Frame.ReorderingThreshold,
             Frame.IgnoreOrder,
             Frame.IgnoreCE);
         break;
@@ -2006,7 +2010,7 @@ QuicFrameLog(
             Frame.Timestamp);
         break;
     }
-    
+
     case QUIC_FRAME_RELIABLE_RESET_STREAM: {
         QUIC_RELIABLE_RESET_STREAM_EX Frame;
         if (!QuicReliableResetFrameDecode(PacketLength, Packet, Offset, &Frame)) {

src/core/frame.h

@@ -846,6 +846,7 @@ typedef struct QUIC_ACK_FREQUENCY_EX {
     QUIC_VAR_INT SequenceNumber;
     QUIC_VAR_INT PacketTolerance;
     QUIC_VAR_INT UpdateMaxAckDelay; // In microseconds (us)
+    QUIC_VAR_INT ReorderingThreshold;
     BOOLEAN IgnoreOrder;
     BOOLEAN IgnoreCE;
 

src/core/quicdef.h

@@ -103,6 +103,12 @@ typedef struct QUIC_RX_PACKET QUIC_RX_PACKET;
 //
 #define QUIC_MIN_ACK_SEND_NUMBER                2
 
+//
+// The value for Reordering threshold when no ACK_FREQUENCY frame is received.
+// This means that the receiver will immediately acknowledge any out-of-order packets.
+//
+#define QUIC_MIN_REORDERING_THRESHOLD           1
+
 //
 // The size of the stateless reset token.
 //

src/core/send.c

@@ -896,6 +896,7 @@ QuicSendWriteFrames(
             Frame.SequenceNumber = Connection->SendAckFreqSeqNum;
             Frame.PacketTolerance = Connection->PeerPacketTolerance;
             Frame.UpdateMaxAckDelay = MS_TO_US(QuicConnGetAckDelay(Connection));
+            Frame.ReorderingThreshold = Connection->PeerReorderingThreshold;
             Frame.IgnoreOrder = FALSE;
             Frame.IgnoreCE = FALSE;
 

src/core/unittest/FrameTest.cpp

@@ -257,7 +257,7 @@ struct ResetStreamFrameParams {
                 uint8_t TestValue = (j & 1) ? 64 : 255;
 
                 if (i & 1) {
-                    Temp.Buffer[1] = TestValue;
+                    Temp.Buffer[1] = TestValue;       
                 } else {
                     Temp.Buffer[1] = 0;
                 }

src/generated/linux/frame.c.clog.h

@@ -1173,16 +1173,17 @@ tracepoint(CLOG_FRAME_C, FrameLogAckFrequencyInvalid , arg2, arg3, arg4);\
 
 /*----------------------------------------------------------
 // Decoder Ring for FrameLogAckFrequency
-// [%c][%cX][%llu]   ACK_FREQUENCY SeqNum:%llu PktTolerance:%llu MaxAckDelay:%llu IgnoreOrder:%hhu IgnoreCE:%hhu
+// [%c][%cX][%llu]   ACK_FREQUENCY SeqNum:%llu PktTolerance:%llu MaxAckDelay:%llu ReorderThreshold:%llu IgnoreOrder:%hhu IgnoreCE:%hhu
 // QuicTraceLogVerbose(
             FrameLogAckFrequency,
-            "[%c][%cX][%llu]   ACK_FREQUENCY SeqNum:%llu PktTolerance:%llu MaxAckDelay:%llu IgnoreOrder:%hhu IgnoreCE:%hhu",
+            "[%c][%cX][%llu]   ACK_FREQUENCY SeqNum:%llu PktTolerance:%llu MaxAckDelay:%llu ReorderThreshold:%llu IgnoreOrder:%hhu IgnoreCE:%hhu",
             PtkConnPre(Connection),
             PktRxPre(Rx),
             PacketNumber,
             Frame.SequenceNumber,
             Frame.PacketTolerance,
             Frame.UpdateMaxAckDelay,
+            Frame.ReorderingThreshold,
             Frame.IgnoreOrder,
             Frame.IgnoreCE);
 // arg2 = arg2 = PtkConnPre(Connection) = arg2
@@ -1191,12 +1192,13 @@ tracepoint(CLOG_FRAME_C, FrameLogAckFrequencyInvalid , arg2, arg3, arg4);\
 // arg5 = arg5 = Frame.SequenceNumber = arg5
 // arg6 = arg6 = Frame.PacketTolerance = arg6
 // arg7 = arg7 = Frame.UpdateMaxAckDelay = arg7
-// arg8 = arg8 = Frame.IgnoreOrder = arg8
-// arg9 = arg9 = Frame.IgnoreCE = arg9
+// arg8 = arg8 = Frame.ReorderingThreshold = arg8
+// arg9 = arg9 = Frame.IgnoreOrder = arg9
+// arg10 = arg10 = Frame.IgnoreCE = arg10
 ----------------------------------------------------------*/
-#ifndef _clog_10_ARGS_TRACE_FrameLogAckFrequency
-#define _clog_10_ARGS_TRACE_FrameLogAckFrequency(uniqueId, encoded_arg_string, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9)\
-tracepoint(CLOG_FRAME_C, FrameLogAckFrequency , arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);\
+#ifndef _clog_11_ARGS_TRACE_FrameLogAckFrequency
+#define _clog_11_ARGS_TRACE_FrameLogAckFrequency(uniqueId, encoded_arg_string, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10)\
+tracepoint(CLOG_FRAME_C, FrameLogAckFrequency , arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);\
 
 #endif