-
Notifications
You must be signed in to change notification settings - Fork 503
Expand file tree
/
Copy pathfd_operator_cache.go
More file actions
99 lines (89 loc) · 2.14 KB
/
fd_operator_cache.go
File metadata and controls
99 lines (89 loc) · 2.14 KB
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
// Copyright 2022 CloudWeGo Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package netpoll
import (
"runtime"
"sync/atomic"
"unsafe"
)
func newOperatorCache() *operatorCache {
return &operatorCache{
cache: make([]*FDOperator, 0, 1024),
freelist: make([]int32, 0, 1024),
}
}
type operatorCache struct {
first *FDOperator
cache []*FDOperator
locked int32
// freelist store the freeable operator
// to reduce GC pressure, we only store op index here
freelocked int32
freelist []int32
}
func (c *operatorCache) alloc() *FDOperator {
lock(&c.locked)
if c.first == nil {
const opSize = unsafe.Sizeof(FDOperator{})
n := block4k / opSize
if n == 0 {
n = 1
}
index := int32(len(c.cache))
for i := uintptr(0); i < n; i++ {
pd := &FDOperator{index: index}
c.cache = append(c.cache, pd)
pd.next = c.first
c.first = pd
index++
}
}
op := c.first
c.first = op.next
unlock(&c.locked)
return op
}
// freeable mark the operator that could be freed
// only poller could do the real free action
func (c *operatorCache) freeable(op *FDOperator) {
// reset all state
op.unused()
op.reset()
lock(&c.freelocked)
c.freelist = append(c.freelist, op.index)
unlock(&c.freelocked)
}
func (c *operatorCache) free() {
lock(&c.freelocked)
defer unlock(&c.freelocked)
if len(c.freelist) == 0 {
return
}
lock(&c.locked)
for _, idx := range c.freelist {
op := c.cache[idx]
op.next = c.first
c.first = op
}
c.freelist = c.freelist[:0]
unlock(&c.locked)
}
func lock(locked *int32) {
for !atomic.CompareAndSwapInt32(locked, 0, 1) {
runtime.Gosched()
}
}
func unlock(locked *int32) {
atomic.StoreInt32(locked, 0)
}