1
0
mirror of https://github.com/v2fly/v2ray-core.git synced 2024-12-22 18:17:52 -05:00
v2fly/common/alloc/buffer.go

133 lines
2.8 KiB
Go
Raw Normal View History

package alloc
import (
"sync"
)
2015-10-11 08:46:12 -04:00
// Buffer is a recyclable allocation of a byte array. Buffer.Release() recycles
// the buffer into an internal buffer pool, in order to recreate a buffer more
// quickly.
type Buffer struct {
head []byte
pool *bufferPool
Value []byte
}
2015-10-11 08:46:12 -04:00
// Release recycles the buffer into an internal buffer pool.
func (b *Buffer) Release() {
b.pool.free(b)
2015-10-08 11:41:38 -04:00
b.head = nil
b.Value = nil
b.pool = nil
}
2015-10-11 08:46:12 -04:00
// Clear clears the content of the buffer, results an empty buffer with
// Len() = 0.
2015-10-08 17:06:12 -04:00
func (b *Buffer) Clear() *Buffer {
2015-10-08 11:41:38 -04:00
b.Value = b.head[:0]
2015-10-08 17:06:12 -04:00
return b
}
2015-10-11 08:46:12 -04:00
// AppendBytes appends one or more bytes to the end of the buffer.
2015-10-08 17:06:12 -04:00
func (b *Buffer) AppendBytes(bytes ...byte) *Buffer {
b.Value = append(b.Value, bytes...)
return b
}
2015-10-11 08:46:12 -04:00
// Append appends a byte array to the end of the buffer.
2015-10-08 17:06:12 -04:00
func (b *Buffer) Append(data []byte) *Buffer {
b.Value = append(b.Value, data...)
2015-10-08 17:06:12 -04:00
return b
}
2015-12-14 18:53:27 -05:00
func (b *Buffer) Bytes() []byte {
return b.Value
}
2015-10-11 08:46:12 -04:00
// Slice cuts the buffer at the given position.
2015-10-08 17:06:12 -04:00
func (b *Buffer) Slice(from, to int) *Buffer {
b.Value = b.Value[from:to]
2015-10-08 17:06:12 -04:00
return b
}
2015-10-11 08:46:12 -04:00
// SliceFrom cuts the buffer at the given position.
2015-10-08 17:06:12 -04:00
func (b *Buffer) SliceFrom(from int) *Buffer {
b.Value = b.Value[from:]
2015-10-08 17:06:12 -04:00
return b
}
2015-10-11 08:46:12 -04:00
// Len returns the length of the buffer content.
func (b *Buffer) Len() int {
return len(b.Value)
}
2015-10-11 08:46:12 -04:00
// IsFull returns true if the buffer has no more room to grow.
2015-10-08 17:06:12 -04:00
func (b *Buffer) IsFull() bool {
return len(b.Value) == cap(b.Value)
}
2015-10-11 08:46:12 -04:00
// Write implements Write method in io.Writer.
2015-10-10 14:52:13 -04:00
func (b *Buffer) Write(data []byte) (int, error) {
b.Append(data)
return len(data), nil
}
type bufferPool struct {
chain chan []byte
allocator *sync.Pool
}
2016-01-09 14:36:23 -05:00
func newBufferPool(bufferSize, poolSize int) *bufferPool {
pool := &bufferPool{
chain: make(chan []byte, poolSize),
allocator: &sync.Pool{
New: func() interface{} { return make([]byte, bufferSize) },
},
}
2016-01-09 14:36:23 -05:00
for i := 0; i < poolSize; i++ {
2015-10-08 11:41:38 -04:00
pool.chain <- make([]byte, bufferSize)
}
return pool
}
func (p *bufferPool) allocate() *Buffer {
2015-10-08 11:41:38 -04:00
var b []byte
select {
case b = <-p.chain:
default:
b = p.allocator.Get().([]byte)
2015-10-08 11:41:38 -04:00
}
return &Buffer{
head: b,
pool: p,
Value: b,
}
}
func (p *bufferPool) free(buffer *Buffer) {
select {
2015-10-08 11:41:38 -04:00
case p.chain <- buffer.head:
default:
p.allocator.Put(buffer.head)
}
}
2016-01-09 14:36:23 -05:00
var smallPool = newBufferPool(1024, 256)
var mediumPool = newBufferPool(8*1024, 512)
var largePool = newBufferPool(64*1024, 128)
2015-10-11 08:46:12 -04:00
// NewSmallBuffer creates a Buffer with 1K bytes of arbitrary content.
2015-10-08 17:06:12 -04:00
func NewSmallBuffer() *Buffer {
return smallPool.allocate()
}
2015-10-08 17:06:12 -04:00
2015-10-11 08:46:12 -04:00
// NewBuffer creates a Buffer with 8K bytes of arbitrary content.
2015-10-08 17:06:12 -04:00
func NewBuffer() *Buffer {
return mediumPool.allocate()
}
2015-10-11 08:46:12 -04:00
// NewLargeBuffer creates a Buffer with 64K bytes of arbitrary content.
2015-10-08 17:06:12 -04:00
func NewLargeBuffer() *Buffer {
return largePool.allocate()
}