2 Stockfish, a UCI chess playing engine derived from Glaurung 2.1
3 Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
4 Copyright (C) 2008-2012 Marco Costalba, Joona Kiiski, Tord Romstad
6 Stockfish is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 Stockfish is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
20 #if !defined(THREAD_H_INCLUDED)
21 #define THREAD_H_INCLUDED
31 const int MAX_THREADS = 32;
32 const int MAX_SPLITPOINTS_PER_THREAD = 8;
38 // Const data after split point has been setup
40 const Search::Stack* ss;
47 // Const pointers to shared data
53 volatile uint64_t slavesMask;
54 volatile int64_t nodes;
56 volatile Value bestValue;
57 volatile Move bestMove;
58 volatile int moveCount;
63 /// Thread struct keeps together all the thread related stuff like locks, state
64 /// and especially split points. We also use per-thread pawn and material hash
65 /// tables so that once we get a pointer to an entry its life time is unlimited
66 /// and we don't have to care about someone changing the entry under our feet.
70 Thread(const Thread&); // Only declared to disable the default ones
71 Thread& operator=(const Thread&); // that are not suitable in this case.
73 typedef void (Thread::* Fn) ();
80 bool cutoff_occurred() const;
81 bool is_available_to(Thread* master) const;
82 void idle_loop(SplitPoint* sp_master);
83 void idle_loop() { idle_loop(NULL); } // Hack to allow storing in start_fn
86 void wait_for_stop_or_ponderhit();
88 SplitPoint splitPoints[MAX_SPLITPOINTS_PER_THREAD];
89 MaterialTable materialTable;
94 WaitCondition sleepCond;
97 SplitPoint* volatile curSplitPoint;
98 volatile int splitPointsCnt;
99 volatile bool is_searching;
100 volatile bool do_sleep;
101 volatile bool do_exit;
105 /// ThreadsManager class handles all the threads related stuff like init, starting,
106 /// parking and, the most important, launching a slave thread at a split point.
107 /// All the access to shared thread data is done through this class.
109 class ThreadsManager {
110 /* As long as the single ThreadsManager object is defined as a global we don't
111 need to explicitly initialize to zero its data members because variables with
112 static storage duration are automatically set to zero before enter main()
115 void init(); // No c'tor becuase Threads is static and we need engine initialized
118 Thread& operator[](int id) { return *threads[id]; }
119 bool use_sleeping_threads() const { return useSleepingThreads; }
120 int min_split_depth() const { return minimumSplitDepth; }
121 int size() const { return (int)threads.size(); }
122 Thread* main_thread() { return threads[0]; }
124 void wake_up() const;
126 void read_uci_options();
127 bool available_slave_exists(Thread* master) const;
128 void set_timer(int msec);
129 void wait_for_search_finished();
130 void start_searching(const Position& pos, const Search::LimitsType& limits,
131 const std::vector<Move>& searchMoves);
134 Value split(Position& pos, Search::Stack* ss, Value alpha, Value beta, Value bestValue, Move* bestMove,
135 Depth depth, Move threatMove, int moveCount, MovePicker* mp, int nodeType);
139 std::vector<Thread*> threads;
142 WaitCondition sleepCond;
143 Depth minimumSplitDepth;
144 int maxThreadsPerSplitPoint;
145 bool useSleepingThreads;
148 extern ThreadsManager Threads;
150 #endif // !defined(THREAD_H_INCLUDED)