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

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

 #include <sys/time.h>

 /* 测试数据大小 */
 #define SIZE_1K 1024
 #define SIZE_10K 1024*10
 #define SIZE_100K 1024*100
 #define SIZE_1M 1024*1024


 /* 1M数据*/
 void test_1M(void)
 {
     struct timeval start;
     struct timeval end;
     int ret_start = -1;
     int ret_end = -1;

     char src[SIZE_1M];
     char dst[SIZE_1M];

     int i;
     long delta_time;

     /* 测试开始 */
     ret_start = gettimeofday(&start, NULL);
     for ( i = 0; i< 1000; ++i )
     {
         memcpy(src, dst, SIZE_1M);
     }
     ret_end = gettimeofday(&end, NULL);

     /* 测试结束,确保函数执行成功 */
     if ( ret_start != 0 || ret_end != 0 )
     {
         exit( -1 );
     }

     /* 输出测试结果 */
     delta_time = (end.tv_sec* 1000000 + end.tv_usec) - (start.tv_sec * 1000000 + start.tv_usec);
     fprintf(stderr, "SIZE_1M, \t\t%ldus\n", delta_time);
 }

 /* 100K数据*/
 void test_100k(void)
 {
     struct timeval start;
     struct timeval end;
     int ret_start = -1;
     int ret_end = -1;

     char src[SIZE_100K];
     char dst[SIZE_100K];

     int i;
     long delta_time;

     /* 测试开始 */
     ret_start = gettimeofday(&start, NULL);
     for ( i = 0; i< 1000; ++i )
     {
         memcpy(src, dst, SIZE_100K);
     }
     ret_end = gettimeofday(&end, NULL);

     /* 测试结束,确保函数执行成功 */
     if ( ret_start != 0 || ret_end != 0 )
     {
         exit( -1 );
     }

     /* 输出测试结果 */
     delta_time = (end.tv_sec* 1000000 + end.tv_usec) - (start.tv_sec * 1000000 + start.tv_usec);
     fprintf(stderr, "SIZE_100K, \t\t%ldus\n", delta_time);
 }

 /* 10K数据*/
 void test_10k(void)
 {
     struct timeval start;
     struct timeval end;
     int ret_start = -1;
     int ret_end = -1;

     char src[SIZE_10K];
     char dst[SIZE_10K];

     int i;
     long delta_time;

     /* 测试开始 */
     ret_start = gettimeofday(&start, NULL);
     for ( i = 0; i< 1000; ++i )
     {
         memcpy(src, dst, SIZE_10K);
     }
     ret_end = gettimeofday(&end, NULL);

     /* 测试结束,确保函数执行成功 */
     if ( ret_start != 0 || ret_end != 0 )
     {
         exit( -1 );
     }

     /* 输出测试结果 */
     delta_time = (end.tv_sec* 1000000 + end.tv_usec) - (start.tv_sec * 1000000 + start.tv_usec);
     fprintf(stderr, "SIZE_10k, \t\t%ldus\n", delta_time);
 }

 /* 1K数据*/
 void test_1k(void)
 {
     struct timeval start;
     struct timeval end;
     int ret_start = -1;
     int ret_end = -1;

     char src[SIZE_1K];
     char dst[SIZE_1K];

     int i;
     long delta_time;

     /* 测试开始 */
     ret_start = gettimeofday(&start, NULL);
     for ( i = 0; i< 1000; ++i )
     {
         memcpy(src, dst, SIZE_1K);
     }
     ret_end = gettimeofday(&end, NULL);

     /* 测试结束,确保函数执行成功 */
     if ( ret_start != 0 || ret_end != 0 )
     {
         exit( -1 );
     }

     /* 输出测试结果 */
     delta_time = (end.tv_sec* 1000000 + end.tv_usec) - (start.tv_sec * 1000000 + start.tv_usec);
     fprintf(stderr, "SIZE_1k, \t\t%ldus\n", delta_time);
 }

 int main(int argc, char **argv)
 {

     test_1k();

     test_10k();

     test_100k();

     test_1M();

     return 0;
 }

测试结果：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

阅读(3146) | 评论(4) | 转发(3) |

0

上一篇：WIRESHARK之SSL解密

下一篇：缓存小结

相关热门文章

• socket中的短连接与长连接,心...
• Haproxy、Keepalived双主高可...
• Tomcat的性能与最大并发(1000)...
• Nginx深入详解之日志
• socket编程的同步、异步与阻塞...

• linux dhcp peizhi roc
• 关于Unix文件的软链接
• 求教这个命令什么意思，我是新...
• sed -e "/grep/d" 是什么意思...
• 谁能够帮我解决LINUX 2.6 10...

给主人留下些什么吧！~~

tanningzhong2013-05-31 14:25:29

楼主不是test 1K的数据么？ 怎么还得循环拷贝一千次？

回复 | 举报

ckelsel2013-05-07 10:46:54

pxy052152：楼主没有考虑cache的影响，这个测试是有问题的。

确实没考虑到，这个是DEMO版，还需要继续优化

回复 | 举报

pxy0521522013-05-07 09:02:06

楼主没有考虑cache的影响，这个测试是有问题的。

回复 | 举报

firecityplans2013-05-06 19:30:31

学习了。

回复 | 举报

评论热议