1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-07-12 03:59:15 +00:00

Use thread specific mutexes instead of a global one.

This is necessary to improve the scalability with high number of cores.

There is no functional change in a single thread mode.

Resolves #281
This commit is contained in:
Joona Kiiski 2015-03-11 21:50:41 +00:00 committed by Joona Kiiski
parent 4b59347194
commit 81c7975dcd
3 changed files with 34 additions and 33 deletions

View file

@ -1526,13 +1526,12 @@ void Thread::idle_loop() {
// If this thread has been assigned work, launch a search // If this thread has been assigned work, launch a search
while (searching) while (searching)
{ {
Threads.mutex.lock(); mutex.lock();
assert(activeSplitPoint); assert(activeSplitPoint);
SplitPoint* sp = activeSplitPoint; SplitPoint* sp = activeSplitPoint;
Threads.mutex.unlock(); mutex.unlock();
Stack stack[MAX_PLY+4], *ss = stack+2; // To allow referencing (ss-2) and (ss+2) Stack stack[MAX_PLY+4], *ss = stack+2; // To allow referencing (ss-2) and (ss+2)
Position pos(*sp->pos, this); Position pos(*sp->pos, this);
@ -1618,20 +1617,24 @@ void Thread::idle_loop() {
sp = bestSp; sp = bestSp;
// Recheck the conditions under lock protection // Recheck the conditions under lock protection
Threads.mutex.lock();
sp->mutex.lock(); sp->mutex.lock();
if ( sp->allSlavesSearching if ( sp->allSlavesSearching
&& sp->slavesMask.count() < MAX_SLAVES_PER_SPLITPOINT && sp->slavesMask.count() < MAX_SLAVES_PER_SPLITPOINT)
&& can_join(sp))
{ {
sp->slavesMask.set(idx); mutex.lock();
activeSplitPoint = sp;
searching = true; if (can_join(sp))
{
sp->slavesMask.set(idx);
activeSplitPoint = sp;
searching = true;
}
mutex.unlock();
} }
sp->mutex.unlock(); sp->mutex.unlock();
Threads.mutex.unlock();
} }
} }
@ -1687,12 +1690,11 @@ void check_time() {
else if (Limits.nodes) else if (Limits.nodes)
{ {
Threads.mutex.lock();
int64_t nodes = RootPos.nodes_searched(); int64_t nodes = RootPos.nodes_searched();
// Loop across all split points and sum accumulated SplitPoint nodes plus // Loop across all split points and sum accumulated SplitPoint nodes plus
// all the currently active positions nodes. // all the currently active positions nodes.
// FIXME: Racy...
for (Thread* th : Threads) for (Thread* th : Threads)
for (size_t i = 0; i < th->splitPointsSize; ++i) for (size_t i = 0; i < th->splitPointsSize; ++i)
{ {
@ -1709,8 +1711,6 @@ void check_time() {
sp.mutex.unlock(); sp.mutex.unlock();
} }
Threads.mutex.unlock();
if (nodes >= Limits.nodes) if (nodes >= Limits.nodes)
Signals.stop = true; Signals.stop = true;
} }

View file

@ -144,6 +144,8 @@ void Thread::split(Position& pos, Stack* ss, Value alpha, Value beta, Value* bes
// Pick and init the next available split point // Pick and init the next available split point
SplitPoint& sp = splitPoints[splitPointsSize]; SplitPoint& sp = splitPoints[splitPointsSize];
sp.mutex.lock(); // No contention here until we don't increment splitPointsSize
sp.master = this; sp.master = this;
sp.parentSplitPoint = activeSplitPoint; sp.parentSplitPoint = activeSplitPoint;
sp.slavesMask = 0, sp.slavesMask.set(idx); sp.slavesMask = 0, sp.slavesMask.set(idx);
@ -160,27 +162,29 @@ void Thread::split(Position& pos, Stack* ss, Value alpha, Value beta, Value* bes
sp.nodes = 0; sp.nodes = 0;
sp.cutoff = false; sp.cutoff = false;
sp.ss = ss; 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.mutex.lock();
sp.mutex.lock();
sp.allSlavesSearching = true; // Must be set under lock protection sp.allSlavesSearching = true; // Must be set under lock protection
++splitPointsSize; ++splitPointsSize;
activeSplitPoint = &sp; activeSplitPoint = &sp;
activePosition = nullptr; activePosition = nullptr;
// Try to allocate available threads
Thread* slave; Thread* slave;
while ( sp.slavesMask.count() < MAX_SLAVES_PER_SPLITPOINT while ( sp.slavesMask.count() < MAX_SLAVES_PER_SPLITPOINT
&& (slave = Threads.available_slave(activeSplitPoint)) != nullptr) && (slave = Threads.available_slave(&sp)) != nullptr)
{ {
sp.slavesMask.set(slave->idx); slave->mutex.lock();
slave->activeSplitPoint = activeSplitPoint;
slave->searching = true; // Slave leaves idle_loop() if (slave->can_join(activeSplitPoint))
slave->notify_one(); // Could be sleeping {
activeSplitPoint->slavesMask.set(slave->idx);
slave->activeSplitPoint = activeSplitPoint;
slave->searching = true;
slave->sleepCondition.notify_one(); // Could be sleeping
}
slave->mutex.unlock();
} }
// Everything is set up. The master thread enters the idle loop, from which // Everything is set up. The master thread enters the idle loop, from which
@ -188,7 +192,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 // The thread will return from the idle loop when all slaves have finished
// their work at this split point. // their work at this split point.
sp.mutex.unlock(); sp.mutex.unlock();
Threads.mutex.unlock();
Thread::idle_loop(); // Force a call to base class idle_loop() Thread::idle_loop(); // Force a call to base class idle_loop()
@ -198,13 +201,13 @@ void Thread::split(Position& pos, Stack* ss, Value alpha, Value beta, Value* bes
assert(!searching); assert(!searching);
assert(!activePosition); assert(!activePosition);
searching = true;
// We have returned from the idle loop, which means that all threads are // We have returned from the idle loop, which means that all threads are
// finished. Note that setting 'searching' and decreasing splitPointsSize must // finished. Note that decreasing splitPointsSize must be done under lock
// be done under lock protection to avoid a race with Thread::available_to(). // protection to avoid a race with Thread::can_join().
Threads.mutex.lock();
sp.mutex.lock(); sp.mutex.lock();
searching = true;
--splitPointsSize; --splitPointsSize;
activeSplitPoint = sp.parentSplitPoint; activeSplitPoint = sp.parentSplitPoint;
activePosition = &pos; activePosition = &pos;
@ -213,7 +216,6 @@ void Thread::split(Position& pos, Stack* ss, Value alpha, Value beta, Value* bes
*bestValue = sp.bestValue; *bestValue = sp.bestValue;
sp.mutex.unlock(); sp.mutex.unlock();
Threads.mutex.unlock();
} }

View file

@ -151,7 +151,6 @@ struct ThreadPool : public std::vector<Thread*> {
void start_thinking(const Position&, const Search::LimitsType&, Search::StateStackPtr&); void start_thinking(const Position&, const Search::LimitsType&, Search::StateStackPtr&);
Depth minimumSplitDepth; Depth minimumSplitDepth;
Mutex mutex;
ConditionVariable sleepCondition; ConditionVariable sleepCondition;
TimerThread* timer; TimerThread* timer;
}; };