1       分支记录

1.1      介绍

在需要确定程序的指令流时，只需要关注最具代表性的指令——分支跳转指令，因为分支总是基本块中的最后一个指令。现代CPU提供分支记录机制（Branch Recording Mechanisms），使得能够在分支上进行采样，并在每次采样期间，记录先前执行的N个分支。

     Inter与ARM平台都支持分支记录机制，它们的基本原则是相同的：硬件记录每个分支的from、to地址以及一些额外数据（例如分支预测位）。

2       ARM平台的BRBE（Branch Record Buffer Extension）

2.1      介绍

BRBE是一个硬件实现的环形缓冲区，保存最近执行的 N 条分支记录。每条记录内容主要有：分支的源地址、分支的目标地址、分支类型、分支预测结果等。如图所示：

BRBE采集可以限制在一组特定的分支类型上，例如用户可以选择只记录函数调用和返回。用户还可以过滤条件跳转和无条件跳转、间接跳转和调用、系统调用、中断等。在perf中， -j 选项可以启用/禁用记录各种分支类型。如下图所示：

例如，一个典型的采样命令：
                perf record -F 1000 -j u,any -e cycles -p 123456

指定了采样频率、过滤器、采样事件、采样进程。

2.2      BRBE的应用

2.2.1      捕获调用栈

分支记录最广泛的应用之一是捕获调用堆栈。对于这样一个程序，可以通过brbe采样获取调用栈信息：

// test.cpp
void func3()
{
    for(int i = 0;i<300000;i++)
    {
 
    }
}
 
void func2()
{
    for(int i = 0;i<200000;i++)
    {
        
    }
    func3();
}
 
void func1()
{
    for(int i = 0;i<100000;i++)
    {
        
    }
    func2();
}
 
int main()
{
    for(int i=0;i<1000;i++)
    {
        func1();
    }
}

   通过这几步：

g++ -g test.cpp -o test
perf record --call-graph dwarf -- ./test
perf report -n –stdio

   可得到调用栈：

从中可以看出各函数调用路线以及耗时占比。具体来说，func1() → func2() → func3()显然是占用时钟周期最长的调用路线，其主要耗时集中在 func3()，占比 50.67%，因此整条路线的性能瓶颈即为此处，符合程序本身的结构。对于更复杂的应用，也可以通过类似的方法进行分析。

2.2.2      识别热点分支

分支记录可以帮助识别哪些代码行占用CPU的比例更高。

例如，对于这样一个sort程序：

#include <iostream>
#include <algorithm>
#include <ctime>
 
int main()
{
    // 随机产生整数
    const unsigned arraySize = 32768;
    int data[arraySize];
 
    for (unsigned c = 0; c < arraySize; ++c)
        data[c] = std::rand() % 256;
 
    // 排序
    std::sort(data, data + arraySize);
 
    // 测试部分
    clock_t start = clock();
    long long sum = 0;
 
    for (unsigned i = 0; i < 100000; ++i)
    {
        // 主要计算部分：选一半元素参与计算
        for (unsigned c = 0; c < arraySize; ++c)
        {
            if (data[c] >= 128)
                sum += data[c];
        }
    }
 
    double elapsedTime = static_cast<double>(clock() - start) / CLOCKS_PER_SEC;
 
    std::cout << elapsedTime << std::endl;
    std::cout << "sum = " << sum << std::endl;
 
    return 0;
}

可以通过如下步骤，获取热点分支信息：

g++ -g -O0 -o sort sort.cpp
perf record -e cycles -b --call-graph=dwarf  -- ./sort
perf report -n --sort overhead,srcline -F +dso,symbol –stdio

结果如图所示：

     可以看出性能消耗主要集中在24、26、27行，即程序的计算部分。

2.2.3      反馈优化

brbe数据经过处理后可用于反馈优化，例如，对于这样一个冒泡排序程序

// sort.c
#include <stdlib.h>
#include <sys/time.h>
#define ARRAY_LEN 30000
 
static struct timeval tm1;
 
static inline void start() {
    gettimeofday(&tm1, NULL);
}
 
static inline void stop() {
    struct timeval tm2;
    gettimeofday(&tm2, NULL);
    unsigned long long t = 1000 * (tm2.tv_sec - tm1.tv_sec) +\
                           (tm2.tv_usec - tm1.tv_usec) / 1000;
    printf("%llu ms\n", t);
}
 
void bubble_sort (int *a, int n) {
    int i, t, s = 1;
    while (s) {
        s = 0;
        for (i = 1; i < n; i++) {
            if (a[i] < a[i - 1]) {
                t = a[i];
                a[i] = a[i - 1];
                a[i - 1] = t;
                s = 1;
            }
        }
    }
}
 
void sort_array() {
    printf("Bubble sorting array of %d elements\n", ARRAY_LEN);
    int data[ARRAY_LEN], i;
    for(i=0; i<ARRAY_LEN; ++i){
        data[i] = rand();
    }
    bubble_sort(data, ARRAY_LEN);
}
int main(){
    start();
    sort_array();
    stop();
    return 0;
}

   可以通过以下步骤反馈优化，减少程序运行时间：

(1)   安装autofdo：yum install autofdo.aarch64
(2)   编译原始代码： gcc -g -O3 sort.c -o sort
(3)   执行未优化的二进制文件10次，记录耗时

(4) 使用perf采集brbe，记录执行时的数据：perf record -e cycles -j any,save_type ./sort
(5) 生成gcov文件：create_gcov --binary=./sort
--profile=perf.data --gcov=sort.gcov gcov_version=2
(6)   使用 AutoFDO 编译优化后的代码：gcc -O3 -fauto-profile=sort.gcov sort.c -o sort_autofdo
(7)   执行优化后的程序10次,对比优化前后程序耗时

   在本例中，sort.c的耗时显著降低。对于大型应用，也可以在编译时加入反馈优化选项，然后运行benchmark采集brbe，再在二次编译时加入处理后的brbe数据，以此优化应用的性能。

3      libkperf采集BRBE

3.1      介绍

libkperf是一个轻量级linux性能采集库，它能够让开发者以API的方式执行性能采集，包括pmu采样和符号解析。libkperf把采集数据内存化，使开发者能够在内存中直接处理采集数据，避免了读写perf.data带来的开销。

libkperf的开源地址：https://gitee.com/openeuler/libkperf

编译生成动态库和C的API：：

    git clone --recurse-submodules https://gitee.com/openeuler/libkperf.git
    cd libkperf
    bash build.sh install_path=/path/to/install

libkperf提供了采集brbe的能力，例如：

#include <iostream>
#include "symbol.h"
#include "pmu.h"
 
int main()
{
char* evtList[1] = {"cycles"};
int* cpuList = nullptr;
PmuAttr attr = {0};
attr.evtList = evtList;
attr.numEvt = 1; 
attr.cpuList = cpuList;
attr.numCpu = 0;
attr.freq = 1000;
attr.useFreq = 1;
attr.symbolMode = NO_SYMBOL_RESOLVE;
int pidList[1] = {1}; // 该pid值替换成对应需要采集应用的pid
attr.pidList = pidList;
attr.numPid = 1;
attr.branchSampleFilter =
KPERF_SAMPLE_BRANCH_USER | KPERF_SAMPLE_BRANCH_ANY;
int pd = PmuOpen(SAMPLING, &attr);
if (pd == -1) {
    std::cout
<< Perror() << std::endl;
    return;
}
PmuEnable(pd);
sleep(3);
PmuDisable(pd);
PmuData* data = nullptr;
int len = PmuRead(pd, &data);
for (int i = 0; i < len; i++)
{
    PmuData &pmuData = data[i];
    if
(pmuData.ext)
    {
        for (int j = 0; j < pmuData.ext->nr; j++)
        {
            auto *rd = pmuData.ext->branchRecords;
            std::string predStr = "P";
            if (rd[j].misPred == 1) {
                predStr = "M";
            }
            std::cout << std::hex << rd[j].fromAddr << "->"
<< rd[j].toAddr << " " << rd[j].cycles << "
" << predStr << std::endl;
        }
    }
}
PmuDataFree(data);
PmuClose(pd);
}

其中branchSampleFilter定义了过滤器，含义与perf record中的-j参数相同。

执行上述代码，输出的结果类似如下：

ffff88f6065c->ffff88f60b0c 35 P
ffff88f60aa0->ffff88f60618 1  P
40065c->ffff88f60b00 1 P
400824->400650 1 P
400838->400804 1 P

结果展示了分支跳转的起始地址、周期数、预测标志位。