forked from v2ray/v2ray-core
-
Notifications
You must be signed in to change notification settings - Fork 1
/
buffer.go
144 lines (124 loc) · 3.06 KB
/
buffer.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
package alloc
import (
"time"
)
// 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
}
// Release recycles the buffer into an internal buffer pool.
func (b *Buffer) Release() {
b.pool.free(b)
b.head = nil
b.Value = nil
b.pool = nil
}
// Clear clears the content of the buffer, results an empty buffer with
// Len() = 0.
func (b *Buffer) Clear() *Buffer {
b.Value = b.head[:0]
return b
}
// AppendBytes appends one or more bytes to the end of the buffer.
func (b *Buffer) AppendBytes(bytes ...byte) *Buffer {
b.Value = append(b.Value, bytes...)
return b
}
// Append appends a byte array to the end of the buffer.
func (b *Buffer) Append(data []byte) *Buffer {
b.Value = append(b.Value, data...)
return b
}
// Slice cuts the buffer at the given position.
func (b *Buffer) Slice(from, to int) *Buffer {
b.Value = b.Value[from:to]
return b
}
// SliceFrom cuts the buffer at the given position.
func (b *Buffer) SliceFrom(from int) *Buffer {
b.Value = b.Value[from:]
return b
}
// Len returns the length of the buffer content.
func (b *Buffer) Len() int {
return len(b.Value)
}
// IsFull returns true if the buffer has no more room to grow.
func (b *Buffer) IsFull() bool {
return len(b.Value) == cap(b.Value)
}
// Write implements Write method in io.Writer.
func (b *Buffer) Write(data []byte) (int, error) {
b.Append(data)
return len(data), nil
}
type bufferPool struct {
chain chan []byte
bufferSize int
buffers2Keep int
}
func newBufferPool(bufferSize, buffers2Keep, poolSize int) *bufferPool {
pool := &bufferPool{
chain: make(chan []byte, poolSize),
bufferSize: bufferSize,
buffers2Keep: buffers2Keep,
}
for i := 0; i < buffers2Keep; i++ {
pool.chain <- make([]byte, bufferSize)
}
go pool.cleanup(time.Tick(1 * time.Second))
return pool
}
func (p *bufferPool) allocate() *Buffer {
var b []byte
select {
case b = <-p.chain:
default:
b = make([]byte, p.bufferSize)
}
return &Buffer{
head: b,
pool: p,
Value: b,
}
}
func (p *bufferPool) free(buffer *Buffer) {
select {
case p.chain <- buffer.head:
default:
}
}
func (p *bufferPool) cleanup(tick <-chan time.Time) {
for range tick {
pSize := len(p.chain)
if pSize > p.buffers2Keep {
<-p.chain
continue
}
for delta := p.buffers2Keep - pSize; delta > 0; delta-- {
select {
case p.chain <- make([]byte, p.bufferSize):
default:
}
}
}
}
var smallPool = newBufferPool(1024, 64, 512)
var mediumPool = newBufferPool(8*1024, 256, 2048)
var largePool = newBufferPool(64*1024, 128, 1024)
// NewSmallBuffer creates a Buffer with 1K bytes of arbitrary content.
func NewSmallBuffer() *Buffer {
return smallPool.allocate()
}
// NewBuffer creates a Buffer with 8K bytes of arbitrary content.
func NewBuffer() *Buffer {
return mediumPool.allocate()
}
// NewLargeBuffer creates a Buffer with 64K bytes of arbitrary content.
func NewLargeBuffer() *Buffer {
return largePool.allocate()
}