RootMoveList Rml;
// MultiPV mode
- int MultiPV, UCIMultiPV, MultiPVIteration;
+ int MultiPV, UCIMultiPV, MultiPVIdx;
// Time management variables
bool StopOnPonderhit, FirstRootMove, StopRequest, QuitRequest, AspirationFailLow;
if (moveIsCheck && pos.see_sign(m) >= 0)
result += CheckExtension[PvNode];
- if (piece_type(pos.piece_on(move_from(m))) == PAWN)
+ if (type_of(pos.piece_on(move_from(m))) == PAWN)
{
Color c = pos.side_to_move();
if (relative_rank(c, move_to(m)) == RANK_7)
}
if ( captureOrPromotion
- && piece_type(pos.piece_on(move_to(m))) != PAWN
+ && type_of(pos.piece_on(move_to(m))) != PAWN
&& ( pos.non_pawn_material(WHITE) + pos.non_pawn_material(BLACK)
- piece_value_midgame(pos.piece_on(move_to(m))) == VALUE_ZERO)
- && !move_is_special(m))
+ && !is_special(m))
{
result += PawnEndgameExtension[PvNode];
*dangerous = true;
bool think(Position& pos, const SearchLimits& limits, Move searchMoves[]) {
- static Book book;
+ static Book book; // Define static to initialize the PRNG only once
// Initialize global search-related variables
StopOnPonderhit = StopRequest = QuitRequest = AspirationFailLow = false;
if (Options["Book File"].value<string>() != book.name())
book.open(Options["Book File"].value<string>());
- Move bookMove = book.get_move(pos, Options["Best Book Move"].value<bool>());
+ Move bookMove = book.probe(pos, Options["Best Book Move"].value<bool>());
if (bookMove != MOVE_NONE)
{
if (Limits.ponder)
read_evaluation_uci_options(pos.side_to_move());
Threads.read_uci_options();
- // Allocate pawn and material hash tables if number of active threads
- // increased and set a new TT size if changed.
- Threads.init_hash_tables();
+ // Set a new TT size if changed
TT.set_size(Options["Hash"].value<int>());
if (Options["Clear Hash"].value<bool>())
// Iterative deepening loop until requested to stop or target depth reached
while (!StopRequest && ++depth <= PLY_MAX && (!Limits.maxDepth || depth <= Limits.maxDepth))
{
- // Save last iteration's scores, this needs to be done now, because in
- // the following MultiPV loop Rml moves could be reordered.
+ // Save now last iteration's scores, before Rml moves are reordered
for (size_t i = 0; i < Rml.size(); i++)
Rml[i].prevScore = Rml[i].score;
Rml.bestMoveChanges = 0;
- // MultiPV iteration loop
- for (MultiPVIteration = 0; MultiPVIteration < Min(MultiPV, (int)Rml.size()); MultiPVIteration++)
+ // MultiPV loop. We perform a full root search for each PV line
+ for (MultiPVIdx = 0; MultiPVIdx < Min(MultiPV, (int)Rml.size()); MultiPVIdx++)
{
// Calculate dynamic aspiration window based on previous iterations
- if (depth >= 5 && abs(Rml[MultiPVIteration].prevScore) < VALUE_KNOWN_WIN)
+ if (depth >= 5 && abs(Rml[MultiPVIdx].prevScore) < VALUE_KNOWN_WIN)
{
int prevDelta1 = bestValues[depth - 1] - bestValues[depth - 2];
int prevDelta2 = bestValues[depth - 2] - bestValues[depth - 3];
aspirationDelta = Min(Max(abs(prevDelta1) + abs(prevDelta2) / 2, 16), 24);
aspirationDelta = (aspirationDelta + 7) / 8 * 8; // Round to match grainSize
- alpha = Max(Rml[MultiPVIteration].prevScore - aspirationDelta, -VALUE_INFINITE);
- beta = Min(Rml[MultiPVIteration].prevScore + aspirationDelta, VALUE_INFINITE);
+ alpha = Max(Rml[MultiPVIdx].prevScore - aspirationDelta, -VALUE_INFINITE);
+ beta = Min(Rml[MultiPVIdx].prevScore + aspirationDelta, VALUE_INFINITE);
}
else
{
// Start with a small aspiration window and, in case of fail high/low,
// research with bigger window until not failing high/low anymore.
do {
- // Search starting from ss+1 to allow referencing (ss-1). This is
+ // Search starts from ss+1 to allow referencing (ss-1). This is
// needed by update_gains() and ss copy when splitting at Root.
value = search<Root>(pos, ss+1, alpha, beta, depth * ONE_PLY);
- // It is critical that sorting is done with a stable algorithm
- // because all the values but the first are usually set to
- // -VALUE_INFINITE and we want to keep the same order for all
- // the moves but the new PV that goes to head.
- sort<RootMove>(Rml.begin() + MultiPVIteration, Rml.end());
-
- // In case we have found an exact score reorder the PV moves
- // before leaving the fail high/low loop, otherwise leave the
- // last PV move in its position so to be searched again.
- if (value > alpha && value < beta)
- sort<RootMove>(Rml.begin(), Rml.begin() + MultiPVIteration);
+ // Bring to front the best move. It is critical that sorting is
+ // done with a stable algorithm because all the values but the first
+ // and eventually the new best one are set to -VALUE_INFINITE and
+ // we want to keep the same order for all the moves but the new
+ // PV that goes to the front. Note that in case of MultiPV search
+ // the already searched PV lines are preserved.
+ sort<RootMove>(Rml.begin() + MultiPVIdx, Rml.end());
+
+ // In case we have found an exact score and we are going to leave
+ // the fail high/low loop then reorder the PV moves, otherwise
+ // leave the last PV move in its position so to be searched again.
+ // Of course this is needed only in MultiPV search.
+ if (MultiPVIdx && value > alpha && value < beta)
+ sort<RootMove>(Rml.begin(), Rml.begin() + MultiPVIdx);
// Write PV back to transposition table in case the relevant entries
// have been overwritten during the search.
- for (int i = 0; i <= MultiPVIteration; i++)
+ for (int i = 0; i <= MultiPVIdx; i++)
Rml[i].insert_pv_in_tt(pos);
- // Value cannot be trusted. Break out immediately!
+ // If search has been stopped exit the aspiration window loop,
+ // note that sorting and writing PV back to TT is safe becuase
+ // Rml is still valid, although refers to the previous iteration.
if (StopRequest)
break;
// Send full PV info to GUI if we are going to leave the loop or
- // if we have a fail high/low and we are deep in the search.
+ // if we have a fail high/low and we are deep in the search. UCI
+ // protocol requires to send all the PV lines also if are still
+ // to be searched and so refer to the previous search's score.
if ((value > alpha && value < beta) || current_search_time() > 2000)
- for (int i = 0; i < Min(UCIMultiPV, MultiPVIteration + 1); i++)
+ for (int i = 0; i < Min(UCIMultiPV, (int)Rml.size()); i++)
+ {
+ bool updated = (i <= MultiPVIdx);
+
+ if (depth == 1 && !updated)
+ continue;
+
+ Depth d = (updated ? depth : depth - 1) * ONE_PLY;
+ Value s = (updated ? Rml[i].score : Rml[i].prevScore);
+
cout << "info"
- << depth_to_uci(depth * ONE_PLY)
- << (i == MultiPVIteration ? score_to_uci(Rml[i].score, alpha, beta) :
- score_to_uci(Rml[i].score))
+ << depth_to_uci(d)
+ << (i == MultiPVIdx ? score_to_uci(s, alpha, beta) : score_to_uci(s))
<< speed_to_uci(pos.nodes_searched())
<< pv_to_uci(&Rml[i].pv[0], i + 1, pos.is_chess960())
<< endl;
+ }
- // In case of failing high/low increase aspiration window and research,
- // otherwise exit the fail high/low loop.
+ // In case of failing high/low increase aspiration window and
+ // research, otherwise exit the fail high/low loop.
if (value >= beta)
{
beta = Min(beta + aspirationDelta, VALUE_INFINITE);
bestValues[depth] = value;
bestMoveChanges[depth] = Rml.bestMoveChanges;
- // Do we need to pick now the best and the ponder moves ?
+ // Skills: Do we need to pick now the best and the ponder moves ?
if (SkillLevelEnabled && depth == 1 + SkillLevel)
do_skill_level(&skillBest, &skillPonder);
if (LogFile.is_open())
LogFile << pretty_pv(pos, depth, value, current_search_time(), &Rml[0].pv[0]) << endl;
- // Init easyMove after first iteration or drop if differs from the best move
+ // Init easyMove at first iteration or drop it if differs from the best move
if (depth == 1 && (Rml.size() == 1 || Rml[0].score > Rml[1].score + EasyMoveMargin))
easyMove = bestMove;
else if (bestMove != easyMove)
// Check for some early stop condition
if (!StopRequest && Limits.useTimeManagement())
{
- // Stop search early if one move seems to be much better than the
- // others or if there is only a single legal move. Also in the latter
- // case we search up to some depth anyway to get a proper score.
+ // Easy move: Stop search early if one move seems to be much better
+ // than the others or if there is only a single legal move. Also in
+ // the latter case search to some depth anyway to get a proper score.
if ( depth >= 7
&& easyMove == bestMove
&& ( Rml.size() == 1
excludedMove = ss->excludedMove;
posKey = excludedMove ? pos.get_exclusion_key() : pos.get_key();
tte = TT.probe(posKey);
- ttMove = RootNode ? Rml[MultiPVIteration].pv[0] : tte ? tte->move() : MOVE_NONE;
+ ttMove = RootNode ? Rml[MultiPVIdx].pv[0] : tte ? tte->move() : MOVE_NONE;
// At PV nodes we check for exact scores, while at non-PV nodes we check for
// a fail high/low. Biggest advantage at probing at PV nodes is to have a
: can_return_tt(tte, depth, beta, ss->ply)))
{
TT.refresh(tte);
- ss->bestMove = ttMove; // Can be MOVE_NONE
- return value_from_tt(tte->value(), ss->ply);
+ ss->bestMove = move = 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])
+ {
+ ss->killers[1] = ss->killers[0];
+ ss->killers[0] = move;
+ }
+ return value;
}
// Step 5. Evaluate the position statically and update parent's gain statistics
&& (move = mp.get_next_move()) != MOVE_NONE
&& !thread.cutoff_occurred())
{
- assert(move_is_ok(move));
+ assert(is_ok(move));
if (move == excludedMove)
continue;
- // At root obey the "searchmoves" option and skip moves not listed in Root Move List.
- // Also in MultiPV mode we skip moves which already have got an exact score
- // in previous MultiPV Iteration. Finally any illegal move is skipped here.
- if (RootNode && !Rml.find(move, MultiPVIteration))
+ // At root obey the "searchmoves" option and skip moves not listed in Root
+ // Move List, as a consequence any illegal move is also skipped. In MultiPV
+ // mode we also skip PV moves which have been already searched.
+ if (RootNode && !Rml.find(move, MultiPVIdx))
continue;
// At PV and SpNode nodes we want all moves to be legal since the beginning
if (pos.thread() == 0 && current_search_time() > 2000)
cout << "info" << depth_to_uci(depth)
<< " currmove " << move
- << " currmovenumber " << moveCount + MultiPVIteration << endl;
+ << " currmovenumber " << moveCount + MultiPVIdx << endl;
}
// At Root and at first iteration do a PV search on all the moves to score root moves
isPvMove = (PvNode && moveCount <= (RootNode && depth <= ONE_PLY ? MAX_MOVES : 1));
givesCheck = pos.move_gives_check(move, ci);
- captureOrPromotion = pos.move_is_capture_or_promotion(move);
+ captureOrPromotion = pos.is_capture_or_promotion(move);
// Step 12. Decide the new search depth
ext = extension<PvNode>(pos, move, captureOrPromotion, givesCheck, &dangerous);
&& !inCheck
&& !dangerous
&& move != ttMove
- && !move_is_castle(move))
+ && !is_castle(move))
{
// Move count based pruning
if ( moveCount >= futility_move_count(depth)
if ( depth > 3 * ONE_PLY
&& !captureOrPromotion
&& !dangerous
- && !move_is_castle(move)
+ && !is_castle(move)
&& ss->killers[0] != move
&& ss->killers[1] != move
&& (ss->reduction = reduction<PvNode>(depth, moveCount)) != DEPTH_ZERO)
// Update killers and history only for non capture moves that fails high
if ( bestValue >= beta
- && !pos.move_is_capture_or_promotion(move))
+ && !pos.is_capture_or_promotion(move))
{
if (move != ss->killers[0])
{
while ( bestValue < beta
&& (move = mp.get_next_move()) != MOVE_NONE)
{
- assert(move_is_ok(move));
+ assert(is_ok(move));
givesCheck = pos.move_gives_check(move, ci);
&& !givesCheck
&& move != ttMove
&& enoughMaterial
- && !move_is_promotion(move)
- && !pos.move_is_passed_pawn_push(move))
+ && !is_promotion(move)
+ && !pos.is_passed_pawn_push(move))
{
futilityValue = futilityBase
+ piece_value_endgame(pos.piece_on(move_to(move)))
- + (move_is_ep(move) ? PawnValueEndgame : VALUE_ZERO);
+ + (is_enpassant(move) ? PawnValueEndgame : VALUE_ZERO);
if (futilityValue < beta)
{
evasionPrunable = !PvNode
&& inCheck
&& bestValue > VALUE_MATED_IN_PLY_MAX
- && !pos.move_is_capture(move)
+ && !pos.is_capture(move)
&& !pos.can_castle(pos.side_to_move());
// Don't search moves with negative SEE values
if ( !PvNode
&& (!inCheck || evasionPrunable)
&& move != ttMove
- && !move_is_promotion(move)
+ && !is_promotion(move)
&& pos.see_sign(move) < 0)
continue;
&& !inCheck
&& givesCheck
&& move != ttMove
- && !pos.move_is_capture_or_promotion(move)
+ && !pos.is_capture_or_promotion(move)
&& ss->eval + PawnValueMidgame / 4 < beta
&& !check_is_dangerous(pos, move, futilityBase, beta, &bestValue))
{
from = move_from(move);
to = move_to(move);
- them = opposite_color(pos.side_to_move());
+ them = flip(pos.side_to_move());
ksq = pos.king_square(them);
kingAtt = pos.attacks_from<KING>(ksq);
pc = pos.piece_on(from);
return true;
// Rule 2. Queen contact check is very dangerous
- if ( piece_type(pc) == QUEEN
+ if ( type_of(pc) == QUEEN
&& bit_is_set(kingAtt, to))
return true;
Piece p1, p2;
Square ksq;
- assert(m1 && move_is_ok(m1));
- assert(m2 && move_is_ok(m2));
+ assert(is_ok(m1));
+ assert(is_ok(m2));
// Case 1: The moving piece is the same in both moves
f2 = move_from(m2);
bool connected_threat(const Position& pos, Move m, Move threat) {
- assert(move_is_ok(m));
- assert(threat && move_is_ok(threat));
- assert(!pos.move_is_capture_or_promotion(m));
- assert(!pos.move_is_passed_pawn_push(m));
+ assert(is_ok(m));
+ assert(is_ok(threat));
+ assert(!pos.is_capture_or_promotion(m));
+ assert(!pos.is_passed_pawn_push(m));
Square mfrom, mto, tfrom, tto;
// Case 2: If the threatened piece has value less than or equal to the
// value of the threatening piece, don't prune moves which defend it.
- if ( pos.move_is_capture(threat)
+ if ( pos.is_capture(threat)
&& ( piece_value_midgame(pos.piece_on(tfrom)) >= piece_value_midgame(pos.piece_on(tto))
- || piece_type(pos.piece_on(tfrom)) == KING)
+ || type_of(pos.piece_on(tfrom)) == KING)
&& pos.move_attacks_square(m, tto))
return true;
&& before != VALUE_NONE
&& after != VALUE_NONE
&& pos.captured_piece_type() == PIECE_TYPE_NONE
- && !move_is_special(m))
+ && !is_special(m))
H.update_gain(pos.piece_on(move_to(m)), move_to(m), -(before + after));
}
int ply = 1;
Move m = pv[0];
- assert(m != MOVE_NONE && pos.move_is_pl(m));
+ assert(m != MOVE_NONE && pos.is_pseudo_legal(m));
pv.clear();
pv.push_back(m);
while ( (tte = TT.probe(pos.get_key())) != NULL
&& tte->move() != MOVE_NONE
- && pos.move_is_pl(tte->move())
+ && pos.is_pseudo_legal(tte->move())
&& pos.pl_move_is_legal(tte->move(), pos.pinned_pieces())
&& ply < PLY_MAX
&& (!pos.is_draw<false>() || ply < 2))
Value v, m = VALUE_NONE;
int ply = 0;
- assert(pv[0] != MOVE_NONE && pos.move_is_pl(pv[0]));
+ assert(pv[0] != MOVE_NONE && pos.is_pseudo_legal(pv[0]));
do {
k = pos.get_key();
} // namespace
-// Little helper used by idle_loop() to check that all the slaves of a
-// master thread have finished searching.
+// Little helper used by idle_loop() to check that all the slave threads of a
+// split point have finished searching.
static bool all_slaves_finished(SplitPoint* sp) {
- assert(sp);
-
for (int i = 0; i < Threads.size(); i++)
if (sp->is_slave[i])
return false;
// instead of wasting CPU time polling for work.
while ( do_sleep
|| do_terminate
- || (Threads.use_sleeping_threads() && state == Thread::AVAILABLE))
+ || (Threads.use_sleeping_threads() && !is_searching))
{
assert((!sp && threadID) || Threads.use_sleeping_threads());
- // Grab the lock to avoid races with Thread::wake_up()
- lock_grab(&sleepLock);
-
// Slave thread should exit as soon as do_terminate flag raises
if (do_terminate)
{
assert(!sp);
- lock_release(&sleepLock);
return;
}
+ // Grab the lock to avoid races with Thread::wake_up()
+ lock_grab(&sleepLock);
+
// If we are master and all slaves have finished don't go to sleep
if (sp && all_slaves_finished(sp))
{
// particular we need to avoid a deadlock in case a master thread has,
// in the meanwhile, allocated us and sent the wake_up() call before we
// had the chance to grab the lock.
- if (do_sleep || state == Thread::AVAILABLE)
+ if (do_sleep || !is_searching)
cond_wait(&sleepCond, &sleepLock);
lock_release(&sleepLock);
}
// If this thread has been assigned work, launch a search
- if (state == Thread::WORKISWAITING)
+ if (is_searching)
{
assert(!do_terminate);
- state = Thread::SEARCHING;
-
// Copy split point position and search stack and call search()
SearchStack ss[PLY_MAX_PLUS_2];
SplitPoint* tsp = splitPoint;
else
assert(false);
- assert(state == Thread::SEARCHING);
+ assert(is_searching);
- state = Thread::AVAILABLE;
+ is_searching = false;
// Wake up master thread so to allow it to return from the idle loop in
// case we are the last slave of the split point.
if ( Threads.use_sleeping_threads()
&& threadID != tsp->master
- && Threads[tsp->master].state == Thread::AVAILABLE)
+ && !Threads[tsp->master].is_searching)
Threads[tsp->master].wake_up();
}