kate/BadFish
1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-04-29 16:23:09 +00:00
Code Issues Releases Wiki Activity

Rename RootMoveList members removing 'move'

Browse source 
It is redundant being a move list ;-)

Also better document the two scores used by root list.

No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
This commit is contained in:
Marco Costalba 2010-12-27 10:52:04 +01:00
parent e7ab3a0d16
commit 12eb27b6e9
1 changed files with 47 additions and 43 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

90
src/search.cpp
View file

@ -104,26 +104,28 @@ namespace {
}; };
// RootMove struct is used for moves at the root at the tree. For each // RootMove struct is used for moves at the root at the tree. For each root
// root move, we store a score, a node count, and a PV (really a refutation // move, we store two scores, a node count, and a PV (really a refutation
// in the case of moves which fail low). // 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
// according to the order in which moves are returned by MovePicker.
struct RootMove { struct RootMove {
RootMove() : mp_score(0), nodes(0) {} RootMove() : nodes(0) { pvScore = nonPvScore = -VALUE_INFINITE; }
// RootMove::operator<() is the comparison function used when // RootMove::operator<() is the comparison function used when
// sorting the moves. A move m1 is considered to be better // sorting the moves. A move m1 is considered to be better
// than a move m2 if it has a higher score, or if the moves // than a move m2 if it has an higher pvScore, or if it has
// have equal score but m1 has the higher beta cut-off count. // equal pvScore but m1 has the higher nonPvScore. In this way
// we are guaranteed that PV moves are always sorted as first.
bool operator<(const RootMove& m) const { bool operator<(const RootMove& m) const {
return pvScore != m.pvScore ? pvScore < m.pvScore : nonPvScore <= m.nonPvScore;
return score != m.score ? score < m.score : mp_score <= m.mp_score;
} }
Move move; Move move;
Value score; Value pvScore;
int mp_score; Value nonPvScore;
int64_t nodes; int64_t nodes;
Move pv[PLY_MAX_PLUS_2]; Move pv[PLY_MAX_PLUS_2];
}; };
@ -139,14 +141,14 @@ namespace {
Move move(int moveNum) const { return moves[moveNum].move; } Move move(int moveNum) const { return moves[moveNum].move; }
Move move_pv(int moveNum, int i) const { return moves[moveNum].pv[i]; } Move move_pv(int moveNum, int i) const { return moves[moveNum].pv[i]; }
int move_count() const { return count; } int size() const { return count; }
Value move_score(int moveNum) const { return moves[moveNum].score; } Value pv_score(int moveNum) const { return moves[moveNum].pvScore; }
int64_t move_nodes(int moveNum) const { return moves[moveNum].nodes; } int64_t nodes(int moveNum) const { return moves[moveNum].nodes; }
void add_move_nodes(int moveNum, int64_t nodes) { moves[moveNum].nodes += nodes; } void add_nodes(int moveNum, int64_t n) { moves[moveNum].nodes += n; }
void set_move_score(int moveNum, Value score) { moves[moveNum].score = score; } void set_pv_score(int moveNum, Value v) { moves[moveNum].pvScore = v; }
void set_move_pv(int moveNum, const Move pv[]); void set_pv(int moveNum, const Move pv[]);
void score_moves(const Position& pos); void set_non_pv_scores(const Position& pos);
void sort(); void sort();
void sort_multipv(int n); void sort_multipv(int n);
@ -527,7 +529,7 @@ namespace {
RootMoveList rml(pos, searchMoves); RootMoveList rml(pos, searchMoves);
// Handle special case of searching on a mate/stale position // Handle special case of searching on a mate/stale position
if (rml.move_count() == 0) if (rml.size() == 0)
{ {
if (PonderSearch) if (PonderSearch)
wait_for_stop_or_ponderhit(); wait_for_stop_or_ponderhit();
@ -540,7 +542,7 @@ namespace {
cout << set960(pos.is_chess960()) // Is enough to set once at the beginning cout << set960(pos.is_chess960()) // Is enough to set once at the beginning
<< "info depth " << 1 << "info depth " << 1
<< "\ninfo depth " << 1 << "\ninfo depth " << 1
<< " score " << value_to_uci(rml.move_score(0)) << " score " << value_to_uci(rml.pv_score(0))
<< " time " << current_search_time() << " time " << current_search_time()
<< " nodes " << pos.nodes_searched() << " nodes " << pos.nodes_searched()
<< " nps " << nps(pos) << " nps " << nps(pos)
@ -551,12 +553,12 @@ namespace {
H.clear(); H.clear();
init_ss_array(ss, PLY_MAX_PLUS_2); init_ss_array(ss, PLY_MAX_PLUS_2);
pv[0] = pv[1] = MOVE_NONE; pv[0] = pv[1] = MOVE_NONE;
ValueByIteration[1] = rml.move_score(0); ValueByIteration[1] = rml.pv_score(0);
Iteration = 1; Iteration = 1;
// Is one move significantly better than others after initial scoring ? // Is one move significantly better than others after initial scoring ?
if ( rml.move_count() == 1 if ( rml.size() == 1
|| rml.move_score(0) > rml.move_score(1) + EasyMoveMargin) || rml.pv_score(0) > rml.pv_score(1) + EasyMoveMargin)
EasyMove = rml.move(0); EasyMove = rml.move(0);
// Iterative deepening loop // Iterative deepening loop
@ -605,7 +607,7 @@ namespace {
// Stop search early if there is only a single legal move, // Stop search early if there is only a single legal move,
// we search up to Iteration 6 anyway to get a proper score. // we search up to Iteration 6 anyway to get a proper score.
if (Iteration >= 6 && rml.move_count() == 1) if (Iteration >= 6 && rml.size() == 1)
stopSearch = true; stopSearch = true;
// Stop search early when the last two iterations returned a mate score // Stop search early when the last two iterations returned a mate score
@ -617,9 +619,9 @@ namespace {
// Stop search early if one move seems to be much better than the others // Stop search early if one move seems to be much better than the others
if ( Iteration >= 8 if ( Iteration >= 8
&& EasyMove == pv[0] && EasyMove == pv[0]
&& ( ( rml.move_nodes(0) > (pos.nodes_searched() * 85) / 100 && ( ( rml.nodes(0) > (pos.nodes_searched() * 85) / 100
&& current_search_time() > TimeMgr.available_time() / 16) && current_search_time() > TimeMgr.available_time() / 16)
||( rml.move_nodes(0) > (pos.nodes_searched() * 98) / 100 ||( rml.nodes(0) > (pos.nodes_searched() * 98) / 100
&& current_search_time() > TimeMgr.available_time() / 32))) && current_search_time() > TimeMgr.available_time() / 32)))
stopSearch = true; stopSearch = true;
@ -691,7 +693,7 @@ namespace {
<< move_to_san(pos, pv[1]) // Works also with MOVE_NONE << move_to_san(pos, pv[1]) // Works also with MOVE_NONE
<< endl; << endl;
} }
return rml.move_score(0); return rml.pv_score(0);
} }
@ -740,11 +742,11 @@ namespace {
while (1) while (1)
{ {
// Sort the moves before to (re)search // Sort the moves before to (re)search
rml.score_moves(pos); rml.set_non_pv_scores(pos);
rml.sort(); rml.sort();
// Step 10. Loop through all moves in the root move list // Step 10. Loop through all moves in the root move list
for (int i = 0; i < rml.move_count() && !AbortSearch; i++) for (int i = 0; i < rml.size() && !AbortSearch; i++)
{ {
// This is used by time management // This is used by time management
FirstRootMove = (i == 0); FirstRootMove = (i == 0);
@ -772,7 +774,7 @@ namespace {
// Step extra. Fail high loop // Step extra. Fail high loop
// If move fails high, we research with bigger window until we are not failing // If move fails high, we research with bigger window until we are not failing
// high anymore. // high anymore.
value = - VALUE_INFINITE; value = -VALUE_INFINITE;
while (1) while (1)
{ {
@ -848,10 +850,10 @@ namespace {
// We are failing high and going to do a research. It's important to update // 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. // the score before research in case we run out of time while researching.
rml.set_move_score(i, value); rml.set_pv_score(i, value);
ss->bestMove = move; ss->bestMove = move;
extract_pv_from_tt(pos, move, pv); extract_pv_from_tt(pos, move, pv);
rml.set_move_pv(i, pv); rml.set_pv(i, pv);
// Print information to the standard output // Print information to the standard output
print_pv_info(pos, pv, alpha, beta, value); print_pv_info(pos, pv, alpha, beta, value);
@ -871,23 +873,23 @@ namespace {
break; break;
// Remember searched nodes counts for this move // Remember searched nodes counts for this move
rml.add_move_nodes(i, pos.nodes_searched() - nodes); rml.add_nodes(i, pos.nodes_searched() - nodes);
assert(value >= -VALUE_INFINITE && value <= VALUE_INFINITE); assert(value >= -VALUE_INFINITE && value <= VALUE_INFINITE);
assert(value < beta); assert(value < beta);
// Step 17. Check for new best move // Step 17. Check for new best move
if (value <= alpha && i >= MultiPV) if (value <= alpha && i >= MultiPV)
rml.set_move_score(i, -VALUE_INFINITE); rml.set_pv_score(i, -VALUE_INFINITE);
else else
{ {
// PV move or new best move! // PV move or new best move!
// Update PV // Update PV
rml.set_move_score(i, value); rml.set_pv_score(i, value);
ss->bestMove = move; ss->bestMove = move;
extract_pv_from_tt(pos, move, pv); extract_pv_from_tt(pos, move, pv);
rml.set_move_pv(i, pv); rml.set_pv(i, pv);
if (MultiPV == 1) if (MultiPV == 1)
{ {
@ -907,10 +909,10 @@ namespace {
else // MultiPV > 1 else // MultiPV > 1
{ {
rml.sort_multipv(i); rml.sort_multipv(i);
for (int j = 0; j < Min(MultiPV, rml.move_count()); j++) for (int j = 0; j < Min(MultiPV, rml.size()); j++)
{ {
cout << "info multipv " << j + 1 cout << "info multipv " << j + 1
<< " score " << value_to_uci(rml.move_score(j)) << " score " << value_to_uci(rml.pv_score(j))
<< " depth " << (j <= i ? Iteration : Iteration - 1) << " depth " << (j <= i ? Iteration : Iteration - 1)
<< " time " << current_search_time() << " time " << current_search_time()
<< " nodes " << pos.nodes_searched() << " nodes " << pos.nodes_searched()
@ -922,7 +924,7 @@ namespace {
cout << endl; cout << endl;
} }
alpha = rml.move_score(Min(i, MultiPV - 1)); alpha = rml.pv_score(Min(i, MultiPV - 1));
} }
} // PV move or new best move } // PV move or new best move
@ -2697,7 +2699,7 @@ split_point_start: // At split points actual search starts from here
moves[count].move = ss[0].currentMove = moves[count].pv[0] = cur->move; moves[count].move = ss[0].currentMove = moves[count].pv[0] = cur->move;
moves[count].pv[1] = MOVE_NONE; moves[count].pv[1] = MOVE_NONE;
pos.do_move(cur->move, st); pos.do_move(cur->move, st);
moves[count].score = -qsearch<PV>(pos, ss+1, -VALUE_INFINITE, VALUE_INFINITE, DEPTH_ZERO, 1); moves[count].pvScore = -qsearch<PV>(pos, ss+1, -VALUE_INFINITE, VALUE_INFINITE, DEPTH_ZERO, 1);
pos.undo_move(cur->move); pos.undo_move(cur->move);
count++; count++;
} }
@ -2706,25 +2708,27 @@ split_point_start: // At split points actual search starts from here
// Score root moves using the standard way used in main search, the moves // Score root moves using the standard way used in main search, the moves
// are scored according to the order in which are returned by MovePicker. // are scored according to the order in which are returned by MovePicker.
// This is the second order score that is used to compare the moves when
// the first order pv scores of both moves are equal.
void RootMoveList::score_moves(const Position& pos) void RootMoveList::set_non_pv_scores(const Position& pos)
{ {
Move move; Move move;
int score = 1000; Value score = VALUE_ZERO;
MovePicker mp(pos, MOVE_NONE, ONE_PLY, H); MovePicker mp(pos, MOVE_NONE, ONE_PLY, H);
while ((move = mp.get_next_move()) != MOVE_NONE) while ((move = mp.get_next_move()) != MOVE_NONE)
for (int i = 0; i < count; i++) for (int i = 0; i < count; i++)
if (moves[i].move == move) if (moves[i].move == move)
{ {
moves[i].mp_score = score--; moves[i].nonPvScore = score--;
break; break;
} }
} }
// RootMoveList simple methods definitions // RootMoveList simple methods definitions
void RootMoveList::set_move_pv(int moveNum, const Move pv[]) { void RootMoveList::set_pv(int moveNum, const Move pv[]) {
int j; int j;