X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fthread.cpp;h=4b5d845bd83577992601f1306a881bdacb812d19;hp=ba5d13d5666908e45b0ad8149a51e72b4365f54a;hb=13d4df95cd4c56c0e730328648de54d9ed8bd81e;hpb=0b36ba74fc0a80388cac43a35962ffc73c01b071 diff --git a/src/thread.cpp b/src/thread.cpp index ba5d13d5..4b5d845b 100644 --- a/src/thread.cpp +++ b/src/thread.cpp @@ -61,7 +61,7 @@ namespace { void ThreadBase::notify_one() { - std::unique_lock(this->mutex); + std::unique_lock(this->mutex); sleepCondition.notify_one(); } @@ -70,7 +70,7 @@ void ThreadBase::notify_one() { void ThreadBase::wait_for(volatile const bool& condition) { - std::unique_lock lk(mutex); + std::unique_lock lk(mutex); sleepCondition.wait(lk, [&]{ return condition; }); } @@ -102,14 +102,13 @@ bool Thread::cutoff_occurred() const { } -// Thread::available_to() checks whether the thread is available to help the -// thread 'master' at a split point. An obvious requirement is that thread must -// be idle. With more than two threads, this is not sufficient: If the thread is -// the master of some split point, it is only available as a slave to the slaves -// which are busy searching the split point at the top of slave's split point -// stack (the "helpful master concept" in YBWC terminology). +// Thread::can_join() checks whether the thread is available to join the split +// point 'sp'. An obvious requirement is that thread must be idle. With more than +// two threads, this is not sufficient: If the thread is the master of some split +// point, it is only available as a slave for the split points below his active +// one (the "helpful master" concept in YBWC terminology). -bool Thread::available_to(const Thread* master) const { +bool Thread::can_join(const SplitPoint* sp) const { if (searching) return false; @@ -120,7 +119,7 @@ bool Thread::available_to(const Thread* master) const { // No split points means that the thread is available as a slave for any // other thread otherwise apply the "helpful master" concept if possible. - return !size || splitPoints[size - 1].slavesMask.test(master->idx); + return !size || splitPoints[size - 1].slavesMask.test(sp->master->idx); } @@ -145,6 +144,8 @@ void Thread::split(Position& pos, Stack* ss, Value alpha, Value beta, Value* bes // Pick and init the next available split point SplitPoint& sp = splitPoints[splitPointsSize]; + sp.spinlock.acquire(); // No contention here until we don't increment splitPointsSize + sp.master = this; sp.parentSplitPoint = activeSplitPoint; sp.slavesMask = 0, sp.slavesMask.set(idx); @@ -161,27 +162,28 @@ void Thread::split(Position& pos, Stack* ss, Value alpha, Value beta, Value* bes sp.nodes = 0; sp.cutoff = false; sp.ss = ss; - - // Try to allocate available threads and ask them to start searching setting - // 'searching' flag. This must be done under lock protection to avoid concurrent - // allocation of the same slave by another master. - Threads.spinlock.acquire(); - sp.spinlock.acquire(); - sp.allSlavesSearching = true; // Must be set under lock protection + ++splitPointsSize; activeSplitPoint = &sp; activePosition = nullptr; + // Try to allocate available threads Thread* slave; while ( sp.slavesMask.count() < MAX_SLAVES_PER_SPLITPOINT - && (slave = Threads.available_slave(this)) != nullptr) + && (slave = Threads.available_slave(&sp)) != nullptr) { - sp.slavesMask.set(slave->idx); - slave->activeSplitPoint = &sp; - slave->searching = true; // Slave leaves idle_loop() - slave->notify_one(); // Could be sleeping + slave->spinlock.acquire(); + + if (slave->can_join(activeSplitPoint)) + { + activeSplitPoint->slavesMask.set(slave->idx); + slave->activeSplitPoint = activeSplitPoint; + slave->searching = true; + } + + slave->spinlock.release(); } // Everything is set up. The master thread enters the idle loop, from which @@ -189,7 +191,6 @@ void Thread::split(Position& pos, Stack* ss, Value alpha, Value beta, Value* bes // The thread will return from the idle loop when all slaves have finished // their work at this split point. sp.spinlock.release(); - Threads.spinlock.release(); Thread::idle_loop(); // Force a call to base class idle_loop() @@ -199,13 +200,13 @@ void Thread::split(Position& pos, Stack* ss, Value alpha, Value beta, Value* bes assert(!searching); assert(!activePosition); + searching = true; + // We have returned from the idle loop, which means that all threads are - // finished. Note that setting 'searching' and decreasing splitPointsSize must - // be done under lock protection to avoid a race with Thread::available_to(). - Threads.spinlock.acquire(); + // finished. Note that decreasing splitPointsSize must be done under lock + // protection to avoid a race with Thread::can_join(). sp.spinlock.acquire(); - searching = true; --splitPointsSize; activeSplitPoint = sp.parentSplitPoint; activePosition = &pos; @@ -214,7 +215,6 @@ void Thread::split(Position& pos, Stack* ss, Value alpha, Value beta, Value* bes *bestValue = sp.bestValue; sp.spinlock.release(); - Threads.spinlock.release(); } @@ -225,7 +225,7 @@ void TimerThread::idle_loop() { while (!exit) { - std::unique_lock lk(mutex); + std::unique_lock lk(mutex); if (!exit) sleepCondition.wait_for(lk, std::chrono::milliseconds(run ? Resolution : INT_MAX)); @@ -245,7 +245,7 @@ void MainThread::idle_loop() { while (!exit) { - std::unique_lock lk(mutex); + std::unique_lock lk(mutex); thinking = false; @@ -325,12 +325,12 @@ void ThreadPool::read_uci_options() { // ThreadPool::available_slave() tries to find an idle thread which is available -// as a slave for the thread 'master'. +// to join SplitPoint 'sp'. -Thread* ThreadPool::available_slave(const Thread* master) const { +Thread* ThreadPool::available_slave(const SplitPoint* sp) const { for (Thread* th : *this) - if (th->available_to(master)) + if (th->can_join(sp)) return th; return nullptr; @@ -341,7 +341,7 @@ Thread* ThreadPool::available_slave(const Thread* master) const { void ThreadPool::wait_for_think_finished() { - std::unique_lock lk(main()->mutex); + std::unique_lock lk(main()->mutex); sleepCondition.wait(lk, [&]{ return !main()->thinking; }); } @@ -373,5 +373,7 @@ void ThreadPool::start_thinking(const Position& pos, const LimitsType& limits, RootMoves.push_back(RootMove(m)); main()->thinking = true; - main()->notify_one(); // Starts main thread + + for (Thread* th : *this) + th->notify_one(); }