mirror of
https://github.com/sockspls/badfish
synced 2025-05-03 10:09:35 +00:00
ed436a36ba
This patch removes the UCI option for setting Contempt in classical evaluation. It is exactly equivalent to using Contempt=0 for the UCI contempt value and keeping the dynamic part in the algo (renaming this dynamic part `trend` to better describe what it does). We have tried quite hard to implement a working Contempt feature for NNUE but nothing really worked, so it is probably time to give up. Interested chess fans wishing to keep playing with the UCI option for Contempt and use it with the classical eval are urged to download the version tagged "SF_Classical" of Stockfish (dated 31 July 2020), as it was the last version where our search algorithm was tuned for the classical eval and is probably our strongest classical player ever: https://github.com/official-stockfish/Stockfish/tags Passed STC: LLR: 2.95 (-2.94,2.94) <-2.50,0.50> Total: 72904 W: 6228 L: 6175 D: 60501 Ptnml(0-2): 221, 5006, 25971, 5007, 247 https://tests.stockfishchess.org/tests/view/60c98bf9457376eb8bcab18d Passed LTC: LLR: 2.93 (-2.94,2.94) <-2.50,0.50> Total: 45168 W: 1601 L: 1547 D: 42020 Ptnml(0-2): 38, 1331, 19786, 1397, 32 https://tests.stockfishchess.org/tests/view/60c9c7fa457376eb8bcab1bb closes https://github.com/official-stockfish/Stockfish/pull/3575 Bench: 4947716
134 lines
3.6 KiB
C++
134 lines
3.6 KiB
C++
/*
|
|
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
|
|
Copyright (C) 2004-2021 The Stockfish developers (see AUTHORS file)
|
|
|
|
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"
|
|
|
|
namespace Stockfish {
|
|
|
|
/// 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 {
|
|
|
|
std::mutex mutex;
|
|
std::condition_variable 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();
|
|
size_t id() const { return idx; }
|
|
|
|
Pawns::Table pawnsTable;
|
|
Material::Table materialTable;
|
|
size_t pvIdx, pvLast;
|
|
uint64_t ttHitAverage;
|
|
int selDepth, nmpMinPly;
|
|
Color nmpColor;
|
|
std::atomic<uint64_t> nodes, tbHits, bestMoveChanges;
|
|
|
|
Position rootPos;
|
|
StateInfo rootState;
|
|
Search::RootMoves rootMoves;
|
|
Depth rootDepth, completedDepth;
|
|
CounterMoveHistory counterMoves;
|
|
ButterflyHistory mainHistory;
|
|
LowPlyHistory lowPlyHistory;
|
|
CapturePieceToHistory captureHistory;
|
|
ContinuationHistory continuationHistory[2][2];
|
|
Score trend;
|
|
};
|
|
|
|
|
|
/// 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 bestPreviousScore;
|
|
Value iterValue[4];
|
|
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); }
|
|
Thread* get_best_thread() const;
|
|
void start_searching();
|
|
void wait_for_search_finished() const;
|
|
|
|
std::atomic_bool stop, increaseDepth;
|
|
|
|
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;
|
|
|
|
} // namespace Stockfish
|
|
|
|
#endif // #ifndef THREAD_H_INCLUDED
|