#include "movegen.h"
#include "search.h"
#include "thread.h"
-#include "ucioption.h"
+#include "uci.h"
using namespace Search;
maxPly = splitPointsSize = 0;
activeSplitPoint = NULL;
activePosition = NULL;
- idx = Threads.size();
+ idx = Threads.size(); // Starts from 0
}
// 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);
}
// 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<TimerThread>();
push_back(new_thread<MainThread>());
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() {
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);
// leave their idle loops and call search(). When all threads have returned from
// search() then split() returns.
-template <bool Fake>
-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) {
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;
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
// 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;
Threads.mutex.unlock();
}
-// Explicit template instantiations
-template void Thread::split<false>(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() {
projects / stockfish / blobdiff