Remove keep_lock argument in theano.compile.compilelock.lock_ctx

theano/compile/compilelock.py

@@ -43,11 +43,10 @@ def force_unlock():
 
 
 @contextmanager
-def lock_ctx(lock_dir=None, keep_lock=False, **kw):
+def lock_ctx(lock_dir=None, **kw):
     get_lock(lock_dir=lock_dir, **kw)
     yield
-    if not keep_lock:
-        release_lock()
+    release_lock()
 
 
 # We define this name with an underscore so that python shutdown

theano/link/c/basic.py

@@ -1174,7 +1174,10 @@ class CLinker(Linker):
         return [r for r in uniq(ret) if r]
 
     def __compile__(
-        self, input_storage=None, output_storage=None, storage_map=None, keep_lock=False
+        self,
+        input_storage=None,
+        output_storage=None,
+        storage_map=None,
     ):
         """
         Compiles this linker's fgraph.
@@ -1216,7 +1219,6 @@ class CLinker(Linker):
             input_storage,
             output_storage,
             storage_map,
-            keep_lock=keep_lock,
         )
         return (
             thunk,
@@ -1248,9 +1250,7 @@ class CLinker(Linker):
             id += 2
         return init_tasks, tasks
 
-    def make_thunk(
-        self, input_storage=None, output_storage=None, storage_map=None, keep_lock=False
-    ):
+    def make_thunk(self, input_storage=None, output_storage=None, storage_map=None):
         """
         Compiles this linker's fgraph and returns a function to perform the
         computations, as well as lists of storage cells for both the inputs
@@ -1269,9 +1269,6 @@ class CLinker(Linker):
         storage_map: dict that map variables to storages.
             This is used when you need to customize the storage of
             this thunk
-        keep_lock:
-            If True, we won't release the lock on the compiledir
-            at the end of this function call.
         Returns: thunk, input_storage, output_storage
 
         The return values can be used as follows:
@@ -1283,7 +1280,7 @@ class CLinker(Linker):
         """
         init_tasks, tasks = self.get_init_tasks()
         cthunk, module, in_storage, out_storage, error_storage = self.__compile__(
-            input_storage, output_storage, storage_map, keep_lock=keep_lock
+            input_storage, output_storage, storage_map
         )
 
         res = _CThunk(cthunk, init_tasks, tasks, error_storage, module)
@@ -1685,9 +1682,7 @@ class CLinker(Linker):
             self._mod = mod
         return self._mod
 
-    def cthunk_factory(
-        self, error_storage, in_storage, out_storage, storage_map=None, keep_lock=False
-    ):
+    def cthunk_factory(self, error_storage, in_storage, out_storage, storage_map=None):
         """
         Returns a thunk that points to an instance of a C struct that
         can carry on the computation of this linker's fgraph
@@ -1715,9 +1710,7 @@ class CLinker(Linker):
             # Set compute_map as None as clinker do not support lazy evaluation
             for node in self.node_order:
                 node.op.prepare_node(node, storage_map, None, "c")
-            module = get_module_cache().module_from_key(
-                key=key, lnk=self, keep_lock=keep_lock
-            )
+            module = get_module_cache().module_from_key(key=key, lnk=self)
 
         vars = self.inputs + self.outputs + self.orphans
         # List of indices that should be ignored when passing the arguments

theano/link/c/cmodule.py

@@ -1051,11 +1051,11 @@ class ModuleCache:
             return None
         return self._get_module(name)
 
-    def _get_from_hash(self, module_hash, key, keep_lock=False):
+    def _get_from_hash(self, module_hash, key):
         if module_hash in self.module_hash_to_key_data:
             key_data = self.module_hash_to_key_data[module_hash]
             module = self._get_from_key(None, key_data)
-            with lock_ctx(keep_lock=keep_lock):
+            with lock_ctx():
                 try:
                     key_data.add_key(key, save_pkl=bool(key[0]))
                     key_broken = False
@@ -1130,7 +1130,7 @@ class ModuleCache:
         self._update_mappings(key, key_data, module.__file__, not key_broken)
         return key_data
 
-    def module_from_key(self, key, lnk=None, keep_lock=False):
+    def module_from_key(self, key, lnk=None):
         """
         Return a module from the cache, compiling it if necessary.
 
@@ -1144,8 +1144,6 @@ class ModuleCache:
             the `get_src_code()` and `compile_cmodule(location)` functions. The
             first one returns the source code of the module to load/compile and
             the second performs the actual compilation.
-        keep_lock : bool
-            If True, the compilation lock will not be released if taken.
 
         """
         # Is the module in the cache?
@@ -1156,11 +1154,11 @@ class ModuleCache:
         src_code = lnk.get_src_code()
         # Is the source code already in the cache?
         module_hash = get_module_hash(src_code, key)
-        module = self._get_from_hash(module_hash, key, keep_lock=keep_lock)
+        module = self._get_from_hash(module_hash, key)
         if module is not None:
             return module
 
-        with lock_ctx(keep_lock=keep_lock):
+        with lock_ctx():
             # 1) Maybe somebody else compiled it for us while we
             #    where waiting for the lock. Try to load it again.
             # 2) If other repo that import Theano have Theano ops defined,