Add comments to uncommented parts of code

https://github.com/official-stockfish/Stockfish/pull/3250

No functional change

diff --git a/src/evaluate.cpp b/src/evaluate.cpp
index a1b04316e79b52f3ffb474596948ef1617123cf2..ef33adf5d774a56fb306a6333c4774fd3fd11daa 100644 (file)
--- a/src/evaluate.cpp
+++ b/src/evaluate.cpp
@@ -844,6 +844,8 @@ namespace {
     behind |= shift<Down>(behind);
     behind |= shift<Down+Down>(behind);
 
     behind |= shift<Down>(behind);
     behind |= shift<Down+Down>(behind);
 

+    // Compute space score based on the number of safe squares and number of our pieces
+    // increased with number of total blocked pawns in position.

     int bonus = popcount(safe) + popcount(behind & safe & ~attackedBy[Them][ALL_PIECES]);
     int weight = pos.count<ALL_PIECES>(Us) - 3 + std::min(pe->blocked_count(), 9);
     Score score = make_score(bonus * weight * weight / 16, 0);
     int bonus = popcount(safe) + popcount(behind & safe & ~attackedBy[Them][ALL_PIECES]);
     int weight = pos.count<ALL_PIECES>(Us) - 3 + std::min(pe->blocked_count(), 9);
     Score score = make_score(bonus * weight * weight / 16, 0);


@@ -905,24 +907,36 @@ namespace {
     {
         if (pos.opposite_bishops())
         {
     {
         if (pos.opposite_bishops())
         {

+            // For pure opposite colored bishops endgames use scale factor
+            // based on the number of passed pawns of the strong side.

             if (   pos.non_pawn_material(WHITE) == BishopValueMg
                 && pos.non_pawn_material(BLACK) == BishopValueMg)
                 sf = 18 + 4 * popcount(pe->passed_pawns(strongSide));
             if (   pos.non_pawn_material(WHITE) == BishopValueMg
                 && pos.non_pawn_material(BLACK) == BishopValueMg)
                 sf = 18 + 4 * popcount(pe->passed_pawns(strongSide));

+            // For every other opposite colored bishops endgames use scale factor
+            // based on the number of all pieces of the strong side.

             else
                 sf = 22 + 3 * pos.count<ALL_PIECES>(strongSide);
         }
             else
                 sf = 22 + 3 * pos.count<ALL_PIECES>(strongSide);
         }

+        // For rook endgames with strong side not having overwhelming pawn number advantage
+        // and its pawns being on one flank and weak side protecting its pieces with a king
+        // use lower scale factor.

         else if (  pos.non_pawn_material(WHITE) == RookValueMg
                 && pos.non_pawn_material(BLACK) == RookValueMg
                 && pos.count<PAWN>(strongSide) - pos.count<PAWN>(~strongSide) <= 1
                 && bool(KingSide & pos.pieces(strongSide, PAWN)) != bool(QueenSide & pos.pieces(strongSide, PAWN))
                 && (attacks_bb<KING>(pos.square<KING>(~strongSide)) & pos.pieces(~strongSide, PAWN)))
             sf = 36;
         else if (  pos.non_pawn_material(WHITE) == RookValueMg
                 && pos.non_pawn_material(BLACK) == RookValueMg
                 && pos.count<PAWN>(strongSide) - pos.count<PAWN>(~strongSide) <= 1
                 && bool(KingSide & pos.pieces(strongSide, PAWN)) != bool(QueenSide & pos.pieces(strongSide, PAWN))
                 && (attacks_bb<KING>(pos.square<KING>(~strongSide)) & pos.pieces(~strongSide, PAWN)))
             sf = 36;

+        // For queen vs no queen endgames use scale factor
+        // based on number of minors of side that doesn't have queen.

         else if (pos.count<QUEEN>() == 1)
             sf = 37 + 3 * (pos.count<QUEEN>(WHITE) == 1 ? pos.count<BISHOP>(BLACK) + pos.count<KNIGHT>(BLACK)
                                                         : pos.count<BISHOP>(WHITE) + pos.count<KNIGHT>(WHITE));
         else if (pos.count<QUEEN>() == 1)
             sf = 37 + 3 * (pos.count<QUEEN>(WHITE) == 1 ? pos.count<BISHOP>(BLACK) + pos.count<KNIGHT>(BLACK)
                                                         : pos.count<BISHOP>(WHITE) + pos.count<KNIGHT>(WHITE));

+        // In every other case use scale factor based on
+        // the number of pawns of the strong side reduced if pawns are on a single flank.

         else
             sf = std::min(sf, 36 + 7 * pos.count<PAWN>(strongSide)) - 4 * !pawnsOnBothFlanks;
 
         else
             sf = std::min(sf, 36 + 7 * pos.count<PAWN>(strongSide)) - 4 * !pawnsOnBothFlanks;
 

+        // Reduce scale factor in case of pawns being on a single flank

         sf -= 4 * !pawnsOnBothFlanks;
     }
 
         sf -= 4 * !pawnsOnBothFlanks;
     }
 


@@ -1046,6 +1060,8 @@ Value Eval::evaluate(const Position& pos) {
       bool  largePsq = psq * 16 > (NNUEThreshold1 + pos.non_pawn_material() / 64) * r50;
       bool  classical = largePsq || (psq > PawnValueMg / 4 && !(pos.this_thread()->nodes & 0xB));
 
       bool  largePsq = psq * 16 > (NNUEThreshold1 + pos.non_pawn_material() / 64) * r50;
       bool  classical = largePsq || (psq > PawnValueMg / 4 && !(pos.this_thread()->nodes & 0xB));
 

+      // Use classical evaluation for really low piece endgames.
+      // The most critical case is a bishop + A/H file pawn vs naked king draw.

       bool strongClassical = pos.non_pawn_material() < 2 * RookValueMg && pos.count<PAWN>() < 2;
 
       v = classical || strongClassical ? Evaluation<NO_TRACE>(pos).value() : adjusted_NNUE();
       bool strongClassical = pos.non_pawn_material() < 2 * RookValueMg && pos.count<PAWN>() < 2;
 
       v = classical || strongClassical ? Evaluation<NO_TRACE>(pos).value() : adjusted_NNUE();

diff --git a/src/search.cpp b/src/search.cpp
index ab559696ebebfa5525eec84a8063a9ac995ae60e..ba9265ddb38c39a5192bdb84d654e80c88b6c963 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -676,6 +676,7 @@ namespace {
         ss->ttPv = PvNode || (ss->ttHit && tte->is_pv());
     formerPv = ss->ttPv && !PvNode;
 
         ss->ttPv = PvNode || (ss->ttHit && tte->is_pv());
     formerPv = ss->ttPv && !PvNode;
 

+    // Update low ply history for previous move if we are near root and position is or has been in PV

     if (   ss->ttPv
         && depth > 12
         && ss->ply - 1 < MAX_LPH
     if (   ss->ttPv
         && depth > 12
         && ss->ply - 1 < MAX_LPH


@@ -700,6 +701,7 @@ namespace {
         {
             if (ttValue >= beta)
             {
         {
             if (ttValue >= beta)
             {

+                // Bonus for a quiet ttMove that fails high

                 if (!pos.capture_or_promotion(ttMove))
                     update_quiet_stats(pos, ss, ttMove, stat_bonus(depth), depth);
 
                 if (!pos.capture_or_promotion(ttMove))
                     update_quiet_stats(pos, ss, ttMove, stat_bonus(depth), depth);
 


@@ -716,6 +718,8 @@ namespace {
             }
         }
 
             }
         }
 

+        // Partial workaround for the graph history interaction problem
+        // For high rule50 counts don't produce transposition table cutoffs.

         if (pos.rule50_count() < 90)
             return ttValue;
     }
         if (pos.rule50_count() < 90)
             return ttValue;
     }


@@ -789,6 +793,7 @@ namespace {
         if (eval == VALUE_NONE)
             ss->staticEval = eval = evaluate(pos);
 
         if (eval == VALUE_NONE)
             ss->staticEval = eval = evaluate(pos);
 

+        // Randomize draw evaluation

         if (eval == VALUE_DRAW)
             eval = value_draw(thisThread);
 
         if (eval == VALUE_DRAW)
             eval = value_draw(thisThread);
 


@@ -799,11 +804,14 @@ namespace {
     }
     else
     {
     }
     else
     {

+        // In case of null move search use previous static eval with a different sign
+        // and addition of two tempos

         if ((ss-1)->currentMove != MOVE_NULL)
             ss->staticEval = eval = evaluate(pos);
         else
             ss->staticEval = eval = -(ss-1)->staticEval + 2 * Tempo;
 
         if ((ss-1)->currentMove != MOVE_NULL)
             ss->staticEval = eval = evaluate(pos);
         else
             ss->staticEval = eval = -(ss-1)->staticEval + 2 * Tempo;
 

+        // Save static evaluation into transposition table

         tte->save(posKey, VALUE_NONE, ss->ttPv, BOUND_NONE, DEPTH_NONE, MOVE_NONE, eval);
     }
 
         tte->save(posKey, VALUE_NONE, ss->ttPv, BOUND_NONE, DEPTH_NONE, MOVE_NONE, eval);
     }
 


@@ -822,6 +830,10 @@ namespace {
         &&  eval <= alpha - RazorMargin)
         return qsearch<NT>(pos, ss, alpha, beta);
 
         &&  eval <= alpha - RazorMargin)
         return qsearch<NT>(pos, ss, alpha, beta);
 

+    // Set up improving flag that is used in various pruning heuristics
+    // We define position as improving if static evaluation of position is better
+    // Than the previous static evaluation at our turn
+    // In case of us being in check at our previous move we look at move prior to it

     improving =  (ss-2)->staticEval == VALUE_NONE
                ? ss->staticEval > (ss-4)->staticEval || (ss-4)->staticEval == VALUE_NONE
                : ss->staticEval > (ss-2)->staticEval;
     improving =  (ss-2)->staticEval == VALUE_NONE
                ? ss->staticEval > (ss-4)->staticEval || (ss-4)->staticEval == VALUE_NONE
                : ss->staticEval > (ss-2)->staticEval;


@@ -1183,6 +1195,7 @@ moves_loop: // When in check, search starts from here
           if ((rootNode || !PvNode) && depth > 10 && thisThread->bestMoveChanges <= 2)
               r++;
 
           if ((rootNode || !PvNode) && depth > 10 && thisThread->bestMoveChanges <= 2)
               r++;
 

+          // More reductions for late moves if position was not in previous PV

           if (moveCountPruning && !formerPv)
               r++;
 
           if (moveCountPruning && !formerPv)
               r++;
 


@@ -1258,6 +1271,7 @@ moves_loop: // When in check, search starts from here
       {
           value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth, !cutNode);
 
       {
           value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth, !cutNode);
 

+          // If the move passed LMR update its stats

           if (didLMR && !captureOrPromotion)
           {
               int bonus = value > alpha ?  stat_bonus(newDepth)
           if (didLMR && !captureOrPromotion)
           {
               int bonus = value > alpha ?  stat_bonus(newDepth)


@@ -1309,8 +1323,7 @@ moves_loop: // When in check, search starts from here
                   rm.pv.push_back(*m);
 
               // We record how often the best move has been changed in each
                   rm.pv.push_back(*m);
 
               // We record how often the best move has been changed in each

-              // iteration. This information is used for time management: when
-              // the best move changes frequently, we allocate some more time.
+              // iteration. This information is used for time management and LMR

               if (moveCount > 1)
                   ++thisThread->bestMoveChanges;
           }
               if (moveCount > 1)
                   ++thisThread->bestMoveChanges;
           }


@@ -1343,6 +1356,7 @@ moves_loop: // When in check, search starts from here
           }
       }
 
           }
       }
 

+      // If the move is worse than some previously searched move, remember it to update its stats later

       if (move != bestMove)
       {
           if (captureOrPromotion && captureCount < 32)
       if (move != bestMove)
       {
           if (captureOrPromotion && captureCount < 32)


@@ -1372,6 +1386,7 @@ moves_loop: // When in check, search starts from here
         bestValue = excludedMove ? alpha
                    :     ss->inCheck ? mated_in(ss->ply) : VALUE_DRAW;
 
         bestValue = excludedMove ? alpha
                    :     ss->inCheck ? mated_in(ss->ply) : VALUE_DRAW;
 

+    // If there is a move which produces search value greater than alpha we update stats of searched moves

     else if (bestMove)
         update_all_stats(pos, ss, bestMove, bestValue, beta, prevSq,
                          quietsSearched, quietCount, capturesSearched, captureCount, depth);
     else if (bestMove)
         update_all_stats(pos, ss, bestMove, bestValue, beta, prevSq,
                          quietsSearched, quietCount, capturesSearched, captureCount, depth);


@@ -1393,6 +1408,7 @@ moves_loop: // When in check, search starts from here
     else if (depth > 3)
         ss->ttPv = ss->ttPv && (ss+1)->ttPv;
 
     else if (depth > 3)
         ss->ttPv = ss->ttPv && (ss+1)->ttPv;
 

+    // Write gathered information in transposition table

     if (!excludedMove && !(rootNode && thisThread->pvIdx))
         tte->save(posKey, value_to_tt(bestValue, ss->ply), ss->ttPv,
                   bestValue >= beta ? BOUND_LOWER :
     if (!excludedMove && !(rootNode && thisThread->pvIdx))
         tte->save(posKey, value_to_tt(bestValue, ss->ply), ss->ttPv,
                   bestValue >= beta ? BOUND_LOWER :


@@ -1488,6 +1504,8 @@ moves_loop: // When in check, search starts from here
                 bestValue = ttValue;
         }
         else
                 bestValue = ttValue;
         }
         else

+            // In case of null move search use previous static eval with a different sign
+            // and addition of two tempos

             ss->staticEval = bestValue =
             (ss-1)->currentMove != MOVE_NULL ? evaluate(pos)
                                              : -(ss-1)->staticEval + 2 * Tempo;
             ss->staticEval = bestValue =
             (ss-1)->currentMove != MOVE_NULL ? evaluate(pos)
                                              : -(ss-1)->staticEval + 2 * Tempo;


@@ -1495,6 +1513,7 @@ moves_loop: // When in check, search starts from here
         // Stand pat. Return immediately if static value is at least beta
         if (bestValue >= beta)
         {
         // Stand pat. Return immediately if static value is at least beta
         if (bestValue >= beta)
         {

+            // Save gathered info in transposition table

             if (!ss->ttHit)
                 tte->save(posKey, value_to_tt(bestValue, ss->ply), false, BOUND_LOWER,
                           DEPTH_NONE, MOVE_NONE, ss->staticEval);
             if (!ss->ttHit)
                 tte->save(posKey, value_to_tt(bestValue, ss->ply), false, BOUND_LOWER,
                           DEPTH_NONE, MOVE_NONE, ss->staticEval);


@@ -1623,6 +1642,7 @@ moves_loop: // When in check, search starts from here
         return mated_in(ss->ply); // Plies to mate from the root
     }
 
         return mated_in(ss->ply); // Plies to mate from the root
     }
 

+    // Save gathered info in transposition table

     tte->save(posKey, value_to_tt(bestValue, ss->ply), pvHit,
               bestValue >= beta ? BOUND_LOWER :
               PvNode && bestValue > oldAlpha  ? BOUND_EXACT : BOUND_UPPER,
     tte->save(posKey, value_to_tt(bestValue, ss->ply), pvHit,
               bestValue >= beta ? BOUND_LOWER :
               PvNode && bestValue > oldAlpha  ? BOUND_EXACT : BOUND_UPPER,


@@ -1706,9 +1726,10 @@ moves_loop: // When in check, search starts from here
 
     if (!pos.capture_or_promotion(bestMove))
     {
 
     if (!pos.capture_or_promotion(bestMove))
     {

+        // Increase stats for the best move in case it was a quiet move

         update_quiet_stats(pos, ss, bestMove, bonus2, depth);
 
         update_quiet_stats(pos, ss, bestMove, bonus2, depth);
 

-        // Decrease all the non-best quiet moves
+        // Decrease stats for all non-best quiet moves

         for (int i = 0; i < quietCount; ++i)
         {
             thisThread->mainHistory[us][from_to(quietsSearched[i])] << -bonus2;
         for (int i = 0; i < quietCount; ++i)
         {
             thisThread->mainHistory[us][from_to(quietsSearched[i])] << -bonus2;


@@ -1716,14 +1737,16 @@ moves_loop: // When in check, search starts from here
         }
     }
     else
         }
     }
     else

+        // Increase stats for the best move in case it was a capture move

         captureHistory[moved_piece][to_sq(bestMove)][captured] << bonus1;
 
         captureHistory[moved_piece][to_sq(bestMove)][captured] << bonus1;
 

-    // Extra penalty for a quiet early move that was not a TT move or main killer move in previous ply when it gets refuted
+    // Extra penalty for a quiet early move that was not a TT move or
+    // main killer move in previous ply when it gets refuted.

     if (   ((ss-1)->moveCount == 1 + (ss-1)->ttHit || ((ss-1)->currentMove == (ss-1)->killers[0]))
         && !pos.captured_piece())
             update_continuation_histories(ss-1, pos.piece_on(prevSq), prevSq, -bonus1);
 
     if (   ((ss-1)->moveCount == 1 + (ss-1)->ttHit || ((ss-1)->currentMove == (ss-1)->killers[0]))
         && !pos.captured_piece())
             update_continuation_histories(ss-1, pos.piece_on(prevSq), prevSq, -bonus1);
 

-    // Decrease all the non-best capture moves
+    // Decrease stats for all non-best capture moves

     for (int i = 0; i < captureCount; ++i)
     {
         moved_piece = pos.moved_piece(capturesSearched[i]);
     for (int i = 0; i < captureCount; ++i)
     {
         moved_piece = pos.moved_piece(capturesSearched[i]);


@@ -1740,6 +1763,7 @@ moves_loop: // When in check, search starts from here
 
     for (int i : {1, 2, 4, 6})
     {
 
     for (int i : {1, 2, 4, 6})
     {

+        // Only update first 2 continuation histories if we are in check

         if (ss->inCheck && i > 2)
             break;
         if (is_ok((ss-i)->currentMove))
         if (ss->inCheck && i > 2)
             break;
         if (is_ok((ss-i)->currentMove))


@@ -1752,6 +1776,7 @@ moves_loop: // When in check, search starts from here
 
   void update_quiet_stats(const Position& pos, Stack* ss, Move move, int bonus, int depth) {
 
 
   void update_quiet_stats(const Position& pos, Stack* ss, Move move, int bonus, int depth) {
 

+    // Update killers

     if (ss->killers[0] != move)
     {
         ss->killers[1] = ss->killers[0];
     if (ss->killers[0] != move)
     {
         ss->killers[1] = ss->killers[0];


@@ -1763,15 +1788,18 @@ moves_loop: // When in check, search starts from here
     thisThread->mainHistory[us][from_to(move)] << bonus;
     update_continuation_histories(ss, pos.moved_piece(move), to_sq(move), bonus);
 
     thisThread->mainHistory[us][from_to(move)] << bonus;
     update_continuation_histories(ss, pos.moved_piece(move), to_sq(move), bonus);
 

+    // Penalty for reversed move in case of moved piece not being a pawn

     if (type_of(pos.moved_piece(move)) != PAWN)
         thisThread->mainHistory[us][from_to(reverse_move(move))] << -bonus;
 
     if (type_of(pos.moved_piece(move)) != PAWN)
         thisThread->mainHistory[us][from_to(reverse_move(move))] << -bonus;
 

+    // Update countermove history

     if (is_ok((ss-1)->currentMove))
     {
         Square prevSq = to_sq((ss-1)->currentMove);
         thisThread->counterMoves[pos.piece_on(prevSq)][prevSq] = move;
     }
 
     if (is_ok((ss-1)->currentMove))
     {
         Square prevSq = to_sq((ss-1)->currentMove);
         thisThread->counterMoves[pos.piece_on(prevSq)][prevSq] = move;
     }
 

+    // Update low ply history

     if (depth > 11 && ss->ply < MAX_LPH)
         thisThread->lowPlyHistory[ss->ply][from_to(move)] << stat_bonus(depth - 7);
   }
     if (depth > 11 && ss->ply < MAX_LPH)
         thisThread->lowPlyHistory[ss->ply][from_to(move)] << stat_bonus(depth - 7);
   }