producers passing tests... working in general?

core.py

@@ -84,8 +84,6 @@ def _compile_dir():
         sys.path.append(cachedir)
     return cachedir
 
-class Allocated:
-    """Memory has been allocated, but contents are not the owner's output."""
 class Numpy2(ResultBase):
     """Result storing a numpy ndarray"""
     __slots__ = ['_dtype', '_shape', ]
@@ -122,8 +120,7 @@ class Numpy2(ResultBase):
     __array_struct__ = property(lambda self: self._data.__array_struct__ )
 
     def data_alloc(self):
-        self.data = numpy.ndarray(self.shape, self.dtype)
-        self.state = Allocated
+        return numpy.ndarray(self.shape, self.dtype)
 
     # self._dtype is used when self._data hasn't been set yet
     def __dtype_get(self):
@@ -211,7 +208,7 @@ class _test_Numpy2(unittest.TestCase):
         self.failUnless(r.data is None)
         self.failUnless(r.shape == (3,3))
         self.failUnless(str(r.dtype) == 'int32')
-        r.data_alloc()
+        r.alloc()
         self.failUnless(isinstance(r.data, numpy.ndarray))
         self.failUnless(r.shape == (3,3))
         self.failUnless(str(r.dtype) == 'int32')
@@ -443,6 +440,8 @@ class omega_op(gof.PythonOp):
     def gen_outputs(self):
         return [Numpy2() for i in xrange(self.nout)]
     
+    #TODO: use the version of this code that is in grad.py
+    #      requires: eliminating module dependency cycles
     def update_gradient(self, grad_d):
         """Call self.grad() and add the result to grad_d
 
@@ -861,13 +860,25 @@ def scalar_switch(normal_f, scalar_f, scalar_f_reverse = None):
 from grad import Undefined
 
 def wrap_producer(f):
-    class producer(omega_op):
+    class producer(gof.lib.NewPythonOp):
+        def __init__(self, shape, dtype, order):
+            assert order == 'C' #TODO: let Numpy2 support this
+            if current_mode() == 'build_eval':
+                gof.lib.NewPythonOp.__init__(self, 
+                        [input(shape), input(dtype), input(order)],
+                        [Numpy2(data = f(shape, dtype))])
+            elif current_mode() == 'build':
+                gof.lib.NewPythonOp.__init__(self, 
+                        [input(shape), input(dtype), input(order)],
+                        [Numpy2(data = (shape, dtype))])
+        def gen_outputs(self):
+            return [Numpy2() for i in xrange(self.nout)]
         impl = f
         def grad(*args):
             return [Undefined] * (len(args) - 1)
     producer.__name__ = f.__name__
-    def ret(dim, dtype = 'float', order = 'C'):
-        return producer(dim, dtype, order)
+    def ret(shape, dtype = 'float64', order = 'C'):
+        return producer(shape, dtype, order).out
     return ret
 
 ndarray = wrap_producer(numpy.ndarray)
@@ -880,19 +891,19 @@ class _testCase_producer_build_mode(unittest.TestCase):
         """producer in build mode"""
         build_mode()
         a = ones(4)
-        self.failUnless(a.data is None)
-        self.failUnless(a.state is gof.result.Empty)
-        self.failUnless(a.shape == (4,))
-        self.failUnless(a.dtype == 'float64')
+        self.failUnless(a.data is None, a.data)
+        self.failUnless(a.state is gof.result.Empty, a.state)
+        self.failUnless(a.shape == 4, a.shape)
+        self.failUnless(str(a.dtype) == 'float64', a.dtype)
         pop_mode()
     def test_1(self):
         """producer in build_eval mode"""
         build_eval_mode()
         a = ones(4)
-        self.failUnless((a.data == numpy.ones(4)).all())
-        self.failUnless(a.state is gof.result.Computed)
-        self.failUnless(a.shape == (4,))
-        self.failUnless(a.dtype == 'float64')
+        self.failUnless((a.data == numpy.ones(4)).all(), a.data)
+        self.failUnless(a.state is gof.result.Computed, a.state)
+        self.failUnless(a.shape == (4,), a.shape)
+        self.failUnless(str(a.dtype) == 'float64', a.dtype)
         pop_mode()
 
 

gof/lib.py

@@ -345,7 +345,16 @@ class DestroyHandler(features.Listener, features.Constraint, features.Orderings)
         return ords
 
 
-class PythonOp(Op):
+class NewPythonOp(Op):
+
+    def view_map(self):
+        return {}
+
+    def destroy_map(self):
+        return {}
+
+
+class PythonOp(NewPythonOp):
     
     __metaclass__ = ClsInit
 
@@ -377,7 +386,7 @@ class PythonOp(Op):
             return op.outputs
     
     def __init__(self, *inputs):
-        Op.__init__(self, inputs, self.gen_outputs())
+        NewPythonOp.__init__(self, inputs, self.gen_outputs())
 
     def __validate__(self):
         return all([ is_result(i) for i in self.inputs])
@@ -385,10 +394,6 @@ class PythonOp(Op):
     def gen_outputs(self):
         raise AbstractFunctionError()
     
-    def view_map(self): return {}
-
-    def destroy_map(self): return {}
-
     @staticmethod
     def root_inputs(input):
         owner = input.owner
@@ -445,21 +450,20 @@ class PythonOp(Op):
         else:
             results = self._impl()
         if self.nout == 1:
-            self.out.set_value(results)
+            self.out.data = results
         else:
             assert self.nout == len(results)
             for result, output in zip(results, self.outputs):
-                output.set_value(result)
+                output.data = result
 
     def _perform(self):
         results = self._impl()
         if self.nout == 1:
-            self.out.set_value(results)
-#            self.outputs[0].data = results
+            self.out.data = results
         else:
             assert self.nout == len(results)
             for result, output in zip(results, self.outputs):
-                output.set_value(result)
+                output.data = result
 
     def _perform_inplace(self):
         results = self._impl()

gof/result.py

@@ -37,8 +37,9 @@ class BrokenLinkError(GofError):
 
 
 # ResultBase state keywords
-class Empty : pass
-class Computed : pass
+class Empty : """Memory has not been allocated"""
+class Allocated: """Memory has been allocated, contents are not the owner's output."""
+class Computed : """Memory has been allocated, contents are the owner's output."""
 
 
 ############################
@@ -63,11 +64,16 @@ class ResultBase(object):
     role - (rw)
     owner - (ro)
     index - (ro)
-    data - (rw)
+    data - (rw) : calls data_filter when setting
     replaced - (rw) : True iff _role is BrokenLink
 
+    Methods:
+    alloc() - create storage in data, suitable for use by C ops. 
+                (calls data_alloc)
+
     Abstract Methods:
     data_filter
+    data_alloc
 
 
     Notes (from previous implementation):
@@ -184,6 +190,24 @@ class ResultBase(object):
         """
         raise ResultBase.AbstractFunction()
 
+    #
+    # alloc
+    #
+
+    def alloc(self):
+        """Create self.data from data_alloc, and set state to Allocated"""
+        self.data = self.data_alloc()  #might raise exception
+        self.state = Allocated
+
+    def data_alloc(self):
+        """(abstract) Return an appropriate _data based on self.
+
+        If a subclass overrides this function, then that overriding
+        implementation will be used in alloc() to produce a data object.
+        
+        """
+        raise ResultBase.AbstractFunction()
+
 
     #
     # replaced