kate/BadFish
1
0
Fork 0
mirror of https://github.com/sockspls/badfish synced 2025-04-30 08:43:09 +00:00
Code Issues Releases Wiki Activity

Skip some useless initializations in search()

Browse source 
And rearrange a bit the initialization code. Still
some polishing to do, but it is a first step.

No functional change.
This commit is contained in:
Marco Costalba 2012-09-29 18:26:17 +02:00
parent d53c928261
commit e5463eb3ae
1 changed files with 24 additions and 27 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

51
src/search.cpp
View file

@ -516,25 +516,25 @@ namespace {
const bool RootNode = (NT == Root || NT == SplitPointRoot);
assert(alpha >= -VALUE_INFINITE && alpha < beta && beta <= VALUE_INFINITE);
assert((alpha == beta - 1) || PvNode);
assert(PvNode || (alpha == beta - 1));
assert(depth > DEPTH_ZERO);
Move movesSearched[64];
StateInfo st;
const TTEntry *tte;
SplitPoint* sp;
Key posKey;
Move ttMove, move, excludedMove, bestMove, threatMove;
Depth ext, newDepth;
Bound bt;
Value bestValue, value, oldAlpha, ttValue;
Value refinedValue, nullValue, futilityBase, futilityValue;
Value refinedValue, nullValue, futilityValue;
bool pvMove, inCheck, singularExtensionNode, givesCheck;
bool captureOrPromotion, dangerous, doFullDepthSearch;
int moveCount = 0, playedMoveCount = 0;
Thread* thisThread = pos.this_thread();
SplitPoint* sp = NULL;
int moveCount, playedMoveCount;
refinedValue = bestValue = value = -VALUE_INFINITE;
Thread* thisThread = pos.this_thread();
moveCount = playedMoveCount = 0;
oldAlpha = alpha;
inCheck = pos.in_check();
ss->ply = (ss-1)->ply + 1;
@ -548,43 +548,40 @@ namespace {
{
tte = NULL;
ttMove = excludedMove = MOVE_NONE;
ttValue = VALUE_ZERO;
ttValue = VALUE_NONE;
sp = ss->sp;
bestMove = sp->bestMove;
threatMove = sp->threatMove;
bestValue = sp->bestValue;
moveCount = sp->moveCount; // Lock must be held here
assert(bestValue > -VALUE_INFINITE && moveCount > 0);
assert(bestValue > -VALUE_INFINITE && sp->moveCount > 0);
goto split_point_start;
}
else
{
bestValue = -VALUE_INFINITE;
ss->currentMove = threatMove = (ss+1)->excludedMove = bestMove = MOVE_NONE;
(ss+1)->skipNullMove = false; (ss+1)->reduction = DEPTH_ZERO;
(ss+2)->killers[0] = (ss+2)->killers[1] = MOVE_NONE;
}
// Step 2. Check for aborted search and immediate draw
// Enforce node limit here. FIXME: This only works with 1 search thread.
if (Limits.nodes && pos.nodes_searched() >= Limits.nodes)
Signals.stop = true;
if (( Signals.stop
|| pos.is_draw<false>()
|| ss->ply > MAX_PLY) && !RootNode)
return VALUE_DRAW;
// Step 3. Mate distance pruning. Even if we mate at the next move our score
// would be at best mate_in(ss->ply+1), but if alpha is already bigger because
// a shorter mate was found upward in the tree then there is no need to search
// further, we will never beat current alpha. Same logic but with reversed signs
// applies also in the opposite condition of being mated instead of giving mate,
// in this case return a fail-high score.
if (!RootNode)
{
// Step 2. Check for aborted search and immediate draw
if (Signals.stop || pos.is_draw<false>() || ss->ply > MAX_PLY)
return VALUE_DRAW;
// Step 3. Mate distance pruning. Even if we mate at the next move our score
// would be at best mate_in(ss->ply+1), but if alpha is already bigger because
// a shorter mate was found upward in the tree then there is no need to search
// further, we will never beat current alpha. Same logic but with reversed signs
// applies also in the opposite condition of being mated instead of giving mate,
// in this case return a fail-high score.
alpha = std::max(mated_in(ss->ply), alpha);
beta = std::min(mate_in(ss->ply+1), beta);
if (alpha >= beta)
@ -598,7 +595,7 @@ namespace {
posKey = excludedMove ? pos.exclusion_key() : pos.key();
tte = TT.probe(posKey);
ttMove = RootNode ? RootMoves[PVIdx].pv[0] : tte ? tte->move() : MOVE_NONE;
ttValue = tte ? value_from_tt(tte->value(), ss->ply) : VALUE_ZERO;
ttValue = tte ? value_from_tt(tte->value(), ss->ply) : VALUE_NONE;
// At PV nodes we check for exact scores, while at non-PV nodes we check for
// a fail high/low. Biggest advantage at probing at PV nodes is to have a
@ -623,7 +620,7 @@ namespace {
// Step 5. Evaluate the position statically and update parent's gain statistics
if (inCheck)
ss->eval = ss->evalMargin = VALUE_NONE;
ss->eval = ss->evalMargin = refinedValue = VALUE_NONE;
else if (tte)
{
assert(tte->static_value() != VALUE_NONE);
@ -791,7 +788,7 @@ split_point_start: // At split points actual search starts from here
MovePicker mp(pos, ttMove, depth, H, ss, PvNode ? -VALUE_INFINITE : beta);
CheckInfo ci(pos);
futilityBase = ss->eval + ss->evalMargin;
value = bestValue; // Workaround a bogus 'uninitialized' warning under gcc
singularExtensionNode = !RootNode
&& !SpNode
&& depth >= SingularExtensionDepth[PvNode]
@ -899,7 +896,7 @@ split_point_start: // At split points actual search starts from here
// We illogically ignore reduction condition depth >= 3*ONE_PLY for predicted depth,
// but fixing this made program slightly weaker.
Depth predictedDepth = newDepth - reduction<PvNode>(depth, moveCount);
futilityValue = futilityBase + futility_margin(predictedDepth, moveCount)
futilityValue = ss->eval + ss->evalMargin + futility_margin(predictedDepth, moveCount)
+ H.gain(pos.piece_moved(move), to_sq(move));
if (futilityValue < beta)
@ -928,7 +925,7 @@ split_point_start: // At split points actual search starts from here
continue;
}
pvMove = PvNode ? moveCount <= 1 : false;
pvMove = PvNode ? moveCount == 1 : false;
ss->currentMove = move;
if (!SpNode && !captureOrPromotion && playedMoveCount < 64)
movesSearched[playedMoveCount++] = move;