return search<PvNode, false>(pos, ss, alpha, beta, depth, ply);
}
- template <NodeType PvNode>
- void sp_search(Position& pos, SearchStack* ss, Value dumy, Value beta, Depth depth, int ply);
-
template <NodeType PvNode>
Value qsearch(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply);
- template <NodeType PvNode>
- void do_sp_search(SplitPoint* sp, int threadID);
-
template <NodeType PvNode>
Depth extension(const Position& pos, Move m, bool captureOrPromotion, bool moveIsCheck, bool singleEvasion, bool mateThreat, bool* dangerous);
int64_t nodes;
Move move;
Depth depth, ext, newDepth;
- Value value, evalMargin, alpha, beta;
+ Value value, alpha, beta;
bool isCheck, moveIsCheck, captureOrPromotion, dangerous;
int researchCountFH, researchCountFL;
// 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, evalMargin);
+ ss->evalMargin = VALUE_NONE;
+ ss->eval = isCheck ? VALUE_NONE : evaluate(pos, ss->evalMargin);
// Step 6. Razoring (omitted at root)
// Step 7. Static null move pruning (omitted at root)
}
- // search<>() is the main search function for both PV and non-PV nodes
+ // search<>() is the main search function for both PV and non-PV nodes and for
+ // normal and SplitPoint nodes. When called just after a split point the search
+ // is simpler because we have already probed the hash table, done a null move
+ // search, and searched the first move before splitting, we don't have to repeat
+ // all this work again. We also don't need to store anything to the hash table
+ // here: This is taken care of after we return from the split point.
template <NodeType PvNode, bool SplitPoint>
Value search(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply) {
Key posKey;
Move ttMove, move, excludedMove, threatMove;
Depth ext, newDepth;
- Value bestValue, value, evalMargin, oldAlpha;
+ Value bestValue, value, oldAlpha;
Value refinedValue, nullValue, futilityBase, futilityValueScaled; // Non-PV specific
bool isCheck, singleEvasion, singularExtensionNode, moveIsCheck, captureOrPromotion, dangerous;
bool mateThreat = false;
ttMove = excludedMove = MOVE_NONE;
threatMove = ss->sp->threatMove;
mateThreat = ss->sp->mateThreat;
- goto split_start;
+ goto split_point_start;
}
// Step 1. Initialize node and poll. Polling can abort search
// Step 5. Evaluate the position statically and
// update gain statistics of parent move.
if (isCheck)
- ss->eval = evalMargin = VALUE_NONE;
+ ss->eval = ss->evalMargin = VALUE_NONE;
else if (tte)
{
assert(tte->static_value() != VALUE_NONE);
ss->eval = tte->static_value();
- evalMargin = tte->static_value_margin();
+ ss->evalMargin = tte->static_value_margin();
refinedValue = refine_eval(tte, ss->eval, ply);
}
else
{
- refinedValue = ss->eval = evaluate(pos, evalMargin);
- TT.store(posKey, VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, evalMargin);
+ refinedValue = ss->eval = evaluate(pos, ss->evalMargin);
+ TT.store(posKey, VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, ss->evalMargin);
}
// Save gain for the parent non-capture move
if (PvNode)
mateThreat = pos.has_mate_threat();
-split_start:
+split_point_start: // At split points actual search starts from here
// Initialize a MovePicker object for the current position
+ // FIXME currently MovePicker() c'tor is needless called also in SplitPoint
MovePicker mpBase = MovePicker(pos, ttMove, depth, H, ss, (PvNode ? -VALUE_INFINITE : beta));
MovePicker& mp = SplitPoint ? *ss->sp->mp : mpBase;
CheckInfo ci(pos);
ss->bestMove = MOVE_NONE;
- singleEvasion = SplitPoint ? false : isCheck && mp.number_of_evasions() == 1;
- futilityBase = SplitPoint ? ss->eval : ss->eval + evalMargin;
+ singleEvasion = !SplitPoint && isCheck && mp.number_of_evasions() == 1;
+ futilityBase = ss->eval + ss->evalMargin;
singularExtensionNode = !SplitPoint
&& depth >= SingularExtensionDepth[PvNode]
&& tte
{
lock_grab(&(ss->sp->lock));
if (futilityValueScaled > ss->sp->bestValue)
- ss->sp->bestValue = futilityValueScaled;
+ ss->sp->bestValue = bestValue = futilityValueScaled;
}
else if (futilityValueScaled > bestValue)
bestValue = futilityValueScaled;
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, evalMargin);
+ TT.store(posKey, value_to_tt(bestValue, ply), vt, depth, move, ss->eval, ss->evalMargin);
// Update killers and history only for non capture moves that fails high
if ( bestValue >= beta
}
- // sp_search() is used to search from a split point. This function is called
- // by each thread working at the split point. It is similar to the normal
- // search() function, but simpler. Because we have already probed the hash
- // table, done a null move search, and searched the first move before
- // splitting, we don't have to repeat all this work in sp_search(). We
- // also don't need to store anything to the hash table here: This is taken
- // care of after we return from the split point.
-
- template <NodeType PvNode>
- void do_sp_search(SplitPoint* sp, int threadID) {
-
- assert(threadID >= 0 && threadID < ThreadsMgr.active_threads());
- assert(ThreadsMgr.active_threads() > 1);
-
- Position pos(*sp->pos, threadID);
- SearchStack* ss = sp->sstack[threadID] + 1;
- ss->sp = sp;
-
- search<PvNode, true>(pos, ss, sp->alpha, sp->beta, sp->depth, sp->ply);
- }
-
- template <NodeType PvNode>
- void sp_search(Position& pos, SearchStack* ss, Value, Value beta, Depth depth, int ply) {
-
- StateInfo st;
- Move move;
- Depth ext, newDepth;
- Value value;
- Value futilityValueScaled; // NonPV specific
- bool isCheck, moveIsCheck, captureOrPromotion, dangerous;
- int moveCount;
- value = -VALUE_INFINITE;
- SplitPoint* sp = ss->sp;
- Move threatMove = sp->threatMove;
- MovePicker& mp = *sp->mp;
- int threadID = pos.thread();
-
- CheckInfo ci(pos);
- isCheck = pos.is_check();
-
- // Step 10. Loop through moves
- // Loop through all legal moves until no moves remain or a beta cutoff occurs
- lock_grab(&(sp->lock));
-
- while ( sp->bestValue < beta
- && (move = mp.get_next_move()) != MOVE_NONE
- && !ThreadsMgr.thread_should_stop(threadID))
- {
- moveCount = ++sp->moveCount;
- lock_release(&(sp->lock));
-
- assert(move_is_ok(move));
-
- moveIsCheck = pos.move_is_check(move, ci);
- captureOrPromotion = pos.move_is_capture_or_promotion(move);
-
- // Step 11. Decide the new search depth
- ext = extension<PvNode>(pos, move, captureOrPromotion, moveIsCheck, false, sp->mateThreat, &dangerous);
- newDepth = depth - ONE_PLY + ext;
-
- // Update current move
- ss->currentMove = move;
-
- // Step 12. Futility pruning (is omitted in PV nodes)
- if ( !PvNode
- && !captureOrPromotion
- && !isCheck
- && !dangerous
- && !move_is_castle(move))
- {
- // Move count based pruning
- if ( moveCount >= futility_move_count(depth)
- && !(threatMove && connected_threat(pos, move, threatMove))
- && sp->bestValue > value_mated_in(PLY_MAX))
- {
- lock_grab(&(sp->lock));
- continue;
- }
-
- // Value based pruning
- Depth predictedDepth = newDepth - reduction<NonPV>(depth, moveCount);
- futilityValueScaled = ss->eval + futility_margin(predictedDepth, moveCount)
- + H.gain(pos.piece_on(move_from(move)), move_to(move));
-
- if (futilityValueScaled < beta)
- {
- lock_grab(&(sp->lock));
-
- if (futilityValueScaled > sp->bestValue)
- sp->bestValue = futilityValueScaled;
- continue;
- }
- }
-
- // Step 13. Make the move
- pos.do_move(move, st, ci, moveIsCheck);
-
- // Step 14. Reduced search
- // If the move fails high will be re-searched at full depth.
- bool doFullDepthSearch = true;
-
- if ( !captureOrPromotion
- && !dangerous
- && !move_is_castle(move)
- && !move_is_killer(move, ss))
- {
- ss->reduction = reduction<PvNode>(depth, moveCount);
- if (ss->reduction)
- {
- Value localAlpha = sp->alpha;
- Depth d = newDepth - ss->reduction;
- value = d < ONE_PLY ? -qsearch<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, DEPTH_ZERO, ply+1)
- : - search<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, d, ply+1);
-
- doFullDepthSearch = (value > localAlpha);
- }
-
- // The move failed high, but if reduction is very big we could
- // face a false positive, retry with a less aggressive reduction,
- // if the move fails high again then go with full depth search.
- if (doFullDepthSearch && ss->reduction > 2 * ONE_PLY)
- {
- assert(newDepth - ONE_PLY >= ONE_PLY);
-
- ss->reduction = ONE_PLY;
- Value localAlpha = sp->alpha;
- value = -search<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, newDepth-ss->reduction, ply+1);
- doFullDepthSearch = (value > localAlpha);
- }
- ss->reduction = DEPTH_ZERO; // Restore original reduction
- }
-
- // Step 15. Full depth search
- if (doFullDepthSearch)
- {
- Value localAlpha = sp->alpha;
- value = newDepth < ONE_PLY ? -qsearch<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, DEPTH_ZERO, ply+1)
- : - search<NonPV>(pos, ss+1, -(localAlpha+1), -localAlpha, newDepth, ply+1);
-
- // Step extra. pv search (only in PV nodes)
- // Search only for possible new PV nodes, if instead value >= beta then
- // parent node fails low with value <= alpha and tries another move.
- if (PvNode && value > localAlpha && value < beta)
- value = newDepth < ONE_PLY ? -qsearch<PV>(pos, ss+1, -beta, -sp->alpha, DEPTH_ZERO, ply+1)
- : - search<PV>(pos, ss+1, -beta, -sp->alpha, newDepth, ply+1);
- }
-
- // Step 16. Undo move
- pos.undo_move(move);
-
- assert(value > -VALUE_INFINITE && value < VALUE_INFINITE);
-
- // Step 17. Check for new best move
- lock_grab(&(sp->lock));
-
- if (value > sp->bestValue && !ThreadsMgr.thread_should_stop(threadID))
- {
- sp->bestValue = value;
- if (value > sp->alpha)
- {
- if (!PvNode || value >= beta)
- sp->stopRequest = true;
-
- if (PvNode && value < beta) // We want always sp->alpha < beta
- sp->alpha = value;
-
- sp->parentSstack->bestMove = ss->bestMove = move;
- }
- }
- }
-
- /* Here we have the lock still grabbed */
-
- sp->slaves[threadID] = 0;
-
- lock_release(&(sp->lock));
- }
-
-
// connected_moves() tests whether two moves are 'connected' in the sense
// that the first move somehow made the second move possible (for instance
// if the moving piece is the same in both moves). The first move is assumed
threads[threadID].state = THREAD_SEARCHING;
- if (threads[threadID].splitPoint->pvNode)
- do_sp_search<PV>(threads[threadID].splitPoint, threadID);
+ // Here we call search() with SplitPoint template parameter set to true
+ SplitPoint* tsp = threads[threadID].splitPoint;
+ Position pos(*tsp->pos, threadID);
+ SearchStack* ss = tsp->sstack[threadID] + 1;
+ ss->sp = tsp;
+
+ if (tsp->pvNode)
+ search<PV, true>(pos, ss, tsp->alpha, tsp->beta, tsp->depth, tsp->ply);
else
- do_sp_search<NonPV>(threads[threadID].splitPoint, threadID);
+ search<NonPV, true>(pos, ss, tsp->alpha, tsp->beta, tsp->depth, tsp->ply);
assert(threads[threadID].state == THREAD_SEARCHING);
// Initialize search stack
init_ss_array(ss, PLY_MAX_PLUS_2);
- ss[0].eval = VALUE_NONE;
+ ss[0].eval = ss[0].evalMargin = VALUE_NONE;
count = 0;
// Generate all legal moves
projects / stockfish / blobdiff