kate/BadFish
1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-05-02 09:39:36 +00:00
Code Issues Releases Wiki Activity

Retire refine_eval()

Browse source 
Inline its content and better comment what it does through
some renaming.

No functional change.
This commit is contained in:
Marco Costalba 2012-10-22 09:50:00 +02:00
parent 5fc8b27db9
commit 70b1b79264
3 changed files with 36 additions and 49 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
src/movepick.cpp
View file

@ -79,12 +79,12 @@ MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const History& h,
killers[1].move = ss->killers[1]; killers[1].move = ss->killers[1];
// Consider sligtly negative captures as good if at low depth and far from beta // Consider sligtly negative captures as good if at low depth and far from beta
if (ss && ss->eval < beta - PawnValueMg && d < 3 * ONE_PLY) if (ss && ss->staticEval < beta - PawnValueMg && d < 3 * ONE_PLY)
captureThreshold = -PawnValueMg; captureThreshold = -PawnValueMg;
// Consider negative captures as good if still enough to reach beta // Consider negative captures as good if still enough to reach beta
else if (ss && ss->eval > beta) else if (ss && ss->staticEval > beta)
captureThreshold = beta - ss->eval; captureThreshold = beta - ss->staticEval;
} }
ttMove = (ttm && pos.is_pseudo_legal(ttm) ? ttm : MOVE_NONE); ttMove = (ttm && pos.is_pseudo_legal(ttm) ? ttm : MOVE_NONE);

77
src/search.cpp
View file

@ -107,7 +107,6 @@ namespace {
Value value_to_tt(Value v, int ply); Value value_to_tt(Value v, int ply);
Value value_from_tt(Value v, int ply); Value value_from_tt(Value v, int ply);
bool connected_threat(const Position& pos, Move m, Move threat); bool connected_threat(const Position& pos, Move m, Move threat);
Value refine_eval(const TTEntry* tte, Value ttValue, Value defaultEval);
Move do_skill_level(); Move do_skill_level();
string uci_pv(const Position& pos, int depth, Value alpha, Value beta); string uci_pv(const Position& pos, int depth, Value alpha, Value beta);
@ -486,7 +485,7 @@ namespace {
Move ttMove, move, excludedMove, bestMove, threatMove; Move ttMove, move, excludedMove, bestMove, threatMove;
Depth ext, newDepth; Depth ext, newDepth;
Value bestValue, value, ttValue; Value bestValue, value, ttValue;
Value refinedValue, nullValue, futilityValue; Value eval, nullValue, futilityValue;
bool inCheck, givesCheck, pvMove, singularExtensionNode; bool inCheck, givesCheck, pvMove, singularExtensionNode;
bool captureOrPromotion, dangerous, doFullDepthSearch; bool captureOrPromotion, dangerous, doFullDepthSearch;
int moveCount, playedMoveCount; int moveCount, playedMoveCount;
@ -576,40 +575,45 @@ namespace {
// Step 5. Evaluate the position statically and update parent's gain statistics // Step 5. Evaluate the position statically and update parent's gain statistics
if (inCheck) if (inCheck)
ss->eval = ss->evalMargin = refinedValue = VALUE_NONE; ss->staticEval = ss->evalMargin = eval = VALUE_NONE;
else if (tte) else if (tte)
{ {
assert(tte->static_value() != VALUE_NONE); assert(tte->static_value() != VALUE_NONE);
assert(ttValue != VALUE_NONE || tte->type() == BOUND_NONE);
ss->eval = tte->static_value(); ss->staticEval = eval = tte->static_value();
ss->evalMargin = tte->static_value_margin(); ss->evalMargin = tte->static_value_margin();
refinedValue = refine_eval(tte, ttValue, ss->eval);
// Can ttValue be used as a better position evaluation?
if ( ((tte->type() & BOUND_LOWER) && ttValue > eval)
|| ((tte->type() & BOUND_UPPER) && ttValue < eval))
eval = ttValue;
} }
else else
{ {
refinedValue = ss->eval = evaluate(pos, ss->evalMargin); eval = ss->staticEval = evaluate(pos, ss->evalMargin);
TT.store(posKey, VALUE_NONE, BOUND_NONE, DEPTH_NONE, MOVE_NONE, TT.store(posKey, VALUE_NONE, BOUND_NONE, DEPTH_NONE, MOVE_NONE,
ss->eval, ss->evalMargin); ss->staticEval, ss->evalMargin);
} }
// Update gain for the parent non-capture move given the static position // Update gain for the parent non-capture move given the static position
// evaluation before and after the move. // evaluation before and after the move.
if ( (move = (ss-1)->currentMove) != MOVE_NULL if ( (move = (ss-1)->currentMove) != MOVE_NULL
&& (ss-1)->eval != VALUE_NONE && (ss-1)->staticEval != VALUE_NONE
&& ss->eval != VALUE_NONE && ss->staticEval != VALUE_NONE
&& !pos.captured_piece_type() && !pos.captured_piece_type()
&& type_of(move) == NORMAL) && type_of(move) == NORMAL)
{ {
Square to = to_sq(move); Square to = to_sq(move);
H.update_gain(pos.piece_on(to), to, -(ss-1)->eval - ss->eval); H.update_gain(pos.piece_on(to), to, -(ss-1)->staticEval - ss->staticEval);
} }
// Step 6. Razoring (is omitted in PV nodes) // Step 6. Razoring (is omitted in PV nodes)
if ( !PvNode if ( !PvNode
&& depth < 4 * ONE_PLY && depth < 4 * ONE_PLY
&& !inCheck && !inCheck
&& refinedValue + razor_margin(depth) < beta && eval + razor_margin(depth) < beta
&& ttMove == MOVE_NONE && ttMove == MOVE_NONE
&& abs(beta) < VALUE_MATE_IN_MAX_PLY && abs(beta) < VALUE_MATE_IN_MAX_PLY
&& !pos.pawn_on_7th(pos.side_to_move())) && !pos.pawn_on_7th(pos.side_to_move()))
@ -629,17 +633,17 @@ namespace {
&& !ss->skipNullMove && !ss->skipNullMove
&& depth < 4 * ONE_PLY && depth < 4 * ONE_PLY
&& !inCheck && !inCheck
&& refinedValue - FutilityMargins[depth][0] >= beta && eval - FutilityMargins[depth][0] >= beta
&& abs(beta) < VALUE_MATE_IN_MAX_PLY && abs(beta) < VALUE_MATE_IN_MAX_PLY
&& pos.non_pawn_material(pos.side_to_move())) && pos.non_pawn_material(pos.side_to_move()))
return refinedValue - FutilityMargins[depth][0]; return eval - FutilityMargins[depth][0];
// Step 8. Null move search with verification search (is omitted in PV nodes) // Step 8. Null move search with verification search (is omitted in PV nodes)
if ( !PvNode if ( !PvNode
&& !ss->skipNullMove && !ss->skipNullMove
&& depth > ONE_PLY && depth > ONE_PLY
&& !inCheck && !inCheck
&& refinedValue >= beta && eval >= beta
&& abs(beta) < VALUE_MATE_IN_MAX_PLY && abs(beta) < VALUE_MATE_IN_MAX_PLY
&& pos.non_pawn_material(pos.side_to_move())) && pos.non_pawn_material(pos.side_to_move()))
{ {
@ -649,7 +653,7 @@ namespace {
Depth R = 3 * ONE_PLY + depth / 4; Depth R = 3 * ONE_PLY + depth / 4;
// Null move dynamic reduction based on value // Null move dynamic reduction based on value
if (refinedValue - PawnValueMg > beta) if (eval - PawnValueMg > beta)
R += ONE_PLY; R += ONE_PLY;
pos.do_null_move<true>(st); pos.do_null_move<true>(st);
@ -730,7 +734,7 @@ namespace {
// Step 10. Internal iterative deepening // Step 10. Internal iterative deepening
if ( depth >= (PvNode ? 5 * ONE_PLY : 8 * ONE_PLY) if ( depth >= (PvNode ? 5 * ONE_PLY : 8 * ONE_PLY)
&& ttMove == MOVE_NONE && ttMove == MOVE_NONE
&& (PvNode || (!inCheck && ss->eval + Value(256) >= beta))) && (PvNode || (!inCheck && ss->staticEval + Value(256) >= beta)))
{ {
Depth d = (PvNode ? depth - 2 * ONE_PLY : depth / 2); Depth d = (PvNode ? depth - 2 * ONE_PLY : depth / 2);
@ -862,7 +866,7 @@ split_point_start: // At split points actual search starts from here
// We illogically ignore reduction condition depth >= 3*ONE_PLY for predicted depth, // We illogically ignore reduction condition depth >= 3*ONE_PLY for predicted depth,
// but fixing this made program slightly weaker. // but fixing this made program slightly weaker.
Depth predictedDepth = newDepth - reduction<PvNode>(depth, moveCount); Depth predictedDepth = newDepth - reduction<PvNode>(depth, moveCount);
futilityValue = ss->eval + ss->evalMargin + futility_margin(predictedDepth, moveCount) futilityValue = ss->staticEval + ss->evalMargin + futility_margin(predictedDepth, moveCount)
+ H.gain(pos.piece_moved(move), to_sq(move)); + H.gain(pos.piece_moved(move), to_sq(move));
if (futilityValue < beta) if (futilityValue < beta)
@ -1038,7 +1042,7 @@ split_point_start: // At split points actual search starts from here
if (bestValue >= beta) // Failed high if (bestValue >= beta) // Failed high
{ {
TT.store(posKey, value_to_tt(bestValue, ss->ply), BOUND_LOWER, depth, TT.store(posKey, value_to_tt(bestValue, ss->ply), BOUND_LOWER, depth,
bestMove, ss->eval, ss->evalMargin); bestMove, ss->staticEval, ss->evalMargin);
if (!pos.is_capture_or_promotion(bestMove) && !inCheck) if (!pos.is_capture_or_promotion(bestMove) && !inCheck)
{ {
@ -1063,7 +1067,7 @@ split_point_start: // At split points actual search starts from here
else // Failed low or PV search else // Failed low or PV search
TT.store(posKey, value_to_tt(bestValue, ss->ply), TT.store(posKey, value_to_tt(bestValue, ss->ply),
PvNode && bestMove != MOVE_NONE ? BOUND_EXACT : BOUND_UPPER, PvNode && bestMove != MOVE_NONE ? BOUND_EXACT : BOUND_UPPER,
depth, bestMove, ss->eval, ss->evalMargin); depth, bestMove, ss->staticEval, ss->evalMargin);
assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE); assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE);
@ -1127,7 +1131,7 @@ split_point_start: // At split points actual search starts from here
// Evaluate the position statically // Evaluate the position statically
if (inCheck) if (inCheck)
{ {
ss->eval = ss->evalMargin = VALUE_NONE; ss->staticEval = ss->evalMargin = VALUE_NONE;
bestValue = futilityBase = -VALUE_INFINITE; bestValue = futilityBase = -VALUE_INFINITE;
enoughMaterial = false; enoughMaterial = false;
} }
@ -1137,18 +1141,18 @@ split_point_start: // At split points actual search starts from here
{ {
assert(tte->static_value() != VALUE_NONE); assert(tte->static_value() != VALUE_NONE);
ss->eval = bestValue = tte->static_value(); ss->staticEval = bestValue = tte->static_value();
ss->evalMargin = tte->static_value_margin(); ss->evalMargin = tte->static_value_margin();
} }
else else
ss->eval = bestValue = evaluate(pos, ss->evalMargin); ss->staticEval = bestValue = evaluate(pos, ss->evalMargin);
// Stand pat. Return immediately if static value is at least beta // Stand pat. Return immediately if static value is at least beta
if (bestValue >= beta) if (bestValue >= beta)
{ {
if (!tte) if (!tte)
TT.store(pos.key(), value_to_tt(bestValue, ss->ply), BOUND_LOWER, TT.store(pos.key(), value_to_tt(bestValue, ss->ply), BOUND_LOWER,
DEPTH_NONE, MOVE_NONE, ss->eval, ss->evalMargin); DEPTH_NONE, MOVE_NONE, ss->staticEval, ss->evalMargin);
return bestValue; return bestValue;
} }
@ -1156,7 +1160,7 @@ split_point_start: // At split points actual search starts from here
if (PvNode && bestValue > alpha) if (PvNode && bestValue > alpha)
alpha = bestValue; alpha = bestValue;
futilityBase = ss->eval + ss->evalMargin + Value(128); futilityBase = ss->staticEval + ss->evalMargin + Value(128);
enoughMaterial = pos.non_pawn_material(pos.side_to_move()) > RookValueMg; enoughMaterial = pos.non_pawn_material(pos.side_to_move()) > RookValueMg;
} }
@ -1223,7 +1227,7 @@ split_point_start: // At split points actual search starts from here
&& givesCheck && givesCheck
&& move != ttMove && move != ttMove
&& !pos.is_capture_or_promotion(move) && !pos.is_capture_or_promotion(move)
&& ss->eval + PawnValueMg / 4 < beta && ss->staticEval + PawnValueMg / 4 < beta
&& !check_is_dangerous(pos, move, futilityBase, beta)) && !check_is_dangerous(pos, move, futilityBase, beta))
continue; continue;
@ -1255,7 +1259,7 @@ split_point_start: // At split points actual search starts from here
else // Fail high else // Fail high
{ {
TT.store(posKey, value_to_tt(value, ss->ply), BOUND_LOWER, TT.store(posKey, value_to_tt(value, ss->ply), BOUND_LOWER,
ttDepth, move, ss->eval, ss->evalMargin); ttDepth, move, ss->staticEval, ss->evalMargin);
return value; return value;
} }
@ -1270,7 +1274,7 @@ split_point_start: // At split points actual search starts from here
TT.store(posKey, value_to_tt(bestValue, ss->ply), TT.store(posKey, value_to_tt(bestValue, ss->ply),
PvNode && bestMove != MOVE_NONE ? BOUND_EXACT : BOUND_UPPER, PvNode && bestMove != MOVE_NONE ? BOUND_EXACT : BOUND_UPPER,
ttDepth, bestMove, ss->eval, ss->evalMargin); ttDepth, bestMove, ss->staticEval, ss->evalMargin);
assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE); assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE);
@ -1436,23 +1440,6 @@ split_point_start: // At split points actual search starts from here
} }
// refine_eval() returns the transposition table score if possible, otherwise
// falls back on static position evaluation. Note that we never return VALUE_NONE
// even if v == VALUE_NONE.
Value refine_eval(const TTEntry* tte, Value v, Value defaultEval) {
assert(tte);
assert(v != VALUE_NONE || !tte->type());
if ( ((tte->type() & BOUND_LOWER) && v >= defaultEval)
|| ((tte->type() & BOUND_UPPER) && v < defaultEval))
return v;
return defaultEval;
}
// When playing with strength handicap choose best move among the MultiPV set // When playing with strength handicap choose best move among the MultiPV set
// using a statistical rule dependent on SkillLevel. Idea by Heinz van Saanen. // using a statistical rule dependent on SkillLevel. Idea by Heinz van Saanen.

2
src/search.h
View file

@ -44,7 +44,7 @@ struct Stack {
Move excludedMove; Move excludedMove;
Move killers[2]; Move killers[2];
Depth reduction; Depth reduction;
Value eval; Value staticEval;
Value evalMargin; Value evalMargin;
int skipNullMove; int skipNullMove;
}; };