pack packets into large buffers when GSO is available

send_queue.go

@@ -1,15 +1,22 @@
 package quic
 
+import "github.com/quic-go/quic-go/internal/protocol"
+
 type sender interface {
-	Send(p *packetBuffer)
+	Send(p *packetBuffer, packetSize protocol.ByteCount)
 	Run() error
 	WouldBlock() bool
 	Available() <-chan struct{}
 	Close()
 }
 
+type queueEntry struct {
+	buf  *packetBuffer
+	size protocol.ByteCount
+}
+
 type sendQueue struct {
-	queue       chan *packetBuffer
+	queue       chan queueEntry
 	closeCalled chan struct{} // runStopped when Close() is called
 	runStopped  chan struct{} // runStopped when the run loop returns
 	available   chan struct{}
@@ -26,16 +33,16 @@ func newSendQueue(conn sendConn) sender {
 		runStopped:  make(chan struct{}),
 		closeCalled: make(chan struct{}),
 		available:   make(chan struct{}, 1),
-		queue:       make(chan *packetBuffer, sendQueueCapacity),
+		queue:       make(chan queueEntry, sendQueueCapacity),
 	}
 }
 
 // Send sends out a packet. It's guaranteed to not block.
 // Callers need to make sure that there's actually space in the send queue by calling WouldBlock.
 // Otherwise Send will panic.
-func (h *sendQueue) Send(p *packetBuffer) {
+func (h *sendQueue) Send(p *packetBuffer, size protocol.ByteCount) {
 	select {
-	case h.queue <- p:
+	case h.queue <- queueEntry{buf: p, size: size}:
 		// clear available channel if we've reached capacity
 		if len(h.queue) == sendQueueCapacity {
 			select {
@@ -69,8 +76,8 @@ func (h *sendQueue) Run() error {
 			h.closeCalled = nil // prevent this case from being selected again
 			// make sure that all queued packets are actually sent out
 			shouldClose = true
-		case p := <-h.queue:
-			if err := h.conn.Write(p.Data); err != nil {
+		case e := <-h.queue:
+			if err := h.conn.Write(e.buf.Data, e.size); err != nil {
 				// This additional check enables:
 				// 1. Checking for "datagram too large" message from the kernel, as such,
 				// 2. Path MTU discovery,and
@@ -79,7 +86,7 @@ func (h *sendQueue) Run() error {
 					return err
 				}
 			}
-			p.Release()
+			e.buf.Release()
 			select {
 			case h.available <- struct{}{}:
 			default: