/*
Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
- Copyright (C) 2008-2009 Marco Costalba
+ Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad
Stockfish is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
void put_threads_to_sleep();
void idle_loop(int threadID, SplitPoint* waitSp);
bool split(const Position& pos, SearchStack* ss, int ply, Value* alpha, const Value beta, Value* bestValue,
- Depth depth, int* moves, MovePicker* mp, int master, bool pvNode);
+ Depth depth, bool mateThreat, int* moves, MovePicker* mp, int master, bool pvNode);
private:
friend void poll(SearchStack ss[], int ply);
int MultiPV;
// Time managment variables
- int RootMoveNumber, SearchStartTime, MaxNodes, MaxDepth;
- int MaxSearchTime, AbsoluteMaxSearchTime, ExtraSearchTime, ExactMaxTime;
+ int SearchStartTime, MaxNodes, MaxDepth, MaxSearchTime;
+ int AbsoluteMaxSearchTime, ExtraSearchTime, ExactMaxTime;
bool UseTimeManagement, InfiniteSearch, PonderSearch, StopOnPonderhit;
- bool AbortSearch, Quit, AspirationFailLow;
+ bool FirstRootMove, AbortSearch, Quit, AspirationFailLow;
// Show current line?
bool ShowCurrentLine;
/// Local functions
Value id_loop(const Position& pos, Move searchMoves[]);
- Value root_search(Position& pos, SearchStack ss[], RootMoveList& rml, Value& oldAlpha, Value& beta);
+ Value root_search(Position& pos, SearchStack ss[], RootMoveList& rml, Value* alphaPtr, Value* betaPtr);
Value search_pv(Position& pos, SearchStack ss[], Value alpha, Value beta, Depth depth, int ply, int threadID);
Value search(Position& pos, SearchStack ss[], Value beta, Depth depth, int ply, bool allowNullmove, int threadID, Move excludedMove = MOVE_NONE);
Value qsearch(Position& pos, SearchStack ss[], Value alpha, Value beta, Depth depth, int ply, int threadID);
// Initialize global search variables
StopOnPonderhit = AbortSearch = Quit = AspirationFailLow = false;
+ MaxSearchTime = AbsoluteMaxSearchTime = ExtraSearchTime = 0;
NodesSincePoll = 0;
TM.resetNodeCounters();
SearchStartTime = get_system_time();
{
TM.set_active_threads(newActiveThreads);
init_eval(TM.active_threads());
- // HACK: init_eval() destroys the static castleRightsMask[] array in the
- // Position class. The below line repairs the damage.
- Position p(pos.to_fen());
- assert(pos.is_ok());
}
// Wake up sleeping threads
while (Iteration < PLY_MAX)
{
// Initialize iteration
- rml.sort();
Iteration++;
BestMoveChangesByIteration[Iteration] = 0;
- if (Iteration <= 5)
- ExtraSearchTime = 0;
cout << "info depth " << Iteration << endl;
beta = Min(ValueByIteration[Iteration - 1] + AspirationDelta, VALUE_INFINITE);
}
- // Search to the current depth
- value = root_search(p, ss, rml, alpha, beta);
+ // Search to the current depth, rml is updated and sorted, alpha and beta could change
+ value = root_search(p, ss, rml, &alpha, &beta);
// Write PV to transposition table, in case the relevant entries have
// been overwritten during the search.
break;
}
- rml.sort();
-
// If we are pondering or in infinite search, we shouldn't print the
// best move before we are told to do so.
if (!AbortSearch && (PonderSearch || InfiniteSearch))
// scheme, prints some information to the standard output and handles
// the fail low/high loops.
- Value root_search(Position& pos, SearchStack ss[], RootMoveList& rml, Value& oldAlpha, Value& beta) {
+ Value root_search(Position& pos, SearchStack ss[], RootMoveList& rml, Value* alphaPtr, Value* betaPtr) {
EvalInfo ei;
StateInfo st;
+ CheckInfo ci(pos);
int64_t nodes;
Move move;
Depth depth, ext, newDepth;
- Value value, alpha;
+ Value value, alpha, beta;
bool isCheck, moveIsCheck, captureOrPromotion, dangerous;
- int researchCount = 0;
- CheckInfo ci(pos);
- alpha = oldAlpha;
+ int researchCountFH, researchCountFL;
+
+ researchCountFH = researchCountFL = 0;
+ alpha = *alphaPtr;
+ beta = *betaPtr;
isCheck = pos.is_check();
- // Evaluate the position statically
- ss[0].eval = !isCheck ? evaluate(pos, ei, 0) : VALUE_NONE;
+ // Step 1. Initialize node and poll (omitted at root, but I can see no good reason for this, FIXME)
+ // Step 2. Check for aborted search (omitted at root, because we do not initialize root node)
+ // Step 3. Mate distance pruning (omitted at root)
+ // Step 4. Transposition table lookup (omitted at root)
+
+ // Step 5. Evaluate the position statically
+ // At root we do this only to get reference value for child nodes
+ if (!isCheck)
+ ss[0].eval = evaluate(pos, ei, 0);
+ else
+ ss[0].eval = VALUE_NONE; // HACK because we do not initialize root node
- while (1) // Fail low loop
+ // Step 6. Razoring (omitted at root)
+ // Step 7. Static null move pruning (omitted at root)
+ // Step 8. Null move search with verification search (omitted at root)
+ // Step 9. Internal iterative deepening (omitted at root)
+
+ // Step extra. Fail low loop
+ // We start with small aspiration window and in case of fail low, we research
+ // with bigger window until we are not failing low anymore.
+ while (1)
{
- // Loop through all the moves in the root move list
+ // Sort the moves before to (re)search
+ rml.sort();
+
+ // Step 10. Loop through all moves in the root move list
for (int i = 0; i < rml.move_count() && !AbortSearch; i++)
{
- if (alpha >= beta)
- {
- // We failed high, invalidate and skip next moves, leave node-counters
- // and beta-counters as they are and quickly return, we will try to do
- // a research at the next iteration with a bigger aspiration window.
- rml.set_move_score(i, -VALUE_INFINITE);
- continue;
- }
-
- // This is used by time management and starts from 1
- RootMoveNumber = i + 1;
+ // This is used by time management
+ FirstRootMove = (i == 0);
// Save the current node count before the move is searched
nodes = TM.nodes_searched();
if (current_search_time() >= 1000)
cout << "info currmove " << move
- << " currmovenumber " << RootMoveNumber << endl;
+ << " currmovenumber " << i + 1 << endl;
- // Decide search depth for this move
moveIsCheck = pos.move_is_check(move);
captureOrPromotion = pos.move_is_capture_or_promotion(move);
+
+ // Step 11. Decide the new search depth
depth = (Iteration - 2) * OnePly + InitialDepth;
ext = extension(pos, move, true, captureOrPromotion, moveIsCheck, false, false, &dangerous);
newDepth = depth + ext;
- // Reset value before the search
+ // Step 12. Futility pruning (omitted at root)
+
+ // Step extra. Fail high loop
+ // If move fails high, we research with bigger window until we are not failing
+ // high anymore.
value = - VALUE_INFINITE;
- while (1) // Fail high loop
+ while (1)
{
- // Make the move, and search it
+ // Step 13. Make the move
pos.do_move(move, st, ci, moveIsCheck);
+ // Step extra. pv search
+ // We do pv search for first moves (i < MultiPV)
+ // and for fail high research (value > alpha)
if (i < MultiPV || value > alpha)
{
// Aspiration window is disabled in multi-pv case
}
else
{
- // Try to reduce non-pv search depth by one ply if move seems not problematic,
- // if the move fails high will be re-searched at full depth.
+ // Step 14. Reduced search
+ // if the move fails high will be re-searched at full depth
bool doFullDepthSearch = true;
- if ( depth >= 3 * OnePly // FIXME was newDepth
+ if ( depth >= 3 * OnePly
&& !dangerous
&& !captureOrPromotion
&& !move_is_castle(move))
}
}
+ // Step 15. Full depth search
if (doFullDepthSearch)
{
// Full depth non-pv search using alpha as upperbound
}
}
+ // Step 16. Undo move
pos.undo_move(move);
// Can we exit fail high loop ?
print_pv_info(pos, ss, alpha, beta, value);
// Prepare for a research after a fail high, each time with a wider window
- researchCount++;
- beta = Min(beta + AspirationDelta * (1 << researchCount), VALUE_INFINITE);
+ *betaPtr = beta = Min(beta + AspirationDelta * (1 << researchCountFH), VALUE_INFINITE);
+ researchCountFH++;
} // End of fail high loop
break;
// Remember beta-cutoff and searched nodes counts for this move. The
- // info is used to sort the root moves at the next iteration.
+ // info is used to sort the root moves for the next iteration.
int64_t our, their;
TM.get_beta_counters(pos.side_to_move(), our, their);
rml.set_beta_counters(i, our, their);
rml.set_move_nodes(i, TM.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_move_score(i, -VALUE_INFINITE);
else
// Print information to the standard output
print_pv_info(pos, ss, alpha, beta, value);
- // Raise alpha to setup proper non-pv search upper bound, note
- // that we can end up with alpha >= beta and so get a fail high.
+ // Raise alpha to setup proper non-pv search upper bound
if (value > alpha)
alpha = value;
}
}
} // PV move or new best move
- assert(alpha >= oldAlpha);
+ assert(alpha >= *alphaPtr);
- AspirationFailLow = (alpha == oldAlpha);
+ AspirationFailLow = (alpha == *alphaPtr);
if (AspirationFailLow && StopOnPonderhit)
StopOnPonderhit = false;
}
// Can we exit fail low loop ?
- if (AbortSearch || alpha > oldAlpha)
+ if (AbortSearch || !AspirationFailLow)
break;
// Prepare for a research after a fail low, each time with a wider window
- researchCount++;
- alpha = Max(alpha - AspirationDelta * (1 << researchCount), -VALUE_INFINITE);
- oldAlpha = alpha;
+ *alphaPtr = alpha = Max(alpha - AspirationDelta * (1 << researchCountFL), -VALUE_INFINITE);
+ researchCountFL++;
} // Fail low loop
+ // Sort the moves before to return
+ rml.sort();
+
return alpha;
}
&& !AbortSearch
&& !TM.thread_should_stop(threadID)
&& TM.split(pos, ss, ply, &alpha, beta, &bestValue,
- depth, &moveCount, &mp, threadID, true))
+ depth, mateThreat, &moveCount, &mp, threadID, true))
break;
}
Value rbeta = beta - razor_margin(depth);
Value v = qsearch(pos, ss, rbeta-1, rbeta, Depth(0), ply, threadID);
if (v < rbeta)
- return v; //FIXME: Logically should be: return (v + razor_margin(depth));
+ // Logically we should return (v + razor_margin(depth)), but
+ // surprisingly this did slightly weaker in tests.
+ return v;
}
// Step 7. Static null move pruning
&& !AbortSearch
&& !TM.thread_should_stop(threadID)
&& TM.split(pos, ss, ply, NULL, beta, &bestValue,
- depth, &moveCount, &mp, threadID, false))
+ depth, mateThreat, &moveCount, &mp, threadID, false))
break;
}
// splitting, we don't have to repeat all this work in sp_search(). We
// also don't need to store anything to the hash table here: This is taken
// care of after we return from the split point.
- // FIXME: We are currently ignoring mateThreat flag here
void sp_search(SplitPoint* sp, int threadID) {
captureOrPromotion = pos.move_is_capture_or_promotion(move);
// Step 11. Decide the new search depth
- ext = extension(pos, move, false, captureOrPromotion, moveIsCheck, false, false, &dangerous);
+ ext = extension(pos, move, false, captureOrPromotion, moveIsCheck, false, sp->mateThreat, &dangerous);
newDepth = sp->depth - OnePly + ext;
// Update current move
// don't have to repeat all this work in sp_search_pv(). We also don't
// need to store anything to the hash table here: This is taken care of
// after we return from the split point.
- // FIXME: We are ignoring mateThreat flag!
void sp_search_pv(SplitPoint* sp, int threadID) {
captureOrPromotion = pos.move_is_capture_or_promotion(move);
// Step 11. Decide the new search depth
- ext = extension(pos, move, true, captureOrPromotion, moveIsCheck, false, false, &dangerous);
+ ext = extension(pos, move, true, captureOrPromotion, moveIsCheck, false, sp->mateThreat, &dangerous);
newDepth = sp->depth - OnePly + ext;
// Update current move
if (PonderSearch)
return;
- bool stillAtFirstMove = RootMoveNumber == 1
+ bool stillAtFirstMove = FirstRootMove
&& !AspirationFailLow
&& t > MaxSearchTime + ExtraSearchTime;
int t = current_search_time();
PonderSearch = false;
- bool stillAtFirstMove = RootMoveNumber == 1
+ bool stillAtFirstMove = FirstRootMove
&& !AspirationFailLow
&& t > MaxSearchTime + ExtraSearchTime;
bool ThreadsManager::split(const Position& p, SearchStack* sstck, int ply,
Value* alpha, const Value beta, Value* bestValue,
- Depth depth, int* moves, MovePicker* mp, int master, bool pvNode) {
+ Depth depth, bool mateThreat, int* moves, MovePicker* mp, int master, bool pvNode) {
assert(p.is_ok());
assert(sstck != NULL);
splitPoint->stopRequest = false;
splitPoint->ply = ply;
splitPoint->depth = depth;
+ splitPoint->mateThreat = mateThreat;
splitPoint->alpha = pvNode ? *alpha : beta - 1;
splitPoint->beta = beta;
splitPoint->pvNode = pvNode;
projects / stockfish / blobdiff