void extract_pv_from_tt(Position& pos);
void insert_pv_in_tt(Position& pos);
- std::string pv_info_to_uci(Position& pos, Depth depth, Value alpha, Value beta, int pvLine = 0);
+ std::string pv_info_to_uci(Position& pos, int depth, Value alpha, Value beta, int pvLine = 0);
int64_t nodes;
Value pv_score;
// Minimum depth for use of singular extension
const Depth SingularExtensionDepth[2] = { 8 * ONE_PLY /* non-PV */, 6 * ONE_PLY /* PV */};
- // If the TT move is at least SingularExtensionMargin better then the
+ // If the TT move is at least SingularExtensionMargin better than the
// remaining ones we will extend it.
const Value SingularExtensionMargin = Value(0x20);
// MultiPV mode
int MultiPV;
- // Time managment variables
+ // Time management variables
int SearchStartTime, MaxNodes, MaxDepth, ExactMaxTime;
bool UseTimeManagement, InfiniteSearch, Pondering, StopOnPonderhit;
bool FirstRootMove, StopRequest, QuitRequest, AspirationFailLow;
Value score = VALUE_ZERO;
// Score root moves using the standard way used in main search, the moves
- // are scored according to the order in which are returned by MovePicker.
+ // are scored according to the order in which they are returned by MovePicker.
// This is the second order score that is used to compare the moves when
// the first order pv scores of both moves are equal.
while ((move = MovePicker::get_next_move()) != MOVE_NONE)
SearchStack ss[PLY_MAX_PLUS_2];
Value bestValues[PLY_MAX_PLUS_2];
int bestMoveChanges[PLY_MAX_PLUS_2];
- int iteration, researchCountFL, researchCountFH, aspirationDelta;
+ int depth, researchCountFL, researchCountFH, aspirationDelta;
Value value, alpha, beta;
- Depth depth;
Move bestMove, easyMove;
// Moves to search are verified, scored and sorted
TT.new_search();
H.clear();
memset(ss, 0, PLY_MAX_PLUS_2 * sizeof(SearchStack));
- alpha = -VALUE_INFINITE, beta = VALUE_INFINITE;
*ponderMove = bestMove = easyMove = MOVE_NONE;
- aspirationDelta = 0;
- iteration = 1;
+ depth = aspirationDelta = 0;
ss->currentMove = MOVE_NULL; // Hack to skip update_gains()
+ alpha = -VALUE_INFINITE, beta = VALUE_INFINITE;
- // Handle special case of searching on a mate/stale position
+ // Handle special case of searching on a mate/stalemate position
if (Rml.size() == 0)
{
- cout << "info depth " << iteration << " score "
+ cout << "info depth 0 score "
<< value_to_uci(pos.is_check() ? -VALUE_MATE : VALUE_DRAW)
<< endl;
return MOVE_NONE;
}
- // Send initial scoring (iteration 1)
- cout << set960(pos.is_chess960()) // Is enough to set once at the beginning
- << "info depth " << iteration
- << "\n" << Rml[0].pv_info_to_uci(pos, ONE_PLY, alpha, beta) << endl;
-
// Is one move significantly better than others after initial scoring ?
if ( Rml.size() == 1
|| Rml[0].pv_score > Rml[1].pv_score + EasyMoveMargin)
easyMove = Rml[0].pv[0];
// Iterative deepening loop
- while (++iteration <= PLY_MAX && (!MaxDepth || iteration <= MaxDepth) && !StopRequest)
+ while (++depth <= PLY_MAX && (!MaxDepth || depth <= MaxDepth) && !StopRequest)
{
- cout << "info depth " << iteration << endl;
-
Rml.bestMoveChanges = researchCountFL = researchCountFH = 0;
- depth = (iteration - 1) * ONE_PLY;
+ cout << "info depth " << depth << endl;
// Calculate dynamic aspiration window based on previous iterations
- if (MultiPV == 1 && iteration >= 6 && abs(bestValues[iteration - 1]) < VALUE_KNOWN_WIN)
+ if (MultiPV == 1 && depth >= 5 && abs(bestValues[depth - 1]) < VALUE_KNOWN_WIN)
{
- int prevDelta1 = bestValues[iteration - 1] - bestValues[iteration - 2];
- int prevDelta2 = bestValues[iteration - 2] - bestValues[iteration - 3];
+ int prevDelta1 = bestValues[depth - 1] - bestValues[depth - 2];
+ int prevDelta2 = bestValues[depth - 2] - bestValues[depth - 3];
- aspirationDelta = Max(abs(prevDelta1) + abs(prevDelta2) / 2, 16);
+ aspirationDelta = Min(Max(abs(prevDelta1) + abs(prevDelta2) / 2, 16), 24);
aspirationDelta = (aspirationDelta + 7) / 8 * 8; // Round to match grainSize
- alpha = Max(bestValues[iteration - 1] - aspirationDelta, -VALUE_INFINITE);
- beta = Min(bestValues[iteration - 1] + aspirationDelta, VALUE_INFINITE);
+ alpha = Max(bestValues[depth - 1] - aspirationDelta, -VALUE_INFINITE);
+ beta = Min(bestValues[depth - 1] + aspirationDelta, VALUE_INFINITE);
}
// Start with a small aspiration window and, in case of fail high/low,
while (true)
{
// Search starting from ss+1 to allow calling update_gains()
- value = search<PV, false, true>(pos, ss+1, alpha, beta, depth, 0);
+ value = search<PV, false, true>(pos, ss+1, alpha, beta, depth * ONE_PLY, 0);
- // Write PV lines to transposition table, in case the relevant entries
- // have been overwritten during the search.
+ // Send PV line to GUI and write to transposition table in case the
+ // relevant entries have been overwritten during the search.
for (int i = 0; i < Min(MultiPV, (int)Rml.size()); i++)
+ {
Rml[i].insert_pv_in_tt(pos);
+ cout << set960(pos.is_chess960())
+ << Rml[i].pv_info_to_uci(pos, depth, alpha, beta, i) << endl;
+ }
// Value cannot be trusted. Break out immediately!
if (StopRequest)
// Collect info about search result
bestMove = Rml[0].pv[0];
- bestValues[iteration] = value;
- bestMoveChanges[iteration] = Rml.bestMoveChanges;
+ bestValues[depth] = value;
+ bestMoveChanges[depth] = Rml.bestMoveChanges;
// Drop the easy move if differs from the new best move
if (bestMove != easyMove)
bool noMoreTime = false;
// Stop search early when the last two iterations returned a mate score
- if ( iteration >= 6
- && abs(bestValues[iteration]) >= abs(VALUE_MATE) - 100
- && abs(bestValues[iteration-1]) >= abs(VALUE_MATE) - 100)
+ if ( depth >= 5
+ && abs(bestValues[depth]) >= abs(VALUE_MATE) - 100
+ && abs(bestValues[depth - 1]) >= abs(VALUE_MATE) - 100)
noMoreTime = true;
// Stop search early if one move seems to be much better than the
// others or if there is only a single legal move. In this latter
// case we search up to Iteration 8 anyway to get a proper score.
- if ( iteration >= 8
+ if ( depth >= 7
&& easyMove == bestMove
&& ( Rml.size() == 1
||( Rml[0].nodes > (pos.nodes_searched() * 85) / 100
noMoreTime = true;
// Add some extra time if the best move has changed during the last two iterations
- if (iteration > 5 && iteration <= 50)
- TimeMgr.pv_instability(bestMoveChanges[iteration], bestMoveChanges[iteration-1]);
+ if (depth > 4 && depth < 50)
+ TimeMgr.pv_instability(bestMoveChanges[depth], bestMoveChanges[depth-1]);
// Stop search if most of MaxSearchTime is consumed at the end of the
// iteration. We probably don't have enough time to search the first
// Step 4. Transposition table lookup
// We don't want the score of a partial search to overwrite a previous full search
- // TT value, so we use a different position key in case of an excluded move exists.
+ // TT value, so we use a different position key in case of an excluded move.
excludedMove = ss->excludedMove;
posKey = excludedMove ? pos.get_exclusion_key() : pos.get_key();
tte = TT.retrieve(posKey);
ttMove = tte ? tte->move() : MOVE_NONE;
- // At PV nodes, we don't use the TT for pruning, but only for move ordering.
- // This is to avoid problems in the following areas:
- //
- // * Repetition draw detection
- // * Fifty move rule detection
- // * Searching for a mate
- // * Printing of full PV line
- if (!PvNode && tte && ok_to_use_TT(tte, depth, beta, ply))
+ // At PV nodes we check for exact scores, while at non-PV nodes we check for
+ // and return a fail high/low. Biggest advantage at probing at PV nodes is
+ // to have a smooth experience in analysis mode.
+ if ( !Root
+ && tte
+ && (PvNode ? tte->depth() >= depth && tte->type() == VALUE_TYPE_EXACT
+ : ok_to_use_TT(tte, depth, beta, ply)))
{
TT.refresh(tte);
ss->bestMove = ttMove; // Can be MOVE_NONE
// Singular extension search. If all moves but one fail low on a search of (alpha-s, beta-s),
// and just one fails high on (alpha, beta), then that move is singular and should be extended.
// To verify this we do a reduced search on all the other moves but the ttMove, if result is
- // lower then ttValue minus a margin then we extend ttMove.
+ // lower than ttValue minus a margin then we extend ttMove.
if ( singularExtensionNode
&& move == tte->move()
&& ext < ONE_PLY)
mp.rm->extract_pv_from_tt(pos);
// We record how often the best move has been changed in each
- // iteration. This information is used for time managment: When
+ // iteration. This information is used for time management: When
// the best move changes frequently, we allocate some more time.
if (!isPvMove && MultiPV == 1)
Rml.bestMoveChanges++;
- // Inform GUI that PV has changed, in case of multi-pv UCI protocol
- // requires we send all the PV lines properly sorted.
Rml.sort_multipv(moveCount);
- for (int j = 0; j < Min(MultiPV, (int)Rml.size()); j++)
- cout << Rml[j].pv_info_to_uci(pos, depth, alpha, beta, j) << endl;
-
// Update alpha. In multi-pv we don't use aspiration window, so
// set alpha equal to minimum score among the PV lines.
if (MultiPV > 1)
// connected_threat() tests whether it is safe to forward prune a move or if
- // is somehow coonected to the threat move returned by null search.
+ // is somehow connected to the threat move returned by null search.
bool connected_threat(const Position& pos, Move m, Move threat) {
return true;
// Case 2: If the threatened piece has value less than or equal to the
- // value of the threatening piece, don't prune move which defend it.
+ // value of the threatening piece, don't prune moves which defend it.
if ( pos.move_is_capture(threat)
&& ( pos.midgame_value_of_piece_on(tfrom) >= pos.midgame_value_of_piece_on(tto)
|| pos.type_of_piece_on(tfrom) == KING)
k = pos.get_key();
tte = TT.retrieve(k);
- // Don't overwrite exsisting correct entries
+ // Don't overwrite existing correct entries
if (!tte || tte->move() != pv[ply])
{
v = (pos.is_check() ? VALUE_NONE : evaluate(pos, m));
// formatted according to UCI specification and eventually writes the info
// to a log file. It is called at each iteration or after a new pv is found.
- std::string RootMove::pv_info_to_uci(Position& pos, Depth depth, Value alpha, Value beta, int pvLine) {
+ std::string RootMove::pv_info_to_uci(Position& pos, int depth, Value alpha, Value beta, int pvLine) {
std::stringstream s, l;
Move* m = pv;
while (*m != MOVE_NONE)
l << *m++ << " ";
- s << "info depth " << depth / ONE_PLY
+ s << "info depth " << depth
<< " seldepth " << int(m - pv)
<< " multipv " << pvLine + 1
<< " score " << value_to_uci(pv_score)
ValueType t = pv_score >= beta ? VALUE_TYPE_LOWER :
pv_score <= alpha ? VALUE_TYPE_UPPER : VALUE_TYPE_EXACT;
- LogFile << pretty_pv(pos, current_search_time(), depth / ONE_PLY, pv_score, t, pv) << endl;
+ LogFile << pretty_pv(pos, current_search_time(), depth, pv_score, t, pv) << endl;
}
return s.str();
}