DEBI PRAHARADIKA
← Back to Blog Index
System Design2026-05-278 min read

Latency vs Throughput vs Bandwidth: Pilar Utama Kinerja Sistem Jaringan

Panduan teknis memahami metrik performa jaringan, perhitungan BDP, dan strategi optimasi socket pada sistem terdistribusi.

Dalam rekayasa perangkat lunak terdistribusi (distributed systems), microservices, aplikasi real-time, hingga platform web berskala besar, pemahaman tentang bagaimana data mengalir di dalam jaringan internet adalah hal wajib. Seringkali, developer mengeluhkan: "Server kami lambat meskipun kami sudah menyewa bandwidth internet sebesar 1 Gbps!"

Masalah ini terjadi karena adanya kesalahpahaman mendasar tentang hubungan antara Latency (Latensi), Throughput (Troughput), dan Bandwidth. Ketiganya adalah metrik yang saling membatasi, namun mengukur dimensi fisik jaringan yang sepenuhnya berbeda.

Di dalam artikel rekayasa mendalam ini, kita akan mengupas tuntas trias metrik kinerja jaringan, membedah hubungan matematisnya melalui Bandwidth-Delay Product (BDP), melihat visualisasi analoginya, serta mempelajari kode benchmarking praktis untuk mengukurnya.

Analogi Visual Trias Jaringan (Highway & Pipe Analogy)

Untuk mempermudah pemahaman insinyur, mari kita visualisasikan aliran data menggunakan analogi Jalan Tol dan Pipa Aliran Air berikut:

Analogi Latency Throughput Bandwidth

1. Bandwidth (Kapasitas Maksimal Teoretis)

Bandwidth adalah kapasitas maksimum dari media komunikasi untuk mentransfer data dalam hitungan waktu tertentu (biasanya diukur dalam bit per detik seperti Gbps atau Mbps).

  • Analogi Jalan Tol: Jumlah lajur jalan tol yang tersedia (misal jalan tol 5 lajur memiliki kapasitas kendaraan masuk yang jauh lebih besar dibanding jalan tol 1 lajur).
  • Analogi Pipa: Ketebalan atau diameter pipa air. Semakin besar diameter pipa, semakin banyak air yang dapat ditampung di dalamnya pada saat yang sama.

2. Latency (Waktu Tempuh / Delay)

Latency adalah waktu yang dibutuhkan oleh satu paket data tunggal untuk merambat dari titik asal (Client) ke tujuan (Server), ditambah waktu untuk kembali lagi. Ini sering disebut sebagai Round-Trip Time (RTT) dan diukur dalam milidetik (ms).

  • Analogi Jalan Tol: Waktu yang dibutuhkan oleh satu buah mobil untuk menempuh perjalanan dari gerbang tol A ke gerbang tol B (meskipun jalan tol memiliki 10 lajur, kecepatan mobil tetap dibatasi oleh batas kecepatan fisik jalan tol).
  • Analogi Pipa: Waktu perjalanan tetesan air pertama dari keran di ujung A sampai keluar di ujung B.

3. Throughput (Kinerja Aktual yang Tercapai)

Throughput adalah jumlah data aktual yang berhasil ditransfer melalui jaringan dan diproses dengan sukses oleh sistem penerima dalam satu unit waktu tertentu.

  • Analogi Jalan Tol: Jumlah mobil aktual yang berhasil keluar dari pintu gerbang tol per menit. Jika terjadi penyempitan lajur (bottleneck) atau kecelakaan, throughput mobil akan anjlok meskipun kapasitas lajur jalan tol (bandwidth) sangat besar.
  • Analogi Pipa: Volume air nyata yang berhasil mengalir keluar dari pipa per detik. Jika terdapat sumbatan atau hambatan gesekan di dalam pipa, volume air keluar (throughput) akan lebih kecil dari diameter pipa teoritis (bandwidth).

Mengapa Bandwidth Besar Tidak Menjamin Kecepatan Tinggi? (Bottleneck Latency)

Banyak developer mengira bahwa meningkatkan bandwidth dari 100 Mbps ke 1 Gbps akan otomatis membuat API mereka 10 kali lebih cepat. Ini adalah mitos. Kecepatan transfer data dibatasi secara ketat oleh hukum fisika kecepatan cahaya di serat optik (latensi) dan protokol transportasi kontrol seperti TCP.

Hubungan ini didefinisikan secara matematis melalui Bandwidth-Delay Product (BDP):

$$\text{BDP (Bits)} = \text{Bandwidth (bits/sec)} \times \text{Latency RTT (seconds)}$$

BDP merepresentasikan volume data maksimum yang dapat berada di dalam kabel jaringan ("in-flight") pada satu waktu tertentu sebelum penerima mengirimkan sinyal konfirmasi (Acknowledgment / ACK).

Pada protokol TCP, pengirim dibatasi oleh ukuran jendela penerima (TCP Window Size). Throughput maksimum teoretis untuk koneksi TCP tunggal dibatasi oleh rumus berikut:

$$\text{Throughput Maksimum} \le \frac{\text{TCP Window Size}}{\text{RTT (Latency)}}$$

Contoh Kasus Nyata:

Misalkan Anda mengirimkan data dari Jakarta ke San Francisco dengan spesifikasi:

  • Bandwidth: 1 Gbps (1.000.000.000 bps)
  • Latency (RTT): 200 ms (0,2 detik) karena jarak geografis yang jauh.
  • TCP Window Size Default: 64 KB (524.288 bit)

Mari kita hitung throughput maksimum teoretis TCP Anda:

$$\text{Throughput Maksimum} = \frac{524.288\text{ bit}}{0,2\text{ detik}} = 2.621.440\text{ bps} \approx 2,62\text{ Mbps}$$

Kesimpulan Tragis: Meskipun Anda membayar langganan bandwidth internet sebesar 1 Gbps, koneksi transfer data tunggal Anda hanya mampu mencapai throughput maksimal 2,62 Mbps akibat batasan latensi 200ms! Satu-satunya cara menaikkan throughput ini adalah dengan melakukan TCP Window Tuning di sisi sistem operasi atau menggunakan koneksi paralel.

Kode Benchmark Pengujian Latency vs Throughput (Node.js)

Sebagai insinyur perangkat lunak, kita dapat membuat skrip pengujian sederhana untuk mengukur Latensi RTT rata-rata dan Throughput pengiriman data ke server tujuan.

Berikut adalah kode pengujian berbasis Node.js menggunakan modul perf_hooks untuk presisi milidetik yang tinggi:

const http = require('http');
const { performance } = require('perf_hooks');

const TARGET_URL = 'http://localhost:3000/api/data';
const TOTAL_REQUESTS = 100;
const CONCURRENCY = 10; // Jumlah request paralel

let completedRequests = 0;
let totalLatency = 0;
let totalBytesTransferred = 0;

const startTime = performance.now();

function sendRequest() {
  if (completedRequests >= TOTAL_REQUESTS) {
    printReport();
    return;
  }

  const reqStartTime = performance.now();
  
  const req = http.get(TARGET_URL, (res) => {
    let bodyLength = 0;

    res.on('data', (chunk) => {
      bodyLength += chunk.length;
    });

    res.on('end', () => {
      const reqEndTime = performance.now();
      const latency = reqEndTime - reqStartTime; // Mengukur Latency RTT individu
      
      totalLatency += latency;
      totalBytesTransferred += bodyLength;
      completedRequests++;

      // Picu request berikutnya (Event-Loop Driven)
      sendRequest();
    });
  });

  req.on('error', (err) => {
    console.error('Request Error:', err.message);
    completedRequests++;
    sendRequest();
  });
}

function printReport() {
  const endTime = performance.now();
  const totalDurationSeconds = (endTime - startTime) / 1000;
  
  const averageLatency = totalLatency / TOTAL_REQUESTS;
  const throughputRequestsPerSecond = TOTAL_REQUESTS / totalDurationSeconds;
  const throughputMegabitsPerSecond = ((totalBytesTransferred * 8) / 1000000) / totalDurationSeconds;

  console.log('===================================================');
  console.log('         LAPORAN BENCHMARK JARINGAN NETWORKS       ');
  console.log('===================================================');
  console.log(`Total Waktu Pengujian : ${totalDurationSeconds.toFixed(2)} detik`);
  console.log(`Total Data Terkirim    : ${(totalBytesTransferred / 1024).toFixed(2)} KB`);
  console.log(`Rata-rata Latensi (RTT): ${averageLatency.toFixed(2)} ms`);
  console.log(`Throughput (Requests)  : ${throughputRequestsPerSecond.toFixed(2)} req/detik`);
  console.log(`Throughput (Bandwidth) : ${throughputMegabitsPerSecond.toFixed(2)} Mbps`);
  console.log('===================================================');
}

// Menjalankan request awal berdasarkan tingkat Concurrency
console.log(`Memulai benchmark dengan ${TOTAL_REQUESTS} total requests...`);
for (let i = 0; i < CONCURRENCY; i++) {
  sendRequest();
}

Strategi Rekayasa untuk Mengoptimalkan Jaringan

Bagi software engineer, cara kita menulis kode dan mendesain infrastruktur dapat meminimalkan dampak hambatan jaringan ini secara drastis:

  1. Gunakan CDN (Content Delivery Network) untuk Mengurangi Latensi: Dengan mendistribusikan aset statis dan API dinamis di server Edge yang dekat secara geografis dengan pengguna (misalnya Cloudflare, AWS CloudFront), RTT (latensi) dapat dipangkas dari 200ms menjadi di bawah 15ms. Hal ini otomatis mendongkrak Throughput secara instan.
  2. Kompresi Payload (Brotli / Gzip): Dengan mengompres berkas JSON/HTML/CSS sebesar 70%, jumlah bita (bytes) yang dikirim melintasi pipa jaringan berkurang drastis. Throughput relatif (kecepatan aplikasi memuat data) meningkat tanpa perlu menaikkan bandwidth fisik.
  3. Connection Pooling & HTTP/2 Multiplexing: Handshake koneksi TCP awal dan jabat tangan TLS/SSL memakan waktu latensi RTT yang mahal (3-way handshake). Dengan menggunakan teknik Connection Pooling (mempertahankan koneksi tetap hidup / Keep-Alive) dan HTTP/2 Multiplexing (mengirim banyak data dalam satu koneksi TCP tunggal secara bersamaan), kita mengeliminasi overhead latensi jabat tangan tersebut.
  4. TCP Window Auto-Tuning: Pada backend server sistem operasi Linux modern, pastikan parameter sysctl untuk TCP buffer autotuning diaktifkan (misalnya net.ipv4.tcp_rmem dan net.ipv4.tcp_wmem) agar ukuran jendela TCP secara otomatis membesar saat melintasi jalur latensi tinggi guna memaksimalkan throughput.

Kesimpulan Ringkas

  • Bandwidth adalah seberapa lebar jalur pipa data Anda.
  • Latency adalah seberapa cepat paket data tunggal dapat mengarungi perjalanan bolak-balik di dalam pipa tersebut.
  • Throughput adalah volume nyata data selamat yang berhasil diproses per detik.

Seorang insinyur perangkat lunak yang hebat tidak hanya berfokus pada seberapa besar Bandwidth yang dimiliki, melainkan secara taktis menekan angka Latensi serendah mungkin guna membuka sumbatan bottleneck Throughput sistem terdistribusi mereka demi terciptanya pengalaman pengguna yang responsif dan andal!

← Back to Blog Index