Results 1  10
of
31
Simple, Accurate Time Synchronization for Wireless Sensor Networks
, 2003
"... Time synchronization is important for any distributed system. In particular, wireless sensor networks make extensive use of synchronized time in many contexts (e.g. for data fusion, TDMA schedules, synchronized sleep periods, etc.). Existing time synchronization methods were not designed with wirele ..."
Abstract

Cited by 142 (1 self)
 Add to MetaCart
Time synchronization is important for any distributed system. In particular, wireless sensor networks make extensive use of synchronized time in many contexts (e.g. for data fusion, TDMA schedules, synchronized sleep periods, etc.). Existing time synchronization methods were not designed with wireless sensor networks in mind, and need to be extended or redesigned. Our solution centers around the development of a deterministic time synchronization method relevant for wireless sensor networks. The proposed solution features minimal complexity in network bandwidth, storage and processing and can achieve good accuracy. Highly relevant for sensor networks, it also provides tight, deterministic bounds on both the offsets and clock drifts. A method to synchronize the entire network in preparation for data fusion is presented. A real implementation of a wireless adhoc network is used to evaluate the performance of the proposed approach.
Gradient clock synchronization
 In Proceedings of the 23rd Annual ACM Symposium on Principles of Distributed Computing (PODC). ACM
"... We introduce the distributed gradient clock synchronization problem. As in traditional distributed clock synchronization, we consider a network of nodes equipped with hardware clocks with bounded drift. Nodes compute logical clock values based on their hardware clocks and message exchanges, and the ..."
Abstract

Cited by 40 (1 self)
 Add to MetaCart
We introduce the distributed gradient clock synchronization problem. As in traditional distributed clock synchronization, we consider a network of nodes equipped with hardware clocks with bounded drift. Nodes compute logical clock values based on their hardware clocks and message exchanges, and the goal is to synchronize the nodes ’ logical clocks as closely as possible, while satisfying certain validity conditions. The new feature of gradient clock synchronization (GCS for short) is to require that the skew between any two nodes ’ logical clocks be bounded by a nondecreasing function of the uncertainty in message delay (call this the distance) between the two nodes. That is, we require nearby nodes to be closely synchronized, and allow faraway nodes to be more loosely synchronized. We contrast GCS with traditional clock synchronization, and discuss several practical motivations for GCS, mostly arising in sensor and ad hoc networks. Our main result is that the worst case clock skew between two nodes at distance d from each other is log D log log D), where D is the diameter1 of the network. Ω(d + This means that clock synchronization is not a local property, in the sense that the clock skew between two nodes depends not only on the distance between the nodes, but also on the size of the network. Our lower bound implies, for example, that the TDMA protocol with a fixed slot granularity will fail as the network grows, even if the maximum degree of each node stays constant. Categories and Subject Descriptors: F.2.0 [Theory of Computation]: analysis of algorithms and problem complexity— general
Optimal Clock Synchronization in Networks
"... Having access to an accurate time is a vital building block in all networks; in wireless sensor networks even more so, because wireless media access or data fusion may depend on it. Starting out with a novel analysis, we show that orthodox clock synchronization algorithms make fundamental mistakes. ..."
Abstract

Cited by 37 (8 self)
 Add to MetaCart
(Show Context)
Having access to an accurate time is a vital building block in all networks; in wireless sensor networks even more so, because wireless media access or data fusion may depend on it. Starting out with a novel analysis, we show that orthodox clock synchronization algorithms make fundamental mistakes. The stateoftheart clock synchronization algorithm FTSP exhibits an error that grows exponentially with the size of the network, for instance. Since the involved parameters are small, the error only becomes visible in midsize networks of about 1020 nodes. In contrast, we present PulseSync, a new clock synchronization algorithm that is asymptotically optimal. We evaluate PulseSync on a Mica2 testbed, and by simulation on larger networks. On a 20 node network, the prototype implementation of PulseSync outperforms FTSP by a factor of 5. Theory and simulation show that for larger networks, PulseSync offers an accuracy which is several orders of magnitude better than FTSP. To round off the presentation, we investigate several optimization issues, e.g. media access and local skew.
R.: Oblivious Gradient Clock Synchronization
 In: Proc. of the 20 th Int. Symposium on Distributed Computing (DISC). (2006
"... Abstract. We study the gradient clock synchronization (GCS) problem, in which the worstcase clock skew between neighboring nodes has to be minimized. In particular, we consider oblivious clock synchronization algorithms which base their decision on how to adapt the clock solely on the most accurate ..."
Abstract

Cited by 26 (11 self)
 Add to MetaCart
(Show Context)
Abstract. We study the gradient clock synchronization (GCS) problem, in which the worstcase clock skew between neighboring nodes has to be minimized. In particular, we consider oblivious clock synchronization algorithms which base their decision on how to adapt the clock solely on the most accurate timing information received from each neighbor. For several intuitive clock synchronization algorithms, which attempt to minimize the skew at all times, we show that the clock skew between neighboring nodes can be significantly larger than the proven lower bound of log D log log D Ω (), where D denotes the diameter of the network. All of these natural algorithms belong to the class of oblivious clock synchronization algorithms. Additionally, we present an oblivious algorithm with a worstcase skew of O(d + √ D) between any two nodes at distance d.
Tight bounds for clock synchronization
 In Proceedings of the 28th Annual ACM Symposium on Principles of Distributed Computing (PODC). ACM
"... Abstract. We present a novel clock synchronization algorithm and prove tight upper and lower bounds on the worstcase clock skew that may occur between any two participants in any given distributed system. More importantly, the worstcase clock skew between neighboring nodes is (asymptotically) at m ..."
Abstract

Cited by 23 (6 self)
 Add to MetaCart
Abstract. We present a novel clock synchronization algorithm and prove tight upper and lower bounds on the worstcase clock skew that may occur between any two participants in any given distributed system. More importantly, the worstcase clock skew between neighboring nodes is (asymptotically) at most a factor of two larger than the best possible bound. While previous results solely focused on the dependency of the skew bounds on the network diameter, we prove that our techniques are optimal also with respect to the maximum clock drift, the uncertainty in message delays, and the imposed bounds on the clock rates. The presented results all hold in a general model where both the clock drifts and the message delays may vary arbitrarily within prespecified bounds. Furthermore, our algorithm exhibits a number of other highly desirable properties. First, the algorithm ensures that the clock values remain in an affine linear envelope of real time. A better worstcase bound on the accuracy with respect to real time cannot be achieved in the absence of an external timer. Second, the algorithm minimizes the number and size of messages that need to be exchanged in a given time period. Moreover, only a small number of bits must be stored locally for each neighbor. Finally, our algorithm can easily be adapted for a variety of other prominent synchronization models.
Gradient Clock Synchronization in Dynamic Networks
 In Proc. 21st ACM Symposium on Parallelism in Algorithms and Architectures (SPAA
, 2009
"... Over the last years, largescale decentralized computer networks such as peertopeer and mobile ad hoc networks have become increasingly prevalent. The topologies of many of these networks are often highly dynamic. This is especially true for ad hoc networks formed by mobile wireless devices. In th ..."
Abstract

Cited by 17 (6 self)
 Add to MetaCart
(Show Context)
Over the last years, largescale decentralized computer networks such as peertopeer and mobile ad hoc networks have become increasingly prevalent. The topologies of many of these networks are often highly dynamic. This is especially true for ad hoc networks formed by mobile wireless devices. In this paper, we study the fundamental problem of clock synchronization in dynamic networks. We show that there is an inherent tradeoff between the skew S guaranteed along sufficiently old links and the time needed to guarantee a small skew along new links. For any sufficiently large initial skew on a new link, there are executions in which the time required to reduce the skew on the link to O(S) is at least Ω(n/S). We show that this bound is tight for moderately small values of S. Assuming a fixed set of n nodes and an arbitrary pattern of edge insertions and removals, a weak dynamic connectivity requirement suffices to prove the following results. We present an algorithm that always maintains a skew of O(n) between any two nodes in the network. For a parameter S = Ω ( √ ρn), where ρ is the maximum hardware clock drift, it is further guaranteed that if a communication link between two nodes u, v persists in the network for Θ(n/S) time, the clock skew between u and v is reduced to no more than O(S).
Optimal Gradient Clock Synchronization in Dynamic Networks
"... We study the problem of clock synchronization in highly dynamic networks, where communication links can appear or disappear at any time. The nodes in the network are equipped with hardware clocks, but the rate of the hardware clocks can vary arbitrarily within specific bounds, and the estimates that ..."
Abstract

Cited by 14 (4 self)
 Add to MetaCart
(Show Context)
We study the problem of clock synchronization in highly dynamic networks, where communication links can appear or disappear at any time. The nodes in the network are equipped with hardware clocks, but the rate of the hardware clocks can vary arbitrarily within specific bounds, and the estimates that nodes can obtain about the clock values of other nodes are inherently inaccurate. Our goal in this setting is to output a logical clock at each node, such that the logical clocks of any two nodes are not too far apart, and nodes that remain close to each other in the network for a long time are better synchronized than distant nodes. This property is called gradient clock synchronization. Gradient clock synchronization has been widely studied in the static setting. We show that the bounds for the static case also apply to our highly dynamic setting: if two nodes remain at distance d from each other for sufficiently long, it is possible to synchronize their clocks to within O(d log(D/d)), where D is the diameter of the network. This is known to be optimal for static networks, and since a static network is a special case of a dynamic network, it is optimal for dynamic networks as well. Furthermore, we show that our algorithm has optimal stabilization time: when a path of length d appears between two nodes, the time required until the skew between the two nodes is reduced to O(d log(D/d)) is O(D), which we prove is optimal.
Conditional oblivious transfer and timedrelease encryption
 Lecture Notes in Computer Science
, 1592
"... Abstract. We consider the problem of sending messages “into the future.” Previous constructions for this task were either based on heuristic assumptions or did not provide anonymity to the sender of the message. In the publickey setting, we present an efficient and secure timedrelease encryption s ..."
Abstract

Cited by 10 (1 self)
 Add to MetaCart
(Show Context)
Abstract. We consider the problem of sending messages “into the future.” Previous constructions for this task were either based on heuristic assumptions or did not provide anonymity to the sender of the message. In the publickey setting, we present an efficient and secure timedrelease encryption scheme using a “time server ” which inputs the current time into the system. The server has to only interact with the receiver and never learns the sender’s identity. The scheme’s computational and communicational cost per request are only logarithmic in the time parameter. The construction of our scheme is based on a novel cryptographic primitive: a variant of oblivious transfer which we call conditional oblivious transfer. We define this primitive (which may be of independent interest) and show an efficient construction for an instance of this new primitive based on the quadratic residuosity assumption. 1
SevenO’Clock: A New Distributed GVT Algorithm Using Network Atomic Operations
 In Proceedings of the Workshop on Parallel and Distributed Simulation (PADS ’05
, 2005
"... In this paper we introduce a new concept, network atomic operations (NAOs) to create a zerocost consistent cut. Using NAOs, we define a wallclocktime driven GVT algorithm called the seven o’clock algorithm that is an extension of Fujimoto’s shared memory GVT algorithm. Using this new GVT algorith ..."
Abstract

Cited by 8 (2 self)
 Add to MetaCart
(Show Context)
In this paper we introduce a new concept, network atomic operations (NAOs) to create a zerocost consistent cut. Using NAOs, we define a wallclocktime driven GVT algorithm called the seven o’clock algorithm that is an extension of Fujimoto’s shared memory GVT algorithm. Using this new GVT algorithm, we report good optimistic parallel performance on a cluster of stateoftheart ItaniumII quad processor systems as well as a dated cluster of 40 dual Pentium III systems for both benchmark applications such as PHOLD and realworld applications such as a largescale TCP/Internet model. In some cases, superlinear speedup is observed. We present a new measurement for determining the optimal performance achieved in a parallel and distributed simulation when the sequential case cannot be performed due to model size. The Seven O’clock algorithm greatly simplifies the GVT synchronization, which is unavoidable for traditional GVT algorithms by creating a zerocost “consistent cut ” across the distributed simulation. 1
Optimal Clock Synchronization under Energy Constraints
 in Wireless AdHoc Networks, The 9th International Conference on Principles of Distributed Systems
, 2005
"... Abstract. Clock synchronization is a crucial service in many distributed systems, including wireless adhoc networks. This paper studies external clock synchronization, in which nodes should bring their clocks close to the value of some external reference time, which is provided in the system by one ..."
Abstract

Cited by 8 (0 self)
 Add to MetaCart
(Show Context)
Abstract. Clock synchronization is a crucial service in many distributed systems, including wireless adhoc networks. This paper studies external clock synchronization, in which nodes should bring their clocks close to the value of some external reference time, which is provided in the system by one or more source clocks. Reference broadcast synchronization (RBS) is a known approach that exploits the broadcast nature of wireless networks for a single hop. However, when networks are large in physical extent, additional mechanisms must be employed. Using multihop algorithms that rebroadcast time information to short distances reduces the energy consumed for clock synchronization. The reason is that energy costs grow more than linearly with the broadcast distance. On the other hand, the quality of the clock synchronization, as measured in the closeness of the clocks, deteriorates as the number of hops increases. This paper shows how to balance these two contradictory goals, achieving optimal clock synchronization while adhering to an energy budget at each node. In particular, a distributed algorithm is presented that uses multihop broadcasting over a shallow infrastructure to synchronize the clocks. The closeness of clock synchronization achieved by the algorithm is proved to be optimal for the given energy constraints.