From: Marco Costalba Date: Tue, 18 Nov 2014 10:57:57 +0000 (+0100) Subject: Codying style in accurate PV X-Git-Url: https://git.sesse.net/?p=stockfish;a=commitdiff_plain;h=4aca11ae2a37df653b54f554a3d8b3005c063447;ds=sidebyside 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. --- diff --git a/src/search.cpp b/src/search.cpp index 5e356115..31e94447 100644 --- a/src/search.cpp +++ b/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 quietsSearched[64]; + Move pv[MAX_PLY+1], quietsSearched[64]; StateInfo st; const TTEntry *tte; SplitPoint* splitPoint; @@ -466,11 +466,8 @@ 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 - // 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 + // At non-PV nodes we check for a fail high/low. We don't probe at PV nodes + if ( !PvNode && tte && tte->depth() >= depth && ttValue != VALUE_NONE // Only in case of TT access race @@ -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)))) { - pv.pv[0] = MOVE_NONE; - (ss+1)->pv = &pv; + if (PvNode && (moveCount == 1 || (value > alpha && (RootNode || value < beta)))) + { + pv[0] = MOVE_NONE; + (ss+1)->pv = pv; value = newDepth < ONE_PLY ? givesCheck ? -qsearch(pos, ss+1, -beta, -alpha, DEPTH_ZERO) : -qsearch(pos, ss+1, -beta, -alpha, DEPTH_ZERO) : - search(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) - rm.pv.push_back((ss+1)->pv->pv[i]); + for (int i = 0; (ss+1)->pv && (ss+1)->pv[i] != MOVE_NONE; ++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) { - ss->pv->update(move, (ss+1)->pv); + if (PvNode && !RootNode) + { + 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) { - // To flag BOUND_EXACT a node with eval above alpha and no available moves - oldAlpha = alpha; - - (ss+1)->pv = &pv; - ss->pv->pv[0] = MOVE_NONE; + if (PvNode) + { + oldAlpha = alpha; // To flag BOUND_EXACT when eval above alpha and no available moves + (ss+1)->pv = pv; + ss->pv[0] = MOVE_NONE; } ss->currentMove = bestMove = MOVE_NONE; @@ -1053,7 +1052,7 @@ moves_loop: // When in check and at SpNode search starts from here ttMove = tte ? tte->move() : MOVE_NONE; ttValue = tte ? value_from_tt(tte->value(),ss->ply) : VALUE_NONE; - if ( !PvNode + if ( !PvNode && tte && tte->depth() >= ttDepth && ttValue != VALUE_NONE // Only in case of TT access race @@ -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(pos).contains(pv[idx])); + pos.do_move(pv[idx], *st++); } diff --git a/src/search.h b/src/search.h index afa12b3a..a399beba 100644 --- a/src/search.h +++ b/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;