X-Git-Url: https://git.sesse.net/?p=stockfish;a=blobdiff_plain;f=src%2Fbitcount.h;h=940dbaf52af207c8a24977e8780b42679e36650c;hp=6b5f5b5789bb5f8b0b895fafa650566ceba107c2;hb=04001f776edd312418ad8334f4287b4d1dba5f7b;hpb=72ab2cd3e98e694ef22316153a42462e2484b466 diff --git a/src/bitcount.h b/src/bitcount.h index 6b5f5b57..940dbaf5 100644 --- a/src/bitcount.h +++ b/src/bitcount.h @@ -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-2009 Marco Costalba + Copyright (C) 2008-2010 Marco Costalba, Joona Kiiski, Tord Romstad Stockfish is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -22,69 +22,25 @@ #if !defined(BITCOUNT_H_INCLUDED) #define BITCOUNT_H_INCLUDED -// To enable POPCNT support uncomment USE_POPCNT define. For PGO compile on a Core i7 -// you may want to collect profile data first with USE_POPCNT disabled and then, in a -// second profiling session, with USE_POPCNT enabled so to exercise both paths. Don't -// forget to leave USE_POPCNT enabled for the final optimized compile though ;-) - -//#define USE_POPCNT - - #include "types.h" -// Select type of intrinsic bit count instruction to use - -#if defined(__INTEL_COMPILER) && defined(IS_64BIT) && defined(USE_POPCNT) // Intel compiler - -#include - -inline bool cpu_has_popcnt() { - - int CPUInfo[4] = {-1}; - __cpuid(CPUInfo, 0x00000001); - return (CPUInfo[2] >> 23) & 1; -} - -// Define a dummy template to workaround a compile error if _mm_popcnt_u64() is not defined. -// -// If _mm_popcnt_u64() is defined in it will be choosen first due to -// C++ overload rules that always prefer a function to a template with the same name. -// If not, we avoid a compile error and because cpu_has_popcnt() should return false, -// our templetized _mm_popcnt_u64() is never called anyway. -template inline unsigned _mm_popcnt_u64(T) { return 0; } // Is never called - -#define POPCNT_INTRINSIC(x) _mm_popcnt_u64(x) - -#elif defined(_MSC_VER) && defined(IS_64BIT) && defined(USE_POPCNT) // Microsoft compiler - -#include - -inline bool cpu_has_popcnt() { - - int CPUInfo[4] = {-1}; - __cpuid(CPUInfo, 0x00000001); - return (CPUInfo[2] >> 23) & 1; -} - -// See comment of _mm_popcnt_u64<>() few lines above for an explanation. -template inline unsigned __popcnt64(T) { return 0; } // Is never called +enum BitCountType { + CNT64, + CNT64_MAX15, + CNT32, + CNT32_MAX15, + CNT_POPCNT +}; -#define POPCNT_INTRINSIC(x) __popcnt64(x) - -#else // Safe fallback for unsupported compilers or when USE_POPCNT is disabled - -inline bool cpu_has_popcnt() { return false; } - -#define POPCNT_INTRINSIC(x) 0 - -#endif // cpu_has_popcnt() and POPCNT_INTRINSIC() definitions - - -/// Software implementation of bit count functions - -#if defined(IS_64BIT) - -inline int count_1s(Bitboard b) { +/// count_1s() counts the number of nonzero bits in a bitboard. +/// We have different optimized versions according if platform +/// is 32 or 64 bits, and to the maximum number of nonzero bits. +/// We also support hardware popcnt instruction. See Readme.txt +/// on how to pgo compile with popcnt support. +template inline int count_1s(Bitboard); + +template<> +inline int count_1s(Bitboard b) { b -= ((b>>1) & 0x5555555555555555ULL); b = ((b>>2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL); b = ((b>>4) + b) & 0x0F0F0F0F0F0F0F0FULL; @@ -92,16 +48,16 @@ inline int count_1s(Bitboard b) { return int(b >> 56); } -inline int count_1s_max_15(Bitboard b) { +template<> +inline int count_1s(Bitboard b) { b -= (b>>1) & 0x5555555555555555ULL; b = ((b>>2) & 0x3333333333333333ULL) + (b & 0x3333333333333333ULL); b *= 0x1111111111111111ULL; return int(b >> 60); } -#else // if !defined(IS_64BIT) - -inline int count_1s(Bitboard b) { +template<> +inline int count_1s(Bitboard b) { unsigned w = unsigned(b >> 32), v = unsigned(b); v -= (v >> 1) & 0x55555555; // 0-2 in 2 bits w -= (w >> 1) & 0x55555555; @@ -113,7 +69,8 @@ inline int count_1s(Bitboard b) { return int(v >> 24); } -inline int count_1s_max_15(Bitboard b) { +template<> +inline int count_1s(Bitboard b) { unsigned w = unsigned(b >> 32), v = unsigned(b); v -= (v >> 1) & 0x55555555; // 0-2 in 2 bits w -= (w >> 1) & 0x55555555; @@ -124,38 +81,47 @@ inline int count_1s_max_15(Bitboard b) { return int(v >> 28); } -#endif // BITCOUNT - - -/// count_1s() counts the number of nonzero bits in a bitboard. -/// If template parameter is true an intrinsic is called, otherwise -/// we fallback on a software implementation. - -template -inline int count_1s(Bitboard b) { - - return UseIntrinsic ? POPCNT_INTRINSIC(b) : count_1s(b); +template<> +inline int count_1s(Bitboard b) { +#if !defined(USE_POPCNT) + return int(b != 0); // Avoid 'b not used' warning +#elif defined(_MSC_VER) && defined(__INTEL_COMPILER) + return _mm_popcnt_u64(b); +#elif defined(_MSC_VER) + return (int)__popcnt64(b); +#elif defined(__GNUC__) + unsigned long ret; + __asm__("popcnt %1, %0" : "=r" (ret) : "r" (b)); + return ret; +#endif } -template -inline int count_1s_max_15(Bitboard b) { - return UseIntrinsic ? POPCNT_INTRINSIC(b) : count_1s_max_15(b); +/// cpu_has_popcnt() detects support for popcnt instruction at runtime +inline bool cpu_has_popcnt() { + + int CPUInfo[4] = {-1}; + __cpuid(CPUInfo, 0x00000001); + return (CPUInfo[2] >> 23) & 1; } -// Global constant initialized at startup that is set to true if -// CPU on which application runs supports POPCNT intrinsic. Unless -// USE_POPCNT is not defined. +/// CpuHasPOPCNT is a global constant initialized at startup that +/// is set to true if CPU on which application runs supports popcnt +/// hardware instruction. Unless USE_POPCNT is not defined. +#if defined(USE_POPCNT) const bool CpuHasPOPCNT = cpu_has_popcnt(); +#else +const bool CpuHasPOPCNT = false; +#endif -// Global constant used to print info about the use of 64 optimized -// functions to verify that a 64 bit compile has been correctly built. +/// CpuIs64Bit is a global constant initialized at compile time that +/// is set to true if CPU on which application runs is a 64 bits. #if defined(IS_64BIT) -const bool CpuHas64BitPath = true; +const bool CpuIs64Bit = true; #else -const bool CpuHas64BitPath = false; +const bool CpuIs64Bit = false; #endif #endif // !defined(BITCOUNT_H_INCLUDED)