#include <fstream>
#include <iostream>
#include <sstream>
+#include <vector>
#include "book.h"
#include "evaluate.h"
// RootMove struct is used for moves at the root at the tree. For each root
// move, we store two scores, a node count, and a PV (really a refutation
- // in the case of moves which fail low). Value pvScore is normally set at
- // -VALUE_INFINITE for all non-pv moves, while nonPvScore is computed
+ // in the case of moves which fail low). Value pv_score is normally set at
+ // -VALUE_INFINITE for all non-pv moves, while non_pv_score is computed
// according to the order in which moves are returned by MovePicker.
struct RootMove {
- RootMove() : nodes(0) { pvScore = nonPvScore = -VALUE_INFINITE; }
+ RootMove();
+ RootMove(const RootMove& rm) { *this = rm; }
+ RootMove& operator=(const RootMove& rm);
// RootMove::operator<() is the comparison function used when
// sorting the moves. A move m1 is considered to be better
- // than a move m2 if it has an higher pvScore, or if it has
- // equal pvScore but m1 has the higher nonPvScore. In this way
- // we are guaranteed that PV moves are always sorted as first.
+ // than a move m2 if it has an higher pv_score, or if it has
+ // equal pv_score but m1 has the higher non_pv_score. In this
+ // way we are guaranteed that PV moves are always sorted as first.
bool operator<(const RootMove& m) const {
- return pvScore != m.pvScore ? pvScore < m.pvScore : nonPvScore <= m.nonPvScore;
+ return pv_score != m.pv_score ? pv_score < m.pv_score
+ : non_pv_score <= m.non_pv_score;
}
+ void set_pv(const Move newPv[]);
- Move move;
- Value pvScore;
- Value nonPvScore;
int64_t nodes;
+ Value pv_score;
+ Value non_pv_score;
+ Move move;
Move pv[PLY_MAX_PLUS_2];
};
+ RootMove::RootMove() {
- // The RootMoveList class is essentially an array of RootMove objects, with
- // a handful of methods for accessing the data in the individual moves.
+ nodes = 0;
+ pv_score = non_pv_score = -VALUE_INFINITE;
+ move = pv[0] = MOVE_NONE;
+ }
- class RootMoveList {
+ RootMove& RootMove::operator=(const RootMove& rm) {
- public:
- RootMoveList(Position& pos, Move searchMoves[]);
+ nodes = rm.nodes;
+ pv_score = rm.pv_score;
+ non_pv_score = rm.non_pv_score;
+ move = rm.move;
+ set_pv(rm.pv); // Skip costly full pv[] copy
+ return *this;
+ }
+
+ void RootMove::set_pv(const Move newPv[]) {
+
+ Move* p = pv;
+
+ do *p++ = *newPv; while (*newPv++ != MOVE_NONE);
+ }
+
+
+ // RootMoveList struct is essentially a std::vector<> of RootMove objects,
+ // with an handful of methods above the standard ones.
+
+ struct RootMoveList : public std::vector<RootMove> {
- Move move(int moveNum) const { return moves[moveNum].move; }
- Move move_pv(int moveNum, int i) const { return moves[moveNum].pv[i]; }
- int size() const { return count; }
- Value pv_score(int moveNum) const { return moves[moveNum].pvScore; }
- int64_t nodes(int moveNum) const { return moves[moveNum].nodes; }
- void add_nodes(int moveNum, int64_t n) { moves[moveNum].nodes += n; }
- void set_pv_score(int moveNum, Value v) { moves[moveNum].pvScore = v; }
+ typedef std::vector<RootMove> Base;
- void set_pv(int moveNum, const Move pv[]);
+ RootMoveList(Position& pos, Move searchMoves[]);
void set_non_pv_scores(const Position& pos);
- void sort();
- void sort_multipv(int n);
- private:
- RootMove moves[MOVES_MAX];
- int count;
+ void sort() { insertion_sort<RootMove, Base::iterator>(begin(), end()); }
+ void sort_multipv(int n) { insertion_sort<RootMove, Base::iterator>(begin(), begin() + n); }
};
cout << set960(pos.is_chess960()) // Is enough to set once at the beginning
<< "info depth " << 1
<< "\ninfo depth " << 1
- << " score " << value_to_uci(rml.pv_score(0))
+ << " score " << value_to_uci(rml[0].pv_score)
<< " time " << current_search_time()
<< " nodes " << pos.nodes_searched()
<< " nps " << nps(pos)
- << " pv " << rml.move(0) << "\n";
+ << " pv " << rml[0].move << "\n";
// Initialize
TT.new_search();
H.clear();
init_ss_array(ss, PLY_MAX_PLUS_2);
pv[0] = pv[1] = MOVE_NONE;
- ValueByIteration[1] = rml.pv_score(0);
+ ValueByIteration[1] = rml[0].pv_score;
Iteration = 1;
// Is one move significantly better than others after initial scoring ?
if ( rml.size() == 1
- || rml.pv_score(0) > rml.pv_score(1) + EasyMoveMargin)
- EasyMove = rml.move(0);
+ || rml[0].pv_score > rml[1].pv_score + EasyMoveMargin)
+ EasyMove = rml[0].move;
// Iterative deepening loop
while (Iteration < PLY_MAX)
// Stop search early if one move seems to be much better than the others
if ( Iteration >= 8
&& EasyMove == pv[0]
- && ( ( rml.nodes(0) > (pos.nodes_searched() * 85) / 100
+ && ( ( rml[0].nodes > (pos.nodes_searched() * 85) / 100
&& current_search_time() > TimeMgr.available_time() / 16)
- ||( rml.nodes(0) > (pos.nodes_searched() * 98) / 100
+ ||( rml[0].nodes > (pos.nodes_searched() * 98) / 100
&& current_search_time() > TimeMgr.available_time() / 32)))
stopSearch = true;
// Print the best move and the ponder move to the standard output
if (pv[0] == MOVE_NONE || MultiPV > 1)
{
- pv[0] = rml.move(0);
+ pv[0] = rml[0].move;
pv[1] = MOVE_NONE;
}
<< move_to_san(pos, pv[1]) // Works also with MOVE_NONE
<< endl;
}
- return rml.pv_score(0);
+ return rml[0].pv_score;
}
rml.sort();
// Step 10. Loop through all moves in the root move list
- for (int i = 0; i < rml.size() && !AbortSearch; i++)
+ for (int i = 0; i < (int)rml.size() && !AbortSearch; i++)
{
// This is used by time management
FirstRootMove = (i == 0);
// Pick the next root move, and print the move and the move number to
// the standard output.
- move = ss->currentMove = rml.move(i);
+ move = ss->currentMove = rml[i].move;
if (current_search_time() >= 1000)
cout << "info currmove " << move
value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth-ss->reduction, 1);
doFullDepthSearch = (value > alpha);
}
-
- // The move failed high, but if reduction is very big we could
- // face a false positive, retry with a less aggressive reduction,
- // if the move fails high again then go with full depth search.
- if (doFullDepthSearch && ss->reduction > 2 * ONE_PLY)
- {
- assert(newDepth - ONE_PLY >= ONE_PLY);
-
- ss->reduction = ONE_PLY;
- value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth-ss->reduction, 1);
- doFullDepthSearch = (value > alpha);
- }
ss->reduction = DEPTH_ZERO; // Restore original reduction
}
// We are failing high and going to do a research. It's important to update
// the score before research in case we run out of time while researching.
- rml.set_pv_score(i, value);
+ rml[i].pv_score = value;
ss->bestMove = move;
extract_pv_from_tt(pos, move, pv);
- rml.set_pv(i, pv);
+ rml[i].set_pv(pv);
// Print information to the standard output
print_pv_info(pos, pv, alpha, beta, value);
break;
// Remember searched nodes counts for this move
- rml.add_nodes(i, pos.nodes_searched() - nodes);
+ rml[i].nodes += pos.nodes_searched() - nodes;
assert(value >= -VALUE_INFINITE && value <= VALUE_INFINITE);
assert(value < beta);
// Step 17. Check for new best move
if (value <= alpha && i >= MultiPV)
- rml.set_pv_score(i, -VALUE_INFINITE);
+ rml[i].pv_score = -VALUE_INFINITE;
else
{
// PV move or new best move!
// Update PV
- rml.set_pv_score(i, value);
+ rml[i].pv_score = value;
ss->bestMove = move;
extract_pv_from_tt(pos, move, pv);
- rml.set_pv(i, pv);
+ rml[i].set_pv(pv);
if (MultiPV == 1)
{
else // MultiPV > 1
{
rml.sort_multipv(i);
- for (int j = 0; j < Min(MultiPV, rml.size()); j++)
+ for (int j = 0; j < Min(MultiPV, (int)rml.size()); j++)
{
cout << "info multipv " << j + 1
- << " score " << value_to_uci(rml.pv_score(j))
+ << " score " << value_to_uci(rml[j].pv_score)
<< " depth " << (j <= i ? Iteration : Iteration - 1)
<< " time " << current_search_time()
<< " nodes " << pos.nodes_searched()
<< " nps " << nps(pos)
<< " pv ";
- for (int k = 0; rml.move_pv(j, k) != MOVE_NONE && k < PLY_MAX; k++)
- cout << rml.move_pv(j, k) << " ";
+ for (int k = 0; rml[j].pv[k] != MOVE_NONE && k < PLY_MAX; k++)
+ cout << rml[j].pv[k] << " ";
cout << endl;
}
- alpha = rml.pv_score(Min(i, MultiPV - 1));
+ alpha = rml[Min(i, MultiPV - 1)].pv_score;
}
} // PV move or new best move
doFullDepthSearch = (value > alpha);
}
-
- // The move failed high, but if reduction is very big we could
- // face a false positive, retry with a less aggressive reduction,
- // if the move fails high again then go with full depth search.
- if (doFullDepthSearch && ss->reduction > 2 * ONE_PLY)
- {
- assert(newDepth - ONE_PLY >= ONE_PLY);
-
- ss->reduction = ONE_PLY;
- alpha = SpNode ? sp->alpha : alpha;
- value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, newDepth-ss->reduction, ply+1);
- doFullDepthSearch = (value > alpha);
- }
ss->reduction = DEPTH_ZERO; // Restore original reduction
}
/// The RootMoveList class
- // RootMoveList c'tor
-
RootMoveList::RootMoveList(Position& pos, Move searchMoves[]) {
SearchStack ss[PLY_MAX_PLUS_2];
MoveStack mlist[MOVES_MAX];
StateInfo st;
- bool includeAllMoves = (searchMoves[0] == MOVE_NONE);
+ Move* sm;
// Initialize search stack
init_ss_array(ss, PLY_MAX_PLUS_2);
ss[0].eval = ss[0].evalMargin = VALUE_NONE;
- count = 0;
// Generate all legal moves
MoveStack* last = generate_moves(pos, mlist);
- // Add each move to the moves[] array
+ // Add each move to the RootMoveList's vector
for (MoveStack* cur = mlist; cur != last; cur++)
{
- bool includeMove = includeAllMoves;
+ // If we have a searchMoves[] list then verify cur->move
+ // is in the list before to add it.
+ for (sm = searchMoves; *sm && *sm != cur->move; sm++) {}
- for (int k = 0; !includeMove && searchMoves[k] != MOVE_NONE; k++)
- includeMove = (searchMoves[k] == cur->move);
-
- if (!includeMove)
+ if (searchMoves[0] && *sm != cur->move)
continue;
- // Find a quick score for the move
- moves[count].move = ss[0].currentMove = moves[count].pv[0] = cur->move;
- moves[count].pv[1] = MOVE_NONE;
+ // Find a quick score for the move and add to the list
pos.do_move(cur->move, st);
- moves[count].pvScore = -qsearch<PV>(pos, ss+1, -VALUE_INFINITE, VALUE_INFINITE, DEPTH_ZERO, 1);
+
+ RootMove rm;
+ rm.move = ss[0].currentMove = rm.pv[0] = cur->move;
+ rm.pv[1] = MOVE_NONE;
+ rm.pv_score = -qsearch<PV>(pos, ss+1, -VALUE_INFINITE, VALUE_INFINITE, DEPTH_ZERO, 1);
+ push_back(rm);
+
pos.undo_move(cur->move);
- count++;
}
sort();
}
MovePicker mp(pos, MOVE_NONE, ONE_PLY, H);
while ((move = mp.get_next_move()) != MOVE_NONE)
- for (int i = 0; i < count; i++)
- if (moves[i].move == move)
+ for (Base::iterator it = begin(); it != end(); ++it)
+ if (it->move == move)
{
- moves[i].nonPvScore = score--;
+ it->non_pv_score = score--;
break;
}
}
- // RootMoveList simple methods definitions
-
- void RootMoveList::set_pv(int moveNum, const Move pv[]) {
-
- int j;
-
- for (j = 0; pv[j] != MOVE_NONE; j++)
- moves[moveNum].pv[j] = pv[j];
-
- moves[moveNum].pv[j] = MOVE_NONE;
- }
-
-
- // RootMoveList::sort() sorts the root move list at the beginning of a new
- // iteration.
-
- void RootMoveList::sort() {
-
- sort_multipv(count - 1); // Sort all items
- }
-
-
- // RootMoveList::sort_multipv() sorts the first few moves in the root move
- // list by their scores and depths. It is used to order the different PVs
- // correctly in MultiPV mode.
-
- void RootMoveList::sort_multipv(int n) {
-
- int i,j;
-
- for (i = 1; i <= n; i++)
- {
- RootMove rm = moves[i];
- for (j = i; j > 0 && moves[j - 1] < rm; j--)
- moves[j] = moves[j - 1];
-
- moves[j] = rm;
- }
- }
-
} // namespace
projects / stockfish / blobdiff