Benchmark and performance evaluation for bpftime

The benchmark directory contains benchmarks and experiments for the bpftime project, including:

• Scripts for running experiments and generating figures
• Benchmark environments for different use cases
• Test code for performance evaluation

The benchmark is also tested for each commit in the CI: https://github.com/eunomia-bpf/bpftime/tree/master/.github/workflows/benchmarks.yml

The result will be published in https://eunomia-bpf.github.io/bpftime/benchmark/uprobe/results.html

You can check our OSDI paper Extending Applications Safely and Efficiently for more benchmark detail.

Getting Started

Install Dependencies

Please refer to our manual in bpftime build and test documentation for installing dependencies or using the Docker image.

The benchmark experiment scripts may automatically install dependencies and clone repos from the GitHub. Make sure you have Network access.

Run the experiments needs you have a Linux kernel with eBPF support, at lease 4 cores, and 16GB memory on x86_64 architecture.

Basic Usage

Check out the bpftime usage documentation for basic usage instructions. For the detail usage, please refer to each experiment directory.

Run All Experiments

before running the experiments, you also need to install some additional dependencies for the python scripts:

cd /path/to/bpftime
pip install -r benchmark/requirements.txt

then you can build and run the experiments by:

make benchmark # build the benchmark
make run-all-benchmark # run all benchmarks

(build time: 10min - 20min)

See the makefile for the details of the commands.

You can also check the CI for how we build the experiments and run them in .github/workflows/build-benchmarks.yml.

Experiments Overview

Experiment 1: Micro-benchmarks

This experiment measures the performance overhead and latency differences between bpftime and traditional kernel eBPF across various operations and use cases.

An example would be like:

Generated on 2025-04-30 0313. Environment

• OS: Linux 6.11.0-24-generic
• CPU: Intel(R) Core(TM) Ultra 7 258V (4 cores, 4 threads)
• Memory: 15.07 GB
• Python: 3.12.7

Core Uprobe Performance Summary

Kernel vs Userspace eBPF Detailed Comparison

Part 1: bpftime vs eBPF

Performance comparison including:

• Uprobe/uretprobe (see ./uprobe/)
• Memory read/write operations (see ./uprobe/)
• Map operations (see ./uprobe/)
• Embedded VM in your program without hooking (see ./uprobe/ and the code in test_embed.c)
• Syscall tracepoint (see ./syscall/)
• MPK enable/disable (see ./mpk/)

You can check each directory for the details of the experiments, how to run them and the results.

(20min - 30 min computation time)

Part 2: Execution Engine Efficiency

This part evaluates the execution performance of different eBPF virtual machines and JIT compilers to compare their efficiency in running eBPF programs.

See the code used in our bpf-benchmark repository.

Part 3: Load Latency

This part measures the time required to load and attach eBPF programs.

The measurement tool is located in ../tools/cli/main.cpp.

Experiment 2: SSL/TLS Traffic Inspection (sslsniff)

This experiment demonstrates bpftime's capability to intercept and inspect SSL/TLS traffic in real-time by hooking into OpenSSL functions within nginx, measuring both performance impact and functionality.

• Environment and results: See ./ssl-nginx/
• Example code: See ../example/tracing/sslsniff

Experiment 3: System Call Counting (syscount)

This experiment evaluates bpftime's ability to trace and count system calls made by applications like nginx, comparing the overhead and accuracy with kernel-based tracing.

• Environment and results: See ./syscount-nginx/
• Example code: See ../example/tracing/syscount

Experiment 4: Nginx Plugin/Module

This experiment showcases how bpftime can be integrated as a plugin or module within nginx.

• Implementation code: See ../example/attach_implementation
• Benchmark scripts are included in the implementation directory

Experiment 5: DeepFlow

This experiment measures the performance impact of integrating bpftime with DeepFlow, an observability platform, to evaluate how userspace eBPF affects network monitoring and tracing workloads.

Performance evaluation for DeepFlow integration - see ./deepflow/ directory.

Experiment 6: FUSE (Filesystem in Userspace)

This experiment evaluates bpftime's performance when instrumenting FUSE-based filesystems to cache syscall results.

FUSE-related benchmarks - see ./fuse/ directory.

Experiment 7: Redis Durability Tuning

This experiment demonstrates how bpftime can be used to dynamically tune Redis durability settings at runtime, measuring the performance benefits of userspace extensions for database optimization.

Redis durability tuning benchmarks - see ./redis-durability-tuning/ directory.

Experiment 8: Compatibility

This experiment validates that existing eBPF programs can run seamlessly on both kernel eBPF and bpftime without modification, demonstrating the compatibility and portability of the userspace eBPF runtime.

Various compatibility examples that can run on both kernel eBPF and bpftime - see ../example directory.