🤖 AI Summary
Addressing the challenge of verifying convergence for parallel algorithms in asynchronous multiprocessor systems, this paper proposes a theoretical framework that eschews global synchronization mechanisms. Methodologically, it introduces a novel characterization of global convergence via partial orders among local state transition graphs—thereby avoiding the exponential construction and traversal of global state spaces inherent in conventional approaches. Integrating distributed state machine modeling with partial order theory, the framework enables the design of lock-free asynchronous algorithms whose convergence is formally provable and robust under arbitrary adversarial schedulers. Experimental evaluation demonstrates significantly improved convergence speed under asynchrony, alongside consistent efficiency and stability across both scheduler-sensitive and scheduler-insensitive scenarios. The results thus establish a rigorous theoretical foundation while maintaining practical applicability.
📝 Abstract
We currently see a steady rise in the usage and size of multiprocessor systems, and so the community is evermore interested in developing fast parallel processing algorithms. However, most algorithms require a synchronization mechanism, which is costly in terms of computational resources and time. If an algorithm can be executed in asynchrony, then it can use all the available computation power, and the nodes can execute without being scheduled or locked. However, to show that an algorithm guarantees convergence in asynchrony, we need to generate the entire global state transition graph and check for the absence of cycles. This takes time exponential in the size of the global state space. In this dissertation, we present a theory that explains the necessary and sufficient properties of a multiprocessor algorithm that guarantees convergence even without synchronization. We develop algorithms for various problems that do not require synchronization. Additionally, we show for several existing algorithms that they can be executed without any synchronization mechanism. A significant theoretical benefit of our work is in proving that an algorithm can converge even in asynchrony. Our theory implies that we can make such conclusions about an algorithm, by only showing that the local state transition graph of a computing node forms a partial order, rather than generating the entire global state space and determining the absence of cycles in it. Thus, the complexity of rendering such proofs, formal or social, is phenomenally reduced. Experiments show a significant reduction in time taken to converge, when we compare the execution time of algorithms in the literature versus the algorithms that we design. We get similar results when we run an algorithm, that guarantees convergence in asynchrony, under a scheduler versus in asynchrony.