struct RootMove {
- RootMove() : mp_score(0), nodes(0), cumulativeNodes(0) {}
+ RootMove() : mp_score(0), nodes(0) {}
// RootMove::operator<() is the comparison function used when
// sorting the moves. A move m1 is considered to be better
Move move;
Value score;
int mp_score;
- int64_t nodes, cumulativeNodes;
+ int64_t nodes;
Move pv[PLY_MAX_PLUS_2];
};
Value get_move_score(int moveNum) const { return moves[moveNum].score; }
void set_move_score(int moveNum, Value score) { moves[moveNum].score = score; }
Move get_move_pv(int moveNum, int i) const { return moves[moveNum].pv[i]; }
- int64_t get_move_cumulative_nodes(int moveNum) const { return moves[moveNum].cumulativeNodes; }
+ int64_t get_move_nodes(int moveNum) const { return moves[moveNum].nodes; }
void score_moves(const Position& pos);
- void set_move_nodes(int moveNum, int64_t nodes);
+ void add_move_nodes(int moveNum, int64_t nodes) { moves[moveNum].nodes += nodes; }
void set_move_pv(int moveNum, const Move pv[]);
void sort();
void sort_multipv(int n);
int64_t nodes = ThreadsMgr.nodes_searched();
if ( Iteration >= 8
&& EasyMove == pv[0]
- && ( ( rml.get_move_cumulative_nodes(0) > (nodes * 85) / 100
+ && ( ( rml.get_move_nodes(0) > (nodes * 85) / 100
&& current_search_time() > TimeMgr.available_time() / 16)
- ||( rml.get_move_cumulative_nodes(0) > (nodes * 98) / 100
+ ||( rml.get_move_nodes(0) > (nodes * 98) / 100
&& current_search_time() > TimeMgr.available_time() / 32)))
stopSearch = true;
Value root_search(Position& pos, SearchStack* ss, Move* pv, RootMoveList& rml, Value* alphaPtr, Value* betaPtr) {
- EvalInfo ei;
+ Value margins[2];
StateInfo st;
CheckInfo ci(pos);
int64_t nodes;
// 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, ei);
+ ss->eval = isCheck ? VALUE_NONE : evaluate(pos, margins);
// Step 6. Razoring (omitted at root)
// Step 7. Static null move pruning (omitted at root)
break;
// Remember searched nodes counts for this move
- rml.set_move_nodes(i, ThreadsMgr.nodes_searched() - nodes);
+ rml.add_move_nodes(i, ThreadsMgr.nodes_searched() - nodes);
assert(value >= -VALUE_INFINITE && value <= VALUE_INFINITE);
assert(value < beta);
assert(pos.thread() >= 0 && pos.thread() < ThreadsMgr.active_threads());
Move movesSearched[256];
- EvalInfo ei;
+ Value margins[2];
StateInfo st;
const TTEntry *tte;
Key posKey;
Move ttMove, move, excludedMove, threatMove;
Depth ext, newDepth;
Value bestValue, value, oldAlpha;
- Value refinedValue, nullValue, futilityValueScaled; // Non-PV specific
+ Value refinedValue, nullValue, futilityBase, futilityValueScaled; // Non-PV specific
bool isCheck, singleEvasion, singularExtensionNode, moveIsCheck, captureOrPromotion, dangerous;
bool mateThreat = false;
int moveCount = 0;
assert(tte->static_value() != VALUE_NONE);
ss->eval = tte->static_value();
- ei.margin[pos.side_to_move()] = tte->static_value_margin();
+ margins[pos.side_to_move()] = tte->static_value_margin();
refinedValue = refine_eval(tte, ss->eval, ply);
}
else
{
- refinedValue = ss->eval = evaluate(pos, ei);
- TT.store(posKey, VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, ei.margin[pos.side_to_move()]);
+ 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()]);
}
// Save gain for the parent non-capture move
CheckInfo ci(pos);
ss->bestMove = MOVE_NONE;
singleEvasion = isCheck && mp.number_of_evasions() == 1;
+ futilityBase = ss->eval + margins[pos.side_to_move()];
singularExtensionNode = depth >= SingularExtensionDepth[PvNode]
&& tte
&& tte->move()
// We illogically ignore reduction condition depth >= 3*ONE_PLY for predicted depth,
// but fixing this made program slightly weaker.
Depth predictedDepth = newDepth - reduction<NonPV>(depth, moveCount);
- futilityValueScaled = ss->eval + futility_margin(predictedDepth, moveCount)
+ futilityValueScaled = futilityBase + futility_margin(predictedDepth, moveCount)
+ H.gain(pos.piece_on(move_from(move)), move_to(move));
if (futilityValueScaled < beta)
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, ei.margin[pos.side_to_move()]);
+ TT.store(posKey, value_to_tt(bestValue, ply), vt, depth, move, ss->eval, margins[pos.side_to_move()]);
// Update killers and history only for non capture moves that fails high
if ( bestValue >= beta
assert(ply > 0 && ply < PLY_MAX);
assert(pos.thread() >= 0 && pos.thread() < ThreadsMgr.active_threads());
- EvalInfo ei;
+ Value margins[2];
StateInfo st;
Move ttMove, move;
Value bestValue, value, futilityValue, futilityBase;
{
assert(tte->static_value() != VALUE_NONE);
- ei.margin[pos.side_to_move()] = tte->static_value_margin();
+ margins[pos.side_to_move()] = tte->static_value_margin();
bestValue = tte->static_value();
}
else
- bestValue = evaluate(pos, ei);
+ bestValue = evaluate(pos, margins);
ss->eval = bestValue;
update_gains(pos, (ss-1)->currentMove, (ss-1)->eval, ss->eval);
if (bestValue >= beta)
{
if (!tte)
- TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, DEPTH_NONE, MOVE_NONE, ss->eval, ei.margin[pos.side_to_move()]);
+ TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, DEPTH_NONE, MOVE_NONE, ss->eval, margins[pos.side_to_move()]);
return bestValue;
}
deepChecks = (depth == -ONE_PLY && bestValue >= beta - PawnValueMidgame / 8);
// Futility pruning parameters, not needed when in check
- futilityBase = bestValue + FutilityMarginQS + ei.margin[pos.side_to_move()];
+ futilityBase = bestValue + FutilityMarginQS + margins[pos.side_to_move()];
enoughMaterial = pos.non_pawn_material(pos.side_to_move()) > RookValueMidgame;
}
// 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, ei.margin[pos.side_to_move()]);
+ TT.store(pos.get_key(), value_to_tt(bestValue, ply), vt, d, ss->bestMove, ss->eval, margins[pos.side_to_move()]);
// Update killers only for checking moves that fails high
if ( bestValue >= beta
StateInfo st;
TTEntry* tte;
Position p(pos, pos.thread());
- EvalInfo ei;
+ Value margins[2];
Value v;
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, ei));
- TT.store(p.get_key(), VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, pv[i], v, ei.margin[pos.side_to_move()]);
+ 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()]);
}
p.do_move(pv[i], st);
}
// RootMoveList simple methods definitions
- void RootMoveList::set_move_nodes(int moveNum, int64_t nodes) {
-
- moves[moveNum].nodes = nodes;
- moves[moveNum].cumulativeNodes += nodes;
- }
-
void RootMoveList::set_move_pv(int moveNum, const Move pv[]) {
int j;