kate/BadFish
1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-04-29 16:23:09 +00:00
Code Issues Releases Wiki Activity

Simplify id_loop() signature

Browse source 
And related assorted cleanup of this
very important function.

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
This commit is contained in:
Marco Costalba 2011-12-14 12:12:28 +01:00
parent 0af3af5d25
commit af4fadebda
1 changed files with 75 additions and 79 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

154
src/search.cpp
View file

@ -145,7 +145,7 @@ namespace {
/// Namespace variables /// Namespace variables
std::vector<RootMove> RootMoves; std::vector<RootMove> RootMoves;
size_t MultiPV, UCIMultiPV, MultiPVIdx; size_t MultiPV, UCIMultiPV, PVIdx;
TimeManager TimeMgr; TimeManager TimeMgr;
int BestMoveChanges; int BestMoveChanges;
int SkillLevel; int SkillLevel;
@ -155,7 +155,7 @@ namespace {
/// Local functions /// Local functions
Move id_loop(Position& pos, Move* ponderMove); void id_loop(Position& pos);
template <NodeType NT> template <NodeType NT>
Value search(Position& pos, Stack* ss, Value alpha, Value beta, Depth depth); Value search(Position& pos, Stack* ss, Value alpha, Value beta, Depth depth);
@ -171,7 +171,7 @@ namespace {
bool connected_threat(const Position& pos, Move m, Move threat); bool connected_threat(const Position& pos, Move m, Move threat);
Value refine_eval(const TTEntry* tte, Value defaultEval, int ply); Value refine_eval(const TTEntry* tte, Value defaultEval, int ply);
void update_history(const Position& pos, Move move, Depth depth, Move movesSearched[], int moveCount); void update_history(const Position& pos, Move move, Depth depth, Move movesSearched[], int moveCount);
void do_skill_level(Move* best, Move* ponder); Move do_skill_level();
int elapsed_time(bool reset = false); int elapsed_time(bool reset = false);
string score_to_uci(Value v, Value alpha = -VALUE_INFINITE, Value beta = VALUE_INFINITE); string score_to_uci(Value v, Value alpha = -VALUE_INFINITE, Value beta = VALUE_INFINITE);
void pv_info_to_log(Position& pos, int depth, Value score, int time, Move pv[]); void pv_info_to_log(Position& pos, int depth, Value score, int time, Move pv[]);
@ -245,7 +245,7 @@ namespace {
} // namespace } // namespace
/// init_search() is called during startup to initialize various lookup tables /// Search::init() is called during startup to initialize various lookup tables
void Search::init() { void Search::init() {
@ -272,8 +272,8 @@ void Search::init() {
} }
/// perft() is our utility to verify move generation. All the leaf nodes up to /// Search::perft() is our utility to verify move generation. All the leaf nodes
/// the given depth are generated and counted and the sum returned. /// up to the given depth are generated and counted and the sum returned.
int64_t Search::perft(Position& pos, Depth depth) { int64_t Search::perft(Position& pos, Depth depth) {
@ -297,9 +297,9 @@ int64_t Search::perft(Position& pos, Depth depth) {
} }
/// think() is the external interface to Stockfish's search, and is called by the /// Search::think() is the external interface to Stockfish's search, and is
/// main thread when the program receives the UCI 'go' command. It searches from /// called by the main thread when the program receives the UCI 'go' command. It
/// RootPosition and at the end prints the "bestmove" to output. /// searches from RootPosition and at the end prints the "bestmove" to output.
void Search::think() { void Search::think() {
@ -308,6 +308,16 @@ void Search::think() {
Position& pos = RootPosition; Position& pos = RootPosition;
elapsed_time(true); elapsed_time(true);
TimeMgr.init(Limits, pos.startpos_ply_counter()); TimeMgr.init(Limits, pos.startpos_ply_counter());
TT.new_search();
H.clear();
RootMoves.clear();
// Populate RootMoves with all the legal moves (default) or, if a SearchMoves
// is given, with the subset of legal moves to search.
for (MoveList<MV_LEGAL> ml(pos); !ml.end(); ++ml)
if ( SearchMoves.empty()
|| std::count(SearchMoves.begin(), SearchMoves.end(), ml.move()))
RootMoves.push_back(RootMove(ml.move()));
// Set output stream mode: normal or chess960. Castling notation is different // Set output stream mode: normal or chess960. Castling notation is different
cout << set960(pos.is_chess960()); cout << set960(pos.is_chess960());
@ -359,7 +369,6 @@ void Search::think() {
<< endl; << endl;
} }
// Wake up needed threads and reset maxPly counter
for (int i = 0; i < Threads.size(); i++) for (int i = 0; i < Threads.size(); i++)
{ {
Threads[i].maxPly = 0; Threads[i].maxPly = 0;
@ -373,9 +382,8 @@ void Search::think() {
else else
Threads.set_timer(100); Threads.set_timer(100);
// We're ready to start thinking. Call the iterative deepening loop function // We're ready to start searching. Call the iterative deepening loop function
Move ponderMove = MOVE_NONE; id_loop(pos);
Move bestMove = id_loop(pos, &ponderMove);
// Stop timer and send all the slaves to sleep, if not already sleeping // Stop timer and send all the slaves to sleep, if not already sleeping
Threads.set_timer(0); Threads.set_timer(0);
@ -388,12 +396,12 @@ void Search::think() {
Log log(Options["Search Log Filename"].value<string>()); Log log(Options["Search Log Filename"].value<string>());
log << "Nodes: " << pos.nodes_searched() log << "Nodes: " << pos.nodes_searched()
<< "\nNodes/second: " << (e > 0 ? pos.nodes_searched() * 1000 / e : 0) << "\nNodes/second: " << (e > 0 ? pos.nodes_searched() * 1000 / e : 0)
<< "\nBest move: " << move_to_san(pos, bestMove); << "\nBest move: " << move_to_san(pos, RootMoves[0].pv[0]);
StateInfo st; StateInfo st;
pos.do_move(bestMove, st); pos.do_move(RootMoves[0].pv[0], st);
log << "\nPonder move: " << move_to_san(pos, ponderMove) << endl; log << "\nPonder move: " << move_to_san(pos, RootMoves[0].pv[1]) << endl;
pos.undo_move(bestMove); // Return from think() with unchanged position pos.undo_move(RootMoves[0].pv[0]);
} }
// When we reach max depth we arrive here even without a StopRequest, but if // When we reach max depth we arrive here even without a StopRequest, but if
@ -403,12 +411,12 @@ void Search::think() {
Threads.wait_for_stop_or_ponderhit(); Threads.wait_for_stop_or_ponderhit();
// Could be MOVE_NONE when searching on a stalemate position // Could be MOVE_NONE when searching on a stalemate position
cout << "bestmove " << bestMove; cout << "bestmove " << RootMoves[0].pv[0];
// UCI protol is not clear on allowing sending an empty ponder move, instead // UCI protol is not clear on allowing sending an empty ponder move, instead
// it is clear that ponder move is optional. So skip it if empty. // it is clear that ponder move is optional. So skip it if empty.
if (ponderMove != MOVE_NONE) if (RootMoves[0].pv[1] != MOVE_NONE)
cout << " ponder " << ponderMove; cout << " ponder " << RootMoves[0].pv[1];
cout << endl; cout << endl;
} }
@ -420,56 +428,49 @@ namespace {
// with increasing depth until the allocated thinking time has been consumed, // with increasing depth until the allocated thinking time has been consumed,
// user stops the search, or the maximum search depth is reached. // user stops the search, or the maximum search depth is reached.
Move id_loop(Position& pos, Move* ponderMove) { void id_loop(Position& pos) {
Stack ss[PLY_MAX_PLUS_2]; Stack ss[PLY_MAX_PLUS_2];
int bestMoveChanges[PLY_MAX_PLUS_2]; int depth, prevBestMoveChanges;
int depth;
Value bestValue, alpha, beta, delta; Value bestValue, alpha, beta, delta;
Move bestMove, skillBest, skillPonder;
bool bestMoveNeverChanged = true; bool bestMoveNeverChanged = true;
Move skillBest = MOVE_NONE;
memset(ss, 0, 4 * sizeof(Stack)); memset(ss, 0, 4 * sizeof(Stack));
TT.new_search(); depth = BestMoveChanges = 0;
H.clear(); bestValue = delta = -VALUE_INFINITE;
RootMoves.clear();
*ponderMove = bestMove = skillBest = skillPonder = MOVE_NONE;
depth = 0;
bestValue = alpha = -VALUE_INFINITE, beta = delta = VALUE_INFINITE;
ss->currentMove = MOVE_NULL; // Hack to skip update gains ss->currentMove = MOVE_NULL; // Hack to skip update gains
for (MoveList<MV_LEGAL> ml(pos); !ml.end(); ++ml) // Handle the special case of a mate/stalemate position
if ( SearchMoves.empty()
|| std::count(SearchMoves.begin(), SearchMoves.end(), ml.move()))
RootMoves.push_back(RootMove(ml.move()));
// Handle special case of searching on a mate/stalemate position
if (RootMoves.empty()) if (RootMoves.empty())
{ {
cout << "info depth 0" cout << "info depth 0"
<< score_to_uci(pos.in_check() ? -VALUE_MATE : VALUE_DRAW, alpha, beta) << endl; << score_to_uci(pos.in_check() ? -VALUE_MATE : VALUE_DRAW) << endl;
return MOVE_NONE; RootMoves.push_back(MOVE_NONE);
return;
} }
// Iterative deepening loop until requested to stop or target depth reached // Iterative deepening loop until requested to stop or target depth reached
while (!Signals.stop && ++depth <= PLY_MAX && (!Limits.maxDepth || depth <= Limits.maxDepth)) while (!Signals.stop && ++depth <= PLY_MAX && (!Limits.maxDepth || depth <= Limits.maxDepth))
{ {
// Save now last iteration's scores, before Rml moves are reordered // 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++) for (size_t i = 0; i < RootMoves.size(); i++)
RootMoves[i].prevScore = RootMoves[i].score; RootMoves[i].prevScore = RootMoves[i].score;
prevBestMoveChanges = BestMoveChanges;
BestMoveChanges = 0; BestMoveChanges = 0;
// MultiPV loop. We perform a full root search for each PV line // MultiPV loop. We perform a full root search for each PV line
for (MultiPVIdx = 0; MultiPVIdx < std::min(MultiPV, RootMoves.size()); MultiPVIdx++) for (PVIdx = 0; PVIdx < std::min(MultiPV, RootMoves.size()); PVIdx++)
{ {
// Aspiration window // Set aspiration window default width
if (depth >= 5 && abs(RootMoves[MultiPVIdx].prevScore) < VALUE_KNOWN_WIN) if (depth >= 5 && abs(RootMoves[PVIdx].prevScore) < VALUE_KNOWN_WIN)
{ {
delta = Value(16); delta = Value(16);
alpha = RootMoves[MultiPVIdx].prevScore - delta; alpha = RootMoves[PVIdx].prevScore - delta;
beta = RootMoves[MultiPVIdx].prevScore + delta; beta = RootMoves[PVIdx].prevScore + delta;
} }
else else
{ {
@ -490,23 +491,23 @@ namespace {
// we want to keep the same order for all the moves but the new // 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 // PV that goes to the front. Note that in case of MultiPV search
// the already searched PV lines are preserved. // the already searched PV lines are preserved.
sort<RootMove>(RootMoves.begin() + MultiPVIdx, RootMoves.end()); sort<RootMove>(RootMoves.begin() + PVIdx, RootMoves.end());
// In case we have found an exact score and we are going to leave // 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 // the fail high/low loop then reorder the PV moves, otherwise
// leave the last PV move in its position so to be searched again. // leave the last PV move in its position so to be searched again.
// Of course this is needed only in MultiPV search. // Of course this is needed only in MultiPV search.
if (MultiPVIdx && bestValue > alpha && bestValue < beta) if (PVIdx && bestValue > alpha && bestValue < beta)
sort<RootMove>(RootMoves.begin(), RootMoves.begin() + MultiPVIdx); sort<RootMove>(RootMoves.begin(), RootMoves.begin() + PVIdx);
// Write PV back to transposition table in case the relevant entries // Write PV back to transposition table in case the relevant
// have been overwritten during the search. // entries have been overwritten during the search.
for (size_t i = 0; i <= MultiPVIdx; i++) for (size_t i = 0; i <= PVIdx; i++)
RootMoves[i].insert_pv_in_tt(pos); RootMoves[i].insert_pv_in_tt(pos);
// If search has been stopped exit the aspiration window loop, // If search has been stopped exit the aspiration window loop.
// note that sorting and writing PV back to TT is safe becuase // Sorting and writing PV back to TT is safe becuase RootMoves
// Rml is still valid, although refers to the previous iteration. // is still valid, although refers to previous iteration.
if (Signals.stop) if (Signals.stop)
break; break;
@ -538,32 +539,29 @@ namespace {
} while (abs(bestValue) < VALUE_KNOWN_WIN); } while (abs(bestValue) < VALUE_KNOWN_WIN);
} }
bestMove = RootMoves[0].pv[0]; // Skills: Do we need to pick now the best move ?
*ponderMove = RootMoves[0].pv[1];
bestMoveChanges[depth] = BestMoveChanges;
// Skills: Do we need to pick now the best and the ponder moves ?
if (SkillLevelEnabled && depth == 1 + SkillLevel) if (SkillLevelEnabled && depth == 1 + SkillLevel)
do_skill_level(&skillBest, &skillPonder); skillBest = do_skill_level();
if (Options["Use Search Log"].value<bool>()) if (Options["Use Search Log"].value<bool>())
pv_info_to_log(pos, depth, bestValue, elapsed_time(), &RootMoves[0].pv[0]); pv_info_to_log(pos, depth, bestValue, elapsed_time(), &RootMoves[0].pv[0]);
// Filter out startup noise when monitoring best move stability // Filter out startup noise when monitoring best move stability
if (depth > 2 && bestMoveChanges[depth]) if (depth > 2 && BestMoveChanges)
bestMoveNeverChanged = false; bestMoveNeverChanged = false;
// Do we have time for the next iteration? Can we stop searching now? // Do we have time for the next iteration? Can we stop searching now?
if (!Signals.stop && !Signals.stopOnPonderhit && Limits.useTimeManagement()) if (!Signals.stop && !Signals.stopOnPonderhit && Limits.useTimeManagement())
{ {
bool stop = false; // Local variable instead of the volatile Signals.stop bool stop = false; // Local variable, not the volatile Signals.stop
// Take in account some extra time if the best move has changed // Take in account some extra time if the best move has changed
if (depth > 4 && depth < 50) if (depth > 4 && depth < 50)
TimeMgr.pv_instability(bestMoveChanges[depth], bestMoveChanges[depth - 1]); TimeMgr.pv_instability(BestMoveChanges, prevBestMoveChanges);
// Stop search if most of available time is already consumed. We probably don't // Stop search if most of available time is already consumed. We
// have enough time to search the first move at the next iteration anyway. // probably don't have enough time to search the first move at the
// next iteration anyway.
if (elapsed_time() > (TimeMgr.available_time() * 62) / 100) if (elapsed_time() > (TimeMgr.available_time() * 62) / 100)
stop = true; stop = true;
@ -574,7 +572,7 @@ namespace {
|| elapsed_time() > (TimeMgr.available_time() * 40) / 100)) || elapsed_time() > (TimeMgr.available_time() * 40) / 100))
{ {
Value rBeta = bestValue - EasyMoveMargin; Value rBeta = bestValue - EasyMoveMargin;
(ss+1)->excludedMove = bestMove; (ss+1)->excludedMove = RootMoves[0].pv[0];
(ss+1)->skipNullMove = true; (ss+1)->skipNullMove = true;
Value v = search<NonPV>(pos, ss+1, rBeta - 1, rBeta, (depth * ONE_PLY) / 2); Value v = search<NonPV>(pos, ss+1, rBeta - 1, rBeta, (depth * ONE_PLY) / 2);
(ss+1)->skipNullMove = false; (ss+1)->skipNullMove = false;
@ -596,17 +594,14 @@ namespace {
} }
} }
// When using skills overwrite best and ponder moves with the sub-optimal ones // When using skills swap best PV line with the sub-optimal one
if (SkillLevelEnabled) if (SkillLevelEnabled)
{ {
if (skillBest == MOVE_NONE) // Still unassigned ? if (skillBest == MOVE_NONE) // Still unassigned ?
do_skill_level(&skillBest, &skillPonder); skillBest = do_skill_level();
bestMove = skillBest; std::swap(RootMoves[0], *std::find(RootMoves.begin(), RootMoves.end(), skillBest));
*ponderMove = skillPonder;
} }
return bestMove;
} }
@ -691,7 +686,7 @@ namespace {
excludedMove = ss->excludedMove; excludedMove = ss->excludedMove;
posKey = excludedMove ? pos.get_exclusion_key() : pos.get_key(); posKey = excludedMove ? pos.get_exclusion_key() : pos.get_key();
tte = TT.probe(posKey); tte = TT.probe(posKey);
ttMove = RootNode ? RootMoves[MultiPVIdx].pv[0] : tte ? tte->move() : MOVE_NONE; ttMove = RootNode ? RootMoves[PVIdx].pv[0] : tte ? tte->move() : MOVE_NONE;
// At PV nodes we check for exact scores, while at non-PV nodes we check for // 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 // a fail high/low. Biggest advantage at probing at PV nodes is to have a
@ -914,7 +909,7 @@ split_point_start: // At split points actual search starts from here
// At root obey the "searchmoves" option and skip moves not listed in Root // 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 // Move List, as a consequence any illegal move is also skipped. In MultiPV
// mode we also skip PV moves which have been already searched. // mode we also skip PV moves which have been already searched.
if (RootNode && !std::count(RootMoves.begin() + MultiPVIdx, RootMoves.end(), move)) if (RootNode && !std::count(RootMoves.begin() + PVIdx, RootMoves.end(), move))
continue; continue;
// At PV and SpNode nodes we want all moves to be legal since the beginning // At PV and SpNode nodes we want all moves to be legal since the beginning
@ -939,7 +934,7 @@ split_point_start: // At split points actual search starts from here
if (pos.thread() == 0 && elapsed_time() > 2000) if (pos.thread() == 0 && elapsed_time() > 2000)
cout << "info depth " << depth / ONE_PLY cout << "info depth " << depth / ONE_PLY
<< " currmove " << move << " currmove " << move
<< " currmovenumber " << moveCount + MultiPVIdx << endl; << " currmovenumber " << moveCount + PVIdx << endl;
} }
isPvMove = (PvNode && moveCount <= 1); isPvMove = (PvNode && moveCount <= 1);
@ -1693,7 +1688,7 @@ split_point_start: // At split points actual search starts from here
for (size_t i = 0; i < std::min(UCIMultiPV, RootMoves.size()); i++) for (size_t i = 0; i < std::min(UCIMultiPV, RootMoves.size()); i++)
{ {
bool updated = (i <= MultiPVIdx); bool updated = (i <= PVIdx);
if (depth == 1 && !updated) if (depth == 1 && !updated)
continue; continue;
@ -1704,7 +1699,7 @@ split_point_start: // At split points actual search starts from here
cout << "info" cout << "info"
<< " depth " << d << " depth " << d
<< " seldepth " << selDepth << " seldepth " << selDepth
<< (i == MultiPVIdx ? score_to_uci(s, alpha, beta) : score_to_uci(s)) << (i == PVIdx ? score_to_uci(s, alpha, beta) : score_to_uci(s))
<< " nodes " << pos.nodes_searched() << " nodes " << pos.nodes_searched()
<< " nps " << (t > 0 ? pos.nodes_searched() * 1000 / t : 0) << " nps " << (t > 0 ? pos.nodes_searched() * 1000 / t : 0)
<< " time " << t << " time " << t
@ -1811,7 +1806,7 @@ split_point_start: // At split points actual search starts from here
// When playing with strength handicap choose best move among the MultiPV set // When playing with strength handicap choose best move among the MultiPV set
// using a statistical rule dependent on SkillLevel. Idea by Heinz van Saanen. // using a statistical rule dependent on SkillLevel. Idea by Heinz van Saanen.
void do_skill_level(Move* best, Move* ponder) { Move do_skill_level() {
assert(MultiPV > 1); assert(MultiPV > 1);
@ -1826,6 +1821,7 @@ split_point_start: // At split points actual search starts from here
int variance = std::min(RootMoves[0].score - RootMoves[size - 1].score, PawnValueMidgame); int variance = std::min(RootMoves[0].score - RootMoves[size - 1].score, PawnValueMidgame);
int weakness = 120 - 2 * SkillLevel; int weakness = 120 - 2 * SkillLevel;
int max_s = -VALUE_INFINITE; int max_s = -VALUE_INFINITE;
Move best = MOVE_NONE;
// Choose best move. For each move score we add two terms both dependent on // 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, // weakness, one deterministic and bigger for weaker moves, and one random,
@ -1845,10 +1841,10 @@ split_point_start: // At split points actual search starts from here
if (s > max_s) if (s > max_s)
{ {
max_s = s; max_s = s;
*best = RootMoves[i].pv[0]; best = RootMoves[i].pv[0];
*ponder = RootMoves[i].pv[1];
} }
} }
return best;
} }