Changeset 666 for branches

Timestamp:

05/28/13 21:26:34 (3 years ago)

Author:

mmckerns

Message:

sync'd memoize with cache; added cache method in memoize

Location:

branches/decorate

Files:

• memoize.py (modified) (6 diffs)
• test_cached_memoize.py (modified) (1 diff)
• test_memoize.py (modified) (3 diffs)
• test_timed_monitor.py (modified) (1 diff)

branches/decorate/memoize.py

@@ -2 +2 @@
 decorators that cache results to memory, to file, or to a database
 """
+from functools import update_wrapper, wraps as functools_wraps
+from rounding import deep_round, simple_round
+from archives import archive_dict
 from keymaps import stringmap
-from archives import archive_dict
-from rounding import deep_round, simple_round
+from cache import _CacheInfo
 
 __all__ = ['memoize', 'memoized']
@@ -11 +13 @@
 #XXX: memoized fails when decorating a class method ???
 
+#XXX: essentially this is: cache.inf_cache(keymap=stringmap(flat=False))
 def memoized(cache=None, keymap=None, tol=None, deep=False):
     """Decorator that memoizes a function's return value each time it is called.
@@ -23 +26 @@
     deep = boolean for rounding depth (default is False, i.e. 'shallow')
     """
-    if keymap is None: keymap = stringmap(flat=False)
+    maxsize = None
+
+    if keymap is None: keymap = stringmap(flat=False) #XXX: hashmap(flat=True)
     if cache is None: cache = archive_dict()
     elif type(cache) is dict: cache = archive_dict(cache)
@@ -36 +41 @@
         return (args, kwds)
 
-    def dec(f):
-        def func(*args, **kwds):
+    def decorating_function(user_function):
+        _len = len                      # localize the global len() function
+        stats = [0, 0, 0]               # make statistics updateable non-locally
+        HIT, MISS, LOAD = 0, 1, 2       # names for the stats fields
+        _len = len                      # localize the global len() function
+       #lock = RLock()                  # linkedlist updates aren't threadsafe
+
+        def wrapper(*args, **kwds):
             try:
                 _args, _kwds = rounded_args(*args, **kwds)
-                argstr = keymap(*_args, **_kwds)
-                if cache.has_key(argstr):
-                    return cache[argstr]
-                if cache.archived():
-                    cache.load(argstr)
-                    if cache.has_key(argstr):
-                        return cache[argstr]
-                res = f(*args, **kwds)
-                cache[argstr] = res  #XXX: any automated dump to archive?
-                return res
+                key = keymap(*_args, **_kwds)
+
+                try:
+                    # get cache entry
+                    result = cache[key]
+                    stats[HIT] += 1
+                except KeyError:
+                    # if not in cache, look in archive
+                    if cache.archived():
+                        cache.load(key)
+                    try:
+                        result = cache[key]
+                        stats[LOAD] += 1
+                    except KeyError:
+                        # if not found, then compute
+                        result = user_function(*args, **kwds)
+                        cache[key] = result
+                        stats[MISS] += 1
+                    #XXX:  NO cache purge...
             except: #TypeError
-                return f(*args, **kwds)
-        func.cache = cache
-        return func
-    return dec
+                result = user_function(*args, **kwds)
+            return result
+
+        def archive(obj):
+            """Replace the cache archive"""
+            cache.archive = obj
+
+        def __get_cache():
+            """Get the cache"""
+            return cache
+
+        def clear(keepstats=False):
+            """Clear the cache and statistics"""
+            cache.clear()
+            if not keepstats: stats[:] = [0, 0, 0]
+
+        def info():
+            """Report cache statistics"""
+            return _CacheInfo(stats[HIT], stats[MISS], stats[LOAD], maxsize, len(cache))
+
+        # interface
+        wrapper.__wrapped__ = user_function
+        wrapper.info = info
+        wrapper.clear = clear
+        wrapper.load = cache.load
+        wrapper.dump = cache.dump
+        wrapper.archive = archive
+        wrapper.archived = cache.archived
+        wrapper.__cache__ = __get_cache
+        return update_wrapper(wrapper, user_function)
+
+    return decorating_function
 
 
@@ -64 +112 @@
     """
     def __init__(self, cache=None, keymap=None, tol=None, deep=False):
-#       self.func = func
-        if keymap is None: keymap = stringmap(flat=False)
+        self.__maxsize = None
+        if keymap is None: keymap = stringmap(flat=False) #XXX: hashmap(True) ?
         if cache is None: cache = archive_dict()
         elif type(cache) is dict: cache = archive_dict(cache)
-        self.cache = cache
+        self.__cache = cache
         self.__keymap = keymap
 
@@ -80 +128 @@
         return
 
-    def __call__(self, func):
-        self.func = func
-        import functools
-        @functools.wraps(func)
-        def dec(*args, **kwds):
+    def __call__(self, user_function): #XXX: i.e. 'decorating_function'
+        stats = [0, 0, 0]               # make statistics updateable non-locally
+        HIT, MISS, LOAD = 0, 1, 2       # names for the stats fields
+
+        def wrapper(*args, **kwds):
             try:
                 _args, _kwds = self.__rounded_args(*args, **kwds)
-                argstr = self.__keymap(*_args, **_kwds)
-                if self.cache.has_key(argstr):
-                    return self.cache[argstr]
-                if self.cache.archived():
-                    self.cache.load(argstr)
-                    if self.cache.has_key(argstr):
-                        return self.cache[argstr]
-                res = self.func(*args, **kwds)
-                self.cache[argstr] = res
-                return res
+                key = self.__keymap(*_args, **_kwds)
+
+                try:
+                    # get cache entry
+                    result = self.__cache[key]
+                    stats[HIT] += 1
+                except KeyError:
+                    # if not in cache, look in archive
+                    if self.__cache.archived():
+                        self.__cache.load(key)
+                    try:
+                        result = self.__cache[key]
+                        stats[LOAD] += 1
+                    except KeyError:
+                        # if not found, then compute
+                        result = user_function(*args, **kwds)
+                        self.__cache[key] = result
+                        stats[MISS] += 1
+                    #XXX:  NO cache purge...
             except: #TypeError
-                return self.func(*args, **kwds)
-        return dec
+                result = user_function(*args, **kwds)
+            return result
 
-    def __repr__(self):
-        """Return the function's docstring."""
-        return self.func.__doc__
+        def archive(obj):
+            """Replace the cache archive"""
+            self.__cache.archive = obj
+
+        def __get_cache():
+            """Get the cache"""
+            return self.__cache
+
+        def clear(keepstats=False):
+            """Clear the cache and statistics"""
+            self.__cache.clear()
+            if not keepstats: stats[:] = [0, 0, 0]
+
+        def info():
+            """Report cache statistics"""
+            return _CacheInfo(stats[HIT], stats[MISS], stats[LOAD], self.__maxsize, len(self.__cache))
+
+        # interface
+        wrapper.__wrapped__ = user_function
+        wrapper.info = info
+        wrapper.clear = clear
+        wrapper.load = self.__cache.load
+        wrapper.dump = self.__cache.dump
+        wrapper.archive = archive
+        wrapper.archived = self.__cache.archived
+        wrapper.__cache__ = __get_cache
+        return update_wrapper(wrapper, user_function)
+
+#   def __repr__(self):
+#       """Return the function's docstring."""
+#       return self.func.__doc__
 
     def __get__(self, obj, objtype):

branches/decorate/test_cached_memoize.py

@@ -13 +13 @@
     return fibonacci(n-1) + fibonacci(n-2)
 
-fibonacci.cache.archive = file_archive('fibonacci.pkl')
-fibonacci.cache.load()
+fibonacci.archive(file_archive('fibonacci.pkl'))
+fibonacci.load()
 
 print fibonacci(7)
 print fibonacci(9)
 
-fibonacci.cache.dump()
+fibonacci.dump()
 
 

branches/decorate/test_memoize.py

@@ -118 +118 @@
 add(1,2)
 add(1,3)
-print "db_cache = %s" % add.cache
+print "db_cache = %s" % add.__cache__()
 
 @memoized(cache=dict())
@@ -126 +126 @@
 add(1,2)
 add(1,3)
-print "dict_cache = %s" % add.cache
+print "dict_cache = %s" % add.__cache__()
 
-@memoized(cache=add.cache)
+@memoized(cache=add.__cache__())
 def add(x,y):
     return x+y
 add(1,2)
 add(2,2)
-print "re_dict_cache = %s" % add.cache
+print "re_dict_cache = %s" % add.__cache__()
 
 @memoized(keymap=dumps)
@@ -141 +141 @@
 add(1,2)
 add(1,3)
-print "pickle_dict_cache = %s" % add.cache
+print "pickle_dict_cache = %s" % add.__cache__()
 
 

branches/decorate/test_timed_monitor.py

@@ -174 +174 @@
   print " upper bounds: %s" % upper_bounds
 # print " ..."
-  try: model.cache.load()
+  try: model.load()
   except: pass
   diameter = UQ(RVstart,RVend,lower_bounds,upper_bounds)
-  try: model.cache.dump()
+  try: model.dump()
   except: pass