KREX 2026: Arsitektur Concurrent Kernel Benchmarking pada Shared GPU via Region-Granular Exclusivity, Eliminasi Driver Lock Mutex, dan 3.4x Throughput Evaluasi AI Coding Agents

Di tengah perlombaan otomasi rekayasa perangkat lunak artificial intelligence, autonomous kernel coding agents—seperti Atrex Kernel Agent dari Alibaba, kernel-design-agents dari NVIDIA Labs, dan GEAK dari AMD—telah merevolusi cara industri mengoptimasi kernel GPU (Triton, CUDA, dan ROCm/HIP). Namun, di balik keberhasilan agen-agen ini menandingi insinyur manusia, tersembunyi sebuah krisis infrastruktur yang jarang dibahas: krisis utilisasi dan fidelitas benchmarking pada kluster GPU akselerator.

1. Anatomi Masalah: Dilema Alokasi GPU pada Autonomous Kernel Agents

Untuk memahami mengapa sistem evaluasi konvensional runtuh di bawah beban agentic workflows, perhatikan siklus kerja tipikal autonomous coding agent saat mengoptimasi kernel:

1. Reasoning & Code Generation: Agen menganalisis kernel baseline, menelaah profil NCU, dan menghasilkan varian kode Triton/CUDA baru via panggilan API LLM (memakan waktu 5 hingga 30 detik).
2. Setup & Environment Bootstrapping: Menjalankan proses Python baru, memuat PyTorch dan Triton runtime, menginisialisasi CUDA driver context, dan mengalokasikan tensor uji (ratusan milidetik).
3. Fungsionalitas & Unit Testing: Memeriksa apakah output kernel baru cocok dengan output referensi FP32/FP64 (keakuratan matematis).
4. Benchmarking Timing Loop: Menjalankan warm-up loop (puluhan iterasi) disusul timed loop menggunakan cudaEventRecord untuk mencatat durasi eksekusi kernel (hanya beberapa milidetik).

Profil telemetri empiris dari Alibaba Group pada kluster produksi menunjukkan fakta mencengangkan: perintah GPU hanya mengambil 19.3% dari total wall-clock time sesi agen, dan GPU hanya aktif melakukan komputasi hardware selama 17.4% dari interval tersebut. Hasil akhirnya: utilisasi GPU murni hanya 3.4%! Lebih dari 96% kapasitas akselerator kelas enterprise seharga puluhan ribu dolar terbuang sia-sia dalam keadaan menganggur (idle).

2. Mengapa Ungated GPU Sharing Fatal bagi Algoritma Optimasi Agen?

Mengapa kita tidak bisa sekadar menjalankan banyak kontainer Docker atau proses evaluasi di GPU yang sama secara bersamaan? Jawabannya terletak pada kontensi mikro-arsitektur perangkat keras.

Ketika dua proses menjalankan kernel pada GPU NVIDIA atau AMD secara simultan:

• L2 Cache Thrashing: SM (Streaming Multiprocessors) mengeksekusi warp dari kedua proses. Cache baris L2 milik kernel yang sedang diukur akan terlempar (evicted) oleh data dari proses kompetitor, melipatgandakan latensi akses HBM.
• DRAM Memory Bandwidth Contention: Pengukuran kernel yang berkarakter memory-bound (seperti FlashAttention atau RoPE rotary embeddings) sangat sensitif terhadap saturasi bus DRAM. Permintaan transfer memori dari tenant lain mendistorsi metrik durasi hingga 150%+.
• CPU Scheduler & Driver Jitter: Panggilan cudaLaunchKernel atau synchronous cudaStreamSynchronize di-drive oleh thread CPU host. Jika CPU terbebani oleh kompilasi C++/Triton tenant lain, jeda penjadwalan CPU akan tercatat sebagai lonjakan waktu eksekusi kernel.

Dalam evaluasi empiris, pada mode ungated sharing di GPU NVIDIA H20, hanya 11.0% hasil pengukuran yang berada dalam rentang toleransi 5% dari waktu referensi asli. Sisanya mengalami inflasi hingga 154%! Akibatnya, agen pencari berbasis reinforcement learning atau beam search (seperti pada KernelOPT) akan menghukum kode yang sangat efisien hanya karena saat diuji kebetulan bertabrakan dengan kernel lain, dan sebaliknya mempromosikan kode buruk.

3. Paradigma Baru: Region-Granular Exclusivity

Inti dari penemuan KREX adalah pemisahan tegas antara bagian program yang harus eksklusif dan bagian program yang bebas berbagi resource.

KREX memperkenalkan context manager minimalis:

# Menandai blok sensitif waktu pada script evaluasi agent
import krex.region as region

# Fungsionalitas non-kritis berjalan bersamaan dengan kandidat lain di GPU yang sama:
model = init_candidate_triton_kernel()
inputs = allocate_test_tensors()
assert_functional_correctness(model, inputs) # Off-Region Concurrency (Shared)

# Blok kritis yang memerlukan fidelitas tinggi:
with region.critical():
    # Warm-up loop untuk menstabilkan cache dan clock hardware:
    for _ in range(25):
        model(*inputs)
    torch.cuda.synchronize()
    
    # Timed benchmark loop:
    start_event.record()
    for _ in range(100):
        model(*inputs)
    end_event.record()
    torch.cuda.synchronize()
    
elapsed_ms = start_event.elapsed_time(end_event) / 100

Mengapa batasan (boundaries) ini tidak bisa dideteksi otomatis oleh compiler tanpa penandaan eksplisit? Peneliti KREX membuktikan bahwa jika runtime hanya mengisolasi pemanggilan timer (antara start_event.record dan end_event.record), warm-up loop akan terlempar ke zona publik. Tanpa isolasi pada warm-up loop, inisialisasi internal runtime dan kestabilan cache tidak pernah tercapai sebelum pengukuran dimulai. Sebaliknya, jika runtime mengisolasi seluruh loop pada program, pemeriksaan kebenaran fungsional (correctness assertions) yang memakan waktu lama akan ikut memonopoli GPU dan membunuh konkurensi.

4. Protokol Eksklusivitas In-Region 8-Tahap

Ketika sebuah proses kandidat (disebut Holder) memasuki region.critical(), tenant lain pada GPU yang sama (disebut Siblings) mungkin sedang menjalankan instruksi kernel atau memiliki antrean GPU yang belum tuntas. KREX mengeksekusi protokol 8 langkah yang sangat presisi untuk menjamin isolasi mutlak:

5. Menghilangkan Pajak Inisialisasi: Persistent Context Process Pooling

Tantangan besar berikutnya saat menjalankan lusinan perintah evaluasi kandidat secara paralel adalah Driver-Level Lock Contention.

Pada arsitektur GPU modern (baik NVIDIA Unified Memory nvidia-uvm maupun AMD KFD), setiap kali sebuah proses pengguna memanggil cudaSetDevice atau menginisialisasi context GPU pertama kali, driver kernel mengambil global node-wide mutex lock. Pembuatan context ini membutuhkan waktu antara 200 hingga 500 milidetik per perintah.

Jika sebuah node 8-GPU menerima ratusan perintah per menit dari berbagai agen, server akan mengalami mutex thrashing: proses-proses baru saling memblokir satu sama lain di level kernel OS, bahkan antar-GPU yang sama sekali berbeda! Konkurensi multi-tenant pun runtuh menjadi antrean serial yang lambat.

6. Hasil Benchmark Empiris pada NVIDIA H20 & AMD MI308X

Peneliti mengevaluasi KREX menggunakan lebih dari 20.000 benchmarking commands riil yang dikumpulkan dari autonomous coding agents (Alibaba Atrex, NVlabs kernel-design-agents, dan AMD GEAK) melintasi tiga benchmark standar industri: KernelBench, Atrex-Bench, dan FlashInfer-Trace pada kluster 16 GPU NVIDIA H20 dan 16 GPU AMD MI308X.

Temuan penting lainnya adalah integrasi NVIDIA Multi-Process Service (MPS). Dengan mengaktifkan MPS pada zona off-region, throughput evaluasi pada NVIDIA H20 meningkat tambahan 24% (dari 44.2 menjadi 54.8 cmds/menit) tanpa memperburuk fidelitas pengukuran karena MPS sepenuhnya diproteksi oleh gerbang in-region KREX selama critical timing loop.

7. Spesifikasi Arsitektur: KREX Multi-Tenant Engine di TypeScript

Di bawah ini adalah representasi desain perangkat lunak clean-architecture dari komponen pengatur gerbang, protokol koordinasi 8-tahap, dan pengelolaan pool context persisten yang menjadi jantung runtime KREX:

// KREX Runtime: Region-Granular Exclusivity & Context Pool Engine
// Arsitektur Berdasarkan Riset arXiv:2609.30057 (HKUST & Alibaba Group, September 2026)
//
// Komponen Kunci:
// 1. SharedMemoryGate: Atomic lock & gate synchronization dengan epoch counter
// 2. InFlightSubmissionCounter: Tracking operasi GPU sebelum submission path
// 3. Coordinator8StepProtocol: 8-Tahap penguncian, drain kernel, freeze sibling, & core isolation
// 4. PersistentContextPool: Eliminasi driver lock serialisasi node-wide (uvm/kfd)

import { EventEmitter } from 'events';

export type TenantState = 'IDLE' | 'COMPILING' | 'WARMING_UP' | 'IN_CRITICAL_REGION' | 'FROZEN';

export interface GpuTenant {
  tenantId: string;
  gpuId: number;
  pid: number;
  state: TenantState;
  inFlightGpuOps: number;
  assignedCores: number[];
}

export interface GateState {
  isLocked: boolean;
  holderTenantId: string | null;
  epoch: number;
  drainedTimestamp: number | null;
}

/**
 * 1. Shared-Memory Gate & Atomic State Synchronization
 * Mengontrol akses eksklusif region tanpa round-trip RPC ke daemon pusat
 */
export class SharedMemoryGate {
  private state: GateState = {
    isLocked: false,
    holderTenantId: null,
    epoch: 0,
    drainedTimestamp: null,
  };

  public tryClaimGate(tenantId: string): boolean {
    if (this.state.isLocked) return false;
    this.state.isLocked = true;
    this.state.holderTenantId = tenantId;
    this.state.epoch += 1;
    return true;
  }

  public releaseGate(tenantId: string): void {
    if (this.state.holderTenantId === tenantId) {
      this.state.isLocked = false;
      this.state.holderTenantId = null;
      this.state.drainedTimestamp = null;
    }
  }

  public isGateHeldByOther(tenantId: string): boolean {
    return this.state.isLocked && this.state.holderTenantId !== tenantId;
  }

  public getEpoch(): number {
    return this.state.epoch;
  }
}

/**
 * 2. Eight-Step Region Exclusivity Coordinator
 * Menjamin zero contention pada GPU hardware queue dan CPU driver thread
 */
export class EightStepRegionCoordinator extends EventEmitter {
  private gate = new SharedMemoryGate();
  private activeTenants: Map = new Map();
  private isolatedCpuCoreMask = [0, 1]; // Core eksklusif untuk benchmark timing thread

  public registerTenant(tenant: GpuTenant): void {
    this.activeTenants.set(tenant.tenantId, tenant);
  }

  public unregisterTenant(tenantId: string): void {
    this.activeTenants.delete(tenantId);
  }

  /**
   * Langkah 1-6: Protokol Masuk ke Region Eksklusif (Region Entry)
   */
  public async enterCriticalRegion(holderId: string): Promise {
    const holder = this.activeTenants.get(holderId);
    if (!holder) throw new Error(`Tenant ${holderId} not registered`);

    // Step 1: Request regional lock dari GPU coordinator
    while (!this.gate.tryClaimGate(holderId)) {
      await new Promise((r) => setTimeout(r, 0.5)); // Spin-wait mikrodetik
    }

    // Step 2 & 3: Gate ditutup secara atomik; submission baru oleh sibling dicegat
    const siblings = Array.from(this.activeTenants.values()).filter((t) => t.tenantId !== holderId);

    // Step 4: Drain outstanding work yang sudah terlanjur dikirim ke antrean GPU
    await this.drainSiblingGpuQueues(siblings);

    // Step 5: Freeze proses sibling menggunakan Linux cgroup v2 freezer atau SIGSTOP
    for (const sibling of siblings) {
      this.freezeProcess(sibling);
    }

    // Step 6: CPU Core Isolation — sematkan driver thread ke core CPU terisolasi
    this.applyCpuAffinity(holder.pid, this.isolatedCpuCoreMask);
    holder.state = 'IN_CRITICAL_REGION';
    this.emit('region_entered', { holderId, epoch: this.gate.getEpoch() });
  }

  /**
   * Langkah 7 & 8: Eksekusi Selesai dan Protokol Keluar Region (Region Exit)
   */
  public async exitCriticalRegion(holderId: string): Promise {
    const holder = this.activeTenants.get(holderId);
    if (!holder) return;

    const siblings = Array.from(this.activeTenants.values()).filter((t) => t.tenantId !== holderId);

    // Step 8a: Kembalikan afinitas CPU thread holder ke mask normal
    this.resetCpuAffinity(holder.pid);

    // Step 8b: Thaw / Unfreeze sibling processes (SIGCONT)
    for (const sibling of siblings) {
      this.thawProcess(sibling);
    }

    // Step 8c: Rilis Shared-Memory Gate & Buka kembali antrean GPU submission
    this.gate.releaseGate(holderId);
    holder.state = 'IDLE';
    this.emit('region_exited', { holderId });
  }

  private async drainSiblingGpuQueues(siblings: GpuTenant[]): Promise {
    const maxDrainTimeoutMs = 500;
    const start = Date.now();

    while (siblings.some((s) => s.inFlightGpuOps > 0)) {
      if (Date.now() - start > maxDrainTimeoutMs) {
        console.warn('[KREX] Drain timeout: memaksa sinkronisasi stream hardware');
        break;
      }
      await new Promise((r) => setTimeout(r, 0.1));
    }
  }

  private freezeProcess(tenant: GpuTenant): void {
    // Di level sistem Linux: echo "1" > /sys/fs/cgroup/krex-tenant-{pid}/cgroup.freeze
    tenant.state = 'FROZEN';
  }

  private thawProcess(tenant: GpuTenant): void {
    // Di level sistem Linux: echo "0" > /sys/fs/cgroup/krex-tenant-{pid}/cgroup.freeze
    tenant.state = 'IDLE';
  }

  private applyCpuAffinity(pid: number, cores: number[]): void {
    // Di level sistem: sched_setaffinity(pid, sizeof(mask), &mask)
  }

  private resetCpuAffinity(pid: number): void {
    // Reset afinitas ke default host
  }
}

/**
 * 3. Persistent GPU Context Pool
 * Mengeliminasi lock serialisasi node-wide driver (200-500ms per kompilasi)
 */
export class PersistentContextPool {
  private poolSize: number;
  private availableContexts: Array<{ contextId: string; gpuId: number; processPid: number }> = [];

  constructor(gpuCount: number, contextsPerGpu: number) {
    this.poolSize = gpuCount * contextsPerGpu;
    for (let g = 0; g < gpuCount; g++) {
      for (let c = 0; c < contextsPerGpu; c++) {
        this.availableContexts.push({
          contextId: `ctx-gpu${g}-${c}`,
          gpuId: g,
          processPid: 10000 + g * 100 + c,
        });
      }
    }
  }

  public acquireContext(gpuId?: number): { contextId: string; gpuId: number } {
    let index = -1;
    if (gpuId !== undefined) {
      index = this.availableContexts.findIndex((c) => c.gpuId === gpuId);
    } else {
      index = 0;
    }

    if (index === -1 || this.availableContexts.length === 0) {
      throw new Error('ResourceExhausted: Seluruh persistent context sedang aktif');
    }

    const [acquired] = this.availableContexts.splice(index, 1);
    return acquired;
  }

  public releaseAndSanitizeContext(context: { contextId: string; gpuId: number; processPid: number }): void {
    // Reset arena memori GPU, verifikasi status CUDA tanpa merusak context daemons
    this.availableContexts.push(context);
  }
}

8. Implikasi Strategis bagi Infrastruktur AI & Platform Engineering Enterprise

Bagi organisasi yang sedang membangun kluster evaluasi internal untuk autonomous LLM agents atau automated compiler pipelines, temuan riset KREX memberikan panduan arsitektur krusial:

1. Hentikan Alokasi Eksklusif 1:1 untuk AI Agents: Memesan 1 GPU per agen adalah pemborosan modal terbesar di era AI modern. Pisahkan fase eksplorasi simbolik (LLM inference) dari fase benchmarking fisik.
2. Isolasi CPU Wajib Bersama Isolasi GPU: Banyak engineer lupa bahwa eksekusi GPU dikendalikan oleh host CPU. Kegagalan membatasi jitter CPU melalui isolasi core (core affinity) dan pembekuan proses latar belakang (cgroup freezer) akan menghasilkan metrik GPU palsu yang merusak reward model agen.
3. Gunakan Pre-Warmed Context Pooling: Jika pipeline evaluasi Anda sering memanggil binary Python/Triton baru secara berulang, hilangkan inisialisasi context driver CUDA/ROCm dari jalur kritis melalui IPC shared memory ke daemon persisten.
4. Padukan KREX dengan Optimizer Seperti KernelOPT: Menggabungkan dispatch-aware agentic search (seperti KernelOPT) dengan region-granular concurrency runtime (seperti KREX) membuka kapasitas optimasi kernel hingga 10x lebih cepat dengan biaya hardware yang sepertiga lebih hemat.