Value value_from_tt(Value v, int ply);
void update_pv(Move* pv, Move move, Move* childPv);
void update_stats(const Position& pos, Stack* ss, Move move, Depth depth, Move* quiets, int quietsCnt);
+ void check_time();
} // namespace
}
}
- Threads.timer->run = true;
- Threads.timer->notify_one(); // Start the recurring timer
-
search(true); // Let's start searching!
- // Stop the threads and the timer
+ // Stop the threads
Signals.stop = true;
- Threads.timer->run = false;
// Wait until all threads have finished
for (Thread* th : Threads)
bestValue = -VALUE_INFINITE;
ss->ply = (ss-1)->ply + 1;
+ // Check for available remaining time
+ if (thisThread->resetCallsCnt.load(std::memory_order_relaxed))
+ {
+ thisThread->resetCallsCnt = false;
+ thisThread->callsCnt = 0;
+ }
+ if (++thisThread->callsCnt > 4096)
+ {
+ for (Thread* th : Threads)
+ th->resetCallsCnt = true;
+
+ check_time();
+ }
+
// Used to send selDepth info to GUI
if (PvNode && thisThread->maxPly < ss->ply)
thisThread->maxPly = ss->ply;
return best;
}
+
+ // check_time() is used to print debug info and, more importantly, to detect
+ // when we are out of available time and thus stop the search.
+
+ void check_time() {
+
+ static TimePoint lastInfoTime = now();
+
+ int elapsed = Time.elapsed();
+ TimePoint tick = Limits.startTime + elapsed;
+
+ if (tick - lastInfoTime >= 1000)
+ {
+ lastInfoTime = tick;
+ dbg_print();
+ }
+
+ // An engine may not stop pondering until told so by the GUI
+ if (Limits.ponder)
+ return;
+
+ if (Limits.use_time_management())
+ {
+ bool stillAtFirstMove = Signals.firstRootMove.load(std::memory_order_relaxed)
+ && !Signals.failedLowAtRoot.load(std::memory_order_relaxed)
+ && elapsed > Time.available() * 3 / 4;
+
+ if (stillAtFirstMove || elapsed > Time.maximum() - 10)
+ Signals.stop = true;
+ }
+ else if (Limits.movetime && elapsed >= Limits.movetime)
+ Signals.stop = true;
+
+ else if (Limits.nodes && Threads.nodes_searched() >= Limits.nodes)
+ Signals.stop = true;
+ }
+
} // namespace
return false;
}
-
-
-/// TimerThread::check_time() is called by when the timer triggers. It is used
-/// to print debug info and, more importantly, to detect when we are out of
-/// available time and thus stop the search.
-
-void TimerThread::check_time() {
-
- static TimePoint lastInfoTime = now();
- int elapsed = Time.elapsed();
-
- if (now() - lastInfoTime >= 1000)
- {
- lastInfoTime = now();
- dbg_print();
- }
-
- // An engine may not stop pondering until told so by the GUI
- if (Limits.ponder)
- return;
-
- if (Limits.use_time_management())
- {
- bool stillAtFirstMove = Signals.firstRootMove
- && !Signals.failedLowAtRoot
- && elapsed > Time.available() * 3 / 4;
-
- if ( stillAtFirstMove
- || elapsed > Time.maximum() - 2 * TimerThread::Resolution)
- Signals.stop = true;
- }
- else if (Limits.movetime && elapsed >= Limits.movetime)
- Signals.stop = true;
-
- else if (Limits.nodes && Threads.nodes_searched() >= Limits.nodes)
- Signals.stop = true;
-}
/// typically in an async fashion e.g. to stop the search by the GUI.
struct SignalsType {
- std::atomic<bool> stop, stopOnPonderhit, firstRootMove, failedLowAtRoot;
+ std::atomic_bool stop, stopOnPonderhit, firstRootMove, failedLowAtRoot;
};
typedef std::unique_ptr<std::stack<StateInfo>> StateStackPtr;
// ThreadBase::wait() set the thread to sleep until 'condition' turns true
-void ThreadBase::wait(std::atomic<bool>& condition) {
+void ThreadBase::wait(std::atomic_bool& condition) {
std::unique_lock<Mutex> lk(mutex);
sleepCondition.wait(lk, [&]{ return bool(condition); });
// ThreadBase::wait_while() set the thread to sleep until 'condition' turns false
-void ThreadBase::wait_while(std::atomic<bool>& condition) {
+void ThreadBase::wait_while(std::atomic_bool& condition) {
std::unique_lock<Mutex> lk(mutex);
sleepCondition.wait(lk, [&]{ return !condition; });
Thread::Thread() {
- searching = false;
- maxPly = 0;
+ searching = resetCallsCnt = false;
+ maxPly = callsCnt = 0;
history.clear();
counterMoves.clear();
idx = Threads.size(); // Starts from 0
}
-// TimerThread::idle_loop() is where the timer thread waits Resolution milliseconds
-// and then calls check_time(). When not searching, thread sleeps until it's woken up.
-
-void TimerThread::idle_loop() {
-
- while (!exit)
- {
- std::unique_lock<Mutex> lk(mutex);
-
- if (!exit)
- sleepCondition.wait_for(lk, std::chrono::milliseconds(run ? Resolution : INT_MAX));
-
- lk.unlock();
-
- if (!exit && run)
- check_time();
- }
-}
-
-
// Thread::idle_loop() is where the thread is parked when it has no work to do
void Thread::idle_loop() {
void ThreadPool::init() {
- timer = new_thread<TimerThread>();
push_back(new_thread<MainThread>());
read_uci_options();
}
void ThreadPool::exit() {
- delete_thread(timer); // As first because check_time() accesses threads data
- timer = nullptr;
-
for (Thread* th : *this)
delete_thread(th);
virtual ~ThreadBase() = default;
virtual void idle_loop() = 0;
void notify_one();
- void wait(std::atomic<bool>& b);
- void wait_while(std::atomic<bool>& b);
+ void wait(std::atomic_bool& b);
+ void wait_while(std::atomic_bool& b);
Mutex mutex;
ConditionVariable sleepCondition;
- std::atomic<bool> exit;
+ std::atomic_bool exit;
};
Material::Table materialTable;
Endgames endgames;
size_t idx, PVIdx;
- int maxPly;
- std::atomic<bool> searching;
+ int maxPly, callsCnt;
+ std::atomic_bool searching, resetCallsCnt;
Position rootPos;
Search::RootMoveVector rootMoves;
};
-/// MainThread and TimerThread are derived classes used to characterize the two
-/// special threads: the main one and the recurring timer.
+/// MainThread is a derived classes used to characterize the the main one
struct MainThread : public Thread {
MainThread() { thinking = true; } // Avoid a race with start_thinking()
virtual void idle_loop();
void join();
void think();
- std::atomic<bool> thinking;
-};
-
-struct TimerThread : public ThreadBase {
-
- static const int Resolution = 5; // Millisec between two check_time() calls
-
- virtual void idle_loop();
- void check_time();
-
- bool run = false;
+ std::atomic_bool thinking;
};
struct ThreadPool : public std::vector<Thread*> {
- void init(); // No constructor and destructor, threads rely on globals that should
+ void init(); // No constructor and destructor, threads rely on globals that should
void exit(); // be initialized and valid during the whole thread lifetime.
MainThread* main() { return static_cast<MainThread*>(at(0)); }
void read_uci_options();
void start_thinking(const Position&, const Search::LimitsType&, Search::StateStackPtr&);
int64_t nodes_searched();
- TimerThread* timer;
};
extern ThreadPool Threads;
projects / fairystockfish.git / commitdiff