JustFit 2026: Arsitektur 200K-Token LLM Serving pada Laptop 24 GiB, Just-in-Time State Management (KVExec, PhaseSwap, StateTrans), dan Apple Silicon MLX Acceleration

Di era modern model penalaran dan coding berparameter besar (seperti Qwen3.8-27B), mengeksekusi inferensi lokal pada workstation laptop telah menjadi impian utama setiap engineer software. Namun, tantangan terberat yang membendung adopsi inferensi edge lokal bukan sekadar kompresi bobot model (weights quantization), melainkan ledakan konsumsi Key-Value (KV) Cache dan execution state yang melumat habis kapasitas unified memory hingga memicu system OOM killer.

1. Anatomi Kegagalan Inferensi Lokal: Mengapa Quantization Bobot Saja Gagal

Pada arsitektur komputasi terpadu seperti Apple Silicon Unified Memory Architecture (UMA), CPU, GPU, dan Neural Engine berbagi satu ruang memori fisik yang sama tanpa adanya isolasi DRAM terpisah. Formula total footprint memori dinamis sistem pada saat inferensi berjalan dirumuskan sebagai:

Di mana W(t) adalah bobot model yang dapat diakses, K(t) adalah persistent packed KV cache, S(t) adalah recurrent state (Gated DeltaNet) dan speculative state, X(t) adalah workspace eksekusi sementara (intermediate activation workspaces), dan H(t) adalah overhead alokator runtime.

Mayoritas optimasi konvensional hanya fokus mengecilkan W(t) menggunakan format low-bit seperti MXFP4 atau INT4. Namun, ketika prompt bertambah panjang (misalnya memuat seluruh repositori kode atau berkas log raksasa), K(t) dan ruang dekuantisasi X(t) membengkak secara eksponensial. Pada geometri Qwen3.8-27B (interleaving 16 full-attention layers dan 48 Gated DeltaNet layers dengan 4 KV heads bertranslasi pada 256 dimensi), representasi FP16 standar menuntut 65.536 byte per posisi konteks. Pada 229.376 posisi, KV cache FP16 menuntut lebih dari 14,33 GiB VRAM—seketika menabrak batas guard 21.000 MiB macOS.

2. Tiga Pilar Arsitektur JustFit: KVExec, PhaseSwap, dan StateTrans

JustFit memecahkan dilema tersebut melalui paradigma Just-in-Time (JIT) State Management, memecah tanggung jawab runtime ke dalam tiga subsistem yang saling terkoordinasi secara ketat:

3. Deep Dive KVExec: Fused Direct-Inverse Reconstruct & Page-Native TQ4

Pendekatan kompresi KV konvensional kerap gagal karena workspace rekonstruksinya (intermediate dequantized buffers) melampaui memori yang berhasil dihemat. KVExec mengadopsi formulasi matematis TurboQuant (Zandieh et al., 2025). Untuk setiap vektor atensi \(x\) dengan norm \(\rho = \|x\|_2\), unnormalized Hadamard matrix \(H_d\), dan random-sign diagonal matrix \(S\):

Setiap vektor Key atau Value dikompresi menjadi 128 byte packed indices (8 index 4-bit per U32 word) dan 2-byte norm FP16 (dihitung dari FP32). Total payload KV per token posisi konteks terpangkas drastis:

Dibandingkan dengan 65.536 Byte pada FP16, JustFit menghasilkan efisiensi kompresi 3.94x. Yang paling revolusioner: inverse Hadamard transform dieksekusi secara fused in-kernel menggunakan kernel Apple Metal Shader khusus (dua tahap radix-16 dalam 16-thread group buffer). Hasil tensor floating K/V langsung dikonsumsi oleh Apple MLX Scaled Dot-Product Attention (SDPA) pada layer tersebut dan langsung di-release sebelum layer berikutnya dieksekusi, memastikan working set memory tidak pernah bocor ke layer selanjutnya.

4. Koordinasi PhaseSwap & StateTrans: Speculation vs Continuous Batching

Tantangan besar dalam sistem multi-tasking edge adalah fluktuasi kebutuhan beban kerja. Ketika request berjalan sendirian (singleton request), JustFit memanfaatkan Multi-Token Prediction (MTP) dengan auxiliary drafter predictor untuk melipatgandakan kecepatan decoding. Namun saat request kedua masuk ke antrean, memori laptop tidak cukup untuk menjalankan multi-drafter secara simultan.

StateTrans menerapkan Algorithm 1 Serving Iteration:

• Zero-Overhead Transition: Saat request peer diizinkan masuk, StateTrans menunggu satu putaran spekulatif selesai, melepaskan (detach) bobot MTP predictor seberat 215.21 MiB, lalu mengonversi eksekusi ke Autoregressive (AR) Batching tanpa membuang KV Cache target yang telah dibangun.
• Phase-Aware Vision Lease: Permintaan yang membawa media gambar tidak disisipkan sembarangan ke dalam active decode cohort. Vision tower dimuat secara eksklusif selama tahap pemrosesan feature image, di-evaluate, lalu segera di-release sebelum token prefill teks dilanjutkan.
• Bounded Chunk Interleaving: Selama batch decode aktif, alokator membatasi kesempatan prefill sebesar maksimal 64 token per 4 langkah decode forward (skema N4/PF64), mencegah lonjakan latensi interaktif bagi request yang sedang melakukan stream teks.

5. Evaluasi Empiris: 212K Context Capacity & Benchmark AIME 2026

Riset ini diuji secara ketat pada perangkat Apple MacBook M4 Pro (24 GiB Unified Memory) menjalankan model Qwen3.8-27B MXFP4. Berikut adalah komparasi metrik empiris terhadap baseline:

Tiga pengujian independen pada batas 196.608 token input + 16.384 token output berhasil diselesaikan 100% tanpa ada crash atau silent truncation, dengan variasi memori puncak yang luar biasa stabil (20.960 hingga 20.977 MiB).

Lebih penting lagi, kompresi 4-bit TQ4 tidak merusak daya pikir model: pada benchmark penalaran matematika bergengsi AIME 2026, runtime JustFit terintegrasi berhasil memecahkan 29 dari 30 soal secara akurat (akurasi 96.67%) pada kecepatan tertimbang 15.04 token/detik, membuktikan bahwa kompresi state berbasis orthogonal transform mempertahankan integritas reasoning jangka panjang.

6. Implementasi Arsitektur: StateTrans & PhaseSwap Coordinator

Di bawah ini adalah implementasi referensi state coordinator yang menerapkan prinsip Algorithm 1 JustFit untuk mengelola memori terpadu dan transisi status request secara deterministik:

"""
JustFit Production State Management Engine: Apple Silicon Unified Memory Coordinator
Berdasarkan Arsitektur Resmi Makalah Riset arXiv:2609.17475 (Yuhua Chen, September 2026).
Mengimplementasikan koordinasi KVExec (TQ4 Fused Kernel), PhaseSwap (Lease Manager),
dan StateTrans (MTP <-> AR serving transition boundary).
"""

import time
import math
from typing import Dict, List, Optional, Tuple, Set
from dataclasses import dataclass, field
from enum import Enum

class ServingMode(str, Enum):
    SINGLETON_MTP = "SINGLETON_MTP"  # Multi-Token Prediction Speculative Mode
    AUTOREGRESSIVE_BATCH = "AR_BATCH" # Multi-Row Continuous Batching

class ComponentType(str, Enum):
    LM_HEAD = "LM_HEAD"
    VISION_TOWER = "VISION_TOWER"
    MTP_DRAFTER = "MTP_DRAFTER"

@dataclass
class PageTableEntry:
    page_id: int
    logical_slot: int
    ref_count: int = 1
    is_evicted: bool = False

@dataclass
class ServingRequest:
    req_id: str
    prompt_tokens: int
    output_budget: int
    allocated_pages: List[int] = field(default_factory=list)
    has_vision_payload: bool = False
    tokens_generated: int = 0
    is_completed: bool = False

class JustFitStateCoordinator:
    """
    Sub-sistem StateTrans & PhaseSwap:
    Mengelola unified memory 24 GiB pada Apple Silicon M-Series, mencegah OOM guard kill,
    dan memanipulasi kepemilikan memori fisik secara zero-overhead.
    """
    PAGE_SIZE = 256  # 256 tokens per physical page
    TQ4_BYTES_PER_TOKEN = 16640  # 16 layers * 2(K/V) * 4 heads * (128 bytes indices + 2 bytes norm)

    def __init__(self, total_unified_memory_mib: int = 24576, memory_guard_limit_mib: int = 21000):
        self.total_memory = total_unified_memory_mib
        self.guard_limit = memory_guard_limit_mib
        self.serving_mode = ServingMode.SINGLETON_MTP
        
        # Component Leases (PhaseSwap)
        self.active_leases: Dict[ComponentType, Set[str]] = {
            ComponentType.LM_HEAD: set(),
            ComponentType.VISION_TOWER: set(),
            ComponentType.MTP_DRAFTER: set(),
        }
        
        # Physical Page Management (KVExec & StateTrans)
        self.free_page_ids: List[int] = list(range(1024))  # 1024 * 256 tokens = 262,144 token slots
        self.page_directory: Dict[int, PageTableEntry] = {}
        self.active_requests: Dict[str, ServingRequest] = {}

    def calculate_reservation_pages(self, prompt_len: int, output_budget: int) -> int:
        """
        Persamaan (7) Makalah JustFit:
        Ri = ceil( (prompt_len + min(output_budget, 8192)) / 256 )
        """
        guaranteed_tokens = prompt_len + min(output_budget, 8192)
        return math.ceil(guaranteed_tokens / self.PAGE_SIZE)

    def acquire_component_lease(self, comp: ComponentType, requester_id: str) -> bool:
        """PhaseSwap: Materialisasi komponen hanya saat dibutuhkan, retain selama ada lease."""
        self.active_leases[comp].add(requester_id)
        return True

    def release_component_lease(self, comp: ComponentType, requester_id: str) -> None:
        """PhaseSwap: Lepas komponen segera setelah fase komputasi selesai."""
        self.active_leases[comp].discard(requester_id)

    def admit_request(self, req: ServingRequest) -> bool:
        """
        StateTrans: Evaluasi budget kuota memori sebelum admisi.
        Jika transisi dari Singleton MTP ke AR Batching, preserve target prompt cache & detach MTP drafter.
        """
        needed_pages = self.calculate_reservation_pages(req.prompt_tokens, req.output_budget)
        if len(self.free_page_ids) < needed_pages:
            return False  # Blocked in queue without polluting cache

        # Alokasi halaman fisik
        allocated = [self.free_page_ids.pop(0) for _ in range(needed_pages)]
        req.allocated_pages = allocated
        for pid in allocated:
            self.page_directory[pid] = PageTableEntry(page_id=pid, logical_slot=len(self.page_directory))

        self.active_requests[req.req_id] = req

        # Transisi mode jika terdapat >1 concurrent requests
        if len(self.active_requests) > 1 and self.serving_mode == ServingMode.SINGLETON_MTP:
            self.transition_to_autoregressive_batch()

        return True

    def transition_to_autoregressive_batch(self) -> None:
        """Konversi mode ke AR Batching tanpa mereset target prompt cache."""
        self.serving_mode = ServingMode.AUTOREGRESSIVE_BATCH
        # Detach singleton MTP drafter (menghemat 215.21 MiB VRAM seketika)
        self.active_leases[ComponentType.MTP_DRAFTER].clear()

    def complete_request(self, req_id: str) -> None:
        """
        Algorithm 1 StateTrans:
        1. Selesaikan step aktif.
        2. Evaluasi pending write ke backing buffer.
        3. Filter row yang selesai, decref page table.
        4. Jika ref_count == 0, kembalikan page ID ke free list.
        """
        req = self.active_requests.pop(req_id, None)
        if not req:
            return

        for pid in req.allocated_pages:
            entry = self.page_directory.get(pid)
            if entry:
                entry.ref_count -= 1
                if entry.ref_count <= 0:
                    del self.page_directory[pid]
                    self.free_page_ids.append(pid)

        # Cek re-promosi kembali ke Singleton MTP jika tersisa 1 request aktif
        if len(self.active_requests) == 1 and self.serving_mode == ServingMode.AUTOREGRESSIVE_BATCH:
            survivor_id = next(iter(self.active_requests.keys()))
            self.serving_mode = ServingMode.SINGLETON_MTP
            self.acquire_component_lease(ComponentType.MTP_DRAFTER, survivor_id)

7. Implikasi Strategis bagi Local AI Coding & Edge Inference 2026

Keberhasilan JustFit membuktikan pergeseran fundamental dalam lanskap komputasi kecerdasan buatan:

• Demokratisasi Full-Repository Reasoning: Pengembang software independen tidak lagi bergantung mutlak pada GPU cluster cloud (A100/H100) hanya untuk melakukan analisis codebase skala besar (200K context). Laptop kelas konsumen kini mampu menampung seluruh pohon dependensi kode secara lokal dengan privasi total.
• Pergeseran Paradigma dari Model Weights ke State Management: Persaingan efisiensi AI bukan lagi semata-mata mencari arsitektur model baru, melainkan bagaimana sistem operasi dan runtime inferensi mengelola siklus hidup memori (memory lifecycle management) secara hardware-aware.
• Sinergi dengan Algoritma Kompresi Eviksi: Mengombinasikan pendekatan JIT resident state JustFit dengan seleksi token cerdas seperti BeaconKV (arXiv:2609.04971) membuka potensi melayani konteks hingga 1 Juta token pada perangkat laptop standar di masa mendatang.