feat(util/script_state): use recursive_mutex instead of mutex

Signed-off-by: Leonardo de Moura <leonardo@microsoft.com>

src/util/script_state.cpp

@@ -40,8 +40,8 @@ void open_extra(lua_State * L);
 static char g_weak_ptr_key; // key for Lua registry (used at get_weak_ptr and save_weak_ptr)
 
 struct script_state::imp {
-    lua_State * m_state;
+    lua_State *           m_state;
-    mutex       m_mutex;
+    recursive_mutex       m_mutex;
     std::unordered_set<std::string> m_imported_modules;
 
     static std::weak_ptr<imp> * get_weak_ptr(lua_State * L) {
@@ -100,12 +100,12 @@ struct script_state::imp {
     }
 
     void dofile(char const * fname) {
-        lock_guard<mutex> lock(m_mutex);
+        lock_guard<recursive_mutex> lock(m_mutex);
         ::lean::dofile(m_state, fname);
     }
 
     void dostring(char const * str) {
-        lock_guard<mutex> lock(m_mutex);
+        lock_guard<recursive_mutex> lock(m_mutex);
         ::lean::dostring(m_state, str);
     }
 
@@ -162,7 +162,7 @@ bool script_state::import_explicit(char const * str) {
     return m_ptr->import_explicit(str);
 }
 
-mutex & script_state::get_mutex() {
+recursive_mutex & script_state::get_mutex() {
     return m_ptr->m_mutex;
 }
 

src/util/script_state.h

@@ -20,7 +20,7 @@ public:
 private:
     std::shared_ptr<imp> m_ptr;
     friend script_state to_script_state(lua_State * L);
-    mutex & get_mutex();
+    recursive_mutex & get_mutex();
     lua_State * get_state();
     friend class data_channel;
 public:
@@ -60,7 +60,7 @@ public:
     */
     template<typename F>
     typename std::result_of<F(lua_State * L)>::type apply(F && f) {
-        lock_guard<mutex> lock(get_mutex());
+        lock_guard<recursive_mutex> lock(get_mutex());
         return f(get_state());
     }
 
@@ -74,13 +74,13 @@ public:
     */
     template<typename F>
     void exec_unprotected(F && f) {
-        unlock_guard unlock(get_mutex());
+        unlock_guard<recursive_mutex> unlock(get_mutex());
         f();
     }
 
     template<typename F>
     void exec_protected(F && f) {
-        lock_guard<mutex> lock(get_mutex());
+        lock_guard<recursive_mutex> lock(get_mutex());
         f();
     }
 };

src/util/thread.h

@@ -18,6 +18,7 @@ namespace lean {
 inline void set_thread_stack_size(size_t ) {}
 using std::thread;
 using std::mutex;
+using std::recursive_mutex;
 using std::atomic;
 using std::atomic_bool;
 using std::atomic_ushort;
@@ -40,7 +41,7 @@ namespace lean {
 void set_thread_stack_size(size_t );
 boost::thread::attributes const & get_thread_attributes();
 using boost::thread;
-using boost::mutex;
+using boost::recursive_mutex;
 using boost::atomic;
 using boost::memory_order_relaxed;
 using boost::condition_variable;
@@ -118,6 +119,11 @@ public:
     void lock() {}
     void unlock() {}
 };
+class recursive_mutex {
+public:
+    void lock() {}
+    void unlock() {}
+};
 class condition_variable {
 public:
     template<typename Lock> void wait(Lock const &) {}

src/util/unlock_guard.h

@@ -29,10 +29,11 @@ namespace lean {
 
    \warning The calling thread must own the lock to m_mutex
 */
+template<typename Mutex>
 class unlock_guard {
-    mutex & m_mutex;
+    Mutex & m_mutex;
 public:
-    explicit unlock_guard(mutex & m):m_mutex(m) { m_mutex.unlock(); }
+    explicit unlock_guard(Mutex & m):m_mutex(m) { m_mutex.unlock(); }
     unlock_guard(unlock_guard const &) = delete;
     unlock_guard(unlock_guard &&) = delete;
     unlock_guard & operator=(unlock_guard const &) = delete;