为了效率，我们可以用的招数 之 strlen
如果要你写一个计算字符串长度的函数 strlen，应该怎么写？相信你很容易写出如下实现：
1 int strlen_1(const char* str) { 2 int cnt = 0; 3 4 if (NULL == str) { 5 return 0; 6 } 7 8 while (*str != '\0') { 9 cnt++; 10 str++; 11 } 12 return cnt; 13 }
那么，它的运行情况怎么样？写段代码测试一下：
1 const char* strs[] = { 2 NULL, 3 "", 4 "1", 5 "12", 6 "123", 7 "012345678901234567890" 8 "012345678901234567890" 9 "012345678901234567890" 10 "012345678901234567890" 11 "012345678901234567890" 12 "012345678901234567890" 13 "012345678901234567890" 14 "012345678901234567890" 15 "012345678901234567890" 16 "012345678901234567890" 17 }; 18 19 int main() 20 { 21 int arrSize = sizeof(strs) / sizeof(char*); 22 for (int i = 0; i < arrSize; i++) { 23 printf("%5d: %10d\n", i, strlen_1(strs[i])); 24 } 25 26 return 0; 27 }
运行结果如下：
我们得到了正确结果，但是这样就够了吗？写代码，尤其是经常被调用的代码，效率是一个很重要的考虑方面，我们的 strlen_1 的效率如何呢？为了测试效率，我们测量一个100M 个字符的超长的字符串。编辑如下测试代码:
1 typedef size_t(*pStrLen)(const char* str); 2 void testProf( 3 pStrLen sl, 4 const char* testName, 5 const char* str) { 6 7 long start = GetTickCount64(); 8 long end = 0; 9 10 int len = sl(str); 11 12 end = GetTickCount64(); 13 14 printf( 15 "%s, start: %ld, end: %ld, total: %ld, result: %d\n", 16 testName, 17 start, 18 end, 19 end - start, 20 len 21 ); 22 } 23 24 void testLen(pStrLen sl, const char* name) { 25 int arrSize = sizeof(strs) / sizeof(char*); 26 puts("------------------------------------------"); 27 puts(name); 28 puts("\n"); 29 30 for (int i = 0; i < arrSize; i++) { 31 printf("%5d: %10d\n", i, strs[i] == NULL ? 0 : sl(strs[i])); 32 } 33 }
修改主程序如下：
// 100M #define STR_SIZE 100000000 int main() { char* str = (char*)malloc(sizeof(char) * STR_SIZE); if (str == NULL) { return -1; } memset(str, 'a', STR_SIZE - 1); str[STR_SIZE - 1] = '\0'; testLen(strlen_1, "strlen_1"); testProf(strlen_1, "strlen_1", str); free((void*)str); return 0; }
得到结果如下（为了去除debug信息的影响，这里使用 release x86 编译，以下同）：
耗时94ms，时间有点长啊，可以优化吗?考虑到我们只需要计算开始和结束地址之间的差，就得到了长度，那么如果省略计数变量，改成如下会不会好些？
1 size_t strlen_2(const char* str) { 2 const char* eos = str; 3 if (NULL == eos) { 4 return 0; 5 } 6 while (*eos) { 7 eos++; 8 } 9 return (eos - str); 10 }
添加 strlen_2 的测试，修改主程序如下：
1 // 100M 2 #define STR_SIZE 100000000 3 int main() 4 { 5 char* str = (char*)malloc(sizeof(char) * STR_SIZE); 6 7 if (str == NULL) { 8 return -1; 9 } 10 11 memset(str, 'a', STR_SIZE - 1); 12 str[STR_SIZE - 1] = '\0'; 13 14 testLen(strlen_1, "strlen_1"); 15 testLen(strlen_2, "strlen_2"); 16 17 testProf(strlen_1, "strlen_1", str); 18 testProf(strlen_2, "strlen_2", str); 19 20 free((void*)str); 21 22 return 0; 23 }
运行一下，得到如下结果：
看起来有一些效果，但这就够了吗？那么系统自带的 strlen 函数效果怎么样呢？新增 strlen 的测试代码:
1 testLen(strlen_1, "strlen_1"); 2 testLen(strlen_2, "strlen_2"); 3 testLen(strlen, "strlen"); 4 5 testProf(strlen_1, "strlen_1", str); 6 testProf(strlen_2, "strlen_2", str); 7 testProf(strlen, "strlen", str);
运行结果如下：
哇，居然快了4倍(63/15=4.2)，那就要了解下系统自带strlen的实现了，经过查找，找到系统 strlen 的汇编代码如下：
1 public strlen 2 3 strlen proc \ 4 buf:ptr byte 5 6 OPTION PROLOGUE:NONE, EPILOGUE:NONE 7 8 .FPO ( 0, 1, 0, 0, 0, 0 ) 9 10 string equ [esp + 4] 11 12 mov ecx,string ; ecx -> string 13 test ecx,3 ; test if string is aligned on 32 bits 14 je short main_loop 15 16 str_misaligned: 17 ; simple byte loop until string is aligned 18 mov al,byte ptr [ecx] 19 add ecx,1 20 test al,al 21 je short byte_3 22 test ecx,3 23 jne short str_misaligned 24 25 add eax,dword ptr 0 ; 5 byte nop to align label below 26 27 align 16 ; should be redundant 28 29 main_loop: 30 mov eax,dword ptr [ecx] ; read 4 bytes 31 mov edx,7efefeffh 32 add edx,eax 33 xor eax,-1 34 xor eax,edx 35 add ecx,4 36 test eax,81010100h 37 je short main_loop 38 ; found zero byte in the loop 39 mov eax,[ecx - 4] 40 test al,al ; is it byte 0 41 je short byte_0 42 test ah,ah ; is it byte 1 43 je short byte_1 44 test eax,00ff0000h ; is it byte 2 45 je short byte_2 46 test eax,0ff000000h ; is it byte 3 47 je short byte_3 48 jmp short main_loop ; taken if bits 24-30 are clear and bit 49 ; 31 is set 50 51 byte_3: 52 lea eax,[ecx - 1] 53 mov ecx,string 54 sub eax,ecx 55 ret 56 byte_2: 57 lea eax,[ecx - 2] 58 mov ecx,string 59 sub eax,ecx 60 ret 61 byte_1: 62 lea eax,[ecx - 3] 63 mov ecx,string 64 sub eax,ecx 65 ret 66 byte_0: 67 lea eax,[ecx - 4] 68 mov ecx,string 69 sub eax,ecx 70 ret 71 72 strlen endp
简单说明如下：
12 - 14 行，判断ecx 指针是否4字节对齐,如果4字节对齐，就跳转到 主循环，否则就进入str_misaligned 循环；
16 - 23 行，逐字节读取字符并判断是否为 '\0',如果找到 '\0',就跳转到第 51 行(byte_3)，计算地址差（即为字符串长度），并返回；如果没有找到 '\0' 字符并且地址已经四字节对齐，就继续执行主循环（29行);
29 - 49 行，是程序主循环，逻辑可用 C 描述为：
1 // 已经32位对齐 2 int* eos = (int*)c; 3 int val = 0; 4 while (true) { 5 val = *eos; 6 int ad = val + 0x7efefeff; 7 val ^= -1; // 0b 1111 1111 1111 1111 1111 1111 1111 1111 8 val ^= ad; 9 eos++; 10 if (!(val & 0x81010100)) { 11 continue; 12 } 13 val = *(eos - 1); 14 if ((val & 0x000000ff) == 0) { 15 return (int)eos - (int)str - 4; 16 } 17 18 if ((val & 0x0000ff00) == 0) { 19 return ((int)eos - (int)str) - 3; 20 } 21 22 if ((val & 0x00ff0000) == 0) { 23 return ((int)eos - (int)str) - 2; 24 } 25 26 if ((val & 0xff000000) == 0) { 27 return ((int)eos - (int)str) - 1; 28 } 29 // taken if bits 24-30 are clear and bit 31 is set 30 }
其中，每次读取，均读取四字节，且一次性进行是否包含 '\0' 的判断，减少操作次数位逐个字节读取的 1/4，怪不得速度上也是快了四倍左右。
那么，系统strlen是怎样一次判断四个字节呢？我们注意到两个特殊值，0x7efefeff 和 0x81010100，那么为什么可以用这两个值判断是否包含 '\0' 呢？我们看看这两个值得二进制表示：
我们看看第一步操作:
1 int ad = val + 0x7efefeff;
我们把四个字节和 0x7efefeff 这个值相加了，如果 val 的最后一个字节不为0，则会向上一个字节产生一个进位，从而导致 ad 的倒数第二个字节的最后一位不为0，则倒数第二个字节就会变成 1111 1111 的状态，第二个字节同理，如果不为0，则会补充倒数第三个字节，最后，倒数第三个字节又会补充第一个字节；这就导致，在每个字节都不为 0 的前提下，ad 每个字节的最低位肯定和 0x7efefeff 与 val 值相加对应位的本应值相反（因为产生了进位，如果当前字节相加结果的最低位为1，则因为上一个字节的进位，则最低位会变成0，如果结果的最低位为0，则因为进位，最低位为1）；
我们再看第二步，val值异或 -1，这里实际上是将 val 值得各个位取反，然后再用 val 值得取反结果异或 ad; 从上一步分析我们可以知道，如果第一步从字符串取到的 4 个字节均不为 0，则经过操作，ad对应字节的最低位肯定和原始值相反，这里拿 val 值的取反结果异或 ad，则在四字节均不为 0 的情况下，各个字节的最低位肯定为0；
最后一步，拿第二步获取到的结果和 0x81010100 相与(test)，则因为上一步获取到的值最低位在取到四字节均不为0的情况下，最低位肯定为 0，所以如果 val & 0x81010100 为 0，则说明四字节均不为0(即'\0')；
其他步骤就好说了，读取四字节，并一次判断各个字节的值是否为 0,如果为 0，则计算结果并返回。
最后，编辑 strlen_3 如下：
1 size_t __cdecl strlen_3(const char* str) { 2 if (NULL == str) { 3 return 0; 4 } 5 6 const char* c = str; 7 8 while (((int)c) & 3) { 9 if (*c == '\0') { 10 return c - str; 11 } 12 c++; 13 } 14 15 // 已经32位对齐 16 int* eos = (int*)c; 17 int val = 0; 18 while (true) { 19 val = *eos; 20 int ad = val + 0x7efefeff; 21 val ^= -1; // 0b 1111 1111 1111 1111 1111 1111 1111 1111 22 val ^= ad; 23 eos++; 24 if (!(val & 0x81010100)) { 25 continue; 26 } 27 val = *(eos - 1); 28 if ((val & 0x000000ff) == 0) { 29 return (int)eos - (int)str - 4; 30 } 31 32 if ((val & 0x0000ff00) == 0) { 33 return ((int)eos - (int)str) - 3; 34 } 35 36 if ((val & 0x00ff0000) == 0) { 37 return ((int)eos - (int)str) - 2; 38 } 39 40 if ((val & 0xff000000) == 0) { 41 return ((int)eos - (int)str) - 1; 42 } 43 // taken if bits 24-30 are clear and bit 31 is set 44 } 45 }
添加并执行测试代码，结果如下：
可以看到，新版本的 strlen 运行时间已经和系统 strlen 一样级别了。
最后，我们再考虑下，这里用的是 32 位系统，如果在 64 位系统上，是否也可以用类似方法呢？答案是肯定的，而且事实上，strlen 的 64 位版本也是这么做的：
可以看到，这里使用的方法和 32 位是一样的，只不过位数增加了。
