Codying style in accurate PV

This is the first of a patch series to
rearrange and simplify accurate PV.

In this patch there is simple coding
style and reformatting stuff.

Verified with fishtest it does not crash
with MAX_PLY = 8

No functional change.

src/search.cpp

@@ -87,6 +87,7 @@ namespace {
   void id_loop(Position& pos);
   Value value_to_tt(Value v, int ply);
   Value value_from_tt(Value v, int ply);
+  void update_pv(Move* pv, Move move, Move* child);
   void update_stats(const Position& pos, Stack* ss, Move move, Depth depth, Move* quiets, int quietsCnt);
   string uci_pv(const Position& pos, Depth depth, Value alpha, Value beta);
 
@@ -394,8 +395,7 @@ namespace {
     assert(PvNode || (alpha == beta - 1));
     assert(depth > DEPTH_ZERO);
 
-    PVEntry pv;
+    Move pv[MAX_PLY+1], quietsSearched[64];
-    Move quietsSearched[64];
     StateInfo st;
     const TTEntry *tte;
     SplitPoint* splitPoint;
@@ -466,10 +466,7 @@ namespace {
     ss->ttMove = ttMove = RootNode ? RootMoves[PVIdx].pv[0] : tte ? tte->move() : MOVE_NONE;
     ttValue = tte ? value_from_tt(tte->value(), ss->ply) : VALUE_NONE;
 
-    // At PV nodes we check for exact scores, whilst at non-PV nodes we check for
+    // At non-PV nodes we check for a fail high/low. We don't probe at PV nodes
-    // a fail high/low. The biggest advantage to 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 (  !PvNode
         && tte
         && tte->depth() >= depth
@@ -865,14 +862,16 @@ moves_loop: // When in check and at SpNode search starts from here
       // For PV nodes only, do a full PV search on the first move or after a fail
       // high (in the latter case search only if value < beta), otherwise let the
       // parent node fail low with value <= alpha and to try another move.
-      if (PvNode && (moveCount == 1 || (value > alpha && (RootNode || value < beta)))) {
+      if (PvNode && (moveCount == 1 || (value > alpha && (RootNode || value < beta))))
-          pv.pv[0] = MOVE_NONE;
+      {
-          (ss+1)->pv = &pv;
+          pv[0] = MOVE_NONE;
+          (ss+1)->pv = pv;
           value = newDepth <   ONE_PLY ?
                             givesCheck ? -qsearch<PV,  true>(pos, ss+1, -beta, -alpha, DEPTH_ZERO)
                                        : -qsearch<PV, false>(pos, ss+1, -beta, -alpha, DEPTH_ZERO)
                                        : - search<PV, false>(pos, ss+1, -beta, -alpha, newDepth, false);
       }
+
       // Step 17. Undo move
       pos.undo_move(move);
 
@@ -901,8 +900,8 @@ moves_loop: // When in check and at SpNode search starts from here
           {
               rm.score = value;
               rm.pv.resize(1);
-              for (int i = 0; (ss+1)->pv && i < MAX_PLY && (ss+1)->pv->pv[i] != MOVE_NONE; ++i)
+              for (int i = 0; (ss+1)->pv && (ss+1)->pv[i] != MOVE_NONE; ++i)
-                  rm.pv.push_back((ss+1)->pv->pv[i]);
+                  rm.pv.push_back((ss+1)->pv[i]);
 
               // We record how often the best move has been changed in each
               // iteration. This information is used for time management: When
@@ -925,10 +924,11 @@ moves_loop: // When in check and at SpNode search starts from here
           {
               bestMove = SpNode ? splitPoint->bestMove = move : move;
 
-              if (NT == PV) {
+              if (PvNode && !RootNode)
-                  ss->pv->update(move, (ss+1)->pv);
+              {
+                  update_pv(ss->pv, move, (ss+1)->pv);
                   if (SpNode)
-                      splitPoint->ss->pv->update(move, (ss+1)->pv);
+                      update_pv(splitPoint->ss->pv, move, (ss+1)->pv);
               }
 
               if (PvNode && value < beta) // Update alpha! Always alpha < beta
@@ -1015,7 +1015,7 @@ moves_loop: // When in check and at SpNode search starts from here
     assert(PvNode || (alpha == beta - 1));
     assert(depth <= DEPTH_ZERO);
 
-    PVEntry pv;
+    Move pv[MAX_PLY+1];
     StateInfo st;
     const TTEntry* tte;
     Key posKey;
@@ -1024,12 +1024,11 @@ moves_loop: // When in check and at SpNode search starts from here
     bool givesCheck, evasionPrunable;
     Depth ttDepth;
 
-    if (PvNode) {
+    if (PvNode)
-        // To flag BOUND_EXACT a node with eval above alpha and no available moves
+    {
-        oldAlpha = alpha;
+        oldAlpha = alpha; // To flag BOUND_EXACT when eval above alpha and no available moves
-
+        (ss+1)->pv = pv;
-        (ss+1)->pv = &pv;
+        ss->pv[0] = MOVE_NONE;
-        ss->pv->pv[0] = MOVE_NONE;
     }
 
     ss->currentMove = bestMove = MOVE_NONE;
@@ -1181,7 +1180,7 @@ moves_loop: // When in check and at SpNode search starts from here
           if (value > alpha)
           {
               if (PvNode)
-                  ss->pv->update(move, &pv);
+                  update_pv(ss->pv, move, (ss+1)->pv);
 
               if (PvNode && value < beta) // Update alpha here! Always alpha < beta
               {
@@ -1239,6 +1238,15 @@ moves_loop: // When in check and at SpNode search starts from here
   }
 
 
+  // update_pv() copies child node pv[] adding current move
+
+  void update_pv(Move* pv, Move move, Move* child) {
+
+    for (*pv++ = move; child && *child != MOVE_NONE; )
+        *pv++ = *child++;
+    *pv = MOVE_NONE;
+  }
+
   // update_stats() updates killers, history, countermoves and followupmoves stats after a fail-high
   // of a quiet move.
 
@@ -1371,15 +1379,17 @@ void RootMove::insert_pv_in_tt(Position& pos) {
 
   StateInfo state[MAX_PLY], *st = state;
   const TTEntry* tte;
-  int idx = 0;
+  size_t idx = 0;
 
-  for (; idx < int(pv.size()); ++idx) {
+  for ( ; idx < pv.size(); ++idx)
+  {
       tte = TT.probe(pos.key());
 
       if (!tte || tte->move() != pv[idx]) // Don't overwrite correct entries
           TT.store(pos.key(), VALUE_NONE, BOUND_NONE, DEPTH_NONE, pv[idx], VALUE_NONE);
 
       assert(MoveList<LEGAL>(pos).contains(pv[idx]));
+
       pos.do_move(pv[idx], *st++);
   }
 

src/search.h

@@ -32,26 +32,13 @@ struct SplitPoint;
 
 namespace Search {
 
-struct PVEntry {
-  Move pv[MAX_PLY+1];
-
-  void update(Move move, PVEntry* child) {
-      pv[0] = move;
-
-      int i = 1;
-      for (; child && i < MAX_PLY && child->pv[i - 1] != MOVE_NONE; ++i)
-          pv[i] = child->pv[i - 1];
-      pv[i] = MOVE_NONE;
-  } 
-};
-
 /// The Stack struct keeps track of the information we need to remember from
 /// nodes shallower and deeper in the tree during the search. Each search thread
 /// has its own array of Stack objects, indexed by the current ply.
 
 struct Stack {
   SplitPoint* splitPoint;
-  PVEntry* pv;
+  Move* pv;
   int ply;
   Move currentMove;
   Move ttMove;