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
|
|
|
|
Copyright (C) 2015-2016 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"
|
2014-10-26 00:09:19 -06:00
|
|
|
#include "uci.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
|
|
|
|
2016-01-16 14:34:29 -07:00
|
|
|
/// Thread constructor launches the thread and then waits until it goes to sleep
|
2015-11-20 23:48:50 -07:00
|
|
|
/// in idle_loop().
|
2011-04-24 02:20:03 -06:00
|
|
|
|
2015-11-05 00:40:23 -07:00
|
|
|
Thread::Thread() {
|
2013-07-30 22:59:24 -06:00
|
|
|
|
2015-11-20 23:48:50 -07:00
|
|
|
resetCalls = exit = false;
|
2016-10-22 00:21:38 -06:00
|
|
|
maxPly = callsCnt = 0;
|
|
|
|
tbHits = 0;
|
2015-11-05 00:40:23 -07:00
|
|
|
history.clear();
|
|
|
|
counterMoves.clear();
|
2015-11-20 23:48:50 -07:00
|
|
|
idx = Threads.size(); // Start from 0
|
|
|
|
|
|
|
|
std::unique_lock<Mutex> lk(mutex);
|
|
|
|
searching = true;
|
|
|
|
nativeThread = std::thread(&Thread::idle_loop, this);
|
|
|
|
sleepCondition.wait(lk, [&]{ return !searching; });
|
2013-07-30 22:59:24 -06:00
|
|
|
}
|
2011-04-24 02:20:03 -06:00
|
|
|
|
2012-04-06 11:36:46 -06:00
|
|
|
|
2016-01-16 14:34:29 -07:00
|
|
|
/// Thread destructor waits for thread termination before returning
|
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
|
|
|
|
2015-11-05 00:40:23 -07:00
|
|
|
mutex.lock();
|
2015-11-20 23:48:50 -07:00
|
|
|
exit = true;
|
|
|
|
sleepCondition.notify_one();
|
2015-11-05 00:40:23 -07:00
|
|
|
mutex.unlock();
|
2015-11-20 23:48:50 -07:00
|
|
|
nativeThread.join();
|
2015-11-05 00:40:23 -07:00
|
|
|
}
|
2013-07-31 01:33:26 -06:00
|
|
|
|
|
|
|
|
2016-01-16 14:34:29 -07:00
|
|
|
/// Thread::wait_for_search_finished() waits on sleep condition
|
|
|
|
/// until not searching
|
2015-11-20 23:48:50 -07:00
|
|
|
|
|
|
|
void Thread::wait_for_search_finished() {
|
2013-07-31 01:33:26 -06:00
|
|
|
|
2015-03-10 05:42:40 -06:00
|
|
|
std::unique_lock<Mutex> lk(mutex);
|
2015-11-05 00:40:23 -07:00
|
|
|
sleepCondition.wait(lk, [&]{ return !searching; });
|
2013-07-31 01:33:26 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-01-16 14:34:29 -07:00
|
|
|
/// Thread::wait() waits on sleep condition until condition is true
|
2015-11-05 00:40:23 -07:00
|
|
|
|
2015-11-20 23:48:50 -07:00
|
|
|
void Thread::wait(std::atomic_bool& condition) {
|
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
|
|
|
|
|
|
|
std::unique_lock<Mutex> lk(mutex);
|
2015-11-20 23:48:50 -07:00
|
|
|
sleepCondition.wait(lk, [&]{ return bool(condition); });
|
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
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-01-16 14:34:29 -07:00
|
|
|
/// Thread::start_searching() wakes up the thread that will start the search
|
2012-03-24 14:36:33 -06:00
|
|
|
|
2015-11-20 23:48:50 -07:00
|
|
|
void Thread::start_searching(bool resume) {
|
2012-03-24 13:10:13 -06:00
|
|
|
|
2015-11-05 00:40:23 -07:00
|
|
|
std::unique_lock<Mutex> lk(mutex);
|
2015-11-20 23:48:50 -07:00
|
|
|
|
|
|
|
if (!resume)
|
|
|
|
searching = true;
|
|
|
|
|
|
|
|
sleepCondition.notify_one();
|
2012-03-24 13:10:13 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-11-20 23:48:50 -07:00
|
|
|
/// Thread::idle_loop() is where the thread is parked 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
|
|
|
|
2013-01-16 01:28:41 -07:00
|
|
|
while (!exit)
|
2012-02-03 08:07:13 -07:00
|
|
|
{
|
2015-03-10 05:42:40 -06:00
|
|
|
std::unique_lock<Mutex> lk(mutex);
|
2013-01-16 01:26:10 -07:00
|
|
|
|
2015-11-05 00:40:23 -07:00
|
|
|
searching = false;
|
2013-01-16 01:26:10 -07:00
|
|
|
|
2015-11-05 00:40:23 -07:00
|
|
|
while (!searching && !exit)
|
2012-02-03 08:07:13 -07:00
|
|
|
{
|
2015-11-20 23:48:50 -07:00
|
|
|
sleepCondition.notify_one(); // Wake up any waiting thread
|
2015-01-18 00:00:50 -07:00
|
|
|
sleepCondition.wait(lk);
|
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
|
|
|
|
2015-11-20 23:48:50 -07:00
|
|
|
if (!exit)
|
2015-11-05 00:40:23 -07:00
|
|
|
search();
|
2012-02-03 08:07:13 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-01-16 14:34:29 -07:00
|
|
|
/// ThreadPool::init() creates and launches requested threads that will go
|
2015-11-20 23:48:50 -07:00
|
|
|
/// immediately to sleep. We cannot use a constructor 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
|
|
|
|
2012-06-24 02:30:40 -06:00
|
|
|
void ThreadPool::init() {
|
2012-03-26 00:58:10 -06:00
|
|
|
|
2015-11-05 00:40:23 -07:00
|
|
|
push_back(new MainThread);
|
2012-03-26 00:58:10 -06:00
|
|
|
read_uci_options();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-01-16 14:34:29 -07:00
|
|
|
/// ThreadPool::exit() terminates threads before the program exits. Cannot be
|
2015-11-20 23:48:50 -07:00
|
|
|
/// done in destructor because threads must be terminated before deleting any
|
2016-01-16 14:34:29 -07:00
|
|
|
/// static objects while still in main().
|
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
|
|
|
|
2015-11-20 23:48:50 -07:00
|
|
|
while (size())
|
|
|
|
delete back(), pop_back();
|
2012-03-26 00:58:10 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-11-20 23:48:50 -07:00
|
|
|
/// ThreadPool::read_uci_options() updates internal threads parameters from the
|
|
|
|
/// corresponding UCI options and creates/destroys threads to match requested
|
|
|
|
/// number. Thread objects are dynamically allocated.
|
2011-04-24 02:20:03 -06:00
|
|
|
|
2012-06-24 02:30:40 -06:00
|
|
|
void ThreadPool::read_uci_options() {
|
2011-04-24 02:20:03 -06:00
|
|
|
|
2015-11-20 23:48:50 -07:00
|
|
|
size_t requested = Options["Threads"];
|
2012-03-24 14:36:33 -06:00
|
|
|
|
2012-03-25 05:01:56 -06:00
|
|
|
assert(requested > 0);
|
|
|
|
|
2013-02-04 14:38:42 -07:00
|
|
|
while (size() < requested)
|
2015-11-05 00:40:23 -07:00
|
|
|
push_back(new Thread);
|
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
|
|
|
|
2016-01-16 14:34:29 -07:00
|
|
|
/// ThreadPool::nodes_searched() returns the number of nodes searched
|
2011-04-24 02:20:03 -06:00
|
|
|
|
2016-10-22 00:21:38 -06:00
|
|
|
uint64_t ThreadPool::nodes_searched() const {
|
2011-04-24 02:20:03 -06:00
|
|
|
|
2016-10-20 13:16:09 -06:00
|
|
|
uint64_t nodes = 0;
|
2015-11-20 23:48:50 -07:00
|
|
|
for (Thread* th : *this)
|
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
|
|
|
nodes += th->rootPos.nodes_searched();
|
|
|
|
return nodes;
|
2011-04-24 02:20:03 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-10-20 13:16:09 -06:00
|
|
|
/// ThreadPool::tb_hits() returns the number of TB hits
|
|
|
|
|
2016-10-22 00:21:38 -06:00
|
|
|
uint64_t ThreadPool::tb_hits() const {
|
2016-10-20 13:16:09 -06:00
|
|
|
|
|
|
|
uint64_t hits = 0;
|
|
|
|
for (Thread* th : *this)
|
|
|
|
hits += th->tbHits;
|
|
|
|
return hits;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-01-16 14:34:29 -07:00
|
|
|
/// ThreadPool::start_thinking() wakes up the main thread sleeping in idle_loop()
|
|
|
|
/// and starts a new search, then returns immediately.
|
2014-02-09 09:31:45 -07:00
|
|
|
|
2016-06-03 23:53:29 -06:00
|
|
|
void ThreadPool::start_thinking(Position& pos, StateListPtr& states,
|
2016-04-11 08:45:36 -06:00
|
|
|
const Search::LimitsType& limits) {
|
2015-11-20 23:48:50 -07:00
|
|
|
|
|
|
|
main()->wait_for_search_finished();
|
2012-03-26 00:58:10 -06:00
|
|
|
|
2016-04-11 08:45:36 -06:00
|
|
|
Search::Signals.stopOnPonderhit = Search::Signals.stop = false;
|
|
|
|
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))
|
2016-04-11 08:45:36 -06:00
|
|
|
rootMoves.push_back(Search::RootMove(m));
|
|
|
|
|
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
|
|
|
|
|
2016-04-17 13:31:19 -06:00
|
|
|
StateInfo tmp = setupStates->back();
|
|
|
|
|
2016-04-11 08:45:36 -06:00
|
|
|
for (Thread* th : Threads)
|
|
|
|
{
|
|
|
|
th->maxPly = 0;
|
2016-10-22 00:21:38 -06:00
|
|
|
th->tbHits = 0;
|
2016-04-11 08:45:36 -06:00
|
|
|
th->rootDepth = DEPTH_ZERO;
|
|
|
|
th->rootMoves = rootMoves;
|
|
|
|
th->rootPos.set(pos.fen(), pos.is_chess960(), &setupStates->back(), th);
|
|
|
|
}
|
2011-11-05 00:53:19 -06:00
|
|
|
|
2016-04-17 13:31:19 -06:00
|
|
|
setupStates->back() = tmp; // Restore st->previous, cleared by Position::set()
|
|
|
|
|
2015-11-20 23:48:50 -07:00
|
|
|
main()->start_searching();
|
2011-12-29 01:55:09 -07:00
|
|
|
}
|