Wie benutzt man MSVC-Intrinsics, um das Äquivalent dieses GCC-Codes zu erhalten?

Question

Der folgende Code ruft die integrierten Funktionen für clz/ctz in GCC auf und hat auf anderen Systemen C-Versionen. Offensichtlich sind die C-Versionen ein bisschen suboptimal, wenn das System eine eingebaute clz/ctz-Anweisung hat, wie x86 und ARM.

#ifdef __GNUC__ 
#define clz(x) __builtin_clz(x) 
#define ctz(x) __builtin_ctz(x) 
#else 
static uint32_t ALWAYS_INLINE popcnt(uint32_t x) 
{ 
    x -= ((x >> 1) & 0x55555555); 
    x = (((x >> 2) & 0x33333333) + (x & 0x33333333)); 
    x = (((x >> 4) + x) & 0x0f0f0f0f); 
    x += (x >> 8); 
    x += (x >> 16); 
    return x & 0x0000003f; 
} 
static uint32_t ALWAYS_INLINE clz(uint32_t x) 
{ 
    x |= (x >> 1); 
    x |= (x >> 2); 
    x |= (x >> 4); 
    x |= (x >> 8); 
    x |= (x >> 16); 
    return 32 - popcnt(x); 
} 
static uint32_t ALWAYS_INLINE ctz(uint32_t x) 
{ 
    return popcnt((x & -x) - 1); 
} 

#endif 

Welche Funktionen muss ich anrufen, die Header muss ich schließen, etc hier eine richtige ifdef für MSVC hinzufügen? Ich habe mir schon this page angesehen, aber ich bin mir nicht ganz sicher, wofür das #pragma ist (ist es erforderlich?) Und welche Einschränkungen es den MSVC-Versionsanforderungen für die Kompilierung auferlegt. Als jemand, der MSVC nicht wirklich benutzt, weiß ich auch nicht, ob diese intrinsischen Elemente C-Äquivalente auf anderen Architekturen haben, oder ob ich #ifdef x86/x86_64 auch verwenden muss, wenn ich # definiere.

Answer 1

Wenn MSVC einen Compiler Eigen dafür hat, wird es hier sein:

Compiler Intrinsics on MSDN

Andernfalls werden Sie es schreiben __asm ​​mit

Answer 2

Es gibt zwei Spezifika "_BitScanForward" und "_BitScanReverse", was dem gleichen Zweck für MSVC entspricht. Einbeziehen. Die Funktionen sind:

#ifdef _MSC_VER 
#include <intrin.h> 

static uint32_t __inline ctz(uint32_t x) 
{ 
    int r = 0; 
    _BitScanReverse(&r, x); 
    return r; 
} 

static uint32_t __inline clz(uint32_t x) 
{ 
    int r = 0; 
    _BitScanForward(&r, x); 
    return r; 
} 
#endif 

gleichwertige 64-Bit-Versionen "_BitScanForward64" und "_BitScanReverse64" Es gibt.

Lesen Sie hier mehr:

x86 Intrinsics on MSDN

Answer 3

von sh0dan Code Bouncing sollte die Umsetzung wie folgt korrigiert werden:

#ifdef _MSC_VER 
#include <intrin.h> 

uint32_t __inline ctz(uint32_t value) 
{ 
    DWORD trailing_zero = 0; 

    if (_BitScanForward(&trailing_zero, value)) 
    { 
     return trailing_zero; 
    } 
    else 
    { 
     // This is undefined, I better choose 32 than 0 
     return 32; 
    } 
} 

uint32_t __inline clz(uint32_t value) 
{ 
    DWORD leading_zero = 0; 

    if (_BitScanReverse(&leading_zero, value)) 
    { 
     return 31 - leading_zero; 
    } 
    else 
    { 
     // Same remarks as above 
     return 32; 
    } 
} 
#endif 

Wie im Code kommentiert, sowohl ctz und clz nicht definiert sind, wenn Wert ist 0. In unserer Abstraktion haben wir __builtin_clz(value) als (value?__builtin_clz(value):32) behoben aber es ist eine Wahl

Answer 4

T sierte auf Linux und Windows (x86):

#ifdef WIN32 
    #include <intrin.h> 
    static uint32_t __inline __builtin_clz(uint32_t x) { 
     unsigned long r = 0; 
     _BitScanReverse(&r, x); 
     return (31-r); 
    } 
#endif 

uint32_t clz64(const uint64_t x) 
{ 
    uint32_t u32 = (x >> 32); 
    uint32_t result = u32 ? __builtin_clz(u32) : 32; 
    if (result == 32) { 
     u32 = x & 0xFFFFFFFFUL; 
     result += (u32 ? __builtin_clz(u32) : 32); 
    } 
    return result; 
}