Permalink
Browse files

Merge pull request #11 from glinscott/squash

Add more detailed pawn shelter/storm evaluation

After 10670 games at 10"+0.05
Mod vs Orig 2277 - 1941 - 6452 ELO +11 !!!

The first real increase since 2.2.2, congratulations Gary !!!

Signed-off-by: Marco Costalba <mcostalba@gmail.com>
  • Loading branch information...
2 parents 22e294e + 374c9e6 commit cc2b3ece5c5d8d1183f8526fbb0ee4e1ea7a69fe @mcostalba mcostalba committed Mar 28, 2012
Showing with 102 additions and 16 deletions.
  1. +26 −0 src/bitboard.cpp
  2. +25 −4 src/bitboard.h
  3. +51 −12 src/pawns.cpp
View
@@ -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 } };
View
@@ -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<Color Us>
+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();
View
@@ -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<Color Us>
+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<Us>(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<Us>(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<Color Us>
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<Us>(pos, ksq);
+ if (pos.can_castle(Us == WHITE ? WHITE_OO : BLACK_OO))
+ shelter = std::min(shelter, computePawnShelter<Us>(pos, relative_square(Us, SQ_G1)));
+ if (pos.can_castle(Us == WHITE ? WHITE_OOO : BLACK_OOO))
+ shelter = std::min(shelter, computePawnShelter<Us>(pos, relative_square(Us, SQ_C1)));
+ shelter = PawnShelterBasis - shelter;
}
+
kingSquares[Us] = ksq;
kingShelters[Us] = make_score(shelter, 0);
return kingShelters[Us];

0 comments on commit cc2b3ec

Please sign in to comment.