From 5e63e9d56668a62a87b581ac66ab9701e3a31042 Mon Sep 17 00:00:00 2001
From: agnosticdev <agnosticdev@gmail.com>
Date: Sun, 14 Jun 2026 14:54:07 -0700
Subject: [PATCH 1/3] SwiftQUIC: PERF: acknowledgedSendDataInner is using too
 much CPU

---
 .../SwiftNetwork/QUIC/StreamSendBuffer.swift  | 105 +++++++++++++++---
 1 file changed, 89 insertions(+), 16 deletions(-)

diff --git a/Sources/SwiftNetwork/QUIC/StreamSendBuffer.swift b/Sources/SwiftNetwork/QUIC/StreamSendBuffer.swift
index a690804..9689648 100644
--- a/Sources/SwiftNetwork/QUIC/StreamSendBuffer.swift
+++ b/Sources/SwiftNetwork/QUIC/StreamSendBuffer.swift
@@ -161,7 +161,7 @@ struct StreamSendBuffer: ~Copyable {
         return totalLengthCopied
     }
 
-    var acknowledgedDataRanges = RangeSet<StreamOffset>()
+    var acknowledgedDataRanges = AcknowledgedRanges()
 
     mutating private func acknowledgedSendDataInner(
         offset acknowledgedOffset: StreamOffset,
@@ -192,7 +192,34 @@ struct StreamSendBuffer: ~Copyable {
             acknowledgedOffset = storageStartOffset
         }
 
-        // Record the newly acked range
+        // ACK is contiguous with storageStartOffset and in-order
+        if acknowledgedOffset == storageStartOffset {
+            var newStartOffset = totalAcknowledgedOffset
+            var consumed = 0
+            while consumed < acknowledgedDataRanges.ranges.count
+                && acknowledgedDataRanges.ranges[consumed].lowerBound <= newStartOffset
+            {
+                newStartOffset = max(newStartOffset, acknowledgedDataRanges.ranges[consumed].upperBound)
+                consumed += 1
+            }
+            // Remove the consumed in one shot
+            if consumed > 0 {
+                acknowledgedDataRanges.ranges.removeSubrange(0..<consumed)
+            }
+            let difference = newStartOffset - storageStartOffset
+            storageStartOffset = newStartOffset
+            if !storage.isEmpty {
+                guard storage.claim(fromStart: Int(difference)) else {
+                    log.fault(
+                        "Failed to claim \(difference) bytes from start of stream send buffer storage"
+                    )
+                    return
+                }
+            }
+            return
+        }
+
+        // Out of order ACK, buffer it and check if the gap is closed.
         acknowledgedDataRanges.insert(contentsOf: acknowledgedOffset..<totalAcknowledgedOffset)
 
         guard acknowledgedDataRanges.ranges[0].lowerBound == storageStartOffset else {
@@ -200,25 +227,22 @@ struct StreamSendBuffer: ~Copyable {
             return
         }
 
-        // The first acked data range is contiguous with previous data. The end of that
-        // range will be the new start offset.
+        // The first buffered range is now contiguous with storageStartOffset.
+        // Consume any subsequent ranges that are also contiguous.
         let oldStartOffset = storageStartOffset
-        let newStartOffset = acknowledgedDataRanges.ranges[0].upperBound
-
-        guard newStartOffset > oldStartOffset else {
-            // No change, ignore
-            return
+        var newStartOffset = acknowledgedDataRanges.ranges[0].upperBound
+        var consumed = 1
+        while consumed < acknowledgedDataRanges.ranges.count
+            && acknowledgedDataRanges.ranges[consumed].lowerBound <= newStartOffset
+        {
+            newStartOffset = max(newStartOffset, acknowledgedDataRanges.ranges[consumed].upperBound)
+            consumed += 1
         }
+        acknowledgedDataRanges.ranges.removeSubrange(0..<consumed)
 
-        // Update stored ranges
-        acknowledgedDataRanges.remove(contentsOf: oldStartOffset..<newStartOffset)
-
-        // Update offset cursor
         storageStartOffset = newStartOffset
-
+        let difference = newStartOffset - oldStartOffset
         if !storage.isEmpty {
-            // Drop frame data for newly acked data
-            let difference = newStartOffset - oldStartOffset
             guard storage.claim(fromStart: Int(difference)) else {
                 log.fault("Failed to claim \(difference) bytes from start of stream send buffer storage")
                 return
@@ -240,6 +264,55 @@ struct StreamSendBuffer: ~Copyable {
     }
 }
 
+// Sorted list of ACK byte ranges. Used to track out of order ACKs.
+struct AcknowledgedRanges {
+    var ranges: [Range<StreamOffset>] = []
+
+    var isEmpty: Bool {
+        ranges.isEmpty
+    }
+
+    // Insert a range and merge with any overlapping or adjacent existing ranges.
+    mutating func insert(contentsOf newRange: Range<StreamOffset>) {
+        guard !newRange.isEmpty else { return }
+
+        let lower = newRange.lowerBound
+        let upper = newRange.upperBound
+
+        // startIndex is the first range where upperBound >= lower.
+        var low = 0
+        var high = ranges.count
+        while low < high {
+            let mid = low + (high - low) / 2
+            if ranges[mid].upperBound < lower {
+                low = mid + 1
+            } else {
+                high = mid
+            }
+        }
+        let startIndex = low
+
+        // endIndex is the first range where lowerBound > upper.
+        low = startIndex
+        high = ranges.count
+        while low < high {
+            let mid = low + (high - low) / 2
+            if ranges[mid].lowerBound <= upper {
+                low = mid + 1
+            } else {
+                high = mid
+            }
+        }
+        let endIndex = low
+
+        // Merge the new range with all existing ranges in [startIndex, endIndex) by
+        // taking the minimum lower bound and maximum upper bound across the whole set.
+        let mergedLower = startIndex < endIndex ? min(lower, ranges[startIndex].lowerBound) : lower
+        let mergedUpper = startIndex < endIndex ? max(upper, ranges[endIndex - 1].upperBound) : upper
+        ranges.replaceSubrange(startIndex..<endIndex, with: CollectionOfOne(mergedLower..<mergedUpper))
+    }
+}
+
 // Special case of frame array that keeps track of the total unclaimed length
 struct FrameArrayQueue: ~Copyable {
     private var frames = FrameArray()

From 778751c3dd76a09c99feb1a6d9929d409ad47c15 Mon Sep 17 00:00:00 2001
From: agnosticdev <agnosticdev@gmail.com>
Date: Mon, 15 Jun 2026 07:48:53 -0700
Subject: [PATCH 2/3] Clean up redundant code

---
 .../SwiftNetwork/QUIC/StreamSendBuffer.swift  | 31 ++-----------------
 1 file changed, 2 insertions(+), 29 deletions(-)

diff --git a/Sources/SwiftNetwork/QUIC/StreamSendBuffer.swift b/Sources/SwiftNetwork/QUIC/StreamSendBuffer.swift
index 9689648..1917c0e 100644
--- a/Sources/SwiftNetwork/QUIC/StreamSendBuffer.swift
+++ b/Sources/SwiftNetwork/QUIC/StreamSendBuffer.swift
@@ -219,35 +219,9 @@ struct StreamSendBuffer: ~Copyable {
             return
         }
 
-        // Out of order ACK, buffer it and check if the gap is closed.
+        // Out of order ACK. The gap will be consumed when the in-order
+        // path above processes an ACK that fits this range.
         acknowledgedDataRanges.insert(contentsOf: acknowledgedOffset..<totalAcknowledgedOffset)
-
-        guard acknowledgedDataRanges.ranges[0].lowerBound == storageStartOffset else {
-            // We can't increment the storageStartOffset due to a gap. Return.
-            return
-        }
-
-        // The first buffered range is now contiguous with storageStartOffset.
-        // Consume any subsequent ranges that are also contiguous.
-        let oldStartOffset = storageStartOffset
-        var newStartOffset = acknowledgedDataRanges.ranges[0].upperBound
-        var consumed = 1
-        while consumed < acknowledgedDataRanges.ranges.count
-            && acknowledgedDataRanges.ranges[consumed].lowerBound <= newStartOffset
-        {
-            newStartOffset = max(newStartOffset, acknowledgedDataRanges.ranges[consumed].upperBound)
-            consumed += 1
-        }
-        acknowledgedDataRanges.ranges.removeSubrange(0..<consumed)
-
-        storageStartOffset = newStartOffset
-        let difference = newStartOffset - oldStartOffset
-        if !storage.isEmpty {
-            guard storage.claim(fromStart: Int(difference)) else {
-                log.fault("Failed to claim \(difference) bytes from start of stream send buffer storage")
-                return
-            }
-        }
     }
 
     // Returns true if it acknowledged to the end of the data now, i.e. end of stream.
@@ -293,7 +267,6 @@ struct AcknowledgedRanges {
         let startIndex = low
 
         // endIndex is the first range where lowerBound > upper.
-        low = startIndex
         high = ranges.count
         while low < high {
             let mid = low + (high - low) / 2

From aea34ef460fb2fe3609cadd5bbee196a63655ce0 Mon Sep 17 00:00:00 2001
From: agnosticdev <agnosticdev@gmail.com>
Date: Mon, 15 Jun 2026 16:00:33 -0700
Subject: [PATCH 3/3] Moved back to RangeSet

---
 .../SwiftNetwork/QUIC/StreamSendBuffer.swift  | 52 +------------------
 1 file changed, 2 insertions(+), 50 deletions(-)

diff --git a/Sources/SwiftNetwork/QUIC/StreamSendBuffer.swift b/Sources/SwiftNetwork/QUIC/StreamSendBuffer.swift
index 1917c0e..dfc440e 100644
--- a/Sources/SwiftNetwork/QUIC/StreamSendBuffer.swift
+++ b/Sources/SwiftNetwork/QUIC/StreamSendBuffer.swift
@@ -161,7 +161,7 @@ struct StreamSendBuffer: ~Copyable {
         return totalLengthCopied
     }
 
-    var acknowledgedDataRanges = AcknowledgedRanges()
+    var acknowledgedDataRanges = RangeSet<StreamOffset>()
 
     mutating private func acknowledgedSendDataInner(
         offset acknowledgedOffset: StreamOffset,
@@ -204,7 +204,7 @@ struct StreamSendBuffer: ~Copyable {
             }
             // Remove the consumed in one shot
             if consumed > 0 {
-                acknowledgedDataRanges.ranges.removeSubrange(0..<consumed)
+                acknowledgedDataRanges.remove(contentsOf: 0..<UInt64(consumed))
             }
             let difference = newStartOffset - storageStartOffset
             storageStartOffset = newStartOffset
@@ -238,54 +238,6 @@ struct StreamSendBuffer: ~Copyable {
     }
 }
 
-// Sorted list of ACK byte ranges. Used to track out of order ACKs.
-struct AcknowledgedRanges {
-    var ranges: [Range<StreamOffset>] = []
-
-    var isEmpty: Bool {
-        ranges.isEmpty
-    }
-
-    // Insert a range and merge with any overlapping or adjacent existing ranges.
-    mutating func insert(contentsOf newRange: Range<StreamOffset>) {
-        guard !newRange.isEmpty else { return }
-
-        let lower = newRange.lowerBound
-        let upper = newRange.upperBound
-
-        // startIndex is the first range where upperBound >= lower.
-        var low = 0
-        var high = ranges.count
-        while low < high {
-            let mid = low + (high - low) / 2
-            if ranges[mid].upperBound < lower {
-                low = mid + 1
-            } else {
-                high = mid
-            }
-        }
-        let startIndex = low
-
-        // endIndex is the first range where lowerBound > upper.
-        high = ranges.count
-        while low < high {
-            let mid = low + (high - low) / 2
-            if ranges[mid].lowerBound <= upper {
-                low = mid + 1
-            } else {
-                high = mid
-            }
-        }
-        let endIndex = low
-
-        // Merge the new range with all existing ranges in [startIndex, endIndex) by
-        // taking the minimum lower bound and maximum upper bound across the whole set.
-        let mergedLower = startIndex < endIndex ? min(lower, ranges[startIndex].lowerBound) : lower
-        let mergedUpper = startIndex < endIndex ? max(upper, ranges[endIndex - 1].upperBound) : upper
-        ranges.replaceSubrange(startIndex..<endIndex, with: CollectionOfOne(mergedLower..<mergedUpper))
-    }
-}
-
 // Special case of frame array that keeps track of the total unclaimed length
 struct FrameArrayQueue: ~Copyable {
     private var frames = FrameArray()