bytespool

package module
v1.0.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Dec 11, 2021 License: MIT Imports: 6 Imported by: 10

README

💫 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.
  • BufPool implements the httputil.BufferPool interface.
  • High performance, See: Benchmarks.

⚙️ Installation

go get -u github.com/fufuok/bytespool

📚 Examples

Please see: examples

Release warning: examples/warning

Simple reverse proxy: examples/reverse_proxy

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

func Get(size int) []byte
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 Put(buf []byte)
func Release(buf []byte) bool
type BufPool struct{ ... }
    func NewBufPool(size int) *BufPool
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)
♾ BufPool
bufPool := bytespool.NewBufPool(32 * 1024)
bs := bufPool.Get()

data := []byte("test")
n := copy(bs, data)
// n: 4, bs: test
fmt.Printf("n: %d, bs: %s", n, bs[:n])

bufPool.Put(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

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func Get added in v1.0.1 

func Get(size int) []byte

func InitDefaultPools 

func InitDefaultPools(minSize, maxSize int)

InitDefaultPools initialize to the default pool.

func Make 

func Make(size int) []byte

func Make64 added in v0.0.2 

func Make64(size uint64) []byte

func MakeMax added in v0.0.2 

func MakeMax() []byte

func MakeMin added in v0.0.2 

func MakeMin() []byte

func New 

func New(size int) []byte
Example 
package main

import (
	"fmt"

	"github.com/fufuok/bytespool"
)

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

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

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

	// 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: 8192, abc
len: 3, cap: 4, 123
same array: true
bs3: 123, bs4: 123
len: 4, cap: 4, xy3

func New64 added in v0.0.2 

func New64(size uint64) []byte

func NewMax added in v0.0.2 

func NewMax() []byte

func NewMin added in v0.0.2 

func NewMin() []byte

func Put added in v1.0.1 

func Put(buf []byte)

func Release 

func Release(buf []byte) bool

Types

type BufPool added in v1.0.1 

type BufPool struct {
	// contains filtered or unexported fields
}

BufPool implements the httputil.BufferPool interface.

func NewBufPool added in v1.0.1 

func NewBufPool(size int) *BufPool

func (*BufPool) Get added in v1.0.1 

func (b *BufPool) Get() []byte

func (*BufPool) Put added in v1.0.1 

func (b *BufPool) Put(buf []byte)

type CapacityPools 

type CapacityPools struct {
	// contains filtered or unexported fields
}

func NewCapacityPools 

func NewCapacityPools(minSize, maxSize int) *CapacityPools

NewCapacityPools divide into multiple pools according to the capacity scale. Maximum range of byte slice pool: [minCapacity,1<<31]

func (*CapacityPools) Get added in v1.0.1 

func (p *CapacityPools) Get(size int) []byte

func (*CapacityPools) Make 

func (p *CapacityPools) Make(capacity int) []byte

Make return an empty bytes pointer variable. Length is 0, default capacity is maxSize.

func (*CapacityPools) Make64 added in v0.0.2 

func (p *CapacityPools) Make64(capacity uint64) []byte

func (*CapacityPools) MakeMax added in v0.0.2 

func (p *CapacityPools) MakeMax() []byte

func (*CapacityPools) MakeMin added in v0.0.2 

func (p *CapacityPools) MakeMin() []byte

func (*CapacityPools) New 

func (p *CapacityPools) New(size int) (buf []byte)

New return bytes of the specified size. Length is size, may contain old data.

func (*CapacityPools) New64 added in v0.0.2 

func (p *CapacityPools) New64(size uint64) []byte

func (*CapacityPools) NewMax added in v0.0.2 

func (p *CapacityPools) NewMax() []byte

func (*CapacityPools) NewMin added in v0.0.2 

func (p *CapacityPools) NewMin() []byte

func (*CapacityPools) Put added in v1.0.1 

func (p *CapacityPools) Put(buf []byte)

func (*CapacityPools) Release 

func (p *CapacityPools) Release(buf []byte) bool

Release put it back into the pool of the corresponding scale. Discard buffer larger than the maximum capacity.

Source Files

View all Source files

Directories

Path Synopsis
examples
bufpool
custom_pools
quickstart
reset_default
reverse_proxy
warning

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.