Instead of creating a running std::thread and
returning, wait in Thread c'tor that the native
thread of execution goes to sleep in idle_loop().
In this way we can simplify how search is started,
because when main thread is idle we are sure also
all other threads will be idle, in any case, even
at thread creation and startup.
After lazy smp went in, we can simpify and rewrite
a lot of logic that is now no more needed. This is
hopefully the final big cleanup.
Tested for no regression at 5+0.1 with 3 threads:
LLR: 2.95 (-2.94,2.94) [-5.00,0.00]
Total: 17411 W: 3248 L: 3198 D: 10965
No functional change.
Search::StateStackPtr st;
limits.startTime = now();
Threads.start_thinking(pos, limits, st);
Search::StateStackPtr st;
limits.startTime = now();
Threads.start_thinking(pos, limits, st);
- Threads.main()->join();
+ Threads.main()->wait_for_search_finished();
nodes += Threads.nodes_searched();
}
}
nodes += Threads.nodes_searched();
}
}
#include "types.h"
class Position;
#include "types.h"
class Position;
-/// CheckInfo struct is initialized at constructor time and keeps info used to
+/// CheckInfo struct is initialized at constructor time and keeps info used to
/// detect if a move gives check.
struct CheckInfo {
/// detect if a move gives check.
struct CheckInfo {
{
th->maxPly = 0;
th->rootDepth = DEPTH_ZERO;
{
th->maxPly = 0;
th->rootDepth = DEPTH_ZERO;
if (th != this)
{
th->rootPos = Position(rootPos, th);
th->rootMoves = rootMoves;
if (th != this)
{
th->rootPos = Position(rootPos, th);
th->rootMoves = rootMoves;
- th->notify_one(); // Wake up the thread and start searching
// Wait until all threads have finished
for (Thread* th : Threads)
if (th != this)
// 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;
// Check if there are threads with a better score than main thread.
Thread* bestThread = this;
ThreadPool Threads; // Global object
ThreadPool Threads; // Global object
-// Thread constructor makes some init and launches the thread that will go to
-// sleep in idle_loop().
+/// Thread constructor launch the thread and then wait until it goes to sleep
+/// in idle_loop().
- searching = true; // Avoid a race with start_thinking()
- exit = resetCalls = false;
+ resetCalls = exit = false;
maxPly = callsCnt = 0;
history.clear();
counterMoves.clear();
maxPly = callsCnt = 0;
history.clear();
counterMoves.clear();
- idx = Threads.size(); // Starts from 0
- std::thread::operator=(std::thread(&Thread::idle_loop, this));
+ idx = Threads.size(); // Start from 0
+
+ std::unique_lock<Mutex> lk(mutex);
+ searching = true;
+ nativeThread = std::thread(&Thread::idle_loop, this);
+ sleepCondition.wait(lk, [&]{ return !searching; });
-// Thread destructor waits for thread termination before deleting
+/// Thread destructor wait for thread termination before returning
Thread::~Thread() {
mutex.lock();
Thread::~Thread() {
mutex.lock();
- exit = true; // Search must be already finished
+ exit = true;
+ sleepCondition.notify_one();
-
- notify_one();
- std::thread::join(); // Wait for thread termination
-// Thread::join() waits for the thread to finish searching
-void Thread::join() {
+/// Thread::wait_for_search_finished() wait on sleep condition until not searching
+
+void Thread::wait_for_search_finished() {
std::unique_lock<Mutex> lk(mutex);
sleepCondition.wait(lk, [&]{ return !searching; });
}
std::unique_lock<Mutex> lk(mutex);
sleepCondition.wait(lk, [&]{ return !searching; });
}
-// Thread::notify_one() wakes up the thread when there is some work to do
+/// Thread::wait() wait on sleep condition until condition is true
-void Thread::notify_one() {
+void Thread::wait(std::atomic_bool& condition) {
std::unique_lock<Mutex> lk(mutex);
std::unique_lock<Mutex> lk(mutex);
- sleepCondition.notify_one();
+ sleepCondition.wait(lk, [&]{ return bool(condition); });
-// Thread::wait() set the thread to sleep until 'condition' turns true
+/// Thread::start_searching() wake up the thread that will start the search
-void Thread::wait(std::atomic_bool& condition) {
+void Thread::start_searching(bool resume) {
std::unique_lock<Mutex> lk(mutex);
std::unique_lock<Mutex> lk(mutex);
- sleepCondition.wait(lk, [&]{ return bool(condition); });
+
+ if (!resume)
+ searching = true;
+
+ sleepCondition.notify_one();
-// Thread::idle_loop() is where the thread is parked when it has no work to do
+/// Thread::idle_loop() is where the thread is parked when it has no work to do
void Thread::idle_loop() {
void Thread::idle_loop() {
while (!searching && !exit)
{
while (!searching && !exit)
{
- sleepCondition.notify_one(); // Wake up main thread if needed
+ sleepCondition.notify_one(); // Wake up any waiting thread
sleepCondition.wait(lk);
}
lk.unlock();
sleepCondition.wait(lk);
}
lk.unlock();
- if (!exit && searching)
-// ThreadPool::init() is called at startup to create and launch requested threads,
-// that will go immediately to sleep. We cannot use a constructor because Threads
-// is a static object and we need a fully initialized engine at this point due to
-// allocation of Endgames in the Thread constructor.
+/// ThreadPool::init() create and launch requested threads, that will go
+/// immediately to sleep. We cannot use a constructor because Threads is a
+/// static object and we need a fully initialized engine at this point due to
+/// allocation of Endgames in the Thread constructor.
void ThreadPool::init() {
void ThreadPool::init() {
-// ThreadPool::exit() terminates the threads before the program exits. Cannot be
-// done in destructor because threads must be terminated before freeing us.
+/// ThreadPool::exit() terminate threads before the program exits. Cannot be
+/// done in destructor because threads must be terminated before deleting any
+/// static objects, so while still in main().
void ThreadPool::exit() {
void ThreadPool::exit() {
- for (Thread* th : *this)
- delete th;
-
- clear(); // Get rid of stale pointers
+ while (size())
+ delete back(), pop_back();
-// ThreadPool::read_uci_options() updates internal threads parameters from the
-// corresponding UCI options and creates/destroys threads to match the requested
-// number. Thread objects are dynamically allocated to avoid creating all possible
-// threads in advance (which include pawns and material tables), even if only a
-// few are to be used.
+/// ThreadPool::read_uci_options() updates internal threads parameters from the
+/// corresponding UCI options and creates/destroys threads to match requested
+/// number. Thread objects are dynamically allocated.
void ThreadPool::read_uci_options() {
void ThreadPool::read_uci_options() {
- size_t requested = Options["Threads"];
+ size_t requested = Options["Threads"];
push_back(new Thread);
while (size() > requested)
push_back(new Thread);
while (size() > requested)
- {
- delete back();
- pop_back();
- }
+ delete back(), pop_back();
-// ThreadPool::nodes_searched() returns the number of nodes searched
+/// ThreadPool::nodes_searched() return the number of nodes searched
int64_t ThreadPool::nodes_searched() {
int64_t nodes = 0;
int64_t ThreadPool::nodes_searched() {
int64_t nodes = 0;
- for (Thread *th : *this)
+ for (Thread* th : *this)
nodes += th->rootPos.nodes_searched();
return nodes;
}
nodes += th->rootPos.nodes_searched();
return nodes;
}
-// ThreadPool::start_thinking() wakes up the main thread sleeping in
-// MainThread::idle_loop() and starts a new search, then returns immediately.
+/// ThreadPool::start_thinking() wake up the main thread sleeping in idle_loop()
+/// and start a new search, then return immediately.
void ThreadPool::start_thinking(const Position& pos, const LimitsType& limits,
StateStackPtr& states) {
void ThreadPool::start_thinking(const Position& pos, const LimitsType& limits,
StateStackPtr& states) {
- for (Thread* th : Threads)
- th->join();
+
+ main()->wait_for_search_finished();
Signals.stopOnPonderhit = Signals.firstRootMove = false;
Signals.stop = Signals.failedLowAtRoot = false;
Signals.stopOnPonderhit = Signals.firstRootMove = false;
Signals.stop = Signals.failedLowAtRoot = false;
|| std::count(limits.searchmoves.begin(), limits.searchmoves.end(), m))
main()->rootMoves.push_back(RootMove(m));
|| std::count(limits.searchmoves.begin(), limits.searchmoves.end(), m))
main()->rootMoves.push_back(RootMove(m));
- main()->searching = true;
- main()->notify_one(); // Wake up main thread: 'searching' must be already set
+ main()->start_searching();
/// entry its life time is unlimited and we don't have to care about someone
/// changing the entry under our feet.
/// entry its life time is unlimited and we don't have to care about someone
/// changing the entry under our feet.
-struct Thread : public std::thread {
+ std::thread nativeThread;
+ Mutex mutex;
+ ConditionVariable sleepCondition;
+ bool exit, searching;
+
+public:
Thread();
virtual ~Thread();
virtual void search();
void idle_loop();
Thread();
virtual ~Thread();
virtual void search();
void idle_loop();
- void join();
- void notify_one();
+ void start_searching(bool resume = false);
+ void wait_for_search_finished();
void wait(std::atomic_bool& b);
void wait(std::atomic_bool& b);
- std::atomic_bool exit, searching, resetCalls;
- Mutex mutex;
- ConditionVariable sleepCondition;
-
Pawns::Table pawnsTable;
Material::Table materialTable;
Endgames endgames;
Pawns::Table pawnsTable;
Material::Table materialTable;
Endgames endgames;
HistoryStats history;
MovesStats counterMoves;
Depth completedDepth;
HistoryStats history;
MovesStats counterMoves;
Depth completedDepth;
+ std::atomic_bool resetCalls;
-/// MainThread is a derived classes used to characterize the the main one
+/// MainThread is a derived class with a specific overload for the main thread
struct MainThread : public Thread {
virtual void search();
struct MainThread : public Thread {
virtual void search();
/// ThreadPool struct handles all the threads related stuff like init, starting,
/// ThreadPool struct handles all the threads related stuff like init, starting,
-/// parking and, most importantly, launching a thread.
-/// All the access to shared thread data is done through this class.
+/// parking and, most importantly, launching a thread. All the access to threads
+/// data is done through this class.
struct ThreadPool : public std::vector<Thread*> {
struct ThreadPool : public std::vector<Thread*> {
void exit(); // be initialized and valid during the whole thread lifetime.
MainThread* main() { return static_cast<MainThread*>(at(0)); }
void exit(); // be initialized and valid during the whole thread lifetime.
MainThread* main() { return static_cast<MainThread*>(at(0)); }
- void read_uci_options();
void start_thinking(const Position&, const Search::LimitsType&, Search::StateStackPtr&);
void start_thinking(const Position&, const Search::LimitsType&, Search::StateStackPtr&);
+ void read_uci_options();
int64_t nodes_searched();
};
int64_t nodes_searched();
};
|| (token == "ponderhit" && Search::Signals.stopOnPonderhit))
{
Search::Signals.stop = true;
|| (token == "ponderhit" && Search::Signals.stopOnPonderhit))
{
Search::Signals.stop = true;
- Threads.main()->notify_one(); // Could be sleeping
+ Threads.main()->start_searching(true); // Could be sleeping
}
else if (token == "ponderhit")
Search::Limits.ponder = 0; // Switch to normal search
}
else if (token == "ponderhit")
Search::Limits.ponder = 0; // Switch to normal search
} while (token != "quit" && argc == 1); // Passed args have one-shot behaviour
} while (token != "quit" && argc == 1); // Passed args have one-shot behaviour
- Threads.main()->join(); // Cannot quit whilst the search is running
+ Threads.main()->wait_for_search_finished();