Init project

Author: imannamdari

.gitignore

@@ -0,0 +1,17 @@
+debug
+debug.test
+main
+mockgen_tmp.go
+*.qtr
+*.qlog
+*.txt
+race.[0-9]*
+
+fuzzing/*/*.zip
+fuzzing/*/coverprofile
+fuzzing/*/crashers
+fuzzing/*/sonarprofile
+fuzzing/*/suppressions
+fuzzing/*/corpus/
+
+gomock_reflect_*/

.golangci.yml

@@ -0,0 +1,44 @@
+run:
+  skip-files:
+    - internal/qtls/structs_equal_test.go
+
+linters-settings:
+  depguard:
+    type: blacklist
+    packages:
+      - github.com/marten-seemann/qtls
+    packages-with-error-message:
+      - github.com/marten-seemann/qtls: "importing qtls only allowed in internal/qtls"
+  misspell:
+    ignore-words:
+      - ect
+
+linters:
+  disable-all: true
+  enable:
+    - asciicheck
+    - deadcode
+    - depguard
+    - exhaustive
+    - exportloopref
+    - goimports
+    - gofmt # redundant, since gofmt *should* be a no-op after gofumpt
+    - gofumpt
+    - gosimple
+    - ineffassign
+    - misspell
+    - prealloc
+    - staticcheck
+    - stylecheck
+    - structcheck
+    - unconvert
+    - unparam
+    - unused
+    - varcheck
+    - vet
+
+issues:
+  exclude-rules:
+    - path: internal/qtls
+      linters:
+        - depguard

buffer_pool.go

@@ -0,0 +1,80 @@
+package quic
+
+import (
+	"sync"
+
+	"github.com/imannamdari/quic-go/internal/protocol"
+)
+
+type packetBuffer struct {
+	Data []byte
+
+	// refCount counts how many packets Data is used in.
+	// It doesn't support concurrent use.
+	// It is > 1 when used for coalesced packet.
+	refCount int
+}
+
+// Split increases the refCount.
+// It must be called when a packet buffer is used for more than one packet,
+// e.g. when splitting coalesced packets.
+func (b *packetBuffer) Split() {
+	b.refCount++
+}
+
+// Decrement decrements the reference counter.
+// It doesn't put the buffer back into the pool.
+func (b *packetBuffer) Decrement() {
+	b.refCount--
+	if b.refCount < 0 {
+		panic("negative packetBuffer refCount")
+	}
+}
+
+// MaybeRelease puts the packet buffer back into the pool,
+// if the reference counter already reached 0.
+func (b *packetBuffer) MaybeRelease() {
+	// only put the packetBuffer back if it's not used any more
+	if b.refCount == 0 {
+		b.putBack()
+	}
+}
+
+// Release puts back the packet buffer into the pool.
+// It should be called when processing is definitely finished.
+func (b *packetBuffer) Release() {
+	b.Decrement()
+	if b.refCount != 0 {
+		panic("packetBuffer refCount not zero")
+	}
+	b.putBack()
+}
+
+// Len returns the length of Data
+func (b *packetBuffer) Len() protocol.ByteCount {
+	return protocol.ByteCount(len(b.Data))
+}
+
+func (b *packetBuffer) putBack() {
+	if cap(b.Data) != int(protocol.MaxPacketBufferSize) {
+		panic("putPacketBuffer called with packet of wrong size!")
+	}
+	bufferPool.Put(b)
+}
+
+var bufferPool sync.Pool
+
+func getPacketBuffer() *packetBuffer {
+	buf := bufferPool.Get().(*packetBuffer)
+	buf.refCount = 1
+	buf.Data = buf.Data[:0]
+	return buf
+}
+
+func init() {
+	bufferPool.New = func() interface{} {
+		return &packetBuffer{
+			Data: make([]byte, 0, protocol.MaxPacketBufferSize),
+		}
+	}
+}

buffer_pool_test.go

@@ -0,0 +1,55 @@
+package quic
+
+import (
+	"github.com/imannamdari/quic-go/internal/protocol"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+var _ = Describe("Buffer Pool", func() {
+	It("returns buffers of cap", func() {
+		buf := getPacketBuffer()
+		Expect(buf.Data).To(HaveCap(int(protocol.MaxPacketBufferSize)))
+	})
+
+	It("releases buffers", func() {
+		buf := getPacketBuffer()
+		buf.Release()
+	})
+
+	It("gets the length", func() {
+		buf := getPacketBuffer()
+		buf.Data = append(buf.Data, []byte("foobar")...)
+		Expect(buf.Len()).To(BeEquivalentTo(6))
+	})
+
+	It("panics if wrong-sized buffers are passed", func() {
+		buf := getPacketBuffer()
+		buf.Data = make([]byte, 10)
+		Expect(func() { buf.Release() }).To(Panic())
+	})
+
+	It("panics if it is released twice", func() {
+		buf := getPacketBuffer()
+		buf.Release()
+		Expect(func() { buf.Release() }).To(Panic())
+	})
+
+	It("panics if it is decremented too many times", func() {
+		buf := getPacketBuffer()
+		buf.Decrement()
+		Expect(func() { buf.Decrement() }).To(Panic())
+	})
+
+	It("waits until all parts have been released", func() {
+		buf := getPacketBuffer()
+		buf.Split()
+		buf.Split()
+		// now we have 3 parts
+		buf.Decrement()
+		buf.Decrement()
+		buf.Decrement()
+		Expect(func() { buf.Decrement() }).To(Panic())
+	})
+})