diff --git a/tools/cache_collect/CMakeLists.txt b/tools/cache_collect/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..54a2a3951a81d3212cb31fe79593878e070391c9
--- /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 0000000000000000000000000000000000000000..7df18e82ab15207e9d6e4cc4320e0e60619d6ff8
--- /dev/null
+++ b/tools/cache_collect/README.md
@@ -0,0 +1,144 @@
+# Cache Collect Tool
+### Description
+This tool is designed to collect L2I cache, l2D cache infomation of go program.
+
+1. It generates statistics of hotspots from the function and instruction perspectives. 
+
+2. It reports the L2I cache miss ratio, L2D cache miss ratio, and IPC (Instructions Per Cycle) for each process.
+
+In L2I cache collect mode, the corresponding data can be output as a txt file for BOLT in the work directory.
+Format: 1 [funcName] [offset] [number]
+
+[number] is the sample count for [funcName] at [offset]
+
+### 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 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
+```
+
+### Example
+pwd: /home/test/libkperf/tools/cache_collect/build
+#### The function level:
+command:
+```
+./cache_collect -p 1630278 -b all
+```
+
+The output results is:
+```
+====================================================================================================================================================================================
+                                                                    HOTSPOT FUNC
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+Function                                          Pid         Start Addr        End Addr          Length            l2 icache refill    l2 icache      Cycles         Ratio(%)
+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+main.addSub                                       1630278     244e20            244f30            110               76                  144            13820058736    52.65
+main.addSubFuse                                   1630278     244f30            245030            100               7921                2586           12423196469    47.33
+gogo                                              1630278     7b0e0             7b120             40                1428                1017           2575901        0.01
+runtime.sighandler                                1630278     5fa80             60070             5f0               56                  1741           2568366        0.01
+runtime.retake                                    1630278     572e0             575b0             2d0               0                   0              433392         0.00
+runtime.unlock2                                   1630278     1c580             1c650             d0                780                 5707           296167         0.00
+runtime.nanotime1.abi0                            1630278     7f3c0             7f4a0             e0                306                 4522           3155           0.00
+runtime.usleep.abi0                               1630278     7f150             7f1b0             60                0                   31             34             0.00
+runtime.sysmon                                    1630278     56e30             572e0             4b0               33                  1              30             0.00
+....
+____________________________________________________________________________________________________________________________________________________________________________________
+Bolt file: /home/test/libkperf/tools/cache_collect/build/1630278_20251106_160118_cycles.txt
+Bolt file: /home/test/libkperf/tools/cache_collect/build/1630278_20251106_160118_l2i_cache_refill.txt
+Bolt file: /home/test/libkperf/tools/cache_collect/build/1630278_20251106_160118_l2i_cache.txt
+======================================================================
+SUMMARY
+----------------------------------------------------------------------
+Pid             l2 icache Miss Rate      l2 dcache Miss Rate       IPC
+----------------------------------------------------------------------
+1630278                      59.60%                   49.89%      2.71
+----------------------------------------------------------------------
+```
+
+The content of '1630278_20251106_160118_cycles.txt' is:
+```
+no_lbr cycles:
+1 main.addSub/1 20 5352
+1 main.addSubFuse/1 20 4813
+1 gogo/1 20 1 1 runtime.sighandler/1 30 1
+1 runtime.retake/1 7c 2
+1 runtime.unlock2/1 30 1
+1 runtime.nanotime1.abi0/1 98 3
+1 runtime.usleep.abi0/1 48 4
+1 runtime.sysmon/1 e4 2
+```
+
+#### The instruction level:
+command:
+```
+./cache_collect -p 1630278 -l inst -b cycles
+```
+
+The output results is:
+```
+=================================================================================================================================================
+                                                                    HOTSPOT INST
+-------------------------------------------------------------------------------------------------------------------------------------------------
+Addr                FuncName                                          Pid            l2 icache refill    l2 icache      Cycles         Ratio(%)
+-------------------------------------------------------------------------------------------------------------------------------------------------
+244f50              main.addSubFuse                                   1630278        1004                1699           4574485132     17.49
+244e98              main.addSub                                       1630278        50                  0              2237117248     8.55
+244e50              main.addSub                                       1630278        0                   90             2157851199     8.25
+244e40              main.addSub                                       1630278        0                   0              1647745701     6.30
+244edc              main.addSub                                       1630278        0                   132            1616315405     6.18
+244eb0              main.addSub                                       1630278        37                  0              1483391344     5.67
+244fa4              main.addSubFuse                                   1630278        0                   64             1343424392     5.14
+244fe8              main.addSubFuse                                   1630278        0                   0              1115313116     4.26
+244fac              main.addSubFuse                                   1630278        1                   0              900182732      3.44
+244fc4              main.addSubFuse                                   1630278        42                  553            755279597      2.89
+244f88              main.addSubFuse                                   1630278        60                  1357           714211321      2.73
+244f6c              main.addSubFuse                                   1630278        93                  131            639790055      2.45
+244e74              main.addSub                                       1630278        0                   0              565132676      2.16
+...
+__________________________________________________________________________________________________________________________________________________
+Bolt file: /home/test/libkperf/tools/cache_collect/build/1630278_20251106_161435_cycles.txt
+...
+```
+
+The content of bolt file is :
+```
+no_lbr cycles:
+1 main.addSubFuse/1 20 1768
+1 main.addSub/1 78 869
+1 main.addSub/1 30 838
+1 main.addSub/1 20 641
+1 main.addSub/1 bc 629
+1 main.addSub/1 90 576
+1 main.addSubFuse/1 74 500 
+1 main.addSubFuse/1 b8 433
+...
+```
\ 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 0000000000000000000000000000000000000000..896689bc870e1bc3b5e3547b56bfb1a6b3f5cb29
--- /dev/null
+++ b/tools/cache_collect/collect.cpp
@@ -0,0 +1,509 @@
+/******************************************************************************
+ * 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";
+
+    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, "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, "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";
+        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 << "Bolt file: " << GetFullPath(fs.cyclesPath) << "\n";
+    }
+    if (boltType == BoltOption::L2I_CACHE_REFILL || boltType == BoltOption::ALL) {
+        std::cout << "Bolt file: " << GetFullPath(fs.l2iCacheRefillPath) << "\n";
+    }
+    if (boltType == BoltOption::L2I_CACHE || boltType == BoltOption::ALL) {
+        std::cout << "Bolt 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;
+            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)
+{
+    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");
+        }
+    }
+
+    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);
+
+    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;
+
+        PidSummary s;
+        s.pid = pid;
+        s.l2Icache_miss_rate = l2Icache_miss_rate;
+        s.l2Dcache_miss_rate = l2Dcache_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 * 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";
+    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;
+        l2Icache_str << std::fixed << std::setprecision(2) << (s.l2Icache_miss_rate * 100) << "%";
+        l2Dcache_str << std::fixed << std::setprecision(2) << (s.l2Dcache_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();
+        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();
+    bool summaryCollect = true;
+    bool dataSummaryCollect = true;
+    EventConfig cfg = buildEventConfig(dataSummaryCollect, true);
+
+    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 0000000000000000000000000000000000000000..fd00de2c2400b84e10d0ccf5cfbb0517c39c1723
--- /dev/null
+++ b/tools/cache_collect/collect.h
@@ -0,0 +1,75 @@
+/******************************************************************************
+ * 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 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 ipc;
+};
+
+struct HotspotFunc {
+    PmuData data;
+    uint64_t l2RefillPeriod = 0;
+    uint64_t l2AccessPeriod = 0;
+    uint64_t cyclesPeriod = 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 0000000000000000000000000000000000000000..cd08616fdee65057f635bdf83396e91bda16babd
--- /dev/null
+++ b/tools/cache_collect/collect_args.cpp
@@ -0,0 +1,153 @@
+/******************************************************************************
+ * 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 <unordered_map>
+#include "collect_args.h"
+
+
+const std::unordered_map<std::string, BoltOption> boltOptionMap = {
+    {"cycles", BoltOption::CYCLES},
+    {"l2i_cache", BoltOption::L2I_CACHE},
+    {"l2i_cache_refill", BoltOption::L2I_CACHE_REFILL},
+    {"all", BoltOption::ALL}
+};
+
+BoltOption CollectArgs::ParseBoltOption(const std::string& value) {
+    auto it = boltOptionMap.find(value);
+    if (it != boltOptionMap.end()) {
+        return it->second;
+    }
+    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 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 0000000000000000000000000000000000000000..8c57f4b18d2b54c120ee64bd932dcc6312e50265
--- /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 0000000000000000000000000000000000000000..c00c67523e784c1de031db6af67d78a4809a6028
--- /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 0000000000000000000000000000000000000000..5c89235aafdab3190ed0c92a8a0523186ed6d0f6
--- /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 0000000000000000000000000000000000000000..08024256c5822928b39a8657af451b3c024d815c
--- /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