read_evaluation_uci_options(pos.side_to_move());
Threads.read_uci_options();
- // Allocate pawn and material hash tables if number of active threads
- // increased and set a new TT size if changed.
- Threads.init_hash_tables();
+ // Set a new TT size if changed
TT.set_size(Options["Hash"].value<int>());
if (Options["Clear Hash"].value<bool>())
Rml.bestMoveChanges = 0;
- // MultiPV iteration loop
- for (MultiPVIteration = 0; MultiPVIteration < Min(MultiPV, (int)Rml.size()); MultiPVIteration++)
+ // MultiPV iteration loop. At depth 1 perform at least 2 iterations to
+ // get a score of the second best move for easy move detection.
+ int e = Min(Max(MultiPV, 2 * int(depth == 1)), (int)Rml.size());
+ for (MultiPVIteration = 0; MultiPVIteration < e; MultiPVIteration++)
{
// Calculate dynamic aspiration window based on previous iterations
if (depth >= 5 && abs(Rml[MultiPVIteration].prevScore) < VALUE_KNOWN_WIN)
<< " currmovenumber " << moveCount + MultiPVIteration << endl;
}
- // At Root and at first iteration do a PV search on all the moves to score root moves
- isPvMove = (PvNode && moveCount <= (RootNode && depth <= ONE_PLY ? MAX_MOVES : 1));
+ isPvMove = (PvNode && moveCount == 1);
givesCheck = pos.move_gives_check(move, ci);
captureOrPromotion = pos.move_is_capture_or_promotion(move);
} // namespace
-// Little helper used by idle_loop() to check that all the slaves of a
-// master thread have finished searching.
+// Little helper used by idle_loop() to check that all the slave threads of a
+// split point have finished searching.
static bool all_slaves_finished(SplitPoint* sp) {
- assert(sp);
-
for (int i = 0; i < Threads.size(); i++)
if (sp->is_slave[i])
return false;
// instead of wasting CPU time polling for work.
while ( do_sleep
|| do_terminate
- || (Threads.use_sleeping_threads() && state == Thread::AVAILABLE))
+ || (Threads.use_sleeping_threads() && !is_searching))
{
- assert(!sp || Threads.use_sleeping_threads());
- assert(threadID != 0 || Threads.use_sleeping_threads());
+ assert((!sp && threadID) || Threads.use_sleeping_threads());
+
+ // Grab the lock to avoid races with Thread::wake_up()
+ lock_grab(&sleepLock);
// Slave thread should exit as soon as do_terminate flag raises
if (do_terminate)
{
assert(!sp);
- state = Thread::TERMINATED;
+ lock_release(&sleepLock);
return;
}
- if (state == Thread::INITIALIZING)
- state = Thread::AVAILABLE;
-
- // Grab the lock to avoid races with Thread::wake_up()
- lock_grab(&sleepLock);
-
// If we are master and all slaves have finished don't go to sleep
if (sp && all_slaves_finished(sp))
{
// particular we need to avoid a deadlock in case a master thread has,
// in the meanwhile, allocated us and sent the wake_up() call before we
// had the chance to grab the lock.
- if (do_sleep || state == Thread::AVAILABLE)
+ if (do_sleep || !is_searching)
cond_wait(&sleepCond, &sleepLock);
lock_release(&sleepLock);
}
// If this thread has been assigned work, launch a search
- if (state == Thread::WORKISWAITING)
+ if (is_searching)
{
assert(!do_terminate);
- state = Thread::SEARCHING;
-
// Copy split point position and search stack and call search()
SearchStack ss[PLY_MAX_PLUS_2];
SplitPoint* tsp = splitPoint;
else
assert(false);
- assert(state == Thread::SEARCHING);
+ assert(is_searching);
- state = Thread::AVAILABLE;
+ is_searching = false;
// Wake up master thread so to allow it to return from the idle loop in
// case we are the last slave of the split point.
if ( Threads.use_sleeping_threads()
&& threadID != tsp->master
- && Threads[tsp->master].state == Thread::AVAILABLE)
+ && !Threads[tsp->master].is_searching)
Threads[tsp->master].wake_up();
}