X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fsearch.cpp;h=7feb28b1e57caaa57a4fbb3e8d290fd1d1c7e2d5;hb=49a6fee4fa993a4e7fadba7846dc4ee058c8723e;hp=00fa04dd44a8408258b3261a7b71402a6f4781a7;hpb=65606bc49ed26f630bdd8ee1a460d80ee74e9330;p=stockfish diff --git a/src/search.cpp b/src/search.cpp index 00fa04dd..7feb28b1 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -280,15 +280,14 @@ namespace { Value search(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply); template - inline Value search(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply) { - return search(pos, ss, alpha, beta, depth, ply); - } + Value qsearch(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply); template - void sp_search(Position& pos, SearchStack* ss, Value, Value beta, Depth depth, int ply); + inline Value search(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply) { - template - Value qsearch(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply); + return depth < ONE_PLY ? qsearch(pos, ss, alpha, beta, DEPTH_ZERO, ply) + : search(pos, ss, alpha, beta, depth, ply); + } template Depth extension(const Position& pos, Move m, bool captureOrPromotion, bool moveIsCheck, bool singleEvasion, bool mateThreat, bool* dangerous); @@ -703,7 +702,7 @@ namespace { 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; @@ -722,7 +721,8 @@ namespace { // 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) @@ -968,7 +968,8 @@ namespace { Key posKey; Move ttMove, move, excludedMove, threatMove; Depth ext, newDepth; - Value bestValue, value, evalMargin, oldAlpha; + ValueType vt; + Value bestValue, value, oldAlpha; Value refinedValue, nullValue, futilityBase, futilityValueScaled; // Non-PV specific bool isCheck, singleEvasion, singularExtensionNode, moveIsCheck, captureOrPromotion, dangerous; bool mateThreat = false; @@ -983,12 +984,11 @@ namespace { { sp = ss->sp; tte = NULL; - evalMargin = VALUE_ZERO; ttMove = excludedMove = MOVE_NONE; threatMove = sp->threatMove; mateThreat = sp->mateThreat; goto split_point_start; - } + } else {} // Hack to fix icc's "statement is unreachable" warning // Step 1. Initialize node and poll. Polling can abort search ThreadsMgr.incrementNodeCounter(threadID); @@ -1002,10 +1002,8 @@ namespace { } // Step 2. Check for aborted search and immediate draw - if (AbortSearch || ThreadsMgr.thread_should_stop(threadID)) - return VALUE_DRAW; - - if (pos.is_draw() || ply >= PLY_MAX - 1) + if ( AbortSearch || ThreadsMgr.thread_should_stop(threadID) + || pos.is_draw() || ply >= PLY_MAX - 1) return VALUE_DRAW; // Step 3. Mate distance pruning @@ -1022,7 +1020,7 @@ namespace { posKey = excludedMove ? pos.get_exclusion_key() : pos.get_key(); tte = TT.retrieve(posKey); - ttMove = (tte ? tte->move() : MOVE_NONE); + ttMove = tte ? tte->move() : MOVE_NONE; // At PV nodes, we don't use the TT for pruning, but only for move ordering. // This is to avoid problems in the following areas: @@ -1031,12 +1029,9 @@ namespace { // * Fifty move rule detection // * Searching for a mate // * Printing of full PV line - if (!PvNode && tte && ok_to_use_TT(tte, depth, beta, ply)) { - // Refresh tte entry to avoid aging - TT.store(posKey, tte->value(), tte->type(), tte->depth(), ttMove, tte->static_value(), tte->static_value_margin()); - + TT.refresh(tte); ss->bestMove = ttMove; // Can be MOVE_NONE return value_from_tt(tte->value(), ply); } @@ -1044,19 +1039,19 @@ namespace { // 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 @@ -1112,9 +1107,7 @@ namespace { pos.do_null_move(st); (ss+1)->skipNullMove = true; - - nullValue = depth-R*ONE_PLY < ONE_PLY ? -qsearch(pos, ss+1, -beta, -alpha, DEPTH_ZERO, ply+1) - : - search(pos, ss+1, -beta, -alpha, depth-R*ONE_PLY, ply+1); + nullValue = -search(pos, ss+1, -beta, -alpha, depth-R*ONE_PLY, ply+1); (ss+1)->skipNullMove = false; pos.undo_null_move(); @@ -1177,12 +1170,12 @@ 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 mpBase(pos, ttMove, depth, H, ss, (PvNode ? -VALUE_INFINITE : beta)); MovePicker& mp = SpNode ? *sp->mp : mpBase; CheckInfo ci(pos); ss->bestMove = MOVE_NONE; singleEvasion = !SpNode && isCheck && mp.number_of_evasions() == 1; - futilityBase = ss->eval + evalMargin; + futilityBase = ss->eval + ss->evalMargin; singularExtensionNode = !SpNode && depth >= SingularExtensionDepth[PvNode] && tte @@ -1202,16 +1195,17 @@ split_point_start: // At split points actual search starts from here && (move = mp.get_next_move()) != MOVE_NONE && !ThreadsMgr.thread_should_stop(threadID)) { + assert(move_is_ok(move)); + if (SpNode) { moveCount = ++sp->moveCount; lock_release(&(sp->lock)); } - - assert(move_is_ok(move)); - - if (move == excludedMove) + else if (move == excludedMove) continue; + else + movesSearched[moveCount++] = move; moveIsCheck = pos.move_is_check(move, ci); captureOrPromotion = pos.move_is_capture_or_promotion(move); @@ -1243,10 +1237,9 @@ split_point_start: // At split points actual search starts from here } } - newDepth = depth - ONE_PLY + ext; - // Update current move (this must be done after singular extension search) - movesSearched[moveCount++] = ss->currentMove = move; + ss->currentMove = move; + newDepth = depth - ONE_PLY + ext; // Step 12. Futility pruning (is omitted in PV nodes) if ( !PvNode @@ -1295,8 +1288,7 @@ split_point_start: // At split points actual search starts from here // Step extra. pv search (only in PV nodes) // The first move in list is the expected PV if (!SpNode && PvNode && moveCount == 1) - value = newDepth < ONE_PLY ? -qsearch(pos, ss+1, -beta, -alpha, DEPTH_ZERO, ply+1) - : - search(pos, ss+1, -beta, -alpha, newDepth, ply+1); + value = -search(pos, ss+1, -beta, -alpha, newDepth, ply+1); else { // Step 14. Reduced depth search @@ -1314,8 +1306,7 @@ split_point_start: // At split points actual search starts from here { alpha = SpNode ? sp->alpha : alpha; Depth d = newDepth - ss->reduction; - value = d < ONE_PLY ? -qsearch(pos, ss+1, -(alpha+1), -alpha, DEPTH_ZERO, ply+1) - : - search(pos, ss+1, -(alpha+1), -alpha, d, ply+1); + value = -search(pos, ss+1, -(alpha+1), -alpha, d, ply+1); doFullDepthSearch = (value > alpha); } @@ -1339,15 +1330,13 @@ split_point_start: // At split points actual search starts from here if (doFullDepthSearch) { alpha = SpNode ? sp->alpha : alpha; - value = newDepth < ONE_PLY ? -qsearch(pos, ss+1, -(alpha+1), -alpha, DEPTH_ZERO, ply+1) - : - search(pos, ss+1, -(alpha+1), -alpha, newDepth, ply+1); + value = -search(pos, ss+1, -(alpha+1), -alpha, 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 > alpha && value < beta) - value = newDepth < ONE_PLY ? -qsearch(pos, ss+1, -beta, -alpha, DEPTH_ZERO, ply+1) - : - search(pos, ss+1, -beta, -alpha, newDepth, ply+1); + value = -search(pos, ss+1, -beta, -alpha, newDepth, ply+1); } } @@ -1406,37 +1395,38 @@ split_point_start: // At split points actual search starts from here threatMove, mateThreat, moveCount, &mp, PvNode); } - if (SpNode) - { - /* Here we have the lock still grabbed */ - sp->slaves[threadID] = 0; - lock_release(&(sp->lock)); - return bestValue; - } - // Step 19. Check for mate and stalemate // All legal moves have been searched and if there are // no legal moves, it must be mate or stalemate. // If one move was excluded return fail low score. - if (!moveCount) + if (!SpNode && !moveCount) return excludedMove ? oldAlpha : isCheck ? value_mated_in(ply) : VALUE_DRAW; // Step 20. Update tables // If the search is not aborted, update the transposition table, // history counters, and killer moves. - if (AbortSearch || ThreadsMgr.thread_should_stop(threadID)) - return bestValue; + if (!SpNode && !AbortSearch && !ThreadsMgr.thread_should_stop(threadID)) + { + move = bestValue <= oldAlpha ? MOVE_NONE : ss->bestMove; + vt = bestValue <= oldAlpha ? VALUE_TYPE_UPPER + : bestValue >= beta ? VALUE_TYPE_LOWER : VALUE_TYPE_EXACT; - 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 - && !pos.move_is_capture_or_promotion(move)) - { + // Update killers and history only for non capture moves that fails high + if ( bestValue >= beta + && !pos.move_is_capture_or_promotion(move)) + { update_history(pos, move, depth, movesSearched, moveCount); update_killers(move, ss); + } + } + + if (SpNode) + { + // Here we have the lock still grabbed + sp->slaves[threadID] = 0; + lock_release(&(sp->lock)); } assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE); @@ -1615,172 +1605,6 @@ split_point_start: // At split points actual search starts from here } - // 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 - 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(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(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) - && !(ss->killers[0] == move || ss->killers[1] == move)) - { - 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, ply+1) - : - search(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(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(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 < 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 - 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 @@ -2432,12 +2256,10 @@ split_point_start: // At split points actual search starts from here ss->sp = tsp; if (tsp->pvNode) - //search(pos, ss, tsp->alpha, tsp->beta, tsp->depth, tsp->ply); - sp_search(pos, ss, tsp->alpha, tsp->beta, tsp->depth, tsp->ply); - else - //search(pos, ss, tsp->alpha, tsp->beta, tsp->depth, tsp->ply); - sp_search(pos, ss, tsp->alpha, tsp->beta, tsp->depth, tsp->ply); - + search(pos, ss, tsp->alpha, tsp->beta, tsp->depth, tsp->ply); + else { + search(pos, ss, tsp->alpha, tsp->beta, tsp->depth, tsp->ply); + } assert(threads[threadID].state == THREAD_SEARCHING); threads[threadID].state = THREAD_AVAILABLE; @@ -2504,6 +2326,7 @@ split_point_start: // At split points actual search starts from here #if !defined(_MSC_VER) pthread_t pthread[1]; ok = (pthread_create(pthread, NULL, init_thread, (void*)(&i)) == 0); + pthread_detach(pthread[0]); #else ok = (CreateThread(NULL, 0, init_thread, (LPVOID)(&i), 0, NULL) != NULL); #endif @@ -2619,9 +2442,8 @@ split_point_start: // At split points actual search starts from here // split point objects), the function immediately returns. If splitting is // possible, a SplitPoint object is initialized with all the data that must be // copied to the helper threads and we tell our helper threads that they have - // been assigned work. This will cause them to instantly leave their idle loops - // and call sp_search(). When all threads have returned from sp_search() then - // split() returns. + // been assigned work. This will cause them to instantly leave their idle loops and + // call search().When all threads have returned from search() then split() returns. template void ThreadsManager::split(const Position& p, SearchStack* ss, int ply, Value* alpha, @@ -2752,7 +2574,7 @@ split_point_start: // At split points actual search starts from here // 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