X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=920310da713d1fbacc11c9ad60334c49a82b5aa0;hp=82b7c55cc7875647c7791f94b5a8b76dcfed5ed9;hb=c2fc80e5d16339266b5bf6687fa843ff65de3b3e;hpb=d8e56cbe54378c91fbbd9e6f6cee8ef5a27b02e9

diff --git a/src/search.cpp b/src/search.cpp
index 82b7c55c..920310da 100644
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -28,7 +28,6 @@
 #include "book.h"
 #include "evaluate.h"
 #include "history.h"
-#include "misc.h"
 #include "movegen.h"
 #include "movepick.h"
 #include "search.h"
@@ -43,11 +42,13 @@ namespace Search {
   LimitsType Limits;
   std::vector<RootMove> RootMoves;
   Position RootPosition;
+  Time SearchTime;
 }
 
 using std::string;
 using std::cout;
 using std::endl;
+using Eval::evaluate;
 using namespace Search;
 
 namespace {
@@ -117,7 +118,6 @@ namespace {
 
   size_t MultiPV, UCIMultiPV, PVIdx;
   TimeManager TimeMgr;
-  Time SearchTime;
   int BestMoveChanges;
   int SkillLevel;
   bool SkillLevelEnabled, Chess960;
@@ -135,9 +135,9 @@ namespace {
   bool connected_moves(const Position& pos, Move m1, Move m2);
   Value value_to_tt(Value v, int ply);
   Value value_from_tt(Value v, int ply);
-  bool can_return_tt(const TTEntry* tte, Depth depth, Value beta, int ply);
+  bool can_return_tt(const TTEntry* tte, Depth depth, Value ttValue, Value beta);
   bool connected_threat(const Position& pos, Move m, Move threat);
-  Value refine_eval(const TTEntry* tte, Value defaultEval, int ply);
+  Value refine_eval(const TTEntry* tte, Value ttValue, Value defaultEval);
   Move do_skill_level();
   string score_to_uci(Value v, Value alpha = -VALUE_INFINITE, Value beta = VALUE_INFINITE);
   void pv_info_to_log(Position& pos, int depth, Value score, int time, Move pv[]);
@@ -251,9 +251,8 @@ void Search::think() {
 
   Position& pos = RootPosition;
   Chess960 = pos.is_chess960();
-  EvalRootColor = pos.side_to_move();
-  SearchTime.restart();
-  TimeMgr.init(Limits, pos.startpos_ply_counter());
+  Eval::RootColor = pos.side_to_move();
+  TimeMgr.init(Limits, pos.startpos_ply_counter(), pos.side_to_move());
   TT.new_search();
   H.clear();
 
@@ -291,13 +290,13 @@ void Search::think() {
       log << "\nSearching: "  << pos.to_fen()
           << "\ninfinite: "   << Limits.infinite
           << " ponder: "      << Limits.ponder
-          << " time: "        << Limits.time
-          << " increment: "   << Limits.increment
-          << " moves to go: " << Limits.movesToGo
+          << " time: "        << Limits.time[pos.side_to_move()]
+          << " increment: "   << Limits.inc[pos.side_to_move()]
+          << " moves to go: " << Limits.movestogo
           << endl;
   }
 
-  Threads.set_size(Options["Threads"]);
+  Threads.wake_up();
 
   // Set best timer interval to avoid lagging under time pressure. Timer is
   // used to check for remaining available thinking time.
@@ -309,9 +308,8 @@ void Search::think() {
   // We're ready to start searching. Call the iterative deepening loop function
   id_loop(pos);
 
-  // Stop timer and send all the slaves to sleep, if not already sleeping
-  Threads.set_timer(0);
-  Threads.set_size(1);
+  Threads.set_timer(0); // Stop timer
+  Threads.sleep();
 
   if (Options["Use Search Log"])
   {
@@ -334,7 +332,7 @@ finalize:
   // but if we are pondering or in infinite search, we shouldn't print the best
   // move before we are told to do so.
   if (!Signals.stop && (Limits.ponder || Limits.infinite))
-      Threads[pos.thread()].wait_for_stop_or_ponderhit();
+      pos.this_thread()->wait_for_stop_or_ponderhit();
 
   // Best move could be MOVE_NONE when searching on a stalemate position
   cout << "bestmove " << move_to_uci(RootMoves[0].pv[0], Chess960)
@@ -362,7 +360,7 @@ namespace {
     ss->currentMove = MOVE_NULL; // Hack to skip update gains
 
     // Iterative deepening loop until requested to stop or target depth reached
-    while (!Signals.stop && ++depth <= MAX_PLY && (!Limits.maxDepth || depth <= Limits.maxDepth))
+    while (!Signals.stop && ++depth <= MAX_PLY && (!Limits.depth || depth <= Limits.depth))
     {
         // Save last iteration's scores before first PV line is searched and all
         // the move scores but the (new) PV are set to -VALUE_INFINITE.
@@ -532,7 +530,6 @@ namespace {
     assert(alpha >= -VALUE_INFINITE && alpha < beta && beta <= VALUE_INFINITE);
     assert((alpha == beta - 1) || PvNode);
     assert(depth > DEPTH_ZERO);
-    assert(pos.thread() >= 0 && pos.thread() < Threads.size());
 
     Move movesSearched[MAX_MOVES];
     StateInfo st;
@@ -541,12 +538,12 @@ namespace {
     Move ttMove, move, excludedMove, bestMove, threatMove;
     Depth ext, newDepth;
     Bound bt;
-    Value bestValue, value, oldAlpha;
+    Value bestValue, value, oldAlpha, ttValue;
     Value refinedValue, nullValue, futilityBase, futilityValue;
     bool isPvMove, inCheck, singularExtensionNode, givesCheck;
     bool captureOrPromotion, dangerous, doFullDepthSearch;
     int moveCount = 0, playedMoveCount = 0;
-    Thread& thread = Threads[pos.thread()];
+    Thread* thisThread = pos.this_thread();
     SplitPoint* sp = NULL;
 
     refinedValue = bestValue = value = -VALUE_INFINITE;
@@ -555,14 +552,15 @@ namespace {
     ss->ply = (ss-1)->ply + 1;
 
     // Used to send selDepth info to GUI
-    if (PvNode && thread.maxPly < ss->ply)
-        thread.maxPly = ss->ply;
+    if (PvNode && thisThread->maxPly < ss->ply)
+        thisThread->maxPly = ss->ply;
 
     // Step 1. Initialize node
     if (SpNode)
     {
         tte = NULL;
         ttMove = excludedMove = MOVE_NONE;
+        ttValue = VALUE_ZERO;
         sp = ss->sp;
         bestMove = sp->bestMove;
         threatMove = sp->threatMove;
@@ -583,7 +581,7 @@ namespace {
 
     // Step 2. Check for aborted search and immediate draw
     // Enforce node limit here. FIXME: This only works with 1 search thread.
-    if (Limits.maxNodes && pos.nodes_searched() >= Limits.maxNodes)
+    if (Limits.nodes && pos.nodes_searched() >= Limits.nodes)
         Signals.stop = true;
 
     if ((   Signals.stop
@@ -612,19 +610,19 @@ namespace {
     posKey = excludedMove ? pos.exclusion_key() : pos.key();
     tte = TT.probe(posKey);
     ttMove = RootNode ? RootMoves[PVIdx].pv[0] : tte ? tte->move() : MOVE_NONE;
+    ttValue = tte ? value_from_tt(tte->value(), ss->ply) : VALUE_ZERO;
 
     // At PV nodes we check for exact scores, while at non-PV nodes we check for
     // a fail high/low. Biggest advantage at probing at PV nodes is to have a
     // smooth experience in analysis mode. We don't probe at Root nodes otherwise
     // we should also update RootMoveList to avoid bogus output.
     if (!RootNode && tte && (PvNode ? tte->depth() >= depth && tte->type() == BOUND_EXACT
-                                    : can_return_tt(tte, depth, beta, ss->ply)))
+                                    : can_return_tt(tte, depth, ttValue, beta)))
     {
         TT.refresh(tte);
         ss->currentMove = ttMove; // Can be MOVE_NONE
-        value = value_from_tt(tte->value(), ss->ply);
 
-        if (   value >= beta
+        if (   ttValue >= beta
             && ttMove
             && !pos.is_capture_or_promotion(ttMove)
             && ttMove != ss->killers[0])
@@ -632,7 +630,7 @@ namespace {
             ss->killers[1] = ss->killers[0];
             ss->killers[0] = ttMove;
         }
-        return value;
+        return ttValue;
     }
 
     // Step 5. Evaluate the position statically and update parent's gain statistics
@@ -644,7 +642,7 @@ namespace {
 
         ss->eval = tte->static_value();
         ss->evalMargin = tte->static_value_margin();
-        refinedValue = refine_eval(tte, ss->eval, ss->ply);
+        refinedValue = refine_eval(tte, ttValue, ss->eval);
     }
     else
     {
@@ -671,7 +669,7 @@ namespace {
         &&  refinedValue + razor_margin(depth) < beta
         &&  ttMove == MOVE_NONE
         &&  abs(beta) < VALUE_MATE_IN_MAX_PLY
-        && !pos.has_pawn_on_7th(pos.side_to_move()))
+        && !pos.pawn_on_7th(pos.side_to_move()))
     {
         Value rbeta = beta - razor_margin(depth);
         Value v = qsearch<NonPV>(pos, ss, rbeta-1, rbeta, DEPTH_ZERO);
@@ -818,7 +816,7 @@ split_point_start: // At split points actual search starts from here
     // Loop through all pseudo-legal moves until no moves remain or a beta cutoff occurs
     while (   bestValue < beta
            && (move = mp.next_move()) != MOVE_NONE
-           && !thread.cutoff_occurred()
+           && !thisThread->cutoff_occurred()
            && !Signals.stop)
     {
       assert(is_ok(move));
@@ -848,7 +846,7 @@ split_point_start: // At split points actual search starts from here
       {
           Signals.firstRootMove = (moveCount == 1);
 
-          if (pos.thread() == 0 && SearchTime.elapsed() > 2000)
+          if (thisThread == Threads.main_thread() && SearchTime.elapsed() > 2000)
               cout << "info depth " << depth / ONE_PLY
                    << " currmove " << move_to_uci(move, Chess960)
                    << " currmovenumber " << moveCount + PVIdx << endl;
@@ -877,8 +875,6 @@ split_point_start: // At split points actual search starts from here
           && move == ttMove
           && pos.pl_move_is_legal(move, ci.pinned))
       {
-          Value ttValue = value_from_tt(tte->value(), ss->ply);
-
           if (abs(ttValue) < VALUE_KNOWN_WIN)
           {
               Value rBeta = ttValue - int(depth);
@@ -1042,7 +1038,7 @@ split_point_start: // At split points actual search starts from here
               && value < beta) // We want always alpha < beta
               alpha = value;
 
-          if (SpNode && !thread.cutoff_occurred())
+          if (SpNode && !thisThread->cutoff_occurred())
           {
               sp->bestValue = value;
               sp->bestMove = move;
@@ -1057,9 +1053,9 @@ split_point_start: // At split points actual search starts from here
       if (   !SpNode
           && depth >= Threads.min_split_depth()
           && bestValue < beta
-          && Threads.available_slave_exists(pos.thread())
+          && Threads.available_slave_exists(thisThread)
           && !Signals.stop
-          && !thread.cutoff_occurred())
+          && !thisThread->cutoff_occurred())
           bestValue = Threads.split<FakeSplit>(pos, ss, alpha, beta, bestValue, &bestMove,
                                                depth, threatMove, moveCount, &mp, NT);
     }
@@ -1083,7 +1079,7 @@ split_point_start: // At split points actual search starts from here
 
     // Step 21. Update tables
     // Update transposition table entry, killers and history
-    if (!SpNode && !Signals.stop && !thread.cutoff_occurred())
+    if (!SpNode && !Signals.stop && !thisThread->cutoff_occurred())
     {
         move = bestValue <= oldAlpha ? MOVE_NONE : bestMove;
         bt   = bestValue <= oldAlpha ? BOUND_UPPER
@@ -1134,11 +1130,10 @@ split_point_start: // At split points actual search starts from here
     assert(alpha >= -VALUE_INFINITE && alpha < beta && beta <= VALUE_INFINITE);
     assert((alpha == beta - 1) || PvNode);
     assert(depth <= DEPTH_ZERO);
-    assert(pos.thread() >= 0 && pos.thread() < Threads.size());
 
     StateInfo st;
     Move ttMove, move, bestMove;
-    Value bestValue, value, evalMargin, futilityValue, futilityBase;
+    Value ttValue, bestValue, value, evalMargin, futilityValue, futilityBase;
     bool inCheck, enoughMaterial, givesCheck, evasionPrunable;
     const TTEntry* tte;
     Depth ttDepth;
@@ -1162,11 +1157,12 @@ split_point_start: // At split points actual search starts from here
     // pruning, but only for move ordering.
     tte = TT.probe(pos.key());
     ttMove = (tte ? tte->move() : MOVE_NONE);
+    ttValue = tte ? value_from_tt(tte->value(),ss->ply) : VALUE_ZERO;
 
-    if (!PvNode && tte && can_return_tt(tte, ttDepth, beta, ss->ply))
+    if (!PvNode && tte && can_return_tt(tte, ttDepth, ttValue, beta))
     {
         ss->currentMove = ttMove; // Can be MOVE_NONE
-        return value_from_tt(tte->value(), ss->ply);
+        return ttValue;
     }
 
     // Evaluate the position statically
@@ -1334,7 +1330,7 @@ split_point_start: // At split points actual search starts from here
     kingAtt = pos.attacks_from<KING>(ksq);
     pc = pos.piece_moved(move);
 
-    occ = pos.occupied_squares() & ~(1ULL << from) & ~(1ULL << ksq);
+    occ = pos.pieces() ^ from ^ ksq;
     oldAtt = pos.attacks_from(pc, from, occ);
     newAtt = pos.attacks_from(pc,   to, occ);
 
@@ -1402,7 +1398,7 @@ split_point_start: // At split points actual search starts from here
     ksq = pos.king_square(pos.side_to_move());
     if (    piece_is_slider(p1)
         && (squares_between(t1, ksq) & f2)
-        && (pos.attacks_from(p1, t1, pos.occupied_squares() ^ f2) & ksq))
+        && (pos.attacks_from(p1, t1, pos.pieces() ^ f2) & ksq))
         return true;
 
     return false;
@@ -1484,9 +1480,7 @@ split_point_start: // At split points actual search starts from here
   // can_return_tt() returns true if a transposition table score can be used to
   // cut-off at a given point in search.
 
-  bool can_return_tt(const TTEntry* tte, Depth depth, Value beta, int ply) {
-
-    Value v = value_from_tt(tte->value(), ply);
+  bool can_return_tt(const TTEntry* tte, Depth depth, Value v, Value beta) {
 
     return   (   tte->depth() >= depth
               || v >= std::max(VALUE_MATE_IN_MAX_PLY, beta)
@@ -1500,12 +1494,10 @@ split_point_start: // At split points actual search starts from here
   // refine_eval() returns the transposition table score if possible, otherwise
   // falls back on static position evaluation.
 
-  Value refine_eval(const TTEntry* tte, Value defaultEval, int ply) {
+  Value refine_eval(const TTEntry* tte, Value v, Value defaultEval) {
 
       assert(tte);
 
-      Value v = value_from_tt(tte->value(), ply);
-
       if (   ((tte->type() & BOUND_LOWER) && v >= defaultEval)
           || ((tte->type() & BOUND_UPPER) && v < defaultEval))
           return v;
@@ -1833,8 +1825,7 @@ void Thread::idle_loop(SplitPoint* sp_master) {
           lock_release(Threads.splitLock);
 
           Stack ss[MAX_PLY_PLUS_2];
-          Position pos(*sp->pos, threadID);
-          int master = sp->master;
+          Position pos(*sp->pos, this);
 
           memcpy(ss, sp->ss - 1, 4 * sizeof(Stack));
           (ss+1)->sp = sp;
@@ -1853,20 +1844,21 @@ void Thread::idle_loop(SplitPoint* sp_master) {
           assert(is_searching);
 
           is_searching = false;
-          sp->slavesMask &= ~(1ULL << threadID);
+          sp->slavesMask &= ~(1ULL << idx);
           sp->nodes += pos.nodes_searched();
 
-          // After releasing the lock we cannot access anymore any SplitPoint
-          // related data in a reliably way becuase it could have been released
-          // under our feet by the sp master.
-          lock_release(sp->lock);
-
           // Wake up master thread so to allow it to return from the idle loop in
           // case we are the last slave of the split point.
           if (   Threads.use_sleeping_threads()
-              && threadID != master
-              && !Threads[master].is_searching)
-              Threads[master].wake_up();
+              && this != sp->master
+              && !sp->master->is_searching)
+              sp->master->wake_up();
+
+          // After releasing the lock we cannot access anymore any SplitPoint
+          // related data in a safe way becuase it could have been released under
+          // our feet by the sp master. Also accessing other Thread objects is
+          // unsafe because if we are exiting there is a chance are already freed.
+          lock_release(sp->lock);
       }
   }
 }
@@ -1898,6 +1890,6 @@ void check_time() {
                    || stillAtFirstMove;
 
   if (   (Limits.use_time_management() && noMoreTime)
-      || (Limits.maxTime && e >= Limits.maxTime))
+      || (Limits.movetime && e >= Limits.movetime))
       Signals.stop = true;
 }