mirror of
https://github.com/official-stockfish/Stockfish.git
synced 2026-07-23 05:07:14 +00:00
syzygy1andStéphane Nicolet
108f0da4d7
This patch corrects both MultiPV behaviour and "go searchmoves" behaviour for tablebases. We change the logic of table base probing at root positions from filtering to ranking. The ranking code is much more straightforward than the current filtering code (this is a simplification), and also more versatile. If the root is a TB position, each root move is probed and assigned a TB score and a TB rank. The TB score is the Value to be displayed to the user for that move (unless the search finds a mate score), while the TB rank determines which moves should appear higher in a multi-pv search. In game play, the engine will always pick a move with the highest rank. Ranks run from -1000 to +1000: 901 to 1000 : TB win 900 : normally a TB win, in rare cases this could be a draw 1 to 899 : cursed TB wins 0 : draw -1 to -899 : blessed TB losses -900 : normally a TB loss, in rare cases this could be a draw -901 to -1000 : TB loss Normally all winning moves get rank 1000 (to let the search pick the best among them). The exception is if there has been a first repetition. In that case, moves are ranked strictly by DTZ so that the engine will play a move that lowers DTZ (and therefore cannot repeat the position a second time). Losing moves get rank -1000 unless they have relatively high DTZ, meaning they have some drawing chances. Those get ranks towards -901 (when they cross -900 the draw is certain). Closes https://github.com/official-stockfish/Stockfish/pull/1467 No functional change (without tablebases).
125 lines
3.4 KiB
C++
125 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-2018 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.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
|
|
std::thread 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, nmp_ply, nmp_odd;
|
|
std::atomic<uint64_t> nodes, tbHits;
|
|
|
|
Position rootPos;
|
|
Search::RootMoves rootMoves;
|
|
Depth rootDepth, completedDepth;
|
|
CounterMoveHistory counterMoves;
|
|
ButterflyHistory mainHistory;
|
|
CapturePieceToHistory captureHistory;
|
|
ContinuationHistory contHistory;
|
|
Score contempt;
|
|
};
|
|
|
|
|
|
/// MainThread is a derived class specific for main thread
|
|
|
|
struct MainThread : public Thread {
|
|
|
|
using Thread::Thread;
|
|
|
|
void search() override;
|
|
void check_time();
|
|
|
|
bool failedLow;
|
|
double bestMoveChanges, previousTimeReduction;
|
|
Value previousScore;
|
|
int callsCnt;
|
|
};
|
|
|
|
|
|
/// 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, ponder, stopOnPonderhit;
|
|
|
|
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
|