strlen glibc 源码分析

size_t strlen (str) const char *str; { const char *char_ptr; const unsigned long int *longword_ptr; unsigned long int longword, himagic, lomagic; /* Handle the first few characters by reading one character at a time. Do this until CHAR_PTR is aligned on a longword boundary. */ for (char_ptr = str; ((unsigned long int) char_ptr & (sizeof (longword) - 1)) != 0; ++char_ptr) if (*char_ptr == '/0') return char_ptr - str; /* All these elucidatory comments refer to 4-byte longwords, but the theory applies equally well to 8-byte longwords. */ longword_ptr = (unsigned long int *) char_ptr; /* Bits 31, 24, 16, and 8 of this number are zero. Call these bits the "holes." Note that there is a hole just to the left of each byte, with an extra at the end: bits: 01111110 11111110 11111110 11111111 bytes: AAAAAAAA BBBBBBBB CCCCCCCC DDDDDDDD The 1-bits make sure that carries propagate to the next 0-bit. The 0-bits provide holes for carries to fall into. */ himagic = 0x80808080L; lomagic = 0x01010101L; if (sizeof (longword) > 4) { /* 64-bit version of the magic. */ /* Do the shift in two steps to avoid a warning if long has 32 bits. */ himagic = ((himagic << 16) << 16) | himagic; lomagic = ((lomagic << 16) << 16) | lomagic; } if (sizeof (longword) > 8) abort (); /* Instead of the traditional loop which tests each character, we will test a longword at a time. The tricky part is testing if *any of the four* bytes in the longword in question are zero. */ for (;;) { longword = *longword_ptr++; if (((longword - lomagic) & ~longword & himagic) != 0) { /* Which of the bytes was the zero? If none of them were, it was a misfire; continue the search. */ const char *cp = (const char *) (longword_ptr - 1); if (cp[0] == 0) return cp - str; if (cp[1] == 0) return cp - str + 1; if (cp[2] == 0) return cp - str + 2; if (cp[3] == 0) return cp - str + 3; if (sizeof (longword) > 4) { if (cp[4] == 0) return cp - str + 4; if (cp[5] == 0) return cp - str + 5; if (cp[6] == 0) return cp - str + 6; if (cp[7] == 0) return cp - str + 7; } } } } 

 

主要思想： 将每次读取一个字节的字符变成每次读取4／8字节的字符串，提高效率

 

挨个判断字符是否为0，遇到0则退出，代码很简洁，也不算性能低。只是有点不足，在字长是4字节或者8字节的计算机上，每次只
读取一个字节，有些浪费计算机的能力，如果每次都读取4字节或者8字节，总的读取次数就大大减少，在读取4字节或者8字节的时
候，如果地址不在边界上，机器就要分两次才能读取完成，这样性能将会降低，弱化优化效果，所以前几个字符必须单独处理，然后
从字长 边界地址开始，每次读取4字节或者8字节。

方式：

  1、 开头的几字节单独处理

     for (char_ptr = str; ((unsigned long int) char_ptr & (sizeof (longword) - 1)) != 0; ++char_ptr) if (*char_ptr == '/0') return char_ptr - str;
 2、 中间部分4字节或者8字节处理

     
  3、 若中间出现零则单独处理

if (((longword - lomagic) & ~longword & himagic) != 0) { /* Which of the bytes was the zero? If none of them were, it was a misfire; continue the search. */ const char *cp = (const char *) (longword_ptr - 1); if (cp[0] == 0) return cp - str; if (cp[1] == 0) return cp - str + 1; if (cp[2] == 0) return cp - str + 2; if (cp[3] == 0) return cp - str + 3; if (sizeof (longword) > 4) { if (cp[4] == 0) return cp - str + 4; if (cp[5] == 0) return cp - str + 5; if (cp[6] == 0) return cp - str + 6; if (cp[7] == 0) return cp - str + 7; } } 

 

 

看上去很好，但是还有一个问题，4字节或者8字节读取的时候，如何保证有全0的字节存在，因为0是用来表示字符串的结尾的。
判断连 续的几个字节中是否存在全0的字节，成了优化的关键。我们不能一个字节一个字节判断，因为优化的思想就是一次读取
多个字节，减少 总的读取次数，单独判断每一个字节的话，就失去优化的效果了。

怎么办呢，当然首先考虑位运算了。

  * 一个纯0的字节有什么特点? 很明显，每一位都是0，按位取反后每一位都是1。
  * 一个全0的字节还有什么特点? 这个字节减1，必然要从更高字节借1，借1后，该字节的最高位必然是1。

似乎有些眉目了，以4字节整数n为例，我们只要把每个字节分别减去1，如果有纯0的字节存在，必然会有借位，借位之后会在
字节最高 位留下一个1。只要判断每个字节的最高位是否存在1就可以了，然而，这里还有一个问题，就是这个4字节整数里，
某些字节本来最高 位可能就含有1，所以必须排除掉这些字节。

解决方案：

  * 将n的每一个字节分别减1，并取出最高位，得到x，如果存在借位，该字节最高位就是1
  * 将n的每一个字节按位取反并取出最高位，得到y，y中某字节最高位为1，表示它在n里是0
  * 将x和y按位与运算，若不等于0，说明n至少有1字节原本最高位不是1，后来变成1了，就是借位

若n中存在全0字节，则 x&y 一定不为0，因为借位的那个字节最高位会被置为1
若n中不存在全0字节，则不会产生借位，x&y 等于0。
x&y == (n-0x01010101) & ~n & 0x80808080

 

参考：http://topic.csdn.net/u/20091029/18/8f047493-15f8-4af5-bb8d-b5147128f79a.html

           http://simohayha.javaeye.com/blog/439059

           http://bigwhite.blogbus.com/logs/37753065.html