void extract_pv_from_tt(Position& pos);
void insert_pv_in_tt(Position& pos);
- std::string pv_info_to_uci(Position& pos, int depth, Value alpha, Value beta, int pvLine = 0);
+ std::string pv_info_to_uci(Position& pos, int depth, Value alpha, Value beta, int pvLine);
int64_t nodes;
Value pv_score;
// Minimum depth for use of singular extension
const Depth SingularExtensionDepth[2] = { 8 * ONE_PLY /* non-PV */, 6 * ONE_PLY /* PV */};
- // If the TT move is at least SingularExtensionMargin better then the
+ // If the TT move is at least SingularExtensionMargin better than the
// remaining ones we will extend it.
const Value SingularExtensionMargin = Value(0x20);
// MultiPV mode
int MultiPV;
- // Time managment variables
+ // Time management variables
int SearchStartTime, MaxNodes, MaxDepth, ExactMaxTime;
bool UseTimeManagement, InfiniteSearch, Pondering, StopOnPonderhit;
bool FirstRootMove, StopRequest, QuitRequest, AspirationFailLow;
Value score = VALUE_ZERO;
// 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 they 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.
while ((move = MovePicker::get_next_move()) != MOVE_NONE)
std::string name = Options["Search Log Filename"].value<std::string>();
LogFile.open(name.c_str(), std::ios::out | std::ios::app);
- LogFile << "Searching: " << pos.to_fen()
- << "\ninfinite: " << infinite
- << " ponder: " << ponder
- << " time: " << myTime
- << " increment: " << myIncrement
- << " moves to go: " << movesToGo << endl;
+ LogFile << "\nSearching: " << pos.to_fen()
+ << "\ninfinite: " << infinite
+ << " ponder: " << ponder
+ << " time: " << myTime
+ << " increment: " << myIncrement
+ << " moves to go: " << movesToGo
+ << endl;
}
// We're ready to start thinking. Call the iterative deepening loop function
if (UseLogFile)
{
- LogFile << "\nNodes: " << pos.nodes_searched()
+ LogFile << "Nodes: " << pos.nodes_searched()
<< "\nNodes/second: " << nps(pos)
- << "\nBest move: " << move_to_san(pos, bestMove);
+ << "\nBest move: " << move_to_san(pos, bestMove);
StateInfo st;
pos.do_move(bestMove, st);
- LogFile << "\nPonder move: "
- << move_to_san(pos, ponderMove) // Works also with MOVE_NONE
- << endl;
-
- // Return from think() with unchanged position
- pos.undo_move(bestMove);
-
+ LogFile << "\nPonder move: " << move_to_san(pos, ponderMove) << endl;
+ pos.undo_move(bestMove); // Return from think() with unchanged position
LogFile.close();
}
ss->currentMove = MOVE_NULL; // Hack to skip update_gains()
alpha = -VALUE_INFINITE, beta = VALUE_INFINITE;
- // Handle special case of searching on a mate/stale position
+ // Handle special case of searching on a mate/stalemate position
if (Rml.size() == 0)
{
cout << "info depth 0 score "
bestValues[depth] = value;
bestMoveChanges[depth] = Rml.bestMoveChanges;
+ if (UseLogFile)
+ LogFile << pretty_pv(pos, depth, value, current_search_time(), Rml[0].pv) << endl;
+
// Drop the easy move if differs from the new best move
if (bestMove != easyMove)
easyMove = MOVE_NONE;
// Step 4. Transposition table lookup
// We don't want the score of a partial search to overwrite a previous full search
- // TT value, so we use a different position key in case of an excluded move exists.
+ // TT value, so we use a different position key in case of an excluded move.
excludedMove = ss->excludedMove;
posKey = excludedMove ? pos.get_exclusion_key() : pos.get_key();
// Singular extension search. If all moves but one fail low on a search of (alpha-s, beta-s),
// and just one fails high on (alpha, beta), then that move is singular and should be extended.
// To verify this we do a reduced search on all the other moves but the ttMove, if result is
- // lower then ttValue minus a margin then we extend ttMove.
+ // lower than ttValue minus a margin then we extend ttMove.
if ( singularExtensionNode
&& move == tte->move()
&& ext < ONE_PLY)
&& ss->killers[0] != move
&& ss->killers[1] != move)
{
- ss->reduction = Root ? reduction<PvNode>(depth, moveCount - MultiPV + 1)
- : reduction<PvNode>(depth, moveCount);
+ ss->reduction = reduction<PvNode>(depth, moveCount);
if (ss->reduction)
{
alpha = SpNode ? sp->alpha : alpha;
alpha = sp->alpha;
}
- if (!Root && value > bestValue && !(SpNode && ThreadsMgr.cutoff_at_splitpoint(threadID)))
+ if (value > bestValue && !(SpNode && ThreadsMgr.cutoff_at_splitpoint(threadID)))
{
bestValue = value;
if (SpNode)
sp->bestValue = value;
- if (value > alpha)
+ if (!Root && value > alpha)
{
if (PvNode && value < beta) // We want always alpha < beta
{
if (Root)
{
- // To avoid to exit with bestValue == -VALUE_INFINITE
- if (value > bestValue)
- bestValue = value;
-
// Finished searching the move. If StopRequest is true, the search
// was aborted because the user interrupted the search or because we
// ran out of time. In this case, the return value of the search cannot
// Remember searched nodes counts for this move
mp.rm->nodes += pos.nodes_searched() - nodes;
- // Step 17. Check for new best move
- if (!isPvMove && value <= alpha)
- mp.rm->pv_score = -VALUE_INFINITE;
- else
+ // PV move or new best move ?
+ if (isPvMove || value > alpha)
{
- // PV move or new best move!
-
// Update PV
ss->bestMove = move;
mp.rm->pv_score = value;
mp.rm->extract_pv_from_tt(pos);
// We record how often the best move has been changed in each
- // iteration. This information is used for time managment: When
+ // iteration. This information is used for time management: When
// the best move changes frequently, we allocate some more time.
if (!isPvMove && MultiPV == 1)
Rml.bestMoveChanges++;
alpha = Rml[Min(moveCount, MultiPV) - 1].pv_score; // FIXME why moveCount?
else if (value > alpha)
alpha = value;
+ }
+ else
+ mp.rm->pv_score = -VALUE_INFINITE;
- } // PV move or new best move
- }
+ } // Root
// Step 18. Check for split
if ( !Root
// connected_threat() tests whether it is safe to forward prune a move or if
- // is somehow coonected to the threat move returned by null search.
+ // is somehow connected to the threat move returned by null search.
bool connected_threat(const Position& pos, Move m, Move threat) {
return true;
// Case 2: If the threatened piece has value less than or equal to the
- // value of the threatening piece, don't prune move which defend it.
+ // value of the threatening piece, don't prune moves which defend it.
if ( pos.move_is_capture(threat)
&& ( pos.midgame_value_of_piece_on(tfrom) >= pos.midgame_value_of_piece_on(tto)
|| pos.type_of_piece_on(tfrom) == KING)
if (abs(v) < VALUE_MATE - PLY_MAX * ONE_PLY)
s << "cp " << int(v) * 100 / int(PawnValueMidgame); // Scale to centipawns
else
- s << "mate " << (v > 0 ? (VALUE_MATE - v + 1) / 2 : -(VALUE_MATE + v) / 2 );
+ s << "mate " << (v > 0 ? (VALUE_MATE - v + 1) / 2 : -(VALUE_MATE + v) / 2);
return s.str();
}
k = pos.get_key();
tte = TT.retrieve(k);
- // Don't overwrite exsisting correct entries
+ // Don't overwrite existing correct entries
if (!tte || tte->move() != pv[ply])
{
v = (pos.is_check() ? VALUE_NONE : evaluate(pos, m));
}
// pv_info_to_uci() returns a string with information on the current PV line
- // formatted according to UCI specification and eventually writes the info
- // to a log file. It is called at each iteration or after a new pv is found.
+ // formatted according to UCI specification. It is called at each iteration
+ // or after a new pv is found.
std::string RootMove::pv_info_to_uci(Position& pos, int depth, Value alpha, Value beta, int pvLine) {
<< " nps " << nps(pos)
<< " pv " << l.str();
- if (UseLogFile && pvLine == 0)
- {
- ValueType t = pv_score >= beta ? VALUE_TYPE_LOWER :
- pv_score <= alpha ? VALUE_TYPE_UPPER : VALUE_TYPE_EXACT;
-
- LogFile << pretty_pv(pos, current_search_time(), depth, pv_score, t, pv) << endl;
- }
return s.str();
}
projects / stockfish / blobdiff