volatile SignalsType Signals;
LimitsType Limits;
std::vector<RootMove> RootMoves;
- Position RootPosition;
+ Position RootPos;
Color RootColor;
Time::point SearchTime;
StateStackPtr SetupStates;
return (Depth) Reductions[PvNode][std::min(int(d) / ONE_PLY, 63)][std::min(mn, 63)];
}
- size_t MultiPV, UCIMultiPV, PVIdx;
+ size_t PVSize, PVIdx;
TimeManager TimeMgr;
int BestMoveChanges;
- int SkillLevel;
- bool SkillLevelEnabled, Chess960;
Value DrawValue[COLOR_NB];
History H;
Value value_to_tt(Value v, int ply);
Value value_from_tt(Value v, int ply);
bool connected_threat(const Position& pos, Move m, Move threat);
- Move do_skill_level();
string uci_pv(const Position& pos, int depth, Value alpha, Value beta);
+ struct Skill {
+ Skill(int l) : level(l), best(MOVE_NONE) {}
+ ~Skill() {
+ if (enabled()) // Swap best PV line with the sub-optimal one
+ std::swap(RootMoves[0], *std::find(RootMoves.begin(),
+ RootMoves.end(), best ? best : pick_move()));
+ }
+
+ bool enabled() const { return level < 20; }
+ bool time_to_pick(int depth) const { return depth == 1 + level; }
+ Move pick_move();
+
+ int level;
+ Move best;
+ };
+
} // namespace
/// Search::think() is the external interface to Stockfish's search, and is
/// called by the main thread when the program receives the UCI 'go' command. It
-/// searches from RootPosition and at the end prints the "bestmove" to output.
+/// searches from RootPos and at the end prints the "bestmove" to output.
void Search::think() {
static PolyglotBook book; // Defined static to initialize the PRNG only once
- Position& pos = RootPosition;
- Chess960 = pos.is_chess960();
- RootColor = pos.side_to_move();
- TimeMgr.init(Limits, pos.startpos_ply_counter(), pos.side_to_move());
- TT.new_search();
- H.clear();
+ RootColor = RootPos.side_to_move();
+ TimeMgr.init(Limits, RootPos.startpos_ply_counter(), RootColor);
if (RootMoves.empty())
{
+ RootMoves.push_back(MOVE_NONE);
sync_cout << "info depth 0 score "
- << score_to_uci(pos.in_check() ? -VALUE_MATE : VALUE_DRAW) << sync_endl;
+ << score_to_uci(RootPos.in_check() ? -VALUE_MATE : VALUE_DRAW)
+ << sync_endl;
- RootMoves.push_back(MOVE_NONE);
goto finalize;
}
- if (Options["Contempt Factor"] && !Options["UCI_AnalyseMode"])
- {
- int cf = Options["Contempt Factor"] * PawnValueMg / 100; // In centipawns
- cf = cf * MaterialTable::game_phase(pos) / PHASE_MIDGAME; // Scale down with phase
- DrawValue[ RootColor] = VALUE_DRAW - Value(cf);
- DrawValue[~RootColor] = VALUE_DRAW + Value(cf);
- }
- else
- DrawValue[WHITE] = DrawValue[BLACK] = VALUE_DRAW;
-
if (Options["OwnBook"] && !Limits.infinite)
{
- Move bookMove = book.probe(pos, Options["Book File"], Options["Best Book Move"]);
+ Move bookMove = book.probe(RootPos, Options["Book File"], Options["Best Book Move"]);
if (bookMove && std::count(RootMoves.begin(), RootMoves.end(), bookMove))
{
}
}
- UCIMultiPV = Options["MultiPV"];
- SkillLevel = Options["Skill Level"];
-
- // Do we have to play with skill handicap? In this case enable MultiPV that
- // we will use behind the scenes to retrieve a set of possible moves.
- SkillLevelEnabled = (SkillLevel < 20);
- MultiPV = (SkillLevelEnabled ? std::max(UCIMultiPV, (size_t)4) : UCIMultiPV);
+ if (Options["Contempt Factor"] && !Options["UCI_AnalyseMode"])
+ {
+ int cf = Options["Contempt Factor"] * PawnValueMg / 100; // From centipawns
+ cf = cf * MaterialTable::game_phase(RootPos) / PHASE_MIDGAME; // Scale down with phase
+ DrawValue[ RootColor] = VALUE_DRAW - Value(cf);
+ DrawValue[~RootColor] = VALUE_DRAW + Value(cf);
+ }
+ else
+ DrawValue[WHITE] = DrawValue[BLACK] = VALUE_DRAW;
if (Options["Use Search Log"])
{
Log log(Options["Search Log Filename"]);
- log << "\nSearching: " << pos.to_fen()
+ log << "\nSearching: " << RootPos.to_fen()
<< "\ninfinite: " << Limits.infinite
<< " ponder: " << Limits.ponder
- << " time: " << Limits.time[pos.side_to_move()]
- << " increment: " << Limits.inc[pos.side_to_move()]
+ << " time: " << Limits.time[RootColor]
+ << " increment: " << Limits.inc[RootColor]
<< " moves to go: " << Limits.movestogo
<< std::endl;
}
// Set best timer interval to avoid lagging under time pressure. Timer is
// used to check for remaining available thinking time.
if (Limits.use_time_management())
- Threads.set_timer(std::min(100, std::max(TimeMgr.available_time() / 16, TimerResolution)));
+ Threads.set_timer(std::min(100, std::max(TimeMgr.available_time() / 16,
+ TimerResolution)));
else if (Limits.nodes)
Threads.set_timer(2 * TimerResolution);
else
Threads.set_timer(100);
- // We're ready to start searching. Call the iterative deepening loop function
- id_loop(pos);
+ id_loop(RootPos); // Let's start searching !
Threads.set_timer(0); // Stop timer
Threads.sleep();
Time::point elapsed = Time::now() - SearchTime + 1;
Log log(Options["Search Log Filename"]);
- log << "Nodes: " << pos.nodes_searched()
- << "\nNodes/second: " << pos.nodes_searched() * 1000 / elapsed
- << "\nBest move: " << move_to_san(pos, RootMoves[0].pv[0]);
+ log << "Nodes: " << RootPos.nodes_searched()
+ << "\nNodes/second: " << RootPos.nodes_searched() * 1000 / elapsed
+ << "\nBest move: " << move_to_san(RootPos, RootMoves[0].pv[0]);
StateInfo st;
- pos.do_move(RootMoves[0].pv[0], st);
- log << "\nPonder move: " << move_to_san(pos, RootMoves[0].pv[1]) << std::endl;
- pos.undo_move(RootMoves[0].pv[0]);
+ RootPos.do_move(RootMoves[0].pv[0], st);
+ log << "\nPonder move: " << move_to_san(RootPos, RootMoves[0].pv[1]) << std::endl;
+ RootPos.undo_move(RootMoves[0].pv[0]);
}
finalize:
// but if we are pondering or in infinite search, we shouldn't print the best
// move before we are told to do so.
if (!Signals.stop && (Limits.ponder || Limits.infinite))
- pos.this_thread()->wait_for_stop_or_ponderhit();
+ RootPos.this_thread()->wait_for_stop_or_ponderhit();
// Best move could be MOVE_NONE when searching on a stalemate position
- sync_cout << "bestmove " << move_to_uci(RootMoves[0].pv[0], Chess960)
- << " ponder " << move_to_uci(RootMoves[0].pv[1], Chess960) << sync_endl;
+ sync_cout << "bestmove " << move_to_uci(RootMoves[0].pv[0], RootPos.is_chess960())
+ << " ponder " << move_to_uci(RootMoves[0].pv[1], RootPos.is_chess960())
+ << sync_endl;
}
int depth, prevBestMoveChanges;
Value bestValue, alpha, beta, delta;
bool bestMoveNeverChanged = true;
- Move skillBest = MOVE_NONE;
memset(ss, 0, 4 * sizeof(Stack));
depth = BestMoveChanges = 0;
bestValue = delta = -VALUE_INFINITE;
ss->currentMove = MOVE_NULL; // Hack to skip update gains
+ TT.new_search();
+ H.clear();
+
+ PVSize = Options["MultiPV"];
+ Skill skill(Options["Skill Level"]);
+
+ // Do we have to play with skill handicap? In this case enable MultiPV search
+ // that we will use behind the scenes to retrieve a set of possible moves.
+ if (skill.enabled() && PVSize < 4)
+ PVSize = 4;
+
+ PVSize = std::min(PVSize, RootMoves.size());
// Iterative deepening loop until requested to stop or target depth reached
- while (!Signals.stop && ++depth <= MAX_PLY && (!Limits.depth || depth <= Limits.depth))
+ while (++depth <= MAX_PLY && !Signals.stop && (!Limits.depth || depth <= Limits.depth))
{
// Save last iteration's scores before first PV line is searched and all
// the move scores but the (new) PV are set to -VALUE_INFINITE.
for (size_t i = 0; i < RootMoves.size(); i++)
RootMoves[i].prevScore = RootMoves[i].score;
- prevBestMoveChanges = BestMoveChanges;
+ prevBestMoveChanges = BestMoveChanges; // Only sensible when PVSize == 1
BestMoveChanges = 0;
// MultiPV loop. We perform a full root search for each PV line
- for (PVIdx = 0; PVIdx < std::min(MultiPV, RootMoves.size()); PVIdx++)
+ for (PVIdx = 0; PVIdx < PVSize; PVIdx++)
{
// Set aspiration window default width
if (depth >= 5 && abs(RootMoves[PVIdx].prevScore) < VALUE_KNOWN_WIN)
// the already searched PV lines are preserved.
sort<RootMove>(RootMoves.begin() + PVIdx, RootMoves.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 (PVIdx && bestValue > alpha && bestValue < beta)
- sort<RootMove>(RootMoves.begin(), RootMoves.begin() + PVIdx);
-
// Write PV back to transposition table in case the relevant
// entries have been overwritten during the search.
for (size_t i = 0; i <= PVIdx; i++)
RootMoves[i].insert_pv_in_tt(pos);
- // If search has been stopped exit the aspiration window loop.
- // Sorting and writing PV back to TT is safe becuase RootMoves
- // is still valid, although refers to previous iteration.
+ // If search has been stopped return immediately. Sorting and
+ // writing PV back to TT is safe becuase RootMoves is still
+ // valid, although refers to previous iteration.
if (Signals.stop)
+ return;
+
+ // In case of failing high/low increase aspiration window and
+ // research, otherwise exit the loop.
+ if (bestValue > alpha && bestValue < beta)
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 ((bestValue > alpha && bestValue < beta) || Time::now() - SearchTime > 2000)
+ // Give some update (without cluttering the UI) before to research
+ if (Time::now() - SearchTime > 3000)
sync_cout << uci_pv(pos, depth, alpha, beta) << sync_endl;
- // In case of failing high/low increase aspiration window and
- // research, otherwise exit the fail high/low loop.
- if (bestValue >= beta)
+ if (abs(bestValue) >= VALUE_KNOWN_WIN)
+ {
+ alpha = -VALUE_INFINITE;
+ beta = VALUE_INFINITE;
+ }
+ else if (bestValue >= beta)
{
beta += delta;
delta += delta / 2;
}
- else if (bestValue <= alpha)
+ else
{
Signals.failedLowAtRoot = true;
Signals.stopOnPonderhit = false;
alpha -= delta;
delta += delta / 2;
}
- else
- break;
-
- // Search with full window in case we have a win/mate score
- if (abs(bestValue) >= VALUE_KNOWN_WIN)
- {
- alpha = -VALUE_INFINITE;
- beta = VALUE_INFINITE;
- }
assert(alpha >= -VALUE_INFINITE && beta <= VALUE_INFINITE);
}
+
+ // Sort the PV lines searched so far and update the GUI
+ sort<RootMove>(RootMoves.begin(), RootMoves.begin() + PVIdx);
+ sync_cout << uci_pv(pos, depth, alpha, beta) << sync_endl;
}
- // Skills: Do we need to pick now the best move ?
- if (SkillLevelEnabled && depth == 1 + SkillLevel)
- skillBest = do_skill_level();
+ // Do we need to pick now the sub-optimal best move ?
+ if (skill.enabled() && skill.time_to_pick(depth))
+ skill.pick_move();
- if (!Signals.stop && Options["Use Search Log"])
+ if (Options["Use Search Log"])
{
Log log(Options["Search Log Filename"]);
log << pretty_pv(pos, depth, bestValue, Time::now() - SearchTime, &RootMoves[0].pv[0])
bestMoveNeverChanged = false;
// Do we have time for the next iteration? Can we stop searching now?
- if (!Signals.stop && !Signals.stopOnPonderhit && Limits.use_time_management())
+ if (Limits.use_time_management() && !Signals.stopOnPonderhit)
{
bool stop = false; // Local variable, not the volatile Signals.stop
// Take in account some extra time if the best move has changed
- if (depth > 4 && depth < 50)
+ if (depth > 4 && depth < 50 && PVSize == 1)
TimeMgr.pv_instability(BestMoveChanges, prevBestMoveChanges);
// Stop search if most of available time is already consumed. We
// Stop search early if one move seems to be much better than others
if ( depth >= 12
&& !stop
+ && PVSize == 1
&& ( (bestMoveNeverChanged && pos.captured_piece_type())
|| Time::now() - SearchTime > (TimeMgr.available_time() * 40) / 100))
{
}
}
}
-
- // When using skills swap best PV line with the sub-optimal one
- if (SkillLevelEnabled)
- {
- if (skillBest == MOVE_NONE) // Still unassigned ?
- skillBest = do_skill_level();
-
- std::swap(RootMoves[0], *std::find(RootMoves.begin(), RootMoves.end(), skillBest));
- }
}
if (thisThread == Threads.main_thread() && Time::now() - SearchTime > 2000)
sync_cout << "info depth " << depth / ONE_PLY
- << " currmove " << move_to_uci(move, Chess960)
+ << " currmove " << move_to_uci(move, pos.is_chess960())
<< " currmovenumber " << moveCount + PVIdx << sync_endl;
}
// on all the other moves but the ttMove, if result is lower than ttValue minus
// a margin then we extend ttMove.
if ( singularExtensionNode
- && !ext
&& move == ttMove
+ && !ext
&& pos.pl_move_is_legal(move, ci.pinned)
&& abs(ttValue) < VALUE_KNOWN_WIN)
{
// We record how often the best move has been changed in each
// iteration. This information is used for time management: When
// the best move changes frequently, we allocate some more time.
- if (!pvMove && MultiPV == 1)
+ if (!pvMove)
BestMoveChanges++;
}
else
// When playing with strength handicap choose best move among the MultiPV set
- // using a statistical rule dependent on SkillLevel. Idea by Heinz van Saanen.
-
- Move do_skill_level() {
+ // using a statistical rule dependent on 'level'. Idea by Heinz van Saanen.
- assert(MultiPV > 1);
+ Move Skill::pick_move() {
static RKISS rk;
rk.rand<unsigned>();
// RootMoves are already sorted by score in descending order
- size_t size = std::min(MultiPV, RootMoves.size());
- int variance = std::min(RootMoves[0].score - RootMoves[size - 1].score, PawnValueMg);
- int weakness = 120 - 2 * SkillLevel;
+ int variance = std::min(RootMoves[0].score - RootMoves[PVSize - 1].score, PawnValueMg);
+ int weakness = 120 - 2 * level;
int max_s = -VALUE_INFINITE;
- Move best = MOVE_NONE;
+ best = MOVE_NONE;
// Choose best move. For each move score we add two terms both dependent on
// weakness, one deterministic and bigger for weaker moves, and one random,
// then we choose the move with the resulting highest score.
- for (size_t i = 0; i < size; i++)
+ for (size_t i = 0; i < PVSize; i++)
{
int s = RootMoves[i].score;
if (Threads[i].maxPly > selDepth)
selDepth = Threads[i].maxPly;
- for (size_t i = 0; i < std::min(UCIMultiPV, RootMoves.size()); i++)
+ for (size_t i = 0; i < std::min((size_t)Options["MultiPV"], RootMoves.size()); i++)
{
bool updated = (i <= PVIdx);
<< " pv";
for (size_t j = 0; RootMoves[i].pv[j] != MOVE_NONE; j++)
- s << " " << move_to_uci(RootMoves[i].pv[j], Chess960);
+ s << " " << move_to_uci(RootMoves[i].pv[j], pos.is_chess960());
}
return s.str();
{
Threads.mutex.lock();
- nodes = RootPosition.nodes_searched();
+ nodes = RootPos.nodes_searched();
// Loop across all split points and sum accumulated SplitPoint nodes plus
// all the currently active slaves positions.
projects / stockfish / blobdiff