SanzSkuy: Created page with "'''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 '''..."

2026-06-25T02:48:13Z

Created page with "'''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 (109). 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 '''..."

New page

'''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 (109). 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:

{| class="wikitable"
! 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:

<math>\text{FLOPS} = \frac{\text{Jumlah operasi floating-point}}{\text{Waktu eksekusi (detik)}}</math>

Untuk satuan GFLOPS:

<math>\text{GFLOPS} = \frac{\text{FLOPs}}{T \cdot 10^9}</math>

dengan <math>T</math> adalah waktu eksekusi dalam detik.

=== Theoretical peak ===

''Theoretical peak'' GFLOPS suatu prosesor dihitung dari spesifikasi hardware:

<math>\text{Peak GFLOPS} = N_\text{cores} \times f_\text{clock} \times \text{FLOPs}_\text{per cycle}</math>

dengan:
* <math>N_\text{cores}</math> = jumlah ''core'' atau ''compute unit''
* <math>f_\text{clock}</math> = frekuensi ''clock'' (Hz)
* <math>\text{FLOPs}_\text{per cycle}</math> = 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 <math>C = A \times B</math> dengan dimensi <math>A \in \mathbb{R}^{M \times K}</math> dan <math>B \in \mathbb{R}^{K \times N}</math>, jumlah operasi adalah:

<math>\text{FLOPs} = 2 \cdot M \cdot N \cdot K</math>

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

Contoh: untuk matriks ''square'' berukuran <math>N \times N</math>:

<math>\text{FLOPs} = 2 N^3</math>

=== Inner product (dot product) ===

Untuk dua vektor berukuran <math>N</math>:

<math>\text{FLOPs} = 2N - 1 \approx 2N</math>

=== Konvolusi 2D ===

Untuk ''input feature map'' <math>H \times W \times C_\text{in}</math> dan ''kernel'' <math>K \times K \times C_\text{in} \times C_\text{out}</math>:

<math>\text{FLOPs} \approx 2 \cdot H \cdot W \cdot K^2 \cdot C_\text{in} \cdot C_\text{out}</math>

== Contoh perhitungan ==

=== Contoh 1: Matrix multiplication 2048×2048 ===

Misalkan suatu ''kernel'' OpenCL menyelesaikan perkalian matriks <math>2048 \times 2048</math> dalam waktu <math>T = 80</math> ms.

Jumlah operasi:

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

''Throughput'':

<math>\text{GFLOPS} = \frac{1.72 \times 10^{10}}{0.080 \cdot 10^9} \approx 215 \text{ GFLOPS}</math>

=== 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)

<math>\text{Peak} = 2048 \times 1.5 \times 10^9 \times 2 = 6.144 \times 10^{12} \text{ FLOPS} = 6.144 \text{ TFLOPS}</math>

== Snippet pengukuran ==

Pengukuran GFLOPS empiris dalam C:

<syntaxhighlight lang="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;
}
</syntaxhighlight>

== Achieved vs theoretical peak ==

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

<math>\eta = \frac{\text{Achieved GFLOPS}}{\text{Peak GFLOPS}} \times 100\%</math>

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:

{| class="wikitable"
! 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, [https://www.top500.org/ top500.org] peringkat ''supercomputer'' berdasarkan ''benchmark'' LINPACK (Rmax dalam TFLOPS/PFLOPS).

GFLOPS - Revision history