Network updates such as policy and routing changes occur frequently in Software Defined Networks (SDN). Updates should be performed consistently, preventing temporary disruptions, and should require as little overhead as possible. Scalability is increasingly becoming an essential requirement in SDN. In this paper we propose to use time-triggered network updates to achieve consistent updates. Our proposed solution requires lower overhead than existing update approaches, without compromising the consistency during the update. We demonstrate that accurate time enables far more scalable consistent updates in SDN than previously available. In addition, it provides the SDN programmer with fine-grained control over the tradeoff between consistency and scalability.
The use of time in distributed applications has been widely analyzed, both in theory and in practice. Analysis of the usage of time and synchronized clocks, e.g., Lamport @cite_4 @cite_5 dates back to the late 1970s and early 1980s. Accurate time has been used in various different applications, such as distributed database @cite_0 , industrial automation systems @cite_7 , automotive networks @cite_35 , and accurate instrumentation and measurements @cite_31 . While the usage of accurate time in distributed systems has been widely discussed in the literature, we are not aware of similar analyses of the usage of accurate time as a means for performing consistent updates in computer networks.
@cite_35 @cite_4 @cite_7 @cite_0 @cite_5 @cite_31
2143229717 2114658430 2137536023 1503941956
Recent advances in miniaturization and low-cost, low-power design have led to active research in large-scale networks of small, wireless, low-power sensors and actuators. Time synchronization is critical in sensor networks for diverse purposes including sensor data fusion, coordinated actuation, and power-efficient duty cycling. Though the clock accuracy and precision requirements are often stricter than in traditional distributed systems, strict energy constraints limit the resources available to meet these goals.We present Reference-Broadcast Synchronization, a scheme in which nodes send reference beacons to their neighbors using physical-layer broadcasts. A reference broadcast does not contain an explicit timestamp; instead, receivers use its arrival time as a point of reference for comparing their clocks. In this paper, we use measurements from two wireless implementations to show that removing the sender's nondeterminism from the critical path in this way produces high-precision clock agreement (1.85 ± 1.28μsec, using off-the-shelf 802.11 wireless Ethernet), while using minimal energy. We also describe a novel algorithm that uses this same broadcast property to federate clocks across broadcast domains with a slow decay in precision (3.68 ± 2.57μsec after 4 hops). RBS can be used without external references, forming a precise relative timescale, or can maintain microsecond-level synchronization to an external timescale such as UTC. We show a significant improvement over the Network Time Protocol (NTP) under similar conditions. Modern shared-memory multiprocessors use complex memory system implementations that include a variety of non-trivial and interacting optimizations. More time is spent in verifying the correctness of such implementations than in designing the system. In particular, large-scale Distributed Shared Memory (DSM) systems usually rely on a directory cache-coherence protocol to provide the illusion of a sequentially consistent shar ed address space. Verifying that such a distributed protocol satisfies sequential consistency is a difficult task. Current formal protocol verification techniques [18] complement simulation, but ar e some what nonintuitive to system designers and verifiers, and they do not scale well to practical systems. In this paper, we examine a new reasoning technique that is precise and (we find) intuitive. Our technique is based on Lamport’ s logical clocks, which were originally used in distributed systems. We make modest extensions to Lamport’ s logical clocking scheme to assign timestamps to r elevant protocol events to construct a total ordering of such events. Such total orderings can be used to verify that the requirements of a particular memory consistency model have been satisfied. We apply Lamport clocks to prove that a non-trivial directory protocol implements sequential consistency. T o do this, we describe an SGI Origin 2000-like protocol [12] in detail, provide a timestamping scheme that totally orders all protocol events, and then prove sequential consistency (i.e., a load always returns the value of the “last” stor e to the same address in timestamp order). In this paper, we describe a global distributed solution that enables the simultaneous performance of time synchronization and positioning in ultra-wideband (UWB) ad hoc networks. On the one hand, the proposed synchronization scheme basically relies on cooperative two-way-ranging time-of-arrival transactions and a diffusion algorithm that ensures the convergence of clock parameters to average reference values in each node. Although the described solution is generic at first sight, its sensitivity to time-of-arrival accuracy imposes the choice of an impulse-radio ultra-wideband physical layer in the very context. On the other hand, a distributed algorithm coupled with this synchronization scheme mitigates the impact of non-line-of-sight ranging errors on positioning accuracy without any additional protocol hook. More particularly, the realistic UWB ranging error models we use take into account UWB channel effects, as well as detection noises and relative clock drifts. Then, it is demonstrated that a cooperative and distributed maximization of the log-likelihood of range estimates can reduce the uncertainty on estimated positions in comparison with classical distributed weighted least squares approaches. Finally, the proposed distributed maximum log-likelihood algorithm proves to preserve a reasonable level of complexity in each node by approximating asynchronously the positive gradient direction of the log-likelihood function. For both distributed synchronization and positioning algorithms, simulation results are provided to illustrate the relevance of such a solution. Techniques such as replication and caching of objects that implement distributed services lead to consistency problems that must be addressed. We explore new consistency protocols based on the notion of object value lifetimes. By keeping track of the lifetimes of the values stored in shared objects (i.e., the time interval that goes from the writing of a value until the latest time when this value is known to be valid), it is possible to check the mutual consistency of a set of related objects cached at a site. Initially, this technique is presented assuming the presence of physical clocks. Later, these clocks are replaced by vector clocks and then by plausible clocks. Lifetimes based on such clocks result in weaker consistency but do provide more efficient implementations.