-
Notifications
You must be signed in to change notification settings - Fork 974
/
hot_state_cache.go
95 lines (83 loc) · 2.48 KB
/
hot_state_cache.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
package stategen
import (
"sync"
lru "github.com/hashicorp/golang-lru"
"github.com/prometheus/client_golang/prometheus"
"github.com/prometheus/client_golang/prometheus/promauto"
"github.com/prysmaticlabs/prysm/v5/beacon-chain/state"
lruwrpr "github.com/prysmaticlabs/prysm/v5/cache/lru"
)
var (
// hotStateCacheSize defines the max number of hot state this can cache.
hotStateCacheSize = 32
// Metrics
hotStateCacheHit = promauto.NewCounter(prometheus.CounterOpts{
Name: "hot_state_cache_hit",
Help: "The total number of cache hits on the hot state cache.",
})
hotStateCacheMiss = promauto.NewCounter(prometheus.CounterOpts{
Name: "hot_state_cache_miss",
Help: "The total number of cache misses on the hot state cache.",
})
)
// hotStateCache is used to store the processed beacon state after finalized check point.
type hotStateCache struct {
cache *lru.Cache
lock sync.RWMutex
}
// newHotStateCache initializes the map and underlying cache.
func newHotStateCache() *hotStateCache {
return &hotStateCache{
cache: lruwrpr.New(hotStateCacheSize),
}
}
// Get returns a cached response via input block root, if any.
// The response is copied by default.
func (c *hotStateCache) get(blockRoot [32]byte) state.BeaconState {
c.lock.RLock()
defer c.lock.RUnlock()
item, exists := c.cache.Get(blockRoot)
if exists && item != nil {
hotStateCacheHit.Inc()
return item.(state.BeaconState).Copy()
}
hotStateCacheMiss.Inc()
return nil
}
func (c *hotStateCache) ByBlockRoot(r [32]byte) (state.BeaconState, error) {
st := c.get(r)
if st == nil {
return nil, ErrNotInCache
}
return st, nil
}
// GetWithoutCopy returns a non-copied cached response via input block root.
func (c *hotStateCache) getWithoutCopy(blockRoot [32]byte) state.BeaconState {
c.lock.RLock()
defer c.lock.RUnlock()
item, exists := c.cache.Get(blockRoot)
if exists && item != nil {
hotStateCacheHit.Inc()
return item.(state.BeaconState)
}
hotStateCacheMiss.Inc()
return nil
}
// put the response in the cache.
func (c *hotStateCache) put(blockRoot [32]byte, state state.BeaconState) {
c.lock.Lock()
defer c.lock.Unlock()
c.cache.Add(blockRoot, state)
}
// has returns true if the key exists in the cache.
func (c *hotStateCache) has(blockRoot [32]byte) bool {
c.lock.RLock()
defer c.lock.RUnlock()
return c.cache.Contains(blockRoot)
}
// delete deletes the key exists in the cache.
func (c *hotStateCache) delete(blockRoot [32]byte) bool {
c.lock.Lock()
defer c.lock.Unlock()
return c.cache.Remove(blockRoot)
}