Thread::Thread() /* : splitPoints() */ { // Initialization of non POD broken in MSVC
searching = false;
- maxPly = splitPointsSize = 0;
+ maxPly = 0;
+ splitPointsSize = 0;
activeSplitPoint = nullptr;
activePosition = nullptr;
idx = Threads.size(); // Starts from 0
// Make a local copy to be sure it doesn't become zero under our feet while
// testing next condition and so leading to an out of bounds access.
- const int size = splitPointsSize;
+ const size_t size = splitPointsSize;
// No split points means that the thread is available as a slave for any
// other thread otherwise apply the "helpful master" concept if possible.
// Pick and init the next available split point
SplitPoint& sp = splitPoints[splitPointsSize];
- sp.masterThread = this;
+ sp.master = this;
sp.parentSplitPoint = activeSplitPoint;
sp.slavesMask = 0, sp.slavesMask.set(idx);
sp.depth = depth;
// 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();
+ Threads.spinlock.acquire();
+ sp.spinlock.acquire();
sp.allSlavesSearching = true; // Must be set under lock protection
++splitPointsSize;
Thread* slave;
- while ((slave = Threads.available_slave(this)) != nullptr)
+ while ( sp.slavesMask.count() < MAX_SLAVES_PER_SPLITPOINT
+ && (slave = Threads.available_slave(this)) != nullptr)
{
sp.slavesMask.set(slave->idx);
slave->activeSplitPoint = &sp;
// it will instantly launch a search, because its 'searching' flag is set.
// The thread will return from the idle loop when all slaves have finished
// their work at this split point.
- sp.mutex.unlock();
- Threads.mutex.unlock();
+ sp.spinlock.release();
+ Threads.spinlock.release();
Thread::idle_loop(); // Force a call to base class idle_loop()
// 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.mutex.lock();
- sp.mutex.lock();
+ Threads.spinlock.acquire();
+ sp.spinlock.acquire();
searching = true;
--splitPointsSize;
*bestMove = sp.bestMove;
*bestValue = sp.bestValue;
- sp.mutex.unlock();
- Threads.mutex.unlock();
+ sp.spinlock.release();
+ Threads.spinlock.release();
}
assert(!states.get());
}
- for (const ExtMove& ms : MoveList<LEGAL>(pos))
+ for (const auto& m : MoveList<LEGAL>(pos))
if ( limits.searchmoves.empty()
- || std::count(limits.searchmoves.begin(), limits.searchmoves.end(), ms.move))
- RootMoves.push_back(RootMove(ms.move));
+ || std::count(limits.searchmoves.begin(), limits.searchmoves.end(), m))
+ RootMoves.push_back(RootMove(m));
main()->thinking = true;
main()->notify_one(); // Starts main thread