X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fthread.cpp;h=12a9527131b6f73bbb8f46a7b8cb6a219f2e994b;hp=9aa0b55ef0deaafac39f430bbab900a754ba855f;hb=91427c824280d71eaf27f39a4bfdd2188cbdb4ec;hpb=496c7497cb81de4383f7df42b1836af53e432ce3 diff --git a/src/thread.cpp b/src/thread.cpp index 9aa0b55e..12a95271 100644 --- a/src/thread.cpp +++ b/src/thread.cpp @@ -17,6 +17,7 @@ along with this program. If not, see . */ +#include // For std::count #include #include @@ -146,7 +147,7 @@ void Thread::wait_for(volatile const bool& b) { bool Thread::cutoff_occurred() const { - for (SplitPoint* sp = activeSplitPoint; sp; sp = sp->parent) + for (SplitPoint* sp = activeSplitPoint; sp; sp = sp->parentSplitPoint) if (sp->cutoff) return true; @@ -248,26 +249,24 @@ bool ThreadPool::slave_available(Thread* master) const { // search() then split() returns. 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 Thread::split(Position& pos, Stack* ss, Value alpha, Value beta, + Value bestValue, Move* bestMove, Depth depth, Move threatMove, + int moveCount, MovePicker& mp, int nodeType) { assert(pos.pos_is_ok()); assert(bestValue <= alpha && alpha < beta && beta <= VALUE_INFINITE); assert(bestValue > -VALUE_INFINITE); assert(depth >= Threads.minimumSplitDepth); - Thread* master = pos.this_thread(); - - assert(master->searching); - assert(master->splitPointsSize < MAX_SPLITPOINTS_PER_THREAD); + assert(searching); + assert(splitPointsSize < MAX_SPLITPOINTS_PER_THREAD); // Pick the next available split point from the split point stack - SplitPoint& sp = master->splitPoints[master->splitPointsSize]; + SplitPoint& sp = splitPoints[splitPointsSize]; - sp.master = master; - sp.parent = master->activeSplitPoint; - sp.slavesMask = 1ULL << master->idx; + sp.masterThread = this; + sp.parentSplitPoint = activeSplitPoint; + sp.slavesMask = 1ULL << idx; sp.depth = depth; sp.bestMove = *bestMove; sp.threatMove = threatMove; @@ -275,7 +274,7 @@ Value ThreadPool::split(Position& pos, Stack* ss, Value alpha, Value beta, sp.beta = beta; sp.nodeType = nodeType; sp.bestValue = bestValue; - sp.mp = ∓ + sp.movePicker = ∓ sp.moveCount = moveCount; sp.pos = &pos; sp.nodes = 0; @@ -285,25 +284,25 @@ Value ThreadPool::split(Position& pos, Stack* ss, Value alpha, Value beta, // 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. - mutex.lock(); + Threads.mutex.lock(); sp.mutex.lock(); - master->splitPointsSize++; - master->activeSplitPoint = &sp; + splitPointsSize++; + activeSplitPoint = &sp; size_t slavesCnt = 1; // Master is always included - for (size_t i = 0; i < threads.size() && !Fake; ++i) - if (threads[i]->is_available_to(master) && ++slavesCnt <= maxThreadsPerSplitPoint) + for (size_t i = 0; i < Threads.size() && !Fake; ++i) + if (Threads[i].is_available_to(this) && ++slavesCnt <= Threads.maxThreadsPerSplitPoint) { - sp.slavesMask |= 1ULL << i; - threads[i]->activeSplitPoint = &sp; - threads[i]->searching = true; // Slave leaves idle_loop() - threads[i]->notify_one(); // Could be sleeping + sp.slavesMask |= 1ULL << Threads[i].idx; + Threads[i].activeSplitPoint = &sp; + Threads[i].searching = true; // Slave leaves idle_loop() + Threads[i].notify_one(); // Could be sleeping } sp.mutex.unlock(); - mutex.unlock(); + Threads.mutex.unlock(); // Everything is set up. The master thread enters the idle loop, from which // it will instantly launch a search, because its 'searching' flag is set. @@ -311,34 +310,34 @@ Value ThreadPool::split(Position& pos, Stack* ss, Value alpha, Value beta, // their work at this split point. if (slavesCnt > 1 || Fake) { - master->Thread::idle_loop(); // Force a call to base class idle_loop() + Thread::idle_loop(); // Force a call to base class idle_loop() // 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(!master->searching); + assert(!searching); } // We have returned from the idle loop, which means that all threads are // finished. Note that setting 'searching' and decreasing splitPointsSize is // done under lock protection to avoid a race with Thread::is_available_to(). - mutex.lock(); + Threads.mutex.lock(); sp.mutex.lock(); - master->searching = true; - master->splitPointsSize--; - master->activeSplitPoint = sp.parent; + searching = true; + splitPointsSize--; + activeSplitPoint = sp.parentSplitPoint; pos.set_nodes_searched(pos.nodes_searched() + sp.nodes); *bestMove = sp.bestMove; sp.mutex.unlock(); - mutex.unlock(); + Threads.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); +template Value Thread::split(Position&, Stack*, Value, Value, Value, Move*, Depth, Move, int, MovePicker&, int); +template Value Thread::split(Position&, Stack*, Value, Value, Value, Move*, Depth, Move, int, MovePicker&, int); // wait_for_think_finished() waits for main thread to go to sleep then returns @@ -352,8 +351,8 @@ void ThreadPool::wait_for_think_finished() { } -// start_thinking() wakes up the main thread sleeping in main_loop() so to start -// a new search, then returns immediately. +// start_thinking() wakes up the main thread sleeping in MainThread::idle_loop() +// so to start a new search, then returns immediately. void ThreadPool::start_thinking(const Position& pos, const LimitsType& limits, const std::vector& searchMoves, StateStackPtr& states) { @@ -370,7 +369,8 @@ void ThreadPool::start_thinking(const Position& pos, const LimitsType& limits, RootMoves.clear(); for (MoveList ml(pos); !ml.end(); ++ml) - if (searchMoves.empty() || count(searchMoves.begin(), searchMoves.end(), ml.move())) + if ( searchMoves.empty() + || std::count(searchMoves.begin(), searchMoves.end(), ml.move())) RootMoves.push_back(RootMove(ml.move())); main_thread()->thinking = true;