mirror of
https://github.com/opelly27/Stockfish.git
synced 2026-05-20 05:07:46 +00:00
Joost VandeVondele
5410424e3d
Limits::ponder was used as a signal between uci and search threads,
but is not an atomic variable, leading to the following race as
flagged by a sanitized binary.
Expect input:
```
spawn ./stockfish
send "uci\n"
expect "uciok"
send "setoption name Ponder value true\n"
send "go wtime 4000 btime 4000\n"
expect "bestmove"
send "position startpos e2e4 d7d5\n"
send "go wtime 4000 btime 4000 ponder\n"
sleep 0.01
send "ponderhit\n"
expect "bestmove"
send "quit\n"
expect eof
```
Race:
```
WARNING: ThreadSanitizer: data race (pid=7191)
Read of size 4 at 0x0000005c2260 by thread T1:
Previous write of size 4 at 0x0000005c2260 by main thread:
Location is global 'Search::Limits' of size 88 at 0x0000005c2220 (stockfish+0x0000005c2260)
```
The reason of teh race is that ponder is not just set in UCI go()
assignment but also is signaled by an async ponderhit in uci.cpp:
else if (token == "ponderhit")
Search::Limits.ponder = 0; // Switch to normal search
The fix is to add an atomic bool to the threads structure to
signal the ponder status, letting Search::Limits to reflect just
what was passed to 'go'.
No functional change.
113 lines
3.2 KiB
C++
113 lines
3.2 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-2017 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 struct keeps together all the thread-related stuff. We also 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::thread nativeThread;
|
|
Mutex mutex;
|
|
ConditionVariable sleepCondition;
|
|
bool exit, searching;
|
|
|
|
public:
|
|
Thread();
|
|
virtual ~Thread();
|
|
virtual void search();
|
|
void idle_loop();
|
|
void start_searching(bool resume = false);
|
|
void wait_for_search_finished();
|
|
void wait(std::atomic_bool& condition);
|
|
|
|
Pawns::Table pawnsTable;
|
|
Material::Table materialTable;
|
|
Endgames endgames;
|
|
size_t idx, PVIdx;
|
|
int selDepth;
|
|
std::atomic<uint64_t> nodes, tbHits;
|
|
|
|
Position rootPos;
|
|
Search::RootMoves rootMoves;
|
|
Depth rootDepth;
|
|
Depth completedDepth;
|
|
CounterMoveHistory counterMoves;
|
|
ButterflyHistory mainHistory;
|
|
ContinuationHistory contHistory;
|
|
};
|
|
|
|
|
|
/// MainThread is a derived class with a specific overload for the main thread
|
|
|
|
struct MainThread : public Thread {
|
|
virtual void search();
|
|
void check_time();
|
|
|
|
bool easyMovePlayed, failedLow;
|
|
double bestMoveChanges;
|
|
Value previousScore;
|
|
int callsCnt = 0;
|
|
};
|
|
|
|
|
|
/// ThreadPool struct handles all the threads-related stuff like init, starting,
|
|
/// parking and, most importantly, launching a thread. All the access to threads
|
|
/// data is done through this class.
|
|
|
|
struct ThreadPool : public std::vector<Thread*> {
|
|
|
|
void init(); // No constructor and destructor, threads rely on globals that should
|
|
void exit(); // be initialized and valid during the whole thread lifetime.
|
|
|
|
MainThread* main() { return static_cast<MainThread*>(at(0)); }
|
|
void start_thinking(Position&, StateListPtr&, const Search::LimitsType&);
|
|
void read_uci_options();
|
|
uint64_t nodes_searched() const;
|
|
uint64_t tb_hits() const;
|
|
|
|
std::atomic_bool stop, ponder, stopOnPonderhit;
|
|
|
|
private:
|
|
StateListPtr setupStates;
|
|
};
|
|
|
|
extern ThreadPool Threads;
|
|
|
|
#endif // #ifndef THREAD_H_INCLUDED
|