From 374c9e6b63d0e233371ae38cc054d885f2117884 Mon Sep 17 00:00:00 2001 From: Gary Linscott Date: Mon, 26 Mar 2012 07:52:10 -0400 Subject: [PATCH] Add more detailed pawn shelter/storm evaluation --- src/bitboard.cpp | 26 ++++++++++++++++++++ src/bitboard.h | 29 +++++++++++++++++++--- src/pawns.cpp | 63 +++++++++++++++++++++++++++++++++++++++--------- 3 files changed, 102 insertions(+), 16 deletions(-) diff --git a/src/bitboard.cpp b/src/bitboard.cpp index 84e576c6..ebd048be 100644 --- a/src/bitboard.cpp +++ b/src/bitboard.cpp @@ -58,6 +58,7 @@ namespace { CACHE_LINE_ALIGNMENT int BSFTable[64]; + int MS1BTable[256]; Bitboard RTable[0x19000]; // Storage space for rook attacks Bitboard BTable[0x1480]; // Storage space for bishop attacks @@ -140,6 +141,26 @@ Square pop_1st_bit(Bitboard* b) { #endif // !defined(USE_BSFQ) +#if !defined(USE_BSFQ) + +Square last_1(Bitboard b) { + int result = 0; + if (b > 0xFFFFFFFF) { + b >>= 32; + result = 32; + } + if (b > 0xFFFF) { + b >>= 16; + result += 16; + } + if (b > 0xFF) { + b >>= 8; + result += 8; + } + return Square(result + MS1BTable[b]); +} + +#endif // !defined(USE_BSFQ) /// bitboards_init() initializes various bitboard arrays. It is called during /// program initialization. @@ -196,6 +217,11 @@ void bitboards_init() { else BSFTable[((1ULL << i) * 0x218A392CD3D5DBFULL) >> 58] = i; + MS1BTable[0] = 0; + for (int i = 0, k = 1; i < 8; i++) + for (int j = 0; j < (1 << i); j++) + MS1BTable[k++] = i; + int steps[][9] = { {}, { 7, 9 }, { 17, 15, 10, 6, -6, -10, -15, -17 }, {}, {}, {}, { 9, 7, -7, -9, 8, 1, -1, -8 } }; diff --git a/src/bitboard.h b/src/bitboard.h index 6f3a0048..2b916125 100644 --- a/src/bitboard.h +++ b/src/bitboard.h @@ -214,7 +214,6 @@ inline bool single_bit(Bitboard b) { return !(b & (b - 1)); } - /// first_1() finds the least significant nonzero bit in a nonzero bitboard. /// pop_1st_bit() finds and clears the least significant nonzero bit in a /// nonzero bitboard. @@ -224,9 +223,15 @@ inline bool single_bit(Bitboard b) { #if defined(_MSC_VER) && !defined(__INTEL_COMPILER) FORCE_INLINE Square first_1(Bitboard b) { - unsigned long index; - _BitScanForward64(&index, b); - return (Square) index; + unsigned long index; + _BitScanForward64(&index, b); + return (Square) index; +} + +FORCE_INLINE Square last_1(Bitboard b) { + unsigned long index; + _BitScanReverse64(&index, b); + return (Square) index; } #else @@ -235,6 +240,12 @@ FORCE_INLINE Square first_1(Bitboard b) { // Assembly code by Heinz van Saanen __asm__("bsfq %1, %0": "=r"(dummy): "rm"(b) ); return (Square) dummy; } + +FORCE_INLINE Square last_1(Bitboard b) { + Bitboard dummy; + __asm__("bsrq %1, %0": "=r"(dummy): "rm"(b) ); + return (Square) dummy; +} #endif FORCE_INLINE Square pop_1st_bit(Bitboard* b) { @@ -246,10 +257,20 @@ FORCE_INLINE Square pop_1st_bit(Bitboard* b) { #else // if !defined(USE_BSFQ) extern Square first_1(Bitboard b); +extern Square last_1(Bitboard b); extern Square pop_1st_bit(Bitboard* b); #endif +// relative_rank() returns the relative rank of the closest bit set on the Bitboard. +// Only to be used with bitboards that contain a single file. + +template +inline Rank relative_rank(Bitboard b) { + Square s = Us == WHITE ? first_1(b) + : ~last_1(b); + return rank_of(s); +} extern void print_bitboard(Bitboard b); extern void bitboards_init(); diff --git a/src/pawns.cpp b/src/pawns.cpp index 950994ef..eeabcbae 100644 --- a/src/pawns.cpp +++ b/src/pawns.cpp @@ -65,6 +65,19 @@ namespace { #undef S + const File ShelterFile[8] = { FILE_B, FILE_B, FILE_C, FILE_D, FILE_E, FILE_F, FILE_G, FILE_G }; + + inline Value score_non_center_file(const Value v) { + return Value(v * 7 / 16); + } + + typedef Value V; + // Arrays are indexed by rank. Zeroth value is for when no pawn on that file. + const Value PawnShelter[8] = { V(141), V(0), V( 38), V(102), V(128), V(141), V(141), V(141) }; + const Value PawnStorm[8] = { V( 26), V(0), V(128), V( 51), V( 26), V( 0), V( 0), V( 0) }; + // We compute shelter as a penalty for the given color, but shelter is used as a bonus, so we invert it using this as the basis. + const Value PawnShelterBasis = PawnShelter[0] + score_non_center_file(PawnShelter[0]) * 2; + inline Score apply_weight(Score v, Score w) { return make_score((int(mg_value(v)) * mg_value(w)) / 0x100, (int(eg_value(v)) * eg_value(w)) / 0x100); @@ -209,27 +222,53 @@ Score PawnInfoTable::evaluate_pawns(const Position& pos, Bitboard ourPawns, return value; } +template +int computePawnShelter(const Position &pos, Square ksq) { + const Color Them = (Us == WHITE ? BLACK : WHITE); + const File kingFile = ShelterFile[file_of(ksq)]; + const Bitboard ourPawns = pos.pieces(PAWN, Us) & in_front_bb(Us, ksq); + const Bitboard theirPawns = pos.pieces(PAWN, Them) & (RankBB[rank_of(ksq)] | in_front_bb(Us, ksq)); + + int shelter = 0; + + // Compute king shelter and storm values for the file the king is on, as well as the two adjacent files. + for (int fileOffset = -1; fileOffset <= 1; fileOffset++) { + // Shelter takes full penalty for center file, otherwise it's half penalty + Bitboard shelterFile = ourPawns & FileBB[kingFile + fileOffset]; + Rank shelterClosest = shelterFile ? relative_rank(shelterFile) + : RANK_1; + + shelter += fileOffset == 0 ? PawnShelter[shelterClosest] + : score_non_center_file(PawnShelter[shelterClosest]); + + // Storm takes full penalty, unless there is an enemy pawn blocking us + Bitboard stormFile = theirPawns & FileBB[kingFile + fileOffset]; + Rank stormClosest = stormFile ? relative_rank(stormFile) + : RANK_1; + + shelter += shelterClosest + 1 == stormClosest ? PawnStorm[stormClosest] / 2 + : PawnStorm[stormClosest]; + } + + return shelter; +} /// PawnInfo::updateShelter() calculates and caches king shelter. It is called /// only when king square changes, about 20% of total king_shelter() calls. template Score PawnInfo::updateShelter(const Position& pos, Square ksq) { - - const int Shift = (Us == WHITE ? 8 : -8); - - Bitboard pawns; - int r, shelter = 0; + int shelter = 0; if (relative_rank(Us, ksq) <= RANK_4) { - pawns = pos.pieces(PAWN, Us) & this_and_adjacent_files_bb(file_of(ksq)); - r = ksq & (7 << 3); - for (int i = 0; i < 3; i++) - { - r += Shift; - shelter += BitCount8Bit[(pawns >> r) & 0xFF] << (6 - i); - } + shelter = computePawnShelter(pos, ksq); + if (pos.can_castle(Us == WHITE ? WHITE_OO : BLACK_OO)) + shelter = std::min(shelter, computePawnShelter(pos, relative_square(Us, SQ_G1))); + if (pos.can_castle(Us == WHITE ? WHITE_OOO : BLACK_OOO)) + shelter = std::min(shelter, computePawnShelter(pos, relative_square(Us, SQ_C1))); + shelter = PawnShelterBasis - shelter; } + kingSquares[Us] = ksq; kingShelters[Us] = make_score(shelter, 0); return kingShelters[Us]; -- 2.39.2