def testlru(self):
l = LRUCache(10, threshold=.2)
for id in range(1,20):
l[id] = item(id)
# first couple of items should be gone
assert 1 not in l
assert 2 not in l
# next batch over the threshold of 10 should be present
for id in range(11,20):
assert id in l
l[12]
l[15]
l[23] = item(23)
l[24] = item(24)
l[25] = item(25)
l[26] = item(26)
l[27] = item(27)
assert 11 not in l
assert 13 not in l
for id in (25, 24, 23, 14, 12, 19, 18, 17, 16, 15):
assert id in l
def testlru(self):
l = LRUCache(10, threshold=.2)
for id in range(1, 20):
l[id] = item(id)
# first couple of items should be gone
self.assert_(not l.has_key(1))
self.assert_(not l.has_key(2))
# next batch over the threshold of 10 should be present
for id in range(11, 20):
self.assert_(l.has_key(id))
l[12]
l[15]
l[23] = item(23)
l[24] = item(24)
l[25] = item(25)
l[26] = item(26)
l[27] = item(27)
self.assert_(not l.has_key(11))
self.assert_(not l.has_key(13))
for id in (25, 24, 23, 14, 12, 19, 18, 17, 16, 15):
self.assert_(l.has_key(id))
def func_wrapper(*args, **kwargs):
store = __cache.setdefault(rpc.session.db, {}).setdefault(func_name, LRUCache(limit))
key = cPickle.dumps((args, kwargs))
if key not in store:
store[key] = func(*args, **kwargs)
return copy.deepcopy(store[key])
def _disabled_test_threaded(self):
size = 100
threshold = .5
all_elems = 2000
hot_zone = list(range(30,40))
cache = LRUCache(size, threshold)
# element to store
class Element(object):
def __init__(self, id):
self.id = id
self.regets = 0
# return an element. we will favor ids in the relatively small
# "hot zone" 25% of the time.
def get_elem():
if random.randint(1,4) == 1:
return hot_zone[random.randint(0, len(hot_zone) - 1)]
else:
return random.randint(1, all_elems)
total = [0]
# request thread.
def request_elem():
while True:
total[0] += 1
id = get_elem()
try:
elem = cache[id]
elem.regets += 1
except KeyError:
e = Element(id)
cache[id] = e
time.sleep(random.random() / 1000)
for x in range(0,20):
_thread.start_new_thread(request_elem, ())
# assert size doesn't grow unbounded, doesnt shrink well below size
for x in range(0,5):
time.sleep(1)
print("size:", len(cache))
assert len(cache) < size + size * threshold * 2
assert len(cache) > size - (size * .1)
# computs the average number of times a range of elements were "reused",
# i.e. without being removed from the cache.
def average_regets_in_range(start, end):
elem = [e for e in list(cache.values()) if e.id >= start and e.id <= end]
if len(elem) == 0:
return 0
avg = sum([e.regets for e in elem]) / len(elem)
return avg
hotzone_avg = average_regets_in_range(30, 40)
control_avg = average_regets_in_range(450,760)
total_avg = average_regets_in_range(0, 2000)
# hotzone should be way above the others
print("total fetches", total[0], "hotzone", \
hotzone_avg, "control", \
control_avg, "total", total_avg)
assert hotzone_avg > total_avg * 5 > control_avg * 5
# in start-up page and the software header, even if the application
# source code has been changed or updated or code has been added.
#
# You can see the MPL licence at: http://www.mozilla.org/MPL/MPL-1.1.html
#
###############################################################################
import copy
import cPickle
import functools
import cherrypy
from mako.util import LRUCache
import rpc
__cache = LRUCache(cherrypy.config.get('server.db_cache_size', 8))
def clear():
__cache.pop(rpc.session.db, None)
def memoize(limit=100, force=False):
def memoize_wrapper(func):
# Don't use cache for development environment
if not force and cherrypy.config.get('server.environment') == 'development':
return func
func_name = "%s.%s.%s" % (func.__module__, func.func_code.co_firstlineno, func.func_name)
@functools.wraps(func)
def func_wrapper(*args, **kwargs):
