AdaSprite: Resource-efficient Online Co-Adaptation for V2I Systems Under Large-scale Data Drifts

AdaSprite: Resource-efficient Online Co-Adaptation for V2I Systems Under Large-scale Data Drifts Lehao Wang† , Zhiwen Yu†,+,∗ , Sicong Liu†,∗ , Kefan Chen† , Fengmin Wu† , Bin Guo† † Northwestern Polytechnical University, + Harbin Engineering University

arXiv:2608.16188v1 [cs.OS] 17 Aug 2026

Abstract The rise of vehicle–infrastructure (V2I) collaboration enables safer and broader perception. To process large-scale V2I video streams, vision-language models (VLMs) are promising as they unify multiview vision into end-to-end task grounding, reducing handcrafted design. We use Vision Mixture-of-Experts (V-MoE) as the distributed visual backbone of VLMs, leveraging sparse expert routing to enable conditional computation across diverse viewpoints under resource constraints. Yet, V-MoEs face a critical challenge: largescale data shifts over minutes to hours in V2I systems, amplified by agnostic participants and biased features propagating through experts. To maintain accuracy efficiently, we find it beneficial to co-adapt multiple V-MoEs on edge servers, avoiding the latency and privacy risks of cloud offloading and the accuracy sacrifices of on-device methods. However, the resource-constrained edge poses challenges for efficient co-adaptation: i) DRAM fragmentation and imbalance limit expert parallelism, ii) memory-I/O bottlenecks restrict computation reuse, and iii) asynchronous adaptation increases task-switch overhead. Also, prior work rarely explores the upper bound of concurrent tasks under limited edge resources, a critical factor for practical V2I deployment. To address these, we present AdaSprite. By combining cooperative elastic scaling with multilevel multiplexing, AdaSprite optimizes expert lifespans to reduce DRAM fragmentation, exploits predictable activation patterns for efficient I/O reuse, and employs twin-buffer scheduling to leverage sparsity. On a weak edge, AdaSprite supports up to 17 concurrent V2I tasks (vs. ≤ 6 for baselines), improving SLO attainment by 1.6× and throughput by 2.1×. Also, it allows users to trade accuracy and concurrency for second-level adaptation.

CCS Concepts • Computing methodologies → Artificial intelligence; Parallel computing methodologies; • Human-centered computing → Ubiquitous and mobile computing.

Keywords Networked V2I systems, V-MoE co-adaptation ACM Reference Format: Lehao Wang† , Zhiwen Yu†,+,∗ , Sicong Liu†,∗ , Kefan Chen† , Fengmin Wu† , Bin Guo† . 2026. AdaSprite: Resource-efficient Online Co-Adaptation for V2I Systems Under Large-scale Data Drifts. In The 24th Annual International *Zhiwen yu and Sicong liu are corresponding authors.

This work is licensed under a Creative Commons Attribution 4.0 International License. MobiSys ’26, Cambridge, United Kingdom © 2026 Copyright held by the owner/author(s). ACM ISBN 979-8-4007-2027-7/26/06 https://doi.org/10.1145/3745756.3809211

Conference on Mobile Systems, Applications and Services (MobiSys ’26), June 21–25, 2026, Cambridge, United Kingdom. ACM, New York, NY, USA, 13 pages. https://doi.org/10.1145/3745756.3809211

1

Introduction

The rise of mobile and embedded vision has enabled AI-powered perception in vehicle systems [21, 22, 41, 55, 73, 74]. Relying on a single vehicle’s sensors, however, leaves blind spots (e.g., occluded pedestrians [79]), motivating networked vehicle-infrastructure (V2I) perception. In V2I, particularly in the intermediate collaboration [9], vehicles and roadside nodes share and fuse features to extend sensing range, avoiding raw-video backhaul and enabling tunable latency–quality trade-offs and enhance safety-critical tasks such as path planning [44], localization [1], and navigation [29]. Contrary to common belief, vision-language models (VLMs) can process large-scale video streams more resource-efficiently than traditional deep models by aligning visual inputs with task semantics, e.g., “whether to yield,” especially in bandwidth- and computeconstrained V2I systems. In our tests, VLM-based V2I reduces inference latency by 22.6% and transmission by up to 84.9% compared to CooperNaut [10], while maintaining comparable accuracy. Unlike traditional vision models that capture all raw features, VLMs extract task-relevant cues (e.g., pedestrians, vehicles) and discard irrelevant data. This task-driven alignment yields compact embeddings, making VLMs ideal for resource- and bandwidth-limited V2I scenarios. Moreover, VLMs enable instruction-driven tasks, such as high-level visual QA, directly supporting the detect–decide–act loop. To further improve efficiency, we adopt Vision Mixture-ofExperts (V-MoE) [8, 59] as a distributed feature extractor across heterogeneous V2I devices. Its sparse expert routing and lightweight design enable conditional computation, improving accuracy-efficiency trade-off while adapting to device-specific constraints. As shown in Fig. 1, each device runs a compressed V-MoE tailored to its viewpoint: on-vehicle cameras (Device A) focus on dynamic obstacles with 15Mbps streams; roadside cameras (Device B) capture lateral context with 10Mbps streams; intersection cameras (Device C) track global traffic flow with 20Mbps streams. These object-aware embeddings are fused at the edge for downstream tasks, e.g., planning and cooperative inference, enabling timely hazard warnings and improving traffic safety. A key challenge is non-stationary distributed (large-scale) data drifts. While the language module of VLMs generalizes well, visual modules deployed on distributed V2I devices continuously encounter long-horizon data drifts between training and real-world traffic, degrading accuracy. Agnostic participants (e.g., vehicles) increase drift frequency, and shared V-MoE outputs propagate bias or errors (second-hand drift). In Tab. 1, a drift in a single vision module can cause 35.73% system-wide accuracy loss, which is unacceptable.

MobiSys ’26, June 21–25, 2026, Cambridge, United Kingdom

Lehao Wang† , Zhiwen Yu†,+,∗ , Sicong Liu†,∗ , Kefan Chen† , Fengmin Wu† , Bin Guo†

Figure 1: Showcasing networked V2I applications in urban traffic scenarios. Figure 2: Edge-assisted V-MoE co-adaptation. Adaptation with targeted visual updates [33, 71] can mitigate this. However, full cloud offloading [31] raises privacy and latency issues, while on-device tuning [15, 26, 53] sacrifices accuracy for efficiency. Edge-assisted adaptation strikes a balance, asynchronously serving parallel jobs, sharing resources, and enabling a tunable accuracylatency trade-off under continuous non-stationary drifts (e.g., trafficflow changes), as in Microsoft Edge Video Services [3, 47]. Also, prior work rarely explores the upper bound of concurrent adaptation tasks under limited edge resources, a critical factor for practical V2I deployment. As participation scales, constrained GPU memory (DRAM) limits the number of tasks that can maintain accuracy with low latency. For example, a single RTX 3090 edge server can typically handle only six concurrent adaptation tasks using existing methods (see Sec. 5.3), with latency rising sharply as load increases. For example, on a shared RTX 3090 edge server, only a 16% increase in task load can cause a 40% rise in average latency. Our key insight is that co-adaptation, enabled via cooperative elastic scaling and multi-level reuse, makes large-scale online adaptation feasible and effective (Sec. 2.3). First, transformer-based V-MoEs have weaker inductive bias than CNNs; co-adaptation leverages parameter sharing and cross-task expert transfer to improve accuracy and increase the number of concurrent tasks. Tab. 2 shows co-adaptation reduces latency by 42.9% compared to isolated adaptation while improving per-task accuracy. Second, vision workloads share substantial computation [62], creating redundancy. Isolated adaptation redundantly accesses identical DRAM-mapped regions, wasting memory and bandwidth. Co-adaptation instead uses a unified DRAM-resident expert cache, enabling no-copy, in-DRAM reuse across tasks (Fig. 5). Realizing these benefits under dynamic-sparse V-MoE adaptation with large-scale, non-stationary mobile workloads raises three key challenges: • Challenge #1: DRAM-constrained expert parallelism. Although MoEs are parallelizable, inefficient DRAM usage caps coadaptation parallelism, inflating latency and limiting concurrency. Two factors dominate: i) Dynamic, irregular DRAM requests from shared experts cause memory fragmentation, reducing available DRAM for new tasks. Prior tuning or memory-efficient methods [63, 68, 72] improve footprint but often slow execution. ii) Sparse activations and heterogeneous experts, amplified by diverse V2I models, induce load imbalance, causing stalls and high DRAM occupancy. Auxiliary balance losses [6] or strict capacity management [16] partially help but reduce accuracy due to suboptimal routing.

Table 1: Accuracy Loss from second-hand drift Task

Exi.

Cou.

Obj.

Sta.

Com.

Overall

Accuracy loss (%)

7.77

50.04

60.42

39.14

21.29

35.73

Table 2: Comparing isolated- and co-adaptation Accuracy (%)

Adaptation Method Exi. Isolated adaptation Co-adaptation

Avg. latency

Cou.

Obj.

Sta.

Com.

(s)

49.68 8.62 58.06 12.07

15.17 33.10

34.74 48.42

52.05 73.97

385.25 219.86

• Challenge #2: Memory-I/O-bound computation reuse. Crosstask reuse can boost efficiency, but DRAM-constrained edge GPUs (e.g., 10 GB on RTX 3080 vs. 21 GB reuse demand for V-MoE) require offloading redundant computation to disk, creating I/O bottlenecks, especially with heterogeneous V2I streams. Dynamic sparsity and diverse models exacerbate irregular, bursty I/O, causing cache thrashing and latency spikes. Existing systems [21, 25] rely on frequent scattered I/O, while prefetchers [17] assume more regular access than MoE retraining exhibits. Eviction conflicts across shared experts further erode gains. • Challenge #3: Scheduling asynchronous adaptation requests. Non-stationary, asynchronous adaptation requests amplify dynamic sparsity, inflating task-switch overhead via repeated expert cache reloads. Heterogeneous accuracy gains across concurrent tasks complicate scheduling, making fairness-priority trade-offs critical to avoid inefficiency. AdaSprite addresses these challenges with three mechanisms that turn limitations into opportunities. • First: align expert lifespans to reduce fragmentation and imbalance. Long tasks can block shorter ones, so AdaSprite groups experts by lifespan and dependency using lightweight dynamic programming under a shortest-job-first principle [14]. At runtime, resources are scheduled to align expert execution, reducing DRAM fragmentation and balancing load. • Second, exploit predictable activation trends for I/O-efficient reuse. Although MoE retraining is dynamically sparse, the expertactivation probabilities are predictable. We design an I/O-hiding prefetch that reorders input tokens so GPU compute overlaps with runtime I/O. An importance-aware token residency/eviction policy minimizes latency and mitigates cross-expert conflicts, converting dynamic sparsity into predictable, resource-efficient operation.

AdaSprite: Resource-efficient Online Co-Adaptation for V2I Systems Under Large-scale Data Drifts

(a) In cloud

(b) At edge

(c) Comput. scale

MobiSys ’26, June 21–25, 2026, Cambridge, United Kingdom

(d) Comput. reorder

(e) AdaSprite

Figure 3: Comparison of various MoE parallelization strategies in resource-rich cloud or resource-limited edge. • Third, harness sparsity with twin-buffer scheduling. Rather than treating sparsity as a liability in adaptation, AdaSprite employs a twin-buffer scheduler with two-tier GPU preemption [23]. It interleaves services across buffers and preloads inactive experts during task switches, cutting reload overhead while balancing fairness and priority. We implement AdaSprite as Linux microservices (see Sec. 4). We evaluate AdaSprite using three LLMs across five continuous traffic scenarios and five bandwidth settings on two self-collected continuous traffic datasets: CampReal (a two-week real trace) and TrafficSim (10+ road types, 150 vehicles, 38 cameras, and tens of concurrent task combinations). On a weak RTX 3090 edge server, AdaSprite sustains up to 17 concurrent adaptation tasks, whereas the best baseline supports at most 6 under the same configuration. AdaSprite also enables tunable concurrency–latency trade-offs; for example, reducing the task count to 4 yields second-level adaptation latency. Overall, AdaSprite achieves the best accuracy–latency trade-off, cutting adaptation latency by up to 57.9% and improving SLO attainment and throughput by up to 1.6× and 2.1×, respectively. Even under extreme conditions (e.g., expert-group failures), AdaSprite preserves significant gains, such as 42.7% lower DRAM fragmentation. Main contributions are summarized as follows. • To our knowledge, this is the first work to examine the upper bound of concurrent adaptation tasks on weak edge servers. By treating expert dynamic sparsity as an opportunity, AdaSprite enables cooperative elastic scaling and multi-level reuse for efficient MoE co-adaptation in V2I systems. • AdaSprite introduces lifespan alignment, I/O-hiding prefetch with importance-aware residency/eviction, and twin-buffer scheduling, turning fragmentation, load imbalance, and asynchrony into throughput gains under non-stationary mobile scenarios. • Across diverse V2I tasks/scenarios, AdaSprite consistently surpasses state-of-the-art in latency-accuracy trade-off.

2 Background and Motivation 2.1 The Trend of V-MoE in V2I Systems Vision Mixture-of-Experts (V-MoE) augments Vision Transformers (ViTs) by replacing standard self-attention and feed-forward networks (FFNs) with expertized attention/MLP blocks, and by dynamically routing input tokens to the most relevant experts. V-MoE and its structure are increasingly adopted in VLM-based vehicle-infrastructure collaboration (V2I) for two reasons. First, ViTs typically serve as unified visual backbones in VLMs. V-MoEs preserve high-quality, consistent features across devices while avoiding task-specific backbone adaptation. Second, sparse expert activation

Figure 4: GPU utilization during executions.

Figure 5: Latency and computations.

enables conditional computation, improving accuracy-efficiency trade-offs by routing tokens to specialized experts.

2.2

Primer of MoE Merging

MoE merging treats experts from different V-MoEs as a parallel expert set while merging shared components (e.g., layer norms), enabling multiple V-MoEs to operate within a unified co-adaptation framework ( Fig. 2). This is well suited for V2I co-adaptation for two reasons. i) By keeping model-specific knowledge isolated within experts and merging only shared structures, V2I devices can contribute diverse experts to a common pool, improving concurrency through parameter sharing while avoiding interference and catastrophic forgetting. ii) Sparse activation yields minimal inter-expert dependency, allowing device-specific V-MoEs to be attached or detached asynchronously from the co-adaptation pool with negligible accuracy loss [8].

2.3

Challenges and Opportunities

In large-scale drifts, co-adapting experts not only improves modellevel efficiency and knowledge fusion, but also breaks resource isolation, enabling cross-model sharing of DRAM, compute, and I/O. Under this shared context, challenges such as dynamic sparsity and I/O constraints can be reframed as opportunities for adaptation efficiency. 2.3.1 Sparse Activation of the V-MoE. Heterogeneous V2I devices trigger irregular, sparse expert activations, which create two key bottlenecks at the edge. First, fragmentation. Dynamic sparsity produces transient intermediates and irregular DRAM requests, forming small, discontinuous memory blocks that restrict parallelism and cap concurrency. While cloud settings hide this issue with abundant memory (Fig. 3a), edge GPUs (Fig. 3b) can host only a subset of experts per cycle, magnifying fragmentation. Existing memory optimizations, scaling/repartitioning [51], compute reordering [72], swapping/recompute [56, 58], or fragmentationoriented GC/compaction [28, 63, 64, 68], either incur accuracy loss or impose non-trivial overhead on weak edge servers. Second, load

MobiSys ’26, June 21–25, 2026, Cambridge, United Kingdom

Lehao Wang† , Zhiwen Yu†,+,∗ , Sicong Liu†,∗ , Kefan Chen† , Fengmin Wu† , Bin Guo†

Figure 6: Facing new-arrival tasks with ➊, ➋ determines adaptation tasks to service based on task demands and system states while updating ➊ through online profiling. During task execution, for each layer, ➌ identifies tokens for computation and feeds it back to ➍ which schedules the execution of experts to maximize their computation parallelism. Meanwhile, ➌ reuses other tokens with low I/O overhead to improve I/O efficiency. imbalance. Uneven expert activations cause severe imbalance and synchronization stalls; measured GPU utilization under default parallel execution remains around 20%, nearly collapsing to serial execution (Fig. 4). Balancing losses [6] and capacity limits [16] mitigate load skew but degrade accuracy; cloud-optimized schedulers [50] expect abundant DRAM and interfere with other experts on the edge. Asynchrony further worsens both issues. V2I devices upload models at different times, expanding the expert pool and diverging per-task activation sets. This leads to frequent cache reloads, high task-switch overhead, and heterogeneous retraining speeds. Schedulers designed for isolated objectives [3, 19, 33] cannot prevent reload overhead or capture time-varying, multi-task demands without expensive tuning. 2.3.2 Redundant Computations and I/O Overhead. Irregular MoE dynamic sparsity in V2I makes computation reuse inherently I/Obound. The working set of reusable activations (token features and expert outputs) frequently exceeds edge-GPU DRAM, forcing spills to external storage when concurrency grows. For instance, adapting five V-MoEs with batch size 500 generates >20 GB reusable activations per epoch, far beyond 10 GB DRAM of an RTX 3080, resulting in 12 GB disk traffic and ≥25s I/O latency, nearly cancelling the 35 s compute saved by reuse. Dynamic sparsity further produces irregular, short-burst access patterns that thrash caches and increase latency (Fig. 8a). Existing fast-lookup [22], reuse–accuracy trade-off [21], and selectivecaching systems [25] reduce redundant compute but rely on frequent external I/O or assume regular access, incompatible with expert-driven sparsity. 2.3.3 Turning Challenges into Opportunities. V-MoE co-adaptation breaks resource and knowledge isolation, revealing three opportunities that turn dynamic sparsity into a coordination signal rather than a competition/bottleneck. i) Cross-model resource multiplexing. Pooling experts across models amortizes kernel and memorymanagement overheads. Co-scheduling experts with complementary lifespans and dependencies reduces DRAM fragmentation and thread-block idling, improving parallelism without sacrificing accuracy. ii) Unified, DRAM-resident reuse cache. A shared cache enables

global prefetching and eviction decisions across models. Token reordering provides I/O-hiding prefetch that overlaps GPU compute with storage access, while importance-aware residency/eviction preserves high-value experts and avoids eviction conflicts. This keeps reuse effective even when working sets exceed device memory and suppresses I/O-induced latency spikes. iii) Flexible task interleaving without per-model context. Removing strict per-model context enables lightweight task switches: we exploit natural asynchrony in V2I system to interleave tasks while preloading inactive experts, cutting reload overhead and easing fairness-priority trade-offs. We realize them in AdaSprite via three mechanisms detailed next.

3

System Design

To address the challenges and integrate the opportunities, AdaSprite introduces a V-MoE co-adaptation service at the V2I edge. It coordinates concurrent adaptation jobs at both the computation and resource levels, meeting per-model accuracy-latency demands for open-world V2I applications.

3.1

Overview

As shown in Fig. 6, AdaSprite separates the inference phase from the adaptation phase. During inference, mobile/IoT devices (onvehicle, roadside, intersection) run local lightweight V-MoEs and transmit compressed features to the edge for multi-view fusion and downstream inference (vision projector + LLM decoder) (Sec. 2.1). During adaptation, mobile/IoT devices sample and upload frames (and metadata) to the edge on demand [71], where a full-capacity reference ViT produces supervision (features or labels). AdaSprite packages each model’s data and objectives into an adaptation job, merges the corresponding V-MoEs into a unified co-adaptation pool via MoE merging, and manages jobs in isolation-at-the-data but sharing-at-the-resource fashion for fine-grained monitoring and control. We follow the specification-based tuning method, i.e., adapting only the visual module and projector to ensure efficiency. AdaSprite optimizes co-adaptation via three core mechanisms that directly map to Challenges #1-#3 for large-scale data drifts: (i) DRAM-efficient sparse-expert parallelism (Sec. 3.2). Targeting Challenge #1 (fragmentation and load imbalance), AdaSprite employs lightweight dynamic programming to align expert lifespans across

AdaSprite: Resource-efficient Online Co-Adaptation for V2I Systems Under Large-scale Data Drifts

Figure 7: DRAM-efficient expert parallelism.

tasks and performs spatio-temporal co-scheduling with dynamic resource allocation. This shrinks DRAM fragmentation, smooths parallelism, and improves utilization without sacrificing accuracy. (ii) I/O-efficient expert computation reuse (Sec. 3.3). Addressing Challenge #2 (I/O-bound reuse), AdaSprite enables a shared DRAMresident expert cache for in-DRAM reuse across tasks, and uses I/O-hiding prefetch to overlap GPU compute with storage access. An importance-aware residency/eviction policy prioritizes high-leverage experts, mitigating conflicts and minimizing external I/O even when the working set exceeds device memory. (iii) Asynchrony-aware resource scheduling (Sec. 3.4). For Challenge #3 (asynchronous requests), AdaSprite adopts a twin-buffer scheduler with cross-task preemption: it interleaves services across buffers and preloads inactive experts during task switches, cutting reload overhead while balancing fairness and priority.

3.2

DRAM-efficient Expert Parallelism

Expert parallelism can accelerate V-MoE retraining, but on resourcelimited edge GPUs it is constrained by DRAM fragmentation (from dynamic sparsity) and barrier stalls (from load imbalance), as discussed in Sec. 2.3. Limits of Prior Reactive Methods. Previous MoE training systems [50] primarily focus on pretraining or single-model training to improve the throughput of individual models, while overlooking the efficient utilization of scarce resources. And existing memory optimization [64, 68] are fundamentally reactive. They intervene only after fragmentation or imbalance appears, adding unpredictable overhead and implicitly assuming expert activations are uncontrollable randomness. These arise from two structural mismatches: i) Lifespan vs. allocation. Transient intermediates from sparse experts occupy low addresses and retire early; later allocations rarely fit these holes, accumulating fragmentation. Heuristics (e.g., high-address placement [72], scaled computations [51]) partially help but risk accuracy or leave residual holes. ii) Resource vs. demand. Uniform slicing ignores heterogeneous expert costs, causing heavy experts to dominate slice completion time and inflate synchronization stalls.

MobiSys ’26, June 21–25, 2026, Cambridge, United Kingdom

Key Idea. Instead of reacting to symptoms, AdaSprite leverages shared context in modular/partially loaded components to proactively restructure execution. The complex mismatch collapses into two controllable dimensions: where experts co-execute (space) and when they complete (timing). • Spatial grouping (lifespan alignment). Experts pooled across models are partitioned into ordered time slices by grouping complementary live ranges and dependencies. This pre-allocates contiguous slots within a runtime-managed cache region and prevents irregular allocations from creating holes. • Temporal alignment (balance-aware co-scheduling). Within each slice, AdaSprite equalizes expert completion times via resourceaware scheduling, shrinking barrier stalls and smoothing parallelism under DRAM/GPU constraints. As shown in Fig. 7, spatial grouping (Sec. 3.2.1) removes most fragmentation before it forms, while temporal alignment (Sec. 3.2.2) eliminates synchronization bottlenecks during parallel execution. 3.2.1 Fragmentation-aware Expert Grouping. Spatial grouping must assemble experts that tightly fit DRAM and share compatible lifespans to avoid stragglers that stall synchronization. Random grouping leads to poor DRAM utilization and imbalance [43], while aligning experts with large workload gaps extends the wall-clock time of lighter ones. Finding temporally optimal groupings under token-dependent routing is NP-hard, and existing compiler/graph schedulers [12, 37, 42, 78] prioritize compute throughput but ignore edge DRAM constraints. To address this, AdaSprite employs fragmentation-aware expert grouping that combines fast per-expert DRAM estimation with a lightweight DP-based cross-task grouper, enabling efficient solutions to this coupled multi-objective problem. Fast per-expert DRAM estimator. We adopt a lightweight, lifespan-aware DRAM usage estimator to support online grouping. In addition to well-researched static DRAM 𝑀𝑠 [71], for expert 𝑒 with token count 𝑇 = 𝑏 · 𝑛𝑡 (batch 𝑏, tokens per sample 𝑛𝑡 ) and key dimension 𝑑𝑘 in a ViT-style attention block, the temporary footprint decomposes into 𝑀tmp (𝑒) = 𝑚𝑐 (𝑒) + 𝑚 𝑓 (𝑒), where 𝑚𝑐 (𝑒) captures compute-dependent buffers (e.g., Q /K /V projections and attention scores) and 𝑚 𝑓 (𝑒) aggregates function-call overheads (kernels, framework metadata) that are hardware/system-stable
and can be profiled offline. Concretely, 𝑚𝑐 (𝑒) ≈ 𝐵𝑝 𝜃 1 𝑇 𝑑𝑘 +𝜃 2 𝑇 2 , with 𝐵𝑝 the numeric precision (8/1/32-bit) and 𝜃 1, 𝜃 2 constants reflecting the implementation (queries/keys/values vs. score matrices). This estimator avoids irregular online tracing while preserving the key 𝑇 - and 𝑑𝑘 -scalings that dominate memory pressure. Cross-task expert grouping. We denote the estimated runtime (lifespan) as 𝑟𝑒 , predicted in Sec. 3.2.2. Given a candidate set E of experts eligible to co-run and server DRAM budget 𝑀𝑐 , seÍ (𝑒) + 𝑀𝑠 ≤ 𝑀𝑐 , (b) lect a slice 𝑆 ⊆ E that (a) respects 𝑒 ∈𝑆 𝑀 Í tmp (𝑒 )

maximizes DRAM utilization 𝑈 DRAM (𝑆) = 𝑒 ∈𝑆 𝑀𝑐tmp , and (c) minÍ imizes cross-slice total latency 𝐿(E) = 𝑆 ∈ E max𝑒 ∈𝑆 𝑟𝑒 . This is a bi-criteria knapsack with a makespan objective and is NP-hard. Unlike conventional knapsack formulations with one-shot packing and a single objective, our problem is slice-coupled and multiobjective. Greedily maximizing per-slice DRAM can create highlatency “tail” experts, increasing total latency across slices. To address this, we design a lightweight dynamic programming (DP) algorithm that jointly considers each expert’s temporary DRAM 𝑀

Lehao Wang† , Zhiwen Yu†,+,∗ , Sicong Liu†,∗ , Kefan Chen† , Fengmin Wu† , Bin Guo†

MobiSys ’26, June 21–25, 2026, Cambridge, United Kingdom

(a) Reuse without I/O optimization.

(b) Reuse with prefetch.

(c) Reuse with prefetch & residency.

Figure 8: Comparison of computation reuse methods.

3.3

Figure 9: Illustration of token prefetch and eviction.

usage and lifespan, while prioritizing lighter experts and biasing toward Shortest-Job-First [54]. This directly optimizes multi-slice latency with maximal DRAM utilization, rather than focusing solely on single-slice throughput or completion time. Formally, we define 𝑖 each expert’s temporary DRAM usage 𝑀𝑡𝑚𝑝 as both the item weight 𝑀𝑖

𝑤𝑖 and value 𝑣𝑖 = 𝑀𝑡𝑚𝑝 − 𝜂 ∗ 𝑟𝑒 , where 𝜂 is a coefficient to balance 𝑐 these two objectives, allowing for flexibility in different applications. The dynamic programming algorithm starts from the initial state 𝑑𝑝 [0] [0] (no experts selected, no DRAM used). The state transition equation 𝑑𝑝 [𝑖] [ 𝑗] = max(𝑑𝑝 [𝑖 − 1] [ 𝑗], 𝑑𝑝 [𝑖 − 1] [ 𝑗 − 𝑤𝑖 ] + 𝑣𝑖 ) is iteratively applied until 𝑑𝑝 [𝑁 ] [𝑀𝑐 − 𝑀𝑠] yields the optimal expert grouping for 𝑁 experts under available DRAM. The algorithm iteratively proceeds until all candidate experts in the layer are assigned to ordered time-slices. 3.2.2 Expert Lifespan-aware Aligning. After fragmentation-aware grouping, AdaSprite aligns expert lifespans by allocating GPU resources within each slice to minimize waiting time while preserving accuracy. The challenge lies in estimating heterogeneous experts’ resource demands (memory- or compute-bound) under dynamic MoE routing and tight, variable edge budgets. Existing learned latency predictors [71] or bound-driven profiling [30] perform poorly. Instead, we pre-profile each expert to record per-token latency and saturation points. A work coefficient is computed from token count and saturation, capturing the effective resource need. The controller then performs a fill-clamp–refill allocation: Seed each expert with its minimum required threads; Distribute remaining budget proportional to work coefficients so heavier experts catch up; Clamp saturated experts and redistribute leftover to others. This iterative procedure quickly balances latency across unsaturated experts, avoids waste beyond saturation, reduces long-tail delays versus uniform splitting, and improves GPU utilization. In practice, coefficients are refreshed via sliding-window probes with light smoothing, optionally priority-weighted, and integrated with twin-buffer scheduling (Sec. 3.4) to prewarm scheduled experts.

I/O-efficient Expert Computation Reuse

Co-adaptation gives AdaSprite a global view of memory and crosstask reuse, enabling I/O planning and cache management that hides external reads behind GPU computation and prioritizes DRAM for high-value items. The goal is to retain hot expert outputs, prefetch next-needed items, and avoid thrashing. In dynamically sparse VMoEs, reuse is governed by MoE routing and scenario semantics rather than fixed temporal/spatial locality. Existing prefetch/reuse systems [17, 21, 22] assume fixed graphs or steady streams, which fail under dynamic activations: expert firing varies batch to batch, token routing is irregular, and limited DRAM forces frequent evictions. Naive prefetching leads to misses, disk→DRAM stalls, and eviction conflicts, causing latency spikes that nullify reuse gains. Moreover, as reusable tokens grow, prefetch alone cannot fully overlap I/O with GPU work. For example, adapting three V-MoEs with 25% reusable tokens produces > 50s I/O latency. AdaSprite addresses this with I/O-hiding token prefetch (Sec. 3.3.1) and importance-aware token residency and eviction (Sec. 3.3.2), enabling efficient reuse under large-scale, non-stationary drifts (Fig. 8c). 3.3.1 I/O Latency-hiding Token Prefetch. Dynamic sparsity complicates layer-level token reuse, but cross-task token reuse can be predictable from expert activation probabilities, as tokens are assigned sequentially in V-MoEs. AdaSprite hides I/O latency by overlapping GPU computation with token prefetch: tokens are reordered so non-reusable ones are computed immediately, while reusable tokens are prefetched into DRAM. This ensures I/O occurs in parallel with computation, accelerating retraining without blocking GPU work. 3.3.2 Importance-aware Token Residency and Eviction. Existing I/O schedulers and hybrid computation methods interleave tasks but fail under parallel streaming due to isolated expert execution. In V-MoE retraining, partial output tokens can be reused across batches, yet they are typically evicted after backpropagation, forcing redundant prefetches. Intuitively, tokens with high reuse probability and hard-tohide I/O latency are more valuable and should remain resident in computation-reuse system to maximize I/O latency hiding. Thus, AdaSprite proposes importance-aware residency: tokens with high reuse probability and costly-to-hide I/O are retained in DRAM. Dif𝑖 ficulty of hiding I/O latency 𝑅𝑜𝑣𝑒𝑟𝑙𝑎𝑝 for token 𝑖 is measured as the ratio of reused tokens 𝑛𝑖𝑒𝑟𝑒𝑢𝑠𝑒 to computed tokens 𝑛𝑖 𝑐𝑜𝑚𝑝𝑢𝑡𝑒 for cor𝑖 responding expert 𝑒 in the current training batch. Higher 𝑅𝑜𝑣𝑒𝑟𝑙𝑎𝑝 means I/O is heavier relative to compute, and post-compute stalls for I/O latency become more probable, making it more beneficial to keep e’s reuse results resident in DRAM. Reuse probability 𝑃𝑟𝑒𝑢𝑠𝑒 is 𝑒

AdaSprite: Resource-efficient Online Co-Adaptation for V2I Systems Under Large-scale Data Drifts

MobiSys ’26, June 21–25, 2026, Cambridge, United Kingdom

predicted using a lightweight offline-trained neural network. This selectively retains high-value tokens, reducing redundant I/O and improving training efficiency (Fig. 8c), We collect pixel-level similarity of multiple image pairs and statistical features of experts’ outputs (e.g., mean, variance, maximum, sparsity) as data to train the model, using reuse success as labels. Therefore, the importance of output token 𝑖 under expert 𝑖 𝑖 𝑒 in the 𝑚-th training batch is defined as: 𝐼𝑖𝑒 = 𝑅𝑜𝑣𝑒𝑟𝑙𝑎𝑝 × 𝑃𝑟𝑒𝑢𝑠𝑒 = 𝑛𝑒𝑟𝑒𝑢𝑠𝑒

𝑖 𝑖 𝑃𝑟𝑒𝑢𝑠𝑒 × 𝑒𝑐𝑜𝑚𝑝𝑢𝑡𝑒 . For those involving cross-task experts, we extend 𝑛𝑖   𝑗 𝑛𝑖 𝑟𝑒𝑢𝑠𝑒 𝑖 the importance to: 𝐼𝑖 = max1≤ 𝑗 ≤𝑛 𝑃𝑟𝑒𝑢𝑠𝑒 × 𝑗𝑐𝑜𝑚𝑝𝑢𝑡𝑒 . After each 𝑛𝑖

batch’s backpropagation, output tokens with an importance score above a threshold 𝜆 are retained, while others are evicted. However, resident output tokens are not always reused in the next batch. When successfully reused, they reduce system latency, but if not, they occupy valuable DRAM, adding overhead. To manage this, we periodically evict obsolete resident output tokens to avoid unnecessary DRAM consumption, as shown in Fig. 9. Since one reusable output token can correspond to cross-task experts, eviction risks conflicts. To prevent this, we place resident outputs in a dedicated runtimemanaged cache region and map them to a contiguous logical buffer space. Resident output tokens are placed in DRAM from low to high addresses based on the execution order of their last corresponding experts 𝑒 𝑛 , ensuring that those more likely to be evicted are positioned at the boundary to avoid fragmentation. When the 𝑖 resident output token 𝑇𝑟𝑒𝑠𝑖𝑑𝑒𝑛𝑡 is reused by expert 𝑒𝑖𝑗 , it is moved to its corresponding sequential address 𝑎𝑑𝑑𝑟𝑒𝑗𝑖 . After all experts 𝑖 {𝑒𝑖1, 𝑒𝑖2, ..., 𝑒𝑖𝑛 } associated with the resident output token 𝑇𝑟𝑒𝑠𝑖𝑑𝑒𝑛𝑡 finish execution, it is evicted from DRAM. This process repeats for each training batch, maintaining efficient memory management.

3.4

Asynchronous Resource Scheduling

AdaSprite decomposes parameter updates into device-specific retraining jobs and schedules them under GPU time-division multiplexing to track per-device adaptation gains. Efficient scheduling is critical under the large-scale, non-stationary drifts. Prior singlebuffer schedulers serialize arrivals in only one pipeline, causing head-of-line blocking and high task-switch overhead [3, 19, 33]. To overcome this, AdaSprite uses a twin-buffer scheduler, i.e., asynchronous requests are separated into two buffers, and slices are interleaved across buffers. Dynamic estimates (Sec. 3.4.2) enable sparsity-aware cooperative scheduling, hiding switch costs and converting serialized conflicts into parallel, resource-efficient execution (Sec. 3.4.1). 3.4.1 Twin-Buffer Scheduler. We observe that i) task requirements reduce to two objectives—avoiding starvation from imbalanced updates and maximizing accuracy within latency constraints; ii) retraining tasks can exploit a two-tier cross-task GPU preemption [23], leveraging MoE sparsity to preload non-overlapping experts before task switches, reducing overhead. Based on this, AdaSprite introduces a twin-buffer scheduler (Fig. 10) over black-box assumption, applicable to general asynchronous tasks. Unlike generic multi-level queues, it exploits VMoE structure and expert overlap while jointly considering task

Figure 10: Illustration of Resource Scheduling.

demands and system operations. First, buffer division tasks with accuracy and predicted accuracy gain below the lower threshold 𝛼 and Δ are placed in 𝑏𝑢 𝑓 𝑓 𝑒𝑟 𝛼 , while others go into 𝑏𝑢 𝑓 𝑓 𝑒𝑟 𝛽 . Once a task’s accuracy exceeds 𝛽, it is considered complete and AdaSprite returns the model. Second, cross-task GPU sharing. The buffers function as foreground/background pipelines. Scheduling addresses task prioritization for GPU cycles, resource allocation per task, and cooperation between buffers to maximize parallelism and minimize switch overhead. This transforms sparse, asynchronous MoE activations into cooperative scheduling opportunities, improving throughput and lowering latency. • For tasks in 𝑏𝑢 𝑓 𝑓 𝑒𝑟 𝛼 , the goal is to bring all tasks in large-scale drifts to the performance threshold 𝛼 quickly, without needing precise latency predictions. We apply the Shortest-Job-First principle [14], which only requires knowing the time order of tasks reaching 𝛼, and serve tasks for one epoch in a time-slice rotation. The Online prediction of AGE monitors each task’s epoch-accuracy relationship to refine the scheduling order. By adjusting based on actual completion time, we prioritize tasks from shortest to longest, minimizing the total time for all tasks to reach 𝛼. To avoid blocking, we enforce a maximum GPU usage time 𝜏, switching tasks if their accuracy does not reach 𝛼 within this limit. • For tasks in 𝑏𝑢 𝑓 𝑓 𝑒𝑟 𝛽 , the challenge is maximizing accuracy gains under latency constraints, which is an NP-hard problem. Our key insight is that allocating GPU cycles to the task with the fastest accuracy improvement offers an effective heuristic. Therefore, we use the online prediction of AGE (see Sec. 3.4.2) to profile gain per epoch for tasks in 𝑏𝑢 𝑓 𝑓 𝑒𝑟 𝛽 , then select the task with the fastest accuracy improvement for each GPU cycle until the latency constraints are reached. • To facilitate cooperation between the two buffers, we employ an asynchronous pipeline, with 𝑏𝑢 𝑓 𝑓 𝑒𝑟 𝛽 assigned to high-priority streams and 𝑏𝑢 𝑓 𝑓 𝑒𝑟 𝛼 to low-priority streams. AdaSprite prioritizes tasks from 𝑏𝑢 𝑓 𝑓 𝑒𝑟 𝛽 , and before GPU cycles for 𝑏𝑢 𝑓 𝑓 𝑒𝑟 𝛽 end, AdaSprite clears and reloads inactive experts required for the next tasks from 𝑏𝑢 𝑓 𝑓 𝑒𝑟 𝛼 . When the GPU cycle ends, tasks switch seamlessly, requiring only the change of remaining experts’ states and preventing idle GPU time. Once the next task in 𝑏𝑢 𝑓 𝑓 𝑒𝑟 𝛽 is ready and 𝑏𝑢 𝑓 𝑓 𝑒𝑟 𝛼 has saved its computation files, 𝑏𝑢 𝑓 𝑓 𝑒𝑟 𝛽 preempts resources for service with the same task switching strategy as above.

MobiSys ’26, June 21–25, 2026, Cambridge, United Kingdom

Lehao Wang† , Zhiwen Yu†,+,∗ , Sicong Liu†,∗ , Kefan Chen† , Fengmin Wu† , Bin Guo†

py3nvml, it periodically polls coarse-grained device signals, including available DRAM (𝑀𝑐 ) and aggregate utilization. These signals provide auxiliary feedback for admission control and memorypressure awareness, while fine-grained scheduling is driven by AdaSprite’s internal runtime state. CARLA Setup. We simulate large-scale V2I traffic drifts using CARLA [13] (Town03 map, diverse weather, 150 autopilot vehicles, 38 cameras: 20 on-vehicle, 18 fixed at 2–4m). Synchronous mode captures downsampled frames at 5Hz. The code for setup and sampling is available at https://anonymous.4open.science/r/CARLA_ setup_sampling/. Figure 11: Example scenes in TrafficSim and CampReal. 3.4.2 Dynamic Scheduler Inputs. Scheduler requires accuracy gain per epoch (AGE) to prioritize slices. A key simplification: with a fixed V-MoE architecture and update rule, varying resource schedules (e.g., expert parallelism, computation reuse) changes wall-clock time but not the accuracy-vs.-epoch trajectory. AdaSprite exploits this in epoch space, independent of scheduling decisions. It maintains an online convergence fit of accuracy using a non-negative least squares (NNLS) solver [60]. Low-cost early-stopping probes on small data subsets [65] yield near-term AGE estimates with negligible overhead (< 1ms). These AGE predictions feed the twinbuffer scheduler, enabling informed foreground and background task prioritization.

4

System Implementation

AdaSprite adopts a microservice architecture for seamless integration with existing V2I frameworks. High-performance gRPC [18] handles inter-service communication, while a lightweight Flask server provides RESTful APIs for management and monitoring. RabbitMQ [5] manages asynchronous task queues, decoupling services and improving resilience to workload spikes and moderate network perturbations. Deployment only requires running the co-adaptation microservice on the edge, with devices following a unified model-transfer and data-upload protocol; the existing inference pipeline and V2I stack remain unchanged. AdaSprite primarily focuses on optimizing resource utilization at the weak edge. Accordingly, our system is orthogonal to prior work on adaptation triggers [26] and network optimization [46], while remaining compatible with them. Parallelism. We deploy AdaSprite under NVIDIA MPS, allowing multiple expert processes to share GPU hardware with minimal context-switch overhead. CUDA Streams overlap data loading, kernel execution, and data movement. Synchronization is enforced only at slice boundaries to match AdaSprite’s slice-level execution. GPU Memory (DRAM) Management. We use Unified Memory via cudaMallocManaged to simplify CPU-GPU shared access and overlap transfer with execution. Reusable data are staged in managed buffers and asynchronously prefetched into GPU DRAM via cudaMemPrefetchAsync. A custom memory pool recycles frequently used buffers and cache blocks to reduce allocation overhead. The contiguous DRAM region in Sec. 3 refers to a runtime-managed logical cache layout, rather than physical placement. Asynchronous Performance Monitor. We run a lightweight monitor in a separate process using multiprocessing. Through

5 Evaluation 5.1 Experimental Setup AdaSprite focuses on computational tasks related to adaptation in vehicle-infrastructure collaboration systems, and is evaluated with reliable communication and data alignment. Dataset and Models. We test AdaSprite on five vision-QA (VQA) tasks in autonomous driving, i.e., existence (Exi.), counting (Cou.), query-object (Obj.), query-status (Sta.), and comparison (Com.). Due to the lack of public VQA datasets for V2I collaboration under large-scale continuous traffic and asynchronous data arrival, we use two self-collected datasets. CampReal, a 2-week real-world dataset with 1280×720@30FPS videos from six RGB cameras on roadside and AMOVLAB R300 vehicle, capturing traffic in campus from morning to night. TrafficSim, a CARLA-based simulated dataset with more than 10 road types, 150 vehicles, 38 cameras (vehicle- and roadside-mounted), covering tens of task combinations over 100 hours of continuous traffic, with asynchronous arrivals. It spans 4 weather conditions: sunny (𝐷 1 ), cloudy (𝐷 2 ), rainy (𝐷 3 ), and snowy (𝐷 4 ). Fig. 11 shows example scenes from both datasets. We employ V-MoE as the visual module deployed on devices and distill four compressed versions (V-MoE-85M/-65M/-43M/-22M). To perform QA tasks at the edge, we adopt pretrained decoder-only LLMs, including OPT [80] with parameter sizes from 1.3B to 2.7B and BLOOM [4]. For answer generation, we format prompts as “question:Q</s>answer:A</s>”, where “</s>” denotes the end-ofsequence (EOS) token provided by the OPT and BLOOM tokenizers and embedded during pretraining. In addition, we use a well-trained ViT as the teacher model for adaptation and edge performance comparison. Mobile and IoT Devices. We use 20 mobile/embedded IoT devices across four platforms: Jetson Nano (𝐸 1 ), Jetson Xavier NX (𝐸 2 ), Jetson Orin Nano (𝐸 3 ), and Jetson AGX Xavier (𝐸 4 ), all running V-MoE inference on real-time video streams. Two edge servers are equipped with two RTX 3080 GPUs (10 GB DRAM each) and one RTX 3090 GPU (24 GB DRAM). Baselines: We compare AdaSprite with four categories of representative adaptation methods: • No adaptation: A pre-trained V-MoE without adaptation. • Isolated on-device model adaptation: - Tent [69]: selectively updates normalization layers of V-MoEs through entropy minimization for efficient adaptation. - EATA [53]: samples local data and updates part of layers to fine-tune the V-MoE efficiently. • Edge-assisted isolated model adaptation:

AdaSprite: Resource-efficient Online Co-Adaptation for V2I Systems Under Large-scale Data Drifts

MobiSys ’26, June 21–25, 2026, Cambridge, United Kingdom

Table 3: Comparison in accuracy-latency trade-off. Exi.

Accuracy gain (%) Cou. Obj. Sta. Com.

Avg.

Avg. latency (s)

OPT-2.7B

Tent [69] EATA [53] FedAvg [45] AMS [34] RECL [33] AdaMV-MoE [6] AdaSprite

3.7 3.9 7.4 3.7 3.1 6.3 12.8

21.1 21.6 15.2 26.1 41.9 41.1 48.3

29.9 30.6 26.8 31.9 60.7 43.6 52.5

10.7 11.0 10.1 19.7 16.8 21.1 26.5

8.8 9.3 9.1 12.3 10.1 12.8 18.7

14.8 15.3 13.7 18.7 26.5 25.0 31.8

394 390 411 386 263 277 218

OPT-1.3B

Tent [69] EATA [53] FedAvg [45] AMS [34] RECL [33] AdaMV-MoE [6] AdaSprite

5.4 5.3 10.5 5.1 4.8 9.6 12.4

28.2 29.5 25.8 31.1 47.8 46.5 52.6

39.5 40.6 37.6 41.2 68.8 54.2 61.7

14.8 14.9 14.2 27.1 23.6 29.2 34.8

12.7 13.2 13.5 16.8 12.8 18.1 23.3

20.1 20.7 20.3 24.3 31.6 31.5 37.0

394 390 411 331 228 236 193

BLOOM-1B1

Tent [69] EATA [53] FedAvg [45] AMS [34] RECL [33] AdaMV-MoE [6] AdaSprite

3.3 3.6 7.1 2.3 2.2 5.6 10.7

17.1 17.9 12.9 21.7 35.5 37.2 39.4

22.3 23.0 19.7 23.2 53.8 37.7 46.2

7.5 8.1 6.9 12.3 10.1 14.3 21.3

6.6 7.8 7.9 8.2 5.0 7.7 14.7

11.4 12.1 10.9 13.5 21.3 20.5 26.5

394 390 411 263 194 209 173

Methods & LLM

- Adaptive Model Streaming (AMS) [34]: uses a round-robin GPU sharing at edge server across multiple tasks. - RECL [33]: reuses models in history. • Edge-assisted model co-adaptation: - FoggyCache [21]: reuses computation across models without I/O latency-hiding optimization. - FedAvg [45]: enables collaboration between different task models through model aggregation. • Edge-assisted MoE-based co-adaptation: - MoE-SE: sequentially executes each layer. - AdaMV-MoE [6]: balances loads using auxiliary loss. We measure accuracy using the exact match ratio against the teacher model [3, 33], and define adaptation latency as the extra time beyond on-device inference for Tent, EATA, and FedAvg. Additionally, we consider two V2I user-experience metrics: SLO attainment: fraction of adaptation tasks achieving both ≥10% accuracy gain and ≤200s latency; Throughput: rate of tasks meeting their SLOs.

5.2

Performance Comparison

We evaluate AdaSprite against six baselines, i.e., Tent [69], EATA [53], FedAvg [45], AMS [34], RECL [33], and AdaMV-MoE [6], over three LLMs (e.g., OPT-2.7B/1.3B and BLOOM-1B1), focusing on the accuracy-latency trade-off. Using five V-MoE models on different devices with 34Mbps video streams in TrafficSim (𝐷 2 ), AdaSprite achieves the best trade-off, improving accuracy by up to 2.4× and reducing latency by up to 57.9% through parallel execution and I/Ohiding reuse. Furthermore, it surpasses SOTA methods, increasing SLO attainment by 1.6× and throughput by 2.1× via cross-task coadaptation and a twin-buffer scheduler that maintains tail accuracy and latency guarantees.

5.3

Scalability to Task Concurrency

We evaluate AdaSprite on 1∼12 concurrent adaptation tasks using OPT-2.7B on TrafficSim (𝐷 2 ), as shown in Fig. 12. First, latency rises with task count for all baselines except EATA [53]. AdaSprite achieves the lowest latency up to 8 tasks, reducing it by up to 56.5% thanks to DRAM-efficient sparse-expert parallelism and I/O-aware

Figure 12: Latency comparison across task amounts.

Figure 13: Resource utilization comparison.

Figure 14: DRAM fragmentation comparison.

computation reuse, which exploit cross-task redundancy. Second, while isolated adaptations saturate around 6 tasks, AdaSprite handles up to 17 tasks simultaneously via co-adaptation and efficient off-chip storage. Third, by tuning accuracy thresholds and maximum GPU rounds (𝜏), it can trade concurrency and accuracy for lower latency. For example, limiting to 4 concurrent tasks with partial data achieves second-level adaptation latency with 15.04% average accuracy gain.

5.4

Understanding Improvement

Each component is evaluated in isolation by replacing it while keeping the rest of AdaSprite intact. 5.4.1 Benefit of DRAM-efficient Sparse Expert Parallelism. We compare AdaSprite with other parallel/serial execution methods using OPT-2.7B on dataset 𝐷 3 . Fig. 13 shows cumulative GPU utilization, Fig. 14 compares DRAM fragmentation rates, and Fig. 15 presents accuracy gains. First, AdaSprite maintains superior GPU utilization (mostly >45% and rarely <20%) by balancing expert loads and reducing stalls. Second, average DRAM fragmentation is reduced by up to 61.9% via well-aligned execution slices. Third, AdaSprite outperforms AdaMV-MoE in accuracy, as coupling experts across models increases complexity and lowers on-device performance. Overhead: Expert grouping and resource allocation add 1̃.7 ms per mini-batch. Extreme case: On expert-group failures, fallback to aligned random grouping preserves feasibility while still reducing fragmentation by 42.7%. 5.4.2 Benefit of I/O-efficient Computation Reuse. We compare AdaSprite with computation reuse methods over 𝐷 2 . Fig. 16 shows that AdaSprite achieves the lowest latency, reducing it up to 40.9% compared to FoggyCache. Compared with FoggyCache, AdaSprite cuts I/O wait latency by 86.9% while reading >30 GB of reusable computation from disk, which is effectively hidden by GPU computing. Overhead: I/O-hiding prefetching and importance-aware token residency add around 1.4 ms per mini-batch and use at most 150 MB of GPU memory for buffering. Extreme case: On reuseprediction errors, AdaSprite periodically evicts long-idle tokens to prevent blocking.

MobiSys ’26, June 21–25, 2026, Cambridge, United Kingdom

Figure 15: Comparison of load-balancing.

Figure 16: Impact of computation reuse.

Figure 17: Impact of twin-buffer resource scheduling.

Lehao Wang† , Zhiwen Yu†,+,∗ , Sicong Liu†,∗ , Kefan Chen† , Fengmin Wu† , Bin Guo†

Figure 18: Impact of threshold in scheduler.

(a) Generalizing to various V-MoEs

Figure 19: Impact of residency threshold.

(b) AGE prediction performance

Figure 20: Generalization of AdaSprite. 5.4.3 Benefits of Asynchronous Resource Scheduling. We compare AdaSprite’s accuracy gains with different scheduling strategies, i.e., AMS (round-robin) and RECL (time-slice), on TrafficSim (𝐷 4 ) with OPT-2.7B. As shown in Fig. 17, AdaSprite achieves the best accuracy-stability trade-off, with 27.7% average and 18.2% minimum accuracy gains. Moreover, AdaSprite boosts SLO attainment by ≥2.5× and throughput by ≥3.2×. Its twin-buffer scheduler applies buffer-specific policies to maximize accuracy gains, avoid imbalanced updates or starvation, and enforce tail accuracy and latency bounds. Overhead: Evaluating 1,000 runs of AGE shows negligible overhead (<1 ms). Extreme case: Facing AGE estimate errors, the scheduler falls back to round-robin and approximate shortjob-first behavior. This prevents starvation and long-term resource monopolization, still achieving a 20.8% accuracy gain.

5.5

Micro-benchmark

5.5.1 Parameter Sensitivity of Scheduler Threshold 𝛼 and Residency Threshold 𝜆. Across four TrafficSim scenarios, Fig. 18 and 19 show average performance under varying thresholds. AdaSprite is generally robust to them. For example, as for Exi., sweeping 𝛼 from 0.3∼0.5 shows that smaller values reduce mean accuracy, while larger values improve tail accuracy with higher latency. The choice of 𝛼 can be tuned based on application requirements. For 𝜆, values above 0.55 saturate the hiding rate, but larger thresholds can increase evictions. Therefore, we set 𝜆 = 0.55 as a balanced default. 5.5.2 Performance across Diverse Network Bandwidths. We test AdaSprite across five network bandwidths using 10 Obj. tasks on TrafficSim 𝐷 4 (see Fig. 21) to assess its robustness under unstable network conditions. As bandwidth decreases, network latency increases, resulting in higher latency and lower average accuracy. Nonetheless, AdaSprite consistently enhances accuracy by at least 50.1%, demonstrating generalization across varying network conditions. 5.5.3 Generalizing to Various V-MoEs. We demonstrate AdaSprite’s ability to robustly calibrate V-MoEs with different sizes deployed on IoT devices (𝐸 1 , 𝐸 2 , 𝐸 3 , 𝐸 4 ). We evaluate 4 V-MoEs with TrafficSim (𝐷 2 ), shown in Fig. 20a. All V-MoEs achieve significant accuracy gains with AdaSprite, with at least a 33% average improvement.

(a) Network latency

(b) Average accuracy

Figure 21: Generalization of network bandwidths. 5.5.4 Performance of AGE Prediction Method. We evaluate the accuracy gain per epoch (AGE) prediction method from Sec. 3.4. Using 8 video segments from 𝐷 4 , we test the errors of predicted AGE for Obj., as shown in Fig. 20b. The error rates remain below 13.3%, which is acceptable.

5.6

Case Study

We test AdaSprite in an urban VLM-based (OPT-2.7B) V2I application, comparing it with five baselines using a hybrid simulator and real-world setup. In simulator, we model urban traffic (𝐷 1 ) in CARLA, covering tens of concurrent model combinations and 10+ road types, with 20 on-vehicle cameras and 18 roadside cameras (Fig. 22a). We further validate generalization on the two-week real day-by-day data (Fig. 22b). As shown in Table 4, AdaSprite achieves the highest accuracy across four tasks, yielding overall gains of 30.0% (simulation) and 36.1% (real-world) over No adaptation, demonstrating robust performance in dynamic mobile environments. While RECL performs well on the Obj. task, its accuracy-focused scheduler induces starvation in other tasks, causing severe imbalance. AdaSprite consistently outperforms RECL across all other tasks, boosting SLO attainment (≥10% accuracy gain and <350s latency) by 3.1× and throughput by 4.3×. There are two key factors: i) Co-adaptation mechanism optimizes V-MoE convergence and task concurrency, enhancing accuracy gain under limited latency at resource-constrained edge. ii) Parallel optimization and I/O-hiding computation reuse exploit V-MoE’s dynamic sparsity, reducing adaptation latency and runtime even for low-accuracy models.

AdaSprite: Resource-efficient Online Co-Adaptation for V2I Systems Under Large-scale Data Drifts

MobiSys ’26, June 21–25, 2026, Cambridge, United Kingdom

non-monotonic performance [24]. Specification-based tuning selectively updates relevant parameters based on specific data/tasks, keeping others frozen. We follow this to allow efficient fine-tuning while maintaining accuracy. (a) Simulator

(b) Real data collection

Figure 22: Illustration of case study. Table 4: Accuracy comparison in continuous traffic. Methods

6

Metric

Tasks

No adaptation

Tent

AMS

RECL

AdaMV-MoE

AdaSprite

Average accuracy (%)

Exi. (Sim/Real) Cou. (Sim/Real) Obj. (Sim/Real) Sta. (Sim/Real) Com. (Sim/Real)

39.5/32.8 14.2/9.1 20.5/13.2 33.7/25.6 61.3/49.5

41.5/33.8 15.1/10.3 23.1/15.6 35.7/27.8 63.7/52.0

42.1/34.7 16.6/11.9 26.6/17.7 39.9/31.7 64.3/53.1

40.3/33.4 14.6/9.9 33.2/23.1 44.2/34.7 63.4/51.8

44.4/35.6 15.2/11.4 27.4/18.6 41.6/33.6 66.9/52.7

50.2/40.1 20.4/15.9 31.1/23.0 44.7/36.7 72.9/61.2

Related Work

Online Adaptation Methods. Online adaptation addresses data shifts in real-time vision systems. Existing methods include ondevice [26, 52, 53] and server-assisted adaptation [3, 33, 71, 75]. Ondevice adaptation fine-tunes DNNs using local data during inference. However, the high adaptation complexity (e.g., a ViT-Base requires over 1.2 GB of peak memory) prevents adaptation on inferenceoriented hardware. Additionally, they focus on isolated adaptation, limiting collaboration. While federated learning helps [57], object heterogeneity in V2I can result in accuracy loss [35, 52]. Server-assisted adaptation leverages edge/cloud resources, allowing mobile/IoT devices to prioritize inference without interference. Research primarily focuses on maximizing accuracy under latency constraints [3, 33, 36], using techniques like data resampling [34, 49], adaptive triggers [36, 75], sparse updating [71], and latency optimization with task scheduling [33] and resource allocation [3]. However, most methods are task-isolated and collaboration across tasks is less explored. In contrast, AdaSprite uses edge server-assisted adaptation to enable cross-device V-MoE co-adaptation for VLM-based system, ensuring resource efficiency. Edge-assisted Multi-Task Learning. Co-adaptation is similar in form and implementation to the widely-researched multi-task learning. Multi-task learning aiming to construct a unified model improves data and resource efficiency through parameter sharing and knowledge integration. It has seen applications in edge computing, such as blood glucose modeling [20] and depression detection [40]. Existing methods focus on modeling task relationships or optimizing joint objectives to maximize benefits, using relationship modeling [65, 81], adaptive task learning rates [7], dynamic parameter sharing [48, 66], and task gradient balancing [32, 77]. Unlike them, AdaSprite does not aim to obtain a unified model handling multiple tasks simultaneously, but to efficiently fine-tune V-MoEs separately deployed on devices. Efficient ViT Fine-tuning Techniques. Efficient fine-tuning methods for ViT-related models include additional module tuning [61, 76], prompt-based [27, 67, 70], and specification-based tuning [2, 24]. Additional module tuning injects small neural modules or parallel networks into layers, tuning only them for adaptation. However, this increases ViT complexity [24]. Prompt-based tuning introduces learnable parameters [38] or prefixes [39] into embedding space or input data, which causes slow convergence [11] with

7

Conclusion

In this paper, we present AdaSprite, a resource-efficient V-MoE co-adaptation system for large-scale VLM-based V2I perception. By leveraging expert lifespan alignment, I/O-hiding computation reuse, and a twin-buffer scheduler, AdaSprite turns the challenges of isolated adaptation into co-adaptation opportunities. Evaluations across diverse scenarios show substantial accuracy and latency gains over state-of-the-art methods, demonstrating a robust and scalable solution for large-scale mobile applications. Although in V2I applications, real-time inference and information broadcasting enabled by cooperative perception can help address emergencies, thereby complementing adaptation, other applications struggle to handle such situations. While AdaSprite allows accuracyconcurrency trade-offs for second-level adaptation, communication overhead still limits real-time operation. Rapid cross-device knowledge sharing offers a promising avenue for complementing slower retraining, which we plan to explore in future work.

Acknowledgments We sincerely thank our anonymous shepherd and all reviewers for their valuable feedback. This work is supported by National Key R&D Program of China (No. 2024YFB4505502), Young Scientists Fund (Category B) of the National Natural Science Foundation of China (No. 62522215), and National Natural Science Foundation of China (No. 62472354).

References [1] Jinze Bai, Shuai Bai, Shusheng Yang, Shijie Wang, Sinan Tan, Peng Wang, Junyang Lin, Chang Zhou, and Jingren Zhou. 2023. Qwen-VL: A Versatile VisionLanguage Model for Understanding, Localization, Text Reading, and Beyond. arXiv:2308.12966 [cs.CV] https://arxiv.org/abs/2308.12966 [2] Samyadeep Basu, Shell Hu, Daniela Massiceti, and Soheil Feizi. 2024. Strong Baselines for Parameter-Efficient Few-Shot Fine-Tuning. In Proceedings of AAAI, Vol. 38. 11024–11031. [3] Romil Bhardwaj, Zhengxu Xia, Ganesh Ananthanarayanan, Junchen Jiang, Yuanchao Shu, Nikolaos Karianakis, Kevin Hsieh, Paramvir Bahl, and Ion Stoica. 2022. Ekya: Continuous learning of video analytics models on edge compute servers. In Proceedings of NSDI. 119–135. [4] BigScience. 2023. BLOOM. https://huggingface.co/bigscience/bloom. (Accessed on 01/09/2025). [5] Broadcom. 2025. RabbitMQ. https://www.rabbitmq.com/. (Accessed on 04/12/2025). [6] Tianlong Chen, Xuxi Chen, Xianzhi Du, Abdullah Rashwan, Fan Yang, Huizhong Chen, Zhangyang Wang, and Yeqing Li. 2023. Adamv-moe: Adaptive multi-task vision mixture-of-experts. In Proceedings of ICCV. 17346–17357. [7] Zhao Chen, Vijay Badrinarayanan, Chen-Yu Lee, and Andrew Rabinovich. 2018. Gradnorm: Gradient normalization for adaptive loss balancing in deep multitask networks. In Proceedings of ICML. PMLR, 794–803. [8] Zitian Chen, Yikang Shen, Mingyu Ding, Zhenfang Chen, Hengshuang Zhao, Erik G Learned-Miller, and Chuang Gan. 2023. Mod-squad: Designing mixtures of experts as modular multi-task learners. In Proceedings of CVPR. 11828–11837. [9] Ziming Chen, Yifeng Shi, and Jinrang Jia. 2023. Transiff: An instance-level feature fusion framework for vehicle-infrastructure cooperative 3d detection with transformers. In Proceedings of the IEEE/CVF International Conference on Computer Vision. 18205–18214. [10] Jiaxun Cui, Hang Qiu, Dian Chen, Peter Stone, and Yuke Zhu. 2022. Coopernaut: End-to-end driving with cooperative perception for networked vehicles. In Proceedings of CVPR. 17252–17262. [11] Ning Ding, Yujia Qin, Guang Yang, Fuchao Wei, Zonghan Yang, Yusheng Su, Shengding Hu, Yulin Chen, Chi-Min Chan, Weize Chen, et al. 2022. Delta tuning:

MobiSys ’26, June 21–25, 2026, Cambridge, United Kingdom

Lehao Wang† , Zhiwen Yu†,+,∗ , Sicong Liu†,∗ , Kefan Chen† , Fengmin Wu† , Bin Guo†

A comprehensive study of parameter efficient methods for pre-trained language models. arXiv preprint arXiv:2203.06904 (2022). [12] Yaoyao Ding, Ligeng Zhu, Zhihao Jia, Gennady Pekhimenko, and Song Han. 2021. Ios: Inter-operator scheduler for cnn acceleration. Proceedings of MLSys 3 (2021), 167–180. [13] Alexey Dosovitskiy, German Ros, Felipe Codevilla, Antonio Lopez, and Vladlen Koltun. 2017. CARLA: An open urban driving simulator. In Proceedings of CORL. PMLR, 1–16. [14] Samir Elmougy, Shahenda Sarhan, and Manar Joundy. 2017. A novel hybrid of Shortest job first and round Robin with dynamic variable quantum time task scheduling technique. Journal of Cloud computing 6 (2017), 1–12. [15] Cheng Fang, Sicong Liu, Zimu Zhou, Bin Guo, Jiaqi Tang, Ke Ma, and Zhiwen Yu. 2024. AdaShadow: Responsive Test-time Model Adaptation in Non-stationary Mobile Environments. In Proceedings of the 22nd ACM Conference on Embedded Networked Sensor Systems. 295–308. [16] William Fedus, Barret Zoph, and Noam Shazeer. 2022. Switch transformers: Scaling to trillion parameter models with simple and efficient sparsity. Journal of Machine Learning Research 23, 120 (2022), 1–39. [17] Bin Gao, Zhuomin He, Puru Sharma, Qingxuan Kang, Djordje Jevdjic, Junbo Deng, Xingkun Yang, Zhou Yu, and Pengfei Zuo. 2024. AttentionStore: Costeffective Attention Reuse across Multi-turn Conversations in Large Language Model Serving. arXiv preprint arXiv:2403.19708 (2024). [18] gRPC Authors. 2025. gRPC. https://grpc.io/. (Accessed on 04/12/2025). [19] Rong Gu, Yuquan Chen, Shuai Liu, Haipeng Dai, Guihai Chen, Kai Zhang, Yang Che, and Yihua Huang. 2021. Liquid: Intelligent resource estimation and networkefficient scheduling for deep learning jobs on distributed GPU clusters. IEEE Transactions on Parallel and Distributed Systems 33, 11 (2021), 2808–2820. [20] Weixi Gu, Yuxun Zhou, Zimu Zhou, Xi Liu, Han Zou, Pei Zhang, Costas J Spanos, and Lin Zhang. 2017. Sugarmate: Non-intrusive blood glucose monitoring with smartphones. Proceedings of IMWUT 1, 3 (2017), 1–27. [21] Peizhen Guo, Bo Hu, Rui Li, and Wenjun Hu. 2018. Foggycache: Cross-device approximate computation reuse. In Proceedings of MobiCom. 19–34. [22] Peizhen Guo and Wenjun Hu. 2018. Potluck: Cross-application approximate deduplication for computation-intensive mobile applications. In Proceedings of ASPLOS. 271–284. [23] Lixiang Han, Zimu Zhou, and Zhenjiang Li. 2024. Pantheon: Preemptible MultiDNN Inference on Mobile Edge GPUs. In Proceedings of MobiSys. 465–478. [24] Edward J Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. 2021. Lora: Low-rank adaptation of large language models. arXiv preprint arXiv:2106.09685 (2021). [25] Kezhao Huang, Haitian Jiang, Minjie Wang, Guangxuan Xiao, David Wipf, Xiang Song, Quan Gan, Zengfeng Huang, Jidong Zhai, and Zheng Zhang. 2024. FreshGNN: Reducing Memory Access via Stable Historical Embeddings for Graph Neural Network Training. Proceedings of VLDB 17, 6 (2024), 1473–1486. [26] Kai Huang, Boyuan Yang, and Wei Gao. 2023. Elastictrainer: Speeding up ondevice training with runtime elastic tensor selection. In Proceedings of the 21st Annual International Conference on Mobile Systems, Applications and Services. 56–69. [27] Qidong Huang, Xiaoyi Dong, Dongdong Chen, Weiming Zhang, Feifei Wang, Gang Hua, and Nenghai Yu. 2023. Diversity-aware meta visual prompting. In Proceedings of CVPR. 10878–10887. [28] Richard L Hudson and J Eliot B Moss. 2001. Sapphire: Copying GC without stopping the world. In Proceedings of JGI. 48–57. [29] Kanishk Jain, Varun Chhangani, Amogh Tiwari, K Madhava Krishna, and Vineet Gandhi. 2022. Ground then navigate: Language-guided navigation in dynamic scenes. arXiv preprint arXiv:2209.11972 (2022). [30] Fucheng Jia, Deyu Zhang, Ting Cao, Shiqi Jiang, Yunxin Liu, Ju Ren, and Yaoxue Zhang. 2022. CoDL: efficient CPU-GPU co-execution for deep learning inference on mobile devices.. In MobiSys, Vol. 22. 209–221. [31] Caihong Kai, Hao Zhou, Yibo Yi, and Wei Huang. 2020. Collaborative cloud-edgeend task offloading in mobile-edge computing networks with limited communication capability. IEEE Transactions on Cognitive Communications and Networking 7, 2 (2020), 624–634. [32] Alex Kendall, Yarin Gal, and Roberto Cipolla. 2018. Multi-task learning using uncertainty to weigh losses for scene geometry and semantics. In Proceedings of CVPR. 7482–7491. [33] Mehrdad Khani, Ganesh Ananthanarayanan, Kevin Hsieh, Junchen Jiang, Ravi Netravali, Yuanchao Shu, Mohammad Alizadeh, and Victor Bahl. 2023. { RECL } : Responsive { Resource-Efficient } continuous learning for video analytics. In Proceedings of NSDI. 917–932. [34] Mehrdad Khani, Pouya Hamadanian, Arash Nasr-Esfahany, and Mohammad Alizadeh. 2021. Real-time video inference on edge devices via adaptive model streaming. In Proceedings of ICCV. 4572–4582. [35] James Kirkpatrick, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A Rusu, Kieran Milan, John Quan, Tiago Ramalho, Agnieszka Grabska-Barwinska, et al. 2017. Overcoming catastrophic forgetting in neural networks. PNAS 114, 13 (2017), 3521–3526.

[36] Yuxin Kong, Peng Yang, and Yan Cheng. 2023. Edge-assisted on-device model update for video analytics in adverse environments. In Proceedings of ACM MM. 9051–9060. [37] Woosuk Kwon, Gyeong-In Yu, Eunji Jeong, and Byung-Gon Chun. 2020. Nimble: Lightweight and parallel gpu task scheduling for deep learning. Proceedings of NeurIPS 33 (2020), 8343–8354. [38] Brian Lester, Rami Al-Rfou, and Noah Constant. 2021. The power of scale for parameter-efficient prompt tuning. arXiv preprint arXiv:2104.08691 (2021). [39] Xiang Lisa Li and Percy Liang. 2021. Prefix-tuning: Optimizing continuous prompts for generation. arXiv preprint arXiv:2101.00190 (2021). [40] Jin Lu, Chao Shang, Chaoqun Yue, Reynaldo Morillo, Shweta Ware, Jayesh Kamath, Athanasios Bamis, Alexander Russell, Bing Wang, and Jinbo Bi. 2018. Joint modeling of heterogeneous sensing data for depression assessment via multi-task learning. Proceedings of IMWUT 2, 1 (2018), 1–21. [41] Yan Lu, Shiqi Jiang, Ting Cao, and Yuanchao Shu. 2022. Turbo: Opportunistic enhancement for edge video analytics. In Proceedings of SenSys. 263–276. [42] Lingxiao Ma, Zhiqiang Xie, Zhi Yang, Jilong Xue, Youshan Miao, Wei Cui, Wenxiang Hu, Fan Yang, Lintao Zhang, and Lidong Zhou. 2020. Rammer: Enabling holistic deep learning compiler optimizations with { rTasks } . In Proceedings of OSDI. 881–897. [43] Mark Mansi and Michael M Swift. 2024. Characterizing Physical Memory Fragmentation. arXiv preprint arXiv:2401.03523 (2024). [44] Jiageng Mao, Yuxi Qian, Junjie Ye, Hang Zhao, and Yue Wang. 2023. Gpt-driver: Learning to drive with gpt. arXiv preprint arXiv:2310.01415 (2023). [45] Brendan McMahan, Eider Moore, Daniel Ramage, Seth Hampson, and Blaise Aguera y Arcas. 2017. Communication-efficient learning of deep networks from decentralized data. In Proceedings of AISTATS. PMLR, 1273–1282. [46] Zili Meng, Xiao Kong, Jing Chen, Bo Wang, Mingwei Xu, Rui Han, Honghao Liu, Venkat Arun, Hongxin Hu, and Xue Wei. 2024. Hairpin: Rethinking packet loss recovery in edge-based interactive video streaming. In 21st USENIX Symposium on Networked Systems Design and Implementation (NSDI 24). 907–926. [47] Microsoft. 2022. Edge Video Services. https://github.com/microsoft/edge-videoservices. Accessed on 01/09/2025. [48] Ishan Misra, Abhinav Shrivastava, Abhinav Gupta, and Martial Hebert. 2016. Cross-stitch networks for multi-task learning. In Proceedings of CVPR. 3994–4003. [49] Ravi Teja Mullapudi, Steven Chen, Keyi Zhang, Deva Ramanan, and Kayvon Fatahalian. 2019. Online model distillation for efficient video inference. In Proceedings of ICCV. 3573–3582. [50] Xiaonan Nie, Xupeng Miao, Zilong Wang, Zichao Yang, Jilong Xue, Lingxiao Ma, Gang Cao, and Bin Cui. 2023. Flexmoe: Scaling large-scale sparse pre-trained model training via dynamic device placement. Proceedings of SIGMOD 1, 1 (2023), 1–19. [51] Xiaonan Nie, Xupeng Miao, Zhi Yang, and Bin Cui. 2022. Tsplit: Fine-grained gpu memory management for efficient dnn training via tensor splitting. In Proceedings of ICDE. IEEE, 2615–2628. [52] Shuaicheng Niu, Chunyan Miao, Guohao Chen, Pengcheng Wu, and Peilin Zhao. 2024. Test-time model adaptation with only forward passes. arXiv preprint arXiv:2404.01650 (2024). [53] Shuaicheng Niu, Jiaxiang Wu, Yifan Zhang, Yaofo Chen, Shijian Zheng, Peilin Zhao, and Mingkui Tan. 2022. Efficient test-time model adaptation without forgetting. In Proceedings of ICML. PMLR, 16888–16905. [54] Chandandeep Singh Pabla. 2009. Completely fair scheduler. Linux Journal 2009, 184 (2009), 4. [55] Arthi Padmanabhan, Neil Agarwal, Anand Iyer, Ganesh Ananthanarayanan, Yuanchao Shu, Nikolaos Karianakis, Guoqing Harry Xu, and Ravi Netravali. 2023. Gemel: Model Merging for { Memory-Efficient } , { Real-Time } Video Analytics at the Edge. In Proceedings of NSDI. 973–994. [56] Xuan Peng, Xuanhua Shi, Hulin Dai, Hai Jin, Weiliang Ma, Qian Xiong, Fan Yang, and Xuehai Qian. 2020. Capuchin: Tensor-based gpu memory management for deep learning. In Proceedings of ASPLOS. 891–905. [57] Rakibul Hasan Rajib, Md Akil Raihan Iftee, Mir Sazzat Hossain, AKM Rahman, Sajib Mistry, M Ashraful Amin, and Amin Ahsan Ali. 2025. FedCTTA: A Collaborative Approach to Continual Test-Time Adaptation in Federated Learning. arXiv preprint arXiv:2505.13643 (2025). [58] Jie Ren, Samyam Rajbhandari, Reza Yazdani Aminabadi, Olatunji Ruwase, Shuangyan Yang, Minjia Zhang, Dong Li, and Yuxiong He. 2021. { Zero-offload } : Democratizing { billion-scale } model training. In Proceedings of ATC. 551–564. [59] Carlos Riquelme, Joan Puigcerver, Basil Mustafa, Maxim Neumann, Rodolphe Jenatton, André Susano Pinto, Daniel Keysers, and Neil Houlsby. 2021. Scaling Vision with Sparse Mixture of Experts. arXiv:2106.05974 [cs.CV] https://arxiv. org/abs/2106.05974 [60] SciPy. 2008. NNLS. https://docs.scipy.org/doc/scipy/reference/generated/scipy. optimize.nnls.html. (Accessed on 01/09/2025). [61] Mohit Sharma, Claudio Fantacci, Yuxiang Zhou, Skanda Koppula, Nicolas Heess, Jon Scholz, and Yusuf Aytar. 2023. Lossless adaptation of pretrained vision models for robotic manipulation. arXiv preprint arXiv:2304.06600 (2023). [62] Jaekang Shin, Seungkyu Choi, Jongwoo Ra, and Lee-Sup Kim. 2022. Algorithm/architecture co-design for energy-efficient acceleration of multi-task DNN.

AdaSprite: Resource-efficient Online Co-Adaptation for V2I Systems Under Large-scale Data Drifts

In Proceedings of the 59th ACM/IEEE Design Automation Conference. 253–258. [63] Fridtjof Siebert. 2000. Eliminating external fragmentation in a non-moving garbage collector for Java. In Proceedings of CASES. 9–17. [64] David Siegwart and Martin Hirzel. 2006. Improving locality with parallel hierarchical copying GC. In Proceedings of ISMM. 52–63. [65] Trevor Standley, Amir Zamir, Dawn Chen, Leonidas Guibas, Jitendra Malik, and Silvio Savarese. 2020. Which tasks should be learned together in multi-task learning?. In Proceedings of ICML. PMLR, 9120–9132. [66] Ximeng Sun, Rameswar Panda, Rogerio Feris, and Kate Saenko. 2020. Adashare: Learning what to share for efficient deep multi-task learning. Proceedings of NeurIPS 33 (2020), 8728–8740. [67] Yun-Yun Tsai, Chengzhi Mao, and Junfeng Yang. 2023. Convolutional visual prompt for robust visual perception. Proceedings of NeurIPS 36 (2023), 27897– 27921. [68] Ronald Veldema and Michael Philippsen. 2012. Parallel memory defragmentation on a GPU. In Proceedings of MSPC. 38–47. [69] Dequan Wang, Evan Shelhamer, Shaoteng Liu, Bruno Olshausen, and Trevor Darrell. 2020. Tent: Fully test-time adaptation by entropy minimization. arXiv preprint arXiv:2006.10726 (2020). [70] Haixin Wang, Jianlong Chang, Yihang Zhai, Xiao Luo, Jinan Sun, Zhouchen Lin, and Qi Tian. 2024. Lion: Implicit vision prompt tuning. In Proceedings of AAAI, Vol. 38. 5372–5380. [71] Lehao Wang, Zhiwen Yu, Haoyi Yu, Sicong Liu, Yaxiong Xie, Bin Guo, and Yunxin Liu. 2023. AdaEvo: Edge-Assisted Continuous and Timely DNN Model Evolution for Mobile Devices. IEEE Transactions on Mobile Computing (2023). [72] Qipeng Wang, Mengwei Xu, Chao Jin, Xinran Dong, Jinliang Yuan, Xin Jin, Gang Huang, Yunxin Liu, and Xuanzhe Liu. 2022. Melon: Breaking the memory wall for resource-efficient on-device machine learning. In Proceedings of MobiSys. 450–463. [73] Fengmin Wu, Sicong Liu, Kehao Zhu, Xiaochen Li, Bin Guo, Zhiwen Yu, Hongkai Wen, Xiangrui Xu, Lehao Wang, and Xiangyu Liu. 2024. AdaFlow: Opportunistic

MobiSys ’26, June 21–25, 2026, Cambridge, United Kingdom

Inference on Asynchronous Mobile Data with Generalized Affinity Control. In Proceedings of the 22nd ACM Conference on Embedded Networked Sensor Systems. 606–618. [74] Runsheng Xu, Hao Xiang, Zhengzhong Tu, Xin Xia, Ming-Hsuan Yang, and Jiaqi Ma. 2022. V2x-vit: Vehicle-to-everything cooperative perception with vision transformer. In European conference on computer vision. Springer, 107–124. [75] Bufang Yang, Lixing He, Neiwen Ling, Zhenyu Yan, Guoliang Xing, Xian Shuai, Xiaozhe Ren, and Xin Jiang. 2023. Edgefm: Leveraging foundation model for open-set learning on the edge. In Proceedings of SenSys. 111–124. [76] Taojiannan Yang, Yi Zhu, Yusheng Xie, Aston Zhang, Chen Chen, and Mu Li. 2023. Aim: Adapting image models for efficient video action recognition. arXiv preprint arXiv:2302.03024 (2023). [77] Tianhe Yu, Saurabh Kumar, Abhishek Gupta, Sergey Levine, Karol Hausman, and Chelsea Finn. 2020. Gradient surgery for multi-task learning. Proceedings of NeurIPS 33 (2020), 5824–5836. [78] Chen Zhang, Lingxiao Ma, Jilong Xue, Yining Shi, Ziming Miao, Fan Yang, Jidong Zhai, Zhi Yang, and Mao Yang. 2023. Cocktailer: Analyzing and Optimizing Dynamic Control Flow in Deep Learning. In Proceedings of OSDI. 681–699. [79] Chi Zhang, Florian Steinhauser, Gereon Hinz, and Alois Knoll. 2023. Occlusionaware planning for autonomous driving with vehicle-to-everything communication. IEEE Transactions on Intelligent Vehicles 9, 1 (2023), 1229–1242. [80] Susan Zhang, Stephen Roller, Naman Goyal, Mikel Artetxe, Moya Chen, Shuohui Chen, Christopher Dewan, Mona Diab, Xian Li, Xi Victoria Lin, Todor Mihaylov, Myle Ott, Sam Shleifer, Kurt Shuster, Daniel Simig, Punit Singh Koura, Anjali Sridhar, Tianlu Wang, and Luke Zettlemoyer. 2022. OPT: Open Pre-trained Transformer Language Models. arXiv:2205.01068 [cs.CL] https://arxiv.org/abs/ 2205.01068 [81] Zhenyu Zhang, Zhen Cui, Chunyan Xu, Yan Yan, Nicu Sebe, and Jian Yang. 2019. Pattern-affinitive propagation across depth, surface normal and semantic segmentation. In Proceedings of CVPR. 4106–4115.

Related documents

• AdaSprite: Resource-efficient Online Co-Adaptation for V2I Systems Under Large-scale Data Drifts#620596
• AdaSprite: Resource-efficient Online Co-Adaptation for V2I Systems Under Large-scale Data Drifts#618917
• Hoeffding adaptive splitting trees for data stream classification with concept drift and ensemble learning#625226
• Hoeffding adaptive splitting trees for data stream classification with concept drift and ensemble learning#622953
• Hoeffding adaptive splitting trees for data stream classification with concept drift and ensemble learning#459664