Small touches to book.cpp

[stockfish] / src / search.cpp

diff --git a/src/search.cpp b/src/search.cpp
index 0f2373cd28fd28838c1e79990c5d26349ae554a2..eea091d4bcf33d0b9f789a493ff8200d77c9e808 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -270,7 +270,7 @@ namespace {
     if (moveIsCheck && pos.see_sign(m) >= 0)
         result += CheckExtension[PvNode];
 
-    if (piece_type(pos.piece_on(move_from(m))) == PAWN)
+    if (type_of(pos.piece_on(move_from(m))) == PAWN)
     {
         Color c = pos.side_to_move();
         if (relative_rank(c, move_to(m)) == RANK_7)
@@ -286,7 +286,7 @@ namespace {
     }
 
     if (   captureOrPromotion
-        && piece_type(pos.piece_on(move_to(m))) != PAWN
+        && type_of(pos.piece_on(move_to(m))) != PAWN
         && (  pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK)
             - piece_value_midgame(pos.piece_on(move_to(m))) == VALUE_ZERO)
         && !move_is_special(m))
@@ -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;
@@ -391,7 +391,7 @@ bool think(Position& pos, const SearchLimits& limits, Move searchMoves[]) {
       if (Options["Book File"].value<string>() != book.name())
           book.open(Options["Book File"].value<string>());
 
-      Move bookMove = book.get_move(pos, Options["Best Book Move"].value<bool>());
+      Move bookMove = book.probe(pos, Options["Best Book Move"].value<bool>());
       if (bookMove != MOVE_NONE)
       {
           if (Limits.ponder)
@@ -534,10 +534,8 @@ namespace {
 
         Rml.bestMoveChanges = 0;
 
-        // 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++)
+        // MultiPV iteration loop
+        for (MultiPVIteration = 0; MultiPVIteration < Min(MultiPV, (int)Rml.size()); MultiPVIteration++)
         {
             // Calculate dynamic aspiration window based on previous iterations
             if (depth >= 5 && abs(Rml[MultiPVIteration].prevScore) < VALUE_KNOWN_WIN)
@@ -780,8 +778,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
@@ -1002,7 +1010,8 @@ split_point_start: // At split points actual search starts from here
                    << " currmovenumber " << moveCount + MultiPVIteration << endl;
       }
 
-      isPvMove = (PvNode && moveCount == 1);
+      // 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));
       givesCheck = pos.move_gives_check(move, ci);
       captureOrPromotion = pos.move_is_capture_or_promotion(move);
 
@@ -1484,7 +1493,7 @@ split_point_start: // At split points actual search starts from here
 
     from = move_from(move);
     to = move_to(move);
-    them = opposite_color(pos.side_to_move());
+    them = flip(pos.side_to_move());
     ksq = pos.king_square(them);
     kingAtt = pos.attacks_from<KING>(ksq);
     pc = pos.piece_on(from);
@@ -1500,7 +1509,7 @@ split_point_start: // At split points actual search starts from here
         return true;
 
     // Rule 2. Queen contact check is very dangerous
-    if (   piece_type(pc) == QUEEN
+    if (   type_of(pc) == QUEEN
         && bit_is_set(kingAtt, to))
         return true;
 
@@ -1539,8 +1548,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);
@@ -1616,7 +1625,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));
 
@@ -1635,7 +1644,7 @@ split_point_start: // At split points actual search starts from here
     // value of the threatening piece, don't prune moves which defend it.
     if (   pos.move_is_capture(threat)
         && (   piece_value_midgame(pos.piece_on(tfrom)) >= piece_value_midgame(pos.piece_on(tto))
-            || piece_type(pos.piece_on(tfrom)) == KING)
+            || type_of(pos.piece_on(tfrom)) == KING)
         && pos.move_attacks_square(m, tto))
         return true;
 
@@ -2158,17 +2167,16 @@ void Thread::idle_loop(SplitPoint* sp) {
       {
           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))
           {