From 9cb187762a68e431559ee9e4b1ed8c6f16826d89 Mon Sep 17 00:00:00 2001
From: Marco Costalba <mcostalba@gmail.com>
Date: Thu, 29 Dec 2011 09:55:09 +0100
Subject: [PATCH] Wait for main thread to finish before to exit

Currently after a 'quit' command UI thread raises stop
signal, exits from uci_loop() and calls Threads.exit()
while the search threads are still active.

In Threads.exit() main thread is asked to terminate, but
if it is parked in idle_loop() it will exit and free its
resources (in particular the shared Movepicker object) while
sibling slaves are still active and this leads to a crash.

The fix is to let the UI thread always wait for main thread
to finish the search before to return from uci_loop().

Found by Valgrind when running with 8 threads.

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
---
 src/thread.cpp | 23 ++++++++++++++++++++++-
 src/thread.h   |  1 +
 src/uci.cpp    |  9 ++-------
 3 files changed, 25 insertions(+), 8 deletions(-)

diff --git a/src/thread.cpp b/src/thread.cpp
index 5c0ac84b..fef2e9c9 100644
--- a/src/thread.cpp
+++ b/src/thread.cpp
@@ -197,7 +197,7 @@ void ThreadsManager::exit() {
 
   for (int i = 0; i <= MAX_THREADS; i++)
   {
-      threads[i].do_terminate = true;
+      threads[i].do_terminate = true; // Search must be already finished
       threads[i].wake_up();
 
       // Wait for thread termination
@@ -458,6 +458,27 @@ void ThreadsManager::start_thinking(const Position& pos, const LimitsType& limit
 }
 
 
+// ThreadsManager::stop_thinking() is used by UI thread to raise a stop request
+// and to wait for the main thread finishing the search. Needed to wait exiting
+// and terminate the threads after a 'quit' command.
+
+void ThreadsManager::stop_thinking() {
+
+  Thread& main = threads[0];
+
+  Search::Signals.stop = true;
+
+  lock_grab(&main.sleepLock);
+
+  cond_signal(&main.sleepCond); // In case is waiting for stop or ponderhit
+
+  while (!main.do_sleep)
+      cond_wait(&sleepCond, &main.sleepLock);
+
+  lock_release(&main.sleepLock);
+}
+
+
 // ThreadsManager::wait_for_stop_or_ponderhit() is called when the maximum depth
 // is reached while the program is pondering. The point is to work around a wrinkle
 // in the UCI protocol: When pondering, the engine is not allowed to give a
diff --git a/src/thread.h b/src/thread.h
index dcaa5ca3..a7321374 100644
--- a/src/thread.h
+++ b/src/thread.h
@@ -118,6 +118,7 @@ public:
   bool split_point_finished(SplitPoint* sp) const;
   void set_timer(int msec);
   void wait_for_stop_or_ponderhit();
+  void stop_thinking();
   void start_thinking(const Position& pos, const Search::LimitsType& limits,
                       const std::vector<Move>& searchMoves, bool asyncMode);
 
diff --git a/src/uci.cpp b/src/uci.cpp
index 02a3c30c..9faf842f 100644
--- a/src/uci.cpp
+++ b/src/uci.cpp
@@ -68,10 +68,7 @@ void uci_loop() {
       is >> skipws >> token;
 
       if (token == "quit" || token == "stop")
-      {
-          Search::Signals.stop = true;
-          Threads[0].wake_up(); // In case is waiting for stop or ponderhit
-      }
+          Threads.stop_thinking();
 
       else if (token == "ponderhit")
       {
@@ -81,9 +78,7 @@ void uci_loop() {
           Search::Limits.ponder = false;
 
           if (Search::Signals.stopOnPonderhit)
-              Search::Signals.stop = true;
-
-          Threads[0].wake_up(); // In case is waiting for stop or ponderhit
+              Threads.stop_thinking();
       }
 
       else if (token == "go")
-- 
2.39.2