From d156e7a20b4ea15c2cbb4bcfa2dca5f1e96ece3b Mon Sep 17 00:00:00 2001 From: Marco Costalba Date: Wed, 10 Aug 2011 12:12:10 +0100 Subject: [PATCH] Use a boolean instead as thread's state Now that we have just two mutually exclusive thread's states we can repleace them by a simple boolean. No functional change. Signed-off-by: Marco Costalba --- src/search.cpp | 12 ++++++------ src/thread.cpp | 24 ++++++++++++------------ src/thread.h | 8 +------- 3 files changed, 19 insertions(+), 25 deletions(-) diff --git a/src/search.cpp b/src/search.cpp index 65b128f5..0f2373cd 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -2154,7 +2154,7 @@ void Thread::idle_loop(SplitPoint* sp) { // instead of wasting CPU time polling for work. while ( do_sleep || do_terminate - || (Threads.use_sleeping_threads() && state == Thread::AVAILABLE)) + || (Threads.use_sleeping_threads() && !is_searching)) { assert((!sp && threadID) || Threads.use_sleeping_threads()); @@ -2180,14 +2180,14 @@ void Thread::idle_loop(SplitPoint* sp) { // particular we need to avoid a deadlock in case a master thread has, // in the meanwhile, allocated us and sent the wake_up() call before we // had the chance to grab the lock. - if (do_sleep || state == Thread::AVAILABLE) + if (do_sleep || !is_searching) cond_wait(&sleepCond, &sleepLock); lock_release(&sleepLock); } // If this thread has been assigned work, launch a search - if (state == Thread::SEARCHING) + if (is_searching) { assert(!do_terminate); @@ -2208,15 +2208,15 @@ void Thread::idle_loop(SplitPoint* sp) { else assert(false); - assert(state == Thread::SEARCHING); + assert(is_searching); - state = Thread::AVAILABLE; + is_searching = false; // Wake up master thread so to allow it to return from the idle loop in // case we are the last slave of the split point. if ( Threads.use_sleeping_threads() && threadID != tsp->master - && Threads[tsp->master].state == Thread::AVAILABLE) + && !Threads[tsp->master].is_searching) Threads[tsp->master].wake_up(); } diff --git a/src/thread.cpp b/src/thread.cpp index f620c71c..8269dcf3 100644 --- a/src/thread.cpp +++ b/src/thread.cpp @@ -84,7 +84,7 @@ bool Thread::cutoff_occurred() const { bool Thread::is_available_to(int master) const { - if (state != AVAILABLE) + if (is_searching) return false; // Make a local copy to be sure doesn't become zero under our feet while @@ -161,7 +161,7 @@ void ThreadsManager::init() { } // Initialize main thread's associated data - threads[0].state = Thread::SEARCHING; + threads[0].is_searching = true; threads[0].threadID = 0; set_size(1); // This makes all the threads but the main to go to sleep @@ -169,7 +169,7 @@ void ThreadsManager::init() { // threads will go immediately to sleep. for (int i = 1; i < MAX_THREADS; i++) { - threads[i].state = Thread::AVAILABLE; + threads[i].is_searching = false; threads[i].threadID = i; #if defined(_MSC_VER) @@ -286,7 +286,7 @@ Value ThreadsManager::split(Position& pos, SearchStack* ss, Value alpha, Value b sp->is_slave[i] = false; // If we are here it means we are not available - assert(masterThread.state == Thread::SEARCHING); + assert(masterThread.is_searching); int workersCnt = 1; // At least the master is included @@ -303,7 +303,7 @@ Value ThreadsManager::split(Position& pos, SearchStack* ss, Value alpha, Value b threads[i].splitPoint = sp; // This makes the slave to exit from idle_loop() - threads[i].state = Thread::SEARCHING; + threads[i].is_searching = true; if (useSleepingThreads) threads[i].wake_up(); @@ -318,23 +318,23 @@ Value ThreadsManager::split(Position& pos, SearchStack* ss, Value alpha, Value b masterThread.splitPoint = sp; masterThread.activeSplitPoints++; - // Everything is set up. The master thread enters the idle loop, from - // which it will instantly launch a search, because its state is - // Thread::WORKISWAITING. We send the split point as a second parameter to - // the idle loop, which means that the main thread will return from the idle - // loop when all threads have finished their work at this split point. + // 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. + // We pass the split point as a parameter to the idle loop, which means that + // the thread will return from the idle loop when all slaves have finished + // their work at this split point. masterThread.idle_loop(sp); // In helpful master concept a master can help only a sub-tree, and // because here is all finished is not possible master is booked. - assert(masterThread.state == Thread::AVAILABLE); + assert(!masterThread.is_searching); // We have returned from the idle loop, which means that all threads are // finished. Note that changing state and decreasing activeSplitPoints is done // under lock protection to avoid a race with Thread::is_available_to(). lock_grab(&threadsLock); - masterThread.state = Thread::SEARCHING; + masterThread.is_searching = true; masterThread.activeSplitPoints--; lock_release(&threadsLock); diff --git a/src/thread.h b/src/thread.h index 8d3fd615..b7d426e2 100644 --- a/src/thread.h +++ b/src/thread.h @@ -65,12 +65,6 @@ struct SplitPoint { struct Thread { - enum ThreadState - { - AVAILABLE, // Thread is waiting for work - SEARCHING // Thread is performing work - }; - void wake_up(); bool cutoff_occurred() const; bool is_available_to(int master) const; @@ -83,9 +77,9 @@ struct Thread { int maxPly; Lock sleepLock; WaitCondition sleepCond; - volatile ThreadState state; SplitPoint* volatile splitPoint; volatile int activeSplitPoints; + volatile bool is_searching; volatile bool do_sleep; volatile bool do_terminate; -- 2.39.2