Subversion Repositories Games.Chess Giants

Rev

Rev 96 | Rev 169 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 96 Rev 154
Line 20... Line 20...
20 
 
 20 
 
21 
#ifndef SEARCH_H_INCLUDED
 21 
#ifndef SEARCH_H_INCLUDED
22 
#define SEARCH_H_INCLUDED
 22 
#define SEARCH_H_INCLUDED
23 
 
 23 
 
24 
#include <atomic>
 24 
#include <atomic>
25 
#include <memory>  // For std::unique_ptr
 - 
 
26 
#include <stack>
 - 
 
27 
#include <vector>
 25 
#include <vector>
28 
 
 26 
 
29 
#include "misc.h"
 27 
#include "misc.h"
30 
#include "position.h"
 28 
#include "movepick.h"
31 
#include "types.h"
 29 
#include "types.h"
- 
 
 30 
 
- 
 
 31 
class Position;
32 
 
 32 
 
33 
namespace Search {
 33 
namespace Search {
34 
 
 34 
 
35 
/// Stack struct keeps track of the information we need to remember from nodes
 35 
/// Stack struct keeps track of the information we need to remember from nodes
36 
/// shallower and deeper in the tree during the search. Each search thread has
 36 
/// shallower and deeper in the tree during the search. Each search thread has
Line 41... Line 41...
41 
  int ply;
 41 
  int ply;
42 
  Move currentMove;
 42 
  Move currentMove;
43 
  Move excludedMove;
 43 
  Move excludedMove;
44 
  Move killers[2];
 44 
  Move killers[2];
45 
  Value staticEval;
 45 
  Value staticEval;
- 
 
 46 
  Value history;
46 
  bool skipEarlyPruning;
 47 
  bool skipEarlyPruning;
47 
  int moveCount;
 48 
  int moveCount;
- 
 
 49 
  CounterMoveStats* counterMoves;
48 
};
 50 
};
- 
 
 51 
 
49 
 
 52 
 
50 
/// RootMove struct is used for moves at the root of the tree. For each root move
 53 
/// RootMove struct is used for moves at the root of the tree. For each root move
51 
/// we store a score and a PV (really a refutation in the case of moves which
 54 
/// we store a score and a PV (really a refutation in the case of moves which
52 
/// fail low). Score is normally set at -VALUE_INFINITE for all non-pv moves.
 55 
/// fail low). Score is normally set at -VALUE_INFINITE for all non-pv moves.
53 
 
 56 
 
Line 55... Line 58...
55 
 
 58 
 
56 
  explicit RootMove(Move m) : pv(1, m) {}
 59 
  explicit RootMove(Move m) : pv(1, m) {}
57 
 
 60 
 
58 
  bool operator<(const RootMove& m) const { return m.score < score; } // Descending sort
 61 
  bool operator<(const RootMove& m) const { return m.score < score; } // Descending sort
59 
  bool operator==(const Move& m) const { return pv[0] == m; }
 62 
  bool operator==(const Move& m) const { return pv[0] == m; }
60 
  void insert_pv_in_tt(Position& pos);
 - 
 
61 
  bool extract_ponder_from_tt(Position& pos);
 63 
  bool extract_ponder_from_tt(Position& pos);
62 
 
 64 
 
63 
  Value score = -VALUE_INFINITE;
 65 
  Value score = -VALUE_INFINITE;
64 
  Value previousScore = -VALUE_INFINITE;
 66 
  Value previousScore = -VALUE_INFINITE;
65 
  std::vector<Move> pv;
 67 
  std::vector<Move> pv;
66 
};
 68 
};
67 
 
 69 
 
68 
typedef std::vector<RootMove> RootMoveVector;
 70 
typedef std::vector<RootMove> RootMoves;
- 
 
 71 
 
69 
 
 72 
 
70 
/// LimitsType struct stores information sent by GUI about available time to
 73 
/// LimitsType struct stores information sent by GUI about available time to
71 
/// search the current move, maximum depth/time, if we are in analysis mode or
 74 
/// search the current move, maximum depth/time, if we are in analysis mode or
72 
/// if we have to ponder while it's our opponent's turn to move.
 75 
/// if we have to ponder while it's our opponent's turn to move.
73 
 
 76 
 
74 
struct LimitsType {
 77 
struct LimitsType {
75 
 
 78 
 
76 
  LimitsType() { // Init explicitly due to broken value-initialization of non POD in MSVC
 79 
  LimitsType() { // Init explicitly due to broken value-initialization of non POD in MSVC
77 
    nodes = time[WHITE] = time[BLACK] = inc[WHITE] = inc[BLACK] = npmsec = movestogo =
 80 
    nodes = time[WHITE] = time[BLACK] = inc[WHITE] = inc[BLACK] =
78 
    depth = movetime = mate = infinite = ponder = 0;
 81 
    npmsec = movestogo = depth = movetime = mate = infinite = ponder = 0;
79 
  }
 82 
  }
80 
 
 83 
 
81 
  bool use_time_management() const {
 84 
  bool use_time_management() const {
82 
    return !(mate | movetime | depth | nodes | infinite);
 85 
    return !(mate | movetime | depth | nodes | infinite);
83 
  }
 86 
  }
Line 86... Line 89...
86 
  int time[COLOR_NB], inc[COLOR_NB], npmsec, movestogo, depth, movetime, mate, infinite, ponder;
 89 
  int time[COLOR_NB], inc[COLOR_NB], npmsec, movestogo, depth, movetime, mate, infinite, ponder;
87 
  int64_t nodes;
 90 
  int64_t nodes;
88 
  TimePoint startTime;
 91 
  TimePoint startTime;
89 
};
 92 
};
90 
 
 93 
 
- 
 
 94 
 
91 
/// The SignalsType struct stores atomic flags updated during the search
 95 
/// SignalsType struct stores atomic flags updated during the search, typically
92 
/// typically in an async fashion e.g. to stop the search by the GUI.
 96 
/// in an async fashion e.g. to stop the search by the GUI.
93 
 
 97 
 
94 
struct SignalsType {
 98 
struct SignalsType {
95 
  std::atomic_bool stop, stopOnPonderhit;
 99 
  std::atomic_bool stop, stopOnPonderhit;
96 
};
 100 
};
97 
 
 - 
 
98 
typedef std::unique_ptr<std::stack<StateInfo>> StateStackPtr;
 - 
 
99 
 
 101 
 
100 
extern SignalsType Signals;
 102 
extern SignalsType Signals;
101 
extern LimitsType Limits;
 103 
extern LimitsType Limits;
102 
extern StateStackPtr SetupStates;
 - 
 
103 
 
 104 
 
104 
void init();
 105 
void init();
105 
void clear();
 106 
void clear();
106 
template<bool Root = true> uint64_t perft(Position& pos, Depth depth);
 107 
template<bool Root = true> uint64_t perft(Position& pos, Depth depth);
107 
 
 108