X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fevaluate.cpp;h=372313b778e688a7333f5fc6815c85c5ff44e8dc;hp=3e996da8d32ba6f247ad8b516a880af2d28f2dd0;hb=738bf66a2d04d27ce8c5481fef52dc3adc3cafe1;hpb=feb5342b393895160867aa7c7fa4d6cb563718ca

diff --git a/src/evaluate.cpp b/src/evaluate.cpp
index 3e996da8..372313b7 100644
--- a/src/evaluate.cpp
+++ b/src/evaluate.cpp
@@ -1,7 +1,7 @@
 /*
   Stockfish, a UCI chess playing engine derived from Glaurung 2.1
   Copyright (C) 2004-2008 Tord Romstad (Glaurung author)
-  Copyright (C) 2008 Marco Costalba
+  Copyright (C) 2008-2009 Marco Costalba
 
   Stockfish is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -25,6 +25,7 @@
 #include <cassert>
 #include <cstring>
 
+#include "bitcount.h"
 #include "evaluate.h"
 #include "material.h"
 #include "pawns.h"
@@ -39,23 +40,20 @@
 
 namespace {
 
-  const int Sign[2] = {1, -1};
+  const int Sign[2] = { 1, -1 };
 
-  // Evaluation grain size, must be a power of 2.
+  // Evaluation grain size, must be a power of 2
   const int GrainSize = 4;
 
-  // Evaluation weights
-  int WeightMobilityMidgame      = 0x100;
-  int WeightMobilityEndgame      = 0x100;
-  int WeightPawnStructureMidgame = 0x100;
-  int WeightPawnStructureEndgame = 0x100;
-  int WeightPassedPawnsMidgame   = 0x100;
-  int WeightPassedPawnsEndgame   = 0x100;
-  int WeightKingSafety[2] = { 0x100, 0x100 };
+  // Evaluation weights, initialized from UCI options
+  int WeightMobilityMidgame, WeightMobilityEndgame;
+  int WeightPawnStructureMidgame, WeightPawnStructureEndgame;
+  int WeightPassedPawnsMidgame, WeightPassedPawnsEndgame;
+  int WeightKingSafety[2];
   int WeightSpace;
 
-  // Internal evaluation weights.  These are applied on top of the evaluation
-  // weights read from UCI parameters.  The purpose is to be able to change
+  // Internal evaluation weights. These are applied on top of the evaluation
+  // weights read from UCI parameters. The purpose is to be able to change
   // the evaluation weights while keeping the default values of the UCI
   // parameters at 100, which looks prettier.
   //
@@ -86,7 +84,7 @@ namespace {
   };
 
   // Bishop mobility bonus in middle game and endgame, indexed by the number
-  // of attacked squares not occupied by friendly pieces.  X-ray attacks through
+  // of attacked squares not occupied by friendly pieces. X-ray attacks through
   // queens are also included.
   const Value MidgameBishopMobilityBonus[] = {
   //    0       1      2      3      4      5      6      7
@@ -103,7 +101,7 @@ namespace {
   };
 
   // Rook mobility bonus in middle game and endgame, indexed by the number
-  // of attacked squares not occupied by friendly pieces.  X-ray attacks through
+  // of attacked squares not occupied by friendly pieces. X-ray attacks through
   // queens and rooks are also included.
   const Value MidgameRookMobilityBonus[] = {
   //    0       1      2      3      4      5      6      7
@@ -178,38 +176,37 @@ namespace {
   const Value MidgameQueenOn7thBonus = Value(27);
   const Value EndgameQueenOn7thBonus = Value(54);
 
-
   // Rooks on open files
   const Value RookOpenFileBonus = Value(43);
   const Value RookHalfOpenFileBonus = Value(19);
 
   // Penalty for rooks trapped inside a friendly king which has lost the
-  // right to castle:
+  // right to castle.
   const Value TrappedRookPenalty = Value(180);
 
   // Penalty for a bishop on a7/h7 (a2/h2 for black) which is trapped by
-  // enemy pawns:
+  // enemy pawns.
   const Value TrappedBishopA7H7Penalty = Value(300);
 
-  // Bitboard masks for detecting trapped bishops on a7/h7 (a2/h2 for black):
+  // Bitboard masks for detecting trapped bishops on a7/h7 (a2/h2 for black)
   const Bitboard MaskA7H7[2] = {
     ((1ULL << SQ_A7) | (1ULL << SQ_H7)),
     ((1ULL << SQ_A2) | (1ULL << SQ_H2))
   };
 
   // Penalty for a bishop on a1/h1 (a8/h8 for black) which is trapped by
-  // a friendly pawn on b2/g2 (b7/g7 for black).  This can obviously only
+  // a friendly pawn on b2/g2 (b7/g7 for black). This can obviously only
   // happen in Chess960 games.
   const Value TrappedBishopA1H1Penalty = Value(100);
 
-  // Bitboard masks for detecting trapped bishops on a1/h1 (a8/h8 for black):
+  // Bitboard masks for detecting trapped bishops on a1/h1 (a8/h8 for black)
   const Bitboard MaskA1H1[2] = {
     ((1ULL << SQ_A1) | (1ULL << SQ_H1)),
     ((1ULL << SQ_A8) | (1ULL << SQ_H8))
   };
 
   // The SpaceMask[color] contains area of the board which is consdered by
-  // the space evaluation.  In the middle game, each side is given a bonus
+  // the space evaluation. In the middle game, each side is given a bonus
   // based on how many squares inside this area are safe and available for
   // friendly minor pieces.
   const Bitboard SpaceMask[2] = {
@@ -221,30 +218,26 @@ namespace {
     (1ULL<<SQ_C5) | (1ULL<<SQ_D5) | (1ULL<<SQ_E5) | (1ULL<<SQ_F5)
   };
 
-  /// King safety constants and variables.  The king safety scores are taken
-  /// from the array SafetyTable[].  Various little "meta-bonuses" measuring
+  /// King safety constants and variables. The king safety scores are taken
+  /// from the array SafetyTable[]. Various little "meta-bonuses" measuring
   /// the strength of the attack are added up into an integer, which is used
   /// as an index to SafetyTable[].
 
-  // Attack weights for each piece type.
+  // Attack weights for each piece type
   const int QueenAttackWeight  = 5;
   const int RookAttackWeight   = 3;
   const int BishopAttackWeight = 2;
   const int KnightAttackWeight = 2;
 
-  // Bonuses for safe checks for each piece type.
-  int QueenContactCheckBonus = 3;
-  int QueenCheckBonus        = 2;
-  int RookCheckBonus         = 1;
-  int BishopCheckBonus       = 1;
-  int KnightCheckBonus       = 1;
-  int DiscoveredCheckBonus   = 3;
+  // Bonuses for safe checks, initialized from UCI options
+  int QueenContactCheckBonus, DiscoveredCheckBonus;
+  int QueenCheckBonus, RookCheckBonus, BishopCheckBonus, KnightCheckBonus;
 
   // Scan for queen contact mates?
   const bool QueenContactMates = true;
 
-  // Bonus for having a mate threat.
-  int MateThreatBonus = 3;
+  // Bonus for having a mate threat, initialized from UCI options
+  int MateThreatBonus;
 
   // InitKingDanger[] contains bonuses based on the position of the defending
   // king.
@@ -259,27 +252,30 @@ namespace {
     15, 15, 15, 15, 15, 15, 15, 15
   };
 
-  // SafetyTable[] contains the actual king safety scores.  It is initialized
+  // SafetyTable[] contains the actual king safety scores. It is initialized
   // in init_safety().
   Value SafetyTable[100];
 
   // Pawn and material hash tables, indexed by the current thread id
-  PawnInfoTable *PawnTable[8] = {0, 0, 0, 0, 0, 0, 0, 0};
-  MaterialInfoTable *MaterialTable[8] = {0, 0, 0, 0, 0, 0, 0, 0};
+  PawnInfoTable* PawnTable[8] = {0, 0, 0, 0, 0, 0, 0, 0};
+  MaterialInfoTable* MaterialTable[8] = {0, 0, 0, 0, 0, 0, 0, 0};
 
   // Sizes of pawn and material hash tables
   const int PawnTableSize = 16384;
   const int MaterialTableSize = 1024;
 
-  // Array which gives the number of nonzero bits in an 8-bit integer:
+  // Array which gives the number of nonzero bits in an 8-bit integer
   uint8_t BitCount8Bit[256];
 
   // Function prototypes
-  template<PieceType Piece>
+  template<bool HasPopCnt>
+  Value do_evaluate(const Position& pos, EvalInfo& ei, int threadID);
+
+  template<PieceType Piece, bool HasPopCnt>
   void evaluate_pieces(const Position& p, Color us, EvalInfo& ei);
 
   template<>
-  void evaluate_pieces<KING>(const Position& p, Color us, EvalInfo &ei);
+  void evaluate_pieces<KING, false>(const Position& p, Color us, EvalInfo &ei);
 
   void evaluate_passed_pawns(const Position &pos, EvalInfo &ei);
   void evaluate_trapped_bishop_a7h7(const Position &pos, Square s, Color us,
@@ -291,8 +287,6 @@ namespace {
   inline Value apply_weight(Value v, int w);
   Value scale_by_game_phase(Value mv, Value ev, Phase ph, const ScaleFactor sf[]);
 
-  int count_1s_8bit(Bitboard b);
-
   int compute_weight(int uciWeight, int internalWeight);
   int weight_option(const std::string& opt, int weight);
   void init_safety();
@@ -304,11 +298,19 @@ namespace {
 //// Functions
 ////
 
-/// evaluate() is the main evaluation function.  It always computes two
+/// evaluate() is the main evaluation function. It always computes two
 /// values, an endgame score and a middle game score, and interpolates
 /// between them based on the remaining material.
+Value evaluate(const Position& pos, EvalInfo& ei, int threadID) {
+
+    return CpuHasPOPCNT ? do_evaluate<true>(pos, ei, threadID)
+                        : do_evaluate<false>(pos, ei, threadID);
+}
+
+namespace {
 
-Value evaluate(const Position &pos, EvalInfo &ei, int threadID) {
+template<bool HasPopCnt>
+Value do_evaluate(const Position& pos, EvalInfo& ei, int threadID) {
 
   assert(pos.is_ok());
   assert(threadID >= 0 && threadID < THREAD_MAX);
@@ -349,16 +351,16 @@ Value evaluate(const Position &pos, EvalInfo &ei, int threadID) {
   // Initialize pawn attack bitboards for both sides
   ei.attackedBy[WHITE][PAWN] = ((pos.pawns(WHITE) << 9) & ~FileABB) | ((pos.pawns(WHITE) << 7) & ~FileHBB);
   ei.attackedBy[BLACK][PAWN] = ((pos.pawns(BLACK) >> 7) & ~FileABB) | ((pos.pawns(BLACK) >> 9) & ~FileHBB);
-  ei.kingAttackersCount[WHITE] = count_1s_max_15(ei.attackedBy[WHITE][PAWN] & ei.attackedBy[BLACK][KING])/2;
-  ei.kingAttackersCount[BLACK] = count_1s_max_15(ei.attackedBy[BLACK][PAWN] & ei.attackedBy[WHITE][KING])/2;
+  ei.kingAttackersCount[WHITE] = count_1s_max_15<HasPopCnt>(ei.attackedBy[WHITE][PAWN] & ei.attackedBy[BLACK][KING])/2;
+  ei.kingAttackersCount[BLACK] = count_1s_max_15<HasPopCnt>(ei.attackedBy[BLACK][PAWN] & ei.attackedBy[WHITE][KING])/2;
 
   // Evaluate pieces
   for (Color c = WHITE; c <= BLACK; c++)
   {
-      evaluate_pieces<KNIGHT>(pos, c, ei);
-      evaluate_pieces<BISHOP>(pos, c, ei);
-      evaluate_pieces<ROOK>(pos, c, ei);
-      evaluate_pieces<QUEEN>(pos, c, ei);
+      evaluate_pieces<KNIGHT, HasPopCnt>(pos, c, ei);
+      evaluate_pieces<BISHOP, HasPopCnt>(pos, c, ei);
+      evaluate_pieces<ROOK,   HasPopCnt>(pos, c, ei);
+      evaluate_pieces<QUEEN,  HasPopCnt>(pos, c, ei);
 
       // Sum up all attacked squares
       ei.attackedBy[c][0] =   ei.attackedBy[c][PAWN]   | ei.attackedBy[c][KNIGHT]
@@ -370,7 +372,7 @@ Value evaluate(const Position &pos, EvalInfo &ei, int threadID) {
   // because we need complete attack information for all pieces when computing
   // the king safety evaluation.
   for (Color c = WHITE; c <= BLACK; c++)
-      evaluate_pieces<KING>(pos, c, ei);
+      evaluate_pieces<KING, false>(pos, c, ei);
 
   // Evaluate passed pawns.  We evaluate passed pawns for both sides at once,
   // because we need to know which side promotes first in positions where
@@ -446,6 +448,7 @@ Value evaluate(const Position &pos, EvalInfo &ei, int threadID) {
   return (ei.mateThreat[stm] == MOVE_NONE ? v : 8 * QueenValueMidgame - v);
 }
 
+} // namespace
 
 /// quick_evaluate() does a very approximate evaluation of the current position.
 /// It currently considers only material and piece square table scores.  Perhaps
@@ -505,6 +508,8 @@ void quit_eval() {
   {
       delete PawnTable[i];
       delete MaterialTable[i];
+      PawnTable[i] = NULL;
+      MaterialTable[i] = NULL;
   }
 }
 
@@ -535,7 +540,7 @@ namespace {
 
   // evaluate_common() computes terms common to all pieces attack
 
-  template<PieceType Piece>
+  template<PieceType Piece, bool HasPopCnt>
   int evaluate_common(const Position& p, const Bitboard& b, Color us, EvalInfo& ei, Square s = SQ_NONE) {
 
     static const int AttackWeight[] = { 0, 0, KnightAttackWeight, BishopAttackWeight, RookAttackWeight, QueenAttackWeight };
@@ -555,39 +560,39 @@ namespace {
         ei.kingAttackersWeight[us] += AttackWeight[Piece];
         Bitboard bb = (b & ei.attackedBy[them][KING]);
         if (bb)
-            ei.kingAdjacentZoneAttacksCount[us] += count_1s_max_15(bb);
+            ei.kingAdjacentZoneAttacksCount[us] += count_1s_max_15<HasPopCnt>(bb);
     }
 
     // Remove squares protected by enemy pawns
     Bitboard bb = (b & ~ei.attackedBy[them][PAWN]);
 
     // Mobility
-    int mob = (Piece != QUEEN ? count_1s_max_15(bb & ~p.pieces_of_color(us))
-                              : count_1s(bb & ~p.pieces_of_color(us)));
+    int mob = (Piece != QUEEN ? count_1s_max_15<HasPopCnt>(bb & ~p.pieces_of_color(us))
+                              : count_1s<HasPopCnt>(bb & ~p.pieces_of_color(us)));
 
     ei.mgMobility += Sign[us] * MgBonus[Piece][mob];
     ei.egMobility += Sign[us] * EgBonus[Piece][mob];
 
     // Bishop and Knight outposts
-    if (  (Piece != BISHOP && Piece != KNIGHT) // compile time condition
-        || !p.square_is_weak(s, them))
-        return mob;
-
-    // Initial bonus based on square
-    Value v, bonus;
-    v = bonus = OutpostBonus[Piece][relative_square(us, s)];
-
-    // Increase bonus if supported by pawn, especially if the opponent has
-    // no minor piece which can exchange the outpost piece
-    if (v && (p.pawn_attacks(them, s) & p.pawns(us)))
+    if (   (Piece == BISHOP || Piece == KNIGHT) // compile time condition
+        && p.square_is_weak(s, them))
     {
-        bonus += v / 2;
-        if (   p.piece_count(them, KNIGHT) == 0
-            && (SquaresByColorBB[square_color(s)] & p.bishops(them)) == EmptyBoardBB)
-            bonus += v;
+        // Initial bonus based on square
+        Value v, bonus;
+        v = bonus = OutpostBonus[Piece][relative_square(us, s)];
+
+        // Increase bonus if supported by pawn, especially if the opponent has
+        // no minor piece which can exchange the outpost piece
+        if (v && (p.pawn_attacks(them, s) & p.pawns(us)))
+        {
+            bonus += v / 2;
+            if (   p.piece_count(them, KNIGHT) == 0
+                   && (SquaresByColorBB[square_color(s)] & p.bishops(them)) == EmptyBoardBB)
+                bonus += v;
+        }
+        ei.mgValue += Sign[us] * bonus;
+        ei.egValue += Sign[us] * bonus;
     }
-    ei.mgValue += Sign[us] * bonus;
-    ei.egValue += Sign[us] * bonus;
     return mob;
   }
 
@@ -595,7 +600,7 @@ namespace {
   // evaluate_pieces<>() assigns bonuses and penalties to the pieces of a given
   // color.
 
-  template<PieceType Piece>
+  template<PieceType Piece, bool HasPopCnt>
   void evaluate_pieces(const Position& pos, Color us, EvalInfo& ei) {
 
     Bitboard b;
@@ -616,7 +621,7 @@ namespace {
             b = rook_attacks_bb(s, pos.occupied_squares() & ~pos.rooks_and_queens(us));
 
         // Attacks, mobility and outposts
-        mob = evaluate_common<Piece>(pos, b, us, ei, s);
+        mob = evaluate_common<Piece, HasPopCnt>(pos, b, us, ei, s);
 
         // Special patterns: trapped bishops on a7/h7/a2/h2
         // and trapped bishops on a1/h1/a8/h8 in Chess960.
@@ -699,7 +704,7 @@ namespace {
   // color.
 
   template<>
-  void evaluate_pieces<KING>(const Position& p, Color us, EvalInfo& ei) {
+  void evaluate_pieces<KING, false>(const Position& p, Color us, EvalInfo& ei) {
 
     int shelter = 0, sign = Sign[us];
     Square s = p.king_square(us);
@@ -707,11 +712,19 @@ namespace {
     // King shelter
     if (relative_rank(us, s) <= RANK_4)
     {
-        Bitboard pawns = p.pawns(us) & this_and_neighboring_files_bb(s);
-        Rank r = square_rank(s);
-        for (int i = 1; i < 4; i++)
-            shelter += count_1s_8bit(shiftRowsDown(pawns, r+i*sign)) * (128>>i);
-
+        // Shelter cache lookup
+        shelter = ei.pi->kingShelter(us, s);
+        if (shelter == -1)
+        {
+            shelter = 0;
+            Bitboard pawns = p.pawns(us) & this_and_neighboring_files_bb(s);
+            Rank r = square_rank(s);
+            for (int i = 1; i < 4; i++)
+                shelter += BitCount8Bit[shiftRowsDown(pawns, r+i*sign) & 0xFF] * (128 >> i);
+
+            // Cache shelter value in pawn info
+            ei.pi->setKingShelter(us, s, shelter);
+        }
         ei.mgValue += sign * Value(shelter);
     }
 
@@ -782,7 +795,7 @@ namespace {
                         if (    bit_is_set(p.piece_attacks<QUEEN>(from), to)
                             && !bit_is_set(p.pinned_pieces(them), from)
                             && !(rook_attacks_bb(to, occ & ClearMaskBB[from]) & p.rooks_and_queens(us))
-                            && !(rook_attacks_bb(to, occ & ClearMaskBB[from]) & p.rooks_and_queens(us)))
+                            && !(bishop_attacks_bb(to, occ & ClearMaskBB[from]) & p.bishops_and_queens(us)))
 
                             ei.mateThreat[them] = make_move(from, to);
                     }
@@ -920,29 +933,23 @@ namespace {
                         && (squares_behind(us, s) & pos.rooks_and_queens(them)))
                         b3 = b2;
 
-                    if ((b2 & pos.pieces_of_color(them)) == EmptyBoardBB)
-                    {
-                        // There are no enemy pieces in the pawn's path! Are any of the
-                        // squares in the pawn's path attacked by the enemy?
-                        if (b3 == EmptyBoardBB)
-                            // No enemy attacks, huge bonus!
-                            ebonus += Value(tr * (b2 == b4 ? 17 : 15));
-                        else
-                            // OK, there are enemy attacks. Are those squares which are
-                            // attacked by the enemy also attacked by us?  If yes, big bonus
-                            // (but smaller than when there are no enemy attacks), if no,
-                            // somewhat smaller bonus.
-                            ebonus += Value(tr * ((b3 & b4) == b3 ? 13 : 8));
-                    }
+                    // Squares attacked or occupied by enemy pieces
+                    b3 |= (b2 & pos.pieces_of_color(them));
+
+                    // There are no enemy pawns in the pawn's path
+                    assert((b2 & pos.pieces_of_color_and_type(them, PAWN)) == EmptyBoardBB);
+
+                    // Are any of the squares in the pawn's path attacked or occupied by the enemy?
+                    if (b3 == EmptyBoardBB)
+                        // No enemy attacks or pieces, huge bonus!
+                        ebonus += Value(tr * (b2 == b4 ? 17 : 15));
                     else
-                    {
-                        // There are some enemy pieces in the pawn's path. While this is
-                        // sad, we still assign a moderate bonus if all squares in the path
-                        // which are either occupied by or attacked by enemy pieces are
-                        // also attacked by us.
-                        if (((b3 | (b2 & pos.pieces_of_color(them))) & ~b4) == EmptyBoardBB)
-                            ebonus += Value(tr * 6);
-                    }
+                        // OK, there are enemy attacks or pieces (but not pawns). Are those
+                        // squares which are attacked by the enemy also attacked by us?
+                        // If yes, big bonus (but smaller than when there are no enemy attacks),
+                        // if no, somewhat smaller bonus.
+                        ebonus += Value(tr * ((b3 & b4) == b3 ? 13 : 8));
+
                     // At last, add a small bonus when there are no *friendly* pieces
                     // in the pawn's path.
                     if ((b2 & pos.pieces_of_color(us)) == EmptyBoardBB)
@@ -1164,15 +1171,6 @@ namespace {
   }
 
 
-  // count_1s_8bit() counts the number of nonzero bits in the 8 least
-  // significant bits of a Bitboard. This function is used by the king
-  // shield evaluation.
-
-  int count_1s_8bit(Bitboard b) {
-    return int(BitCount8Bit[b & 0xFF]);
-  }
-
-
   // compute_weight() computes the value of an evaluation weight, by combining
   // an UCI-configurable weight with an internal weight.