Tootfinder

Automated Insertion of Flushes and Fences for Persistency
Yutong Guo, Weiyu Luo, Brian Demsky
https://arxiv.org/abs/2509.19459 https://arxiv.org/pdf/2509.1…

Automated Insertion of Flushes and Fences for Persistency
CXL shared memory and persistent memory allow the contents of memory to persist beyond crashes. Stores to persistent or CXL memory are typically not immediately made persistent; developers must manually flush the corresponding cache lines to force the data to be written to the underlying storage. Correctly using flush and fence operations is known to be challenging. While state-of-the-art tools can find missing flush instructions, they often require bug-revealing test cases. No existing tools c…

An Asynchronous Many-Task Algorithm for Unstructured $S_{N}$ Transport on Shared Memory Systems
Alex Elwood, Tom Deakin, Justin Lovegrove, Chris Nelson
https://arxiv.org/abs/2510.11513

An Asynchronous Many-Task Algorithm for Unstructured $S_{N}$ Transport on Shared Memory Systems
Discrete ordinates $S_N$ transport solvers on unstructured meshes pose a challenge to scale due to complex data dependencies, memory access patterns and a high-dimensional domain. In this paper, we review the performance bottlenecks within the shared memory parallelization scheme of an existing transport solver on modern many-core architectures with high core counts. With this analysis, we then survey the performance of this solver across a variety of compute hardware. We then present a new Asy…

Weak Memory Model Formalisms: Introduction and Survey
Roger C. Su, Robert J. Colvin
https://arxiv.org/abs/2508.04115 https://arxiv.org/pdf/2508.04115

Weak Memory Model Formalisms: Introduction and Survey
Memory consistency models define the order in which accesses to shared memory in a concurrent system may be observed to occur. Such models are a necessity since program order is not a reliable indicator of execution order, due to microarchitectural features or compiler transformations. Concurrent programming, already a challenging task, is thus made even harder when weak memory effects must be addressed. A rigorous specification of weak memory models is therefore essential to make this problem …

A Dynamic Allocation Scheme for Adaptive Shared-Memory Mapping on Kilo-core RV Clusters for Attention-Based Model Deployment
Bowen Wang, Marco Bertuletti, Yichao Zhang, Victor J. B. Jung, Luca Benini
https://arxiv.org/abs/2508.01180

A Dynamic Allocation Scheme for Adaptive Shared-Memory Mapping on Kilo-core RV Clusters for Attention-Based Model Deployment
Attention-based models demand flexible hardware to manage diverse kernels with varying arithmetic intensities and memory access patterns. Large clusters with shared L1 memory, a common architectural pattern, struggle to fully utilize their processing elements (PEs) when scaled up due to reduced throughput in the hierarchical PE-to-L1 intra-cluster interconnect. This paper presents Dynamic Allocation Scheme (DAS), a runtime programmable address remapping hardware unit coupled with a unified memo…

Memshare: Memory Sharing for Multicore Computation in R with an Application to Feature Selection by Mutual Information using PDE
Michael C. Thrun, Julian M\"arte
https://arxiv.org/abs/2509.08632

Memshare: Memory Sharing for Multicore Computation in R with an Application to Feature Selection by Mutual Information using PDE
We present memshare\footnote{The Software package is published as a CRAN package under https://CRAN.R-project.org/package=memshare, a package that enables shared memory multicore computation in R by allocating buffers in C++ shared memory and exposing them to R through ALTREP views. We compare memshare to SharedObject (Bioconductor) discuss semantics and safety, and report a 2x speedup over SharedObject with no additional resident memory in a column wise apply benchmark. Finally, we illustrate …

Visual Perception Engine: Fast and Flexible Multi-Head Inference for Robotic Vision Tasks
Jakub {\L}ucki, Jonathan Becktor, Georgios Georgakis, Robert Royce, Shehryar Khattak
https://arxiv.org/abs/2508.11584

Visual Perception Engine: Fast and Flexible Multi-Head Inference for Robotic Vision Tasks
Deploying multiple machine learning models on resource-constrained robotic platforms for different perception tasks often results in redundant computations, large memory footprints, and complex integration challenges. In response, this work presents Visual Perception Engine (VPEngine), a modular framework designed to enable efficient GPU usage for visual multitasking while maintaining extensibility and developer accessibility. Our framework architecture leverages a shared foundation model backb…

🔄 Supports HTTP-01 challenges with 4-step workflow: server setup, shared memory allocation, challenge configuration & certificate renewal
🌐 Automates entire #TLS certificate lifecycle management, making secure connections standard expectation
📈 Positions #NGINX for future growth in

Carrier-Assisted Entanglement Purification
Jaemin Kim, Karthik Mohan, Sung Won Yun, Joonwoo Bae
https://arxiv.org/abs/2509.07514 https://arxiv.org/pdf/2509…

Carrier-Assisted Entanglement Purification
Entanglement distillation, a fundamental building block of quantum networks, enables the purification of noisy entangled states shared among distant nodes by local operations and classical communication. Its practical realization presents several technical challenges, including the storage of quantum states in quantum memory and the execution of coherent quantum operations on multiple copies of states within the quantum memory. In this work, we present an entanglement purification protocol via …

Scaling atomic ordering in shared memory
Lorenzo Martignetti, Eli\~a Batista, Gianpaolo Cugola, Fernando Pedone
https://arxiv.org/abs/2509.07781 https://ar…

Scaling atomic ordering in shared memory
Atomic multicast is a communication primitive used in dependable systems to ensure consistent ordering of messages delivered to a set of replica groups. This primitive enables critical services to integrate replication and sharding (i.e., state partitioning) to achieve fault tolerance and scalability. While several atomic multicast protocols have been developed for message-passing systems, only a few are designed for the shared memory system model. This paper introduces TRAM, an atomic multicas…

Limited Preemption of the 3-Phase Task Model using Preemption Thresholds
Thilanka Thilakasiri, Matthias Becker
https://arxiv.org/abs/2508.19760 https://arx…

Limited Preemption of the 3-Phase Task Model using Preemption Thresholds
Phased execution models are a well-known solution to tackle the unpredictability of today's complex COTS multi-core platforms. The semantics of these models dedicate phases for a task's execution and shared memory accesses. Memory phases are solely dedicated to load all necessary instructions and data to private local memory, and to write back the results of the computation. During execution phases, only the private local memory is accessed. While non-preemptive execution phases utilize the loc…

from my link log —
Shared memory consistency models: a tutorial. (1996)
http://www.ai.mit.edu/projects/aries/papers/consistency/computer_29_12_dec1996_p66.pdf
saved 2025-08-19

Semantic IDs for Music Recommendation
M. Jeffrey Mei, Florian Henkel, Samuel E. Sandberg, Oliver Bembom, Andreas F. Ehmann
https://arxiv.org/abs/2507.18800 https://

Semantic IDs for Music Recommendation
Training recommender systems for next-item recommendation often requires unique embeddings to be learned for each item, which may take up most of the trainable parameters for a model. Shared embeddings, such as using content information, can reduce the number of distinct embeddings to be stored in memory. This allows for a more lightweight model; correspondingly, model complexity can be increased due to having fewer embeddings to store in memory. We show the benefit of using shared content-base…

Self-organized hyperuniformity in a minimal model of population dynamics
Tal Agranov, Natan Wiegenfeld, Omer Karin, Benjamin D. Simons
https://arxiv.org/abs/2509.08077 https://

Self-organized hyperuniformity in a minimal model of population dynamics
We identify a novel scenario for hyperuniformity in a generic model of population dynamics that has been recently introduced to account for biological memory in the immune system and epigenetic inheritance. In this model, individuals' competition over a shared resource guides the population towards a critical steady state with prolonged individual life time. Here we uncover that the spatially extended model is characterized by hyperuniform density fluctuations. A hydrodynamic theory is derived …

SemShareKV: Efficient KVCache Sharing for Semantically Similar Prompts via Token-Level LSH Matching
Xinye Zhao, Spyridon Mastorakis
https://arxiv.org/abs/2509.24832 https://

SemShareKV: Efficient KVCache Sharing for Semantically Similar Prompts via Token-Level LSH Matching
As large language models (LLMs) continue to scale, the memory footprint of key-value (KV) caches during inference has become a significant bottleneck. Existing approaches primarily focus on compressing KV caches within a single prompt or reusing shared prefixes or frequently ocurred text segments across prompts. However, such strategies are limited in scenarios where prompts are semantically similar but lexically different, which frequently occurs in tasks such as multi-document summarization a…

Checking Consistency of Event-driven Traces
Parosh Aziz Abdulla, Mohamed Faouzi Atig, R. Govind, Samuel Grahn, Ramanathan S. Thinniyam
https://arxiv.org/abs/2508.07855 https://

Checking Consistency of Event-driven Traces
Event-driven programming is a popular paradigm where the flow of execution is controlled by two features: (1) shared memory and (2) sending and receiving of messages between multiple handler threads (just called handler). Each handler has a mailbox (modelled as a queue) for receiving messages, with the constraint that the handler processes its messages sequentially. Executions of messages by different handlers may be interleaved. A central problem in this setting is checking whether a candidate…

TeraNoC: A Multi-Channel 32-bit Fine-Grained, Hybrid Mesh-Crossbar NoC for Efficient Scale-up of 1000 Core Shared-L1-Memory Clusters
Yichao Zhang, Zexin Fu, Tim Fischer, Yinrong Li, Marco Bertuletti, Luca Benini
https://arxiv.org/abs/2508.02446

TeraNoC: A Multi-Channel 32-bit Fine-Grained, Hybrid Mesh-Crossbar NoC for Efficient Scale-up of 1000+ Core Shared-L1-Memory Clusters
A key challenge in on-chip interconnect design is to scale up bandwidth while maintaining low latency and high area efficiency. 2D-meshes scale with low wiring area and congestion overhead; however, their end-to-end latency increases with the number of hops, making them unsuitable for latency-sensitive core-to-L1-memory access. On the other hand, crossbars offer low latency, but their routing complexity grows quadratically with the number of I/Os, requiring large physical routing resources and …

Batched high-rate logical operations for quantum LDPC codes
Qian Xu, Hengyun Zhou, Dolev Bluvstein, Madelyn Cain, Marcin Kalinowski, John Preskill, Mikhail D. Lukin, Nishad Maskara
https://arxiv.org/abs/2510.06159

Batched high-rate logical operations for quantum LDPC codes
High-rate quantum LDPC (qLDPC) codes reduce memory overhead by densely packing many logical qubits into a single block of physical qubits. Here we extend this concept to high-rate computation by constructing \emph{batched} fault-tolerant operations that apply the same logical gate across many code blocks in parallel. By leveraging shared physical resources to execute many logical operations in parallel, these operations realize high rates in space-time and significantly reduce computational cos…

HYLU: Hybrid Parallel Sparse LU Factorization
Xiaoming Chen
https://arxiv.org/abs/2509.07690 https://arxiv.org/pdf/2509.07690

HYLU: Hybrid Parallel Sparse LU Factorization
This article introduces HYLU, a hybrid parallel LU factorization-based general-purpose solver designed for efficiently solving sparse linear systems (Ax=b) on multi-core shared-memory architectures. The key technical feature of HYLU is the integration of hybrid numerical kernels so that it can adapt to various sparsity patterns of coefficient matrices. Tests on 34 sparse matrices from SuiteSparse Matrix Collection reveal that HYLU outperforms Intel MKL PARDISO in the numerical factorization pha…

Locality-Aware Automatic Differentiation on the GPU for Mesh-Based Computations
Ahmed H. Mahmoud, Jonathan Ragan-Kelley, Justin Solomon
https://arxiv.org/abs/2509.00406 https://…

Locality-Aware Automatic Differentiation on the GPU for Mesh-Based Computations
We present a high-performance system for automatic differentiation (AD) of functions defined on triangle meshes that exploits the inherent sparsity and locality of mesh-based energy functions to achieve fast gradient and Hessian computation on the GPU. Our system is designed around per-element forward-mode differentiation, enabling all local computations to remain in GPU registers or shared memory. Unlike reverse-mode approaches that construct and traverse global computation graphs, our method …

CloudFormer: An Attention-based Performance Prediction for Public Clouds with Unknown Workload
Amirhossein Shahbazinia, Darong Huang, Luis Costero, David Atienza
https://arxiv.org/abs/2509.03394

CloudFormer: An Attention-based Performance Prediction for Public Clouds with Unknown Workload
Cloud platforms are increasingly relied upon to host diverse, resource-intensive workloads due to their scalability, flexibility, and cost-efficiency. In multi-tenant cloud environments, virtual machines are consolidated on shared physical servers to improve resource utilization. While virtualization guarantees resource partitioning for CPU, memory, and storage, it cannot ensure performance isolation. Competition for shared resources such as last-level cache, memory bandwidth, and network inter…

ClusterFusion: Expanding Operator Fusion Scope for LLM Inference via Cluster-Level Collective Primitive
Xinhao Luo, Zihan Liu, Yangjie Zhou, Shihan Fang, Ziyu Huang, Yu Feng, Chen Zhang, Shixuan Sun, Zhenzhe Zheng, Jingwen Leng, Minyi Guo
https://arxiv.org/abs/2508.18850

ClusterFusion: Expanding Operator Fusion Scope for LLM Inference via Cluster-Level Collective Primitive
Large language model (LLM) decoding suffers from high latency due to fragmented execution across operators and heavy reliance on off-chip memory for data exchange and reduction. This execution model limits opportunities for fusion and incurs significant memory traffic and kernel launch overhead. While modern architectures such as NVIDIA Hopper provide distributed shared memory and low-latency intra-cluster interconnects, they expose only low-level data movement instructions, lacking structured …

TokenLake: A Unified Segment-level Prefix Cache Pool for Fine-grained Elastic Long-Context LLM Serving
Bingyang Wu, Zili Zhang, Yinmin Zhong, Guanzhe Huang, Yibo Zhu, Xuanzhe Liu, Xin Jin
https://arxiv.org/abs/2508.17219

TokenLake: A Unified Segment-level Prefix Cache Pool for Fine-grained Elastic Long-Context LLM Serving
Prefix caching is crucial to accelerate multi-turn interactions and requests with shared prefixes. At the cluster level, existing prefix caching systems are tightly coupled with request scheduling to optimize cache efficiency and computation performance together, leading to load imbalance, data redundancy, and memory fragmentation of caching systems across instances. To address these issues, memory pooling is promising to shield the scheduler from the underlying cache management so that it can …

TeraAgent: A Distributed Agent-Based Simulation Engine for Simulating Half a Trillion Agents
Lukas Breitwieser, Ahmad Hesam, Abdullah Giray Ya\u{g}l{\i}k\c{c}{\i}, Mohammad Sadrosadati, Fons Rademakers, Onur Mutlu
https://arxiv.org/abs/2509.24063

TeraAgent: A Distributed Agent-Based Simulation Engine for Simulating Half a Trillion Agents
Agent-based simulation is an indispensable paradigm for studying complex systems. These systems can comprise billions of agents, requiring the computing resources of multiple servers to simulate. Unfortunately, the state-of-the-art platform, BioDynaMo, does not scale out across servers due to its shared-memory-based implementation. To overcome this key limitation, we introduce TeraAgent, a distributed agent-based simulation engine. A critical challenge in distributed execution is the exchange…