X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fthread.cpp;h=1c5c67bacfc2b587a5bac6f6f56fd84316aaa1bf;hp=9aa0b55ef0deaafac39f430bbab900a754ba855f;hb=1a414cd9cb274d9572c60fe4067671cd993ffb36;hpb=6950d07bf421b122ccb5a15a2ed4fa3a993d9609 diff --git a/src/thread.cpp b/src/thread.cpp index 9aa0b55e..1c5c67ba 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; @@ -185,7 +186,7 @@ void ThreadPool::init() { sleepWhileIdle = true; timer = new TimerThread(); - threads.push_back(new MainThread()); + push_back(new MainThread()); read_uci_options(); } @@ -196,8 +197,8 @@ void ThreadPool::exit() { delete timer; // As first because check_time() accesses threads data - for (size_t i = 0; i < threads.size(); i++) - delete threads[i]; + for (iterator it = begin(); it != end(); ++it) + delete *it; } @@ -214,13 +215,13 @@ void ThreadPool::read_uci_options() { assert(requested > 0); - while (threads.size() < requested) - threads.push_back(new Thread()); + while (size() < requested) + push_back(new Thread()); - while (threads.size() > requested) + while (size() > requested) { - delete threads.back(); - threads.pop_back(); + delete back(); + pop_back(); } } @@ -230,8 +231,8 @@ void ThreadPool::read_uci_options() { bool ThreadPool::slave_available(Thread* master) const { - for (size_t i = 0; i < threads.size(); i++) - if (threads[i]->is_available_to(master)) + for (const_iterator it = begin(); it != end(); ++it) + if ((*it)->is_available_to(master)) return true; return false; @@ -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,29 @@ 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 + size_t slavesCnt = 1; // This thread is always included + + for (ThreadPool::iterator it = Threads.begin(); it != Threads.end() && !Fake; ++it) + { + Thread* slave = *it; - for (size_t i = 0; i < threads.size() && !Fake; ++i) - if (threads[i]->is_available_to(master) && ++slavesCnt <= maxThreadsPerSplitPoint) + if (slave->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 << slave->idx; + slave->activeSplitPoint = &sp; + slave->searching = true; // Slave leaves idle_loop() + slave->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 +314,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 +355,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 +373,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;