mirror of
https://github.com/official-stockfish/Stockfish.git
synced 2026-07-23 05:07:14 +00:00
Steinar H. Gunderson
f0793a2080
This is a rather involved merge, since the cluster changes interact fairly badly with the refactoring we're merging: The new code wants the search to know nothing at all about the UCI protocol, it just calls a callback with some worker information (including a Position), which then transforms that information into a InfoFull which is then sent through another callback, upon which UCIEngine converts it to UCI and writes it to stdout. On the other hand, the MPI information wants to exchange PVs between workers at this point, and it wants to use the UCI string as the primary medium of exchange. Position is a lot of work to serialize, so we choose a middle road; we capture the InfoFull by switching out the callback, serializes it, does the MPI exchange on that, unserializes it and then continues with the print callback (if there is new information).
122 lines
3.8 KiB
C++
122 lines
3.8 KiB
C++
/*
|
|
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
|
|
Copyright (C) 2004-2024 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 <cstddef>
|
|
#include <cstdint>
|
|
#include <memory>
|
|
#include <mutex>
|
|
#include <vector>
|
|
|
|
#include "movepick.h"
|
|
#include "position.h"
|
|
#include "search.h"
|
|
#include "thread_win32_osx.h"
|
|
|
|
namespace Stockfish {
|
|
|
|
|
|
class OptionsMap;
|
|
using Value = int;
|
|
|
|
// Abstraction of a thread. It contains a pointer to the worker and a native thread.
|
|
// After construction, the native thread is started with idle_loop()
|
|
// waiting for a signal to start searching.
|
|
// When the signal is received, the thread starts searching and when
|
|
// the search is finished, it goes back to idle_loop() waiting for a new signal.
|
|
class Thread {
|
|
public:
|
|
Thread(Search::SharedState&, std::unique_ptr<Search::ISearchManager>, size_t);
|
|
virtual ~Thread();
|
|
|
|
void idle_loop();
|
|
void start_searching();
|
|
void wait_for_search_finished();
|
|
size_t id() const { return idx; }
|
|
|
|
std::unique_ptr<Search::Worker> worker;
|
|
|
|
private:
|
|
std::mutex mutex;
|
|
std::condition_variable cv;
|
|
size_t idx, nthreads;
|
|
bool exit = false, searching = true; // Set before starting std::thread
|
|
NativeThread stdThread;
|
|
};
|
|
|
|
|
|
// 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.
|
|
class ThreadPool {
|
|
|
|
public:
|
|
~ThreadPool() {
|
|
// destroy any existing thread(s)
|
|
if (threads.size() > 0)
|
|
{
|
|
main_thread()->wait_for_search_finished();
|
|
|
|
while (threads.size() > 0)
|
|
delete threads.back(), threads.pop_back();
|
|
}
|
|
}
|
|
|
|
void start_thinking(const OptionsMap&, Position&, StateListPtr&, Search::LimitsType);
|
|
void clear();
|
|
void set(Search::SharedState, Search::SearchManager::UpdateContext&);
|
|
|
|
Search::SearchManager* main_manager();
|
|
Thread* main_thread() const { return threads.front(); }
|
|
uint64_t nodes_searched() const;
|
|
uint64_t tb_hits() const;
|
|
uint64_t TT_saves() const;
|
|
Thread* get_best_thread() const;
|
|
void start_searching();
|
|
void wait_for_search_finished() const;
|
|
|
|
std::atomic_bool stop, abortedSearch, increaseDepth;
|
|
|
|
auto cbegin() const noexcept { return threads.cbegin(); }
|
|
auto begin() noexcept { return threads.begin(); }
|
|
auto end() noexcept { return threads.end(); }
|
|
auto cend() const noexcept { return threads.cend(); }
|
|
auto size() const noexcept { return threads.size(); }
|
|
auto empty() const noexcept { return threads.empty(); }
|
|
|
|
private:
|
|
StateListPtr setupStates;
|
|
std::vector<Thread*> threads;
|
|
|
|
uint64_t accumulate(std::atomic<uint64_t> Search::Worker::* member) const {
|
|
|
|
uint64_t sum = 0;
|
|
for (Thread* th : threads)
|
|
sum += (th->worker.get()->*member).load(std::memory_order_relaxed);
|
|
return sum;
|
|
}
|
|
};
|
|
|
|
} // namespace Stockfish
|
|
|
|
#endif // #ifndef THREAD_H_INCLUDED
|