Belajar LLVM - MLIR: Multi-Level Intermediate Representation

#Pendahuluan

Setelah di episode 21 kita membahas sanitizers dan fuzzing, pada episode ini kita membahas tren paling menarik dalam ekosistem LLVM: MLIR (Multi-Level Intermediate Representation).

MLIR adalah kerangka kerja untuk membangun compiler yang bekerja pada multiple level of abstraction — dari algebra tingkat tinggi hingga machine code rendah. MLIR menjadi semakin penting karena era AI/ML membutuhkan compiler yang bisa bekerja dengan heterogeneous computing (CPU + GPU + TPU + custom accelerators).

#Motivasi: Limitasi Single-Level IR

LLVM IR dirancang untuk representasi satu level — cukup dekat dengan hardware untuk optimasi kode general-purpose. Tetapi untuk domain-specific computation (ML, DSP, cryptograph), satu level IR tidak cukup:

Masalah	Penjelasan
Tidak ada representasi tensor	ML workload bekerja pada tensor, bukan scalar
Tidak ada tiling concept	Tiling adalah optimasi kritis untuk GPU/TPU
Tidak ada dialect untuk domain	ML, signal processing, cryptography butuh operasi khusus

MLIR menyelesaikan ini dengan konsep dialects — kumpulan operasi dan tipe yang bisa hidup berdampingan dalam satu module, dengan progressive lowering dari dialect tinggi ke rendah.

#Konsep MLIR

#Dialect

Dialect adalah namespace untuk operasi dan tipe yang berhubungan:

Dialect toy

toy.func @multiply_transpose(%arg0: tensor<2x3xf64>,
                              %arg1: tensor<3x2xf64>) -> tensor<2x2xf64> {
  %t = toy.transpose(%arg0) {mapping = [1, 0]} : tensor<2x3xf64> -> tensor<3x2xf64>
  %0 = toy.mul(%t, %arg1) : tensor<3x2xf64>
  %1 = toy.cast(%0) : tensor<3x2xf64> to tensor<2x2xf64>
  toy.return %1 : tensor<2x2xf64>
}

Beberapa dialects populer:

Dialect	Domain
`arith`	Arithmetic operations
`linalg`	Linear algebra (tensor operations)
`tosa`	Tensor Operator Set Architecture (ML)
`scf`	Structured Control Flow (for, if)
`gpu`	GPU operations (launch, memcopy)
`llvm`	LLVM dialect (lowering ke LLVM IR)

#Operations

Setiap operasi dalam MLIR adalah first-class citizen — bisa di-query, ditransformasi, dan dimatch secara fleksibel.

#Regions

MLIR menggunakan regions (bukan basic blocks biasa) untuk merepresentasikan hierarki kontrol dan data — mendukung nested computation yang natural untuk domain ML.

#Progressive Lowering

MLIR mendukung progressive lowering — menurunkan representasi dari dialect tinggi ke rendah secara bertahap:

100%

Setiap tahapan lowering memungkinkan optimasi yang spesifik untuk level abstraksi tersebut.

#Praktik: Dialect Toy → LLVM IR

Compile dialect toy ke LLVM IR

# Lowering berjenjang
mlir-opt toy.mlir \
    -convert-toy-to-linalg \
    -linalg-bufferize \
    -convert-linalg-to-affine-loops \
    -lower-affine \
    -convert-scf-to-cf \
    -convert-cf-to-llvm \
    -convert-memref-to-llvm \
    -convert-arith-to-llvm \
    -convert-func-to-llvm \
    -reconcile-unrealized-casts \
    -o toy.ll

Jalankan hasilnya:

Jalankan MLIR yang sudah di-lower

mlir-cpu-runner toy.ll -e main -entry-point-result=void

Note

MLIR bukan pengganti LLVM IR — ia melengkapinya. MLIR menangani level abstraksi tinggi (tensor, tiling, domain-specific), sementara LLVM IR tetap menjadi target codegen akhir untuk CPU/GPU. Keduanya saling melengkapi dalam pipeline compiler modern.

#Ekosistem MLIR

Proyek	Keterangan
IREE	Runtime dan compiler MLIR untuk deployment model ML
Torch-MLIR	Mengonversi PyTorch model ke MLIR
TensorFlow	Menggunakan MLIR untuk graph optimization
Mojo	Bahasa baru yang dibangun di atas MLIR dari awal

MLIR menjadi standar de facto untuk compiler AI/ML di 2025-2026.

#Penutup

Inti yang harus dibawa pulang:

MLIR menangani limitasi single-level IR untuk ML/heterogeneous computing.
Dialects: kumpulan operasi dan tipe yang bisa hidup berdampingan dalam satu module.
Progressive lowering: menurunkan dari dialect tinggi ke LLVM IR secara bertahap.
Ekosistem: IREE, Torch-MLIR, TensorFlow, Mojo — semua dibangun di atas MLIR.

Di episode 23 selanjutnya kita akan membahas GPU & heterogeneous computing — targets NVPTX (NVIDIA), AMDGPU (ROCm), SPIR-V, SYCL, dan praktik mengkompilasi kernel sederhana ke PTX dan SPIR-V. Sampai jumpa di episode 23!