glibc代码学习(1)：strcpy源代码(1)

1040阅读　0评论2015-05-29　hongjiujing
分类：C/C++

本文的copyleft归gfree.wind@gmail.com所有，使用GPL发布，可以自由拷贝，转载。但转载请保持文档的完整性，注明原作者及原链接，严禁用于任何商业用途。
作者：gfree.wind@gmail.com
博客：linuxfocus.blog.chinaunix.net  

终于开始glibc的代码学习了，这段时间纠结的事情太多，牵涉了不少精力。好，下面进入正题。
第一个函数strcpy：
  1. /* 代码风格应该是K&R风格 */
  2. char *
  3. strcpy (dest, src)
  4.      char *dest;
  5.      const char *src;
  6. {
  7.   reg_char c;
  8.   /*
  9.   关于__unbounded和CHECK_BOUNDS_LOW，可以不作理会，可使其为空的宏定义。
  10.   引入这两个宏的原因是因为bounded pointer，其定义参见wiki：
  11.   */
  12.   char *__unbounded s = (char *__unbounded) CHECK_BOUNDS_LOW (src);
   /*
   计算目的地址dest与源地址s的偏移-1的值。之所以要减去1，是因为后面的代码。
   */
  1.   const ptrdiff_t off = CHECK_BOUNDS_LOW (dest) - s - 1;
  2.   size_t n;

  4.   do
  5.     {
  6.       c = *s++;
  7.       /* 前面计算偏移的时候多减了一个1，就因为上一个语句s进行了自加运算 */
  8.       s[off] = c;
  9.     }
  10.   while (c != '\0');
  
   /* 这部分代码也可以无视 */
  1.   n = s - src;
  2.   (void) CHECK_BOUNDS_HIGH (src + n);
  3.   (void) CHECK_BOUNDS_HIGH (dest + n);

  5.   return dest;
  6. }
光看这部分代码，可能学不到什么东西，那么来想一下如果是自己去实现strcpy，会怎么写呢？
  1. char* my_strcpy1(char *dest, const char *src)
  2. {
  3.     char *d = dest;
  4.     do {
  5.         *d++ = *src;
  6.     } while ('\0' != *src++);

  8.     return dest;
  9. }
下面对比一下C库和上面的代码，测试一下效率。为了公平，我复制了C库的代码，并去掉了bound pointer的相关代码，将其命名为my_strcpy2。然后复制2个字符串，重复一千万次。而且在编译的过程中，不使用任何优化参数。

  1. #include <stdio.h>

  3. char* my_strcpy1(char *dest, const char *src)
  4. {
  5.     char *d = dest;
  6.     do {
  7.         *d++ = *src;
  8.     } while ('\0' != *src++);

  10.     return dest;
  11. }

  13. /* Copy SRC to DEST. */
  14. char *
  15. my_strcpy2 (dest, src)
  16.      char *dest;
  17.      const char *src;
  18. {
  19.   register char c;
  20.   char * s = (char *)src;
  21.   const int off = dest - s - 1;

  23.   do
  24.     {
  25.       c = *s++;
  26.       s[off] = c;
  27.     }
  28.   while (c != '\0');

  30.   return dest;
  31. }

  33. int main()
  34. {
  35.     const char *str1 = "test1";
  36.     const char *str2 = "test2";
  37.     char buf[100];

  39.     int i;
  40.     for (i = 0; i < 10000000; ++i) {
  41.         my_strcpy1(buf, str1);
  42.         my_strcpy1(buf, str2);
  43.     }
  44.     
  45.     return 0;
  46. }
当调用my_strcpy1时，其结果如下：
  1. [xxx@xxx-vm-fc13 test]$ time ./a.out

  3. real 0m0.373s
  4. user 0m0.369s
  5. sys 0m0.004s
  6. [xxx@xxx-vm-fc13 test]$ time ./a.out

  8. real 0m0.374s
  9. user 0m0.368s
  10. sys 0m0.004s
  11. [xxx@xxx-vm-fc13 test]$ time ./a.out

  13. real 0m0.373s
  14. user 0m0.369s
  15. sys 0m0.004s
使用消耗在用户态的时间，三次的平均时间为0.369s

当调用my_strcpy2时，其结果如下：
  1. [xxx@xxx-vm-fc13 test]$ time ./a.out

  3. real 0m0.387s
  4. user 0m0.383s
  5. sys 0m0.004s
  6. [xxx@xxx-vm-fc13 test]$ time ./a.out

  8. real 0m0.385s
  9. user 0m0.380s
  10. sys 0m0.004s
  11. [xxx@xxx-vm-fc13 test]$ time ./a.out

  13. real 0m0.386s
  14. user 0m0.380s
  15. sys 0m0.004s
同样取用户态的平均时间为0.381s。


看到这里，出乎了我的意料，因为C库的实现按理说应该更高效才对啊，但是事实不是这样。那么再次对比上面的代码，发现一个问题。my_strcpy1没有考虑到src和dest指向同一内存地址的情况，而glibc的代码my_strcpy2却没有问题——尽管在应用中，也不应该有这样的需求，strcpy的两个参数指向同一内存地址，但是作为一个库函数来说，必然却要做这样的考虑。Ok，那么修改my_strcpy1的代码，使其同样支持src和dest指向同一地址。
  1. char* my_strcpy1(char *dest, const char *src)
  2. {
  3.     char *d = dest;
  4.     register char c;
  5.     
  6.     do {
  7.         c = *src++;
  8.         *d++ = c;
  9.     } while ('\0' != c);

  11.     return dest;
  12. }

  14. /* Copy SRC to DEST. */
  15. char *
  16. my_strcpy2 (dest, src)
  17.      char *dest;
  18.      const char *src;
  19. {
  20.   register char c;
  21.   char * s = (char *)src;
  22.   const int off = dest - s - 1;

  24.   do
  25.     {
  26.       c = *s++;
  27.       s[off] = c;
  28.     }
  29.   while (c != '\0');

  31.   return dest;
  32. }

  34. int main()
  35. {
  36.     const char *str1 = "test1";
  37.     const char *str2 = "test2";
  38.     char buf[100];

  40.     int i;
  41.     for (i = 0; i < 10000000; ++i) {
  42.         my_strcpy1(buf, str1);
  43.         my_strcpy1(buf, str2);
  44.     }
  45.     
  46.     return 0;
  47. }
结果如下：
  1. [xxx@xxx-vm-fc13 test]$ time ./a.out

  3. real 0m0.321s
  4. user 0m0.318s
  5. sys 0m0.003s
  6. [xxx@xxx-vm-fc13 test]$ time ./a.out

  8. real 0m0.296s
  9. user 0m0.291s
  10. sys 0m0.003s
  11. [xxx@xxx-vm-fc13 test]$ time ./a.out

  13. real 0m0.321s
  14. user 0m0.320s
  15. sys 0m0.000s
这个版本的my_strcpy1增加了一个临时变量更高效了。这有些困惑啊。这让我搞不明白为什么C库要这样实现了。即使为了保证src不变，再引入一个新的局部变量
  1. char* my_strcpy1(char *dest, const char *src)
  2. {
  3.     const char *s = src;
  4.     char *d = dest;
  5.     register char c;
  6.     
  7.     do {
  8.         c = *s++;
  9.         *d++ = c;
  10.     } while ('\0' != c);

  12.     return dest;
  13. }
测试的结果仍然优于C库的实现。


那么C库究竟为什么要用偏移的方式来设置dest的内容呢？

上一篇：gcc 优化选项 -O1 -O2 -O3 -Os 优先级，-fomit-frame-pointer .
下一篇：[z]手把手教你玩转GDB(二)——Breakpoint, Watchpoint和Catchpoin