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);
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;
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
// 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<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);
{
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
{
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
assert(PvNode || (alpha == beta - 1));
assert(depth <= DEPTH_ZERO);
- PVEntry pv;
+ Move pv[MAX_PLY+1];
StateInfo st;
const TTEntry* tte;
Key posKey;
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;
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
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
{
}
+ // 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.
// Increase history value of the cut-off move and decrease all the other
// played quiet moves.
- Value bonus = Value(4 * int(depth) * int(depth));
+ Value bonus = Value(int(depth) * int(depth));
History.update(pos.moved_piece(move), to_sq(move), bonus);
for (int i = 0; i < quietsCnt; ++i)
{
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++);
}