if (!RootNode)
{
// Step 2. Check for aborted search and immediate draw
- if (Signals.stop || pos.is_draw<false,true>() || ss->ply > MAX_PLY)
+ if (Signals.stop || pos.is_draw<true, PvNode>() || ss->ply > MAX_PLY)
return DrawValue[pos.side_to_move()];
// Step 3. Mate distance pruning. Even if we mate at the next move our score
if (alpha >= beta)
return alpha;
}
- else
- {
- if(pos.is_draw<false,false>()) return DrawValue[pos.side_to_move()];
- }
// Step 4. Transposition table lookup
// We don't want the score of a partial search to overwrite a previous full search
// 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 && tte->depth() >= depth
+ && tte
+ && tte->depth() >= depth
+ && ttValue != VALUE_NONE // Only in case of TT access race
&& ( PvNode ? tte->type() == BOUND_EXACT
: ttValue >= beta ? (tte->type() & BOUND_LOWER)
: (tte->type() & BOUND_UPPER)))
{
- assert(ttValue != VALUE_NONE); // Due to depth > DEPTH_NONE
-
TT.refresh(tte);
ss->currentMove = ttMove; // Can be MOVE_NONE
else if (tte)
{
- assert(tte->static_value() != VALUE_NONE);
- assert(ttValue != VALUE_NONE || tte->type() == BOUND_NONE);
+ // Following asserts are valid only in single thread condition because
+ // TT access is always racy and its contents cannot be trusted.
+ assert(tte->static_value() != VALUE_NONE || Threads.size() > 1);
+ assert(ttValue != VALUE_NONE || tte->type() == BOUND_NONE || Threads.size() > 1);
ss->staticEval = eval = tte->static_value();
ss->evalMargin = tte->static_value_margin();
+ if (eval == VALUE_NONE || ss->evalMargin == VALUE_NONE) // Due to a race
+ eval = ss->staticEval = evaluate(pos, ss->evalMargin);
+
// Can ttValue be used as a better position evaluation?
- if ( ((tte->type() & BOUND_LOWER) && ttValue > eval)
- || ((tte->type() & BOUND_UPPER) && ttValue < eval))
- eval = ttValue;
+ if (ttValue != VALUE_NONE)
+ if ( ((tte->type() & BOUND_LOWER) && ttValue > eval)
+ || ((tte->type() & BOUND_UPPER) && ttValue < eval))
+ eval = ttValue;
}
else
{
ss->ply = (ss-1)->ply + 1;
// Check for an instant draw or maximum ply reached
- if (pos.is_draw<true,true>() || ss->ply > MAX_PLY)
+ if (pos.is_draw<false, false>() || ss->ply > MAX_PLY)
return DrawValue[pos.side_to_move()];
// Transposition table lookup. At PV nodes, we don't use the TT for
// only two types of depth in TT: DEPTH_QS_CHECKS or DEPTH_QS_NO_CHECKS.
ttDepth = inCheck || depth >= DEPTH_QS_CHECKS ? DEPTH_QS_CHECKS
: DEPTH_QS_NO_CHECKS;
- if ( tte && tte->depth() >= ttDepth
+ if ( tte
+ && tte->depth() >= ttDepth
+ && ttValue != VALUE_NONE // Only in case of TT access race
&& ( PvNode ? tte->type() == BOUND_EXACT
: ttValue >= beta ? (tte->type() & BOUND_LOWER)
: (tte->type() & BOUND_UPPER)))
{
- assert(ttValue != VALUE_NONE); // Due to ttDepth > DEPTH_NONE
-
ss->currentMove = ttMove; // Can be MOVE_NONE
return ttValue;
}
{
if (tte)
{
- assert(tte->static_value() != VALUE_NONE);
+ assert(tte->static_value() != VALUE_NONE || Threads.size() > 1);
ss->staticEval = bestValue = tte->static_value();
ss->evalMargin = tte->static_value_margin();
+
+ if (ss->staticEval == VALUE_NONE || ss->evalMargin == VALUE_NONE) // Due to a race
+ ss->staticEval = bestValue = evaluate(pos, ss->evalMargin);
}
else
ss->staticEval = bestValue = evaluate(pos, ss->evalMargin);
StateInfo state[MAX_PLY_PLUS_2], *st = state;
TTEntry* tte;
- int ply = 1;
+ int ply = 0;
Move m = pv[0];
- assert(m != MOVE_NONE && pos.is_pseudo_legal(m));
-
pv.clear();
- pv.push_back(m);
- pos.do_move(m, *st++);
-
- while ( (tte = TT.probe(pos.key())) != NULL
- && (m = tte->move()) != MOVE_NONE // Local copy, TT entry could change
- && pos.is_pseudo_legal(m)
- && pos.pl_move_is_legal(m, pos.pinned_pieces())
- && ply < MAX_PLY
- && (!pos.is_draw<false,true>() || ply < 2))
- {
+
+ do {
pv.push_back(m);
- pos.do_move(m, *st++);
- ply++;
- }
- pv.push_back(MOVE_NONE);
- do pos.undo_move(pv[--ply]); while (ply);
+ assert(pos.move_is_legal(pv[ply]));
+ pos.do_move(pv[ply++], *st++);
+ tte = TT.probe(pos.key());
+
+ } while ( tte
+ && pos.is_pseudo_legal(m = tte->move()) // Local copy, TT could change
+ && pos.pl_move_is_legal(m, pos.pinned_pieces())
+ && ply < MAX_PLY
+ && (!pos.is_draw<true, true>() || ply < 2));
+
+ pv.push_back(MOVE_NONE); // Must be zero-terminating
+
+ while (ply) pos.undo_move(pv[--ply]);
}
StateInfo state[MAX_PLY_PLUS_2], *st = state;
TTEntry* tte;
- Key k;
- Value v, m = VALUE_NONE;
int ply = 0;
-
- assert(pv[ply] != MOVE_NONE && pos.is_pseudo_legal(pv[ply]));
+ Value v, m;
do {
- k = pos.key();
- tte = TT.probe(k);
+ tte = TT.probe(pos.key());
- // Don't overwrite existing correct entries
- if (!tte || tte->move() != pv[ply])
+ if (!tte || tte->move() != pv[ply]) // Don't overwrite correct entries
{
- v = (pos.in_check() ? VALUE_NONE : evaluate(pos, m));
- TT.store(k, VALUE_NONE, BOUND_NONE, DEPTH_NONE, pv[ply], v, m);
+ if (pos.in_check())
+ v = m = VALUE_NONE;
+ else
+ v = evaluate(pos, m);
+
+ TT.store(pos.key(), VALUE_NONE, BOUND_NONE, DEPTH_NONE, pv[ply], v, m);
}
- pos.do_move(pv[ply], *st++);
- } while (pv[++ply] != MOVE_NONE);
+ assert(pos.move_is_legal(pv[ply]));
+ pos.do_move(pv[ply++], *st++);
+
+ } while (pv[ply] != MOVE_NONE);
- do pos.undo_move(pv[--ply]); while (ply);
+ while (ply) pos.undo_move(pv[--ply]);
}
projects / stockfish / blobdiff