Tootfinder

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…

I rewrote a data analysis pipeline, moving it from #python to #julialang . I am now in love with the threading support in Julia.
The task is very parallelizable but each thread needs random read access to a tens-of-GB dataset. In Python (with multiprocessing, shared stores, etc) data bookkeeping was a nightmar…

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…

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…

Trying to bring up IPC between the CPU1 and CPU2 subsystems on STM32MP2.
Doing shared memory compute between a 32 and 64 bit processor that need to share pointers (the physical address spaces overlap and are zero extended on the 64 bit side) makes things... interesting.

from my link log —
Parallel threads in Racket v9.0.
https://blog.racket-lang.org/2025/11/parallel-threads.html
saved 2025-11-23 https://

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…

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…