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
|
2018-11-19 03:18:21 -07:00
|
|
|
Copyright (C) 2015-2019 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"
|
2017-12-26 02:40:42 -07:00
|
|
|
#include "uci.h"
|
2016-06-03 23:53:29 -06:00
|
|
|
#include "syzygy/tbprobe.h"
|
2018-06-02 09:02:23 -06:00
|
|
|
#include "tt.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-31 01:34:32 -06:00
|
|
|
/// Thread::clear() reset histories, usually before a new game
|
|
|
|
|
|
|
|
void Thread::clear() {
|
|
|
|
|
|
|
|
counterMoves.fill(MOVE_NONE);
|
|
|
|
mainHistory.fill(0);
|
2017-11-03 05:37:11 -06:00
|
|
|
captureHistory.fill(0);
|
2017-08-31 01:34:32 -06:00
|
|
|
|
2018-07-19 10:26:05 -06:00
|
|
|
for (auto& to : continuationHistory)
|
2017-08-31 01:34:32 -06:00
|
|
|
for (auto& h : to)
|
2018-07-28 07:33:39 -06:00
|
|
|
h->fill(0);
|
2017-08-31 01:34:32 -06:00
|
|
|
|
2018-07-28 07:33:39 -06:00
|
|
|
continuationHistory[NO_PIECE][0]->fill(Search::CounterMovePruneThreshold - 1);
|
2017-08-31 01:34:32 -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
|
|
|
|
2017-12-26 02:40:42 -07:00
|
|
|
// If OS already scheduled us on a different group than 0 then don't overwrite
|
|
|
|
// the choice, eventually we are one of many one-threaded processes running on
|
|
|
|
// some Windows NUMA hardware, for instance in fishtest. To make it simple,
|
|
|
|
// just check if running threads are below a threshold, in this case all this
|
|
|
|
// NUMA machinery is not needed.
|
2018-09-04 05:36:42 -06:00
|
|
|
if (Options["Threads"] > 8)
|
2017-12-26 02:40:42 -07:00
|
|
|
WinProcGroup::bindThisThread(idx);
|
2016-11-21 23:41:46 -07:00
|
|
|
|
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-12-26 02:40:42 -07:00
|
|
|
/// ThreadPool::set() creates/destroys threads to match the requested number.
|
2018-06-02 09:41:37 -06:00
|
|
|
/// Created and launched threads will go immediately to sleep in idle_loop.
|
2017-12-26 02:40:42 -07:00
|
|
|
/// Upon resizing, threads are recreated to allow for binding if necessary.
|
2012-02-03 08:07:13 -07:00
|
|
|
|
2017-12-26 02:40:42 -07:00
|
|
|
void ThreadPool::set(size_t requested) {
|
2012-03-26 00:58:10 -06:00
|
|
|
|
2017-12-26 02:40:42 -07:00
|
|
|
if (size() > 0) { // destroy any existing thread(s)
|
|
|
|
main()->wait_for_search_finished();
|
2012-03-26 00:58:10 -06:00
|
|
|
|
2017-12-26 02:40:42 -07:00
|
|
|
while (size() > 0)
|
|
|
|
delete back(), pop_back();
|
|
|
|
}
|
2012-03-26 00:58:10 -06:00
|
|
|
|
2017-12-26 02:40:42 -07:00
|
|
|
if (requested > 0) { // create new thread(s)
|
|
|
|
push_back(new MainThread(0));
|
2012-03-26 00:58:10 -06:00
|
|
|
|
2017-12-26 02:40:42 -07:00
|
|
|
while (size() < requested)
|
|
|
|
push_back(new Thread(size()));
|
|
|
|
clear();
|
|
|
|
}
|
2018-06-02 09:02:23 -06:00
|
|
|
|
|
|
|
// Reallocate the hash with the new threadpool size
|
|
|
|
TT.resize(Options["Hash"]);
|
2012-03-26 00:58:10 -06:00
|
|
|
}
|
|
|
|
|
2017-12-26 02:40:42 -07:00
|
|
|
/// ThreadPool::clear() sets threadPool data to initial values.
|
2012-03-26 00:58:10 -06:00
|
|
|
|
2017-12-26 02:40:42 -07:00
|
|
|
void ThreadPool::clear() {
|
2011-04-24 02:20:03 -06:00
|
|
|
|
2017-12-26 02:40:42 -07:00
|
|
|
for (Thread* th : *this)
|
|
|
|
th->clear();
|
2012-03-25 05:01:56 -06:00
|
|
|
|
2017-12-26 02:40:42 -07:00
|
|
|
main()->callsCnt = 0;
|
|
|
|
main()->previousScore = VALUE_INFINITE;
|
2018-02-12 14:57:42 -07:00
|
|
|
main()->previousTimeReduction = 1.0;
|
2012-03-24 12:29:12 -06:00
|
|
|
}
|
2011-08-08 16:07:09 -06: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())
|
2018-04-18 10:38:38 -06:00
|
|
|
Tablebases::rank_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
|
|
|
|
2017-12-26 02:40:42 -07:00
|
|
|
for (Thread* th : *this)
|
2016-04-11 08:45:36 -06:00
|
|
|
{
|
2018-06-02 09:41:37 -06:00
|
|
|
th->nodes = th->tbHits = th->nmpMinPly = 0;
|
2017-08-13 00:58:31 -06:00
|
|
|
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
|
|
|
}
|