Chinaunix首页 | 论坛 | 博客
  • 博客访问: 244460
  • 博文数量: 53
  • 博客积分: 1910
  • 博客等级: 中尉
  • 技术积分: 1130
  • 用 户 组: 普通用户
  • 注册时间: 2010-05-10 14:56
文章分类

全部博文(53)

文章存档

2013年(1)

2012年(17)

2011年(33)

2010年(2)

分类: C/C++

2011-09-01 00:50:25

三个函数做循环1000次执行,是分开循环快,还是一次循环快

大概代码的意思如下:

 

  1. A: (一次循环调用)
  2. for(i=0;i<1000;i++){
  3.   a_func();
  4.   b_func();
  5.   c_func();
  6. }
  7. ---------------------------
  8. B: (二次循环调用)
  9. for(i=0;i<1000;i++){
  10.   a_func();
  11. }

  12. for(i=0;i<1000;i++){
  13.   b_func();
  14. }

  15. for(i=0;i<1000;i++){
  16.   c_func();
  17. }

 

兄弟我第1反映两种操作的含义不同, 比如retry 机制,
A 表示a,b,c func 是一个序列,要么全部完成成功
B 却不同
但到底谁快,比较迷茫,
我得到的答案为B快,B 可以使用指令cache,
而A 不能

有点时间,写了个代码分析下,不要笑我无聊

现在如果假设A,B 两者意义相同的情况
测试代码如下:

 

  1. int a_func(int i)
  2. {
  3.     return i;
  4. }

  5. int b_func(int i)
  6. {
  7.     return i+1;
  8. }


  9. int main(void){
  10.     int i,j,k;

  11. #if 1

  12. struct timeval tpstart,tpend;
  13. float timeuse;
  14.         j=0;
  15.         k=0;
  16. gettimeofday(&tpstart,NULL);

  17.     for(i=0;i<1000;i++){
  18.         j+=a_func(i);
  19.         k+=b_func(i);
  20.     }
  21. gettimeofday(&tpend,NULL);
  22. timeuse=1000000*(tpend.tv_sec-tpstart.tv_sec)+
  23. tpend.tv_usec-tpstart.tv_usec;
  24. timeuse/=1000000;
  25. printf("Used Time:%f\n",timeuse);
  26.     
  27. #else

  28. struct timeval tpstart,tpend;
  29. float timeuse;
  30.         j=0;
  31.         k=0;

  32. gettimeofday(&tpstart,NULL);

  33.     for(i=0;i<1000;i++){
  34.         j+=a_func(i);
  35.     }
  36.     
  37.     for(i=0;i<1000;i++){
  38.         k+=b_func(i);
  39.     }
  40. gettimeofday(&tpend,NULL);
  41. timeuse=1000000*(tpend.tv_sec-tpstart.tv_sec)+
  42. tpend.tv_usec-tpstart.tv_usec;
  43. timeuse/=1000000;
  44. printf("Used Time:%f\n",timeuse);
  45.     

  46. #endif
  47.     printf("j=%d,k=%d\n",j,k); /* j=4950,k=5050 */
  48. }

使用gcc 编译测试结果如下
一次循环A:
输出结果:
Used Time:0.000008
j=499500,k=500500

real    0m0.001s
user    0m0.000s
sys     0m0.001s

二次循环B:
Used Time:0.000010
j=499500,k=500500

real    0m0.001s
user    0m0.000s
sys     0m0.000s


从time 统计来看,时间差不多
而代码中计算来看好象A 更快

下面看下上面的汇编:
A:(一次循环调用)

 

B:(二次循环调用)

 

从汇编部分看:
B 中
cmp ptr [ebp-14h],3e7h
add ptr [ebp-14h] ,1
这两条被多执行了1000次

那么一共2000次

所以实际执行反而,A 更快

 

找了块arm11 的板执行上面代码

A:(一次循环调用)


B:(二次循环调用)


看来也是A 快


arm 的汇编,也差不多,只是i=0 会单独执行下

然后执行 也是cmp 指令循环 999次

A:(一次循环调用)

B:(二次循环调用)

 

比如arm gcc 中对循环总是先做1次,然后再循环,不论改为while ,goto 反汇编的代码都是这样

所以如果到了一两条指令都要计较的的时候,要快,那么可以自己根据循环代码反汇编来自己写汇编优化

将机器编译的代码中冗余部分去掉,毕竟是编译器要考虑的东西太多

 

无聊的分析下,如果无聊可以无聊的看下

 

 

阅读(574) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
评论热议
请登录后评论。

登录 注册