2011-04-24 02:20:03 -06:00
|
|
|
/*
|
|
|
|
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
|
|
|
|
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
|
2011-12-30 05:24:41 -07:00
|
|
|
Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
|
2011-04-24 02:20:03 -06:00
|
|
|
|
|
|
|
Stockfish is free software: you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
Stockfish is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
2012-01-16 13:20:13 -07:00
|
|
|
#include <cassert>
|
2011-04-24 02:20:03 -06:00
|
|
|
#include <iostream>
|
|
|
|
|
2012-01-14 05:49:25 -07:00
|
|
|
#include "movegen.h"
|
2011-11-05 04:19:21 -06:00
|
|
|
#include "search.h"
|
2011-04-24 02:20:03 -06:00
|
|
|
#include "thread.h"
|
|
|
|
#include "ucioption.h"
|
|
|
|
|
2011-12-04 03:46:31 -07:00
|
|
|
using namespace Search;
|
|
|
|
|
2011-11-28 07:54:40 -07:00
|
|
|
ThreadsManager Threads; // Global object
|
2011-04-24 02:20:03 -06:00
|
|
|
|
2011-04-29 02:07:23 -06:00
|
|
|
namespace { extern "C" {
|
2011-04-24 02:20:03 -06:00
|
|
|
|
2011-04-29 02:07:23 -06:00
|
|
|
// start_routine() is the C function which is called when a new thread
|
2011-11-28 07:54:40 -07:00
|
|
|
// is launched. It simply calls idle_loop() of the supplied thread. The first
|
|
|
|
// and last thread are special. First one is the main search thread while the
|
|
|
|
// last one mimics a timer, they run in main_loop() and timer_loop().
|
2011-04-24 02:20:03 -06:00
|
|
|
|
2012-03-23 06:12:26 -06:00
|
|
|
long start_routine(Thread* th) {
|
2011-11-28 07:54:40 -07:00
|
|
|
|
|
|
|
if (th->threadID == 0)
|
|
|
|
th->main_loop();
|
|
|
|
|
|
|
|
else if (th->threadID == MAX_THREADS)
|
|
|
|
th->timer_loop();
|
2011-11-05 04:19:21 -06:00
|
|
|
|
2011-11-05 00:53:19 -06:00
|
|
|
else
|
2011-11-28 07:54:40 -07:00
|
|
|
th->idle_loop(NULL);
|
2011-04-24 02:20:03 -06:00
|
|
|
|
2011-11-05 00:53:19 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2011-04-24 02:20:03 -06:00
|
|
|
|
2011-04-29 02:07:23 -06:00
|
|
|
} }
|
2011-04-24 02:20:03 -06:00
|
|
|
|
|
|
|
|
2012-02-03 08:07:13 -07:00
|
|
|
// Thread::timer_loop() is where the timer thread waits maxPly milliseconds and
|
|
|
|
// then calls do_timer_event(). If maxPly is 0 thread sleeps until is woken up.
|
|
|
|
extern void check_time();
|
|
|
|
|
|
|
|
void Thread::timer_loop() {
|
|
|
|
|
|
|
|
while (!do_exit)
|
|
|
|
{
|
|
|
|
lock_grab(sleepLock);
|
|
|
|
timed_wait(sleepCond, sleepLock, maxPly ? maxPly : INT_MAX);
|
|
|
|
lock_release(sleepLock);
|
|
|
|
check_time();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Thread::main_loop() is where the main thread is parked waiting to be started
|
|
|
|
// when there is a new search. Main thread will launch all the slave threads.
|
|
|
|
|
|
|
|
void Thread::main_loop() {
|
|
|
|
|
|
|
|
while (true)
|
|
|
|
{
|
|
|
|
lock_grab(sleepLock);
|
|
|
|
|
|
|
|
do_sleep = true; // Always return to sleep after a search
|
|
|
|
is_searching = false;
|
|
|
|
|
|
|
|
while (do_sleep && !do_exit)
|
|
|
|
{
|
|
|
|
cond_signal(Threads.sleepCond); // Wake up UI thread if needed
|
|
|
|
cond_wait(sleepCond, sleepLock);
|
|
|
|
}
|
|
|
|
|
|
|
|
lock_release(sleepLock);
|
|
|
|
|
|
|
|
if (do_exit)
|
|
|
|
return;
|
|
|
|
|
|
|
|
is_searching = true;
|
|
|
|
|
|
|
|
Search::think();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Thread::wake_up() wakes up the thread, normally at the beginning of the search
|
|
|
|
// or, if "sleeping threads" is used, when there is some work to do.
|
2011-04-24 17:22:48 -06:00
|
|
|
|
|
|
|
void Thread::wake_up() {
|
|
|
|
|
2012-01-23 07:20:53 -07:00
|
|
|
lock_grab(sleepLock);
|
|
|
|
cond_signal(sleepCond);
|
|
|
|
lock_release(sleepLock);
|
2011-04-24 17:22:48 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-03 08:07:13 -07:00
|
|
|
// Thread::wait_for_stop_or_ponderhit() is called when the maximum depth is
|
|
|
|
// reached while the program is pondering. The point is to work around a wrinkle
|
|
|
|
// in the UCI protocol: When pondering, the engine is not allowed to give a
|
|
|
|
// "bestmove" before the GUI sends it a "stop" or "ponderhit" command. We simply
|
|
|
|
// wait here until one of these commands (that raise StopRequest) is sent and
|
|
|
|
// then return, after which the bestmove and pondermove will be printed.
|
|
|
|
|
|
|
|
void Thread::wait_for_stop_or_ponderhit() {
|
|
|
|
|
|
|
|
Signals.stopOnPonderhit = true;
|
|
|
|
|
|
|
|
lock_grab(sleepLock);
|
|
|
|
|
|
|
|
while (!Signals.stop)
|
|
|
|
cond_wait(sleepCond, sleepLock);
|
|
|
|
|
|
|
|
lock_release(sleepLock);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-08-09 14:08:55 -06:00
|
|
|
// cutoff_occurred() checks whether a beta cutoff has occurred in the current
|
|
|
|
// active split point, or in some ancestor of the split point.
|
2011-04-24 17:22:48 -06:00
|
|
|
|
|
|
|
bool Thread::cutoff_occurred() const {
|
|
|
|
|
2012-02-18 02:57:00 -07:00
|
|
|
for (SplitPoint* sp = curSplitPoint; sp; sp = sp->parent)
|
2012-02-03 08:07:13 -07:00
|
|
|
if (sp->cutoff)
|
2011-04-24 17:22:48 -06:00
|
|
|
return true;
|
2011-11-28 07:54:40 -07:00
|
|
|
|
2011-04-24 17:22:48 -06:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// is_available_to() checks whether the thread is available to help the thread with
|
|
|
|
// threadID "master" at a split point. An obvious requirement is that thread must be
|
|
|
|
// idle. With more than two threads, this is not by itself sufficient: If the thread
|
|
|
|
// is the master of some active split point, it is only available as a slave to the
|
|
|
|
// threads which are busy searching the split point at the top of "slave"'s split
|
|
|
|
// point stack (the "helpful master concept" in YBWC terminology).
|
|
|
|
|
|
|
|
bool Thread::is_available_to(int master) const {
|
|
|
|
|
2011-08-10 05:12:10 -06:00
|
|
|
if (is_searching)
|
2011-04-24 17:22:48 -06:00
|
|
|
return false;
|
|
|
|
|
|
|
|
// Make a local copy to be sure doesn't become zero under our feet while
|
|
|
|
// testing next condition and so leading to an out of bound access.
|
2012-02-18 02:57:00 -07:00
|
|
|
int spCnt = splitPointsCnt;
|
2011-04-24 17:22:48 -06:00
|
|
|
|
|
|
|
// No active split points means that the thread is available as a slave for any
|
|
|
|
// other thread otherwise apply the "helpful master" concept if possible.
|
2012-02-18 02:57:00 -07:00
|
|
|
return !spCnt || (splitPoints[spCnt - 1].slavesMask & (1ULL << master));
|
2011-04-24 17:22:48 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-12 06:07:21 -07:00
|
|
|
// read_uci_options() updates internal threads parameters from the corresponding
|
|
|
|
// UCI options. It is called before to start a new search.
|
2011-04-24 02:20:03 -06:00
|
|
|
|
|
|
|
void ThreadsManager::read_uci_options() {
|
|
|
|
|
2011-12-28 10:27:18 -07:00
|
|
|
maxThreadsPerSplitPoint = Options["Max Threads per Split Point"];
|
|
|
|
minimumSplitDepth = Options["Min Split Depth"] * ONE_PLY;
|
|
|
|
useSleepingThreads = Options["Use Sleeping Threads"];
|
2011-08-08 05:03:16 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// set_size() changes the number of active threads and raises do_sleep flag for
|
|
|
|
// all the unused threads that will go immediately to sleep.
|
|
|
|
|
|
|
|
void ThreadsManager::set_size(int cnt) {
|
|
|
|
|
2012-02-12 06:07:21 -07:00
|
|
|
assert(cnt > 0 && cnt < MAX_THREADS);
|
2011-08-08 05:03:16 -06:00
|
|
|
|
|
|
|
activeThreads = cnt;
|
|
|
|
|
2012-02-12 06:07:21 -07:00
|
|
|
for (int i = 0; i < MAX_THREADS; i++)
|
2011-08-08 16:07:09 -06:00
|
|
|
if (i < activeThreads)
|
|
|
|
{
|
|
|
|
// Dynamically allocate pawn and material hash tables according to the
|
|
|
|
// number of active threads. This avoids preallocating memory for all
|
2011-11-28 07:54:40 -07:00
|
|
|
// possible threads if only few are used.
|
2011-08-08 16:07:09 -06:00
|
|
|
threads[i].pawnTable.init();
|
|
|
|
threads[i].materialTable.init();
|
2012-02-12 06:07:21 -07:00
|
|
|
threads[i].maxPly = 0;
|
2011-08-08 16:07:09 -06:00
|
|
|
|
|
|
|
threads[i].do_sleep = false;
|
2012-02-12 06:07:21 -07:00
|
|
|
|
|
|
|
if (!useSleepingThreads)
|
|
|
|
threads[i].wake_up();
|
2011-08-08 16:07:09 -06:00
|
|
|
}
|
|
|
|
else
|
|
|
|
threads[i].do_sleep = true;
|
2011-04-24 02:20:03 -06:00
|
|
|
}
|
|
|
|
|
2011-04-24 11:46:26 -06:00
|
|
|
|
2011-04-29 02:07:23 -06:00
|
|
|
// init() is called during startup. Initializes locks and condition variables
|
|
|
|
// and launches all threads sending them immediately to sleep.
|
2011-04-24 02:20:03 -06:00
|
|
|
|
2011-04-24 17:22:48 -06:00
|
|
|
void ThreadsManager::init() {
|
2011-04-24 02:20:03 -06:00
|
|
|
|
2012-03-04 09:57:01 -07:00
|
|
|
read_uci_options();
|
|
|
|
|
2012-01-23 07:20:53 -07:00
|
|
|
cond_init(sleepCond);
|
2012-01-30 06:09:20 -07:00
|
|
|
lock_init(splitLock);
|
2011-04-24 02:20:03 -06:00
|
|
|
|
2011-11-28 07:54:40 -07:00
|
|
|
// Allocate main thread tables to call evaluate() also when not searching
|
2011-11-23 12:07:29 -07:00
|
|
|
threads[0].pawnTable.init();
|
|
|
|
threads[0].materialTable.init();
|
2011-08-09 14:08:55 -06:00
|
|
|
|
2011-11-23 12:07:29 -07:00
|
|
|
// Create and launch all the threads, threads will go immediately to sleep
|
|
|
|
for (int i = 0; i <= MAX_THREADS; i++)
|
2011-04-24 02:20:03 -06:00
|
|
|
{
|
2011-08-10 05:12:10 -06:00
|
|
|
threads[i].is_searching = false;
|
2012-01-03 13:13:29 -07:00
|
|
|
threads[i].do_sleep = (i != 0); // Avoid a race with start_thinking()
|
2011-08-08 05:03:16 -06:00
|
|
|
threads[i].threadID = i;
|
2011-04-24 02:20:03 -06:00
|
|
|
|
2012-03-22 15:39:10 -06:00
|
|
|
lock_init(threads[i].sleepLock);
|
|
|
|
cond_init(threads[i].sleepCond);
|
|
|
|
|
|
|
|
for (int j = 0; j < MAX_SPLITPOINTS_PER_THREAD; j++)
|
|
|
|
lock_init(threads[i].splitPoints[j].lock);
|
|
|
|
|
2012-01-24 22:29:30 -07:00
|
|
|
if (!thread_create(threads[i].handle, start_routine, threads[i]))
|
2011-04-24 02:20:03 -06:00
|
|
|
{
|
2011-08-09 07:19:44 -06:00
|
|
|
std::cerr << "Failed to create thread number " << i << std::endl;
|
2011-04-24 17:22:48 -06:00
|
|
|
::exit(EXIT_FAILURE);
|
2011-04-24 02:20:03 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-08-08 03:53:52 -06:00
|
|
|
// exit() is called to cleanly terminate the threads when the program finishes
|
2011-04-24 02:20:03 -06:00
|
|
|
|
2011-04-24 17:22:48 -06:00
|
|
|
void ThreadsManager::exit() {
|
2011-04-24 02:20:03 -06:00
|
|
|
|
2011-11-23 12:07:29 -07:00
|
|
|
for (int i = 0; i <= MAX_THREADS; i++)
|
2011-04-24 02:20:03 -06:00
|
|
|
{
|
2012-02-03 08:07:13 -07:00
|
|
|
assert(threads[i].do_sleep);
|
|
|
|
|
2012-01-26 15:18:43 -07:00
|
|
|
threads[i].do_exit = true; // Search must be already finished
|
2011-11-23 12:07:29 -07:00
|
|
|
threads[i].wake_up();
|
2011-11-05 00:53:19 -06:00
|
|
|
|
2012-01-23 07:20:53 -07:00
|
|
|
thread_join(threads[i].handle); // Wait for thread termination
|
2011-04-24 02:20:03 -06:00
|
|
|
|
2012-01-23 07:20:53 -07:00
|
|
|
lock_destroy(threads[i].sleepLock);
|
|
|
|
cond_destroy(threads[i].sleepCond);
|
2011-04-24 02:20:03 -06:00
|
|
|
|
2012-02-18 02:57:00 -07:00
|
|
|
for (int j = 0; j < MAX_SPLITPOINTS_PER_THREAD; j++)
|
2012-01-23 07:20:53 -07:00
|
|
|
lock_destroy(threads[i].splitPoints[j].lock);
|
2011-04-24 02:20:03 -06:00
|
|
|
}
|
|
|
|
|
2012-01-30 06:09:20 -07:00
|
|
|
lock_destroy(splitLock);
|
2012-01-23 07:20:53 -07:00
|
|
|
cond_destroy(sleepCond);
|
2011-04-24 02:20:03 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-04-24 17:22:48 -06:00
|
|
|
// available_slave_exists() tries to find an idle thread which is available as
|
2011-11-28 07:54:40 -07:00
|
|
|
// a slave for the thread with threadID 'master'.
|
2011-04-24 02:20:03 -06:00
|
|
|
|
2011-04-24 17:22:48 -06:00
|
|
|
bool ThreadsManager::available_slave_exists(int master) const {
|
2011-04-24 02:20:03 -06:00
|
|
|
|
|
|
|
assert(master >= 0 && master < activeThreads);
|
|
|
|
|
|
|
|
for (int i = 0; i < activeThreads; i++)
|
2011-11-28 07:54:40 -07:00
|
|
|
if (threads[i].is_available_to(master))
|
2011-04-24 02:20:03 -06:00
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// split() does the actual work of distributing the work at a node between
|
2011-11-28 07:54:40 -07:00
|
|
|
// several available threads. If it does not succeed in splitting the node
|
|
|
|
// (because no idle threads are available, or because we have no unused split
|
|
|
|
// point objects), the function immediately returns. If splitting is possible, a
|
|
|
|
// SplitPoint object is initialized with all the data that must be copied to the
|
|
|
|
// helper threads and then helper threads are told that they have been assigned
|
|
|
|
// work. This will cause them to instantly leave their idle loops and call
|
|
|
|
// search(). When all threads have returned from search() then split() returns.
|
2011-04-24 02:20:03 -06:00
|
|
|
|
|
|
|
template <bool Fake>
|
2011-12-04 03:46:31 -07:00
|
|
|
Value ThreadsManager::split(Position& pos, Stack* ss, Value alpha, Value beta,
|
2012-02-20 06:21:25 -07:00
|
|
|
Value bestValue, Move* bestMove, Depth depth,
|
2012-03-23 06:12:26 -06:00
|
|
|
Move threatMove, int moveCount, MovePicker* mp, int nodeType) {
|
2011-10-16 16:56:25 -06:00
|
|
|
assert(pos.pos_is_ok());
|
2011-12-08 11:12:17 -07:00
|
|
|
assert(bestValue > -VALUE_INFINITE);
|
2011-08-07 02:24:40 -06:00
|
|
|
assert(bestValue <= alpha);
|
|
|
|
assert(alpha < beta);
|
2011-04-24 02:20:03 -06:00
|
|
|
assert(beta <= VALUE_INFINITE);
|
|
|
|
assert(depth > DEPTH_ZERO);
|
|
|
|
assert(pos.thread() >= 0 && pos.thread() < activeThreads);
|
|
|
|
assert(activeThreads > 1);
|
|
|
|
|
2012-01-30 06:09:20 -07:00
|
|
|
int master = pos.thread();
|
2011-04-24 02:20:03 -06:00
|
|
|
Thread& masterThread = threads[master];
|
|
|
|
|
2012-02-18 02:57:00 -07:00
|
|
|
if (masterThread.splitPointsCnt >= MAX_SPLITPOINTS_PER_THREAD)
|
2011-08-07 02:24:40 -06:00
|
|
|
return bestValue;
|
2011-04-24 02:20:03 -06:00
|
|
|
|
2011-11-28 07:54:40 -07:00
|
|
|
// Pick the next available split point from the split point stack
|
2012-02-19 02:32:06 -07:00
|
|
|
SplitPoint* sp = &masterThread.splitPoints[masterThread.splitPointsCnt++];
|
2011-04-24 02:20:03 -06:00
|
|
|
|
2012-02-18 02:57:00 -07:00
|
|
|
sp->parent = masterThread.curSplitPoint;
|
2011-08-08 03:53:52 -06:00
|
|
|
sp->master = master;
|
2012-02-03 08:07:13 -07:00
|
|
|
sp->cutoff = false;
|
2012-01-30 06:09:20 -07:00
|
|
|
sp->slavesMask = 1ULL << master;
|
2011-08-08 03:53:52 -06:00
|
|
|
sp->depth = depth;
|
2012-02-20 06:21:25 -07:00
|
|
|
sp->bestMove = *bestMove;
|
2011-08-08 03:53:52 -06:00
|
|
|
sp->threatMove = threatMove;
|
|
|
|
sp->alpha = alpha;
|
|
|
|
sp->beta = beta;
|
|
|
|
sp->nodeType = nodeType;
|
|
|
|
sp->bestValue = bestValue;
|
|
|
|
sp->mp = mp;
|
|
|
|
sp->moveCount = moveCount;
|
|
|
|
sp->pos = &pos;
|
|
|
|
sp->nodes = 0;
|
|
|
|
sp->ss = ss;
|
2011-11-28 07:54:40 -07:00
|
|
|
|
2011-08-10 05:12:10 -06:00
|
|
|
assert(masterThread.is_searching);
|
2011-08-06 12:11:35 -06:00
|
|
|
|
2012-02-19 02:32:06 -07:00
|
|
|
masterThread.curSplitPoint = sp;
|
2012-01-30 06:09:20 -07:00
|
|
|
int slavesCnt = 0;
|
2011-04-24 02:20:03 -06:00
|
|
|
|
2011-08-07 12:56:53 -06:00
|
|
|
// Try to allocate available threads and ask them to start searching setting
|
2011-11-28 07:54:40 -07:00
|
|
|
// is_searching flag. This must be done under lock protection to avoid concurrent
|
|
|
|
// allocation of the same slave by another master.
|
2012-02-03 05:18:51 -07:00
|
|
|
lock_grab(sp->lock);
|
2012-01-30 06:09:20 -07:00
|
|
|
lock_grab(splitLock);
|
2011-04-24 02:20:03 -06:00
|
|
|
|
2012-01-30 06:09:20 -07:00
|
|
|
for (int i = 0; i < activeThreads && !Fake; i++)
|
2011-11-28 07:54:40 -07:00
|
|
|
if (threads[i].is_available_to(master))
|
2011-04-24 02:20:03 -06:00
|
|
|
{
|
2012-01-30 06:09:20 -07:00
|
|
|
sp->slavesMask |= 1ULL << i;
|
2012-02-18 02:57:00 -07:00
|
|
|
threads[i].curSplitPoint = sp;
|
2012-01-30 06:09:20 -07:00
|
|
|
threads[i].is_searching = true; // Slave leaves idle_loop()
|
2011-08-07 12:56:53 -06:00
|
|
|
|
|
|
|
if (useSleepingThreads)
|
|
|
|
threads[i].wake_up();
|
2012-01-26 15:18:43 -07:00
|
|
|
|
2012-01-30 06:09:20 -07:00
|
|
|
if (++slavesCnt + 1 >= maxThreadsPerSplitPoint) // Master is always included
|
2012-01-26 15:18:43 -07:00
|
|
|
break;
|
2011-04-24 02:20:03 -06:00
|
|
|
}
|
|
|
|
|
2012-01-30 06:09:20 -07:00
|
|
|
lock_release(splitLock);
|
2012-02-03 05:18:51 -07:00
|
|
|
lock_release(sp->lock);
|
2012-01-30 06:09:20 -07:00
|
|
|
|
2011-08-10 05:12:10 -06:00
|
|
|
// 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.
|
2012-01-30 06:09:20 -07:00
|
|
|
if (slavesCnt || Fake)
|
2012-02-19 02:32:06 -07:00
|
|
|
{
|
2012-01-30 06:09:20 -07:00
|
|
|
masterThread.idle_loop(sp);
|
2011-04-24 02:20:03 -06:00
|
|
|
|
2012-02-19 02:32:06 -07:00
|
|
|
// In helpful master concept a master can help only a sub-tree of its split
|
|
|
|
// point, and because here is all finished is not possible master is booked.
|
|
|
|
assert(!masterThread.is_searching);
|
|
|
|
}
|
|
|
|
|
2011-04-24 02:20:03 -06:00
|
|
|
// We have returned from the idle loop, which means that all threads are
|
2012-02-19 02:32:06 -07:00
|
|
|
// finished. Note that setting is_searching and decreasing splitPointsCnt is
|
2012-01-30 06:09:20 -07:00
|
|
|
// done under lock protection to avoid a race with Thread::is_available_to().
|
2012-01-26 15:18:43 -07:00
|
|
|
lock_grab(sp->lock); // To protect sp->nodes
|
2012-02-03 05:18:51 -07:00
|
|
|
lock_grab(splitLock);
|
2012-01-26 15:18:43 -07:00
|
|
|
|
2011-08-10 05:12:10 -06:00
|
|
|
masterThread.is_searching = true;
|
2012-02-18 02:57:00 -07:00
|
|
|
masterThread.splitPointsCnt--;
|
|
|
|
masterThread.curSplitPoint = sp->parent;
|
2011-08-08 03:53:52 -06:00
|
|
|
pos.set_nodes_searched(pos.nodes_searched() + sp->nodes);
|
2012-02-20 06:21:25 -07:00
|
|
|
*bestMove = sp->bestMove;
|
2011-08-08 03:53:52 -06:00
|
|
|
|
2012-01-30 06:09:20 -07:00
|
|
|
lock_release(splitLock);
|
2012-02-03 05:18:51 -07:00
|
|
|
lock_release(sp->lock);
|
2012-01-26 15:18:43 -07:00
|
|
|
|
2011-08-08 03:53:52 -06:00
|
|
|
return sp->bestValue;
|
2011-04-24 02:20:03 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
// Explicit template instantiations
|
2012-02-20 06:21:25 -07:00
|
|
|
template Value ThreadsManager::split<false>(Position&, Stack*, Value, Value, Value, Move*, Depth, Move, int, MovePicker*, int);
|
|
|
|
template Value ThreadsManager::split<true>(Position&, Stack*, Value, Value, Value, Move*, Depth, Move, int, MovePicker*, int);
|
2011-11-05 00:53:19 -06:00
|
|
|
|
|
|
|
|
2011-11-05 04:19:21 -06:00
|
|
|
// ThreadsManager::set_timer() is used to set the timer to trigger after msec
|
|
|
|
// milliseconds. If msec is 0 then timer is stopped.
|
|
|
|
|
|
|
|
void ThreadsManager::set_timer(int msec) {
|
|
|
|
|
2011-11-23 12:07:29 -07:00
|
|
|
Thread& timer = threads[MAX_THREADS];
|
2011-11-05 04:19:21 -06:00
|
|
|
|
2012-01-23 07:20:53 -07:00
|
|
|
lock_grab(timer.sleepLock);
|
2011-11-05 04:19:21 -06:00
|
|
|
timer.maxPly = msec;
|
2012-01-23 07:20:53 -07:00
|
|
|
cond_signal(timer.sleepCond); // Wake up and restart the timer
|
|
|
|
lock_release(timer.sleepLock);
|
2011-11-05 04:19:21 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-11-23 12:07:29 -07:00
|
|
|
// ThreadsManager::start_thinking() is used by UI thread to wake up the main
|
|
|
|
// thread parked in main_loop() and starting a new search. If asyncMode is true
|
|
|
|
// then function returns immediately, otherwise caller is blocked waiting for
|
|
|
|
// the search to finish.
|
2011-11-05 00:53:19 -06:00
|
|
|
|
2011-12-04 03:46:31 -07:00
|
|
|
void ThreadsManager::start_thinking(const Position& pos, const LimitsType& limits,
|
2012-01-14 05:49:25 -07:00
|
|
|
const std::set<Move>& searchMoves, bool async) {
|
2011-11-23 12:07:29 -07:00
|
|
|
Thread& main = threads[0];
|
2011-11-05 00:53:19 -06:00
|
|
|
|
2012-01-23 07:20:53 -07:00
|
|
|
lock_grab(main.sleepLock);
|
2011-11-27 09:07:17 -07:00
|
|
|
|
2011-11-23 12:07:29 -07:00
|
|
|
// Wait main thread has finished before to launch a new search
|
2011-11-27 09:07:17 -07:00
|
|
|
while (!main.do_sleep)
|
2012-01-23 07:20:53 -07:00
|
|
|
cond_wait(sleepCond, main.sleepLock);
|
2011-11-27 04:16:23 -07:00
|
|
|
|
2011-11-28 07:54:40 -07:00
|
|
|
// Copy input arguments to initialize the search
|
2011-12-04 03:46:31 -07:00
|
|
|
RootPosition.copy(pos, 0);
|
|
|
|
Limits = limits;
|
2012-01-14 05:49:25 -07:00
|
|
|
RootMoves.clear();
|
|
|
|
|
|
|
|
// Populate RootMoves with all the legal moves (default) or, if a searchMoves
|
|
|
|
// set is given, with the subset of legal moves to search.
|
|
|
|
for (MoveList<MV_LEGAL> ml(pos); !ml.end(); ++ml)
|
|
|
|
if (searchMoves.empty() || searchMoves.count(ml.move()))
|
|
|
|
RootMoves.push_back(RootMove(ml.move()));
|
2011-11-05 00:53:19 -06:00
|
|
|
|
2011-11-28 07:54:40 -07:00
|
|
|
// Reset signals before to start the new search
|
2012-01-12 23:56:59 -07:00
|
|
|
Signals.stopOnPonderhit = Signals.firstRootMove = false;
|
|
|
|
Signals.stop = Signals.failedLowAtRoot = false;
|
2011-11-26 08:29:54 -07:00
|
|
|
|
2011-11-23 12:07:29 -07:00
|
|
|
main.do_sleep = false;
|
2012-01-23 07:20:53 -07:00
|
|
|
cond_signal(main.sleepCond); // Wake up main thread and start searching
|
2011-11-05 00:53:19 -06:00
|
|
|
|
2012-01-14 05:49:25 -07:00
|
|
|
if (!async)
|
2012-01-02 06:37:44 -07:00
|
|
|
while (!main.do_sleep)
|
2012-01-23 07:20:53 -07:00
|
|
|
cond_wait(sleepCond, main.sleepLock);
|
2011-11-05 00:53:19 -06:00
|
|
|
|
2012-01-23 07:20:53 -07:00
|
|
|
lock_release(main.sleepLock);
|
2011-11-05 00:53:19 -06:00
|
|
|
}
|
2011-11-26 04:07:35 -07:00
|
|
|
|
|
|
|
|
2011-12-29 01:55:09 -07:00
|
|
|
// ThreadsManager::stop_thinking() is used by UI thread to raise a stop request
|
|
|
|
// and to wait for the main thread finishing the search. Needed to wait exiting
|
|
|
|
// and terminate the threads after a 'quit' command.
|
|
|
|
|
|
|
|
void ThreadsManager::stop_thinking() {
|
|
|
|
|
|
|
|
Thread& main = threads[0];
|
|
|
|
|
|
|
|
Search::Signals.stop = true;
|
|
|
|
|
2012-01-23 07:20:53 -07:00
|
|
|
lock_grab(main.sleepLock);
|
2011-12-29 01:55:09 -07:00
|
|
|
|
2012-01-23 07:20:53 -07:00
|
|
|
cond_signal(main.sleepCond); // In case is waiting for stop or ponderhit
|
2011-12-29 01:55:09 -07:00
|
|
|
|
|
|
|
while (!main.do_sleep)
|
2012-01-23 07:20:53 -07:00
|
|
|
cond_wait(sleepCond, main.sleepLock);
|
2011-12-29 01:55:09 -07:00
|
|
|
|
2012-01-23 07:20:53 -07:00
|
|
|
lock_release(main.sleepLock);
|
2011-12-29 01:55:09 -07:00
|
|
|
}
|