calloc函数的效率

aero

昨天上网，看到一些代码用calloc函数写的。申请内存的函数，平时不常用。因为不常用，所以见了便想它为什么不常用呢？是不是它和malloc+memset函数的效率有差别啊？所以写了验证程序，一看，果然如此，calloc函数的效率要比malloc+memset函数的效率低一点。测试如下：

环境：

1. 
   
2. Red Hat Linux release 8.0 (Psyche)
   
3. Kernel 2.4.18-14smp on an i686
   
4. login: yangwl
   
5. Password:
   

复制代码

测试办法：用calloc函数申请100个字节的空间，申请1亿次，记时。用malloc+memset函数完成同样的工作，记时。比较两次记时的大小。

自己猜想后简单的测试代码及结果：

1. 
   
2. [yangwl:/home/users50/yangwl/test]$ cat time.c
   
3. #include <stdio.h>;
   
4. #include <stdlib.h>;
   
5. #include <time.h>;
   
6. #include <string.h>;
   
7. 
   
8. int main(void) {
   
9.         int     i;
   
10.         char    *p;
    
11.         time_t  t;
    
12. 
    
13.         t = time(0);
    
14.         printf("begin...\n");
    
15.         for ( i = 0; i < 100000000; i++) {
    
16. #ifdef CA
    
17.                 p = (char *)calloc(100,sizeof(char));
    
18. #endif
    
19. #ifdef MA
    
20.                 p = (char *)malloc(100*sizeof(char));
    
21.                 memset(p,0,100);
    
22. #endif
    
23.                 if ( p == NULL ) {
    
24.                         printf("calloc error!\n");
    
25.                         exit(1);
    
26.                 }
    
27.                 free(p);
    
28.         }
    
29.         t = time(0) - t;
    
30.         printf("%ld\n",t);
    
31.         exit(0);
    
32. }
    
33. [yangwl:/home/users50/yangwl/test]$ gcc -o ca time.c -O2 -DCA
    
34. [yangwl:/home/users50/yangwl/test]$ gcc -o ma time.c -O2 -DMA
    
35. [yangwl:/home/users50/yangwl/test]$ ./ca
    
36. begin...
    
37. 33
    
38. [yangwl:/home/users50/yangwl/test]$ ./ma
    
39. begin...
    
40. 32
    
41. [yangwl:/home/users50/yangwl/test]$ ./ca
    
42. begin...
    
43. 33
    
44. [yangwl:/home/users50/yangwl/test]$ ./ma
    
45. begin...
    
46. 31
    
47. [yangwl:/home/users50/yangwl/test]$ ./ca
    
48. begin...
    
49. 34
    
50. [yangwl:/home/users50/yangwl/test]$ ./ma
    
51. begin...
    
52. 32
    
53. [yangwl:/home/users50/yangwl/test]$
    

复制代码

怕自己因为测的次数少，结果不正确，所以写一个长期测试的程序，下班放在服务器上运行。将结果写入文件，测试代码及结果如下：

1. 
   
2. [yangwl:/home/users50/yangwl/test]$ cat time.c
   
3. #include <stdio.h>;
   
4. #include <stdlib.h>;
   
5. #include <time.h>;
   
6. #include <string.h>;
   
7. 
   
8. time_t ma(FILE *);
   
9. time_t ca(FILE *);
   
10. 
    
11. int main(void) {
    
12.         int     i,
    
13.                 count = 0,
    
14.                 true = 0,
    
15.                 false = 0;
    
16.         time_t  t,
    
17.                 tmp;
    
18.         struct tm       *tforp;
    
19.         FILE    *fp1,*fp2;
    
20. 
    
21.         fp1 = fopen("./log1","w");
    
22.         if ( fp1 == NULL ) {
    
23.                 printf("log1 open error!\n");
    
24.                 exit(1);
    
25.         }
    
26. 
    
27.         fp2 = fopen("./log2","w");
    
28.         if ( fp2 == NULL ) {
    
29.                 printf("log2 open error!\n");
    
30.                 exit(1);
    
31.         }
    
32. 
    
33.         t = time(0);
    
34.         tforp = localtime(&t);
    
35. 
    
36.         fprintf(fp1,"begin time:%d-%d-%d %d:%d:%d\n",tforp->;tm_year+1900,tforp->;tm_mon+1,tforp->;tm_mday,
    
37.                                                      tforp->;tm_hour,tforp->;tm_min,tforp->;tm_sec);
    
38. 
    
39.         fprintf(fp2,"begin time:%d-%d-%d %d:%d:%d\n",tforp->;tm_year+1900,tforp->;tm_mon+1,tforp->;tm_mday,
    
40.                                                      tforp->;tm_hour,tforp->;tm_min,tforp->;tm_sec);
    
41. 
    
42.         for ( i = 0; i < 10*60; i++ ) {
    
43.                 tmp = ca(fp2)-ma(fp2);
    
44.                 fprintf(fp2," %ld",tmp);
    
45.                 tmp >; 0 ? true++ : false++;
    
46.                 count++;
    
47.         }
    
48. 
    
49.         fprintf(fp1,"true:%d\nfalse:%d\ncount:%d\n",true,false,count);
    
50. 
    
51.         t = time(0);
    
52.         tforp = localtime(&t);
    
53. 
    
54.         fprintf(fp1,"end time:%d-%d-%d %d:%d:%d\n",tforp->;tm_year+1900,tforp->;tm_mon+1,tforp->;tm_mday,
    
55.                                                      tforp->;tm_hour,tforp->;tm_min,tforp->;tm_sec);
    
56. 
    
57.         fprintf(fp2,"end time:%d-%d-%d %d:%d:%d\n",tforp->;tm_year+1900,tforp->;tm_mon+1,tforp->;tm_mday,
    
58.                                                      tforp->;tm_hour,tforp->;tm_min,tforp->;tm_sec);
    
59. 
    
60.         fclose(fp1);
    
61.         fclose(fp2);
    
62. 
    
63.         exit(0);
    
64. }
    
65. 
    
66. time_t ma(FILE *fp2) {
    
67.         int     i;
    
68.         char    *p;
    
69.         time_t  t;
    
70. 
    
71.         t = time(0);
    
72.         for ( i = 0; i < 100000000; i++) {
    
73.                 p = (char *)malloc(100*sizeof(char));
    
74.                 memset(p,0,100);
    
75.                 if ( p == NULL ) {
    
76.                         fprintf(fp2,"calloc error!\n");
    
77.                         exit(1);
    
78.                 }
    
79.                 free(p);
    
80.         }
    
81.         t = time(0)-t;
    
82. 
    
83.         return t;
    
84. }
    
85. 
    
86. time_t ca(FILE *fp2) {
    
87.         int     i;
    
88.         char    *p;
    
89.         time_t  t;
    
90. 
    
91.         t = time(0);
    
92. 
    
93.         for ( i = 0; i < 100000000; i++) {
    
94.                 p = (char *)calloc(100,sizeof(char));
    
95.                 if ( p == NULL ) {
    
96.                         fprintf(fp2,"calloc error!\n");
    
97.                         exit(1);
    
98.                 }
    
99.                 free(p);
    
100.         }
     
101.         t = time(0)-t;
     
102. 
     
103.         return t;
     
104. }
     
105. [yangwl:/home/users50/yangwl/test]$ cat log1
     
106. begin time:104-8-8 19:19:22
     
107. true:586
     
108. false:14
     
109. count:600
     
110. end time:70-0-1 21:1:21
     
111. [yangwl:/home/users50/yangwl/test]$ cat log2
     
112. begin time:104-8-8 19:19:22
     
113. 2 2 1 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 1 0 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 1 0 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 1 0 2 2 2 2 2 2 1 2 2 2 2 2 2 1 2 2 2 2 2 2 1 2 2 2 2 2 2 1 2 1 2 1 2 1 2 2 2 2 2 1 0 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 1 0 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 1 0 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 1 0 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 1 0 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 1 0 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 1 0 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 1 2 2 2 2 2 1 2 2 2 2 2 1 0 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 1 0 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 1 0 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 1 0 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1 2 2 2 2 2 2 2 1end time:70-0-1 21:1:21
     
114. [yangwl:/home/users50/yangwl/test]$
     

复制代码

结果：果然calloc函数的效率要稍微低一点，平均差2sec，少数差1sec，极少可以做到几乎不差。要注意，结果只能精确到sec。

猜想原因：有一个很明显的能看出来的差别是，calloc函数要在函数运行中计算总共开辟多大空间。而malloc函数的参数只有一个，在上面的程序钟，这个参数是一个可以在编译的过程中就确定大小的表达式，因此能事先确定开辟空间的大小。但是，性能的差别仅仅在于一个乘法操作吗？

bug：呵呵，大家可以看出来，log文件中的日期时间有问题。是因为忘记了localtime的用法，以及取时间语句的一个错误，昨天着急写程序所致，不过并不影响结果。

意外：本来一次循环应该耗时1分多钟，所以我定了600次循环，本来以为可以让它运行一晚上，结果看log，2个小时不到就结束了，不知道为什么，是服务器在晚上的运算速度提高了？还是经常性的“分配”“释放”，系统的内存管理机制习惯了这样的动作导致“熟能生巧”了？[/code]

JohnBull

...而malloc函数可以在编译的过程中就确定开辟空间的大小。

不是这样的.

aero

原帖由 "JohnBull" 发表：

不是这样的.

怎么不是呢？

calloc(100,sizeof(char))是一定要做一个100*sizeof(char)的动作的，而
malloc(100*sizeof(char))里面，不是可以在编译的时候就确定sizeof的值，而且将100*1这样的算式直接优化成100这个值吗？好像编译器都有这样的优化吧？

ljttlf

>;>; 系统的内存管理机制习惯了这样的动作导致“熟能生巧”了

我来帮你解释吧。

因为局部引用的特性 和 cpu的高速缓存的作用。它高速缓存了指令和数据，如果命中都是在一级缓存的话，该缓存的速度和cpu是一样的，如果是二级缓存命中的话，二级缓存速度是cpu的一半。不管怎么样，还是比没有缓存命中的速度高很多。经过长时间运行，高速缓存算法淘汰了其他进程的缓存，可以认为，长时间运行时，缓存的都是这个进程的数据和代码。

也可能还有mmu的TLB寄存器起作用，开始访问数据和代码的时候是需要经过mmu进行虚拟地址到物理地址的转换，运行一段时间以后，这些地址已经保存在了TLB里面，它也是和cpu等速度的。一旦高速缓存中没有命中，也不需要付出地址变换的代价。

还有就是存储器替换算法的作用，因为开始运行的时候，内存中的进程比较多，一次分配大存储空间是需要较长时间查找，因为可能有内存碎片，如果还没有找到你需要的大空间的话，OS会选择替换内存数据，直到找到符合请求的内存。

而长时间运行后，一些进程OS会将他交换出物理内存，这样的话，就可以组成更大的空闲空间，os在进行内存分配请求的时候就不需要花很多时间来进行查找。

所以“熟能生巧”

aero

[quote]原帖由 "ljttlf"]是的，因为局部引用的特性 和 cpu的高速缓存的作用。它高速缓存了指令和数据，如果命中都是在一级缓存的话，该缓存的速度和cpu是一样的，如果是二级缓存命中的话，二级缓存速度是cpu的一半。不管怎么样，还是比没有?.........[/quote 发表：


^_^，对，对，就是这样，偶想的不深入，谢谢ljttlf兄了，上学学的东西全忘了。

ljttlf

呵呵，大家学习

iLesiwo

看了ljttlf的解释，对为什么总体运行时间少了有了一点认识。
可是，关于为什么calloc没有melloc＋memset快还是没有解开，继续聆听，期待中……

JohnBull

[quote]原帖由 "aero" 发表：


怎么不是呢？

calloc(100,sizeof(char))是一定要做一个100*sizeof(char)的动作的，而
malloc(100*sizeof(char))里面，不是可以在编译的时候就确定sizeof的值，而且将100*1这样的算式直接优化成100这个值吗？

aero

呵呵，谢谢JohnBull老大。自己表述的有问题呢。^_^。改过来了。

思一克

没有乘法操作。
100*sizeof(char)是个常数=100，在编译时就确定。