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