WEBKT

系统管理员的eBPF实战：CPU性能监控与优化指南

116 0 0 0

为什么要用 eBPF 监控 CPU？

eBPF 监控 CPU 的原理

实战：使用 eBPF 监控进程 CPU 使用率

1. 准备工作

2. 编写 eBPF 程序

3. 运行 eBPF 程序

4. 分析 CPU 使用情况

进阶：监控 CPU 上下文切换

优化建议

总结

作为一名系统管理员，优化服务器性能和资源利用率是日常工作的重中之重。面对日益复杂的应用环境，传统的监控工具往往难以提供足够精细的 CPU 使用情况。这时，eBPF (extended Berkeley Packet Filter) 技术就成了我们的利器。它允许我们在内核中安全地运行自定义代码，实时监控和分析 CPU 资源的使用情况，从而实现更高效的性能优化。今天，我就来分享如何利用 eBPF 监控 CPU 资源，并通过实战案例，让你快速掌握这项技术。

为什么要用 eBPF 监控 CPU？

传统的性能监控工具，例如 top、vmstat 等，虽然可以提供 CPU 的总体使用情况，但它们往往无法深入到进程级别，更难以追踪到具体的函数调用。而 eBPF 则不同，它具有以下优势：

  • 内核级监控：eBPF 程序运行在内核空间，可以访问内核数据结构和事件，从而实现更精细的监控。
  • 低开销：eBPF 程序经过内核验证和 JIT 编译，执行效率高，对系统性能的影响很小。
  • 高度可定制：我们可以根据自己的需求编写 eBPF 程序，监控特定的 CPU 指标，例如进程 CPU 使用率、上下文切换次数、缓存命中率等。
  • 实时性：eBPF 程序可以实时收集和分析数据，及时发现性能瓶颈。

eBPF 监控 CPU 的原理

eBPF 监控 CPU 的原理主要基于以下几个关键点：

  1. 探针 (Probe)：eBPF 允许我们将程序挂载到内核中的特定事件点，例如函数入口、函数返回、系统调用等。这些事件点被称为探针。常见的探针类型包括 kprobe (内核探针)、uprobe (用户态探针)、tracepoint 等。

  2. 事件过滤：我们可以通过设置过滤器，只捕获特定进程或用户的事件。例如，我们可以只监控某个特定进程的 CPU 使用情况。

  3. 数据收集与存储：当探针被触发时，eBPF 程序会收集相关数据，例如进程 ID、CPU 时间、函数参数等。这些数据可以存储在 eBPF 的数据结构中，例如哈希表、数组等。

  4. 数据分析与输出：我们可以编写用户态程序，从 eBPF 数据结构中读取数据，并进行分析和展示。例如，我们可以计算每个进程的 CPU 使用率，并将其以图表的形式展示出来。

实战：使用 eBPF 监控进程 CPU 使用率

下面，我们通过一个实战案例，演示如何使用 eBPF 监控进程的 CPU 使用率。我们将使用 bcc (BPF Compiler Collection) 工具集，它提供了一系列 Python 封装，方便我们编写和运行 eBPF 程序。

1. 准备工作

首先，我们需要安装 bcc 工具集。在 Ubuntu 系统上，可以使用以下命令安装：

sudo apt-get update
sudo apt-get install -y bpfcc-tools linux-headers-$(uname -r)

安装完成后，我们需要确保内核头文件与当前运行的内核版本匹配。如果不匹配，可能会导致编译错误。

2. 编写 eBPF 程序

接下来，我们编写 eBPF 程序，用于监控进程的 CPU 使用率。创建一个名为 cpu_usage.py 的文件，并添加以下代码：

#!/usr/bin/env python3
 
from bcc import BPF
import time
 
# eBPF 程序代码
program = '''
#include <uapi/linux/ptrace.h>
#include <linux/sched.h>
 
struct key_t {
  u32 pid;
  char comm[TASK_COMM_LEN];
};
 
BPF_HASH(start, struct key_t, u64);
BPF_HASH(counts, struct key_t, u64);
 
int sched_switch(struct pt_regs *ctx, struct task_struct *prev) {
  struct key_t key = {.pid = prev->pid};
  bpf_get_current_comm(&key.comm, sizeof(key.comm));
 
  u64 ts = bpf_ktime_get_ns();
  start.update(&key, &ts);
 
  return 0;
}
 
int sched_wakeup(struct pt_regs *ctx, struct task_struct *p) {
  struct key_t key = {.pid = p->pid};
  bpf_get_current_comm(&key.comm, sizeof(key.comm));
 
  u64 *tsp = start.lookup(&key);
  if (tsp) {
    u64 delta = bpf_ktime_get_ns() - *tsp;
    counts.increment(key, delta);
    start.delete(&key);
  }
 
  return 0;
}
'''
 
# 创建 BPF 实例
bpf = BPF(text=program)
 
# 挂载探针
bpf.attach_kprobe(event='finish_task_switch', fn_name='sched_switch')
bpf.attach_kprobe(event='wake_up_new_task', fn_name='sched_wakeup')
 
# 打印表头
print('Tracing... Press Ctrl+C to end.')
print('%-16s %-6s %s' % ('COMM', 'PID', 'CPU (ms)'))
 
# 循环读取数据
try:
  while True:
    time.sleep(1)
    for k, v in bpf['counts'].items():
      cpu_ms = v.value / 1000000
      print('%-16s %-6d %.2f' % (k.comm.decode(), k.pid, cpu_ms))
    bpf['counts'].clear()
except KeyboardInterrupt:
  pass

这段代码主要做了以下几件事：

  • 定义 eBPF 程序：使用 C 语言编写 eBPF 程序，其中定义了两个哈希表 start 和 counts。start 用于记录进程开始运行的时间戳，counts 用于累加进程的 CPU 时间。
  • 挂载探针：使用 attach_kprobe 函数将 eBPF 程序挂载到 finish_task_switch 和 wake_up_new_task 两个内核事件点。finish_task_switch 在进程切换时被触发，wake_up_new_task 在新进程被唤醒时被触发。
  • 读取数据：循环读取 counts 哈希表中的数据，计算每个进程的 CPU 时间，并打印出来。

3. 运行 eBPF 程序

保存 cpu_usage.py 文件，并使用以下命令运行：

sudo python3 cpu_usage.py

运行后，你将会看到类似以下的输出：

Tracing... Press Ctrl+C to end.
COMM             PID    CPU (ms)
python3          1234   10.23
syslogd          456    2.56
...             ...

这表示 python3 进程使用了 10.23 毫秒的 CPU 时间，syslogd 进程使用了 2.56 毫秒的 CPU 时间。你可以根据自己的需求，调整监控的时间间隔和输出格式。

4. 分析 CPU 使用情况

通过运行 eBPF 程序，我们可以实时监控每个进程的 CPU 使用情况。如果发现某个进程的 CPU 使用率过高，我们可以进一步分析该进程，找出性能瓶颈。

例如，我们可以使用 perf 工具分析该进程的函数调用，找出 CPU 密集型的函数。或者，我们可以使用 strace 工具跟踪该进程的系统调用，找出 IO 瓶颈。

进阶：监控 CPU 上下文切换

除了监控 CPU 使用率，我们还可以使用 eBPF 监控 CPU 上下文切换次数。上下文切换是指 CPU 从一个进程切换到另一个进程的过程。过多的上下文切换会降低系统性能，因为它需要保存和恢复进程的状态。

我们可以修改上面的 eBPF 程序，添加对上下文切换次数的监控。修改后的代码如下：

#!/usr/bin/env python3
 
from bcc import BPF
import time
 
# eBPF 程序代码
program = '''
#include <uapi/linux/ptrace.h>
#include <linux/sched.h>
 
struct key_t {
  u32 pid;
  char comm[TASK_COMM_LEN];
};
 
BPF_HASH(start, struct key_t, u64);
BPF_HASH(counts, struct key_t, u64);
BPF_HASH(switches, struct key_t, u64);
 
int sched_switch(struct pt_regs *ctx, struct task_struct *prev) {
  struct key_t key = {.pid = prev->pid};
  bpf_get_current_comm(&key.comm, sizeof(key.comm));
 
  u64 ts = bpf_ktime_get_ns();
  start.update(&key, &ts);
 
  switches.increment(key);
 
  return 0;
}
 
int sched_wakeup(struct pt_regs *ctx, struct task_struct *p) {
  struct key_t key = {.pid = p->pid};
  bpf_get_current_comm(&key.comm, sizeof(key.comm));
 
  u64 *tsp = start.lookup(&key);
  if (tsp) {
    u64 delta = bpf_ktime_get_ns() - *tsp;
    counts.increment(key, delta);
    start.delete(&key);
  }
 
  return 0;
}
'''
 
# 创建 BPF 实例
bpf = BPF(text=program)
 
# 挂载探针
bpf.attach_kprobe(event='finish_task_switch', fn_name='sched_switch')
bpf.attach_kprobe(event='wake_up_new_task', fn_name='sched_wakeup')
 
# 打印表头
print('Tracing... Press Ctrl+C to end.')
print('%-16s %-6s %-10s %s' % ('COMM', 'PID', 'SWITCHES', 'CPU (ms)'))
 
# 循环读取数据
try:
  while True:
    time.sleep(1)
    for k, v in bpf['counts'].items():
      cpu_ms = v.value / 1000000
      switches_count = bpf['switches'][k].value
      print('%-16s %-6d %-10d %.2f' % (k.comm.decode(), k.pid, switches_count, cpu_ms))
    bpf['counts'].clear()
    bpf['switches'].clear()
except KeyboardInterrupt:
  pass

这段代码主要做了以下修改：

  • 添加 switches 哈希表：用于记录每个进程的上下文切换次数。
  • 在 sched_switch 函数中增加计数：每次进程切换时，switches 哈希表中对应进程的计数器加 1。
  • 修改输出格式：在输出中增加上下文切换次数。

运行修改后的代码，你将会看到类似以下的输出：

Tracing... Press Ctrl+C to end.
COMM             PID    SWITCHES   CPU (ms)
python3          1234   123        10.23
syslogd          456    45         2.56
...             ...

这表示 python3 进程进行了 123 次上下文切换，syslogd 进程进行了 45 次上下文切换。如果发现某个进程的上下文切换次数过多，我们可以进一步分析该进程，找出导致上下文切换过多的原因。

优化建议

通过 eBPF 监控 CPU 使用情况，我们可以发现潜在的性能瓶颈，并采取相应的优化措施。以下是一些常见的优化建议：

  • 减少不必要的进程：关闭不必要的进程，减少 CPU 的负担。
  • 优化代码：优化 CPU 密集型的代码，减少 CPU 的使用时间。
  • 增加 CPU 资源：如果 CPU 资源不足，可以考虑增加 CPU 核心数或提高 CPU 频率。
  • 调整进程优先级：根据进程的重要性，调整进程的优先级，确保重要进程能够获得足够的 CPU 资源。
  • 减少上下文切换：优化代码，减少进程的阻塞和唤醒，从而减少上下文切换次数。

总结

eBPF 是一项强大的技术，可以帮助我们深入了解 CPU 资源的使用情况，并进行精细化的性能优化。通过本文的介绍和实战案例，相信你已经掌握了使用 eBPF 监控 CPU 的基本方法。在实际工作中，你可以根据自己的需求，编写自定义的 eBPF 程序，监控更多的 CPU 指标，从而实现更高效的性能优化。

希望这篇文章能够帮助你更好地理解和应用 eBPF 技术。如果你在实践过程中遇到任何问题，欢迎留言讨论。

内核探索者 eBPFCPU监控性能优化

评论点评

打赏赞助
sponsor

感谢您的支持让我们更好的前行

分享

QRcode

https://www.webkt.com/article/9214