#include "book.h"
#include "evaluate.h"
#include "history.h"
-#include "maxgain.h"
#include "misc.h"
#include "movegen.h"
#include "movepick.h"
// History table
History H;
- // MaxGain table
- MaxGain MG;
-
/// Functions
Value id_loop(const Position& pos, Move searchMoves[]);
Value refine_eval(const TTEntry* tte, Value defaultEval, int ply);
void update_history(const Position& pos, Move move, Depth depth, Move movesSearched[], int moveCount);
void update_killers(Move m, SearchStack& ss);
+ void update_gains(const Position& pos, Move move, Value before, Value after);
bool fail_high_ply_1();
int current_search_time();
tte = TT.retrieve(pos.get_key());
}
- // Evaluate the position statically
isCheck = pos.is_check();
- EvalInfo ei;
if (!isCheck)
{
+ // Update gain statistics of the previous move that lead
+ // us in this position.
+ EvalInfo ei;
ss[ply].eval = evaluate(pos, ei, threadID);
-
- // Store gain statistics
- Move m = ss[ply - 1].currentMove;
- if ( m != MOVE_NULL
- && pos.captured_piece() == NO_PIECE_TYPE
- && !move_is_castle(m)
- && !move_is_promotion(m))
- MG.store(pos.piece_on(move_to(m)), move_from(m), move_to(m), ss[ply - 1].eval, -ss[ply].eval);
-
+ update_gains(pos, ss[ply - 1].currentMove, ss[ply - 1].eval, ss[ply].eval);
}
// Initialize a MovePicker object for the current position, and prepare
Move ttMove, move;
Depth ext, newDepth;
Value bestValue, staticValue, nullValue, value, futilityValue, futilityValueScaled;
- bool isCheck, useFutilityPruning, singleEvasion, moveIsCheck, captureOrPromotion, dangerous;
+ bool isCheck, singleEvasion, moveIsCheck, captureOrPromotion, dangerous;
bool mateThreat = false;
int moveCount = 0;
futilityValue = staticValue = bestValue = value = -VALUE_INFINITE;
// Calculate depth dependant futility pruning parameters
const int FutilityMoveCountMargin = 3 + (1 << (3 * int(depth) / 8));
- const int FutilityValueMargin = 112 * bitScanReverse32(int(depth) * int(depth) / 2);
+ const int PostFutilityValueMargin = 112 * bitScanReverse32(int(depth) * int(depth) / 2);
// Evaluate the position statically
if (!isCheck)
}
ss[ply].eval = staticValue;
- futilityValue = staticValue + FutilityValueMargin;
+ futilityValue = staticValue + PostFutilityValueMargin; //FIXME: Remove me, only for split
staticValue = refine_eval(tte, staticValue, ply); // Enhance accuracy with TT value if possible
-
- // Store gain statistics
- Move m = ss[ply - 1].currentMove;
- if ( m != MOVE_NULL
- && pos.captured_piece() == NO_PIECE_TYPE
- && !move_is_castle(m)
- && !move_is_promotion(m))
- MG.store(pos.piece_on(move_to(m)), move_from(m), move_to(m), ss[ply - 1].eval, -ss[ply].eval);
+ update_gains(pos, ss[ply - 1].currentMove, ss[ply - 1].eval, ss[ply].eval);
}
+ // Do a "stand pat". If we are above beta by a good margin then
+ // return immediately.
+ // FIXME: test with added condition 'allowNullmove || depth <= OnePly' and !value_is_mate(beta)
+ // FIXME: test with modified condition 'depth < RazorDepth'
+ if ( !isCheck
+ && depth < SelectiveDepth
+ && staticValue - PostFutilityValueMargin >= beta)
+ return staticValue - PostFutilityValueMargin;
+
// Null move search
if ( allowNullmove
&& depth > OnePly
// to search all moves.
MovePicker mp = MovePicker(pos, ttMove, depth, H, &ss[ply]);
CheckInfo ci(pos);
- useFutilityPruning = depth < SelectiveDepth && !isCheck;
// Loop through all legal moves until no moves remain or a beta cutoff occurs
while ( bestValue < beta
// Update current move
movesSearched[moveCount++] = ss[ply].currentMove = move;
+ // Futility pruning for captures
+ // FIXME: test disabling 'Futility pruning for captures'
+ // FIXME: test with 'newDepth < RazorDepth'
+ Color them = opposite_color(pos.side_to_move());
+
+ if ( !isCheck
+ && newDepth < SelectiveDepth
+ && !dangerous
+ && pos.move_is_capture(move)
+ && !pos.move_is_check(move, ci)
+ && !move_is_promotion(move)
+ && move != ttMove
+ && !move_is_ep(move)
+ && (pos.type_of_piece_on(move_to(move)) != PAWN || !pos.pawn_is_passed(them, move_to(move)))) // Do not prune passed pawn captures
+ {
+ int preFutilityValueMargin = 0;
+
+ if (newDepth >= OnePly)
+ preFutilityValueMargin = 112 * bitScanReverse32(int(newDepth) * int(newDepth) / 2);
+
+ Value futilityCaptureValue = ss[ply].eval + pos.endgame_value_of_piece_on(move_to(move)) + preFutilityValueMargin + ei.futilityMargin + 90;
+
+ if (futilityCaptureValue < beta)
+ {
+ if (futilityCaptureValue > bestValue)
+ bestValue = futilityCaptureValue;
+ continue;
+ }
+ }
+
// Futility pruning
- if ( useFutilityPruning
+ if ( !isCheck
&& !dangerous
&& !captureOrPromotion
+ && !move_is_castle(move)
&& move != ttMove)
{
// Move count based pruning
continue;
// Value based pruning
- futilityValueScaled = futilityValue - moveCount * IncrementalFutilityMargin;
+ Depth predictedDepth = newDepth;
- if (futilityValueScaled < beta)
+ //FIXME HACK: awful code duplication
+ double red = 0.5 + ln(moveCount) * ln(depth / 2) / 3.0;
+ if (red >= 1.0)
+ predictedDepth -= int(floor(red * int(OnePly)));
+
+ if (predictedDepth < SelectiveDepth)
{
- if (futilityValueScaled > bestValue)
- bestValue = futilityValueScaled;
- continue;
+ int preFutilityValueMargin = 0;
+ if (predictedDepth >= OnePly)
+ preFutilityValueMargin = 112 * bitScanReverse32(int(predictedDepth) * int(predictedDepth) / 2);
+
+ preFutilityValueMargin += H.gain(pos.piece_on(move_from(move)), move_from(move), move_to(move)) + 45;
+
+ futilityValueScaled = ss[ply].eval + preFutilityValueMargin - moveCount * IncrementalFutilityMargin;
+
+ if (futilityValueScaled < beta)
+ {
+ if (futilityValueScaled > bestValue)
+ bestValue = futilityValueScaled;
+ continue;
+ }
}
}
&& idle_thread_exists(threadID)
&& !AbortSearch
&& !thread_should_stop(threadID)
- && split(pos, ss, ply, &beta, &beta, &bestValue, futilityValue,
+ && split(pos, ss, ply, &beta, &beta, &bestValue, futilityValue, //FIXME: SMP & futilityValue
depth, &moveCount, &mp, threadID, false))
break;
}
if (!isCheck)
{
ss[ply].eval = staticValue;
- // Store gain statistics
- Move m = ss[ply - 1].currentMove;
- if ( m != MOVE_NULL
- && pos.captured_piece() == NO_PIECE_TYPE
- && !move_is_castle(m)
- && !move_is_promotion(m))
- MG.store(pos.piece_on(move_to(m)), move_from(m), move_to(m), ss[ply - 1].eval, -ss[ply].eval);
+ update_gains(pos, ss[ply - 1].currentMove, ss[ply - 1].eval, ss[ply].eval);
}
-
// Initialize "stand pat score", and return it immediately if it is
// at least beta.
bestValue = staticValue;
SearchStack* ss = sp->sstack[threadID];
Value value = -VALUE_INFINITE;
Move move;
+ int moveCount;
bool isCheck = pos.is_check();
bool useFutilityPruning = sp->depth < SelectiveDepth
&& !isCheck;
const int FutilityMoveCountMargin = 3 + (1 << (3 * int(sp->depth) / 8));
- while ( sp->bestValue < sp->beta
+ while ( lock_grab_bool(&(sp->lock))
+ && sp->bestValue < sp->beta
&& !thread_should_stop(threadID)
- && (move = sp->mp->get_next_move(sp->lock)) != MOVE_NONE)
+ && (move = sp->mp->get_next_move()) != MOVE_NONE)
{
+ moveCount = ++sp->moves;
+ lock_release(&(sp->lock));
+
assert(move_is_ok(move));
bool moveIsCheck = pos.move_is_check(move, ci);
bool captureOrPromotion = pos.move_is_capture_or_promotion(move);
- lock_grab(&(sp->lock));
- int moveCount = ++sp->moves;
- lock_release(&(sp->lock));
-
ss[sp->ply].currentMove = move;
- // Decide the new search depth.
+ // Decide the new search depth
bool dangerous;
Depth ext = extension(pos, move, false, captureOrPromotion, moveIsCheck, false, false, &dangerous);
Depth newDepth = sp->depth - OnePly + ext;
assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
if (thread_should_stop(threadID))
+ {
+ lock_grab(&(sp->lock));
break;
+ }
// New best move?
if (value > sp->bestValue) // Less then 2% of cases
}
}
- lock_grab(&(sp->lock));
+ /* Here we have the lock still grabbed */
// If this is the master thread and we have been asked to stop because of
// a beta cutoff higher up in the tree, stop all slave threads.
CheckInfo ci(pos);
SearchStack* ss = sp->sstack[threadID];
Value value = -VALUE_INFINITE;
+ int moveCount;
Move move;
- while ( sp->alpha < sp->beta
+ while ( lock_grab_bool(&(sp->lock))
+ && sp->alpha < sp->beta
&& !thread_should_stop(threadID)
- && (move = sp->mp->get_next_move(sp->lock)) != MOVE_NONE)
+ && (move = sp->mp->get_next_move()) != MOVE_NONE)
{
- bool moveIsCheck = pos.move_is_check(move, ci);
- bool captureOrPromotion = pos.move_is_capture_or_promotion(move);
+ moveCount = ++sp->moves;
+ lock_release(&(sp->lock));
assert(move_is_ok(move));
- lock_grab(&(sp->lock));
- int moveCount = ++sp->moves;
- lock_release(&(sp->lock));
+ bool moveIsCheck = pos.move_is_check(move, ci);
+ bool captureOrPromotion = pos.move_is_capture_or_promotion(move);
ss[sp->ply].currentMove = move;
- // Decide the new search depth.
+ // Decide the new search depth
bool dangerous;
Depth ext = extension(pos, move, true, captureOrPromotion, moveIsCheck, false, false, &dangerous);
Depth newDepth = sp->depth - OnePly + ext;
assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
if (thread_should_stop(threadID))
+ {
+ lock_grab(&(sp->lock));
break;
+ }
// New best move?
if (value > sp->bestValue) // Less then 2% of cases
}
}
- lock_grab(&(sp->lock));
+ /* Here we have the lock still grabbed */
// If this is the master thread and we have been asked to stop because of
// a beta cutoff higher up in the tree, stop all slave threads.
Square mfrom, mto, tfrom, tto;
- // Prune if there isn't any threat move and
- // is not a castling move (common case).
- if (threat == MOVE_NONE && !move_is_castle(m))
+ // Prune if there isn't any threat move
+ if (threat == MOVE_NONE)
return true;
mfrom = move_from(m);
tfrom = move_from(threat);
tto = move_to(threat);
- // Case 1: Castling moves are never pruned
- if (move_is_castle(m))
- return false;
-
- // Case 2: Don't prune moves which move the threatened piece
+ // Case 1: Don't prune moves which move the threatened piece
if (mfrom == tto)
return false;
- // Case 3: If the threatened piece has value less than or equal to the
+ // Case 2: If the threatened piece has value less than or equal to the
// value of the threatening piece, don't prune move which defend it.
if ( pos.move_is_capture(threat)
&& ( pos.midgame_value_of_piece_on(tfrom) >= pos.midgame_value_of_piece_on(tto)
&& pos.move_attacks_square(m, tto))
return false;
- // Case 4: If the moving piece in the threatened move is a slider, don't
+ // Case 3: If the moving piece in the threatened move is a slider, don't
// prune safe moves which block its ray.
if ( piece_is_slider(pos.piece_on(tfrom))
&& bit_is_set(squares_between(tfrom, tto), mto)
}
+ // update_gains() updates the gains table of a non-capture move given
+ // the static position evaluation before and after the move.
+
+ void update_gains(const Position& pos, Move m, Value before, Value after) {
+
+ if ( m != MOVE_NULL
+ && before != VALUE_NONE
+ && after != VALUE_NONE
+ && pos.captured_piece() == NO_PIECE_TYPE
+ && !move_is_castle(m)
+ && !move_is_promotion(m))
+ H.set_gain(pos.piece_on(move_to(m)), move_from(m), move_to(m), -(before + after));
+ }
+
+
// fail_high_ply_1() checks if some thread is currently resolving a fail
// high at ply 1 at the node below the first root node. This information
// is used for time management.
projects / stockfish / blobdiff