kate/BadFish
1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-07-11 19:49:14 +00:00
Code Issues Releases Wiki Activity

Rename ThreadsManager to ThreadPool

Browse source 
It is a more standard naming convention.

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
This commit is contained in:
Marco Costalba 2012-06-24 09:30:40 +01:00
parent 5f5d056c8f
commit 960a689769
2 changed files with 28 additions and 27 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

43
src/thread.cpp
View file

@ -27,7 +27,7 @@
using namespace Search; using namespace Search;
ThreadsManager Threads; // Global object ThreadPool Threads; // Global object
namespace { extern "C" { namespace { extern "C" {
@ -199,7 +199,7 @@ bool Thread::is_available_to(Thread* master) const {
// a c'tor becuase Threads is a static object and we need a fully initialized // a c'tor becuase Threads is a static object and we need a fully initialized
// engine at this point due to allocation of endgames in Thread c'tor. // engine at this point due to allocation of endgames in Thread c'tor.
void ThreadsManager::init() { void ThreadPool::init() {
cond_init(sleepCond); cond_init(sleepCond);
lock_init(splitLock); lock_init(splitLock);
@ -211,7 +211,7 @@ void ThreadsManager::init() {
// d'tor cleanly terminates the threads when the program exits. // d'tor cleanly terminates the threads when the program exits.
ThreadsManager::~ThreadsManager() { ThreadPool::~ThreadPool() {
for (int i = 0; i < size(); i++) for (int i = 0; i < size(); i++)
delete threads[i]; delete threads[i];
@ -227,7 +227,7 @@ ThreadsManager::~ThreadsManager() {
// objects are dynamically allocated to avoid creating in advance all possible // objects are dynamically allocated to avoid creating in advance all possible
// threads, with included pawns and material tables, if only few are used. // threads, with included pawns and material tables, if only few are used.
void ThreadsManager::read_uci_options() { void ThreadPool::read_uci_options() {
maxThreadsPerSplitPoint = Options["Max Threads per Split Point"]; maxThreadsPerSplitPoint = Options["Max Threads per Split Point"];
minimumSplitDepth = Options["Min Split Depth"] * ONE_PLY; minimumSplitDepth = Options["Min Split Depth"] * ONE_PLY;
@ -251,7 +251,7 @@ void ThreadsManager::read_uci_options() {
// on the sleep condition and to reset maxPly. When useSleepingThreads is set // on the sleep condition and to reset maxPly. When useSleepingThreads is set
// threads will be woken up at split time. // threads will be woken up at split time.
void ThreadsManager::wake_up() const { void ThreadPool::wake_up() const {
for (int i = 0; i < size(); i++) for (int i = 0; i < size(); i++)
{ {
@ -267,7 +267,7 @@ void ThreadsManager::wake_up() const {
// sleep() is called after the search finishes to ask all the threads but the // sleep() is called after the search finishes to ask all the threads but the
// main one to go waiting on a sleep condition. // main one to go waiting on a sleep condition.
void ThreadsManager::sleep() const { void ThreadPool::sleep() const {
for (int i = 1; i < size(); i++) // Main thread will go to sleep by itself for (int i = 1; i < size(); i++) // Main thread will go to sleep by itself
threads[i]->do_sleep = true; // to avoid a race with start_searching() threads[i]->do_sleep = true; // to avoid a race with start_searching()
@ -277,7 +277,7 @@ void ThreadsManager::sleep() const {
// available_slave_exists() tries to find an idle thread which is available as // available_slave_exists() tries to find an idle thread which is available as
// a slave for the thread 'master'. // a slave for the thread 'master'.
bool ThreadsManager::available_slave_exists(Thread* master) const { bool ThreadPool::available_slave_exists(Thread* master) const {
for (int i = 0; i < size(); i++) for (int i = 0; i < size(); i++)
if (threads[i]->is_available_to(master)) if (threads[i]->is_available_to(master))
@ -297,9 +297,10 @@ bool ThreadsManager::available_slave_exists(Thread* master) const {
// search(). When all threads have returned from search() then split() returns. // search(). When all threads have returned from search() then split() returns.
template <bool Fake> template <bool Fake>
Value ThreadsManager::split(Position& pos, Stack* ss, Value alpha, Value beta, Value ThreadPool::split(Position& pos, Stack* ss, Value alpha, Value beta,
Value bestValue, Move* bestMove, Depth depth, Value bestValue, Move* bestMove, Depth depth,
Move threatMove, int moveCount, MovePicker* mp, int nodeType) { Move threatMove, int moveCount, MovePicker* mp, int nodeType) {
assert(pos.pos_is_ok()); assert(pos.pos_is_ok());
assert(bestValue > -VALUE_INFINITE); assert(bestValue > -VALUE_INFINITE);
assert(bestValue <= alpha); assert(bestValue <= alpha);
@ -395,14 +396,14 @@ Value ThreadsManager::split(Position& pos, Stack* ss, Value alpha, Value beta,
} }
// Explicit template instantiations // Explicit template instantiations
template Value ThreadsManager::split<false>(Position&, Stack*, Value, Value, Value, Move*, Depth, Move, int, MovePicker*, int); template Value ThreadPool::split<false>(Position&, Stack*, Value, Value, Value, Move*, Depth, Move, int, MovePicker*, int);
template Value ThreadsManager::split<true>(Position&, Stack*, Value, Value, Value, Move*, Depth, Move, int, MovePicker*, int); template Value ThreadPool::split<true>(Position&, Stack*, Value, Value, Value, Move*, Depth, Move, int, MovePicker*, int);
// ThreadsManager::set_timer() is used to set the timer to trigger after msec // set_timer() is used to set the timer to trigger after msec milliseconds.
// milliseconds. If msec is 0 then timer is stopped. // If msec is 0 then timer is stopped.
void ThreadsManager::set_timer(int msec) { void ThreadPool::set_timer(int msec) {
lock_grab(timer->sleepLock); lock_grab(timer->sleepLock);
timer->maxPly = msec; timer->maxPly = msec;
@ -411,10 +412,10 @@ void ThreadsManager::set_timer(int msec) {
} }
// ThreadsManager::wait_for_search_finished() waits for main thread to go to // wait_for_search_finished() waits for main thread to go to sleep, this means
// sleep, this means search is finished. Then returns. // search is finished. Then returns.
void ThreadsManager::wait_for_search_finished() { void ThreadPool::wait_for_search_finished() {
Thread* t = main_thread(); Thread* t = main_thread();
lock_grab(t->sleepLock); lock_grab(t->sleepLock);
@ -424,10 +425,10 @@ void ThreadsManager::wait_for_search_finished() {
} }
// ThreadsManager::start_searching() wakes up the main thread sleeping in // start_searching() wakes up the main thread sleeping in main_loop() so to start
// main_loop() so to start a new search, then returns immediately. // a new search, then returns immediately.
void ThreadsManager::start_searching(const Position& pos, const LimitsType& limits, void ThreadPool::start_searching(const Position& pos, const LimitsType& limits,
const std::vector<Move>& searchMoves) { const std::vector<Move>& searchMoves) {
wait_for_search_finished(); wait_for_search_finished();

12
src/thread.h
View file

@ -102,18 +102,18 @@ public:
}; };
/// ThreadsManager class handles all the threads related stuff like init, starting, /// ThreadPool class handles all the threads related stuff like init, starting,
/// parking and, the most important, launching a slave thread at a split point. /// parking and, the most important, launching a slave thread at a split point.
/// All the access to shared thread data is done through this class. /// All the access to shared thread data is done through this class.
class ThreadsManager { class ThreadPool {
/* As long as the single ThreadsManager object is defined as a global we don't /* As long as the single ThreadPool object is defined as a global we don't
need to explicitly initialize to zero its data members because variables with need to explicitly initialize to zero its data members because variables with
static storage duration are automatically set to zero before enter main() static storage duration are automatically set to zero before enter main()
*/ */
public: public:
void init(); // No c'tor becuase Threads is static and we need engine initialized void init(); // No c'tor becuase Threads is global and we need engine initialized
~ThreadsManager(); ~ThreadPool();
Thread& operator[](int id) { return *threads[id]; } Thread& operator[](int id) { return *threads[id]; }
bool use_sleeping_threads() const { return useSleepingThreads; } bool use_sleeping_threads() const { return useSleepingThreads; }
@ -145,6 +145,6 @@ private:
bool useSleepingThreads; bool useSleepingThreads;
}; };
extern ThreadsManager Threads; extern ThreadPool Threads;
#endif // !defined(THREAD_H_INCLUDED) #endif // !defined(THREAD_H_INCLUDED)