只为uC而生，uS成长历程3

辛昕

只为uC而生，uS成长历程3 [复制链接]

在决定了继续使用函数回调的机制实现 uSer和Apper之间通信的方法，在继续实现以前，我们先做一件很重要的事情。

我们来进行一次简单的 时间开销 测试。
因为使用的难易可以通过改进，但是时间开销却是一个硬性指标。

我们已经大致预见到，这样的函数回调数量不会少。（想想，i2c等时序都需要IO实现，所以这样的回调是非常多的，所以它的时间开销会产生致命性影响，不可不慎查。）

为了方便起见，我们采用一种不需要任何其他条件的方法，在debug模式下，通过比较 普通函数调用 和 通过函数指针调用函数 所用的时间差别。
因为我们只关心相对比例，所以我们不需要一个多么精确地计时器。

为此，一个最简单的实现方法是一个 定时中断。

我们也不采用复杂的uSer和Apper这种复杂的调用机制，而是最一般的做法。
以下是code:

1. void TestFun(void)
   
2. {
   
3. }
   
4. 
   
5. extern U16 Times;
   
6. void main(void)
   
7. {  
   
8.     static U16 i;
   
9.     void (*pTest)(void) = NULL;
   
10.    
    
11.     Timer_Initial();
    
12.    
    
13.     pTest = TestFun;
    
14.    
    
15.     while(1)
    
16.     {
    
17.         Times = 0;
    
18.         for(i = 0;i < 5000;i++)
    
19.             //TestFun();
    
20.             (*pTest)();
    
21.         i = 0;  // for breakpoint here.
    
22.     }

复制代码

1. U16 Times = 0;
   
2. 
   
3. #pragma vector=0xF
   
4. __interrupt void TIM2_UPD_OVF_BRK_IRQHandler(void)
   
5. {  
   
6.    TIM2_ClearITPendingBit(TIM2_IT_UPDATE);
   
7.    
   
8.    Times++;
   
9. }

复制代码

上面是main函数，下面是 定时中断，整个函数非常纯粹。
在debug时，把断点设在 i = 0;的语句。

测试发现，直接调用函数，断点时Timer值为17；
而通过函数指针调用，断点时Timer值为19；

这个比例说起来不算太大，但也不小。
既然已经做了测试，我们不妨再做一个更加符合真实情况的测试。判断函数指针是否为NULL

——实际应用中，不管是调用前直接判断，还是函数一开始就判断，其实说起来都是多了一句判断，所以这个测试是非常符合实际的。

1.     while(1)
   
2.     {
   
3.         Times = 0;
   
4.         for(i = 0;i < 5000;i++)
   
5.         {
   
6.             //TestFun();
   
7.           if(pTest != NULL)  
   
8.              (*pTest)();
   
9.         }
   
10.         i = 0;  // for breakpoint here.
    
11.     }

复制代码

现在测试的结果是 23.
这个结果就比较危险了。
23-17/17  将近1/3.

辛昕

既然已经开始了测试，我们就顺带把该测试的都测试完。

1. static U16 gVar = 0;
   
2. 
   
3. extern U16 Times;
   
4. void main(void)
   
5. {  
   
6.     static U16 i;
   
7.     static U16 pVal;
   
8.     void (*pTest)(void) = NULL;
   
9.    
   
10.     Timer_Initial();
    
11.    
    
12.     pTest = TestFun;
    
13.    
    
14.     while(1)
    
15.     {
    
16.         Times = 0;
    
17.         for(i = 0;i < 5000;i++)
    
18.         {
    
19.           gVar = 1;
    
20.         }
    
21.         i = 0;  // for breakpoint here.
    
22.     }

复制代码

断点时，Timer = 13;

现在换成本地变量pVar

1.     while(1)
   
2.     {
   
3.         Times = 0;
   
4.         for(i = 0;i < 5000;i++)
   
5.         {
   
6.           pVar = 1;
   
7.         }
   
8.         i = 0;  // for breakpoint here.
   
9.     }

复制代码

现在结果一样，还是13，我担心次数太少，于是我换成了10000次，结果都是27，可见， 对于变量，不管是 全局还是局部，开销是一样的。

误会误会，刚才那个pVar还是静态变量，我换成了 局部变量，去了static。结果是11，仍然略有差别，但是小了许多。

现在再试一下，通过指针的方式。

1.     static U16 i;
   
2.     U16 pVar;
   
3.     U16 *pV = &pVar;
   
4.    
   
5.     Timer_Initial();
   
6.    
   
7.     while(1)
   
8.     {
   
9.         Times = 0;
   
10.         for(i = 0;i < 5000;i++)
    
11.         {
    
12.           *pV = 1;
    
13.         }
    
14.         i = 0;  // for breakpoint here.
    
15.     }

复制代码

现在是 16.

辛昕

因为在我们以后的实现方法里，结构体封装变量和函数指针是很常见的方法。

1. void TestFun(void)
   
2. {
   
3. }
   
4. 
   
5. static U16 gVar = 0;
   
6. 
   
7. extern U16 Times;
   
8. 
   
9. typedef struct
   
10. {
    
11.     U16 Times;
    
12.     void (*pTest)(void);
    
13. }pStr;
    
14. 
    
15. void main(void)
    
16. {  
    
17.     static U16 i;
    
18.     U16 pVar;
    
19.     U16 *pV = &pVar;
    
20.     void (*pTest)(void) = NULL;
    
21.     pStr *Str = NULL,TestStr;
    
22.    
    
23.     Timer_Initial();
    
24.    
    
25.     while(1)
    
26.     {
    
27.         Times = 0;
    
28.         for(i = 0;i < 5000;i++)
    
29.         {
    
30.             Str->Times = 0;
    
31.         }
    
32.         i = 0;  // for breakpoint here.
    
33.     }

复制代码

这是通过结构体指针引用变量，结果是15.

现在换成 结构体指针引用函数指针

1.     Str->pTest = TestFun;
   
2.    
   
3.     Timer_Initial();
   
4.    
   
5.     while(1)
   
6.     {
   
7.         Times = 0;
   
8.         for(i = 0;i < 5000;i++)
   
9.         {
   
10.             (*(Str->pTest))();
    
11.         }
    
12.         i = 0;  // for breakpoint here.
    
13.     }

复制代码

这时的结果是22；

最后再考虑一下，如果是结构体变量会如何。

1.     while(1)
   
2.     {
   
3.         Times = 0;
   
4.         for(i = 0;i < 5000;i++)
   
5.         {
   
6.             TestStr.Times = 0;
   
7.         }
   
8.         i = 0;  // for breakpoint here.
   
9.     }

复制代码

现在是13；

最后是结构体变量引用函数指针

1.     while(1)
   
2.     {
   
3.         Times = 0;
   
4.         for(i = 0;i < 5000;i++)
   
5.         {
   
6.             (*(TestStr.pTest))();
   
7.         }
   
8.         i = 0;  // for breakpoint here.
   
9.     }

复制代码

结果是22.

好了，至此，全部测试完成。
我们要整理一下结果

辛昕

我们来比较一下

对于变量而言。

直接调用 和 全局变量 相差不大，14:13 我重新测试了一次，仍是这个结果，让我略有点吃惊。全局居然比局部还快。

而通过结构体引用时，这个开销又稍微大了点，很明显的结果就是 通过指针 要 比直接变量 多。这个区别 是 14:16

除去全局哪一个地方比较奇怪，我们可以得出基本结论：
直接调用自然是最快的，而通过结构体变量取和直接取是没区别的，都是14.
这一点也可以在另一组对比作为验证。通过指针比直接调用，要多了2个单位。
而通过结构体指针比起通过结构体变量，也是多了2，再次验证一个事实

通过指针要比直接调用多2个时间单位，但是通过结构体和直接调用本身是没有区别的。

我曾经担心过，是不是5000次太少，于是我把次数拉到50000次，结果对于 结构体指针和结构体变量的结果
是 161:145
也就是说，这个区别不会超出10%的区别。14/!6 和 145/161 的区别可以认为没区别（0.875和0.901）

接着是函数的情形
前面关于 通过指针 和 直接调用 的 差别是类似的，都是2个相对单位。
唯一有点差别的是，通过结构体的时候，我们发现，通过结构体变量要比结构体指针快一些
当然我们要注意，也许是因为这个次数稍微有点少，假如我们把次数增多，也许最后会发现，这两者都有少许差别，
但可以认为这个差别不会超出现有比例的10%

我们可以实际试试 50000次的结果 直接调用 通过指针 通过结构体变量引用 通过结构体指针引用
161 185 185 234

这个比例仍然一致。

结论一下就是
关于通过指针和直接调用的差别是一致的。
但是，通过结构体引用变量的开销比起引用函数指针要稍微小一点，大致是2倍，或者只是纯粹碰巧，本来就是多了2个单位，因此刚好是2倍而已。

但不论如何，通过结构体指针引用函数指针的开销相对很大。

[ 本帖最后由 辛昕 于 2013-8-1 22:43 编辑 ]

辛昕

今晚的时间就这样过去了。
非常遗憾，不过这个测试确实让我们量化了我们的忧虑，也算是有意义。

可以看出对于我们最关心的区别

通过函数指针调用和直接调用

区别虽然看着很吓人，但实际上也只是 1/3

这个区别有时候仅仅意味着 1到2个时钟周期。

要注意一个细节：我测试的函数是空函数。
而实际上我们写的函数再小再小也有一个寄存器操作。

而更多的情形就更多语句了，这意味着，这个1/3的区别指的是 和 进出函数的时间开销相比，所以，在大多数情形下，这个比例很可能变成 1/30甚至是1/300

因此。
我们可以认为，尽管它确实多了一些开销。
但是这个开销的区别微不足道。

1. static U16 gVar = 0;
   
2. 
   
3. extern U16 Times;
   
4. 
   
5. void TestFun(void)
   
6. {
   
7.      gVar = 1;
   
8.      gVar = 2;
   
9.      gVar = 3;
   
10.      gVar = 4;     
    
11. }
    
12. 
    
13. 
    
14. 
    
15. typedef struct
    
16. {
    
17.     U16 Times;
    
18.     void (*pTest)(void);
    
19. }pStr;
    
20. 
    
21. void main(void)
    
22. {  
    
23.     //static U8 Status = IDLE;
    
24.    
    
25.     //UltraSonic_Test();
    
26.    
    
27. 
    
28.     static U16 i;
    
29.     U16 pVar;
    
30. 
    
31.     TestStr.pTest = TestFun;
    
32.     Str->pTest = TestFun;
    
33.     pTest = TestFun;
    
34.    
    
35.     Timer_Initial();
    
36.    
    
37.     while(1)
    
38.     {
    
39.         Times = 0;
    
40.         for(i = 0;i < 50000;i++)
    
41.         {
    
42.             //TestFun();
    
43.             if(pTest != NULL)
    
44.               (*pTest)();
    
45.         }
    
46.         i = 0;  // for breakpoint here.
    
47.     }

复制代码

为此我故意在函数里做了一些无用功。
然后对比 直接调用  通过指针调用  指针调用前加非NULL判断
50000次的结果是
                      298        336                    363
我们可以看看，这个比例已经下降了。而这个函数十分简单，就算比起只有一两个寄存器操作，也不会相差太多。
                     而差别大致只是 10:11:12

247153481

支持，跟紧楼主的帖子

soso

辛昕 加油

eric_wang

支持楼主！