为什么C++11的lambda演算速度比用functor还要慢?

zuiwei

我想对比一下lambda演算的性能，和以前自己写一个functor的时候的性能。哪一个更高。
自己写一个functor来调用类的函数，需要我在functor构造的时候把类函数地址和参数地址都存下来，然后operator()的时候再调用类对象。这样会产生一个开销，就是要存储这些参数，然后按照指针的方式来调用。
functor用了1281ms
lambda用了1328ms

可是我发现用lambda演算的时候，时间需要的更长。VC2010 sp1编译，代码如下。
这是为什么呢?

1. 
   
2. #include"stdafx.h"
   
3. #include<iostream>
   
4. #include<string>
   
5. #include<vector>
   
6. #include<functional>
   
7. #include<algorithm>
   
8. #include<Windows.h>
   
9. using namespace std;
   
10. template<class C, class T1, class T2>
    
11. class Pred2Vars{
    
12. public:
    
13.     typedef void (C::*PredPtr)( T1, T2 );
    
14. 
    
15.     Pred2Vars( T1 p1, T2 p2, PredPtr pPred ) :
    
16.         m_p1( p1 ),m_p2( p2 ),m_pPred( pPred ){}
    
17. 
    
18.     void operator()( C* pObject )    {
    
19.         ((*pObject).*m_pPred)( m_p1, m_p2 );
    
20.     }
    
21. private:
    
22.     T1 m_p1;
    
23.     T2 m_p2;
    
24.     PredPtr m_pPred;
    
25. };
    
26. 
    
27. struct s{
    
28.         void f2(int a,int b){
    
29.                 i+=a;
    
30.                 i+=b;
    
31.         }
    
32.         void f7(int i1,int i2,int i3,int i4,int i5,int i6,int i7){
    
33.                 i+=i1;
    
34.                 i+=i2;
    
35.                 i+=i3;
    
36.                 i+=i4;
    
37.                 i+=i5;
    
38.                 i+=i6;
    
39.                 i+=i7;
    
40.         }
    
41.         int i;
    
42.         s():i(0){}
    
43. };
    
44. typedef void (s::*psf)(int,int);
    
45. int main(int argc, char *argv[])
    
46. {
    
47.         const int l=100000000;
    
48.         s* ps=new s[l];
    
49.         vector<s*> vps;
    
50.         for(int i=0;i<l;++i){
    
51.                 ps[i].i=1;
    
52.                 vps.push_back(&ps[i]);
    
53.         }
    
54.         volatile int i=2;
    
55.         volatile int j=i+1;
    
56.     {//2605
    
57.                 DWORD ret1=GetTickCount();
    
58.                 std::for_each(vps.begin(),vps.end(),
    
59.                         Pred2Vars<s,int,int>(i,j,&s::f2));
    
60.                 DWORD ret2=GetTickCount();
    
61.                 printf("%d\n",ret2-ret1);
    
62.         }
    
63.         {//2574
    
64.                 DWORD ret1=GetTickCount();
    
65.                 std::for_each(vps.begin(),vps.end(),[&](s* ps){ps->f2(i,j);});
    
66.                 DWORD ret2=GetTickCount();
    
67.                 printf("%d\n",ret2-ret1);
    
68.         }
    
69.         delete[] ps;
    
70.     return EXIT_SUCCESS;
    
71. }

复制代码

zuiwei

我现在是VC2010编译release版开了/O2，我测试了一下7个参数的情况，发现还是functor比lamdba快:
代码如下: functor运行781ms,lambda运行860ms。我交换了运行的顺序，发现结果不变。
这又是为什么呢?

1. 
   
2. #include"stdafx.h"
   
3. #include<iostream>
   
4. #include<string>
   
5. #include<vector>
   
6. #include<functional>
   
7. #include<algorithm>
   
8. #include<Windows.h>
   
9. using namespace std;
   
10. 
    
11. template<class C, class T1, class T2, class T3, class T4, class T5, class T6, class T7>class Pred7Var
    
12. {
    
13. public:
    
14.     typedef void (C::*PredPtr)( T1, T2, T3, T4, T5, T6, T7 );
    
15. 
    
16.     Pred7Var( T1 p1, T2 p2, T3 p3, T4 p4, T5 p5, T6 p6, T7 p7, PredPtr pPred ) :
    
17.     m_p1( p1 ),
    
18.         m_p2( p2 ),
    
19.         m_p3( p3 ),
    
20.         m_p4( p4 ),
    
21.         m_p5( p5 ),
    
22.         m_p6( p6 ),
    
23.         m_p7( p7 ),
    
24.         m_pPred( pPred ){}
    
25. 
    
26.     void operator()( C* pObject )
    
27.     {
    
28.         ((*pObject).*m_pPred)( m_p1, m_p2, m_p3, m_p4, m_p5, m_p6, m_p7 );
    
29.     }
    
30. 
    
31. private:
    
32.     T1 m_p1;
    
33.     T2 m_p2;
    
34.     T3 m_p3;
    
35.     T4 m_p4;
    
36.     T5 m_p5;
    
37.     T6 m_p6;
    
38.     T7 m_p7;
    
39.     PredPtr m_pPred;
    
40. };
    
41. struct s{
    
42.      void f2(int a,int b){
    
43.          i+=a;
    
44.          i+=b;
    
45.      }
    
46.      void f7(int i1,int i2,int i3,int i4,int i5,int i6,int i7){
    
47.          i+=i1;
    
48.          i+=i2;
    
49.          i+=i3;
    
50.          i+=i4;
    
51.          i+=i5;
    
52.          i+=i6;
    
53.          i+=i7;
    
54.      }
    
55.      int i;
    
56.      s():i(0){}
    
57. };
    
58. int main(int argc, char *argv[])
    
59. {
    
60.         const int l=100000000;
    
61.         s* ps=new s[l];
    
62.         vector<s*> vps;
    
63.         for(int i=0;i<l;++i){
    
64.                 ps[i].i=1;
    
65.                 vps.push_back(&ps[i]);
    
66.         }
    
67.         volatile int i=2;
    
68.         volatile int j=i+1;
    
69. 
    
70. 
    
71.         {
    
72.                 DWORD ret1=GetTickCount();
    
73.                 std::for_each(vps.begin(),vps.end(),
    
74.                         Pred7Var<s,int,int,int,int,int,int,int>(i,j,i,j,i,j,i,&s::f7));
    
75.                 DWORD ret2=GetTickCount();
    
76.                 printf("%d\n",ret2-ret1);
    
77.         }       
    
78.         {
    
79.                 DWORD ret1=GetTickCount();
    
80.                 std::for_each(vps.begin(),vps.end(),[&](s* ps){ps->f7(i,j,i,j,i,j,i);});
    
81.                 DWORD ret2=GetTickCount();
    
82.                 printf("%d\n",ret2-ret1);
    
83.         }
    
84.     delete[] ps;
    
85.     return EXIT_SUCCESS;
    
86. }
    

复制代码

AD8018

gcc 4.6.2的测试结果, lambda完胜

第一段
718
452

第二段
1062
718

bruceteen

我只觉得你的代码很奇怪，尤其是那个 volatile。i 是 volatile，但你传给一个非volatile后，后者不会神奇的自动变为volatile，所以它根本没用
我把代码修了一下

1. #include <iostream>
   
2. #include <vector>
   
3. #include <algorithm>
   
4. #include <ctime>
   
5. using namespace std;
   
6. 
   
7. template<class C, class T1, class T2>
   
8. class Pred2Vars
   
9. {
   
10. public:
    
11.     typedef void (C::*PredPtr)( T1, T2 );
    
12. 
    
13.     Pred2Vars( T1 p1, T2 p2, PredPtr pPred ) : m_p1(p1),m_p2(p2),m_pPred(pPred)
    
14.     {
    
15.     }
    
16.     void operator()( C& Object )
    
17.     {
    
18.         (Object.*m_pPred)( m_p1, m_p2 );
    
19.     }
    
20. private:
    
21.     T1 m_p1;
    
22.     T2 m_p2;
    
23.     PredPtr m_pPred;
    
24. };
    
25. 
    
26. struct s
    
27. {
    
28.     int i;
    
29. 
    
30.     explicit s( int val=0 ) : i(val)
    
31.     {
    
32.     }
    
33. 
    
34.     void f2( int a,int b )
    
35.     {
    
36.         i += a;
    
37.         i += b;
    
38.     }
    
39.     void f7( int i1, int i2, int i3, int i4, int i5, int i6, int i7 )
    
40.     {
    
41.         i += i1;
    
42.         i += i2;
    
43.         i += i3;
    
44.         i += i4;
    
45.         i += i5;
    
46.         i += i6;
    
47.         i += i7;
    
48.     }
    
49. };
    
50. 
    
51. int main()
    
52. {
    
53.     const size_t len = 100000000;
    
54.     vector<s> vps( len, s(1) );
    
55. 
    
56.     const int i = 2;
    
57.     const int j = 3;
    
58.     {
    
59.         clock_t ret1 = clock();
    
60.         std::for_each( vps.begin(), vps.end(), Pred2Vars<s,int,int>(i,j,&s::f2) );
    
61.         clock_t ret2 = clock();
    
62.         cout << ret2-ret1 << endl;
    
63.     }
    
64.     {
    
65.         clock_t ret1 = clock();
    
66.         std::for_each( vps.begin(), vps.end(), [i,j](s& object){object.f2(i,j);} );
    
67.         clock_t ret2 = clock();
    
68.         cout << ret2-ret1 << endl;
    
69.     }
    
70. 
    
71.     return EXIT_SUCCESS;
    
72. }

复制代码

AD8018

volatile .. 看懂了，楼主就是要探索传值时，lambda有没比functor多了复制次数。

zuiwei

AD8018 发表于 2012-04-06 12:28
volatile .. 看懂了，楼主就是要探索传值时，lambda有没比functor多了复制次数。

是这个意思，但是看反汇编我又看不太懂。
不知道C++11有没有在实现层做规定，这个lambda有没有复制一次变量?

egmkang

lambda和functor应该是一样的效率
都可以被内联

sytpb

http://blog.csdn.net/cywosp/article/details/9379403