X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fsearch.cpp;h=11ae249ba2b88aec9d9db7d5b562236e1ee3fe88;hp=e07134c4f69bfeec31d3bf3b20565309f509f198;hb=d664773a8316f04ba6e59b7bfccd14c3dc2af5f1;hpb=b177e6dd91a176ca3b49c0a35a21d1cad8d17dfa diff --git a/src/search.cpp b/src/search.cpp index e07134c4..11ae249b 100644 --- a/src/search.cpp +++ b/src/search.cpp @@ -52,7 +52,7 @@ using std::endl; namespace { - /// Types + // Types enum NodeType { NonPV, PV }; // Set to true to force running with one thread. @@ -88,7 +88,7 @@ namespace { template void split(const Position& pos, SearchStack* ss, int ply, Value* alpha, const Value beta, Value* bestValue, - Depth depth, Move threatMove, bool mateThreat, int* moveCount, MovePicker* mp, bool pvNode); + Depth depth, Move threatMove, bool mateThreat, int moveCount, MovePicker* mp, bool pvNode); private: friend void poll(); @@ -114,7 +114,7 @@ namespace { struct RootMove { - RootMove() : mp_score(0), nodes(0), cumulativeNodes(0) {} + RootMove() : mp_score(0), nodes(0) {} // RootMove::operator<() is the comparison function used when // sorting the moves. A move m1 is considered to be better @@ -128,7 +128,7 @@ namespace { Move move; Value score; int mp_score; - int64_t nodes, cumulativeNodes; + int64_t nodes; Move pv[PLY_MAX_PLUS_2]; }; @@ -141,22 +141,21 @@ namespace { public: RootMoveList(Position& pos, Move searchMoves[]); + Move move(int moveNum) const { return moves[moveNum].move; } + Move move_pv(int moveNum, int i) const { return moves[moveNum].pv[i]; } int move_count() const { return count; } - Move get_move(int moveNum) const { return moves[moveNum].move; } - Value get_move_score(int moveNum) const { return moves[moveNum].score; } + Value move_score(int moveNum) const { return moves[moveNum].score; } + int64_t move_nodes(int moveNum) const { return moves[moveNum].nodes; } + void add_move_nodes(int moveNum, int64_t nodes) { moves[moveNum].nodes += nodes; } void set_move_score(int moveNum, Value score) { moves[moveNum].score = score; } - Move get_move_pv(int moveNum, int i) const { return moves[moveNum].pv[i]; } - int64_t get_move_cumulative_nodes(int moveNum) const { return moves[moveNum].cumulativeNodes; } - void score_moves(const Position& pos); - void set_move_nodes(int moveNum, int64_t nodes); void set_move_pv(int moveNum, const Move pv[]); + void score_moves(const Position& pos); void sort(); void sort_multipv(int n); private: - static const int MaxRootMoves = 500; - RootMove moves[MaxRootMoves]; + RootMove moves[MOVES_MAX]; int count; }; @@ -186,12 +185,6 @@ namespace { // Dynamic razoring margin based on depth inline Value razor_margin(Depth d) { return Value(0x200 + 0x10 * int(d)); } - // Step 8. Null move search with verification search - - // Null move margin. A null move search will not be done if the static - // evaluation of the position is more than NullMoveMargin below beta. - const Value NullMoveMargin = Value(0x200); - // Maximum depth for use of dynamic threat detection when null move fails low const Depth ThreatDepth = 5 * ONE_PLY; @@ -224,10 +217,10 @@ namespace { const Value FutilityMarginQS = Value(0x80); // Futility lookup tables (initialized at startup) and their getter functions - int32_t FutilityMarginsMatrix[16][64]; // [depth][moveNumber] + Value FutilityMarginsMatrix[16][64]; // [depth][moveNumber] int FutilityMoveCountArray[32]; // [depth] - inline Value futility_margin(Depth d, int mn) { return Value(d < 7 * ONE_PLY ? FutilityMarginsMatrix[Max(d, 1)][Min(mn, 63)] : 2 * VALUE_INFINITE); } + inline Value futility_margin(Depth d, int mn) { return d < 7 * ONE_PLY ? FutilityMarginsMatrix[Max(d, 1)][Min(mn, 63)] : 2 * VALUE_INFINITE; } inline int futility_move_count(Depth d) { return d < 16 * ONE_PLY ? FutilityMoveCountArray[d] : 512; } // Step 14. Reduced search @@ -291,14 +284,16 @@ namespace { Value id_loop(const Position& pos, Move searchMoves[]); Value root_search(Position& pos, SearchStack* ss, Move* pv, RootMoveList& rml, Value* alphaPtr, Value* betaPtr); - template + template 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); + inline Value search(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply) { + return search(pos, ss, alpha, beta, depth, ply); + } template - void sp_search(SplitPoint* sp, int threadID); + Value qsearch(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply); template Depth extension(const Position& pos, Move m, bool captureOrPromotion, bool moveIsCheck, bool singleEvasion, bool mateThreat, bool* dangerous); @@ -366,11 +361,11 @@ void init_search() { // Init futility margins array for (d = 1; d < 16; d++) for (mc = 0; mc < 64; mc++) - FutilityMarginsMatrix[d][mc] = 112 * int(log(double(d * d) / 2) / log(2.0) + 1.001) - 8 * mc + 45; + FutilityMarginsMatrix[d][mc] = Value(112 * int(log(double(d * d) / 2) / log(2.0) + 1.001) - 8 * mc + 45); // Init futility move count array for (d = 0; d < 32; d++) - FutilityMoveCountArray[d] = 3 + (1 << (3 * d / 8)); + FutilityMoveCountArray[d] = int(3.001 + 0.25 * pow(d, 2.0)); } @@ -379,7 +374,7 @@ void init_search() { int perft(Position& pos, Depth depth) { - MoveStack mlist[256]; + MoveStack mlist[MOVES_MAX]; StateInfo st; Move m; int sum = 0; @@ -551,24 +546,24 @@ namespace { cout << set960(p.is_chess960()) // Is enough to set once at the beginning << "info depth " << 1 << "\ninfo depth " << 1 - << " score " << value_to_uci(rml.get_move_score(0)) + << " score " << value_to_uci(rml.move_score(0)) << " time " << current_search_time() << " nodes " << ThreadsMgr.nodes_searched() << " nps " << nps() - << " pv " << rml.get_move(0) << "\n"; + << " pv " << rml.move(0) << "\n"; // Initialize TT.new_search(); H.clear(); init_ss_array(ss, PLY_MAX_PLUS_2); pv[0] = pv[1] = MOVE_NONE; - ValueByIteration[1] = rml.get_move_score(0); + ValueByIteration[1] = rml.move_score(0); Iteration = 1; // Is one move significantly better than others after initial scoring ? if ( rml.move_count() == 1 - || rml.get_move_score(0) > rml.get_move_score(1) + EasyMoveMargin) - EasyMove = rml.get_move(0); + || rml.move_score(0) > rml.move_score(1) + EasyMoveMargin) + EasyMove = rml.move(0); // Iterative deepening loop while (Iteration < PLY_MAX) @@ -629,15 +624,15 @@ namespace { int64_t nodes = ThreadsMgr.nodes_searched(); if ( Iteration >= 8 && EasyMove == pv[0] - && ( ( rml.get_move_cumulative_nodes(0) > (nodes * 85) / 100 + && ( ( rml.move_nodes(0) > (nodes * 85) / 100 && current_search_time() > TimeMgr.available_time() / 16) - ||( rml.get_move_cumulative_nodes(0) > (nodes * 98) / 100 + ||( rml.move_nodes(0) > (nodes * 98) / 100 && current_search_time() > TimeMgr.available_time() / 32))) stopSearch = true; // Add some extra time if the best move has changed during the last two iterations if (Iteration > 5 && Iteration <= 50) - TimeMgr.pv_unstability(BestMoveChangesByIteration[Iteration], + TimeMgr.pv_instability(BestMoveChangesByIteration[Iteration], BestMoveChangesByIteration[Iteration-1]); // Stop search if most of MaxSearchTime is consumed at the end of the @@ -672,7 +667,7 @@ namespace { // Print the best move and the ponder move to the standard output if (pv[0] == MOVE_NONE) { - pv[0] = rml.get_move(0); + pv[0] = rml.move(0); pv[1] = MOVE_NONE; } @@ -703,7 +698,7 @@ namespace { << move_to_san(p, pv[1]) // Works also with MOVE_NONE << endl; } - return rml.get_move_score(0); + return rml.move_score(0); } @@ -714,7 +709,6 @@ namespace { Value root_search(Position& pos, SearchStack* ss, Move* pv, RootMoveList& rml, Value* alphaPtr, Value* betaPtr) { - Value margins[2]; StateInfo st; CheckInfo ci(pos); int64_t nodes; @@ -739,7 +733,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, margins); + 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) @@ -766,7 +761,7 @@ namespace { // Pick the next root move, and print the move and the move number to // the standard output. - move = ss->currentMove = rml.get_move(i); + move = ss->currentMove = rml.move(i); if (current_search_time() >= 1000) cout << "info currmove " << move @@ -883,7 +878,7 @@ namespace { break; // Remember searched nodes counts for this move - rml.set_move_nodes(i, ThreadsMgr.nodes_searched() - nodes); + rml.add_move_nodes(i, ThreadsMgr.nodes_searched() - nodes); assert(value >= -VALUE_INFINITE && value <= VALUE_INFINITE); assert(value < beta); @@ -922,19 +917,19 @@ namespace { for (int j = 0; j < Min(MultiPV, rml.move_count()); j++) { cout << "info multipv " << j + 1 - << " score " << value_to_uci(rml.get_move_score(j)) + << " score " << value_to_uci(rml.move_score(j)) << " depth " << (j <= i ? Iteration : Iteration - 1) << " time " << current_search_time() << " nodes " << ThreadsMgr.nodes_searched() << " nps " << nps() << " pv "; - for (int k = 0; rml.get_move_pv(j, k) != MOVE_NONE && k < PLY_MAX; k++) - cout << rml.get_move_pv(j, k) << " "; + for (int k = 0; rml.move_pv(j, k) != MOVE_NONE && k < PLY_MAX; k++) + cout << rml.move_pv(j, k) << " "; cout << endl; } - alpha = rml.get_move_score(Min(i, MultiPV - 1)); + alpha = rml.move_score(Min(i, MultiPV - 1)); } } // PV move or new best move @@ -963,9 +958,14 @@ namespace { } - // 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 + template Value search(Position& pos, SearchStack* ss, Value alpha, Value beta, Depth depth, int ply) { assert(alpha >= -VALUE_INFINITE && alpha <= VALUE_INFINITE); @@ -974,8 +974,7 @@ namespace { assert(ply > 0 && ply < PLY_MAX); assert(pos.thread() >= 0 && pos.thread() < ThreadsMgr.active_threads()); - Move movesSearched[256]; - Value margins[2]; + Move movesSearched[MOVES_MAX]; StateInfo st; const TTEntry *tte; Key posKey; @@ -989,6 +988,16 @@ namespace { int threadID = pos.thread(); refinedValue = bestValue = value = -VALUE_INFINITE; oldAlpha = alpha; + isCheck = pos.is_check(); + + if (SplitPoint) + { + tte = NULL; + ttMove = excludedMove = MOVE_NONE; + threatMove = ss->sp->threatMove; + mateThreat = ss->sp->mateThreat; + goto split_point_start; + } // Step 1. Initialize node and poll. Polling can abort search ThreadsMgr.incrementNodeCounter(threadID); @@ -1003,7 +1012,7 @@ namespace { // Step 2. Check for aborted search and immediate draw if (AbortSearch || ThreadsMgr.thread_should_stop(threadID)) - return VALUE_ZERO; + return VALUE_DRAW; if (pos.is_draw() || ply >= PLY_MAX - 1) return VALUE_DRAW; @@ -1043,21 +1052,20 @@ namespace { // Step 5. Evaluate the position statically and // update gain statistics of parent move. - isCheck = pos.is_check(); if (isCheck) - ss->eval = VALUE_NONE; + ss->eval = ss->evalMargin = VALUE_NONE; else if (tte) { assert(tte->static_value() != VALUE_NONE); ss->eval = tte->static_value(); - margins[pos.side_to_move()] = tte->static_value_margin(); + ss->evalMargin = tte->static_value_margin(); refinedValue = refine_eval(tte, ss->eval, ply); } else { - refinedValue = ss->eval = evaluate(pos, margins); - TT.store(posKey, VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, MOVE_NONE, ss->eval, margins[pos.side_to_move()]); + 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 @@ -1094,14 +1102,11 @@ namespace { return refinedValue - futility_margin(depth, 0); // Step 8. Null move search with verification search (is omitted in PV nodes) - // When we jump directly to qsearch() we do a null move only if static value is - // at least beta. Otherwise we do a null move if static value is not more than - // NullMoveMargin under beta. if ( !PvNode && !ss->skipNullMove && depth > ONE_PLY && !isCheck - && refinedValue >= beta - (depth >= 4 * ONE_PLY ? NullMoveMargin : 0) + && refinedValue >= beta && !value_is_mate(beta) && pos.non_pawn_material(pos.side_to_move())) { @@ -1177,13 +1182,18 @@ namespace { if (PvNode) mateThreat = pos.has_mate_threat(); +split_point_start: // At split points actual search starts from here + // Initialize a MovePicker object for the current position - MovePicker mp = MovePicker(pos, ttMove, depth, H, ss, (PvNode ? -VALUE_INFINITE : beta)); + // 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 = isCheck && mp.number_of_evasions() == 1; - futilityBase = ss->eval + margins[pos.side_to_move()]; - singularExtensionNode = depth >= SingularExtensionDepth[PvNode] + singleEvasion = !SplitPoint && isCheck && mp.number_of_evasions() == 1; + futilityBase = ss->eval + ss->evalMargin; + singularExtensionNode = !SplitPoint + && depth >= SingularExtensionDepth[PvNode] && tte && tte->move() && !excludedMove // Do not allow recursive singular extension search @@ -1192,10 +1202,22 @@ namespace { // Step 10. Loop through moves // Loop through all legal moves until no moves remain or a beta cutoff occurs + if (SplitPoint) + { + lock_grab(&(ss->sp->lock)); + bestValue = ss->sp->bestValue; + } + while ( bestValue < beta && (move = mp.get_next_move()) != MOVE_NONE && !ThreadsMgr.thread_should_stop(threadID)) { + if (SplitPoint) + { + moveCount = ++ss->sp->moveCount; + lock_release(&(ss->sp->lock)); + } + assert(move_is_ok(move)); if (move == excludedMove) @@ -1247,8 +1269,12 @@ namespace { // Move count based pruning if ( moveCount >= futility_move_count(depth) && !(threatMove && connected_threat(pos, move, threatMove)) - && bestValue > value_mated_in(PLY_MAX)) + && bestValue > value_mated_in(PLY_MAX)) // FIXME bestValue is racy + { + if (SplitPoint) + lock_grab(&(ss->sp->lock)); continue; + } // Value based pruning // We illogically ignore reduction condition depth >= 3*ONE_PLY for predicted depth, @@ -1259,7 +1285,13 @@ namespace { if (futilityValueScaled < beta) { - if (futilityValueScaled > bestValue) + if (SplitPoint) + { + lock_grab(&(ss->sp->lock)); + if (futilityValueScaled > ss->sp->bestValue) + ss->sp->bestValue = bestValue = futilityValueScaled; + } + else if (futilityValueScaled > bestValue) bestValue = futilityValueScaled; continue; } @@ -1270,7 +1302,7 @@ namespace { // Step extra. pv search (only in PV nodes) // The first move in list is the expected PV - if (PvNode && moveCount == 1) + if (!SplitPoint && 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); else @@ -1288,6 +1320,7 @@ namespace { ss->reduction = reduction(depth, moveCount); if (ss->reduction) { + alpha = SplitPoint ? ss->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); @@ -1303,6 +1336,7 @@ namespace { assert(newDepth - ONE_PLY >= ONE_PLY); ss->reduction = ONE_PLY; + alpha = SplitPoint ? ss->sp->alpha : alpha; value = -search(pos, ss+1, -(alpha+1), -alpha, newDepth-ss->reduction, ply+1); doFullDepthSearch = (value > alpha); } @@ -1312,6 +1346,7 @@ namespace { // Step 15. Full depth search if (doFullDepthSearch) { + alpha = SplitPoint ? ss->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); @@ -1330,11 +1365,21 @@ namespace { assert(value > -VALUE_INFINITE && value < VALUE_INFINITE); // Step 17. Check for new best move - if (value > bestValue) + if (SplitPoint) + { + lock_grab(&(ss->sp->lock)); + bestValue = ss->sp->bestValue; + alpha = ss->sp->alpha; + } + + if (value > bestValue && !(SplitPoint && ThreadsMgr.thread_should_stop(threadID))) { bestValue = value; if (value > alpha) { + if (SplitPoint && (!PvNode || value >= beta)) + ss->sp->stopRequest = true; + if (PvNode && value < beta) // We want always alpha < beta alpha = value; @@ -1343,10 +1388,17 @@ namespace { ss->bestMove = move; } + if (SplitPoint) + { + ss->sp->bestValue = bestValue; + ss->sp->alpha = alpha; + ss->sp->parentSstack->bestMove = ss->bestMove; + } } // Step 18. Check for split - if ( depth >= MinimumSplitDepth + if ( !SplitPoint + && depth >= MinimumSplitDepth && ThreadsMgr.active_threads() > 1 && bestValue < beta && ThreadsMgr.available_thread_exists(threadID) @@ -1354,7 +1406,15 @@ namespace { && !ThreadsMgr.thread_should_stop(threadID) && Iteration <= 99) ThreadsMgr.split(pos, ss, ply, &alpha, beta, &bestValue, depth, - threatMove, mateThreat, &moveCount, &mp, PvNode); + threatMove, mateThreat, moveCount, &mp, PvNode); + } + + if (SplitPoint) + { + /* Here we have the lock still grabbed */ + ss->sp->slaves[threadID] = 0; + lock_release(&(ss->sp->lock)); + return bestValue; } // Step 19. Check for mate and stalemate @@ -1372,7 +1432,7 @@ namespace { 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, margins[pos.side_to_move()]); + 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 @@ -1402,10 +1462,9 @@ namespace { assert(ply > 0 && ply < PLY_MAX); assert(pos.thread() >= 0 && pos.thread() < ThreadsMgr.active_threads()); - Value margins[2]; StateInfo st; Move ttMove, move; - Value bestValue, value, futilityValue, futilityBase; + Value bestValue, value, evalMargin, futilityValue, futilityBase; bool isCheck, deepChecks, enoughMaterial, moveIsCheck, evasionPrunable; const TTEntry* tte; Value oldAlpha = alpha; @@ -1434,7 +1493,7 @@ namespace { if (isCheck) { bestValue = futilityBase = -VALUE_INFINITE; - ss->eval = VALUE_NONE; + ss->eval = evalMargin = VALUE_NONE; deepChecks = enoughMaterial = false; } else @@ -1443,20 +1502,19 @@ namespace { { assert(tte->static_value() != VALUE_NONE); - margins[pos.side_to_move()] = tte->static_value_margin(); - bestValue = tte->static_value(); + evalMargin = tte->static_value_margin(); + ss->eval = bestValue = tte->static_value(); } else - bestValue = evaluate(pos, margins); + ss->eval = bestValue = evaluate(pos, evalMargin); - ss->eval = bestValue; update_gains(pos, (ss-1)->currentMove, (ss-1)->eval, ss->eval); // Stand pat. Return immediately if static value is at least beta if (bestValue >= beta) { if (!tte) - TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, DEPTH_NONE, MOVE_NONE, ss->eval, margins[pos.side_to_move()]); + TT.store(pos.get_key(), value_to_tt(bestValue, ply), VALUE_TYPE_LOWER, DEPTH_NONE, MOVE_NONE, ss->eval, evalMargin); return bestValue; } @@ -1468,7 +1526,7 @@ namespace { deepChecks = (depth == -ONE_PLY && bestValue >= beta - PawnValueMidgame / 8); // Futility pruning parameters, not needed when in check - futilityBase = bestValue + FutilityMarginQS + margins[pos.side_to_move()]; + futilityBase = ss->eval + evalMargin + FutilityMarginQS; enoughMaterial = pos.non_pawn_material(pos.side_to_move()) > RookValueMidgame; } @@ -1508,11 +1566,10 @@ namespace { } } - // Detect blocking evasions that are candidate to be pruned + // Detect non-capture evasions that are candidate to be pruned evasionPrunable = isCheck && bestValue > value_mated_in(PLY_MAX) && !pos.move_is_capture(move) - && pos.type_of_piece_on(move_from(move)) != KING && !pos.can_castle(pos.side_to_move()); // Don't search moves with negative SEE values @@ -1553,12 +1610,7 @@ namespace { // Update transposition table Depth d = (depth == DEPTH_ZERO ? DEPTH_ZERO : DEPTH_ZERO - ONE_PLY); ValueType vt = (bestValue <= oldAlpha ? VALUE_TYPE_UPPER : bestValue >= beta ? VALUE_TYPE_LOWER : VALUE_TYPE_EXACT); - TT.store(pos.get_key(), value_to_tt(bestValue, ply), vt, d, ss->bestMove, ss->eval, margins[pos.side_to_move()]); - - // Update killers only for checking moves that fails high - if ( bestValue >= beta - && !pos.move_is_capture_or_promotion(ss->bestMove)) - update_killers(ss->bestMove, ss); + TT.store(pos.get_key(), value_to_tt(bestValue, ply), vt, d, ss->bestMove, ss->eval, evalMargin); assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE); @@ -1566,174 +1618,6 @@ namespace { } - // 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(SplitPoint* sp, int threadID) { - - assert(threadID >= 0 && threadID < ThreadsMgr.active_threads()); - assert(ThreadsMgr.active_threads() > 1); - - StateInfo st; - Move move; - Depth ext, newDepth; - Value value; - Value futilityValueScaled; // NonPV specific - bool isCheck, moveIsCheck, captureOrPromotion, dangerous; - int moveCount; - value = -VALUE_INFINITE; - - 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 - && !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 = sp->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(sp->depth) - && !(sp->threatMove && connected_threat(pos, move, sp->threatMove)) - && sp->bestValue > value_mated_in(PLY_MAX)) - { - lock_grab(&(sp->lock)); - continue; - } - - // Value based pruning - Depth predictedDepth = newDepth - reduction(sp->depth, moveCount); - futilityValueScaled = ss->eval + futility_margin(predictedDepth, moveCount) - + H.gain(pos.piece_on(move_from(move)), move_to(move)); - - if (futilityValueScaled < sp->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(sp->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); - - 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, sp->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, sp->ply+1) - : - search(pos, ss+1, -(localAlpha+1), -localAlpha, newDepth, sp->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); - } - - // 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 (sp->bestValue > sp->alpha) - { - if (!PvNode || value >= sp->beta) - sp->stopRequest = true; - - if (PvNode && value < sp->beta) // This guarantees that always: sp->alpha < sp->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 @@ -2171,6 +2055,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; @@ -2243,16 +2128,15 @@ namespace { StateInfo st; TTEntry* tte; Position p(pos, pos.thread()); - Value margins[2]; - Value v; + Value v, m = VALUE_NONE; for (int i = 0; pv[i] != MOVE_NONE; i++) { tte = TT.retrieve(p.get_key()); if (!tte || tte->move() != pv[i]) { - v = (p.is_check() ? VALUE_NONE : evaluate(p, margins)); - TT.store(p.get_key(), VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, pv[i], v, margins[pos.side_to_move()]); + v = (p.is_check() ? VALUE_NONE : evaluate(p, m)); + TT.store(p.get_key(), VALUE_NONE, VALUE_TYPE_NONE, DEPTH_NONE, pv[i], v, m); } p.do_move(pv[i], st); } @@ -2383,10 +2267,16 @@ namespace { threads[threadID].state = THREAD_SEARCHING; - if (threads[threadID].splitPoint->pvNode) - sp_search(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(pos, ss, tsp->alpha, tsp->beta, tsp->depth, tsp->ply); else - sp_search(threads[threadID].splitPoint, threadID); + search(pos, ss, tsp->alpha, tsp->beta, tsp->depth, tsp->ply); assert(threads[threadID].state == THREAD_SEARCHING); @@ -2405,6 +2295,8 @@ namespace { lock_grab(&(sp->lock)); lock_release(&(sp->lock)); + // In helpful master concept a master can help only a sub-tree, and + // because here is all finished is not possible master is booked. assert(threads[threadID].state == THREAD_AVAILABLE); threads[threadID].state = THREAD_SEARCHING; @@ -2482,13 +2374,11 @@ namespace { void ThreadsManager::exit_threads() { - ActiveThreads = MAX_THREADS; // HACK - AllThreadsShouldSleep = true; // HACK + ActiveThreads = MAX_THREADS; // Wake up all the threads + AllThreadsShouldExit = true; // Let the woken up threads to exit idle_loop() + AllThreadsShouldSleep = true; // Avoid an assert in wake_sleeping_threads() wake_sleeping_threads(); - // This makes the threads to exit idle_loop() - AllThreadsShouldExit = true; - // Wait for thread termination for (int i = 1; i < MAX_THREADS; i++) while (threads[i].state != THREAD_TERMINATED) {} @@ -2511,9 +2401,9 @@ namespace { assert(threadID >= 0 && threadID < ActiveThreads); - SplitPoint* sp; + SplitPoint* sp = threads[threadID].splitPoint; - for (sp = threads[threadID].splitPoint; sp && !sp->stopRequest; sp = sp->parent) {} + for ( ; sp && !sp->stopRequest; sp = sp->parent) {} return sp != NULL; } @@ -2538,12 +2428,9 @@ namespace { // Make a local copy to be sure doesn't change under our feet int localActiveSplitPoints = threads[slave].activeSplitPoints; - if (localActiveSplitPoints == 0) - // No active split points means that the thread is available as - // a slave for any other thread. - return true; - - if (ActiveThreads == 2) + // No active split points means that the thread is available as + // a slave for any other thread. + if (localActiveSplitPoints == 0 || ActiveThreads == 2) return true; // Apply the "helpful master" concept if possible. Use localActiveSplitPoints @@ -2585,7 +2472,7 @@ namespace { template void ThreadsManager::split(const Position& p, SearchStack* ss, int ply, Value* alpha, const Value beta, Value* bestValue, Depth depth, Move threatMove, - bool mateThreat, int* moveCount, MovePicker* mp, bool pvNode) { + bool mateThreat, int moveCount, MovePicker* mp, bool pvNode) { assert(p.is_ok()); assert(ply > 0 && ply < PLY_MAX); assert(*bestValue >= -VALUE_INFINITE); @@ -2625,7 +2512,7 @@ namespace { splitPoint.pvNode = pvNode; splitPoint.bestValue = *bestValue; splitPoint.mp = mp; - splitPoint.moveCount = *moveCount; + splitPoint.moveCount = moveCount; splitPoint.pos = &p; splitPoint.parentSstack = ss; for (i = 0; i < ActiveThreads; i++) @@ -2726,17 +2613,17 @@ namespace { // RootMoveList c'tor - RootMoveList::RootMoveList(Position& pos, Move searchMoves[]) : count(0) { + RootMoveList::RootMoveList(Position& pos, Move searchMoves[]) { SearchStack ss[PLY_MAX_PLUS_2]; - MoveStack mlist[MaxRootMoves]; + MoveStack mlist[MOVES_MAX]; StateInfo st; bool includeAllMoves = (searchMoves[0] == MOVE_NONE); // Initialize search stack init_ss_array(ss, PLY_MAX_PLUS_2); - ss[0].currentMove = ss[0].bestMove = MOVE_NONE; - ss[0].eval = VALUE_NONE; + ss[0].eval = ss[0].evalMargin = VALUE_NONE; + count = 0; // Generate all legal moves MoveStack* last = generate_moves(pos, mlist); @@ -2753,12 +2640,10 @@ namespace { continue; // Find a quick score for the move + moves[count].move = ss[0].currentMove = moves[count].pv[0] = cur->move; + moves[count].pv[1] = MOVE_NONE; pos.do_move(cur->move, st); - ss[0].currentMove = cur->move; - moves[count].move = cur->move; moves[count].score = -qsearch(pos, ss+1, -VALUE_INFINITE, VALUE_INFINITE, DEPTH_ZERO, 1); - moves[count].pv[0] = cur->move; - moves[count].pv[1] = MOVE_NONE; pos.undo_move(cur->move); count++; } @@ -2785,12 +2670,6 @@ namespace { // RootMoveList simple methods definitions - void RootMoveList::set_move_nodes(int moveNum, int64_t nodes) { - - moves[moveNum].nodes = nodes; - moves[moveNum].cumulativeNodes += nodes; - } - void RootMoveList::set_move_pv(int moveNum, const Move pv[]) { int j; @@ -2829,4 +2708,4 @@ namespace { } } -} // namspace +} // namespace