// 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 */};
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
+ // Root move list
RootMoveList Rml;
// MultiPV mode
}
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);
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);
void update_killers(Move m, Move killers[]);
void update_gains(const Position& pos, Move move, Value before, Value after);
+ void qsearch_scoring(Position& pos, MoveStack* mlist, MoveStack* last);
int current_search_time();
std::string value_to_uci(Value v);
int nps(const Position& pos);
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);
#endif
- // A dispatcher to choose among different move sources according to the type of node
+ // 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 moves before to search them.
- template<> struct MovePickerExt<false, true> : private MovePicker {
-
- MovePickerExt(const Position& p, Move, Depth, const History& h, SearchStack* ss, Value beta)
- : MovePicker(p, Rml[0].pv[0], ONE_PLY, h, ss, beta), firstCall(true) { // FIXME use depth
-
- 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 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;
- }
+ // 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 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();
- }
+ Rml.sort();
+ rm = Rml.begin();
+ }
- Move get_next_move() {
+ Move get_next_move() {
- if (!firstCall)
- ++rm;
- else
- firstCall = false;
+ if (!firstCall)
+ ++rm;
+ else
+ firstCall = false;
- return rm != Rml.end() ? rm->pv[0] : MOVE_NONE;
- }
- int number_of_evasions() const { return (int)Rml.size(); }
+ return rm != Rml.end() ? rm->pv[0] : MOVE_NONE;
+ }
- RootMoveList::iterator rm;
- bool firstCall;
+ RootMoveList::iterator rm;
+ bool firstCall;
};
- // In SpNodes use split point's shared MovePicker as move source
- template<> struct MovePickerExt<true, false> {
+ // In SpNodes use split point's shared MovePicker object as move source
+ template<> struct MovePickerExt<true, false> : public MovePicker {
- MovePickerExt(const Position&, Move, Depth, const History&, SearchStack* ss, Value)
- : mp(ss->sp->mp) {}
+ 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(); }
- int number_of_evasions() const { return mp->number_of_evasions(); }
+ Move get_next_move() { return mp->get_next_move(); }
- RootMoveList::iterator rm; // Dummy, never used
- MovePicker* mp;
+ RootMoveList::iterator rm; // Dummy, needed to compile
+ MovePicker* mp;
};
- // Normal case, create and use a MovePicker object as source
+ // 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 beta) : MovePicker(p, ttm, d, h, ss, beta) {}
+ 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, never used
+ 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>();
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) {
int iteration, researchCountFL, researchCountFH, aspirationDelta;
Value value, alpha, beta;
Depth depth;
- Move EasyMove;
+ Move bestMove, easyMove;
// Moves to search are verified, scored and sorted
Rml.init(pos, searchMoves);
// Initialize FIXME move before Rml.init()
TT.new_search();
H.clear();
- init_ss_array(ss, PLY_MAX_PLUS_2);
+ memset(ss, 0, PLY_MAX_PLUS_2 * sizeof(SearchStack));
alpha = -VALUE_INFINITE, beta = VALUE_INFINITE;
- EasyMove = MOVE_NONE;
+ *ponderMove = bestMove = easyMove = MOVE_NONE;
aspirationDelta = 0;
iteration = 1;
+ ss->currentMove = MOVE_NULL; // Hack to skip update_gains()
// Handle special case of searching on a mate/stale position
if (Rml.size() == 0)
// 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];
+ easyMove = Rml[0].pv[0];
// Iterative deepening loop
while (++iteration <= PLY_MAX && (!MaxDepth || iteration <= MaxDepth) && !StopRequest)
cout << "info depth " << iteration << endl;
Rml.bestMoveChanges = researchCountFL = researchCountFH = 0;
- depth = (iteration - 2) * ONE_PLY + InitialDepth;
+ depth = (iteration - 1) * ONE_PLY;
// Calculate dynamic aspiration window based on previous iterations
if (MultiPV == 1 && iteration >= 6 && abs(bestValues[iteration - 1]) < VALUE_KNOWN_WIN)
beta = Min(bestValues[iteration - 1] + aspirationDelta, VALUE_INFINITE);
}
- // 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.
+ // Start with a small aspiration window and, in case of fail high/low,
+ // research with bigger window until not failing high/low anymore.
while (true)
{
- // Search to the current depth
- value = search<PV, false, true>(pos, ss, alpha, beta, depth, 0);
+ // Search starting from ss+1 to allow calling update_gains()
+ value = search<PV, false, true>(pos, ss+1, alpha, beta, depth, 0);
- // Sort root moves and write PV lines to transposition table, in case
- // the relevant entries have been overwritten during the search.
- Rml.sort();
+ // Write PV lines 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);
// Value cannot be trusted. Break out immediately!
if (StopRequest)
- break; // FIXME move to 'while' condition
+ break;
assert(value >= alpha);
- bestMoveChanges[iteration] = Rml.bestMoveChanges; // FIXME move outside fail high/low loop
-
// In case of failing high/low increase aspiration window and research,
// otherwise exit the fail high/low loop.
if (value >= beta)
break;
}
- //Save info about search result
+ // Collect info about search result
+ bestMove = Rml[0].pv[0];
bestValues[iteration] = value;
+ bestMoveChanges[iteration] = Rml.bestMoveChanges;
// Drop the easy move if differs from the new best move
- if (Rml[0].pv[0] != EasyMove)
- EasyMove = MOVE_NONE;
+ if (bestMove != easyMove)
+ easyMove = MOVE_NONE;
if (UseTimeManagement && !StopRequest)
{
// Time to stop?
bool noMoreTime = 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)
- noMoreTime = true;
-
// 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)
noMoreTime = true;
- // Stop search early if one move seems to be much better than the others
+ // 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
- && EasyMove == Rml[0].pv[0]
- && ( ( Rml[0].nodes > (pos.nodes_searched() * 85) / 100
+ && 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
&& current_search_time() > TimeMgr.available_time() / 32)))
}
*ponderMove = Rml[0].pv[1];
- return Rml[0].pv[0];
+ return bestMove;
}
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;
ss->currentMove = ss->bestMove = threatMove = MOVE_NONE;
(ss+2)->killers[0] = (ss+2)->killers[1] = (ss+2)->mateKiller = MOVE_NONE;
- if (!Root) // FIXME remove
+ 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.
excludedMove = ss->excludedMove;
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 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)))
{
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
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
else if (move == excludedMove)
continue;
else
- movesSearched[moveCount++] = move;
+ moveCount++;
if (Root)
{
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.
// 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)
&& !StopRequest
&& !ThreadsMgr.cutoff_at_splitpoint(threadID))
ThreadsMgr.split<FakeSplit>(pos, ss, ply, &alpha, beta, &bestValue, depth,
- threatMove, mateThreat, moveCount, (MovePicker*)&mp, PvNode);
+ threatMove, mateThreat, moveCount, &mp, PvNode);
}
// Step 19. Check for mate and stalemate
if ( bestValue >= beta
&& !pos.move_is_capture_or_promotion(move))
{
- update_history(pos, move, depth, movesSearched, moveCount);
+ update_history(pos, move, depth, movesSearched, playedMoveCount);
update_killers(move, ss->killers);
}
}
}
+ // qsearch_scoring() scores each move of a list using a qsearch() evaluation,
+ // it is used in RootMoveList to get an initial scoring.
+ void qsearch_scoring(Position& pos, MoveStack* mlist, MoveStack* last) {
+
+ SearchStack ss[PLY_MAX_PLUS_2];
+ StateInfo st;
+
+ memset(ss, 0, 4 * sizeof(SearchStack));
+ ss[0].eval = ss[0].evalMargin = VALUE_NONE;
+
+ for (MoveStack* cur = mlist; cur != last; cur++)
+ {
+ ss[0].currentMove = cur->move;
+ pos.do_move(cur->move, st);
+ cur->score = -qsearch<PV>(pos, ss+1, -VALUE_INFINITE, VALUE_INFINITE, DEPTH_ZERO, 1);
+ pos.undo_move(cur->move);
+ }
+ }
+
+
// check_is_dangerous() tests if a checking move can be pruned in qsearch().
// bestValue is updated only when returning false because in that case move
// will 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];
}
// ok_to_use_TT() returns true if a transposition table score
- // can be used at a given point in search.
+ // 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.
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.
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);
}
}
void update_killers(Move m, Move killers[]) {
- if (m == killers[0])
- return;
-
- killers[1] = killers[0];
- killers[0] = m;
+ if (m != killers[0])
+ {
+ killers[1] = killers[0];
+ killers[0] = m;
+ }
}
}
- // 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) {
-
- for (int i = 0; i < size; i++, ss++)
- {
- ss->excludedMove = MOVE_NONE;
- ss->skipNullMove = false;
- ss->reduction = DEPTH_ZERO;
- ss->sp = NULL;
-
- if (i < 3)
- ss->killers[0] = ss->killers[1] = ss->mateKiller = MOVE_NONE;
- }
- }
-
-
// value_to_uci() converts a value to a string suitable for use with the UCI
// protocol specifications:
//
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;
- bestMoveChanges = 0;
clear();
+ bestMoveChanges = 0;
- // Generate all legal moves
+ // Generate all legal moves and score them
MoveStack* last = generate<MV_LEGAL>(pos, mlist);
+ qsearch_scoring(pos, mlist, last);
// Add each move to the RootMoveList's vector
for (MoveStack* cur = mlist; cur != last; cur++)
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(cur->score);
push_back(rm);
-
- pos.undo_move(cur->move);
}
sort();
}
projects / stockfish / blobdiff