// Futility lookup tables (initialized at startup) and their access functions
Value FutilityMargins[16][64]; // [depth][moveNumber]
- int FutilityMoveCounts[32]; // [depth]
+ int FutilityMoveCounts[2][32]; // [improving][depth]
inline Value futility_margin(Depth d, int mn) {
// Init futility move count array
for (d = 0; d < 32; d++)
- FutilityMoveCounts[d] = int(3.001 + 0.3 * pow(double(d), 1.8));
+ {
+ FutilityMoveCounts[1][d] = int(3.001 + 0.3 * pow(double(d), 1.8));
+ FutilityMoveCounts[0][d] = d < 5 ? FutilityMoveCounts[1][d]
+ : 3 * FutilityMoveCounts[1][d] / 4;
+ }
}
/// Search::perft() is our utility to verify move generation. All the leaf nodes
/// up to the given depth are generated and counted and the sum returned.
-size_t Search::perft(Position& pos, Depth depth) {
+static size_t perft(Position& pos, Depth depth) {
StateInfo st;
size_t cnt = 0;
for (MoveList<LEGAL> it(pos); *it; ++it)
{
pos.do_move(*it, st, ci, pos.move_gives_check(*it, ci));
- cnt += leaf ? MoveList<LEGAL>(pos).size() : perft(pos, depth - ONE_PLY);
+ cnt += leaf ? MoveList<LEGAL>(pos).size() : ::perft(pos, depth - ONE_PLY);
pos.undo_move(*it);
}
return cnt;
}
+size_t Search::perft(Position& pos, Depth depth) {
+ return depth > ONE_PLY ? ::perft(pos, depth) : MoveList<LEGAL>(pos).size();
+}
/// Search::think() is the external interface to Stockfish's search, and is
/// called by the main thread when the program receives the UCI 'go' command. It
else
DrawValue[WHITE] = DrawValue[BLACK] = VALUE_DRAW;
- if (Options["Use Search Log"])
+ if (Options["Write Search Log"])
{
Log log(Options["Search Log Filename"]);
log << "\nSearching: " << RootPos.fen()
for (size_t i = 0; i < Threads.size(); i++)
Threads[i]->maxPly = 0;
- Threads.sleepWhileIdle = Options["Use Sleeping Threads"];
+ Threads.sleepWhileIdle = Options["Idle Threads Sleep"];
// Set best timer interval to avoid lagging under time pressure. Timer is
// used to check for remaining available thinking time.
Threads.timer->msec = 0; // Stop the timer
Threads.sleepWhileIdle = true; // Send idle threads to sleep
- if (Options["Use Search Log"])
+ if (Options["Write Search Log"])
{
Time::point elapsed = Time::now() - SearchTime + 1;
void id_loop(Position& pos) {
- Stack stack[MAX_PLY_PLUS_2], *ss = stack+1; // To allow referencing (ss-1)
+ Stack stack[MAX_PLY_PLUS_3], *ss = stack+2; // To allow referencing (ss-2)
int depth, prevBestMoveChanges;
Value bestValue, alpha, beta, delta;
- memset(ss-1, 0, 4 * sizeof(Stack));
+ std::memset(ss-2, 0, 5 * sizeof(Stack));
(ss-1)->currentMove = MOVE_NULL; // Hack to skip update gains
depth = BestMoveChanges = 0;
if (Signals.stop)
return;
+ // When failing high/low give some update (without cluttering
+ // the UI) before to research.
+ if ( (bestValue <= alpha || bestValue >= beta)
+ && Time::now() - SearchTime > 3000)
+ sync_cout << uci_pv(pos, depth, alpha, beta) << sync_endl;
+
// In case of failing low/high increase aspiration window and
// research, otherwise exit the loop.
if (bestValue <= alpha)
delta += delta / 2;
assert(alpha >= -VALUE_INFINITE && beta <= VALUE_INFINITE);
-
- // Give some update (without cluttering the UI) before to research
- if (Time::now() - SearchTime > 3000)
- sync_cout << uci_pv(pos, depth, alpha, beta) << sync_endl;
}
// Sort the PV lines searched so far and update the GUI
if (skill.enabled() && skill.time_to_pick(depth))
skill.pick_move();
- if (Options["Use Search Log"])
+ if (Options["Write Search Log"])
{
RootMove& rm = RootMoves[0];
if (skill.best != MOVE_NONE)
Depth ext, newDepth;
Value bestValue, value, ttValue;
Value eval, nullValue, futilityValue;
- bool inCheck, givesCheck, pvMove, singularExtensionNode;
+ bool inCheck, givesCheck, pvMove, singularExtensionNode, improving;
bool captureOrPromotion, dangerous, doFullDepthSearch;
int moveCount, quietCount;
// Step 1. Initialize node
Thread* thisThread = pos.this_thread();
- moveCount = quietCount = 0;
inCheck = pos.checkers();
if (SpNode)
assert(splitPoint->bestValue > -VALUE_INFINITE && splitPoint->moveCount > 0);
- goto split_point_start;
+ goto moves_loop;
}
+ moveCount = quietCount = 0;
bestValue = -VALUE_INFINITE;
ss->currentMove = threatMove = (ss+1)->excludedMove = bestMove = MOVE_NONE;
ss->ply = (ss-1)->ply + 1;
// Step 5. Evaluate the position statically and update parent's gain statistics
if (inCheck)
+ {
ss->staticEval = ss->evalMargin = eval = VALUE_NONE;
+ goto moves_loop;
+ }
else if (tte)
{
Gains.update(pos.piece_on(to), to, -(ss-1)->staticEval - ss->staticEval);
}
- // Step 6. Razoring (is omitted in PV nodes)
+ // Step 6. Razoring (skipped when in check)
if ( !PvNode
&& depth < 4 * ONE_PLY
- && !inCheck
&& eval + razor_margin(depth) < beta
&& ttMove == MOVE_NONE
&& abs(beta) < VALUE_MATE_IN_MAX_PLY
return v;
}
- // Step 7. Static null move pruning (is omitted in PV nodes)
+ // Step 7. Static null move pruning (skipped when in check)
// We're betting that the opponent doesn't have a move that will reduce
// the score by more than futility_margin(depth) if we do a null move.
if ( !PvNode
&& !ss->skipNullMove
&& depth < 4 * ONE_PLY
- && !inCheck
&& eval - futility_margin(depth, (ss-1)->futilityMoveCount) >= beta
&& abs(beta) < VALUE_MATE_IN_MAX_PLY
&& abs(eval) < VALUE_KNOWN_WIN
if ( !PvNode
&& !ss->skipNullMove
&& depth > ONE_PLY
- && !inCheck
&& eval >= beta
&& abs(beta) < VALUE_MATE_IN_MAX_PLY
&& pos.non_pawn_material(pos.side_to_move()))
}
}
- // Step 9. ProbCut (is omitted in PV nodes)
+ // Step 9. ProbCut (skipped when in check)
// If we have a very good capture (i.e. SEE > seeValues[captured_piece_type])
// and a reduced search returns a value much above beta, we can (almost) safely
// prune the previous move.
if ( !PvNode
&& depth >= 5 * ONE_PLY
- && !inCheck
&& !ss->skipNullMove
&& abs(beta) < VALUE_MATE_IN_MAX_PLY)
{
}
}
- // Step 10. Internal iterative deepening
+ // Step 10. Internal iterative deepening (skipped when in check)
if ( depth >= (PvNode ? 5 * ONE_PLY : 8 * ONE_PLY)
&& ttMove == MOVE_NONE
- && (PvNode || (!inCheck && ss->staticEval + Value(256) >= beta)))
+ && (PvNode || ss->staticEval + Value(256) >= beta))
{
Depth d = depth - 2 * ONE_PLY - (PvNode ? DEPTH_ZERO : depth / 4);
ttMove = tte ? tte->move() : MOVE_NONE;
}
-split_point_start: // At split points actual search starts from here
+moves_loop: // When in check and at SpNode search starts from here
Square prevMoveSq = to_sq((ss-1)->currentMove);
Move countermoves[] = { Countermoves[pos.piece_on(prevMoveSq)][prevMoveSq].first,
Countermoves[pos.piece_on(prevMoveSq)][prevMoveSq].second };
- MovePicker mp(pos, ttMove, depth, History, countermoves, ss, PvNode ? -VALUE_INFINITE : beta);
+ MovePicker mp(pos, ttMove, depth, History, countermoves, ss);
CheckInfo ci(pos);
value = bestValue; // Workaround a bogus 'uninitialized' warning under gcc
+ improving = ss->staticEval >= (ss-2)->staticEval;
singularExtensionNode = !RootNode
&& !SpNode
&& depth >= (PvNode ? 6 * ONE_PLY : 8 * ONE_PLY)
{
Signals.firstRootMove = (moveCount == 1);
- if (thisThread == Threads.main_thread() && Time::now() - SearchTime > 3000)
+ if (thisThread == Threads.main() && Time::now() - SearchTime > 3000)
sync_cout << "info depth " << depth / ONE_PLY
<< " currmove " << move_to_uci(move, pos.is_chess960())
<< " currmovenumber " << moveCount + PVIdx << sync_endl;
{
// Move count based pruning
if ( depth < 16 * ONE_PLY
- && moveCount >= FutilityMoveCounts[depth]
+ && moveCount >= FutilityMoveCounts[improving][depth]
&& (!threatMove || !refutes(pos, move, threatMove)))
{
if (SpNode)
Key posKey;
Move ttMove, move, bestMove;
Value bestValue, value, ttValue, futilityValue, futilityBase, oldAlpha;
- bool givesCheck, enoughMaterial, evasionPrunable;
+ bool givesCheck, evasionPrunable;
Depth ttDepth;
// To flag BOUND_EXACT a node with eval above alpha and no available moves
{
ss->staticEval = ss->evalMargin = VALUE_NONE;
bestValue = futilityBase = -VALUE_INFINITE;
- enoughMaterial = false;
}
else
{
alpha = bestValue;
futilityBase = ss->staticEval + ss->evalMargin + Value(128);
- enoughMaterial = pos.non_pawn_material(pos.side_to_move()) > RookValueMg;
}
// Initialize a MovePicker object for the current position, and prepare
&& !InCheck
&& !givesCheck
&& move != ttMove
- && enoughMaterial
&& type_of(move) != PROMOTION
&& !pos.is_passed_pawn_push(move))
{
}
// Detect non-capture evasions that are candidate to be pruned
- evasionPrunable = !PvNode
- && InCheck
+ evasionPrunable = InCheck
&& bestValue > VALUE_MATED_IN_MAX_PLY
&& !pos.is_capture(move)
&& !pos.can_castle(pos.side_to_move());
| (attacks_bb<BISHOP>(m2to, occ) & pos.pieces(color_of(pc), QUEEN, BISHOP));
// Verify attackers are triggered by our move and not already existing
- if (xray && (xray ^ (xray & pos.attacks_from<QUEEN>(m2to))))
+ if (unlikely(xray) && (xray & ~pos.attacks_from<QUEEN>(m2to)))
return true;
}
void RootMove::extract_pv_from_tt(Position& pos) {
- StateInfo state[MAX_PLY_PLUS_2], *st = state;
+ StateInfo state[MAX_PLY_PLUS_3], *st = state;
const TTEntry* tte;
int ply = 0;
Move m = pv[0];
void RootMove::insert_pv_in_tt(Position& pos) {
- StateInfo state[MAX_PLY_PLUS_2], *st = state;
+ StateInfo state[MAX_PLY_PLUS_3], *st = state;
const TTEntry* tte;
int ply = 0;
Threads.mutex.lock();
assert(searching);
+ assert(activeSplitPoint);
SplitPoint* sp = activeSplitPoint;
Threads.mutex.unlock();
- Stack stack[MAX_PLY_PLUS_2], *ss = stack+1; // To allow referencing (ss-1)
+ Stack stack[MAX_PLY_PLUS_3], *ss = stack+2; // To allow referencing (ss-2)
Position pos(*sp->pos, this);
- memcpy(ss-1, sp->ss-1, 4 * sizeof(Stack));
+ std::memcpy(ss-2, sp->ss-2, 5 * sizeof(Stack));
ss->splitPoint = sp;
sp->mutex.lock();