Complexity of network synchronization

Reviewer: David B. Skillicorn

This paper presents a method of simulating a synchronous network using an asynchronous network. This is done by means of a synchronizer that generates “clock pulses” at each node on receipt of all messages that should have arrived during the corresponding clock period of a synchronous network. Thus, all processor nodes can tell which time period of the synchronous algorithm they are currently executing. The complexities in time and messages of the synchronizer are within a constant factor of the lower bound for an infinite number of networks. Time and message complexity can be traded off by selection of a parameter in the initialization phase of the synchronizer. This simulation method produces new results on the complexity of asynchronous algorithms by taking synchronous algorithms and executing them on an asynchronous network together with the synchronizer. The author gives results for the complexity of maximum flow and breadth first search arrived at in this way. The essential idea behind the design of the synchronizer is that, given that execution within processor nodes takes negligible time, any node is ready to go on to the next step of the (synchronous) algorithm if all of the messages that it sent during the current step have arrived at their destination processors. If acknowledgment messages are assumed, then this information is in fact available to each node. Now, if all of a node's neighbors are ready to proceed to the next step of the algorithm, then it is certainly safe for the node to do so since there cannot be any outstanding messages for it. The synchronizer thus works by ensuring that nodes inform their neighbors when they are ready to proceed to the next step. The time/communication tradeoff in the synchronizer is achieved by varying the size of clusters of nodes that consult within themselves concerning their readiness to proceed. A clustering phase is thus required before the synchronous algorithm can begin to execute; the author presents a distributed clustering algorithm that does this. The paper is very well written and gives a clear and fairly intuitive presentation. It might have helped if there had been some assessment of how powerful a technique this is likely to be. That is, for how many problems it might be expected that a synchronous algorithm on a synchronized asynchronous network might give new complexity results. Although it is common to do so, it seems misleading to calculate time complexities assuming small fixed transmission times when the network model assumes that such times cannot be bounded.