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;
60 volatile bool allSlavesRunning;
64 /// Thread struct keeps together all the thread related stuff like locks, state
65 /// and especially split points. We also use per-thread pawn and material hash
66 /// tables so that once we get a pointer to an entry its life time is unlimited
67 /// and we don't have to care about someone changing the entry under our feet.
71 Thread(const Thread&); // Only declared to disable the default ones
72 Thread& operator=(const Thread&); // that are not suitable in this case.
74 typedef void (Thread::* Fn) ();
81 bool cutoff_occurred() const;
82 bool is_available_to(Thread* master) const;
83 void idle_loop(SplitPoint* sp_master);
84 void idle_loop() { idle_loop(NULL); } // Hack to allow storing in start_fn
87 void wait_for_stop_or_ponderhit();
89 SplitPoint splitPoints[MAX_SPLITPOINTS_PER_THREAD];
90 MaterialTable materialTable;
95 WaitCondition sleepCond;
98 SplitPoint* volatile curSplitPoint;
99 volatile int splitPointsCnt;
100 volatile bool is_searching;
101 volatile bool do_sleep;
102 volatile bool do_exit;
106 /// ThreadsManager class handles all the threads related stuff like init, starting,
107 /// parking and, the most important, launching a slave thread at a split point.
108 /// All the access to shared thread data is done through this class.
110 class ThreadsManager {
111 /* As long as the single ThreadsManager object is defined as a global we don't
112 need to explicitly initialize to zero its data members because variables with
113 static storage duration are automatically set to zero before enter main()
116 void init(); // No c'tor becuase Threads is static and we need engine initialized
119 Thread& operator[](int id) { return *threads[id]; }
120 bool use_sleeping_threads() const { return useSleepingThreads; }
121 int min_split_depth() const { return minimumSplitDepth; }
122 int size() const { return (int)threads.size(); }
123 Thread* main_thread() { return threads[0]; }
125 void wake_up() const;
127 void read_uci_options();
128 bool available_slave_exists(Thread* master) const;
129 void set_timer(int msec);
130 void wait_for_search_finished();
131 void start_searching(const Position& pos, const Search::LimitsType& limits,
132 const std::vector<Move>& searchMoves);
135 Value split(Position& pos, Search::Stack* ss, Value alpha, Value beta, Value bestValue, Move* bestMove,
136 Depth depth, Move threatMove, int moveCount, MovePicker* mp, int nodeType);
140 std::vector<Thread*> threads;
143 WaitCondition sleepCond;
144 Depth minimumSplitDepth;
145 int maxThreadsPerSplitPoint;
146 bool useSleepingThreads;
149 extern ThreadsManager Threads;
151 #endif // !defined(THREAD_H_INCLUDED)