X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=d54794bbc8712205a066cf977da4f692b3cb4c02;hp=9fc1bd42565e9b90b3800d268279d928c5e1a223;hb=7733dadfd7c8781e3bde3cc4e21751fa44ab6ed8;hpb=427dc2a82c82c69e964a3f7a2030f9417d0beee9

diff --git a/src/search.cpp b/src/search.cpp
index 9fc1bd42..d54794bb 100644
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -52,7 +52,7 @@ using std::endl;
 
 namespace {
 
-  /// Types
+  // Types
   enum NodeType { NonPV, PV };
 
   // Set to true to force running with one thread.
@@ -141,22 +141,21 @@ namespace {
   public:
     RootMoveList(Position& pos, Move searchMoves[]);
 
+    Move move(int moveNum) const { return moves[moveNum].move; }
+    Move move_pv(int moveNum, int i) const { return moves[moveNum].pv[i]; }
     int move_count() const { return count; }
-    Move get_move(int moveNum) const { return moves[moveNum].move; }
-    Value get_move_score(int moveNum) const { return moves[moveNum].score; }
+    Value move_score(int moveNum) const { return moves[moveNum].score; }
+    int64_t move_nodes(int moveNum) const { return moves[moveNum].nodes; }
+    void add_move_nodes(int moveNum, int64_t nodes) { moves[moveNum].nodes += nodes; }
     void set_move_score(int moveNum, Value score) { moves[moveNum].score = score; }
-    Move get_move_pv(int moveNum, int i) const { return moves[moveNum].pv[i]; }
-    int64_t get_move_nodes(int moveNum) const { return moves[moveNum].nodes; }
-    void score_moves(const Position& pos);
 
-    void add_move_nodes(int moveNum, int64_t nodes) { moves[moveNum].nodes += nodes; }
     void set_move_pv(int moveNum, const Move pv[]);
+    void score_moves(const Position& pos);
     void sort();
     void sort_multipv(int n);
 
   private:
-    static const int MaxRootMoves = 500;
-    RootMove moves[MaxRootMoves];
+    RootMove moves[MOVES_MAX];
     int count;
   };
 
@@ -186,12 +185,6 @@ namespace {
   // Dynamic razoring margin based on depth
   inline Value razor_margin(Depth d) { return Value(0x200 + 0x10 * int(d)); }
 
-  // Step 8. Null move search with verification search
-
-  // Null move margin. A null move search will not be done if the static
-  // evaluation of the position is more than NullMoveMargin below beta.
-  const Value NullMoveMargin = Value(0x200);
-
   // Maximum depth for use of dynamic threat detection when null move fails low
   const Depth ThreatDepth = 5 * ONE_PLY;
 
@@ -224,10 +217,10 @@ namespace {
   const Value FutilityMarginQS = Value(0x80);
 
   // Futility lookup tables (initialized at startup) and their getter functions
-  int32_t FutilityMarginsMatrix[16][64]; // [depth][moveNumber]
+  Value FutilityMarginsMatrix[16][64]; // [depth][moveNumber]
   int FutilityMoveCountArray[32]; // [depth]
 
-  inline Value futility_margin(Depth d, int mn) { return Value(d < 7 * ONE_PLY ? FutilityMarginsMatrix[Max(d, 1)][Min(mn, 63)] : 2 * VALUE_INFINITE); }
+  inline Value futility_margin(Depth d, int mn) { return d < 7 * ONE_PLY ? FutilityMarginsMatrix[Max(d, 1)][Min(mn, 63)] : 2 * VALUE_INFINITE; }
   inline int futility_move_count(Depth d) { return d < 16 * ONE_PLY ? FutilityMoveCountArray[d] : 512; }
 
   // Step 14. Reduced search
@@ -366,11 +359,11 @@ void init_search() {
 
   // Init futility margins array
   for (d = 1; d < 16; d++) for (mc = 0; mc < 64; mc++)
-      FutilityMarginsMatrix[d][mc] = 112 * int(log(double(d * d) / 2) / log(2.0) + 1.001) - 8 * mc + 45;
+      FutilityMarginsMatrix[d][mc] = Value(112 * int(log(double(d * d) / 2) / log(2.0) + 1.001) - 8 * mc + 45);
 
   // Init futility move count array
   for (d = 0; d < 32; d++)
-      FutilityMoveCountArray[d] = 3 + (1 << (3 * d / 8));
+      FutilityMoveCountArray[d] = int(3.001 + 0.25 * pow(d, 2.0));
 }
 
 
@@ -379,7 +372,7 @@ void init_search() {
 
 int perft(Position& pos, Depth depth)
 {
-    MoveStack mlist[256];
+    MoveStack mlist[MOVES_MAX];
     StateInfo st;
     Move m;
     int sum = 0;
@@ -551,24 +544,24 @@ namespace {
     cout << set960(p.is_chess960()) // Is enough to set once at the beginning
          << "info depth " << 1
          << "\ninfo depth " << 1
-         << " score " << value_to_uci(rml.get_move_score(0))
+         << " score " << value_to_uci(rml.move_score(0))
          << " time " << current_search_time()
          << " nodes " << ThreadsMgr.nodes_searched()
          << " nps " << nps()
-         << " pv " << rml.get_move(0) << "\n";
+         << " pv " << rml.move(0) << "\n";
 
     // Initialize
     TT.new_search();
     H.clear();
     init_ss_array(ss, PLY_MAX_PLUS_2);
     pv[0] = pv[1] = MOVE_NONE;
-    ValueByIteration[1] = rml.get_move_score(0);
+    ValueByIteration[1] = rml.move_score(0);
     Iteration = 1;
 
     // Is one move significantly better than others after initial scoring ?
     if (   rml.move_count() == 1
-        || rml.get_move_score(0) > rml.get_move_score(1) + EasyMoveMargin)
-        EasyMove = rml.get_move(0);
+        || rml.move_score(0) > rml.move_score(1) + EasyMoveMargin)
+        EasyMove = rml.move(0);
 
     // Iterative deepening loop
     while (Iteration < PLY_MAX)
@@ -629,15 +622,15 @@ namespace {
             int64_t nodes = ThreadsMgr.nodes_searched();
             if (   Iteration >= 8
                 && EasyMove == pv[0]
-                && (  (   rml.get_move_nodes(0) > (nodes * 85) / 100
+                && (  (   rml.move_nodes(0) > (nodes * 85) / 100
                        && current_search_time() > TimeMgr.available_time() / 16)
-                    ||(   rml.get_move_nodes(0) > (nodes * 98) / 100
+                    ||(   rml.move_nodes(0) > (nodes * 98) / 100
                        && current_search_time() > TimeMgr.available_time() / 32)))
                 stopSearch = true;
 
             // Add some extra time if the best move has changed during the last two iterations
             if (Iteration > 5 && Iteration <= 50)
-                TimeMgr.pv_unstability(BestMoveChangesByIteration[Iteration],
+                TimeMgr.pv_instability(BestMoveChangesByIteration[Iteration],
                                        BestMoveChangesByIteration[Iteration-1]);
 
             // Stop search if most of MaxSearchTime is consumed at the end of the
@@ -672,7 +665,7 @@ namespace {
     // Print the best move and the ponder move to the standard output
     if (pv[0] == MOVE_NONE)
     {
-        pv[0] = rml.get_move(0);
+        pv[0] = rml.move(0);
         pv[1] = MOVE_NONE;
     }
 
@@ -703,7 +696,7 @@ namespace {
                 << move_to_san(p, pv[1]) // Works also with MOVE_NONE
                 << endl;
     }
-    return rml.get_move_score(0);
+    return rml.move_score(0);
   }
 
 
@@ -714,13 +707,12 @@ namespace {
 
   Value root_search(Position& pos, SearchStack* ss, Move* pv, RootMoveList& rml, Value* alphaPtr, Value* betaPtr) {
 
-    Value margins[2];
     StateInfo st;
     CheckInfo ci(pos);
     int64_t nodes;
     Move move;
     Depth depth, ext, newDepth;
-    Value value, alpha, beta;
+    Value value, evalMargin, alpha, beta;
     bool isCheck, moveIsCheck, captureOrPromotion, dangerous;
     int researchCountFH, researchCountFL;
 
@@ -739,7 +731,7 @@ namespace {
 
     // Step 5. Evaluate the position statically
     // At root we do this only to get reference value for child nodes
-    ss->eval = isCheck ? VALUE_NONE : evaluate(pos, margins);
+    ss->eval = isCheck ? VALUE_NONE : evaluate(pos, evalMargin);
 
     // Step 6. Razoring (omitted at root)
     // Step 7. Static null move pruning (omitted at root)
@@ -766,7 +758,7 @@ namespace {
 
             // Pick the next root move, and print the move and the move number to
             // the standard output.
-            move = ss->currentMove = rml.get_move(i);
+            move = ss->currentMove = rml.move(i);
 
             if (current_search_time() >= 1000)
                 cout << "info currmove " << move
@@ -922,19 +914,19 @@ namespace {
                     for (int j = 0; j < Min(MultiPV, rml.move_count()); j++)
                     {
                         cout << "info multipv " << j + 1
-                             << " score " << value_to_uci(rml.get_move_score(j))
+                             << " score " << value_to_uci(rml.move_score(j))
                              << " depth " << (j <= i ? Iteration : Iteration - 1)
                              << " time " << current_search_time()
                              << " nodes " << ThreadsMgr.nodes_searched()
                              << " nps " << nps()
                              << " pv ";
 
-                        for (int k = 0; rml.get_move_pv(j, k) != MOVE_NONE && k < PLY_MAX; k++)
-                            cout << rml.get_move_pv(j, k) << " ";
+                        for (int k = 0; rml.move_pv(j, k) != MOVE_NONE && k < PLY_MAX; k++)
+                            cout << rml.move_pv(j, k) << " ";
 
                         cout << endl;
                     }
-                    alpha = rml.get_move_score(Min(i, MultiPV - 1));
+                    alpha = rml.move_score(Min(i, MultiPV - 1));
                 }
             } // PV move or new best move
 
@@ -974,14 +966,13 @@ namespace {
     assert(ply > 0 && ply < PLY_MAX);
     assert(pos.thread() >= 0 && pos.thread() < ThreadsMgr.active_threads());
 
-    Move movesSearched[256];
-    Value margins[2];
+    Move movesSearched[MOVES_MAX];
     StateInfo st;
     const TTEntry *tte;
     Key posKey;
     Move ttMove, move, excludedMove, threatMove;
     Depth ext, newDepth;
-    Value bestValue, value, oldAlpha;
+    Value bestValue, value, evalMargin, oldAlpha;
     Value refinedValue, nullValue, futilityBase, futilityValueScaled; // Non-PV specific
     bool isCheck, singleEvasion, singularExtensionNode, moveIsCheck, captureOrPromotion, dangerous;
     bool mateThreat = false;
@@ -1045,19 +1036,19 @@ namespace {
     // update gain statistics of parent move.
     isCheck = pos.is_check();
     if (isCheck)
-        ss->eval = VALUE_NONE;
+        ss->eval = evalMargin = VALUE_NONE;
     else if (tte)
     {
         assert(tte->static_value() != VALUE_NONE);
 
         ss->eval = tte->static_value();
-        margins[pos.side_to_move()] = tte->static_value_margin();
+        evalMargin = tte->static_value_margin();
         refinedValue = refine_eval(tte, ss->eval, ply);
     }
     else
     {
-        refinedValue = ss->eval = evaluate(pos, margins);
-        TT.store(posKey, VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, margins[pos.side_to_move()]);
+        refinedValue = ss->eval = evaluate(pos, evalMargin);
+        TT.store(posKey, VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, evalMargin);
     }
 
     // Save gain for the parent non-capture move
@@ -1094,14 +1085,11 @@ namespace {
         return refinedValue - futility_margin(depth, 0);
 
     // Step 8. Null move search with verification search (is omitted in PV nodes)
-    // When we jump directly to qsearch() we do a null move only if static value is
-    // at least beta. Otherwise we do a null move if static value is not more than
-    // NullMoveMargin under beta.
     if (   !PvNode
         && !ss->skipNullMove
         &&  depth > ONE_PLY
         && !isCheck
-        &&  refinedValue >= beta - (depth >= 4 * ONE_PLY ? NullMoveMargin : 0)
+        &&  refinedValue >= beta
         && !value_is_mate(beta)
         &&  pos.non_pawn_material(pos.side_to_move()))
     {
@@ -1182,7 +1170,7 @@ namespace {
     CheckInfo ci(pos);
     ss->bestMove = MOVE_NONE;
     singleEvasion = isCheck && mp.number_of_evasions() == 1;
-    futilityBase = ss->eval + margins[pos.side_to_move()];
+    futilityBase = ss->eval + evalMargin;
     singularExtensionNode =   depth >= SingularExtensionDepth[PvNode]
                            && tte
                            && tte->move()
@@ -1372,7 +1360,7 @@ namespace {
 
     ValueType vt = (bestValue <= oldAlpha ? VALUE_TYPE_UPPER : bestValue >= beta ? VALUE_TYPE_LOWER : VALUE_TYPE_EXACT);
     move = (bestValue <= oldAlpha ? MOVE_NONE : ss->bestMove);
-    TT.store(posKey, value_to_tt(bestValue, ply), vt, depth, move, ss->eval, margins[pos.side_to_move()]);
+    TT.store(posKey, value_to_tt(bestValue, ply), vt, depth, move, ss->eval, evalMargin);
 
     // Update killers and history only for non capture moves that fails high
     if (    bestValue >= beta
@@ -1402,10 +1390,9 @@ namespace {
     assert(ply > 0 && ply < PLY_MAX);
     assert(pos.thread() >= 0 && pos.thread() < ThreadsMgr.active_threads());
 
-    Value margins[2];
     StateInfo st;
     Move ttMove, move;
-    Value bestValue, value, futilityValue, futilityBase;
+    Value bestValue, value, evalMargin, futilityValue, futilityBase;
     bool isCheck, deepChecks, enoughMaterial, moveIsCheck, evasionPrunable;
     const TTEntry* tte;
     Value oldAlpha = alpha;
@@ -1434,7 +1421,7 @@ namespace {
     if (isCheck)
     {
         bestValue = futilityBase = -VALUE_INFINITE;
-        ss->eval = VALUE_NONE;
+        ss->eval = evalMargin = VALUE_NONE;
         deepChecks = enoughMaterial = false;
     }
     else
@@ -1443,20 +1430,19 @@ namespace {
         {
             assert(tte->static_value() != VALUE_NONE);
 
-            margins[pos.side_to_move()] = tte->static_value_margin();
-            bestValue = tte->static_value();
+            evalMargin = tte->static_value_margin();
+            ss->eval = bestValue = tte->static_value();
         }
         else
-            bestValue = evaluate(pos, margins);
+            ss->eval = bestValue = evaluate(pos, evalMargin);
 
-        ss->eval = bestValue;
         update_gains(pos, (ss-1)->currentMove, (ss-1)->eval, ss->eval);
 
         // Stand pat. Return immediately if static value is at least beta
         if (bestValue >= beta)
         {
             if (!tte)
-                TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, DEPTH_NONE, MOVE_NONE, ss->eval, margins[pos.side_to_move()]);
+                TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, DEPTH_NONE, MOVE_NONE, ss->eval, evalMargin);
 
             return bestValue;
         }
@@ -1468,7 +1454,7 @@ namespace {
         deepChecks = (depth == -ONE_PLY && bestValue >= beta - PawnValueMidgame / 8);
 
         // Futility pruning parameters, not needed when in check
-        futilityBase = bestValue + FutilityMarginQS + margins[pos.side_to_move()];
+        futilityBase = ss->eval + evalMargin + FutilityMarginQS;
         enoughMaterial = pos.non_pawn_material(pos.side_to_move()) > RookValueMidgame;
     }
 
@@ -1508,11 +1494,10 @@ namespace {
           }
       }
 
-      // Detect blocking evasions that are candidate to be pruned
+      // Detect non-capture evasions that are candidate to be pruned
       evasionPrunable =   isCheck
                        && bestValue > value_mated_in(PLY_MAX)
                        && !pos.move_is_capture(move)
-                       && pos.type_of_piece_on(move_from(move)) != KING
                        && !pos.can_castle(pos.side_to_move());
 
       // Don't search moves with negative SEE values
@@ -1553,12 +1538,7 @@ namespace {
     // Update transposition table
     Depth d = (depth == DEPTH_ZERO ? DEPTH_ZERO : DEPTH_ZERO - ONE_PLY);
     ValueType vt = (bestValue <= oldAlpha ? VALUE_TYPE_UPPER : bestValue >= beta ? VALUE_TYPE_LOWER : VALUE_TYPE_EXACT);
-    TT.store(pos.get_key(), value_to_tt(bestValue, ply), vt, d, ss->bestMove, ss->eval, margins[pos.side_to_move()]);
-
-    // Update killers only for checking moves that fails high
-    if (    bestValue >= beta
-        && !pos.move_is_capture_or_promotion(ss->bestMove))
-        update_killers(ss->bestMove, ss);
+    TT.store(pos.get_key(), value_to_tt(bestValue, ply), vt, d, ss->bestMove, ss->eval, evalMargin);
 
     assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE);
 
@@ -2243,16 +2223,15 @@ namespace {
     StateInfo st;
     TTEntry* tte;
     Position p(pos, pos.thread());
-    Value margins[2];
-    Value v;
+    Value v, m = VALUE_NONE;
 
     for (int i = 0; pv[i] != MOVE_NONE; i++)
     {
         tte = TT.retrieve(p.get_key());
         if (!tte || tte->move() != pv[i])
         {
-            v = (p.is_check() ? VALUE_NONE : evaluate(p, margins));
-            TT.store(p.get_key(), VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, pv[i], v, margins[pos.side_to_move()]);
+            v = (p.is_check() ? VALUE_NONE : evaluate(p, m));
+            TT.store(p.get_key(), VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, pv[i], v, m);
         }
         p.do_move(pv[i], st);
     }
@@ -2726,17 +2705,17 @@ namespace {
 
   // RootMoveList c'tor
 
-  RootMoveList::RootMoveList(Position& pos, Move searchMoves[]) : count(0) {
+  RootMoveList::RootMoveList(Position& pos, Move searchMoves[]) {
 
     SearchStack ss[PLY_MAX_PLUS_2];
-    MoveStack mlist[MaxRootMoves];
+    MoveStack mlist[MOVES_MAX];
     StateInfo st;
     bool includeAllMoves = (searchMoves[0] == MOVE_NONE);
 
     // Initialize search stack
     init_ss_array(ss, PLY_MAX_PLUS_2);
-    ss[0].currentMove = ss[0].bestMove = MOVE_NONE;
     ss[0].eval = VALUE_NONE;
+    count = 0;
 
     // Generate all legal moves
     MoveStack* last = generate_moves(pos, mlist);
@@ -2753,12 +2732,10 @@ namespace {
             continue;
 
         // Find a quick score for the move
+        moves[count].move = ss[0].currentMove = moves[count].pv[0] = cur->move;
+        moves[count].pv[1] = MOVE_NONE;
         pos.do_move(cur->move, st);
-        ss[0].currentMove = cur->move;
-        moves[count].move = cur->move;
         moves[count].score = -qsearch<PV>(pos, ss+1, -VALUE_INFINITE, VALUE_INFINITE, DEPTH_ZERO, 1);
-        moves[count].pv[0] = cur->move;
-        moves[count].pv[1] = MOVE_NONE;
         pos.undo_move(cur->move);
         count++;
     }
@@ -2823,4 +2800,4 @@ namespace {
     }
   }
 
-} // namspace
+} // namespace