Rename ei.kingDanger in ei.margin

[stockfish] / src / search.cpp

diff --git a/src/search.cpp b/src/search.cpp
index 032ff4034153e1ed8acc939e1fc39a60b5f0795b..7d9d402c0ac6c5dedc6af55711809293ee69a069 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -76,12 +76,9 @@ namespace {
     int active_threads() const { return ActiveThreads; }
     void set_active_threads(int newActiveThreads) { ActiveThreads = newActiveThreads; }
     void incrementNodeCounter(int threadID) { threads[threadID].nodes++; }
     int active_threads() const { return ActiveThreads; }
     void set_active_threads(int newActiveThreads) { ActiveThreads = newActiveThreads; }
     void incrementNodeCounter(int threadID) { threads[threadID].nodes++; }

-    void incrementBetaCounter(Color us, Depth d, int threadID) { threads[threadID].betaCutOffs[us] += unsigned(d); }

 
     void resetNodeCounters();
 
     void resetNodeCounters();

-    void resetBetaCounters();

     int64_t nodes_searched() const;
     int64_t nodes_searched() const;

-    void get_beta_counters(Color us, int64_t& our, int64_t& their) const;

     bool available_thread_exists(int master) const;
     bool thread_is_available(int slave, int master) const;
     bool thread_should_stop(int threadID) const;
     bool available_thread_exists(int master) const;
     bool thread_is_available(int slave, int master) const;
     bool thread_should_stop(int threadID) const;


@@ -117,7 +114,7 @@ namespace {
 
   struct RootMove {
 
 
   struct RootMove {
 

-    RootMove() { nodes = cumulativeNodes = ourBeta = theirBeta = 0ULL; }
+    RootMove() : mp_score(0), nodes(0), cumulativeNodes(0) {}

 
     // RootMove::operator<() is the comparison function used when
     // sorting the moves. A move m1 is considered to be better
 
     // RootMove::operator<() is the comparison function used when
     // sorting the moves. A move m1 is considered to be better


@@ -125,12 +122,13 @@ namespace {
     // have equal score but m1 has the higher beta cut-off count.
     bool operator<(const RootMove& m) const {
 
     // have equal score but m1 has the higher beta cut-off count.
     bool operator<(const RootMove& m) const {
 

-        return score != m.score ? score < m.score : theirBeta <= m.theirBeta;
+        return score != m.score ? score < m.score : mp_score <= m.mp_score;

     }
 
     Move move;
     Value score;
     }
 
     Move move;
     Value score;

-    int64_t nodes, cumulativeNodes, ourBeta, theirBeta;
+    int mp_score;
+    int64_t nodes, cumulativeNodes;

     Move pv[PLY_MAX_PLUS_2];
   };
 
     Move pv[PLY_MAX_PLUS_2];
   };
 


@@ -149,9 +147,9 @@ namespace {
     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_cumulative_nodes(int moveNum) const { return moves[moveNum].cumulativeNodes; }
     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_cumulative_nodes(int moveNum) const { return moves[moveNum].cumulativeNodes; }

+    void score_moves(const Position& pos);

 
     void set_move_nodes(int moveNum, int64_t nodes);
 
     void set_move_nodes(int moveNum, int64_t nodes);

-    void set_beta_counters(int moveNum, int64_t our, int64_t their);

     void set_move_pv(int moveNum, const Move pv[]);
     void sort();
     void sort_multipv(int n);
     void set_move_pv(int moveNum, const Move pv[]);
     void sort();
     void sort_multipv(int n);


@@ -163,6 +161,21 @@ namespace {
   };
 
 
   };
 
 

+  // When formatting a move for std::cout we must know if we are in Chess960
+  // or not. To keep using the handy operator<<() on the move the trick is to
+  // embed this flag in the stream itself. Function-like named enum set960 is
+  // used as a custom manipulator and the stream internal general-purpose array,
+  // accessed through ios_base::iword(), is used to pass the flag to the move's
+  // operator<<() that will use it to properly format castling moves.
+  enum set960 {};
+
+  std::ostream& operator<< (std::ostream& os, const set960& m) {
+
+    os.iword(0) = int(m);
+    return os;
+  }
+
+

   /// Adjustments
 
   // Step 6. Razoring
   /// Adjustments
 
   // Step 6. Razoring


@@ -450,7 +463,6 @@ bool think(const Position& pos, bool infinite, bool ponder, int time[], int incr
   MinimumSplitDepth       = get_option_value_int("Minimum Split Depth") * ONE_PLY;
   MaxThreadsPerSplitPoint = get_option_value_int("Maximum Number of Threads per Split Point");
   MultiPV                 = get_option_value_int("MultiPV");
   MinimumSplitDepth       = get_option_value_int("Minimum Split Depth") * ONE_PLY;
   MaxThreadsPerSplitPoint = get_option_value_int("Maximum Number of Threads per Split Point");
   MultiPV                 = get_option_value_int("MultiPV");

-  Chess960                = get_option_value_bool("UCI_Chess960");

   UseLogFile              = get_option_value_bool("Use Search Log");
 
   if (UseLogFile)
   UseLogFile              = get_option_value_bool("Use Search Log");
 
   if (UseLogFile)


@@ -536,7 +548,8 @@ namespace {
 
     // Print RootMoveList startup scoring to the standard output,
     // so to output information also for iteration 1.
 
     // Print RootMoveList startup scoring to the standard output,
     // so to output information also for iteration 1.

-    cout << "info depth " << 1
+    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))
          << " time " << current_search_time()
          << "\ninfo depth " << 1
          << " score " << value_to_uci(rml.get_move_score(0))
          << " time " << current_search_time()


@@ -739,6 +752,7 @@ namespace {
     while (1)
     {
         // Sort the moves before to (re)search
     while (1)
     {
         // Sort the moves before to (re)search

+        rml.score_moves(pos);

         rml.sort();
 
         // Step 10. Loop through all moves in the root move list
         rml.sort();
 
         // Step 10. Loop through all moves in the root move list


@@ -750,9 +764,6 @@ namespace {
             // Save the current node count before the move is searched
             nodes = ThreadsMgr.nodes_searched();
 
             // Save the current node count before the move is searched
             nodes = ThreadsMgr.nodes_searched();
 

-            // Reset beta cut-off counters
-            ThreadsMgr.resetBetaCounters();
-

             // Pick the next root move, and print the move and the move number to
             // the standard output.
             move = ss->currentMove = rml.get_move(i);
             // Pick the next root move, and print the move and the move number to
             // the standard output.
             move = ss->currentMove = rml.get_move(i);


@@ -871,11 +882,7 @@ namespace {
             if (AbortSearch)
                 break;
 
             if (AbortSearch)
                 break;
 

-            // Remember beta-cutoff and searched nodes counts for this move. The
-            // info is used to sort the root moves for the next iteration.
-            int64_t our, their;
-            ThreadsMgr.get_beta_counters(pos.side_to_move(), our, their);
-            rml.set_beta_counters(i, our, their);
+            // Remember searched nodes counts for this move

             rml.set_move_nodes(i, ThreadsMgr.nodes_searched() - nodes);
 
             assert(value >= -VALUE_INFINITE && value <= VALUE_INFINITE);
             rml.set_move_nodes(i, ThreadsMgr.nodes_searched() - nodes);
 
             assert(value >= -VALUE_INFINITE && value <= VALUE_INFINITE);


@@ -996,7 +1003,7 @@ namespace {
 
     // Step 2. Check for aborted search and immediate draw
     if (AbortSearch || ThreadsMgr.thread_should_stop(threadID))
 
     // Step 2. Check for aborted search and immediate draw
     if (AbortSearch || ThreadsMgr.thread_should_stop(threadID))

-        return Value(0);
+        return VALUE_ZERO;

 
     if (pos.is_draw() || ply >= PLY_MAX - 1)
         return VALUE_DRAW;
 
     if (pos.is_draw() || ply >= PLY_MAX - 1)
         return VALUE_DRAW;


@@ -1028,7 +1035,7 @@ namespace {
     if (!PvNode && tte && ok_to_use_TT(tte, depth, beta, ply))
     {
         // Refresh tte entry to avoid aging
     if (!PvNode && tte && ok_to_use_TT(tte, depth, beta, ply))
     {
         // Refresh tte entry to avoid aging

-        TT.store(posKey, tte->value(), tte->type(), tte->depth(), ttMove, tte->static_value(), tte->king_danger());
+        TT.store(posKey, tte->value(), tte->type(), tte->depth(), ttMove, tte->static_value(), tte->static_value_margin());

 
         ss->bestMove = ttMove; // Can be MOVE_NONE
         return value_from_tt(tte->value(), ply);
 
         ss->bestMove = ttMove; // Can be MOVE_NONE
         return value_from_tt(tte->value(), ply);


@@ -1044,13 +1051,13 @@ namespace {
         assert(tte->static_value() != VALUE_NONE);
 
         ss->eval = tte->static_value();
         assert(tte->static_value() != VALUE_NONE);
 
         ss->eval = tte->static_value();

-        ei.kingDanger[pos.side_to_move()] = tte->king_danger();
+        ei.margin[pos.side_to_move()] = tte->static_value_margin();

         refinedValue = refine_eval(tte, ss->eval, ply);
     }
     else
     {
         refinedValue = ss->eval = evaluate(pos, ei);
         refinedValue = refine_eval(tte, ss->eval, ply);
     }
     else
     {
         refinedValue = ss->eval = evaluate(pos, ei);

-        TT.store(posKey, VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, ei.kingDanger[pos.side_to_move()]);
+        TT.store(posKey, VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, ei.margin[pos.side_to_move()]);

     }
 
     // Save gain for the parent non-capture move
     }
 
     // Save gain for the parent non-capture move


@@ -1179,7 +1186,7 @@ namespace {
                            && tte
                            && tte->move()
                            && !excludedMove // Do not allow recursive singular extension search
                            && tte
                            && tte->move()
                            && !excludedMove // Do not allow recursive singular extension search

-                           && is_lower_bound(tte->type())
+                           && (tte->type() & VALUE_TYPE_LOWER)

                            && tte->depth() >= depth - 3 * ONE_PLY;
 
     // Step 10. Loop through moves
                            && tte->depth() >= depth - 3 * ONE_PLY;
 
     // Step 10. Loop through moves


@@ -1364,17 +1371,14 @@ namespace {
 
     ValueType vt = (bestValue <= oldAlpha ? VALUE_TYPE_UPPER : bestValue >= beta ? VALUE_TYPE_LOWER : VALUE_TYPE_EXACT);
     move = (bestValue <= oldAlpha ? MOVE_NONE : ss->bestMove);
 
     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, ei.kingDanger[pos.side_to_move()]);
+    TT.store(posKey, value_to_tt(bestValue, ply), vt, depth, move, ss->eval, ei.margin[pos.side_to_move()]);

 
     // Update killers and history only for non capture moves that fails high
 
     // Update killers and history only for non capture moves that fails high

-    if (bestValue >= beta)
+    if (    bestValue >= beta
+        && !pos.move_is_capture_or_promotion(move))

     {
     {

-        ThreadsMgr.incrementBetaCounter(pos.side_to_move(), depth, threadID);
-        if (!pos.move_is_capture_or_promotion(move))
-        {

             update_history(pos, move, depth, movesSearched, moveCount);
             update_killers(move, ss);
             update_history(pos, move, depth, movesSearched, moveCount);
             update_killers(move, ss);

-        }

     }
 
     assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE);
     }
 
     assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE);


@@ -1438,7 +1442,7 @@ namespace {
         {
             assert(tte->static_value() != VALUE_NONE);
 
         {
             assert(tte->static_value() != VALUE_NONE);
 

-            ei.kingDanger[pos.side_to_move()] = tte->king_danger();
+            ei.margin[pos.side_to_move()] = tte->static_value_margin();

             bestValue = tte->static_value();
         }
         else
             bestValue = tte->static_value();
         }
         else


@@ -1451,7 +1455,7 @@ namespace {
         if (bestValue >= beta)
         {
             if (!tte)
         if (bestValue >= beta)
         {
             if (!tte)

-                TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, DEPTH_NONE, MOVE_NONE, ss->eval, ei.kingDanger[pos.side_to_move()]);
+                TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, DEPTH_NONE, MOVE_NONE, ss->eval, ei.margin[pos.side_to_move()]);

 
             return bestValue;
         }
 
             return bestValue;
         }


@@ -1463,7 +1467,7 @@ namespace {
         deepChecks = (depth == -ONE_PLY && bestValue >= beta - PawnValueMidgame / 8);
 
         // Futility pruning parameters, not needed when in check
         deepChecks = (depth == -ONE_PLY && bestValue >= beta - PawnValueMidgame / 8);
 
         // Futility pruning parameters, not needed when in check

-        futilityBase = bestValue + FutilityMarginQS + ei.kingDanger[pos.side_to_move()];
+        futilityBase = bestValue + FutilityMarginQS + ei.margin[pos.side_to_move()];

         enoughMaterial = pos.non_pawn_material(pos.side_to_move()) > RookValueMidgame;
     }
 
         enoughMaterial = pos.non_pawn_material(pos.side_to_move()) > RookValueMidgame;
     }
 


@@ -1493,7 +1497,7 @@ namespace {
       {
           futilityValue =  futilityBase
                          + pos.endgame_value_of_piece_on(move_to(move))
       {
           futilityValue =  futilityBase
                          + pos.endgame_value_of_piece_on(move_to(move))

-                         + (move_is_ep(move) ? PawnValueEndgame : Value(0));
+                         + (move_is_ep(move) ? PawnValueEndgame : VALUE_ZERO);

 
           if (futilityValue < alpha)
           {
 
           if (futilityValue < alpha)
           {


@@ -1548,7 +1552,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);
     // 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, ei.kingDanger[pos.side_to_move()]);
+    TT.store(pos.get_key(), value_to_tt(bestValue, ply), vt, d, ss->bestMove, ss->eval, ei.margin[pos.side_to_move()]);

 
     // Update killers only for checking moves that fails high
     if (    bestValue >= beta
 
     // Update killers only for checking moves that fails high
     if (    bestValue >= beta


@@ -1884,7 +1888,7 @@ namespace {
     if (   captureOrPromotion
         && pos.type_of_piece_on(move_to(m)) != PAWN
         && (  pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK)
     if (   captureOrPromotion
         && pos.type_of_piece_on(move_to(m)) != PAWN
         && (  pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK)

-            - pos.midgame_value_of_piece_on(move_to(m)) == Value(0))
+            - pos.midgame_value_of_piece_on(move_to(m)) == VALUE_ZERO)

         && !move_is_promotion(m)
         && !move_is_ep(m))
     {
         && !move_is_promotion(m)
         && !move_is_ep(m))
     {


@@ -1957,8 +1961,8 @@ namespace {
               || v >= Max(value_mate_in(PLY_MAX), beta)
               || v < Min(value_mated_in(PLY_MAX), beta))
 
               || v >= Max(value_mate_in(PLY_MAX), beta)
               || v < Min(value_mated_in(PLY_MAX), beta))
 

-          && (   (is_lower_bound(tte->type()) && v >= beta)
-              || (is_upper_bound(tte->type()) && v < beta));
+          && (   ((tte->type() & VALUE_TYPE_LOWER) && v >= beta)
+              || ((tte->type() & VALUE_TYPE_UPPER) && v < beta));

   }
 
 
   }
 
 


@@ -1971,8 +1975,8 @@ namespace {
 
       Value v = value_from_tt(tte->value(), ply);
 
 
       Value v = value_from_tt(tte->value(), ply);
 

-      if (   (is_lower_bound(tte->type()) && v >= defaultEval)
-          || (is_upper_bound(tte->type()) && v < defaultEval))
+      if (   ((tte->type() & VALUE_TYPE_LOWER) && v >= defaultEval)
+          || ((tte->type() & VALUE_TYPE_UPPER) && v < defaultEval))

           return v;
 
       return defaultEval;
           return v;
 
       return defaultEval;


@@ -2247,7 +2251,7 @@ namespace {
         if (!tte || tte->move() != pv[i])
         {
             v = (p.is_check() ? VALUE_NONE : evaluate(p, ei));
         if (!tte || tte->move() != pv[i])
         {
             v = (p.is_check() ? VALUE_NONE : evaluate(p, ei));

-            TT.store(p.get_key(), VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, pv[i], v, ei.kingDanger[pos.side_to_move()]);
+            TT.store(p.get_key(), VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, pv[i], v, ei.margin[pos.side_to_move()]);

         }
         p.do_move(pv[i], st);
     }
         }
         p.do_move(pv[i], st);
     }


@@ -2320,12 +2324,6 @@ namespace {
         threads[i].nodes = 0ULL;
   }
 
         threads[i].nodes = 0ULL;
   }
 

-  void ThreadsManager::resetBetaCounters() {
-
-    for (int i = 0; i < MAX_THREADS; i++)
-        threads[i].betaCutOffs[WHITE] = threads[i].betaCutOffs[BLACK] = 0ULL;
-  }
-

   int64_t ThreadsManager::nodes_searched() const {
 
     int64_t result = 0ULL;
   int64_t ThreadsManager::nodes_searched() const {
 
     int64_t result = 0ULL;


@@ -2335,16 +2333,6 @@ namespace {
     return result;
   }
 
     return result;
   }
 

-  void ThreadsManager::get_beta_counters(Color us, int64_t& our, int64_t& their) const {
-
-    our = their = 0UL;
-    for (int i = 0; i < MAX_THREADS; i++)
-    {
-        our += threads[i].betaCutOffs[us];
-        their += threads[i].betaCutOffs[opposite_color(us)];
-    }
-  }
-

 
   // idle_loop() is where the threads are parked when they have no work to do.
   // The parameter 'sp', if non-NULL, is a pointer to an active SplitPoint
 
   // idle_loop() is where the threads are parked when they have no work to do.
   // The parameter 'sp', if non-NULL, is a pointer to an active SplitPoint


@@ -2776,6 +2764,23 @@ namespace {
     sort();
   }
 
     sort();
   }
 

+  // Score root moves using the standard way used in main search, the moves
+  // are scored according to the order in which are returned by MovePicker.
+
+  void RootMoveList::score_moves(const Position& pos)
+  {
+      Move move;
+      int score = 1000;
+      MovePicker mp = MovePicker(pos, MOVE_NONE, ONE_PLY, H);
+
+      while ((move = mp.get_next_move()) != MOVE_NONE)
+          for (int i = 0; i < count; i++)
+              if (moves[i].move == move)
+              {
+                  moves[i].mp_score = score--;
+                  break;
+              }
+  }

 
   // RootMoveList simple methods definitions
 
 
   // RootMoveList simple methods definitions
 


@@ -2785,12 +2790,6 @@ namespace {
     moves[moveNum].cumulativeNodes += nodes;
   }
 
     moves[moveNum].cumulativeNodes += nodes;
   }
 

-  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;
   void RootMoveList::set_move_pv(int moveNum, const Move pv[]) {
 
     int j;