X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fthread.cpp;h=b11447dfc175f41180fc3d2a265c215ad79b8372;hp=d9fa9c512c53cc1a5919ebdf2926035876b793a3;hb=81cd7d787ef2b9d914c9c09ddbed59dffb78ec77;hpb=831f91b859c43a5fa895ef0c955516ec8b7a8212 diff --git a/src/thread.cpp b/src/thread.cpp index d9fa9c51..b11447df 100644 --- a/src/thread.cpp +++ b/src/thread.cpp @@ -42,7 +42,7 @@ namespace { extern "C" { // Thread c'tor starts a newly-created thread of execution that will call // the idle loop function pointed by start_fn going immediately to sleep. -Thread::Thread(Fn fn) { +Thread::Thread(Fn fn) : splitPoints() { is_searching = do_exit = false; maxPly = splitPointsCnt = 0; @@ -67,7 +67,7 @@ Thread::~Thread() { assert(do_sleep); do_exit = true; // Search must be already finished - wake_up(); + notify_one(); thread_join(handle); // Wait for thread termination } @@ -120,10 +120,10 @@ void Thread::main_loop() { } -// Thread::wake_up() wakes up the thread, normally at the beginning of the search -// or, if "sleeping threads" is used at split time. +// Thread::notify_one() wakes up the thread, normally at the beginning of the +// search or, if "sleeping threads" is used at split time. -void Thread::wake_up() { +void Thread::notify_one() { mutex.lock(); sleepCondition.notify_one(); @@ -131,19 +131,17 @@ void Thread::wake_up() { } -// Thread::wait_for_stop_or_ponderhit() is called when the maximum depth is -// reached while the program is pondering. The point is to work around a wrinkle -// in the UCI protocol: When pondering, the engine is not allowed to give a -// "bestmove" before the GUI sends it a "stop" or "ponderhit" command. We simply -// wait here until one of these commands (that raise StopRequest) is sent and +// Thread::wait_for_stop() is called when the maximum depth is reached while +// the program is pondering. The point is to work around a wrinkle in the UCI +// protocol: When pondering, the engine is not allowed to give a "bestmove" +// before the GUI sends it a "stop" or "ponderhit" command. We simply wait here +// until one of these commands (that raise Signals.stop) is sent and // then return, after which the bestmove and pondermove will be printed. -void Thread::wait_for_stop_or_ponderhit() { - - Signals.stopOnPonderhit = true; +void Thread::wait_for_stop() { mutex.lock(); - while (!Signals.stop) sleepCondition.wait(mutex);; + while (!Signals.stop) sleepCondition.wait(mutex); mutex.unlock(); } @@ -200,10 +198,10 @@ void ThreadPool::init() { void ThreadPool::exit() { + delete timer; // As first becuase check_time() accesses threads data + for (size_t i = 0; i < threads.size(); i++) delete threads[i]; - - delete timer; } @@ -244,7 +242,7 @@ void ThreadPool::wake_up() const { threads[i]->do_sleep = false; if (!useSleepingThreads) - threads[i]->wake_up(); + threads[i]->notify_one(); } } @@ -273,6 +271,16 @@ bool ThreadPool::available_slave_exists(Thread* master) const { } +// set_timer() is used to set the timer to trigger after msec milliseconds. +// If msec is 0 then timer is stopped. + +void ThreadPool::set_timer(int msec) { + + timer->maxPly = msec; + timer->notify_one(); // Wake up and restart the timer +} + + // 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 @@ -284,8 +292,8 @@ bool ThreadPool::available_slave_exists(Thread* master) const { template Value ThreadPool::split(Position& pos, Stack* ss, Value alpha, Value beta, - Value bestValue, Move* bestMove, Depth depth, - Move threatMove, int moveCount, MovePicker* mp, int nodeType) { + Value bestValue, Move* bestMove, Depth depth, Move threatMove, + int moveCount, MovePicker& mp, int nodeType) { assert(pos.pos_is_ok()); assert(bestValue > -VALUE_INFINITE); @@ -313,7 +321,7 @@ Value ThreadPool::split(Position& pos, Stack* ss, Value alpha, Value beta, sp.beta = beta; sp.nodeType = nodeType; sp.bestValue = bestValue; - sp.mp = mp; + sp.mp = ∓ sp.moveCount = moveCount; sp.pos = &pos; sp.nodes = 0; @@ -327,8 +335,8 @@ Value ThreadPool::split(Position& pos, Stack* ss, Value alpha, Value beta, // Try to allocate available threads and ask them to start searching setting // is_searching flag. This must be done under lock protection to avoid concurrent // allocation of the same slave by another master. - sp.mutex.lock(); mutex.lock(); + sp.mutex.lock(); for (size_t i = 0; i < threads.size() && !Fake; ++i) if (threads[i]->is_available_to(master)) @@ -338,7 +346,7 @@ Value ThreadPool::split(Position& pos, Stack* ss, Value alpha, Value beta, threads[i]->is_searching = true; // Slave leaves idle_loop() if (useSleepingThreads) - threads[i]->wake_up(); + threads[i]->notify_one(); if (++slavesCnt + 1 >= maxThreadsPerSplitPoint) // Master is always included break; @@ -346,8 +354,8 @@ Value ThreadPool::split(Position& pos, Stack* ss, Value alpha, Value beta, master->splitPointsCnt++; - mutex.unlock(); sp.mutex.unlock(); + mutex.unlock(); // Everything is set up. The master thread enters the idle loop, from which // it will instantly launch a search, because its is_searching flag is set. @@ -365,8 +373,8 @@ Value ThreadPool::split(Position& pos, Stack* ss, Value alpha, Value beta, // We have returned from the idle loop, which means that all threads are // finished. Note that setting is_searching and decreasing splitPointsCnt is // done under lock protection to avoid a race with Thread::is_available_to(). - sp.mutex.lock(); // To protect sp.nodes mutex.lock(); + sp.mutex.lock(); master->is_searching = true; master->splitPointsCnt--; @@ -374,27 +382,15 @@ Value ThreadPool::split(Position& pos, Stack* ss, Value alpha, Value beta, pos.set_nodes_searched(pos.nodes_searched() + sp.nodes); *bestMove = sp.bestMove; - mutex.unlock(); sp.mutex.unlock(); + mutex.unlock(); return sp.bestValue; } // Explicit template instantiations -template Value ThreadPool::split(Position&, Stack*, Value, Value, Value, Move*, Depth, Move, int, MovePicker*, int); -template Value ThreadPool::split(Position&, Stack*, Value, Value, Value, Move*, Depth, Move, int, MovePicker*, int); - - -// set_timer() is used to set the timer to trigger after msec milliseconds. -// If msec is 0 then timer is stopped. - -void ThreadPool::set_timer(int msec) { - - timer->mutex.lock(); - timer->maxPly = msec; - timer->sleepCondition.notify_one(); // Wake up and restart the timer - timer->mutex.unlock(); -} +template Value ThreadPool::split(Position&, Stack*, Value, Value, Value, Move*, Depth, Move, int, MovePicker&, int); +template Value ThreadPool::split(Position&, Stack*, Value, Value, Value, Move*, Depth, Move, int, MovePicker&, int); // wait_for_search_finished() waits for main thread to go to sleep, this means @@ -404,7 +400,6 @@ void ThreadPool::wait_for_search_finished() { Thread* t = main_thread(); t->mutex.lock(); - t->sleepCondition.notify_one(); // In case is waiting for stop or ponderhit while (!t->do_sleep) sleepCondition.wait(t->mutex); t->mutex.unlock(); } @@ -417,12 +412,12 @@ void ThreadPool::start_searching(const Position& pos, const LimitsType& limits, const std::vector& searchMoves, StateStackPtr& states) { wait_for_search_finished(); - SearchTime = Time::current_time(); // As early as possible + SearchTime = Time::now(); // As early as possible Signals.stopOnPonderhit = Signals.firstRootMove = false; Signals.stop = Signals.failedLowAtRoot = false; - RootPosition = pos; + RootPos = pos; Limits = limits; SetupStates = states; // Ownership transfer here RootMoves.clear(); @@ -432,5 +427,5 @@ void ThreadPool::start_searching(const Position& pos, const LimitsType& limits, RootMoves.push_back(RootMove(ml.move())); main_thread()->do_sleep = false; - main_thread()->wake_up(); + main_thread()->notify_one(); }