Don't take the lock if the cutil is well compiled.

theano/gof/cc.py

@@ -1155,7 +1155,7 @@ class OpWiseCLinker(link.LocalLinker):
         # compilation will be finished. This allow to don't
         # require the lock when all c code are already compiled!
         keep_lock=True
-        orig_n_lock = get_lock.n_lock
+        orig_n_lock = getattr(get_lock,"n_lock",0)
         try:
 
             env = self.env

theano/gof/cutils.py

@@ -10,58 +10,65 @@ if os.path.exists(os.path.join(config.compiledir,'cutils_ext.so')):
 # Ensure no-one else is currently modifying the content of the compilation
 # directory. This is important to prevent multiple processes from trying to
 # compile the cutils_ext module simultaneously.
-get_lock()
 try:
-    try:
-        from cutils_ext.cutils_ext import *
-    except ImportError:
-        import cmodule
+    from cutils_ext.cutils_ext import *
+except ImportError:
+    import cmodule
 
-        code = """
-    #include <Python.h>
-    extern "C"{
-    static PyObject *
-    run_cthunk(PyObject *self, PyObject *args)
-    {
-      PyObject *py_cthunk = NULL;
-      if(!PyArg_ParseTuple(args,"O",&py_cthunk))
-        return NULL;
+    get_lock()
+    try:
+        try:
+            # We must retry to import it as some other processs could
+            # have been compiling it between the first failed import
+            # and when we receive the lock
+            from cutils_ext.cutils_ext import *
+        except ImportError:
+            import cmodule
 
-      if (!PyCObject_Check(py_cthunk)) {
-        PyErr_SetString(PyExc_ValueError,
-                       "Argument to run_cthunk must be a PyCObject.");
-        return NULL;
-      }
-      void * ptr_addr = PyCObject_AsVoidPtr(py_cthunk);
-      int (*fn)(void*) = (int (*)(void*))(ptr_addr);
-      void* it = PyCObject_GetDesc(py_cthunk);
-      int failure = fn(it);
+            code = """
+        #include <Python.h>
+        extern "C"{
+        static PyObject *
+        run_cthunk(PyObject *self, PyObject *args)
+        {
+          PyObject *py_cthunk = NULL;
+          if(!PyArg_ParseTuple(args,"O",&py_cthunk))
+            return NULL;
 
-      return Py_BuildValue("i", failure);
-    }
+          if (!PyCObject_Check(py_cthunk)) {
+            PyErr_SetString(PyExc_ValueError,
+                           "Argument to run_cthunk must be a PyCObject.");
+            return NULL;
+          }
+          void * ptr_addr = PyCObject_AsVoidPtr(py_cthunk);
+          int (*fn)(void*) = (int (*)(void*))(ptr_addr);
+          void* it = PyCObject_GetDesc(py_cthunk);
+          int failure = fn(it);
 
-    static PyMethodDef CutilsExtMethods[] = {
-        {"run_cthunk",  run_cthunk, METH_VARARGS|METH_KEYWORDS,
-         "Run a theano cthunk."},
-        {NULL, NULL, 0, NULL}        /* Sentinel */
-    };
+          return Py_BuildValue("i", failure);
+        }
 
-    PyMODINIT_FUNC
-    initcutils_ext(void)
-    {
-      (void) Py_InitModule("cutils_ext", CutilsExtMethods);
-    }
-    }
-    """
+        static PyMethodDef CutilsExtMethods[] = {
+            {"run_cthunk",  run_cthunk, METH_VARARGS|METH_KEYWORDS,
+             "Run a theano cthunk."},
+            {NULL, NULL, 0, NULL}        /* Sentinel */
+        };
 
-        loc = os.path.join(config.compiledir, 'cutils_ext')
-        if not os.path.exists(loc):
-            os.mkdir(loc)
+        PyMODINIT_FUNC
+        initcutils_ext(void)
+        {
+          (void) Py_InitModule("cutils_ext", CutilsExtMethods);
+        }
+        }
+        """
 
-        cmodule.gcc_module_compile_str('cutils_ext', code, location=loc)
-        from cutils_ext.cutils_ext import *
+            loc = os.path.join(config.compiledir, 'cutils_ext')
+            if not os.path.exists(loc):
+                os.mkdir(loc)
 
-finally:
-    # Release lock on compilation directory.
-    release_lock()
+            cmodule.gcc_module_compile_str('cutils_ext', code, location=loc)
+            from cutils_ext.cutils_ext import *
 
+    finally:
+        # Release lock on compilation directory.
+        release_lock()