Document why Book is defined static

[stockfish] / src / search.cpp

diff --git a/src/search.cpp b/src/search.cpp
index 4cce6a9171de9139d8e51e717d966af819912492..1f848183481a573cf59710f2993a1c4fb890a1f2 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -363,7 +363,7 @@ int64_t perft(Position& pos, Depth depth) {
 
 bool think(Position& pos, const SearchLimits& limits, Move searchMoves[]) {
 
-  static Book book;
+  static Book book; // Define static to initialize the PRNG only once
 
   // Initialize global search-related variables
   StopOnPonderhit = StopRequest = QuitRequest = AspirationFailLow = false;
@@ -534,8 +534,10 @@ namespace {
 
         Rml.bestMoveChanges = 0;
 
-        // MultiPV iteration loop
-        for (MultiPVIteration = 0; MultiPVIteration < Min(MultiPV, (int)Rml.size()); MultiPVIteration++)
+        // MultiPV iteration loop. At depth 1 perform at least 2 iterations to
+        // get a score of the second best move for easy move detection.
+        int e = Min(Max(MultiPV, 2 * int(depth == 1)), (int)Rml.size());
+        for (MultiPVIteration = 0; MultiPVIteration < e; MultiPVIteration++)
         {
             // Calculate dynamic aspiration window based on previous iterations
             if (depth >= 5 && abs(Rml[MultiPVIteration].prevScore) < VALUE_KNOWN_WIN)
@@ -778,8 +780,18 @@ namespace {
                                     : can_return_tt(tte, depth, beta, ss->ply)))
     {
         TT.refresh(tte);
-        ss->bestMove = ttMove; // Can be MOVE_NONE
-        return value_from_tt(tte->value(), ss->ply);
+        ss->bestMove = move = ttMove; // Can be MOVE_NONE
+        value = value_from_tt(tte->value(), ss->ply);
+
+        if (   value >= beta
+            && move
+            && !pos.move_is_capture_or_promotion(move)
+            && move != ss->killers[0])
+        {
+            ss->killers[1] = ss->killers[0];
+            ss->killers[0] = move;
+        }
+        return value;
     }
 
     // Step 5. Evaluate the position statically and update parent's gain statistics
@@ -1000,8 +1012,7 @@ split_point_start: // At split points actual search starts from here
                    << " currmovenumber " << moveCount + MultiPVIteration << endl;
       }
 
-      // At Root and at first iteration do a PV search on all the moves to score root moves
-      isPvMove = (PvNode && moveCount <= (RootNode && depth <= ONE_PLY ? MAX_MOVES : 1));
+      isPvMove = (PvNode && moveCount == 1);
       givesCheck = pos.move_gives_check(move, ci);
       captureOrPromotion = pos.move_is_capture_or_promotion(move);
 
@@ -1538,8 +1549,8 @@ split_point_start: // At split points actual search starts from here
     Piece p1, p2;
     Square ksq;
 
-    assert(m1 && move_is_ok(m1));
-    assert(m2 && move_is_ok(m2));
+    assert(move_is_ok(m1));
+    assert(move_is_ok(m2));
 
     // Case 1: The moving piece is the same in both moves
     f2 = move_from(m2);
@@ -1615,7 +1626,7 @@ split_point_start: // At split points actual search starts from here
   bool connected_threat(const Position& pos, Move m, Move threat) {
 
     assert(move_is_ok(m));
-    assert(threat && move_is_ok(threat));
+    assert(move_is_ok(threat));
     assert(!pos.move_is_capture_or_promotion(m));
     assert(!pos.move_is_passed_pawn_push(m));
 
@@ -2128,13 +2139,11 @@ split_point_start: // At split points actual search starts from here
 } // namespace
 
 
-// Little helper used by idle_loop() to check that all the slaves of a
-// master thread have finished searching.
+// Little helper used by idle_loop() to check that all the slave threads of a
+// split point have finished searching.
 
 static bool all_slaves_finished(SplitPoint* sp) {
 
-  assert(sp);
-
   for (int i = 0; i < Threads.size(); i++)
       if (sp->is_slave[i])
           return false;
@@ -2155,21 +2164,20 @@ void Thread::idle_loop(SplitPoint* sp) {
       // instead of wasting CPU time polling for work.
       while (   do_sleep
              || do_terminate
-             || (Threads.use_sleeping_threads() && state == Thread::AVAILABLE))
+             || (Threads.use_sleeping_threads() && !is_searching))
       {
           assert((!sp && threadID) || Threads.use_sleeping_threads());
 
-          // Grab the lock to avoid races with Thread::wake_up()
-          lock_grab(&sleepLock);
-
           // Slave thread should exit as soon as do_terminate flag raises
           if (do_terminate)
           {
               assert(!sp);
-              lock_release(&sleepLock);
               return;
           }
 
+          // Grab the lock to avoid races with Thread::wake_up()
+          lock_grab(&sleepLock);
+
           // If we are master and all slaves have finished don't go to sleep
           if (sp && all_slaves_finished(sp))
           {
@@ -2181,19 +2189,17 @@ void Thread::idle_loop(SplitPoint* sp) {
           // particular we need to avoid a deadlock in case a master thread has,
           // in the meanwhile, allocated us and sent the wake_up() call before we
           // had the chance to grab the lock.
-          if (do_sleep || state == Thread::AVAILABLE)
+          if (do_sleep || !is_searching)
               cond_wait(&sleepCond, &sleepLock);
 
           lock_release(&sleepLock);
       }
 
       // If this thread has been assigned work, launch a search
-      if (state == Thread::WORKISWAITING)
+      if (is_searching)
       {
           assert(!do_terminate);
 
-          state = Thread::SEARCHING;
-
           // Copy split point position and search stack and call search()
           SearchStack ss[PLY_MAX_PLUS_2];
           SplitPoint* tsp = splitPoint;
@@ -2211,15 +2217,15 @@ void Thread::idle_loop(SplitPoint* sp) {
           else
               assert(false);
 
-          assert(state == Thread::SEARCHING);
+          assert(is_searching);
 
-          state = Thread::AVAILABLE;
+          is_searching = false;
 
           // Wake up master thread so to allow it to return from the idle loop in
           // case we are the last slave of the split point.
           if (   Threads.use_sleeping_threads()
               && threadID != tsp->master
-              && Threads[tsp->master].state == Thread::AVAILABLE)
+              && !Threads[tsp->master].is_searching)
               Threads[tsp->master].wake_up();
       }