Belajar LLVM - Performance Engineering & Production Practices

#Pendahuluan

Setelah di episode 24 kita memahami cross-compilation dan embedded toolchain, pada episode ini kita membahas bagaimana mengoptimalkan performa aplikasi di production menggunakan teknik LLVM yang sophisticated: PGO (Profile-Guided Optimization) dan LTO.

PGO adalah teknik optimasi yang menggunakan data runtime profiling untuk memberitahu optimizer tentang hot path, branch prediction, dan function inlining decisions. PGO + LTO bersamaan bisa menghasilkan performa 10-30% lebih cepat dibanding -O2 biasa.

#Profile-Guided Optimization (PGO)

#Alur Kerja PGO

#1. Instrumented Build

clang -O2 -fprofile-instr-generate -fcoverage-mapping -o app_instrumented app.c

#2. Jalankan dengan Workload Representatif

./app_instrumented < production_input.txt
# atau jalankan test suite yang mewakili penggunaan nyata
./run_benchmark.sh

#3. Merge Profile

llvm-profdata merge -output=merged.profdata *.profraw

#4. Build dengan PGO

clang -O2 -fprofile-instr-use=merged.profdata -o app_pgo app.c

#Sample-Based PGO (AutoFDO)

AutoFDO menggunakan sampling dari perf daripada instrumen — overhead yang jauh lebih rendah untuk production:

# 1. Jalankan aplikasi dengan perf
perf record -b -o perf.data ./app_production
 
# 2. Konversi perf data ke LLVM profile
create_llvm_prof --binary=app_production --out=profile.afdo perf.data
 
# 3. Build dengan profile
clang -O2 -fprofile-sample-use=profile.afdo -o app_optimized app.c

#Context-Sensitive Splitting

PGO bisa mengoptimalkan inline decisions berdasarkan hot path: fungsi yang sering dipanggil dari hot call site akan di-inline, sementara fungsi yang hanya dipanggil dari cold path tidak di-inline — menghasilkan binary yang lebih kecil tanpa mengorbankan performa hot path.

#Benchmark vs GCC (Metodologi Phoronix)

Phoronix adalah standar industri untuk benchmark compiler. Metodologi:

# Build dengan GCC
gcc -O2 -o app_gcc app.c
# Build dengan Clang
clang -O2 -o app_clang app.c
# Build dengan PGO
clang -O2 -fprofile-instr-use=merged.profdata -o app_pgo app.c
 
# Benchmark
time ./app_gcc < input.txt
time ./app_clang < input.txt
time ./app_pgo < input.txt

Gunakan Phoronix Test Suite untuk benchmark otomatis dengan statistik yang benar:

phoronix-test-suite benchmark system/compiler

#Compile-Time Tracker

Compile time yang buruk menghambat produktivitas. Track compile time untuk mendeteksi regression:

# Time build penuh
time cmake --build build -j$(nproc)
 
# Time setiap target
cmake --build build -j1 -- --stats

Gunakan --stats pada Ninja untuk melihat waktu build per-target.

#Praktik: PGO + LTO pada Aplikasi Nyata

# 1. Build instrumen dengan LTO
clang -flto -fprofile-instr-generate -o app_inst app.c
 
# 2. Jalankan workload
./app_inst < workload.txt
 
# 3. Merge profile
llvm-profdata merge -output=merged.profdata *.profraw
 
# 4. Build final dengan PGO + ThinLTO
clang -O2 -flto=thin -fprofile-instr-use=merged.profdata \
    -fuse-ld=lld -o app_final app.c
 
# 5. Ukur improvement
time ./app_original  # Baseline
time ./app_final     # Dengan PGO + LTO

Gain tipikal: PGO saja memberikan 10-15% improvement; PGO + LTO memberikan 15-25% improvement; PGO + Full LTO bisa mencapai 25-30% untuk aplikasi branch-heavy.

#Penutup

Inti yang harus dibawa pulang:

• PGO: instrumented build → runtime profiling → merge profile → optimized build.
• AutoFDO: sample-based dari perf — overhead rendah untuk production.
• PGO + LTO bersamaan memberikan gain 15-30% — sering lebih efektif dari -O3 saja.
• Gunakan Phoronix Test Suite untuk benchmark compiler yang valid secara statistik.

Di episode 26 selanjutnya kita akan membahas ekosistem & tren modern 2026 — release cadence LLVM 22/23, highlight fitur LLVM 22, tren AI/ML compilers, Rust/Zig/Mojo, dan komunitas LLVM. Sampai jumpa di episode 26!