X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fthread.cpp;h=4fc0953eac6ec7145ba8ade4e16b228db6d70e0f;hp=9e96be6eb7fa326d79b91761fe1aae73e232af8d;hb=4739037f967ac3c818907e89cc88c7b97021d027;hpb=3e5470d88fdcbfd4f3e7f773160961c3bca45ab9 diff --git a/src/thread.cpp b/src/thread.cpp index 9e96be6e..4fc0953e 100644 --- a/src/thread.cpp +++ b/src/thread.cpp @@ -23,7 +23,7 @@ #include "movegen.h" #include "search.h" #include "thread.h" -#include "ucioption.h" +#include "uci.h" using namespace Search; @@ -88,7 +88,7 @@ Thread::Thread() /* : splitPoints() */ { // Value-initialization bug in MSVC maxPly = splitPointsSize = 0; activeSplitPoint = NULL; activePosition = NULL; - idx = Threads.size(); + idx = Threads.size(); // Starts from 0 } @@ -119,11 +119,11 @@ bool Thread::available_to(const Thread* master) const { // Make a local copy to be sure it doesn't become zero under our feet while // testing next condition and so leading to an out of bounds access. - int size = splitPointsSize; + const int size = splitPointsSize; // No split points means that the thread is available as a slave for any // other thread otherwise apply the "helpful master" concept if possible. - return !size || (splitPoints[size - 1].slavesMask & (1ULL << master->idx)); + return !size || splitPoints[size - 1].slavesMask.test(master->idx); } @@ -181,20 +181,20 @@ void MainThread::idle_loop() { // init() is called at startup to create and launch requested threads, that will -// go immediately to sleep due to 'sleepWhileIdle' set to true. We cannot use -// a c'tor because Threads is a static object and we need a fully initialized -// engine at this point due to allocation of Endgames in Thread c'tor. +// go immediately to sleep. We cannot use a c'tor because Threads is a static +// object and we need a fully initialized engine at this point due to allocation +// of Endgames in Thread c'tor. void ThreadPool::init() { - sleepWhileIdle = true; timer = new_thread(); push_back(new_thread()); read_uci_options(); } -// exit() cleanly terminates the threads before the program exits +// exit() cleanly terminates the threads before the program exits. Cannot be done in +// d'tor because we have to terminate the threads before to free ThreadPool object. void ThreadPool::exit() { @@ -213,9 +213,8 @@ void ThreadPool::exit() { void ThreadPool::read_uci_options() { - maxThreadsPerSplitPoint = Options["Max Threads per Split Point"]; - minimumSplitDepth = Options["Min Split Depth"] * ONE_PLY; - size_t requested = Options["Threads"]; + minimumSplitDepth = Options["Min Split Depth"] * ONE_PLY; + size_t requested = Options["Threads"]; assert(requested > 0); @@ -256,8 +255,7 @@ Thread* ThreadPool::available_slave(const Thread* master) const { // leave their idle loops and call search(). When all threads have returned from // search() then split() returns. -template -void Thread::split(Position& pos, const Stack* ss, Value alpha, Value beta, Value* bestValue, +void Thread::split(Position& pos, Stack* ss, Value alpha, Value beta, Value* bestValue, Move* bestMove, Depth depth, int moveCount, MovePicker* movePicker, int nodeType, bool cutNode) { @@ -272,7 +270,7 @@ void Thread::split(Position& pos, const Stack* ss, Value alpha, Value beta, Valu sp.masterThread = this; sp.parentSplitPoint = activeSplitPoint; - sp.slavesMask = 1ULL << idx; + sp.slavesMask = 0, sp.slavesMask.set(idx); sp.depth = depth; sp.bestValue = *bestValue; sp.bestMove = *bestMove; @@ -293,17 +291,14 @@ void Thread::split(Position& pos, const Stack* ss, Value alpha, Value beta, Valu Threads.mutex.lock(); sp.mutex.lock(); + sp.allSlavesSearching = true; // Must be set under lock protection ++splitPointsSize; activeSplitPoint = &sp; activePosition = NULL; - size_t slavesCnt = 1; // This thread is always included - Thread* slave; - - while ( (slave = Threads.available_slave(this)) != NULL - && ++slavesCnt <= Threads.maxThreadsPerSplitPoint && !Fake) + for (Thread* slave; (slave = Threads.available_slave(this)) != NULL; ) { - sp.slavesMask |= 1ULL << slave->idx; + sp.slavesMask.set(slave->idx); slave->activeSplitPoint = &sp; slave->searching = true; // Slave leaves idle_loop() slave->notify_one(); // Could be sleeping @@ -313,25 +308,22 @@ void Thread::split(Position& pos, const Stack* ss, Value alpha, Value beta, Valu // it will instantly launch a search, because its 'searching' flag is set. // The thread will return from the idle loop when all slaves have finished // their work at this split point. - if (slavesCnt > 1 || Fake) - { - sp.mutex.unlock(); - Threads.mutex.unlock(); - - Thread::idle_loop(); // Force a call to base class idle_loop() - - // In the helpful master concept, a master can help only a sub-tree of its - // split point and because everything is finished here, it's not possible - // for the master to be booked. - assert(!searching); - assert(!activePosition); - - // We have returned from the idle loop, which means that all threads are - // finished. Note that setting 'searching' and decreasing splitPointsSize is - // done under lock protection to avoid a race with Thread::available_to(). - Threads.mutex.lock(); - sp.mutex.lock(); - } + sp.mutex.unlock(); + Threads.mutex.unlock(); + + Thread::idle_loop(); // Force a call to base class idle_loop() + + // In the helpful master concept, a master can help only a sub-tree of its + // split point and because everything is finished here, it's not possible + // for the master to be booked. + assert(!searching); + assert(!activePosition); + + // We have returned from the idle loop, which means that all threads are + // finished. Note that setting 'searching' and decreasing splitPointsSize is + // done under lock protection to avoid a race with Thread::available_to(). + Threads.mutex.lock(); + sp.mutex.lock(); searching = true; --splitPointsSize; @@ -345,11 +337,6 @@ void Thread::split(Position& pos, const Stack* ss, Value alpha, Value beta, Valu Threads.mutex.unlock(); } -// Explicit template instantiations -template void Thread::split(Position&, const Stack*, Value, Value, Value*, Move*, Depth, int, MovePicker*, int, bool); -template void Thread::split< true>(Position&, const Stack*, Value, Value, Value*, Move*, Depth, int, MovePicker*, int, bool); - - // wait_for_think_finished() waits for main thread to go to sleep then returns void ThreadPool::wait_for_think_finished() {