log2取整效率测试
RMQ问题中有个ST算法,当然还有个标准算法.LCA问题可以转化为带限制的RMQ(RMQ+-1)问题来解决.我们姑且认为这些问题的时间复杂度是查询$O(1)$的.但是,注意到对于RMQ(/+-1)问题,这个问题有个长度的限制,我们记为n.那么对于每个查询,我们都要询问一个范围[L,R],1<=L<=R<=n.这个区间的长度为R-L+1.然后我们将原区间分成两个Sparse Table上的项,即长度为int_log2(R-L+1)-1的两个子区间求解min,即合并两个子区间的信息.
那么问题来了,int_log2(R-L+1)-1也是要花时间的.有些人推荐用floor(log(n)/lg2-1),非常仪赖于cmath库的log函数,潜意识里认为它是$O(1)$的.我非常反对这种"眼不见为净"的人,于是我想出了一系列算法求解int_log2(n)-1.我做了一些测试来对比这些算法的效率.
1) cmath log函数求解
2) iterate 迭代右移求解
3) binary 二分右移求解
4) float conversion 转换为浮点数进行位运算求解
下面简述一下这些求解法.
log函数求解
<cmath>库中提供了函数log.直接调用log计算.
代码
inline int ilog2_cmath(int n){
return floor(log(n+.0)/l2)-1;
}
就这样.非常简单.
迭代右移求解
我们循环右移n,当n为0时退出循环.每次循环将一个计数器加1.
inline int ilog2_iter(int n){
int i;for(i=0,n>>=1;n;++i) n>>=1;
return i-1;
}
二分右移求解
我们二分n有的bits.
inline int ilog2_bin(int n){
int i=0;
if(n>>16) i|=16,n>>=16;
if(n>>8) i|=8,n>>=8;
if(n>>4) i|=4,n>>=4;
if(n>>2) i|=2,n>>=2;
if(n>>1) i|=1,n>>=1;
return i-1;
}
转换为浮点数进行位运算求解
这个办法比较难以理解了.
我们需要从浮点数的构造着手.
Float: [1bit sign bit][8bit exponent bits][23bit mantissa bits]
00000000101000100010001000100010
^ 符号位
^------^ 指数位
^---------------------^ 尾数位(有效数字.[开头的1已省去])
我们要获取的,就是这个符号位的信息.
这个符号位恰好是int_log2(n)-1.因此,我们甚至无需减1.这是一个非常好的性质.
那么我们只需要把一个整数转成Float,右移23位再用31做与&运算掩码即可.
inline int ilog2_kf(int n){
float q=(float)n;
return (*(int*)&q)>>23&31;
}
代码很短.开O3时很快.
测试
实践是检验真理的唯一标准.
代码
#define sizex 100000000
#define l2 0.6931471805599453
#include <cmath>
inline int ilog2_cmath(int n){
return floor(log(n+.0)/l2)-1;
}
inline int ilog2_iter(int n){
int i;for(i=0,n>>=1;n;++i) n>>=1;
return i-1;
}
inline int ilog2_bin(int n){
int i=0;
if(n>>16) i|=16,n>>=16;
if(n>>8) i|=8,n>>=8;
if(n>>4) i|=4,n>>=4;
if(n>>2) i|=2,n>>=2;
if(n>>1) i|=1,n>>=1;
return i-1;
}
inline int ilog2_kf(int n){
float q=(float)n;
return (*(int*)&q)>>23&31;
}
#include <cstdio>
#include <random>
#include <malloc.h>
#include <sys/time.h>
using namespace std;
int *data,res;
long long mytic(){
long long result = 0.0;
struct timeval tv;
gettimeofday( &tv, NULL );
result = ((long long)tv.tv_sec)*1000000 + (long long)tv.tv_usec;
return result;
}
#define dic1() disA(generator)
void genData(int a){
mt19937 generator;
uniform_int_distribution<int> disA(0,2147483647);
int i=0;
for(;i<a;++i) data[i]=dic1();
}
void testN(int k){
int i;
printf("cmath log method\n");
long long start=mytic();
for(i=0;i<k;++i){
res=ilog2_cmath(data[i]);
}
start=mytic()-start;
printf("%d\n",res);
printf("Time usage: %lld us\n",start);
}
void testU(int k){
int i;
printf("iterate log method\n");
long long start=mytic();
for(i=0;i<k;++i){
res=ilog2_iter(data[i]);
}
start=mytic()-start;
printf("%d\n",res);
printf("Time usage: %lld us\n",start);
}
void testP(int k){
int i;
printf("binary divide log method\n");
long long start=mytic();
for(i=0;i<k;++i){
res=ilog2_bin(data[i]);
}
start=mytic()-start;
printf("%d\n",res);
printf("Time usage: %lld us\n",start);
}
void testUP(int k){
int i;
printf("float convertion log method\n");
long long start=mytic();
for(i=0;i<k;++i){
res=ilog2_kf(data[i]);
}
start=mytic()-start;
printf("%d\n",res);
printf("Time usage: %lld us\n",start);
}
int main(){
int a,b,c,i,j,k,l,m,n,N,U,P,UP;
data=(int*)malloc(400000000*sizeof(int));
while(printf("0 to quit> "),scanf("%d",&a),a){
printf("CMLog Iter Bina Flcv\n");
scanf("%d%d%d%d",&N,&U,&P,&UP);
if(a>400000000) continue;
genData(a);
if(N) testN(a);
if(U) testU(a);
if(P) testP(a);
if(UP) testUP(a);
printf("%d %d %d %d\n",ilog2_cmath(a),ilog2_iter(a),ilog2_bin(a),ilog2_kf(a));
}
free(data);
return 0;
}
测试结果
//数据大小: 4×10^8数 //cmath log 19277285 us ~ 19.3 s //iterate 6197113 us ~ 6.2 s 3.1x faster than cmath log //binary iterate 2018023 us ~ 2.0 s 3.1x faster than iterate //float bit operation 406996 us ~ 0.41 s 5.0x faster than binary iterate and 47.4x faster than cmath log
数据无误.结果无误.
(机器数据:i7 4700m 2.0GHz (16GB=15.6GiB RAM DDR3 800MHz)?)
(编译命令:gcc ... -O3)
结果分析
第四种方法特别快.事实上从用时中看得出来每一次运算几乎是整的2个时钟周期.
由此看来i7 int2float的效率是1时钟周期.
下面贴-O2的数据.依次为CMLog Iter Binary FloatConvBitOperation 单位us 数据均由mt19937随机数算法随机生成
19301840 6186242 2379282 400056
下面贴-O1的数据.
19267001 6466776 2446129 385642
下面贴-O的数据.
19302953 6472134 2460882 400694
下面贴-Os的数据.
19247815 8508664 2500930 390131
下面贴不带optimize选项的数据.
19198380 25362664 6802623 1290716
下面贴-O3带-march=corei7-avx的数据.
19301717 6196286 2010706 377347
数据分析:
只要带optimize选项,fclm都是最快的,在0.4s左右.否则fclm还是最快的,1.2s左右.
-Os的Iter从6.2s变成8.5s,变慢了许多.
不开optimize的除了cmath log(已编译好直接连接)外都慢了很多很多,3-4x左右.大约是函数调用开销!
corei7-avx减少了fclm的时间.
程序优化notes: 开-O2的地方基本不用担心速度了.
评测程序: 修改了并查集测试的程序用.
编程建议: 使用fclm方法来获取highbit等intlog2的应用.
优点:
1) 代码短
2) 没有判断.充分利用处理器架构.
3) 代码不容易看懂.
4) 在IEEE754 compatiable的机器上均可使用.(几乎没有不能使用的机器.)
5) 非常非常快.几乎相当于lowbit的速度,然而求出lowbit必须用fclm转换成指数.
缺点:
1) 在特别特别特别老或特别奇葩的机器上不能用.
2) 动态类型语言不可用.可以用native extension或biniter解决.动态语言不需要高效率.
该问题完美解决.
2个时钟周期的算法无论如何都不能看作$O(\log{\log{n}})$了.显然是$O(1)$时间复杂度的算法.
