X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fthread.cpp;h=8a8e7199d43e00c42b3c5405ea95ace53af93d40;hp=81a718df8a0ff8e691cc7431736c2fd34378cb0d;hb=57e942145c113e9d1bed7eeef5089dd22eedaad6;hpb=a189a5f0c53ec444652fdec78cff206279575bf8 diff --git a/src/thread.cpp b/src/thread.cpp index 81a718df..8a8e7199 100644 --- a/src/thread.cpp +++ b/src/thread.cpp @@ -97,15 +97,11 @@ bool Thread::is_available_to(int master) const { // 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; + int sp_count = activeSplitPoints; // 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; - - return false; + return !sp_count || (splitPoints[sp_count - 1].slavesMask & (1ULL << master)); } @@ -152,11 +148,9 @@ void ThreadsManager::set_size(int cnt) { void ThreadsManager::init() { - // Initialize sleep condition and lock used by thread manager cond_init(sleepCond); - lock_init(threadsLock); + lock_init(splitLock); - // Initialize thread's sleep conditions and split point locks for (int i = 0; i <= MAX_THREADS; i++) { lock_init(threads[i].sleepLock); @@ -190,14 +184,15 @@ void ThreadsManager::init() { void ThreadsManager::exit() { + assert(threads[0].is_searching == false); + for (int i = 0; i <= MAX_THREADS; i++) { - threads[i].do_terminate = true; // Search must be already finished + threads[i].do_exit = true; // Search must be already finished threads[i].wake_up(); thread_join(threads[i].handle); // Wait for thread termination - // Now we can safely destroy associated locks and wait conditions lock_destroy(threads[i].sleepLock); cond_destroy(threads[i].sleepCond); @@ -205,7 +200,7 @@ void ThreadsManager::exit() { lock_destroy(threads[i].splitPoints[j].lock); } - lock_destroy(threadsLock); + lock_destroy(splitLock); cond_destroy(sleepCond); } @@ -225,19 +220,6 @@ bool ThreadsManager::available_slave_exists(int master) const { } -// split_point_finished() checks if all the slave threads of a given split -// point have finished searching. - -bool ThreadsManager::split_point_finished(SplitPoint* sp) const { - - for (int i = 0; i < activeThreads; i++) - if (sp->is_slave[i]) - return false; - - return true; -} - - // 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 @@ -260,20 +242,19 @@ Value ThreadsManager::split(Position& pos, Stack* ss, Value alpha, Value beta, assert(pos.thread() >= 0 && pos.thread() < activeThreads); assert(activeThreads > 1); - int i, master = pos.thread(); + int 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 from the split point stack SplitPoint* sp = &masterThread.splitPoints[masterThread.activeSplitPoints]; - // Initialize the split point sp->parent = masterThread.splitPoint; sp->master = master; sp->is_betaCutoff = false; + sp->slavesMask = 1ULL << master; sp->depth = depth; sp->threatMove = threatMove; sp->alpha = alpha; @@ -286,66 +267,58 @@ Value ThreadsManager::split(Position& pos, Stack* ss, Value alpha, Value beta, 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.is_searching); - int workersCnt = 1; // At least the master is included + int slavesCnt = 0; // 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. - lock_grab(threadsLock); + lock_grab(splitLock); + lock_grab(sp->lock); // To protect sp->slaves_mask - for (i = 0; !Fake && i < activeThreads && workersCnt < maxThreadsPerSplitPoint; i++) + for (int i = 0; i < activeThreads && !Fake; i++) if (threads[i].is_available_to(master)) { - workersCnt++; - sp->is_slave[i] = true; + sp->slavesMask |= 1ULL << i; threads[i].splitPoint = sp; - - // This makes the slave to exit from idle_loop() - threads[i].is_searching = true; + threads[i].is_searching = true; // Slave leaves idle_loop() if (useSleepingThreads) threads[i].wake_up(); - } - - lock_release(threadsLock); - // We failed to allocate even one slave, return - if (!Fake && workersCnt == 1) - return bestValue; + if (++slavesCnt + 1 >= maxThreadsPerSplitPoint) // Master is always included + break; + } masterThread.splitPoint = sp; masterThread.activeSplitPoints++; + lock_release(sp->lock); + lock_release(splitLock); + // 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. // We pass the split point as a parameter to the idle loop, which means that // the thread will return from the idle loop when all slaves have finished // their work at this split point. - masterThread.idle_loop(sp); - - // In helpful master concept a master can help only a sub-tree of its split - // point, and because here is all finished is not possible master is booked. - assert(!masterThread.is_searching); + if (slavesCnt || Fake) + masterThread.idle_loop(sp); // 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); + // finished. Note that setting is_searching and decreasing activeSplitPoints is + // done under lock protection to avoid a race with Thread::is_available_to(). + lock_grab(splitLock); + lock_grab(sp->lock); // To protect sp->nodes masterThread.is_searching = true; masterThread.activeSplitPoints--; - - lock_release(threadsLock); - masterThread.splitPoint = sp->parent; pos.set_nodes_searched(pos.nodes_searched() + sp->nodes); + lock_release(sp->lock); + lock_release(splitLock); + return sp->bestValue; } @@ -360,7 +333,7 @@ extern void check_time(); void Thread::timer_loop() { - while (!do_terminate) + while (!do_exit) { lock_grab(sleepLock); timed_wait(sleepCond, sleepLock, maxPly ? maxPly : INT_MAX); @@ -396,7 +369,7 @@ void Thread::main_loop() { do_sleep = true; // Always return to sleep after a search is_searching = false; - while (do_sleep && !do_terminate) + while (do_sleep && !do_exit) { cond_signal(Threads.sleepCond); // Wake up UI thread if needed cond_wait(sleepCond, sleepLock); @@ -406,7 +379,7 @@ void Thread::main_loop() { lock_release(sleepLock); - if (do_terminate) + if (do_exit) return; Search::think();