Subversion Repositories Games.Chess Giants

Rev

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

Rev 154 Rev 169
Line 4... Line 4...
4 
  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
 4 
  Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
5 
  Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
 5 
  Copyright (C) 2015-2018 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad
6 
 
 6 
 
7 
  Stockfish is free software: you can redistribute it and/or modify
 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
 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
 9 
  the Free Software Foundation, either version 3 of the License, or
10 
  (at your option) any later version.
 10 
  (at your option) any later version.
Line 19... Line 19...
19 
*/
 19 
*/
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>
 - 
 
25 
#include <vector>
 24 
#include <vector>
26 
 
 25 
 
27 
#include "misc.h"
 26 
#include "misc.h"
28 
#include "movepick.h"
 27 
#include "movepick.h"
29 
#include "types.h"
 28 
#include "types.h"
30 
 
 29 
 
31 
class Position;
 30 
class Position;
32 
 
 31 
 
33 
namespace Search {
 32 
namespace Search {
- 
 
 33 
 
- 
 
 34 
/// Threshold used for countermoves based pruning
- 
 
 35 
const int CounterMovePruneThreshold = 0;
- 
 
 36 
 
34 
 
 37 
 
35 
/// Stack struct keeps track of the information we need to remember from nodes
 38 
/// 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
 39 
/// shallower and deeper in the tree during the search. Each search thread has
37 
/// its own array of Stack objects, indexed by the current ply.
 40 
/// its own array of Stack objects, indexed by the current ply.
38 
 
 41 
 
39 
struct Stack {
 42 
struct Stack {
40 
  Move* pv;
 43 
  Move* pv;
- 
 
 44 
  PieceToHistory* contHistory;
41 
  int ply;
 45 
  int ply;
42 
  Move currentMove;
 46 
  Move currentMove;
43 
  Move excludedMove;
 47 
  Move excludedMove;
44 
  Move killers[2];
 48 
  Move killers[2];
45 
  Value staticEval;
 49 
  Value staticEval;
46 
  Value history;
 50 
  int statScore;
47 
  bool skipEarlyPruning;
 - 
 
48 
  int moveCount;
 51 
  int moveCount;
49 
  CounterMoveStats* counterMoves;
 - 
 
50 
};
 52 
};
51 
 
 53 
 
52 
 
 54 
 
53 
/// RootMove struct is used for moves at the root of the tree. For each root move
 55 
/// RootMove struct is used for moves at the root of the tree. For each root move
54 
/// we store a score and a PV (really a refutation in the case of moves which
 56 
/// we store a score and a PV (really a refutation in the case of moves which
55 
/// fail low). Score is normally set at -VALUE_INFINITE for all non-pv moves.
 57 
/// fail low). Score is normally set at -VALUE_INFINITE for all non-pv moves.
56 
 
 58 
 
57 
struct RootMove {
 59 
struct RootMove {
58 
 
 60 
 
59 
  explicit RootMove(Move m) : pv(1, m) {}
 61 
  explicit RootMove(Move m) : pv(1, m) {}
60 
 
 - 
 
61 
  bool operator<(const RootMove& m) const { return m.score < score; } // Descending sort
 62 
  bool extract_ponder_from_tt(Position& pos);
62 
  bool operator==(const Move& m) const { return pv[0] == m; }
 63 
  bool operator==(const Move& m) const { return pv[0] == m; }
- 
 
 64 
  bool operator<(const RootMove& m) const { // Sort in descending order
63 
  bool extract_ponder_from_tt(Position& pos);
 65 
    return m.score != score ? m.score < score
- 
 
 66 
                            : m.previousScore < previousScore;
- 
 
 67 
  }
64 
 
 68 
 
65 
  Value score = -VALUE_INFINITE;
 69 
  Value score = -VALUE_INFINITE;
66 
  Value previousScore = -VALUE_INFINITE;
 70 
  Value previousScore = -VALUE_INFINITE;
- 
 
 71 
  int selDepth = 0;
67 
  std::vector<Move> pv;
 72 
  std::vector<Move> pv;
68 
};
 73 
};
69 
 
 74 
 
70 
typedef std::vector<RootMove> RootMoves;
 75 
typedef std::vector<RootMove> RootMoves;
71 
 
 76 
 
72 
 
 77 
 
73 
/// LimitsType struct stores information sent by GUI about available time to
 78 
/// LimitsType struct stores information sent by GUI about available time to
74 
/// search the current move, maximum depth/time, if we are in analysis mode or
 79 
/// search the current move, maximum depth/time, or if we are in analysis mode.
75 
/// if we have to ponder while it's our opponent's turn to move.
 - 
 
76 
 
 80 
 
77 
struct LimitsType {
 81 
struct LimitsType {
78 
 
 82 
 
79 
  LimitsType() { // Init explicitly due to broken value-initialization of non POD in MSVC
 83 
  LimitsType() { // Init explicitly due to broken value-initialization of non POD in MSVC
80 
    nodes = time[WHITE] = time[BLACK] = inc[WHITE] = inc[BLACK] =
 84 
    nodes = time[WHITE] = time[BLACK] = inc[WHITE] = inc[BLACK] =
81 
    npmsec = movestogo = depth = movetime = mate = infinite = ponder = 0;
 85 
    npmsec = movestogo = depth = movetime = mate = perft = infinite = 0;
82 
  }
 86 
  }
83 
 
 87 
 
84 
  bool use_time_management() const {
 88 
  bool use_time_management() const {
85 
    return !(mate | movetime | depth | nodes | infinite);
 89 
    return !(mate | movetime | depth | nodes | perft | infinite);
86 
  }
 90 
  }
87 
 
 91 
 
88 
  std::vector<Move> searchmoves;
 92 
  std::vector<Move> searchmoves;
89 
  int time[COLOR_NB], inc[COLOR_NB], npmsec, movestogo, depth, movetime, mate, infinite, ponder;
 93 
  int time[COLOR_NB], inc[COLOR_NB], npmsec, movestogo, depth,
- 
 
 94 
      movetime, mate, perft, infinite;
90 
  int64_t nodes;
 95 
  int64_t nodes;
91 
  TimePoint startTime;
 96 
  TimePoint startTime;
92 
};
 97 
};
93 
 
 98 
 
94 
 
 - 
 
95 
/// SignalsType struct stores atomic flags updated during the search, typically
 - 
 
96 
/// in an async fashion e.g. to stop the search by the GUI.
 - 
 
97 
 
 - 
 
98 
struct SignalsType {
 - 
 
99 
  std::atomic_bool stop, stopOnPonderhit;
 - 
 
100 
};
 - 
 
101 
 
 - 
 
102 
extern SignalsType Signals;
 - 
 
103 
extern LimitsType Limits;
 99 
extern LimitsType Limits;
104 
 
 100 
 
105 
void init();
 101 
void init();
106 
void clear();
 102 
void clear();
107 
template<bool Root = true> uint64_t perft(Position& pos, Depth depth);
 - 
 
108 
 
 103 
 
109 
} // namespace Search
 104 
} // namespace Search
110 
 
 105 
 
111 
#endif // #ifndef SEARCH_H_INCLUDED
 106 
#endif // #ifndef SEARCH_H_INCLUDED