On the Runtime of Local Mutual Exclusion for Anonymous Dynamic Networks
Anya Chaturvedi, Joshua J. Daymude, Andréa W. Richa
TL;DR
This work analyzes the runtime of a randomized local mutual exclusion algorithm for anonymous nodes in adversarially dynamic networks. By refining the fairness model and making small algorithmic adjustments, the authors prove that any node can lock itself and its persistent neighbors within $O(n \Delta^3)$ open rounds in expectation, while preserving mutual exclusion and lockout freedom. The analysis employs a competition DAG to bound the duration of each competition trial and aggregates over the expected number of trials, yielding a polynomial-time bound that scales with network size and maximum degree. The results provide concrete performance guarantees for lock-based concurrency control in dynamic, anonymous distributed systems and suggest directions for future lower-bound and tightness investigations. They also discuss practical considerations like memory and message-size implications and potential scheduler alternatives for runtime analysis.
Abstract
Algorithms for mutual exclusion aim to isolate potentially concurrent accesses to the same shared resources. Motivated by distributed computing research on programmable matter and population protocols where interactions among entities are often assumed to be isolated, Daymude, Richa, and Scheideler (SAND`22) introduced a variant of the local mutual exclusion problem that applies to arbitrary dynamic networks: each node, on issuing a lock request, must acquire exclusive locks on itself and all its persistent neighbors, i.e., the neighbors that remain connected to it over the duration of the lock request. Assuming adversarial edge dynamics, semi-synchronous or asynchronous concurrency, and anonymous nodes communicating via message passing, their randomized algorithm achieves mutual exclusion (non-intersecting lock sets) and lockout freedom (eventual success with probability 1). However, they did not analyze their algorithm's runtime. In this paper, we prove that any node will successfully lock itself and its persistent neighbors within O$(nΔ^3)$ open rounds of its lock request in expectation, where $n$ is the number of nodes in the dynamic network, $Δ$ is the maximum degree of the dynamic network, rounds are normalized to the execution time of the ``slowest'' node, and ``closed'' rounds when some persistent neighbors are already locked by another node are ignored (i.e., only ``open" rounds are considered).