integer string极速互转 优化过程

【前言】

在C/C++编码中有大量的string、interger互转需求，系统接口要么不好用，要么性能不高。基于性能优化、个人兴趣两个主要目的，对string、integer互转优化做了大量的尝试，下面分享一下优化中的一些过程。

【优化效果概览】

32位环境（-O2）：

[----------] 4 tests from performance

[ RUN ] performance.int32_to_str

fi2s int32 cost: 16765 us

snprintf int32 cost: 594351 us

!!!!!!!!!!!! fi2s(32) is 35.451894 times faster than snprintf

[ OK ] performance.int32_to_str (613 ms)

[ RUN ] performance.int64_to_str

fi2s int64 cost: 189455 us

snprintf int64 cost: 1625197 us

!!!!!!!!!!!! fi2s(64) is 8.578275 times faster than snprintf

[ OK ] performance.int64_to_str (1815 ms)

[ RUN ] performance.str_to_int32

fs2i int32 cost: 3763 us

atoi int32 cost: 77420 us

!!!!!!!!!!!! fs2i(32) is 20.574010 times faster than atoi

[ OK ] performance.str_to_int32 (81 ms)

[ RUN ] performance.str_to_int64

fs2i int64 cost: 5521 us

atoi int64 cost: 168755 us

!!!!!!!!!!!! fs2i(64) is 30.566021 times faster than atoll

[ OK ] performance.str_to_int64 (174 ms)

[----------] 4 tests from performance (2683 ms total)

64位环境（-O2）：

[----------] 4 tests from performance

[ RUN ] performance.int32_to_str

fi2s int32 cost: 20086 us

snprintf int32 cost: 502266 us

!!!!!!!!!!!! fi2s(32) is 25.005775 times faster than snprintf

[ OK ] performance.int32_to_str (522 ms)

[ RUN ] performance.int64_to_str

fi2s int64 cost: 80195 us

snprintf int64 cost: 1261576 us

!!!!!!!!!!!! fi2s(64) is 15.731355 times faster than snprintf

[ OK ] performance.int64_to_str (1342 ms)

[ RUN ] performance.str_to_int32

fs2i int32 cost: 4471 us

atoi int32 cost: 67413 us

!!!!!!!!!!!! fs2i(32) is 15.077835 times faster than atoi

[ OK ] performance.str_to_int32 (72 ms)

[ RUN ] performance.str_to_int64

fs2i int64 cost: 5735 us

atoi int64 cost: 115071 us

!!!!!!!!!!!! fs2i(64) is 20.064690 times faster than atoll

[ OK ] performance.str_to_int64 (121 ms)

[----------] 4 tests from performance (2057 ms total)

【整数转字符串优化】

一般用系统接口snprintf(sprintf是高危函数，不考虑)来做整数转字符串的需求，用起来稍微有点麻烦，大致如下：

char buffer[32];

snprintf(buffer, sizeof(buffer), "%d", 12345);

考虑到snprintf性能不好、不方便，决定实现一个自己的转换。

常规的转换（这里以正整数举例，负数需要先处理符号）：

char buffer[32] = {0};

char* ptr = buffer + 30; // pos 31 for tail '\0'

int n = 12345, d = 0;

do

{

d = n / 10;

*(ptr--) = n - d * 10 + '0'; // 乘法+减法 代替求模

n = d;

} while (n != 0);

最终ptr指向的字符串就是我们想要的结果。

由上面代码可见，常规的方法需要作大量除法，int最多需要除10次，int64最多需要除20次，而除法操作需要大量的时钟周期，所以想优化的话，就要尽量减少除法的次数。

这里整数转字符串的核心思想很简单：用空间换时间，减少除法次数。

先建立一个字典： 

struct HydraIntStrNode

{

char str[5];

char len;

};

HydraIntStrNode g_hydra_int_to_str[10^5]; // 数字到串的映射

建立整数到字符串的映射，数组的下标是整数，对应的值就是字符串。使得【0,99999】这个区间的的整数转字符串可以直接查找字典（数组）完成。

那么为什么我们这里字典的元素要设置成10^5了，为什么不设置成2^32，直接将所有int映射成串不是更快？原因很简单，2^32*6字节=24G，浪费不起这么多内存。

而设置成10^5只需要几百k，而且uint最多10位，转换也最多需要一次除法！10^5是一个很好的折衷点。

转换逻辑（这里针对正整数，负数可以先处理符号，再转换成正整数）：

如果 整数 < 10^5

直接从字典里面取映射串

否则如果 整数 < 10^10 // 需要一次除法

将整数/10^5得到high+low两截，high、low一定都在【0,99999】这个区间里面，分别从字典里面取得映射串然后作拼接即可

否则如果 整数 < 10^15 // 需要两次除法

分成3截，从字典取出3个串进行拼接

否则 // 肯定 < 10^20, 因为uint64最大值 < 10^20，需要3次除法

分成4截，从字典取出4个串进行拼接

以上转换逻辑非常简单，但是为了性能，实际操作起来比这个逻辑要复杂。考虑到int64运算比int32运算要慢很多，

所以实际上【10^10, 10^15】这个区间被一分为二：【10^10,2^32-1】，【2^32,10^15】，使得落在【10^10,2^32-1】这个区间的整数可以直接用uint运算，从而得到更高的性能。

另外值得一提的是“前缀0填充”，对与类似100000这样的数字，会做一次除法，导致数字被截断成两截：1， 00000。00000这一截实际上在uint里面存储的只是0，

从字典得到的映射串是“0”，而不是我们预期的“00000”。对于这种情况需要进行”前缀0填充“。在前缀0填充的时候又有一个值得注意的细节，用for循环填充？用memset？答案都是NO，这两种填充都太慢，好的方法是：*(uint64*)dst = *(uint64*)"00000000"; *(uint*)dst = *(uint*)"0000"; 聪明的你一看就懂了，不用多讲，对于填充的字节不是8也不是4的情况，需要做一些修补工作，详情请参考代码。

最后一个小技巧，将字典的构造放在具有__attribute__((constructor)) 属性的函数里面完成，不需要任何显式的调用，程序加载的时候自动调用它，非常方便。

【字符串转整数优化】

这其中的版本有5个以上，这里只列出主要的几个

第一版：

最朴素的迭代乘、最多比ato*快3倍

代码：

template

TInt StrToIntImpl(const char* str)

{

TInt res = 0;

for (char c; (c = *(str++)) >= '0' && c <= '9'; )

res = res * 10 + (c ^ '0');

return res;

}

第二版：

在第一版基础上做循环展开、比第一版快，最多比ato*快5倍

代码：

#define _TO_NUM(v) ((v) ^ '0')

#define _IS_NUM(v) (v >= '0' && v <= '9')

template

TInt StrToIntImpl(const char* str)

{

TInt res = 0;

for (int k = 0; ; k += 4)

{

if (not _IS_NUM(str[k]))

return res;

else if (not _IS_NUM(str[k + 1]))

return res * 10 + _TO_NUM(str[k]);

else if (not _IS_NUM(str[k + 2]))

return res * 100 + _TO_NUM(str[k]) * 10 + _TO_NUM(str[k + 1]);

else if (not _IS_NUM(str[k + 3]))

{

return res * 1000 + _TO_NUM(str[k]) * 100

+ _TO_NUM(str[k + 1]) * 10 + _TO_NUM(str[k + 2]);

}

else 

{

res = res * 10000 + _TO_NUM(str[k]) * 1000 + _TO_NUM(str[k + 1]) 
                *  100 + _TO_NUM(str[k + 2]) * 10 + _TO_NUM(str[k + 3]);

}

}

return res;

}

第三版：

乘法相对耗时，试图减少乘法次数。方法是先建立一个字典，使得每四个字节才需要一次乘法。

字典定义为一个数组：

ushort dict[65536]; 

映射策略：将形如“1234567”这样的串切分成“1234 567”这样的串，用位运算将“1234”拼凑成一个整数，拼凑成的整数只需要占用2个字节。

拼凑策略：因为最大的单个数字9(二进制布局：1111，也就是8+0+0+1)只需要占用4个比特位，所以可以将2个数字字符“紧凑”到一个字节里面,

4个数字字符经过 移位、或 运算后，可以“紧凑”到2个字节（unsigned short）里面，从而可以讲拼凑成的unsigned short数字作为字典的下标，

找到对应的值(dict【紧凑（"1234”）】=1234）。

这样划分后，实际上将10进制转换成了10000进制，所以每次迭代需要 乘10000，而不再是10. 

代码：

#define _IS_NUM(v) (v >= '0' && v <= '9')

#define _TO_NUM(v) ((v) ^ '0')

#define _SHIFT(idx, n) (_TO_NUM(str[idx]) << n)

#define _4BYTE (_SHIFT(k,12) | _SHIFT(k+1,8) | _SHIFT(k+2,4) | _SHIFT(k+3,0))

#define _3BYTE (_SHIFT(k,8) | _SHIFT(k+1,4) | _SHIFT(k+2,0))

#define _2BYTE (_SHIFT(k,4) | _SHIFT(k+1,0))

#define _1BYTE (_SHIFT(k,0))

template

TInt StrToIntImpl(const char* str)

{

TInt res = 0;

int len = 0, k = 0;

while (_IS_NUM(str[len])) ++len;

if (0 == len) return 0;

static const void* ADDR1[] = { &&a0, &&a1, &&a2, &&a3, &&a4, &&a5, };

static const void* ADDR2[] = { &&aa0, &&aa1, &&aa2, &&aa3, };

static const uint MUL[] = { 1, 10, 100, 1000, };

goto *ADDR1[len >> 2];

a5:

res = (res + g_hydra_str_to_int[_4BYTE]) * 10000; k += 4;

a4:

res = (res + g_hydra_str_to_int[_4BYTE]) * 10000; k += 4;

a3:

res = (res + g_hydra_str_to_int[_4BYTE]) * 10000; k += 4;

a2:

res = (res + g_hydra_str_to_int[_4BYTE]) * 10000; k += 4;

a1:

res = (res + g_hydra_str_to_int[_4BYTE]) * MUL[len & 3]; k += 4;

a0:

goto *ADDR2[len & 3];

aa3:

return res + g_hydra_str_to_int[_3BYTE];

aa2:

return res + g_hydra_str_to_int[_2BYTE];

aa1:

return res + g_hydra_str_to_int[_1BYTE];

aa0:

return res;

}

遗憾的是，这个版本居然比最朴素的版本还要慢！让人非常失望。感觉是某个小细节没有做对，不该这样慢的！

第四版：

前面的版本都比较失败，是因为无论如何，都没有摆脱乘法操作，如果有办法完全摆脱乘法，岂不是非常完美？

。。。。各种头脑风暴。。。。。，最后想到一种方式: 首先依然依赖字典，不过这个字典跟之前的有所不同，严格

来说，不是一个字典，而是N个。举例如下：

第1个字典，映射 单个数字字符 到 数字*10^1(10的一次方，下同）, 如map1['8'] = 8 * 10^1, map1['5'] = 5 * 10^1.

第2个字典，映射 单个数字字符 到 数字*10^2, 如map2['8'] = 8 * 10^2, map2['5'] = 5 * 10^2.

。。。。。

第19个字典，映射 单个数字字符 到 数字*10^19, 如map19['1'] = 1 * 10^19, map19['5'] = 5 * 10^19(实际上5*10^19已经超出了uint64的范围，实际用不到，忽略）.

转换算法：

例子1："123":  map2['1'] + map1['2'] + ('3' ^ '0') => 123(integer)

例子2："1234567":  map6['1'] + map5['2]' + map4['3]' + map3['4]' + map2['5]' + map1['6]' + ('7' ^ '0') => 1234567(integer)

以此类推。。

代码：

#define HYDRA_TO_NUM(v) (v ^ '0')

#define HYDRA_IS_NUM(v) (v >= '0' && v <= '9')

static inline uint64 StrToIntImpl(const char* in)

{

const uchar* str = (const uchar*)in;

// 整数最多20字节(参照ULLONG_MAX)

if (not HYDRA_IS_NUM(str[0]))

return 0;

else if (not HYDRA_IS_NUM(str[1]))

return HYDRA_TO_NUM(str[0]);

else if (not HYDRA_IS_NUM(str[2]))

return g_hydra_mul1[str[0]] + HYDRA_TO_NUM(str[1]);

else if (not HYDRA_IS_NUM(str[3]))

return g_hydra_mul2[str[0]] + g_hydra_mul1[str[1]] 

    + HYDRA_TO_NUM(str[2]);

else if (not HYDRA_IS_NUM(str[4]))

{

uint a = g_hydra_mul3[str[0]] + g_hydra_mul2[str[1]];

uint b = g_hydra_mul1[str[2]] + HYDRA_TO_NUM(str[3]);

return a + b;

}

else if (not HYDRA_IS_NUM(str[5]))

{

uint a = g_hydra_mul4[str[0]] + g_hydra_mul3[str[1]];

uint b = g_hydra_mul2[str[2]] + g_hydra_mul1[str[3]];

return a + b + HYDRA_TO_NUM(str[4]);

}

else if (not HYDRA_IS_NUM(str[6]))

{

uint a = g_hydra_mul5[str[0]] + g_hydra_mul4[str[1]];

uint b = g_hydra_mul3[str[2]] + g_hydra_mul2[str[3]];

uint c = g_hydra_mul1[str[4]] + HYDRA_TO_NUM(str[5]);

return a + b + c;

}

// .... 省略N行

else if (not HYDRA_IS_NUM(str[20]))

{

uint64 a = g_hydra_mul19[str[0]] + g_hydra_mul18[str[1]];

uint64 b = g_hydra_mul17[str[2]] + g_hydra_mul16[str[3]];

uint64 c = g_hydra_mul15[str[4]] + g_hydra_mul14[str[5]];

uint64 d = g_hydra_mul13[str[6]] + g_hydra_mul12[str[7]];

uint64 e = g_hydra_mul11[str[8]] + g_hydra_mul10[str[9]];

uint64 f = g_hydra_mul9[str[10]] + g_hydra_mul8[str[11]];

uint g = g_hydra_mul7[str[12]] + g_hydra_mul6[str[13]];

uint h = g_hydra_mul5[str[14]] + g_hydra_mul4[str[15]];

uint i = g_hydra_mul3[str[16]] + g_hydra_mul2[str[17]];

uint j = g_hydra_mul1[str[18]] + HYDRA_TO_NUM(str[19]);

uint64 k = a + b;

uint64 l = c + d;

uint64 m = e + f;

uint n = g + h;

uint o = i + j;

return k + l + m + n + o;

}

else

return 0;

}

特点：

1. 乘法零使用，查找字典做加法和位运算

2. 完全循环展开，编译器可以充分优化

3. 无关联部位“并行加”将结果存储到不同的变量，最后将和汇总

结果：没让人失望，比ato*快了20到30多倍。虽然结果令人满意，但是过程依然艰辛，一开始将StrToIntImpl实现为模板，发现只比ato*快4倍，有点失望，后来发现StrToIntImpl的实现根本与模板无关，就把模板变成了内联函数，返回值统一为uint64(负数的符号处理等更多细节这里略过，可参照完整代码），速度提升的令人意外！应该是跟编译的细节有关联，暂时没有深究。后来想想这个实现有点长，试图把实现放到cpp里面，测试发现性能大打折扣，只比ato*快4倍，所以决定保留为inline实现。

后话：也许这并不是最佳性能，如果用SIMD向量指令做并行计算的话，可以带来二次惊喜吗？优化无止境！