Merge pull request #593 from nouiz/c_code_cache_version

NEWS.txt

@@ -63,6 +63,15 @@ New Features
   can't be cached as there is no c_code_cache_version() function to at
   least of of those Ops.  (Frederic B.)
  * CPU alloc now always generate c code (Pascal L.)
+ * New Theano flag cmodule.warn_no_version=False. When True, warn when an op
+   with c code is not versionned. This force to recompile it everytimes.
+   (Frédéric B.)
+ * Made a few Ops with c code versionned to reduce compilation time.
+   (Frédéric B, Pascal L.)
+
+ * c code reuse preallocated output(only done by Scan) (Pascal L.)
+ * gc of intermediate result during theano function call for op with c code
+   (Pascal L.)
 
 Sparse
  * Implement theano.sparse.mul(sparse1, sparse2) when both inputs don't

theano/compile/tests/test_debugmode.py

@@ -47,6 +47,9 @@ class BROKEN_ON_PURPOSE_Add(gof.Op):
         else:
             out[0] = z
 
+    def c_code_cache_version(self):
+        return (1,)
+
     def c_code(self, node, name, inp, out, sub):
         a, b = inp
         z, = out
@@ -130,6 +133,9 @@ class WeirdBrokenOp(gof.Op):
         else:
             raise ValueError(self.behaviour)
 
+    def c_code_cache_version(self):
+        return (1,)
+
     def c_code(self, node, name, inp, out, sub):
         a, = inp
         z, = out
@@ -553,100 +559,104 @@ class Test_check_isfinite(unittest.TestCase):
         return
 
 
-class Test_preallocated_output(unittest.TestCase):
+class BrokenCImplementationAdd(gof.Op):
+    def __eq__(self, other):
+        return type(self) == type(other)
 
-    class BrokenCImplementationAdd(gof.Op):
-        def __eq__(self, other):
-            return type(self) == type(other)
+    def __hash__(self):
+        return hash(type(self))
 
-        def __hash__(self):
-            return hash(type(self))
+    def make_node(self, a, b):
+        a = theano.tensor.as_tensor_variable(a)
+        b = theano.tensor.as_tensor_variable(b)
+        assert a.type.dtype == 'float32'
+        assert a.type.dtype == b.type.dtype
+        assert a.type.ndim == 2
+        r = gof.Apply(self, [a, b], [a.type()])
+        return r
 
-        def make_node(self, a, b):
-            a = theano.tensor.as_tensor_variable(a)
-            b = theano.tensor.as_tensor_variable(b)
-            assert a.type.dtype == 'float32'
-            assert a.type.dtype == b.type.dtype
-            assert a.type.ndim == 2
-            r = gof.Apply(self, [a, b], [a.type()])
-            return r
-
-        def perform(self, node, inp, out_):
-            print 'executing python perform'
-            a, b = inp
-            out, = out_
-            z = a + b
-            print 'out[0] was:', out[0]
-            out[0] = z
+    def perform(self, node, inp, out_):
+        print 'executing python perform'
+        a, b = inp
+        out, = out_
+        z = a + b
+        print 'out[0] was:', out[0]
+        out[0] = z
 
-        def c_code(self, node, name, inp, out, sub):
-            a, b = inp
-            z, = out
-            debug = 0
-            return """
-            //printf("executing c_code\\n");
-            if (%(a)s->nd != 2) {PyErr_SetString(PyExc_NotImplementedError, "rank(a) != 2"); %(fail)s;}
-            if (%(b)s->nd != 2) {PyErr_SetString(PyExc_NotImplementedError, "rank(b) != 2"); %(fail)s;}
+    def c_code_cache_version(self):
+        return (1,)
 
-            if (%(a)s->descr->type_num != PyArray_FLOAT)
-            {PyErr_SetString(PyExc_NotImplementedError, "a dtype not NPY_FLOAT"); %(fail)s;}
+    def c_code(self, node, name, inp, out, sub):
+        a, b = inp
+        z, = out
+        debug = 0
+        return """
+        //printf("executing c_code\\n");
+        if (%(a)s->nd != 2) {PyErr_SetString(PyExc_NotImplementedError, "rank(a) != 2"); %(fail)s;}
+        if (%(b)s->nd != 2) {PyErr_SetString(PyExc_NotImplementedError, "rank(b) != 2"); %(fail)s;}
 
-            if (%(b)s->descr->type_num != PyArray_FLOAT)
-            {PyErr_SetString(PyExc_NotImplementedError, "b's dtype not NPY_FLOAT"); %(fail)s;}
+        if (%(a)s->descr->type_num != PyArray_FLOAT)
+        {PyErr_SetString(PyExc_NotImplementedError, "a dtype not NPY_FLOAT"); %(fail)s;}
 
-            if (%(a)s->dimensions[0] != %(a)s->dimensions[1])
-            {PyErr_SetString(PyExc_NotImplementedError, "a is not square"); %(fail)s;}
+        if (%(b)s->descr->type_num != PyArray_FLOAT)
+        {PyErr_SetString(PyExc_NotImplementedError, "b's dtype not NPY_FLOAT"); %(fail)s;}
 
-            if (%(b)s->dimensions[0] != %(b)s->dimensions[1])
-            {PyErr_SetString(PyExc_NotImplementedError, "b is not square"); %(fail)s;}
+        if (%(a)s->dimensions[0] != %(a)s->dimensions[1])
+        {PyErr_SetString(PyExc_NotImplementedError, "a is not square"); %(fail)s;}
 
-            if (%(a)s->dimensions[0] != %(b)s->dimensions[0])
-            {PyErr_SetString(PyExc_NotImplementedError, "a and b have different dimensions"); %(fail)s;}
+        if (%(b)s->dimensions[0] != %(b)s->dimensions[1])
+        {PyErr_SetString(PyExc_NotImplementedError, "b is not square"); %(fail)s;}
 
-            // We do not check for c_contiguous property here
-            if (%(debug)s)
-            {
-                if (!%(z)s)
-                    printf("%(z)s is not there, %%p \\n", %(z)s);
-                else if (%(z)s->dimensions[0] != %(b)s->dimensions[0])
-                    printf("Dimension 0 mismatch for %(z)s and %(b)s\\n");
-                else if (%(z)s->dimensions[1] != %(b)s->dimensions[1])
-                    printf("Dimension 1 mismatch for %(z)s and %(b)s\\n");
-                else
-                    printf("Reusing %(z)s\\n");
-            }
+        if (%(a)s->dimensions[0] != %(b)s->dimensions[0])
+        {PyErr_SetString(PyExc_NotImplementedError, "a and b have different dimensions"); %(fail)s;}
 
-            if ((!%(z)s)
-                || (%(z)s->dimensions[0] != %(b)s->dimensions[0])
-                || (%(z)s->dimensions[1] != %(b)s->dimensions[1])
-                )
-            {
-                Py_XDECREF(%(z)s);
-                npy_intp dims[] = {0, 0};
-                dims[0] = %(b)s->dimensions[0];
-                dims[1] = %(b)s->dimensions[1];
-                %(z)s = (PyArrayObject*) PyArray_SimpleNew(2, dims, %(b)s->descr->type_num);
-            }
+        // We do not check for c_contiguous property here
+        if (%(debug)s)
+        {
+            if (!%(z)s)
+                printf("%(z)s is not there, %%p \\n", %(z)s);
+            else if (%(z)s->dimensions[0] != %(b)s->dimensions[0])
+                printf("Dimension 0 mismatch for %(z)s and %(b)s\\n");
+            else if (%(z)s->dimensions[1] != %(b)s->dimensions[1])
+                printf("Dimension 1 mismatch for %(z)s and %(b)s\\n");
+            else
+                printf("Reusing %(z)s\\n");
+        }
 
-            // Let us assume that %(z)s is c_contiguous
+        if ((!%(z)s)
+            || (%(z)s->dimensions[0] != %(b)s->dimensions[0])
+            || (%(z)s->dimensions[1] != %(b)s->dimensions[1])
+            )
+        {
+            Py_XDECREF(%(z)s);
+            npy_intp dims[] = {0, 0};
+            dims[0] = %(b)s->dimensions[0];
+            dims[1] = %(b)s->dimensions[1];
+            %(z)s = (PyArrayObject*) PyArray_SimpleNew(2, dims, %(b)s->descr->type_num);
+        }
+
+        // Let us assume that %(z)s is c_contiguous
+        {
+            dtype_%(z)s * z = ((dtype_%(z)s*)(PyArray_GETPTR2(%(z)s,0,0)));
+            for (int i=0; i<%(b)s->dimensions[0]; i++)
             {
-                dtype_%(z)s * z = ((dtype_%(z)s*)(PyArray_GETPTR2(%(z)s,0,0)));
-                for (int i=0; i<%(b)s->dimensions[0]; i++)
+                for (int j=0; j<%(b)s->dimensions[1]; j++)
                 {
-                    for (int j=0; j<%(b)s->dimensions[1]; j++)
-                    {
-                        *z = ((float*)PyArray_GETPTR2(%(a)s, i, j))[0] +
-                             ((float*)PyArray_GETPTR2(%(b)s, i, j))[0] ;
-                        z++;
-                    }
+                    *z = ((float*)PyArray_GETPTR2(%(a)s, i, j))[0] +
+                         ((float*)PyArray_GETPTR2(%(b)s, i, j))[0] ;
+                    z++;
                 }
             }
-            """ % dict(locals(), **sub)
+        }
+        """ % dict(locals(), **sub)
+
+
+class Test_preallocated_output(unittest.TestCase):
 
     def test_f_contiguous(self):
         a = theano.tensor.fmatrix('a')
         b = theano.tensor.fmatrix('b')
-        z = self.BrokenCImplementationAdd()(a, b)
+        z = BrokenCImplementationAdd()(a, b)
         # Needed so that z is not the output of the graph
         out = theano.tensor.dot(z, numpy.eye(7))
 

theano/gof/tests/test_cc.py

@@ -9,10 +9,12 @@ from theano.gof.op import Op
 from theano.gof import env
 from theano.gof import toolbox
 
+
 def as_variable(x):
     assert isinstance(x, Variable)
     return x
 
+
 class TDouble(Type):
     def filter(self, data):
         return float(data)
@@ -58,12 +60,19 @@ class TDouble(Type):
         """ % locals()
 
     def c_code_cache_version(self):
-        return ()
+        return (1,)
+
+    def __eq__(self, other):
+        return type(self) == type(other)
+
+    def __hash__(self):
+        return hash(type(self))
 
 tdouble = TDouble()
 
+
 def double(name):
-    return Variable(tdouble, None, None, name = name)
+    return Variable(tdouble, None, None, name=name)
 
 
 class MyOp(Op):
@@ -84,16 +93,26 @@ class MyOp(Op):
     def __str__(self):
         return self.name
 
+    def __eq__(self, other):
+        return (type(self) == type(other) and
+                self.name == other.name and
+                self.nin == other.nin)
+
+    def __hash__(self):
+        return hash(type(self)) ^ hash(self.name) ^ hash(self.nin)
+
     def perform(self, node, inputs, out_):
         out, = out_
         out[0] = self.impl(*inputs)
+
     def c_code_cache_version(self):
         return ()
 
 
-class Unary(MyOp):
-    def __init__(self):
-        MyOp.__init__(self, 1, self.__class__.__name__)
+#class Unary(MyOp):
+#    def __init__(self):
+#        MyOp.__init__(self, 1, self.__class__.__name__)
+
 
 class Binary(MyOp):
     def __init__(self):
@@ -105,37 +124,45 @@ class Add(Binary):
         x, y = inp
         z, = out
         return "%(z)s = %(x)s + %(y)s;" % locals()
+
     def impl(self, x, y):
         return x + y
 add = Add()
 
+
 class Sub(Binary):
     def c_code(self, node, name, inp, out, sub):
         x, y = inp
         z, = out
         return "%(z)s = %(x)s - %(y)s;" % locals()
+
     def impl(self, x, y):
-        return -10 # erroneous (most of the time)
+        return -10  # erroneous (most of the time)
 sub = Sub()
 
+
 class Mul(Binary):
     def c_code(self, node, name, inp, out, sub):
         x, y = inp
         z, = out
         return "%(z)s = %(x)s * %(y)s;" % locals()
+
     def impl(self, x, y):
         return x * y
 mul = Mul()
 
+
 class Div(Binary):
     def c_code(self, node, name, inp, out, sub):
         x, y = inp
         z, = out
         return "%(z)s = %(x)s / %(y)s;" % locals()
+
     def impl(self, x, y):
         return x / y
 div = Div()
 
+
 def inputs():
     x = double('x')
     y = double('y')
@@ -159,6 +186,7 @@ def test_clinker_straightforward():
     fn = lnk.make_function()
     assert fn(2.0, 2.0, 2.0) == 2.0
 
+
 def test_clinker_literal_inlining():
     x, y, z = inputs()
     z = Constant(tdouble, 4.12345678)
@@ -169,7 +197,8 @@ def test_clinker_literal_inlining():
     code = lnk.code_gen()
     print "=== Code generated ==="
     print code
-    assert "4.12345678" in code # we expect the number to be inlined
+    assert "4.12345678" in code  # we expect the number to be inlined
+
 
 def test_clinker_single_node():
     x, y, z = inputs()
@@ -178,6 +207,7 @@ def test_clinker_single_node():
     fn = lnk.make_function()
     assert fn(2.0, 7.0) == 9
 
+
 def test_clinker_dups():
     # Testing that duplicate inputs are allowed.
     x, y, z = inputs()
@@ -187,6 +217,7 @@ def test_clinker_dups():
     assert fn(2.0, 2.0) == 4
     # note: for now the behavior of fn(2.0, 7.0) is undefined
 
+
 def test_clinker_dups_inner():
     # Testing that duplicates are allowed inside the graph
     x, y, z = inputs()
@@ -196,7 +227,6 @@ def test_clinker_dups_inner():
     assert fn(1.0, 2.0, 3.0) == 8.0
 
 
-
 ######################
 # Test OpWiseCLinker #
 ######################
@@ -208,9 +238,10 @@ def test_opwiseclinker_straightforward():
     fn = lnk.make_function()
     assert fn(2.0, 2.0, 2.0) == 2.0
 
+
 def test_opwiseclinker_constant():
     x, y, z = inputs()
-    x = Constant(tdouble, 7.2, name = 'x')
+    x = Constant(tdouble, 7.2, name='x')
     e = add(mul(x, y), mul(y, z))
     lnk = OpWiseCLinker().accept(Env([y, z], [e]))
     fn = lnk.make_function()
@@ -218,13 +249,14 @@ def test_opwiseclinker_constant():
     assert res == 15.3
 
 
-
-
 class MyExc(Exception):
     pass
+
+
 def _my_checker(x, y):
     if x[0] != y[0]:
-        raise MyExc("Output mismatch.", {'performlinker': x[0], 'clinker': y[0]})
+        raise MyExc("Output mismatch.",
+                    {'performlinker': x[0], 'clinker': y[0]})
 
 
 ###################
@@ -233,22 +265,27 @@ def _my_checker(x, y):
 
 def test_duallinker_straightforward():
     x, y, z = inputs()
-    e = add(mul(x, y), mul(y, z)) # add and mul are correct in C and in Python
-    lnk = DualLinker(checker = _my_checker).accept(Env([x, y, z], [e]))
+    e = add(mul(x, y), mul(y, z))  # add and mul are correct in C and in Python
+    lnk = DualLinker(checker=_my_checker).accept(Env([x, y, z], [e]))
     fn = lnk.make_function()
     res = fn(7.2, 1.5, 3.0)
     assert res == 15.3
 
+
 def test_duallinker_mismatch():
     x, y, z = inputs()
-    e = sub(mul(x, y), mul(y, z)) # sub is correct in C but erroneous in Python
+    # sub is correct in C but erroneous in Python
+    e = sub(mul(x, y), mul(y, z))
     g = Env([x, y, z], [e])
-    lnk = DualLinker(checker = _my_checker).accept(g)
+    lnk = DualLinker(checker=_my_checker).accept(g)
     fn = lnk.make_function()
 
-    assert CLinker().accept(g).make_function()(1.0, 2.0, 3.0) == -4.0 # good
-    assert OpWiseCLinker().accept(g).make_function()(1.0, 2.0, 3.0) == -4.0 # good
-    assert PerformLinker().accept(g).make_function()(1.0, 2.0, 3.0) == -10.0 # (purposely) wrong
+    # good
+    assert CLinker().accept(g).make_function()(1.0, 2.0, 3.0) == -4.0
+    # good
+    assert OpWiseCLinker().accept(g).make_function()(1.0, 2.0, 3.0) == -4.0
+    # (purposely) wrong
+    assert PerformLinker().accept(g).make_function()(1.0, 2.0, 3.0) == -10.0
 
     try:
         # this runs OpWiseCLinker and PerformLinker in parallel and feeds
@@ -268,17 +305,19 @@ class AddFail(Binary):
     def c_code(self, node, name, inp, out, sub):
         x, y = inp
         z, = out
-        fail=sub['fail']
+        fail = sub['fail']
         return """%(z)s = %(x)s + %(y)s;
             PyErr_SetString(PyExc_RuntimeError, "failing here");
             %(fail)s;""" % locals()
+
     def impl(self, x, y):
         return x + y
 add_fail = AddFail()
 
+
 def test_fail_error():
     x, y, z = inputs()
-    x = Constant(tdouble, 7.2, name = 'x')
+    x = Constant(tdouble, 7.2, name='x')
     e = add_fail(mul(x, y), mul(y, z))
     lnk = OpWiseCLinker().accept(Env([y, z], [e]))
     fn = lnk.make_function()
@@ -286,7 +325,5 @@ def test_fail_error():
         res = fn(1.5, 3.0)
     except RuntimeError:
         print 'Yay, TEST PASSED'
-        return #test passed
-    assert 0 #test failed
-
-
+        return  # test passed
+    assert 0  # test failed

theano/gof/tests/test_compute_test_value.py

@@ -348,6 +348,9 @@ class TestComputeTestValue(unittest.TestCase):
                 output = input.type()
                 return Apply(self, [input], [output])
 
+            def c_code_cache_version(self):
+                return (1,)
+
             def c_code(self, node, name, inputs, outputs, sub):
                 x, = inputs
                 z, = outputs

theano/gof/type.py

@@ -449,6 +449,9 @@ class Generic(SingletonType):
         Py_INCREF(py_%(name)s);
         """ % locals()
 
+    def c_code_cache_version(self):
+        return (1,)
+
     def __str__(self):
         return self.__class__.__name__