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

Revert "Retire eval margin and gains"

Browse source 
This reverts commit ecd07e51d0.

Patch was incorrect and partial. It will be reapplied in
the correct form.

bench: 9189063
This commit is contained in:
Marco Costalba 2013-11-07 22:29:07 +01:00
parent 13d1f0ae43
commit 343544f3f7
7 changed files with 112 additions and 47 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

38
src/evaluate.cpp
View file

@ -229,7 +229,7 @@ namespace {
// Function prototypes
template<bool Trace>
Value do_evaluate(const Position& pos);
Value do_evaluate(const Position& pos, Value& margin);
template<Color Us>
void init_eval_info(const Position& pos, EvalInfo& ei);
@ -238,7 +238,7 @@ namespace {
Score evaluate_pieces_of_color(const Position& pos, EvalInfo& ei, Score* mobility);
template<Color Us, bool Trace>
Score evaluate_king(const Position& pos, const EvalInfo& ei);
Score evaluate_king(const Position& pos, const EvalInfo& ei, Value margins[]);
template<Color Us, bool Trace>
Score evaluate_threats(const Position& pos, const EvalInfo& ei);
@ -264,8 +264,8 @@ namespace Eval {
/// values, an endgame score and a middle game score, and interpolates
/// between them based on the remaining material.
Value evaluate(const Position& pos) {
return do_evaluate<false>(pos);
Value evaluate(const Position& pos, Value& margin) {
return do_evaluate<false>(pos, margin);
}
@ -307,14 +307,19 @@ namespace Eval {
namespace {
template<bool Trace>
Value do_evaluate(const Position& pos) {
Value do_evaluate(const Position& pos, Value& margin) {
assert(!pos.checkers());
EvalInfo ei;
Value margins[COLOR_NB];
Score score, mobility[2] = { SCORE_ZERO, SCORE_ZERO };
Thread* th = pos.this_thread();
// margins[] store the uncertainty estimation of position's evaluation
// that typically is used by the search for pruning decisions.
margins[WHITE] = margins[BLACK] = VALUE_ZERO;
// Initialize score by reading the incrementally updated scores included
// in the position object (material + piece square tables) and adding
// Tempo bonus. Score is computed from the point of view of white.
@ -327,7 +332,10 @@ Value do_evaluate(const Position& pos) {
// If we have a specialized evaluation function for the current material
// configuration, call it and return.
if (ei.mi->specialized_eval_exists())
{
margin = VALUE_ZERO;
return ei.mi->evaluate(pos);
}
// Probe the pawn hash table
ei.pi = Pawns::probe(pos, th->pawnsTable);
@ -345,8 +353,8 @@ Value do_evaluate(const Position& pos) {
// Evaluate kings after all other pieces because we need complete attack
// information when computing the king safety evaluation.
score += evaluate_king<WHITE, Trace>(pos, ei)
- evaluate_king<BLACK, Trace>(pos, ei);
score += evaluate_king<WHITE, Trace>(pos, ei, margins)
- evaluate_king<BLACK, Trace>(pos, ei, margins);
// Evaluate tactical threats, we need full attack information including king
score += evaluate_threats<WHITE, Trace>(pos, ei)
@ -393,6 +401,7 @@ Value do_evaluate(const Position& pos) {
sf = ScaleFactor(50);
}
margin = margins[pos.side_to_move()];
Value v = interpolate(score, ei.mi->game_phase(), sf);
// In case of tracing add all single evaluation contributions for both white and black
@ -405,7 +414,9 @@ Value do_evaluate(const Position& pos) {
Score b = ei.mi->space_weight() * evaluate_space<BLACK>(pos, ei);
Tracing::add(SPACE, apply_weight(w, Weights[Space]), apply_weight(b, Weights[Space]));
Tracing::add(TOTAL, score);
Tracing::stream << "\nScaling: " << std::noshowpos
Tracing::stream << "\nUncertainty margin: White: " << to_cp(margins[WHITE])
<< ", Black: " << to_cp(margins[BLACK])
<< "\nScaling: " << std::noshowpos
<< std::setw(6) << 100.0 * ei.mi->game_phase() / 128.0 << "% MG, "
<< std::setw(6) << 100.0 * (1.0 - ei.mi->game_phase() / 128.0) << "% * "
<< std::setw(6) << (100.0 * sf) / SCALE_FACTOR_NORMAL << "% EG.\n"
@ -629,7 +640,7 @@ Value do_evaluate(const Position& pos) {
// evaluate_king() assigns bonuses and penalties to a king of a given color
template<Color Us, bool Trace>
Score evaluate_king(const Position& pos, const EvalInfo& ei) {
Score evaluate_king(const Position& pos, const EvalInfo& ei, Value margins[]) {
const Color Them = (Us == WHITE ? BLACK : WHITE);
@ -724,8 +735,12 @@ Value do_evaluate(const Position& pos) {
attackUnits = std::min(99, std::max(0, attackUnits));
// Finally, extract the king danger score from the KingDanger[]
// array and subtract the score from evaluation.
// array and subtract the score from evaluation. Set also margins[]
// value that will be used for pruning because this value can sometimes
// be very big, and so capturing a single attacking piece can therefore
// result in a score change far bigger than the value of the captured piece.
score -= KingDanger[Us == Search::RootColor][attackUnits];
margins[Us] += mg_value(KingDanger[Us == Search::RootColor][attackUnits]);
}
if (Trace)
@ -1009,7 +1024,8 @@ Value do_evaluate(const Position& pos) {
stream << std::showpoint << std::showpos << std::fixed << std::setprecision(2);
std::memset(scores, 0, 2 * (TOTAL + 1) * sizeof(Score));
do_evaluate<true>(pos);
Value margin;
do_evaluate<true>(pos, margin);
std::string totals = stream.str();
stream.str("");

2
src/evaluate.h
View file

@ -27,7 +27,7 @@ class Position;
namespace Eval {
extern void init();
extern Value evaluate(const Position& pos);
extern Value evaluate(const Position& pos, Value& margin);
extern std::string trace(const Position& pos);
}

17
src/movepick.h
View file

@ -30,13 +30,14 @@
/// The Stats struct stores moves statistics. According to the template parameter
/// the class can store History and Countermoves. History records how often
/// the class can store History, Gains and Countermoves. History records how often
/// different moves have been successful or unsuccessful during the current search
/// and is used for reduction and move ordering decisions.
/// and is used for reduction and move ordering decisions. Gains records the move's
/// best evaluation gain from one ply to the next and is used for pruning decisions.
/// Countermoves store the move that refute a previous one. Entries are stored
/// according only to moving piece and destination square, hence two moves with
/// different origin but same destination and piece will be considered identical.
template<typename T>
template<bool Gain, typename T>
struct Stats {
static const Value Max = Value(2000);
@ -55,7 +56,10 @@ struct Stats {
void update(Piece p, Square to, Value v) {
if (abs(table[p][to] + v) < Max)
if (Gain)
table[p][to] = std::max(v, table[p][to] - 1);
else if (abs(table[p][to] + v) < Max)
table[p][to] += v;
}
@ -63,8 +67,9 @@ private:
T table[PIECE_NB][SQUARE_NB];
};
typedef Stats<Value> HistoryStats;
typedef Stats<std::pair<Move, Move> > CountermovesStats;
typedef Stats< true, Value> GainsStats;
typedef Stats<false, Value> HistoryStats;
typedef Stats<false, std::pair<Move, Move> > CountermovesStats;
/// MovePicker class is used to pick one pseudo legal move at a time from the

89
src/search.cpp
View file

@ -63,12 +63,13 @@ namespace {
inline Value razor_margin(Depth d) { return Value(512 + 16 * int(d)); }
// Futility lookup tables (initialized at startup) and their access functions
Value FutilityMargins[14][64]; // [depth][moveNumber]
Value FutilityMargins[16][64]; // [depth][moveNumber]
int FutilityMoveCounts[2][32]; // [improving][depth]
inline Value futility_margin(Depth d, int mn) {
assert(DEPTH_ZERO <= d && d < 7 * ONE_PLY);
return FutilityMargins[d][std::min(mn, 63)];
return d < 7 * ONE_PLY ? FutilityMargins[std::max(int(d), 1)][std::min(mn, 63)]
: 2 * VALUE_INFINITE;
}
// Reduction lookup tables (initialized at startup) and their access function
@ -84,6 +85,7 @@ namespace {
double BestMoveChanges;
Value DrawValue[COLOR_NB];
HistoryStats History;
GainsStats Gains;
CountermovesStats Countermoves;
template <NodeType NT>
@ -145,8 +147,8 @@ void Search::init() {
}
// Init futility margins array
for (d = 0; d < 14; ++d) for (mc = 0; mc < 64; ++mc)
FutilityMargins[d][mc] = Value(112 * int(2.9 * log(d >= 1 ? double(d) : 1.0)) - 8 * mc + 45);
for (d = 1; d < 16; ++d) for (mc = 0; mc < 64; ++mc)
FutilityMargins[d][mc] = Value(112 * int(2.9 * log(double(d))) - 8 * mc + 45);
// Init futility move count array
for (d = 0; d < 32; ++d)
@ -299,6 +301,7 @@ namespace {
Value bestValue, alpha, beta, delta;
std::memset(ss-2, 0, 5 * sizeof(Stack));
(ss-1)->currentMove = MOVE_NULL; // Hack to skip update gains
depth = 0;
BestMoveChanges = 0;
@ -307,6 +310,7 @@ namespace {
TT.new_search();
History.clear();
Gains.clear();
Countermoves.clear();
PVSize = Options["MultiPV"];
@ -495,7 +499,7 @@ namespace {
Move ttMove, move, excludedMove, bestMove, threatMove;
Depth ext, newDepth;
Value bestValue, value, ttValue;
Value eval, nullValue;
Value eval, nullValue, futilityValue;
bool inCheck, givesCheck, pvMove, singularExtensionNode, improving;
bool captureOrPromotion, dangerous, doFullDepthSearch;
int moveCount, quietCount;
@ -587,15 +591,16 @@ namespace {
// Step 5. Evaluate the position statically and update parent's gain statistics
if (inCheck)
{
ss->staticEval = eval = VALUE_NONE;
ss->staticEval = ss->evalMargin = eval = VALUE_NONE;
goto moves_loop;
}
else if (tte)
{
// Never assume anything on values stored in TT
if ((ss->staticEval = eval = tte->eval_value()) == VALUE_NONE)
eval = ss->staticEval = evaluate(pos);
if ( (ss->staticEval = eval = tte->eval_value()) == VALUE_NONE
||(ss->evalMargin = tte->eval_margin()) == VALUE_NONE)
eval = ss->staticEval = evaluate(pos, ss->evalMargin);
// Can ttValue be used as a better position evaluation?
if (ttValue != VALUE_NONE)
@ -604,8 +609,21 @@ namespace {
}
else
{
eval = ss->staticEval = evaluate(pos);
TT.store(posKey, VALUE_NONE, BOUND_NONE, DEPTH_NONE, MOVE_NONE, ss->staticEval);
eval = ss->staticEval = evaluate(pos, ss->evalMargin);
TT.store(posKey, VALUE_NONE, BOUND_NONE, DEPTH_NONE, MOVE_NONE,
ss->staticEval, ss->evalMargin);
}
// Update gain for the parent non-capture move given the static position
// evaluation before and after the move.
if ( !pos.captured_piece_type()
&& ss->staticEval != VALUE_NONE
&& (ss-1)->staticEval != VALUE_NONE
&& (move = (ss-1)->currentMove) != MOVE_NULL
&& type_of(move) == NORMAL)
{
Square to = to_sq(move);
Gains.update(pos.piece_on(to), to, -(ss-1)->staticEval - ss->staticEval);
}
// Step 6. Razoring (skipped when in check)
@ -624,10 +642,12 @@ namespace {
return v;
}
// Step 7. post-Futility pruning (skipped when in check)
// Step 7. Static null move pruning (skipped when in check)
// We're betting that the opponent doesn't have a move that will reduce
// the score by more than futility_margin(depth) if we do a null move.
if ( !PvNode
&& !ss->skipNullMove
&& depth < 7 * ONE_PLY
&& depth < 4 * ONE_PLY
&& eval - futility_margin(depth, (ss-1)->futilityMoveCount) >= beta
&& abs(beta) < VALUE_MATE_IN_MAX_PLY
&& abs(eval) < VALUE_KNOWN_WIN
@ -834,13 +854,13 @@ moves_loop: // When in check and at SpNode search starts from here
// Update current move (this must be done after singular extension search)
newDepth = depth - ONE_PLY + ext;
Depth predictedDepth = newDepth - reduction<PvNode>(improving, depth, moveCount);
// Step 13. Futility pruning (is omitted in PV nodes)
if ( !PvNode
&& !captureOrPromotion
&& !inCheck
&& !dangerous
/* && move != ttMove Already implicit in the next condition */
&& bestValue > VALUE_MATED_IN_MAX_PLY)
{
// Move count based pruning
@ -854,6 +874,26 @@ moves_loop: // When in check and at SpNode search starts from here
continue;
}
// Value based pruning
// We illogically ignore reduction condition depth >= 3*ONE_PLY for predicted depth,
// but fixing this made program slightly weaker.
Depth predictedDepth = newDepth - reduction<PvNode>(improving, depth, moveCount);
futilityValue = ss->staticEval + ss->evalMargin + futility_margin(predictedDepth, moveCount)
+ Gains[pos.moved_piece(move)][to_sq(move)];
if (futilityValue < beta)
{
bestValue = std::max(bestValue, futilityValue);
if (SpNode)
{
splitPoint->mutex.lock();
if (bestValue > splitPoint->bestValue)
splitPoint->bestValue = bestValue;
}
continue;
}
// Prune moves with negative SEE at low depths
if ( predictedDepth < 4 * ONE_PLY
&& pos.see_sign(move) < 0)
@ -1039,7 +1079,7 @@ moves_loop: // When in check and at SpNode search starts from here
TT.store(posKey, value_to_tt(bestValue, ss->ply),
bestValue >= beta ? BOUND_LOWER :
PvNode && bestMove ? BOUND_EXACT : BOUND_UPPER,
depth, bestMove, ss->staticEval);
depth, bestMove, ss->staticEval, ss->evalMargin);
// Quiet best move: update killers, history and countermoves
if ( bestValue >= beta
@ -1132,7 +1172,7 @@ moves_loop: // When in check and at SpNode search starts from here
// Evaluate the position statically
if (InCheck)
{
ss->staticEval = VALUE_NONE;
ss->staticEval = ss->evalMargin = VALUE_NONE;
bestValue = futilityBase = -VALUE_INFINITE;
}
else
@ -1140,8 +1180,9 @@ moves_loop: // When in check and at SpNode search starts from here
if (tte)
{
// Never assume anything on values stored in TT
if ((ss->staticEval = bestValue = tte->eval_value()) == VALUE_NONE)
ss->staticEval = bestValue = evaluate(pos);
if ( (ss->staticEval = bestValue = tte->eval_value()) == VALUE_NONE
||(ss->evalMargin = tte->eval_margin()) == VALUE_NONE)
ss->staticEval = bestValue = evaluate(pos, ss->evalMargin);
// Can ttValue be used as a better position evaluation?
if (ttValue != VALUE_NONE)
@ -1149,14 +1190,14 @@ moves_loop: // When in check and at SpNode search starts from here
bestValue = ttValue;
}
else
ss->staticEval = bestValue = evaluate(pos);
ss->staticEval = bestValue = evaluate(pos, ss->evalMargin);
// Stand pat. Return immediately if static value is at least beta
if (bestValue >= beta)
{
if (!tte)
TT.store(pos.key(), value_to_tt(bestValue, ss->ply), BOUND_LOWER,
DEPTH_NONE, MOVE_NONE, ss->staticEval);
DEPTH_NONE, MOVE_NONE, ss->staticEval, ss->evalMargin);
return bestValue;
}
@ -1164,7 +1205,7 @@ moves_loop: // When in check and at SpNode search starts from here
if (PvNode && bestValue > alpha)
alpha = bestValue;
futilityBase = bestValue + Value(128);
futilityBase = bestValue + ss->evalMargin + Value(128);
}
// Initialize a MovePicker object for the current position, and prepare
@ -1253,7 +1294,7 @@ moves_loop: // When in check and at SpNode search starts from here
else // Fail high
{
TT.store(posKey, value_to_tt(value, ss->ply), BOUND_LOWER,
ttDepth, move, ss->staticEval);
ttDepth, move, ss->staticEval, ss->evalMargin);
return value;
}
@ -1268,7 +1309,7 @@ moves_loop: // When in check and at SpNode search starts from here
TT.store(posKey, value_to_tt(bestValue, ss->ply),
PvNode && bestValue > oldAlpha ? BOUND_EXACT : BOUND_UPPER,
ttDepth, bestMove, ss->staticEval);
ttDepth, bestMove, ss->staticEval, ss->evalMargin);
assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE);
@ -1531,7 +1572,7 @@ void RootMove::insert_pv_in_tt(Position& pos) {
tte = TT.probe(pos.key());
if (!tte || tte->move() != pv[ply]) // Don't overwrite correct entries
TT.store(pos.key(), VALUE_NONE, BOUND_NONE, DEPTH_NONE, pv[ply], VALUE_NONE);
TT.store(pos.key(), VALUE_NONE, BOUND_NONE, DEPTH_NONE, pv[ply], VALUE_NONE, VALUE_NONE);
assert(MoveList<LEGAL>(pos).contains(pv[ply]));

1
src/search.h
View file

@ -45,6 +45,7 @@ struct Stack {
Move killers[2];
Depth reduction;
Value staticEval;
Value evalMargin;
int skipNullMove;
int futilityMoveCount;
};

4
src/tt.cpp
View file

@ -89,7 +89,7 @@ const TTEntry* TranspositionTable::probe(const Key key) const {
/// more valuable than a TTEntry t2 if t1 is from the current search and t2 is from
/// a previous search, or if the depth of t1 is bigger than the depth of t2.
void TranspositionTable::store(const Key key, Value v, Bound b, Depth d, Move m, Value statV) {
void TranspositionTable::store(const Key key, Value v, Bound b, Depth d, Move m, Value statV, Value evalM) {
int c1, c2, c3;
TTEntry *tte, *replace;
@ -117,5 +117,5 @@ void TranspositionTable::store(const Key key, Value v, Bound b, Depth d, Move m,
replace = tte;
}
replace->save(key32, v, b, d, m, generation, statV);
replace->save(key32, v, b, d, m, generation, statV, evalM);
}

8
src/tt.h
View file

@ -36,7 +36,7 @@
struct TTEntry {
void save(uint32_t k, Value v, Bound b, Depth d, Move m, int g, Value ev) {
void save(uint32_t k, Value v, Bound b, Depth d, Move m, int g, Value ev, Value em) {
key32 = (uint32_t)k;
move16 = (uint16_t)m;
@ -45,6 +45,7 @@ struct TTEntry {
value16 = (int16_t)v;
depth16 = (int16_t)d;
evalValue = (int16_t)ev;
evalMargin = (int16_t)em;
}
void set_generation(uint8_t g) { generation8 = g; }
@ -55,12 +56,13 @@ struct TTEntry {
Bound bound() const { return (Bound)bound8; }
int generation() const { return (int)generation8; }
Value eval_value() const { return (Value)evalValue; }
Value eval_margin() const { return (Value)evalMargin; }
private:
uint32_t key32;
uint16_t move16;
uint8_t bound8, generation8;
int16_t value16, depth16, evalValue;
int16_t value16, depth16, evalValue, evalMargin;
};
@ -83,7 +85,7 @@ public:
void refresh(const TTEntry* tte) const;
void set_size(size_t mbSize);
void clear();
void store(const Key key, Value v, Bound type, Depth d, Move m, Value statV);
void store(const Key key, Value v, Bound type, Depth d, Move m, Value statV, Value kingD);
private:
uint32_t hashMask;