Retire ss->bestMove

And introduce SPlitPoint bestMove to pass back the
best move after a split point.

This allow to define as const the search stack passed
to split.

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>

diff --git a/src/search.cpp b/src/search.cpp
index e53baabd98903430ae37bdc78d4bf64e3e4525bf..a322a01df4cec0fe93f517f5fc2c6c6049641718 100644 (file)
--- a/src/search.cpp
+++ b/src/search.cpp
@@ -548,7 +548,7 @@ namespace {
     StateInfo st;
     const TTEntry *tte;
     Key posKey;
-    Move ttMove, move, excludedMove, threatMove;
+    Move ttMove, move, excludedMove, bestMove, threatMove;
     Depth ext, newDepth;
     Bound bt;
     Value bestValue, value, oldAlpha;
@@ -574,6 +574,7 @@ namespace {
         tte = NULL;
         ttMove = excludedMove = MOVE_NONE;
         sp = ss->sp;
+        bestMove = sp->bestMove;
         threatMove = sp->threatMove;
         bestValue = sp->bestValue;
         moveCount = sp->moveCount; // Lock must be held here
@@ -584,7 +585,7 @@ namespace {
     }
     else
     {
-        ss->currentMove = ss->bestMove = threatMove = (ss+1)->excludedMove = MOVE_NONE;
+        ss->currentMove = threatMove = (ss+1)->excludedMove = bestMove = MOVE_NONE;
         (ss+1)->skipNullMove = false; (ss+1)->reduction = DEPTH_ZERO;
         (ss+2)->killers[0] = (ss+2)->killers[1] = MOVE_NONE;
 
@@ -630,16 +631,16 @@ namespace {
                                     : can_return_tt(tte, depth, beta, ss->ply)))
     {
         TT.refresh(tte);
-        ss->bestMove = move = ttMove; // Can be MOVE_NONE
+        ss->currentMove = ttMove; // Can be MOVE_NONE
         value = value_from_tt(tte->value(), ss->ply);
 
         if (   value >= beta
-            && move
-            && !pos.is_capture_or_promotion(move)
-            && move != ss->killers[0])
+            && ttMove
+            && !pos.is_capture_or_promotion(ttMove)
+            && ttMove != ss->killers[0])
         {
             ss->killers[1] = ss->killers[0];
-            ss->killers[0] = move;
+            ss->killers[0] = ttMove;
         }
         return value;
     }
@@ -752,7 +753,7 @@ namespace {
             // 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).
-            threatMove = (ss+1)->bestMove;
+            threatMove = (ss+1)->currentMove;
 
             if (   depth < ThreatDepth
                 && (ss-1)->reduction
@@ -778,6 +779,7 @@ namespace {
 
         assert(rdepth >= ONE_PLY);
         assert((ss-1)->currentMove != MOVE_NONE);
+        assert((ss-1)->currentMove != MOVE_NULL);
 
         MovePicker mp(pos, ttMove, H, pos.captured_piece_type());
         CheckInfo ci(pos);
@@ -813,7 +815,6 @@ split_point_start: // At split points actual search starts from here
 
     MovePickerExt<SpNode> mp(pos, ttMove, depth, H, ss, PvNode ? -VALUE_INFINITE : beta);
     CheckInfo ci(pos);
-    ss->bestMove = MOVE_NONE;
     futilityBase = ss->eval + ss->evalMargin;
     singularExtensionNode =   !RootNode
                            && !SpNode
@@ -896,7 +897,6 @@ split_point_start: // At split points actual search starts from here
               value = search<NonPV>(pos, ss, rBeta - 1, rBeta, depth / 2);
               ss->skipNullMove = false;
               ss->excludedMove = MOVE_NONE;
-              ss->bestMove = MOVE_NONE;
               if (value < rBeta)
                   ext = ONE_PLY;
           }
@@ -1045,7 +1045,7 @@ split_point_start: // At split points actual search starts from here
       if (value > bestValue)
       {
           bestValue = value;
-          ss->bestMove = move;
+          bestMove = move;
 
           if (   PvNode
               && value > alpha
@@ -1055,7 +1055,7 @@ split_point_start: // At split points actual search starts from here
           if (SpNode && !thread.cutoff_occurred())
           {
               sp->bestValue = value;
-              sp->ss->bestMove = move;
+              sp->bestMove = move;
               sp->alpha = alpha;
 
               if (value >= beta)
@@ -1070,8 +1070,8 @@ split_point_start: // At split points actual search starts from here
           && Threads.available_slave_exists(pos.thread())
           && !Signals.stop
           && !thread.cutoff_occurred())
-          bestValue = Threads.split<FakeSplit>(pos, ss, alpha, beta, bestValue, depth,
-                                               threatMove, moveCount, &mp, NT);
+          bestValue = Threads.split<FakeSplit>(pos, ss, alpha, beta, bestValue, &bestMove,
+                                               depth, threatMove, moveCount, &mp, NT);
     }
 
     // Step 20. Check for mate and stalemate
@@ -1088,14 +1088,14 @@ split_point_start: // At split points actual search starts from here
     {
         assert(!playedMoveCount);
 
-        bestValue = alpha;
+        bestValue = oldAlpha;
     }
 
     // Step 21. Update tables
     // Update transposition table entry, killers and history
     if (!SpNode && !Signals.stop && !thread.cutoff_occurred())
     {
-        move = bestValue <= oldAlpha ? MOVE_NONE : ss->bestMove;
+        move = bestValue <= oldAlpha ? MOVE_NONE : bestMove;
         bt   = bestValue <= oldAlpha ? BOUND_UPPER
              : bestValue >= beta ? BOUND_LOWER : BOUND_EXACT;
 
@@ -1147,7 +1147,7 @@ split_point_start: // At split points actual search starts from here
     assert(pos.thread() >= 0 && pos.thread() < Threads.size());
 
     StateInfo st;
-    Move ttMove, move;
+    Move ttMove, move, bestMove;
     Value bestValue, value, evalMargin, futilityValue, futilityBase;
     bool inCheck, enoughMaterial, givesCheck, evasionPrunable;
     const TTEntry* tte;
@@ -1155,7 +1155,7 @@ split_point_start: // At split points actual search starts from here
     Bound bt;
     Value oldAlpha = alpha;
 
-    ss->bestMove = ss->currentMove = MOVE_NONE;
+    ss->currentMove = bestMove = MOVE_NONE;
     ss->ply = (ss-1)->ply + 1;
 
     // Check for an instant draw or maximum ply reached
@@ -1175,7 +1175,7 @@ split_point_start: // At split points actual search starts from here
 
     if (!PvNode && tte && can_return_tt(tte, ttDepth, beta, ss->ply))
     {
-        ss->bestMove = ttMove; // Can be MOVE_NONE
+        ss->currentMove = ttMove; // Can be MOVE_NONE
         return value_from_tt(tte->value(), ss->ply);
     }
 
@@ -1299,7 +1299,7 @@ split_point_start: // At split points actual search starts from here
       if (value > bestValue)
       {
           bestValue = value;
-          ss->bestMove = move;
+          bestMove = move;
 
           if (   PvNode
               && value > alpha
@@ -1314,7 +1314,7 @@ split_point_start: // At split points actual search starts from here
         return mated_in(ss->ply); // Plies to mate from the root
 
     // Update transposition table
-    move = bestValue <= oldAlpha ? MOVE_NONE : ss->bestMove;
+    move = bestValue <= oldAlpha ? MOVE_NONE : bestMove;
     bt   = bestValue <= oldAlpha ? BOUND_UPPER
          : bestValue >= beta ? BOUND_LOWER : BOUND_EXACT;
 

diff --git a/src/search.h b/src/search.h
index a4cba6bf700ed7e716b8a8aaf2fdd1c723290b42..bd371a4aac1b705fb3b6a8eb1a1df9c7799bf09a 100644 (file)
--- a/src/search.h
+++ b/src/search.h
@@ -39,7 +39,6 @@ struct Stack {
   int ply;
   Move currentMove;
   Move excludedMove;
-  Move bestMove;
   Move killers[2];
   Depth reduction;
   Value eval;

diff --git a/src/thread.cpp b/src/thread.cpp
index 4fa081482ffab4144de201a4fd56014e25c1be19..7ffc3dfe8e78ed6823dde782cffe4b6ab3768f52 100644 (file)
--- a/src/thread.cpp
+++ b/src/thread.cpp
@@ -299,8 +299,8 @@ bool ThreadsManager::available_slave_exists(int master) const {
 
 template <bool Fake>
 Value ThreadsManager::split(Position& pos, Stack* ss, Value alpha, Value beta,
-                            Value bestValue, Depth depth, Move threatMove,
-                            int moveCount, MovePicker* mp, int nodeType) {
+                            Value bestValue, Move* bestMove, Depth depth,
+                            Move threatMove, int moveCount, MovePicker *mp, int nodeType) {
   assert(pos.pos_is_ok());
   assert(bestValue > -VALUE_INFINITE);
   assert(bestValue <= alpha);
@@ -324,6 +324,7 @@ Value ThreadsManager::split(Position& pos, Stack* ss, Value alpha, Value beta,
   sp->cutoff = false;
   sp->slavesMask = 1ULL << master;
   sp->depth = depth;
+  sp->bestMove = *bestMove;
   sp->threatMove = threatMove;
   sp->alpha = alpha;
   sp->beta = beta;
@@ -387,6 +388,7 @@ Value ThreadsManager::split(Position& pos, Stack* ss, Value alpha, Value beta,
   masterThread.splitPointsCnt--;
   masterThread.curSplitPoint = sp->parent;
   pos.set_nodes_searched(pos.nodes_searched() + sp->nodes);
+  *bestMove = sp->bestMove;
 
   lock_release(splitLock);
   lock_release(sp->lock);
@@ -395,8 +397,8 @@ Value ThreadsManager::split(Position& pos, Stack* ss, Value alpha, Value beta,
 }
 
 // Explicit template instantiations
-template Value ThreadsManager::split<false>(Position&, Stack*, Value, Value, Value, Depth, Move, int, MovePicker*, int);
-template Value ThreadsManager::split<true>(Position&, Stack*, Value, Value, Value, Depth, Move, int, MovePicker*, int);
+template Value ThreadsManager::split<false>(Position&, Stack*, Value, Value, Value, Move*, Depth, Move, int, MovePicker*, int);
+template Value ThreadsManager::split<true>(Position&, Stack*, Value, Value, Value, Move*, Depth, Move, int, MovePicker*, int);
 
 
 // ThreadsManager::set_timer() is used to set the timer to trigger after msec

diff --git a/src/thread.h b/src/thread.h
index e863d3269237b66fab96108422926eb3b9669eb0..11c8778d8e21e4ce8a5c603fecb0e74981509a5e 100644 (file)
--- a/src/thread.h
+++ b/src/thread.h
@@ -34,9 +34,9 @@ const int MAX_SPLITPOINTS_PER_THREAD = 8;
 
 struct SplitPoint {
 
-  // Const data after splitPoint has been setup
-  SplitPoint* parent;
+  // Const data after split point has been setup
   const Position* pos;
+  const Search::Stack* ss;
   Depth depth;
   Value beta;
   int nodeType;
@@ -45,7 +45,8 @@ struct SplitPoint {
 
   // Const pointers to shared data
   MovePicker* mp;
-  Search::Stack* ss;
+  SplitPoint* parent;
+
 
   // Shared data
   Lock lock;
@@ -53,6 +54,7 @@ struct SplitPoint {
   volatile int64_t nodes;
   volatile Value alpha;
   volatile Value bestValue;
+  volatile Move bestMove;
   volatile int moveCount;
   volatile bool cutoff;
 };
@@ -116,7 +118,7 @@ public:
                       const std::set<Move>& = std::set<Move>(), bool async = false);
 
   template <bool Fake>
-  Value split(Position& pos, Search::Stack* ss, Value alpha, Value beta, Value bestValue,
+  Value split(Position& pos, Search::Stack* ss, Value alpha, Value beta, Value bestValue, Move* bestMove,
               Depth depth, Move threatMove, int moveCount, MovePicker* mp, int nodeType);
 private:
   friend struct Thread;