X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=src%2Fmovepick.cpp;h=69d848d27564a0680e2c97d7baf97f02ef401dda;hb=20d6a8e57f55e586f5ab8b3bcb60bfe17c5f2708;hp=d6cd4e230d66e89c23fec925d5e680a439e2acef;hpb=f3189bdc9af1451449473bdd1977ed1ffa663c85;p=stockfish diff --git a/src/movepick.cpp b/src/movepick.cpp index d6cd4e23..69d848d2 100644 --- a/src/movepick.cpp +++ b/src/movepick.cpp @@ -35,7 +35,7 @@ namespace { STOP }; - // Our insertion sort, which is guaranteed (and also needed) to be stable + // Our insertion sort, which is guaranteed to be stable, as it should be void insertion_sort(ExtMove* begin, ExtMove* end) { ExtMove tmp, *p, *q; @@ -49,14 +49,15 @@ namespace { } } - // Picks the best move in the range (begin, end) and moves it to the front. - // It's faster than sorting all the moves in advance when there are few - // moves e.g. possible captures. - inline ExtMove* pick_best(ExtMove* begin, ExtMove* end) + // pick_best() finds the best move in the range (begin, end) and moves it to + // the front. It's faster than sorting all the moves in advance when there + // are few moves e.g. the possible captures. + inline Move pick_best(ExtMove* begin, ExtMove* end) { std::swap(*begin, *std::max_element(begin, end)); - return begin; + return begin->move; } + } // namespace @@ -148,11 +149,15 @@ void MovePicker::score() { // has been picked up in pick_move_from_list(). This way we save some SEE // calls in case we get a cutoff. for (auto& m : *this) - m.value = PieceValue[MG][pos.piece_on(to_sq(m))] - - Value(type_of(pos.moved_piece(m))) - + (type_of(m) == ENPASSANT ? PieceValue[MG][PAWN] : - type_of(m) == PROMOTION ? PieceValue[MG][promotion_type(m)] - PieceValue[MG][PAWN] - : VALUE_ZERO); + if (type_of(m) == ENPASSANT) + m.value = PieceValue[MG][PAWN] - Value(PAWN); + + else if (type_of(m) == PROMOTION) + m.value = PieceValue[MG][pos.piece_on(to_sq(m))] - Value(PAWN) + + PieceValue[MG][promotion_type(m)] - PieceValue[MG][PAWN]; + else + m.value = PieceValue[MG][pos.piece_on(to_sq(m))] + - Value(type_of(pos.moved_piece(m))); } template<> @@ -192,64 +197,48 @@ void MovePicker::generate_next_stage() { case CAPTURES_S1: case CAPTURES_S3: case CAPTURES_S4: case CAPTURES_S5: case CAPTURES_S6: endMoves = generate(pos, moves); score(); - return; + break; case KILLERS_S1: cur = killers; - endMoves = cur + 2; - + endMoves = cur + 6; killers[0].move = ss->killers[0]; killers[1].move = ss->killers[1]; - killers[2].move = killers[3].move = MOVE_NONE; - killers[4].move = killers[5].move = MOVE_NONE; - - // Please note that following code is racy and could yield to rare (less - // than 1 out of a million) duplicated entries in SMP case. This is harmless. - - // Be sure countermoves are different from killers - for (int i = 0; i < 2; ++i) - if ( countermoves[i] != (cur+0)->move - && countermoves[i] != (cur+1)->move) - (endMoves++)->move = countermoves[i]; - - // Be sure followupmoves are different from killers and countermoves - for (int i = 0; i < 2; ++i) - if ( followupmoves[i] != (cur+0)->move - && followupmoves[i] != (cur+1)->move - && followupmoves[i] != (cur+2)->move - && followupmoves[i] != (cur+3)->move) - (endMoves++)->move = followupmoves[i]; - return; + killers[2].move = countermoves[0]; + killers[3].move = countermoves[1]; + killers[4].move = followupmoves[0]; + killers[5].move = followupmoves[1]; + break; case QUIETS_1_S1: endQuiets = endMoves = generate(pos, moves); score(); endMoves = std::partition(cur, endMoves, [](const ExtMove& m) { return m.value > VALUE_ZERO; }); insertion_sort(cur, endMoves); - return; + break; case QUIETS_2_S1: cur = endMoves; endMoves = endQuiets; if (depth >= 3 * ONE_PLY) insertion_sort(cur, endMoves); - return; + break; case BAD_CAPTURES_S1: // Just pick them in reverse order to get MVV/LVA ordering cur = moves + MAX_MOVES - 1; endMoves = endBadCaptures; - return; + break; case EVASIONS_S2: endMoves = generate(pos, moves); - if (endMoves > moves + 1) + if (endMoves - moves > 1) score(); - return; + break; case QUIET_CHECKS_S3: endMoves = generate(pos, moves); - return; + break; case EVASION: case QSEARCH_0: case QSEARCH_1: case PROBCUT: case RECAPTURE: stage = STOP; @@ -257,7 +246,7 @@ void MovePicker::generate_next_stage() { case STOP: endMoves = cur + 1; // Avoid another next_phase() call - return; + break; default: assert(false); @@ -286,7 +275,7 @@ Move MovePicker::next_move() { return ttMove; case CAPTURES_S1: - move = pick_best(cur++, endMoves)->move; + move = pick_best(cur++, endMoves); if (move != ttMove) { if (pos.see_sign(move) >= VALUE_ZERO) @@ -298,49 +287,56 @@ Move MovePicker::next_move() { break; case KILLERS_S1: - move = (cur++)->move; + move = *cur++; if ( move != MOVE_NONE && move != ttMove && pos.pseudo_legal(move) && !pos.capture(move)) + { + // Check for duplicated entries + for (int i = 0; i < cur - 1 - killers; i++) + if (move == killers[i]) + goto skip; return move; + } + skip: break; case QUIETS_1_S1: case QUIETS_2_S1: - move = (cur++)->move; + move = *cur++; if ( move != ttMove - && move != killers[0].move - && move != killers[1].move - && move != killers[2].move - && move != killers[3].move - && move != killers[4].move - && move != killers[5].move) + && move != killers[0] + && move != killers[1] + && move != killers[2] + && move != killers[3] + && move != killers[4] + && move != killers[5]) return move; break; case BAD_CAPTURES_S1: - return (cur--)->move; + return *cur--; case EVASIONS_S2: case CAPTURES_S3: case CAPTURES_S4: - move = pick_best(cur++, endMoves)->move; + move = pick_best(cur++, endMoves); if (move != ttMove) return move; break; case CAPTURES_S5: - move = pick_best(cur++, endMoves)->move; + move = pick_best(cur++, endMoves); if (move != ttMove && pos.see(move) > captureThreshold) return move; break; case CAPTURES_S6: - move = pick_best(cur++, endMoves)->move; + move = pick_best(cur++, endMoves); if (to_sq(move) == recaptureSquare) return move; break; case QUIET_CHECKS_S3: - move = (cur++)->move; + move = *cur++; if (move != ttMove) return move; break;