如果要你寫一個計算字串長度的函式 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 位是一樣的，只不過位數增加了。
