arXiv subjects

Haibo Chen

Publications and source records attributed to Haibo Chen.

At least 19 recordsLinked to original sources

arXiv2026

safeL4: Rethinking Safe-Language-Based Single Address Space Microkernels

Microkernels provide good features such as high security, safety, and flexibility, but their reliance on hardware-based isolation leads to heavy performance overhead, limiting their widespread adoption. Although constructing single-address-space microkernels based on safe language-based isolation is a promising approach to addressing the performance issue, this approach still faces challenges in maintaining the principle of minimality and enforcing capability-based, fine-grained access control over system resources. We propose safeL4, an approach to constructing microkernels based on safe languages. It guarantees minimality through low-level abstractions for unsafe operations, and implements a capability system based on the safe language's object capabilities to achieve fine-grained access control over all operations on system resources. We implement a prototype system in Rust, and our evaluation results show that the primitives provided by safeL4 are, on average, 1.9$\times$ faster than those of seL4.

cs.OS↗

arXiv2026

Classification of $U(\mathfrak h)$-Free Modules over the Heisenberg-Virasoro type Lie superalgebra via Polynomial Shift Operators

Let $\mathcal L$ be the Heisenberg-Virasoro type Lie superalgebra whose even part is the twisted Heisenberg-Virasoro algebra and whose odd part is an abelian ideal. We classify $\mathbb Z_2$-graded $\mathcal L$-modules that are free of super-rank $1|1$ over $U(\mathfrak h)=\mathbb C[L_0,F_0]$. Using polynomial shift operators, we express the defining relations as functional equations for the matrix entries of the generators. Assuming the rank one classification for the even subalgebra, we show that, up to parity reversal, every module with nontrivial odd action belongs to a triangular family $Ω^+(λ,β,d)$, whereas every module with trivial odd action is a direct sum of two rank-one modules for the even subalgebra. We determine the graded isomorphism classes: within the triangular family, the coupling polynomial $d$ is invariant up to multiplication by a non-zero scalar. We also describe canonical proper submodules and show that every module in the classification is reducible. In particular, we provide a new realization of the Heisenberg-Virasoro type Lie superalgebra using $2\times2$ matrices with entries associated with polynomial shift-differential operators.

math.RT↗

arXiv2026

Efficient K-generalizable Learned Search

Learned top-K search improves the accuracy-latency trade-off of graph-based vector search, but existing methods target a fixed K. Serving real-world workloads with various K values thus incurs preprocessing cost proportional to the number of distinct Ks. We present OMEGA, which supports efficient arbitrary K learned search with the preprocessing cost of one top-1 model. It achieves so by reducing learned top-K search to repeated masked learned top-1 search with refinement, using carefully crafted trajectory features that generalize across Ks. OMEGA further employs rank-wise confidence allocation to tame error accumulation during refinements and applies a statistical forecast method to reduce model invocation overhead without compromising recall. Across nine dataset-scale configurations, OMEGA meets the 0.95 recall target and reduces mean latency by up to 65% (average: 23%; median: 20%) compared with learned search methods (including LAET, DARTH, MultiK-DARTH, ANNiE, and Ada-ef) at their lowest-preprocessing configurations. On production traces, it reduces total CPU time by up to 28% versus traditional HNSW search.

cs.DB↗

arXiv2026

Characterizing CPU-GPU Memory Sharing over Unified Memory Architecture

Unified Memory Architecture (UMA) enables the CPU and GPU to share a single physical memory. However, its complexity and opacity often drive applications back to inefficient copying or to incorrect direct access that sacrifices performance or even correctness. This paper presents a comprehensive study of CPU-GPU memory sharing on UMA, covering correctness and performance across data-plane transmission and control-plane coordination on four platforms. It yields four findings that guide libumsh, a portable library that delivers correct and efficient memory sharing across platforms and extends to emerging ones (e.g., NVIDIA DGX Spark). Applied to nine real-world systems, libumsh reduces data-plane time by 16-75% and control-plane overhead by 7-90%.

cs.OS↗

arXiv2026

VUDA: Enabling Controlled Spatial Sharing of Graphics and Compute on NVIDIA GPUs

Graphics and compute increasingly share a single GPU in embodied AI simulators, AI-enabled games, and VR systems. Running these workloads concurrently can improve utilization, but contention can also compromise rendering and inference latency. Effective sharing therefore requires control over both concurrency and resource allocation. Native CUDA and Vulkan runtimes complicate this task: they place work in separate scheduling domains, while compute-oriented resource controls do not govern the graphics pipeline. We present VUDA, a system that enables controlled spatial sharing of native CUDA compute and Vulkan graphics on NVIDIA GPUs. An analysis of GPU scheduling, address translation, and workload dispatch reveals how to coordinate the two execution stacks without replacing either one. VUDA redirects CUDA channels into Vulkan's scheduling domain while preserving the runtimes' separate data address spaces. It then uses GPU front-end controls to partition execution resources between the graphics and compute pipelines, with allocations adjustable at runtime. Together, these mechanisms let applications control resource sharing without modifying GPU drivers or rewriting kernels and shaders. We evaluate VUDA across four application scenarios on three NVIDIA GPU platforms, covering throughput and latency objectives for graphics, compute, or both. In embodied AI simulation, enabling concurrency improves throughput by up to $1.62\times$ over the same asynchronous pipeline under default time sharing. In driving perception, partitioned co-execution reduces the measured inference-budget miss rate from 80.1% to zero while sustaining 60-FPS rendering.

cs.OS↗

arXiv2026

C-HAT-Bench: Benchmarking Chinese AI-Text Detection Beyond Fully Generated Text

Large Language Models (LLMs) increasingly participate in writing by modifying or extending human drafts, causing machine involvement to vary in both form and extent. Yet most Machine-Generated Text (MGT) detectors are evaluated only on fully human-written versus fully AI-generated text. Because human--AI collaboration can weaken or redistribute cues associated with machine generation, strong performance under this binary setting may overstate detector reliability. This mismatch remains underexplored in Chinese: detection cues are shaped by tokenization and language-specific text distributions, yet controlled resources spanning production settings, domains, and generators remain limited. To fill this gap, we present a Chinese Human-AI Collaborative Text Detection Benchmark (C-HAT-Bench), a unified benchmark that links $5,000$ human-written source texts from five domains to more than $240,000$ variants produced using six generative models under Prefix-Conditioned Continuation as a reference setting and three collaborative production modes. We evaluate $21$ detectors through four protocols spanning zero-shot and pretrained supervised document-level detection, boundary localization, and cross-condition generalization. Relative to Prefix-Conditioned Continuation, mean AUROC across document-level detectors is $12.0\%$ lower on the collaborative production modes, with the largest detector-specific relative decrease reaching $44.4\%$. Transfer across collaborative production modes is also asymmetric, indicating that performance in a given production setting is not a reliable predictor of performance in other production settings.

cs.CL↗

arXiv2026

MetaPermit: Scalable and Auditable Access Control for AI Agents via LLM-Inferred Meta-Attributes

The rise of autonomous AI agents equipped with tools has introduced significant security risks, ranging from unintended tool misuse to adversarial manipulation through Indirect Prompt Injection (IPI) attacks. In practice, deployed agent systems such as OpenAI Codex and Claude Code protect tool invocations through a combination of coarse-grained permission rules and LLM-based judgments about individual proposed actions. Both components, however, have important limitations: static policies must anticipate possible user intents and therefore do not scale to open-ended tasks, while LLM-driven authorization supports dynamic decisions but produces inconsistent outcomes and remains vulnerable to targeted IPI attacks. To provide scalable and more consistent authorization, we propose MetaPermit, a policy-based tool access-control framework that decouples semantic inference from security enforcement. By analyzing agent-user interactions, we derive a compact, task-independent set of meta-attributes that capture the relationships among the user's intent, the execution context, and the proposed tool call. These meta-attributes allow MetaPermit to authorize tool use without enumerating user intents. At runtime, an LLM infers the meta-attribute values for each proposed tool call, while a fixed policy evaluates these values to allow or deny the call, making each decision auditable through the inferred values and the applied policy rule. We evaluate MetaPermit on the AgentDojo and AgentDyn benchmarks, across seven task suites and five attack methods, using two widely deployed open-weight LLMs. The results show that MetaPermit produces 31% more consistent authorization decisions than LLM-driven authorization and outperforms the state-of-the-art defenses CaMeL and IPIGuard in both task completion, with improvements of up to 109%, and robustness to IPI attacks, with no malicious tool calls executed.

cs.CR↗

arXiv2026

SMetric: Rethink LLM Scheduling for Serving Agents with Balanced Session-centric Scheduling

LLM scheduling is critical to serving, yet how well existing designs fit agentic serving--where agents, not humans, issue the requests--remains unclear. Agents shift the workload in two ways: they consume many more tokens than humans, so the cluster must provide high throughput (TPS) at low latency; and their requests reuse far more KV\$ than chat. Existing schedulers still trade off load balance against KV\$ reuse: cache-aware schedulers may crowd requests onto the few instances caching the KV\$, leaving the rest idle, while balanced schedulers may lose the opportunity for reuse, which is costly at a high reuse ratio. We thus present two key insights: (1) with a global-tier KV\$ store, pursuing load balance need not compromise KV\$ reuse, though the slower global tier must be used with care; and (2) given the agent's intra-session locality, routing requests by their sessions can balance the load with high KV\$ reuse. A key challenge in realizing session-centric scheduling is that the scheduler must identify a request's session statelessly, which is difficult for model providers serving arbitrary agents. SMetric addresses this with differential scheduling based on two indicators derived from the request itself, the session turn and the local KV\$ hit: it schedules first-turn requests for load balance, and sticks follow-ups to the instance with the highest local hit for high KV\$ reuse. As sessions differ widely in size, SMetric sticks a follow-up only if the instance can serve it within its SLO, and otherwise migrates the session to the least-loaded instance to prevent many long sessions from eventually imbalancing the load. Evaluated on real-world traces, SMetric improves the peak TPS by 9-15% under prefill-decode colocation with a provisioned global tier and the peak prefill TPS by 9% under disaggregation over state-of-the-art schedulers, also with lower latency.

cs.DC↗

arXiv2026

Classification of Simple Harish-Chandra Modules over the Loop Mirror HeisenbergVirasoro Algebra

The loop mirror Heisenberg-Virasoro algebra, an embedded subalgebra of the loop Heisenberg-Virasoro algebra, admits a family of interesting truncated subalgebras including those of Takiff type and $\mathfrak{bms}_3$ type. We give a complete classification of simple Harish-Chandra modules over the loop mirror Heisenberg-Virasoro algebra, whose simple modules fall into three categories, highest weight modules, lowest weight modules, and evaluation modules of the intermediate series. As a by-product, we classify all simple Harish-Chandra modules over the truncated mirror Heisenberg-Virasoro algebras $\mathcal{L}(n)$ for $n\geq2$. By virtue of shift operators in the $d$-parameter family, we give a more streamlined proof of Theorem 3.3 from the work [Classification of simple $W_n$-modules with finite-dimensional weight spaces, {\it J. Reine Angew. Math.}, {\bf 720} (2016), 199-216] by Y. Billig and V. Futorny, which states the key Billig-Futorny identity. Furthermore, our approach can be extended to the computation of annihilators for uniformly bounded modules over some other Lie (super)algebras.

math.RT↗

arXiv2026

Modules over the Takiff Block type Lie algebra

In this paper, we introduce a family of infinite-dimensional Lie algebras $B(q)$ of Takiff Block type, containing Heisenberg-Virasoro algebra, $W$-algebra $W(2,2)$, and BMS-Kac-Moody algebra as subalgebras. For $q\in\mathbb C^*$, we classify the $ B(q)$-modules that are free of rank one over $U(\mathfrak h)$, where $\mathfrak h=\mathbb C L_{0,0}\oplus\mathbb C W_{0,0}$, and determine their irreducibility and isomorphism classes. We also establish irreducibility and isomorphism criteria for their tensor products with irreducible restricted modules. Finally, restricting the above $B(-1)$-modules to several natural subalgebras of the central quotient $B(-1)/(\mathbb C C_1\oplus\mathbb C C_2)$ yields families of non-weight modules.

math.RT↗

arXiv2026

SimP: Unifying Syntax- and Semantic-Guided Techniques for Efficient Program Reduction

Compiler bugs are pervasive in modern compiler systems, but the test programs that trigger them are often too large for practical debugging. Program reduction addresses this by minimizing test program size while preserving the original bug-triggering behavior. Existing approaches mainly rely on syntax-guided, rule-based deletion strategies that iteratively remove parts of the program in a trial-and-error manner. While effective in reduction quality, these approaches suffer from slow reduction speed. This paper presents SimP, a program reduction framework that combines traditional reduction with LLM-based syntax- and semantic-guided reduction. SimP leverages customized prompt design to guide the reduction process. SimP synergistically combines rule-based and LLM-based reduction stages to optimize the reduction performance. The results show that SimP improves reduction efficiency while achieving comparable reduction quality, with negligible LLM monetary cost.

cs.PL↗

arXiv2026

OSFoundry: Building and Evolving Operating Systems with Specification-Guided Agents

Operating systems must evolve continuously. Yet their development remains code-centric and largely manual: even a localized change can require recovering implicit assumptions, coordinating multiple subsystems, and repeatedly building, booting, testing, and debugging the complete system. General-purpose coding agents automate individual edits, but their prompt-centric workflows repeatedly reconstruct task boundaries and OS semantics from scattered context, limiting their reliability for sustained OS evolution. This paper presents OSFoundry, an OS-specialized agent harness that makes design intent persistent throughout OS development. Its key insight is to separate stable intent from diverse implementation. Instead of relying on free-form natural-language prompts to convey design intent, OSFoundry uses SysSpec*, a shared development blueprint comprising a task-bounding Plan and an OS-specific Specification: the Plan bounds what a change should achieve, while the Specification records the interfaces, modular dependencies, and concurrency semantics that its implementation must preserve. Agents implement and validate code against this same blueprint, refining both SysSpec* and the implementation when execution or review exposes a mismatch. We evaluate OSFoundry along three ways. First, OSFoundry generates SpecOS from SysSpec*; the resulting complete OS boots and passes all 70 functional tests. Second, specification patches evolve SpecOS with a GUI and three performance optimizations that improve performance by up to 4.41x. Third, across 11 recent Linux-kernel bug-fix tasks, OSFoundry achieves 1.8x the accuracy of Codex using GPT-5.5. These results show that persistent specifications can shift OS construction and evolution from repeated manual kernel engineering toward specification-guided development.

cs.OS↗

arXiv2026

CHIME: A Case for Efficient Long-Context Attention-FC Disaggregated Inference with DIMM-PIM

Attention-FC Disaggregated (AFD) LLM inference systems offload memory-bound Attention operations to memory-rich accelerators (e.g., CPUs, HBM-PIM) while retaining compute-bound Fully-Connected (FC) operations on GPUs. In this paper, we first design a Disaggregated Roofline Model (DRM) to characterize AFD performance, revealing that system throughput is constrained by the accelerator's limiting factor: either memory bandwidth or capacity. We observe that prior AFD systems often overlook these constraints and fail to balance them, leading to resource underutilization or constrained throughput. Therefore, we propose CHIME, the first AFD system integrating DIMM-PIM, which is a case of the new accelerator that strikes the balance with scalable capacity and bandwidth. To address the synchronization challenges inherent to the distributed cooperating DRAM chips in DIMM-PIM, CHIME employs bubble-free pipelining and hybrid-grained re-layout for efficient attention computation. Furthermore, it maximizes cross-device resource utilization via rankset-granular communication-computation overlapping and alignment-predicting scheduling. Evaluations show CHIME achieves up to 5.15$\times$ speedup over state-of-the-art HBM-PIM solutions.

cs.AR↗

arXiv2026

Determinism-Preserving GPU Spatial Sharing with Vitamin-E

GPU sharing faces a determinism--utilization tradeoff: fixed bindings can strand capacity as demand fluctuates, while resource-driven kernel reshaping improves utilization by altering a launch's parallel structure, potentially changing output bits. We rethink modern GPU scheduling and observe that it decouples logical structure from physical width: one unmodified launch spans a family of widths through changes in block placement and wave count. From this observation, we derive the parallel-structure invariant: for fixed-structure deterministic workloads, keeping each launch immutable makes its output bits independent of physical width. Guided by this invariant, Vitamin-E late-binds immutable launches to pooled physical contexts, preserving bitwise equality across allocations, whereas resource-driven reshaping can alter the selected token under temperature-zero greedy decoding. Across all workload--baseline comparisons, Vitamin-E achieves up to 3.50$\times$ the aggregate normalized LLM training throughput, 62.5\% lower inference p99 latency, and 1.43$\times$ the background-training throughput. With the same mechanism, \textsc{TPOT-First} reduces TPOT SLO violations by up to 46.1\% over \textsc{Throughput-Oriented} on three serving workloads, demonstrating mechanism effectiveness and policy flexibility.

cs.DC↗

arXiv2026

An Agentic OS Kernel for Flexible and Enhanced Semantics

Modern OS kernels expose general-purpose but rigid interfaces (e.g., syscalls) that are slow to evolve due to compatibility, performance, and security constraints, leaving apps to pay for mismatched semantics and legacy APIs. Existing kernel mechanism customization approaches (e.g., eBPF) improve flexibility but still face strict safety and performance restrictions and thus require substantial expertise. What's more, they targets customized kernel mechanisms rather than kernel abstractions. This paper presents agentic kernel, a new architecture that decomposes monolithic syscall functions into fine-grained, composable kernel-native micro-syscalls, and then enables Large Language Models (LLMs) to orchestrate them dynamically. Agentic kernel introduces a new entry, isyscall (intent syscall), which lets apps submit high-level intents describing their requirements. Then the kernel leverages LLMs to resolve each intent into composition plan of micro-syscalls to satisfy the user's goal. LLMs can further optimize the plan continuously at kernel runtime. To eliminate LLM inference costs on the critical path, agentic kernel caches and reuses verified plans to bypass LLM entirely. Crucially, agentic kernel's safety guarantees are independent of LLM correctness: micro-syscalls follows syscall-level security mechanisms, ensuring OS safety under arbitrary combinations and orchestration. We implement agentic kernel in Linux, called IntentOS, and evaluate it across four kernel versions and three application domains (about ten intents each). IntentOS outperforms baseline Linux in real-world applications, achieving up to 17.55% latency reduction for backend processes creation, 6.97% performance gain for multiple files operations, and 75.52% lower performance impact for frontend Nginx server during memory operations triggered by backend tasks.

cs.OS↗

arXiv2026

Simple restricted modules over the deformative Schrödinger-Virasoro algebra

This paper investigates simple restricted modules over the deformed Schrödinger-Virasoro algebra $\mathcal{G}_{λ,μ}$, which gives a complete classification of them for some $λ,μ\in\mathbb{C}$. More precisely, we provide a systematic construction of these modules, including highest weight modules and Whittaker modules, by inducing simple modules from the positive part's quotient algebras. We prove that any simple restricted $\mathcal{G}_{λ,μ}$-module satisfying certain injective conditions is isomorphic to such an induced module. As an application, we obtain some simple weak $V(c)$-modules over vertex algebras associated to $\mathcal{G}_{λ,μ}$ for some $λ,μ\in\mathbb{C}$. Note that our results include the Schrödinger-Virasoro algebra and the deformed $\mathfrak{bms}_3$ algebra as special cases, thereby improving upon some of the previously reported results of [5,Theorem 3.4] and [6,Theorem 2]. This work effectively classifies and generalizes the representation theory of the deformed family.

math.RT↗

arXiv2026

MosaicKV: Serving Long-Context LLM with Dynamic Two-D KV Cache Compression

Long-context LLM services now sustain prompts with hundreds of thousands to millions of tokens, making the key-value (KV) cache a first-order serving cost. Because the cache grows linearly with context length, it can exhaust GPU memory, force smaller batches, and reduce serving throughput. Prior KV cache compression techniques typically target only the sequence dimension or only the channel dimension, which leaves limited headroom as context windows scale. Compressing both dimensions promises higher memory reduction, but applying the two forms of compression directly leads to significant accuracy loss. This paper introduces MosaicKV, a dynamic two-D (dimensional) KV cache compression system for extremely long-context serving. MosaicKV uses dynamic two-D compression to address the accuracy challenge, exploiting the non-uniform importance distribution of elements within the KV cache. Instead of applying one compression pattern globally, MosaicKV identifies important elements for each KV vector and selects compression strategies at the granularity of KV cache segments. To address the performance challenge, where fine-grained sparsity and compression management overhead can offset the gains from compression, MosaicKV introduces compressed KV cache management. This mechanism uses underutilized GPU and CPU resources to maintain compressed KV caches and accelerate attention computation. Evaluation on an H800 GPU with multiple LLMs shows that MosaicKV delivers up to 16x attention speedup, 4.8x lower decode latency, and 7.3x higher throughput than the uncompressed baseline. At the same time, it reduces memory usage by 3x and incurs only 1.76% average accuracy loss on LongBench and RULER.

cs.LG↗

arXiv2026

EnerInfer: Energy-Aware On-Device LLM Inference

On-device LLM inference is increasingly attractive for privacy-preserving, reliable, and cost-effective deployment, yet its energy and thermal costs remain a critical bottleneck. Existing systems primarily optimize for decoding speed, implicitly assuming that faster execution is always preferable. We show instead that on-device LLM inference often has exploitable configuration slack: modestly lowering NPU and memory frequencies preserves quality of experience (QoE) while substantially improving energy efficiency and reducing heat. Realizing this opportunity in production is challenging. The most energy-efficient NPU/DDR setting varies with the model, inference engine, platform, and runtime conditions, with no stable ranking across configurations. Commercial devices further lack component-level power sensing, and shell temperature evolves with request arrivals, response lengths, and thermal history. To address these challenges, we propose EnerInfer, the first on-device LLM inference framework that jointly manages energy efficiency, throughput, and thermal comfort for LLM workloads. EnerInfer replaces per-model profiling and sensor-heavy control with disaggregated, model-structure-aware prediction and ranking-driven online feedback. It predicts throughput and power for unseen LLMs across NPU/DDR frequency settings, selects QoE-satisfying efficient configurations under runtime interference, and uses lightweight limited-horizon thermal prediction to dynamically switch between energy-optimized and thermally constrained inference. Evaluations on real-world LLMs show that EnerInfer improves energy efficiency by up to 65%, 12%, and 24% on phones, a laptop, and a development board, respectively, without QoE violation.

cs.SE↗