mirror of
https://github.com/peterosterlund2/droidfish.git
synced 2025-12-21 05:02:17 +01:00
DroidFish: Update stockfish to version 7Beta1.
This commit is contained in:
Peter Osterlund
@@ -29,93 +29,68 @@ using namespace Search;
|
||||
|
||||
ThreadPool Threads; // Global object
|
||||
|
||||
extern void check_time();
|
||||
/// Thread constructor launch the thread and then wait until it goes to sleep
|
||||
/// in idle_loop().
|
||||
|
||||
namespace {
|
||||
Thread::Thread() {
|
||||
|
||||
// Helpers to launch a thread after creation and joining before delete. Must be
|
||||
// outside Thread c'tor and d'tor because the object must be fully initialized
|
||||
// when start_routine (and hence virtual idle_loop) is called and when joining.
|
||||
|
||||
template<typename T> T* new_thread() {
|
||||
std::thread* th = new T;
|
||||
*th = std::thread(&T::idle_loop, (T*)th); // Will go to sleep
|
||||
return (T*)th;
|
||||
}
|
||||
|
||||
void delete_thread(ThreadBase* th) {
|
||||
|
||||
th->mutex.lock();
|
||||
th->exit = true; // Search must be already finished
|
||||
th->mutex.unlock();
|
||||
|
||||
th->notify_one();
|
||||
th->join(); // Wait for thread termination
|
||||
delete th;
|
||||
}
|
||||
resetCalls = exit = false;
|
||||
maxPly = callsCnt = 0;
|
||||
history.clear();
|
||||
counterMoves.clear();
|
||||
idx = Threads.size(); // Start from 0
|
||||
|
||||
std::unique_lock<Mutex> lk(mutex);
|
||||
searching = true;
|
||||
nativeThread = std::thread(&Thread::idle_loop, this);
|
||||
sleepCondition.wait(lk, [&]{ return !searching; });
|
||||
}
|
||||
|
||||
|
||||
// ThreadBase::notify_one() wakes up the thread when there is some work to do
|
||||
/// Thread destructor wait for thread termination before returning
|
||||
|
||||
void ThreadBase::notify_one() {
|
||||
Thread::~Thread() {
|
||||
|
||||
mutex.lock();
|
||||
exit = true;
|
||||
sleepCondition.notify_one();
|
||||
mutex.unlock();
|
||||
nativeThread.join();
|
||||
}
|
||||
|
||||
|
||||
/// Thread::wait_for_search_finished() wait on sleep condition until not searching
|
||||
|
||||
void Thread::wait_for_search_finished() {
|
||||
|
||||
std::unique_lock<Mutex> lk(mutex);
|
||||
sleepCondition.wait(lk, [&]{ return !searching; });
|
||||
}
|
||||
|
||||
|
||||
/// Thread::wait() wait on sleep condition until condition is true
|
||||
|
||||
void Thread::wait(std::atomic_bool& condition) {
|
||||
|
||||
std::unique_lock<Mutex> lk(mutex);
|
||||
sleepCondition.wait(lk, [&]{ return bool(condition); });
|
||||
}
|
||||
|
||||
|
||||
/// Thread::start_searching() wake up the thread that will start the search
|
||||
|
||||
void Thread::start_searching(bool resume) {
|
||||
|
||||
std::unique_lock<Mutex> lk(mutex);
|
||||
|
||||
if (!resume)
|
||||
searching = true;
|
||||
|
||||
sleepCondition.notify_one();
|
||||
}
|
||||
|
||||
|
||||
// ThreadBase::wait() set the thread to sleep until 'condition' turns true
|
||||
|
||||
void ThreadBase::wait(volatile const bool& condition) {
|
||||
|
||||
std::unique_lock<Mutex> lk(mutex);
|
||||
sleepCondition.wait(lk, [&]{ return condition; });
|
||||
}
|
||||
|
||||
|
||||
// ThreadBase::wait_while() set the thread to sleep until 'condition' turns false
|
||||
|
||||
void ThreadBase::wait_while(volatile const bool& condition) {
|
||||
|
||||
std::unique_lock<Mutex> lk(mutex);
|
||||
sleepCondition.wait(lk, [&]{ return !condition; });
|
||||
}
|
||||
|
||||
|
||||
// Thread c'tor makes some init but does not launch any execution thread that
|
||||
// will be started only when c'tor returns.
|
||||
|
||||
Thread::Thread() /* : splitPoints() */ { // Initialization of non POD broken in MSVC
|
||||
|
||||
searching = false;
|
||||
maxPly = 0;
|
||||
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
|
||||
/// Thread::idle_loop() is where the thread is parked when it has no work to do
|
||||
|
||||
void Thread::idle_loop() {
|
||||
|
||||
@@ -123,122 +98,83 @@ void Thread::idle_loop() {
|
||||
{
|
||||
std::unique_lock<Mutex> lk(mutex);
|
||||
|
||||
searching = false;
|
||||
|
||||
while (!searching && !exit)
|
||||
sleepCondition.wait(lk);
|
||||
|
||||
lk.unlock();
|
||||
|
||||
if (!exit && searching)
|
||||
search();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// MainThread::idle_loop() is where the main thread is parked waiting to be started
|
||||
// when there is a new search. The main thread will launch all the slave threads.
|
||||
|
||||
void MainThread::idle_loop() {
|
||||
|
||||
while (!exit)
|
||||
{
|
||||
std::unique_lock<Mutex> lk(mutex);
|
||||
|
||||
thinking = false;
|
||||
|
||||
while (!thinking && !exit)
|
||||
{
|
||||
sleepCondition.notify_one(); // Wake up the UI thread if needed
|
||||
sleepCondition.notify_one(); // Wake up any waiting thread
|
||||
sleepCondition.wait(lk);
|
||||
}
|
||||
|
||||
lk.unlock();
|
||||
|
||||
if (!exit)
|
||||
think();
|
||||
search();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// MainThread::join() waits for main thread to finish thinking
|
||||
|
||||
void MainThread::join() {
|
||||
|
||||
std::unique_lock<Mutex> lk(mutex);
|
||||
sleepCondition.wait(lk, [&]{ return !thinking; });
|
||||
}
|
||||
|
||||
|
||||
// ThreadPool::init() is called at startup to create and launch requested threads,
|
||||
// that will go immediately to sleep. We cannot use a c'tor because Threads is a
|
||||
// static object and we need a fully initialized engine at this point due to
|
||||
// allocation of Endgames in Thread c'tor.
|
||||
/// ThreadPool::init() create and launch requested threads, that will go
|
||||
/// immediately to sleep. We cannot use a constructor because Threads is a
|
||||
/// static object and we need a fully initialized engine at this point due to
|
||||
/// allocation of Endgames in the Thread constructor.
|
||||
|
||||
void ThreadPool::init() {
|
||||
|
||||
timer = new_thread<TimerThread>();
|
||||
push_back(new_thread<MainThread>());
|
||||
push_back(new MainThread);
|
||||
read_uci_options();
|
||||
}
|
||||
|
||||
|
||||
// ThreadPool::exit() terminates the threads before the program exits. Cannot be
|
||||
// done in d'tor because threads must be terminated before freeing us.
|
||||
/// ThreadPool::exit() terminate threads before the program exits. Cannot be
|
||||
/// done in destructor because threads must be terminated before deleting any
|
||||
/// static objects, so while still in main().
|
||||
|
||||
void ThreadPool::exit() {
|
||||
|
||||
delete_thread(timer); // As first because check_time() accesses threads data
|
||||
timer = nullptr;
|
||||
|
||||
for (Thread* th : *this)
|
||||
delete_thread(th);
|
||||
|
||||
clear(); // Get rid of stale pointers
|
||||
while (size())
|
||||
delete back(), pop_back();
|
||||
}
|
||||
|
||||
|
||||
// ThreadPool::read_uci_options() updates internal threads parameters from the
|
||||
// corresponding UCI options and creates/destroys threads to match the requested
|
||||
// number. Thread objects are dynamically allocated to avoid creating all possible
|
||||
// threads in advance (which include pawns and material tables), even if only a
|
||||
// few are to be used.
|
||||
/// ThreadPool::read_uci_options() updates internal threads parameters from the
|
||||
/// corresponding UCI options and creates/destroys threads to match requested
|
||||
/// number. Thread objects are dynamically allocated.
|
||||
|
||||
void ThreadPool::read_uci_options() {
|
||||
|
||||
size_t requested = Options["Threads"];
|
||||
size_t requested = Options["Threads"];
|
||||
|
||||
assert(requested > 0);
|
||||
|
||||
while (size() < requested)
|
||||
push_back(new_thread<Thread>());
|
||||
push_back(new Thread);
|
||||
|
||||
while (size() > requested)
|
||||
{
|
||||
delete_thread(back());
|
||||
pop_back();
|
||||
}
|
||||
delete back(), pop_back();
|
||||
}
|
||||
|
||||
|
||||
// ThreadPool::nodes_searched() returns the number of nodes searched
|
||||
/// ThreadPool::nodes_searched() return the number of nodes searched
|
||||
|
||||
int64_t ThreadPool::nodes_searched() {
|
||||
|
||||
int64_t nodes = 0;
|
||||
for (Thread *th : *this)
|
||||
for (Thread* th : *this)
|
||||
nodes += th->rootPos.nodes_searched();
|
||||
return nodes;
|
||||
}
|
||||
|
||||
|
||||
// ThreadPool::start_thinking() wakes up the main thread sleeping in
|
||||
// MainThread::idle_loop() and starts a new search, then returns immediately.
|
||||
/// ThreadPool::start_thinking() wake up the main thread sleeping in idle_loop()
|
||||
/// and start a new search, then return immediately.
|
||||
|
||||
void ThreadPool::start_thinking(const Position& pos, const LimitsType& limits,
|
||||
StateStackPtr& states) {
|
||||
main()->join();
|
||||
|
||||
Signals.stopOnPonderhit = Signals.firstRootMove = false;
|
||||
Signals.stop = Signals.failedLowAtRoot = false;
|
||||
main()->wait_for_search_finished();
|
||||
|
||||
Signals.stopOnPonderhit = Signals.stop = false;
|
||||
|
||||
main()->rootMoves.clear();
|
||||
main()->rootPos = pos;
|
||||
@@ -254,6 +190,5 @@ void ThreadPool::start_thinking(const Position& pos, const LimitsType& limits,
|
||||
|| std::count(limits.searchmoves.begin(), limits.searchmoves.end(), m))
|
||||
main()->rootMoves.push_back(RootMove(m));
|
||||
|
||||
main()->thinking = true;
|
||||
main()->notify_one(); // Wake up main thread: 'thinking' must be already set
|
||||
main()->start_searching();
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user