Tootfinder

The Future of Memory: Limits and Opportunities
Shuhan Liu, Samuel Dayo, Peijing Li, Philip Levis, Subhasish Mitra, Thierry Tambe, David Tennenhouse, H. -S. Philip Wong
https://arxiv.org/abs/2508.20425 …

The Future of Memory: Limits and Opportunities
Memory latency, bandwidth, capacity, and energy increasingly limit performance. In this paper, we reconsider proposed system architectures that consist of huge (many-terabyte to petabyte scale) memories shared among large numbers of CPUs. We argue two practical engineering challenges, scaling and signaling, limit such designs. We propose the opposite approach. Rather than create large, shared, homogenous memories, systems explicitly break memory up into smaller slices more tightly coupled with …

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…

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…

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 …

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

SAM4D: Segment Anything in Camera and LiDAR Streams
Jianyun Xu, Song Wang, Ziqian Ni, Chunyong Hu, Sheng Yang, Jianke Zhu, Qiang Li
https://arxiv.org/abs/2506.21547

SAM4D: Segment Anything in Camera and LiDAR Streams
We present SAM4D, a multi-modal and temporal foundation model designed for promptable segmentation across camera and LiDAR streams. Unified Multi-modal Positional Encoding (UMPE) is introduced to align camera and LiDAR features in a shared 3D space, enabling seamless cross-modal prompting and interaction. Additionally, we propose Motion-aware Cross-modal Memory Attention (MCMA), which leverages ego-motion compensation to enhance temporal consistency and long-horizon feature retrieval, ensuring …

This shared memory pool feature is neat in #dotnet 10 preview 6.
https://github.com/dotnet/core/blob/main/release-no…

core/release-notes/10.0/preview/preview6/aspnetcore.md at main · dotnet/core
.NET news, announcements, release notes, and more! - dotnet/core

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 …

Towards Bug-Free Distributed Go Programs
Zhengqun Koo
https://arxiv.org/abs/2506.15135 https://arxiv.org/pdf/2506.15135

Towards Bug-Free Distributed Go Programs
Programmers of distributed systems need to reason about concurrency to avoid races. However, reasoning about concurrency is difficult, and unexpected races show up as bugs. Data race detection in shared memory systems is well-studied (dynamic data race detection [13], behavioral types [15], dynamic race detection [31]). Similar to how a data race consists of reads and writes not related by happens-before at a shared memory location, a communication race consists of receives and sends not relate…

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 …

Photonic Fabric Platform for AI Accelerators
Jing Ding, Trung Diep
https://arxiv.org/abs/2507.14000 https://arxiv.org/pdf/2507.14000

Photonic Fabric Platform for AI Accelerators
This paper presents the Photonic FabricTM and the Photonic Fabric ApplianceTM (PFA), a photonic-enabled switch and memory subsystem that delivers low latency, high bandwidth, and low per-bit energy. By integrating high-bandwidth HBM3E memory, an on-module photonic switch, and external DDR5 in a 2.5D electro-optical system-in-package, the PFA offers up to 32 TB of shared memory alongside 115 Tbps of all-to-all digital switching. The Photonic FabricTM enables distributed AI training and inference…

🔄 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

gemma-3-12b runs quite well on a 15" M2 MacBook Air with 24GB of shared memory.
Are there other models that you'd recommend?
#ai #llm #mac

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…

PBFT-Backed Semantic Voting for Multi-Agent Memory Pruning
Duong Bach
https://arxiv.org/abs/2506.17338 https://arxiv.org/pdf/2506.173…

PBFT-Backed Semantic Voting for Multi-Agent Memory Pruning
The proliferation of multi-agent systems (MAS) in complex, dynamic environments necessitates robust and efficient mechanisms for managing shared knowledge. A critical challenge is ensuring that distributed memories remain synchronized, relevant, and free from the accumulation of outdated or inconsequential data - a process analogous to biological forgetting. This paper introduces the Co-Forgetting Protocol, a novel, comprehensive framework designed to address this challenge by enabling synchron…

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…

Point3R: Streaming 3D Reconstruction with Explicit Spatial Pointer Memory
Yuqi Wu, Wenzhao Zheng, Jie Zhou, Jiwen Lu
https://arxiv.org/abs/2507.02863 https…

Point3R: Streaming 3D Reconstruction with Explicit Spatial Pointer Memory
Dense 3D scene reconstruction from an ordered sequence or unordered image collections is a critical step when bringing research in computer vision into practical scenarios. Following the paradigm introduced by DUSt3R, which unifies an image pair densely into a shared coordinate system, subsequent methods maintain an implicit memory to achieve dense 3D reconstruction from more images. However, such implicit memory is limited in capacity and may suffer from information loss of earlier frames. We …

Superposed Parameterised Quantum Circuits
Viktoria Patapovich, Mo Kordzanganeh, Alexey Melnikov
https://arxiv.org/abs/2506.08749 https://

Superposed Parameterised Quantum Circuits
Quantum machine learning has shown promise for high-dimensional data analysis, yet many existing approaches rely on linear unitary operations and shared trainable parameters across outputs. These constraints limit expressivity and scalability relative to the multi-layered, non-linear architectures of classical deep networks. We introduce superposed parameterised quantum circuits to overcome these limitations. By combining flip-flop quantum random-access memory with repeat-until-success protocol…

reading this: #fuzzer? and …

This https://arxiv.org/abs/2501.15104 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_csPL_…

Two-sorted algebraic decompositions of Brookes's shared-state denotational semantics
We use a two sorted equational theory of algebraic effects to model concurrent shared state with preemptive interleaving, recovering Brookes's seminal 1996 trace-based model precisely. The decomposition allows us to analyse Brookes's model algebraically in terms of separate but interacting components. The multiple sorts partition terms into layers. We use two sorts: a "hold" sort for layers that disallow interleaving of environment memory accesses, analogous to holding a global lock on the memo…

ShyLU node: On-node Scalable Solvers and Preconditioners Recent Progresses and Current Performance
Ichitaro Yamazaki, Nathan Ellingwood, Sivasankaran Rajamanickam
https://arxiv.org/abs/2506.05793

ShyLU node: On-node Scalable Solvers and Preconditioners Recent Progresses and Current Performance
ShyLU-node is an open-source software package that implements linear solvers and preconditioners on shared-memory multicore CPUs or on a GPU. It is part of the Trilinos software framework and designed to provide a robust and efficient solution of large-scale linear systems from real-world applications on the current and emerging computers. In this paper, we discuss two sparse direct solvers, Basker and Tacho, and an algebraic preconditioner, FastILU, in ShyLU-node package. These ShyLU solvers a…

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 …

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…

InfiniteAudio: Infinite-Length Audio Generation with Consistency
Chaeyoung Jung, Hojoon Ki, Ji-Hoon Kim, Junmo Kim, Joon Son Chung
https://arxiv.org/abs/2506.03020

InfiniteAudio: Infinite-Length Audio Generation with Consistency
This paper presents InfiniteAudio, a simple yet effective strategy for generating infinite-length audio using diffusion-based text-to-audio methods. Current approaches face memory constraints because the output size increases with input length, making long duration generation challenging. A common workaround is to concatenate short audio segments, but this often leads to inconsistencies due to the lack of shared temporal context. To address this, InfiniteAudio integrates seamlessly into existin…

On Optimizing Resource Utilization in Distributed Connected Components
Mohsen Koohi Esfahani
https://arxiv.org/abs/2507.03695 https://

On Optimizing Resource Utilization in Distributed Connected Components
Connected Components (CC) is a core graph problem with numerous applications. This paper investigates accelerating distributed CC by optimizing memory and network bandwidth utilization. We present two novel distributed CC algorithms, SiskinCC and RobinCC, which are built upon the Jayanti-Tarjan disjoint set union algorithm. To optimize memory utilization, SiskinCC and RobinCC are designed to facilitate efficient access to a shared array for all cores running in a machine. This allows execution …

Optimizing Scalable Multi-Cluster Architectures for Next-Generation Wireless Sensing and Communication
Samuel Riedel, Yichao Zhang, Marco Bertuletti, Luca Benini
https://arxiv.org/abs/2507.05012

Optimizing Scalable Multi-Cluster Architectures for Next-Generation Wireless Sensing and Communication
Next-generation wireless technologies (for immersive-massive communication, joint communication and sensing) demand highly parallel architectures for massive data processing. A common architectural template scales up by grouping tens to hundreds of cores into shared-memory clusters, which are then scaled out as multi-cluster manycore systems. This hierarchical design, used in GPUs and accelerators, requires a balancing act between fewer large clusters and more smaller clusters, affecting design…

EvoGit: Decentralized Code Evolution via Git-Based Multi-Agent Collaboration
Beichen Huang, Ran Cheng, Kay Chen Tan
https://arxiv.org/abs/2506.02049 https:…

EvoGit: Decentralized Code Evolution via Git-Based Multi-Agent Collaboration
We introduce EvoGit, a decentralized multi-agent framework for collaborative software development driven by autonomous code evolution. EvoGit deploys a population of independent coding agents, each proposing edits to a shared codebase without centralized coordination, explicit message passing, or shared memory. Instead, all coordination emerges through a Git-based phylogenetic graph that tracks the full version lineage and enables agents to asynchronously read from and write to the evolving cod…

Understanding the Performance and Power of LLM Inferencing on Edge Accelerators
Mayank Arya, Yogesh Simmhan
https://arxiv.org/abs/2506.09554 https://

Understanding the Performance and Power of LLM Inferencing on Edge Accelerators
Large Language Models (LLMs) have demonstrated exceptional benefits to a wide range of domains, for tasks as diverse as code generation and robot navigation. While LLMs are usually served from cloud data centers, mission-critical and privacy-sensitive applications may require local hosting of open LLM models. Given the large GPU memory footprint needed for LLMs, edge accelerators such as Nvidia Jetson Orin AGX with 64GB of shared GPU-CPU RAM are a compelling choice. However, the feasibility and…