Merge pull request #1994 from nouiz/lazy

doc/extending/cop.txt

@@ -211,18 +211,18 @@ version that it produces in the code I gave above.
            return self.ccode % locals()
 
 
-   add = BinaryDoubleOp(name = 'add',
-                        fn = lambda x, y: x + y,
-                        ccode = "%(z)s = %(x)s + %(y)s;")
+   add = BinaryDoubleOp(name='add',
+                        fn=lambda x, y: x + y,
+                        ccode="%(z)s = %(x)s + %(y)s;")
 
-   sub = BinaryDoubleOp(name = 'sub',
-                        fn = lambda x, y: x - y,
-                        ccode = "%(z)s = %(x)s - %(y)s;")
+   sub = BinaryDoubleOp(name='sub',
+                        fn=lambda x, y: x - y,
+                        ccode="%(z)s = %(x)s - %(y)s;")
 
-   mul = BinaryDoubleOp(name = 'mul',
-                        fn = lambda x, y: x * y,
-                        ccode = "%(z)s = %(x)s * %(y)s;")
+   mul = BinaryDoubleOp(name='mul',
+                        fn=lambda x, y: x * y,
+                        ccode="%(z)s = %(x)s * %(y)s;")
 
-   div = BinaryDoubleOp(name = 'div',
-                        fn = lambda x, y: x / y,
-                        ccode = "%(z)s = %(x)s / %(y)s;")
+   div = BinaryDoubleOp(name='div',
+                        fn=lambda x, y: x / y,
+                        ccode="%(z)s = %(x)s / %(y)s;")

doc/extending/op.txt

@@ -633,17 +633,17 @@ arithmetic operators:
        def __str__(self):
            return self.name
 
-   add = BinaryDoubleOp(name = 'add',
-                        fn = lambda x, y: x + y)
+   add = BinaryDoubleOp(name='add',
+                        fn=lambda x, y: x + y)
 
-   sub = BinaryDoubleOp(name = 'sub',
-                        fn = lambda x, y: x - y)
+   sub = BinaryDoubleOp(name='sub',
+                        fn=lambda x, y: x - y)
 
-   mul = BinaryDoubleOp(name = 'mul',
-                        fn = lambda x, y: x * y)
+   mul = BinaryDoubleOp(name='mul',
+                        fn=lambda x, y: x * y)
 
-   div = BinaryDoubleOp(name = 'div',
-                        fn = lambda x, y: x / y)
+   div = BinaryDoubleOp(name='div',
+                        fn=lambda x, y: x / y)
 
 Instead of working directly on an instance of Op, we create a subclass of
 Op that we can parametrize. All the operations we define are binary. They

doc/tutorial/using_gpu.txt

@@ -685,15 +685,19 @@ Modify and execute to work for a matrix of shape (20, 10).
     class PyCUDADoubleOp(theano.Op):
         def __eq__(self, other):
             return type(self) == type(other)
+
         def __hash__(self):
             return hash(type(self))
+
         def __str__(self):
             return self.__class__.__name__
+
         def make_node(self, inp):
             inp = cuda.basic_ops.gpu_contiguous(
                cuda.basic_ops.as_cuda_ndarray_variable(inp))
             assert inp.dtype == "float32"
             return theano.Apply(self, [inp], [inp.type()])
+
         def make_thunk(self, node, storage_map, _, _2):
             mod = SourceModule("""
         __global__ void my_fct(float * i0, float * o0, int size) {
@@ -703,15 +707,16 @@ Modify and execute to work for a matrix of shape (20, 10).
         }
       }""")
             pycuda_fct = mod.get_function("my_fct")
-            inputs = [ storage_map[v] for v in node.inputs]
-            outputs = [ storage_map[v] for v in node.outputs]
+            inputs = [storage_map[v] for v in node.inputs]
+            outputs = [storage_map[v] for v in node.outputs]
+
             def thunk():
                 z = outputs[0]
-                if z[0] is None or z[0].shape!=inputs[0][0].shape:
+                if z[0] is None or z[0].shape != inputs[0][0].shape:
                     z[0] = cuda.CudaNdarray.zeros(inputs[0][0].shape)
-                grid = (int(numpy.ceil(inputs[0][0].size / 512.)),1)
+                grid = (int(numpy.ceil(inputs[0][0].size / 512.)), 1)
                 pycuda_fct(inputs[0][0], z[0], numpy.intc(inputs[0][0].size),
-                           block=(512,1,1), grid=grid)
+                           block=(512, 1, 1), grid=grid)
             return thunk
 
 
@@ -719,7 +724,7 @@ Use this code to test it:
 
 >>> x = theano.tensor.fmatrix()
 >>> f = theano.function([x], PyCUDADoubleOp()(x))
->>> xv=numpy.ones((4,5), dtype="float32")
+>>> xv = numpy.ones((4, 5), dtype="float32")
 >>> assert numpy.allclose(f(xv), xv*2)
 >>> print numpy.asarray(f(xv))
 

theano/gof/vm.py

@@ -886,6 +886,11 @@ class VM_Linker(link.LocalLinker):
                                                  storage_map,
                                                  compute_map,
                                                  no_recycling))
+                if not hasattr(thunks[-1], 'lazy'):
+                    # We don't want all ops maker to think about lazy Ops.
+                    # So if they didn't specify that its lazy or not, it isn't.
+                    # If this member isn't present, it will crash later.
+                    thunks[-1].lazy = False
             except Exception, e:
                 e.args = ("The following error happened while"
                           " compiling the node", node, "\n") + e.args

theano/misc/tests/test_pycuda_example.py

@@ -9,7 +9,7 @@ if not theano.misc.pycuda_init.pycuda_available:
                    " with pycuda code.")
 
 import theano.sandbox.cuda as cuda_ndarray
-if cuda_ndarray.cuda_available == False:
+if not cuda_ndarray.cuda_available:
     from nose.plugins.skip import SkipTest
     raise SkipTest('Optional package cuda disabled')