Tootfinder

TrainVerify: Equivalence-Based Verification for Distributed LLM Training
Yunchi Lu, Youshan Miao, Cheng Tan, Peng Huang, Yi Zhu, Xian Zhang, Fan Yang
https://arxiv.org/abs/2506.15961

TrainVerify: Equivalence-Based Verification for Distributed LLM Training
Training large language models (LLMs) at scale requires parallel execution across thousands of devices, incurring enormous computational costs. Yet, these costly distributed trainings are rarely verified, leaving them prone to silent errors and potentially wasting millions of GPU hours. We introduce TrainVerify, a system for verifiable distributed training of LLMs. Given a deep learning model's logical specification as the ground truth, TrainVerify formally verifies that a distributed parallel …

DistFlow: A Fully Distributed RL Framework for Scalable and Efficient LLM Post-Training
Zhixin Wang, Tianyi Zhou, Liming Liu, Ao Li, Jiarui Hu, Dian Yang, Jinlong Hou, Siyuan Feng, Yuan Cheng, Yuan Qi
https://arxiv.org/abs/2507.13833

DistFlow: A Fully Distributed RL Framework for Scalable and Efficient LLM Post-Training
Reinforcement learning (RL) has become the pivotal post-training technique for large language model. Effectively scaling reinforcement learning is now the key to unlocking advanced reasoning capabilities and ensuring safe, goal-aligned behavior in the most powerful LLMs. Mainstream frameworks usually employ a hybrid-controller architecture where a single-controller dispatches the overall execution logic and manages overall data transfer and the multi-controller executes distributed computation.…

FOGNITE: Federated Learning-Enhanced Fog-Cloud Architecture
Somayeh Sobati-M
https://arxiv.org/abs/2507.16668 https://arxiv.org/pdf/2…

FOGNITE: Federated Learning-Enhanced Fog-Cloud Architecture
Modern smart grids demand fast, intelligent, and energy-aware computing at the edge to manage real time fluctuations and ensure reliable operation. This paper introduces FOGNITE Fog-based Grid In intelligence with Neural Integration and Twin based Execution a next-generation fog cloud framework designed to enhance autonomy, resilience, and efficiency in distributed energy systems. FOGNITE combines three core components: federated learning, reinforcement learning, and digital twin validation. Ea…

Designing Deep Learning Frameworks for LLMs:Challenges, Expectations, and Opportunities
Yanzhou Mu, Rong Wang, Juan Zhai, Chunrong Fang, Xiang Chen, Jiacong Wu, An Guo, Jiawei Shen, Bingzhuo Li, Zhenyu Chen
https://arxiv.org/abs/2506.13114

Designing Deep Learning Frameworks for LLMs:Challenges, Expectations, and Opportunities
Large language models (LLMs) drive significant advancements in real industry applications. LLMs rely on DL frameworks for efficient model construction, distributed execution, and optimized deployment. Their large parameter scale and long execution cycles place extreme demands on DL frameworks in terms of scalability, stability, and efficiency. Therefore, poor usability, limited functionality, and subtle bugs in DL frameworks may hinder development efficiency and cause severe failures or resourc…

LIFT: Automating Symbolic Execution Optimization with Large Language Models for AI Networks
Ruoxi Wang, Kun Li, Minghui Xu, Yue Zhang, Kaidi Xu, Chunchi Liu, Yinhao Xiao, Xiuzhen Cheng
https://arxiv.org/abs/2507.04931

LIFT: Automating Symbolic Execution Optimization with Large Language Models for AI Networks
Dynamic Symbolic Execution (DSE) is a key technique in program analysis, widely used in software testing, vulnerability discovery, and formal verification. In distributed AI systems, DSE plays a crucial role in identifying hard-to-detect bugs, especially those arising from complex network communication patterns. However, traditional approaches to symbolic execution are often hindered by scalability issues and inefficiencies, particularly in large-scale systems. This paper introduces LIFT (Large…

Convergence and Robustness Bounds for Distributed Asynchronous Shortest-Path
Jared Miller, Mattia Bianchi, Florian D\"orfler
https://arxiv.org/abs/2507.07263

Convergence and Robustness Bounds for Distributed Asynchronous Shortest-Path
This work analyzes convergence times and robustness bounds for asynchronous distributed shortest-path computation. We focus on the Adaptive Bellman--Ford algorithm, a self-stabilizing method in which each agent updates its shortest-path estimate based only on the estimates of its neighbors and forgetting its previous estimate. In the asynchronous framework considered in this paper, agents are allowed to idle or encounter race conditions during their execution of the Adaptive Bellman--Ford algor…

from my link log —
Idris 2: quantitative type theory in practice.
https://arxiv.org/abs/2104.00480
saved 2025-06-11 https://dotat…

Idris 2: Quantitative Type Theory in Practice
Dependent types allow us to express precisely what a function is intended to do. Recent work on Quantitative Type Theory (QTT) extends dependent type systems with linearity, also allowing precision in expressing when a function can run. This is promising, because it suggests the ability to design and reason about resource usage protocols, such as we might find in distributed and concurrent programming, where the state of a communication channel changes throughout program execution. As yet, howe…

WANify: Gauging and Balancing Runtime WAN Bandwidth for Geo-distributed Data Analytics
Anshuman Das Mohapatra, Kwangsung Oh
https://arxiv.org/abs/2508.12961 https://

WANify: Gauging and Balancing Runtime WAN Bandwidth for Geo-distributed Data Analytics
Accurate wide area network (WAN) bandwidth (BW) is essential for geo-distributed data analytics (GDA) systems to make optimal decisions such as data and task placement to improve performance. Existing GDA systems, however, measure WAN BW statically and independently between data centers (DCs), while data transfer occurs dynamically and simultaneously among DCs during workload execution. Also, they use a single connection WAN BW that cannot capture actual WAN capacities between distant DCs. Such…

Verification of the Release-Acquire Semantics
Parosh Abdulla, Elli Anastasiadi, Mohamed Faouzi Atig, Samuel Grahn
https://arxiv.org/abs/2506.08238 https://…

Verification of the Release-Acquire Semantics
The Release-Acquire (RA) semantics and its variants are some of the most fundamental models of concurrent semantics for architectures, programming languages, and distributed systems. Several steps have been taken in the direction of testing such semantics, where one is interested in whether a single program execution is consistent with a memory model. The more general verification problem, i.e., checking whether all allowed program runs are consistent with a memory model, has still not been stu…

The {purrr} package is a powerfull way to replace loops. The {furrr} package takes this approach one step further by parallel execution: #rstats

Apply Mapping Functions in Parallel using Futures
Implementations of the family of map() functions from purrr that can be resolved using any future-supported backend, e.g. parallel on the local machine or distributed on a compute cluster.

Towards Energy-Efficient Distributed Agreement
Hugo Mirault, Peter Robinson
https://arxiv.org/abs/2506.12282 https://arxiv.org/pdf/25…

Towards Energy-Efficient Distributed Agreement
We study fault-tolerant consensus in a variant of the synchronous message passing model, where, in each round, every node can choose to be awake or asleep. This is known as the sleeping model (Chatterjee, Gmyr, Pandurangan PODC 2020) and defines the awake complexity (also called \emph{energy complexity}), which measures the maximum number of rounds that any node is awake throughout the execution. Only awake nodes can send and receive messages in a given round and all messages sent to sleeping n…

GPU-Accelerated Distributed QAOA on Large-scale HPC Ecosystems
Zhihao Xu, Srikar Chundury, Seongmin Kim, Amir Shehata, Xinyi Li, Ang Li, Tengfei Luo, Frank Mueller, In-Saeng Suh
https://arxiv.org/abs/2506.10531

GPU-Accelerated Distributed QAOA on Large-scale HPC Ecosystems
Quantum computing holds great potential to accelerate the process of solving complex combinatorial optimization problems. The Distributed Quantum Approximate Optimization Algorithm (DQAOA) addresses high-dimensional, dense problems using current quantum computing techniques and high-performance computing (HPC) systems. In this work, we improve the scalability and efficiency of DQAOA through advanced problem decomposition and parallel execution using message passing on the Frontier CPU/GPU super…

VeFIA: An Efficient Inference Auditing Framework for Vertical Federated Collaborative Software
Chung-ju Huang, Ziqi Zhang, Yinggui Wang, Binghui Wang, Tao Wei, Leye Wang
https://arxiv.org/abs/2507.02376

VeFIA: An Efficient Inference Auditing Framework for Vertical Federated Collaborative Software
Vertical Federated Learning (VFL) is a distributed AI software deployment mechanism for cross-silo collaboration without accessing participants' data. However, existing VFL work lacks a mechanism to audit the execution correctness of the inference software of the data party. To address this problem, we design a Vertical Federated Inference Auditing (VeFIA) framework. VeFIA helps the task party to audit whether the data party's inference software is executed as expected during large-scale infere…

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 …

Towards Efficient and Scalable Distributed Vector Search with RDMA
Xiangyu Zhi, Meng Chen, Xiao Yan, Baotong Lu, Hui Li, Qianxi Zhang, Qi Chen, James Cheng
https://arxiv.org/abs/2507.06653

Towards Efficient and Scalable Distributed Vector Search with RDMA
Similarity-based vector search facilitates many important applications such as search and recommendation but is limited by the memory capacity and bandwidth of a single machine due to large datasets and intensive data read. In this paper, we present CoTra, a system that scales up vector search for distributed execution. We observe a tension between computation and communication efficiency, which is the main challenge for good scalability, i.e., handling the local vectors on each machine indepen…

Generating representative macrobenchmark microservice systems from distributed traces with Palette
Vaastav Anand, Matheus Stolet, Jonathan Mace, Antoine Kaufmann
https://arxiv.org/abs/2506.06448

Generating representative macrobenchmark microservice systems from distributed traces with Palette
Microservices are the dominant design for developing cloud systems today. Advancements for microservice need to be evaluated in representative systems, e.g. with matching scale, topology, and execution patterns. Unfortunately in practice, researchers and practitioners alike often do not have access to representative systems. Thus they have to resort to sub-optimal non-representative alternatives, e.g. small and oversimplified synthetic benchmark systems or simulated system models instead. …

Improved Byzantine Agreement under an Adaptive Adversary
Fabien Dufoulon, Gopal Pandurangan
https://arxiv.org/abs/2506.04919 https://…

Improved Byzantine Agreement under an Adaptive Adversary
Byzantine agreement is a fundamental problem in fault-tolerant distributed computing that has been studied intensively for the last four decades. Much of the research has focused on a static Byzantine adversary, where the adversary is constrained to choose the Byzantine nodes in advance of the protocol's execution. This work focuses on the harder case of an adaptive Byzantine adversary that can choose the Byzantine nodes \emph{adaptively} based on the protocol's execution. While efficient $O(\l…

FedFog: Resource-Aware Federated Learning in Edge and Fog Networks
Somayeh Sobati-M
https://arxiv.org/abs/2507.03952 https://arxiv.or…

FedFog: Resource-Aware Federated Learning in Edge and Fog Networks
As edge and fog computing become central to modern distributed systems, there's growing interest in combining serverless architectures with privacy-preserving machine learning techniques like federated learning (FL). However, current simulation tools fail to capture this integration effectively. In this paper, we introduce FedFog, a simulation framework that extends the FogFaaS environment to support FL-aware serverless execution across edge-fog infrastructures. FedFog incorporates an adaptive …