From c136f72a011fc48b001cd449f4301c65f6f1b935 Mon Sep 17 00:00:00 2001
From: Steven Allen <steven@stebalien.com>
Date: Fri, 5 Oct 2018 18:45:18 -0700
Subject: [PATCH] pool pointers to pointers

So, creating interfaces *allocates*. That means `pool.Put([]byte)` allocates,
that's obviously bad. This was, unfortunately, showing up in go-ipfs after
switching to a pool-backed yamux.

What's the solution to too many allocations? More object pools!
---
 pool.go      | 22 +++++++++++++++++++---
 pool_test.go | 16 ++++++++++++++++
 2 files changed, 35 insertions(+), 3 deletions(-)

diff --git a/pool.go b/pool.go
index e483a4e..d812840 100644
--- a/pool.go
+++ b/pool.go
@@ -41,6 +41,11 @@ const MaxLength = math.MaxInt32
 // You MUST NOT copy Pool after using.
 type BufferPool struct {
 	pools [32]sync.Pool // a list of singlePools
+	ptrs  sync.Pool
+}
+
+type bufp struct {
+	buf []byte
 }
 
 // Get retrieves a buffer of the appropriate length from the buffer pool or
@@ -57,8 +62,12 @@ func (p *BufferPool) Get(length int) []byte {
 		return make([]byte, length)
 	}
 	idx := nextLogBase2(uint32(length))
-	if buf := p.pools[idx].Get(); buf != nil {
-		return buf.([]byte)[:uint32(length)]
+	if ptr := p.pools[idx].Get(); ptr != nil {
+		bp := ptr.(*bufp)
+		buf := bp.buf[:uint32(length)]
+		bp.buf = nil
+		p.ptrs.Put(ptr)
+		return buf
 	}
 	return make([]byte, 1<<idx)[:uint32(length)]
 }
@@ -70,7 +79,14 @@ func (p *BufferPool) Put(buf []byte) {
 		return // drop it
 	}
 	idx := prevLogBase2(uint32(capacity))
-	p.pools[idx].Put(buf)
+	var bp *bufp
+	if ptr := p.ptrs.Get(); ptr != nil {
+		bp = ptr.(*bufp)
+	} else {
+		bp = new(bufp)
+	}
+	bp.buf = buf
+	p.pools[idx].Put(bp)
 }
 
 // Get retrieves a buffer of the appropriate length from the global buffer pool
diff --git a/pool_test.go b/pool_test.go
index e3d7d14..524278a 100644
--- a/pool_test.go
+++ b/pool_test.go
@@ -16,6 +16,22 @@ import (
 	"testing"
 )
 
+func TestAllocations(t *testing.T) {
+	var m1, m2 runtime.MemStats
+	runtime.ReadMemStats(&m1)
+	runtime.GC()
+	for i := 0; i < 10000; i++ {
+		b := Get(1010)
+		Put(b)
+	}
+	runtime.GC()
+	runtime.ReadMemStats(&m2)
+	frees := m2.Frees - m1.Frees
+	if frees > 100 {
+		t.Fatalf("expected less than 100 frees after GC, got %d", frees)
+	}
+}
+
 func TestPool(t *testing.T) {
 	// disable GC so we can control when it happens.
 	defer debug.SetGCPercent(debug.SetGCPercent(-1))
-- 
GitLab