Linux编程： C++程序线程CPU使用率监控与分析小工具

0. 引言

本文将介绍一个结合 C++ 和 Python 的高性能 CPU 使用率监控和分析工具。该工具通过读取 Linux 系统的 /proc 文件系统实时采集 CPU 使用数据，利用 UnQLite 数据库进行高效存储，并通过 Python 实现数据解析和可视化。本工具支持对多个进程同时进行分析。
代码仓库路径：thread-monitor

1. 数据采集与处理（C++部分）

本部分的核心任务是实时采集系统中各个线程的 CPU 使用情况，并将数据存储到本地UnQLite数据库中以备进一步分析。

1.1 基于 Linux /proc 文件系统的监控机制

Linux 的 /proc 文件系统是一个虚拟文件系统，用于存储内核数据结构和各种系统信息。通过读取 /proc 下的特定文件，可以获取系统中进程和线程的状态信息。本文的工具主要使用以下两个文件来获取数据：

• /proc/[pid]/stat：用于获取指定进程的状态信息，包括 CPU 时间、内存使用、进程优先级等。
• /proc/[pid]/task/[tid]/stat：用于获取指定进程内各线程的状态信息，尤其是线程的用户态和内核态 CPU 时间。

这些文件中的字段位置和数量可能会随着系统的架构和版本而变化。为此，工具在设计时考虑了跨平台兼容性，通过条件编译来调整对不同字段的解析。

1.1.1 跨平台数据获取

不同的平台（如 x86 和 ARM 架构）可能在 /proc 文件系统中的字段位置上存在差异。例如，在 x86 平台上，进程的优先级字段位于 /proc/[pid]/stat 文件的第 18 和 19 个字段，而在 ARM (aarch64) 平台上，这些字段可能位于第 19 和 20 个位置。通过以下代码片段，我们可以根据系统平台动态调整字段索引：

#if defined(__aarch64__) || defined(RK3566)
#define PRIORITY_FIELD_INDEX 18
#define NICE_FIELD_INDEX 19
#define USER_TICKS_FIELD_INDEX 13
#define KERNEL_TICKS_FIELD_INDEX 14
#else  // default is x86
#define PRIORITY_FIELD_INDEX 17
#define NICE_FIELD_INDEX 18
#define USER_TICKS_FIELD_INDEX 13
#define KERNEL_TICKS_FIELD_INDEX 14
#endif

通过这种方式，工具能够在不同的平台上正确解析和处理 /proc 文件中的数据。

1.2 基于 C++ 的定时器和循环机制的数据采集程序

为了确保数据采集的实时性和稳定性，工具采用了一个高效的 C++ 程序，使用定时器和循环机制来定期读取 /proc 文件系统中的数据。程序通过一个无限循环（while 循环），每隔固定时间间隔（refresh_delay_ 秒）进行一次数据采集。信号处理机制（SignalHandler）用来捕捉终止信号（如 SIGINT），从而实现程序的平滑退出。

void Run() {GetThreadCpuTicks();current_total_cpu_time_ = GetTotalCpuTime();StoreCurrentTicksAsPrevious();while (cpu_monitor::keep_running) {std::this_thread::sleep_for(std::chrono::seconds(refresh_delay_));InitializeThreads();GetThreadCpuTicks();current_total_cpu_time_ = GetTotalCpuTime();delta_total_cpu_time_ = current_total_cpu_time_ - previous_total_cpu_time_;if (delta_total_cpu_time_ > 0) {ComputeCpuUsage();}StoreCurrentTicksAsPrevious();}fprintf(stdout, "Exiting gracefully...\n");
}

该函数首先获取每个线程的 CPU 时间（GetThreadCpuTicks），然后计算 CPU 使用率（ComputeCpuUsage），并将结果存储到 UnQLite 数据库中。通过使用 RAII（Resource Acquisition Is Initialization）模式的 DirCloser 和 FileCloser 类，工具确保了文件和目录的资源在使用后能够被自动释放，避免了潜在的资源泄露问题。

1.3 数据解析与处理

数据解析和处理的核心在于从 /proc/[pid]/task/[tid]/stat 文件中提取各个线程的 CPU 使用情况，并计算它们在一段时间内的使用率。

1.3.1 ParseStatFile 函数

ParseStatFile 函数用于解析指定的 stat 文件，提取其中的用户态时间 (utime) 和内核态时间 (stime)：

std::vector<int64_t> ParseStatFile(const std::string& filename) const {std::ifstream file(filename);if (!file.is_open()) {fprintf(stderr, "Failed to open file: %s\n", filename.c_str());return {};}std::string line;if (!std::getline(file, line)) {fprintf(stderr, "Failed to read line from file: %s\n", filename.c_str());return {};}std::istringstream iss(line);std::vector<int64_t> values;std::string temp;for (int i = 0; i < USER_TICKS_FIELD_INDEX; ++i) {if (!(iss >> temp)) {fprintf(stderr, "Error parsing stat file: %s\n", filename.c_str());return {};}}int64_t user_time = 0;int64_t kernel_time = 0;if (!(iss >> user_time)) {fprintf(stderr, "Error parsing user_time from stat file: %s\n", filename.c_str());return {};}if (!(iss >> kernel_time)) {fprintf(stderr, "Error parsing kernel_time from stat file: %s\n", filename.c_str());return {};}values.push_back(user_time);values.push_back(kernel_time);return values;
}

函数首先打开指定的 stat 文件，并读取其中的数据。然后，使用字符串流 (std::istringstream) 解析每一行，根据字段索引提取 utime 和 stime，并返回一个包含这两个值的向量。

1.3.2 ComputeCpuUsage 函数

ComputeCpuUsage 函数用于计算每个线程的 CPU 使用百分比。通过比较当前采集周期与前一周期的 CPU 使用情况，计算出每个线程在该时间段内的 CPU 使用率。

void ComputeCpuUsage() {std::lock_guard<std::mutex> lck(data_mutex_);auto now = std::chrono::system_clock::now();auto time_since_start =std::chrono::duration_cast<std::chrono::seconds>(now.time_since_epoch() % std::chrono::seconds(259200)).count();  // 259200 seconds = 3 daysuint32_t compressed_timestamp = static_cast<uint32_t>(time_since_start);std::vector<CompactCpuUsageData> batch_data;for (const auto& thread : threads_) {int64_t user_delta = 0;int64_t kernel_delta = 0;if (previous_ticks_.find(thread) != previous_ticks_.end()) {user_delta = current_ticks_.at(thread).first - previous_ticks_.at(thread).first;kernel_delta = current_ticks_.at(thread).second - previous_ticks_.at(thread).second;}uint32_t user_percent = 0;uint32_t kernel_percent = 0;if (delta_total_cpu_time_ > 0) {user_percent = static_cast<uint32_t>(static_cast<double>(user_delta) / delta_total_cpu_time_ * 100.0);kernel_percent = static_cast<uint32_t>(static_cast<double>(kernel_delta) / delta_total_cpu_time_ * 100.0);}uint32_t thread_status = 0;  // eg. 0 = running, 1 = sleeping, 2 = waiting, 3 = stoppeduint32_t extra_flags = 0;    // eg. priority or other flags can be storedif (thread_names_[thread].find("worker") != std::string::npos) {thread_status = 1;  // Assuming a thread with the name 'worker' is in sleep mode}extra_flags = thread_priorities_[thread] & 0xF;  // Only take the lower 4 bits of priority as additional flagsint real_thread_id = std::stoi(thread);int compressed_thread_id = thread_id_mapper_.GetOrAssignCompressedThreadId(real_thread_id);CompactCpuUsageData data;data.user_percent = user_percent & 0x7F;data.kernel_percent= kernel_percent & 0x7F;data.user_ticks = static_cast<uint16_t>(current_ticks_.at(thread).first);data.kernel_ticks = static_cast<uint16_t>(current_ticks_.at(thread).second);data.timestamp = compressed_timestamp & 0xFFFFF;data.thread_id = compressed_thread_id & 0x7F;data.thread_status = thread_status & 0x03;data.extra_flags = extra_flags & 0x07;batch_data.push_back(data);DEBUG_PRINT("Thread %u: user_percent=%u, kernel_percent=%u, status=%u, flags=%u\n", data.thread_id, user_percent,kernel_percent, thread_status, extra_flags);}std::string collection_key = "batch_" + std::to_string(compressed_timestamp);db_.store(collection_key, batch_data.data(), batch_data.size() * sizeof(CompactCpuUsageData));
}

该函数首先计算当前时间距离某个基准时间（例如启动时间）的秒数，并生成一个压缩的时间戳（compressed_timestamp）。然后，它计算每个线程的用户态和内核态 CPU 使用率，将这些信息存储在一个紧凑的结构体（CompactCpuUsageData）中，并将所有数据批量存储到 UnQLite 数据库中。

1.4 数据存储

1.4.1. 使用 UnQLite 作为数据存储的优势

UnQLite 是一种嵌入式 NoSQL 数据库，详细请看UnQLite：多语言支持的嵌入式NoSQL数据库深入解析。

在本工具中，UnQLite 数据库主要用于存储从 /proc 文件系统采集的每个线程的 CPU 使用数据。每次数据采集后，程序会将所有线程的数据作为一个 “batch” 存储在 UnQLite 数据库中，键的格式为 "batch_<timestamp>"，值是包含所有线程 CPU 使用信息的紧凑数据结构。

1.4.2. C++ 结构体设计的优点

在 C++ 程序中，我们设计了一个紧凑的结构体 CompactCpuUsageData，用于存储每个线程的 CPU 使用信息。该结构体使用了位域（bit fields） 和紧凑的数据布局来最大化数据存储效率。

• CompactCpuUsageData 结构体的内容

  #pragma pack(push, 1)
  struct CompactCpuUsageData {uint8_t user_percent : 7;  // 7 bits for user-mode CPU usage percentage (0-100).// The upper bound of 7 bits allows a maximum value of 127,// but typical usage percentages are within 0-100.uint8_t kernel_percent : 7;  // 7 bits for kernel-mode CPU usage percentage (0-100).// Similar to user_percent, it uses 7 bits for compact storage.uint16_t user_ticks;  // 16 bits to store the number of CPU ticks spent in user mode.// This represents the accumulated CPU time for user processes.uint16_t kernel_ticks;  // 16 bits to store the number of CPU ticks spent in kernel mode.// This represents the accumulated CPU time for kernel processes.uint32_t timestamp : 20;  // 20 bits for a compressed timestamp (seconds since an epoch).// The limited bit-width is used to reduce storage, typically// representing time in seconds within a specific rolling window.uint8_t thread_id : 7;  // 7 bits to store a compressed thread identifier.// This allows for 128 unique thread IDs, which is usually sufficient// for most applications tracking a limited number of threads.uint8_t thread_status : 2;  // 2 bits for thread status, indicating the current state of the thread.// Possible values could represent states such as running, sleeping,// waiting, or stopped.uint8_t extra_flags : 3;  // 3 bits for additional flags or metadata about the thread.// This could encode priority information, special states, or other// thread-specific attributes.
  };
  #pragma pack(pop)  // Restore the previous packing alignment.
  

• 结构体设计的优点

  • 空间效率：通过使用位域，CompactCpuUsageData 结构体中的每个字段都被压缩到最少的位数，确保数据结构尽可能小。这对于减少存储和传输的数据量至关重要。尤其是在高频数据采集场景中，数据量大且传输频繁，空间效率的提升显著减少了存储开销。

  • 最小化内存对齐开销：#pragma pack(push, 1) 指令确保结构体的对齐方式为 1 字节对齐，这避免了编译器在结构体字段之间插入额外的填充字节，从而进一步减少了结构体的大小。

  • 提高数据处理速度：由于数据结构小且紧凑，程序在从数据库中读取和处理这些数据时的速度也更快。对于高频次的数据采集和存储应用，这样的设计能显著提高程序的性能。

  • 便于解析和存储：紧凑的结构体设计使得数据可以直接存储到数据库中，而无需进行复杂的序列化或反序列化操作。在 Python 脚本中，只需按顺序解码这些字段即可获取数据，简化了数据解析逻辑。

1.5. 多个进程同时分析支持

本方案支持同时监控多个进程，无论是通过进程名还是 PID，系统都会为每个进程生成单独的数据库collection。在监控过程中，每个进程的 CPU 使用情况会分别记录到独立的数据库记录中。

用户可以通过命令行输入多个进程名或 PID，使用空格分隔。例如： bash ./your_program -n 2 process1 process2 1234 其中 process1、process2 为进程名，1234 为 PID。

2. 数据解析与可视化（Python部分）

为了方便后续的数据分析和展示，设计了 Python 脚本来从 UnQLite 数据库中提取数据，进行聚合分析，并生成图形化的 CPU 使用情况报告。

2.1 数据聚合与统计分析

Python 脚本负责读取 UnQLite 数据库中的数据，并将其转换为 Pandas DataFrame 以便进行分析。

2.1.1 read_db_data 函数

该函数从数据库中读取所有数据，并按照线程 ID 和时间戳进行聚合。数据读取后，将其解析为 CPU 使用率的紧凑数据结构，并进一步转换为 Pandas DataFrame 格式。

def read_db_data(db_filename):db = UnqliteDB(db_filename)thread_id_map = load_thread_id_mapping(db)keys = db.db.keys()keys = sorted(db.db.keys())temp_data = {}for key in keys:if isinstance(key, bytes):key_str = key.decode("utf-8")else:key_str = keyif key_str.startswith("batch_"):raw_data = db.db[key]parsed_records = parse_compact_cpu_usage_data(raw_data)for record in parsed_records:real_thread_id = thread_id_map.get(record["thread_id"], "unknown")thread_key = f"tid_{real_thread_id}"if thread_key not in temp_data:temp_data[thread_key] = {"timestamp": [record["timestamp"]],"thread_name": thread_key,"user_usage": [record["user_percent"]],"kernel_usage": [record["kernel_percent"]],}else:temp_data[thread_key]["timestamp"].append(record["timestamp"])temp_data[thread_key]["user_usage"].append(record["user_percent"])temp_data[thread_key]["kernel_usage"].append(record["kernel_percent"])db.close()frames = []for thread_name, usage in temp_data.items():df = pd.DataFrame({"timestamp": pd.to_datetime(usage["timestamp"], unit="s"),"thread_name": thread_name,"user_usage": usage["user_usage"],"kernel_usage": usage["kernel_usage"],})frames.append(df)return pd.concat(frames, ignore_index=True)

通过 read_db_data 函数，工具能够高效地从数据库中读取数据并进行预处理，为后续的统计分析和可视化做准备。

2.2 CPU 使用率曲线绘制

plot_cpu_usage 函数用于生成进程和线程的 CPU 使用率随时间变化的曲线图。工具支持多种自定义选项，例如按线程名称、CPU 类型（用户态或内核态）进行过滤，并能够在特定时间范围内显示数据。

def plot_cpu_usage(thread_info,data,filter_thread=None,filter_cpu_type=None,time_range=None,show_summary_info=True,
):plt.figure(figsize=(14, 10))# 计算进程总CPU使用情况process_cpu = calculate_process_cpu(data)# 将时间戳转换为小时:分钟:秒格式process_cpu["timestamp"] = pd.to_datetime(process_cpu["timestamp"]).dt.strftime("%H:%M:%S")# 绘制进程总CPU使用情况曲线plt.plot(process_cpu["timestamp"],process_cpu["total_usage"],label="Process Total CPU Usage",color="black",linewidth=2,)# 过滤线程或CPU类型if filter_thread:data = data[data["thread_name"].str.contains(filter_thread, case=False)]if filter_cpu_type:if filter_cpu_type.lower() == "user":data = data[["timestamp", "thread_name", "user_usage"]]elif filter_cpu_type.lower() == "kernel":data = data[["timestamp", "thread_name", "kernel_usage"]]if time_range:start_time, end_time = time_rangedata = data[(data["timestamp"] >= start_time) & (data["timestamp"] <= end_time)]data["timestamp"] = pd.to_datetime(data["timestamp"]).dt.strftime("%H:%M:%S")# 绘制每个线程的CPU使用情况曲线for thread_name in data["thread_name"].unique():subset = data[data["thread_name"] == thread_name]user_sum = subset.get("user_usage", 0)kernel_sum = subset.get("kernel_usage", 0)if isinstance(user_sum, int):user_sum = pd.Series(user_sum, index=subset.index)if isinstance(kernel_sum, int):kernel_sum = pd.Series(kernel_sum, index=subset.index)if user_sum.sum() + kernel_sum.sum() == 0:continuesubset = subset.fillna(0)# 绘制用户模式的CPU使用曲线if "user_usage" in subset.columns:plt.plot(subset["timestamp"],subset["user_usage"],label=f"{thread_name} (User)",linestyle="--",)# 绘制内核模式的CPU使用曲线if "kernel_usage" in subset.columns:plt.plot(subset["timestamp"],subset["kernel_usage"],label=f"{thread_name} (Kernel)",linestyle=":",)plt.xlabel("Time (HH:MM:SS)")plt.ylabel("CPU Usage (%)")plt.title("CPU Usage Over Time by Thread")# 调整x轴标签的密度x_ticks = plt.gca().get_xticks()plt.xticks(x_ticks[:: max(1, len(x_ticks) // 10)], rotation=45)plt.legend(loc="upper left", bbox_to_anchor=(1, 1))plt.grid(True)plt.tight_layout(rect=[0, 0.1, 1, 0.95])if show_summary_info:summary_info = get_summary_table(thread_info, data)plt.figtext(0.02,0.01,summary_info,fontsize=9,verticalalignment="bottom",horizontalalignment="left",bbox=dict(facecolor="white", alpha=0.5),)plt.savefig("cpu_usage_over_time.png")plt.show()

这个函数生成一个包含进程和线程 CPU 使用率的折线图。

2.3 分析结果

2.3.1 C++程序执行并生成数据库文件

使用C++程序thread_cpu_unqlite，我们可以实时采集指定进程或线程的CPU使用情况，并将这些数据存储在UnQLite数据库文件中。

执行命令：

./thread_cpu_unqlite -n1 dummp_worker -d dummp_worker.db

• -n1：指定数据采集的刷新频率为1秒。
• dummp_worker：指定要监控的进程名称或PID。
• -d dummp_worker.db：指定存储采集数据的数据库文件名为dummp_worker.db。

在上述命令中，C++程序会定期（每1秒）采集目标进程（或线程）的CPU使用数据，并将这些数据存储在名为dummp_worker.db的UnQLite数据库文件中。该文件包含每个线程的详细CPU使用信息，包括用户态时间、内核态时间、优先级等。

2.3.2 Python程序读取并分析数据库文件

Python程序thread_cpu_unqlite.py用于读取和分析由C++程序生成的数据库文件dummp_worker.db，并生成CPU使用情况的统计信息和可视化结果。

执行命令：

python3 thread_cpu_unqlite.py dummp_worker.db

• dummp_worker.db：指定需要分析的UnQLite数据库文件名。

Python程序将从dummp_worker.db中读取所有存储的CPU使用数据，并进行如下分析和展示：

• 线程CPU使用统计：计算每个线程的用户态和内核态CPU使用的最大值和平均值。例如：

  tid_1489: Max/Avg User=10%/4.44% | Max/Avg Kernel=21%/16.78%
  tid_1490: Max/Avg User=12%/4.36% | Max/Avg Kernel=20%/16.83%
  

  以上结果表明，线程tid_1489的用户态CPU使用率最大为10%，平均为4.44%；内核态CPU使用率最大为21%，平均为16.78%。类似地，线程tid_1490的用户态和内核态CPU使用率分别统计出来。

• 可视化展示：Python程序会生成一张CPU使用情况随时间变化的折线图，直观展示每个线程在不同时间段内的CPU使用率。

3. C++和Python程序关系的概述

+-------------------------------------------------+
|                  C++ 程序                        |
|  (Data Collection and Storage)                  |
|                                                 |
| +---------------------------------------------+ |
| |            数据采集 (Data Collection)       | |
| | - 从 `/proc` 文件系统读取进程和线程信息       | |
| | - 解析 stat 文件提取 CPU 使用数据            | |
| +---------------------------------------------+ |
|                                                 |
| +---------------------------------------------+ |
| |           数据处理 (Data Processing)        | |
| | - 计算每个线程的用户态和内核态 CPU 使用率    | |
| | - 将计算结果转换为紧凑的数据结构              | |
| +---------------------------------------------+ |
|                                                 |
| +---------------------------------------------+ |
| |            数据存储 (Data Storage)          | |
| | - 将处理后的数据存储到 UnQLite 数据库        | |
| | - 按时间批次存储，便于后续读取                | |
| +---------------------------------------------+ |
|                                                 |
+-------------------------------------------------+||数据存储 (Data Storage)|_______________________________________v+-------------------------------------------------+|                  Python 程序                     ||  (Data Analysis and Visualization)               ||                                                 || +---------------------------------------------+ || |            数据读取 (Data Reading)           | || | - 从 UnQLite 数据库中读取批量存储的数据       | || +---------------------------------------------+ ||                                                 || +---------------------------------------------+ || |            数据解析 (Data Parsing)           | || | - 解析紧凑的 CPU 使用数据结构                 | || | - 提取用户态和内核态的 CPU 使用率             | || +---------------------------------------------+ ||                                                 || +---------------------------------------------+ || |          数据可视化 (Data Visualization)     | || | - 生成 CPU 使用率随时间变化的折线图            | || | - 显示线程和进程的统计信息                    | || +---------------------------------------------+ ||                                                 |+-------------------------------------------------+

关系说明:

• 数据采集和存储：C++程序负责实时采集系统中各个线程的CPU使用情况，并将这些数据以紧凑的格式存储到UnQLite数据库中。
• 数据读取和分析：Python程序从UnQLite数据库中读取存储的数据，解析这些紧凑的数据格式，提取出各线程的CPU使用率信息。
• 数据可视化：Python程序生成直观的CPU使用率图表，帮助用户分析系统性能和资源利用率。

这种设计利用C++的高性能特性来进行数据采集和处理，确保了实时性和高效性；同时利用了Python的易用性和强大的数据分析与可视化能力.