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)
|
2016-01-02 02:43:25 -07:00
|
|
|
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
|
2017-01-11 00:46:29 -07:00
|
|
|
Copyright (C) 2015-2017 Marco Costalba, Joona Kiiski, Gary Linscott, 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/>.
|
|
|
|
*/
|
|
|
|
|
2013-02-02 08:04:41 -07:00
|
|
|
#include <algorithm> // For std::count
|
2012-01-16 13:20:13 -07:00
|
|
|
#include <cassert>
|
2011-04-24 02:20:03 -06:00
|
|
|
|
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"
|
2016-06-03 23:53:29 -06:00
|
|
|
#include "syzygy/tbprobe.h"
|
2011-04-24 02:20:03 -06:00
|
|
|
|
2012-06-24 02:30:40 -06:00
|
|
|
ThreadPool Threads; // Global object
|
2011-04-24 02:20:03 -06:00
|
|
|
|
|
|
|
|
2017-08-13 00:58:31 -06:00
|
|
|
/// Thread constructor launches the thread and waits until it goes to sleep
|
|
|
|
/// in idle_loop(). Note that 'searching' and 'exit' should be alredy set.
|
2013-07-30 22:59:24 -06:00
|
|
|
|
2017-08-13 00:58:31 -06:00
|
|
|
Thread::Thread(size_t n) : idx(n), stdThread(&Thread::idle_loop, this) {
|
2015-11-20 23:48:50 -07:00
|
|
|
|
2017-08-13 00:58:31 -06:00
|
|
|
wait_for_search_finished();
|
2013-07-30 22:59:24 -06:00
|
|
|
}
|
2011-04-24 02:20:03 -06:00
|
|
|
|
2012-04-06 11:36:46 -06:00
|
|
|
|
2017-08-13 00:58:31 -06:00
|
|
|
/// Thread destructor wakes up the thread in idle_loop() and waits
|
|
|
|
/// for its termination. Thread should be already waiting.
|
2013-07-31 01:33:26 -06:00
|
|
|
|
2015-11-05 00:40:23 -07:00
|
|
|
Thread::~Thread() {
|
2013-07-31 01:33:26 -06:00
|
|
|
|
2017-08-13 00:58:31 -06:00
|
|
|
assert(!searching);
|
|
|
|
|
2015-11-20 23:48:50 -07:00
|
|
|
exit = true;
|
2017-08-13 00:58:31 -06:00
|
|
|
start_searching();
|
|
|
|
stdThread.join();
|
2015-11-05 00:40:23 -07:00
|
|
|
}
|
2013-07-31 01:33:26 -06:00
|
|
|
|
|
|
|
|
2017-08-13 00:58:31 -06:00
|
|
|
/// Thread::start_searching() wakes up the thread that will start the search
|
2015-11-20 23:48:50 -07:00
|
|
|
|
2017-08-13 00:58:31 -06:00
|
|
|
void Thread::start_searching() {
|
2013-07-31 01:33:26 -06:00
|
|
|
|
2017-08-13 00:58:31 -06:00
|
|
|
std::lock_guard<Mutex> lk(mutex);
|
|
|
|
searching = true;
|
|
|
|
cv.notify_one(); // Wake up the thread in idle_loop()
|
2013-07-31 01:33:26 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-08-13 00:58:31 -06:00
|
|
|
/// Thread::wait_for_search_finished() blocks on the condition variable
|
|
|
|
/// until the thread has finished searching.
|
2012-03-24 14:36:33 -06:00
|
|
|
|
2017-08-13 00:58:31 -06:00
|
|
|
void Thread::wait_for_search_finished() {
|
2012-03-24 13:10:13 -06:00
|
|
|
|
2015-11-05 00:40:23 -07:00
|
|
|
std::unique_lock<Mutex> lk(mutex);
|
2017-08-13 00:58:31 -06:00
|
|
|
cv.wait(lk, [&]{ return !searching; });
|
2012-03-24 13:10:13 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-08-13 00:58:31 -06:00
|
|
|
/// Thread::idle_loop() is where the thread is parked, blocked on the
|
|
|
|
/// condition variable, when it has no work to do.
|
2012-02-03 08:07:13 -07:00
|
|
|
|
Lazy SMP
Start all threads searching on root position and
use only the shared TT table as synching scheme.
It seems this scheme scales better than YBWC for
high number of threads.
Verified for nor regression at STC 3 threads
LLR: -2.95 (-2.94,2.94) [-3.00,1.00]
Total: 40232 W: 6908 L: 7130 D: 26194
Verified for nor regression at LTC 3 threads
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 28186 W: 3908 L: 3798 D: 20480
Verified for nor regression at STC 7 threads
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 3607 W: 674 L: 526 D: 2407
Verified for nor regression at LTC 7 threads
LLR: 2.95 (-2.94,2.94) [-3.00,1.00]
Total: 4235 W: 671 L: 528 D: 3036
Tested with fixed games at LTC with 20 threads
ELO: 44.75 +-7.6 (95%) LOS: 100.0%
Total: 2069 W: 407 L: 142 D: 1520
Tested with fixed games at XLTC (120secs) with 20 threads
ELO: 28.01 +-6.7 (95%) LOS: 100.0%
Total: 2275 W: 349 L: 166 D: 1760
Original patch of mbootsector, with additional work
from Ivan Ivec (log formula), Joerg Oster (id loop
simplification) and Marco Costalba (assorted formatting
and rework).
Bench: 8116244
2015-10-06 00:15:17 -06:00
|
|
|
void Thread::idle_loop() {
|
2012-02-03 08:07:13 -07:00
|
|
|
|
2016-11-21 23:41:46 -07:00
|
|
|
WinProcGroup::bindThisThread(idx);
|
|
|
|
|
2017-08-13 00:58:31 -06:00
|
|
|
while (true)
|
2012-02-03 08:07:13 -07:00
|
|
|
{
|
2015-03-10 05:42:40 -06:00
|
|
|
std::unique_lock<Mutex> lk(mutex);
|
2015-11-05 00:40:23 -07:00
|
|
|
searching = false;
|
2017-08-13 00:58:31 -06:00
|
|
|
cv.notify_one(); // Wake up anyone waiting for search finished
|
|
|
|
cv.wait(lk, [&]{ return searching; });
|
2013-01-16 01:26:10 -07:00
|
|
|
|
2017-08-13 00:58:31 -06:00
|
|
|
if (exit)
|
|
|
|
return;
|
2012-02-03 08:07:13 -07:00
|
|
|
|
2015-01-18 00:00:50 -07:00
|
|
|
lk.unlock();
|
2012-02-03 08:07:13 -07:00
|
|
|
|
2017-08-13 00:58:31 -06:00
|
|
|
search();
|
2012-02-03 08:07:13 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-08-13 00:58:31 -06:00
|
|
|
/// ThreadPool::init() creates and launches the threads that will go
|
|
|
|
/// immediately to sleep in idle_loop. We cannot use the c'tor 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.
|
2012-03-26 00:58:10 -06:00
|
|
|
|
2017-08-13 00:58:31 -06:00
|
|
|
void ThreadPool::init(size_t requested) {
|
2012-03-26 00:58:10 -06:00
|
|
|
|
2017-08-13 00:58:31 -06:00
|
|
|
push_back(new MainThread(0));
|
|
|
|
set(requested);
|
2012-03-26 00:58:10 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-01-16 14:34:29 -07:00
|
|
|
/// ThreadPool::exit() terminates threads before the program exits. Cannot be
|
2017-08-13 00:58:31 -06:00
|
|
|
/// done in the destructor because threads must be terminated before deleting
|
|
|
|
/// any static object, so before main() returns.
|
2012-03-26 00:58:10 -06:00
|
|
|
|
2012-08-29 08:43:01 -06:00
|
|
|
void ThreadPool::exit() {
|
2012-03-26 00:58:10 -06:00
|
|
|
|
2017-08-13 00:58:31 -06:00
|
|
|
main()->wait_for_search_finished();
|
|
|
|
set(0);
|
2012-03-26 00:58:10 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-08-13 00:58:31 -06:00
|
|
|
/// ThreadPool::set() creates/destroys threads to match the requested number
|
2011-04-24 02:20:03 -06:00
|
|
|
|
2017-08-13 00:58:31 -06:00
|
|
|
void ThreadPool::set(size_t requested) {
|
2012-03-25 05:01:56 -06:00
|
|
|
|
2013-02-04 14:38:42 -07:00
|
|
|
while (size() < requested)
|
2017-08-13 00:58:31 -06:00
|
|
|
push_back(new Thread(size()));
|
2012-03-24 14:36:33 -06:00
|
|
|
|
2013-02-04 14:38:42 -07:00
|
|
|
while (size() > requested)
|
2015-11-20 23:48:50 -07:00
|
|
|
delete back(), pop_back();
|
2012-03-24 12:29:12 -06:00
|
|
|
}
|
2011-08-08 16:07:09 -06:00
|
|
|
|
2012-02-12 06:07:21 -07:00
|
|
|
|
2017-08-13 00:58:31 -06:00
|
|
|
/// ThreadPool::start_thinking() wakes up main thread waiting in idle_loop() and
|
|
|
|
/// returns immediately. Main thread will wake up other threads and start the search.
|
2014-02-09 09:31:45 -07:00
|
|
|
|
2016-06-03 23:53:29 -06:00
|
|
|
void ThreadPool::start_thinking(Position& pos, StateListPtr& states,
|
2017-08-10 13:32:50 -06:00
|
|
|
const Search::LimitsType& limits, bool ponderMode) {
|
2015-11-20 23:48:50 -07:00
|
|
|
|
|
|
|
main()->wait_for_search_finished();
|
2012-03-26 00:58:10 -06:00
|
|
|
|
2017-08-10 11:57:28 -06:00
|
|
|
stopOnPonderhit = stop = false;
|
2017-08-10 13:32:50 -06:00
|
|
|
ponder = ponderMode;
|
2016-04-11 08:45:36 -06:00
|
|
|
Search::Limits = limits;
|
|
|
|
Search::RootMoves rootMoves;
|
2012-01-14 05:49:25 -07:00
|
|
|
|
2015-01-31 10:39:51 -07:00
|
|
|
for (const auto& m : MoveList<LEGAL>(pos))
|
2014-02-09 09:31:45 -07:00
|
|
|
if ( limits.searchmoves.empty()
|
2015-01-31 10:39:51 -07:00
|
|
|
|| std::count(limits.searchmoves.begin(), limits.searchmoves.end(), m))
|
2017-08-13 00:58:31 -06:00
|
|
|
rootMoves.emplace_back(m);
|
2016-04-11 08:45:36 -06:00
|
|
|
|
2016-09-23 23:30:37 -06:00
|
|
|
if (!rootMoves.empty())
|
|
|
|
Tablebases::filter_root_moves(pos, rootMoves);
|
2016-06-03 23:53:29 -06:00
|
|
|
|
2016-04-11 08:45:36 -06:00
|
|
|
// After ownership transfer 'states' becomes empty, so if we stop the search
|
|
|
|
// and call 'go' again without setting a new position states.get() == NULL.
|
|
|
|
assert(states.get() || setupStates.get());
|
|
|
|
|
|
|
|
if (states.get())
|
|
|
|
setupStates = std::move(states); // Ownership transfer, states is now empty
|
|
|
|
|
2017-08-14 10:12:16 -06:00
|
|
|
// We use Position::set() to set root position across threads. But there are
|
|
|
|
// some StateInfo fields (previous, pliesFromNull, capturedPiece) that cannot
|
|
|
|
// be deduced from a fen string, so set() clears them and to not lose the info
|
|
|
|
// we need to backup and later restore setupStates->back(). Note that setupStates
|
|
|
|
// is shared by threads but is accessed in read-only mode.
|
|
|
|
StateInfo tmp = setupStates->back();
|
2016-04-17 13:31:19 -06:00
|
|
|
|
2016-04-11 08:45:36 -06:00
|
|
|
for (Thread* th : Threads)
|
|
|
|
{
|
2017-08-13 00:58:31 -06:00
|
|
|
th->nodes = th->tbHits = 0;
|
|
|
|
th->rootDepth = th->completedDepth = DEPTH_ZERO;
|
2016-04-11 08:45:36 -06:00
|
|
|
th->rootMoves = rootMoves;
|
|
|
|
th->rootPos.set(pos.fen(), pos.is_chess960(), &setupStates->back(), th);
|
|
|
|
}
|
2011-11-05 00:53:19 -06:00
|
|
|
|
2017-08-14 10:12:16 -06:00
|
|
|
setupStates->back() = tmp;
|
2016-04-17 13:31:19 -06:00
|
|
|
|
2015-11-20 23:48:50 -07:00
|
|
|
main()->start_searching();
|
2011-12-29 01:55:09 -07:00
|
|
|
}
|