disable FIN-packing optimization, increasing transfer rate by 5%

stream_framer.go

@@ -1,8 +1,6 @@
 package quic
 
 import (
-	"runtime"
-
 	"github.com/lucas-clemente/quic-go/flowcontrol"
 	"github.com/lucas-clemente/quic-go/frames"
 	"github.com/lucas-clemente/quic-go/protocol"
@@ -102,13 +100,7 @@ func (f *streamFramer) maybePopNormalFrames(maxBytes protocol.ByteCount) (res []
 
 		data := s.getDataForWriting(maxLen)
 
-		// Here, stream.Write() may return in parallel. Afterwards, the user may
-		// call stream.Close(). We want to pack the FIN into the same frame,
-		// so we speculatively allow the other goroutines to run.
-		// In tests, this increased the percentage of FINs packed into the same
-		// frame from ~20% to ~97%.
-		runtime.Gosched()
-
+		// This is unlikely, but check it nonetheless, the scheduler might have jumped in. Seems to happen in ~20% of cases in the tests.
 		shouldSendFin := s.shouldSendFin()
 		if data == nil && !shouldSendFin {
 			return true, nil

stream_framer_test.go

@@ -2,7 +2,6 @@ package quic
 
 import (
 	"bytes"
-	"time"
 
 	"github.com/lucas-clemente/quic-go/frames"
 	"github.com/lucas-clemente/quic-go/protocol"
@@ -262,36 +261,14 @@ var _ = Describe("Stream Framer", func() {
 			})
 
 			It("bundles FINs with data", func() {
-				// Since this is non-deterministic (see the comment in maybePopNormalFrames),
-				// we give it a few tries and assert that FINs were packed at least
-				// some times.
-				stream1.onData = func() {}
-				stream1.doneWritingOrErrCond.L = &stream1.mutex
-				const n = 1000
-				nFins := 0
-				for i := 0; i < n; {
-					go func() {
-						defer GinkgoRecover()
-						_, err := stream1.Write([]byte("foobar"))
-						Expect(err).NotTo(HaveOccurred())
-						stream1.Close()
-					}()
-					time.Sleep(time.Microsecond)
-					fs := framer.PopStreamFrames(1000)
-					if len(fs) != 1 {
-						continue
-					}
-					Expect(fs[0].StreamID).To(Equal(stream1.streamID))
-					if fs[0].FinBit {
-						nFins++
-					}
-					stream1.closed = 0
-					stream1.finSent = false
-					stream1.dataForWriting = nil
-					i++
-				}
-				Expect(nFins).To(BeNumerically(">", n/2))
-			}, 5)
+				stream1.dataForWriting = []byte("foobar")
+				stream1.closed = 1
+				fs := framer.PopStreamFrames(1000)
+				Expect(fs).To(HaveLen(1))
+				Expect(fs[0].StreamID).To(Equal(stream1.streamID))
+				Expect(fs[0].Data).To(Equal([]byte("foobar")))
+				Expect(fs[0].FinBit).To(BeTrue())
+			})
 		})
 	})