From debc8153520f95c25c1045b723c70ddb4b0d7f80 Mon Sep 17 00:00:00 2001 From: Marco Costalba Date: Tue, 14 Sep 2010 10:57:48 +0200 Subject: [PATCH] We need just one eval margin in search No functional change. Signed-off-by: Marco Costalba --- src/evaluate.cpp | 25 +++++++++++++------------ src/evaluate.h | 2 +- src/search.cpp | 42 +++++++++++++++++++----------------------- src/uci.cpp | 4 ++-- 4 files changed, 35 insertions(+), 38 deletions(-) diff --git a/src/evaluate.cpp b/src/evaluate.cpp index db08b1c4..82bf7b06 100644 --- a/src/evaluate.cpp +++ b/src/evaluate.cpp @@ -230,7 +230,7 @@ namespace { // Function prototypes template - Value do_evaluate(const Position& pos, Value margins[]); + Value do_evaluate(const Position& pos, Value& margin); template void init_eval_info(const Position& pos, EvalInfo& ei); @@ -239,7 +239,7 @@ namespace { Score evaluate_pieces_of_color(const Position& pos, EvalInfo& ei, Score& mobility); template - Score evaluate_king(const Position& pos, EvalInfo& ei, Value margins[]); + Score evaluate_king(const Position& pos, EvalInfo& ei, Value& margin); template Score evaluate_threats(const Position& pos, EvalInfo& ei); @@ -273,16 +273,16 @@ void prefetchPawn(Key key, int threadID) { /// evaluate() is the main evaluation function. It always computes two /// values, an endgame score and a middle game score, and interpolates /// between them based on the remaining material. -Value evaluate(const Position& pos, Value margins[]) { +Value evaluate(const Position& pos, Value& margin) { - return CpuHasPOPCNT ? do_evaluate(pos, margins) - : do_evaluate(pos, margins); + return CpuHasPOPCNT ? do_evaluate(pos, margin) + : do_evaluate(pos, margin); } namespace { template -Value do_evaluate(const Position& pos, Value margins[]) { +Value do_evaluate(const Position& pos, Value& margin) { EvalInfo ei; ScaleFactor factor[2]; @@ -296,9 +296,9 @@ Value do_evaluate(const Position& pos, Value margins[]) { // in the position object (material + piece square tables). Score bonus = pos.value(); - // margins[color] is the uncertainty estimation of position's evaluation + // margin is the uncertainty estimation of position's evaluation // and typically is used by the search for pruning decisions. - margins[WHITE] = margins[BLACK] = VALUE_ZERO; + margin = VALUE_ZERO; // Probe the material hash table MaterialInfo* mi = MaterialTable[pos.thread()]->get_material_info(pos); @@ -329,8 +329,8 @@ Value do_evaluate(const Position& pos, Value margins[]) { // Evaluate kings after all other pieces because we need complete attack // information when computing the king safety evaluation. - bonus += evaluate_king(pos, ei, margins) - - evaluate_king(pos, ei, margins); + bonus += evaluate_king(pos, ei, margin) + - evaluate_king(pos, ei, margin); // Evaluate tactical threats, we need full attack information including king bonus += evaluate_threats(pos, ei) @@ -663,7 +663,7 @@ namespace { // evaluate_king<>() assigns bonuses and penalties to a king of a given color template - Score evaluate_king(const Position& pos, EvalInfo& ei, Value margins[]) { + Score evaluate_king(const Position& pos, EvalInfo& ei, Value& margin) { const Color Them = (Us == WHITE ? BLACK : WHITE); @@ -764,7 +764,8 @@ namespace { // 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. bonus -= KingDangerTable[Us][attackUnits]; - margins[Us] += mg_value(KingDangerTable[Us][attackUnits]); + if (pos.side_to_move() == Us) + margin += mg_value(KingDangerTable[Us][attackUnits]); } return bonus; } diff --git a/src/evaluate.h b/src/evaluate.h index 538f982e..4a04e739 100644 --- a/src/evaluate.h +++ b/src/evaluate.h @@ -26,7 +26,7 @@ class Position; -extern Value evaluate(const Position& pos, Value margins[]); +extern Value evaluate(const Position& pos, Value& margin); extern void init_eval(int threads); extern void quit_eval(); extern void read_weights(Color sideToMove); diff --git a/src/search.cpp b/src/search.cpp index 4a5473fc..627a64af 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -716,13 +716,12 @@ namespace { Value root_search(Position& pos, SearchStack* ss, Move* pv, RootMoveList& rml, Value* alphaPtr, Value* betaPtr) { - Value margins[2]; StateInfo st; CheckInfo ci(pos); int64_t nodes; Move move; Depth depth, ext, newDepth; - Value value, alpha, beta; + Value value, evalMargin, alpha, beta; bool isCheck, moveIsCheck, captureOrPromotion, dangerous; int researchCountFH, researchCountFL; @@ -741,7 +740,7 @@ namespace { // Step 5. Evaluate the position statically // At root we do this only to get reference value for child nodes - ss->eval = isCheck ? VALUE_NONE : evaluate(pos, margins); + ss->eval = isCheck ? VALUE_NONE : evaluate(pos, evalMargin); // Step 6. Razoring (omitted at root) // Step 7. Static null move pruning (omitted at root) @@ -977,13 +976,12 @@ namespace { assert(pos.thread() >= 0 && pos.thread() < ThreadsMgr.active_threads()); Move movesSearched[MOVES_MAX]; - Value margins[2]; StateInfo st; const TTEntry *tte; Key posKey; Move ttMove, move, excludedMove, threatMove; Depth ext, newDepth; - Value bestValue, value, oldAlpha; + Value bestValue, value, evalMargin, oldAlpha; Value refinedValue, nullValue, futilityBase, futilityValueScaled; // Non-PV specific bool isCheck, singleEvasion, singularExtensionNode, moveIsCheck, captureOrPromotion, dangerous; bool mateThreat = false; @@ -1047,19 +1045,19 @@ namespace { // update gain statistics of parent move. isCheck = pos.is_check(); if (isCheck) - ss->eval = VALUE_NONE; + ss->eval = evalMargin = VALUE_NONE; else if (tte) { assert(tte->static_value() != VALUE_NONE); ss->eval = tte->static_value(); - margins[pos.side_to_move()] = tte->static_value_margin(); + evalMargin = tte->static_value_margin(); refinedValue = refine_eval(tte, ss->eval, ply); } else { - refinedValue = ss->eval = evaluate(pos, margins); - TT.store(posKey, VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, margins[pos.side_to_move()]); + refinedValue = ss->eval = evaluate(pos, evalMargin); + TT.store(posKey, VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, evalMargin); } // Save gain for the parent non-capture move @@ -1184,7 +1182,7 @@ namespace { CheckInfo ci(pos); ss->bestMove = MOVE_NONE; singleEvasion = isCheck && mp.number_of_evasions() == 1; - futilityBase = ss->eval + margins[pos.side_to_move()]; + futilityBase = ss->eval + evalMargin; singularExtensionNode = depth >= SingularExtensionDepth[PvNode] && tte && tte->move() @@ -1374,7 +1372,7 @@ namespace { ValueType vt = (bestValue <= oldAlpha ? VALUE_TYPE_UPPER : bestValue >= beta ? VALUE_TYPE_LOWER : VALUE_TYPE_EXACT); move = (bestValue <= oldAlpha ? MOVE_NONE : ss->bestMove); - TT.store(posKey, value_to_tt(bestValue, ply), vt, depth, move, ss->eval, margins[pos.side_to_move()]); + TT.store(posKey, value_to_tt(bestValue, ply), vt, depth, move, ss->eval, evalMargin); // Update killers and history only for non capture moves that fails high if ( bestValue >= beta @@ -1404,10 +1402,9 @@ namespace { assert(ply > 0 && ply < PLY_MAX); assert(pos.thread() >= 0 && pos.thread() < ThreadsMgr.active_threads()); - Value margins[2]; StateInfo st; Move ttMove, move; - Value bestValue, value, futilityValue, futilityBase; + Value bestValue, value, evalMargin, futilityValue, futilityBase; bool isCheck, deepChecks, enoughMaterial, moveIsCheck, evasionPrunable; const TTEntry* tte; Value oldAlpha = alpha; @@ -1436,7 +1433,7 @@ namespace { if (isCheck) { bestValue = futilityBase = -VALUE_INFINITE; - ss->eval = VALUE_NONE; + ss->eval = evalMargin = VALUE_NONE; deepChecks = enoughMaterial = false; } else @@ -1445,11 +1442,11 @@ namespace { { assert(tte->static_value() != VALUE_NONE); - margins[pos.side_to_move()] = tte->static_value_margin(); + evalMargin = tte->static_value_margin(); bestValue = tte->static_value(); } else - bestValue = evaluate(pos, margins); + bestValue = evaluate(pos, evalMargin); ss->eval = bestValue; update_gains(pos, (ss-1)->currentMove, (ss-1)->eval, ss->eval); @@ -1458,7 +1455,7 @@ namespace { if (bestValue >= beta) { if (!tte) - TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, DEPTH_NONE, MOVE_NONE, ss->eval, margins[pos.side_to_move()]); + TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, DEPTH_NONE, MOVE_NONE, ss->eval, evalMargin); return bestValue; } @@ -1470,7 +1467,7 @@ namespace { deepChecks = (depth == -ONE_PLY && bestValue >= beta - PawnValueMidgame / 8); // Futility pruning parameters, not needed when in check - futilityBase = bestValue + FutilityMarginQS + margins[pos.side_to_move()]; + futilityBase = bestValue + FutilityMarginQS + evalMargin; enoughMaterial = pos.non_pawn_material(pos.side_to_move()) > RookValueMidgame; } @@ -1555,7 +1552,7 @@ namespace { // Update transposition table Depth d = (depth == DEPTH_ZERO ? DEPTH_ZERO : DEPTH_ZERO - ONE_PLY); ValueType vt = (bestValue <= oldAlpha ? VALUE_TYPE_UPPER : bestValue >= beta ? VALUE_TYPE_LOWER : VALUE_TYPE_EXACT); - TT.store(pos.get_key(), value_to_tt(bestValue, ply), vt, d, ss->bestMove, ss->eval, margins[pos.side_to_move()]); + TT.store(pos.get_key(), value_to_tt(bestValue, ply), vt, d, ss->bestMove, ss->eval, evalMargin); // Update killers only for checking moves that fails high if ( bestValue >= beta @@ -2245,16 +2242,15 @@ namespace { StateInfo st; TTEntry* tte; Position p(pos, pos.thread()); - Value margins[2]; - Value v; + Value v, m = VALUE_NONE; for (int i = 0; pv[i] != MOVE_NONE; i++) { tte = TT.retrieve(p.get_key()); if (!tte || tte->move() != pv[i]) { - v = (p.is_check() ? VALUE_NONE : evaluate(p, margins)); - TT.store(p.get_key(), VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, pv[i], v, margins[pos.side_to_move()]); + v = (p.is_check() ? VALUE_NONE : evaluate(p, m)); + TT.store(p.get_key(), VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, pv[i], v, m); } p.do_move(pv[i], st); } diff --git a/src/uci.cpp b/src/uci.cpp index 0225a85a..5ba31e70 100644 --- a/src/uci.cpp +++ b/src/uci.cpp @@ -150,10 +150,10 @@ namespace { } else if (token == "eval") { - Value margins[2]; + Value evalMargin; cout << "Incremental mg: " << mg_value(RootPosition.value()) << "\nIncremental eg: " << eg_value(RootPosition.value()) - << "\nFull eval: " << evaluate(RootPosition, margins) << endl; + << "\nFull eval: " << evaluate(RootPosition, evalMargin) << endl; } else if (token == "key") cout << "key: " << hex << RootPosition.get_key() -- 2.39.2