Stockfish, a UCI chess playing engine derived from Glaurung 2.1
Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad
+ Copyright (C) 2015-2016 Marco Costalba, Joona Kiiski, Gary Linscott, 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
};
EasyMoveManager EasyMove;
- bool easyPlayed, failedLow;
- double BestMoveChanges;
Value DrawValue[COLOR_NB];
CounterMovesHistoryStats CounterMovesHistory;
th->history.clear();
th->counterMoves.clear();
}
+
+ Threads.main()->previousMoveScore = VALUE_INFINITE;
}
if (th != this)
th->wait_for_search_finished();
- // Check if there are threads with a better score than main thread.
+ // Check if there are threads with a better score than main thread
Thread* bestThread = this;
- if (!easyPlayed && Options["MultiPV"] == 1 && !Skill(Options["Skill Level"]).enabled())
+ if ( !this->easyMovePlayed
+ && Options["MultiPV"] == 1
+ && !Skill(Options["Skill Level"]).enabled())
+ {
for (Thread* th : Threads)
if ( th->completedDepth > bestThread->completedDepth
&& th->rootMoves[0].score > bestThread->rootMoves[0].score)
- bestThread = th;
+ bestThread = th;
+ }
- // Send new PV when needed.
- // FIXME: Breaks multiPV, and skill levels
+ previousMoveScore = bestThread->rootMoves[0].score;
+
+ // Send new PV when needed
if (bestThread != this)
sync_cout << UCI::pv(bestThread->rootPos, bestThread->completedDepth, -VALUE_INFINITE, VALUE_INFINITE) << sync_endl;
Stack stack[MAX_PLY+4], *ss = stack+2; // To allow referencing (ss-2) and (ss+2)
Value bestValue, alpha, beta, delta;
Move easyMove = MOVE_NONE;
- bool isMainThread = (this == Threads.main());
+ MainThread* mainThread = (this == Threads.main() ? Threads.main() : nullptr);
std::memset(ss-2, 0, 5 * sizeof(Stack));
beta = VALUE_INFINITE;
completedDepth = DEPTH_ZERO;
- if (isMainThread)
+ if (mainThread)
{
easyMove = EasyMove.get(rootPos.key());
EasyMove.clear();
- easyPlayed = false;
- BestMoveChanges = 0;
+ mainThread->easyMovePlayed = mainThread->failedLow = false;
+ mainThread->bestMoveChanges = 0;
TT.new_search();
}
{
// Set up the new depth for the helper threads skipping in average each
// 2nd ply (using a half density map similar to a Hadamard matrix).
- if (!isMainThread)
+ if (!mainThread)
{
int d = rootDepth + rootPos.game_ply();
{
// Table of values of 6 bits with 3 of them set
static const int HalfDensityMap[] = {
- 0x07, 0x0b, 0x0d, 0x0e, 0x13, 0x16, 0x19, 0x1a, 0x1c,
- 0x23, 0x25, 0x26, 0x29, 0x2c, 0x31, 0x32, 0x34, 0x38
+ 0x07, 0x0b, 0x0d, 0x0e, 0x13, 0x16, 0x19, 0x1a, 0x1c,
+ 0x23, 0x25, 0x26, 0x29, 0x2c, 0x31, 0x32, 0x34, 0x38
};
if ((HalfDensityMap[idx - 7] >> (d % 6)) & 1)
}
// Age out PV variability metric
- if (isMainThread)
- BestMoveChanges *= 0.505, failedLow = false;
+ if (mainThread)
+ mainThread->bestMoveChanges *= 0.505, mainThread->failedLow = false;
// Save the last iteration's scores before first PV line is searched and
// all the move scores except the (new) PV are set to -VALUE_INFINITE.
// When failing high/low give some update (without cluttering
// the UI) before a re-search.
- if ( isMainThread
+ if ( mainThread
&& multiPV == 1
&& (bestValue <= alpha || bestValue >= beta)
&& Time.elapsed() > 3000)
beta = (alpha + beta) / 2;
alpha = std::max(bestValue - delta, -VALUE_INFINITE);
- if (isMainThread)
+ if (mainThread)
{
- failedLow = true;
+ mainThread->failedLow = true;
Signals.stopOnPonderhit = false;
}
}
// Sort the PV lines searched so far and update the GUI
std::stable_sort(rootMoves.begin(), rootMoves.begin() + PVIdx + 1);
- if (!isMainThread)
+ if (!mainThread)
break;
if (Signals.stop)
if (!Signals.stop)
completedDepth = rootDepth;
- if (!isMainThread)
+ if (!mainThread)
continue;
// If skill level is enabled and time is up, pick a sub-optimal best move
{
// Take some extra time if the best move has changed
if (rootDepth > 4 * ONE_PLY && multiPV == 1)
- Time.pv_instability(BestMoveChanges);
+ Time.pv_instability(mainThread->bestMoveChanges);
// Stop the search if only one legal move is available or all
// of the available time has been used or we matched an easyMove
// from the previous search and just did a fast verification.
if ( rootMoves.size() == 1
- || Time.elapsed() > Time.available() * (failedLow? 641 : 315)/640
- || ( easyPlayed = ( rootMoves[0].pv[0] == easyMove
- && BestMoveChanges < 0.03
- && Time.elapsed() > Time.available() / 8)))
+ || Time.elapsed() > Time.available() * ( 640 - 160 * !mainThread->failedLow
+ - 126 * (bestValue >= mainThread->previousMoveScore)
+ - 124 * (bestValue >= mainThread->previousMoveScore && !mainThread->failedLow))/640
+ || ( mainThread->easyMovePlayed = ( rootMoves[0].pv[0] == easyMove
+ && mainThread->bestMoveChanges < 0.03
+ && Time.elapsed() > Time.available() * 25/206)))
{
// If we are allowed to ponder do not stop the search now but
// keep pondering until the GUI sends "ponderhit" or "stop".
}
}
- if (!isMainThread)
+ if (!mainThread)
return;
// Clear any candidate easy move that wasn't stable for the last search
// iterations; the second condition prevents consecutive fast moves.
- if (EasyMove.stableCnt < 6 || easyPlayed)
+ if (EasyMove.stableCnt < 6 || mainThread->easyMovePlayed)
EasyMove.clear();
// If skill level is enabled, swap best PV line with the sub-optimal one
assert(0 <= ss->ply && ss->ply < MAX_PLY);
ss->currentMove = (ss+1)->excludedMove = bestMove = MOVE_NONE;
- (ss+1)->skipEarlyPruning = false; (ss+1)->reduction = DEPTH_ZERO;
+ (ss+1)->skipEarlyPruning = false;
(ss+2)->killers[0] = (ss+2)->killers[1] = MOVE_NONE;
// Step 4. Transposition table lookup. We don't want the score of a partial
// re-searched at full depth.
if ( depth >= 3 * ONE_PLY
&& moveCount > 1
- && !captureOrPromotion
- && move != ss->killers[0]
- && move != ss->killers[1])
+ && !captureOrPromotion)
{
-
ss->reduction = reduction<PvNode>(improving, depth, moveCount);
+
Depth r = reduction<PvNode>(improving, depth, moveCount);
// Increase reduction for cut nodes and moves with a bad history
if ( (!PvNode && cutNode)
|| ( thisThread->history[pos.piece_on(to_sq(move))][to_sq(move)] < VALUE_ZERO
&& cmh[pos.piece_on(to_sq(move))][to_sq(move)] <= VALUE_ZERO))
- ss->reduction += ONE_PLY;
+ r += ONE_PLY;
// Decrease reduction for moves with a good history
if ( thisThread->history[pos.piece_on(to_sq(move))][to_sq(move)] > VALUE_ZERO
&& cmh[pos.piece_on(to_sq(move))][to_sq(move)] > VALUE_ZERO)
- ss->reduction = std::max(DEPTH_ZERO, ss->reduction - ONE_PLY);
+ r = std::max(DEPTH_ZERO, r - ONE_PLY);
- // Decrease reduction for moves that escape a capture
- if ( ss->reduction
+ // Decrease reduction for moves that escape a capture. Filter out castling
+ // moves because are coded as "king captures rook" and break make_move().
+ // Also use see() instead of see_sign() because destination square is empty.
+ if ( r
&& type_of(move) == NORMAL
&& type_of(pos.piece_on(to_sq(move))) != PAWN
&& pos.see(make_move(to_sq(move), from_sq(move))) < VALUE_ZERO)
- ss->reduction = std::max(DEPTH_ZERO, ss->reduction - ONE_PLY);
+ r = std::max(DEPTH_ZERO, r - ONE_PLY);
- Depth d = std::max(newDepth - ss->reduction, ONE_PLY);
+ Depth d = std::max(newDepth - r, ONE_PLY);
value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, d, true);
- doFullDepthSearch = (value > alpha && ss->reduction != DEPTH_ZERO);
- ss->reduction = DEPTH_ZERO;
+ doFullDepthSearch = (value > alpha && r != DEPTH_ZERO);
}
else
doFullDepthSearch = !PvNode || moveCount > 1;
// iteration. This information is used for time management: When
// the best move changes frequently, we allocate some more time.
if (moveCount > 1 && thisThread == Threads.main())
- ++BestMoveChanges;
+ ++static_cast<MainThread*>(thisThread)->bestMoveChanges;
}
else
// All other moves but the PV are set to the lowest value: this is
projects / stockfish / blobdiff