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);
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;
+ iteration = 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 (++iteration <= PLY_MAX && !StopRequest)
{
- cout << "info depth " << iteration << endl;
-
Rml.bestMoveChanges = researchCountFL = researchCountFH = 0;
- depth = (iteration - 1) * ONE_PLY;
+ depth = iteration * ONE_PLY;
+
+ if (MaxDepth && depth > MaxDepth * ONE_PLY)
+ break;
+
+ cout << "info depth " << depth / ONE_PLY << endl;
// Calculate dynamic aspiration window based on previous iterations
- if (MultiPV == 1 && iteration >= 6 && abs(bestValues[iteration - 1]) < VALUE_KNOWN_WIN)
+ if (MultiPV == 1 && iteration >= 5 && abs(bestValues[iteration - 1]) < VALUE_KNOWN_WIN)
{
int prevDelta1 = bestValues[iteration - 1] - bestValues[iteration - 2];
int prevDelta2 = bestValues[iteration - 2] - bestValues[iteration - 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);
// Search starting from ss+1 to allow calling update_gains()
value = search<PV, false, true>(pos, ss+1, alpha, beta, depth, 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)
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 ( iteration >= 5
+ && abs(bestValues[iteration]) >= abs(VALUE_MATE) - 100
+ && abs(bestValues[iteration - 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 ( iteration >= 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)
+ if (iteration > 4 && iteration < 50)
TimeMgr.pv_instability(bestMoveChanges[iteration], bestMoveChanges[iteration-1]);
// Stop search if most of MaxSearchTime is consumed at the end of the
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.