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;
Value value_to_tt(Value v, int ply);
Value value_from_tt(Value v, int ply);
bool ok_to_use_TT(const TTEntry* tte, Depth depth, Value beta, int ply);
- bool ok_to_use_TT_PV(const TTEntry* tte, Depth depth, Value alpha, Value beta, int ply);
bool connected_threat(const Position& pos, Move m, Move threat);
Value refine_eval(const TTEntry* tte, Value defaultEval, int ply);
void update_history(const Position& pos, Move move, Depth depth, Move movesSearched[], int moveCount);
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
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
tte = TT.retrieve(posKey);
ttMove = tte ? tte->move() : MOVE_NONE;
- // At PV nodes we check for exact scores within (alha, beta) range, 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 ? ok_to_use_TT_PV(tte, depth, alpha, beta, ply) : 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
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)
// ok_to_use_TT() returns true if a transposition table score
- // can be used at a given point in search. There are two versions
- // one to be used in non-PV nodes and one in PV nodes where we look
- // for an exact score that falls between (alha, beta) boundaries.
+ // can be used at a given point in search.
bool ok_to_use_TT(const TTEntry* tte, Depth depth, Value beta, int ply) {
|| ((tte->type() & VALUE_TYPE_UPPER) && v < beta));
}
- bool ok_to_use_TT_PV(const TTEntry* tte, Depth depth, Value alpha, Value beta, int ply) {
-
- Value v = value_from_tt(tte->value(), ply);
-
- return tte->depth() >= depth
- && tte->type() == VALUE_TYPE_EXACT
- && tte->move() != MOVE_NONE
- && v < beta
- && v > alpha;
- }
-
// refine_eval() returns the transposition table score if
// possible otherwise falls back on static position evaluation.
// 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();
}
projects / stockfish / blobdiff