From 5dacbbf2cd2389ee8349e8afa1f12551404a47f5 Mon Sep 17 00:00:00 2001 From: eho <2220386943@qq.com> Date: Tue, 19 Nov 2024 10:52:47 +0800 Subject: [PATCH] udpate version to 1.1-2 --- ...e-python-modules-_libkperf-Symbol.py.patch | 26 + 0002-update-docs.patch | 769 ++++++++++++++++++ ...ter-pmuopen-delete-evtList-exception.patch | 340 ++++++++ ...the-repeated-judgement-on-formatPath.patch | 62 ++ 0005-pmu-event.patch | 147 ++++ 0006-adapt-events.patch | 110 +++ ...date-python-modules-_libkperf-Pmu.py.patch | 30 + 0008-.patch | 56 ++ 0009-adapt-gcc-4.8.5.patch | 25 + 0010-fix-spelling-error.patch | 48 ++ 0011-add-perrno-operation-not-supported.patch | 51 ++ 0012-UT-SpeProcCollectSubProc.patch | 44 + ...Data-call-by-removing-redundant-buf-.patch | 29 + 0014-Update-Details.md.patch | 101 +++ ...-remove-unused-variable-childPidList.patch | 28 + 0016-update-include-pmu.h.patch | 35 + ...port-packages-and-fix-spelling-mista.patch | 38 + ...ocation-check-in-symbol_resolve.cpp-.patch | 30 + 0019-update-python-modules-kperf-pmu.py.patch | 30 + 0020-update-pmu-spe.h.patch | 30 + libkperf-1.1.tar.gz | Bin 104035 -> 0 bytes libkperf-v1.2.tar.gz | Bin 0 -> 686080 bytes libkperf.spec | 34 +- 23 files changed, 2060 insertions(+), 3 deletions(-) create mode 100644 0001-update-python-modules-_libkperf-Symbol.py.patch create mode 100644 0002-update-docs.patch create mode 100644 0003-fix-after-pmuopen-delete-evtList-exception.patch create mode 100644 0004-Delete-the-repeated-judgement-on-formatPath.patch create mode 100644 0005-pmu-event.patch create mode 100644 0006-adapt-events.patch create mode 100644 0007-update-python-modules-_libkperf-Pmu.py.patch create mode 100644 0008-.patch create mode 100644 0009-adapt-gcc-4.8.5.patch create mode 100644 0010-fix-spelling-error.patch create mode 100644 0011-add-perrno-operation-not-supported.patch create mode 100644 0012-UT-SpeProcCollectSubProc.patch create mode 100644 0013-simplify-CoreSpeData-call-by-removing-redundant-buf-.patch create mode 100644 0014-Update-Details.md.patch create mode 100644 0015-cleanup-remove-unused-variable-childPidList.patch create mode 100644 0016-update-include-pmu.h.patch create mode 100644 0017-Delete-unused-import-packages-and-fix-spelling-mista.patch create mode 100644 0018-Fixed-memory-allocation-check-in-symbol_resolve.cpp-.patch create mode 100644 0019-update-python-modules-kperf-pmu.py.patch create mode 100644 0020-update-pmu-spe.h.patch delete mode 100644 libkperf-1.1.tar.gz create mode 100644 libkperf-v1.2.tar.gz diff --git a/0001-update-python-modules-_libkperf-Symbol.py.patch b/0001-update-python-modules-_libkperf-Symbol.py.patch new file mode 100644 index 0000000..77a2449 --- /dev/null +++ b/0001-update-python-modules-_libkperf-Symbol.py.patch @@ -0,0 +1,26 @@ +From 3742958aa92ed147e56ea38226ca4ee683f618f0 Mon Sep 17 00:00:00 2001 +From: Caohongtao +Date: Thu, 11 Jul 2024 01:29:32 +0000 +Subject: [PATCH 01/20] update python/modules/_libkperf/Symbol.py. + +Signed-off-by: Caohongtao +--- + python/modules/_libkperf/Symbol.py | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/python/modules/_libkperf/Symbol.py b/python/modules/_libkperf/Symbol.py +index 6db0f2c..9134c96 100644 +--- a/python/modules/_libkperf/Symbol.py ++++ b/python/modules/_libkperf/Symbol.py +@@ -224,7 +224,7 @@ class Stack: + self.__c_stack = CtypesStack( + symbol=symbol.c_sym if symbol else None, + next=next.c_stack if next else None, +- prev=prev.c_stack if next else None, ++ prev=prev.c_stack if prev else None, + count=count + ) + +-- +2.43.0 + diff --git a/0002-update-docs.patch b/0002-update-docs.patch new file mode 100644 index 0000000..090f92a --- /dev/null +++ b/0002-update-docs.patch @@ -0,0 +1,769 @@ +From d22ccd84355100e95b4aafa6ed9753236533dfec Mon Sep 17 00:00:00 2001 +From: ganlixiong +Date: Tue, 24 Sep 2024 15:18:52 +0800 +Subject: [PATCH 02/20] update docs. + +Update README and add Details.md for detailed usage of libkperf. +--- + README.en.md | 178 +++----------------------------- + README.md | 179 ++++---------------------------- + docs/Details.md | 264 ++++++++++++++++++++++++++++++++++++++++++++++++ + 3 files changed, 298 insertions(+), 323 deletions(-) + create mode 100644 docs/Details.md + +diff --git a/README.en.md b/README.en.md +index ff85b3a..40fbc26 100644 +--- a/README.en.md ++++ b/README.en.md +@@ -1,58 +1,36 @@ + # libkperf + + #### Description +-Implement a low overhead pmu collection library, providing abstract interfaces for counting, sampling and symbol resolve. ++libkperf is a lightweight performance collection library on linux, that enables developers to perform performance collection in an API fashion. libkperf provides performance data in memory and allows develops to process data directly, reducing overhead of writing and reading perf.data. + +-#### Software Architecture +-This repo includes two modules: pmu collections and symbol resolve. +- +-Pmu collection module is developed on syscall perf_event_open to enable kernel pmu counting and sampling, using -thread or per-core mode depending on user input. +-Pmu data packets are read from ring buffer and are parsed to different structure for counting, sampling and spe sampling. +-For sampling, symbols are resolved according to ips or pc from data packet. Each symbol contains symbol name, address, source file path and line number if possible. +- +-Symbol resolve module is developed on elfin-parser, a library for parsing elf and dwarf. The module manages all symbol data in well-designed data structures for fast query. +- +-#### Download +- +-Git method: ++#### Build + ++To build a library with C API: + ```shell + git clone --recurse-submodules https://gitee.com/openeuler/libkperf.git +-``` +-If you only use +-```shell +-git clone https://gitee.com/openeuler/libkperf.git +-``` +-Please continue with the execution +-```shell + cd libkperf +-git submodule update --init --recursive ++bash build.sh install_path=/path/to/install + ``` + +-When unable to use git: +- +-1. Download the libkperf compressed file and decompress it. +- +-2. Go to the third_party directory of libkperf on Gitee, click on the link(as shown in the example elfin-parser@13e57e2 Click on the submit ID after @), to redirect and download the compressed package of the third-party library. After decompression, place it in the third_party directory of the local libkperf project. (elfin Parser is necessary for installation) +- +-#### Installation +-Run bash script: +- +-```sh +-bash build.sh install_path=/home/libkperf ++To build a library with debug version: ++```shell ++bash build.sh install_path=/path/to/install buildType=debug + ``` +-As mentioned above, the header and library will be installed in the/home/libkperf output directory, and installPath is an optional parameter. If not set, it will be installed in the output directory under libkperf by default. + +-If you want to add additional python library support, you can install it as follows: ++To build a python package: + ```shell +-bash build.sh python=true ++bash build.sh install_path=/path/to/install python=true + ``` + +-If you need to uninstall the python library after installation, you can run the following command: ++To uninstall python package: + ```shell +-python -m pip uninstall -y libkperf ++python3 -m pip uninstall -y libkperf + ``` + ++#### Documents ++Refer to ```docs``` directory for detailed docs: ++- [Detailed usage](./docs/Details.md) ++ + #### Instructions + All pmu functions are accomplished by the following interfaces: + * PmuOpen +@@ -60,14 +38,12 @@ All pmu functions are accomplished by the following interfaces: + * PmuEnable + Start collection. + * PmuRead +- Read pmu data and a list is returned. ++ Read collection data. + * PmuDisable + Stop collection. + * PmuClose + Close pmu device. + +-Refer to pmu.h for details of interfaces. +- + Here are some examples: + * Get pmu count for a process. + ```C +@@ -147,89 +123,16 @@ PmuDataFree(data); + // Like fd, call PmuClose if pd will not be used. + PmuClose(pd); + ``` +-* config event group function +-```C +-int pidList[1]; +-pidList[0] = pid; +-unsigned numEvt = 16; +-char *evtList[numEvt] = {"r3", "r4", "r1", "r14", "r10", "r12", "r5", "r25", +- "r2", "r26", "r2d", "r17", "r8", "r22", "r24", "r11"}; +-// initialize event list, the same group id is the same event group. +-// if event grouping is not required, leave the event group_id list blank. +-// In addition, if group_id is -1, the event group function is forcibly disabled. +-PmuAttr attr = {0}; +-attr.evtList = evtList; +-attr.numEvt = numEvt; +-attr.pidList = pidList; +-attr.numPid = 1; +-struct EvttAttr groupId[numEvt] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 13, 13, 13}; +-attr.evtAttr = groupId; +-// Call PmuOpen and pmu descriptor is return. +-// is an identity for current task. +-int pd = PmuOpen(COUNTING, &attr); +-// Start collection. +-PmuEnable(pd); +-// Collect for one second. +-sleep(1); +-// Stop collection. +-PmuDisable(pd); +-PmuData *data = NULL; +-// Read pmu data. You can also read data before PmuDisable. +-int len = PmuRead(pd, &data); +-for (int i = 0; i < len; ++i) { +- ... +-} +-// To free PmuData, call PmuDataFree. +-PmuDataFree(data); +-// Like fd, call PmuClose if pd will not be used. +-PmuClose(pd); +-``` +- +-- Counting supports fork thread. +-```C +-int pidList[1]; +-pidList[0] = pid; +-unsigned numEvt = 1; +-char *evtList[numEvt] = {"cycles"}; +-PmuAttr attr = {0}; +-attr.evtList = evtList; +-attr.numEvt = numEvt; +-attr.pidList = pidList; +-attr.numPid = 1; +-// In count mode, enable it you can get the new child thread count, default is disabled. +-attr.includeNewFork = 1; +-// Call PmuOpen and pmu descriptor is return. +-// is an identity for current task. +-int pd = PmuOpen(COUNTING, &attr); +-// Start collection. +-PmuEnable(pd); +-// Collect for two second. +-sleep(2); +-// Stop collection. +-PmuDisable(pd); +-PmuData *data = NULL; +-// Read pmu data. You can also read data before PmuDisable. +-int len = PmuRead(pd, &data); +-for (int i = 0; i < len; ++i) { +- ... +-} +-// To free PmuData, call PmuDataFree. +-PmuDataFree(data); +-// Like fd, call PmuClose if pd will not be used. +-PmuClose(pd); +-``` + + Python examples: + ```python + import time + from collections import defaultdict +-import subprocess + + import kperf + + def Counting(): + evtList = ["r11", "cycles"] +- evtAttr = [2, 2] # Event group id list corresponding to the event list. the same group id is the same event group. + pmu_attr = kperf.PmuAttr(evtList=evtList) + pd = kperf.open(kperf.PmuTaskType.COUNTING, pmu_attr) + if pd == -1: +@@ -250,53 +153,4 @@ def Counting(): + + kperf.disable(pd) + kperf.close(pd) +- +- +-def NewFork(): +- # test_new_fork demo in test_perf, you can find test_new_fork.cpp +- p=subprocess.Popen(['test_new_fork']); +- pidList=[p.pid] +- evtList=["cycles"] +- pmu_attr = kperf.PmuAttr(evtList=evtList, includeNewFork=True, pidList=pidList) +- pd = kperf.open(kperf.PmuTaskType.COUNTING, pmu_attr) +- if pd == -1: +- print(kperf.error()) +- return +- kperf.enable(pd) +- time.sleep(4) +- pmu_data = kperf.read(pd) +- for data in pmu_data.iter: +- print(f"evt:{data.evt} count:{data.count} tid:{data.tid} pid:{data.pid}") +- kperf.disable(pd) +- kperf.close(pd) +- +- +-def PerfList(): +- event_iter = kperf.event_list(kperf.PmuEventType.CORE_EVENT) +- for event in event_iter: +- print(f"event: {event}") +- +- +-if __name__ == '__main__': +- Counting() +- PerfList() +- NewFork() + ``` +- +- +-#### Contribution +- +-1. Fork the repository +-2. Create Feat_xxx branch +-3. Commit your code +-4. Create Pull Request +- +- +-#### Gitee Feature +- +-1. You can use Readme\_XXX.md to support different languages, such as Readme\_en.md, Readme\_zh.md +-2. Gitee blog [blog.gitee.com](https://blog.gitee.com) +-3. Explore open source project [https://gitee.com/explore](https://gitee.com/explore) +-4. The most valuable open source project [GVP](https://gitee.com/gvp) +-5. The manual of Gitee [https://gitee.com/help](https://gitee.com/help) +-6. The most popular members [https://gitee.com/gitee-stars/](https://gitee.com/gitee-stars/) +diff --git a/README.md b/README.md +index 0763ac8..505fb59 100644 +--- a/README.md ++++ b/README.md +@@ -2,54 +2,25 @@ + + #### 描述 + +-实现了一个低开销的pmu集合库，为计数、采样和符号解析提供了抽象接口。 ++libkperf是一个轻量级linux性能采集库，它能够让开发者以API的方式执行性能采集，包括pmu采样和符号解析。libkperf把采集数据内存化，使开发者能够在内存中直接处理采集数据，避免了读写perf.data带来的开销。 + +-#### 软件构架 +- +-这个存储库包括两个模块：pmu集合和符号解析。 +- +-Pmu收集模块是在syscall perf_event_open上开发的，用于启用内核pmu计数和采样，根据用户输入使用-thread或per-core模式。 +-从环形缓冲区读取Pmu数据包，并将其解析为不同的结构，进行计数，采样和spe采样。 +-对于采样，根据ips或pc从数据包中解析符号。每个符号包含符号名称、地址、源文件路径和行号（如果可能）。 +- +-符号解析模块是在elfin-parser上开发的，elfin-parser是一个解析elf和dwarf的库。该模块以设计良好的数据结构管理所有符号数据，以实现快速查询。 +- +-#### 下载 +- +-git方法: ++#### 编译 + ++编译生成动态库和C的API： + ```shell + git clone --recurse-submodules https://gitee.com/openeuler/libkperf.git +-``` +-如果你只使用 +-```shell +-git clone https://gitee.com/openeuler/libkperf.git +-``` +-请再执行 +-```shell + cd libkperf +-git submodule update --init --recursive ++bash build.sh install_path=/path/to/install + ``` + +-无法使用git时: +- +-1.下载libkperf压缩包并解压。 +- +-2.进入gitee上的libkperf的third_party目录，点击链接(如elfin-parser@13e57e2，点击@后面的提交ID)，进行跳转并下载第三方库的压缩包，解压后放置于本地的libkperf项目的third_party目录。(elfin-parser对于安装是必须的) +- +-#### 安装 +- +-运行bash脚本: +- ++如果想要编译调试版本： + ```shell +-bash build.sh install_path=/home/libkperf ++bash build.sh install_path=/path/to/install buildType=debug + ``` + +-如上，头文件和库将安装到/home/libkperf输出目录，installPath是可选参数，若没有设置，则默认安装到libkperf下的output目录。 +- +-如果要额外增加python库支持，可以通过如下方式安装 ++如果想要编译python包： + ```shell +-bash build.sh python=true ++bash build.sh install_path=/path/to/install python=true + ``` + + 安装后若需要卸载python库， 可以执行下述命令 +@@ -57,22 +28,23 @@ bash build.sh python=true + python3 -m pip uninstall -y libkperf + ``` + +-#### 指令 ++#### 文档 ++详细文档可以参考docs目录： ++- [详细使用文档](./docs/Details.md) + +-所有pmu功能都通过以下接口完成： ++#### 快速使用 + ++主要有以下几个API： + - PmuOpen + 输入pid、core id和event，打开pmu设备。 + - PmuEnable + 开始收集。 + - PmuRead +- 读取pmu数据并返回一个列表。 ++ 读取采集数据。 + - PmuDisable + 停止收集。 + - PmuClose +- 关闭PMU装置。 +- +-API的详细说明请参考pmu.h。 ++ 关闭pmu设备。 + + 以下是一些示例： + +@@ -101,7 +73,8 @@ PmuData *data = NULL; + // 读取PmuData，它是一个数组，长度是len。 + int len = PmuRead(pd, &data); + for (int i = 0; i < len; ++i) { +- ... ++ PmuData *d = &data[i]; ++ ... + } + // 释放PmuData。 + PmuDataFree(data); +@@ -150,75 +123,6 @@ PmuDataFree(data); + // 类似fd，当任务结束时调用PmuClose释放资源。 + PmuClose(pd); + ``` +-- 配置事件分组功能 +-```C +-int pidList[1]; +-pidList[0] = pid; +-unsigned numEvt = 16; +-char *evtList[numEvt] = {"r3", "r4", "r1", "r14", "r10", "r12", "r5", "r25", +- "r2", "r26", "r2d", "r17", "r8", "r22", "r24", "r11"}; +-// 初始化事件列表，相同的group_id表示是同一个事件组 +-// 如果不使用事件分组功能，需要配置事件组参数列表为空 +-// 说明：如果事件的group_id为-1，表示此事件强制不进行分组 +-PmuAttr attr = {0}; +-attr.evtList = evtList; +-attr.numEvt = numEvt; +-attr.pidList = pidList; +-attr.numPid = 1; +-struct EvttAttr groupId[numEvt] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 13, 13, 13}; +-attr.evtAttr = groupId; +-// 调用PmuOpen，返回pd。pd表示该任务的id。 +-int pd = PmuOpen(COUNTING, &attr); +-// 开始采集。 +-PmuEnable(pd); +-// 采集1秒。 +-sleep(1); +-// 停止采集。 +-PmuDisable(pd); +-PmuData *data = NULL; +-// 读取PmuData，它是一个数组，长度是len。 +-int len = PmuRead(pd, &data); +-for (int i = 0; i < len; ++i) { +- ... +-} +-// 释放PmuData。 +-PmuDataFree(data); +-// 类似fd，当任务结束时调用PmuClose释放资源。 +-PmuClose(pd); +-``` +- +-- Counting模式支持采集fork新生成子进程的能力 +-```C +-int pidList[1]; +-pidList[0] = pid; +-unsigned numEvt = 1; +-char *evtList[numEvt] = {"cycles"}; +-PmuAttr attr = {0}; +-attr.evtList = evtList; +-attr.numEvt = numEvt; +-attr.pidList = pidList; +-attr.numPid = 1; +-// 增加参数includeNewFork，为1可获取新生成子进程的数据，默认不获取 +-attr.includeNewFork = 1; +-// 调用PmuOpen，返回pd。pd表示该任务的id。 +-int pd = PmuOpen(COUNTING, &attr); +-// 开始采集。 +-PmuEnable(pd); +-// 采集1秒。 +-sleep(1); +-// 停止采集。 +-PmuDisable(pd); +-PmuData *data = NULL; +-// 读取PmuData，它是一个数组，长度是len。 +-int len = PmuRead(pd, &data); +-for (int i = 0; i < len; ++i) { +- ... +-} +-// 释放PmuData。 +-PmuDataFree(data); +-// 类似fd，当任务结束时调用PmuClose释放资源。 +-PmuClose(pd); +-``` + + Python 例子: + ```python +@@ -230,8 +134,7 @@ import kperf + + def Counting(): + evtList = ["r11", "cycles"] +- evtAttr = [2, 2] # 与事件列表对应的事件分组id列表，相同的事件id表示是同一个事件组; 不启用的话，可以不使用这个参数 +- pmu_attr = kperf.PmuAttr(evtList=evtList, evtAttr=evtAttr) ++ pmu_attr = kperf.PmuAttr(evtList=evtList) + pd = kperf.open(kperf.PmuTaskType.COUNTING, pmu_attr) + if pd == -1: + print(kperf.errorno()) +@@ -252,50 +155,4 @@ def Counting(): + kperf.disable(pd) + kperf.close(pd) + +- +-def NewFork(): +- # test_new_fork demo in test_perf, you can find test_new_fork.cpp +- p=subprocess.Popen(['test_new_fork']); +- pidList=[p.pid] +- evtList=["cycles"] +- pmu_attr = kperf.PmuAttr(evtList=evtList, includeNewFork=True, pidList=pidList) +- pd = kperf.open(kperf.PmuTaskType.COUNTING, pmu_attr) +- if pd == -1: +- print(kperf.error()) +- return +- kperf.enable(pd) +- time.sleep(4) +- pmu_data = kperf.read(pd) +- for data in pmu_data.iter: +- print(f"evt:{data.evt} count:{data.count} tid:{data.tid} pid:{data.pid}") +- kperf.disable(pd) +- kperf.close(pd) +- +- +-def PerfList(): +- event_iter = kperf.event_list(kperf.PmuEventType.CORE_EVENT) +- for event in event_iter: +- print(f"event: {event}") +- +- +-if __name__ == '__main__': +- Counting() +- PerfList() + ``` +- +-#### 参与贡献 +- +-1. Fork 本仓库 +-2. 新建 Feat_xxx 分支 +-3. 提交代码 +-4. 新建 Pull Request +- +- +-#### 特技 +- +-1. 使用 Readme\_XXX.md 来支持不同的语言，例如 Readme\_en.md, Readme\_zh.md +-2. Gitee 官方博客 [blog.gitee.com](https://blog.gitee.com) +-3. 你可以 [https://gitee.com/explore](https://gitee.com/explore) 这个地址来了解 Gitee 上的优秀开源项目 +-4. [GVP](https://gitee.com/gvp) 全称是 Gitee 最有价值开源项目，是综合评定出的优秀开源项目 +-5. Gitee 官方提供的使用手册 [https://gitee.com/help](https://gitee.com/help) +-6. Gitee 封面人物是一档用来展示 Gitee 会员风采的栏目 [https://gitee.com/gitee-stars/](https://gitee.com/gitee-stars/) +diff --git a/docs/Details.md b/docs/Details.md +new file mode 100644 +index 0000000..db0b407 +--- /dev/null ++++ b/docs/Details.md +@@ -0,0 +1,264 @@ ++Details ++============ ++### Counting ++libkperf提供Counting模式，类似于perf stat功能。 ++例如，如下perf命令: ++``` ++perf stat -e cycles,branch-misses ++``` ++该命令是对系统采集cycles和branch-misses这两个事件的计数。 ++ ++对于libkperf，可以这样来设置PmuAttr： ++```c++ ++char *evtList[2]; ++evtList[0] = "cycles"; ++evtList[1] = "branch-misses"; ++PmuAttr attr = {0}; ++attr.evtList = evtList; ++attr.numEvt = 2; ++int pd = PmuOpen(COUNTING, &attr); ++``` ++通过调用```PmuOpen```初始化了采集任务，并获得了任务的标识符pd。 ++然后，可以利用pd来启动采集： ++```c++ ++PmuEnable(pd); ++sleep(any_duration); ++PmuDisable(pd); ++``` ++不论是否停止了采集，都可以通过```PmuRead```来读取采集数据： ++```c++ ++PmuData *data = NULL; ++int len = PmuRead(pd, &data); ++``` ++```PmuRead```会返回采集数据的长度。 ++如果是对系统采集，那么PmuData的长度等于core的数量乘以事件的数量，PmuData的数据类似如下： ++``` ++cpu 0 count 123 evt cycles ++cpu 1 count 1242354 evt cycles ++cpu 2 count 7897234 evt cycles ++... ++cpu 0 count 423423 evt branch-misses ++cpu 1 count 124235 evt branch-misses ++cpu 2 count 789723 evt branch-misses ++... ++``` ++如果是对进程采集，那么PmuData的长度等于进程内线程的数量乘以事件的数量，PmuData的数据类似如下： ++``` ++pid 4156 tid 4156 count 123 evt cycles ++pid 4156 tid 4157 count 534123 evt cycles ++pid 4156 tid 4158 count 1241244 evt cycles ++... ++pid 4156 tid 4156 count 12414 evt branch-misses ++pid 4156 tid 4157 count 5123 evt branch-misses ++pid 4156 tid 4158 count 64574 evt branch-misses ++... ++``` ++ ++### Sampling ++libkperf提供Sampling模式，类似于perf record的如下命令： ++``` ++perf record -e cycles,branch-misses ++``` ++该命令是对系统采样cycles和branch-misses这两个事件。 ++ ++设置PmuAttr的方式和Counting一样，在调用PmuOpen的时候，把任务类型设置为SAMPLING，并且设置采样频率： ++```c++ ++// 采样频率是1000HZ ++attr.freq = 1000; ++attr.useFreq = 1; ++int pd = PmuOpen(SAMPLING, &attr); ++``` ++ ++启动采集和读取数据的方式和Counting一致。 ++如果是对系统采集，PmuData的数据类似如下（长度取决于数据量）： ++``` ++cpu 0 pid 3145 tid 3145 period 12314352 ++cpu 0 pid 4145 tid 4145 period 12314367 ++... ++cpu 1 pid 23423 tid 23423 period 1231241 ++... ++... ++``` ++如果是对进程采集，PmuData的数据类似如下： ++``` ++cpu 32 pid 7878 tid 7878 period 123144 ++cpu 32 pid 7878 tid 7879 period 1523342 ++cpu 32 pid 7878 tid 7879 period 1234342 ++... ++``` ++每一条记录还包含触发事件的程序地址和符号信息，关于如何获取符号信息，可以参考[获取符号信息](#获取符号信息)这一章节。 ++ ++### SPE Sampling ++libkperf提供SPE采样模式，类似于perf record的如下命令： ++``` ++perf record -e arm_spe_0/load_filter=1/ ++``` ++该命令是对系统进行spe采样，关于linux spe采样的详细介绍，可以参考[这里](https://www.man7.org/linux/man-pages/man1/perf-arm-spe.1.html)。 ++ ++对于libkperf，可以这样设置PmuAttr： ++```c++ ++PmuAttr attr = {0}; ++// 采样周期是8192 ++attr.period = 8192; ++// 设置filter属性为load_filter ++attr.dataFilter = LOAD_FILTER; ++``` ++对于spe采样，不需要设置evtList，而是通过设置dataFilter和evFilter来指定需要采集的事件。dataFilter和evFilter的含义仍然可以参考[perf spe的说明文档](https://www.man7.org/linux/man-pages/man1/perf-arm-spe.1.html)。 ++ ++采样数据PmuData和Sampling模式差不多，差别是： ++- SPE采样的调用栈只有一层，而Sampling可以有多层调用栈。 ++- SPE的PmuData提供了额外的数据struct PmuDataExt *ext. ++PmuDataExt包含spe特有的数据：访存的物理地址、虚拟地址和事件bit。 ++```c++ ++struct PmuDataExt { ++ unsigned long pa; // physical address ++ unsigned long va; // virtual address ++ unsigned long event; // event id, which is a bit map of mixed events, event bit is defined in SPE_EVENTS. ++}; ++``` ++其中，物理地址pa需要在启用PA_ENABLE的情况下才能采集。 ++event是一个bit map，是多个事件的集合，每一个事件占据一个bit，事件对应的bit参考枚举SPE_EVENTS： ++```c++ ++enum SPE_EVENTS { ++ SPE_EV_EXCEPT = 1 << 0, ++ SPE_EV_RETIRED = 1 << 1, ++ SPE_EV_L1D_ACCESS = 1 << 2, ++ SPE_EV_L1D_REFILL = 1 << 3, ++ SPE_EV_TLB_ACCESS = 1 << 4, ++ SPE_EV_TLB_WALK = 1 << 5, ++ SPE_EV_NOT_TAKEN = 1 << 6, ++ SPE_EV_MISPRED = 1 << 7, ++ SPE_EV_LLC_ACCESS = 1 << 8, ++ SPE_EV_LLC_MISS = 1 << 9, ++ SPE_EV_REMOTE_ACCESS= 1 << 10, ++ SPE_EV_ALIGNMENT = 1 << 11, ++ SPE_EV_PARTIAL_PRED = 1 << 17, ++ SPE_EV_EMPTY_PRED = 1 << 18, ++}; ++``` ++ ++### 获取符号信息 ++结构体PmuData里提供了采样数据的调用栈信息，包含调用栈的地址、符号名称等。 ++```c++ ++struct Symbol { ++ unsigned long addr; ++ char* module; ++ char* symbolName; ++ char* fileName; ++ unsigned int lineNum; ++ ... ++}; ++ ++struct Stack { ++ struct Symbol* symbol; ++ struct Stack* next; ++ struct Stack* prev; ++ ... ++} __attribute__((aligned(64))); ++``` ++ ++Stack是链表结构，每一个元素都是一层调用函数。 ++```mermaid ++graph LR ++a(Symbol) --> b(Symbol) ++b --> c(Symbol) ++c --> d(......) ++``` ++ ++Symbol的字段信息受PmuAttr影响： ++- PmuAttr.callStack会决定Stack是完整的调用栈，还是只有一层调用栈（即Stack链表只有一个元素）。 ++- PmuAttr.symbolMode如果等于NO_SYMBOL_RESOLVE，那么PmuData的stack是空指针。 ++- PmuAttr.symbolMode如果等于RESOLVE_ELF，那么Symbol的fileName和lineNum没有数据，都等于0，因为没有解析dwarf信息。 ++- PmuAttr.symbolMode如果等于RESOLVE_ELF_DWARF，那么Symbol的所有信息都有效。 ++ ++### 采集uncore事件 ++libkperf支持uncore事件的采集，只有Counting模式支持uncore事件的采集（和perf一致）。 ++可以像这样设置PmuAttr： ++```c++ ++char *evtList[1]; ++evtList[0] = "hisi_sccl1_ddrc0/flux_rd/"; ++PmuAttr attr = {0}; ++attr.evtList = evtList; ++attr.numEvt = 1; ++int pd = PmuOpen(COUNTING, &attr); ++``` ++uncore事件的格式为```//```，上面代码是采集设备hisi_sccl1_ddrc0的flux_rd事件。 ++ ++也可以把设备索引号省略： ++```c++ ++evtList[0] = "hisi_sccl1_ddrc/flux_rd/"; ++``` ++这里把hisi_sccl1_ddrc0改为了hisi_sccl1_ddrc，这样会采集设备hisi_sccl1_ddrc0、hisi_sccl1_ddrc1、hisi_sccl1_ddrc2...，并且采集数据PmuData是所有设备数据的总和：count = count(hisi_sccl1_ddrc0) + count(hisi_sccl1_ddrc1) + count(hisi_sccl1_ddrc2) + ... ++ ++也可以通过```/config=0xxx/```的方式来指定事件名： ++```c++ ++evtList[0] = "hisi_sccl1_ddrc0/config=0x1/"; ++``` ++这样效果是和指定flux_rd是一样的。 ++ ++### 采集tracepoint ++libkperf支持tracepoint的采集，支持的tracepoint事件可以通过perf list来查看（通常需要root权限）。 ++可以这样设置PmuAttr： ++```c++ ++char *evtList[1]; ++evtList[0] = "sched:sched_switch"; ++PmuAttr attr = {0}; ++attr.evtList = evtList; ++attr.numEvt = 1; ++``` ++ ++tracepoint支持Counting和Sampling两种模式，API调用流程和两者相似。 ++tracepoint能够获取每个事件特有的数据，比如sched:sched_switch包含的数据有：prev_comm, prev_pid, prev_prio, prev_state, next_comm, next_pid, next_prio. ++想要查询每个事件包含哪些数据，可以查看/sys/kernel/tracing/events下面的文件内容，比如/sys/kernel/tracing/events/sched/sched_switch/format。 ++ ++libkperf提供了接口PmuGetField来获取tracepoint的数据。比如对于sched:sched_switch，可以这样调用： ++```c++ ++int prev_pid; ++PmuGetField(pmuData->rawData, "prev_pid", &prev_pid, sizeof(prev_pid)); ++char next_comm[16]; ++PmuGetField(pmuData->rawData, "next_comm", &next_comm, sizeof(next_comm)); ++``` ++这里调用者需要提前了解数据的类型，并且指定数据的大小。数据的类型和大小仍然可以从/sys/kernel/tracing/下每个事件的format文件来得知。 ++ ++### 事件分组 ++libkperf提供了事件分组的能力，能够让多个事件同时处于采集状态。 ++该功能类似于perf的如下使用方式： ++``` ++perf stat -e "{cycles,branch-loads,branch-load-misses,iTLB-loads}",inst_retired ++``` ++ ++对于libkperf，可以通过设置PmuAttr的evtAttr字段来设定哪些事件放在一个group内。 ++比如，可以这样调用： ++```c ++unsigned numEvt = 5; ++char *evtList[numEvt] = {"cycles","branch-loads","branch-load-misses","iTLB-loads","inst_retired"}; ++// 前四个事件是一个分组 ++struct EvtAttr groupId[numEvt] = {1,1,1,1,-1}; ++PmuAttr attr = {0}; ++attr.evtList = evtList; ++attr.numEvt = numEvt; ++attr.evtAttr = groupId; ++``` ++上述代码把前四个事件设定为一个分组，groupId都设定为1，最后一个事件不分组，groupId设定为-1。 ++事件数组attr.evtList和事件属性数组attr.evtAttr必须一一对应，即长度必须一致。 ++或者attr.evtAttr也可以是空指针，那么所有事件都不分组。 ++ ++事件分组的效果可以从PmuData.countPercent来体现。PmuData.countPercent表示事件实际采集时间除以事件期望采集时间。 ++对于同一组的事件，他们的countPercent是相同的。如果一个组的事件过多，超过了硬件计数器的数目，那么这个组的所有事件都不会被采集，countPercent会等于-1. ++ ++### 对进程子线程计数采集 ++```mermaid ++graph TD ++a(主线程) --perf stat--> b(创建线程) ++b --> c(子线程) ++c --end perf--> d(子线程退出) ++``` ++考虑上面的场景：用perf stat对进程采集，之后进程创建了子线程，采集一段事件后，停止perf。 ++查看采集结果，perf只会显示主线程的采集结果，而无法看到子线程的结果：count = count(main thread) + count(thread). perf把子线程的数据聚合到了主线程上。 ++ ++libkperf提供了采集子线程的能力。如果想要在上面场景中获取子线程的计数，可以把PmuAttr.incluceNewFork设置为1. ++```c++ ++attr.includeNewFork = 1; ++``` ++然后，通过PmuRead获取到的PmuData，便能包含子线程计数信息了。 ++注意，该功能是针对Counting模式，因为Sampling和SPE Sampling本身就会采集子线程的数据。 +\ No newline at end of file +-- +2.43.0 + diff --git a/0003-fix-after-pmuopen-delete-evtList-exception.patch b/0003-fix-after-pmuopen-delete-evtList-exception.patch new file mode 100644 index 0000000..7a6d699 --- /dev/null +++ b/0003-fix-after-pmuopen-delete-evtList-exception.patch @@ -0,0 +1,340 @@ +From 3e9e0c7f5d1a54b7688924243cc14707906a14cf Mon Sep 17 00:00:00 2001 +From: eho <2220386943@qq.com> +Date: Wed, 25 Sep 2024 16:34:45 +0800 +Subject: [PATCH 03/20] fix after pmuopen delete evtList exception if you + delete the pointer pointed to by attr.evtList immediately after pmuuopen is + successful, the event will be garbled. + +--- + build/common.sh | 4 ++ + pmu/pmu.cpp | 108 +++++++++++++++++++++++----------- + pmu/pmu_list.cpp | 26 +++++--- + pmu/pmu_list.h | 6 +- + test/test_perf/test_count.cpp | 57 ++++++++++++++++++ + 5 files changed, 155 insertions(+), 46 deletions(-) + +diff --git a/build/common.sh b/build/common.sh +index 9cc16b0..f48b64e 100644 +--- a/build/common.sh ++++ b/build/common.sh +@@ -15,6 +15,10 @@ set -e + + cpu_core_num=$(($(nproc)-1)) + ++if [ "$cpu_core_num" -eq 0 ];then ++ cpu_core_num=1 ++fi ++ + creat_dir(){ + local target_dir="$1" + if [ -d "${target_dir}" ];then +diff --git a/pmu/pmu.cpp b/pmu/pmu.cpp +index b7507ec..207d4fb 100644 +--- a/pmu/pmu.cpp ++++ b/pmu/pmu.cpp +@@ -160,17 +160,29 @@ static int CheckAttr(enum PmuTaskType collectType, struct PmuAttr *attr) + return LIBPERF_ERR_INVALID_SAMPLE_RATE; + } + +- if ((collectType == SAMPLING || collectType == COUNTING) && attr->evtAttr == nullptr) { +- struct EvtAttr *evtAttr = new struct EvtAttr[attr->numEvt]; ++ return SUCCESS; ++} ++ ++static void CopyAttrData(PmuAttr* newAttr, PmuAttr* inputAttr, enum PmuTaskType collectType) ++{ ++ //Coping event data to prevent delete exceptions ++ if (inputAttr->numEvt > 0) { ++ char **newEvtList = new char *[inputAttr->numEvt]; ++ for (int i = 0; i < inputAttr->numEvt; ++i) { ++ newEvtList[i] = new char[strlen(inputAttr->evtList[i]) + 1]; ++ strcpy(newEvtList[i], inputAttr->evtList[i]); ++ } ++ newAttr->evtList = newEvtList; ++ } ++ ++ if ((collectType == SAMPLING || collectType == COUNTING) && inputAttr->evtAttr == nullptr) { ++ struct EvtAttr *evtAttr = new struct EvtAttr[inputAttr->numEvt]; + // handle event group id. -1 means that it doesn't run event group feature. +- for (int i = 0; i < attr->numEvt; ++i) { ++ for (int i = 0; i < inputAttr->numEvt; ++i) { + evtAttr[i].group_id = -1; + } +- attr->evtAttr = evtAttr; +- ++ newAttr->evtAttr = evtAttr; + } +- +- return SUCCESS; + } + + static bool FreeEvtAttr(struct PmuAttr *attr) +@@ -196,6 +208,21 @@ static bool FreeEvtAttr(struct PmuAttr *attr) + return SUCCESS; + } + ++static void FreeEvtList(unsigned evtNum, char** evtList) ++{ ++ if (!evtList) { ++ return; ++ } ++ for (int i = 0; i < evtNum; i++) { ++ if (evtList[i]) { ++ delete[] evtList[i]; ++ evtList[i] = nullptr; ++ } ++ } ++ delete[] evtList; ++ evtList = nullptr; ++} ++ + static bool AppendChildEvents(char* evt, unordered_map& eventSplitMap) + { + string strName(evt); +@@ -304,51 +331,64 @@ static void PmuTaskAttrFree(PmuTaskAttr *taskAttr) + int PmuOpen(enum PmuTaskType collectType, struct PmuAttr *attr) + { + SetWarn(SUCCESS); ++ PmuAttr copiedAttr = {*attr}; ++ pair previousEventList = {0, nullptr}; + try { + auto err = CheckAttr(collectType, attr); + if (err != SUCCESS) { + return -1; + } ++ CopyAttrData(&copiedAttr, attr, collectType); ++ previousEventList = make_pair(copiedAttr.numEvt, copiedAttr.evtList); ++ int pd = -1; + unordered_map eventSplitMap; +- if (!SplitUncoreEvent(attr, eventSplitMap)) { +- return -1; +- } +- auto previousEventList = make_pair(attr->numEvt, attr->evtList); +- vector newEvtlist; +- vector newEvtAttrList; +- auto numEvt = GenerateSplitList(eventSplitMap, newEvtlist, attr, newEvtAttrList); +- FreeEvtAttr(attr); +- attr->numEvt = numEvt; +- attr->evtList = newEvtlist.data(); +- attr->evtAttr = newEvtAttrList.data(); +- +- auto pTaskAttr = AssignPmuTaskParam(collectType, attr); +- if (pTaskAttr == nullptr) { +- return -1; +- } +- unique_ptr taskAttr(pTaskAttr, PmuTaskAttrFree); ++ do { ++ if (!SplitUncoreEvent(&copiedAttr, eventSplitMap)) { ++ break; ++ } ++ vector newEvtlist; ++ vector newEvtAttrList; ++ auto numEvt = GenerateSplitList(eventSplitMap, newEvtlist, &copiedAttr, newEvtAttrList); ++ FreeEvtAttr(&copiedAttr); ++ copiedAttr.numEvt = numEvt; ++ copiedAttr.evtList = newEvtlist.data(); ++ copiedAttr.evtAttr = newEvtAttrList.data(); ++ ++ auto pTaskAttr = AssignPmuTaskParam(collectType, &copiedAttr); ++ if (pTaskAttr == nullptr) { ++ break; ++ } ++ unique_ptr taskAttr(pTaskAttr, PmuTaskAttrFree); ++ ++ pd = KUNPENG_PMU::PmuList::GetInstance()->NewPd(); ++ if (pd == -1) { ++ New(LIBPERF_ERR_NO_AVAIL_PD); ++ break; ++ } ++ ++ KUNPENG_PMU::PmuList::GetInstance()->SetSymbolMode(pd, attr->symbolMode); ++ err = KUNPENG_PMU::PmuList::GetInstance()->Register(pd, taskAttr.get()); ++ if (err != SUCCESS) { ++ PmuList::GetInstance()->Close(pd); ++ pd = -1; ++ } ++ New(err); ++ } while(false); + +- auto pd = KUNPENG_PMU::PmuList::GetInstance()->NewPd(); + if (pd == -1) { +- New(LIBPERF_ERR_NO_AVAIL_PD); ++ FreeEvtList(previousEventList.first, previousEventList.second); + return -1; + } +- +- KUNPENG_PMU::PmuList::GetInstance()->SetSymbolMode(pd, attr->symbolMode); +- err = KUNPENG_PMU::PmuList::GetInstance()->Register(pd, taskAttr.get()); +- if (err != SUCCESS) { +- PmuList::GetInstance()->Close(pd); +- pd = -1; +- } + // store eventList provided by user and the mapping relationship between the user eventList and the split + // eventList into buff + KUNPENG_PMU::PmuList::GetInstance()->StoreSplitData(pd, previousEventList, eventSplitMap); +- New(err); + return pd; + } catch (std::bad_alloc&) { ++ FreeEvtList(previousEventList.first, previousEventList.second); + New(COMMON_ERR_NOMEM); + return -1; + } catch (exception& ex) { ++ FreeEvtList(previousEventList.first, previousEventList.second); + New(UNKNOWN_ERROR, ex.what()); + return -1; + } +diff --git a/pmu/pmu_list.cpp b/pmu/pmu_list.cpp +index 0caba7b..4f293a7 100644 +--- a/pmu/pmu_list.cpp ++++ b/pmu/pmu_list.cpp +@@ -283,8 +283,8 @@ namespace KUNPENG_PMU { + return SUCCESS; + } + +- void PmuList::StoreSplitData(const unsigned pd, pair previousEventList, +- unordered_map eventSplitMap) ++ void PmuList::StoreSplitData(const unsigned pd, pair& previousEventList, ++ unordered_map& eventSplitMap) + { + lock_guard lg(dataParentMtx); + parentEventMap.emplace(pd, move(eventSplitMap)); +@@ -303,7 +303,7 @@ namespace KUNPENG_PMU { + RemoveEpollFd(pd); + EraseSpeCpu(pd); + EraseDummyEvent(pd); +- EraseParentEventMap(); ++ EraseParentEventMap(pd); + SymResolverDestroy(); + PmuEventListFree(); + PointerPasser::FreeRawFieldMap(); +@@ -409,15 +409,23 @@ namespace KUNPENG_PMU { + return dataEvtGroupList[pd]; + } + +- void PmuList::EraseParentEventMap() ++ void PmuList::EraseParentEventMap(const unsigned pd) + { + lock_guard lg(dataParentMtx); +- for (auto& pair: parentEventMap) { +- auto& innerMap = pair.second; +- innerMap.clear(); ++ auto iter = parentEventMap.find(pd); ++ if (iter != parentEventMap.end()) { ++ parentEventMap.at(pd).clear(); ++ parentEventMap.erase(iter); ++ } ++ auto preIter = previousEventMap.find(pd); ++ if (preIter != previousEventMap.end()) { ++ auto pair = previousEventMap.at(pd); ++ for (int i = 0; i < pair.first; i++) { ++ delete[] pair.second[i]; ++ } ++ delete[] pair.second; ++ previousEventMap.erase(preIter); + } +- parentEventMap.clear(); +- previousEventMap.clear(); + } + + PmuList::EventData& PmuList::GetDataList(const unsigned pd) +diff --git a/pmu/pmu_list.h b/pmu/pmu_list.h +index 80346eb..13724f8 100644 +--- a/pmu/pmu_list.h ++++ b/pmu/pmu_list.h +@@ -71,8 +71,8 @@ public: + int NewPd(); + + int GetHistoryData(const int pd, std::vector& pmuData); +- void StoreSplitData(unsigned pd, std::pair previousEventList, +- std::unordered_map eventSplitMap); ++ void StoreSplitData(unsigned pd, std::pair& previousEventList, ++ std::unordered_map& eventSplitMap); + bool IsAllPidExit(const unsigned pd); + + private: +@@ -95,7 +95,7 @@ private: + void InsertEvtList(const unsigned pd, std::shared_ptr evtList); + std::vector>& GetEvtList(const unsigned pd); + void EraseEvtList(const unsigned pd); +- void EraseParentEventMap(); ++ void EraseParentEventMap(const unsigned pd); + + int EvtInit(const bool groupEnable, const std::shared_ptr evtLeader, const int pd, const std::shared_ptr &evtList); + int Init(const int pd); +diff --git a/test/test_perf/test_count.cpp b/test/test_perf/test_count.cpp +index 1fda697..1b64497 100644 +--- a/test/test_perf/test_count.cpp ++++ b/test/test_perf/test_count.cpp +@@ -13,6 +13,7 @@ + * Description: Unit test for counting. + ******************************************************************************/ + #include "test_common.h" ++#include + + using namespace std; + +@@ -307,4 +308,60 @@ TEST_F(TestCount, SimdRatio) + ASSERT_EQ(evtMap.size(), evts.size()); + auto simdRatio = (double)evtMap[aseSpec]/evtMap[instSpec]; + ASSERT_GT(simdRatio, 0.1); ++} ++ ++static std::vector GetHHADirs() { ++ vector hhaEvents; ++ unique_ptr dir(opendir("/sys/devices"), &closedir); ++ if(!dir) { ++ return hhaEvents; ++ } ++ ++ struct dirent* dt; ++ while((dt = readdir(dir.get())) != nullptr) { ++ std::string name = dt->d_name; ++ if(name == "." || name == "..") { ++ continue; ++ } ++ ++ if(dt->d_type == DT_DIR && strstr(name.c_str(), "hha") != nullptr) { ++ hhaEvents.push_back(name + "/"); ++ } ++ } ++ return hhaEvents; ++} ++ ++ ++TEST_F(TestCount, DeleteEvtAfterOpenPmuu) { ++ struct PmuAttr attr = {nullptr}; ++ vector hhaEvents = GetHHADirs(); ++ ASSERT_TRUE(hhaEvents.size() > 0); ++ set evtNames; ++ vector eventsStr = {"rx_outer", "rx_sccl", "rx_ops_num"}; ++ int evtNum = hhaEvents.size() * eventsStr.size(); ++ char **evtList = new char *[evtNum]; ++ for (int i = 0; i < hhaEvents.size(); ++i) { ++ for (int j = 0; j < eventsStr.size(); ++j) { ++ int evtLen = hhaEvents[i].size() + eventsStr[j].size() + 2; ++ evtList[i * eventsStr.size() + j] = new char[evtLen]; ++ snprintf(evtList[i * eventsStr.size() + j], evtLen, "%s%s/", hhaEvents[i].c_str(), eventsStr[j].c_str()); ++ evtNames.emplace(hhaEvents[i] + eventsStr[j] + "/"); ++ } ++ } ++ attr.evtList = evtList; ++ attr.numEvt = evtNum; ++ int pd = PmuOpen(COUNTING, &attr); ++ for (int i = 0; i < evtNum; i++) { ++ delete[] evtList[i]; ++ } ++ delete[] evtList; ++ PmuEnable(pd); ++ sleep(1); ++ PmuDisable(pd); ++ PmuData* pmuData = nullptr; ++ int len = PmuRead(pd, &pmuData); ++ for(int i = 0; i < len; i++) { ++ ASSERT_TRUE(evtNames.find(pmuData[i].evt) != evtNames.end()); ++ } ++ PmuClose(pd); + } +\ No newline at end of file +-- +2.43.0 + diff --git a/0004-Delete-the-repeated-judgement-on-formatPath.patch b/0004-Delete-the-repeated-judgement-on-formatPath.patch new file mode 100644 index 0000000..d828cb9 --- /dev/null +++ b/0004-Delete-the-repeated-judgement-on-formatPath.patch @@ -0,0 +1,62 @@ +From 109fd9f0140668eac0ff48415ca99c4f82853503 Mon Sep 17 00:00:00 2001 +From: eho <2220386943@qq.com> +Date: Tue, 8 Oct 2024 10:31:41 +0800 +Subject: [PATCH 04/20] Delete the repeated judgement on formatPath + +--- + pmu/trace_pointer_parser.cpp | 22 +++++++++++++++------- + 1 file changed, 15 insertions(+), 7 deletions(-) + +diff --git a/pmu/trace_pointer_parser.cpp b/pmu/trace_pointer_parser.cpp +index 4417494..235808a 100644 +--- a/pmu/trace_pointer_parser.cpp ++++ b/pmu/trace_pointer_parser.cpp +@@ -26,22 +26,30 @@ const char *POINTER_OFFSET_REGEX = "%*[^0-9]%i%*[;] %*[^0-9]%i%*[;] %*[^0-9]%i%* + static std::unordered_map> efMap; //the key is event name, value is field and ths field name map. + static std::unordered_map dEvtMap; //The key is the data pointer, value is event name. + static std::map fsrMap; ++static std::unordered_map formatMap; + +-bool PointerPasser::IsNeedFormat(std::ifstream &file, const std::string &evtName) { ++static std::string GetFormatRealPath(const std::string &evtName) { + auto colonId = evtName.find(':'); + if (colonId == string::npos) { +- return false; ++ return {}; + } + string eventName = evtName.substr(colonId + 1); + string systemName = evtName.substr(0, colonId); + const string &eventDir = GetTraceEventDir(); + if (eventDir.empty()) { +- return false; ++ return {}; + } + string formatPath = eventDir + systemName + "/" + eventName + "/format"; +- string realPath = GetRealPath(formatPath); +- if (realPath.empty()) { +- return false; ++ return GetRealPath(formatPath); ++} ++ ++bool PointerPasser::IsNeedFormat(std::ifstream &file, const std::string &evtName) { ++ std::string realPath; ++ if (formatMap.find(evtName) != formatMap.end()) { ++ realPath = formatMap.at(evtName); ++ } else { ++ realPath = GetFormatRealPath(evtName); ++ formatMap.emplace(evtName, realPath); + } + if (!IsValidPath(realPath)) { + return false; +@@ -88,7 +96,7 @@ void PointerPasser::ParserRawFormatData(struct PmuData *pd, KUNPENG_PMU::PerfRaw + union KUNPENG_PMU::PerfEvent *event, + const std::string &evtName) { + ifstream file; +- if (!IsNeedFormat(file, evtName)) { ++ if (efMap.find(evtName) == efMap.end() && !IsNeedFormat(file, evtName)) { + pd->rawData = nullptr; + return; + } +-- +2.43.0 + diff --git a/0005-pmu-event.patch b/0005-pmu-event.patch new file mode 100644 index 0000000..3404efb --- /dev/null +++ b/0005-pmu-event.patch @@ -0,0 +1,147 @@ +From 4a084d12ceb0129c8b901798282ef89f3df13bf2 Mon Sep 17 00:00:00 2001 +From: ganlixiong +Date: Fri, 11 Oct 2024 10:50:07 +0800 +Subject: [PATCH 05/20] =?UTF-8?q?=E4=BF=AE=E5=A4=8D=E5=9C=A8=E6=9F=90?= + =?UTF-8?q?=E4=BA=9B=E7=8E=AF=E5=A2=83=E4=B8=8A=E6=97=A0=E6=B3=95=E8=AF=BB?= + =?UTF-8?q?=E5=8F=96=E5=88=B0pmu=20event=E7=9A=84=E9=97=AE=E9=A2=98?= + =?UTF-8?q?=E3=80=82?= +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +问题： +在某些环境上调用PmuEventList，返回的事件列表为空。 + +原因： +该环境上的arm core设备名称为armv8_pmuv3，而在查询事件列表时，搜索了armv8_pmuv3_0设备的事件。 + +解决方法： +动态寻找arm core设备，而不是用硬编码。参考perf +tool的实现，查询devices下面的所有设备，如果设备下面包含文件cpus，那么认为该设备为arm +core设备。 +--- + pmu/pfm/core.cpp | 44 +++++++++++++++++++++++++++++++++++++++--- + pmu/pfm/core.h | 2 ++ + pmu/pmu_event_list.cpp | 10 ++++++++-- + 3 files changed, 51 insertions(+), 5 deletions(-) + +diff --git a/pmu/pfm/core.cpp b/pmu/pfm/core.cpp +index 80d5e0b..0ab4607 100644 +--- a/pmu/pfm/core.cpp ++++ b/pmu/pfm/core.cpp +@@ -15,6 +15,7 @@ + #include + #include + #include ++#include + #include "pmu_event.h" + #include "core.h" + #include "common.h" +@@ -22,7 +23,7 @@ + using namespace std; + using PMU_PAIR = std::pair; + static CHIP_TYPE g_chipType = UNDEFINED_TYPE; +- ++static string pmuDevice = ""; + + namespace SOFTWARE_EVENT { + PMU_PAIR ALIGNMENT_FAULTS = { +@@ -853,7 +854,11 @@ static struct PmuEvt* ConstructPmuEvtFromCore(KUNPENG_PMU::CoreConfig config, in + + static int64_t GetKernelCoreEventConfig(const string &name) + { +- string eventPath = "/sys/devices/armv8_pmuv3_0/events/" + name; ++ auto pmuDevicePath = GetPmuDevicePath(); ++ if (pmuDevicePath.empty()) { ++ return -1; ++ } ++ string eventPath = pmuDevicePath + "/events/" + name; + string realPath = GetRealPath(eventPath); + if (!IsValidPath(realPath)) { + return -1; +@@ -874,7 +879,11 @@ static int64_t GetKernelCoreEventConfig(const string &name) + + static int64_t GetKernelCoreEventType() + { +- string eventPath = "/sys/devices/armv8_pmuv3_0/type"; ++ auto pmuDevicePath = GetPmuDevicePath(); ++ if (pmuDevicePath.empty()) { ++ return -1; ++ } ++ string eventPath = pmuDevicePath + "/type"; + string realPath = GetRealPath(eventPath); + if (!IsValidPath(realPath)) { + return -1; +@@ -917,4 +926,33 @@ struct PmuEvt* GetCoreEvent(const char* pmuName, int collectType) + return ConstructPmuEvtFromCore(KUNPENG_PMU::CORE_EVENT_MAP.at(g_chipType).at(pmuName), collectType); + } + return ConstructPmuEvtFromKernel(pmuName, collectType); ++} ++ ++std::string GetPmuDevicePath() ++{ ++ if (!pmuDevice.empty()) { ++ return pmuDevice; ++ } ++ ++ static const string DEVICE_PATH = "/sys/bus/event_source/devices/"; ++ DIR *dir = opendir(DEVICE_PATH.c_str()); ++ if (dir == nullptr) { ++ return ""; ++ } ++ struct dirent *dent; ++ while (dent = readdir(dir)) { ++ if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, "..") || !strcmp(dent->d_name, "cpu")) { ++ continue; ++ } ++ ++ // look for devices like /sys/bus/event_source/devices/armv8_pmuv3_0/cpus. ++ // Refer to function in kernel. ++ string armPmuPath = DEVICE_PATH + dent->d_name + "/cpus"; ++ if (ExistPath(armPmuPath)) { ++ pmuDevice = DEVICE_PATH + dent->d_name; ++ break; ++ } ++ } ++ ++ return pmuDevice; + } +\ No newline at end of file +diff --git a/pmu/pfm/core.h b/pmu/pfm/core.h +index 0df6a25..4ecf3fe 100644 +--- a/pmu/pfm/core.h ++++ b/pmu/pfm/core.h +@@ -24,5 +24,7 @@ namespace KUNPENG_PMU { + + struct PmuEvt* GetCoreEvent(const char* pmuName, int collectType); + ++std::string GetPmuDevicePath(); ++ + #endif + +diff --git a/pmu/pmu_event_list.cpp b/pmu/pmu_event_list.cpp +index 2007561..c4cf226 100644 +--- a/pmu/pmu_event_list.cpp ++++ b/pmu/pmu_event_list.cpp +@@ -127,10 +127,16 @@ const char** QueryCoreEvent(unsigned *numEvt) + } + DIR* dir; + struct dirent* entry; +- string path = "/sys/devices/armv8_pmuv3_0/events/"; ++ auto pmuDevPath = GetPmuDevicePath(); ++ if (pmuDevPath.empty()) { ++ *numEvt = coreEventList.size(); ++ return coreEventList.data(); ++ } ++ string path = pmuDevPath + "/events/"; + dir = opendir(path.c_str()); + if (dir == nullptr) { +- return nullptr; ++ *numEvt = coreEventList.size(); ++ return coreEventList.data(); + } + while ((entry = readdir(dir)) != nullptr) { + if (entry->d_type == DT_REG) { +-- +2.43.0 + diff --git a/0006-adapt-events.patch b/0006-adapt-events.patch new file mode 100644 index 0000000..b1f4860 --- /dev/null +++ b/0006-adapt-events.patch @@ -0,0 +1,110 @@ +From 2e4695bff251032e023098e4ec25ff43d6690faf Mon Sep 17 00:00:00 2001 +From: eho <2220386943@qq.com> +Date: Sat, 12 Oct 2024 15:47:28 +0800 +Subject: [PATCH 06/20] adapt events + +--- + pmu/pfm/core.cpp | 40 ++++++++++++++++++++++++++++++++++++++++ + pmu/pmu_event_list.cpp | 2 +- + util/cpu_map.cpp | 3 ++- + util/cpu_map.h | 1 + + 4 files changed, 44 insertions(+), 2 deletions(-) + +diff --git a/pmu/pfm/core.cpp b/pmu/pfm/core.cpp +index 0ab4607..55e5921 100644 +--- a/pmu/pfm/core.cpp ++++ b/pmu/pfm/core.cpp +@@ -833,11 +833,51 @@ const std::unordered_map HIP_F_CORE_PMU_MA + SOFTWARE_EVENT::TASK_CLOCK, + }; + ++const std::unordered_map HIP_E_CORE_PMU_MAP{ ++ HARDWARE_EVENT::BRANCH_MISSES, ++ HARDWARE_EVENT::CACHE_MISSES, ++ HARDWARE_EVENT::CACHE_REFERENCES, ++ HARDWARE_EVENT::CPU_CYCLES, ++ HARDWARE_EVENT::CYCLES, ++ HARDWARE_EVENT::INSTRUCTIONS, ++ HARDWARE_EVENT::STALLED_CYCLES_BACKEND, ++ HARDWARE_EVENT::STALLED_CYCLES_FRONTED, ++ HARDWARE_EVENT::IDLE_CYCLES_BACKEND, ++ HARDWARE_EVENT::IDLE_CYCLES_FRONTED, ++ HW_CACHE_EVENT::L1_DCACHE_LOAD_MISSES, ++ HW_CACHE_EVENT::L1_DCACHE_LOADS, ++ HW_CACHE_EVENT::L1_ICACHE_LOAD_MISSES, ++ HW_CACHE_EVENT::L1_ICACHE_LOADS, ++ HW_CACHE_EVENT::LLC_LOAD_MISSES, ++ HW_CACHE_EVENT::LLC_LOADS, ++ HW_CACHE_EVENT::BRANCH_LOAD_MISSES, ++ HW_CACHE_EVENT::BRANCH_LOADS, ++ HW_CACHE_EVENT::DTLB_LOAD_MISSES, ++ HW_CACHE_EVENT::DTLB_LOADS, ++ HW_CACHE_EVENT::ITLB_LOAD_MISSES, ++ HW_CACHE_EVENT::ITLB_LOADS, ++ SOFTWARE_EVENT::ALIGNMENT_FAULTS, ++ SOFTWARE_EVENT::BPF_OUTPUT, ++ SOFTWARE_EVENT::CONTEXT_SWITCHES, ++ SOFTWARE_EVENT::CS, ++ SOFTWARE_EVENT::CPU_CLOCK, ++ SOFTWARE_EVENT::CPU_MIGRATIONS, ++ SOFTWARE_EVENT::MIGRATIONS, ++ SOFTWARE_EVENT::DUMMY, ++ SOFTWARE_EVENT::EMULATION_FAULTS, ++ SOFTWARE_EVENT::MAJOR_FAULTS, ++ SOFTWARE_EVENT::MINOR_FAULTS, ++ SOFTWARE_EVENT::PAGE_FAULTS, ++ SOFTWARE_EVENT::FAULTS, ++ SOFTWARE_EVENT::TASK_CLOCK, ++}; ++ + const KUNPENG_PMU::CORE_EVT_MAP KUNPENG_PMU::CORE_EVENT_MAP = { + {CHIP_TYPE::HIPA, HIP_A_CORE_PMU_MAP}, + {CHIP_TYPE::HIPB, HIP_B_CORE_PMU_MAP}, + {CHIP_TYPE::HIPC, HIP_C_CORE_PMU_MAP}, + {CHIP_TYPE::HIPF, HIP_F_CORE_PMU_MAP}, ++ {CHIP_TYPE::HIPE, HIP_E_CORE_PMU_MAP}, + }; + + static struct PmuEvt* ConstructPmuEvtFromCore(KUNPENG_PMU::CoreConfig config, int collectType) +diff --git a/pmu/pmu_event_list.cpp b/pmu/pmu_event_list.cpp +index c4cf226..b96e500 100644 +--- a/pmu/pmu_event_list.cpp ++++ b/pmu/pmu_event_list.cpp +@@ -37,7 +37,7 @@ static const string EVENT_DIR = "/events/"; + + static std::mutex pmuEventListMtx; + +-static vector supportDevPrefixs = {"hisi", "smmuv3"}; ++static vector supportDevPrefixs = {"hisi", "smmuv3", "hns3"}; + + static vector uncoreEventList; + static vector traceEventList; +diff --git a/util/cpu_map.cpp b/util/cpu_map.cpp +index 7ed2cd2..ec8f077 100644 +--- a/util/cpu_map.cpp ++++ b/util/cpu_map.cpp +@@ -33,7 +33,8 @@ static CHIP_TYPE g_chipType = CHIP_TYPE::UNDEFINED_TYPE; + static map chipMap = {{"0x00000000481fd010", HIPA}, + {"0x00000000480fd020", HIPB}, + {"0x00000000480fd030", HIPC}, +- {"0x00000000480fd220", HIPF}}; ++ {"0x00000000480fd220", HIPF}, ++ {"0x00000000480fd450", HIPE},}; + + static inline bool ReadCpuPackageId(int coreId, CpuTopology* cpuTopo) + { +diff --git a/util/cpu_map.h b/util/cpu_map.h +index de38af5..58c61b8 100644 +--- a/util/cpu_map.h ++++ b/util/cpu_map.h +@@ -26,6 +26,7 @@ enum CHIP_TYPE { + HIPB = 2, + HIPC = 3, + HIPF = 4, ++ HIPE = 5, + }; + + struct CpuTopology* GetCpuTopology(int coreId); +-- +2.43.0 + diff --git a/0007-update-python-modules-_libkperf-Pmu.py.patch b/0007-update-python-modules-_libkperf-Pmu.py.patch new file mode 100644 index 0000000..7d3d6f5 --- /dev/null +++ b/0007-update-python-modules-_libkperf-Pmu.py.patch @@ -0,0 +1,30 @@ +From 8d93617bed18193386102587841a0eab2da207d5 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?=E8=8F=A0=E8=90=9D=E6=9C=89=E7=82=B9=E9=85=B8?= + +Date: Sat, 12 Oct 2024 08:45:14 +0000 +Subject: [PATCH 07/20] update python/modules/_libkperf/Pmu.py. +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Signed-off-by: 菠萝有点酸 +--- + python/modules/_libkperf/Pmu.py | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/python/modules/_libkperf/Pmu.py b/python/modules/_libkperf/Pmu.py +index 9c111bf..c743d7d 100644 +--- a/python/modules/_libkperf/Pmu.py ++++ b/python/modules/_libkperf/Pmu.py +@@ -639,7 +639,7 @@ class CtypesPmuData(ctypes.Structure): + const char *comm; // process command + uint64_t period; // number of Samples + uint64_t count; // event count. Only available for Counting. +- double countPercent; // event count percent. when count = 0, countPercent = -1; Only avaliable for Counting. ++ double countPercent; // event count percent. when count = 0, countPercent = -1; Only available for Counting. + struct PmuDataExt *ext; // extension. Only available for Spe. + }; + """ +-- +2.43.0 + diff --git a/0008-.patch b/0008-.patch new file mode 100644 index 0000000..ea5e590 --- /dev/null +++ b/0008-.patch @@ -0,0 +1,56 @@ +From 4e13130c164640cc02470074cb816047159159d2 Mon Sep 17 00:00:00 2001 +From: lixiang +Date: Tue, 15 Oct 2024 09:20:40 +0800 +Subject: [PATCH 08/20] =?UTF-8?q?=E6=8F=90=E4=BA=A4=E4=BF=AE=E6=94=B9?= +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +--- + pmu/CMakeLists.txt | 2 +- + pmu/evt_list.h | 2 +- + python/tests/test_api.py | 2 +- + 3 files changed, 3 insertions(+), 3 deletions(-) + +diff --git a/pmu/CMakeLists.txt b/pmu/CMakeLists.txt +index 189e43e..c68bfe0 100644 +--- a/pmu/CMakeLists.txt ++++ b/pmu/CMakeLists.txt +@@ -25,7 +25,7 @@ include_directories(${PROJECT_TOP_DIR}/include) + include_directories(${PMU_FILE_DIR}/) + include_directories(${PFM_FILE_DIR}) + +-# directories for ultilities and symbol resolving ++# directories for utilities and symbol resolving + include_directories(${UTIL_FILE_DIR}) + include_directories(${SYMBOL_FILE_DIR}) + include_directories(${PMU_DECODER_DIR}) +diff --git a/pmu/evt_list.h b/pmu/evt_list.h +index 802e7cf..50b888e 100644 +--- a/pmu/evt_list.h ++++ b/pmu/evt_list.h +@@ -131,7 +131,7 @@ struct EventGroupInfo { + // store event group child events state flag info + /* event group child state explain: + * Enumeration variable uncoreState has four state, Initialization is the InitState; +- * sacn the event List, if find the uncore event, the uncoreState is config the high bit set to 1; ++ * scan the event List, if found the uncore event, the uncoreState is configured with the high bit set to 1; + * if find the other event, the uncoreState is config the low bit set to 0. + */ + enum class UncoreState uncoreState; +diff --git a/python/tests/test_api.py b/python/tests/test_api.py +index e62294b..7e32437 100644 +--- a/python/tests/test_api.py ++++ b/python/tests/test_api.py +@@ -52,7 +52,7 @@ def TestAPI_SpeInitBusy(): + print(f"error number: {kperf.errorno()} error message: {kperf.error()}") + badpd = kperf.open(kperf.PmuTaskType.SPE_SAMPLING, pmu_attr) + if badpd == -1: +- print(f"badpd rror number: {kperf.errorno()} badpd error message: {kperf.error()}") ++ print(f"badpd error number: {kperf.errorno()} badpd error message: {kperf.error()}") + kperf.close(badpd) + + def TestAPI_OpenInvalidTaskType(): +-- +2.43.0 + diff --git a/0009-adapt-gcc-4.8.5.patch b/0009-adapt-gcc-4.8.5.patch new file mode 100644 index 0000000..afcee85 --- /dev/null +++ b/0009-adapt-gcc-4.8.5.patch @@ -0,0 +1,25 @@ +From 31b4552c07cc0216a0d1834c3c67c645129332ad Mon Sep 17 00:00:00 2001 +From: eho <2220386943@qq.com> +Date: Tue, 15 Oct 2024 16:39:20 +0800 +Subject: [PATCH 09/20] adapt gcc 4.8.5 + +--- + pmu/pmu.cpp | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/pmu/pmu.cpp b/pmu/pmu.cpp +index 207d4fb..d2f4c9f 100644 +--- a/pmu/pmu.cpp ++++ b/pmu/pmu.cpp +@@ -331,7 +331,7 @@ static void PmuTaskAttrFree(PmuTaskAttr *taskAttr) + int PmuOpen(enum PmuTaskType collectType, struct PmuAttr *attr) + { + SetWarn(SUCCESS); +- PmuAttr copiedAttr = {*attr}; ++ PmuAttr copiedAttr = *attr; + pair previousEventList = {0, nullptr}; + try { + auto err = CheckAttr(collectType, attr); +-- +2.43.0 + diff --git a/0010-fix-spelling-error.patch b/0010-fix-spelling-error.patch new file mode 100644 index 0000000..08a4cdf --- /dev/null +++ b/0010-fix-spelling-error.patch @@ -0,0 +1,48 @@ +From d0e12d3418b1ba52f0dd5e75e94543b6e7322e91 Mon Sep 17 00:00:00 2001 +From: baixu +Date: Tue, 15 Oct 2024 16:47:07 +0800 +Subject: [PATCH 10/20] fix spelling error + +--- + include/pcerrc.h | 4 ++-- + python/modules/kperf/perror.py | 2 +- + 2 files changed, 3 insertions(+), 3 deletions(-) + +diff --git a/include/pcerrc.h b/include/pcerrc.h +index 13c04e9..c2dd791 100644 +--- a/include/pcerrc.h ++++ b/include/pcerrc.h +@@ -82,7 +82,7 @@ extern "C" { + + #define UNKNOWN_ERROR 9999 + +-// warnning code ++// warning code + #define LIBPERF_WARN_CTXID_LOST 1000 + #define LIBPERF_WARN_FAIL_GET_PROC 1001 + #define LIBPERF_WARN_INVALID_GROUP_HAS_UNCORE 1002 +@@ -97,7 +97,7 @@ int Perrorno(); + const char* Perror(); + + /**. +- * @brief Get warnning codes ++ * @brief Get warning codes + */ + int GetWarn(); + +diff --git a/python/modules/kperf/perror.py b/python/modules/kperf/perror.py +index 6f5cfb3..097f1f6 100644 +--- a/python/modules/kperf/perror.py ++++ b/python/modules/kperf/perror.py +@@ -81,7 +81,7 @@ class Error: + + UNKNOWN_ERROR = 9999 + +- # warnning code ++ # warning code + LIBPERF_WARN_CTXID_LOST = 1000 + LIBPERF_WARN_FAIL_GET_PROC = 1001 + LIBPERF_WARN_INVALID_GROUP_HAS_UNCORE = 1002 +-- +2.43.0 + diff --git a/0011-add-perrno-operation-not-supported.patch b/0011-add-perrno-operation-not-supported.patch new file mode 100644 index 0000000..0beabf1 --- /dev/null +++ b/0011-add-perrno-operation-not-supported.patch @@ -0,0 +1,51 @@ +From c9c20f95f9f58c10af07850bad2a0b33d97a71d8 Mon Sep 17 00:00:00 2001 +From: eho <2220386943@qq.com> +Date: Thu, 24 Oct 2024 10:35:40 +0800 +Subject: [PATCH 11/20] add perrno operation not supported. + +--- + pmu/pmu_event.cpp | 2 ++ + test/test_perf/test_api.cpp | 16 +++++++++++++++- + 2 files changed, 17 insertions(+), 1 deletion(-) + +diff --git a/pmu/pmu_event.cpp b/pmu/pmu_event.cpp +index 8a0bdc6..71a3616 100644 +--- a/pmu/pmu_event.cpp ++++ b/pmu/pmu_event.cpp +@@ -30,6 +30,8 @@ namespace KUNPENG_PMU { + return LIBPERF_ERR_NO_PROC; + case EMFILE: + return LIBPERF_ERR_TOO_MANY_FD; ++ case EOPNOTSUPP: ++ return LIBPERF_ERR_INVALID_EVENT; + default: + return UNKNOWN_ERROR; + } +diff --git a/test/test_perf/test_api.cpp b/test/test_perf/test_api.cpp +index 20f0de2..5cf9213 100644 +--- a/test/test_perf/test_api.cpp ++++ b/test/test_perf/test_api.cpp +@@ -601,4 +601,18 @@ TEST_F(TestAPI, TestSPEEventGroup) + attr.evtAttr = groupId; + pd = PmuOpen(SPE_SAMPLING, &attr); + ASSERT_TRUE(pd == -1); +-} +\ No newline at end of file ++} ++ ++TEST_F(TestAPI, TestOperationNotSupported) ++{ ++ PmuAttr attr = {0}; ++ char* evtList[1] = {"hisi_sccl3_ddrc2/flux_rd/"}; ++ attr.evtList = evtList; ++ attr.numEvt = 1; ++ attr.freq = 1000; ++ attr.useFreq = 1; ++ attr.symbolMode = RESOLVE_ELF; ++ int pd = PmuOpen(SAMPLING, &attr); ++ ASSERT_EQ(pd, -1); ++ ASSERT_EQ(Perrorno(), LIBPERF_ERR_INVALID_EVENT); ++} +-- +2.43.0 + diff --git a/0012-UT-SpeProcCollectSubProc.patch b/0012-UT-SpeProcCollectSubProc.patch new file mode 100644 index 0000000..5b776aa --- /dev/null +++ b/0012-UT-SpeProcCollectSubProc.patch @@ -0,0 +1,44 @@ +From 065ba5f7493b1d27fd5320c99b597e2d96fb3396 Mon Sep 17 00:00:00 2001 +From: glx +Date: Tue, 29 Oct 2024 11:25:00 +0800 +Subject: [PATCH 12/20] =?UTF-8?q?=E4=BF=AE=E5=A4=8DUT=E7=94=A8=E4=BE=8BSpe?= + =?UTF-8?q?ProcCollectSubProc=E3=80=82?= +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +问题： +UT用例SpeProcCollectSubProc报错。 + +原因： +用例SpeProcCollectSubProc执行过程：启动应用，开始采集，应用fork进程，校验子进程是否被采集到。 +子进程未被采集到，因为UpdateProcMap函数里未找到子进程的父进程，所以子进程没有被添加到procMap。 + +解决方法： +对于fork子进程的场景，父进程应该是ppid，而不是pid，可以把ppid传入到UpdateProcMap。 +--- + pmu/spe.cpp | 8 +++++++- + 1 file changed, 7 insertions(+), 1 deletion(-) + +diff --git a/pmu/spe.cpp b/pmu/spe.cpp +index 99b7a89..4d964fb 100644 +--- a/pmu/spe.cpp ++++ b/pmu/spe.cpp +@@ -372,7 +372,13 @@ void Spe::CoreDummyData(struct SpeCoreContext *context, struct ContextSwitchData + if (header->type == PERF_RECORD_FORK) { + struct PerfRecordFork *sample = (struct PerfRecordFork *)header; + DBG_PRINT("Fork pid: %d tid: %d\n", sample->pid, sample->tid); +- UpdateProcMap(sample->pid, sample->tid); ++ if (sample->pid == sample->tid) { ++ // A new process is forked and the parent pid is ppid. ++ UpdateProcMap(sample->ppid, sample->tid); ++ } else { ++ // A new thread is created and the parent pid is pid(process id). ++ UpdateProcMap(sample->pid, sample->tid); ++ } + dataTail += header->size; + continue; + } +-- +2.43.0 + diff --git a/0013-simplify-CoreSpeData-call-by-removing-redundant-buf-.patch b/0013-simplify-CoreSpeData-call-by-removing-redundant-buf-.patch new file mode 100644 index 0000000..48bd616 --- /dev/null +++ b/0013-simplify-CoreSpeData-call-by-removing-redundant-buf-.patch @@ -0,0 +1,29 @@ +From e0142fbd0fe30ae684079342881bfb0e45be51b6 Mon Sep 17 00:00:00 2001 +From: gubin +Date: Tue, 29 Oct 2024 13:48:06 +0800 +Subject: [PATCH 13/20] simplify CoreSpeData call by removing redundant buf + assignment + +Removed unnecessary assignment to buf and directly operated on the provided buffer. + +Signed-off-by: gubin +--- + pmu/spe.cpp | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/pmu/spe.cpp b/pmu/spe.cpp +index 99b7a89..5083ff0 100644 +--- a/pmu/spe.cpp ++++ b/pmu/spe.cpp +@@ -529,7 +529,7 @@ int Spe::SpeReadData(struct SpeContext *context, struct SpeRecord *buf, int size + int remainSize = size; + int dummySize = context->dummyMmapSize; + CoreDummyData(context->coreCtxes, dummyData, dummySize, context->pageSize); +- buf = CoreSpeData(context->coreCtxes, dummyData, buf, &remainSize, context->pageSize, cpu); ++ CoreSpeData(context->coreCtxes, dummyData, buf, &remainSize, context->pageSize, cpu); + return size - remainSize; + } + +-- +2.43.0 + diff --git a/0014-Update-Details.md.patch b/0014-Update-Details.md.patch new file mode 100644 index 0000000..4dd42fb --- /dev/null +++ b/0014-Update-Details.md.patch @@ -0,0 +1,101 @@ +From 6309460981655bd0899bc5ca65af123c2e42b638 Mon Sep 17 00:00:00 2001 +From: glx +Date: Tue, 29 Oct 2024 15:19:06 +0800 +Subject: [PATCH 14/20] Update Details.md + +--- + docs/Details.md | 80 ++++++++++++++++++++++++++++++++++++++++++++++++- + 1 file changed, 79 insertions(+), 1 deletion(-) + +diff --git a/docs/Details.md b/docs/Details.md +index db0b407..14ca694 100644 +--- a/docs/Details.md ++++ b/docs/Details.md +@@ -261,4 +261,82 @@ libkperf提供了采集子线程的能力。如果想要在上面场景中获取 + attr.includeNewFork = 1; + ``` + 然后，通过PmuRead获取到的PmuData，便能包含子线程计数信息了。 +-注意，该功能是针对Counting模式，因为Sampling和SPE Sampling本身就会采集子线程的数据。 +\ No newline at end of file ++注意，该功能是针对Counting模式，因为Sampling和SPE Sampling本身就会采集子线程的数据。 ++ ++### 采集DDRC带宽 ++基于uncore事件可以计算DDRC的访存带宽，不同硬件平台有不同的计算方式。 ++鲲鹏芯片上的访存带宽公式可以参考openeuler kernel的tools/perf/pmu-events/arch/arm64/hisilicon/hip09/sys/uncore-ddrc.json： ++```json ++ { ++ "MetricExpr": "flux_wr * 32 / duration_time", ++ "BriefDescription": "Average bandwidth of DDRC memory write(Byte/s)", ++ "Compat": "0x00000030", ++ "MetricGroup": "DDRC", ++ "MetricName": "ddrc_bw_write", ++ "Unit": "hisi_sccl,ddrc" ++ }, ++ { ++ "MetricExpr": "flux_rd * 32 / duration_time", ++ "BriefDescription": "Average bandwidth of DDRC memory read(Byte/s)", ++ "Compat": "0x00000030", ++ "MetricGroup": "DDRC", ++ "MetricName": "ddrc_bw_read", ++ "Unit": "hisi_sccl,ddrc" ++ }, ++``` ++ ++根据公式，采集flux_wr和flux_rd事件，用于计算带宽： ++```c++ ++ // 采集hisi_scclX_ddrc设备下的flux_rd和flux_wr， ++ // 具体设备名称因硬件而异，可以在/sys/devices/下查询。 ++ vector evts = { ++ "hisi_sccl1_ddrc/flux_rd/", ++ "hisi_sccl3_ddrc/flux_rd/", ++ "hisi_sccl5_ddrc/flux_rd/", ++ "hisi_sccl7_ddrc/flux_rd/", ++ "hisi_sccl1_ddrc/flux_wr/", ++ "hisi_sccl3_ddrc/flux_wr/", ++ "hisi_sccl5_ddrc/flux_wr/", ++ "hisi_sccl7_ddrc/flux_wr/" ++ }; ++ ++ PmuAttr attr = {0}; ++ attr.evtList = evts.data(); ++ attr.numEvt = evts.size(); ++ ++ int pd = PmuOpen(COUNTING, &attr); ++ if (pd == -1) { ++ cout << Perror() << "\n"; ++ return; ++ } ++ ++ PmuEnable(pd); ++ for (int i=0;i<60;++i) { ++ sleep(1); ++ PmuData *data = nullptr; ++ int len = PmuRead(pd, &data); ++ // 有8个uncore事件，所以data的长度等于8. ++ // 前4个是4个numa的read带宽，后4个是4个numa的write带宽。 ++ for (int j=0;j<4;++j) { ++ printf("read bandwidth: %f M/s\n", (float)data[j].count*32/1024/1024); ++ } ++ for (int j=4;j<8;++j) { ++ printf("write bandwidth: %f M/s\n", (float)data[j].count*32/1024/1024); ++ } ++ PmuDataFree(data); ++ } ++ PmuDisable(pd); ++ PmuClose(pd); ++``` ++ ++执行上述代码，输出的结果类似如下： ++``` ++read bandwidth: 17.32 M/s ++read bandwidth: 5.43 M/s ++read bandwidth: 2.83 M/s ++read bandwidth: 4.09 M/s ++write bandwidth: 4.35 M/s ++write bandwidth: 2.29 M/s ++write bandwidth: 0.84 M/s ++write bandwidth: 0.97 M/s ++``` +-- +2.43.0 + diff --git a/0015-cleanup-remove-unused-variable-childPidList.patch b/0015-cleanup-remove-unused-variable-childPidList.patch new file mode 100644 index 0000000..e866d5d --- /dev/null +++ b/0015-cleanup-remove-unused-variable-childPidList.patch @@ -0,0 +1,28 @@ +From 43baa672413baa5bd19bc95af710e5dc93cdd420 Mon Sep 17 00:00:00 2001 +From: gubin +Date: Tue, 29 Oct 2024 23:21:10 +0800 +Subject: [PATCH 15/20] cleanup: remove unused variable childPidList + +The variable 'childPidList' was declared but never used. +It has been removed to simplify the code and improve readability. + +Signed-off-by: gubin +--- + pmu/dummy_event.cpp | 1 - + 1 file changed, 1 deletion(-) + +diff --git a/pmu/dummy_event.cpp b/pmu/dummy_event.cpp +index a058a24..723a753 100644 +--- a/pmu/dummy_event.cpp ++++ b/pmu/dummy_event.cpp +@@ -140,7 +140,6 @@ namespace KUNPENG_PMU { + uint8_t* ringBuf = (uint8_t*) (mapPage) + PAGE_SIZE; + uint64_t dataHead = mapPage->data_head; + uint64_t dataTail = mapPage->data_tail; +- std::vector childPidList; + while (dataTail < dataHead) { + uint64_t off = dataTail % mapPage->data_size; + auto* header = (struct perf_event_header*) (ringBuf + off); +-- +2.43.0 + diff --git a/0016-update-include-pmu.h.patch b/0016-update-include-pmu.h.patch new file mode 100644 index 0000000..4d4127d --- /dev/null +++ b/0016-update-include-pmu.h.patch @@ -0,0 +1,35 @@ +From c1c61ed3b437469c6509ac73a02b6f7790ba77d3 Mon Sep 17 00:00:00 2001 +From: xuyongliang_01 +Date: Wed, 30 Oct 2024 09:48:57 +0000 +Subject: [PATCH 16/20] update include/pmu.h. + +Signed-off-by: xuyongliang_01 +--- + include/pmu.h | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/include/pmu.h b/include/pmu.h +index 1e51802..d0b7e43 100644 +--- a/include/pmu.h ++++ b/include/pmu.h +@@ -96,7 +96,7 @@ struct PmuAttr { + + // event group id + // if not use event group function, this field will be nullptr. +- // if use event group function. please confrim the event group id with eveList is one by one. ++ // if use event group function. please confirm the event group id with eveList is one by one. + // the same group id is the a event group. + // Note: if the group id value is -1, it indicates that the event is not grouped. + struct EvtAttr *evtAttr; +@@ -266,7 +266,7 @@ void PmuStop(int pd); + * If is NULL and the error code is not 0, an error occurs in the collection process and data cannot be read. + * @param pd task id + * @param pmuData pmu data which is a pointer to an array +- * @return lenght of pmu data ++ * @return length of pmu data + */ + int PmuRead(int pd, struct PmuData** pmuData); + +-- +2.43.0 + diff --git a/0017-Delete-unused-import-packages-and-fix-spelling-mista.patch b/0017-Delete-unused-import-packages-and-fix-spelling-mista.patch new file mode 100644 index 0000000..560e4d5 --- /dev/null +++ b/0017-Delete-unused-import-packages-and-fix-spelling-mista.patch @@ -0,0 +1,38 @@ +From 11a153b1d67139d2fb38cc43f818d58688b3fa97 Mon Sep 17 00:00:00 2001 +From: Susanooo +Date: Wed, 6 Nov 2024 05:47:55 +0000 +Subject: [PATCH 17/20] Delete unused import packages and fix spelling mistake + +Signed-off-by: Susanooo +--- + python/modules/ksym/symbol.py | 2 +- + python/tests/test_api.py | 3 --- + 2 files changed, 1 insertion(+), 4 deletions(-) + +diff --git a/python/modules/ksym/symbol.py b/python/modules/ksym/symbol.py +index f47b057..0e7099e 100644 +--- a/python/modules/ksym/symbol.py ++++ b/python/modules/ksym/symbol.py +@@ -70,7 +70,7 @@ def record_module(pid: int, dwarf: bool = True) -> None: + + def get_stack(pid: int, stacks: List[int]) -> Iterator[Stack]: + """ +- Convert a callstack to a unsigned long long hashid ++ Convert a callstack to an unsigned long long hashid + """ + return _libkperf.StackToHash(pid, stacks) + +diff --git a/python/tests/test_api.py b/python/tests/test_api.py +index 7e32437..467700a 100644 +--- a/python/tests/test_api.py ++++ b/python/tests/test_api.py +@@ -1,6 +1,3 @@ +-import time +-from collections import defaultdict +- + import kperf + + def TestAPI_InitCountNullEvt(): +-- +2.43.0 + diff --git a/0018-Fixed-memory-allocation-check-in-symbol_resolve.cpp-.patch b/0018-Fixed-memory-allocation-check-in-symbol_resolve.cpp-.patch new file mode 100644 index 0000000..56643b8 --- /dev/null +++ b/0018-Fixed-memory-allocation-check-in-symbol_resolve.cpp-.patch @@ -0,0 +1,30 @@ +From e228d064beed56b2a96b8f991e439df39922dc20 Mon Sep 17 00:00:00 2001 +From: Hou haole +Date: Wed, 6 Nov 2024 17:10:56 +0800 +Subject: [PATCH 18/20] Fixed memory allocation check in symbol_resolve.cpp + before calling memset + +--- + symbol/symbol_resolve.cpp | 3 ++- + 1 file changed, 2 insertions(+), 1 deletion(-) + +diff --git a/symbol/symbol_resolve.cpp b/symbol/symbol_resolve.cpp +index 3a54142..7bca356 100644 +--- a/symbol/symbol_resolve.cpp ++++ b/symbol/symbol_resolve.cpp +@@ -85,10 +85,11 @@ namespace { + static inline char* InitChar(int len) + { + char* str = new char[len + 1]; +- memset(str, 0, len + 1); ++ + if (str == nullptr) { + return nullptr; + } ++ memset(str, 0, len + 1); + return str; + } + +-- +2.43.0 + diff --git a/0019-update-python-modules-kperf-pmu.py.patch b/0019-update-python-modules-kperf-pmu.py.patch new file mode 100644 index 0000000..2a68c8d --- /dev/null +++ b/0019-update-python-modules-kperf-pmu.py.patch @@ -0,0 +1,30 @@ +From 6fd43f900a661ef8e3beed9976fe70cd4fba69fc Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?=E8=8F=A0=E8=90=9D=E6=9C=89=E7=82=B9=E9=85=B8?= + +Date: Fri, 8 Nov 2024 01:52:59 +0000 +Subject: [PATCH 19/20] update python/modules/kperf/pmu.py. +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Signed-off-by: 菠萝有点酸 +--- + python/modules/kperf/pmu.py | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/python/modules/kperf/pmu.py b/python/modules/kperf/pmu.py +index 10cd960..d74fa8d 100644 +--- a/python/modules/kperf/pmu.py ++++ b/python/modules/kperf/pmu.py +@@ -95,7 +95,7 @@ class PmuAttr(_libkperf.PmuAttr): + if both and are not NULL, specified processes on specified cores will be monitored. + evtAttr: event group id attributes. + if not use event group function, this field will be NULL. +- if use event group function. please confrim the event group id with eveList is one by one. ++ if use event group function. please confirm the event group id with eveList is one by one. + the same group id is the a event group. + Note: if the group id value is -1, it indicates that the event is not grouped. + sampleRate: sample time enum. +-- +2.43.0 + diff --git a/0020-update-pmu-spe.h.patch b/0020-update-pmu-spe.h.patch new file mode 100644 index 0000000..b05d2f7 --- /dev/null +++ b/0020-update-pmu-spe.h.patch @@ -0,0 +1,30 @@ +From 65944528b098c9093124fd06b186260f98448c24 Mon Sep 17 00:00:00 2001 +From: =?UTF-8?q?=E8=8F=A0=E8=90=9D=E6=9C=89=E7=82=B9=E9=85=B8?= + +Date: Fri, 8 Nov 2024 01:53:23 +0000 +Subject: [PATCH 20/20] update pmu/spe.h. +MIME-Version: 1.0 +Content-Type: text/plain; charset=UTF-8 +Content-Transfer-Encoding: 8bit + +Signed-off-by: 菠萝有点酸 +--- + pmu/spe.h | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/pmu/spe.h b/pmu/spe.h +index fc937d1..f2b833a 100644 +--- a/pmu/spe.h ++++ b/pmu/spe.h +@@ -150,7 +150,7 @@ public: + + /** + * @brief Start collect. +- * @param clearPrevRecords whether clear all records from previos collection. ++ * @param clearPrevRecords whether clear all records from previous collection. + */ + int Enable(bool clearPrevRecords = true); + +-- +2.43.0 + diff --git a/libkperf-1.1.tar.gz b/libkperf-1.1.tar.gz deleted file mode 100644 index dac256e45a1714de1b4101f69b941f118962a8d9..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 104035 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 z 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 X%%Ax)f9B8p$@={N2ZZe60I&%F{>=t> diff --git a/libkperf-v1.2.tar.gz b/libkperf-v1.2.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..0de90bc9fe4ef72e903ff226b264dd94445e9560 GIT binary patch literal 686080 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 bfj$NL6zEf+Pk}xK`V{C>pihAVpuqnH9MQI( literal 0 HcmV?d00001 diff --git a/libkperf.spec b/libkperf.spec index e8c633d..9ff3e0b 100644 --- a/libkperf.spec +++ b/libkperf.spec @@ -1,10 +1,30 @@ Name: libkperf -Version: 1.1 -Release: 1 +Version: v1.2 +Release: 2 Summary: Accelerated perf acquisition and symbol resolution License: Mulan PSL v2 URL: https://gitee.com/openeuler/libkperf Source0: %{name}-%{version}.tar.gz +Patch1: 0001-update-python-modules-_libkperf-Symbol.py.patch +Patch2: 0002-update-docs.patch +Patch3: 0003-fix-after-pmuopen-delete-evtList-exception.patch +Patch4: 0004-Delete-the-repeated-judgement-on-formatPath.patch +Patch5: 0005-pmu-event.patch +Patch6: 0006-adapt-events.patch +Patch7: 0007-update-python-modules-_libkperf-Pmu.py.patch +Patch8: 0008-.patch +Patch9: 0009-adapt-gcc-4.8.5.patch +Patch10: 0010-fix-spelling-error.patch +Patch11: 0011-add-perrno-operation-not-supported.patch +Patch12: 0012-UT-SpeProcCollectSubProc.patch +Patch13: 0013-simplify-CoreSpeData-call-by-removing-redundant-buf-.patch +Patch14: 0014-Update-Details.md.patch +Patch15: 0015-cleanup-remove-unused-variable-childPidList.patch +Patch16: 0016-update-include-pmu.h.patch +Patch17: 0017-Delete-unused-import-packages-and-fix-spelling-mista.patch +Patch18: 0018-Fixed-memory-allocation-check-in-symbol_resolve.cpp-.patch +Patch19: 0019-update-python-modules-kperf-pmu.py.patch +Patch20: 0020-update-pmu-spe.h.patch BuildRequires: gcc-c++ make cmake numactl-devel ExclusiveArch: aarch64 %description @@ -12,7 +32,7 @@ Implement a low overhead pmu collection library, providing abstract interfaces f %package devel Summary: Development package for building Applications that use libkperf -License: Mulan PSL v2 +License: Mulan PSL v2 Requires: %{name} = %{version}-%{release} %description devel @@ -20,6 +40,7 @@ Development package for libkperf library calls %prep %setup -q +%autosetup -n %{name}-%{version} -p1 wget https://gitee.com/openeuler/elfin-parser/repository/archive/v1.0-h1.tar.gz tar -xvf v1.0-h1.tar.gz cp -r elfin-parser-v1.0-h1/* third_party/elfin-parser/ @@ -68,5 +89,12 @@ mv %{buildroot}/include/pcerrc.h %{buildroot}/%{_includedir}/libkperf/ %{_libdir}/libsym.so %attr(755,root,root) %changelog +* Tue Nov 19 2024 echo <2220386943@qq.com> - 1.2-2 +- update version to 1.2-2 +- support new create thread +- description of supplementary documents +- support event grouping +- add the mangleName in symbol.h + * Fri Aug 9 2024 echo <2220386943@qq.com> - 1.1-1 - Package init \ No newline at end of file