Merge pull request #829 from lamblin/fix_profile_py24

theano/compile/debugmode.py

@@ -1560,7 +1560,7 @@ class _Linker(gof.link.LocalLinker):
             no_recycling = []
         if self.fgraph is not None and self.fgraph is not fgraph:
             assert type(self) is _Linker
-            return type(self)(self.fgraph, self.maker).accept(fgraph, no_recycling)
+            return type(self)(maker=self.maker).accept(fgraph, no_recycling)
         self.fgraph = fgraph
         self.no_recycling = no_recycling
         return self

theano/compile/mode.py

@@ -328,7 +328,7 @@ class Mode(object):
         self.linker_time = 0
 
     def __str__(self):
-        return "Mode(linker = %s, optimizer = %s)" % (
+        return "%s(linker = %s, optimizer = %s)" % (self.__class__.__name__,
                 self.provided_linker, self.provided_optimizer)
 
     def __get_optimizer(self):

theano/compile/tests/test_modes.py

 """
 Test compilation modes
 """
+import copy
 import unittest
 
 import theano
@@ -25,7 +26,6 @@ class T_bunch_of_modes(unittest.TestCase):
         modes = predef_modes + [Mode(linker, 'fast_run') for linker in linkers]
 
         for mode in modes:
-
             x = T.matrix()
             y = T.vector()
             f = theano.function([x, y], x + y, mode=mode)
@@ -33,6 +33,7 @@ class T_bunch_of_modes(unittest.TestCase):
             f([[1, 2], [3, 4]], [5, 6])
             linker_classes_involved.append(f.maker.mode.linker.__class__)
             #print 'MODE:', mode, f.maker.mode.linker, 'stop'
+
         # regression check:
         # there should be
         # - VM_Linker
@@ -42,5 +43,26 @@ class T_bunch_of_modes(unittest.TestCase):
         # - DebugMode's Linker  (DEBUG_MODE)
         assert 5 == len(set(linker_classes_involved))
 
+
+class T_ProfileMode_WrapLinker(unittest.TestCase):
+    def test_1(self):
+        # First, compile a function with a new ProfileMode() object
+        # No need to call that function
+        x = T.matrix()
+        mode = ProfileMode()
+        theano.function([x], x * 2, mode=mode)
+
+        # Then, build a mode with the same linker, and a modified optimizer
+        default_mode = theano.compile.mode.get_default_mode()
+        modified_mode = default_mode.including('specialize')
+
+        # The following line used to fail, with Python 2.4, in July 2012,
+        # because an fgraph was associated to the default linker
+        copy.deepcopy(modified_mode)
+
+        # More straightforward test
+        assert theano.compile.mode.get_default_mode().linker.fgraph is None
+
+
 if __name__ == '__main__':
     unittest.main()

theano/gof/cc.py

@@ -1408,8 +1408,11 @@ class OpWiseCLinker(link.LocalLinker):
         if no_recycling is None:
             no_recycling = []
         if self.fgraph is not None and self.fgraph is not fgraph:
-            return type(self)(self.fallback_on_perform).accept(fgraph,
-                                                               no_recycling)
+            return type(self)(
+                    fallback_on_perform=self.fallback_on_perform,
+                    allow_gc=self.allow_gc,
+                    nice_errors=self.nice_errors
+                    ).accept(fgraph, no_recycling)
             #raise Exception("Cannot accept from a Linker that is
             #already tied to another FunctionGraph.")
         self.fgraph = fgraph

theano/gof/link.py

@@ -433,7 +433,7 @@ class PerformLinker(LocalLinker):
         if no_recycling is None:
             no_recycling = []
         if self.fgraph is not None and self.fgraph is not fgraph:
-            return type(self)().accept(fgraph, no_recycling)
+            return type(self)(allow_gc=self.allow_gc).accept(fgraph, no_recycling)
             #raise Exception("Cannot accept from a Linker that is already tied to another FunctionGraph.")
         self.fgraph = fgraph
         self.no_recycling = no_recycling
@@ -553,6 +553,22 @@ class WrapLinker(Linker):
         self.linkers = linkers
         self.wrapper = wrapper
 
+    def __copy__(self):
+        """
+        Shallow copy of a WrapLinker.
+
+        @returns: A copy of self, where each of the linkers in self.linkers
+            have been shallow-copied.
+
+        It is useful because in FunctionMaker, copy.copy is called on the
+        Mode's linker, so that it is not modified inplace when linker.accept()
+        is called. In this case, we want the wrapped linkers to be copied too.
+        """
+        other = self.__class__(
+                linkers=[copy(l) for l in self.linkers],
+                wrapper=self.wrapper)
+        return other
+
     def accept(self, fgraph, no_recycling=None):
         """
         @type fgraph: gof.FunctionGraph

theano/gof/unify.py

@@ -9,6 +9,7 @@ if there exists an assignment to all unification variables such that
 """
 from copy import copy
 
+from python25 import partial
 from utils import *
 
 

theano/gof/utils.py

@@ -179,17 +179,6 @@ def from_return_values(values):
         return [values]
 
 
-def partial(func, *args, **keywords):
-    def newfunc(*fargs, **fkeywords):
-        newkeywords = keywords.copy()
-        newkeywords.update(fkeywords)
-        return func(*(args + fargs), **newkeywords)
-    newfunc.func = func
-    newfunc.args = args
-    newfunc.keywords = keywords
-    return newfunc
-
-
 class ClsInit(type):
     """Class initializer for L{Op} subclasses"""
     def __init__(cls, name, bases, dct):