为了效率，我们可以用的招数 之 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 位是一样的，只不过位数增加了。