Don't take the lock by unless needed at exit

theano/gof/cmodule.py

@@ -1299,13 +1299,17 @@ class ModuleCache(object):
         else:
             age_thresh_use = None
 
+        too_old_to_use = self.refresh(
+            age_thresh_use=age_thresh_use,
+            delete_if_problem=delete_if_problem,
+            # The clean up is done at init, no need to trigger it again
+            cleanup=False)
+        if not too_old_to_use:
+            return
         with compilelock.lock_ctx():
             # Update the age of modules that have been accessed by other
             # processes and get all module that are too old to use
             # (not loaded in self.entry_from_key).
-            too_old_to_use = self.refresh(
-                age_thresh_use=age_thresh_use,
-                delete_if_problem=delete_if_problem)
 
             for entry in too_old_to_use:
                 # TODO: we are assuming that modules that haven't been
@@ -1392,7 +1396,8 @@ class ModuleCache(object):
         if min_age is None:
             min_age = self.age_thresh_del_unversioned
 
-        with compilelock.lock_ctx():
+        # As this delete object that we build and other don't use, we
+        # don't need the lock.
         all_key_datas = list(self.module_hash_to_key_data.values())
         for key_data in all_key_datas:
             if not key_data.keys:
@@ -1430,6 +1435,7 @@ class ModuleCache(object):
         for key in self.entry_from_key:
             assert key[0]
 
+        to_del = []
         time_now = time.time()
         for filename in os.listdir(self.dirname):
             if filename.startswith('tmp'):
@@ -1463,13 +1469,26 @@ class ModuleCache(object):
                     # we wait one week and suppose that the processus
                     # crashed, and we take care of the clean-up.
                     if age > min_age:
-                            _rmtree(os.path.join(self.dirname, filename),
+                        to_del.append(os.path.join(self.dirname, filename))
+
+        if not to_del:
+            return
+        with compilelock.lock_ctx():
+            for f in to_del:
+                _rmtree(f,
                     msg='old unversioned', level=logging.INFO,
                     ignore_nocleanup=True)
 
     def _on_atexit(self):
         # Note: no need to call refresh() since it is called by clear_old().
-        with compilelock.lock_ctx():
+
+        # Note: no need to take the lock. For unversioned files, we
+        # don't need it as they aren't shared. For old unversioned
+        # files, this happen rarely, so we take the lock only when
+        # this happen.
+
+        # Note: for clear_old(), as this happen unfrequently, we only
+        # take the lock when it happen.
         self.clear_old()
         self.clear_unversioned()
         _logger.debug('Time spent checking keys: %s',