export MALLOC_CONF="prof:true,prof_prefix:./jeprof.out,lg_prof_interval:30,lg_prof_sample:20"

sudo ./jeprof /opt/taobao/java/bin/java jeprof.out.651.2.i2.heap

# 安装 profing 进程二进制的 debuginfo 包（略）

#perf record -a -F 999 -g -p 19309 sleep 120 >perf.data
Warning:
PID/TID switch overriding SYSTEM
[ perf record: Woken up 1 times to write data ]
[ perf record: Captured and wrote 0.071 MB perf.data (188 samples) ]

# 将 perf.data 转换为文本文件
$ perf script >perf.txt
$ head perf.txt
bp-agent 20608 5140019.602283:          1 cycles:ppp:
        ffffffff90067b76 native_write_msr+0x6 ([kernel.kallsyms])
        ffffffff9000c987 __intel_pmu_enable_all.constprop.26+0x47 ([kernel.kallsyms])
        ffffffff901dba3b __perf_event_task_sched_in+0x19b ([kernel.kallsyms])
        ffffffff900c440a finish_task_switch+0x13a ([kernel.kallsyms])
        ffffffff908446b7 __sched_text_start+0x3d7 ([kernel.kallsyms])
        ffffffff90844973 schedule+0x33 ([kernel.kallsyms])
        ffffffff90135e91 futex_wait_queue_me+0xc1 ([kernel.kallsyms])
        ffffffff90136ba6 futex_wait+0xf6 ([kernel.kallsyms])
        ffffffff901393cb do_futex+0x12b ([kernel.kallsyms])

perf record -F 99 -g --call-graph=dwarf -p 35775 -g -- sleep 10
perf report
perf script > out.perf

git clone https://github.com/brendangregg/FlameGraph
cd FlameGraph/
# 使用 ./stackcollapse-perf.pl 工具将 perf 数据转换
./stackcollapse-perf.pl  ../out.perf > out.folded
./flamegraph.pl out.folded > process.svg
open process.svg

sudo bpftrace -e 'profile:hz:99 { @[kstack] = count(); }' > trace.data
cd FlameGraph
# 使用 stackcollapse-bpftrace.pl 工具进行转换
./stackcollapse-bpftrace.pl trace.data > trace.folded
./flamegraph.pl --inverted trace.folded > traceflamegraph.svg

# 也可以对 uprobe 指定的函数调用栈生成 tarce 数据，然后生成火焰图
$ grep libwebp /proc/25760/maps
7f7bc6af3000-7f7bc6af6000 r--p 00000000 09:01 38281904                   /usr/lib/x86_64-linux-gnu/libwebp.so.6.0.2
$ sudo bpftrace -e 'uprobe:/usr/lib/x86_64-linux-gnu/libwebp.so.6.0.2:* {time("%H:%M:%S "); printf("%s %d\n",comm,pid);}' | tee /tmp/libwebp.trace

# profiling 前需要先放开内核限制
echo '-1' | sudo tee /proc/sys/kernel/perf_event_paranoid

#https://github.com/zed-industries/zed/pull/8972/files
echo "Running perf on collab, collecting 30s of data..."

kubectl -n $environment exec -it deployments/collab -- perf record -p 1 -g -m 64 --call-graph dwarf -- sleep 30

run="collab-$environment-$(date -Iseconds)"
echo "Processing data and downloading to '$run.perf'..."

kubectl -n $environment exec -it deployments/collab -- perf --no-pager script > "$run.perf"

# inferno 是 Rust 版本的 https://github.com/brendangregg/FlameGraph 实现
# 参考：https://github.com/jonhoo/inferno?tab=readme-ov-file
which inferno-flamegraph 2>/dev/null || (echo "installing inferno..."; cargo install inferno)
inferno-collapse-perf "$run.perf" | inferno-flamegraph > "$run.svg"

open "$run.svg"

perf record \
    -e cycles \                             # on-CPU profiling
    -e sched:sched_switch --switch-events \ # off-CPU profiling
    --sample-cpu \                          # track on which core code is executed
    -m 8M \                                 # reduce chance of event loss
    --aio -z \                              # reduce disk-I/O overhead and data size
    --call-graph dwarf \                    # we definitely want backtraces
    <your application>

echo '-1' | sudo tee /proc/sys/kernel/perf_event_paranoid

samply record ./my-application my-arguments

go install github.com/google/pprof@latest

# https://github.com/google/perf_data_converter

# Profile a command using perf, for example:
perf record /bin/ls

# Recent versions of pprof will automatically invoke perf_to_profile:
pprof -web perf.data

# profiling 前需要先放开内核限制
echo '-1' | sudo tee /proc/sys/kernel/perf_event_paranoid

# Linux 系统安装 perf 工具。（略）

# Rust 项目集成，直接编译和运行二进制，并进行 CPU Profiling
cargo flamegraph

# Run your default target with no arguments
cargo flamegraph

# Run your default target with the arguments after --
cargo flamegraph -- arg1 arg2 arg3

# Run the specified bin target with arguments
cargo flamegraph -b mybin -- arg1 arg2 arg3

# Run your default target with arguments and save
# the results to a different filename
cargo flamegraph -o myoutput.svg -- arg1 arg2 arg3

# 任意二进制 profing 和生成火焰图
flamegraph -- /path/to/binary

# profing 正在运行的进程
flamegraph [-o my_flamegraph.svg] --pid 1337

sudo apt-get install valgrind
valgrind --tool=dhat ./my-program

#yum info heaptrack
Last metadata expiration check: 0:05:52 ago on Fri 10 Oct 2025 06:16:52 PM CST.
Available Packages
Name         : heaptrack
Version      : 1.2.0
Release      : 7.el8
Architecture : x86_64
Size         : 562 k
Source       : heaptrack-1.2.0-7.el8.src.rpm
Repository   : epel
Summary      : A heap memory profiler for Linux
URL          : https://cgit.kde.org/heaptrack.git/
License      : GPLv2+
Description  : Heaptrack traces all memory allocations and annotates these events with stack
             : traces.Dedicated analysis tools then allow you to interpret the heap memory
             : profile to:
             : - find hotspots that need to be optimized to reduce the memory footprint of your
             :   application
             : - find memory leaks, i.e. locations that allocate memory which is never
             :   deallocated
             : - find allocation hotspots, i.e. code locations that trigger a lot of memory
             :   allocation calls
             : - find temporary allocations, which are allocations that are directly followed
             :   by their deallocation

# 直接执行程序
heaptrack <your application and its parameters>

heaptrack output will be written to "/tmp/heaptrack.APP.PID.gz"
starting application, this might take some time...

...

heaptrack stats:
    allocations:            65
    leaked allocations:     60
    temporary allocations:  1

Heaptrack finished! Now run the following to investigate the data:

    heaptrack --analyze "/tmp/heaptrack.APP.PID.gz"


# 或者，采集正在运行的程序
heaptrack --pid $(pidof <your application>)

heaptrack output will be written to "/tmp/heaptrack.APP.PID.gz"
injecting heaptrack into application via GDB, this might take some time...
injection finished

...

Heaptrack finished! Now run the following to investigate the data:

    heaptrack --analyze "/tmp/heaptrack.APP.PID.gz"

heaptrack_print heaptrack.APP.PID.gz | less

# https://github.com/rust-lang/rustc-demangle

$ cargo build -p rustc-demangle-capi --release

# 头文件：crates/capi/include/rustc_demangle.h
# 库文件：target/release/librustc_demangle.a and target/release/librustc_demangle.so

#yum install gperftools.x86_64

#rpm -qi gperftools.x86_64 |grep Source
Source RPM  : gperftools-2.7-9.el8.src.rpm

#rpm -ql gperftools-libs
/usr/lib/.build-id
/usr/lib/.build-id/03
/usr/lib/.build-id/03/a826e894296e8a834a7a5378821885acda325f
/usr/lib/.build-id/17
/usr/lib/.build-id/17/00677b96115d66836234a49fa7c1568979e3e2
/usr/lib/.build-id/2a
/usr/lib/.build-id/2a/f8a846581d5a62a36ebf5528ccd5a2484be464
/usr/lib/.build-id/2c
/usr/lib/.build-id/2c/61dab09d46c69147ec39b9cec0b5daed2fc101
/usr/lib/.build-id/7e
/usr/lib/.build-id/7e/ec65f2b4e39dbefad415e9640a631851a77ffa
/usr/lib/.build-id/d5
/usr/lib/.build-id/d5/555de1328238f4aea66a1d976f53665df81f90
/usr/lib64/libprofiler.so.0
/usr/lib64/libprofiler.so.0.4.18
/usr/lib64/libtcmalloc.so.4
/usr/lib64/libtcmalloc.so.4.5.3
/usr/lib64/libtcmalloc_and_profiler.so.4
/usr/lib64/libtcmalloc_and_profiler.so.4.5.3
/usr/lib64/libtcmalloc_debug.so.4
/usr/lib64/libtcmalloc_debug.so.4.5.3
/usr/lib64/libtcmalloc_minimal.so.4
/usr/lib64/libtcmalloc_minimal.so.4.5.3
/usr/lib64/libtcmalloc_minimal_debug.so.4
/usr/lib64/libtcmalloc_minimal_debug.so.4.5.3

#LD_PRELOAD=/usr/lib64/libprofiler.so  CPUPROFILE=find.cpu.prof find /
#pprof --pdf /usr/bin/find find.cpu.prof  >find.cpu.pdf
#open find.cpu.pdf

export LD_PRELOAD=/usr/local/lib/libprofiler.so.0
export CPUPROFILE=a.out.prof
export CPUPROFILESIGNAL=12
export CPUPROFILE_FREQUENCY=100
export CPUPROFILE_REALTIME=1  # 默认是 ITIMER_PROF，设置该环境变量后切换为 ITIMER_REAL
export CPUPROFILE_TIMER_SIGNAL=34 # override SIGALRM used in REALTIME mode
export CPUPROFILE_PER_THREAD_TIMERS=1 # 使用 POSIX timer_create 来支持多线程 profiling: https://github.com/gperftools/gperftools/issues/690
./a.out &
export LD_PRELOAD=

// https://github.com/gperftools/gperftools/blob/119136d3c3c985fa45f5c8d95b1cf496659615dc/src/profile-handler.h#L45

/*
* This module manages the cpu profile timers and the associated interrupt
* handler. When enabled, all threads in the program are profiled.
*
* Any component interested in receiving a profile timer interrupt can do so by
* registering a callback. All registered callbacks must be async-signal-safe.
*
* Note: This module requires the sole ownership of the configured timer and
* signal. The timer defaults to ITIMER_PROF, can be changed to ITIMER_REAL by
* the environment variable CPUPROFILE_REALTIME, or is changed to a POSIX timer
* with CPUPROFILE_PER_THREAD_TIMERS. The signal defaults to SIGPROF/SIGALRM to
* match the choice of timer and can be set to an arbitrary value using
* CPUPROFILE_TIMER_SIGNAL with CPUPROFILE_PER_THREAD_TIMERS.
*/

# 运行程序，动态注入 libtcmalloc，通过 HEAPPROFILE 环境变量来开启 heap profiling
#LD_PRELOAD=/usr/lib64/libtcmalloc.so.4 HEAPPROFILE=/tmp/mybin.hprof find /

#ls -l /tmp/mybin.hprof.000*
-rw-r--r-- 1 root root 15278 Oct 10 19:56 /tmp/mybin.hprof.0001.heap
-rw-r--r-- 1 root root 15279 Oct 10 19:56 /tmp/mybin.hprof.0002.heap
-rw-r--r-- 1 root root 15280 Oct 10 19:56 /tmp/mybin.hprof.0003.heap

# 生成 PDF
#pprof --pdf /usr/bin/find /tmp/mybin.hprof.0003.heap  /tmp/mybin.hprof.0002.heap /tmp/mybin.hprof.0001.heap > find.heap.pdf

# 查看 PDF
# open find.heap.pdf

// First, get a guard to start profiling. Profiling will continue until this guard was dropped.
let guard = pprof::ProfilerGuardBuilder::default().frequency(1000).blocklist(&["libc", "libgcc", "pthread", "vdso"]).build().unwrap();

// During the profiling time, you can get a report with the guard.
if let Ok(report) = guard.report().build() {
    println!("report: {:?}", &report);
};

match guard.report().build() {
    Ok(report) => {
        let mut file = File::create("profile.pb").unwrap();
        let profile = report.pprof().unwrap();

        let mut content = Vec::new();
        profile.encode(&mut content).unwrap();
        file.write_all(&content).unwrap();

        println!("report: {}", &report);
    }
    Err(_) => {}
};

~/go/bin/pprof -svg profile.pb

// https://github.com/polarsignals/rust-jemalloc-pprof?tab=readme-ov-file
#[tokio::main]
async fn main() {
    let mut v = vec![];
    for i in 0..1000000 {
        v.push(i);
    }

    let app = axum::Router::new()
        .route("/debug/pprof/allocs", axum::routing::get(handle_get_heap));

    // run our app with hyper, listening globally on port 3000
    let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

use axum::http::StatusCode;
use axum::response::IntoResponse;

pub async fn handle_get_heap() -> Result<impl IntoResponse, (StatusCode, String)> {
    let mut prof_ctl = jemalloc_pprof::PROF_CTL.as_ref().unwrap().lock().await;
    require_profiling_activated(&prof_ctl)?;
    let pprof = prof_ctl
        .dump_pprof()
        .map_err(|err| (StatusCode::INTERNAL_SERVER_ERROR, err.to_string()))?;
    Ok(pprof)
}

/// Checks whether jemalloc profiling is activated an returns an error response if not.
fn require_profiling_activated(prof_ctl: &jemalloc_pprof::JemallocProfCtl) -> Result<(), (StatusCode, String)> {
    if prof_ctl.activated() {
        Ok(())
    } else {
        Err((axum::http::StatusCode::FORBIDDEN, "heap profiling not activated".into()))
    }
}

curl localhost:3000/debug/pprof/allocs > heap.pb.gz
pprof -http=:8080 heap.pb.gz

go tool pprof --http=: http://localhost:6060/debug/pprof/profile # CPU profiling
go tool pprof --http=: http://localhost:6060/debug/pprof/allocs # memory profiling

// https://github.com/rust-lang/rust-analyzer/blob/master/crates/profile/src/lib.rs

/// A wrapper around google_cpu_profiler.
///
/// Usage:
/// 1. Install gperf_tools (<https://github.com/gperftools/gperftools>), probably packaged with your Linux distro.
/// 2. Build with `cpu_profiler` feature.
/// 3. Run the code, the *raw* output would be in the `./out.profile` file.
/// 4. Install pprof for visualization (<https://github.com/google/pprof>).
/// 5. Bump sampling frequency to once per ms: `export CPUPROFILE_FREQUENCY=1000`
/// 6. Use something like `pprof -svg target/release/rust-analyzer ./out.profile` to see the results.
///
/// For example, here's how I run profiling on NixOS:
///
///
/// $ bat -p shell.nix
/// with import <nixpkgs> {};
/// mkShell {
///   buildInputs = [ gperftools ];
///   shellHook = ''
///     export LD_LIBRARY_PATH="${gperftools}/lib:"
///   '';
/// }
/// $ set -x CPUPROFILE_FREQUENCY 1000
/// $ nix-shell --run 'cargo test --release --package rust-analyzer --lib -- benchmarks::benchmark_integrated_highlighting --exact --nocapture'
/// $ pprof -svg target/release/deps/rust_analyzer-8739592dc93d63cb crates/rust-analyzer/out.profile > profile.svg
///
///
/// See this diff for how to profile completions:
///
/// <https://github.com/rust-lang/rust-analyzer/pull/5306>

# 安装
cargo install cargo-criterion

# Then you can use it to run your Criterion-rs benchmarks:
cargo criterion

# Generated reports will appear in target/criterion/reports.

use criterion::{black_box, criterion_group, criterion_main, Criterion};
use mycrate::fibonacci;

pub fn criterion_benchmark(c: &mut Criterion) {
    c.bench_function("fib 20", |b| b.iter(|| fibonacci(black_box(20))));
}

criterion_group!(benches, criterion_benchmark);
criterion_main!(benches);

Running target/release/deps/example-423eedc43b2b3a93
Benchmarking fib 20
Benchmarking fib 20: Warming up for 3.0000 s
Benchmarking fib 20: Collecting 100 samples in estimated 5.0658 s (188100 iterations)
Benchmarking fib 20: Analyzing
fib 20                  time:   [26.029 us 26.251 us 26.505 us]
Found 11 outliers among 99 measurements (11.11%)
6 (6.06%) high mild
5 (5.05%) high severe
slope  [26.029 us 26.505 us] R^2            [0.8745662 0.8728027]
mean   [26.106 us 26.561 us] std. dev.      [808.98 ns 1.4722 us]
median [25.733 us 25.988 us] med. abs. dev. [234.09 ns 544.07 ns]

change: [-38.292% -37.342% -36.524%] (p = 0.00 < 0.05)
Performance has improved.

built-in            abbrev
--------------------------
Activity Monitor
Allocations         (alloc)
Animation Hitches
App Launch
Core Data
Counters
Energy Log
File Activity       (io)
Game Performance
Leaks
Logging
Metal System Trace
Network
SceneKit
SwiftUI
System Trace        (sys)
Time Profiler       (time)
Zombies