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;
36 // Const data after split point has been setup
38 const Search::Stack* ss;
45 // Const pointers to shared data
51 volatile uint64_t slavesMask;
52 volatile int64_t nodes;
54 volatile Value bestValue;
55 volatile Move bestMove;
56 volatile int moveCount;
61 /// Thread struct keeps together all the thread related stuff like locks, state
62 /// and especially split points. We also use per-thread pawn and material hash
63 /// tables so that once we get a pointer to an entry its life time is unlimited
64 /// and we don't have to care about someone changing the entry under our feet.
68 Thread(const Thread&); // Only declared to disable the default ones
69 Thread& operator=(const Thread&); // that are not suitable in this case.
71 typedef void (Thread::* Fn) ();
78 bool cutoff_occurred() const;
79 bool is_available_to(int master) const;
80 void idle_loop(SplitPoint* sp_master);
81 void idle_loop() { idle_loop(NULL); } // Hack to allow storing in start_fn
84 void wait_for_stop_or_ponderhit();
86 SplitPoint splitPoints[MAX_SPLITPOINTS_PER_THREAD];
87 MaterialTable materialTable;
92 WaitCondition sleepCond;
95 SplitPoint* volatile curSplitPoint;
96 volatile int splitPointsCnt;
97 volatile bool is_searching;
98 volatile bool do_sleep;
99 volatile bool do_exit;
103 /// ThreadsManager class handles all the threads related stuff like init, starting,
104 /// parking and, the most important, launching a slave thread at a split point.
105 /// All the access to shared thread data is done through this class.
107 class ThreadsManager {
108 /* As long as the single ThreadsManager object is defined as a global we don't
109 need to explicitly initialize to zero its data members because variables with
110 static storage duration are automatically set to zero before enter main()
113 void init(); // No c'tor becuase Threads is static and we need engine initialized
116 Thread& operator[](int id) { return *threads[id]; }
117 bool use_sleeping_threads() const { return useSleepingThreads; }
118 int min_split_depth() const { return minimumSplitDepth; }
119 int size() const { return (int)threads.size(); }
121 void wake_up() const;
123 void read_uci_options();
124 bool available_slave_exists(int master) const;
125 void set_timer(int msec);
126 void wait_for_search_finished();
127 void start_searching(const Position& pos, const Search::LimitsType& limits,
128 const std::vector<Move>& searchMoves);
131 Value split(Position& pos, Search::Stack* ss, Value alpha, Value beta, Value bestValue, Move* bestMove,
132 Depth depth, Move threatMove, int moveCount, MovePicker* mp, int nodeType);
136 std::vector<Thread*> threads;
139 WaitCondition sleepCond;
140 Depth minimumSplitDepth;
141 int maxThreadsPerSplitPoint;
142 bool useSleepingThreads;
145 extern ThreadsManager Threads;
147 #endif // !defined(THREAD_H_INCLUDED)