#include "movegen.h"
#include "search.h"
#include "thread.h"
-#include "ucioption.h"
+#include "uci.h"
using namespace Search;
}
-// wait_for() set the thread to sleep until condition 'b' turns true
+// wait_for() set the thread to sleep until 'condition' turns true
-void ThreadBase::wait_for(volatile const bool& b) {
+void ThreadBase::wait_for(volatile const bool& condition) {
mutex.lock();
- while (!b) sleepCondition.wait(mutex);
+ while (!condition) sleepCondition.wait(mutex);
mutex.unlock();
}
// 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.
// 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();
// 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) {
activeSplitPoint = &sp;
activePosition = NULL;
- if (!Fake)
- for (Thread* slave; (slave = Threads.available_slave(this)) != NULL; )
- {
- sp.slavesMask.set(slave->idx);
- slave->activeSplitPoint = &sp;
- slave->searching = true; // Slave leaves idle_loop()
- slave->notify_one(); // Could be sleeping
- }
+ for (Thread* slave; (slave = Threads.available_slave(this)) != NULL; )
+ {
+ sp.slavesMask.set(slave->idx);
+ slave->activeSplitPoint = &sp;
+ slave->searching = true; // Slave leaves idle_loop()
+ slave->notify_one(); // Could be sleeping
+ }
// Everything is set up. The master thread enters the idle loop, from which
// it will instantly launch a search, because its 'searching' flag is set.
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() {
- MainThread* t = main();
- t->mutex.lock();
- while (t->thinking) sleepCondition.wait(t->mutex);
- t->mutex.unlock();
+ MainThread* th = main();
+ th->mutex.lock();
+ while (th->thinking) sleepCondition.wait(th->mutex);
+ th->mutex.unlock();
}