Changeset 4333

Timestamp:

Mar 28, 2007, 5:11:05 PM (17 years ago)

Author:

ole

Message:

Added test that revealed issue where identical functions with different memory addresses caused cache to recompute.
Fixed problem.

Location:

anuga_core/source/anuga/caching

Files:

• caching.py (modified) (1 diff)
• test_caching.py (modified) (5 diffs)

anuga_core/source/anuga/caching/caching.py

@@ -1454 +1454 @@
     funcname = string.join(tmp)
 
+    # Truncate memory address as in
+    # class __main__.Dummy at 0x00A915D0
+    index = funcname.find('at 0x')
+    if index >= 0:
+      funcname = funcname[:index+5] # Keep info that there is an address 
+
   funcname = nospace(funcname)
   return(funcname)

anuga_core/source/anuga/caching/test_caching.py

@@ -21 +21 @@
 
 class Dummy:
-  def __init__(self,value, another):
+  def __init__(self, value, another):
     self.value = value
+
+
+class Dummy_memorytest:
+  def __init__(self, value, another):
+    self.value = value
+
+
+def clear_and_create_cache(Dummy, verbose=False):
+  a = cache(Dummy, 'clear', verbose=verbose)
+        
+  a = cache(Dummy, args=(9,10),
+            verbose=verbose)
+      
+
+def retrieve_cache(Dummy, verbose=False):
+  if verbose: print 'Check that cache is there'
+  assert cache(Dummy, args=(9,10), test=1,
+               verbose=verbose)      
+      
+
+    
 
 class Test_Caching(unittest.TestCase):
     def setUp(self):
         set_option('verbose', 0)  #Why
-        
+
         pass
 
@@ -45 +66 @@
     def test_basic_caching(self):
 
-        
+        verbose=False
         # Make some test input arguments
         #
@@ -66 +87 @@
             #
             T1 = cache(f, (a,b,c,N), {'x':x, 'y':y}, evaluate=1, \
-                       compression=comp)
+                       compression=comp, verbose=verbose)
 
             # Retrieve
@@ -304 +325 @@
       """
       verbose = True
-      verbose = False
+      #verbose = False
 
       for i in range(2):
         if verbose: print "clear cache"
-        a = cache(Dummy,'clear')     
+        a = cache(Dummy, 'clear')
+        
         if verbose: print "cache for first time"
-        a = cache(Dummy,args=(9,10) ,verbose=verbose)
+        a = cache(Dummy, args=(9,10), verbose=verbose)
         hash_value = myhash(a)
+        
         #print "hash_value",hash_value 
         if verbose: print "cache for second time"
-        a = cache(Dummy,args=(9,10) ,verbose=verbose)
+        a = cache(Dummy, args=(9,10), verbose=verbose)
+        
         #print "myhash(a)",myhash(a) 
         assert hash_value == myhash(a)
 
+
+    def test_objects_are_created(self):
+      """
+      However, this test shows how instances can be created from cache
+      as long as input arguments are unchanged.
+
+      Such instances will have different id's and cannot be used as input
+      arguments in subsequent caches. However, this is still useful.
+
+      Do it for all combinations of compression
+
+      """
+
+      verbose = False
+
+      for compression_store in [False, True]:
+        for compression_retrieve in [False, True]:        
+        
+          if verbose: print 'clear cache'
+          a = cache(Dummy, 'clear')
+        
+          if verbose: print 'cache for first time'
+          a = cache(Dummy, args=(9,10),
+                    compression=compression_store,
+                    verbose=verbose)
+          
+          if verbose: print 'Check that cache is there'
+          assert cache(Dummy, args=(9,10), test=1,
+                       compression=compression_retrieve,
+                       verbose=verbose)
+
+
+
+
+    def test_objects_are_created_memory(self):
+      """
       
+      This test shows how instances can be created from cache
+      as long as input arguments are unchanged - even if the class
+      lives in different memory locations.
+
+      This is using cache created in the main program
+
+      """
+
+      verbose = False
+
+      # Redefine class Dummy_memorytest
+      class Dummy_memorytest:
+        def __init__(self, value, another):
+          self.value = value      
+
+      retrieve_cache(Dummy_memorytest, verbose=verbose)      
+          
+
+
+
+     
         
 
@@ -324 +405 @@
 #-------------------------------------------------------------
 if __name__ == "__main__":
+
+    # Cache created for test_objects_are_created_memory to make sure it has a different memory address
+    clear_and_create_cache(Dummy_memorytest, verbose=False)
+  
     suite = unittest.makeSuite(Test_Caching,'test')
     runner = unittest.TextTestRunner()