LimitsType Limits;
RootMoveVector RootMoves;
Position RootPos;
- TimePoint SearchTime;
StateStackPtr SetupStates;
}
enum NodeType { Root, PV, NonPV };
// Razoring and futility margin based on depth
- inline Value razor_margin(Depth d) { return Value(512 + 32 * d); }
- inline Value futility_margin(Depth d) { return Value(200 * d); }
+ Value razor_margin(Depth d) { return Value(512 + 32 * d); }
+ Value futility_margin(Depth d) { return Value(200 * d); }
// Futility and reductions lookup tables, initialized at startup
int FutilityMoveCounts[2][16]; // [improving][depth]
Depth Reductions[2][2][64][64]; // [pv][improving][depth][moveNumber]
- template <bool PvNode> inline Depth reduction(bool i, Depth d, int mn) {
+ template <bool PvNode> Depth reduction(bool i, Depth d, int mn) {
return Reductions[PvNode][i][std::min(d, 63 * ONE_PLY)][std::min(mn, 63)];
}
};
size_t PVIdx;
- TimeManager TimeMgr;
EasyMoveManager EasyMove;
double BestMoveChanges;
Value DrawValue[COLOR_NB];
HistoryStats History;
CounterMovesHistoryStats CounterMovesHistory;
- GainsStats Gains;
- MovesStats Countermoves, Followupmoves;
+ MovesStats Countermoves;
template <NodeType NT, bool SpNode>
Value search(Position& pos, Stack* ss, Value alpha, Value beta, Depth depth, bool cutNode);
}
+/// Search::reset() clears all search memory, to obtain reproducible search results
+
+void Search::reset () {
+
+ TT.clear();
+ History.clear();
+ CounterMovesHistory.clear();
+ Countermoves.clear();
+}
+
+
/// Search::perft() is our utility to verify move generation. All the leaf nodes
/// up to the given depth are generated and counted and the sum returned.
template<bool Root>
void Search::think() {
- TimeMgr.init(Limits, RootPos.side_to_move(), RootPos.game_ply());
+ Color us = RootPos.side_to_move();
+ Time.init(Limits, us, RootPos.game_ply(), now());
int contempt = Options["Contempt"] * PawnValueEg / 100; // From centipawns
- DrawValue[ RootPos.side_to_move()] = VALUE_DRAW - Value(contempt);
- DrawValue[~RootPos.side_to_move()] = VALUE_DRAW + Value(contempt);
+ DrawValue[ us] = VALUE_DRAW - Value(contempt);
+ DrawValue[~us] = VALUE_DRAW + Value(contempt);
TB::Hits = 0;
TB::RootInTB = false;
Threads.timer->run = false;
}
+ // When playing in 'nodes as time' mode, subtract the searched nodes from
+ // the available ones before to exit.
+ if (Limits.npmsec)
+ Time.availableNodes += Limits.inc[us] - RootPos.nodes_searched();
+
// When we reach the maximum depth, we can arrive here without a raise of
// Signals.stop. However, if we are pondering or in an infinite search,
// the UCI protocol states that we shouldn't print the best move before the
beta = VALUE_INFINITE;
TT.new_search();
- History.clear();
- CounterMovesHistory.clear();
- Gains.clear();
- Countermoves.clear();
- Followupmoves.clear();
size_t multiPV = Options["MultiPV"];
Skill skill(Options["Skill Level"]);
// the UI) before a re-search.
if ( multiPV == 1
&& (bestValue <= alpha || bestValue >= beta)
- && now() - SearchTime > 3000)
+ && Time.elapsed() > 3000)
sync_cout << UCI::pv(pos, depth, alpha, beta) << sync_endl;
// In case of failing low/high increase aspiration window and
if (Signals.stop)
sync_cout << "info nodes " << RootPos.nodes_searched()
- << " time " << now() - SearchTime << sync_endl;
+ << " time " << Time.elapsed() << sync_endl;
- else if (PVIdx + 1 == multiPV || now() - SearchTime > 3000)
+ else if (PVIdx + 1 == multiPV || Time.elapsed() > 3000)
sync_cout << UCI::pv(pos, depth, alpha, beta) << sync_endl;
}
{
// Take some extra time if the best move has changed
if (depth > 4 * ONE_PLY && multiPV == 1)
- TimeMgr.pv_instability(BestMoveChanges);
+ Time.pv_instability(BestMoveChanges);
// Stop the search if only one legal move is available or all
// of the available time has been used or we matched an easyMove
// from the previous search and just did a fast verification.
if ( RootMoves.size() == 1
- || now() - SearchTime > TimeMgr.available_time()
+ || Time.elapsed() > Time.available()
|| ( RootMoves[0].pv[0] == easyMove
&& BestMoveChanges < 0.03
- && now() - SearchTime > TimeMgr.available_time() / 10))
+ && Time.elapsed() > Time.available() / 10))
{
// If we are allowed to ponder do not stop the search now but
// keep pondering until the GUI sends "ponderhit" or "stop".
// Clear any candidate easy move that wasn't stable for the last search
// iterations; the second condition prevents consecutive fast moves.
- if (EasyMove.stableCnt < 6 || now() - SearchTime < TimeMgr.available_time())
+ if (EasyMove.stableCnt < 6 || Time.elapsed() < Time.available())
EasyMove.clear();
// If skill level is enabled, swap best PV line with the sub-optimal one
Depth extension, newDepth, predictedDepth;
Value bestValue, value, ttValue, eval, nullValue, futilityValue;
bool ttHit, inCheck, givesCheck, singularExtensionNode, improving;
- bool captureOrPromotion, dangerous, doFullDepthSearch;
+ bool captureOrPromotion, doFullDepthSearch;
int moveCount, quietCount;
// Step 1. Initialize node
goto moves_loop;
}
- moveCount = quietCount = 0;
+ moveCount = quietCount = ss->moveCount = 0;
bestValue = -VALUE_INFINITE;
ss->ply = (ss-1)->ply + 1;
ss->ttMove = ttMove = RootNode ? RootMoves[PVIdx].pv[0] : ttHit ? tte->move() : MOVE_NONE;
ttValue = ttHit ? value_from_tt(tte->value(), ss->ply) : VALUE_NONE;
- // At non-PV nodes we check for a fail high/low. We don't probe at PV nodes
+ // At non-PV nodes we check for a fail high/low. We don't prune at PV nodes
if ( !PvNode
&& ttHit
&& tte->depth() >= depth
{
ss->currentMove = ttMove; // Can be MOVE_NONE
- // If ttMove is quiet, update killers, history, counter move and followup move on TT hit
- if (ttValue >= beta && ttMove && !pos.capture_or_promotion(ttMove) && !inCheck)
+ // If ttMove is quiet, update killers, history, counter move on TT hit
+ if (ttValue >= beta && ttMove && !pos.capture_or_promotion(ttMove))
update_stats(pos, ss, ttMove, depth, nullptr, 0);
return ttValue;
}
}
- // Step 5. Evaluate the position statically and update parent's gain statistics
+ // Step 5. Evaluate the position statically
if (inCheck)
{
ss->staticEval = eval = VALUE_NONE;
if (ss->skipEarlyPruning)
goto moves_loop;
- if ( !pos.captured_piece_type()
- && ss->staticEval != VALUE_NONE
- && (ss-1)->staticEval != VALUE_NONE
- && (move = (ss-1)->currentMove) != MOVE_NULL
- && move != MOVE_NONE
- && type_of(move) == NORMAL)
- {
- Square to = to_sq(move);
- Gains.update(pos.piece_on(to), to, -(ss-1)->staticEval - ss->staticEval);
- }
-
// Step 6. Razoring (skipped when in check)
if ( !PvNode
&& depth < 4 * ONE_PLY
&& eval + razor_margin(depth) <= alpha
- && ttMove == MOVE_NONE
- && !pos.pawn_on_7th(pos.side_to_move()))
+ && ttMove == MOVE_NONE)
{
if ( depth <= ONE_PLY
&& eval + razor_margin(3 * ONE_PLY) <= alpha)
assert((ss-1)->currentMove != MOVE_NONE);
assert((ss-1)->currentMove != MOVE_NULL);
- MovePicker mp(pos, ttMove, History, CounterMovesHistory, pos.captured_piece_type());
+ MovePicker mp(pos, ttMove, History, CounterMovesHistory, PieceValue[MG][pos.captured_piece_type()]);
CheckInfo ci(pos);
while ((move = mp.next_move<false>()) != MOVE_NONE)
&& !ttMove
&& (PvNode || ss->staticEval + 256 >= beta))
{
- Depth d = 2 * (depth - 2 * ONE_PLY) - (PvNode ? DEPTH_ZERO : depth / 2);
+ Depth d = depth - 2 * ONE_PLY - (PvNode ? DEPTH_ZERO : depth / 4);
ss->skipEarlyPruning = true;
- search<PvNode ? PV : NonPV, false>(pos, ss, alpha, beta, d / 2, true);
+ search<PvNode ? PV : NonPV, false>(pos, ss, alpha, beta, d, true);
ss->skipEarlyPruning = false;
tte = TT.probe(posKey, ttHit);
moves_loop: // When in check and at SpNode search starts from here
Square prevMoveSq = to_sq((ss-1)->currentMove);
- Move countermoves[] = { Countermoves[pos.piece_on(prevMoveSq)][prevMoveSq].first,
- Countermoves[pos.piece_on(prevMoveSq)][prevMoveSq].second };
+ Move countermove = Countermoves[pos.piece_on(prevMoveSq)][prevMoveSq];
- Square prevOwnMoveSq = to_sq((ss-2)->currentMove);
- Move followupmoves[] = { Followupmoves[pos.piece_on(prevOwnMoveSq)][prevOwnMoveSq].first,
- Followupmoves[pos.piece_on(prevOwnMoveSq)][prevOwnMoveSq].second };
-
- MovePicker mp(pos, ttMove, depth, History, CounterMovesHistory, countermoves, followupmoves, ss);
+ MovePicker mp(pos, ttMove, depth, History, CounterMovesHistory, countermove, ss);
CheckInfo ci(pos);
value = bestValue; // Workaround a bogus 'uninitialized' warning under gcc
improving = ss->staticEval >= (ss-2)->staticEval
if (!pos.legal(move, ci.pinned))
continue;
- moveCount = ++splitPoint->moveCount;
+ ss->moveCount = moveCount = ++splitPoint->moveCount;
splitPoint->spinlock.release();
}
else
- ++moveCount;
+ ss->moveCount = ++moveCount;
if (RootNode)
{
Signals.firstRootMove = (moveCount == 1);
- if (thisThread == Threads.main() && now() - SearchTime > 3000)
+ if (thisThread == Threads.main() && Time.elapsed() > 3000)
sync_cout << "info depth " << depth / ONE_PLY
<< " currmove " << UCI::move(move, pos.is_chess960())
<< " currmovenumber " << moveCount + PVIdx << sync_endl;
captureOrPromotion = pos.capture_or_promotion(move);
givesCheck = type_of(move) == NORMAL && !ci.dcCandidates
- ? ci.checkSq[type_of(pos.piece_on(from_sq(move)))] & to_sq(move)
+ ? ci.checkSquares[type_of(pos.piece_on(from_sq(move)))] & to_sq(move)
: pos.gives_check(move, ci);
- dangerous = givesCheck
- || type_of(move) != NORMAL
- || pos.advanced_pawn_push(move);
-
// Step 12. Extend checks
if (givesCheck && pos.see_sign(move) >= VALUE_ZERO)
extension = ONE_PLY;
if ( !RootNode
&& !captureOrPromotion
&& !inCheck
- && !dangerous
+ && !givesCheck
+ && !pos.advanced_pawn_push(move)
&& bestValue > VALUE_MATED_IN_MAX_PLY)
{
// Move count based pruning
// Futility pruning: parent node
if (predictedDepth < 7 * ONE_PLY)
{
- futilityValue = ss->staticEval + futility_margin(predictedDepth)
- + 128 + Gains[pos.moved_piece(move)][to_sq(move)];
+ futilityValue = ss->staticEval + futility_margin(predictedDepth) + 256;
if (futilityValue <= alpha)
{
// Check for legality just before making the move
if (!RootNode && !SpNode && !pos.legal(move, ci.pinned))
{
- moveCount--;
+ ss->moveCount = --moveCount;
continue;
}
ss->currentMove = move;
- if (!SpNode && !captureOrPromotion && quietCount < 64)
- quietsSearched[quietCount++] = move;
// Step 14. Make the move
pos.do_move(move, st, givesCheck);
ss->reduction = reduction<PvNode>(improving, depth, moveCount);
if ( (!PvNode && cutNode)
- || History[pos.piece_on(to_sq(move))][to_sq(move)] < VALUE_ZERO)
+ || ( History[pos.piece_on(to_sq(move))][to_sq(move)] < VALUE_ZERO
+ && CounterMovesHistory[pos.piece_on(prevMoveSq)][prevMoveSq]
+ [pos.piece_on(to_sq(move))][to_sq(move)] <= VALUE_ZERO))
ss->reduction += ONE_PLY;
- if (move == countermoves[0] || move == countermoves[1])
+ if ( History[pos.piece_on(to_sq(move))][to_sq(move)] > VALUE_ZERO
+ && CounterMovesHistory[pos.piece_on(prevMoveSq)][prevMoveSq]
+ [pos.piece_on(to_sq(move))][to_sq(move)] > VALUE_ZERO)
ss->reduction = std::max(DEPTH_ZERO, ss->reduction - ONE_PLY);
// Decrease reduction for moves that escape a capture
value = -search<NonPV, false>(pos, ss+1, -(alpha+1), -alpha, d, true);
- // Re-search at intermediate depth if reduction is very high
- if (value > alpha && ss->reduction >= 4 * ONE_PLY)
- {
- Depth d2 = std::max(newDepth - 2 * ONE_PLY, ONE_PLY);
- value = -search<NonPV, false>(pos, ss+1, -(alpha+1), -alpha, d2, true);
- }
-
doFullDepthSearch = (value > alpha && ss->reduction != DEPTH_ZERO);
ss->reduction = DEPTH_ZERO;
}
}
}
+ if (!SpNode && !captureOrPromotion && move != bestMove && quietCount < 64)
+ quietsSearched[quietCount++] = move;
+
// Step 19. Check for splitting the search
if ( !SpNode
&& Threads.size() >= 2
bestValue = excludedMove ? alpha
: inCheck ? mated_in(ss->ply) : DrawValue[pos.side_to_move()];
- // Quiet best move: update killers, history, countermoves and followupmoves
- else if (bestValue >= beta && !pos.capture_or_promotion(bestMove) && !inCheck)
- update_stats(pos, ss, bestMove, depth, quietsSearched, quietCount - 1);
+ // Quiet best move: update killers, history and countermoves
+ else if (bestMove && !pos.capture_or_promotion(bestMove))
+ update_stats(pos, ss, bestMove, depth, quietsSearched, quietCount);
tte->save(posKey, value_to_tt(bestValue, ss->ply),
bestValue >= beta ? BOUND_LOWER :
assert(is_ok(move));
givesCheck = type_of(move) == NORMAL && !ci.dcCandidates
- ? ci.checkSq[type_of(pos.piece_on(from_sq(move)))] & to_sq(move)
+ ? ci.checkSquares[type_of(pos.piece_on(from_sq(move)))] & to_sq(move)
: pos.gives_check(move, ci);
// Futility pruning
// Detect non-capture evasions that are candidates to be pruned
evasionPrunable = InCheck
&& bestValue > VALUE_MATED_IN_MAX_PLY
- && !pos.capture(move)
- && !pos.can_castle(pos.side_to_move());
+ && !pos.capture(move);
// Don't search moves with negative SEE values
if ( (!InCheck || evasionPrunable)
*pv = MOVE_NONE;
}
- // update_stats() updates killers, history, countermoves and followupmoves
- // stats after a fail-high of a quiet move.
- void update_stats(const Position& pos, Stack* ss, Move move, Depth depth, Move* quiets, int quietsCnt) {
+ // update_stats() updates killers, history, countermove history and
+ // countermoves stats for a quiet best move.
+
+ void update_stats(const Position& pos, Stack* ss, Move move,
+ Depth depth, Move* quiets, int quietsCnt) {
if (ss->killers[0] != move)
{
cmh.update(pos.moved_piece(quiets[i]), to_sq(quiets[i]), -bonus);
}
- if (is_ok((ss-2)->currentMove) && (ss-1)->currentMove == (ss-1)->ttMove)
+ // Extra penalty for PV move in previous ply when it gets refuted
+ if (is_ok((ss-2)->currentMove) && (ss-1)->moveCount == 1 && !pos.captured_piece_type())
{
Square prevPrevSq = to_sq((ss-2)->currentMove);
- Followupmoves.update(pos.piece_on(prevPrevSq), prevPrevSq, move);
+ HistoryStats& ttMoveCmh = CounterMovesHistory[pos.piece_on(prevPrevSq)][prevPrevSq];
+ ttMoveCmh.update(pos.piece_on(prevSq), prevSq, -bonus - 2 * depth / ONE_PLY - 1);
}
}
string UCI::pv(const Position& pos, Depth depth, Value alpha, Value beta) {
std::stringstream ss;
- TimePoint elapsed = now() - SearchTime + 1;
+ int elapsed = Time.elapsed() + 1;
size_t multiPV = std::min((size_t)Options["MultiPV"], RootMoves.size());
int selDepth = 0;
assert(searching);
+ spinlock.acquire();
+
searching = false;
activePosition = nullptr;
+
+ spinlock.release();
+
sp->slavesMask.reset(idx);
sp->allSlavesSearching = false;
sp->nodes += pos.nodes_searched();
void check_time() {
static TimePoint lastInfoTime = now();
- TimePoint elapsed = now() - SearchTime;
+ int elapsed = Time.elapsed();
if (now() - lastInfoTime >= 1000)
{
{
bool stillAtFirstMove = Signals.firstRootMove
&& !Signals.failedLowAtRoot
- && elapsed > TimeMgr.available_time() * 75 / 100;
+ && elapsed > Time.available() * 75 / 100;
if ( stillAtFirstMove
- || elapsed > TimeMgr.maximum_time() - 2 * TimerThread::Resolution)
+ || elapsed > Time.maximum() - 2 * TimerThread::Resolution)
Signals.stop = true;
}
else if (Limits.movetime && elapsed >= Limits.movetime)