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)
|
2015-01-10 03:43:28 -07:00
|
|
|
Copyright (C) 2008-2015 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/>.
|
|
|
|
*/
|
|
|
|
|
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"
|
2011-04-24 02:20:03 -06:00
|
|
|
|
2011-12-04 03:46:31 -07:00
|
|
|
using namespace Search;
|
|
|
|
|
2012-06-24 02:30:40 -06:00
|
|
|
ThreadPool Threads; // Global object
|
2011-04-24 02:20:03 -06:00
|
|
|
|
2015-11-05 00:40:23 -07:00
|
|
|
// Thread constructor makes some init and launches the thread that will go to
|
|
|
|
// sleep 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-05 00:40:23 -07:00
|
|
|
searching = true; // Avoid a race with start_thinking()
|
|
|
|
exit = resetCalls = false;
|
|
|
|
maxPly = callsCnt = 0;
|
|
|
|
history.clear();
|
|
|
|
counterMoves.clear();
|
|
|
|
idx = Threads.size(); // Starts from 0
|
|
|
|
std::thread::operator=(std::thread(&Thread::idle_loop, this));
|
2013-07-30 22:59:24 -06:00
|
|
|
}
|
2011-04-24 02:20:03 -06:00
|
|
|
|
2012-04-06 11:36:46 -06:00
|
|
|
|
2015-11-05 00:40:23 -07:00
|
|
|
// Thread destructor waits for thread termination before deleting
|
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();
|
|
|
|
exit = true; // Search must be already finished
|
|
|
|
mutex.unlock();
|
2013-07-31 01:33:26 -06:00
|
|
|
|
2015-11-05 00:40:23 -07:00
|
|
|
notify_one();
|
|
|
|
std::thread::join(); // Wait for thread termination
|
|
|
|
}
|
2013-07-31 01:33:26 -06:00
|
|
|
|
|
|
|
|
2015-11-05 00:40:23 -07:00
|
|
|
// Thread::join() waits for the thread to finish searching
|
|
|
|
void Thread::join() {
|
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
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-11-05 00:40:23 -07:00
|
|
|
// Thread::notify_one() wakes up the thread when there is some work to do
|
|
|
|
|
|
|
|
void Thread::notify_one() {
|
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-05 00:40:23 -07:00
|
|
|
sleepCondition.notify_one();
|
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
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-11-05 00:40:23 -07:00
|
|
|
// Thread::wait() set the thread to sleep until 'condition' turns true
|
2012-03-24 14:36:33 -06:00
|
|
|
|
2015-11-05 00:40:23 -07:00
|
|
|
void Thread::wait(std::atomic_bool& condition) {
|
2012-03-24 13:10:13 -06:00
|
|
|
|
2015-11-05 00:40:23 -07:00
|
|
|
std::unique_lock<Mutex> lk(mutex);
|
|
|
|
sleepCondition.wait(lk, [&]{ return bool(condition); });
|
2012-03-24 13:10:13 -06: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
|
|
|
// 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-05 00:40:23 -07:00
|
|
|
sleepCondition.notify_one(); // Wake up main thread if needed
|
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-05 00:40:23 -07:00
|
|
|
if (!exit && searching)
|
|
|
|
search();
|
2012-02-03 08:07:13 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-01-01 02:46:31 -07:00
|
|
|
// ThreadPool::init() is called at startup to create and launch requested threads,
|
2015-10-25 01:30:07 -06:00
|
|
|
// that will go immediately to sleep. We cannot use a constructor because Threads
|
2015-10-25 05:07:22 -06:00
|
|
|
// 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();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-01-01 02:46:31 -07:00
|
|
|
// ThreadPool::exit() terminates the threads before the program exits. Cannot be
|
2015-10-25 05:07:22 -06:00
|
|
|
// done in destructor because threads must be terminated before freeing us.
|
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-01-18 00:00:50 -07:00
|
|
|
for (Thread* th : *this)
|
2015-11-05 00:40:23 -07:00
|
|
|
delete th;
|
2015-03-22 05:41:11 -06:00
|
|
|
|
|
|
|
clear(); // Get rid of stale pointers
|
2012-03-26 00:58:10 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-01-01 02:46:31 -07:00
|
|
|
// ThreadPool::read_uci_options() updates internal threads parameters from the
|
|
|
|
// corresponding UCI options and creates/destroys threads to match the requested
|
|
|
|
// number. Thread objects are dynamically allocated to avoid creating all possible
|
|
|
|
// threads in advance (which include pawns and material tables), even if only a
|
|
|
|
// few are to be used.
|
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
|
|
|
|
2014-03-15 14:13:43 -06: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)
|
2012-03-24 14:36:33 -06:00
|
|
|
{
|
2015-11-05 00:40:23 -07:00
|
|
|
delete back();
|
2013-02-04 14:38:42 -07:00
|
|
|
pop_back();
|
2012-03-24 14:36:33 -06:00
|
|
|
}
|
2012-03-24 12:29:12 -06:00
|
|
|
}
|
2011-08-08 16:07:09 -06:00
|
|
|
|
2012-02-12 06:07:21 -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
|
|
|
// ThreadPool::nodes_searched() returns the number of nodes searched
|
2011-04-24 02:20:03 -06: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
|
|
|
int64_t ThreadPool::nodes_searched() {
|
2011-04-24 02:20:03 -06: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
|
|
|
int64_t nodes = 0;
|
|
|
|
for (Thread *th : *this)
|
|
|
|
nodes += th->rootPos.nodes_searched();
|
|
|
|
return nodes;
|
2011-04-24 02:20:03 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-01-01 02:46:31 -07:00
|
|
|
// ThreadPool::start_thinking() wakes up the main thread sleeping in
|
|
|
|
// MainThread::idle_loop() and starts a new search, then returns immediately.
|
2014-02-09 09:31:45 -07:00
|
|
|
|
2015-01-01 02:46:31 -07:00
|
|
|
void ThreadPool::start_thinking(const Position& pos, const LimitsType& limits,
|
|
|
|
StateStackPtr& states) {
|
2015-11-05 00:40:23 -07:00
|
|
|
for (Thread* th : Threads)
|
|
|
|
th->join();
|
2012-03-26 00:58:10 -06:00
|
|
|
|
|
|
|
Signals.stopOnPonderhit = Signals.firstRootMove = false;
|
|
|
|
Signals.stop = Signals.failedLowAtRoot = false;
|
2011-11-27 04:16:23 -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
|
|
|
main()->rootMoves.clear();
|
|
|
|
main()->rootPos = pos;
|
2011-12-04 03:46:31 -07:00
|
|
|
Limits = limits;
|
2013-06-01 07:45:46 -06:00
|
|
|
if (states.get()) // If we don't set a new position, preserve current state
|
|
|
|
{
|
2015-01-18 00:00:50 -07:00
|
|
|
SetupStates = std::move(states); // Ownership transfer here
|
2013-06-01 07:45:46 -06:00
|
|
|
assert(!states.get());
|
|
|
|
}
|
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))
|
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
|
|
|
main()->rootMoves.push_back(RootMove(m));
|
2011-11-05 00:53:19 -06:00
|
|
|
|
2015-11-05 00:40:23 -07:00
|
|
|
main()->searching = true;
|
|
|
|
main()->notify_one(); // Wake up main thread: 'searching' must be already set
|
2011-12-29 01:55:09 -07:00
|
|
|
}
|