Maintain an internal buffer pool to accelerate allocation

common/alloc/buffer.go

@@ -0,0 +1,104 @@
+package alloc
+
+import (
+	//"fmt"
+	"time"
+)
+
+type Buffer struct {
+	head  []byte
+	pool  *bufferPool
+	Value []byte
+}
+
+func (b *Buffer) Release() {
+	b.pool.free(b)
+}
+
+func (b *Buffer) Clear() {
+	b.Value = b.Value[:0]
+}
+
+func (b *Buffer) Append(data []byte) {
+	b.Value = append(b.Value, data...)
+}
+
+func (b *Buffer) Slice(from, to int) {
+	b.Value = b.Value[from:to]
+}
+
+func (b *Buffer) SliceFrom(from int) {
+	b.Value = b.Value[from:]
+}
+
+func (b *Buffer) Len() int {
+	return len(b.Value)
+}
+
+type bufferPool struct {
+	chain       chan *Buffer
+	allocator   func(*bufferPool) *Buffer
+	minElements int
+	maxElements int
+}
+
+func newBufferPool(allocator func(*bufferPool) *Buffer, minElements, maxElements int) *bufferPool {
+	pool := &bufferPool{
+		chain:       make(chan *Buffer, maxElements*2),
+		allocator:   allocateSmall,
+		minElements: minElements,
+		maxElements: maxElements,
+	}
+	for i := 0; i < minElements; i++ {
+		pool.chain <- allocator(pool)
+	}
+	go pool.cleanup(time.Tick(1 * time.Second))
+	return pool
+}
+
+func (p *bufferPool) allocate() *Buffer {
+	//fmt.Printf("Pool size: %d\n", len(p.chain))
+	var b *Buffer
+	select {
+	case b = <-p.chain:
+	default:
+		b = p.allocator(p)
+	}
+	b.Value = b.head
+	return b
+}
+
+func (p *bufferPool) free(buffer *Buffer) {
+	select {
+	case p.chain <- buffer:
+	default:
+	}
+	//fmt.Printf("Pool size: %d\n", len(p.chain))
+}
+
+func (p *bufferPool) cleanup(tick <-chan time.Time) {
+	for range tick {
+		pSize := len(p.chain)
+		for delta := pSize - p.minElements; delta > 0; delta-- {
+			p.chain <- p.allocator(p)
+		}
+		for delta := p.maxElements - pSize; delta > 0; delta-- {
+			<-p.chain
+		}
+	}
+}
+
+func allocateSmall(pool *bufferPool) *Buffer {
+	b := &Buffer{
+		head: make([]byte, 8*1024),
+	}
+	b.Value = b.head
+	b.pool = pool
+	return b
+}
+
+var smallPool = newBufferPool(allocateSmall, 256, 1024)
+
+func NewBuffer() *Buffer {
+	return smallPool.allocate()
+}