#include <cassert>
#include <cstring>
+#include "bitcount.h"
#include "evaluate.h"
#include "material.h"
#include "pawns.h"
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,
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();
//// 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);
// 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<false>(ei.attackedBy[WHITE][PAWN] & ei.attackedBy[BLACK][KING])/2;
+ ei.kingAttackersCount[BLACK] = count_1s_max_15<false>(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]
// 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
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
for (Bitboard b = 0ULL; b < 256ULL; b++)
{
- assert(count_1s(b) == int(uint8_t(count_1s(b))));
- BitCount8Bit[b] = (uint8_t)count_1s(b);
+ assert(count_1s<false>(b) == int(uint8_t(count_1s<false>(b))));
+ BitCount8Bit[b] = (uint8_t)count_1s<false>(b);
}
}
// 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 };
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];
// 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;
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.
// 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);
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 += BitCount8Bit[shiftRowsDown(pawns, r+i*sign) & 0xFF] * (128 >> i);
// Cache shelter value in pawn info
ei.pi->setKingShelter(us, s, shelter);
// quality of the pawn shelter.
int attackUnits =
Min((ei.kingAttackersCount[them] * ei.kingAttackersWeight[them]) / 2, 25)
- + (ei.kingAdjacentZoneAttacksCount[them] + count_1s_max_15(undefended)) * 3
+ + (ei.kingAdjacentZoneAttacksCount[them] + count_1s_max_15<false>(undefended)) * 3
+ InitKingDanger[relative_square(us, s)] - (shelter >> 5);
// Analyse safe queen contact checks
{
// The bitboard b now contains the squares available for safe queen
// contact checks.
- int count = count_1s_max_15(b);
+ int count = count_1s_max_15<false>(b);
attackUnits += QueenContactCheckBonus * count * (sente ? 2 : 1);
// Is there a mate threat?
// Queen checks
b2 = b & ei.attacked_by(them, QUEEN);
if( b2)
- attackUnits += QueenCheckBonus * count_1s_max_15(b2);
+ attackUnits += QueenCheckBonus * count_1s_max_15<false>(b2);
// Rook checks
b2 = b & ei.attacked_by(them, ROOK);
if (b2)
- attackUnits += RookCheckBonus * count_1s_max_15(b2);
+ attackUnits += RookCheckBonus * count_1s_max_15<false>(b2);
}
if (QueenCheckBonus > 0 || BishopCheckBonus > 0)
{
// Queen checks
b2 = b & ei.attacked_by(them, QUEEN);
if (b2)
- attackUnits += QueenCheckBonus * count_1s_max_15(b2);
+ attackUnits += QueenCheckBonus * count_1s_max_15<false>(b2);
// Bishop checks
b2 = b & ei.attacked_by(them, BISHOP);
if (b2)
- attackUnits += BishopCheckBonus * count_1s_max_15(b2);
+ attackUnits += BishopCheckBonus * count_1s_max_15<false>(b2);
}
if (KnightCheckBonus > 0)
{
// Knight checks
b2 = b & ei.attacked_by(them, KNIGHT);
if (b2)
- attackUnits += KnightCheckBonus * count_1s_max_15(b2);
+ attackUnits += KnightCheckBonus * count_1s_max_15<false>(b2);
}
// Analyse discovered checks (only for non-pawns right now, consider
{
b = p.discovered_check_candidates(them) & ~p.pawns();
if (b)
- attackUnits += DiscoveredCheckBonus * count_1s_max_15(b) * (sente? 2 : 1);
+ attackUnits += DiscoveredCheckBonus * count_1s_max_15<false>(b) * (sente? 2 : 1);
}
// Has a mate threat been found? We don't do anything here if the
if (d < 0)
{
int mtg = RANK_8 - relative_rank(us, s);
- int blockerCount = count_1s_max_15(squares_in_front_of(us,s) & pos.occupied_squares());
+ int blockerCount = count_1s_max_15<false>(squares_in_front_of(us,s) & pos.occupied_squares());
mtg += blockerCount;
d += blockerCount;
if (d < 0)
behindFriendlyPawns |= (behindFriendlyPawns << 16);
}
- int space = count_1s_max_15(safeSquares)
- + count_1s_max_15(behindFriendlyPawns & safeSquares);
+ int space = count_1s_max_15<false>(safeSquares)
+ + count_1s_max_15<false>(behindFriendlyPawns & safeSquares);
ei.mgValue += Sign[us] * apply_weight(Value(space * ei.mi->space_weight()), WeightSpace);
}
}
- // 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.