Profiling

Performance profiling tools for Jolt zkVM

Jolt provides comprehensive profiling capabilities to help you analyze and optimize the performance of your zkVM programs.

Execution Profiling

Jolt uses tokio-rs/tracing for execution profiling, allowing you to generate detailed traces of your program’s execution.

Basic Trace Generation

To generate an execution trace, run:

cargo run --release -p jolt-core profile --name sha3 --format chrome

The --name parameter accepts the following benchmark programs:

• sha2
• sha3
• sha2-chain
• fibonacci
• btreemap

The corresponding guest programs can be found in the examples directory. Benchmark inputs are provided in bench.rs.

This command outputs a JSON file in the workspace root with the name trace-<timestamp>.json, which can be viewed in Perfetto.

CPU and Memory Monitoring

To track CPU and memory usage alongside your execution trace, use the monitor feature:

cargo run --release --features monitor -p jolt-core profile --name sha3 --format chrome

This logs CPU and memory metrics as tracing events. To convert these counter events into Perfetto counter tracks for easier visualization:

# Run profiling with monitor feature
cargo run --release --features monitor -p jolt-core profile --name sha3 --format chrome

# Post-process the trace for better visualization
python3 scripts/postprocess_trace.py benchmark-runs/perfetto_traces/*.json

The monitor feature provides real-time insights into resource consumption during proving, which is especially useful for identifying bottlenecks.

CPU Profiling with pprof

For detailed CPU profiling, enable the pprof feature:

cargo run --release --features pprof -p jolt-core profile --name sha3 --format chrome

This produces a .pb profile file that can be viewed using pprof:

go tool pprof -http=:8080 target/release/jolt-core benchmark-runs/pprof/sha3_prove.pb

The pprof visualization helps identify hot paths in your code, making it easier to optimize performance-critical sections.

Memory Profiling

Jolt uses allocative for memory profiling, allowing you to measure the total heap space occupied by data structures and generate flamegraphs.

Generating Memory Profiles

Most sumcheck data structures in Jolt implement the Allocative trait. Flamegraphs are generated at the start and end of stages 2-5 (see jolt_dag.rs).

To generate allocative output:

RUST_LOG=debug cargo run --release --features allocative -p jolt-core profile --name sha3 --format chrome

The --name parameter accepts the same benchmark programs as execution profiling:

• sha2
• sha3
• sha2-chain
• fibonacci
• btreemap

Understanding the Output

The command will:

1. Log memory usage information to the command line
2. Output multiple SVG files (e.g., stage3_start_flamechart.svg)
3. Generate flamegraphs that can be viewed in any web browser

Memory flamegraphs provide a visual representation of heap allocations, making it easy to identify memory-intensive data structures.

Best Practices

When profiling:

• Always use --release builds for accurate performance measurements
• Start with execution profiling to identify slow stages
• Use memory profiling to optimize heap usage in critical stages
• Combine multiple profiling techniques for comprehensive analysis

Debug builds can be orders of magnitude slower than release builds. Always profile with --release to get realistic performance data.