Subversion Repositories Games.Chess Giants

Rev

Rev 154 | Go to most recent revision | Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
96 pmbaty 1
/*
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-2015 Marco Costalba, Joona Kiiski, Tord Romstad
5
  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
6
 
7
  Stockfish is free software: you can redistribute it and/or modify
8
  it under the terms of the GNU General Public License as published by
9
  the Free Software Foundation, either version 3 of the License, or
10
  (at your option) any later version.
11
 
12
  Stockfish is distributed in the hope that it will be useful,
13
  but WITHOUT ANY WARRANTY; without even the implied warranty of
14
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
  GNU General Public License for more details.
16
 
17
  You should have received a copy of the GNU General Public License
18
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
19
*/
20
 
21
#ifndef THREAD_H_INCLUDED
22
#define THREAD_H_INCLUDED
23
 
24
#include <atomic>
25
#include <bitset>
26
#include <condition_variable>
27
#include <mutex>
28
#include <thread>
29
#include <vector>
30
 
31
#include "material.h"
32
#include "movepick.h"
33
#include "pawns.h"
34
#include "position.h"
35
#include "search.h"
36
#include "thread_win32.h"
37
 
38
 
39
/// Thread struct keeps together all the thread-related stuff. We also use
40
/// per-thread pawn and material hash tables so that once we get a pointer to an
41
/// entry its life time is unlimited and we don't have to care about someone
42
/// changing the entry under our feet.
43
 
44
class Thread {
45
 
46
  std::thread nativeThread;
47
  Mutex mutex;
48
  ConditionVariable sleepCondition;
49
  bool exit, searching;
50
 
51
public:
52
  Thread();
53
  virtual ~Thread();
54
  virtual void search();
55
  void idle_loop();
56
  void start_searching(bool resume = false);
57
  void wait_for_search_finished();
58
  void wait(std::atomic_bool& b);
59
 
60
  Pawns::Table pawnsTable;
61
  Material::Table materialTable;
62
  Endgames endgames;
63
  size_t idx, PVIdx;
64
  int maxPly, callsCnt;
65
 
66
  Position rootPos;
67
  Search::RootMoveVector rootMoves;
68
  Depth rootDepth;
69
  HistoryStats history;
70
  MoveStats counterMoves;
71
  Depth completedDepth;
72
  std::atomic_bool resetCalls;
73
};
74
 
75
 
76
/// MainThread is a derived class with a specific overload for the main thread
77
 
78
struct MainThread : public Thread {
79
  virtual void search();
80
 
81
  bool easyMovePlayed, failedLow;
82
  double bestMoveChanges;
83
  Value previousScore;
84
};
85
 
86
 
87
/// ThreadPool struct handles all the threads-related stuff like init, starting,
88
/// parking and, most importantly, launching a thread. All the access to threads
89
/// data is done through this class.
90
 
91
struct ThreadPool : public std::vector<Thread*> {
92
 
93
  void init(); // No constructor and destructor, threads rely on globals that should
94
  void exit(); // be initialized and valid during the whole thread lifetime.
95
 
96
  MainThread* main() { return static_cast<MainThread*>(at(0)); }
97
  void start_thinking(const Position&, const Search::LimitsType&, Search::StateStackPtr&);
98
  void read_uci_options();
99
  int64_t nodes_searched();
100
};
101
 
102
extern ThreadPool Threads;
103
 
104
#endif // #ifndef THREAD_H_INCLUDED