Lines Matching refs:self
29 self, argument
53 self.access_time = access_time
54 self.block_id = block_id
55 self.block_type = block_type
56 self.block_size = block_size + block_key_size
57 self.cf_id = cf_id
58 self.cf_name = cf_name
59 self.level = level
60 self.fd = fd
61 self.caller = caller
63 self.no_insert = True
65 self.no_insert = False
66 self.get_id = get_id
67 self.key_id = key_id
68 self.kv_size = kv_size
70 self.is_hit = True
72 self.is_hit = False
74 self.referenced_key_exist_in_block = True
76 self.referenced_key_exist_in_block = False
77 self.num_keys_in_block = num_keys_in_block
78 self.table_id = table_id
79 self.seq_number = seq_number
80 self.block_key_size = block_key_size
81 self.key_size = key_size
82 self.block_offset_in_file = block_offset_in_file
83 self.next_access_seq_no = next_access_seq_no
90 self, argument
100 self.value_size = value_size
101 self.last_access_number = access_number
102 self.num_hits = num_hits
103 self.cf_id = 0
104 self.level = level
105 self.block_type = block_type
106 self.last_access_time = time_s
107 self.insertion_time = time_s
108 self.table_id = table_id
110 def __repr__(self): argument
113 self.value_size,
114 self.last_access_number,
115 self.num_hits,
116 self.cf_id,
117 self.level,
118 self.block_type,
121 def cost_class(self, cost_class_label): argument
123 return "{}-{}".format(self.table_id, self.block_type)
125 return "{}".format(self.table_id)
127 return "{}".format(self.block_type)
129 return "{}".format(self.cf_id)
131 return "{}-{}".format(self.cf_id, self.block_type)
133 return "{}-{}-{}".format(self.table_id, self.level, self.block_type)
141 def __init__(self, key, hash, value): argument
142 self.key = key
143 self.hash = hash
144 self.value = value
146 def __repr__(self): argument
147 return "k={},h={},v=[{}]".format(self.key, self.hash, self.value)
158 def __init__(self): argument
159 self.initial_size = 32
160 self.table = [None] * self.initial_size
161 self.elements = 0
163 def random_sample(self, sample_size): argument
166 index = random.randint(0, len(self.table) - 1)
171 if self.table[pos] is not None:
172 for i in range(len(self.table[pos])):
173 if self.table[pos][i] is None:
175 samples.append(self.table[pos][i])
179 pos = pos % len(self.table)
185 def __repr__(self): argument
187 for i in range(len(self.table)):
188 if self.table[i] is None:
190 for j in range(len(self.table[i])):
191 if self.table[i][j] is not None:
192 all_entries.append(self.table[i][j])
195 def values(self): argument
197 for i in range(len(self.table)):
198 if self.table[i] is None:
200 for j in range(len(self.table[i])):
201 if self.table[i][j] is not None:
202 all_values.append(self.table[i][j].value)
205 def __len__(self): argument
206 return self.elements
208 def insert(self, key, hash, value): argument
213 self.grow()
215 index = hash % len(self.table)
216 if self.table[index] is None:
217 self.table[index] = []
219 for i in range(len(self.table[index])):
220 if self.table[index][i] is None:
222 if self.table[index][i].hash == hash and self.table[index][i].key == key:
224 self.table[index][i] = HashEntry(key, hash, value)
228 for i in range(len(self.table[index])):
229 if self.table[index][i] is None:
230 self.table[index][i] = HashEntry(key, hash, value)
234 self.table[index].append(HashEntry(key, hash, value))
235 self.elements += 1
237 def resize(self, new_size): argument
238 if new_size == len(self.table):
240 if new_size < self.initial_size:
242 if self.elements < 100:
246 for i in range(len(self.table)):
247 entries = self.table[i]
257 self.table = new_table
263 def grow(self): argument
264 if self.elements < 4 * len(self.table):
266 new_size = int(len(self.table) * 1.5)
267 self.resize(new_size)
269 def delete(self, key, hash): argument
270 index = hash % len(self.table)
273 if self.table[index] is None:
275 for i in range(len(self.table[index])):
277 self.table[index][i] is not None
278 and self.table[index][i].hash == hash
279 and self.table[index][i].key == key
281 deleted_entry = self.table[index][i]
282 self.table[index][i] = None
283 self.elements -= 1
287 self.shrink()
290 def shrink(self): argument
291 if self.elements * 2 >= len(self.table):
293 new_size = int(len(self.table) * 0.7)
294 self.resize(new_size)
296 def lookup(self, key, hash): argument
297 index = hash % len(self.table)
298 if self.table[index] is None:
300 for i in range(len(self.table[index])):
302 self.table[index][i] is not None
303 and self.table[index][i].hash == hash
304 and self.table[index][i].key == key
306 return self.table[index][i].value
311 def __init__(self, time_unit): argument
312 self.num_misses = 0
313 self.num_accesses = 0
314 self.time_unit = time_unit
315 self.time_misses = {}
316 self.time_miss_bytes = {}
317 self.time_accesses = {}
319 def update_metrics(self, access_time, is_hit, miss_bytes): argument
320 access_time /= kMicrosInSecond * self.time_unit
321 self.num_accesses += 1
322 if access_time not in self.time_accesses:
323 self.time_accesses[access_time] = 0
324 self.time_accesses[access_time] += 1
326 self.num_misses += 1
327 if access_time not in self.time_misses:
328 self.time_misses[access_time] = 0
329 self.time_miss_bytes[access_time] = 0
330 self.time_misses[access_time] += 1
331 self.time_miss_bytes[access_time] += miss_bytes
333 def reset_counter(self): argument
334 self.num_misses = 0
335 self.num_accesses = 0
336 self.time_miss_bytes.clear()
337 self.time_misses.clear()
338 self.time_accesses.clear()
340 def compute_miss_bytes(self): argument
342 for at in self.time_miss_bytes:
343 miss_bytes.append(self.time_miss_bytes[at])
354 def miss_ratio(self): argument
355 return float(self.num_misses) * 100.0 / float(self.num_accesses)
358 self, cache_type, cache_size, target_cf_name, result_dir, start, end argument
360 start /= kMicrosInSecond * self.time_unit
361 end /= kMicrosInSecond * self.time_unit
363 result_dir, self.time_unit, cache_type, cache_size, target_cf_name
372 result_dir, self.time_unit, cache_type, cache_size, target_cf_name
377 row += ",{}".format(self.time_misses.get(trace_time, 0))
381 self, cache_type, cache_size, target_cf_name, result_dir, start, end argument
383 start /= kMicrosInSecond * self.time_unit
384 end /= kMicrosInSecond * self.time_unit
386 result_dir, self.time_unit, cache_type, cache_size, target_cf_name
395 result_dir, self.time_unit, cache_type, cache_size, target_cf_name
400 naccesses = self.time_accesses.get(trace_time, 0)
404 self.time_misses.get(trace_time, 0) * 100.0
411 def __init__(self, time_unit, policies): argument
412 self.time_selected_polices = {}
413 self.time_accesses = {}
414 self.policy_names = {}
415 self.time_unit = time_unit
417 self.policy_names[i] = policies[i].policy_name()
419 def update_metrics(self, access_time, selected_policy): argument
420 access_time /= kMicrosInSecond * self.time_unit
421 if access_time not in self.time_accesses:
422 self.time_accesses[access_time] = 0
423 self.time_accesses[access_time] += 1
424 if access_time not in self.time_selected_polices:
425 self.time_selected_polices[access_time] = {}
426 policy_name = self.policy_names[selected_policy]
427 if policy_name not in self.time_selected_polices[access_time]:
428 self.time_selected_polices[access_time][policy_name] = 0
429 self.time_selected_polices[access_time][policy_name] += 1
432 self, cache_type, cache_size, target_cf_name, result_dir, start, end argument
434 start /= kMicrosInSecond * self.time_unit
435 end /= kMicrosInSecond * self.time_unit
437 result_dir, self.time_unit, cache_type, cache_size, target_cf_name
446 result_dir, self.time_unit, cache_type, cache_size, target_cf_name
449 for policy in self.policy_names:
450 policy_name = self.policy_names[policy]
454 self.time_selected_polices.get(trace_time, {}).get(
461 self, cache_type, cache_size, target_cf_name, file_path, start, end argument
463 start /= kMicrosInSecond * self.time_unit
464 end /= kMicrosInSecond * self.time_unit
466 result_dir, self.time_unit, cache_type, cache_size, target_cf_name
475 result_dir, self.time_unit, cache_type, cache_size, target_cf_name
478 for policy in self.policy_names:
479 policy_name = self.policy_names[policy]
482 naccesses = self.time_accesses.get(trace_time, 0)
486 self.time_selected_polices.get(trace_time, {}).get(
502 def __init__(self): argument
503 self.evicted_keys = {}
505 def evict(self, key, max_size): argument
506 self.evicted_keys[key] = 0
508 def delete(self, key): argument
509 self.evicted_keys.pop(key, None)
511 def prioritize_samples(self, samples, auxilliary_info): argument
514 def policy_name(self): argument
517 def generate_reward(self, key): argument
518 if key in self.evicted_keys:
524 def prioritize_samples(self, samples, auxilliary_info): argument
531 def policy_name(self): argument
536 def prioritize_samples(self, samples, auxilliary_info): argument
543 def policy_name(self): argument
548 def prioritize_samples(self, samples, auxilliary_info): argument
551 def policy_name(self): argument
565 def compare(self, e1, e2, now): argument
588 def prioritize_samples(self, samples, auxilliary_info): argument
591 return sorted(samples, cmp=lambda e1, e2: self.compare(e1, e2, now))
593 def policy_name(self): argument
605 def compare(self, e1, e2, now, cost_classes, cost_class_label): argument
641 def prioritize_samples(self, samples, auxilliary_info): argument
648 cmp=lambda e1, e2: self.compare(
653 def policy_name(self): argument
663 def __init__(self, cache_size, enable_cache_row_key): argument
664 self.cache_size = cache_size
665 self.used_size = 0
666 self.per_second_miss_ratio_stats = MissRatioStats(1)
667 self.miss_ratio_stats = MissRatioStats(kSecondsInMinute)
668 self.per_hour_miss_ratio_stats = MissRatioStats(kSecondsInHour)
671 self.enable_cache_row_key = enable_cache_row_key
672 self.get_id_row_key_map = {}
673 self.max_seen_get_id = 0
674 self.retain_get_id_range = 100000
676 def block_key(self, trace_record): argument
679 def row_key(self, trace_record): argument
682 def _lookup(self, trace_record, key, hash): argument
689 def _evict(self, trace_record, key, hash, value_size): argument
696 def _insert(self, trace_record, key, hash, value_size): argument
702 def _should_admit(self, trace_record, key, hash, value_size): argument
710 def cache_name(self): argument
716 def is_ml_cache(self): argument
719 def _update_stats(self, access_time, is_hit, miss_bytes): argument
720 self.per_second_miss_ratio_stats.update_metrics(access_time, is_hit, miss_bytes)
721 self.miss_ratio_stats.update_metrics(access_time, is_hit, miss_bytes)
722 self.per_hour_miss_ratio_stats.update_metrics(access_time, is_hit, miss_bytes)
724 def access(self, trace_record): argument
729 assert self.used_size <= self.cache_size
731 self.enable_cache_row_key > 0
737 self._access_row(trace_record)
739 is_hit = self._access_kv(
741 self.block_key(trace_record),
746 self._update_stats(
750 def _access_row(self, trace_record): argument
751 row_key = self.row_key(trace_record)
752 self.max_seen_get_id = max(self.max_seen_get_id, trace_record.get_id)
753 self.get_id_row_key_map.pop(
754 self.max_seen_get_id - self.retain_get_id_range, None
756 if trace_record.get_id not in self.get_id_row_key_map:
757 self.get_id_row_key_map[trace_record.get_id] = {}
758 self.get_id_row_key_map[trace_record.get_id]["h"] = False
759 if self.get_id_row_key_map[trace_record.get_id]["h"]:
763 self._update_stats(trace_record.access_time, is_hit=True, miss_bytes=0)
765 if row_key not in self.get_id_row_key_map[trace_record.get_id]:
767 is_hit = self._access_kv(
777 self.get_id_row_key_map[trace_record.get_id][row_key] = inserted
778 self.get_id_row_key_map[trace_record.get_id]["h"] = is_hit
779 if self.get_id_row_key_map[trace_record.get_id]["h"]:
783 self._update_stats(trace_record.access_time, is_hit=True, miss_bytes=0)
788 self.enable_cache_row_key == 2
793 is_hit = self._access_kv(
795 key=self.block_key(trace_record),
800 self._update_stats(
805 and not self.get_id_row_key_map[trace_record.get_id][row_key]
808 self._access_kv(
816 self.get_id_row_key_map[trace_record.get_id][row_key] = True
818 def _access_kv(self, trace_record, key, hash, value_size, no_insert): argument
820 assert self.used_size <= self.cache_size
821 if self._lookup(trace_record, key, hash):
827 if value_size > self.cache_size:
830 self._evict(trace_record, key, hash, value_size)
831 if self._should_admit(trace_record, key, hash, value_size):
832 self._insert(trace_record, key, hash, value_size)
833 self.used_size += value_size
844 def __init__(self): argument
845 self.hits = 0
846 self.num_entries_in_cache = 0
847 self.size_in_cache = 0
848 self.sum_insertion_times = 0
849 self.sum_last_access_time = 0
851 def insert(self, trace_record, key, value_size): argument
852 self.size_in_cache += value_size
853 self.num_entries_in_cache += 1
854 self.sum_insertion_times += trace_record.access_time / kMicrosInSecond
855 self.sum_last_access_time += trace_record.access_time / kMicrosInSecond
857 def remove(self, insertion_time, last_access_time, key, value_size, num_hits): argument
858 self.hits -= num_hits
859 self.num_entries_in_cache -= 1
860 self.sum_insertion_times -= insertion_time / kMicrosInSecond
861 self.size_in_cache -= value_size
862 self.sum_last_access_time -= last_access_time / kMicrosInSecond
864 def update_on_hit(self, trace_record, last_access_time): argument
865 self.hits += 1
866 self.sum_last_access_time -= last_access_time / kMicrosInSecond
867 self.sum_last_access_time += trace_record.access_time / kMicrosInSecond
869 def avg_lifetime_in_cache(self, now): argument
870 avg_insertion_time = self.sum_insertion_times / self.num_entries_in_cache
873 def avg_last_access_time(self): argument
874 if self.num_entries_in_cache == 0:
876 return float(self.sum_last_access_time) / float(self.num_entries_in_cache)
878 def avg_size(self): argument
879 if self.num_entries_in_cache == 0:
881 return float(self.sum_last_access_time) / float(self.num_entries_in_cache)
883 def density(self, now): argument
884 avg_insertion_time = self.sum_insertion_times / self.num_entries_in_cache
886 return self.size_in_cache * in_cache_duration
895 def __init__(self, cache_size, enable_cache_row_key, policies, cost_class_label): argument
896 super(MLCache, self).__init__(cache_size, enable_cache_row_key)
897 self.table = HashTable()
898 self.policy_stats = PolicyStats(kSecondsInMinute, policies)
899 self.per_hour_policy_stats = PolicyStats(kSecondsInHour, policies)
900 self.policies = policies
901 self.cost_classes = {}
902 self.cost_class_label = cost_class_label
904 def is_ml_cache(self): argument
907 def _lookup(self, trace_record, key, hash): argument
908 value = self.table.lookup(key, hash)
911 if self.cost_class_label is not None:
912 cost_class = value.cost_class(self.cost_class_label)
913 assert cost_class in self.cost_classes
914 self.cost_classes[cost_class].update_on_hit(
918 self.table.insert(
927 access_number=self.miss_ratio_stats.num_accesses,
935 def _evict(self, trace_record, key, hash, value_size): argument
939 policy_index = self._select_policy(trace_record, key)
940 assert policy_index < len(self.policies) and policy_index >= 0
941 self.policies[policy_index].delete(key)
942 self.policy_stats.update_metrics(trace_record.access_time, policy_index)
943 self.per_hour_policy_stats.update_metrics(
946 while self.used_size + value_size > self.cache_size:
948 samples = self.table.random_sample(kSampleSize)
949 samples = self.policies[policy_index].prioritize_samples(
951 [trace_record.access_time, self.cost_classes, self.cost_class_label],
954 assert self.table.delete(hash_entry.key, hash_entry.hash) is not None
955 self.used_size -= hash_entry.value.value_size
956 self.policies[policy_index].evict(
957 key=hash_entry.key, max_size=self.table.elements
960 if self.cost_class_label is not None:
961 cost_class = hash_entry.value.cost_class(self.cost_class_label)
962 assert cost_class in self.cost_classes
963 self.cost_classes[cost_class].remove(
970 if self.used_size + value_size <= self.cache_size:
973 def _insert(self, trace_record, key, hash, value_size): argument
974 assert self.used_size + value_size <= self.cache_size
981 self.miss_ratio_stats.num_accesses,
985 if self.cost_class_label is not None:
986 cost_class = entry.cost_class(self.cost_class_label)
987 if cost_class not in self.cost_classes:
988 self.cost_classes[cost_class] = CostClassEntry()
989 self.cost_classes[cost_class].insert(trace_record, key, value_size)
990 self.table.insert(key, hash, entry)
992 def _should_admit(self, trace_record, key, hash, value_size): argument
995 def _select_policy(self, trace_record, key): argument
1010 self, argument
1018 super(ThompsonSamplingCache, self).__init__(
1021 self._as = {}
1022 self._bs = {}
1024 self._as = [init_a] * len(self.policies)
1025 self._bs = [init_b] * len(self.policies)
1027 def _select_policy(self, trace_record, key): argument
1028 if len(self.policies) == 1:
1031 np.random.beta(self._as[x], self._bs[x]) for x in range(len(self.policies))
1033 selected_policy = max(range(len(self.policies)), key=lambda x: samples[x])
1034 reward = self.policies[selected_policy].generate_reward(key)
1036 self._as[selected_policy] += reward
1037 self._bs[selected_policy] += 1 - reward
1040 def cache_name(self): argument
1041 if self.enable_cache_row_key:
1043 self.cost_class_label
1045 return "ThompsonSampling with cost class {} (ts)".format(self.cost_class_label)
1059 def __init__(self, cache_size, enable_cache_row_key, policies, cost_class_label): argument
1060 super(LinUCBCache, self).__init__(
1063 self.nfeatures = 4 # Block type, level, cf.
1064 self.th = np.zeros((len(self.policies), self.nfeatures))
1065 self.eps = 0.2
1066 self.b = np.zeros_like(self.th)
1067 self.A = np.zeros((len(self.policies), self.nfeatures, self.nfeatures))
1068 self.A_inv = np.zeros((len(self.policies), self.nfeatures, self.nfeatures))
1069 for i in range(len(self.policies)):
1070 self.A[i] = np.identity(self.nfeatures)
1071 self.th_hat = np.zeros_like(self.th)
1072 self.p = np.zeros(len(self.policies))
1073 self.alph = 0.2
1075 def _select_policy(self, trace_record, key): argument
1076 if len(self.policies) == 1:
1078 x_i = np.zeros(self.nfeatures) # The current context vector
1082 p = np.zeros(len(self.policies))
1083 for a in range(len(self.policies)):
1084 self.th_hat[a] = self.A_inv[a].dot(self.b[a])
1085 ta = x_i.dot(self.A_inv[a]).dot(x_i)
1086 a_upper_ci = self.alph * np.sqrt(ta)
1087 a_mean = self.th_hat[a].dot(x_i)
1091 reward = self.policies[selected_policy].generate_reward(key)
1093 self.A[selected_policy] += np.outer(x_i, x_i)
1094 self.b[selected_policy] += reward * x_i
1095 self.A_inv[selected_policy] = np.linalg.inv(self.A[selected_policy])
1099 def cache_name(self): argument
1100 if self.enable_cache_row_key:
1102 self.cost_class_label
1104 return "LinUCB with cost class {} (linucb)".format(self.cost_class_label)
1114 def __init__(self, key, next_access_seq_no, value_size): argument
1115 self.key = key
1116 self.next_access_seq_no = next_access_seq_no
1117 self.value_size = value_size
1118 self.is_removed = False
1120 def __cmp__(self, other): argument
1121 if other.next_access_seq_no != self.next_access_seq_no:
1122 return other.next_access_seq_no - self.next_access_seq_no
1123 return self.value_size - other.value_size
1125 def __repr__(self): argument
1127 self.key, self.next_access_seq_no, self.value_size, self.is_removed
1136 def __init__(self): argument
1139 self.pq = []
1140 self.table = {}
1142 def pqinsert(self, entry): argument
1145 removed_entry = self.table.pop(entry.key, None)
1150 self.table[entry.key] = entry
1151 heapq.heappush(self.pq, entry)
1154 def pqpop(self): argument
1155 while self.pq:
1156 entry = heapq.heappop(self.pq)
1158 del self.table[entry.key]
1162 def pqpeek(self): argument
1163 while self.pq:
1164 entry = self.pq[0]
1167 heapq.heappop(self.pq)
1170 def __contains__(self, k): argument
1171 return k in self.table
1173 def __getitem__(self, k): argument
1174 return self.table[k]
1176 def __len__(self): argument
1177 return len(self.table)
1179 def values(self): argument
1180 return self.table.values()
1200 def __init__(self, cache_size): argument
1201 super(OPTCache, self).__init__(cache_size, enable_cache_row_key=0)
1202 self.table = PQTable()
1204 def _lookup(self, trace_record, key, hash): argument
1205 if key not in self.table:
1209 self.table.pqinsert(
1211 key, trace_record.next_access_seq_no, self.table[key].value_size
1218 def _evict(self, trace_record, key, hash, value_size): argument
1219 while self.used_size + value_size > self.cache_size:
1220 evict_entry = self.table.pqpop()
1222 self.used_size -= evict_entry.value_size
1224 def _insert(self, trace_record, key, hash, value_size): argument
1226 self.table.pqinsert(
1232 def _should_admit(self, trace_record, key, hash, value_size): argument
1235 def cache_name(self): argument
1244 def __init__(self, key, value_size, priority): argument
1245 self.key = key
1246 self.value_size = value_size
1247 self.priority = priority
1248 self.is_removed = False
1250 def __cmp__(self, other): argument
1251 if other.priority != self.priority:
1252 return self.priority - other.priority
1253 return self.value_size - other.value_size
1255 def __repr__(self): argument
1257 self.key, self.next_access_seq_no, self.value_size, self.is_removed
1273 def __init__(self, cache_size, enable_cache_row_key): argument
1274 super(GDSizeCache, self).__init__(cache_size, enable_cache_row_key)
1275 self.table = PQTable()
1276 self.L = 0.0
1278 def cache_name(self): argument
1279 if self.enable_cache_row_key:
1283 def _lookup(self, trace_record, key, hash): argument
1284 if key not in self.table:
1287 entry = self.table[key]
1289 self.table.pqinsert(
1290 GDSizeEntry(key, entry.value_size, self.L + entry.value_size)
1296 def _evict(self, trace_record, key, hash, value_size): argument
1297 while self.used_size + value_size > self.cache_size:
1298 evict_entry = self.table.pqpop()
1300 self.L = evict_entry.priority
1301 self.used_size -= evict_entry.value_size
1303 def _insert(self, trace_record, key, hash, value_size): argument
1305 self.table.pqinsert(GDSizeEntry(key, value_size, self.L + value_size))
1309 def _should_admit(self, trace_record, key, hash, value_size): argument
1316 def __init__(self): argument
1317 self.od = OrderedDict()
1319 def appendleft(self, k): argument
1320 if k in self.od:
1321 del self.od[k]
1322 self.od[k] = None
1324 def pop(self): argument
1325 item = self.od.popitem(last=False) if self.od else None
1330 def remove(self, k): argument
1331 del self.od[k]
1333 def __len__(self): argument
1334 return len(self.od)
1336 def __contains__(self, k): argument
1337 return k in self.od
1339 def __iter__(self): argument
1340 return reversed(self.od)
1342 def __repr__(self): argument
1343 return "Deque(%r)" % (list(self),)
1363 def __init__(self, cache_size, enable_cache_row_key): argument
1364 super(ARCCache, self).__init__(cache_size, enable_cache_row_key)
1365 self.table = {}
1366 self.c = cache_size / 16 * 1024 # Number of elements in the cache.
1367 self.p = 0 # Target size for the list T1
1369 self.t1 = Deque() # T1: recent cache entries
1370 self.b1 = Deque() # B1: ghost entries recently evicted from the T1 cache
1372 self.t2 = Deque() # T2: frequent entries
1373 self.b2 = Deque() # B2: ghost entries recently evicted from the T2 cache
1375 def _replace(self, key, value_size): argument
1376 while self.used_size + value_size > self.cache_size:
1377 if self.t1 and ((key in self.b2) or (len(self.t1) > self.p)):
1378 old = self.t1.pop()
1379 self.b1.appendleft(old)
1381 if self.t2:
1382 old = self.t2.pop()
1383 self.b2.appendleft(old)
1385 old = self.t1.pop()
1386 self.b1.appendleft(old)
1387 self.used_size -= self.table[old].value_size
1388 del self.table[old]
1390 def _lookup(self, trace_record, key, hash): argument
1393 if key in self.t1:
1394 self.t1.remove(key)
1395 self.t2.appendleft(key)
1398 if key in self.t2:
1399 self.t2.remove(key)
1400 self.t2.appendleft(key)
1404 def _evict(self, trace_record, key, hash, value_size): argument
1407 if key in self.b1:
1408 self.p = min(self.c, self.p + max(len(self.b2) / len(self.b1), 1))
1409 self._replace(key, value_size)
1410 self.b1.remove(key)
1411 self.t2.appendleft(key)
1416 if key in self.b2:
1417 self.p = max(0, self.p - max(len(self.b1) / len(self.b2), 1))
1418 self._replace(key, value_size)
1419 self.b2.remove(key)
1420 self.t2.appendleft(key)
1424 self._replace(key, value_size)
1425 while len(self.t1) + len(self.b1) >= self.c and self.b1:
1426 self.b1.pop()
1428 total = len(self.t1) + len(self.b1) + len(self.t2) + len(self.b2)
1429 while total >= (2 * self.c) and self.b2:
1430 self.b2.pop()
1433 self.t1.appendleft(key)
1436 def _insert(self, trace_record, key, hash, value_size): argument
1437 self.table[key] = CacheEntry(
1447 def _should_admit(self, trace_record, key, hash, value_size): argument
1450 def cache_name(self): argument
1451 if self.enable_cache_row_key:
1461 def __init__(self, cache_size, enable_cache_row_key): argument
1462 super(LRUCache, self).__init__(cache_size, enable_cache_row_key)
1463 self.table = {}
1464 self.lru = Deque()
1466 def cache_name(self): argument
1467 if self.enable_cache_row_key:
1471 def _lookup(self, trace_record, key, hash): argument
1472 if key not in self.table:
1475 self.lru.remove(key)
1476 self.lru.appendleft(key)
1479 def _evict(self, trace_record, key, hash, value_size): argument
1480 while self.used_size + value_size > self.cache_size:
1481 evict_key = self.lru.pop()
1482 self.used_size -= self.table[evict_key].value_size
1483 del self.table[evict_key]
1485 def _insert(self, trace_record, key, hash, value_size): argument
1486 self.table[key] = CacheEntry(
1495 self.lru.appendleft(key)
1497 def _should_admit(self, trace_record, key, hash, value_size): argument
1507 def __init__(self, cache_size): argument
1508 super(TraceCache, self).__init__(cache_size, enable_cache_row_key=0)
1510 def _lookup(self, trace_record, key, hash): argument
1513 def _evict(self, trace_record, key, hash, value_size): argument
1516 def _insert(self, trace_record, key, hash, value_size): argument
1519 def _should_admit(self, trace_record, key, hash, value_size): argument
1522 def cache_name(self): argument
1642 def __init__(self): argument
1643 self.accesses = []
1644 self.current_access_index = 1
1646 def get_next_access(self): argument
1647 if self.current_access_index == len(self.accesses):
1649 next_access_seq_no = self.accesses[self.current_access_index]
1650 self.current_access_index += 1