void extract_pv_from_tt(Position& pos);
void insert_pv_in_tt(Position& pos);
- std::string pv_info_to_uci(Position& pos, Value alpha, Value beta, int pvLine = 0);
+ std::string pv_info_to_uci(Position& pos, int depth, Value alpha, Value beta, int pvLine);
int64_t nodes;
Value pv_score;
typedef std::vector<RootMove> Base;
- RootMoveList(Position& pos, Move searchMoves[]);
- void set_non_pv_scores(const Position& pos, Move ttm, SearchStack* ss);
-
+ void init(Position& pos, Move searchMoves[]);
void sort() { insertion_sort<RootMove, Base::iterator>(begin(), end()); }
void sort_multipv(int n) { insertion_sort<RootMove, Base::iterator>(begin(), begin() + n); }
+
+ int bestMoveChanges;
};
// Extensions. Configurable UCI options
// Array index 0 is used at non-PV nodes, index 1 at PV nodes.
- Depth CheckExtension[2], SingleEvasionExtension[2], PawnPushTo7thExtension[2];
- Depth PassedPawnExtension[2], PawnEndgameExtension[2], MateThreatExtension[2];
+ Depth CheckExtension[2], PawnPushTo7thExtension[2], PassedPawnExtension[2];
+ Depth PawnEndgameExtension[2], MateThreatExtension[2];
// 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
- // remaining ones we will extend it.
- const Value SingularExtensionMargin = Value(0x20);
-
// Step 12. Futility pruning
// Futility margin for quiescence search
template <NodeType PV>
inline Depth reduction(Depth d, int mn) { return (Depth) ReductionMatrix[PV][Min(d / 2, 63)][Min(mn, 63)]; }
- // Common adjustments
-
- // Search depth at iteration 1
- const Depth InitialDepth = ONE_PLY;
-
// Easy move margin. An easy move candidate must be at least this much
// better than the second best move.
const Value EasyMoveMargin = Value(0x200);
// Book object
Book OpeningBook;
- // Pointer to root move list
- RootMoveList* Rml;
-
- // Iteration counter
- int Iteration;
-
- // Scores and number of times the best move changed for each iteration
- Value ValueByIteration[PLY_MAX_PLUS_2];
- int BestMoveChangesByIteration[PLY_MAX_PLUS_2];
-
- // Search window management
- int AspirationDelta;
+ // Root move list
+ RootMoveList Rml;
// MultiPV mode
- int MultiPV;
+ int MultiPV, UCIMultiPV;
- // Time managment variables
+ // Time management variables
int SearchStartTime, MaxNodes, MaxDepth, ExactMaxTime;
bool UseTimeManagement, InfiniteSearch, Pondering, StopOnPonderhit;
bool FirstRootMove, StopRequest, QuitRequest, AspirationFailLow;
bool UseLogFile;
std::ofstream LogFile;
+ // Skill level adjustment
+ int SkillLevel;
+ RKISS RK;
+
// Multi-threads manager object
ThreadsManager ThreadsMgr;
}
template <NodeType PvNode>
- Depth extension(const Position& pos, Move m, bool captureOrPromotion, bool moveIsCheck, bool singleEvasion, bool mateThreat, bool* dangerous);
+ Depth extension(const Position& pos, Move m, bool captureOrPromotion, bool moveIsCheck, bool mateThreat, bool* dangerous);
bool check_is_dangerous(Position &pos, Move move, Value futilityBase, Value beta, Value *bValue);
bool connected_moves(const Position& pos, Move m1, Move m2);
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);
- void update_killers(Move m, Move killers[]);
void update_gains(const Position& pos, Move move, Value before, Value after);
int current_search_time();
std::string value_to_uci(Value v);
- int nps(const Position& pos);
+ std::string speed_to_uci(int64_t nodes);
void poll(const Position& pos);
void wait_for_stop_or_ponderhit();
- void init_ss_array(SearchStack* ss, int size);
#if !defined(_MSC_VER)
void* init_thread(void* threadID);
DWORD WINAPI init_thread(LPVOID threadID);
#endif
-}
+
+ // MovePickerExt is an extended MovePicker used to choose at compile time
+ // the proper move source according to the type of node.
+ template<bool SpNode, bool Root> struct MovePickerExt;
+
+ // In Root nodes use RootMoveList Rml as source. Score and sort the root moves
+ // before to search them.
+ template<> struct MovePickerExt<false, true> : public MovePicker {
+
+ MovePickerExt(const Position& p, Move ttm, Depth d, const History& h, SearchStack* ss, Value b)
+ : MovePicker(p, ttm, d, h, ss, b), firstCall(true) {
+ Move move;
+ 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 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)
+ for (rm = Rml.begin(); rm != Rml.end(); ++rm)
+ if (rm->pv[0] == move)
+ {
+ rm->non_pv_score = score--;
+ break;
+ }
+
+ Rml.sort();
+ rm = Rml.begin();
+ }
+
+ Move get_next_move() {
+
+ if (!firstCall)
+ ++rm;
+ else
+ firstCall = false;
+
+ return rm != Rml.end() ? rm->pv[0] : MOVE_NONE;
+ }
+
+ RootMoveList::iterator rm;
+ bool firstCall;
+ };
+
+ // In SpNodes use split point's shared MovePicker object as move source
+ template<> struct MovePickerExt<true, false> : public MovePicker {
+
+ MovePickerExt(const Position& p, Move ttm, Depth d, const History& h,
+ SearchStack* ss, Value b) : MovePicker(p, ttm, d, h, ss, b),
+ mp(ss->sp->mp) {}
+
+ Move get_next_move() { return mp->get_next_move(); }
+
+ RootMoveList::iterator rm; // Dummy, needed to compile
+ MovePicker* mp;
+ };
+
+ // Default case, create and use a MovePicker object as source
+ template<> struct MovePickerExt<false, false> : public MovePicker {
+
+ MovePickerExt(const Position& p, Move ttm, Depth d, const History& h,
+ SearchStack* ss, Value b) : MovePicker(p, ttm, d, h, ss, b) {}
+
+ RootMoveList::iterator rm; // Dummy, needed to compile
+ };
+
+} // namespace
////
CheckExtension[1] = Options["Check Extension (PV nodes)"].value<Depth>();
CheckExtension[0] = Options["Check Extension (non-PV nodes)"].value<Depth>();
- SingleEvasionExtension[1] = Options["Single Evasion Extension (PV nodes)"].value<Depth>();
- SingleEvasionExtension[0] = Options["Single Evasion Extension (non-PV nodes)"].value<Depth>();
PawnPushTo7thExtension[1] = Options["Pawn Push to 7th Extension (PV nodes)"].value<Depth>();
PawnPushTo7thExtension[0] = Options["Pawn Push to 7th Extension (non-PV nodes)"].value<Depth>();
PassedPawnExtension[1] = Options["Passed Pawn Extension (PV nodes)"].value<Depth>();
PawnEndgameExtension[0] = Options["Pawn Endgame Extension (non-PV nodes)"].value<Depth>();
MateThreatExtension[1] = Options["Mate Threat Extension (PV nodes)"].value<Depth>();
MateThreatExtension[0] = Options["Mate Threat Extension (non-PV nodes)"].value<Depth>();
- MultiPV = Options["MultiPV"].value<int>();
+ UCIMultiPV = Options["MultiPV"].value<int>();
+ SkillLevel = Options["Skill level"].value<int>();
UseLogFile = Options["Use Search Log"].value<bool>();
read_evaluation_uci_options(pos.side_to_move());
+ // 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.
+ MultiPV = (SkillLevel < 20 ? Max(UCIMultiPV, 4) : UCIMultiPV);
+
// Set the number of active threads
ThreadsMgr.read_uci_options();
init_eval(ThreadsMgr.active_threads());
std::string name = Options["Search Log Filename"].value<std::string>();
LogFile.open(name.c_str(), std::ios::out | std::ios::app);
- LogFile << "Searching: " << pos.to_fen()
- << "\ninfinite: " << infinite
- << " ponder: " << ponder
- << " time: " << myTime
- << " increment: " << myIncrement
- << " moves to go: " << movesToGo << endl;
+ LogFile << "\nSearching: " << pos.to_fen()
+ << "\ninfinite: " << infinite
+ << " ponder: " << ponder
+ << " time: " << myTime
+ << " increment: " << myIncrement
+ << " moves to go: " << movesToGo
+ << endl;
}
// We're ready to start thinking. Call the iterative deepening loop function
Move bestMove = id_loop(pos, searchMoves, &ponderMove);
// Print final search statistics
- cout << "info nodes " << pos.nodes_searched()
- << " nps " << nps(pos)
- << " time " << current_search_time() << endl;
+ cout << "info" << speed_to_uci(pos.nodes_searched()) << endl;
if (UseLogFile)
{
- LogFile << "\nNodes: " << pos.nodes_searched()
- << "\nNodes/second: " << nps(pos)
- << "\nBest move: " << move_to_san(pos, bestMove);
+ int t = current_search_time();
+
+ LogFile << "Nodes: " << pos.nodes_searched()
+ << "\nNodes/second: " << (t > 0 ? int(pos.nodes_searched() * 1000 / t) : 0)
+ << "\nBest move: " << move_to_san(pos, bestMove);
StateInfo st;
pos.do_move(bestMove, st);
- LogFile << "\nPonder move: "
- << move_to_san(pos, ponderMove) // Works also with MOVE_NONE
- << endl;
-
- // Return from think() with unchanged position
- pos.undo_move(bestMove);
-
+ LogFile << "\nPonder move: " << move_to_san(pos, ponderMove) << endl;
+ pos.undo_move(bestMove); // Return from think() with unchanged position
LogFile.close();
}
if (!StopRequest && (Pondering || InfiniteSearch))
wait_for_stop_or_ponderhit();
- // Could be both MOVE_NONE when searching on a stalemate position
- cout << "bestmove " << bestMove << " ponder " << ponderMove << endl;
+ // Could be MOVE_NONE when searching on a stalemate position
+ cout << "bestmove " << bestMove;
+
+ // 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.
+ if (ponderMove != MOVE_NONE)
+ cout << " ponder " << ponderMove;
+
+ cout << endl;
return !QuitRequest;
}
namespace {
- // id_loop() is the main iterative deepening loop. It calls search()
- // repeatedly with increasing depth until the allocated thinking time has
- // been consumed, the user stops the search, or the maximum search depth is
- // reached.
+ // id_loop() is the main iterative deepening loop. It calls search() repeatedly
+ // with increasing depth until the allocated thinking time has been consumed,
+ // user stops the search, or the maximum search depth is reached.
Move id_loop(Position& pos, Move searchMoves[], Move* ponderMove) {
SearchStack ss[PLY_MAX_PLUS_2];
- Depth depth;
- Move EasyMove = MOVE_NONE;
- Value value, alpha = -VALUE_INFINITE, beta = VALUE_INFINITE;
- int researchCountFL, researchCountFH;
+ Value bestValues[PLY_MAX_PLUS_2];
+ int bestMoveChanges[PLY_MAX_PLUS_2];
+ int depth, aspirationDelta;
+ Value value, alpha, beta;
+ Move bestMove, easyMove;
+
+ // Initialize stuff before a new search
+ memset(ss, 0, 4 * sizeof(SearchStack));
+ TT.new_search();
+ H.clear();
+ *ponderMove = bestMove = easyMove = MOVE_NONE;
+ depth = aspirationDelta = 0;
+ alpha = -VALUE_INFINITE, beta = VALUE_INFINITE;
+ ss->currentMove = MOVE_NULL; // Hack to skip update_gains()
- // Moves to search are verified, scored and sorted
- RootMoveList rml(pos, searchMoves);
- Rml = &rml;
+ // Moves to search are verified and copied
+ Rml.init(pos, searchMoves);
- // Handle special case of searching on a mate/stale position
- if (rml.size() == 0)
+ // Handle special case of searching on a mate/stalemate position
+ if (Rml.size() == 0)
{
- Value s = (pos.is_check() ? -VALUE_MATE : VALUE_DRAW);
-
- cout << "info depth " << 1
- << " score " << value_to_uci(s) << endl;
+ cout << "info depth 0 score "
+ << value_to_uci(pos.is_check() ? -VALUE_MATE : VALUE_DRAW)
+ << endl;
return MOVE_NONE;
}
- // Initialize
- TT.new_search();
- H.clear();
- init_ss_array(ss, PLY_MAX_PLUS_2);
- ValueByIteration[1] = rml[0].pv_score;
- Iteration = 1;
-
- // Send initial RootMoveList 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, 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)
+ while (++depth <= PLY_MAX && (!MaxDepth || depth <= MaxDepth) && !StopRequest)
{
- // Initialize iteration
- Iteration++;
- BestMoveChangesByIteration[Iteration] = 0;
-
- cout << "info depth " << Iteration << endl;
+ Rml.bestMoveChanges = 0;
+ cout << set960(pos.is_chess960()) << "info depth " << depth << endl;
// Calculate dynamic aspiration window based on previous iterations
- if (MultiPV == 1 && Iteration >= 6 && abs(ValueByIteration[Iteration - 1]) < VALUE_KNOWN_WIN)
+ if (MultiPV == 1 && depth >= 5 && abs(bestValues[depth - 1]) < VALUE_KNOWN_WIN)
{
- int prevDelta1 = ValueByIteration[Iteration - 1] - ValueByIteration[Iteration - 2];
- int prevDelta2 = ValueByIteration[Iteration - 2] - ValueByIteration[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 = (AspirationDelta + 7) / 8 * 8; // Round to match grainSize
+ aspirationDelta = Min(Max(abs(prevDelta1) + abs(prevDelta2) / 2, 16), 24);
+ aspirationDelta = (aspirationDelta + 7) / 8 * 8; // Round to match grainSize
- alpha = Max(ValueByIteration[Iteration - 1] - AspirationDelta, -VALUE_INFINITE);
- beta = Min(ValueByIteration[Iteration - 1] + AspirationDelta, VALUE_INFINITE);
+ alpha = Max(bestValues[depth - 1] - aspirationDelta, -VALUE_INFINITE);
+ beta = Min(bestValues[depth - 1] + aspirationDelta, VALUE_INFINITE);
}
- depth = (Iteration - 2) * ONE_PLY + InitialDepth;
-
- researchCountFL = researchCountFH = 0;
+ // Start with a small aspiration window and, in case of fail high/low,
+ // research with bigger window until not failing high/low anymore.
+ do {
+ // Search starting from ss+1 to allow calling update_gains()
+ value = search<PV, false, true>(pos, ss+1, alpha, beta, depth * ONE_PLY, 0);
- // We start with small aspiration window and in case of fail high/low, we
- // research with bigger window until we are not failing high/low anymore.
- while (true)
- {
- // Sort the moves before to (re)search
- rml.set_non_pv_scores(pos, rml[0].pv[0], ss);
- rml.sort();
-
- // Search to the current depth, rml is updated and sorted
- value = search<PV, false, true>(pos, ss, alpha, beta, depth, 0);
-
- // Sort the moves before to return
- rml.sort();
-
- // Write PV lines to transposition table, in case the relevant entries
+ // Write PV back 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);
+ for (int i = 0; i < Min(MultiPV, (int)Rml.size()); i++)
+ Rml[i].insert_pv_in_tt(pos);
+ // Value cannot be trusted. Break out immediately!
if (StopRequest)
break;
assert(value >= alpha);
+ // In case of failing high/low increase aspiration window and research,
+ // otherwise exit the fail high/low loop.
if (value >= beta)
{
- // Prepare for a research after a fail high, each time with a wider window
- beta = Min(beta + AspirationDelta * (1 << researchCountFH), VALUE_INFINITE);
- researchCountFH++;
+ beta = Min(beta + aspirationDelta, VALUE_INFINITE);
+ aspirationDelta += aspirationDelta / 2;
}
else if (value <= alpha)
{
AspirationFailLow = true;
StopOnPonderhit = false;
- // Prepare for a research after a fail low, each time with a wider window
- alpha = Max(alpha - AspirationDelta * (1 << researchCountFL), -VALUE_INFINITE);
- researchCountFL++;
+ alpha = Max(alpha - aspirationDelta, -VALUE_INFINITE);
+ aspirationDelta += aspirationDelta / 2;
}
else
break;
- }
- if (StopRequest)
- break; // Value cannot be trusted. Break out immediately!
+ } while (abs(value) < VALUE_KNOWN_WIN);
+
+ // Collect info about search result
+ bestMove = Rml[0].pv[0];
+ *ponderMove = Rml[0].pv[1];
+ bestValues[depth] = value;
+ bestMoveChanges[depth] = Rml.bestMoveChanges;
- //Save info about search result
- ValueByIteration[Iteration] = value;
+ // Send PV line to GUI and to log file
+ for (int i = 0; i < Min(UCIMultiPV, (int)Rml.size()); i++)
+ cout << Rml[i].pv_info_to_uci(pos, depth, alpha, beta, i) << endl;
- // Drop the easy move if differs from the new best move
- if (rml[0].pv[0] != EasyMove)
- EasyMove = MOVE_NONE;
+ if (UseLogFile)
+ LogFile << pretty_pv(pos, depth, value, current_search_time(), Rml[0].pv) << endl;
- if (UseTimeManagement)
+ // Init easyMove after first iteration or drop if differs from the best move
+ if (depth == 1 && (Rml.size() == 1 || Rml[0].pv_score > Rml[1].pv_score + EasyMoveMargin))
+ easyMove = bestMove;
+ else if (bestMove != easyMove)
+ easyMove = MOVE_NONE;
+
+ if (UseTimeManagement && !StopRequest)
{
// Time to stop?
- bool stopSearch = false;
-
- // Stop search early if there is only a single legal move,
- // we search up to Iteration 6 anyway to get a proper score.
- if (Iteration >= 6 && rml.size() == 1)
- stopSearch = true;
+ bool noMoreTime = false;
// Stop search early when the last two iterations returned a mate score
- if ( Iteration >= 6
- && abs(ValueByIteration[Iteration]) >= abs(VALUE_MATE) - 100
- && abs(ValueByIteration[Iteration-1]) >= abs(VALUE_MATE) - 100)
- stopSearch = true;
-
- // Stop search early if one move seems to be much better than the others
- if ( Iteration >= 8
- && EasyMove == rml[0].pv[0]
- && ( ( rml[0].nodes > (pos.nodes_searched() * 85) / 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 ( depth >= 7
+ && easyMove == bestMove
+ && ( Rml.size() == 1
+ ||( Rml[0].nodes > (pos.nodes_searched() * 85) / 100
&& current_search_time() > TimeMgr.available_time() / 16)
- ||( rml[0].nodes > (pos.nodes_searched() * 98) / 100
+ ||( Rml[0].nodes > (pos.nodes_searched() * 98) / 100
&& current_search_time() > TimeMgr.available_time() / 32)))
- stopSearch = true;
+ 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(BestMoveChangesByIteration[Iteration],
- BestMoveChangesByIteration[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
// move at the next iteration anyway.
if (current_search_time() > (TimeMgr.available_time() * 80) / 128)
- stopSearch = true;
+ noMoreTime = true;
- if (stopSearch)
+ if (noMoreTime)
{
if (Pondering)
StopOnPonderhit = true;
break;
}
}
+ }
+
+ // When playing with strength handicap choose best move among the MultiPV set
+ // using a statistical rule dependent on SkillLevel. Idea by Heinz van Saanen.
+ if (SkillLevel < 20)
+ {
+ assert(MultiPV > 1);
+
+ // Rml list is already sorted by pv_score in descending order
+ int s;
+ int max_s = -VALUE_INFINITE;
+ int size = Min(MultiPV, (int)Rml.size());
+ int max = Rml[0].pv_score;
+ int var = Min(max - Rml[size - 1].pv_score, PawnValueMidgame);
+ int wk = 120 - 2 * SkillLevel;
+
+ // PRNG sequence should be non deterministic
+ for (int i = abs(get_system_time() % 50); i > 0; i--)
+ RK.rand<unsigned>();
+
+ // Choose best move. For each move's score we add two terms both dependent
+ // on wk, one deterministic and bigger for weaker moves, and one random,
+ // then we choose the move with the resulting highest score.
+ for (int i = 0; i < size; i++)
+ {
+ s = Rml[i].pv_score;
- if (MaxDepth && Iteration >= MaxDepth)
- break;
+ // Don't allow crazy blunders even at very low skills
+ if (i > 0 && Rml[i-1].pv_score > s + EasyMoveMargin)
+ break;
+
+ // This is our magical formula
+ s += ((max - s) * wk + var * (RK.rand<unsigned>() % wk)) / 128;
+
+ if (s > max_s)
+ {
+ max_s = s;
+ bestMove = Rml[i].pv[0];
+ *ponderMove = Rml[i].pv[1];
+ }
+ }
}
- *ponderMove = rml[0].pv[1];
- return rml[0].pv[0];
+ return bestMove;
}
Move movesSearched[MOVES_MAX];
int64_t nodes;
- RootMoveList::iterator rm;
StateInfo st;
const TTEntry *tte;
Key posKey;
ValueType vt;
Value bestValue, value, oldAlpha;
Value refinedValue, nullValue, futilityBase, futilityValueScaled; // Non-PV specific
- bool isPvMove, isCheck, singleEvasion, singularExtensionNode, moveIsCheck, captureOrPromotion, dangerous;
+ bool isPvMove, isCheck, singularExtensionNode, moveIsCheck, captureOrPromotion, dangerous;
bool mateThreat = false;
- int moveCount = 0;
+ int moveCount = 0, playedMoveCount = 0;
int threadID = pos.thread();
SplitPoint* sp = NULL;
mateThreat = sp->mateThreat;
goto split_point_start;
}
- else {} // Hack to fix icc's "statement is unreachable" warning
+ else if (Root)
+ bestValue = alpha;
// Step 1. Initialize node and poll. Polling can abort search
- ss->currentMove = ss->bestMove = threatMove = MOVE_NONE;
+ ss->currentMove = ss->bestMove = threatMove = (ss+1)->excludedMove = MOVE_NONE;
+ (ss+1)->skipNullMove = false; (ss+1)->reduction = DEPTH_ZERO;
(ss+2)->killers[0] = (ss+2)->killers[1] = (ss+2)->mateKiller = MOVE_NONE;
- if (!Root)
+ if (threadID == 0 && ++NodesSincePoll > NodesBetweenPolls)
{
- if (threadID == 0 && ++NodesSincePoll > NodesBetweenPolls)
- {
- NodesSincePoll = 0;
- poll(pos);
- }
-
- // Step 2. Check for aborted search and immediate draw
- if ( StopRequest
- || ThreadsMgr.cutoff_at_splitpoint(threadID)
- || pos.is_draw()
- || ply >= PLY_MAX - 1)
- return VALUE_DRAW;
-
- // Step 3. Mate distance pruning
- alpha = Max(value_mated_in(ply), alpha);
- beta = Min(value_mate_in(ply+1), beta);
- if (alpha >= beta)
- return alpha;
+ NodesSincePoll = 0;
+ poll(pos);
}
- // Step 4. Transposition table lookup
+ // Step 2. Check for aborted search and immediate draw
+ if (( StopRequest
+ || ThreadsMgr.cutoff_at_splitpoint(threadID)
+ || pos.is_draw()
+ || ply >= PLY_MAX - 1) && !Root)
+ return VALUE_DRAW;
+
+ // Step 3. Mate distance pruning
+ alpha = Max(value_mated_in(ply), alpha);
+ beta = Min(value_mate_in(ply+1), beta);
+ if (alpha >= beta)
+ return alpha;
+ // 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
}
// Save gain for the parent non-capture move
- if (!Root)
- update_gains(pos, (ss-1)->currentMove, (ss-1)->eval, ss->eval);
+ update_gains(pos, (ss-1)->currentMove, (ss-1)->eval, ss->eval);
// Step 6. Razoring (is omitted in PV nodes)
if ( !PvNode
}
// Step 9. Internal iterative deepening
- if ( !Root
- && depth >= IIDDepth[PvNode]
- && ttMove == MOVE_NONE
+ if ( depth >= IIDDepth[PvNode]
+ && ttMove == MOVE_NONE
&& (PvNode || (!isCheck && ss->eval >= beta - IIDMargin)))
{
Depth d = (PvNode ? depth - 2 * ONE_PLY : depth / 2);
}
// Expensive mate threat detection (only for PV nodes)
- if (PvNode && !Root) // FIXME
+ if (PvNode)
mateThreat = pos.has_mate_threat();
split_point_start: // At split points actual search starts from here
// Initialize a MovePicker object for the current position
- // FIXME currently MovePicker() c'tor is needless called also in SplitPoint
- MovePicker mpBase(pos, ttMove, depth, H, ss, (PvNode ? -VALUE_INFINITE : beta));
- MovePicker& mp = SpNode ? *sp->mp : mpBase;
+ MovePickerExt<SpNode, Root> mp(pos, ttMove, depth, H, ss, (PvNode ? -VALUE_INFINITE : beta));
CheckInfo ci(pos);
ss->bestMove = MOVE_NONE;
- singleEvasion = !SpNode && isCheck && mp.number_of_evasions() == 1;
futilityBase = ss->eval + ss->evalMargin;
singularExtensionNode = !Root
&& !SpNode
&& !excludedMove // Do not allow recursive singular extension search
&& (tte->type() & VALUE_TYPE_LOWER)
&& tte->depth() >= depth - 3 * ONE_PLY;
- if (Root)
- {
- rm = Rml->begin();
- bestValue = alpha;
- }
-
if (SpNode)
{
lock_grab(&(sp->lock));
// Step 10. Loop through moves
// Loop through all legal moves until no moves remain or a beta cutoff occurs
while ( bestValue < beta
- && (!Root || rm != Rml->end())
- && ( Root || (move = mp.get_next_move()) != MOVE_NONE)
+ && (move = mp.get_next_move()) != MOVE_NONE
&& !ThreadsMgr.cutoff_at_splitpoint(threadID))
{
- if (Root)
+ assert(move_is_ok(move));
+
+ if (SpNode)
{
- move = rm->pv[0];
+ moveCount = ++sp->moveCount;
+ lock_release(&(sp->lock));
+ }
+ else if (move == excludedMove)
+ continue;
+ else
+ moveCount++;
+ if (Root)
+ {
// This is used by time management
- FirstRootMove = (rm == Rml->begin());
+ FirstRootMove = (moveCount == 1);
// Save the current node count before the move is searched
nodes = pos.nodes_searched();
if (SendSearchedNodes)
{
SendSearchedNodes = false;
- cout << "info nodes " << nodes
- << " nps " << nps(pos)
- << " time " << current_search_time() << endl;
+ cout << "info" << speed_to_uci(pos.nodes_searched()) << endl;
}
if (current_search_time() >= 1000)
<< " currmovenumber " << moveCount << endl;
}
- assert(move_is_ok(move));
-
- if (SpNode)
- {
- moveCount = ++sp->moveCount;
- lock_release(&(sp->lock));
- }
- else if (move == excludedMove)
- continue;
- else
- movesSearched[moveCount++] = move;
-
- isPvMove = (PvNode && moveCount <= (Root ? MultiPV : 1));
+ // At Root and at first iteration do a PV search on all the moves
+ // to score root moves. Otherwise only the first one is the PV.
+ isPvMove = (PvNode && moveCount <= (Root ? MultiPV + 1000 * (depth <= ONE_PLY) : 1));
moveIsCheck = pos.move_is_check(move, ci);
captureOrPromotion = pos.move_is_capture_or_promotion(move);
// Step 11. Decide the new search depth
- ext = extension<PvNode>(pos, move, captureOrPromotion, moveIsCheck, singleEvasion, mateThreat, &dangerous);
+ ext = extension<PvNode>(pos, move, captureOrPromotion, moveIsCheck, mateThreat, &dangerous);
// 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)
if (abs(ttValue) < VALUE_KNOWN_WIN)
{
- Value b = ttValue - SingularExtensionMargin;
+ Value b = ttValue - int(depth);
ss->excludedMove = move;
ss->skipNullMove = true;
Value v = search<NonPV>(pos, ss, b - 1, b, depth / 2, ply);
// Update current move (this must be done after singular extension search)
ss->currentMove = move;
- newDepth = depth - (!Root ? ONE_PLY : DEPTH_ZERO) + ext;
+ newDepth = depth - ONE_PLY + ext;
// Step 12. Futility pruning (is omitted in PV nodes)
if ( !PvNode
// Step 13. Make the move
pos.do_move(move, st, ci, moveIsCheck);
+ if (!SpNode && !captureOrPromotion)
+ movesSearched[playedMoveCount++] = move;
+
// Step extra. pv search (only in PV nodes)
// The first move in list is the expected PV
if (isPvMove)
&& ss->killers[0] != move
&& ss->killers[1] != move)
{
- ss->reduction = Root ? reduction<PvNode>(depth, moveCount - MultiPV + 1)
- : reduction<PvNode>(depth, moveCount);
+ ss->reduction = reduction<PvNode>(depth, moveCount);
if (ss->reduction)
{
alpha = SpNode ? sp->alpha : alpha;
alpha = sp->alpha;
}
- if (!Root && value > bestValue && !(SpNode && ThreadsMgr.cutoff_at_splitpoint(threadID)))
+ if (value > bestValue && !(SpNode && ThreadsMgr.cutoff_at_splitpoint(threadID)))
{
bestValue = value;
if (SpNode)
sp->bestValue = value;
- if (value > alpha)
+ if (!Root && value > alpha)
{
if (PvNode && value < beta) // We want always alpha < beta
{
ss->bestMove = move;
if (SpNode)
- sp->parentSstack->bestMove = move;
+ sp->ss->bestMove = move;
}
}
break;
// Remember searched nodes counts for this move
- rm->nodes += pos.nodes_searched() - nodes;
+ mp.rm->nodes += pos.nodes_searched() - nodes;
- // Step 17. Check for new best move
- if (!isPvMove && value <= alpha)
- rm->pv_score = -VALUE_INFINITE;
- else
+ // PV move or new best move ?
+ if (isPvMove || value > alpha)
{
- // PV move or new best move!
-
// Update PV
ss->bestMove = move;
- rm->pv_score = value;
- rm->extract_pv_from_tt(pos);
+ mp.rm->pv_score = value;
+ 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)
- BestMoveChangesByIteration[Iteration]++;
+ 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, alpha, beta, j) << endl;
-
- // Update alpha. In multi-pv we don't use aspiration window
- if (MultiPV == 1)
- {
- // Raise alpha to setup proper non-pv search upper bound
- if (value > alpha)
- alpha = bestValue = value;
- }
- else // Set alpha equal to minimum score among the PV lines
- alpha = bestValue = (*Rml)[Min(moveCount, MultiPV) - 1].pv_score; // FIXME why moveCount?
+ Rml.sort_multipv(moveCount);
- } // PV move or new best move
+ // 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)
+ alpha = Rml[Min(moveCount, MultiPV) - 1].pv_score; // FIXME why moveCount?
+ else if (value > alpha)
+ alpha = value;
+ }
+ else
+ mp.rm->pv_score = -VALUE_INFINITE;
- ++rm;
- }
+ } // Root
// Step 18. Check for split
if ( !Root
&& bestValue < beta
&& ThreadsMgr.available_thread_exists(threadID)
&& !StopRequest
- && !ThreadsMgr.cutoff_at_splitpoint(threadID)
- && Iteration <= 99)
+ && !ThreadsMgr.cutoff_at_splitpoint(threadID))
ThreadsMgr.split<FakeSplit>(pos, ss, ply, &alpha, beta, &bestValue, depth,
threatMove, mateThreat, moveCount, &mp, PvNode);
}
if ( bestValue >= beta
&& !pos.move_is_capture_or_promotion(move))
{
- update_history(pos, move, depth, movesSearched, moveCount);
- update_killers(move, ss->killers);
+ if (move != ss->killers[0])
+ {
+ ss->killers[1] = ss->killers[0];
+ ss->killers[0] = move;
+ }
+ update_history(pos, move, depth, movesSearched, playedMoveCount);
}
}
bestValue = futilityValue;
continue;
}
+
+ // Prune moves with negative or equal SEE
+ if ( futilityBase < beta
+ && depth < DEPTH_ZERO
+ && pos.see(move) <= 0)
+ continue;
}
// Detect non-capture evasions that are candidate to be pruned
// extended, as example because the corresponding UCI option is set to zero,
// the move is marked as 'dangerous' so, at least, we avoid to prune it.
template <NodeType PvNode>
- Depth extension(const Position& pos, Move m, bool captureOrPromotion, bool moveIsCheck,
- bool singleEvasion, bool mateThreat, bool* dangerous) {
+ Depth extension(const Position& pos, Move m, bool captureOrPromotion,
+ bool moveIsCheck, bool mateThreat, bool* dangerous) {
assert(m != MOVE_NONE);
Depth result = DEPTH_ZERO;
- *dangerous = moveIsCheck | singleEvasion | mateThreat;
+ *dangerous = moveIsCheck | mateThreat;
if (*dangerous)
{
if (moveIsCheck && pos.see_sign(m) >= 0)
result += CheckExtension[PvNode];
- if (singleEvasion)
- result += SingleEvasionExtension[PvNode];
-
if (mateThreat)
result += MateThreatExtension[PvNode];
}
// 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)
assert(m != move);
- if (!pos.move_is_capture_or_promotion(m))
- H.update(pos.piece_on(move_from(m)), move_to(m), -bonus);
+ H.update(pos.piece_on(move_from(m)), move_to(m), -bonus);
}
}
- // update_killers() add a good move that produced a beta-cutoff
- // among the killer moves of that ply.
-
- void update_killers(Move m, Move killers[]) {
-
- if (m == killers[0])
- return;
-
- killers[1] = killers[0];
- killers[0] = m;
- }
-
-
// update_gains() updates the gains table of a non-capture move given
// the static position evaluation before and after the move.
}
- // init_ss_array() does a fast reset of the first entries of a SearchStack
- // array and of all the excludedMove and skipNullMove entries.
-
- void init_ss_array(SearchStack* ss, int size) {
+ // current_search_time() returns the number of milliseconds which have passed
+ // since the beginning of the current search.
- for (int i = 0; i < size; i++, ss++)
- {
- ss->excludedMove = MOVE_NONE;
- ss->skipNullMove = false;
- ss->reduction = DEPTH_ZERO;
- ss->sp = NULL;
+ int current_search_time() {
- if (i < 3)
- ss->killers[0] = ss->killers[1] = ss->mateKiller = MOVE_NONE;
- }
+ return get_system_time() - SearchStartTime;
}
if (abs(v) < VALUE_MATE - PLY_MAX * ONE_PLY)
s << "cp " << int(v) * 100 / int(PawnValueMidgame); // Scale to centipawns
else
- s << "mate " << (v > 0 ? (VALUE_MATE - v + 1) / 2 : -(VALUE_MATE + v) / 2 );
+ s << "mate " << (v > 0 ? (VALUE_MATE - v + 1) / 2 : -(VALUE_MATE + v) / 2);
return s.str();
}
- // current_search_time() returns the number of milliseconds which have passed
- // since the beginning of the current search.
-
- int current_search_time() {
-
- return get_system_time() - SearchStartTime;
- }
+ // speed_to_uci() returns a string with time stats of current search suitable
+ // to be sent to UCI gui.
+ std::string speed_to_uci(int64_t nodes) {
- // nps() computes the current nodes/second count
+ std::stringstream s;
+ int t = current_search_time();
- int nps(const Position& pos) {
+ s << " nodes " << nodes
+ << " nps " << (t > 0 ? int(nodes * 1000 / t) : 0)
+ << " time " << t;
- int t = current_search_time();
- return (t > 0 ? int((pos.nodes_searched() * 1000) / t) : 0);
+ return s.str();
}
// We are line oriented, don't read single chars
std::string command;
- if (!std::getline(std::cin, command))
- command = "quit";
-
- if (command == "quit")
+ if (!std::getline(std::cin, command) || command == "quit")
{
// Quit the program as soon as possible
Pondering = false;
std::string command;
- while (true)
- {
- // Wait for a command from stdin
- if (!std::getline(std::cin, command))
- command = "quit";
+ // Wait for a command from stdin
+ while ( std::getline(std::cin, command)
+ && command != "ponderhit" && command != "stop" && command != "quit") {};
- if (command == "quit")
- {
- QuitRequest = true;
- break;
- }
- else if (command == "ponderhit" || command == "stop")
- break;
- }
+ if (command != "ponderhit" && command != "stop")
+ QuitRequest = true; // Must be "quit" or getline() returned false
}
threads[threadID].state = THREAD_SEARCHING;
- // Here we call search() with SplitPoint template parameter set to true
+ // Copy SplitPoint position and search stack and call search()
+ // with SplitPoint template parameter set to true.
+ SearchStack ss[PLY_MAX_PLUS_2];
SplitPoint* tsp = threads[threadID].splitPoint;
Position pos(*tsp->pos, threadID);
- SearchStack* ss = tsp->sstack[threadID] + 1;
- ss->sp = tsp;
+
+ memcpy(ss, tsp->ss - 1, 4 * sizeof(SearchStack));
+ (ss+1)->sp = tsp;
if (tsp->pvNode)
- search<PV, true, false>(pos, ss, tsp->alpha, tsp->beta, tsp->depth, tsp->ply);
+ search<PV, true, false>(pos, ss+1, tsp->alpha, tsp->beta, tsp->depth, tsp->ply);
else
- search<NonPV, true, false>(pos, ss, tsp->alpha, tsp->beta, tsp->depth, tsp->ply);
+ search<NonPV, true, false>(pos, ss+1, tsp->alpha, tsp->beta, tsp->depth, tsp->ply);
assert(threads[threadID].state == THREAD_SEARCHING);
splitPoint.moveCount = moveCount;
splitPoint.pos = &pos;
splitPoint.nodes = 0;
- splitPoint.parentSstack = ss;
+ splitPoint.ss = ss;
for (i = 0; i < activeThreads; i++)
splitPoint.slaves[i] = 0;
lock_release(&mpLock);
// Tell the threads that they have work to do. This will make them leave
- // their idle loop. But before copy search stack tail for each thread.
+ // their idle loop.
for (i = 0; i < activeThreads; i++)
if (i == master || splitPoint.slaves[i])
{
- memcpy(splitPoint.sstack[i], ss - 1, 4 * sizeof(SearchStack));
-
assert(i == master || threads[i].state == THREAD_BOOKED);
threads[i].state = THREAD_WORKISWAITING; // This makes the slave to exit from idle_loop()
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));
}
// pv_info_to_uci() returns a string with information on the current PV line
- // 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.
+ // formatted according to UCI specification. It is called at each iteration
+ // or after a new pv is found.
- std::string RootMove::pv_info_to_uci(Position& pos, 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 " << Iteration // FIXME
+ s << "info depth " << depth
<< " seldepth " << int(m - pv)
<< " multipv " << pvLine + 1
<< " score " << value_to_uci(pv_score)
<< (pv_score >= beta ? " lowerbound" : pv_score <= alpha ? " upperbound" : "")
- << " time " << current_search_time()
- << " nodes " << pos.nodes_searched()
- << " nps " << nps(pos)
+ << speed_to_uci(pos.nodes_searched())
<< " pv " << l.str();
- if (UseLogFile && pvLine == 0)
- {
- ValueType t = pv_score >= beta ? VALUE_TYPE_LOWER :
- pv_score <= alpha ? VALUE_TYPE_UPPER : VALUE_TYPE_EXACT;
-
- LogFile << pretty_pv(pos, current_search_time(), Iteration, pv_score, t, pv) << endl;
- }
return s.str();
}
- RootMoveList::RootMoveList(Position& pos, Move searchMoves[]) {
+ void RootMoveList::init(Position& pos, Move searchMoves[]) {
- SearchStack ss[PLY_MAX_PLUS_2];
MoveStack mlist[MOVES_MAX];
- StateInfo st;
Move* sm;
- // Initialize search stack
- init_ss_array(ss, PLY_MAX_PLUS_2);
- ss[0].eval = ss[0].evalMargin = VALUE_NONE;
+ clear();
+ bestMoveChanges = 0;
- // Generate all legal moves
+ // Generate all legal moves and add them to RootMoveList
MoveStack* last = generate<MV_LEGAL>(pos, mlist);
-
- // Add each move to the RootMoveList's vector
for (MoveStack* cur = mlist; cur != last; cur++)
{
// If we have a searchMoves[] list then verify cur->move
if (searchMoves[0] && *sm != cur->move)
continue;
- // Find a quick score for the move and add to the list
- pos.do_move(cur->move, st);
-
RootMove rm;
- rm.pv[0] = ss[0].currentMove = cur->move;
+ rm.pv[0] = cur->move;
rm.pv[1] = MOVE_NONE;
- rm.pv_score = -qsearch<PV>(pos, ss+1, -VALUE_INFINITE, VALUE_INFINITE, DEPTH_ZERO, 1);
+ rm.pv_score = -VALUE_INFINITE;
push_back(rm);
-
- pos.undo_move(cur->move);
}
- sort();
- }
-
- // 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.
- // This is the second order score that is used to compare the moves when
- // the first order pv scores of both moves are equal.
-
- void RootMoveList::set_non_pv_scores(const Position& pos, Move ttm, SearchStack* ss)
- {
- Move move;
- Value score = VALUE_ZERO;
- MovePicker mp(pos, ttm, ONE_PLY, H, ss);
-
- while ((move = mp.get_next_move()) != MOVE_NONE)
- for (Base::iterator it = begin(); it != end(); ++it)
- if (it->pv[0] == move)
- {
- it->non_pv_score = score--;
- break;
- }
}
} // namespace
projects / stockfish / blobdiff