Changeset 6230

Timestamp:

Jan 22, 2009, 1:24:06 PM (16 years ago)

Author:

ole

Message:

Fixed issue with caching of different instances of callable objects
as described in changeset:6229
Also added bytecode determination for classes.

Location:

anuga_core/source/anuga/caching

Files:

• caching.py (modified) (4 diffs)
• test_caching.py (modified) (7 diffs)

anuga_core/source/anuga/caching/caching.py

@@ -86 +86 @@
   'bin': 1,              # Use binary format (more efficient)
   'compression': 1,      # Use zlib compression
-  'bytecode': 0,         # Recompute if bytecode has changed
+  'bytecode': 1,         # Recompute if bytecode has changed
   'expire': 0            # Automatically remove files that have been accessed
                          # least recently
@@ -162 +162 @@
   If the function definition changes after a result has been cached it will be
   detected by examining the functions bytecode (co_code, co_consts,
-  func_defualts, co_argcount) and it will be recomputed.
+  func_defaults, co_argcount) and it will be recomputed.
 
   LIMITATIONS:
@@ -1382 +1382 @@
       val = myhash(I, ids)
   elif type(T) == num.ArrayType:
-      T = num.array(T) # Ensure contiguous
+      T = num.array(T) # Ensure array is contiguous
 
       # Use mean value for efficiency
       val = hash(num.average(T.flat))
   elif type(T) == InstanceType:
+      # Use the attribute values 
       val = myhash(T.__dict__, ids)
   else:
@@ -1547 +1548 @@
 
   if type(func) == types.FunctionType:
-    bytecode = func.func_code.co_code
-    consts = func.func_code.co_consts
-    argcount = func.func_code.co_argcount    
-    defaults = func.func_defaults     
+    return get_func_code_details(func)
   elif type(func) == types.MethodType:
-    bytecode = func.im_func.func_code.co_code
-    consts =  func.im_func.func_code.co_consts
-    argcount =  func.im_func.func_code.co_argcount    
-    defaults = func.im_func.func_defaults         
+    return get_func_code_details(func.im_func)
+  elif type(func) == types.InstanceType:    
+    if callable(func):
+      # Get bytecode from __call__ method
+      bytecode = get_func_code_details(func.__call__.im_func)
+      
+      # Add hash value of object to detect attribute changes
+      return bytecode + (myhash(func),) 
+    else:
+      msg = 'Instance %s was passed into caching in the role of a function ' % str(func)
+      msg = ' but it was not callable.'
+      raise Exception, msg
+  elif type(func) in [types.BuiltinFunctionType, types.BuiltinMethodType]:      
+    # Built-in functions are assumed not to change  
+    return None, 0, 0, 0
+  elif type(func) == types.ClassType:
+      # Get bytecode from __init__ method
+      bytecode = get_func_code_details(func.__init__.im_func)    
+      return bytecode      
   else:
-    #raise Exception  #Test only
-    bytecode = None   #Built-in functions are assumed not to change
-    consts = 0
-    argcount = 0
-    defaults = 0
-
-  return (bytecode, consts, argcount, defaults)
+    msg = 'Unknown function type: %s' % type(func)
+    raise Exception, msg
+
+
+  
+  
+def get_func_code_details(func):
+  """Extract co_code, co_consts, co_argcount, func_defaults
+  """
+  
+  bytecode = func.func_code.co_code
+  consts = func.func_code.co_consts
+  argcount = func.func_code.co_argcount    
+  defaults = func.func_defaults       
+  
+  return bytecode, consts, argcount, defaults  
 
 # -----------------------------------------------------------------------------

anuga_core/source/anuga/caching/test_caching.py

@@ -366 +366 @@
                                     
             
-    def Xtest_caching_of_callable_objects(self):
+    def test_caching_of_callable_objects(self):
         """test_caching_of_callable_objects(self)
         
@@ -386 +386 @@
 
             
-            
         f1 = call(2, 3)
         f2 = call(5, 7)
+        
+        
+        # Check that hash value of callable objects don't change
+        assert myhash(f1) == -758136387
+        assert myhash(f2) == -11221564     
+        
+        bc1 = get_bytecode(f1)
+        bc2 = get_bytecode(f2)
+        
+        #print 'bc1', bc1
+        #print 'bc2', bc2
+        
+        msg = 'Byte code should be different'
+        assert bc1 != bc2, msg
+
         
         x = num.arange(10).astype(num.Float)
@@ -412 +426 @@
         assert num.allclose(res1, ref1)                
         
-        # Test that f2(x) is still clear
-        flag = cache(f2, x, test=True, verbose=False)        
-        msg = 'Function f2(x) should not be cached here'
-        assert flag is None, msg                
-       
         # Run f2(x) and test result
         res2 = cache(f2, x, verbose=False)
@@ -803 +812 @@
 
       verbose = False
-
+     
       for compression_store in [False, True]:
         for compression_retrieve in [False, True]:        
@@ -811 +820 @@
         
           if verbose: print 'cache for first time'
-          a = cache(Dummy, args=(9,10),
-                    compression=compression_store,
-                    verbose=verbose)
+          a_ref = cache(Dummy, args=(9,10),
+                        compression=compression_store,
+                        verbose=verbose)
           
           if verbose: print 'Check that cache is there'
@@ -819 +828 @@
                        compression=compression_retrieve,
                        verbose=verbose)
+                       
+          if verbose: print 'Check cached result'
+          a = cache(Dummy, args=(9,10),
+                    compression=compression_store,
+                    verbose=verbose)                       
+          assert a.__dict__ == a_ref.__dict__
 
 
@@ -868 +883 @@
 #-------------------------------------------------------------
 if __name__ == "__main__":
-    #suite = unittest.makeSuite(Test_Caching, 'test_hash_collision')
+    #suite = unittest.makeSuite(Test_Caching, 'test_caching_of_callable_objects')
     suite = unittest.makeSuite(Test_Caching, 'test')
     runner = unittest.TextTestRunner()