使用eBPF关联函数执行时间与CPU、内存等指标，深度分析性能瓶颈

作为一名整天和代码打交道的程序员，性能优化永远是绕不开的话题。面对日益复杂的系统，仅仅靠经验和猜测很难定位到真正的性能瓶颈。今天，我们来聊聊如何利用eBPF的强大能力，将函数执行时间与CPU、内存等系统性能指标关联起来，从而进行更深入的性能分析。

为什么需要关联函数执行时间和系统性能指标？

通常情况下，我们可能会使用一些 profiling 工具来分析函数的执行时间，或者使用 top 命令来查看 CPU 和内存的使用情况。但这些工具往往是独立的，难以将它们的数据关联起来。比如，我们发现某个函数的执行时间很长，但不知道它在执行期间 CPU 和内存的使用情况，就很难判断是 CPU 密集型还是内存密集型操作导致的性能瓶颈。如果能够将函数的执行时间与 CPU 使用率、内存占用等指标关联起来，就可以更清晰地看到函数执行期间的资源消耗情况，从而更快地定位到性能瓶颈。

举个例子，假设我们发现一个负责处理网络请求的函数执行时间很长。如果通过关联分析发现，在函数执行期间，CPU 使用率一直很高，那么很可能是 CPU 密集型计算导致了瓶颈。这时，我们可以考虑优化算法、使用多线程等方式来提升 CPU 的利用率。但如果发现函数执行期间，内存占用很高，并且频繁发生 page fault，那么很可能是内存分配或访问方式有问题，需要考虑优化内存管理策略。

如何使用 eBPF 关联函数执行时间和系统性能指标？

eBPF 允许我们在内核中安全地运行自定义代码，可以用来收集各种系统事件和性能指标。下面我们将介绍如何使用 eBPF 来关联函数执行时间和 CPU、内存等指标。

1. 确定要监控的函数和性能指标

首先，我们需要确定要监控的关键函数，以及想要关联的性能指标。例如，我们想要监控某个网络服务的请求处理函数 handle_request 的执行时间，并关联 CPU 使用率和内存占用情况。

2. 编写 eBPF 程序

接下来，我们需要编写 eBPF 程序来收集函数执行时间和性能指标。可以使用 BCC (BPF Compiler Collection) 或者 libbpf 提供的工具链来编写和编译 eBPF 程序。以下是一个简单的示例，展示了如何使用 BCC 监控函数执行时间，并记录 CPU 使用率：

from bcc import BPF
import time
 
# 定义 eBPF 程序
program = '''
#include <uapi/linux/ptrace.h>
#include <linux/sched.h>
 
struct data_t {
    u64 pid;
    u64 ts;
    u64 cpu;
    u64 duration;
};
 
BPF_PERF_OUTPUT(events);
 
// 函数入口探针
int kprobe__handle_request(struct pt_regs *ctx) {
    u64 pid = bpf_get_current_pid_tgid();
    u64 ts = bpf_ktime_get_ns();
    u64 cpu = bpf_get_smp_processor_id();
 
    // 存储进程 ID、时间戳和 CPU ID
    bpf_map_update_elem(&start, &pid, &ts, BPF_ANY);
    bpf_map_update_elem(&cpu_id, &pid, &cpu, BPF_ANY);
 
    return 0;
}
 
// 函数返回探针
int kretprobe__handle_request(struct pt_regs *ctx) {
    u64 pid = bpf_get_current_pid_tgid();
    u64 *tsp = bpf_map_lookup_elem(&start, &pid);
    u64 *cpu_p = bpf_map_lookup_elem(&cpu_id, &pid);
 
    if (tsp == NULL || cpu_p == NULL) {
        return 0;   // 进程可能已经退出
    }
 
    u64 ts = *tsp;
    u64 cpu = *cpu_p;
    u64 duration = bpf_ktime_get_ns() - ts;
 
    // 构造数据并发送到用户空间
    struct data_t data = {};
    data.pid = pid;
    data.ts = ts;
    data.cpu = cpu;
    data.duration = duration;
    events.perf_submit(ctx, &data, sizeof(data));
 
    // 清理 map
    bpf_map_delete_elem(&start, &pid);
    bpf_map_delete_elem(&cpu_id, &pid);
 
    return 0;
}
 
BPF_HASH(start, u64, u64);
BPF_HASH(cpu_id, u64, u64);
'''
 
# 加载 eBPF 程序
b = BPF(text=program)
 
# 打印事件
def print_event(cpu, data, size):
    event = b["events"].event(data)
    print("PID: %d, CPU: %d, Duration: %d ns" % (event.pid >> 32, event.cpu, event.duration))
 
# 附加 perf_buffer
b["events"].open_perf_buffer(print_event)
 
# 循环读取事件
while True:
    try:
        b.perf_buffer_poll()
    except KeyboardInterrupt:
        exit()

这段代码使用了 kprobe 和 kretprobe 分别在 handle_request 函数的入口和出口处设置探针。在入口探针中，我们记录了进程 ID、时间戳和 CPU ID。在出口探针中，我们计算了函数执行时间，并将这些数据发送到用户空间。

注意： 上面的代码只是一个简单的示例，用于演示如何监控函数执行时间和 CPU ID。实际应用中，你可能需要根据具体的需求修改代码，例如：

• 使用 bpf_get_current_uid_gid() 获取用户 ID 和组 ID。
• 使用 bpf_probe_read() 读取函数参数或返回值。
• 使用不同的 BPF map 类型，例如 BPF_ARRAY 或 BPF_RINGBUF。

3. 收集 CPU 和内存等系统性能指标

除了函数执行时间，我们还需要收集 CPU 使用率和内存占用等系统性能指标。可以使用 psutil 等 Python 库来获取这些指标。以下是一个简单的示例：

import psutil
 
def get_cpu_usage():
    return psutil.cpu_percent()
 
def get_memory_usage():
    memory = psutil.virtual_memory()
    return memory.percent

4. 关联数据并进行分析

现在，我们已经收集了函数执行时间和系统性能指标，接下来需要将这些数据关联起来。可以在用户空间的 Python 脚本中，将 eBPF 程序输出的函数执行时间与 psutil 获取的 CPU 和内存使用率进行关联。例如，可以按照时间戳将函数执行时间和同一时间段内的 CPU 和内存使用率进行匹配。

# 假设 events 包含了 eBPF 程序输出的函数执行时间数据
# 并且已经按照时间戳排序
 
for event in events:
    timestamp = event.ts
    cpu_usage = get_cpu_usage_at_time(timestamp)
    memory_usage = get_memory_usage_at_time(timestamp)
 
    print("PID: %d, Timestamp: %d, Duration: %d ns, CPU: %.2f%%, Memory: %.2f%%" % (
        event.pid >> 32, timestamp, event.duration, cpu_usage, memory_usage
    ))

关联数据之后，我们可以使用各种工具进行分析，例如：

• 绘制图表，展示函数执行时间与 CPU 和内存使用率的关系。
• 计算函数执行期间的平均 CPU 使用率和内存占用。
• 识别 CPU 和内存使用率异常高的函数调用。

通过这些分析，我们可以更全面地了解函数的性能瓶颈，并采取相应的优化措施。

更进一步：使用 uprobe 监控用户态函数

上面的例子中使用的是 kprobe 和 kretprobe 来监控内核态函数。如果想要监控用户态函数，可以使用 uprobe 和 uretprobe。使用 uprobe 需要知道目标函数在内存中的地址，可以使用 objdump 或 nm 等工具来获取函数地址。以下是一个简单的示例，展示了如何使用 uprobe 监控用户态函数：

from bcc import BPF
 
# 定义 eBPF 程序
program = '''
#include <uapi/linux/ptrace.h>
 
BPF_PERF_OUTPUT(events);
 
int uprobe__my_function(struct pt_regs *ctx) {
    u64 pid = bpf_get_current_pid_tgid();
    u64 ts = bpf_ktime_get_ns();
 
    struct data_t data = {};
    data.pid = pid;
    data.ts = ts;
    events.perf_submit(ctx, &data, sizeof(data));
 
    return 0;
}
 
struct data_t {
    u64 pid;
    u64 ts;
};
'''
 
# 加载 eBPF 程序
b = BPF(text=program, usdt_contexts=[])
 
# 替换为实际的进程 PID 和函数地址
pid = 1234
function_address = 0x12345678
 
# 附加 uprobe
b.attach_uprobe(name="/path/to/your/program", sym="my_function", fn_name="uprobe__my_function", pid=pid)
 
# 打印事件
def print_event(cpu, data, size):
    event = b["events"].event(data)
    print("PID: %d, Timestamp: %d" % (event.pid >> 32, event.ts))
 
# 附加 perf_buffer
b["events"].open_perf_buffer(print_event)
 
# 循环读取事件
while True:
    try:
        b.perf_buffer_poll()
    except KeyboardInterrupt:
        exit()

注意： 使用 uprobe 需要谨慎，因为用户态函数的地址可能会随着程序更新而改变。建议使用 USDT (User Statically Defined Tracing) 来替代 uprobe，USDT 提供了一种更稳定和可靠的方式来跟踪用户态函数。

总结

通过使用 eBPF 关联函数执行时间和系统性能指标，我们可以更全面地了解系统的性能瓶颈，并采取相应的优化措施。希望本文能够帮助你更好地利用 eBPF 进行性能分析。当然，eBPF 的能力远不止于此，还有很多其他的应用场景等待我们去探索。