Move best = MOVE_NONE;
};
- struct FastMove {
- FastMove() { clear(); }
+ // EasyMoveManager struct is used to detect a so called 'easy move'; when PV is
+ // stable across multiple search iterations we can fast return the best move.
+ struct EasyMoveManager {
- inline void clear() {
- expectedPosKey = 0;
- pv3[0] = pv3[1] = pv3[2] = MOVE_NONE;
+ void clear() {
stableCnt = 0;
+ expectedPosKey = 0;
+ pv[0] = pv[1] = pv[2] = MOVE_NONE;
}
- void update(Position& pos) {
- // Keep track how many times in a row the PV stays stable 3 ply deep.
- const std::vector<Move>& RMpv = RootMoves[0].pv;
- if (RMpv.size() >= 3)
- {
- if (pv3[2] == RMpv[2])
- stableCnt++;
- else
- stableCnt = 0, pv3[2] = RMpv[2];
+ Move get(Key key) const {
+ return expectedPosKey == key ? pv[2] : MOVE_NONE;
+ }
- if (!expectedPosKey || pv3[0] != RMpv[0] || pv3[1] != RMpv[1])
- {
- pv3[0] = RMpv[0], pv3[1] = RMpv[1];
- StateInfo st[2];
- pos.do_move(RMpv[0], st[0], pos.gives_check(RMpv[0], CheckInfo(pos)));
- pos.do_move(RMpv[1], st[1], pos.gives_check(RMpv[1], CheckInfo(pos)));
- expectedPosKey = pos.key();
- pos.undo_move(RMpv[1]);
- pos.undo_move(RMpv[0]);
- }
+ void update(Position& pos, const std::vector<Move>& newPv) {
+
+ assert(newPv.size() >= 3);
+
+ // Keep track of how many times in a row 3rd ply remains stable
+ stableCnt = (newPv[2] == pv[2]) ? stableCnt + 1 : 0;
+
+ if (!std::equal(newPv.begin(), newPv.begin() + 3, pv))
+ {
+ std::copy(newPv.begin(), newPv.begin() + 3, pv);
+
+ StateInfo st[2];
+ pos.do_move(newPv[0], st[0], pos.gives_check(newPv[0], CheckInfo(pos)));
+ pos.do_move(newPv[1], st[1], pos.gives_check(newPv[1], CheckInfo(pos)));
+ expectedPosKey = pos.key();
+ pos.undo_move(newPv[1]);
+ pos.undo_move(newPv[0]);
}
- else
- clear();
}
- Key expectedPosKey;
- Move pv3[3];
int stableCnt;
- } FM;
+ Key expectedPosKey;
+ Move pv[3];
+ };
size_t PVIdx;
TimeManager TimeMgr;
+ EasyMoveManager EasyMove;
double BestMoveChanges;
Value DrawValue[COLOR_NB];
HistoryStats History;
CounterMovesHistoryStats CounterMovesHistory;
GainsStats Gains;
- MovesStats Countermoves, Followupmoves;
+ MovesStats Countermoves;
template <NodeType NT, bool SpNode>
Value search(Position& pos, Stack* ss, Value alpha, Value beta, Depth depth, bool cutNode);
}
for (Thread* th : Threads)
+ {
th->maxPly = 0;
+ th->notify_one(); // Wake up all the threads
+ }
Threads.timer->run = true;
- Threads.timer->notify_one(); // Wake up the recurring timer
+ Threads.timer->notify_one(); // Start the recurring timer
id_loop(RootPos); // Let's start searching !
Depth depth;
Value bestValue, alpha, beta, delta;
- // Init fastMove if the previous search generated a candidate and we now got the predicted position.
- const Move fastMove = (FM.expectedPosKey == pos.key()) ? FM.pv3[2] : MOVE_NONE;
- FM.clear();
+ Move easyMove = EasyMove.get(pos.key());
+ EasyMove.clear();
std::memset(ss-2, 0, 5 * sizeof(Stack));
CounterMovesHistory.clear();
Gains.clear();
Countermoves.clear();
- Followupmoves.clear();
size_t multiPV = Options["MultiPV"];
Skill skill(Options["Skill Level"]);
TimeMgr.pv_instability(BestMoveChanges);
// Stop the search if only one legal move is available or all
- // of the available time has been used or we matched a fastMove
+ // 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
|| now() - SearchTime > TimeMgr.available_time()
- || ( fastMove == RootMoves[0].pv[0]
+ || ( RootMoves[0].pv[0] == easyMove
&& BestMoveChanges < 0.03
- && 10 * (now() - SearchTime) > TimeMgr.available_time()))
+ && now() - SearchTime > TimeMgr.available_time() / 10))
{
// If we are allowed to ponder do not stop the search now but
// keep pondering until the GUI sends "ponderhit" or "stop".
}
}
- // Update fast move stats.
- FM.update(pos);
+ if (RootMoves[0].pv.size() >= 3)
+ EasyMove.update(pos, RootMoves[0].pv);
+ else
+ EasyMove.clear();
}
}
- // Clear any candidate fast move that wasn't completely stable for at least
- // the 6 final search iterations. (Independent of actual depth and thus TC.)
- // Time condition prevents consecutive fast moves.
- if (FM.stableCnt < 6 || now() - SearchTime < TimeMgr.available_time())
- FM.clear();
+ // 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 || now() - SearchTime < TimeMgr.available_time())
+ EasyMove.clear();
// If skill level is enabled, swap best PV line with the sub-optimal one
if (skill.enabled())
ss->ttMove = ttMove = RootNode ? RootMoves[PVIdx].pv[0] : ttHit ? tte->move() : MOVE_NONE;
ttValue = ttHit ? value_from_tt(tte->value(), ss->ply) : VALUE_NONE;
- // At non-PV nodes we check for a fail high/low. We don't probe at PV nodes
+ // At non-PV nodes we check for a fail high/low. We don't prune at PV nodes
if ( !PvNode
&& ttHit
&& tte->depth() >= depth
{
ss->currentMove = ttMove; // Can be MOVE_NONE
- // If ttMove is quiet, update killers, history, counter move and followup move on TT hit
+ // If ttMove is quiet, update killers, history, counter move on TT hit
if (ttValue >= beta && ttMove && !pos.capture_or_promotion(ttMove) && !inCheck)
update_stats(pos, ss, ttMove, depth, nullptr, 0);
Move countermoves[] = { Countermoves[pos.piece_on(prevMoveSq)][prevMoveSq].first,
Countermoves[pos.piece_on(prevMoveSq)][prevMoveSq].second };
- Square prevOwnMoveSq = to_sq((ss-2)->currentMove);
- Move followupmoves[] = { Followupmoves[pos.piece_on(prevOwnMoveSq)][prevOwnMoveSq].first,
- Followupmoves[pos.piece_on(prevOwnMoveSq)][prevOwnMoveSq].second };
-
- MovePicker mp(pos, ttMove, depth, History, CounterMovesHistory, countermoves, followupmoves, ss);
+ MovePicker mp(pos, ttMove, depth, History, CounterMovesHistory, countermoves, ss);
CheckInfo ci(pos);
value = bestValue; // Workaround a bogus 'uninitialized' warning under gcc
improving = ss->staticEval >= (ss-2)->staticEval
ss->reduction = reduction<PvNode>(improving, depth, moveCount);
if ( (!PvNode && cutNode)
- || History[pos.piece_on(to_sq(move))][to_sq(move)] < VALUE_ZERO)
+ || History[pos.piece_on(to_sq(move))][to_sq(move)] < VALUE_ZERO
+ || ( History[pos.piece_on(to_sq(move))][to_sq(move)]
+ + CounterMovesHistory[pos.piece_on(prevMoveSq)][prevMoveSq]
+ [pos.piece_on(to_sq(move))][to_sq(move)] < VALUE_ZERO))
ss->reduction += ONE_PLY;
if (move == countermoves[0] || move == countermoves[1])
if (value > alpha)
{
- // Clear fast move if unstable.
- if (PvNode && pos.key() == FM.expectedPosKey && (move != FM.pv3[2] || moveCount > 1))
- FM.clear();
+ // If there is an easy move for this position, clear it if unstable
+ if ( PvNode
+ && EasyMove.get(pos.key())
+ && (move != EasyMove.get(pos.key()) || moveCount > 1))
+ EasyMove.clear();
bestMove = SpNode ? splitPoint->bestMove = move : move;
bestValue = excludedMove ? alpha
: inCheck ? mated_in(ss->ply) : DrawValue[pos.side_to_move()];
- // Quiet best move: update killers, history, countermoves and followupmoves
+ // Quiet best move: update killers, history and countermoves
else if (bestValue >= beta && !pos.capture_or_promotion(bestMove) && !inCheck)
update_stats(pos, ss, bestMove, depth, quietsSearched, quietCount - 1);
*pv = MOVE_NONE;
}
- // update_stats() updates killers, history, countermoves and followupmoves
- // stats after a fail-high of a quiet move.
+ // update_stats() updates killers, history and countermoves stats after a fail-high
+ // of a quiet move.
void update_stats(const Position& pos, Stack* ss, Move move, Depth depth, Move* quiets, int quietsCnt) {
cmh.update(pos.moved_piece(quiets[i]), to_sq(quiets[i]), -bonus);
}
+ // Extra penalty for TT move in previous ply when it gets refuted
if (is_ok((ss-2)->currentMove) && (ss-1)->currentMove == (ss-1)->ttMove)
{
Square prevPrevSq = to_sq((ss-2)->currentMove);
- Followupmoves.update(pos.piece_on(prevPrevSq), prevPrevSq, move);
+ HistoryStats& ttMoveCmh = CounterMovesHistory[pos.piece_on(prevPrevSq)][prevPrevSq];
+ ttMoveCmh.update(pos.piece_on(prevSq), prevSq, -bonus - 2 * depth / ONE_PLY - 1);
}
}
assert(!this_sp || (this_sp->master == this && searching));
- while ( !exit
- && !(this_sp && this_sp->slavesMask.none()))
+ while (!exit && !(this_sp && this_sp->slavesMask.none()))
{
- // If there is nothing to do, sleep.
- while( !exit
- && !(this_sp && this_sp->slavesMask.none())
- && !searching)
- {
- if ( !this_sp
- && !Threads.main()->thinking)
- {
- std::unique_lock<Mutex> lk(mutex);
- while (!exit && !Threads.main()->thinking)
- sleepCondition.wait(lk);
- }
- else
- std::this_thread::yield();
- }
-
// If this thread has been assigned work, launch a search
while (searching)
{
sp->spinlock.release();
}
}
+
+ // If search is finished then sleep, otherwise just yield
+ if (!Threads.main()->thinking)
+ {
+ assert(!this_sp);
+
+ std::unique_lock<Mutex> lk(mutex);
+ while (!exit && !Threads.main()->thinking)
+ sleepCondition.wait(lk);
+ }
+ else
+ std::this_thread::yield(); // Wait for a new job or for our slaves to finish
}
}