From 37055ad002dfc31eb44ea0e053409f9d6bd25a8d Mon Sep 17 00:00:00 2001 From: Marco Costalba Date: Tue, 12 Oct 2010 10:28:25 +0200 Subject: [PATCH] Unify sp_search() and search() step 1 Rewrite sp_search() to have same signature of search() This is the first prerequistite step toward unification. No functional change. Signed-off-by: Marco Costalba --- src/search.cpp | 64 +++++++++++++++++++++++++++++++------------------- src/search.h | 2 ++ 2 files changed, 42 insertions(+), 24 deletions(-) diff --git a/src/search.cpp b/src/search.cpp index 9d1fe017..66a97a3a 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -287,11 +287,14 @@ namespace { template Value search(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply); + template + void sp_search(Position& pos, SearchStack* ss, Value dumy, Value beta, Depth depth, int ply); + template Value qsearch(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply); template - void sp_search(SplitPoint* sp, int threadID); + void do_sp_search(SplitPoint* sp, int threadID); template Depth extension(const Position& pos, Move m, bool captureOrPromotion, bool moveIsCheck, bool singleEvasion, bool mateThreat, bool* dangerous); @@ -1555,11 +1558,21 @@ namespace { // care of after we return from the split point. template - void sp_search(SplitPoint* sp, int threadID) { + 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; + + sp_search(pos, ss, Value(threadID), sp->beta, sp->depth, sp->ply); + } + + template + void sp_search(Position& pos, SearchStack* ss, Value, Value beta, Depth depth, int ply) { + StateInfo st; Move move; Depth ext, newDepth; @@ -1568,18 +1581,20 @@ namespace { 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(); - Position pos(*sp->pos, threadID); CheckInfo ci(pos); - SearchStack* ss = sp->sstack[threadID] + 1; 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 < sp->beta - && (move = sp->mp->get_next_move()) != MOVE_NONE + while ( sp->bestValue < beta + && (move = mp.get_next_move()) != MOVE_NONE && !ThreadsMgr.thread_should_stop(threadID)) { moveCount = ++sp->moveCount; @@ -1592,7 +1607,7 @@ namespace { // Step 11. Decide the new search depth ext = extension(pos, move, captureOrPromotion, moveIsCheck, false, sp->mateThreat, &dangerous); - newDepth = sp->depth - ONE_PLY + ext; + newDepth = depth - ONE_PLY + ext; // Update current move ss->currentMove = move; @@ -1605,8 +1620,8 @@ namespace { && !move_is_castle(move)) { // Move count based pruning - if ( moveCount >= futility_move_count(sp->depth) - && !(sp->threatMove && connected_threat(pos, move, sp->threatMove)) + if ( moveCount >= futility_move_count(depth) + && !(threatMove && connected_threat(pos, move, threatMove)) && sp->bestValue > value_mated_in(PLY_MAX)) { lock_grab(&(sp->lock)); @@ -1614,11 +1629,11 @@ namespace { } // Value based pruning - Depth predictedDepth = newDepth - reduction(sp->depth, moveCount); + Depth predictedDepth = newDepth - reduction(depth, moveCount); futilityValueScaled = ss->eval + futility_margin(predictedDepth, moveCount) + H.gain(pos.piece_on(move_from(move)), move_to(move)); - if (futilityValueScaled < sp->beta) + if (futilityValueScaled < beta) { lock_grab(&(sp->lock)); @@ -1640,13 +1655,13 @@ namespace { && !move_is_castle(move) && !move_is_killer(move, ss)) { - ss->reduction = reduction(sp->depth, moveCount); + ss->reduction = reduction(depth, moveCount); if (ss->reduction) { Value localAlpha = sp->alpha; Depth d = newDepth - ss->reduction; - value = d < ONE_PLY ? -qsearch(pos, ss+1, -(localAlpha+1), -localAlpha, DEPTH_ZERO, sp->ply+1) - : - search(pos, ss+1, -(localAlpha+1), -localAlpha, d, sp->ply+1); + value = d < ONE_PLY ? -qsearch(pos, ss+1, -(localAlpha+1), -localAlpha, DEPTH_ZERO, ply+1) + : - search(pos, ss+1, -(localAlpha+1), -localAlpha, d, ply+1); doFullDepthSearch = (value > localAlpha); } @@ -1660,7 +1675,7 @@ namespace { ss->reduction = ONE_PLY; Value localAlpha = sp->alpha; - value = -search(pos, ss+1, -(localAlpha+1), -localAlpha, newDepth-ss->reduction, sp->ply+1); + value = -search(pos, ss+1, -(localAlpha+1), -localAlpha, newDepth-ss->reduction, ply+1); doFullDepthSearch = (value > localAlpha); } ss->reduction = DEPTH_ZERO; // Restore original reduction @@ -1670,15 +1685,15 @@ namespace { if (doFullDepthSearch) { Value localAlpha = sp->alpha; - value = newDepth < ONE_PLY ? -qsearch(pos, ss+1, -(localAlpha+1), -localAlpha, DEPTH_ZERO, sp->ply+1) - : - search(pos, ss+1, -(localAlpha+1), -localAlpha, newDepth, sp->ply+1); + value = newDepth < ONE_PLY ? -qsearch(pos, ss+1, -(localAlpha+1), -localAlpha, DEPTH_ZERO, ply+1) + : - search(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 < sp->beta) - value = newDepth < ONE_PLY ? -qsearch(pos, ss+1, -sp->beta, -sp->alpha, DEPTH_ZERO, sp->ply+1) - : - search(pos, ss+1, -sp->beta, -sp->alpha, newDepth, sp->ply+1); + if (PvNode && value > localAlpha && value < beta) + value = newDepth < ONE_PLY ? -qsearch(pos, ss+1, -beta, -sp->alpha, DEPTH_ZERO, ply+1) + : - search(pos, ss+1, -beta, -sp->alpha, newDepth, ply+1); } // Step 16. Undo move @@ -1694,10 +1709,10 @@ namespace { sp->bestValue = value; if (value > sp->alpha) { - if (!PvNode || value >= sp->beta) + if (!PvNode || value >= beta) sp->stopRequest = true; - if (PvNode && value < sp->beta) // We want always sp->alpha < sp->beta + if (PvNode && value < beta) // We want always sp->alpha < beta sp->alpha = value; sp->parentSstack->bestMove = ss->bestMove = move; @@ -2150,6 +2165,7 @@ namespace { ss->excludedMove = MOVE_NONE; ss->skipNullMove = false; ss->reduction = DEPTH_ZERO; + ss->sp = NULL; if (i < 3) ss->killers[0] = ss->killers[1] = ss->mateKiller = MOVE_NONE; @@ -2362,9 +2378,9 @@ namespace { threads[threadID].state = THREAD_SEARCHING; if (threads[threadID].splitPoint->pvNode) - sp_search(threads[threadID].splitPoint, threadID); + do_sp_search(threads[threadID].splitPoint, threadID); else - sp_search(threads[threadID].splitPoint, threadID); + do_sp_search(threads[threadID].splitPoint, threadID); assert(threads[threadID].state == THREAD_SEARCHING); diff --git a/src/search.h b/src/search.h index 00e2cd4a..5c635478 100644 --- a/src/search.h +++ b/src/search.h @@ -47,6 +47,7 @@ const int PLY_MAX_PLUS_2 = 102; /// search thread has its own array of SearchStack objects, indexed by the /// current ply. struct EvalInfo; +struct SplitPoint; struct SearchStack { Move currentMove; @@ -57,6 +58,7 @@ struct SearchStack { Depth reduction; Value eval; bool skipNullMove; + SplitPoint* sp; }; -- 2.39.2