void History::clear() {
memset(history, 0, 2 * 8 * 64 * sizeof(int));
- memset(successCount, 0, 2 * 8 * 64 * sizeof(int));
- memset(failureCount, 0, 2 * 8 * 64 * sizeof(int));
}
assert(square_is_ok(to));
history[p][to] += int(d) * int(d);
- successCount[p][to]++;
// Prevent history overflow
if (history[p][to] >= HistoryMax)
/// called for each non-capturing move which failed to produce a beta cutoff
/// at a node where a beta cutoff was finally found.
-void History::failure(Piece p, Square to) {
+void History::failure(Piece p, Square to, Depth d) {
assert(piece_is_ok(p));
assert(square_is_ok(to));
- failureCount[p][to]++;
+ history[p][to] -= int(d) * int(d);
+ if (history[p][to] < 0)
+ history[p][to] = 0;
}
return history[p][to];
}
-
-
-/// History::ok_to_prune() decides whether a move has been sufficiently
-/// unsuccessful that it makes sense to prune it entirely.
-
-bool History::ok_to_prune(Piece p, Square to, Depth d) const {
-
- assert(piece_is_ok(p));
- assert(square_is_ok(to));
-
- return (int(d) * successCount[p][to] < failureCount[p][to]);
-}
History();
void clear();
void success(Piece p, Square to, Depth d);
- void failure(Piece p, Square to);
+ void failure(Piece p, Square to, Depth d);
int move_ordering_score(Piece p, Square to) const;
- bool ok_to_prune(Piece p, Square to, Depth d) const;
private:
int history[16][64]; // [piece][square]
- int successCount[16][64];
- int failureCount[16][64];
};
bool move_is_killer(Move m, const SearchStack& ss);
Depth extension(const Position& pos, Move m, bool pvNode, bool capture, bool check, bool singleReply, bool mateThreat, bool* dangerous);
bool ok_to_do_nullmove(const Position& pos);
- bool ok_to_prune(const Position& pos, Move m, Move threat, Depth d);
+ bool ok_to_prune(const Position& pos, Move m, Move threat);
bool ok_to_use_TT(const TTEntry* tte, Depth depth, Value beta, int ply);
void update_history(const Position& pos, Move m, Depth depth, Move movesSearched[], int moveCount);
void update_killers(Move m, SearchStack& ss);
&& !captureOrPromotion
&& move != ttMove)
{
- // History pruning. See ok_to_prune() definition
+ // Move count based pruning
if ( moveCount >= FutilityMoveCountMargin
- && ok_to_prune(pos, move, ss[ply].threatMove, depth)
+ && ok_to_prune(pos, move, ss[ply].threatMove)
&& bestValue > value_mated_in(PLY_MAX))
continue;
&& !dangerous
&& !captureOrPromotion)
{
- // History pruning. See ok_to_prune() definition
+ // Move count based pruning
if ( moveCount >= 2 + int(sp->depth)
- && ok_to_prune(pos, move, ss[sp->ply].threatMove, sp->depth)
+ && ok_to_prune(pos, move, ss[sp->ply].threatMove)
&& sp->bestValue > value_mated_in(PLY_MAX))
continue;
// non-tactical moves late in the move list close to the leaves are
// candidates for pruning.
- bool ok_to_prune(const Position& pos, Move m, Move threat, Depth d) {
+ bool ok_to_prune(const Position& pos, Move m, Move threat) {
assert(move_is_ok(m));
assert(threat == MOVE_NONE || move_is_ok(threat));
&& pos.move_attacks_square(m, tto))
return false;
- // Case 4: Don't prune moves with good history
- if (!H.ok_to_prune(pos.piece_on(mfrom), mto, d))
- return false;
-
- // Case 5: If the moving piece in the threatened move is a slider, don't
+ // Case 4: If the moving piece in the threatened move is a slider, don't
// prune safe moves which block its ray.
if ( !PruneBlockingMoves
&& threat != MOVE_NONE
{
assert(m != movesSearched[i]);
if (!pos.move_is_capture_or_promotion(movesSearched[i]))
- H.failure(pos.piece_on(move_from(movesSearched[i])), move_to(movesSearched[i]));
+ H.failure(pos.piece_on(move_from(movesSearched[i])), move_to(movesSearched[i]), depth);
}
}