Anatomi Masalah: Selisih Sen pada Agregasi Throughput Tinggi

Ketidaksesuaian nilai pada agregasi saldo atau metrik penagihan (billing) sering kali tidak bersumber dari logika bisnis, melainkan dari cara unit aritmetika komputer merepresentasikan angka riil. Dalam sistem pemrosesan transaksi berkecepatan tinggi, akumulasi jutaan operasi penjumlahan floating-point tipe data float64 standar secara bertahap menghasilkan penyimpangan nilai (adder drift) yang berujung pada selisih pembukuan.

Root Cause: Keterbatasan Representasi IEEE 754 dan Register Hardware

Standar IEEE 754 merepresentasikan floating-point menggunakan tiga komponen: tanda (sign), eksponen, dan fraksi (mantissa). Angka desimal seperti 0.1 atau 0.01 tidak dapat direpresentasikan secara presisi dalam basis 2 (biner), menghasilkan fraksi berulang yang harus dipotong (truncated) sesuai batas bit mantissa.

Masalah ini berakar dari karakteristik unit pemrosesan numerik sejak era co-processor Intel 8087. Chip 8087 memperkenalkan register internal 80-bit extended precision untuk memitigasi galat pembulatan sementara (intermediate rounding error). Namun, ketika nilai dari register internal tersebut disalin kembali ke memori atau register register 64-bit reguler (sebagaimana dilakukan compiler modern via instruksi SSE/AVX), pemotongan bit presisi tetap terjadi.

Ketika melakukan agregasi jutaan record: total += amount, setiap operasi penambahan menggeser mantissa angka yang lebih kecil agar sesuai dengan eksponen angka yang lebih besar. Pergeseran bit ke kanan ini menghilangkan bit-bit presisi rendah (swallowing/catastrophic cancellation). Hasil akhir agregasi menjadi tidak deterministik dan melenceng dari nilai nominal sebenarnya.

Studi Kasus: Bug Agregasi Billing

Kode backend berikut memproses batch kalkulasi biaya komisi transaksi dengan mengandalkan tipe bawaan float64.

Implementasi Cacat (Sebelum Perbaikan)

package main

import (
	"fmt"
)

// AggregateCommission menghitung total fee dari daftar transaksi.
// BUG: Terjadi drift presisi akibat akumulasi floating-point IEEE 754.
func AggregateCommission(fees []float64) float64 {
	var total float64
	for _, fee := range fees {
		total += fee
	}
	return total
}

func main() {
	// 100.000 transaksi masing-masing bernilai fee $0.07
	txCount := 100000
	feePerTx := 0.07

	var fees []float64
	for i := 0; i < txCount; i++ {
		fees = append(fees, feePerTx)
	}

	result := AggregateCommission(fees)
	expected := 7000.0 // 100.000 * 0.07

	// Output: Expected: 7000.000000, Got: 7000.000000001886
	fmt.Printf("Expected: %.6f, Got: %.12f\n", expected, result)
}

Solusi Perbaikan: Migrasi ke Fixed-Point Integer Arithmetic

Aturan utama arsitektur sistem finansial: jangan gunakan floating-point untuk representasi mata uang. Solusi paling efisien dan deterministik adalah mengonversi seluruh nilai finansial ke basis integer terkecil (misalnya sen, basis poin, atau satuan mikro-sen) menggunakan representasi fixed-point.

Implementasi Aman Menggunakan Minor Units (Setelah Perbaikan)

package main

import (
	"fmt"
)

// AggregateCommissionFixed menghitung total fee menggunakan minor unit (cents/satuan terkecil).
// Mengeliminasi galat floating-point adder drift secara deterministik.
func AggregateCommissionFixed(feesInCents []int64) int64 {
	var total int64
	for _, fee := range feesInCents {
		total += fee
	}
	return total
}

func main() {
	txCount := 100000
	// $0.07 direpresentasikan sebagai 7 sen (int64)
	feePerTxCents := int64(7)

	var fees []int64
	for i := 0; i < txCount; i++ {
		fees = append(fees, feePerTxCents)
	}

	resultCents := AggregateCommissionFixed(fees)
	expectedCents := int64(700000) // $7,000.00 dalam sen

	if resultCents != expectedCents {
		panic(fmt.Sprintf("Invariant violated: got %d, want %d", resultCents, expectedCents))
	}

	// Format ke mata uang untuk representasi layer presentasi
	dollars := resultCents / 100
	centsRemainder := resultCents % 100
	fmt.Printf("Balance valid: $%d.%02d\n", dollars, centsRemainder)
}

Catatan: Alternatif lain adalah pustaka shopspring/decimal atau modul native math/big, namun manipulasi integer berbasis minor-unit memberikan throughput agregasi tercepat tanpa alokasi memori tambahan di heap.

Unit Testing: Invariant Checking

Pengujian kalkulasi finansial wajib menggunakan pola invariant check, di mana total distribusi kredit harus selalu identik dengan total debit pada tingkat bit integer.

package main

import "testing"

func TestCommissionInvariant(t *testing.T) {
	const count = 100000
	const fee = int64(7) // 7 sen
	data := make([]int64, count)
	for i := range data {
		data[i] = fee
	}

	got := AggregateCommissionFixed(data)
	want := int64(count) * fee

	if got != want {
		t.Fatalf("Invariant drift detected: got %d, expected exact %d", got, want)
	}
}

Trade-offs dan Pertimbangan Sistem

  • Integer Overflow: Batas nilai int64 adalah sekitar 9.22 × 1018. Menggunakan basis mikro-sen (1/1.000.000 unit) membatasi nilai maksimum hingga sekitar 9 triliun unit mata uang. Gunakan math/big.Int jika agregasi agregat melebihi batas tersebut.
  • Serialisasi API: Selalu konversi representasi fixed-point menjadi string (misal: "7000.00") saat mengirim payload JSON ke client untuk mencegah deserialisasi otomatis ke floating-point oleh engine browser atau parser bahasa pemrograman lain.