memcpy性能测试

存在的问题

1。测试结果以微秒为单位，明显不靠谱
2.gettimeofday精度不足，对高精度需要用汇编改写
3.存在cache缓存，建议测试时尽量模拟真实环境

至少存在以上三个问题，不知道为什么会被搞成“推荐文章”，

1。堆、栈中的内存区别
不同点：
堆内存是malloc分配的，直到程序结束或用free释放
栈内存是函数局部变量或参数，函数结束则自动释放
相同点：
二者都存在于内存中，对于memcpy的测试没影响，因此使用栈内存方便。
2。测试的开始，结束边界
t1 = time1;
for ( ... ) {
memcpy(...);
}
t2 = time2;
delta = t2 - t1;
3。char[1024]的大小
1)位（比特)，bit，表示0或1，速率 （bps)bits per second
2）字节，byte, 1byte = 8bits，速率(Bps)Byte per second
56Kbps拨号上网的速度是7 byte/s
char是8位，1个字节，char[1024]就是1024个字节，也就是1KB
32位系统，int是32位，4个字节大小
4。多组数据测试，1K，10K，100K，1M
1K,char[1024];
10K,char[1024*10];
100K,char[1024*100];
1M,char[1024*1024];
5。GCC优化级别，-O0，-O1，-O2，-O3，-O，-Os
-O0，不做优化
-O1,-O，减少编译后的代码大小和执行时间（reduce code size and execution time）
-O2，在-O1的基础上，增加编译时间和生成的代码的性能
-O3，在-O2的基础上，还加了剩下的几个优化选项
-Os，在-O2的基础上，但是生成的代码比-O2小
由于发行版的程序肯定会做优化，因此测试程序使用-O2
详见文章末尾的参考资料
6。GCC版本
gcc-4.4.1

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. 
   
5. #include <sys/time.h>
   
6. 
   
7. /* 测试数据大小 */
   
8. #define SIZE_1K 1024
   
9. #define SIZE_10K 1024*10
   
10. #define SIZE_100K 1024*100
    
11. #define SIZE_1M 1024*1024
    
12. 
    
13. 
    
14. /* 1M数据*/
    
15. void test_1M(void)
    
16. {
    
17.     struct timeval start;
    
18.     struct timeval end;
    
19.     int ret_start = -1;
    
20.     int ret_end = -1;
    
21. 
    
22.     char src[SIZE_1M];
    
23.     char dst[SIZE_1M];
    
24. 
    
25.     int i;
    
26.     long delta_time;
    
27. 
    
28.     /* 测试开始 */
    
29.     ret_start = gettimeofday(&start, NULL);
    
30.     for ( i = 0; i< 1000; ++i )
    
31.     {
    
32.         memcpy(src, dst, SIZE_1M);
    
33.     }
    
34.     ret_end = gettimeofday(&end, NULL);
    
35. 
    
36.     /* 测试结束,确保函数执行成功 */
    
37.     if ( ret_start != 0 || ret_end != 0 )
    
38.     {
    
39.         exit( -1 );
    
40.     }
    
41. 
    
42.     /* 输出测试结果 */
    
43.     delta_time = (end.tv_sec* 1000000 + end.tv_usec) - (start.tv_sec * 1000000 + start.tv_usec);
    
44.     fprintf(stderr, "SIZE_1M, \t\t%ldus\n", delta_time);
    
45. }
    
46. 
    
47. /* 100K数据*/
    
48. void test_100k(void)
    
49. {
    
50.     struct timeval start;
    
51.     struct timeval end;
    
52.     int ret_start = -1;
    
53.     int ret_end = -1;
    
54. 
    
55.     char src[SIZE_100K];
    
56.     char dst[SIZE_100K];
    
57. 
    
58.     int i;
    
59.     long delta_time;
    
60. 
    
61.     /* 测试开始 */
    
62.     ret_start = gettimeofday(&start, NULL);
    
63.     for ( i = 0; i< 1000; ++i )
    
64.     {
    
65.         memcpy(src, dst, SIZE_100K);
    
66.     }
    
67.     ret_end = gettimeofday(&end, NULL);
    
68. 
    
69.     /* 测试结束,确保函数执行成功 */
    
70.     if ( ret_start != 0 || ret_end != 0 )
    
71.     {
    
72.         exit( -1 );
    
73.     }
    
74. 
    
75.     /* 输出测试结果 */
    
76.     delta_time = (end.tv_sec* 1000000 + end.tv_usec) - (start.tv_sec * 1000000 + start.tv_usec);
    
77.     fprintf(stderr, "SIZE_100K, \t\t%ldus\n", delta_time);
    
78. }
    
79. 
    
80. /* 10K数据*/
    
81. void test_10k(void)
    
82. {
    
83.     struct timeval start;
    
84.     struct timeval end;
    
85.     int ret_start = -1;
    
86.     int ret_end = -1;
    
87. 
    
88.     char src[SIZE_10K];
    
89.     char dst[SIZE_10K];
    
90. 
    
91.     int i;
    
92.     long delta_time;
    
93. 
    
94.     /* 测试开始 */
    
95.     ret_start = gettimeofday(&start, NULL);
    
96.     for ( i = 0; i< 1000; ++i )
    
97.     {
    
98.         memcpy(src, dst, SIZE_10K);
    
99.     }
    
100.     ret_end = gettimeofday(&end, NULL);
     
101. 
     
102.     /* 测试结束,确保函数执行成功 */
     
103.     if ( ret_start != 0 || ret_end != 0 )
     
104.     {
     
105.         exit( -1 );
     
106.     }
     
107. 
     
108.     /* 输出测试结果 */
     
109.     delta_time = (end.tv_sec* 1000000 + end.tv_usec) - (start.tv_sec * 1000000 + start.tv_usec);
     
110.     fprintf(stderr, "SIZE_10k, \t\t%ldus\n", delta_time);
     
111. }
     
112. 
     
113. /* 1K数据*/
     
114. void test_1k(void)
     
115. {
     
116.     struct timeval start;
     
117.     struct timeval end;
     
118.     int ret_start = -1;
     
119.     int ret_end = -1;
     
120. 
     
121.     char src[SIZE_1K];
     
122.     char dst[SIZE_1K];
     
123. 
     
124.     int i;
     
125.     long delta_time;
     
126. 
     
127.     /* 测试开始 */
     
128.     ret_start = gettimeofday(&start, NULL);
     
129.     for ( i = 0; i< 1000; ++i )
     
130.     {
     
131.         memcpy(src, dst, SIZE_1K);
     
132.     }
     
133.     ret_end = gettimeofday(&end, NULL);
     
134. 
     
135.     /* 测试结束,确保函数执行成功 */
     
136.     if ( ret_start != 0 || ret_end != 0 )
     
137.     {
     
138.         exit( -1 );
     
139.     }
     
140. 
     
141.     /* 输出测试结果 */
     
142.     delta_time = (end.tv_sec* 1000000 + end.tv_usec) - (start.tv_sec * 1000000 + start.tv_usec);
     
143.     fprintf(stderr, "SIZE_1k, \t\t%ldus\n", delta_time);
     
144. }
     
145. 
     
146. int main(int argc, char **argv)
     
147. {
     
148.     
     
149.     test_1k();
     
150. 
     
151.     test_10k();
     
152. 
     
153.     test_100k();
     
154. 
     
155.     test_1M();
     
156. 
     
157.     return 0;
     
158. }

测试结果：1000拷贝操作所消耗的时间

SIZE_1k,                350us
SIZE_10k,               5502us
SIZE_100K,              96624us
SIZE_1M,                689399us

参考：
http://gcc.gnu.org/onlinedocs/gcc-4.4.1/gcc/Optimize-Options.html#Optimize-Options