From ca416b97db95f859441b8867d3dc5ece2811dde0 Mon Sep 17 00:00:00 2001
From: wuying39 <921169248@qq.com>
Date: Tue, 21 Oct 2025 09:58:15 +0800
Subject: [PATCH] add cache collect tool

---
 tools/cache_collect/CMakeLists.txt   |  11 +
 tools/cache_collect/README.md        |  48 +++
 tools/cache_collect/collect.cpp      | 551 +++++++++++++++++++++++++++
 tools/cache_collect/collect.h        |  79 ++++
 tools/cache_collect/collect_args.cpp | 152 ++++++++
 tools/cache_collect/collect_args.h   |  49 +++
 tools/cache_collect/main.cpp         |  28 ++
 tools/cache_collect/utils.cpp        |  52 +++
 tools/cache_collect/utils.h          |  29 ++
 9 files changed, 999 insertions(+)
 create mode 100644 tools/cache_collect/CMakeLists.txt
 create mode 100644 tools/cache_collect/README.md
 create mode 100644 tools/cache_collect/collect.cpp
 create mode 100644 tools/cache_collect/collect.h
 create mode 100644 tools/cache_collect/collect_args.cpp
 create mode 100644 tools/cache_collect/collect_args.h
 create mode 100644 tools/cache_collect/main.cpp
 create mode 100644 tools/cache_collect/utils.cpp
 create mode 100644 tools/cache_collect/utils.h

diff --git a/tools/cache_collect/CMakeLists.txt b/tools/cache_collect/CMakeLists.txt
new file mode 100644
index 0000000..54a2a39
--- /dev/null
+++ b/tools/cache_collect/CMakeLists.txt
@@ -0,0 +1,11 @@
+cmake_minimum_required (VERSION 3.12.0)
+project(cache_collect)
+
+include_directories(${CMAKE_CURRENT_LIST_DIR}/../../output/include)
+include_directories(${CMAKE_CURRENT_LIST_DIR}/../../util)
+file(GLOB SRC_FILES ${CMAKE_CURRENT_LIST_DIR}/*.cpp)
+
+add_executable(cache_collect ${SRC_FILES})
+
+target_link_directories(cache_collect PRIVATE ${CMAKE_CURRENT_LIST_DIR}/../../output/lib)
+target_link_libraries(cache_collect PRIVATE sym kperf)
\ No newline at end of file
diff --git a/tools/cache_collect/README.md b/tools/cache_collect/README.md
new file mode 100644
index 0000000..1aed722
--- /dev/null
+++ b/tools/cache_collect/README.md
@@ -0,0 +1,48 @@
+# Cache Collect Tool
+### Description
+This tool is designed to collect L2I cache, l2D cache, and l3D cache infomation.
+
+1. It generates statistics of hotspots from the function and instruction perspectives. 
+
+2. It reports the L2I cache miss ratio, L2D cache miss ratio, L3D cache miss ratio and IPC (Instructions Per Cycle) for each process.
+
+Before running the tool, please check the perf event list to comfirm whether l3D cache events are supported on your device. 
+If l3D cache is not supported, the related data will be excluded from collection and statistics.
+
+In L2I cache collect mode, the corresponding data will be output as a txt file for BOLT in the work directory.
+Format: 1 [funcName] [offset] [data]
+
+### Build
+Build the libkperf tool first:
+```
+bash build.sh
+```
+
+then:
+```
+cd tools/cache_collect
+mkdir build && cd build
+cmake ..
+make
+```
+
+### Run
+Use 'cache_collect --help/-h' to view the help information.
+
+```
+  Usage: cache_collect --pid/-p <pid> [options]
+
+  Required:
+    --pid/-p <pid>           : Target process ID(s). Multiple IDs can be separated by ','
+  Optional:
+    --duration/-d <seconds>  : Set collection time of hotspots. Unit: s, default: 10
+    --level/-l <level>       : Set to 'inst' for instruction-level summary. Default: function-level summary
+    --mode/-m <mode>         : Set to 'dcache' to collect L2D and L3D cache data. Default: L2I cache data
+    --interval/-i <ms>       : Interval for reading the ring buffer. Unit: ms, default: 1000
+    --frequency/-f <freq>    : Sampling frequency, default: 1000
+    --bolt/-b <option>       : Generate BOLT format output file. Options: 'cycles', 'l2i_cache', 'l2i_cache_refill', or 'all'. Only for default mode.
+    --summary/-s <seconds>   : Set collection time of summary ratio and IPC collection. Unit: s, default: 5
+  Examples:
+    cache_collect -p 125785 -d 10 -l inst -m dcache -i 2000
+    cache_collect -p 125785,143789 -m dcache -f 4000 -b cycles
+```
\ No newline at end of file
diff --git a/tools/cache_collect/collect.cpp b/tools/cache_collect/collect.cpp
new file mode 100644
index 0000000..b601b99
--- /dev/null
+++ b/tools/cache_collect/collect.cpp
@@ -0,0 +1,551 @@
+/******************************************************************************
+ * Copyright (c) Huawei Technologies Co., Ltd. 2025. All rights reserved.
+ * libkperf licensed under the Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *     http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+ * PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * Author: Wu
+ * Create: 2025-10-21
+ * Description: Collecting summary info and hotspot info
+ ******************************************************************************/
+#include <iostream>
+#include <iomanip>
+#include <cstring>
+#include <string.h>
+#include <map>
+#include <algorithm>
+#include "pmu.h"
+#include "symbol.h"
+#include "cpu_map.h"
+#include "collect.h"
+
+const char* UNKNOWN = "UNKNOWN";
+const int HEX_BUFFER_SIZE = 20;
+const int FLOAT_PRECISION = 2;
+
+static std::string ProcessSymbol(const Symbol* symbol)
+{
+    std::string res = UNKNOWN;
+    if (symbol->symbolName != nullptr && strcmp(symbol->symbolName, UNKNOWN) != 0) {
+        res = symbol->symbolName;
+    } else if (symbol->codeMapAddr > 0) {
+        char buf[HEX_BUFFER_SIZE];
+        if (sprintf(buf, "0x%lx", symbol->codeMapAddr) < 0) {
+            res = std::string();
+        }
+        res = buf;
+    } else {
+        char buf[HEX_BUFFER_SIZE];
+        if (sprintf(buf, "0x%lx", symbol->addr) < 0) {
+            res = std::string();
+        }
+        res = buf;
+    }
+    return res;
+}
+
+static Stack* FindValidNode(Stack* head) {
+    Stack* curr = head;
+    while (curr) {
+        if (curr->symbol->addr < 0xffff00000000) {
+            return curr;
+        }
+        curr = curr->next;
+    }
+    return head;
+}
+
+static bool ComparePmuData(const PmuData &a, const PmuData &b)
+{
+    if (a.pid != b.pid) {
+        return false;
+    }
+    Stack* stackA = FindValidNode(a.stack);
+    Stack* stackB = FindValidNode(b.stack);
+    if (instStat) {
+        return stackA->symbol->addr == stackB->symbol->addr;
+    }
+    std::string symbolA = ProcessSymbol(stackA->symbol);
+    std::string symbolB = ProcessSymbol(stackB->symbol);
+    if (symbolA.empty() || symbolB.empty() || symbolA != symbolB) {
+        return false;
+    }
+    return true;
+}
+
+static std::string GetPeriodPercent(unsigned pid, uint64_t period)
+{
+    std::ostringstream oss;
+    double totalPeriod = pidPeriod[pid];
+    if (totalPeriod == 0.0) {
+        oss << std::fixed << std::setprecision(FLOAT_PRECISION) << 0.0;
+    } else {
+        oss << std::fixed << std::setprecision(FLOAT_PRECISION) << (static_cast<double>(period) / pidPeriod[pid] * 100.0);
+    }
+    return oss.str();
+}
+
+static int GetPmuDataHotspot(PmuData* pmuData, int pmuDataLen, std::vector<HotspotFunc>& tmpData)
+{
+    if (!pmuData || pmuDataLen == 0) {
+        return SUCCESS;
+    }
+
+    std::string event1 = dataCollect ? "l2d_cache" : "l2i_cache";
+    std::string event2 = dataCollect ? "l2d_cache_refill" : "l2i_cache_refill";
+    std::string event3 = "l3d_cache";
+    std::string event4 = "l3d_cache_refill";
+
+    for (int i = 0; i < pmuDataLen; ++i) {
+        PmuData& data = pmuData[i];
+        if (!data.stack) {
+            continue;
+        }
+        if (strcmp(data.evt, "cycles") == 0) {
+            pidPeriod[data.pid] += data.period;
+        }
+        bool found = false;
+        for (auto &hs : tmpData) {
+            if (ComparePmuData(data, hs.data)) {
+                if (strcmp(data.evt, event1.c_str()) == 0) {
+                    hs.l2AccessPeriod += data.period;
+                    hs.l2iAccessCount += 1;
+                } else if (strcmp(data.evt, event2.c_str()) == 0) {
+                    hs.l2RefillPeriod += data.period;
+                    hs.l2iRefillCount += 1;
+                } else if (strcmp(data.evt, event3.c_str()) == 0) {
+                    hs.l3AccessPeriod += data.period;
+                } else if (strcmp(data.evt, event4.c_str()) == 0) {
+                    hs.l3RefillPeriod += data.period;
+                } else if (strcmp(data.evt, "cycles") == 0) {
+                    hs.cyclesPeriod += data.period;
+                    hs.cyclesCount += 1;
+                }
+                found = true;
+                break;
+            }
+        }
+
+        if (!found) {
+            HotspotFunc hs;
+            hs.data = data;
+            if (strcmp(data.evt, event1.c_str()) == 0) {
+                hs.l2AccessPeriod = data.period;
+                hs.l2iAccessCount = 1;
+            } else if (strcmp(data.evt, event2.c_str()) == 0) {
+                hs.l2RefillPeriod = data.period;
+                hs.l2iRefillCount = 1;
+            } else if (strcmp(data.evt, event3.c_str()) == 0) {
+                hs.l3AccessPeriod = data.period;
+            } else if (strcmp(data.evt, event4.c_str()) == 0) {
+                hs.l3RefillPeriod = data.period;
+            } else if (strcmp(data.evt, "cycles") == 0) {
+                hs.cyclesPeriod = data.period;
+                hs.cyclesCount = 1;
+            }
+            tmpData.push_back(std::move(hs));
+        }
+    }
+
+    std::sort(tmpData.begin(), tmpData.end(), [](const HotspotFunc &a, const HotspotFunc &b) { return a.cyclesPeriod > b.cyclesPeriod; });
+    return SUCCESS;
+}
+
+static void PrintHeader(const std::string& refill, const std::string& cache)
+{
+    std::cout << std::setw(15) << refill
+              << std::setw(12) << cache
+              << std::setw(15) << "Cycles"
+              << std::setw(12) << "Ratio(%)"
+              << "\n";
+}
+
+static void PrintHotSpotTitle(int length) {
+    std::cout << std::string(length, '=') << "\n";
+    std::string title = instStat ? "HOTSPOT INST" : "HOTSPOT FUNC";
+    std::cout << std::setw(80) << std::right << title << "\n";
+    std::cout << std::string(length, '-') << "\n";
+    std::cout << std::left;
+    if (instStat) {
+            std::cout << std::setw(20) << "Addr"
+              << std::setw(50) << "FuncName"
+              << std::setw(15) << "Pid";
+    } else {
+            std::cout<< std::setw(50) << "Function"
+              << std::setw(12) << "Pid"
+              << std::setw(18) << "Start Addr"
+              << std::setw(18) << "End Addr"
+              << std::setw(18) << "Length";
+    }
+    if (dataCollect) {
+        std::cout << std::setw(20) << "l2dcache refill"
+              << std::setw(15) << "l2 dcache";
+        if (l3CacheCollect) {
+            std::cout << std::setw(20) << "l3 dcache refill"
+                << std::setw(15) << "l3 dcache";
+        }
+        std::cout  << std::setw(15) << "Cycles"
+              << std::setw(12) << "Ratio(%)"
+              << "\n";
+    } else {
+        std::cout << std::setw(20) << "l2 icache refill"
+              << std::setw(15) << "l2 icache"
+              << std::setw(15) << "Cycles"
+              << std::setw(12) << "Ratio(%)"
+              << "\n";
+    }
+    std::cout << std::string(length, '-') << "\n";
+}
+
+static void WriteRecord(std::ofstream& out, const std::string& funcname, unsigned long offset, unsigned long value)
+{
+    if (value > 0) {
+        out << 1 << ' ' << funcname << ' ' << std::hex << offset << ' ' << std::dec << value << '\n';
+    }
+}
+
+static void InitOutputFiles(FileSet &fs, int pid, const std::string &timeStr)
+{
+    std::string baseName = std::to_string(pid) + "_" + timeStr;
+
+    if (boltType == BoltOption::CYCLES || boltType == BoltOption::ALL) {
+        fs.cyclesPath = baseName + "_cycles.txt";
+        fs.cyclesFile.open(fs.cyclesPath);
+        fs.cyclesFile << "no_lbr cycles:\n";
+    }
+    if (boltType == BoltOption::L2I_CACHE || boltType == BoltOption::ALL) {
+        fs.l2iCachePath = baseName + "_l2i_cache.txt";
+        fs.l2iCacheFile.open(fs.l2iCachePath);
+        fs.l2iCacheFile << "no_lbr l2i_cache:\n";
+    }
+    if (boltType == BoltOption::L2I_CACHE_REFILL || boltType == BoltOption::ALL) {
+        fs.l2iCacheRefillPath = baseName + "_l2i_cache_refill.txt";
+        fs.l2iCacheRefillFile.open(fs.l2iCacheRefillPath);
+        fs.l2iCacheRefillFile << "no_lbr l2i_cache_refill:\n";
+    }
+}
+
+static void WriteOutputRecords(FileSet &fs, const std::string &funcName, uint64_t offset, const HotspotFunc &hs)
+{
+    if (boltType == BoltOption::L2I_CACHE_REFILL || boltType == BoltOption::ALL) {
+        WriteRecord(fs.l2iCacheRefillFile, funcName, offset, hs.l2iRefillCount);
+    }
+    if (boltType == BoltOption::L2I_CACHE || boltType == BoltOption::ALL) {
+        WriteRecord(fs.l2iCacheFile, funcName, offset, hs.l2iAccessCount);
+    }
+    if (boltType == BoltOption::CYCLES || boltType == BoltOption::ALL) {
+        WriteRecord(fs.cyclesFile, funcName, offset, hs.cyclesCount);
+    }
+}
+
+static void PrintOutputPaths(const FileSet &fs)
+{
+    if (boltType == BoltOption::CYCLES || boltType == BoltOption::ALL) {
+        std::cout << "Output file: " << GetFullPath(fs.cyclesPath) << "\n";
+    }
+    if (boltType == BoltOption::L2I_CACHE_REFILL || boltType == BoltOption::ALL) {
+        std::cout << "Output file: " << GetFullPath(fs.l2iCacheRefillPath) << "\n";
+    }
+    if (boltType == BoltOption::L2I_CACHE || boltType == BoltOption::ALL) {
+        std::cout << "Output file: " << GetFullPath(fs.l2iCachePath) << "\n";
+    }
+}
+
+static void PrintHotSpot(std::vector<HotspotFunc>& hotSpotData)
+{
+    std::map<int, FileSet> files;  // pid, file set
+    std::string timeStr = GetTimeStr();
+
+    int length = instStat? 145 : 180;
+    if (dataCollect) {
+        length += 35;
+    }
+    PrintHotSpotTitle(length);
+
+    bool longName = false;
+    for (const auto& hs : hotSpotData) {
+        auto *callFunc = FindValidNode(hs.data.stack);
+        std::string funcName = ProcessSymbol(callFunc->symbol);
+        std::string fullFuncName = ProcessFunctionString(funcName);
+        if (!longName && funcName.size() > 48) {
+            int halfLen = 48 / 2 - 1;
+            int startPos = funcName.size() - 48 + halfLen + 3;
+            funcName = funcName.substr(0, halfLen) + "..." + funcName.substr(startPos);
+        }
+        std::cout << std::left;
+        if (instStat) {
+            std::cout << std::hex  << std::setw(20) << callFunc->symbol->addr << std::dec
+                    << std::setw(50) << funcName
+                    << std::setw(15) << hs.data.pid;
+        } else {
+            unsigned long beginAddr = callFunc->symbol->codeMapAddr - callFunc->symbol->offset;
+            unsigned long funcLength = callFunc->symbol->codeMapEndAddr == 0 ?
+                                        0 : callFunc->symbol->codeMapEndAddr - beginAddr;
+            std::cout << std::setw(50) << funcName
+                    << std::setw(12) << hs.data.pid
+                    << std::setw(18) << std::hex << beginAddr
+                    << std::setw(18) << std::hex << callFunc->symbol->codeMapEndAddr
+                    << std::setw(18) << std::hex << funcLength << std::dec;
+        }
+
+        auto &fs = files[hs.data.pid];
+        if (!fs.cyclesFile.is_open() && !fs.enabled) {
+            fs.enabled = !dataCollect && (boltType != BoltOption::NONE);
+            if (fs.enabled) {
+                InitOutputFiles(fs, hs.data.pid, timeStr);
+            }
+        }
+
+        if (dataCollect) {
+            std::cout << std::setw(20) << hs.l2RefillPeriod
+                << std::setw(15) << hs.l2AccessPeriod;
+            if (l3CacheCollect) {
+                std::cout << std::setw(20) << hs.l3RefillPeriod
+                    << std::setw(15) << hs.l3AccessPeriod;
+            }
+            std::cout << std::setw(15) << hs.cyclesPeriod
+                << std::setw(12) << GetPeriodPercent(hs.data.pid, hs.cyclesPeriod) << "\n";
+        } else {
+            std::cout << std::setw(20) << hs.l2RefillPeriod
+                << std::setw(15) << hs.l2AccessPeriod
+                << std::setw(15) << hs.cyclesPeriod
+                << std::setw(12) << GetPeriodPercent(hs.data.pid, hs.cyclesPeriod) << "\n";
+            WriteOutputRecords(fs, fullFuncName, callFunc->symbol->offset, hs);
+        }
+    }
+    std::cout << std::string(length, '_') << "\n";
+    // output the file list
+    if (!dataCollect) {
+        for (const auto &kv : files) {
+            if (kv.second.enabled) {
+                PrintOutputPaths(kv.second);
+            }
+        }
+    }
+}
+
+EventConfig buildEventConfig(bool dataCollect, bool summaryCollect, bool l3CacheCollect)
+{
+    EventConfig cfg;
+    if (dataCollect) {
+        cfg.baseEvents = {
+            "cycles",
+            "l2d_cache_refill",
+            "l2d_cache"
+        };
+    } else {
+        cfg.baseEvents = {
+            "cycles",
+            "l2i_cache_refill",
+            "l2i_cache"
+        };
+    }
+
+    if (summaryCollect) {
+        cfg.baseEvents.push_back("instructions");
+        if (dataCollect) {
+            cfg.baseEvents.push_back("l2i_cache_refill");
+            cfg.baseEvents.push_back("l2i_cache");
+        } else {
+            cfg.baseEvents.push_back("l2d_cache_refill");
+            cfg.baseEvents.push_back("l2d_cache");
+        }
+    }
+
+    if (l3CacheCollect) {
+        cfg.baseEvents.push_back("l3d_cache_refill");
+        cfg.baseEvents.push_back("l3d_cache");
+    }
+
+    cfg.groupId.assign(cfg.baseEvents.size(), EvtAttr{1});
+    cfg.evtStorage.reserve(cfg.baseEvents.size());
+    cfg.evtList.reserve(cfg.baseEvents.size());
+    for (const auto& evt : cfg.baseEvents) {
+        auto buf = std::make_unique<char[]>(evt.size() + 1);
+        std::strcpy(buf.get(), evt.c_str());
+        cfg.evtList.push_back(buf.get());
+        cfg.evtStorage.push_back(std::move(buf));
+    }
+
+    return cfg;
+}
+
+void collectMiss(CollectArgs& args)
+{
+    dataCollect = args.enableData;
+    instStat = args.enableInst;
+    boltType = args.boltOption;
+    bool summaryCollect = false;
+    EventConfig cfg = buildEventConfig(dataCollect, summaryCollect, l3CacheCollect);
+
+    PmuAttr attr = {0};
+    attr.evtAttr = cfg.groupId.data();
+    attr.evtList = cfg.evtList.data();
+    attr.numEvt = cfg.baseEvents.size();
+    attr.numGroup = cfg.baseEvents.size();
+    attr.callStack = 1;
+    attr.excludeKernel = true;
+    attr.symbolMode = NO_SYMBOL_RESOLVE;
+    attr.freq = args.frequency;
+    attr.useFreq = 1;
+    attr.pidList = args.pids.data();
+    attr.numPid = args.pids.size();
+
+    int pd = PmuOpen(SAMPLING, &attr);
+    if (pd == -1) {
+        std::cerr << "PmuOpen failed. Error msg:" << Perror() << std::endl;
+        return;
+    }
+    PmuEnable(pd);
+
+    int len;
+    PmuData* pmuData = nullptr;
+    std::vector<HotspotFunc> hotSpotData;
+    int loopCount = (args.duration * 1000) / args.interval;
+    for (int i = 0; i < loopCount; ++i) {
+        usleep(1000 * args.interval);
+        len = PmuRead(pd, &pmuData);
+        if (len == -1) {
+            std::cerr << "PmuRead failed. error msg:" << Perror() << std::endl;
+            return;
+        }
+        ResolvePmuDataSymbol(pmuData);
+        GetPmuDataHotspot(pmuData, len, hotSpotData);
+        PmuDataFree(pmuData);
+    }
+    PrintHotSpot(hotSpotData);
+    PmuDisable(pd);
+    PmuClose(pd);
+}
+
+static void PrintSummaryData(const std::map<int, std::map<std::string, uint64_t>>& pidSummaryMap)
+{
+    std::vector<PidSummary> summaries;
+
+    for (std::map<int, std::map<std::string, uint64_t>>::const_iterator it = pidSummaryMap.begin(); it != pidSummaryMap.end(); ++it) {
+        int pid = it->first;
+        const std::map<std::string, uint64_t>& events = it->second;
+
+        uint64_t l2i_cache = events.at("l2i_cache");
+        uint64_t l2i_cache_refill = events.at("l2i_cache_refill");
+        uint64_t l2d_cache = events.at("l2d_cache");
+        uint64_t l2d_cache_refill = events.at("l2d_cache_refill");
+        uint64_t instructions = events.at("instructions");
+        uint64_t cycles = events.at("cycles");
+
+        double l2Icache_miss_rate = l2i_cache ? static_cast<double>(l2i_cache_refill) / l2i_cache : 0.0;
+        double l2Dcache_miss_rate = l2d_cache ? static_cast<double>(l2d_cache_refill) / l2d_cache : 0.0;
+        double ipc = cycles ? static_cast<double>(instructions) / cycles : 0.0;
+
+        double l3Dcache_miss_rate;
+        if (l3CacheCollect) {
+            uint64_t l3d_cache = events.at("l3d_cache");
+            uint64_t l3d_cache_refill = events.at("l3d_cache_refill");
+            l3Dcache_miss_rate = l3d_cache ? static_cast<double>(l3d_cache_refill) / l3d_cache : 0.0;
+        } else {
+            l3Dcache_miss_rate = 0.0;
+        }
+
+        PidSummary s;
+        s.pid = pid;
+        s.l2Icache_miss_rate = l2Icache_miss_rate;
+        s.l2Dcache_miss_rate = l2Dcache_miss_rate;
+        s.l3Dcache_miss_rate = l3Dcache_miss_rate;
+        s.ipc = ipc;
+
+        summaries.push_back(s);
+    }
+
+    std::sort(summaries.begin(), summaries.end(), [](const PidSummary& a, const PidSummary& b) {
+        if (dataCollect) {
+           return a.l2Dcache_miss_rate > b.l2Dcache_miss_rate;
+        } else {
+            return a.l2Icache_miss_rate > b.l2Icache_miss_rate;
+        }
+    });
+
+    const int pid_width = 10;
+    const int rate_width = 25;
+    const int ipc_width = 10;
+    const int total_width = pid_width + rate_width * (l3CacheCollect ? 3 : 2) + ipc_width;
+
+    std::cout << std::string(total_width, '=') << "\n";
+    std::cout << std::setw((total_width + 7) / 2) << "SUMMARY" << "\n";
+    std::cout << std::string(total_width, '-') << "\n";
+
+    std::cout << std::left << std::setw(pid_width) << "Pid"
+              << std::right << std::setw(rate_width) << "l2 icache Miss Rate"
+              << std::setw(rate_width) << "l2 dcache Miss Rate";
+    if (l3CacheCollect) {
+        std::cout << std::setw(rate_width) << "l3 dcache Miss Rate";
+    }
+    std::cout  << std::setw(ipc_width) << "IPC" << "\n";
+    std::cout << std::string(total_width, '-') << "\n";
+
+    for (size_t i = 0; i < summaries.size(); ++i) {
+        const PidSummary& s = summaries[i];
+
+        std::ostringstream l2Icache_str;
+        std::ostringstream l2Dcache_str;
+        std::ostringstream l3Dcache_str;
+        l2Icache_str << std::fixed << std::setprecision(2) << (s.l2Icache_miss_rate * 100) << "%";
+        l2Dcache_str << std::fixed << std::setprecision(2) << (s.l2Dcache_miss_rate * 100) << "%";
+        l3Dcache_str << std::fixed << std::setprecision(2) << (s.l3Dcache_miss_rate * 100) << "%";
+
+        std::cout << std::left << std::setw(pid_width) << s.pid
+                  << std::right << std::setw(rate_width) << l2Icache_str.str()
+                  << std::setw(rate_width) << l2Dcache_str.str();
+        if (l3CacheCollect) {
+            std::cout << std::setw(rate_width) << l3Dcache_str.str();
+        }
+        std::cout<<std::setw(ipc_width) << std::fixed << std::setprecision(2) << s.ipc << "\n";
+    }
+
+    std::cout << std::string(total_width, '-') << "\n";
+}
+
+void collectSummaryData(CollectArgs& args)
+{
+    CHIP_TYPE chipType = GetCpuType();
+    l3CacheCollect = (chipType == HIPB || chipType == HIPG || chipType == HIPF);
+    bool summaryCollect = true;
+    bool dataSummaryCollect = true;
+    EventConfig cfg = buildEventConfig(dataSummaryCollect, true, l3CacheCollect);
+
+    PmuAttr attr = {0};
+    attr.evtAttr = cfg.groupId.data();
+    attr.evtList = cfg.evtList.data();
+    attr.numEvt = cfg.baseEvents.size();
+    attr.numGroup = cfg.baseEvents.size();
+    attr.pidList = args.pids.data();
+    attr.numPid = args.pids.size();
+
+    int pd = PmuOpen(COUNTING, &attr);
+    if (pd == -1) {
+        std::cerr << "PmuOpen failed. Error msg:" << Perror() << std::endl;
+        return;
+    }
+
+    PmuEnable(pd);
+    sleep(args.summaryTime);
+    PmuDisable(pd);
+
+    PmuData* pmuData = nullptr;
+    int len = PmuRead(pd, &pmuData);
+    if (len == -1) {
+        std::cerr << "PmuRead failed. error msg:" << Perror() << std::endl;
+        return;
+    }
+    std::map<int, std::map<std::string, uint64_t>> pidSummaryMap;
+    for (int i = 0; i < len; i++) {
+        pidSummaryMap[pmuData[i].pid][pmuData[i].evt] += pmuData[i].count;
+    }
+    PrintSummaryData(pidSummaryMap);
+
+    PmuDataFree(pmuData);
+    PmuClose(pd);
+}
diff --git a/tools/cache_collect/collect.h b/tools/cache_collect/collect.h
new file mode 100644
index 0000000..d99d24c
--- /dev/null
+++ b/tools/cache_collect/collect.h
@@ -0,0 +1,79 @@
+/******************************************************************************
+ * Copyright (c) Huawei Technologies Co., Ltd. 2025. All rights reserved.
+ * libkperf licensed under the Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *     http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+ * PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * Author: Wu
+ * Create: 2025-10-21
+ * Description:  Collecting summary info and hotspot info
+ ******************************************************************************/
+#ifndef COLLECT_H
+#define COLLECT_H
+
+#include <vector>
+#include <unordered_map>
+#include <sys/types.h>
+#include <fstream>
+#include <memory>
+#include "pmu.h"
+#include "symbol.h"
+#include "pcerrc.h"
+#include "collect_args.h"
+#include "utils.h"
+
+static bool dataCollect;
+static bool instStat;
+static bool l3CacheCollect;
+static BoltOption boltType;
+
+static std::unordered_map<unsigned, uint64_t> pidPeriod;
+
+// for counting mode statustics of each pid
+struct PidSummary {
+    int pid;
+    double l2Dcache_miss_rate;
+    double l2Icache_miss_rate;
+    double l3Dcache_miss_rate;
+    double ipc;
+};
+
+struct HotspotFunc {
+    PmuData data;
+    uint64_t l2RefillPeriod = 0;
+    uint64_t l2AccessPeriod = 0;
+    uint64_t cyclesPeriod = 0;
+    uint64_t l3RefillPeriod = 0;
+    uint64_t l3AccessPeriod = 0;
+    // for output file
+    uint64_t l2iAccessCount = 0;
+    uint64_t l2iRefillCount = 0;
+    uint64_t cyclesCount = 0;
+};
+
+struct FileSet {
+    std::ofstream cyclesFile;
+    std::ofstream l2iCacheRefillFile;
+    std::ofstream l2iCacheFile;
+    bool enabled = false;
+    std::string cyclesPath;
+    std::string l2iCacheRefillPath;
+    std::string l2iCachePath;
+};
+
+struct EventConfig {
+    std::vector<std::string> baseEvents;
+    std::vector<EvtAttr> groupId;
+    std::vector<std::unique_ptr<char[]>> evtStorage;
+    std::vector<char*> evtList;
+};
+
+// sampling mode: collect l2i cache miss or l2d tlb mis
+void collectMiss(CollectArgs& args);
+// counting mode: collect ipc, l2i cache miss ratio and l2d cache miss ratio of process
+void collectSummaryData(CollectArgs& args);
+#endif
\ No newline at end of file
diff --git a/tools/cache_collect/collect_args.cpp b/tools/cache_collect/collect_args.cpp
new file mode 100644
index 0000000..ca80d6f
--- /dev/null
+++ b/tools/cache_collect/collect_args.cpp
@@ -0,0 +1,152 @@
+/******************************************************************************
+ * Copyright (c) Huawei Technologies Co., Ltd. 2025. All rights reserved.
+ * libkperf licensed under the Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *     http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+ * PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * Author: Wu
+ * Create: 2025-10-21
+ * Description: parse and check collect args
+ ******************************************************************************/
+#include <iostream>
+#include <getopt.h>
+#include <sstream>
+#include "collect_args.h"
+
+BoltOption CollectArgs::ParseBoltOption(const std::string& value) {
+    if (value == "cycles") {
+        return BoltOption::CYCLES;
+    }
+    if (value == "l2i_cache") {
+        return BoltOption::L2I_CACHE;
+    }
+    if (value == "l2i_cache_refill") {
+        return BoltOption::L2I_CACHE_REFILL;
+    }
+    if (value == "all") {
+        return BoltOption::ALL;
+    }
+    return BoltOption::NONE;
+}
+
+bool CollectArgs::ParseOption(int argc, char* argv[])
+{
+    int opt;
+    int option_index = 0;
+    std::string level;
+    std::string mode;
+    std::string bolt;
+    struct option long_options[] = {
+        {"help",      no_argument, 0, 'h'},
+        {"pid",      required_argument, 0, 'p'},
+        {"duration", required_argument, 0, 'd'},
+        {"level",    required_argument, 0, 'l'},
+        {"mode",     required_argument, 0, 'm'},
+        {"interval", required_argument, 0, 'i'},
+        {"frequency", required_argument, 0, 'f'},
+        {"bolt", required_argument, 0, 'b'},
+        {"summary", required_argument, 0, 's'},
+        {0, 0, 0, 0}
+    };
+
+    while ((opt = getopt_long(argc, argv, "hp:d:l:m:i:f:b:s:", long_options, &option_index)) != -1) {
+        switch (opt) {
+            case 'h':
+                printUsage();
+                exit(0);
+            case 'd':
+                try {
+                    duration = std::stoi(optarg);
+                } catch (const std::invalid_argument& e) {
+                    std::cerr << "Not valid collecting duration: " << e.what() << "\n";
+                    return false;
+                }
+                break;
+            case 'p':
+                pidList = optarg;
+                break;
+            case 'l':
+                level = optarg;
+                if (level == "inst") {
+                    enableInst = true;
+                }
+                break;
+            case 'm':
+                mode = optarg;
+                if (mode == "dcache") {
+                    enableData = true;
+                }
+                break;
+            case 'i':
+                try {
+                    interval = std::stoi(optarg);
+                } catch (const std::invalid_argument& e) {
+                    std::cerr << "Not valid interval: " << e.what() << "\n";
+                    return false;
+                }
+                break;
+            case 'f':
+                try {
+                    frequency = std::stoi(optarg);
+                } catch (const std::invalid_argument& e) {
+                    std::cerr << "Not valid frequency: " << e.what() << "\n";
+                    return false;
+                }
+                break;
+            case 'b':
+                bolt = optarg;
+                boltOption = ParseBoltOption(bolt);
+                break;
+            case 's':
+                try {
+                    summaryTime = std::stoi(optarg);
+                } catch (const std::invalid_argument& e) {
+                    std::cerr << "Not valid duration for summary collecting: " << e.what() << "\n";
+                    return false;
+                }
+                break;
+            default:
+                printUsage();
+                return false;
+        }
+    }
+
+    if (pidList.empty()) {
+        std::cerr << "Please input --pid/-p\n";
+        return false;
+    }
+    ParsePidList();
+    return true;
+}
+
+void CollectArgs::ParsePidList()
+{
+    std::stringstream ss(pidList);
+    std::string pidStr;
+    while (std::getline(ss, pidStr, ',')) {
+        pids.push_back(std::stoi(pidStr));
+    }
+}
+
+void CollectArgs::printUsage()
+{
+    std::cerr << "Usage: cache_collect --pid/-p <pid> [options]\n\n";
+
+    std::cerr << "Required:\n";
+    std::cerr << "  --pid/-p <pid>           : Target process ID(s). Multiple IDs can be separated by ','\n";
+    std::cerr << "Optional:\n";
+    std::cerr << "  --duration/-d <seconds>  : Set collection time of hotspots. Unit: s, default: 10\n";
+    std::cerr << "  --level/-l <level>       : Set to 'inst' for instruction-level summary. Default: function-level summary\n";
+    std::cerr << "  --mode/-m <mode>         : Set to 'dcache' to collect L2D and L3D cache data. Default: L2I cache data\n";
+    std::cerr << "  --interval/-i <ms>       : Interval for reading the ring buffer. Unit: ms, default: 1000\n";
+    std::cerr << "  --frequency/-f <freq>    : Sampling frequency, default: 1000\n";
+    std::cerr << "  --bolt/-b <option>       : Generate BOLT format output file. Options: 'cycles', 'l2i_cache', 'l2i_cache_refill', or 'all'. Only for default mode\n";
+    std::cerr << "  --summary/-s <seconds>   : Set collection time of summary ratio and IPC collection. Unit: s, default: 5\n\n";
+    std::cerr << "Examples:\n";
+    std::cerr << "  cache_collect -p 125785 -d 10 -l inst -m dcache -i 2000\n";
+    std::cerr << "  cache_collect -p 125785,143789 -m dcache -f 4000 -b cycles\n";
+}
\ No newline at end of file
diff --git a/tools/cache_collect/collect_args.h b/tools/cache_collect/collect_args.h
new file mode 100644
index 0000000..8c57f4b
--- /dev/null
+++ b/tools/cache_collect/collect_args.h
@@ -0,0 +1,49 @@
+/******************************************************************************
+ * Copyright (c) Huawei Technologies Co., Ltd. 2025. All rights reserved.
+ * libkperf licensed under the Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *     http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+ * PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * Author: Wu
+ * Create: 2025-10-21
+ * Description: collect args
+ ******************************************************************************/
+#ifndef COLLECT_ARGS_H
+#define COLLECT_ARGS_H
+
+#include <string>
+#include <vector>
+#include <unistd.h>
+
+enum class BoltOption {
+    NONE,
+    CYCLES,
+    L2I_CACHE,
+    L2I_CACHE_REFILL,
+    ALL
+};
+
+class CollectArgs {
+public:
+    unsigned long duration = 10;
+    unsigned long summaryTime = 5;
+    unsigned frequency = 1000;
+    unsigned interval = 1000;
+    bool enableData = false;
+    bool enableInst = false;
+    BoltOption boltOption = BoltOption::NONE;
+    std::vector<pid_t> pids;
+
+    bool ParseOption(int argc, char* argv[]);
+    void printUsage();
+
+private:
+    std::string pidList;
+    void ParsePidList();
+    BoltOption ParseBoltOption(const std::string& value);
+};
+#endif
\ No newline at end of file
diff --git a/tools/cache_collect/main.cpp b/tools/cache_collect/main.cpp
new file mode 100644
index 0000000..c00c675
--- /dev/null
+++ b/tools/cache_collect/main.cpp
@@ -0,0 +1,28 @@
+/******************************************************************************
+ * Copyright (c) Huawei Technologies Co., Ltd. 2025. All rights reserved.
+ * libkperf licensed under the Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *     http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+ * PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * Author: Wu
+ * Create: 2025-10-21
+ * Description: Collecting l2 icache miss, l2d tlb miss of process
+ ******************************************************************************/
+#include "collect_args.h"
+#include "collect.h"
+
+int main(int argc, char* argv[])
+{
+    CollectArgs args;
+    if (!args.ParseOption(argc, argv)) {
+        return EXIT_FAILURE;
+    }
+
+    collectMiss(args);
+    collectSummaryData(args);
+    return 0;
+}
diff --git a/tools/cache_collect/utils.cpp b/tools/cache_collect/utils.cpp
new file mode 100644
index 0000000..5c89235
--- /dev/null
+++ b/tools/cache_collect/utils.cpp
@@ -0,0 +1,52 @@
+/******************************************************************************
+ * Copyright (c) Huawei Technologies Co., Ltd. 2025. All rights reserved.
+ * libkperf licensed under the Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *     http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+ * PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * Author: Wu
+ * Create: 2025-10-21
+ * Description: common funcions
+ ******************************************************************************/
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <unistd.h>
+#include <limits.h>
+#include "utils.h"
+
+std::string GetTimeStr() {
+    auto now = std::chrono::system_clock::now();
+    std::time_t t = std::chrono::system_clock::to_time_t(now);
+    std::tm tm{};
+    localtime_r(&t, &tm);
+
+    std::ostringstream oss;
+    oss << std::put_time(&tm, "%Y%m%d_%H%M%S");
+    return oss.str();
+}
+
+std::string GetFullPath(const std::string& filename) {
+    char buf[PATH_MAX];
+    if (getcwd(buf, sizeof(buf)) != nullptr) {
+        return std::string(buf) + "/" + filename;
+    }
+    return filename;
+}
+
+std::string ProcessFunctionString(const std::string& input) {
+    std::ostringstream oss;
+    for (char ch : input) {
+        if (ch == ' ') {
+            oss << "\\ ";
+        } else {
+            oss << ch;
+        }
+    }
+    oss << "/1";
+    return oss.str();
+}
\ No newline at end of file
diff --git a/tools/cache_collect/utils.h b/tools/cache_collect/utils.h
new file mode 100644
index 0000000..0802425
--- /dev/null
+++ b/tools/cache_collect/utils.h
@@ -0,0 +1,29 @@
+/******************************************************************************
+ * Copyright (c) Huawei Technologies Co., Ltd. 2025. All rights reserved.
+ * libkperf licensed under the Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *     http://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR
+ * PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ * Author: Wu
+ * Create: 2025-10-21
+ * Description: common funcions
+ ******************************************************************************/
+#ifndef UTILS_H
+#define UTILS_H
+
+#include <vector>
+#include <unordered_map>
+#include <sys/types.h>
+#include <fstream>
+#include <iomanip>
+#include <chrono>
+
+std::string GetTimeStr();
+std::string GetFullPath(const std::string& filename);
+std::string ProcessFunctionString(const std::string& input);
+
+#endif
\ No newline at end of file
-- 
Gitee