X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=ab3e6f66cdcf9d7988c4dd7e167216bc90b90751;hp=2a2e32f943fae435ef69719364504b7b2f58fedc;hb=4c294932e7b4a6ee3604f0c176dd01124524456f;hpb=c172af1b6181b39288870689f912143c04a4040a

diff --git a/src/search.cpp b/src/search.cpp
index 2a2e32f9..ab3e6f66 100644
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -47,6 +47,23 @@ namespace {
 
   /// Types
 
+  // The BetaCounterType class is used to order moves at ply one.
+  // Apart for the first one that has its score, following moves
+  // normally have score -VALUE_INFINITE, so are ordered according
+  // to the number of beta cutoffs occurred under their subtree during
+  // the last iteration.
+
+  struct BetaCounterType {
+
+    BetaCounterType();
+    void clear();
+    void add(Color us, Depth d, int threadID);
+    void read(Color us, int64_t& our, int64_t& their);
+
+    int64_t hits[THREAD_MAX][2];
+  };
+
+
   // The RootMove class is used for moves at the root at the tree.  For each
   // root move, we store a score, a node count, and a PV (really a refutation
   // in the case of moves which fail low).
@@ -60,6 +77,7 @@ namespace {
     Value score;
     int64_t nodes, cumulativeNodes;
     Move pv[PLY_MAX_PLUS_2];
+    int64_t ourBeta, theirBeta;
   };
 
 
@@ -74,6 +92,7 @@ namespace {
     inline Value get_move_score(int moveNum) const;
     inline void set_move_score(int moveNum, Value score);
     inline void set_move_nodes(int moveNum, int64_t nodes);
+    inline void set_beta_counters(int moveNum, int64_t our, int64_t their);
     void set_move_pv(int moveNum, const Move pv[]);
     inline Move get_move_pv(int moveNum, int i) const;
     inline int64_t get_move_cumulative_nodes(int moveNum) const;
@@ -107,7 +126,7 @@ namespace {
   const bool UseIIDAtNonPVNodes = false;
 
   // Use null move driven internal iterative deepening?
-  bool UseNullDrivenIID = true;
+  bool UseNullDrivenIID = false;
 
   // Internal iterative deepening margin.  At Non-PV moves, when
   // UseIIDAtNonPVNodes is true, we do an internal iterative deepening search
@@ -177,9 +196,10 @@ namespace {
   int NodesSincePoll;
   int NodesBetweenPolls = 30000;
 
-  // Iteration counter
+  // Iteration counters
   int Iteration;
   bool LastIterations;
+  BetaCounterType BetaCounter;
 
   // Scores and number of times the best move changed for each iteration:
   Value ValueByIteration[PLY_MAX_PLUS_2];
@@ -393,6 +413,7 @@ void think(const Position &pos, bool infinite, bool ponder, int side_to_move,
   if (UseLogFile)
       LogFile.open(get_option_value_string("Search Log Filename").c_str(), std::ios::out | std::ios::app);
 
+  UseNullDrivenIID = get_option_value_bool("Null driven IID");
   UseQSearchFutilityPruning = get_option_value_bool("Futility Pruning (Quiescence Search)");
   UseFutilityPruning = get_option_value_bool("Futility Pruning (Main Search)");
 
@@ -728,6 +749,12 @@ namespace {
 
     if (UseLogFile)
     {
+        if (dbg_show_mean)
+            dbg_print_mean(LogFile);
+
+        if (dbg_show_hit_rate)
+            dbg_print_hit_rate(LogFile);
+
         UndoInfo u;
         LogFile << "Nodes: " << nodes_searched() << std::endl
                 << "Nodes/second: " << nps() << std::endl
@@ -767,6 +794,9 @@ namespace {
         // are used to sort the root moves at the next iteration.
         nodes = nodes_searched();
 
+        // Reset beta cut-off counters
+        BetaCounter.clear();
+
         // Pick the next root move, and print the move and the move number to
         // the standard output.
         move = ss[0].currentMove = rml.get_move(i);
@@ -822,6 +852,11 @@ namespace {
         // sort the root moves at the next iteration.
         rml.set_move_nodes(i, nodes_searched() - nodes);
 
+        // Remember the beta-cutoff statistics
+        int64_t our, their;
+        BetaCounter.read(pos.side_to_move(), our, their);
+        rml.set_beta_counters(i, our, their);
+
         assert(value >= -VALUE_INFINITE && value <= VALUE_INFINITE);
 
         if (value <= alpha && i >= MultiPV)
@@ -1072,6 +1107,7 @@ namespace {
 
     else if (bestValue >= beta)
     {
+        BetaCounter.add(pos.side_to_move(), depth, threadID);
         Move m = ss[ply].pv[ply];
         if (ok_to_history(pos, m)) // Only non capture moves are considered
         {
@@ -1138,6 +1174,7 @@ namespace {
 
     // Null move search
     if (    allowNullmove
+        &&  depth > OnePly
         && !isCheck
         &&  ok_to_do_nullmove(pos)
         &&  approximateEval >= beta - NullMoveMargin)
@@ -1146,7 +1183,7 @@ namespace {
 
         UndoInfo u;
         pos.do_null_move(u);
-        int R = (depth > 7 ? 4 : 3);
+        int R = (depth >= 4 * OnePly ? 4 : 3); // Null move dynamic reduction
 
         Value nullValue = -search(pos, ss, -(beta-1), depth-R*OnePly, ply+1, false, threadID);
 
@@ -1159,7 +1196,7 @@ namespace {
             && ttMove == MOVE_NONE
             && ss[ply + 1].currentMove != MOVE_NONE
             && pos.move_is_capture(ss[ply + 1].currentMove)
-            && pos.see(ss[ply + 1].currentMove) * PawnValueMidgame + nullValue > beta - IIDMargin)
+            && pos.see(ss[ply + 1].currentMove) + nullValue >= beta)
             nullDrivenIID = true;
 
         pos.undo_null_move(u);
@@ -1175,9 +1212,9 @@ namespace {
                 return beta;
         } else {
             // The null move failed low, which means that we may be faced with
-            // some kind of threat.  If the previous move was reduced, check if
+            // some kind of threat. If the previous move was reduced, check if
             // the move that refuted the null move was somehow connected to the
-            // move which was reduced.  If a connection is found, return a fail
+            // move which was reduced. If a connection is found, return a fail
             // low score (which will cause the reduced move to fail high in the
             // parent node, which will trigger a re-search with full depth).
             if (nullValue == value_mated_in(ply + 2))
@@ -1216,8 +1253,9 @@ namespace {
         Move tm = ss[ply].threatMove;
 
         assert(tm != MOVE_NONE);
+        assert(ttMove == MOVE_NONE);
 
-        search(pos, ss, beta, Min(depth/2, depth-3*OnePly), ply, false, threadID);
+        search(pos, ss, beta, depth/2, ply, false, threadID);
         ttMove = ss[ply].pv[ply];
         ss[ply].threatMove = tm;
     }
@@ -1346,6 +1384,7 @@ namespace {
         TT.store(pos, value_to_tt(bestValue, ply), depth, MOVE_NONE, VALUE_TYPE_UPPER);
     else
     {
+        BetaCounter.add(pos.side_to_move(), depth, threadID);
         Move m = ss[ply].pv[ply];
         if (ok_to_history(pos, m)) // Only non capture moves are considered
         {
@@ -1744,6 +1783,32 @@ namespace {
     lock_release(&(sp->lock));
   }
 
+  /// The BetaCounterType class
+
+  BetaCounterType::BetaCounterType() { clear(); }
+
+  void BetaCounterType::clear() {
+
+    for (int i = 0; i < THREAD_MAX; i++)
+        hits[i][WHITE] = hits[i][BLACK] = 0ULL;
+  }
+
+  void BetaCounterType::add(Color us, Depth d, int threadID) {
+
+    // Weighted count based on depth
+    hits[threadID][us] += int(d);
+  }
+
+  void BetaCounterType::read(Color us, int64_t& our, int64_t& their) {
+
+    our = their = 0UL;
+    for (int i = 0; i < THREAD_MAX; i++)
+    {
+        our += hits[i][us];
+        their += hits[i][opposite_color(us)];
+    }
+  }
+
 
   /// The RootMove class
 
@@ -1763,7 +1828,7 @@ namespace {
     if (score != m.score)
         return (score < m.score);
 
-    return nodes <= m.nodes;
+    return theirBeta <= m.theirBeta;
   }
 
   /// The RootMoveList class
@@ -1826,6 +1891,11 @@ namespace {
     moves[moveNum].cumulativeNodes += nodes;
   }
 
+  inline void RootMoveList::set_beta_counters(int moveNum, int64_t our, int64_t their) {
+    moves[moveNum].ourBeta = our;
+    moves[moveNum].theirBeta = their;
+  }
+
   void RootMoveList::set_move_pv(int moveNum, const Move pv[]) {
     int j;
     for(j = 0; pv[j] != MOVE_NONE; j++)
@@ -2155,31 +2225,34 @@ namespace {
     tto = move_to(threat);
 
     // Case 1: Castling moves are never pruned.
-    if(move_is_castle(m))
-      return false;
+    if (move_is_castle(m))
+        return false;
 
     // Case 2: Don't prune moves which move the threatened piece
-    if(!PruneEscapeMoves && threat != MOVE_NONE && mfrom == tto)
-      return false;
+    if (!PruneEscapeMoves && threat != MOVE_NONE && mfrom == tto)
+        return false;
 
     // Case 3: If the threatened piece has value less than or equal to the
     // value of the threatening piece, don't prune move which defend it.
-    if(!PruneDefendingMoves && threat != MOVE_NONE
-       && (piece_value_midgame(pos.piece_on(tfrom))
-           >= piece_value_midgame(pos.piece_on(tto)))
-       && pos.move_attacks_square(m, tto))
+    if (   !PruneDefendingMoves
+        && threat != MOVE_NONE
+        && pos.type_of_piece_on(tto) != NO_PIECE_TYPE
+        && (   pos.midgame_value_of_piece_on(tfrom) >= pos.midgame_value_of_piece_on(tto)
+            || pos.type_of_piece_on(tfrom) == KING)
+        && pos.move_attacks_square(m, tto))
       return false;
 
     // Case 4: Don't prune moves with good history.
-    if(!H.ok_to_prune(pos.piece_on(move_from(m)), m, d))
-      return false;
+    if (!H.ok_to_prune(pos.piece_on(move_from(m)), m, d))
+        return false;
 
     // Case 5: If the moving piece in the threatened move is a slider, don't
     // prune safe moves which block its ray.
-    if(!PruneBlockingMoves && threat != MOVE_NONE
-       && piece_is_slider(pos.piece_on(tfrom))
-       && bit_is_set(squares_between(tfrom, tto), mto) && pos.see(m) >= 0)
-      return false;
+    if (  !PruneBlockingMoves
+        && threat != MOVE_NONE
+        && piece_is_slider(pos.piece_on(tfrom))
+        && bit_is_set(squares_between(tfrom, tto), mto) && pos.see(m) >= 0)
+            return false;
 
     return true;
   }