Change advanced pawn push threshold

[stockfish] / src / search.cpp

diff --git a/src/search.cpp b/src/search.cpp
index c33bc9143920324d229dd34ae050072d1079a963..fa592a859947e09e1f30fcefb8bd276ccccec16f 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -35,6 +35,8 @@
 #include "uci.h"
 #include "syzygy/tbprobe.h"
 
 #include "uci.h"
 #include "syzygy/tbprobe.h"
 

+namespace Stockfish {
+

 namespace Search {
 
   LimitsType Limits;
 namespace Search {
 
   LimitsType Limits;


@@ -422,7 +424,7 @@ void Thread::search() {
           while (true)
           {
               Depth adjustedDepth = std::max(1, rootDepth - failedHighCnt - searchAgainCounter);
           while (true)
           {
               Depth adjustedDepth = std::max(1, rootDepth - failedHighCnt - searchAgainCounter);

-              bestValue = ::search<PV>(rootPos, ss, alpha, beta, adjustedDepth, false);
+              bestValue = Stockfish::search<PV>(rootPos, ss, alpha, beta, adjustedDepth, false);

 
               // Bring the best move to the front. It is critical that sorting
               // is done with a stable algorithm because all the values but the
 
               // Bring the best move to the front. It is critical that sorting
               // is done with a stable algorithm because all the values but the


@@ -616,6 +618,7 @@ namespace {
     moveCount = captureCount = quietCount = ss->moveCount = 0;
     bestValue = -VALUE_INFINITE;
     maxValue = VALUE_INFINITE;
     moveCount = captureCount = quietCount = ss->moveCount = 0;
     bestValue = -VALUE_INFINITE;
     maxValue = VALUE_INFINITE;

+    ss->distanceFromPv = (PvNode ? 0 : ss->distanceFromPv);

 
     // Check for the available remaining time
     if (thisThread == Threads.main())
 
     // Check for the available remaining time
     if (thisThread == Threads.main())


@@ -1175,8 +1178,12 @@ moves_loop: // When in check, search starts from here
       // Step 15. Make the move
       pos.do_move(move, st, givesCheck);
 
       // Step 15. Make the move
       pos.do_move(move, st, givesCheck);
 

-      // Step 16. Reduced depth search (LMR, ~200 Elo). If the move fails high it will be
-      // re-searched at full depth.
+      (ss+1)->distanceFromPv = ss->distanceFromPv + moveCount - 1;
+
+      // Step 16. Late moves reduction / extension (LMR, ~200 Elo)
+      // We use various heuristics for the sons of a node after the first son has
+      // been searched. In general we would like to reduce them, but there are many
+      // cases where we extend a son if it has good chances to be "interesting".

       if (    depth >= 3
           &&  moveCount > 1 + 2 * rootNode
           && (  !captureOrPromotion
       if (    depth >= 3
           &&  moveCount > 1 + 2 * rootNode
           && (  !captureOrPromotion


@@ -1258,8 +1265,8 @@ moves_loop: // When in check, search starts from here
                   r++;
 
               // Decrease/increase reduction for moves with a good/bad history (~30 Elo)
                   r++;
 
               // Decrease/increase reduction for moves with a good/bad history (~30 Elo)

-              // If we are not in check use statScore, if we are in check
-              // use sum of main history and first continuation history with an offset
+              // If we are not in check use statScore, but if we are in check we use
+              // the sum of main history and first continuation history with an offset.

               if (ss->inCheck)
                   r -= (thisThread->mainHistory[us][from_to(move)]
                      + (*contHist[0])[movedPiece][to_sq(move)] - 3833) / 16384;
               if (ss->inCheck)
                   r -= (thisThread->mainHistory[us][from_to(move)]
                      + (*contHist[0])[movedPiece][to_sq(move)] - 3833) / 16384;


@@ -1267,18 +1274,20 @@ moves_loop: // When in check, search starts from here
                   r -= ss->statScore / 14790;
           }
 
                   r -= ss->statScore / 14790;
           }
 

-          Depth d = std::clamp(newDepth - r, 1, newDepth);
+          // In general we want to cap the LMR depth search at newDepth. But for nodes
+          // close to the principal variation the cap is at (newDepth + 1), which will
+          // allow these nodes to be searched deeper than the pv (up to 4 plies deeper).
+          Depth d = std::clamp(newDepth - r, 1, newDepth + ((ss+1)->distanceFromPv <= 4));

 
           value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, d, true);
 
 
           value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, d, true);
 

-          doFullDepthSearch = value > alpha && d != newDepth;
-
+          // If the son is reduced and fails high it will be re-searched at full depth
+          doFullDepthSearch = value > alpha && d < newDepth;

           didLMR = true;
       }
       else
       {
           doFullDepthSearch = !PvNode || moveCount > 1;
           didLMR = true;
       }
       else
       {
           doFullDepthSearch = !PvNode || moveCount > 1;

-

           didLMR = false;
       }
 
           didLMR = false;
       }
 


@@ -1566,15 +1575,13 @@ moves_loop: // When in check, search starts from here
 
       moveCount++;
 
 
       moveCount++;
 

-      // Futility pruning
+      // Futility pruning and moveCount pruning

       if (    bestValue > VALUE_TB_LOSS_IN_MAX_PLY
           && !givesCheck
           &&  futilityBase > -VALUE_KNOWN_WIN
           && !pos.advanced_pawn_push(move))
       {
       if (    bestValue > VALUE_TB_LOSS_IN_MAX_PLY
           && !givesCheck
           &&  futilityBase > -VALUE_KNOWN_WIN
           && !pos.advanced_pawn_push(move))
       {

-          assert(type_of(move) != EN_PASSANT); // Due to !pos.advanced_pawn_push

 
 

-          // moveCount pruning

           if (moveCount > 2)
               continue;
 
           if (moveCount > 2)
               continue;
 


@@ -2027,3 +2034,5 @@ void Tablebases::rank_root_moves(Position& pos, Search::RootMoves& rootMoves) {
             m.tbRank = 0;
     }
 }
             m.tbRank = 0;
     }
 }

+
+} // namespace Stockfish