求一个快速分解bit位的方法(续)

[yaos]

http://topic.csdn.net/u/20080217/13/c99865e7-9eee-4c25-a46c-9734e7a2b41b.html?seed=814849127
接上面连接
因为上面连接速度太慢
开新战场
目前测试7种代码

DWORD find_by_yaos(DWORD a, DWORD index[33])
{
__asm
{
mov edx, a;
mov edi, dword ptr index;
xor eax, eax;
loop1:
bsr ecx, edx;
je exit1;
btr edx, ecx;
mov dword ptr [edi + 4*eax], ecx;
inc eax;
jmp loop1;
exit1:
mov dword ptr [edi + 4*eax], -1;
}
}

void find_by_yaos_1(DWORD a, DWORD index[33])
{
__asm
{
mov eax, a
mov edi, dword ptr [index]
loop1:
bsr ebx, eax
je exit1
btr eax, ebx
mov dword ptr [edi], ebx
add edi, 4
jmp loop1
exit1:
mov dword ptr [edi], -1
}
}

void find_by_yaos_2(DWORD a, DWORD index[33])
{
__asm
{
mov eax, a
mov edi, dword ptr [index]
mov ecx, 0
loop1:
shr eax, 1
jnc loop2
mov dword ptr [edi], ecx
add edi, 4
loop2:
inc ecx
cmp ecx, 32
jne loop1
mov dword ptr [edi], -1

}
}

void find_by_yaos_3(DWORD a, DWORD index[33])
{
__asm
{
mov eax, a
mov edi, dword ptr [index]
mov ecx, 32
loop1:
shl eax, 1
jnc loop2
mov dword ptr [edi], ecx
dec dword ptr [edi]
add edi, 4
loop2:
sub ecx, 1
jne loop1
mov dword ptr [edi], -1

}
}

void find_by_yaos_4(DWORD a, DWORD index[33])
{
__asm
{
mov eax, a
mov edi, dword ptr [index]
mov ecx, 32
loop1:
shl eax, 1
jnc loop2
mov dword ptr [edi], ecx
dec dword ptr [edi]
add edi, 4
loop2:
loopne loop1
mov dword ptr [edi], -1

}
}

[shines77]

其实我刚看到这个题目，直接想到的就是查表法，没各位的创新意识，不过查表法要做好才行，yaos旧帖里后面贴的那个查表法效率就不够好。

这里贴个我写的，优点是减少写入内存的次数，共9次（包括最后写入结束标志位），其他是16次加法运算，16次访问内存（查表），这个部分是查表法必须要做的事情，即使数据存在于 L1 Cache 中，也会有一定的CPU时钟消耗，不同的CPU所用的时钟周期不一样，P4约为7个左右。缺点：最大的缺点就是要查表，访问内存，这个部分是最大的消耗，不过对于现在流行的CPU，不会有太大的问题，表的数据量也仅为 16 * 4 * 2 = 128 字节。其实还可以构造一个更大的表，如index_value[8][16], 这样， .... + 0x01010101UL * 4 这部分的代码就可以省掉，应该会更快一些。不过如果是内存很吃紧的系统上还是用小的表比较好。

测试结果如下：
find_by_lbch() computation took 2082.872 ms
find_by_GxQ() computation took 761.370 ms
find_by_GxH() computation took 437.261 ms
find_by_fire_woods() computation took 695.960 ms

如果find_by_GxH()使用__fastcall 则可更快，380～390ms左右

测试环境 VC 6.0 sp5, WinXP SP2, P4 3.0G, 1G RAM

还发现一个问题，如果用ICC 10.1编译的话，会比VC 6.0更快，不过有时候如去掉find_by_GxQ()不编译，find_by_GxH速度反而变慢，所以运行速度不可过于迷信，要看编译器，要看测试环境的硬件（CPU等），我开ICC /fast编译选项反而变慢。

内容太长贴不上来，分几次。。。

[shines77]

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

#define _TEST_SIZE 0x1000000

DWORD bits[32];
static int index_value[16];
static int index_count[16];

// 作者：liangbch
void __fastcall find_by_lbch(DWORD code, int index[32]) //22
{
int i=0;

// 此处代码省略，详细查看旧帖51-52楼

}

#define BIT_CHECK(NUM, MSK, INDEX) \
{ \
index[i] = INDEX; \
i += (WORD)((NUM & MSK) >> INDEX); \
}

// 作者：fire_woods
void __fastcall find_by_fire_woods(DWORD code, int index[32]) // 97
{
WORD i = 0;
BIT_CHECK(code, 0x1, 0);
BIT_CHECK(code, 0x2, 1);
BIT_CHECK(code, 0x4, 2);
BIT_CHECK(code, 0x8, 3);
BIT_CHECK(code, 0x10, 4);
BIT_CHECK(code, 0x20, 5);
BIT_CHECK(code, 0x40, 6);
BIT_CHECK(code, 0x80, 7);
BIT_CHECK(code, 0x100, 8);
BIT_CHECK(code, 0x200, 9);
BIT_CHECK(code, 0x400, 10);
BIT_CHECK(code, 0x800, 11);
BIT_CHECK(code, 0x1000, 12);
BIT_CHECK(code, 0x2000, 13);
BIT_CHECK(code, 0x4000, 14);
BIT_CHECK(code, 0x8000, 15);
BIT_CHECK(code, 0x10000, 16);
BIT_CHECK(code, 0x20000, 17);
BIT_CHECK(code, 0x40000, 18);
BIT_CHECK(code, 0x80000, 19);
BIT_CHECK(code, 0x100000, 20);
BIT_CHECK(code, 0x200000, 21);
BIT_CHECK(code, 0x400000, 22);
BIT_CHECK(code, 0x800000, 23);
BIT_CHECK(code, 0x1000000, 24);
BIT_CHECK(code, 0x2000000, 25);
BIT_CHECK(code, 0x4000000, 26);
BIT_CHECK(code, 0x8000000, 27);
BIT_CHECK(code, 0x10000000, 28);
BIT_CHECK(code, 0x20000000, 29);
BIT_CHECK(code, 0x40000000, 30);
BIT_CHECK(code, 0x80000000, 31);
}

// 作者：GxQ；
// 返回返回当前bit=1的数目
DWORD find_by_GxQ(DWORD code, int index[33])
{
// 代码省略，详看旧帖68楼
}

// 作者：GxH, 查表法, index保存在char数组, 这是该方法的特点
// 原理类似liangbch的方法, 但实现方法不一样
DWORD find_by_GxH(DWORD code, int index[]) {
DWORD code_0f;
DWORD total;
char *p = (char *)index;

code_0f = code & 0x0f;
*(DWORD *)p = index_value[code_0f];
p += index_count[code_0f];;

code_0f = (code >> 4) & 0x0fUL;
*(DWORD *)p = index_value[code_0f] + 0x01010101UL * 4;
p += index_count[code_0f];

code_0f = (code >> 8) & 0x0fUL;
*(DWORD *)p = index_value[code_0f] + 0x01010101UL * 8;
p += index_count[code_0f];

code_0f = (code >> 12) & 0x0fUL;
*(DWORD *)p = index_value[code_0f] + 0x01010101UL * 12;
p += index_count[code_0f];

code_0f = (code >> 16) & 0x0fUL;
*(DWORD *)p = index_value[code_0f] + 0x01010101UL * 16;
p += index_count[code_0f];

code_0f = (code >> 20) & 0x0fUL;
*(DWORD *)p = index_value[code_0f] + 0x01010101UL * 20;
p += index_count[code_0f];

code_0f = (code >> 24) & 0x0fUL;
*(DWORD *)p = index_value[code_0f] + 0x01010101UL * 24;
p += index_count[code_0f];

code_0f = (code >> 28) & 0x0fUL;
*(DWORD *)p = index_value[code_0f] + 0x01010101UL * 28;
p += index_count[code_0f];

total = p - (char *)index;
*(DWORD *)p = (DWORD)-1;

return total;
}

int main(int argc, char * argv[])
{
LARGE_INTEGER lTimestart, lTimeEnd, liFreq;
double dbMs;

DWORD *testData;
DWORD i, j;
int index[33];

DWORD c, bitMask = 1;

for (i = 0; i < 31; i++) {
bits[i] = bitMask;
bitMask <<= 1;
}

DWORD shift, count;
for ( i = 0; i < 16; i++ ) {
bitMask = 1;
shift = 1;
count = 0;
index_value[i] = 0;
for ( j = 0; j < 4; j++ ) {
if ( (i & bitMask) != 0 ) {
index_value[i] += j * shift;
shift <<= 8;
count++;
}
bitMask <<= 1;
}
index_count[i] = count;
}

::SetThreadPriority(::GetCurrentThread(), THREAD_PRIORITY_TIME_CRITICAL);

testData = (DWORD *)malloc( _TEST_SIZE * sizeof( DWORD ) );
srand(GetTickCount());
for ( i=0; i<_TEST_SIZE; ++i ) {
testData[i] = ( (DWORD)(rand()) << 17 ) | rand(); // 确保可充满32bits
}

#if 1
// 对比测试函数1
{
QueryPerformanceCounter(<imestart);
for (i = 0; i < _TEST_SIZE; i++) {
find_by_lbch(testData[i], index); // 调用bit扫描函数
}
QueryPerformanceCounter(<imeEnd);
QueryPerformanceFrequency(&liFreq);

dbMs = ((double)(lTimeEnd.QuadPart - lTimestart.QuadPart) * 1000) / (double)liFreq.QuadPart;
printf("find_by_lbch() computation took %.3f ms\n", dbMs);
}
#endif

#if 1
// 对比测试函数2
{
QueryPerformanceCounter(<imestart);
for (i = 0; i < _TEST_SIZE; i++) {
find_by_GxQ(testData[i], index); // 调用bit扫描函数
}
QueryPerformanceCounter(<imeEnd);
QueryPerformanceFrequency(&liFreq);

dbMs = ((double)(lTimeEnd.QuadPart - lTimestart.QuadPart) * 1000) / (double)liFreq.QuadPart;
printf("find_by_GxQ() computation took %.3f ms\n", dbMs);
}
#endif

#if 1
// 对比测试函数3
{
QueryPerformanceCounter(<imestart);
for (i = 0; i < _TEST_SIZE; i++) {
find_by_GxH(testData[i], index); // 调用bit扫描函数
}
QueryPerformanceCounter(<imeEnd);
QueryPerformanceFrequency(&liFreq);

dbMs = ((double)(lTimeEnd.QuadPart - lTimestart.QuadPart) * 1000) / (double)liFreq.QuadPart;
printf("find_by_GxH() computation took %.3f ms\n", dbMs);
}
#endif

#if 1
// 对比测试函数4
{
QueryPerformanceCounter(<imestart);
for (i = 0; i < _TEST_SIZE; i++) {
find_by_fire_woods(testData[i], index); // 调用bit扫描函数
}
QueryPerformanceCounter(<imeEnd);
QueryPerformanceFrequency(&liFreq);

dbMs = ((double)(lTimeEnd.QuadPart - lTimestart.QuadPart) * 1000) / (double)liFreq.QuadPart;
printf("find_by_fire_woods() computation took %.3f ms\n", dbMs);
}
#endif

//*/

//system("Pause");

/*
// 对比测试函数5, yaos的代码运行出错，省略，我找的是旧帖里的代码，新帖版本太多
{
QueryPerformanceCounter(<imestart);
for(i = 0; i < _TEST_SIZE; i++) {
find_by_yaos1(testData[i], (DWORD *)&index[0], &c); // 调用bit扫描函数
}
QueryPerformanceCounter(<imeEnd);
QueryPerformanceFrequency(&liFreq);

dbMs = ((double)(lTimeEnd.QuadPart - lTimestart.QuadPart) * 1000) / (double)liFreq.QuadPart;
printf("find_by_yaos1() computation took %.3f ms\n", dbMs);
}
*/

free( testData );

system("Pause");
return 0;
}

[shines77]

所以我觉得要尽量减少或不使用循环和条件判断/跳转，尽量减少内存的读/写次数，看yaos的汇编代码里还好多跳转

[无心人]

呵呵
我就是在XEON2上测试的
除了随机测试哇外
结果5, 6怎么比较都比GxQ的好点

现在看到你的测试
我会重新测试随机测试的
还要加上8

估计是CPU差异导致的

[无心人]

我那里存在跳转
最后是这么测试的
设变量n
分别赋FFFFFFFF AAAAAAAA 0测试的跳转的不同情况

还有就是随循环测试i

因为没好方法得到均匀的随机32bit所以没测试随机数据
可以考虑用你们的算法测下随机

[无心人]

明天发个帖子求一个均匀的bit数字产生算法
：）

[无心人]

新的8没测试呢， 仅用来展示下思想
昨天刚想好
你测试用5, 6, 7
重点是6
7仅是个尝试
在没想到如何省略点多余的shl情况下，根本不占优势

[shines77]

奇怪，yaos，你的代码5,6,7在我的机器上表现都很慢。。。7稍微快一点，3800ms左右，打开ICC编译结果差不多

find_by_lbch() computation took 2071.550 ms
find_by_GxQ() computation took 749.953 ms
find_by_GxH() computation took 421.365 ms
find_by_fire_woods() computation took 688.288 ms
find_by_yaos_6() computation took 4133.637 ms

我想你的测试结果和GxQcn的不同之处是他用了随机的数字来测试，而你好像是从1到1000000测试，GxQcn代码:

    testData = (DWORD *)malloc( _TEST_SIZE * sizeof( DWORD ) );
    srand(GetTickCount());
    for ( i=0; i<_TEST_SIZE; i++ ) {
        testData[i] = ( (DWORD)(rand()) << 17 ) | rand(); // 确保可充满32bits
    }

[shines77]

不好意思，重新看了帖子，你前面提到过不同的测试方式，用0xffffffff，这样的常量来测试并不科学，因为有可能被编译器优化，随机样本比较客观，但多少都会受Cache影响，但这也是没有办法的，影响的大小可能吧_TEST_SIZE改得很小，如256以内，让testData[]不至于占满L1 Cache，再和_TEST_SIZE比较大的值比较测试结果则可知。

所以我采用了你的第2种测试方法，不过我测试的0x10000000次，注意是十六进制的，即268435456次，不是10000000次:

for(DWORD   i   =   0;   i    <   0x10000000;   i++){  
  find_by_yaos_2(i,  index);//   调用bit扫描函数  
} 

结果如下：
find_by_lbch() computation took 10788.405 ms
find_by_GxQ() computation took 11404.145 ms
find_by_GxH() computation took 5828.546 ms
find_by_fire_woods() computation took 10128.018 ms
find_by_yaos_6() computation took 26994.502 ms

也谈不上科学，其一是没有循环2^32次，其二这只是求平均时间，实际应用当中多数是随机的输入参数，但不失为一个评判标准。

[yaos]

真随机测试
以随机化算法产生位随机整数100万个测试
Bit Random: 773.018
yaos_2: 374.173
yaos_3: 383.809
yaos_4: 380.818
yaos_5: 366.404
yaos_6: 369.125
yaos_7: 390.325
GxQ: 179.193
GxH: 161.953
fire_wood: 758.799

和以前结果有区别
跳转还是存在损失

[yaos]

随机数字产生算法在
http://topic.csdn.net/u/20080317/09/366bddee-7fbd-4214-b27f-8a5660716210.html

[yaos]

把GxQ算法给循环化
结果是200左右

[yaos]

shines把查表法用到了极限了
除非汇编化了
：）

不过还有可改进地方

[yaos]

大数据测试 1000万 无法测0x10000000, 内存占用大
Bit Random: 7771.770
yaos_2: 3736.435
yaos_3: 3892.549
yaos_4: 3806.792
yaos_5: 3649.323
yaos_6: 3673.204
yaos_7: 3890.506
yaos_8: 1946.635
GxQ: 1738.357
GxH: 1594.124
fire_wood: 7326.780

find_by_yaos_8
乃GxQ算法的循环版本

DWORD find_by_yaos_8(DWORD a, DWORD index[33])
{
__asm
{
mov edx, a
mov edi, dword ptr [index]
mov ecx, 31
xor eax, eax
loop1:
shl edx, 1
adc eax, 0
mov dword ptr [edi + 4 * eax], ecx
sub ecx, 1
jnc loop1
}
}

[fire_woods]

#define BIT_CHECK(NUM, MSK, INDEX) \
{ \
index[i] = INDEX; \
i += (WORD)((NUM & MSK) > > INDEX); \
}

// 作者：fire_woods
void __fastcall find_by_fire_woods(DWORD code, int index[32]) // 97
{
WORD i = 0;
...

i变量设置成DWORD会快一些,不存在转换的问题.

#define BIT_CHECK(NUM, MSK, INDEX)  \ 
{ \ 
    index[i] = INDEX; \ 
    i += ((NUM >> INDEX) & 0x1 ); \ 
} 

// 作者：fire_woods 
DWORD __fastcall find_by_fire_woods(DWORD code, int index[32]) // 97 
{ 
    DWORD i = 0;
...
return i;

[yaos]

恩， 确实快点
到了6500数量级

[yaos]

find_by_yaos_8 作废
指令不对

:(

[ai_3621]

另：

在AMD的机器上貌似GxQ 表现最好。

[ai_3621]

DWORD find_by_GxH_L2DWORD code, int index[])
{
DWORD code_0f = code & 0x0f;
index[0] = index_value[code_0f];
int T = index_count[code_0f];

code_0f = (code >> 4) & 0x0fUL;
index[T] = index_value[code_0f] + 0x04040404UL;
T += index_count[code_0f];

code_0f = (code >> 8) & 0x0fUL;
index[T] = index_value[code_0f] + 0x08080808UL;
T += index_count[code_0f];

code_0f = (code >> 12) & 0x0fUL;
index[T] = index_value[code_0f] + 0x0C0C0C0CUL;
T += index_count[code_0f];

code_0f = (code >> 16) & 0x0fUL;
index[T] = index_value[code_0f] + 0x10101010UL;
T += index_count[code_0f];

code_0f = (code >> 20) & 0x0fUL;
index[T] = index_value[code_0f] + 0x14141414UL;
T += index_count[code_0f];

code_0f = (code >> 24) & 0x0fUL;
index[T] = index_value[code_0f] + 0x18181818UL;
T += index_count[code_0f];

code_0f = (code >> 28) & 0x0fUL;
index[T] = index_value[code_0f] + 0x1C1C1C1CUL;
T += index_count[code_0f];

return T;
}

[ai_3621]

看来 shines 郭子

又进一步优化了liangbch的方法，

好，


DWORD find_by_GxH_L(DWORD code, int index[]) {
DWORD code_0f;
DWORD total;
char *p = (char *)index;

code_0f = code & 0x0f;
*(DWORD *)p = index_value[code_0f];
p += index_count[code_0f];;

code_0f = (code > > 4) & 0x0fUL;
*(DWORD *)p = index_value[code_0f] + 0x04040404UL;
p += index_count[code_0f];

code_0f = (code > > 8) & 0x0fUL;
*(DWORD *)p = index_value[code_0f] + 0x08080808UL;
p += index_count[code_0f];

code_0f = (code > > 12) & 0x0fUL;
*(DWORD *)p = index_value[code_0f] + 0x0C0C0C0CUL;
p += index_count[code_0f];

code_0f = (code > > 16) & 0x0fUL;
*(DWORD *)p = index_value[code_0f] + 0x10101010UL;
p += index_count[code_0f];

code_0f = (code > > 20) & 0x0fUL;
*(DWORD *)p = index_value[code_0f] + 0x14141414UL;
p += index_count[code_0f];

code_0f = (code > > 24) & 0x0fUL;
*(DWORD *)p = index_value[code_0f] + 0x18181818UL;
p += index_count[code_0f];

code_0f = (code > > 28) & 0x0fUL;
*(DWORD *)p = index_value[code_0f] + 0x1C1C1C1CUL;
p += index_count[code_0f];

total = p - (char *)index;
*(DWORD *)p = (DWORD)-1;

return total;
}


难道不能在优化了么？

C也可以达到汇编的水平呵。