EAServe 2026: Arsitektur Encode-Aware Disaggregated Serving pada Multimodal LLM, Reposisi Modality Encoder sebagai Control Point EPD Pipeline, Dynamic SM Partitioning, dan Eliminasi GPU Resource Imbalance

Dalam infrastruktur inferensi kecerdasan buatan modern, transisi dari model bahasa berbasis teks (text-only LLM) menuju Multimodal Large Language Models (MLLM)—seperti LLaVA-1.6, Qwen2.5-VL, InternVL-2.5, dan Ultravox—menghadirkan tantangan komputasi terdistribusi yang belum pernah diantisipasi oleh sistem serving generasi pertama. Jika pada model teks disaggregasi hanya membagi siklus hidup inferensi menjadi dua fase komputasi: Prefill (yang dibatasi oleh kapasitas komputasi / compute-bound) dan Decode (yang dibatasi oleh bandwidth memori VRAM / memory-bandwidth bound), maka MLLM menambahkan fase ketiga yang sangat krusial dan heterogen: Encode.

Fase Encode bertugas memproses input non-teks mentah—seperti resolusi piksel citra visual, deretan frame video resolusi tinggi, atau spektrogram audio analog—menggunakan encoder khusus (seperti CLIP ViT, Whisper, atau multi-frame 3D convolution) dan memproyeksikannya ke ruang embedding model bahasa melalui modul connector (MLP projection atau cross-attention resampler). Penambahan fase ini melahirkan pipeline 3-tahap: Encode-Prefill-Decode (EPD).

Terobosan radikal untuk memecahkan dilema ini diperkenalkan oleh tim peneliti Georgia Institute of Technology dan University of Georgia melalui publikasi riset teranyar mereka di PACT 2026 (arXiv:2609.31551, 25 September 2026) berjudul "EAServe: Encode-Aware Disaggregated Serving for Multimodal Large Language Models". Riset ini memperkenalkan paradigma baru: mereposisi fase Encode sebagai control point aktif dari seluruh pipeline inferensi EPD.

1. Reposisi Encode sebagai Control Point Pipeline EPD Tiga Dimensi

Alih-alih membiarkan worker Encode menjadi entitas statis yang pasif, EAServe memanfaatkan posisi unik Encode di gerbang utama pipeline untuk mengontrol tiga dimensi komputasi yang saling terhubung erat:

2. Hybrid Auto Selection (HAS): Pemangkasan Asimetris & Optimasi Bayesian

Menentukan konfigurasi optimal pada sistem serving MLLM terdisaggregasi adalah problem kombinatorial yang sangat kompleks. Konfigurasi deployment target didefinisikan sebagai tripel:

di mana $ ext{alloc} = (n_E, n_P, n_D)$ adalah alokasi jumlah GPU untuk masing-masing pool Encode, Prefill, dan Decode dari total anggaran GPU $G$; $B$ adalah batas kapasitas micro-batch Encode; dan $s in [0, 1]$ adalah rasio offload Prefill ke remote pool.

Pada cluster 8 GPU saja, terdapat ratusan kemungkinan konfigurasi yang valid. Melakukan pencarian exhaustive grid search di lingkungan produksi adalah hal yang mustahil, karena setiap uji coba deployment membutuhkan waktu beberapa menit pengukuran stabil, yang berujung pada hitungan jam atau hari untuk satu jenis beban kerja.

3. Tiga Mekanisme Runtime EAServe: Presisi Temporal, Spasial, dan Hardware

Setelah konfigurasi $PC^star$ ditentukan secara offline oleh HAS, lapisan runtime EAServe mengeksekusinya secara online melalui 3 mekanisme ko-desain:

A. Load-Adaptive Micro-Batching via Poisson-Gap Rule

Bagaimana scheduler menentukan kapan harus meluncurkan batch Encode jika jumlah request yang terkumpul belum mencapai batas $B$? Dispatcher konvensional yang mengandalkan timeout statis atau batas panjang antrean kaku akan mengalami misalignment saat laju kedatangan request berfluktuasi.

EAServe merumuskan aturan batas celah kedatangan (arrival gap threshold) $g$ langsung dari sifat stokastik proses Poisson dengan laju per-worker $lambda = Lambda / n_E$ dan target probabilitas pengisian batch $p in (0, 1)$:

Formula ini memberikan sifat krusial: $g propto 1/lambda$. Saat beban traffic melonjak tinggi, threshold $g$ mengetat secara otomatis sehingga batch segera meluncur tanpa latensi antrean yang tidak perlu. Sebaliknya, saat beban rendah, threshold melonggar secara anggun, memungkinkan akumulasi request untuk efisiensi komputasi.

B. Rate-Controlled Partial Offload via Deficit Round Robin

Untuk mengeksekusi rasio offload target $s in [0, 1]$, pendekatan acak (probabilistic coin toss) menghasilkan variansi tinggi pada rentang waktu pendek, sementara pendekatan sliding window membutuhkan parameter ukuran window $W$ yang sensitif terhadap beban.

EAServe mengadopsi skema Deficit-Controlled Routing yang diadaptasi dari algoritma antrean jaringan teruji Deficit Round Robin (DRR):

Skema ini membuktikan secara analitis bahwa deviasi kumulatif terhadap rasio ideal $s$ selalu terbatas ketat $|c_k - k cdot s| < 1$, mengeliminasi getaran antrean (queue jitter) dan menjaga beban Prefill lokal dan remote tetap seimbang secara deterministik.

C. Dynamic SM Partitioning dengan Perlindungan QoS Latensi

Ketika worker Prefill lokal dijalankan pada GPU Encode yang sama, keduanya berisiko mengalami interferensi komputasi yang parah jika hanya mengandalkan time-slicing standar CUDA atau hint advisory pada CUDA MPS.

EAServe memanfaatkan partisi fisik Streaming Multiprocessor (SM). Berdasarkan karakterisasi kurva latensi Encode vs persentase SM pada arsitektur GPU Ada Lovelace dan Hopper, latensi Encode turun tajam dari 500 ms pada 10% SM ke 280 ms pada 30% SM, kemudian melandai datar pada rentang 50%-90% SM. EAServe menetapkan latency degradation budget maksimal 20% sebagai batas aman QoS:

Sisa kuota SM (misalnya 70% atau 60%) dialokasikan penuh secara eksklusif ke local prefill worker. Ketika ukuran batch Encode berubah secara dinamis, alokasi SM bergeser secara mulus di antara partisi fisik yang terisolasi, mengeliminasi kontensi eksekusi kernel tanpa mengorbankan SLA p99.

4. Evaluasi Empiris: Kinerja Goodput vs vLLM dan NVIDIA Dynamo

Evaluasi mendalam dilakukan pada kluster 8 GPU NVIDIA RTX 6000 Ada (48GB VRAM) dan A100 SXM4 (80GB VRAM) dengan interkoneksi NIXL/NVLink berkecepatan tinggi, mencakup tiga modalitas input representatif:

• Modalitas Citra (Image): LLaVA-v1.6-34B (CLIP ViT-L/14 @ 336px)
• Modalitas Video (Multi-Frame): Qwen2.5-VL-32B (Dynamic Resolution ViT 3D Conv)
• Modalitas Suara (Audio): Ultravox-v0.6-27B (Whisper-large-v3 Audio Encoder)

Hasil pengujian membuktikan bahwa EAServe mencapai peningkatan goodput yang konsisten di semua modalitas. Lonjakan performa paling masif terjadi pada modalitas audio (4.3x lebih tinggi dibanding Dynamo), di mana encoder audio yang relatif ringan sebelumnya menyia-nyiakan kapasitas GPU secara ekstrem pada arsitektur terdisaggregasi statis. Dengan mengaktifkan local prefill melalui partisi dinamis SM, utilisasi GPU melonjak dari 41% menjadi 89%.

5. Spesifikasi Teknis: Implementasi TypeScript EAServe Orchestration Engine

Berikut adalah implementasi referensi berstandar enterprise dalam TypeScript modern yang mengabstraksikan modul PoissonGapMicroBatcher, DeficitCounterRouter, dan DynamicSMPartitioner untuk integrasi gateway inferensi MLLM:

// EAServe Production Engine: Encode-Aware Disaggregated MLLM Serving
// Berdasarkan Arsitektur PACT 2026 / arXiv:2609.31551 (Zhu et al. - September 2026)
//
// Komponen Inti:
// 1. PoissonGapMicroBatcher: Dynamic threshold g = κ / λ dengan κ = -ln(1 - p^(1/(B-1)))
// 2. DeficitCounterRouter: Deficit-controlled routing untuk rasio offload s ∈ [0, 1] dengan batas deviasi terbukti
// 3. DynamicSMPartitioner: QoS-guarded spatial SM allocation antara Encode dan Co-resident Local Prefill
// 4. HASConfigManager: Hybrid Auto Selection configuration resolver

export interface RequestEnvelope {
  requestId: string;
  modality: 'image' | 'video' | 'audio';
  rawPayloadSize: number; // Bytes or token equivalent
  arrivedAt: number; // High-precision timestamp ms
  targetSloMs: number;
}

export interface DeploymentConfiguration {
  gpuBudget: number; // e.g. 8 GPUs
  encodeWorkers: number; // n_E
  remotePrefillWorkers: number; // n_P
  decodeWorkers: number; // n_D
  batchBoundB: number; // Encode batch ceiling
  offloadRatioS: number; // s ∈ [0, 1]
  targetArrivalRateLambda: number; // req/s
}

/**
 * 1. Poisson-Gap Micro-Batcher
 * Menghitung waktu tunggu dinamis g = κ / λ berdasarkan laju kedatangan riil,
 * memperketat threshold saat beban tinggi dan melonggarkannya saat idle.
 */
export class PoissonGapMicroBatcher {
  private batchBoundB: number;
  private targetP: number; // Default: 0.6 (titik optimal trade-off latency vs throughput)
  private currentArrivalRateLambda: number;
  private kappa: number;
  private gapThresholdMs: number;
  private queue: RequestEnvelope[] = [];
  private lastArrivalTimestamp: number = 0;

  constructor(batchBoundB: number, initialArrivalRateLambda: number, targetP: number = 0.6) {
    this.batchBoundB = batchBoundB;
    this.targetP = targetP;
    this.currentArrivalRateLambda = initialArrivalRateLambda;
    this.kappa = -Math.log(1 - Math.pow(this.targetP, 1 / (this.batchBoundB - 1)));
    this.gapThresholdMs = (this.kappa / this.currentArrivalRateLambda) * 1000;
  }

  public updateArrivalRate(measuredLambda: number): void {
    if (measuredLambda <= 0.01) return;
    this.currentArrivalRateLambda = measuredLambda;
    this.gapThresholdMs = (this.kappa / this.currentArrivalRateLambda) * 1000;
  }

  public enqueue(req: RequestEnvelope): { shouldDispatch: boolean; batch: RequestEnvelope[]; reason: string } {
    const now = performance.now();
    this.queue.push(req);
    this.lastArrivalTimestamp = now;

    // Kondisi 1: Batch penuh mencapai batas B
    if (this.queue.length >= this.batchBoundB) {
      const batchToDispatch = this.queue.splice(0, this.batchBoundB);
      return { shouldDispatch: true, batch: batchToDispatch, reason: 'BATCH_BOUND_REACHED' };
    }

    return { shouldDispatch: false, batch: [], reason: 'QUEUED' };
  }

  public checkGapTimeout(currentTime: number): { shouldDispatch: boolean; batch: RequestEnvelope[]; reason: string } {
    if (this.queue.length === 0) {
      return { shouldDispatch: false, batch: [], reason: 'EMPTY_QUEUE' };
    }

    const elapsedGap = currentTime - this.lastArrivalTimestamp;
    if (elapsedGap >= this.gapThresholdMs) {
      const batchToDispatch = [...this.queue];
      this.queue = [];
      return { shouldDispatch: true, batch: batchToDispatch, reason: 'POISSON_GAP_EXPIRED' };
    }

    return { shouldDispatch: false, batch: [], reason: 'WAITING_FOR_GAP' };
  }
}

/**
 * 2. Deficit-Counter Router
 * Mengatur rute prefill (lokal vs remote) menggunakan akumulator Deficit Round Robin (DRR).
 * Menjamin deviasi rute maksimal bounded |c_k - k*s| < 1 tanpa fluktuasi acak.
 */
export class DeficitCounterRouter {
  private offloadRatioS: number; // s ∈ [0, 1]
  private deficitAccumulator: number = 0;
  private totalLocalDispatched: number = 0;
  private totalRemoteDispatched: number = 0;

  constructor(offloadRatioS: number) {
    this.offloadRatioS = Math.max(0, Math.min(1, offloadRatioS));
  }

  public routeRequest(req: RequestEnvelope): 'LOCAL_PREFILL' | 'REMOTE_PREFILL' {
    this.deficitAccumulator += this.offloadRatioS;

    if (this.deficitAccumulator >= 1.0) {
      this.deficitAccumulator -= 1.0;
      this.totalRemoteDispatched++;
      return 'REMOTE_PREFILL';
    } else {
      this.totalLocalDispatched++;
      return 'LOCAL_PREFILL';
    }
  }

  public getStats() {
    const total = this.totalLocalDispatched + this.totalRemoteDispatched;
    const empiricalS = total > 0 ? this.totalRemoteDispatched / total : 0;
    return {
      targetS: this.offloadRatioS,
      empiricalS: Number(empiricalS.toFixed(4)),
      localCount: this.totalLocalDispatched,
      remoteCount: this.totalRemoteDispatched,
      currentDeficit: Number(this.deficitAccumulator.toFixed(4)),
    };
  }
}

/**
 * 3. Dynamic SM Partitioner
 * Mengalokasikan streaming multiprocessor secara dinamis antara modality encoder
 * dan local prefill worker. Menjamin degradasi latensi Encode <= 20% (QoS preservation).
 */
export class DynamicSMPartitioner {
  // Mapping batch size Encode ke alokasi persentase SM yang menjaga QoS
  private smAllocationTable: Map = new Map([
    [1, { encodeSmPct: 20, localPrefillSmPct: 80 }],
    [2, { encodeSmPct: 30, localPrefillSmPct: 70 }],
    [4, { encodeSmPct: 40, localPrefillSmPct: 60 }],
    [6, { encodeSmPct: 60, localPrefillSmPct: 40 }],
    [8, { encodeSmPct: 75, localPrefillSmPct: 25 }],
  ]);

  public resolveSMPartition(currentEncodeBatchSize: number): { encodeSm: number; localPrefillSm: number } {
    let bestKey = 1;
    for (const key of Array.from(this.smAllocationTable.keys()).sort((a, b) => a - b)) {
      if (currentEncodeBatchSize >= key) {
        bestKey = key;
      }
    }
    const partition = this.smAllocationTable.get(bestKey) || { encodeSmPct: 50, localPrefillSmPct: 50 };
    return {
      encodeSm: partition.encodeSmPct,
      localPrefillSm: partition.localPrefillSmPct,
    };
  }
}

/**
 * 4. Orchestration Harness: EAServe Coordination Node
 */
export class EAServeCoordinationNode {
  private config: DeploymentConfiguration;
  private batcher: PoissonGapMicroBatcher;
  private router: DeficitCounterRouter;
  private smPartitioner: DynamicSMPartitioner;

  constructor(config: DeploymentConfiguration) {
    this.config = config;
    this.batcher = new PoissonGapMicroBatcher(config.batchBoundB, config.targetArrivalRateLambda);
    this.router = new DeficitCounterRouter(config.offloadRatioS);
    this.smPartitioner = new DynamicSMPartitioner();
  }

  public handleIncomingRequest(req: RequestEnvelope) {
    const enqueueResult = this.batcher.enqueue(req);
    if (enqueueResult.shouldDispatch) {
      return this.dispatchEncodeBatch(enqueueResult.batch);
    }
    return { dispatched: false, reason: enqueueResult.reason };
  }

  public dispatchEncodeBatch(batch: RequestEnvelope[]) {
    const smSplit = this.smPartitioner.resolveSMPartition(batch.length);
    const routedBatch = batch.map((r) => ({
      request: r,
      targetStage: this.router.routeRequest(r),
    }));

    return {
      dispatched: true,
      batchSize: batch.length,
      smAllocation: smSplit,
      routingDetails: routedBatch,
      timestamp: performance.now(),
    };
  }
}

6. Panduan Implementasi bagi AI Platform & Infrastructure Engineers

Bagi organisasi enterprise yang mengoperasikan kluster inferensi MLLM mandiri atau merancang arsitektur serving generasi baru:

1. Jangan Mengisolasi Encode sebagai Microservice Terpisah Tanpa Backpressure: Memisahkan encoder citra/video ke layanan Triton atau vLLM terpisah tanpa koordinasi rate-limiting dengan downstream Prefill/Decode hanya akan menciptakan penumpukan antrean liar dan lonjakan ekor TTFT.
2. Terapkan Ko-lokasi Local Prefill pada Node Encode: Karena encoder visual menyisakan lebih dari 60% komputasi SM pada kondisi operasi normal, manfaatkan kapasitas sisa ini untuk memproses tahap awal prompt text-embedding menggunakan partisi SM perangkat keras (NVIDIA MPS atau MIG).
3. Gunakan Aturan Celah Poisson untuk Micro-Batching Dinamis: Tinggalkan timeout statis 10ms atau 50ms yang rentan rusak saat volume query berubah. Turunkan nilai batas waktu tunggu $g$ secara proporsional terhadap estimasi laju kedatangan real-time $lambda$.