一、popcnt指令簡介
popcnt是“population count”的縮寫，該操作一般翻譯爲“位1計數”，即統計有多少個“爲1的位”。例如，十六進制數“FF”，它有8個爲1的位，即“popcnt(0xFF) = 8”。popcnt主要應用在密碼學與通信安全，例如計算漢明重量（Hamming weight）。
x86體系最初是沒有硬件popcnt指令的，只能靠軟件計算。2008年底，Intel發佈了Nehalem架構的處理器，增加了SSE4.2指令集，其中就有硬件popcnt指令。雖然它名義上是屬SSE4.2指令集，但它並不使用XMM寄存器（SSE的128位寄存器），而是使用GPR寄存器（General-Purpose Registers，通用寄存器）。甚至它的CPUID標誌位也不是SSE4.2（CPUID.01H:ECX.SSE4_2[bit 20]），而是專門的POPCNT標誌位（CPUID.01H:ECX.POPCNT[bit 23]）。 使用我以前寫的三個模塊，可以很方便的解決跨平臺問題和指令檢查問題：
1.stdint：智能支持C99的stdint.h，解決整數類型問題：
最新版地址：http://www.cnblogs.com/zyl910/archive/2012/08/08/c99int.html
2.zintrin：在編譯時檢測Intrinsic函數集支持性，並自動引入相關頭文件、修正細節問題。
最新版的地址是： http://www.cnblogs.com/zyl910/archive/2012/10/01/zintrin_v101.html
3.ccpuid：在編譯時檢測指令集的支持性。
最新版的地址是： http://www.cnblogs.com/zyl910/archive/2012/10/13/ccpuid_v103.html
具體來說，檢查popcnt指令是這樣做的：INTRIN_POPCNT 宏是 zintrin.h 提供的，可用來在編譯時檢測編譯器是否支持popcnt指令集。getcpuidfield(CPUF_POPCNT) 是 ccpuid.h 提供的，可用來在運行時檢測當前系統環境是否支持popcnt指令集。
二、編程思路
爲了測試硬件popcnt的性能，我找了幾個軟件算法跟它進行比較。一個是最基本逐位判斷算法，一個是查表法，另外還使用了《高效程序的奧祕》上的高級算法。
爲了比較這些算法的性能，可以讓它們去統計一個數組中有多少個爲1的位。數據樣本足夠大，纔好分析平均性能。
但是現在有一個問題，怎樣去編寫數組統計函數呢。
首先想到的是，爲每一種算法編寫一套數組統計函數。優點是適合編譯器優化，運行效率高。缺點是代碼量大，複雜性高、重用性差。
於是我想，如果能將各種popcnt算法 與 數組統計函數 分離就好了。
具體怎麼分離呢？
在C語言中，有2種辦法——
1. 函數指針。先約定popcnt的函數參數，定義一個指針類型，然後各種popcnt算法根據該約定編寫好函數。而數組統計函數接收一個popcnt函數指針參數，循環調用該函數指針進行統計。
2. 宏。將數組統計寫成宏，接收一個函數名參數，然後根據該函數名寫循環進行統計。
這兩種方式都不太合適。函數指針難以內聯優化，函數指針調用會帶來一定的開銷，影響性能。而用宏的話，沒有語法檢查，難以編寫與調試，可讀性差不易維護。
於是將目光轉向C++，首先想到的是使用虛函數——先定義一個popcnt虛基類，定義好接口。然後各種popcnt算法的類繼承該接口，實現算法。而數組統計函數接收該類的實例，寫循環進行統計。
但這也存在性能問題，虛函數無法內聯優化。而且popcnt是純算法，不應該使用“創建實例再調用”的方式，最好是設計成類中靜態函數，可直接調用。
虛函數是動態多態，C++中有沒有靜態多態的語法呢？有，函數重載、模板。
因popcnt是純算法函數，函數參數格式應該是一樣，但函數重載要求函數參數不同。
而模板正是我們所需要的。編譯優化時會盡量展開模板，進行內聯優化。
大致思路如下：
1.將各種popcnt算法作爲不同的類，類中只有靜態函數，這些類的靜態函數的參數格式均相同。
2.將數組統計函數寫成函數模板，模板參數用於傳遞popcnt算法類，然後在循環中使用模板參數調用它的靜態函數。
而且還可以進一步擴展，構造出兩路循環展開版數組統計函數、四路循環展開版數組統計函數。然後測試程序也可以利用模板傳遞類型來簡化。
該方法的優點是能充分利用編譯優化來提高性能，代碼量少、結構清晰、能很方便的重用。
缺點是，因C++不支持模板參數約束，存在誤用風險，而且IDE無法提供成員函數提示。
VC6對C++標準支持性較差，不支持將模板函數轉爲函數指針，導致無法使用該方法。直到VC2003，才能通過編譯。
三、全部代碼
3.1 testpopcnt.cpp
#define __STDC_LIMIT_MACROS 1 // C99整數範圍常量. [純C程序可以不用, 而C++程序必須定義該宏.]
#define __STDC_CONSTANT_MACROS 1 // C99整數常量宏. [純C程序可以不用, 而C++程序必須定義該宏.]
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include "zintrin.h"
#include "ccpuid.h"
#if !defined(UINT32_C)
#error Need C99 marcos: __STDC_CONSTANT_MACROS.
#endif
// Compiler name
#define MACTOSTR(x) #x
#define MACROVALUESTR(x) MACTOSTR(x)
#if defined(__ICL) // Intel C++
# if defined(__VERSION__)
# define COMPILER_NAME "Intel C++ " __VERSION__
# elif defined(__INTEL_COMPILER_BUILD_DATE)
# define COMPILER_NAME "Intel C++ (" MACROVALUESTR(__INTEL_COMPILER_BUILD_DATE) ")"
# else
# define COMPILER_NAME "Intel C++"
# endif // # if defined(__VERSION__)
#elif defined(_MSC_VER) // Microsoft VC++
# if defined(_MSC_FULL_VER)
# define COMPILER_NAME "Microsoft VC++ (" MACROVALUESTR(_MSC_FULL_VER) ")"
# elif defined(_MSC_VER)
# define COMPILER_NAME "Microsoft VC++ (" MACROVALUESTR(_MSC_VER) ")"
# else
# define COMPILER_NAME "Microsoft VC++"
# endif // # if defined(_MSC_FULL_VER)
#elif defined(__GNUC__) // Microsoft VC++
# if defined(__CYGWIN__)
# define COMPILER_NAME "GCC(Cygmin) " __VERSION__
# elif defined(__MINGW32__)
# define COMPILER_NAME "GCC(MinGW) " __VERSION__
# else
# define COMPILER_NAME "GCC " __VERSION__
# endif // # if defined(_MSC_FULL_VER)
#else
# define COMPILER_NAME "Unknown Compiler"
#endif // #if defined(__ICL) // Intel C++
//////////////////////////////////////////////////
// MPopcnt
//////////////////////////////////////////////////
// 位1計數. 最基本算法, 循環右移判斷最低位是不是1.
class MPopcnt_Base
{
public:
// 位1計數(8位版).
inline static size_t popcnt(uint8_t v)
{
size_t rt = 0;
for(int i=0; i<8; ++i)
{
rt += (v & 1);
v >>= 1;
}
return rt;
}
// 位1計數(32位版).
inline static size_t popcnt(uint32_t v)
{
size_t rt = 0;
for(int i=0; i<32; ++i)
{
rt += (v & 1);
v >>= 1;
}
return rt;
}
// 位1計數(64位版).
inline static size_t popcnt(uint64_t v)
{
size_t rt = 0;
for(int i=0; i<64; ++i)
{
rt += ((size_t)v & 1);
v >>= 1;
}
return rt;
}
};
// 位1計數. 使用X86的POPCNT指令.
#ifdef INTRIN_POPCNT
class MPopcnt_Mx86
{
public:
// 位1計數(8位版).
inline static size_t popcnt(uint8_t v)
{
size_t rt;
#if INTRIN_WORDSIZE>=64
rt = popcnt((uint64_t)v);
#else
rt = popcnt((uint32_t)v);
#endif
return rt;
}
// 位1計數(32位版).
inline static size_t popcnt(uint32_t v)
{
return (size_t)_mm_popcnt_u32(v);
}
// 位1計數(64位版).
inline static size_t popcnt(uint64_t v)
{
size_t rt;
#if INTRIN_WORDSIZE>=64
rt = (size_t)_mm_popcnt_u64(v);
#else
rt = (size_t)(_mm_popcnt_u32((uint32_t)v) + _mm_popcnt_u32((uint32_t)(v>>32)));
#endif
return rt;
}
};
#endif // #ifdef INTRIN_POPCNT
// 位1計數. 查表法.
class MPopcnt_Table
{
public:
// 位1計數(8位版).
inline static size_t popcnt(uint8_t v)
{
static const size_t countTable[256] ={
0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8};
return countTable[v];
}
// 位1計數(32位版).
inline static size_t popcnt(uint32_t v)
{
return popcnt((uint8_t)v) + popcnt((uint8_t)(v>>8)) + popcnt((uint8_t)(v>>16)) + popcnt((uint8_t)(v>>24));
}
// 位1計數(64位版).
inline static size_t popcnt(uint64_t v)
{
return popcnt((uint8_t)v) + popcnt((uint8_t)(v>>8)) + popcnt((uint8_t)(v>>16)) + popcnt((uint8_t)(v>>24)) + popcnt((uint8_t)(v>>32)) + popcnt((uint8_t)(v>>40)) + popcnt((uint8_t)(v>>48)) + popcnt((uint8_t)(v>>56));
}
};
// 位1計數. 《Hacker's Delight》的分治法基本算法.
class MPopcnt_HakBase
{
public:
// 位1計數(8位版).
inline static size_t popcnt(uint8_t v)
{
v = (v & 0x55) + ( (v >> 1) & 0x55);
v = (v & 0x33) + ( (v >> 2) & 0x33);
v = (v & 0x0f) + ( (v >> 4) & 0x0f);
return (size_t)v;
}
// 位1計數(32位版).
inline static size_t popcnt(uint32_t v)
{
v = (v & UINT32_C(0x55555555)) + ( (v >> 1) & UINT32_C(0x55555555));
v = (v & UINT32_C(0x33333333)) + ( (v >> 2) & UINT32_C(0x33333333));
v = (v & UINT32_C(0x0f0f0f0f)) + ( (v >> 4) & UINT32_C(0x0f0f0f0f));
v = (v & UINT32_C(0x00ff00ff)) + ( (v >> 8) & UINT32_C(0x00ff00ff));
v = (v & UINT32_C(0x0000ffff)) + ( (v >>16) & UINT32_C(0x0000ffff));
return (size_t)v;
}
// 位1計數(64位版).
inline static size_t popcnt(uint64_t v)
{
v = (v & UINT64_C(0x5555555555555555)) + ( (v >> 1) & UINT64_C(0x5555555555555555));
v = (v & UINT64_C(0x3333333333333333)) + ( (v >> 2) & UINT64_C(0x3333333333333333));
v = (v & UINT64_C(0x0f0f0f0f0f0f0f0f)) + ( (v >> 4) & UINT64_C(0x0f0f0f0f0f0f0f0f));
v = (v & UINT64_C(0x00ff00ff00ff00ff)) + ( (v >> 8) & UINT64_C(0x00ff00ff00ff00ff));
v = (v & UINT64_C(0x0000ffff0000ffff)) + ( (v >>16) & UINT64_C(0x0000ffff0000ffff));
v = (v & UINT64_C(0x00000000ffffffff)) + ( (v >>32) & UINT64_C(0x00000000ffffffff));
return (size_t)v;
}
};
// 位1計數. 《Hacker's Delight》的分治法的改進算法.
class MPopcnt_HakBaseFast
{
public:
// 位1計數(8位版).
inline static size_t popcnt(uint8_t v)
{
return MPopcnt_HakBase::popcnt(v);
}
// 位1計數(32位版).
inline static size_t popcnt(uint32_t v)
{
v = v - ( (v >> 1) & UINT32_C(0x55555555));
v = (v & UINT32_C(0x33333333)) + ( (v >> 2) & UINT32_C(0x33333333));
v = ( v + (v >> 4) ) & UINT32_C(0x0f0f0f0f);
v = v + (v >> 8);
v = v + (v >>16);
return (size_t)(v&0x3f);
}
// 位1計數(64位版).
inline static size_t popcnt(uint64_t v)
{
v = v - ( (v >> 1) & UINT64_C(0x5555555555555555));
v = (v & UINT64_C(0x3333333333333333)) + ( (v >> 2) & UINT64_C(0x3333333333333333));
v = ( v + (v >> 4) ) & UINT64_C(0x0f0f0f0f0f0f0f0f);
v = v + (v >> 8);
v = v + (v >>16);
v = v + (v >>32);
return (size_t)(v&0x7f);
}
};
// 將最常用的版本定義一個短名稱.
typedef MPopcnt_HakBase MPopcnt;
//////////////////////////////////////////////////
// mpopcnt_array
//////////////////////////////////////////////////
// 數組的位1計數_內部函數.
template<class TPopcnt, class TUINT>
inline size_t mpopcnt_array_internal(const void* pbuf, size_t cbsize)
{
size_t rt = 0; // result.
if (NULL==pbuf) return rt;
// 根據 TUINT 類型批量處理數據.
size_t cntBlock = cbsize / sizeof(TUINT); // 塊數。TUINT類型 能一次處理多個字節.
size_t cntRem = cbsize % sizeof(TUINT); // 剩餘數量.
const TUINT* pt = (const TUINT*)pbuf;
size_t i;
for(i = 0; i < cntBlock; ++i)
{
rt += TPopcnt::popcnt(*pt); // 累加.
++pt;
}
// 逐字節處理尾部數據.
const uint8_t* pb = (const uint8_t*)pt;
for(i = 0; i < cntRem; ++i)
{
rt += TPopcnt::popcnt(*pb); // 累加.
++pb;
}
return rt;
}
// 數組的位1計數.
template<class TPopcnt>
size_t mpopcnt_array(const void* pbuf, size_t cbsize)
{
size_t rt;
#if INTRIN_WORDSIZE>=64
rt = mpopcnt_array_internal<TPopcnt, uint64_t>(pbuf, cbsize);
#else
rt = mpopcnt_array_internal<TPopcnt, uint32_t>(pbuf, cbsize);
#endif
return rt;
}
// 數組的位1計數_2路循環展開_內部函數.
template<class TPopcnt, class TUINT>
inline size_t mpopcnt_array_2loop_internal(const void* pbuf, size_t cbsize)
{
size_t rt = 0; // result.
size_t rt1 = 0;
if (NULL==pbuf) return rt;
// 根據 TUINT 類型批量處理數據.
size_t cbBlock = sizeof(TUINT)*2; // 塊的字節數.
size_t cntBlock = cbsize / cbBlock; // 塊數.
size_t cntRem = cbsize % cbBlock; // 剩餘字節數.
const TUINT* pt = (const TUINT*)pbuf;
for(size_t i = 0; i < cntBlock; ++i)
{
// 累加.
rt += TPopcnt::popcnt(pt[0]);
rt1 += TPopcnt::popcnt(pt[1]);
// next
pt += 2;
}
// 合併
rt += rt1;
// 處理尾部數據.
rt += mpopcnt_array_internal<TPopcnt, TUINT>(pt, cntRem);
return rt;
}
// 數組的位1計數_2路循環展開.
template<class TPopcnt>
size_t mpopcnt_array_2loop(const void* pbuf, size_t cbsize)
{
size_t rt;
#if INTRIN_WORDSIZE>=64
rt = mpopcnt_array_2loop_internal<TPopcnt, uint64_t>(pbuf, cbsize);
#else
rt = mpopcnt_array_2loop_internal<TPopcnt, uint32_t>(pbuf, cbsize);
#endif
return rt;
}
// 數組的位1計數_4路循環展開_內部函數.
template<class TPopcnt, class TUINT>
inline size_t mpopcnt_array_4loop_internal(const void* pbuf, size_t cbsize)
{
size_t rt = 0; // result.
size_t rt1 = 0;
size_t rt2 = 0;
size_t rt3 = 0;
if (NULL==pbuf) return rt;
// 根據 TUINT 類型批量處理數據.
size_t cbBlock = sizeof(TUINT)*4; // 塊的字節數.
size_t cntBlock = cbsize / cbBlock; // 塊數.
size_t cntRem = cbsize % cbBlock; // 剩餘字節數.
const TUINT* pt = (const TUINT*)pbuf;
for(size_t i = 0; i < cntBlock; ++i)
{
// 累加.
rt += TPopcnt::popcnt(pt[0]);
rt1 += TPopcnt::popcnt(pt[1]);
rt2 += TPopcnt::popcnt(pt[2]);
rt3 += TPopcnt::popcnt(pt[3]);
// next
pt += 4;
}
// 合併
rt += rt1 + rt2 + rt3;
// 處理尾部數據.
rt += mpopcnt_array_internal<TPopcnt, TUINT>(pt, cntRem);
return rt;
}
// 數組的位1計數_4路循環展開.
template<class TPopcnt>
size_t mpopcnt_array_4loop(const void* pbuf, size_t cbsize)
{
size_t rt;
#if INTRIN_WORDSIZE>=64
rt = mpopcnt_array_4loop_internal<TPopcnt, uint64_t>(pbuf, cbsize);
#else
rt = mpopcnt_array_4loop_internal<TPopcnt, uint32_t>(pbuf, cbsize);
#endif
return rt;
}
// 數組的位1計數. 《Hacker's Delight》的數組的位1計數算法.
inline size_t mpopcnt_array_hak_internal(const uint32_t* A, size_t n)
{
size_t i, j, lim;
uint32_t s, s8, x;
s = 0;
for(i=0; i<n; i=i+31)
{
lim = i+31;
if (lim>n) lim=n;
s8 = 0;
for(j=i; j<lim; ++j)
{
x = A[j];
x = x - ( (x>>1) & UINT32_C(0x55555555) );
x = (x & UINT32_C(0x33333333)) + ( (x >> 2) & UINT32_C(0x33333333) );
x = ( x + (x >> 4) ) & UINT32_C(0x0f0f0f0f);
s8 = s8 + x;
}
x = (s8 & UINT32_C(0x00ff00ff)) + ( (s8 >> 8) & UINT32_C(0x00ff00ff) );
x = (x & UINT32_C(0x0000ffff)) + (x>>16);
s = s + x;
}
return (size_t)s;
}
size_t mpopcnt_array_hak(const void* pbuf, size_t cbsize)
{
size_t cntBlock = cbsize/sizeof(uint32_t); // 塊數.
size_t cntRem = cbsize % sizeof(uint32_t); // 剩餘字節數.
const uint32_t* pRem = (const uint32_t*)pbuf + cntBlock;
size_t rt = mpopcnt_array_hak_internal((const uint32_t*)pbuf, cntBlock);
#if INTRIN_WORDSIZE>=64
rt += mpopcnt_array_internal<MPopcnt, uint64_t>(pRem, cntRem);
#else
rt += mpopcnt_array_internal<MPopcnt, uint32_t>(pRem, cntRem);
#endif
return rt;
}
//////////////////////////////////////////////////
// main
//////////////////////////////////////////////////
#define BUFSIZE 16384 // = 32KB{L1 Cache} / (2 * sizeof(uint8_t))
uint8_t buf[BUFSIZE];
// 測試時的函數類型
typedef size_t (*TESTPROC)(const void* pbuf, size_t cbsize);
// 進行測試
void runTest(const char* szname, TESTPROC proc)
{
const int testloop = 4000; // 重複運算幾次延長時間，避免計時精度問題.
const clock_t TIMEOUT = CLOCKS_PER_SEC/2; // 最短測試時間.
int i,j,k;
clock_t tm0, dt; // 存儲時間.
double mps; // M/s.
double mps_good = 0; // 最佳M/s. 因線程切換會導致的數值波動, 於是選取最佳值.
volatile size_t n=0; // 避免內循環被優化.
for(i=1; i<=3; ++i) // 多次測試.
{
tm0 = clock();
// main
k=0;
do
{
for(j=1; j<=testloop; ++j) // 重複運算幾次延長時間，避免計時開銷帶來的影響.
{
n = proc(buf, BUFSIZE); // 避免內循環被編譯優化消掉.
}
++k;
dt = clock() - tm0;
}while(dt<TIMEOUT);
// show
mps = (double)k*testloop*BUFSIZE*CLOCKS_PER_SEC/(1024.0*1024.0*dt); // k*testloop*BUFSIZE/(1024.0*1024.0) 將數據規模換算爲M，然後再乘以 CLOCKS_PER_SEC/dt 換算爲M/s .
if (mps_good<mps) mps_good=mps; // 選取最佳值.
//printf("%s:\t%.0f M/s\t//%u\n", szname, mps, (unsigned)n);
}
printf("%s:\t%.0f M/s\t//%u\n", szname, mps_good, (unsigned)n);
}
// 自動測試普通版和循環展開版.
template<class TPopcnt>
void runTest_auto(const char* szname)
{
char szbuf[200];
sprintf(szbuf, "mpopcnt_array<%s>", szname);
runTest(szbuf, mpopcnt_array<TPopcnt>);
sprintf(szbuf, "mpopcnt_array_2loop<%s>", szname);
runTest(szbuf, mpopcnt_array_2loop<TPopcnt>);
sprintf(szbuf, "mpopcnt_array_4loop<%s>", szname);
runTest(szbuf, mpopcnt_array_4loop<TPopcnt>);
}
int main(int argc, char* argv[])
{
int i;
//uint32_t u32 = UINT32_C(0xffffffff);
//uint64_t u64 = UINT64_C(0xffffffffffffffff);
printf("testpopcnt v1.00 (%dbit)\n", INTRIN_WORDSIZE);
printf("Compiler: %s\n\n", COMPILER_NAME);
// init buf
srand( (unsigned)time( NULL ) );
for (i = 0; i < BUFSIZE; i++) buf[i] = (uint8_t)(rand());
//// popcnt
//printf("MPopcnt_Base::popcnt(u32):\t%u\n", (unsigned)MPopcnt_Base::popcnt(u32) );
//printf("MPopcnt_Base::popcnt(u64):\t%u\n", (unsigned)MPopcnt_Base::popcnt(u64) );
//printf("MPopcnt_Mx86::popcnt(u32):\t%u\n", (unsigned)MPopcnt_Mx86::popcnt(u32) );
//printf("MPopcnt_Mx86::popcnt(u64):\t%u\n", (unsigned)MPopcnt_Mx86::popcnt(u64) );
//// mpopcnt_array
//printf("mpopcnt_array<MPopcnt_Base>:\t%u\n", (unsigned)mpopcnt_array<MPopcnt_Base>(&buf, sizeof(buf)) );
//printf("mpopcnt_array<MPopcnt_Mx86>:\t%u\n", (unsigned)mpopcnt_array<MPopcnt_Mx86>(&buf, sizeof(buf)) );
// 進行測試
// runTest("mpopcnt_array<MPopcnt_Base>", mpopcnt_array<MPopcnt_Base>);
//#ifdef INTRIN_POPCNT
// if (getcpuidfield(CPUF_POPCNT)) runTest("mpopcnt_array<MPopcnt_Mx86>", mpopcnt_array<MPopcnt_Mx86>);
//#endif // #ifdef INTRIN_POPCNT
// runTest("mpopcnt_array<MPopcnt_Table>", mpopcnt_array<MPopcnt_Table>);
// runTest("mpopcnt_array<MPopcnt_HakBase>", mpopcnt_array<MPopcnt_HakBase>);
// runTest("mpopcnt_array<MPopcnt_HakBaseFast>", mpopcnt_array<MPopcnt_HakBaseFast>);
// runTest("mpopcnt_array_hak", mpopcnt_array_hak);
// 進行自動測試
runTest_auto<MPopcnt_Base>("MPopcnt_Base");
#ifdef INTRIN_POPCNT
if (getcpuidfield(CPUF_POPCNT)) runTest_auto<MPopcnt_Mx86>("MPopcnt_Mx86");
#endif // #ifdef INTRIN_POPCNT
runTest_auto<MPopcnt_Table>("MPopcnt_Table");
runTest_auto<MPopcnt_HakBase>("MPopcnt_HakBase");
runTest_auto<MPopcnt_HakBaseFast>("MPopcnt_HakBaseFast");
runTest("mpopcnt_array_hak", mpopcnt_array_hak);
return 0;
}
3.2 makefile
# flags
CC = g++
CFS = -Wall -msse
# args
RELEASE =0
BITS =
CFLAGS =
# [args] 生成模式. 0代表debug模式, 1代表release模式. make RELEASE=1.
ifeq ($(RELEASE),0)
# debug
CFS += -g
else
# release
CFS += -O3 -DNDEBUG
endif
# [args] 程序位數. 32代表32位程序, 64代表64位程序, 其他默認. make BITS=32.
ifeq ($(BITS),32)
CFS += -m32
else
ifeq ($(BITS),64)
CFS += -m64
else
endif
endif
# [args] 使用 CFLAGS 添加新的參數. make CFLAGS="-mpopcnt".
CFS += $(CFLAGS)
.PHONY : all clean
# files
TARGETS = testpopcnt
OBJS = testpopcnt.o
all : $(TARGETS)
testpopcnt : $(OBJS)
$(CC) $(CFS) -o $@ $^
testpopcnt.o : testpopcnt.cpp zintrin.h ccpuid.h
$(CC) $(CFS) -c $<
clean :
rm -f $(OBJS) $(TARGETS) $(addsuffix .exe,$(TARGETS))
四、效果測試
測試：略
結果：硬件popcnt最快，其次是查表法。而那些高級軟件算法在x86平臺上效率較差。
循環展開並沒有取得效果，可能是因超過通用寄存器的數量了。
參考文獻------
《高效程序的奧祕》, 原書名“Hacker's Delight”. Henry S.Warren 著, 馮速 譯. 機械工業出版社, 2004年5月.
《Intel® 64 and IA-32 Architectures Software Developer’s Manual Combined Volumes:1, 2A, 2B, 2C, 3A, 3B, and 3C》044US. August 2012. http://www.intel.com/content/www/us/en/processors/architectures-software-developer-manuals.html
《AMD64 Architecture Programmer's Manual Volume 3: General-Purpose and System Instructions》. December 2011. http://developer.amd.com/documentation/guides/Pages/default.aspx#manuals
《[C] 讓VC、BCB支持C99的整數類型（stdint.h、inttypes.h）（兼容GCC）》. http://www.cnblogs.com/zyl910/archive/2012/08/08/c99int.html
《[C] zintrin.h: 智能引入intrinsic函數 V1.01版。改進對Mac OS X的支持，增加INTRIN_WORDSIZE宏》. http://www.cnblogs.com/zyl910/archive/2012/10/01/zintrin_v101.html
《[C/C++] ccpuid：CPUID信息模塊 V1.03版，改進mmx/sse指令可用性檢查（使用signal、setjmp，支持純C）、修正AVX檢查Bug》. http://www.cnblogs.com/zyl910/archive/2012/10/13/ccpuid_v103.html
《[x86]SIMD指令集發展歷程表（MMX、SSE、AVX等）》. http://www.cnblogs.com/zyl910/archive/2012/02/26/x86_simd_table.html
《SIMD（MMX/SSE/AVX）變量命名規範心得》. http://www.cnblogs.com/zyl910/archive/2012/04/23/simd_var_name.html
《GCC 64位程序的makefile條件編譯心得——32位版與64位版、debug版與release版（兼容MinGW、TDM-GCC）》. http://www.cnblogs.com/zyl910/archive/2012/08/14/gcc64_make.html
《[C#] cmdarg_ui：“簡單參數命令行程序”的通用圖形界面》. http://www.cnblogs.com/zyl910/archive/2012/06/19/cmdarg_ui.html
《[C] 跨平臺使用Intrinsic函數範例1——使用SSE、AVX指令集 處理 單精度浮點數組求和（支持vc、gcc，兼容Windows、Linux、Mac）》. http://www.cnblogs.com/zyl910/archive/2012/10/22/simdsumfloat.html
