如何“优雅”的测量系统性能

àì夳堔傛蜴生んèń 2022-10-19 15:59 288阅读 0赞

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1aGVueW91eXV5b3V5dQ_size_16_color_FFFFFF_t_70][]

**【说在前面的话】**

--------------------

在之前的文章《[【嵌入式秘术】相约榨干SysTick的每一滴汁水][SysTick]》里，我们介绍了一个以“寄居”形式（也就是在不影响用户已有SysTick应用的情况下）测量CPU性能的开源函数库 ***perf\_counter***。其仓库连接如下：

***https://github.com/GorgonMeducer/perf\_counter***

不知不觉中，***perf\_counter***已经经历了大大小小7个版本：

*  提高了***delay\_us()*** 的精度
 *  增加了对GCC、IAR的支持
 *  改进了 ***\_\_cycleof\_\_()*** 宏，使其支持嵌套、并**不再强制绑定 printf()**

![图片][47a3d1b99129e4add4b9aca9d4a73820.png]

如果你使用的是Arm Compiler5（armcc）或是Arm Compiler 6（armclang），移植就特别简单。你可以按照[这篇文章的手把手教程][SysTick]在5分钟内完成部署。

**【关于对GCC和IAR的支持】**

--------------------

对于GCC和IAR来说，由于它们都不支持 Arm Compiler 5/6 所特有的 Linker语法——[$Sub$$ 和 $Super$$][Sub_ _ _Super]，因此无法直接通过 Lib 的方式实现对已有SysTick应用的 “寄居”——这里就只能忍痛割爱了。

这并不影响我们以源代码的形式将它们加入已有的 GCC 或是 IAR 工程。大体步骤如下：

**第一步：**将 ***perf\_counter.c*** 和 ***perf\_counter.h*** 拷贝到你的工程目录下，并将perf\_counter.c 加入到编译列表中；

**第二步：**将 ***perf\_counter.h*** 所在的路径加入到编译器的头文件搜索路径中；

**第三步**：***perf\_counter.c*** 依赖 ***CMSIS 5.4.0*** 及其以上版本，确保你的工程中正确的包含了对CMSIS的支持。（这里就不再赘述）。

**第四步**：在需要用到 ***perf\_counter*** 功能的C源文件中加入对头文件的包含：

#include "perf_counter.h"

**第五步**：一般来说，用户会在某一个地方，比如 ***main()*** 函数内完成对CPU工作频率的配置，我们应该在完成这一工作之后确保全局变量 ***SystemCoreClock*** 被正确的更新——保存当前CPU的工作频率，比如：

extern uint32_t SystemCoreClock;void main(void){
           system_clock_update();    //! 更新CPU工作频率    SystemCoreClock = 72000000ul //! 假设更新后的系统频率是 72MHz    ...}

一般来说，你的芯片工程如果本身都是基于较新的CMSIS框架而创建的，你的启动文件中已经为你定义好了全局变量 ***SystemCoreClock***——当然，凡事都有例外，如果你在编译的时候报告找不到变量 ***SystemCoreClock*** 或者说“***Undefined symbol \_\_SystemCoreClock***” 之类的，你自己定义一下就好了，比如：

uint32_t SystemCoreClock;void main(void){
           system_clock_update();    //! 更新CPU工作频率    SystemCoreClock = 72000000ul //! 假设更新后的系统频率是 72MHz    ...}

在这以后，我们需要对 ***perf\_counter*** 库进行初始化。这里分两种情况：

1、用户自己的应用里完全没有使用***SysTick***。对于这种情况，我们要在 main.c （或者别的什么源文件里）添加一个***SysTick***中断处理程序：

#include "perf_counter.h"...
    __attribute__((used))    //!< 避免下面的处理程序被编译器优化掉void SysTick_Handler(void){
           //! 这个函数来自于 perf_counter.h     user_code_insert_to_systick_handler();}

然后我们在 ***main()*** 函数里初始化 ***perf\_counter*** 服务：

#include <stdbool.h>...
    void main(void){
           system_clock_update();       //! 更新CPU工作频率    SystemCoreClock = 72000000ul //! 假设更新后的系统频率是 72MHz    init_cycle_counter(false);    ...}

需要特别注意的是：由于用户并没有自己初始化 ***SysTick***，因此我们需要将这一情况告知 ***perf\_counter*** 库——由它来完成对 ***SysTick*** 的初始化——这里传递 ***false*** 给函数 ***init\_cycle\_counter()*** 就是这个功能。**如果由perf\_counter 库自己来初始化SysTick，它会为了自己功能更可靠将 SysTick的溢出值（LOAD寄存器）设置为最大值（0x00FFFFFF）。**

2、用户自己的应用里使用了SysTick，拥有自己的初始化过程。对于这种情况，我们需要确保一件事情：**即，SysTick的CTRL寄存器的 BIT2（SysTick\_CTRL\_CLKSOURCE\_Msk）是否被置位了——如果其值是1，说明SysTick使用了跟CPU一样的工作频率，那么SysTick的测量结果就是CPU的周期数；****如果其值是0，说明SysTick使用了来自于别处的时钟源，这个时钟源具体频率是多少就只能看芯片手册了****（比如STM32就喜欢将系统频率做 1/8 分频后提供给SysTick作为时钟源）****，****此时SysTick测量出来的结果就不是CPU的周期数。**

在确保了 ***CTRL*** 寄存器的 ***BIT2*** 被正确置位，并且***SysTick***中断被使能（置位 ***BIT1，SysTick\_CTRL\_TICKINT\_Msk*** ）后，我们可以简单的通过 ***init\_cycle\_counter()*** 函数告诉***perf\_counter***模块：***SysTick*** 被用户占用了——这里传递 true 就实现这一功能。

#include <stdbool.h>...
    void main(void){
           system_clock_update();       //! 更新CPU工作频率    SystemCoreClock = 72000000ul //! 假设更新后的系统频率是 72MHz    init_cycle_counter(true);    ...}

当然，不要忘记向已经存在的***SysTick\_Handler()***内加入***perf\_counter()***的插入函数：

#include "perf_counter.h"...
    __attribute__((used))    //!< 避免下面的处理程序被编译器优化掉void SysTick_Handler(void){
           ...    //! 这个函数来自于 perf_counter.h     user_code_insert_to_systick_handler();    ...}

至此，我们就完成了 ***perf\_counter*** 模块在 ***GCC***和***IAR***中的部署。

**【如何测量代码片断占用了多少CPU资源】**

--------------------

很多时候，我们会关心某一段代码或者函数究竟用了多少CPU周期，比如，我们写了一个算法，你很担心“这个算法究竟使用了多少CPU资源”，为了解决这个问题，我们需要用到如下的公式：

CPU资源占用（百分比） =

（函数运行所需的时间）➗ （算法运行间隔的最小值）

✖️ 100%

对于**【函数运行所需的时间】**和**【算法运行间隔的最小值】**来说，虽然它们都是时间单位，但考虑到CPU的频率是给定的（不变的），因此，**这里的时间单位在乘以CPU的工作频率后都可以被换算为CPU的周期数**。举例来说，假如**【算法运行间隔的最小值】**是 20ms、CPU的频率是72MHz，那么对应的周期数就是 72000000 \* (20ms / 1000ms) = 1440000 个周期。看来上述公式中唯一需要我们实际测量的就是**【函数运行所需的周期数】**了。

***perf\_counter*** 提供了一个非常简单的运算符：***\_\_cycleof\_\_()***。假设我们要测量的代码片断如下：

...my_algorithm_step_a();my_algorithm_step_b();...my_algorithm_step_c();...

则我们可以轻松的通过\_\_cycleof\_\_()运算来测量结果：

...__cycleof__("my algorithm") {
           my_algorithm_step_a();    my_algorithm_step_b();    ...    my_algorithm_step_c();}...

如果你的系统支持 ***printf()***，则可以看到类似如下的输出结果：

![图片][17f8c0e0d0ecad13a18ea250ada04fa4.png]

带入上述公式：

**525139 / 14400000 \* 100% ≈ 36.5%**

就计算出这个算法占用了大约 36.5% 的CPU资源，值得说明的是，**从原理上看，这一方式对裸机和RTOS同样有效哦**。

有的小伙伴很快会说，我的系统并不允许我调用***printf***，那我还可以使用 ***\_\_cycleof\_\_()*** 么？当然了！就继续以上述代码为例子：

int32_t nCycleUsed = 0;
    ...__cycleof__("my algorithm", {
           nCycleUsed = _;    }) {
           my_algorithm_step_a();    my_algorithm_step_b();    ...    my_algorithm_step_c();}...

这里的代码所实现的功能是：

*  **测量了用户函数** **my\_algorithm\_step\_xxx()** **所使用的周期数：**
 *  **测量的结果被转存到了一个叫做** **nCycleUsed** **的变量中；**
 *  **\_\_cycleof\_\_()** **将不会调用** **printf()** **进行任何内容输出。**

我相信很多小伙伴会揉了揉眼睛、仔细看了又看，然后回过头来满头问号：

![图片][6988131cdd84241798d5489220dea575.png]

这是C语言？

这是什么语法？

不要怀疑，这就是C语言，只不过使用了一点GCC的语法扩展（感兴趣的小伙伴可以复制这里的连接 **https://gcc.gnu.org/onlinedocs/gcc/Statement-Exprs.html\#Statement-Exprs**），考虑到本文只介绍 ***perf\_counter*** 如何使用，而对其如何实现的并不关心，我们不妨略过GCC扩展语法的部分，专门来看看上述代码的使用细节：

*  首先，为了方便大家观察，我们先忽略圆括号内的部分：

...__cycleof__(...) {
           my_algorithm_step_a();    my_algorithm_step_b();    ...    my_algorithm_step_c();}...

可以发现，这里跟此前并没有什么不同：花括号包围的部分就是我们要测量的代码片断；

*  接下来，我们专门来看***\_\_cycleof\_\_()*** 圆括号中的部分：

int32_t nCycleUsed = 0;
    ...__cycleof__("my algorithm", {
           nCycleUsed = _;    }){
       ...}...

容易发现，**如果以“,” 为分隔符**，那么实际传递给 ***\_\_cycleof\_\_()*** 的是两个部分：

1、标注测量名称的字符串

"my algorithm"

2、一段用花括号括起来的代码片断：

{nCycleUsed = _;}

其中，***nCycleUsed*** 是一个事先已经初始化好的变量。

这里，对于表示测量名称的字符串"my algorithm"，在这一用法下**在最终的编译结果里并不会占用任何RAM或者是ROM**，但**作为语法结构是必须的**。

对于花括号所囊括的代码片段来说，实际上在这个花括号里，你几乎可以为所欲为：

*  你可以写任意数量的代码
 *  你可以调用函数
 *  你可以定义变量（当然这里定义变量肯定就是局部变量了）

但我们一般要做的事情其实是**通过*****\_\_cycleof\_\_()*** **所定义的一个局部变量"*****\_*****"来获取测量结果**——这也是下面代码的本意：

nCycleUsed = _;

需要说明的是，**这个局部变量"\_"生命周期仅限于这个花括号中，因此不会影响 \_\_cycleof\_\_() 整个结构之外的部分——或者说，下述代码是没有意义的：**

int32_t nCycleUsed = 0;
    ...__cycleof__("my algorithm", {
               nCycleUsed = _;    }) {
           my_algorithm_step_a();    my_algorithm_step_b();    ...    my_algorithm_step_c();}
    printf("Cycle Used %d", _);

编译器会毫不客气的告诉你 "***\_***" 是一个未定义的变量，反之如果你这么做：

int32_t nCycleUsed = 0;
    ...__cycleof__("my algorithm", {
               nCycleUsed = _;        printf("Cycle Used %d", _);    }) {
           my_algorithm_step_a();    my_algorithm_step_b();    ...    my_algorithm_step_c();}

则会看到你心怡的输出结果：

![图片][c80ca8cf325d58cd60731d8b5823ed9d.png]

**【没有什么黑魔法】**

--------------------

如果你对上述例子的等效形式（展开形式）感到非常好奇，其实大可不必，上述代码在“逻辑上等效”于如下的形式：

int32_t nCycleUsed = 0;
    ...do {
           int64_t _ = get_system_ticks();    {
               my_algorithm_step_a();        my_algorithm_step_b();        ...        my_algorithm_step_c();    }    _ = get_system_ticks() - _;        //! 我们添加的代码    nCycleUsed = _;    printf("Cycle Used %d", _);} while(0);

是不是突然就没有那么神秘了？通过“逻辑等效”的形式展开，我们很容易发现一些有趣的内容：

*  起核心作用的是一个叫做 ***get\_system\_ticks()*** 的函数。实际上**它返回的是从复位后 SysTick被使能至今所经历的 CPU 周期数**——由于它是int64\_t 的类型，因此不用担心超过 SysTick 24位计数器的量程，也不用担心人类历史范围内会发生溢出的可能。 知道这一点后，聪明的小伙伴就可以自己整活儿了。
 *  由于 "\_" 是一个局部变量，因此可以判断 **\_\_cycleof\_\_() 是支持嵌套的**。

需要特别说明的是，***get\_system\_tick()*** 函数自己也是有CPU时钟开销的，所以如果要获得较为精确的结果，推荐通过下面的方法来获取校准值：

static int64_t s_lPerfCalib;
    void calib_perf_counter(void) {
           int64_t lTemp = get_system_tick();    s_lPerfCalib = get_system_tick() - lTemp;}
    int64_t get_perf_counter_calib(void){
           return s_lPerfCalib;}

具体如何使用，这里就不再赘述了。

**【说在后面的话】**

--------------------

***perf\_counter*** 仍然在不停的演化中，这多亏了开源社区不断的使用和反馈。***perf\_counter*** 的应用场景实际上非常广泛，包括但不限于：

*  **为裸机或者RTOS提供Cycle级别的性能测量；**
 *  **评估代码片段的CPU占用；**
 *  **算法精细优化时用于测量和观察优化的效果；**
 *  **测量中断的响应时间；**
 *  **测量中断的发生间隔（查找最短时间间隔）；**
 *  **评估GUI的帧率或者刷新率；**
 *  **与SystemCoreClock计算后，获得一个系统时间戳（Timestamp）；**
 *  **当做Realtime Clock的基准；**
 *  **作为随机数种子**
 *  **……**

实际上***perf\_counter***在我参与的另外一个开源项目 ***arm-2d***里也被悄悄的藏在了 ***platform\_utilities.lib*** 中用来为例子代码提供帧率的测量服务。

如果你在使用中发现了任何问题、有任何反馈意见，还请提出你的issue，或者直接在评论区留言。谢谢啦。

--------------------

**原创不易，**

**如果你喜欢我的思维、****觉得我的文章对你有所启发，**

**请务必 “点赞、收藏、转发” 三连，这对我很重要！谢谢！**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d1aGVueW91eXV5b3V5dQ_size_16_color_FFFFFF_t_70]: /images/20221004/5dd092763f7f4ee69ce96357ef83538b.png
[SysTick]: http://mp.weixin.qq.com/s?__biz=MzAxMzc2ODMzNg==&mid=2656102606&idx=1&sn=f6b597e4c235b97df6fc72ccb5ec761f&chksm=8039cb31b74e4227a011ca9fe82acfc31b741da872d26b96e245dbf5f6b8db380cf1e4d6f95e&scene=21#wechat_redirect
[47a3d1b99129e4add4b9aca9d4a73820.png]: /images/20221004/aa528e0e5ea4408ea2e01b96bd5fca0f.png
[Sub_ _ _Super]: http://mp.weixin.qq.com/s?__biz=MzAxMzc2ODMzNg==&mid=2656102412&idx=1&sn=beb78986af77336f3a8bc7214258f358&chksm=8039cbf3b74e42e5c0c6e22efa79c70498d57ab17bf0a16f8837e6c25044fb46be8d25f33608&scene=21#wechat_redirect
[17f8c0e0d0ecad13a18ea250ada04fa4.png]: /images/20221004/234f82779d694ec5b8a7777acc2e1e24.png
[6988131cdd84241798d5489220dea575.png]: /images/20221004/c1afdd9fe0ac4aefa2f2afc19cdfe986.png
[c80ca8cf325d58cd60731d8b5823ed9d.png]: /images/20221004/db5235e64d004b99b6f5eb55ef9cb317.png