Searcharxiv⌕ Search

subject

cs.DC

cs.DC: explore 237 source-linked works published from 2025 to 2026, with original documents and citations.

This collection is a preview while coverage and quality are evaluated.

Search within this collection

Coverage and selection

Includes records with this source-supplied label or an explicit phrase match in their metadata. Matches indicate a mention, not proof that a paper uses a method or tests a material. Source versions are consolidated by DOI.

Sources: arxiv. Collection updated 2026-09-16. Counts describe this index, not the complete source archives.

arXiv2026

Characterizing the I/O Behavior of HPC Applications through Modeling and Simulation

Parallel applications process large amounts of data, leading to intensive parallel I/O operations. These operations can exhibit different levels of complexity, including, among others, multiple I/O access patterns, data staging, and contention risks. Therefore, in order to exploit high-performance computing (HPC) systems efficiently and optimize the I/O performance, it is crucial to consider the I/O behaviour of the HPC applications. In this work, we have developed a framework that reproduces the I/O access pattern of real applications in a simulated environment provided by ElastiSim, a batch-system simulator for rigid, malleable, and evolving workloads. The simulated applications are generated based on I/O traces captured from real applications provided by the HPC Input/Output (HPCIO) analysis repository. The HPCIO analysis database includes traces combined with information about real applications' performance across different parallel I/O libraries and layers of the I/O stack. We have conducted detailed case studies of real-world applications' traces to demonstrate how the proposed modeling framework can provide insights into the performance characteristics of I/O applications, including the I/O congestion analysis based on the application's I/O access pattern.

cs.DC↗
arXiv2026

The Illusion of Independent Quorums: Epistemic Fault Domains and Correlated Cognitive Failures in Agentic Quorums

Multi-agent quorums are widely used to authorize high-stakes infrastructure and policy mutations, yet distinct reviewers often share upstream telemetry, documents, or tool backends. When upstream inputs fail, multiple votes collapse onto a single corrupted cause: replication does not imply epistemic redundancy. We introduce Epistemic Fault Domains (EFDs) and the Structural Epistemic Cut κ_E, which quantifies the minimum number of modeled root faults whose exposure covers an authorizing coalition relative to an explicit Epistemic Fault Basis. Under closed causal accounting, conservative exposure, and authorization alignment, κ_E lower-bounds the number of roots required for semantic compromise (κ_S). We prove that arbitrarily large quorums can retain κ_E=1, that recognizing shared ancestry never increases credited resilience, and that adding voters at a fixed threshold cannot increase the cut under compatible exposure extensions. Finally, we design the Dependency-Aware Quorum Controller (DAQC) to enforce structural cuts at runtime admission, evaluate its mechanics via analytical derivations and simulations, and provide a frozen 120-task external benchmark suite.

cs.DC↗
arXiv2026

PowerSlider: Exploiting Phase Asymmetry for LLM Serving under Demand Response

AI inference clusters are increasingly constrained by instantaneous power, not just energy: grid operators condition new capacity on demand response, imposing time-varying power caps. Existing LLM serving systems optimize a static energy objective or shed fixed priority tiers under load; either way, goodput collapses when the power envelope moves. An LLM pipeline is not a uniform load: compute-bound prefill loses throughput almost linearly with GPU frequency, memory-bound answer decode sustains it down to $0.57\times$ nominal, and reasoning's thinking phase couples KV-cache capacity to scheduling -- so a cap should be steered to where each watt costs the least performance. PowerSlider does so with a new Flex SLO contract that turns bounded user slack into an optimization constraint, prefill--think--answer disaggregation exposing per-stage frequency and KV control, and a Karush--Kuhn--Tucker (KKT) online solver re-solving within 7.7 ms of every cap change, backed by a consolidated fail-safe that power-gates drained instances when DVFS bottoms out on static power. On SGLang with production traces, \sys{} sustains 78.3\% online goodput at a 30\% cap reduction versus 47.6\% for the best of five baselines ($1.64\times$), holds latency-critical tails within $1.3\times$ of nominal (baselines: $2.3$--$6\times$, up to $12\times$), and delivers 92\% mean goodput through a replayed CAISO grid-emergency day bottoming at $0.41\times$ (54\% at the trough; every baseline below 7\%).

cs.DC↗
arXiv2026

On Reduction and Synthesis of Petri's Cycloids

Cycloids are particular Petri nets for modelling processes of actions and events, belonging to the fundaments of Petri's general systems theory. Defined by four parameters they provide an algebraic formalism to describe strongly synchronized sequential processes. To further investigate their structure, reduction systems of cycloids are defined in the style of rewriting systems and properties of irreducible cycloids are proved. In particular the synthesis of cycloid parameters from their Petri net structure is derived, leading to an efficient method for a decision procedure for cycloid isomorphism.

cs.DC↗
arXiv2026

A Three-Layer Caching Architecture for Low-Latency LLM Web Search on Commodity CPU Hardware

AI-powered search products such as ChatGPT search, Google's AI Overviews, and Perplexity provide LLM-synthesized answers grounded in live web results. We developed OreoLook (formerly lixSearch), an open-source answer engine using automated browser agents and provider-routed LLM inference. Its local search, caching, session-management, and embedding stack runs on commodity CPU hardware; answer synthesis is performed by a remote inference provider. As usage grew, sessions lost context, equivalent queries triggered redundant work, and URLs were repeatedly embedded across sessions. We present a three-layer caching architecture: (1) a Session Context Window maintaining a rolling window of recent messages in Redis with automatic overflow to Huffman-compressed disk archives; (2) a Semantic Query Cache catches rephrasings via cosine similarity on embedding vectors, eliminating redundant LLM invocations; and (3) a URL Embedding Cache that deduplicates embedding computations across sessions. Deployed on a single 8-vCPU Intel Cascade Lake server (2 GHz, 32 GB RAM) running 30 Hypercorn worker processes across three containerized replicas, the evaluated system reported an 89.3% aggregate Redis keyspace hit rate with 0.1 ms read latency and just 1.38 MB of memory overhead. A background LRU eviction daemon migrates idle sessions from Redis to disk and re-hydrates them on demand, enabling conversations that can be resumed hours or days later under the configured retention policy.

cs.DC↗
arXiv2026

Operation-Type-Aware Client Routing for Leader-Based Consensus Datastores

Leader-based consensus datastores (etcd, ZooKeeper) face two competing routing goals: spread load evenly across members, and route operations to the member whose protocol role matches the operation. Writes must commit through the leader, so sending them elsewhere adds a forwarding hop. Linearizable reads need only a lightweight leader confirmation before any member can serve them locally. The upstream etcd client uses gRPC's round_robin balancer, distributing reads and writes uniformly across cluster members. An operation-aware client resolves this by pinning writes to the leader and distributing reads across the healthy read pool. In steady state on a 3-node etcd cluster (80/20 read/write mix, 5 trials), this lowers write P50 by 29% and raises throughput by 9%. When a follower degrades silently, the operation-aware client detects the latency shift and removes it from the read pool, cutting read P99 by 64%, write P99 by 74%, and raising throughput by 89%. The same routing rule applied to ZooKeeper (ZAB protocol, different implementation) points in the same direction, showing that the result follows from leader-based consensus structure rather than one system's implementation. The key obstacle to discovering this policy adaptively is that the leader confirmation round-trip occurs between cluster members, so the client sees only a blended latency signal rather than the decisive coordination cost directly.

cs.DC↗
arXiv2026

COAST: Congestion-Aware Start-Time Recommendations for Carbon-Aware HPC Jobs

High-performance computing (HPC) workloads consume substantial amounts of electricity, and their carbon emissions vary over time with the carbon intensity of grid electricity. However, uncoordinated shifting of carbon-aware HPC jobs toward low-carbon periods can concentrate recommended start times in the same time slots, creating congestion and eroding the resulting carbon benefits. This paper proposes COAST, a congestion-aware start-time recommendation mechanism that coordinates HPC jobs by balancing carbon savings against additional job delay and congestion in recommended start-time slots. COAST formulates each decision batch as an exact potential game, enabling best-response updates to converge to stable start-time recommendations. Under an idealized realization model that assumes each job can start at its recommended time, we conduct trace-driven simulations using public HPC energy data and historical grid carbon-intensity traces. The results show that COAST reduces estimated carbon emissions by 15.4\% with 1.5 hours of additional average start delay. Compared with carbon-greedy start-time recommendations, COAST reduces peak time-slot load by 23.8\% while preserving 93\% of the achievable carbon savings. These results quantify the potential benefits of congestion-aware start-time coordination for flexible, carbon-aware HPC jobs.

cs.DC↗
arXiv2026

Cold-Start Model Delivery in Kubernetes Inference Serving: An Empirical Study of OCI-Based Distribution and Its Integrity

The startup latency of a model-serving pod on Kubernetes is dominated by one step: delivering the model weights. As models reach the hundred-gigabyte weights of large language models, cold-start delivery time governs the economics of autoscaling and scale-to-zero, yet the dominant mechanisms remain ad-hoc downloads from object storage, with none of the pull caching, digest addressing, or verification Kubernetes provides for container images. We analyze the delivery paths available to a Kubernetes serving platform along two axes: which component pulls the artifact, and whether any admission-time verifier can bind the deployed reference to the arriving bytes. We validate the analysis upstream in KServe, a widely deployed CNCF model-serving platform, by implementing two new delivery paths: oci+native://, which mounts model images as Kubernetes image volumes (KEP-4639), merged upstream, and oci+fetch://, which pulls OCI artifacts inside the storage initializer, under review. We report, to our knowledge, the first controlled comparison of model delivery paths in a Kubernetes serving platform (modelcar sidecars, native image volumes, object-storage download) on artifacts sized to fp16 weights of 1B-, 7B-, and 70B-class models (2-140 GB). Node-cached OCI delivery makes warm replica addition size-independent: 11.7 s for a 70B-class artifact versus 40.7 minutes of re-download over object storage, a 208x difference, while the first cold pull costs up to 2x a plain download, localized to containerd's blob-write-then-unpack double pass. For models on s3://, gs://, or hf:// URIs, where no admission-time verifier observes the bytes, we present a serving-time integrity design proposed to the KServe community: digest pinning and OpenSSF model-signing enforcement in the storage initializer. Streaming hash verification during download adds under 0.1% to delivery time; a post-download pass adds up to 53%.

cs.DC↗
arXiv2026

X-CoSD: Communication-Efficient Cross-Vocabulary Collaborative Speculative Decoding

This paper investigates collaborative speculative decoding (CoSD), a distributed large language model (LLM) inference framework in which an on-device small language model (SLM) drafts candidate tokens and a server LLM verifies them. Existing CoSD methods assume a shared vocabulary between the SLM and the LLM and incur substantial communication load because residual resampling requires token distribution exchange between the user device and the edge server. To address these limitations, we propose cross-vocabulary CoSD (X-CoSD), a lossless and communication-efficient CoSD framework for heterogeneous SLM-LLM vocabularies. X-CoSD is built on hybrid resampling (HR), which splits residual resampling across the common-vocabulary region on the device and the LLM-only region on the server, so that distribution transmission is required only for the common-vocabulary region. We further propose X-CoSD-E, an enhanced variant based on server resampling with device verification (SR-DV), in which the server sends only replacement candidates sampled from the server LLM and their corresponding probabilities for local verification at the device. We prove that both X-CoSD and X-CoSD-E preserve the server LLM distribution, and experiments show that they significantly improve token generation speed while maintaining generation quality comparable to that of the server LLM.

cs.CL↗
arXiv2026

Audit-First Rollback Semantics for Safety-Critical Deployment Pipelines

Distributed deployment runtimes carry a coherence obligation that classical fault-tolerance frameworks do not name directly: the live state a component is configured to run and the audit chain that records how it got there must agree at every terminal configuration. Prior works mainly focus on individual aspects of the deploy-time fault surface (canary controllers, configuration rollback, signed attestations), leaving the cross-cutting question of audit/live coherence under fail-stop crash only loosely specified. Yet a key systems question remains unresolved: how can a deployment runtime guarantee that the audit chain answers truthfully about live state even when a transition crashes mid-flight? We present audit-first rollback semantics, a fault-tolerance mechanism that guarantees audit/live coherence at every committed terminal under fail-stop crashes during transition phases. The mechanism pairs with provisional state machines, pipelines whose "active but not yet promoted" states carry an explicit rollback contract and a bounded deadline. We instantiate both in a runtime deployment system and run a dependability evaluation against a fail-open variant of the same pipeline across twelve fault-injection points spanning three structural failure classes. Across 1,200 injected-failure trials, audit-first rollback achieves 100% audit/live-state coherence (600/600, Wilson 95% CI [0.994,1.000]) with per-cell p95 recovery latency below 500 ms (SLO PASS in 12/12 cells); the fail-open variant preserves coherence on only 33% of trials (200/600, Wilson 95% CI [0.297,0.372]). We further lift the construction to a cross-bridge coordination protocol with a safety argument for fleets of fail-stop bridges, leaving fleet-scale empirical evaluation to follow-on work.

cs.SE↗
arXiv2026

TFR-GNN: Topology- and Fault-Aware Graph Neural Scheduling for Heterogeneous Distributed Computing Systems

Scheduling workflow directed acyclic graphs (DAGs) on heterogeneous distributed systems is a classical NP-hard problem, and the list-scheduling heuristic HEFT remains the defacto standard because of its low complexity and strong makespan. In real deployments, however, machines fail: commodity and pre-emptible nodes are far less reliable than dedicated ones, and a makespan-optimal but reliability-agnostic placement can be dramatically slowed by node failures. We show empirically, on real workflow structures from the WfCommons/Pegasus corpus, that no single fixed heuristic is best across the joint space of failure intensity and cluster load: with no failures HEFT is optimal, whereas under failures a reliability-aware placement can reduce the expected makespan by up to 52% when spare capacity exists. Motivated by this, we present TFR-GNN, a graph neural scheduler that combines bidirectional dependency attention over the task DAG, topology attention over the (bandwidth-weighted) machine graph, and a cross-attention placement head augmented with a failure-gated reliability tilt and an optional replication gate. We train TFR-GNN by distilling a best-of-portfolio fault-tolerant oracle into a single one-shot policy. On real workflows and a bimodal-reliability cluster model, TFR-GNN matches HEFT exactly when there are no failures, reduces the expected makespan under failures by 14.8% on average (up to 47%) over HEFT, beats a fixed reliability-aware baseline (R-HEFT) by 11% and matches a per-scenario hindsight oracle as a single policy without any deployment-time tuning, and generalises to unseen applications and to workflows an order of magnitude larger than those seen in training, while producing schedules in well under a second for graphs of nearly 5,000 tasks. All results are produced by a verified event-level simulator on real workflow data; no experimental numbers are synthetic.

cs.DC↗
arXiv2026

HELIOS: Guardrailed LLM-Driven Evolution of Autonomous Resource Orchestration Policies for Multi-Cloud Distributed Systems

Operating latency-sensitive services across multiple public clouds creates an optimization surface no single provider autoscaler can see: on-demand vCPU prices differ by provider, spot discounts and interruption risks vary by provider and instance type, egress fees penalize state movement, and provider-level failures can take down single-cloud deployments. Large language models (LLMs) are appealing orchestrators because they can synthesize non-trivial decision logic from a natural-language environment description. However, placing an LLM on the critical path of every scheduling decision is impractical: for a 200-service fleet, per-decision inference would cost more than the cloud capacity it manages and add multi-second latency to a millisecond-scale control loop. HELIOS moves the LLM off the critical path. The LLM evolves executable orchestration policies, small Python programs over a fixed feature interface, against a trace-driven multi-cloud simulator. Only the champion program runs in production, wrapped in guardrails that enforce capacity feasibility, SLO-class placement rules, and churn budgets regardless of evolved code's proposal. On real workload traces (PlanetLab, Bitbrains, Azure) combined with 2026 price and interruption-frequency data from AWS, Azure, and GCP, the evolved policy reduces penalized operating cost by 45% versus a single-cloud best-fit baseline and by 9-19% versus calibrated multi-cloud heuristics. It matches an oracle-informed MILP planner's premium-SLO performance at 40% lower cost and outperforms a DQN meta-controller trained with 2.6x more environment interactions. Guardrails are essential: without them, the same policy family degrades to 97-98% premium-tier downtime under a 10x spot-hazard stress test, versus 0.17% when guarded. We release the simulator, policies, LLM prompt/response archive, and per-generation fitness logs for full reproducibility.

cs.DC↗
arXiv2026

Towards Decentralized Registries for Assets Metadata Information

The effort to tokenize non-currency assets faces several hurdles, including the lack of a scalable decentralized computing infrastructure to manage asset-related metadata. While the centralized securities depository model has served the financial industry well for several decades, the vision of tokenization at a global scale requires new infrastructure that enables distributed control while protecting the integrity of asset-related metadata, regardless of where it is stored. In this paper, we discuss the decentralized artifacts metadata registry model for tokenized assets as a possible direction for the financial industry seeking to embrace tokenization. The artifacts metadata registries extend the function of the traditional CSD, and could in fact be a new type of service offered by CSDs around the world.

cs.DC↗
arXiv2026

Maestro: Workload-Aware Cross-Cluster Scheduling for LLM-Based Multi-Agent Systems

Large Language Model based Multi-Agent Systems (LLM-MAS) have emerged as a powerful paradigm for tackling complex tasks by breaking them into collaborative workflows of specialized LLM-powered agents. However, deploying such multi-agent workloads at scale poses significant system challenges. Each user query spawns an iterative pipeline of LLM calls, greatly amplifying resource consumption compared to single-turn queries. In resource-constrained cloud settings, these workflows face non-deterministic and input-dependent costs at decode stage, heavy-tailed multi-model requirements with memory fragmentation and over-provisioning, and cross-cluster scheduling trade-offs. We present Maestro, a workload-aware scheduling system designed for LLM-MAS serving under strict GPU budgets. Maestro explicitly leverages agent semantics and roles: it predicts the output length and memory usage of each stage and uses this prediction to drive a hierarchical scheduler. At the node level, Maestro enables dynamic multi-model co-location via hierarchical weight caching and elastic memory provisioning. At the cluster level, it performs latency-aware routing to avoid cold-start delays and memory overloads. At the global level, it enforces workflow-aware prioritization to minimize head-of-line blocking for interactive tasks. Across prototype experiments and trace-driven simulations, Maestro reduces KV-reservation HBM by 67.2% and improves high-contention SLO attainment over EDF by 23.6 percentage points.

cs.DC↗
arXiv2026

Grid Checkpointing: an Innovative Rollback Support for Speculative Simulation

We present a new technique for application-transparent incremental checkpointing in speculative simulation, referred to as {\em Grid Checkpointing}. With our proposal, we fully separate the interception of memory update operations from memory-map management. This enables tracing memory updates that occur in the state of a simulation object via an extremely limited set of instrumentation instructions. At the methodological level, our proposal exploits an overlaid grid layout on the memory area used to host the chunks of an object state, and manages concise data for enabling incremental checkpointing with no need for knowing which chunks are really allocated/updated into the object state. Additionally, grid checkpointing fully avoids logging the addresses of the touched memory zones, as instead takes place in other existing proposals. We embedded our solution into the PARSIR (PARallel SImulation Runner) open source package and report the results of an experimental study that compares grid checkpointing with other solutions available in the literature. The results demonstrate that our approach enables incremental checkpointing via memory update tracing with nearly negligible runtime cost.

cs.DC↗
arXiv2026

Constella: A Novel Framework for Cost-Efficient Distributed AI Inference in LEO Space Data Centers

Space data centers built from Low-Earth Orbit (LEO) satellite constellations are gaining increasing attention as a scalable computing infrastructure. With access to abundant solar energy and high-throughput optical inter-satellite links, such constellations can run AI workloads directly in orbit, enabling new in-space application types while optimizing existing ones such as Earth observation. However, managing satellite constellations that combine heterogeneous satellite roles introduces a cost optimization challenge. Determining the appropriate constellation size and satellite role ratio for a given workload is challenging, as over-provisioning processing satellites increases system cost, while under-provisioning limits system efficiency. To enable cost-efficient execution of AI inference workloads in such space data centers, we present Constella, a novel framework that leverages DNN splitting for distributed AI inference in LEO satellite constellations. Constella comprises an offline resource identifier that determines the optimal ratio of processor-to-communicator satellites and an online assignment algorithm. The algorithm utilizes constellation telemetry to adaptively route data within the constellation and to ground stations. We evaluate Constella on a real-world satellite dataset across scenarios of increasing complexity. Results demonstrate a reduction in system cost by up to two orders of magnitude and lower end-to-end inference latency by up to 2.7x compared to other approaches, while maintaining no less than 81.9% inference success rate.

cs.DC↗
arXiv2026

SMCC-Empowered Digital Twins for Sensorless Monitoring in Large-Scale AI-Driven IoT Systems

The deployment of AI-driven Digital Twins (DTs) in large-scale Internet-of-Things (IoT) ecosystems demands continuous, high-fidelity synchronization between the physical environment and its virtual replica. Conventional approaches rely on dense sensor deployments, which introduce prohibitive costs in terms of hardware, energy, and network bandwidth. In this paper, we propose SMCC-DT, an integrated Sensing-Memory-Communication-Computation (SMCC) framework that enables sensorless monitoring of physical assets by exploiting Integrated Sensing and Communication (ISAC) waveforms at the 6G Edge. Under the SMCC-DT paradigm, a single radio signal simultaneously extracts environmental telemetry (Sensing) and delivers it to an Edge server (Communication), where a large-scale AI model is loaded into constrained memory (Memory) and executed (Computation) to update the DT state. We formulate the DT synchronization problem as a cross-layer optimization that jointly allocates transmit power, beamforming vectors, memory partitions, and CPU frequency to minimize the end-to-end synchronization latency subject to sensing accuracy, throughput, memory capacity, and computational budget constraints. Because the resulting mixed-integer nonlinear program is NP-hard, we design a Proximal Policy Optimization (PPO)-based Deep Reinforcement Learning (DRL) agent, termed SMCCAGENT, that learns near-optimal resource allocation policies online. Extensive simulations over a 500-node industrial IoT testbed demonstrate that SMCC-DT reduces DT synchronization latency by 38.7% and total energy consumption by 27.4% compared to state-of-the-art orthogonal and compute-only baselines, while sustaining sensing accuracy above 95% and model inference throughput above 30 frames per second.

cs.DC↗
arXiv2026

Beyond Lemma Sharing -- Novel Parallelization Strategies for Property Directed Reachability

Property Directed Reachability (PDR) is a commonly used technique for automated hardware model checking, yet efficiently parallelizing it remains a significant challenge. Existing approaches, such as lemma sharing, often suffer from limited scalability as processor counts increase. In this work, we present two novel sharing-based parallelization strategies, preemptive propagation and ARPOS, and compare their performance with classical lemma sharing. To this end, we develop an asynchronous MPI-based message passing framework for the state-of-the-art rIC3 hardware model checker. Experimental results on the 2025 Hardware Model Checking competition benchmark demonstrate that our preemptive propagation strategy yields a significant performance boost over classical lemma sharing.

cs.DC↗
Compare source metadata on this page
WorkPublishedSource identifierSource
Characterizing the I/O Behavior of HPC Applications through Modeling and Simulation2026-08-272608.27642arxiv
The Illusion of Independent Quorums: Epistemic Fault Domains and Correlated Cognitive Failures in Agentic Quorums2026-08-242609.02925arxiv
PowerSlider: Exploiting Phase Asymmetry for LLM Serving under Demand Response2026-08-222608.21719arxiv
On Reduction and Synthesis of Petri's Cycloids2026-08-172405.21025arxiv
A Three-Layer Caching Architecture for Low-Latency LLM Web Search on Commodity CPU Hardware2026-08-122609.05463arxiv
Operation-Type-Aware Client Routing for Leader-Based Consensus Datastores2026-08-112609.00392arxiv
COAST: Congestion-Aware Start-Time Recommendations for Carbon-Aware HPC Jobs2026-07-292609.05443arxiv
Cold-Start Model Delivery in Kubernetes Inference Serving: An Empirical Study of OCI-Based Distribution and Its Integrity2026-07-182607.16596arxiv
X-CoSD: Communication-Efficient Cross-Vocabulary Collaborative Speculative Decoding2026-07-152609.09166arxiv
Audit-First Rollback Semantics for Safety-Critical Deployment Pipelines2026-07-092609.00406arxiv
TFR-GNN: Topology- and Fault-Aware Graph Neural Scheduling for Heterogeneous Distributed Computing Systems2026-07-082609.09165arxiv
HELIOS: Guardrailed LLM-Driven Evolution of Autonomous Resource Orchestration Policies for Multi-Cloud Distributed Systems2026-07-072609.09164arxiv
Towards Decentralized Registries for Assets Metadata Information2026-06-142609.05430arxiv
Maestro: Workload-Aware Cross-Cluster Scheduling for LLM-Based Multi-Agent Systems2026-06-112606.12950arxiv
Grid Checkpointing: an Innovative Rollback Support for Speculative Simulation2026-06-112609.05428arxiv
Constella: A Novel Framework for Cost-Efficient Distributed AI Inference in LEO Space Data Centers2026-06-082609.05427arxiv
SMCC-Empowered Digital Twins for Sensorless Monitoring in Large-Scale AI-Driven IoT Systems2026-06-042609.09161arxiv
Beyond Lemma Sharing -- Novel Parallelization Strategies for Property Directed Reachability2026-06-022609.05426arxiv

These are bibliographic comparisons, not experimental rankings. Follow the original document for methods and conditions.