class Deterministic_Zipfian_Lambda(object):
def __init__(self, count, theta):
zetan = zipfian_zeta(theta, count)
zeta2theta = zipfian_zeta(theta, 2)
self.count = count
self.theta = theta
freqs = [float(i)**-theta for i in range(1, count + 1)]
s = sum(freqs)
self.lambdas = [s / i for i in freqs]
self.t = 0
self.next_arrivals = SortedCollection(iterable=enumerate(self.lambdas),
key=itemgetter(1))
def get_popularity(self, item):
return (1.0 / self.lambdas[item])
def __get_next(self):
self.t += 1
item = self.next_arrivals[0]
del self.next_arrivals[0]
item_lambda = self.lambdas[item[0]]
item_next = (item[0], item_lambda + self.t)
self.next_arrivals.insert_right(item_next)
return (item_next[0], 1.0 / item_lambda)
def get_next(self, rand_float):
return self.__get_next()
class PerfectKnowledge_PQ(object):
needs_driver = True
def __init__(self, driver = None, name = "PK_Freq", **kwargs):
self.name = name
self.nodes = SortedCollection(key=attrgetter('priority'))
self.error_numer = 0
self.error_denom = 1
self.driver_access = driver
self.watch_for_shift = (driver_access and "just_shifted" in driver_access.__dict__)
def handle_shift(self):
for node in self.nodes:
old_p = node.priority
node.priority = self.driver_access.get_item_pop(node.value) * node.cost
self.nodes.reorder()
def add_node(self, item, cost, popularity):
new_node = PQNode(item, cost)
new_node.priority = popularity * new_node.cost
self.nodes.insert_right(new_node)
if self.watch_for_shift and self.driver_access.just_shifted:
self.handle_shift()
self.driver_access.just_shifted = False
return new_node
def touch(self, node):
if self.watch_for_shift and self.driver_access.just_shifted:
self.handle_shift()
self.driver_access.just_shifted = False
self.nodes.remove(node)
self.nodes.insert_right(node)
def evict_node(self):
to_evict = self.nodes[0]
del self.nodes[0]
return to_evict
class LRU_Ranked(LastAccess):
def __init__(self, S, retain=0):
super(LRU_Ranked, self).__init__(S, retain=retain)
self.Nodes = SortedCollection(key=attrgetter("LA"))
# using error to track the average eviction rank
self.error_denom = 0
self.error_numer = 0
def objective_f(self, node):
return node.LA
def evict_node(self):
# grab the minimum
x = self.get_minimum(self.sample())
to_evict = self.Nodes[x]
self.error_denom += 1
self.error_numer += x
del self.Nodes[x]
return to_evict
def touch(self, node):
self.Nodes.remove(node)
node.LA = self.time
self.time += 1
self.Nodes.insert_right(node)
def add_node(self, value, cost):
new_node = LastAccessNode(value, self.time)
self.time += 1
self.Nodes.insert_right(new_node)
return new_node