};
EasyMoveManager EasyMove;
+ bool easyPlayed, failedLow;
double BestMoveChanges;
Value DrawValue[COLOR_NB];
CounterMovesHistoryStats CounterMovesHistory;
template uint64_t Search::perft<true>(Position&, Depth);
-/// MainThread::think() is called by the main thread when the program receives
+/// MainThread::search() is called by the main thread when the program receives
/// the UCI 'go' command. It searches from root position and at the end prints
/// the "bestmove" to output.
-void MainThread::think() {
+void MainThread::search() {
Color us = rootPos.side_to_move();
Time.init(Limits, us, rootPos.game_ply());
{
th->maxPly = 0;
th->rootDepth = DEPTH_ZERO;
- th->searching = true;
if (th != this)
{
th->rootPos = Position(rootPos, th);
th->rootMoves = rootMoves;
- th->notify_one(); // Wake up the thread and start searching
+ th->start_searching();
}
}
- search(true); // Let's start searching!
-
- // Stop the threads
- Signals.stop = true;
-
- // Wait until all threads have finished
- for (Thread* th : Threads)
- if (th != this)
- th->wait_while(th->searching);
+ Thread::search(); // Let's start searching!
}
// When playing in 'nodes as time' mode, subtract the searched nodes from
wait(Signals.stop);
}
+ // Stop the threads if not already stopped
+ Signals.stop = true;
+
+ // Wait until all threads have finished
+ for (Thread* th : Threads)
+ if (th != this)
+ th->wait_for_search_finished();
+
// Check if there are threads with a better score than main thread.
Thread* bestThread = this;
- for (Thread* th : Threads)
- if ( th->completedDepth > bestThread->completedDepth
- && th->rootMoves[0].score > bestThread->rootMoves[0].score)
- bestThread = th;
+ if (!easyPlayed && Options["MultiPV"] == 1 && !Skill(Options["Skill Level"]).enabled())
+ for (Thread* th : Threads)
+ if ( th->completedDepth > bestThread->completedDepth
+ && th->rootMoves[0].score > bestThread->rootMoves[0].score)
+ bestThread = th;
// Send new PV when needed.
// FIXME: Breaks multiPV, and skill levels
// repeatedly with increasing depth until the allocated thinking time has been
// consumed, user stops the search, or the maximum search depth is reached.
-void Thread::search(bool isMainThread) {
+void Thread::search() {
Stack stack[MAX_PLY+4], *ss = stack+2; // To allow referencing (ss-2) and (ss+2)
Value bestValue, alpha, beta, delta;
Move easyMove = MOVE_NONE;
+ bool isMainThread = (this == Threads.main());
std::memset(ss-2, 0, 5 * sizeof(Stack));
{
easyMove = EasyMove.get(rootPos.key());
EasyMove.clear();
+ easyPlayed = false;
BestMoveChanges = 0;
TT.new_search();
}
// Iterative deepening loop until requested to stop or target depth reached
while (++rootDepth < DEPTH_MAX && !Signals.stop && (!Limits.depth || rootDepth <= Limits.depth))
{
- // Set up the new depth for the helper threads
+ // Set up the new depth for the helper threads skipping in average each
+ // 2nd ply (using a half density map similar to a Hadamard matrix).
if (!isMainThread)
- rootDepth = std::min(DEPTH_MAX - ONE_PLY, Threads.main()->rootDepth + Depth(int(2.2 * log(1 + this->idx))));
+ {
+ int d = rootDepth + rootPos.game_ply();
+
+ if (idx <= 6 || idx > 24)
+ {
+ if (((d + idx) >> (msb(idx + 1) - 1)) % 2)
+ continue;
+ }
+ else
+ {
+ // Table of values of 6 bits with 3 of them set
+ static const int HalfDensityMap[] = {
+ 0x07, 0x0b, 0x0d, 0x0e, 0x13, 0x16, 0x19, 0x1a, 0x1c,
+ 0x23, 0x25, 0x26, 0x29, 0x2c, 0x31, 0x32, 0x34, 0x38
+ };
+
+ if ((HalfDensityMap[idx - 7] >> (d % 6)) & 1)
+ continue;
+ }
+ }
// Age out PV variability metric
if (isMainThread)
- BestMoveChanges *= 0.5;
+ BestMoveChanges *= 0.505, failedLow = false;
// Save the last iteration's scores before first PV line is searched and
// all the move scores except the (new) PV are set to -VALUE_INFINITE.
if (isMainThread)
{
- Signals.failedLowAtRoot = true;
+ failedLow = true;
Signals.stopOnPonderhit = false;
}
}
// 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
- || Time.elapsed() > Time.available()
- || ( rootMoves[0].pv[0] == easyMove
+ || Time.elapsed() > Time.available() * (failedLow? 641 : 315)/640
+ || ( easyPlayed = ( rootMoves[0].pv[0] == easyMove
&& BestMoveChanges < 0.03
- && Time.elapsed() > Time.available() / 10))
+ && Time.elapsed() > Time.available() / 8)))
{
// If we are allowed to ponder do not stop the search now but
// keep pondering until the GUI sends "ponderhit" or "stop".
}
}
- searching = false;
- notify_one(); // Wake up main thread if is sleeping waiting for us
-
if (!isMainThread)
return;
// 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 || Time.elapsed() < Time.available())
+ if (EasyMove.stableCnt < 6 || easyPlayed)
EasyMove.clear();
// If skill level is enabled, swap best PV line with the sub-optimal one
ss->ply = (ss-1)->ply + 1;
// Check for available remaining time
- if (thisThread->resetCallsCnt.load(std::memory_order_relaxed))
+ if (thisThread->resetCalls.load(std::memory_order_relaxed))
{
- thisThread->resetCallsCnt = false;
+ thisThread->resetCalls = false;
thisThread->callsCnt = 0;
}
if (++thisThread->callsCnt > 4096)
{
for (Thread* th : Threads)
- th->resetCallsCnt = true;
+ th->resetCalls = true;
check_time();
}
assert(0 <= ss->ply && ss->ply < MAX_PLY);
- ss->currentMove = ss->ttMove = (ss+1)->excludedMove = bestMove = MOVE_NONE;
+ ss->currentMove = (ss+1)->excludedMove = bestMove = MOVE_NONE;
(ss+1)->skipEarlyPruning = false; (ss+1)->reduction = DEPTH_ZERO;
(ss+2)->killers[0] = (ss+2)->killers[1] = MOVE_NONE;
posKey = excludedMove ? pos.exclusion_key() : pos.key();
tte = TT.probe(posKey, ttHit);
ttValue = ttHit ? value_from_tt(tte->value(), ss->ply) : VALUE_NONE;
- ss->ttMove = ttMove = RootNode ? thisThread->rootMoves[thisThread->PVIdx].pv[0]
- : ttHit ? tte->move() : MOVE_NONE;
+ ttMove = RootNode ? thisThread->rootMoves[thisThread->PVIdx].pv[0]
+ : ttHit ? tte->move() : MOVE_NONE;
// At non-PV nodes we check for an early TT cutoff
if ( !PvNode
ss->moveCount = ++moveCount;
- if (RootNode && thisThread == Threads.main())
- {
- Signals.firstRootMove = (moveCount == 1);
-
- if (Time.elapsed() > 3000)
- sync_cout << "info depth " << depth / ONE_PLY
- << " currmove " << UCI::move(move, pos.is_chess960())
- << " currmovenumber " << moveCount + thisThread->PVIdx << sync_endl;
- }
+ if (RootNode && thisThread == Threads.main() && Time.elapsed() > 3000)
+ sync_cout << "info depth " << depth / ONE_PLY
+ << " currmove " << UCI::move(move, pos.is_chess960())
+ << " currmovenumber " << moveCount + thisThread->PVIdx << sync_endl;
if (PvNode)
(ss+1)->pv = nullptr;
continue;
// History based pruning
- if ( depth <= 3 * ONE_PLY
+ if ( depth <= 4 * ONE_PLY
+ && move != ss->killers[0]
&& thisThread->history[pos.moved_piece(move)][to_sq(move)] < VALUE_ZERO
&& cmh[pos.moved_piece(move)][to_sq(move)] < VALUE_ZERO)
continue;
// re-searched at full depth.
if ( depth >= 3 * ONE_PLY
&& moveCount > 1
- && !captureOrPromotion
- && move != ss->killers[0]
- && move != ss->killers[1])
+ && !captureOrPromotion)
{
ss->reduction = reduction<PvNode>(improving, depth, moveCount);
if (Limits.ponder)
return;
- if (Limits.use_time_management())
- {
- bool stillAtFirstMove = Signals.firstRootMove.load(std::memory_order_relaxed)
- && !Signals.failedLowAtRoot.load(std::memory_order_relaxed)
- && elapsed > Time.available() * 3 / 4;
-
- if (stillAtFirstMove || elapsed > Time.maximum() - 10)
- Signals.stop = true;
- }
- else if (Limits.movetime && elapsed >= Limits.movetime)
- Signals.stop = true;
-
- else if (Limits.nodes && Threads.nodes_searched() >= Limits.nodes)
+ if ( (Limits.use_time_management() && elapsed > Time.maximum() - 10)
+ || (Limits.movetime && elapsed >= Limits.movetime)
+ || (Limits.nodes && Threads.nodes_searched() >= Limits.nodes))
Signals.stop = true;
}
projects / stockfish / blobdiff