Repository navigation
Expand file tree
/
Copy pathwtinylfu_cache.py
More file actions
131 lines (112 loc) · 4.15 KB
/
Copy pathwtinylfu_cache.py
File metadata and controls
131 lines (112 loc) · 4.15 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
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
from cachetools import LRUCache, Cache
from readerwriterlock import rwlock
import random
class CountMinSketch:
def __init__(self, width=1024, depth=4, decay_interval=10000):
self.width = width
self.depth = depth
self.tables = [[0]*width for _ in range(depth)]
self.seeds = [random.randrange(1<<30) for _ in range(depth)]
self.ops = 0
self.decay_interval = decay_interval
def _hash(self, x, seed):
return hash((x, seed)) % self.width
def add(self, x):
self.ops += 1
est = self.estimate(x)
for i, seed in enumerate(self.seeds):
idx = self._hash(x, seed)
if self.tables[i][idx] <= est:
self.tables[i][idx] += 1
if self.ops >= self.decay_interval:
self.decay()
self.ops = 0
def estimate(self, x):
return min(self.tables[i][self._hash(x, seed)]
for i, seed in enumerate(self.seeds))
def decay(self):
for table in self.tables:
for i in range(len(table)):
table[i] >>= 1
class W2TinyLFU(Cache):
def __init__(self, maxsize, window_pct=1):
super().__init__(maxsize)
self.window_size = max(1, int(maxsize * window_pct / 100))
rest = maxsize - self.window_size
self.probation_size = rest // 2
self.protected_size = rest - self.probation_size
self.window = LRUCache(maxsize=self.window_size)
self.probation = LRUCache(maxsize=self.probation_size)
self.protected = LRUCache(maxsize=self.protected_size)
self.cms = CountMinSketch()
self.data = {}
self._rw_lock = rwlock.RWLockWrite()
def __setitem__(self, key, value):
with self._rw_lock.gen_wlock():
self.data[key] = value
self._put(key)
def __getitem__(self, key):
val = self.get(key, default=None)
if val is None:
raise KeyError(key)
return val
def __contains__(self, key):
return key in self.window or key in self.probation or key in self.protected
def __delitem__(self, key):
with self._rw_lock.gen_wlock():
self.data.pop(key, None)
self.window.pop(key, None)
self.probation.pop(key, None)
self.protected.pop(key, None)
def get(self, key, default=None):
if key in self.window:
self.window[key] = True
return self.data.get(key, default)
if key in self.protected:
self.protected[key] = True
return self.data.get(key, default)
if key in self.probation:
self.probation.pop(key)
if len(self.protected) >= self.protected_size:
demoted = next(iter(self.protected))
self.protected.pop(demoted)
self.probation[demoted] = True
self.protected[key] = True
return self.data.get(key, default)
return default
def _put(self, key):
self.cms.add(key)
if key in self:
return
if len(self.window) < self.window_size:
self.window[key] = True
return
victim = next(iter(self.window))
self.window.pop(victim)
if self.cms.estimate(key) >= self.cms.estimate(victim):
self._admit_to_main(victim)
self._admit_to_main(key)
else:
self._admit_to_main(victim)
self.data.pop(key, None)
def _admit_to_main(self, key):
if key in self.protected or key in self.probation:
return
if self.probation_size == 0:
self.data.pop(key, None)
return
if len(self.probation) < self.probation_size:
self.probation[key] = True
elif self.probation:
evicted = next(iter(self.probation))
self.probation.pop(evicted)
self.probation[key] = True
self.data.pop(evicted, None)
else:
self.data.pop(key, None)
def clear(self):
with self._rw_lock.gen_wlock():
self.window.clear()
self.probation.clear()
self.protected.clear()
self.data.clear()