GFLOPS

GFLOPS (Giga Floating-point Operations Per Second) adalah satuan ukuran throughput komputasi yang menyatakan jumlah operasi floating-point yang dapat dilakukan oleh suatu sistem dalam satu detik, dalam skala miliar (10⁹). Satuan ini umum digunakan untuk mengukur performa CPU, GPU, dan accelerator lainnya, terutama dalam konteks high-performance computing (HPC), scientific computing, dan deep learning.

Definisi

Satu FLOP (Floating-point Operation) adalah satu operasi aritmatika pada bilangan floating-point, seperti penjumlahan, pengurangan, perkalian, atau pembagian. FLOPS (FLOPs per Second) adalah laju operasi tersebut per satuan waktu.

Skala satuan:

Satuan	Singkatan	Nilai
KiloFLOPS	kFLOPS	103 FLOPS
MegaFLOPS	MFLOPS	106 FLOPS
GigaFLOPS	GFLOPS	109 FLOPS
TeraFLOPS	TFLOPS	1012 FLOPS
PetaFLOPS	PFLOPS	1015 FLOPS
ExaFLOPS	EFLOPS	1018 FLOPS

Perlu dibedakan:

• FLOPs (huruf s kecil) = jumlah operasi (count).
• FLOPS (huruf S besar) = laju per detik (rate).

Rumus dasar

Secara umum:

$\text{FLOPS}=\frac{\text{Jumlah operasi floating-point}}{\text{Waktu eksekusi (detik)}}$

Untuk satuan GFLOPS:

$\text{GFLOPS}=\frac{\text{FLOPs}}{T\cdot 10^9}$

dengan $T$ adalah waktu eksekusi dalam detik.

Theoretical peak

Theoretical peak GFLOPS suatu prosesor dihitung dari spesifikasi hardware:

$\text{Peak GFLOPS}=N_{\text{cores}}\times f_{\text{clock}}\times {\text{FLOPs}}_{\text{per cycle}}$

dengan:

• $N_{\text{cores}}$ = jumlah core atau compute unit
• $f_{\text{clock}}$ = frekuensi clock (Hz)
• ${\text{FLOPs}}_{\text{per cycle}}$ = jumlah operasi floating-point yang dapat dilakukan per clock cycle per core (tergantung lebar SIMD, FMA support, dll)

Menghitung FLOPs untuk algoritma umum

Matrix multiplication

Untuk perkalian matriks $C=A\times B$ dengan dimensi $A\in {\mathbb{ℝ}}^{M\times K}$ dan $B\in {\mathbb{ℝ}}^{K\times N}$, jumlah operasi adalah:

$\text{FLOPs}=2\cdot M\cdot N\cdot K$

Faktor 2 berasal dari satu perkalian dan satu penjumlahan per elemen inner product.

Contoh: untuk matriks square berukuran $N\times N$:

$\text{FLOPs}=2N^3$

Inner product (dot product)

Untuk dua vektor berukuran $N$:

$\text{FLOPs}=2N-1\approx 2N$

Konvolusi 2D

Untuk input feature map $H\times W\times C_{\text{in}}$ dan kernel $K\times K\times C_{\text{in}}\times C_{\text{out}}$:

$\text{FLOPs}\approx 2\cdot H\cdot W\cdot K^2\cdot C_{\text{in}}\cdot C_{\text{out}}$

Contoh perhitungan

Contoh 1: Matrix multiplication 2048×2048

Misalkan suatu kernel OpenCL menyelesaikan perkalian matriks $2048\times 2048$ dalam waktu $T=80$ ms.

Jumlah operasi:

$\text{FLOPs}=2\cdot 2048^3=2\cdot 8,589,934,592\approx 1.72\times 10^{10}$

Throughput:

$\text{GFLOPS}=\frac{1.72\times 10^{10}}{0.080\cdot 10^9}\approx 215\text{ GFLOPS}$

Contoh 2: Theoretical peak GPU

Sebuah GPU memiliki spesifikasi:

• 2048 CUDA cores
• Clock 1.5 GHz
• 2 FLOPs/cycle (satu fused multiply-add = 2 FLOPs)

$\text{Peak}=2048\times 1.5\times 10^9\times 2=6.144\times 10^{12}\text{ FLOPS}=6.144\text{ TFLOPS}$

Snippet pengukuran

Pengukuran GFLOPS empiris dalam C:

#include <stdio.h>
#include <time.h>

double measure_gflops(long flops, double elapsed_seconds) {
    return (double) flops / (elapsed_seconds * 1e9);
}

int main(void) {
    const int N = 2048;
    long flops = 2L * N * N * N;  // 2 * N^3 untuk matmul

    struct timespec t0, t1;
    clock_gettime(CLOCK_MONOTONIC, &t0);

    // ... jalankan kernel matmul di sini ...

    clock_gettime(CLOCK_MONOTONIC, &t1);
    double elapsed = (t1.tv_sec - t0.tv_sec)
                   + (t1.tv_nsec - t0.tv_nsec) / 1e9;

    double gflops = measure_gflops(flops, elapsed);
    printf("Throughput: %.2f GFLOPS\n", gflops);
    return 0;
}

Achieved vs theoretical peak

Dalam praktiknya, performa terukur (achieved GFLOPS) hampir selalu lebih rendah dari theoretical peak. Rasio antara keduanya disebut efisiensi komputasi:

$\eta =\frac{\text{Achieved GFLOPS}}{\text{Peak GFLOPS}}\times 100\mathrm{\%}$

Penyebab utama efisiensi tidak mencapai 100%:

• Memory-bound workload; bandwidth memori jadi bottleneck, bukan kemampuan komputasi.
• Cache miss dan non-coalesced memory access.
• Branch divergence pada GPU.
• Pipeline stall dan dependency hazard.
• Underutilization: ukuran data terlalu kecil untuk mengisi seluruh compute unit.
• Communication overhead pada sistem terdistribusi.

Untuk menganalisis apakah suatu kernel compute-bound atau memory-bound, umum digunakan Roofline Model.

Presisi numerik

Nilai GFLOPS sangat bergantung pada presisi floating-point yang digunakan:

Presisi	Lebar bit	Konteks penggunaan
FP64 (double)	64	Scientific computing, simulasi numerik
FP32 (single)	32	Grafika, deep learning tradisional
FP16 (half)	16	Deep learning modern, mixed precision
BF16 (bfloat16)	16	Training neural network
FP8 / INT8	8	Inference neural network ter-quantize

GPU modern umumnya memiliki peak FP16 yang 2× lebih tinggi dari FP32, dan FP8 hingga 4× lebih tinggi. Saat melaporkan angka GFLOPS, presisi wajib disebutkan agar perbandingan adil.

Keterbatasan sebagai metrik

GFLOPS bukan ukuran performa yang sempurna. Beberapa keterbatasan:

• Tidak mencerminkan kecepatan eksekusi nyata: algoritma dengan FLOPs lebih sedikit bisa lebih cepat dari yang FLOPs-nya banyak.
• Tidak memperhitungkan memory bandwidth: banyak workload nyata memory-bound.
• Mudah di-game: vendor sering melaporkan peak yang tidak realistis di workload praktis.
• Tidak relevan untuk integer-heavy workload seperti cryptography atau database.

Metrik alternatif yang sering digunakan bersama GFLOPS:

• Wall-clock time: waktu eksekusi murni.
• Memory bandwidth (GB/s).
• Operational intensity (FLOPs/byte): dipakai dalam Roofline Model.
• Energy efficiency (GFLOPS/Watt).

Referensi

• John L. Hennessy, David A. Patterson, Computer Architecture: A Quantitative Approach, 6th ed., Morgan Kaufmann, 2017.
• Samuel Williams et al., "Roofline: An Insightful Visual Performance Model for Multicore Architectures", Communications of the ACM, 2009.
• TOP500 Project, top500.org peringkat supercomputer berdasarkan benchmark LINPACK (Rmax dalam TFLOPS/PFLOPS).