def put(self, key, value=None):
e = self.stored.get(key)
if not e:
e = Entry(key, value)
self.stats.Set(e)
self.stored[key] = e
if self.cn == self.c:
i = 0
while 1:
assert i <= self.cn
o_key = self.cache[self.hand]
o = self.stored[o_key]
if o.RUbit == 0:
del self.stored[o_key]
self.stats.Evict(o)
self.cache[self.hand] = key
break
else:
o.RUbit = 0
self.hand = (self.hand + 1) % self.cn
i += 1
else:
# cache not full
# don't need to evict
assert self.cn < self.c
self.cache.append(key)
self.cn += 1
else:
# Overwrite it correctly
e.value = value
e.RUbit = 1
return 1
def put(self, key, value=None):
if key not in self.stored:
current_time = time.time()
if self.cn == self.c:
# 0 <= is[0],...,is[self.k-1] <= self.cn-1
ivals = [ random.randint(0, self.cn-1) for i in xrange(self.k) ]
oldest_time = float("inf")
oldest_key = None
oldest_i = None
for i in ivals:
o_key = self.cache[i]
o_e = self.stored[o_key]
o_time = o_e.timestamp
if o_time < oldest_time:
oldest_i = i
oldest_time = o_time
oldest_key = o_key
assert oldest_i != None
assert oldest_key != None
del self.stored[oldest_key]
self.cache[oldest_i] = key
else:
self.cn += 1
self.cache.append(key)
e = Entry(key, value)
e.timestamp = current_time
self.stored[key] = e
return 1
else:
return 0
def put(self, key, value=None):
if key not in self.stored:
current_time = time.time()
if self.cn == self.c:
# 0 <= is[0],...,is[self.k-1] <= self.cn-1
ivals = [
random.randint(0, self.cn - 1) for i in xrange(self.k)
]
oldest_time = float("inf")
oldest_key = None
oldest_i = None
for i in ivals:
o_key = self.cache[i]
o_e = self.stored[o_key]
o_time = o_e.timestamp
if o_time < oldest_time:
oldest_i = i
oldest_time = o_time
oldest_key = o_key
assert oldest_i != None
assert oldest_key != None
del self.stored[oldest_key]
self.cache[oldest_i] = key
else:
self.cn += 1
self.cache.append(key)
e = Entry(key, value)
e.timestamp = current_time
self.stored[key] = e
return 1
else:
return 0
def put(self, key, value=None):
e = self.stored.get(key)
if not e:
e = Entry(key, value)
self.stats.Set(e)
self.stored[key] = e
if self.cn == self.c:
i = 0
while 1:
assert i <= self.cn
o_key = self.cache[self.hand]
o = self.stored[o_key]
if o.RUbit == 0:
del self.stored[o_key]
self.stats.Evict(o)
self.cache[self.hand] = key
break
else:
o.RUbit = 0
self.hand = (self.hand + 1) % self.cn
i += 1
else:
# cache not full
# don't need to evict
assert self.cn < self.c
self.cache.append(key)
self.cn += 1
else:
# Overwrite it correctly
e.value = value
e.RUbit = 1
return 1
def load_past_entries(days=8, excluded_live_ids=None):
if excluded_live_ids is None:
excluded_live_ids = ()
# Note that timestamps in the database are in milliseconds
now = arrow.get().timestamp * 1000
x_days_ago = now - 86400 * days * 1000
return [
entry for entry in Entry.select().where((Entry.timestamp > x_days_ago)
& (Entry.timestamp < now))
if entry.live_id not in excluded_live_ids
]
def load_data(local_path):
res = []
with open(local_path) as f:
for line in f.readlines():
l = line.split(',')
id = int(l[0])
diagnosis = -1 if l[1] == 'B' else 1
ff = [float(x) for x in l[2: 32]]
features = numpy.array(ff)
res.append(Entry(id = id, correct = diagnosis, features = features))
return res
def put(self, key, value=None):
e = self.stored.get(key)
current_time = time.time()
if not e:
# Evict first before inserting (don't want to evict the new item)
if self.cn == self.c:
# 0 <= is[0],...,is[self.k-1] <= self.cn-1
ivals = [
random.randint(0, self.cn - 1) for i in xrange(self.k)
]
oldest_time = float("inf")
oldest_key = None
oldest_i = None
for i in ivals:
o_key = self.cache[i]
o_e = self.stored[o_key]
o_time = o_e.timestamp
if o_time < oldest_time:
oldest_i = i
oldest_time = o_time
oldest_key = o_key
assert oldest_i != None
assert oldest_key != None
o = self.stored[oldest_key]
self.stats.Evict(o)
del self.stored[oldest_key]
self.cache[oldest_i] = key
else:
self.cn += 1
self.cache.append(key)
e = Entry(key, value)
self.stats.Set(e)
e.timestamp = current_time
self.stored[key] = e
return 1
else:
self.stats.Set(e)
e.timestamp = current_time
e.value = value
return 1
def put(self, key, value=None):
e = self.stored.get(key)
current_time = time.time()
if not e:
# Evict first before inserting (don't want to evict the new item)
if self.cn == self.c:
# 0 <= is[0],...,is[self.k-1] <= self.cn-1
ivals = [ random.randint(0, self.cn-1) for i in xrange(self.k) ]
oldest_time = float("inf")
oldest_key = None
oldest_i = None
for i in ivals:
o_key = self.cache[i]
o_e = self.stored[o_key]
o_time = o_e.timestamp
if o_time < oldest_time:
oldest_i = i
oldest_time = o_time
oldest_key = o_key
assert oldest_i != None
assert oldest_key != None
o = self.stored[oldest_key]
self.stats.Evict(o)
del self.stored[oldest_key]
self.cache[oldest_i] = key
else:
self.cn += 1
self.cache.append(key)
e = Entry(key, value)
self.stats.Set(e)
e.timestamp = current_time
self.stored[key] = e
return 1
else:
self.stats.Set(e)
e.timestamp = current_time
e.value = value
return 1
def put(self, key, value=None):
e = Entry(key)
for i in xrange(len(self.l)):
if self.l[i].key == key:
e = self.l[i]
return 1
if len(self.l) == self.cachesize:
ed = self.l[-1]
self.l = [
e
] + self.l[:self.cachesize -
1] # Put they key in front and remove the last
else:
self.l = [e] + self.l[:self.cachesize] # Don't remove the last!!
return 1
def put(self, key, value=None):
e = self.stored.get(key)
if not e:
e = Entry(key, value)
self.stats.Set(e)
if self.cn == self.c:
i = random.randint(0, self.cn - 1) # 0 <= i <= (self.cn-1)
dkey = self.cache[i]
de = self.stored[dkey]
self.stats.Evict(de)
del self.stored[dkey]
self.cache[i] = key
else:
self.cn += 1
self.cache.append(key)
self.stored[key] = e
def put(self, key, value=None):
e = self.cached.get(key)
if e:
self.stats.Set(e)
e.value = value
return 1
e = Entry(key, value)
self.cached[key] = e
self.stats.Set(e)
if key in self.b1:
self.p = min(self.c, self.p + max(len(self.b2) / len(self.b1) , 1))
self.replace(key)
self.b1.remove(key)
self.t2.appendleft(key)
return 1
if key in self.b2:
self.p = max(0, self.p - max(len(self.b1)/len(self.b2) , 1))
self.replace(key)
self.b2.remove(key)
self.t2.appendleft(key)
return 1
if len(self.t1) + len(self.b1) == self.c:
if len(self.t1) < self.c:
self.b1.pop()
self.replace(key)
else:
popkey = self.t1.pop()
de = self.cached[popkey]
self.stats.Evict(de)
del self.cached[popkey]
else:
total = len(self.t1) + len(self.b1) + len(self.t2) + len(self.b2)
if total >= self.c:
if total == (2 * self.c):
self.b2.pop()
self.replace(key)
self.t1.appendleft(key)
return 1
def put(self, key, value=None):
if key not in self.stored:
if self.cn == self.c:
valid = False
delkey = None
while not valid:
dist, delkey, valid = heappop(self.heap)
del self.stored[delkey]
dn = self.entries[delkey]
self.stats.Evict(dn)
del self.entries[delkey]
else:
self.cn += 1
item = [1, key, True]
heappush(self.heap, item)
self.stored[key] = item
e = Entry(key, value)
self.stats.Set(e)
self.entries[key] = e
return 1
else:
# TODO: Overwrite it correctly
return 0
def __init__(self, key, value=None):
Entry.__init__(self, key, value)
self.next = None
self.prev = None
def parse(self, m, value):
return Entry.fromResponse(m, value)
def parse(self, m, value):
return Entry.fromResponse(m, value)
def __init__(self, key, value=None):
Entry.__init__(self, key, value)
self.next = None
self.prev = None