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

Use a std::vector to store root moves

Browse source 
No functional change.

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
This commit is contained in:
Marco Costalba 2010-12-27 12:20:26 +01:00
parent 12eb27b6e9
commit e8b5420300
1 changed files with 57 additions and 79 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

136
src/search.cpp
View file

@ -28,6 +28,7 @@
#include <fstream> #include <fstream>
#include <iostream> #include <iostream>
#include <sstream> #include <sstream>
#include <vector>
#include "book.h" #include "book.h"
#include "evaluate.h" #include "evaluate.h"
@ -112,7 +113,7 @@ namespace {
struct RootMove { struct RootMove {
RootMove() : nodes(0) { pvScore = nonPvScore = -VALUE_INFINITE; } RootMove() : nodes(0) { pv_score = non_pv_score = -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
@ -120,41 +121,40 @@ namespace {
// equal pvScore but m1 has the higher nonPvScore. In this way // equal pvScore but m1 has the higher nonPvScore. In this way
// we are guaranteed that PV moves are always sorted as first. // 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 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; Move move;
Value pvScore; Value pv_score;
Value nonPvScore; Value non_pv_score;
int64_t nodes; int64_t nodes;
Move pv[PLY_MAX_PLUS_2]; Move pv[PLY_MAX_PLUS_2];
}; };
void RootMove::set_pv(const Move newPv[]) {
// The RootMoveList class is essentially an array of RootMove objects, with int i = -1;
// a handful of methods for accessing the data in the individual moves.
class RootMoveList { while (newPv[++i] != MOVE_NONE)
pv[i] = newPv[i];
pv[i] = MOVE_NONE;
}
// The 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> {
typedef std::vector<RootMove> Base;
public:
RootMoveList(Position& pos, Move searchMoves[]); RootMoveList(Position& pos, Move searchMoves[]);
void sort() { sort_multipv((int)size() - 1); } // Sort all items
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; }
void set_pv(int moveNum, const Move pv[]);
void set_non_pv_scores(const Position& pos); void set_non_pv_scores(const Position& pos);
void sort();
void sort_multipv(int n); void sort_multipv(int n);
private:
RootMove moves[MOVES_MAX];
int count;
}; };
@ -542,24 +542,24 @@ 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.pv_score(0)) << " score " << value_to_uci(rml[0].pv_score)
<< " time " << current_search_time() << " time " << current_search_time()
<< " nodes " << pos.nodes_searched() << " nodes " << pos.nodes_searched()
<< " nps " << nps(pos) << " nps " << nps(pos)
<< " pv " << rml.move(0) << "\n"; << " pv " << rml[0].move << "\n";
// Initialize // Initialize
TT.new_search(); TT.new_search();
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.pv_score(0); ValueByIteration[1] = rml[0].pv_score;
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.size() == 1 if ( rml.size() == 1
|| rml.pv_score(0) > rml.pv_score(1) + EasyMoveMargin) || rml[0].pv_score > rml[1].pv_score + EasyMoveMargin)
EasyMove = rml.move(0); EasyMove = rml[0].move;
// Iterative deepening loop // Iterative deepening loop
while (Iteration < PLY_MAX) while (Iteration < PLY_MAX)
@ -619,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.nodes(0) > (pos.nodes_searched() * 85) / 100 && ( ( rml[0].nodes > (pos.nodes_searched() * 85) / 100
&& current_search_time() > TimeMgr.available_time() / 16) && 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))) && current_search_time() > TimeMgr.available_time() / 32)))
stopSearch = true; stopSearch = true;
@ -662,7 +662,7 @@ namespace {
// Print the best move and the ponder move to the standard output // Print the best move and the ponder move to the standard output
if (pv[0] == MOVE_NONE || MultiPV > 1) if (pv[0] == MOVE_NONE || MultiPV > 1)
{ {
pv[0] = rml.move(0); pv[0] = rml[0].move;
pv[1] = MOVE_NONE; pv[1] = MOVE_NONE;
} }
@ -693,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.pv_score(0); return rml[0].pv_score;
} }
@ -746,7 +746,7 @@ namespace {
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.size() && !AbortSearch; i++) for (int i = 0; i < (int)rml.size() && !AbortSearch; i++)
{ {
// This is used by time management // This is used by time management
FirstRootMove = (i == 0); FirstRootMove = (i == 0);
@ -756,7 +756,7 @@ namespace {
// Pick the next root move, and print the move and the move number to // Pick the next root move, and print the move and the move number to
// the standard output. // the standard output.
move = ss->currentMove = rml.move(i); move = ss->currentMove = rml[i].move;
if (current_search_time() >= 1000) if (current_search_time() >= 1000)
cout << "info currmove " << move cout << "info currmove " << move
@ -850,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_pv_score(i, value); rml[i].pv_score = value;
ss->bestMove = move; ss->bestMove = move;
extract_pv_from_tt(pos, move, pv); extract_pv_from_tt(pos, move, pv);
rml.set_pv(i, pv); rml[i].set_pv(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);
@ -873,23 +873,23 @@ namespace {
break; break;
// Remember searched nodes counts for this move // 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 >= -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_pv_score(i, -VALUE_INFINITE); rml[i].pv_score = -VALUE_INFINITE;
else else
{ {
// PV move or new best move! // PV move or new best move!
// Update PV // Update PV
rml.set_pv_score(i, value); rml[i].pv_score = value;
ss->bestMove = move; ss->bestMove = move;
extract_pv_from_tt(pos, move, pv); extract_pv_from_tt(pos, move, pv);
rml.set_pv(i, pv); rml[i].set_pv(pv);
if (MultiPV == 1) if (MultiPV == 1)
{ {
@ -909,22 +909,22 @@ namespace {
else // MultiPV > 1 else // MultiPV > 1
{ {
rml.sort_multipv(i); 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 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) << " depth " << (j <= i ? Iteration : Iteration - 1)
<< " time " << current_search_time() << " time " << current_search_time()
<< " nodes " << pos.nodes_searched() << " nodes " << pos.nodes_searched()
<< " nps " << nps(pos) << " nps " << nps(pos)
<< " pv "; << " pv ";
for (int k = 0; rml.move_pv(j, k) != MOVE_NONE && k < PLY_MAX; k++) for (int k = 0; rml[j].pv[k] != MOVE_NONE && k < PLY_MAX; k++)
cout << rml.move_pv(j, k) << " "; cout << rml[j].pv[k] << " ";
cout << endl; cout << endl;
} }
alpha = rml.pv_score(Min(i, MultiPV - 1)); alpha = rml[Min(i, MultiPV - 1)].pv_score;
} }
} // PV move or new best move } // PV move or new best move
@ -2679,7 +2679,6 @@ split_point_start: // At split points actual search starts from here
// Initialize search stack // Initialize search stack
init_ss_array(ss, PLY_MAX_PLUS_2); init_ss_array(ss, PLY_MAX_PLUS_2);
ss[0].eval = ss[0].evalMargin = VALUE_NONE; ss[0].eval = ss[0].evalMargin = VALUE_NONE;
count = 0;
// Generate all legal moves // Generate all legal moves
MoveStack* last = generate_moves(pos, mlist); MoveStack* last = generate_moves(pos, mlist);
@ -2695,13 +2694,14 @@ split_point_start: // At split points actual search starts from here
if (!includeMove) if (!includeMove)
continue; continue;
// Find a quick score for the move // Find a quick score for the move and add to the list
moves[count].move = ss[0].currentMove = moves[count].pv[0] = cur->move; RootMove rm;
moves[count].pv[1] = MOVE_NONE; rm.move = ss[0].currentMove = rm.pv[0] = cur->move;
rm.pv[1] = MOVE_NONE;
pos.do_move(cur->move, st); pos.do_move(cur->move, st);
moves[count].pvScore = -qsearch<PV>(pos, ss+1, -VALUE_INFINITE, VALUE_INFINITE, DEPTH_ZERO, 1); rm.pv_score = -qsearch<PV>(pos, ss+1, -VALUE_INFINITE, VALUE_INFINITE, DEPTH_ZERO, 1);
pos.undo_move(cur->move); pos.undo_move(cur->move);
count++; push_back(rm);
} }
sort(); sort();
} }
@ -2718,36 +2718,14 @@ split_point_start: // At split points actual search starts from here
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 (Base::iterator it = begin(); it != end(); ++it)
if (moves[i].move == move) if (it->move == move)
{ {
moves[i].nonPvScore = score--; it->non_pv_score = score--;
break; 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 // 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 // list by their scores and depths. It is used to order the different PVs
// correctly in MultiPV mode. // correctly in MultiPV mode.
@ -2758,11 +2736,11 @@ split_point_start: // At split points actual search starts from here
for (i = 1; i <= n; i++) for (i = 1; i <= n; i++)
{ {
RootMove rm = moves[i]; const RootMove& rm = this->at(i);
for (j = i; j > 0 && moves[j - 1] < rm; j--) for (j = i; j > 0 && this->at(j - 1) < rm; j--)
moves[j] = moves[j - 1]; (*this)[j] = this->at(j - 1);
moves[j] = rm; (*this)[j] = rm;
} }
} }