Changeset 5856

Timestamp:

Oct 22, 2008, 3:32:09 PM (16 years ago)

Author:

ole

Message:

A bit more fiddling with caching and circular structures not
involving instances.

All relevant tests pass

Location:

anuga_core/source/anuga/caching

Files:

• caching.py (modified) (15 diffs)
• test_caching.py (modified) (5 diffs)

anuga_core/source/anuga/caching/caching.py

@@ -875 +875 @@
   bytecode = get_bytecode(func)
 
-  #print 'Diags'
-  #print argsref
-  #print args
   #print compare(argsref,args),   
-  
   #print compare(kwargsref,kwargs),
   #print compare(bytecode,coderef)
@@ -1327 +1323 @@
 # -----------------------------------------------------------------------------
 
-
-def Xmyhash(T, ids=None):
-    import pickle as pickler # Use non-C version here
-    return hash(pickler.dumps(T,0))
-
     
 def myhash(T, ids=None):
@@ -1347 +1338 @@
   from types import TupleType, ListType, DictType, InstanceType  
   from Numeric import ArrayType, average
-  
-  #if type(T) in [TupleType, ListType, DictType, InstanceType]:  
-  #if type(T) in [ListType, DictType, InstanceType]:  
-  if type(T) == InstanceType:  
-  #if False:
+
+    
+  if type(T) in [TupleType, ListType, DictType, InstanceType]:  
       # Keep track of unique id's to protect against infinite recursion
       if ids is None: ids = []
@@ -1359 +1348 @@
   
       if i in ids:
-          # T has been hashed already      
-      
-          # FIXME (Ole): It seems that different objects get the same id
-          # For example id(D.items()) is the same as id(D.values()).
-
-          #print 'T has already been hashed:', mkargstr(T, 132), id(T), type(T)
-          return 0
+          return 0 # T has been hashed already      
       else:
-          #print 'Appending', T, id(T)
           ids.append(i)
     
 
+    
   # Start hashing  
-  
   
   # On some architectures None, False and True gets different hash values
@@ -1395 +1377 @@
       val = myhash(I, ids)
   elif type(T) == ArrayType:
-      val = hash(average(T.flat))  # Use mean value for efficiency
-      #val = myhash(tuple(T), ids)
+      # Use mean value for efficiency  
+      val = hash(average(T.flat))
   elif type(T) == InstanceType:
       val = myhash(T.__dict__, ids)
-      
-      #print 'Hashed instance:'
-      #print T.__dict__.keys()
-      #print mkargstr(T.__dict__, 132)
-      #print 'with value', val
-
   else:
       try:
@@ -1426 +1402 @@
     """
 
-    if A == B:
-        identical = True
-    else: 
+    try:
+        identical = (A == B)
+    except:
+        # E.g. if A and B are circular or otherwise can't be compared.
+        identical = False
+        
+        
+    if identical is False:    
         # Use pickle to compare data
         # The native pickler must be used
@@ -1435 +1416 @@
         
         import pickle as pickler # Use non-C version here
+        #import cPickle as pickler 
         identical = (pickler.dumps(A,0) == pickler.dumps(B,0))
 
@@ -1440 +1422 @@
 
 
-def Xcompare(A, B, ids=None):
+def old_compare(A, B, ids=None):
     """Safe comparison of general objects
 
@@ -1450 +1432 @@
     """
 
+    # FIXME (Ole): This is probably obsolete now
+    
     from types import TupleType, ListType, DictType, InstanceType
     
@@ -2161 +2145 @@
   print_header_box('Evaluating function %s' %funcname)
   
-  msg7(args,kwargs)
+  msg7(args, kwargs)
   msg8(reason)  
   
@@ -2328 +2312 @@
   print string.ljust('| Function:', textwidth1) + funcname
 
-  msg7(args,kwargs)
+  msg7(args, kwargs)
   
 # -----------------------------------------------------------------------------    
 
-def msg7(args,kwargs):
+def msg7(args, kwargs):
   """Message 7
   
   USAGE:
-    msg7(args,kwargs):
+    msg7(args, kwargs):
   """
   
@@ -2417 +2401 @@
 # -----------------------------------------------------------------------------
 
-def mkargstr(args, textwidth, argstr = ''):
+def mkargstr(args, textwidth, argstr = '', level=0):
   """ Generate a string containing first textwidth characters of arguments.
 
   USAGE:
-    mkargstr(args, textwidth, argstr = '')
+    mkargstr(args, textwidth, argstr = '', level=0)
 
   DESCRIPTION:
@@ -2430 +2414 @@
   import types
 
+  if level > 10:
+      # Protect against circular structures
+      return '...'
+  
   WasTruncated = 0
 
@@ -2451 +2439 @@
       argstr = argstr + "{"
       for key in args.keys():
-        argstr = argstr + mkargstr(key, textwidth) + ": " + \
-                 mkargstr(args[key], textwidth) + ", "
+        argstr = argstr + mkargstr(key, textwidth, level=level+1) + ": " + \
+                 mkargstr(args[key], textwidth, level=level+1) + ", "
         if len(argstr) > textwidth:
           WasTruncated = 1
@@ -2468 +2456 @@
       argstr = argstr + lc
       for arg in args:
-        argstr = argstr + mkargstr(arg, textwidth) + ', '
+        argstr = argstr + mkargstr(arg, textwidth, level=level+1) + ', '
         if len(argstr) > textwidth:
           WasTruncated = 1

anuga_core/source/anuga/caching/test_caching.py

@@ -382 +382 @@
            
 
-    def XXtest_caching_of_simple_circular_structures(self):
-    
-        # FIXME (Ole): This one recurses infinitly on
-        # arg strings. 
-        
+    def test_caching_of_simple_circular_dictionaries(self):
         """test_caching_of_circular_structures
         
@@ -393 +389 @@
         """
         
-        verbose = True
+        verbose = False #True
         
         # Create input argument
@@ -400 +396 @@
         A['B'] = B # Make it circular
         
-        print A
-
         # Test caching
         comprange = 2
@@ -409 +403 @@
             T1 = cache(f_generic, A, evaluate=1,
                        compression=comp, verbose=verbose)
-                       
-            import sys; sys.exit() 
                        
 
@@ -425 +417 @@
 
 
-            assert T1 == T2, 'Cached result does not match computed result'
-            assert T2 == T3, 'Cached result does not match computed result'
-            
-                                    
+            msg = 'Cached result does not match computed result'
+            assert str(T1) == str(T2), msg
+            assert str(T2) == str(T3), msg
+