X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fthread.cpp;h=a8e26b9f85c43a69a3f0260db1313285ca3ccee2;hb=00d9e9fd283b31e63389af091b158dbc3fedfc0e;hp=e631645b3a836350b32f6ed703509e662f6fa4af;hpb=1e92df6b20aa224026b435e03169edaf4bbecdc1;p=stockfish diff --git a/src/thread.cpp b/src/thread.cpp index e631645b..eb64f7ee 100644 --- a/src/thread.cpp +++ b/src/thread.cpp @@ -1,7 +1,7 @@ /* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) - Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad + Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Stockfish is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -17,335 +17,244 @@ along with this program. If not, see . */ -#include +#include // For std::count +#include +#include "movegen.h" +#include "search.h" #include "thread.h" -#include "ucioption.h" +#include "uci.h" -ThreadsManager Threads; // Global object definition +using namespace Search; -namespace { extern "C" { +ThreadPool Threads; // Global object - // start_routine() is the C function which is called when a new thread - // is launched. It simply calls idle_loop() with the supplied threadID. - // There are two versions of this function; one for POSIX threads and - // one for Windows threads. +extern void check_time(); -#if defined(_MSC_VER) +namespace { - DWORD WINAPI start_routine(LPVOID threadID) { + // Helpers to launch a thread after creation and joining before delete. Must be + // outside Thread c'tor and d'tor because the object must be fully initialized + // when start_routine (and hence virtual idle_loop) is called and when joining. - Threads[*(int*)threadID].idle_loop(NULL); - return 0; - } - -#else + template T* new_thread() { + std::thread* th = new T; + *th = std::thread(&T::idle_loop, (T*)th); // Will go to sleep + return (T*)th; + } - void* start_routine(void* threadID) { + void delete_thread(ThreadBase* th) { - Threads[*(int*)threadID].idle_loop(NULL); - return NULL; - } + th->mutex.lock(); + th->exit = true; // Search must be already finished + th->mutex.unlock(); -#endif + th->notify_one(); + th->join(); // Wait for thread termination + delete th; + } -} } +} -// wake_up() wakes up the thread, normally at the beginning of the search or, -// if "sleeping threads" is used, when there is some work to do. +// ThreadBase::notify_one() wakes up the thread when there is some work to do -void Thread::wake_up() { +void ThreadBase::notify_one() { - lock_grab(&sleepLock); - cond_signal(&sleepCond); - lock_release(&sleepLock); + std::unique_lock lk(mutex); + sleepCondition.notify_one(); } -// cutoff_occurred() checks whether a beta cutoff has occurred in -// the thread's currently active split point, or in some ancestor of -// the current split point. +// ThreadBase::wait() set the thread to sleep until 'condition' turns true -bool Thread::cutoff_occurred() const { +void ThreadBase::wait(std::atomic& condition) { - for (SplitPoint* sp = splitPoint; sp; sp = sp->parent) - if (sp->is_betaCutoff) - return true; - return false; + std::unique_lock lk(mutex); + sleepCondition.wait(lk, [&]{ return bool(condition); }); } -// is_available_to() checks whether the thread is available to help the thread with -// threadID "master" at a split point. An obvious requirement is that thread must be -// idle. With more than two threads, this is not by itself sufficient: If the thread -// is the master of some active split point, it is only available as a slave to the -// threads which are busy searching the split point at the top of "slave"'s split -// point stack (the "helpful master concept" in YBWC terminology). +// ThreadBase::wait_while() set the thread to sleep until 'condition' turns false +void ThreadBase::wait_while(std::atomic& condition) { -bool Thread::is_available_to(int master) const { + std::unique_lock lk(mutex); + sleepCondition.wait(lk, [&]{ return !condition; }); +} - if (state != AVAILABLE) - return false; - // Make a local copy to be sure doesn't become zero under our feet while - // testing next condition and so leading to an out of bound access. - int localActiveSplitPoints = activeSplitPoints; +// Thread c'tor makes some init but does not launch any execution thread that +// will be started only when c'tor returns. - // No active split points means that the thread is available as a slave for any - // other thread otherwise apply the "helpful master" concept if possible. - if ( !localActiveSplitPoints - || splitPoints[localActiveSplitPoints - 1].is_slave[master]) - return true; +Thread::Thread() { - return false; + searching = false; + maxPly = 0; + history.clear(); + counterMoves.clear(); + idx = Threads.size(); // Starts from 0 } -// read_uci_options() updates number of active threads and other internal -// parameters according to the UCI options values. It is called before -// to start a new search. +// TimerThread::idle_loop() is where the timer thread waits Resolution milliseconds +// and then calls check_time(). When not searching, thread sleeps until it's woken up. -void ThreadsManager::read_uci_options() { +void TimerThread::idle_loop() { - maxThreadsPerSplitPoint = Options["Maximum Number of Threads per Split Point"].value(); - minimumSplitDepth = Options["Minimum Split Depth"].value() * ONE_PLY; - useSleepingThreads = Options["Use Sleeping Threads"].value(); + while (!exit) + { + std::unique_lock lk(mutex); - set_size(Options["Threads"].value()); -} + if (!exit) + sleepCondition.wait_for(lk, std::chrono::milliseconds(run ? Resolution : INT_MAX)); + lk.unlock(); -// set_size() changes the number of active threads and raises do_sleep flag for -// all the unused threads that will go immediately to sleep. + if (!exit && run) + check_time(); + } +} -void ThreadsManager::set_size(int cnt) { - assert(cnt > 0 && cnt <= MAX_THREADS); +// Thread::idle_loop() is where the thread is parked when it has no work to do - activeThreads = cnt; +void Thread::idle_loop() { - for (int i = 0; i < MAX_THREADS; i++) - threads[i].do_sleep = !(i < activeThreads); -} + while (!exit) + { + std::unique_lock lk(mutex); + while (!searching && !exit) + sleepCondition.wait(lk); -// init() is called during startup. Initializes locks and condition variables -// and launches all threads sending them immediately to sleep. + lk.unlock(); -void ThreadsManager::init() { + if (!exit && searching) + search(); + } +} - // Threads will go to sleep as soon as created, only main thread is kept alive - set_size(1); - threads[0].state = Thread::SEARCHING; - threads[0].threadID = 0; - // Allocate pawn and material hash tables for main thread - init_hash_tables(); +// MainThread::idle_loop() is where the main thread is parked waiting to be started +// when there is a new search. The main thread will launch all the slave threads. - // Initialize threads lock, used when allocating slaves during splitting - lock_init(&threadsLock); +void MainThread::idle_loop() { - // Initialize sleep and split point locks - for (int i = 0; i < MAX_THREADS; i++) + while (!exit) { - lock_init(&threads[i].sleepLock); - cond_init(&threads[i].sleepCond); + std::unique_lock lk(mutex); - for (int j = 0; j < MAX_ACTIVE_SPLIT_POINTS; j++) - lock_init(&(threads[i].splitPoints[j].lock)); - } + thinking = false; - // Create and startup all the threads but the main that is already running - for (int i = 1; i < MAX_THREADS; i++) - { - threads[i].state = Thread::AVAILABLE; - threads[i].threadID = i; - -#if defined(_MSC_VER) - bool ok = (CreateThread(NULL, 0, start_routine, (LPVOID)&threads[i].threadID , 0, NULL) != NULL); -#else - pthread_t pthreadID; - bool ok = (pthread_create(&pthreadID, NULL, start_routine, (void*)&threads[i].threadID) == 0); - pthread_detach(pthreadID); -#endif - if (!ok) + while (!thinking && !exit) { - std::cout << "Failed to create thread number " << i << std::endl; - ::exit(EXIT_FAILURE); + sleepCondition.notify_one(); // Wake up the UI thread if needed + sleepCondition.wait(lk); } + + lk.unlock(); + + if (!exit) + think(); } } -// exit() is called to cleanly terminate the threads when the program finishes +// MainThread::join() waits for main thread to finish thinking -void ThreadsManager::exit() { +void MainThread::join() { - for (int i = 0; i < MAX_THREADS; i++) - { - // Wake up all the slave threads and wait for termination - if (i != 0) - { - threads[i].do_terminate = true; - threads[i].wake_up(); - while (threads[i].state != Thread::TERMINATED) {} - } + std::unique_lock lk(mutex); + sleepCondition.wait(lk, [&]{ return !thinking; }); +} - // Now we can safely destroy locks and wait conditions - lock_destroy(&threads[i].sleepLock); - cond_destroy(&threads[i].sleepCond); - for (int j = 0; j < MAX_ACTIVE_SPLIT_POINTS; j++) - lock_destroy(&(threads[i].splitPoints[j].lock)); - } +// ThreadPool::init() is called at startup to create and launch requested threads, +// that will 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. - lock_destroy(&threadsLock); +void ThreadPool::init() { + + timer = new_thread(); + push_back(new_thread()); + read_uci_options(); } -// init_hash_tables() dynamically allocates pawn and material hash tables -// according to the number of active threads. This avoids preallocating -// memory for all possible threads if only few are used as, for instance, -// on mobile devices where memory is scarce and allocating for MAX_THREADS -// threads could even result in a crash. +// ThreadPool::exit() terminates the threads before the program exits. Cannot be +// done in d'tor because threads must be terminated before freeing us. -void ThreadsManager::init_hash_tables() { +void ThreadPool::exit() { - for (int i = 0; i < activeThreads; i++) - { - threads[i].pawnTable.init(); - threads[i].materialTable.init(); - } -} + delete_thread(timer); // As first because check_time() accesses threads data + timer = nullptr; + for (Thread* th : *this) + delete_thread(th); -// available_slave_exists() tries to find an idle thread which is available as -// a slave for the thread with threadID "master". + clear(); // Get rid of stale pointers +} -bool ThreadsManager::available_slave_exists(int master) const { - assert(master >= 0 && master < activeThreads); +// 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. - for (int i = 0; i < activeThreads; i++) - if (i != master && threads[i].is_available_to(master)) - return true; +void ThreadPool::read_uci_options() { - return false; -} + size_t requested = Options["Threads"]; + assert(requested > 0); -// split() does the actual work of distributing the work at a node between -// several available threads. If it does not succeed in splitting the -// node (because no idle threads are available, or because we have no unused -// split point objects), the function immediately returns. If splitting is -// possible, a SplitPoint object is initialized with all the data that must be -// copied to the helper threads and we tell our helper threads that they have -// been assigned work. This will cause them to instantly leave their idle loops and -// call search().When all threads have returned from search() then split() returns. - -template -Value ThreadsManager::split(Position& pos, SearchStack* ss, Value alpha, Value beta, - Value bestValue, Depth depth, Move threatMove, - int moveCount, MovePicker* mp, int nodeType) { - assert(pos.is_ok()); - assert(bestValue >= -VALUE_INFINITE); - assert(bestValue <= alpha); - assert(alpha < beta); - assert(beta <= VALUE_INFINITE); - assert(depth > DEPTH_ZERO); - assert(pos.thread() >= 0 && pos.thread() < activeThreads); - assert(activeThreads > 1); - - int i, master = pos.thread(); - Thread& masterThread = threads[master]; - - // If we already have too many active split points, don't split - if (masterThread.activeSplitPoints >= MAX_ACTIVE_SPLIT_POINTS) - return bestValue; - - // Pick the next available split point object from the split point stack - SplitPoint* sp = masterThread.splitPoints + masterThread.activeSplitPoints; - - // Initialize the split point object - sp->parent = masterThread.splitPoint; - sp->master = master; - sp->is_betaCutoff = false; - sp->depth = depth; - sp->threatMove = threatMove; - sp->alpha = alpha; - sp->beta = beta; - sp->nodeType = nodeType; - sp->bestValue = bestValue; - sp->mp = mp; - sp->moveCount = moveCount; - sp->pos = &pos; - sp->nodes = 0; - sp->ss = ss; - for (i = 0; i < activeThreads; i++) - sp->is_slave[i] = false; - - // If we are here it means we are not available - assert(masterThread.state == Thread::SEARCHING); - - int workersCnt = 1; // At least the master is included - - // Try to allocate available threads and ask them to start searching setting - // the state to Thread::WORKISWAITING, this must be done under lock protection - // to avoid concurrent allocation of the same slave by another master. - lock_grab(&threadsLock); - - for (i = 0; !Fake && i < activeThreads && workersCnt < maxThreadsPerSplitPoint; i++) - if (i != master && threads[i].is_available_to(master)) - { - workersCnt++; - sp->is_slave[i] = true; - threads[i].splitPoint = sp; + while (size() < requested) + push_back(new_thread()); - // This makes the slave to exit from idle_loop() - threads[i].state = Thread::WORKISWAITING; + while (size() > requested) + { + delete_thread(back()); + pop_back(); + } +} - if (useSleepingThreads) - threads[i].wake_up(); - } - lock_release(&threadsLock); +// ThreadPool::nodes_searched() returns the number of nodes searched - // We failed to allocate even one slave, return - if (!Fake && workersCnt == 1) - return bestValue; +int64_t ThreadPool::nodes_searched() { - masterThread.splitPoint = sp; - masterThread.activeSplitPoints++; - masterThread.state = Thread::WORKISWAITING; + int64_t nodes = 0; + for (Thread *th : *this) + nodes += th->rootPos.nodes_searched(); + return nodes; +} - // Everything is set up. The master thread enters the idle loop, from - // which it will instantly launch a search, because its state is - // Thread::WORKISWAITING. We send the split point as a second parameter to - // the idle loop, which means that the main thread will return from the idle - // loop when all threads have finished their work at this split point. - masterThread.idle_loop(sp); - // In helpful master concept a master can help only a sub-tree, and - // because here is all finished is not possible master is booked. - assert(masterThread.state == Thread::AVAILABLE); +// ThreadPool::start_thinking() wakes up the main thread sleeping in +// MainThread::idle_loop() and starts a new search, then returns immediately. - // We have returned from the idle loop, which means that all threads are - // finished. Note that changing state and decreasing activeSplitPoints is done - // under lock protection to avoid a race with Thread::is_available_to(). - lock_grab(&threadsLock); +void ThreadPool::start_thinking(const Position& pos, const LimitsType& limits, + StateStackPtr& states) { + main()->join(); - masterThread.state = Thread::SEARCHING; - masterThread.activeSplitPoints--; + Signals.stopOnPonderhit = Signals.firstRootMove = false; + Signals.stop = Signals.failedLowAtRoot = false; - lock_release(&threadsLock); + main()->rootMoves.clear(); + main()->rootPos = pos; + Limits = limits; + if (states.get()) // If we don't set a new position, preserve current state + { + SetupStates = std::move(states); // Ownership transfer here + assert(!states.get()); + } - masterThread.splitPoint = sp->parent; - pos.set_nodes_searched(pos.nodes_searched() + sp->nodes); + for (const auto& m : MoveList(pos)) + if ( limits.searchmoves.empty() + || std::count(limits.searchmoves.begin(), limits.searchmoves.end(), m)) + main()->rootMoves.push_back(RootMove(m)); - return sp->bestValue; + main()->thinking = true; + main()->notify_one(); // Wake up main thread: 'thinking' must be already set } - -// Explicit template instantiations -template Value ThreadsManager::split(Position&, SearchStack*, Value, Value, Value, Depth, Move, int, MovePicker*, int); -template Value ThreadsManager::split(Position&, SearchStack*, Value, Value, Value, Depth, Move, int, MovePicker*, int);