Value value_to_tt(Value v, int ply);
Value value_from_tt(Value v, int ply);
void update_pv(Move* pv, Move move, Move* childPv);
- void update_stats(const Position& pos, Stack* ss, Move move, Depth depth, Move* quiets, int quietsCnt);
+ void update_stats(const Position& pos, Stack* ss, Move move, Move* quiets, int quietsCnt, Value bonus);
+ void update_opponent_stats(const Position& pos, Stack* ss, Value bonus);
void check_time();
} // namespace
{
th->history.clear();
th->counterMoves.clear();
+ th->fromTo.clear();
}
Threads.main()->previousScore = VALUE_INFINITE;
ss->currentMove = ttMove; // Can be MOVE_NONE
// If ttMove is quiet, update killers, history, counter move on TT hit
- if (ttValue >= beta && ttMove && !pos.capture_or_promotion(ttMove))
- update_stats(pos, ss, ttMove, depth, nullptr, 0);
+ if (ttValue >= beta && ttMove)
+ {
+ int d = depth / ONE_PLY;
+
+ if (!pos.capture_or_promotion(ttMove))
+ {
+ Value bonus = Value(d * d + 2 * d - 2);
+ update_stats(pos, ss, ttMove, nullptr, 0, bonus);
+ }
+ // Extra penalty for a quiet TT move in previous ply when it gets refuted
+ if ((ss-1)->moveCount == 1 && !pos.captured_piece_type())
+ {
+ Value penalty = Value(d * d + 4 * d + 1);
+ update_opponent_stats(pos, ss, -penalty);
+ }
+ }
return ttValue;
}
}
// Step 10. Internal iterative deepening (skipped when in check)
- if ( depth >= (PvNode ? 5 * ONE_PLY : 8 * ONE_PLY)
+ if ( depth >= 6 * ONE_PLY
&& !ttMove
&& (PvNode || ss->staticEval + 256 >= beta))
{
- Depth d = depth - 2 * ONE_PLY - (PvNode ? DEPTH_ZERO : depth / 4);
ss->skipEarlyPruning = true;
- search<NT>(pos, ss, alpha, beta, d, cutNode);
+ search<NT>(pos, ss, alpha, beta, 3 * depth / 4 - 2 * ONE_PLY, cutNode);
ss->skipEarlyPruning = false;
tte = TT.probe(posKey, ttHit);
if (moveCountPruning)
continue;
+ predictedDepth = std::max(newDepth - reduction<PvNode>(improving, depth, moveCount), DEPTH_ZERO);
+
// Countermoves based pruning
- if ( depth <= 4 * ONE_PLY
+ if ( predictedDepth < 3 * ONE_PLY
&& move != ss->killers[0]
&& (!cmh || (*cmh )[moved_piece][to_sq(move)] < VALUE_ZERO)
&& (!fmh || (*fmh )[moved_piece][to_sq(move)] < VALUE_ZERO)
&& (!fmh2 || (*fmh2)[moved_piece][to_sq(move)] < VALUE_ZERO || (cmh && fmh)))
continue;
- predictedDepth = std::max(newDepth - reduction<PvNode>(improving, depth, moveCount), DEPTH_ZERO);
-
// Futility pruning: parent node
if ( predictedDepth < 7 * ONE_PLY
&& ss->staticEval + 256 + 200 * predictedDepth / ONE_PLY <= alpha)
// re-searched at full depth.
if ( depth >= 3 * ONE_PLY
&& moveCount > 1
- && !captureOrPromotion)
+ && (!captureOrPromotion || moveCountPruning))
{
Depth r = reduction<PvNode>(improving, depth, moveCount);
- Value val = thisThread->history[moved_piece][to_sq(move)]
- + (cmh ? (*cmh )[moved_piece][to_sq(move)] : VALUE_ZERO)
- + (fmh ? (*fmh )[moved_piece][to_sq(move)] : VALUE_ZERO)
- + (fmh2 ? (*fmh2)[moved_piece][to_sq(move)] : VALUE_ZERO);
-
- // Increase reduction for cut nodes
- if (cutNode)
- r += 2 * ONE_PLY;
-
- // Decrease reduction for moves that escape a capture. Filter out
- // castling moves, because they are coded as "king captures rook" and
- // hence break make_move(). Also use see() instead of see_sign(),
- // because the destination square is empty.
- else if ( 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)
- r -= 2 * ONE_PLY;
-
- // Decrease/increase reduction for moves with a good/bad history
- int rHist = (val - 10000) / 20000;
- r = std::max(DEPTH_ZERO, r - rHist * ONE_PLY);
+
+ if (captureOrPromotion)
+ r -= r ? ONE_PLY : DEPTH_ZERO;
+ else
+ {
+ Value val = thisThread->history[moved_piece][to_sq(move)]
+ + (cmh ? (*cmh )[moved_piece][to_sq(move)] : VALUE_ZERO)
+ + (fmh ? (*fmh )[moved_piece][to_sq(move)] : VALUE_ZERO)
+ + (fmh2 ? (*fmh2)[moved_piece][to_sq(move)] : VALUE_ZERO)
+ + thisThread->fromTo.get(~pos.side_to_move(), move);
+
+ // Increase reduction for cut nodes
+ if (cutNode)
+ r += 2 * ONE_PLY;
+
+ // Decrease reduction for moves that escape a capture. Filter out
+ // castling moves, because they are coded as "king captures rook" and
+ // hence break make_move(). Also use see() instead of see_sign(),
+ // because the destination square is empty.
+ else if ( 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)
+ r -= 2 * ONE_PLY;
+
+ // Decrease/increase reduction for moves with a good/bad history
+ int rHist = (val - 8000) / 20000;
+ r = std::max(DEPTH_ZERO, r - rHist * ONE_PLY);
+ }
Depth d = std::max(newDepth - r, ONE_PLY);
value = -search<NonPV>(pos, ss+1, -(alpha+1), -alpha, d, true);
- doFullDepthSearch = (value > alpha && r != DEPTH_ZERO);
+ doFullDepthSearch = (value > alpha && d != newDepth);
}
else
doFullDepthSearch = !PvNode || moveCount > 1;
if (!moveCount)
bestValue = excludedMove ? alpha
: inCheck ? mated_in(ss->ply) : DrawValue[pos.side_to_move()];
+ else if (bestMove)
+ {
+ int d = depth / ONE_PLY;
- // Quiet best move: update killers, history and countermoves
- else if (bestMove && !pos.capture_or_promotion(bestMove))
- update_stats(pos, ss, bestMove, depth, quietsSearched, quietCount);
+ // Quiet best move: update killers, history and countermoves
+ if (!pos.capture_or_promotion(bestMove))
+ {
+ Value bonus = Value(d * d + 2 * d - 2);
+ update_stats(pos, ss, bestMove, quietsSearched, quietCount, bonus);
+ }
+ // Extra penalty for a quiet TT move in previous ply when it gets refuted
+ if ((ss-1)->moveCount == 1 && !pos.captured_piece_type())
+ {
+ Value penalty = Value(d * d + 4 * d + 1);
+ update_opponent_stats(pos, ss, -penalty);
+ }
+ }
// Bonus for prior countermove that caused the fail low
else if ( depth >= 3 * ONE_PLY
- && !bestMove
&& !pos.captured_piece_type()
&& is_ok((ss-1)->currentMove))
{
- Square prevSq = to_sq((ss-1)->currentMove);
- Value bonus = Value((depth / ONE_PLY) * (depth / ONE_PLY) + 2 * depth / ONE_PLY - 2);
- if ((ss-2)->counterMoves)
- (ss-2)->counterMoves->update(pos.piece_on(prevSq), prevSq, bonus);
-
- if ((ss-3)->counterMoves)
- (ss-3)->counterMoves->update(pos.piece_on(prevSq), prevSq, bonus);
-
- if ((ss-5)->counterMoves)
- (ss-5)->counterMoves->update(pos.piece_on(prevSq), prevSq, bonus);
+ int d = depth / ONE_PLY;
+ Value bonus = Value(d * d + 2 * d - 2);
+ update_opponent_stats(pos, ss, bonus);
}
tte->save(posKey, value_to_tt(bestValue, ss->ply),
}
+ // update_opponent_stats() updates countermoves for prior opponent move, i.e.
+ // (ss-1)->currentMove. Called for both capture and non-capture moves.
+
+ void update_opponent_stats(const Position& pos, Stack* ss, Value bonus) {
+
+ Square prevSq = to_sq((ss-1)->currentMove);
+
+ CounterMoveStats* cmh = (ss-2)->counterMoves;
+ CounterMoveStats* fmh1 = (ss-3)->counterMoves;
+ CounterMoveStats* fmh2 = (ss-5)->counterMoves;
+
+ if (cmh)
+ cmh->update(pos.piece_on(prevSq), prevSq, bonus);
+
+ if (fmh1)
+ fmh1->update(pos.piece_on(prevSq), prevSq, bonus);
+
+ if (fmh2)
+ fmh2->update(pos.piece_on(prevSq), prevSq, bonus);
+ }
+
+
// update_stats() updates killers, history, countermove and countermove plus
// follow-up move history when a new quiet best move is found.
void update_stats(const Position& pos, Stack* ss, Move move,
- Depth depth, Move* quiets, int quietsCnt) {
+ Move* quiets, int quietsCnt, Value bonus) {
if (ss->killers[0] != move)
{
ss->killers[0] = move;
}
- Value bonus = Value((depth / ONE_PLY) * (depth / ONE_PLY) + 2 * depth / ONE_PLY - 2);
-
- Square prevSq = to_sq((ss-1)->currentMove);
CounterMoveStats* cmh = (ss-1)->counterMoves;
- CounterMoveStats* fmh = (ss-2)->counterMoves;
+ CounterMoveStats* fmh1 = (ss-2)->counterMoves;
CounterMoveStats* fmh2 = (ss-4)->counterMoves;
- Thread* thisThread = pos.this_thread();
+ Color c = pos.side_to_move();
+ Thread* thisThread = pos.this_thread();
thisThread->history.update(pos.moved_piece(move), to_sq(move), bonus);
+ thisThread->fromTo.update(c, move, bonus);
if (cmh)
{
+ Square prevSq = to_sq((ss-1)->currentMove);
thisThread->counterMoves.update(pos.piece_on(prevSq), prevSq, move);
cmh->update(pos.moved_piece(move), to_sq(move), bonus);
}
- if (fmh)
- fmh->update(pos.moved_piece(move), to_sq(move), bonus);
+ if (fmh1)
+ fmh1->update(pos.moved_piece(move), to_sq(move), bonus);
if (fmh2)
fmh2->update(pos.moved_piece(move), to_sq(move), bonus);
for (int i = 0; i < quietsCnt; ++i)
{
thisThread->history.update(pos.moved_piece(quiets[i]), to_sq(quiets[i]), -bonus);
+ thisThread->fromTo.update(c, quiets[i], -bonus);
if (cmh)
cmh->update(pos.moved_piece(quiets[i]), to_sq(quiets[i]), -bonus);
- if (fmh)
- fmh->update(pos.moved_piece(quiets[i]), to_sq(quiets[i]), -bonus);
+ if (fmh1)
+ fmh1->update(pos.moved_piece(quiets[i]), to_sq(quiets[i]), -bonus);
if (fmh2)
fmh2->update(pos.moved_piece(quiets[i]), to_sq(quiets[i]), -bonus);
}
-
- // Extra penalty for a quiet TT move in previous ply when it gets refuted
- if ((ss-1)->moveCount == 1 && !pos.captured_piece_type())
- {
- if ((ss-2)->counterMoves)
- (ss-2)->counterMoves->update(pos.piece_on(prevSq), prevSq, -bonus - 2 * (depth + 1) / ONE_PLY - 1);
-
- if ((ss-3)->counterMoves)
- (ss-3)->counterMoves->update(pos.piece_on(prevSq), prevSq, -bonus - 2 * (depth + 1) / ONE_PLY - 1);
-
- if ((ss-5)->counterMoves)
- (ss-5)->counterMoves->update(pos.piece_on(prevSq), prevSq, -bonus - 2 * (depth + 1) / ONE_PLY - 1);
- }
}