bool thread_is_available(int slave, int master) const;
bool thread_should_stop(int threadID) const;
void wake_sleeping_thread(int threadID);
- void put_threads_to_sleep();
void idle_loop(int threadID, SplitPoint* sp);
template <bool Fake>
friend void poll();
int ActiveThreads;
- volatile bool AllThreadsShouldExit, AllThreadsShouldSleep;
+ volatile bool AllThreadsShouldExit;
Thread threads[MAX_THREADS];
-
- Lock MPLock, WaitLock;
-
-#if !defined(_MSC_VER)
- pthread_cond_t WaitCond[MAX_THREADS];
-#else
- HANDLE SitIdleEvent[MAX_THREADS];
-#endif
-
+ Lock MPLock;
+ WaitCondition WaitCond[MAX_THREADS];
};
init_eval(ThreadsMgr.active_threads());
}
- // Wake up needed threads
- for (int i = 1; i < newActiveThreads; i++)
- ThreadsMgr.wake_sleeping_thread(i);
-
// Set thinking time
int myTime = time[pos.side_to_move()];
int myIncrement = increment[pos.side_to_move()];
if (UseLogFile)
LogFile.close();
- ThreadsMgr.put_threads_to_sleep();
-
return !Quit;
}
// If we are not thinking, wait for a condition to be signaled
// instead of wasting CPU time polling for work.
- while (AllThreadsShouldSleep || threadID >= ActiveThreads)
+ while ( threadID >= ActiveThreads
+ || threads[threadID].state == THREAD_INITIALIZING
+ || (!sp && threads[threadID].state == THREAD_AVAILABLE))
{
assert(!sp);
assert(threadID != 0);
- threads[threadID].state = THREAD_SLEEPING;
-#if !defined(_MSC_VER)
- lock_grab(&WaitLock);
- if (AllThreadsShouldSleep || threadID >= ActiveThreads)
- pthread_cond_wait(&WaitCond[threadID], &WaitLock);
- lock_release(&WaitLock);
-#else
- WaitForSingleObject(SitIdleEvent[threadID], INFINITE);
-#endif
- }
+ if (AllThreadsShouldExit)
+ break;
- // If thread has just woken up, mark it as available
- if (threads[threadID].state == THREAD_SLEEPING)
+ lock_grab(&MPLock);
+
+ // Retest condition under lock protection
+ if (!( threadID >= ActiveThreads
+ || threads[threadID].state == THREAD_INITIALIZING
+ || (!sp && threads[threadID].state == THREAD_AVAILABLE)))
+ {
+ lock_release(&MPLock);
+ continue;
+ }
+
+ // Put thread to sleep
threads[threadID].state = THREAD_AVAILABLE;
+ cond_wait(&WaitCond[threadID], &MPLock);
+ lock_release(&MPLock);
+ }
// If this thread has been assigned work, launch a search
if (threads[threadID].state == THREAD_WORKISWAITING)
{
- assert(!AllThreadsShouldExit && !AllThreadsShouldSleep);
+ assert(!AllThreadsShouldExit);
threads[threadID].state = THREAD_SEARCHING;
volatile int i;
bool ok;
-#if !defined(_MSC_VER)
- pthread_t pthread[1];
-#endif
-
// Initialize global locks
lock_init(&MPLock);
- lock_init(&WaitLock);
for (i = 0; i < MAX_THREADS; i++)
-#if !defined(_MSC_VER)
- pthread_cond_init(&WaitCond[i], NULL);
-#else
- SitIdleEvent[i] = CreateEvent(0, FALSE, FALSE, 0);
-#endif
+ cond_init(&WaitCond[i]);
// Initialize splitPoints[] locks
for (i = 0; i < MAX_THREADS; i++)
// Will be set just before program exits to properly end the threads
AllThreadsShouldExit = false;
- // Threads will be put to sleep as soon as created
- AllThreadsShouldSleep = true;
-
- // All threads except the main thread should be initialized to THREAD_AVAILABLE
+ // Threads will be put all threads to sleep as soon as created
ActiveThreads = 1;
+
+ // All threads except the main thread should be initialized to THREAD_INITIALIZING
threads[0].state = THREAD_SEARCHING;
for (i = 1; i < MAX_THREADS; i++)
- threads[i].state = THREAD_AVAILABLE;
+ threads[i].state = THREAD_INITIALIZING;
// Launch the helper threads
for (i = 1; i < MAX_THREADS; i++)
{
#if !defined(_MSC_VER)
+ pthread_t pthread[1];
ok = (pthread_create(pthread, NULL, init_thread, (void*)(&i)) == 0);
#else
ok = (CreateThread(NULL, 0, init_thread, (LPVOID)(&i), 0, NULL) != NULL);
}
// Wait until the thread has finished launching and is gone to sleep
- while (threads[i].state != THREAD_SLEEPING) {}
+ while (threads[i].state == THREAD_INITIALIZING) {}
}
}
void ThreadsManager::exit_threads() {
AllThreadsShouldExit = true; // Let the woken up threads to exit idle_loop()
- ActiveThreads = MAX_THREADS; // Avoid any woken up thread comes back to sleep
// Wake up all the threads and waits for termination
for (int i = 1; i < MAX_THREADS; i++)
for (int j = 0; j < MAX_ACTIVE_SPLIT_POINTS; j++)
lock_destroy(&(threads[i].splitPoints[j].lock));
- lock_destroy(&WaitLock);
lock_destroy(&MPLock);
+
+ // Now we can safely destroy the wait conditions
+ for (int i = 0; i < MAX_THREADS; i++)
+ cond_destroy(&WaitCond[i]);
}
assert(i == master || threads[i].state == THREAD_BOOKED);
threads[i].state = THREAD_WORKISWAITING; // This makes the slave to exit from idle_loop()
+ if (i != master)
+ wake_sleeping_thread(i);
}
// Everything is set up. The master thread enters the idle loop, from
void ThreadsManager::wake_sleeping_thread(int threadID) {
- assert(threadID > 0);
- assert(threads[threadID].state == THREAD_SLEEPING);
-
- AllThreadsShouldSleep = false; // Avoid the woken up thread comes back to sleep
-
-#if !defined(_MSC_VER)
- pthread_mutex_lock(&WaitLock);
- pthread_cond_signal(&WaitCond[threadID]);
- pthread_mutex_unlock(&WaitLock);
-#else
- SetEvent(SitIdleEvent[threadID]);
-#endif
+ lock_grab(&MPLock);
+ cond_signal(&WaitCond[threadID]);
+ lock_release(&MPLock);
}
- // put_threads_to_sleep() makes all the threads go to sleep just before
- // to leave think(), at the end of the search. Threads should have already
- // finished the job and should be idle.
-
- void ThreadsManager::put_threads_to_sleep() {
-
- assert(!AllThreadsShouldSleep || ActiveThreads == 1);
-
- // This makes the threads to go to sleep
- AllThreadsShouldSleep = true;
- }
-
/// The RootMoveList class
// RootMoveList c'tor
projects / stockfish / blobdiff