X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fthread.cpp;h=c9cce8d0c6c2240aea7b92234062d68c7361e63b;hp=42ffe63a48a2a9dbe4a4b89b7850c3a184ebde5c;hb=55bd27b8f08a151128d7065fa2819aa3e9605299;hpb=b6883c872d267cf464c575d2a901e117f6a97a84 diff --git a/src/thread.cpp b/src/thread.cpp index 42ffe63a..c9cce8d0 100644 --- a/src/thread.cpp +++ b/src/thread.cpp @@ -42,7 +42,7 @@ namespace { extern "C" { // Thread c'tor starts a newly-created thread of execution that will call // the idle loop function pointed by start_fn going immediately to sleep. -Thread::Thread(Fn fn) { +Thread::Thread(Fn fn) : splitPoints() { is_searching = do_exit = false; maxPly = splitPointsCnt = 0; @@ -114,6 +114,8 @@ void Thread::main_loop() { is_searching = true; Search::think(); + + assert(is_searching); } } @@ -194,14 +196,14 @@ void ThreadPool::init() { } -// d'tor cleanly terminates the threads when the program exits. +// exit() cleanly terminates the threads before the program exits. -ThreadPool::~ThreadPool() { +void ThreadPool::exit() { - for (size_t i = 0; i < size(); i++) - delete threads[i]; + delete timer; // As first becuase check_time() accesses threads data - delete timer; + for (size_t i = 0; i < threads.size(); i++) + delete threads[i]; } @@ -219,10 +221,10 @@ void ThreadPool::read_uci_options() { assert(requested > 0); - while (size() < requested) + while (threads.size() < requested) threads.push_back(new Thread(&Thread::idle_loop)); - while (size() > requested) + while (threads.size() > requested) { delete threads.back(); threads.pop_back(); @@ -236,7 +238,7 @@ void ThreadPool::read_uci_options() { void ThreadPool::wake_up() const { - for (size_t i = 0; i < size(); i++) + for (size_t i = 0; i < threads.size(); i++) { threads[i]->maxPly = 0; threads[i]->do_sleep = false; @@ -252,8 +254,9 @@ void ThreadPool::wake_up() const { void ThreadPool::sleep() const { - for (size_t i = 1; i < size(); i++) // Main thread will go to sleep by itself - threads[i]->do_sleep = true; // to avoid a race with start_searching() + // Main thread will go to sleep by itself to avoid a race with start_searching() + for (size_t i = 1; i < threads.size(); i++) + threads[i]->do_sleep = true; } @@ -262,7 +265,7 @@ void ThreadPool::sleep() const { bool ThreadPool::available_slave_exists(Thread* master) const { - for (size_t i = 0; i < size(); i++) + for (size_t i = 0; i < threads.size(); i++) if (threads[i]->is_available_to(master)) return true; @@ -281,8 +284,8 @@ bool ThreadPool::available_slave_exists(Thread* master) const { 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 bestValue, Move* bestMove, Depth depth, Move threatMove, + int moveCount, MovePicker& mp, int nodeType) { assert(pos.pos_is_ok()); assert(bestValue > -VALUE_INFINITE); @@ -310,7 +313,7 @@ Value ThreadPool::split(Position& pos, Stack* ss, Value alpha, Value beta, sp.beta = beta; sp.nodeType = nodeType; sp.bestValue = bestValue; - sp.mp = mp; + sp.mp = ∓ sp.moveCount = moveCount; sp.pos = &pos; sp.nodes = 0; @@ -324,10 +327,10 @@ Value ThreadPool::split(Position& pos, Stack* ss, Value alpha, Value beta, // Try to allocate available threads and ask them to start searching setting // is_searching flag. This must be done under lock protection to avoid concurrent // allocation of the same slave by another master. - sp.mutex.lock(); mutex.lock(); + sp.mutex.lock(); - for (size_t i = 0; i < size() && !Fake; ++i) + for (size_t i = 0; i < threads.size() && !Fake; ++i) if (threads[i]->is_available_to(master)) { sp.slavesMask |= 1ULL << i; @@ -343,8 +346,8 @@ Value ThreadPool::split(Position& pos, Stack* ss, Value alpha, Value beta, master->splitPointsCnt++; - mutex.unlock(); sp.mutex.unlock(); + mutex.unlock(); // Everything is set up. The master thread enters the idle loop, from which // it will instantly launch a search, because its is_searching flag is set. @@ -362,8 +365,8 @@ Value ThreadPool::split(Position& pos, Stack* ss, Value alpha, Value beta, // We have returned from the idle loop, which means that all threads are // finished. Note that setting is_searching and decreasing splitPointsCnt is // done under lock protection to avoid a race with Thread::is_available_to(). - sp.mutex.lock(); // To protect sp.nodes mutex.lock(); + sp.mutex.lock(); master->is_searching = true; master->splitPointsCnt--; @@ -371,15 +374,15 @@ Value ThreadPool::split(Position& pos, Stack* ss, Value alpha, Value beta, pos.set_nodes_searched(pos.nodes_searched() + sp.nodes); *bestMove = sp.bestMove; - mutex.unlock(); sp.mutex.unlock(); + 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 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); // set_timer() is used to set the timer to trigger after msec milliseconds. @@ -411,16 +414,17 @@ void ThreadPool::wait_for_search_finished() { // a new search, then returns immediately. void ThreadPool::start_searching(const Position& pos, const LimitsType& limits, - const std::vector& searchMoves) { + const std::vector& searchMoves, StateStackPtr& states) { wait_for_search_finished(); - SearchTime.restart(); // As early as possible + SearchTime = Time::now(); // As early as possible Signals.stopOnPonderhit = Signals.firstRootMove = false; Signals.stop = Signals.failedLowAtRoot = false; RootPosition = pos; Limits = limits; + SetupStates = states; // Ownership transfer here RootMoves.clear(); for (MoveList ml(pos); !ml.end(); ++ml)