mirror of
https://github.com/sockspls/badfish
synced 2025-07-12 03:59:15 +00:00
1982fe25f8
The current update only by main thread depends on the luck of whether main thread sees any/many changes to the best move or not. It then makes large, lumpy changes to the time to be used (1x, 2x, 3x, etc) depending on that sample of 1. Use the average across all threads to get a more reliable number with a smoother distribution. STC @ 5+0.05 th 4 : LLR: 2.95 (-2.94,2.94) [0.50,4.50] Total: 51899 W: 11446 L: 11029 D: 29424 http://tests.stockfishchess.org/tests/view/5ca32ff20ebc5925cf0016fb STC @ 5+0.05 th 8 : LLR: 2.96 (-2.94,2.94) [0.50,4.50] Total: 13851 W: 2843 L: 2620 D: 8388 http://tests.stockfishchess.org/tests/view/5ca35ae00ebc5925cf001adb LTC @ 20+0.2 th 8 : LLR: 2.95 (-2.94,2.94) [0.00,3.50] Total: 48527 W: 7941 L: 7635 D: 32951 http://tests.stockfishchess.org/tests/view/5ca37cb70ebc5925cf001cec Further work: Similar changes might be possible for the fallingEval and timeReduction calculations (and elsewhere?), using either the min, average or max values across all threads. Bench 3506898
126 lines
3.4 KiB
C++
126 lines
3.4 KiB
C++
/*
|
|
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
|
|
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
|
|
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
|
|
Copyright (C) 2015-2019 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
|
|
|
|
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/>.
|
|
*/
|
|
|
|
#ifndef THREAD_H_INCLUDED
|
|
#define THREAD_H_INCLUDED
|
|
|
|
#include <atomic>
|
|
#include <condition_variable>
|
|
#include <mutex>
|
|
#include <thread>
|
|
#include <vector>
|
|
|
|
#include "material.h"
|
|
#include "movepick.h"
|
|
#include "pawns.h"
|
|
#include "position.h"
|
|
#include "search.h"
|
|
#include "thread_win32_osx.h"
|
|
|
|
|
|
/// Thread class keeps together all the thread-related stuff. We use
|
|
/// per-thread pawn and material hash tables so that once we get a
|
|
/// pointer to an entry its life time is unlimited and we don't have
|
|
/// to care about someone changing the entry under our feet.
|
|
|
|
class Thread {
|
|
|
|
Mutex mutex;
|
|
ConditionVariable cv;
|
|
size_t idx;
|
|
bool exit = false, searching = true; // Set before starting std::thread
|
|
NativeThread stdThread;
|
|
|
|
public:
|
|
explicit Thread(size_t);
|
|
virtual ~Thread();
|
|
virtual void search();
|
|
void clear();
|
|
void idle_loop();
|
|
void start_searching();
|
|
void wait_for_search_finished();
|
|
|
|
Pawns::Table pawnsTable;
|
|
Material::Table materialTable;
|
|
Endgames endgames;
|
|
size_t pvIdx, pvLast;
|
|
int selDepth, nmpMinPly;
|
|
Color nmpColor;
|
|
std::atomic<uint64_t> nodes, tbHits, bestMoveChanges;
|
|
|
|
Position rootPos;
|
|
Search::RootMoves rootMoves;
|
|
Depth rootDepth, completedDepth;
|
|
CounterMoveHistory counterMoves;
|
|
ButterflyHistory mainHistory;
|
|
CapturePieceToHistory captureHistory;
|
|
ContinuationHistory continuationHistory;
|
|
Score contempt;
|
|
};
|
|
|
|
|
|
/// MainThread is a derived class specific for main thread
|
|
|
|
struct MainThread : public Thread {
|
|
|
|
using Thread::Thread;
|
|
|
|
void search() override;
|
|
void check_time();
|
|
|
|
double previousTimeReduction;
|
|
Value previousScore;
|
|
int callsCnt;
|
|
bool stopOnPonderhit;
|
|
std::atomic_bool ponder;
|
|
};
|
|
|
|
|
|
/// ThreadPool struct handles all the threads-related stuff like init, starting,
|
|
/// parking and, most importantly, launching a thread. All the access to threads
|
|
/// is done through this class.
|
|
|
|
struct ThreadPool : public std::vector<Thread*> {
|
|
|
|
void start_thinking(Position&, StateListPtr&, const Search::LimitsType&, bool = false);
|
|
void clear();
|
|
void set(size_t);
|
|
|
|
MainThread* main() const { return static_cast<MainThread*>(front()); }
|
|
uint64_t nodes_searched() const { return accumulate(&Thread::nodes); }
|
|
uint64_t tb_hits() const { return accumulate(&Thread::tbHits); }
|
|
|
|
std::atomic_bool stop;
|
|
|
|
private:
|
|
StateListPtr setupStates;
|
|
|
|
uint64_t accumulate(std::atomic<uint64_t> Thread::* member) const {
|
|
|
|
uint64_t sum = 0;
|
|
for (Thread* th : *this)
|
|
sum += (th->*member).load(std::memory_order_relaxed);
|
|
return sum;
|
|
}
|
|
};
|
|
|
|
extern ThreadPool Threads;
|
|
|
|
#endif // #ifndef THREAD_H_INCLUDED
|