本文主要是介绍Linux编程: C++程序线程CPU使用率监控与分析小工具,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!
文章目录
- 0. 引言
- 1. 数据采集与处理(C++部分)
- 1.1 基于 Linux `/proc` 文件系统的监控机制
- 1.1.1 跨平台数据获取
- 1.2 基于 C++ 的定时器和循环机制的数据采集程序
- 1.3 数据解析与处理
- 1.3.1 `ParseStatFile` 函数
- 1.3.2 `ComputeCpuUsage` 函数
- 1.4 数据存储
- 1.4.1. 使用 UnQLite 作为数据存储的优势
- 1.4.2. C++ 结构体设计的优点
- 1.5. 多个进程同时分析支持
- 2. 数据解析与可视化(Python部分)
- 2.1 数据聚合与统计分析
- 2.1.1 `read_db_data` 函数
- 2.2 CPU 使用率曲线绘制
- 2.3 分析结果
- 2.3.1 **C++程序执行并生成数据库文件**
- 2.3.2 **Python程序读取并分析数据库文件**
- 3. C++和Python程序关系的概述
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的易用性和强大的数据分析与可视化能力.
这篇关于Linux编程: C++程序线程CPU使用率监控与分析小工具的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!