From e5463eb3ae6c1a035fe1da717fb88568ee654237 Mon Sep 17 00:00:00 2001 From: Marco Costalba Date: Sat, 29 Sep 2012 18:26:17 +0200 Subject: [PATCH] Skip some useless initializations in search() And rearrange a bit the initialization code. Still some polishing to do, but it is a first step. No functional change. --- src/search.cpp | 51 ++++++++++++++++++++++++-------------------------- 1 file changed, 24 insertions(+), 27 deletions(-) diff --git a/src/search.cpp b/src/search.cpp index 6cab3f6c..29dc00a9 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -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() - || 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() || 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(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; -- 2.39.2