Introduce Search namespace

Move global search-related variables under "Search" namespace.

As a side effect we can move uci_async_command() and
wait_for_stop_or_ponderhit() away from search.cpp

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>

diff --git a/src/benchmark.cpp b/src/benchmark.cpp
index 551c341b1043df21dfc56d0a0c0cdecdae42a589..45304671993c1d49c07cae6899bac14fa920a965 100644 (file)
--- a/src/benchmark.cpp
+++ b/src/benchmark.cpp
@@ -76,11 +76,11 @@ void benchmark(int argc, char* argv[]) {
 
   // Search should be limited by nodes, time or depth ?
   if (valType == "nodes")
-      Limits.maxNodes = atoi(valStr.c_str());
+      Search::Limits.maxNodes = atoi(valStr.c_str());
   else if (valType == "time")
-      Limits.maxTime = 1000 * atoi(valStr.c_str()); // maxTime is in ms
+      Search::Limits.maxTime = 1000 * atoi(valStr.c_str()); // maxTime is in ms
   else
-      Limits.maxDepth = atoi(valStr.c_str());
+      Search::Limits.maxDepth = atoi(valStr.c_str());
 
   // Do we need to load positions from a given FEN file?
   if (fenFile != "default")
@@ -105,22 +105,22 @@ void benchmark(int argc, char* argv[]) {
           fenList.push_back(Defaults[i]);
 
   // Ok, let's start the benchmark !
+  Search::RootMoves.push_back(MOVE_NONE);
   totalNodes = 0;
   time = get_system_time();
-  SearchMoves.push_back(MOVE_NONE);
 
   for (size_t i = 0; i < fenList.size(); i++)
   {
       Position pos(fenList[i], false, 0);
-      RootPosition = &pos;
+      Search::RootPosition = &pos;
 
       cerr << "\nBench position: " << i + 1 << '/' << fenList.size() << endl;
 
       if (valType == "perft")
       {
-          int64_t cnt = perft(pos, Limits.maxDepth * ONE_PLY);
+          int64_t cnt = Search::perft(pos, Search::Limits.maxDepth * ONE_PLY);
 
-          cerr << "\nPerft " << Limits.maxDepth
+          cerr << "\nPerft " << Search::Limits.maxDepth
                << " nodes counted: " << cnt << endl;
 
           totalNodes += cnt;

diff --git a/src/main.cpp b/src/main.cpp
index b2cb0745cd0343cbe2d20e852b8084942973bd0d..202cf5f36484a8891942d0a7cab7b4b8c163527d 100644 (file)
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -53,7 +53,7 @@ int main(int argc, char* argv[]) {
   init_bitboards();
   Position::init();
   kpk_bitbase_init();
-  init_search();
+  Search::init();
   Threads.init();
 
 #ifdef USE_CALLGRIND

diff --git a/src/search.cpp b/src/search.cpp
index 560f64f1778e0e19d0a54be6cfe56e05c85a1715..b1581c6ff222f60d27349ac57274ad6e4bb2d8a4 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -42,10 +42,16 @@
 using std::cout;
 using std::endl;
 using std::string;
+using Search::Signals;
+using Search::Limits;
 
-SearchLimits Limits;
-std::vector<Move> SearchMoves;
-Position* RootPosition;
+namespace Search {
+
+  volatile SignalsType Signals;
+  LimitsType Limits;
+  std::vector<Move> RootMoves;
+  Position* RootPosition;
+}
 
 namespace {
 
@@ -78,7 +84,7 @@ namespace {
   // RootMoveList struct is mainly a std::vector of RootMove objects
   struct RootMoveList : public std::vector<RootMove> {
 
-    void init(Position& pos, Move searchMoves[]);
+    void init(Position& pos, Move rootMoves[]);
     RootMove* find(const Move& m, int startIndex = 0);
 
     int bestMoveChanges;
@@ -166,7 +172,6 @@ namespace {
   int MultiPV, UCIMultiPV, MultiPVIdx;
 
   // Time management variables
-  volatile bool StopOnPonderhit, FirstRootMove, StopRequest, AspirationFailLow;
   TimeManager TimeMgr;
 
   // Skill level adjustment
@@ -179,7 +184,7 @@ namespace {
 
   /// Local functions
 
-  Move id_loop(Position& pos, Move searchMoves[], Move* ponderMove);
+  Move id_loop(Position& pos, Move rootMoves[], Move* ponderMove);
 
   template <NodeType NT>
   Value search(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth);
@@ -295,7 +300,7 @@ namespace {
 
 /// init_search() is called during startup to initialize various lookup tables
 
-void init_search() {
+void Search::init() {
 
   int d;  // depth (ONE_PLY == 2)
   int hd; // half depth (ONE_PLY == 1)
@@ -323,7 +328,7 @@ void init_search() {
 /// perft() is our utility to verify move generation. All the leaf nodes up to
 /// the given depth are generated and counted and the sum returned.
 
-int64_t perft(Position& pos, Depth depth) {
+int64_t Search::perft(Position& pos, Depth depth) {
 
   StateInfo st;
   int64_t sum = 0;
@@ -353,7 +358,7 @@ int64_t perft(Position& pos, Depth depth) {
 /// variables, and calls id_loop(). It returns false when a "quit" command is
 /// received during the search.
 
-void think() {
+void Search::think() {
 
   static Book book; // Defined static to initialize the PRNG only once
 
@@ -362,8 +367,8 @@ void think() {
   // Save "search start" time and reset elapsed time to zero
   elapsed_search_time(get_system_time());
 
-  // Initialize global search-related variables
-  StopOnPonderhit = StopRequest = AspirationFailLow = false;
+  // Reset global search signals
+  memset((void*)&Signals, 0, sizeof(Signals));
 
   // Set output stream mode: normal or chess960. Castling notation is different
   cout << set960(pos.is_chess960());
@@ -377,7 +382,7 @@ void think() {
       Move bookMove = book.probe(pos, Options["Best Book Move"].value<bool>());
       if (bookMove != MOVE_NONE)
       {
-          if (!StopRequest && (Limits.ponder || Limits.infinite))
+          if (!Signals.stop && (Limits.ponder || Limits.infinite))
               Threads.wait_for_stop_or_ponderhit();
 
           cout << "bestmove " << bookMove << endl;
@@ -437,7 +442,7 @@ void think() {
 
   // We're ready to start thinking. Call the iterative deepening loop function
   Move ponderMove = MOVE_NONE;
-  Move bestMove = id_loop(pos, &SearchMoves[0], &ponderMove);
+  Move bestMove = id_loop(pos, &RootMoves[0], &ponderMove);
 
   // Stop timer, no need to check for available time any more
   Threads.set_timer(0);
@@ -464,7 +469,7 @@ void think() {
   // When we reach max depth we arrive here even without a StopRequest, but if
   // we are pondering or in infinite search, we shouldn't print the best move
   // before we are told to do so.
-  if (!StopRequest && (Limits.ponder || Limits.infinite))
+  if (!Signals.stop && (Limits.ponder || Limits.infinite))
       Threads.wait_for_stop_or_ponderhit();
 
   // Could be MOVE_NONE when searching on a stalemate position
@@ -485,7 +490,7 @@ namespace {
   // with increasing depth until the allocated thinking time has been consumed,
   // user stops the search, or the maximum search depth is reached.
 
-  Move id_loop(Position& pos, Move searchMoves[], Move* ponderMove) {
+  Move id_loop(Position& pos, Move rootMoves[], Move* ponderMove) {
 
     SearchStack ss[PLY_MAX_PLUS_2];
     Value bestValues[PLY_MAX_PLUS_2];
@@ -505,7 +510,7 @@ namespace {
     ss->currentMove = MOVE_NULL; // Hack to skip update gains
 
     // Moves to search are verified and copied
-    Rml.init(pos, searchMoves);
+    Rml.init(pos, rootMoves);
 
     // Handle special case of searching on a mate/stalemate position
     if (!Rml.size())
@@ -517,7 +522,7 @@ namespace {
     }
 
     // Iterative deepening loop until requested to stop or target depth reached
-    while (!StopRequest && ++depth <= PLY_MAX && (!Limits.maxDepth || depth <= Limits.maxDepth))
+    while (!Signals.stop && ++depth <= PLY_MAX && (!Limits.maxDepth || depth <= Limits.maxDepth))
     {
         // Save now last iteration's scores, before Rml moves are reordered
         for (size_t i = 0; i < Rml.size(); i++)
@@ -576,7 +581,7 @@ namespace {
                 // If search has been stopped exit the aspiration window loop,
                 // note that sorting and writing PV back to TT is safe becuase
                 // Rml is still valid, although refers to the previous iteration.
-                if (StopRequest)
+                if (Signals.stop)
                     break;
 
                 // Send full PV info to GUI if we are going to leave the loop or
@@ -611,8 +616,8 @@ namespace {
                 }
                 else if (bestValue <= alpha)
                 {
-                    AspirationFailLow = true;
-                    StopOnPonderhit = false;
+                    Signals.failedLowAtRoot = true;
+                    Signals.stopOnPonderhit = false;
 
                     alpha = std::max(alpha - aspirationDelta, -VALUE_INFINITE);
                     aspirationDelta += aspirationDelta / 2;
@@ -644,7 +649,7 @@ namespace {
             bestMoveNeverChanged = false;
 
         // Do we have time for the next iteration? Can we stop searching now?
-        if (!StopRequest && !StopOnPonderhit && Limits.useTimeManagement())
+        if (!Signals.stop && !Signals.stopOnPonderhit && Limits.useTimeManagement())
         {
             // Take in account some extra time if the best move has changed
             if (depth > 4 && depth < 50)
@@ -653,11 +658,11 @@ namespace {
             // Stop search if most of available time is already consumed. We probably don't
             // have enough time to search the first move at the next iteration anyway.
             if (elapsed_search_time() > (TimeMgr.available_time() * 62) / 100)
-                StopRequest = true;
+                Signals.stop = true;
 
             // Stop search early if one move seems to be much better than others
             if (   depth >= 10
-                && !StopRequest
+                && !Signals.stop
                 && (   bestMoveNeverChanged
                     || elapsed_search_time() > (TimeMgr.available_time() * 40) / 100))
             {
@@ -669,14 +674,14 @@ namespace {
                 (ss+1)->excludedMove = MOVE_NONE;
 
                 if (v < rBeta)
-                    StopRequest = true;
+                    Signals.stop = true;
             }
 
             // If we are allowed to ponder do not stop the search now but keep pondering
-            if (StopRequest && Limits.ponder) // FIXME Limits.ponder is racy
+            if (Signals.stop && Limits.ponder) // FIXME Limits.ponder is racy
             {
-                StopRequest = false;
-                StopOnPonderhit = true;
+                Signals.stop = false;
+                Signals.stopOnPonderhit = true;
             }
         }
     }
@@ -756,7 +761,7 @@ namespace {
     }
 
     // Step 2. Check for aborted search and immediate draw
-    if ((   StopRequest
+    if ((   Signals.stop
          || pos.is_draw<false>()
          || ss->ply > PLY_MAX) && !RootNode)
         return VALUE_DRAW;
@@ -1015,7 +1020,7 @@ split_point_start: // At split points actual search starts from here
       if (RootNode)
       {
           // This is used by time management
-          FirstRootMove = (moveCount == 1);
+          Signals.firstRootMove = (moveCount == 1);
 
           // Save the current node count before the move is searched
           nodes = pos.nodes_searched();
@@ -1184,7 +1189,7 @@ split_point_start: // At split points actual search starts from here
       // was aborted because the user interrupted the search or because we
       // ran out of time. In this case, the return value of the search cannot
       // be trusted, and we don't update the best move and/or PV.
-      if (RootNode && !StopRequest)
+      if (RootNode && !Signals.stop)
       {
           // Remember searched nodes counts for this move
           RootMove* rm = Rml.find(move);
@@ -1235,7 +1240,7 @@ split_point_start: // At split points actual search starts from here
           && depth >= Threads.min_split_depth()
           && bestValue < beta
           && Threads.available_slave_exists(pos.thread())
-          && !StopRequest
+          && !Signals.stop
           && !thread.cutoff_occurred())
           bestValue = Threads.split<FakeSplit>(pos, ss, alpha, beta, bestValue, depth,
                                                threatMove, moveCount, &mp, NT);
@@ -1253,7 +1258,7 @@ split_point_start: // At split points actual search starts from here
     // Step 21. Update tables
     // If the search is not aborted, update the transposition table,
     // history counters, and killer moves.
-    if (!SpNode && !StopRequest && !thread.cutoff_occurred())
+    if (!SpNode && !Signals.stop && !thread.cutoff_occurred())
     {
         move = bestValue <= oldAlpha ? MOVE_NONE : ss->bestMove;
         vt   = bestValue <= oldAlpha ? VALUE_TYPE_UPPER
@@ -1943,7 +1948,7 @@ split_point_start: // At split points actual search starts from here
 
   /// RootMove and RootMoveList method's definitions
 
-  void RootMoveList::init(Position& pos, Move searchMoves[]) {
+  void RootMoveList::init(Position& pos, Move rootMoves[]) {
 
     Move* sm;
     bestMoveChanges = 0;
@@ -1952,11 +1957,11 @@ split_point_start: // At split points actual search starts from here
     // Generate all legal moves and add them to RootMoveList
     for (MoveList<MV_LEGAL> ml(pos); !ml.end(); ++ml)
     {
-        // If we have a searchMoves[] list then verify the move
+        // If we have a rootMoves[] list then verify the move
         // is in the list before to add it.
-        for (sm = searchMoves; *sm && *sm != ml.move(); sm++) {}
+        for (sm = rootMoves; *sm && *sm != ml.move(); sm++) {}
 
-        if (sm != searchMoves && *sm != ml.move())
+        if (sm != rootMoves && *sm != ml.move())
             continue;
 
         RootMove rm;
@@ -2138,49 +2143,6 @@ void Thread::idle_loop(SplitPoint* sp) {
 }
 
 
-// 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
-// "bestmove" before the GUI sends it a "stop" or "ponderhit" command.
-// We simply wait here until one of these commands (that raise StopRequest) is
-// sent, and return, after which the bestmove and pondermove will be printed.
-
-void ThreadsManager::wait_for_stop_or_ponderhit() {
-
-  StopOnPonderhit = true;
-
-  Thread& main = threads[0];
-
-  lock_grab(&main.sleepLock);
-
-  while (!StopRequest)
-      cond_wait(&main.sleepCond, &main.sleepLock);
-
-  lock_release(&main.sleepLock);
-}
-
-
-// uci_async_command() is called when a 'cmd' input line is received from the
-// GUI while searching.
-
-void uci_async_command(const std::string& cmd) {
-
-  if (cmd == "quit" || cmd == "stop")
-      StopRequest = true;
-
-  else if (cmd == "ponderhit")
-  {
-      // The opponent has played the expected move. GUI sends "ponderhit" if
-      // we were told to ponder on the same move the opponent has played. We
-      // should continue searching but switching from pondering to normal search.
-      Limits.ponder = false;
-
-      if (StopOnPonderhit)
-          StopRequest = true;
-  }
-}
-
-
 // do_timer_event() is called by the timer thread when the timer triggers
 
 void do_timer_event() {
@@ -2201,8 +2163,8 @@ void do_timer_event() {
   if (Limits.ponder)
       return;
 
-  bool stillAtFirstMove =    FirstRootMove
-                         && !AspirationFailLow
+  bool stillAtFirstMove =    Signals.firstRootMove
+                         && !Signals.failedLowAtRoot
                          &&  e > TimeMgr.available_time();
 
   bool noMoreTime =   e > TimeMgr.maximum_time()
@@ -2211,5 +2173,5 @@ void do_timer_event() {
   if (   (Limits.useTimeManagement() && noMoreTime)
       || (Limits.maxTime && e >= Limits.maxTime)
          /* missing nodes limit */ ) // FIXME
-      StopRequest = true;
+      Signals.stop = true;
 }

diff --git a/src/search.h b/src/search.h
index 3262c757cbe05aa4ff50e07ad3711ac3ec453aab..4f98cc762fb041a0dac265a81cc9b1336b401150 100644 (file)
--- a/src/search.h
+++ b/src/search.h
@@ -46,26 +46,34 @@ struct SearchStack {
   int skipNullMove;
 };
 
+namespace Search {
 
 /// The SearchLimits struct stores information sent by GUI about available time
 /// to search the current move, maximum depth/time, if we are in analysis mode
 /// or if we have to ponder while is our opponent's side to move.
 
-struct SearchLimits {
+struct LimitsType {
 
   bool useTimeManagement() const { return !(maxTime | maxDepth | maxNodes | infinite); }
 
   int time, increment, movesToGo, maxTime, maxDepth, maxNodes, infinite, ponder;
 };
 
-extern SearchLimits Limits;
-extern std::vector<Move> SearchMoves;
+struct SignalsType {
+  bool stopOnPonderhit, firstRootMove, stop, failedLowAtRoot;
+};
+
+extern volatile SignalsType Signals;
+extern LimitsType Limits;
+extern std::vector<Move> RootMoves;
 extern Position* RootPosition;
 
-extern void init_search();
+extern void init();
 extern int64_t perft(Position& pos, Depth depth);
 extern void think();
-extern void uci_async_command(const std::string& cmd);
+
+}
+
 extern void do_timer_event();
 
 #endif // !defined(SEARCH_H_INCLUDED)

diff --git a/src/thread.cpp b/src/thread.cpp
index 57faa6e90bb39b53ccff0a3cf3f5c6e84ef6f225..2978f188b6878be190a4c2b366e509489ac27a99 100644 (file)
--- a/src/thread.cpp
+++ b/src/thread.cpp
@@ -418,7 +418,7 @@ void Thread::main_loop() {
       if (do_terminate)
           return;
 
-      think(); // Search entry point
+      Search::think();
   }
 }
 
@@ -446,3 +446,25 @@ void ThreadsManager::start_thinking(bool asyncMode) {
 
   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
+// "bestmove" before the GUI sends it a "stop" or "ponderhit" command.
+// We simply wait here until one of these commands (that raise StopRequest) is
+// sent, and return, after which the bestmove and pondermove will be printed.
+
+void ThreadsManager::wait_for_stop_or_ponderhit() {
+
+  Search::Signals.stopOnPonderhit = true;
+
+  Thread& main = threads[0];
+
+  lock_grab(&main.sleepLock);
+
+  while (!Search::Signals.stop)
+      cond_wait(&main.sleepCond, &main.sleepLock);
+
+  lock_release(&main.sleepLock);
+}

diff --git a/src/timeman.cpp b/src/timeman.cpp
index edbc34e42b5cba142804c62e20f9ec9a7a65f50d..8282f2c629a384f1cbfd9fe21f937ad05605fc16 100644 (file)
--- a/src/timeman.cpp
+++ b/src/timeman.cpp
@@ -84,7 +84,7 @@ void TimeManager::pv_instability(int curChanges, int prevChanges) {
 }
 
 
-void TimeManager::init(const SearchLimits& limits, int currentPly)
+void TimeManager::init(const Search::LimitsType& limits, int currentPly)
 {
   /* We support four different kind of time controls:
 

diff --git a/src/timeman.h b/src/timeman.h
index bf489b7f9fbc662771ceceeabad53105f28050ff..703dc234b7cf630fdbe3bce62aae8a066377bd6b 100644 (file)
--- a/src/timeman.h
+++ b/src/timeman.h
@@ -25,7 +25,7 @@ struct SearchLimits;
 class TimeManager {
 public:
 
-  void init(const SearchLimits& limits, int currentPly);
+  void init(const Search::LimitsType& limits, int currentPly);
   void pv_instability(int curChanges, int prevChanges);
   int available_time() const { return optimumSearchTime + unstablePVExtraTime; }
   int maximum_time() const { return maximumSearchTime; }

diff --git a/src/uci.cpp b/src/uci.cpp
index ebb74d439f0bb3d852db7f45e488af8575e5e4cf..8127a742c8ea4907fa41dbf1c5eb295aae651ca4 100644 (file)
--- a/src/uci.cpp
+++ b/src/uci.cpp
@@ -67,14 +67,27 @@ void uci_loop() {
 
       is >> skipws >> token;
 
-      quit = (token == "quit");
-
-      if (token == "quit" || token == "stop" || token == "ponderhit")
+      if (cmd == "quit" || cmd == "stop")
       {
-          uci_async_command(token);
+          quit = (token == "quit");
+          Search::Signals.stop = true;
           Threads[0].wake_up(); // In case is waiting for stop or ponderhit
       }
 
+      else if (cmd == "ponderhit")
+      {
+          // The opponent has played the expected move. GUI sends "ponderhit" if
+          // we were told to ponder on the same move the opponent has played. We
+          // should continue searching but switching from pondering to normal search.
+          Search::Limits.ponder = false; // FIXME racing
+
+          if (Search::Signals.stopOnPonderhit)
+          {
+              Search::Signals.stop = true;
+              Threads[0].wake_up(); // In case is waiting for stop or ponderhit
+          }
+      }
+
       else if (token == "go")
           go(pos, is);
 
@@ -195,16 +208,16 @@ namespace {
     string token;
     int time[] = { 0, 0 }, inc[] = { 0, 0 };
 
-    memset(&Limits, 0, sizeof(SearchLimits));
-    SearchMoves.clear();
-    RootPosition = &pos;
+    memset(&Search::Limits, 0, sizeof(Search::Limits));
+    Search::RootMoves.clear();
+    Search::RootPosition = &pos;
 
     while (is >> token)
     {
         if (token == "infinite")
-            Limits.infinite = true;
+            Search::Limits.infinite = true;
         else if (token == "ponder")
-            Limits.ponder = true;
+            Search::Limits.ponder = true;
         else if (token == "wtime")
             is >> time[WHITE];
         else if (token == "btime")
@@ -214,21 +227,21 @@ namespace {
         else if (token == "binc")
             is >> inc[BLACK];
         else if (token == "movestogo")
-            is >> Limits.movesToGo;
+            is >> Search::Limits.movesToGo;
         else if (token == "depth")
-            is >> Limits.maxDepth;
+            is >> Search::Limits.maxDepth;
         else if (token == "nodes")
-            is >> Limits.maxNodes;
+            is >> Search::Limits.maxNodes;
         else if (token == "movetime")
-            is >> Limits.maxTime;
+            is >> Search::Limits.maxTime;
         else if (token == "searchmoves")
             while (is >> token)
-                SearchMoves.push_back(move_from_uci(pos, token));
+                Search::RootMoves.push_back(move_from_uci(pos, token));
     }
 
-    SearchMoves.push_back(MOVE_NONE);
-    Limits.time = time[pos.side_to_move()];
-    Limits.increment = inc[pos.side_to_move()];
+    Search::RootMoves.push_back(MOVE_NONE);
+    Search::Limits.time = time[pos.side_to_move()];
+    Search::Limits.increment = inc[pos.side_to_move()];
 
     Threads.start_thinking();
   }
@@ -248,7 +261,7 @@ namespace {
 
     time = get_system_time();
 
-    n = perft(pos, depth * ONE_PLY);
+    n = Search::perft(pos, depth * ONE_PLY);
 
     time = get_system_time() - time;