bytespool

💫 BytesPool

Reuse used byte slices to achieve zero allocation.

The existing byte slices are stored in groups according to the capacity length range, and suitable byte slice objects are automatically allocated according to the capacity length when used.

✨ Features

• Customize the capacity range, or use the default pool.
• Get byte slices always succeed without panic.
• Optional length of 0 or fixed-length byte slices.
• Automatic garbage collection of big-byte slices.
• High performance, See: Benchmarks.

⚙️ Installation

go get -u github.com/fufuok/bytespool

📚 Examples

Please see: examples

Release warning: examples/warning

package bytespool // import "github.com/fufuok/bytespool"

func InitDefaultPools(minSize, maxSize int)
func Make(size int) []byte
func Make64(size uint64) []byte
func MakeMax() []byte
func MakeMin() []byte
func New(size int) []byte
func New64(size uint64) []byte
func NewMax() []byte
func NewMin() []byte
func Release(buf []byte) bool
type CapacityPools struct{ ... }
    func NewCapacityPools(minSize, maxSize int) *CapacityPools

⚡️ Quickstart

package main

import (
	"fmt"

	"github.com/fufuok/bytespool"
)

func main() {
	// len: 0, capacity: 8192 (Default maximum)
	bs := bytespool.MakeMax()

	// Use...
	bs = append(bs, "abc"...)
	fmt.Printf("len: %d, cap: %d, value: %s\n", len(bs), cap(bs), bs)

	// Put it back into the pool after use
	bytespool.Release(bs)

	// len: 0, capacity: 8 (Specified capacity)
	bs = bytespool.Make(8)
	fmt.Printf("len: %d, cap: %d\n", len(bs), cap(bs))
	bytespool.Release(bs)

	// len: 8, capacity: 8 (Fixed length)
	bs = bytespool.New(8)
	copy(bs, "12345678")
	fmt.Printf("len: %d, cap: %d, value: %s\n", len(bs), cap(bs), bs)
	bytespool.Release(bs)

	// Output:
	// len: 3, cap: 8192, value: abc
	// len: 0, cap: 8
	// len: 8, cap: 8, value: 12345678
}

⏳ Automated reuse

// len: 0, cap: 4 (Specified capacity, automatically adapt to the capacity scale)
bs3 := bytespool.Make(3)

bs3 = append(bs3, "123"...)
fmt.Printf("len: %d, cap: %d, %s\n", len(bs3), cap(bs3), bs3)

bytespool.Release(bs3)

// len: 4, cap: 4 (Fixed length)
bs4 := bytespool.New(4)

// Reuse of bs3
fmt.Printf("same array: %v\n", &bs3[0] == &bs4[0])
// Contain old data
fmt.Printf("bs3: %s, bs4: %s\n", bs3, bs4[:3])

copy(bs4, "xy")
fmt.Printf("len: %d, cap: %d, %s\n", len(bs4), cap(bs4), bs4[:3])

bytespool.Release(bs4)

// Output:
// len: 3, cap: 4, 123
// same array: true
// bs3: 123, bs4: 123
// len: 4, cap: 4, xy3

🛠 Reset DefaultPools

bytespool.InitDefaultPools(512, 4096)

bs := bytespool.Make(10)
fmt.Printf("len: %d, cap: %d\n", len(bs), cap(bs))
bytespool.Release(bs)

bs = bytespool.MakeMax()
fmt.Printf("len: %d, cap: %d\n", len(bs), cap(bs))
bytespool.Release(bs)

bs = bytespool.New(10240)
fmt.Printf("len: %d, cap: %d\n", len(bs), cap(bs))
ok := bytespool.Release(bs)
fmt.Printf("Discard: %v\n", !ok)

// Output:
// len: 0, cap: 512
// len: 0, cap: 4096
// len: 10240, cap: 10240
// Discard: true

🎨 Custom pools

bspool := bytespool.NewCapacityPools(8, 1024)
bs := bspool.MakeMax()
bspool.Release(bs)
bs = bspool.Make(64)
bspool.Release(bs)
bs = bspool.New(128)
bspool.Release(bs)

🤖 Benchmarks

go test -run=^$ -benchmem -benchtime=1s -count=2 -bench=.
goos: linux
goarch: amd64
pkg: github.com/fufuok/bytespool
cpu: Intel(R) Xeon(R) Gold 6151 CPU @ 3.00GHz
BenchmarkCapacityPools/New-4                     27477343                44.06 ns/op            0 B/op          0 allocs/op
BenchmarkCapacityPools/New-4                     26587846                43.59 ns/op            0 B/op          0 allocs/op
BenchmarkCapacityPools/Make-4                    26847370                44.09 ns/op            0 B/op          0 allocs/op
BenchmarkCapacityPools/Make-4                    27189642                43.44 ns/op            0 B/op          0 allocs/op
BenchmarkCapacityPools/MakeMax-4                 52711242                22.77 ns/op            0 B/op          0 allocs/op
BenchmarkCapacityPools/MakeMax-4                 52321828                24.49 ns/op            0 B/op          0 allocs/op
BenchmarkCapacityPools/New.Parallel-4           100000000                10.55 ns/op            0 B/op          0 allocs/op
BenchmarkCapacityPools/New.Parallel-4           100000000                10.52 ns/op            0 B/op          0 allocs/op
BenchmarkCapacityPools/Make.Parallel-4          100000000                10.48 ns/op            0 B/op          0 allocs/op
BenchmarkCapacityPools/Make.Parallel-4          100000000                10.57 ns/op            0 B/op          0 allocs/op
BenchmarkCapacityPools/MakeMax.Parallel-4       204589562                5.929 ns/op            0 B/op          0 allocs/op
BenchmarkCapacityPools/MakeMax.Parallel-4       199840848                5.931 ns/op            0 B/op          0 allocs/op

ff