|
|
| Line 1: |
Line 1: |
| {{Cleanup|date=November 2009}}
| | I am Tatiana and was born on 25 December 1978. My hobbies are Basket Weaving and Computer programming.<br><br>Also visit my blog post ... [http://www.montagestudioafrica.com/?p=148302 4inkjets Coupons] |
| | |
| '''Self-stabilization''' is a concept of [[fault-tolerance]] in [[distributed computing]]. A distributed system that is self-stabilizing will end up in a correct [[State (computer science)|state]] no matter what state it is initialized with. That correct state is reached after a finite number of execution steps.
| |
| | |
| At first glance, the guarantee of self stabilization may seem less promising than that of the more traditional fault-tolerance of algorithms, that aims to guarantee that the system always remains in a correct state, under certain kinds of state transitions. However, that traditional fault tolerance cannot always be achieved. For example, it cannot be achieved when the system is started in an incorrect state or is corrupted by an intruder. Moreover, because of their complexity, it is very hard to debug and to analyze distributed systems. Hence, it is very hard to prevent a distributed system from reaching an incorrect state. Indeed, some forms of self stabilization are incorporated into most modern [[computer network|computer]] and [[telecommunications network|telecommunications]] networks, since it gives them the ability to cope with faults that were not foreseen in the design of the algorithm.
| |
| | |
| Many years after the seminal paper of [[Edsger W. Dijkstra|Edsger Dijkstra]] in 1974, this concept remains important as it presents an important foundation for [[Self-management (computer science)|self-managing computer systems]] and [[fault-tolerant system]]s. As a result, Dijkstra's paper received the 2002 [[Association for Computing Machinery|ACM]] [[PODC Influential-Paper Award]] - one of the highest recognitions in the distributed computing community.<ref>{{Citation | url=http://www.podc.org/influential/2002.html | title=PODC Influential Paper Award: 2002 | work=ACM Symposium on Principles of Distributed Computing | accessdate=2009-09-01}}</ref>
| |
| Moreover, after Dijkstra's death, the award was renamed and is now called the Dijkstra Award.
| |
| | |
| == History ==
| |
| [[Edsger Dijkstra|E.W. Dijkstra]] in 1974 presented the concept of self-stabilization, prompting further research in this area.<ref>{{Citation
| |
| | last1=Dijkstra | first1=Edsger W. | authorlink1=Edsger W. Dijkstra
| |
| | title=Self-stabilizing systems in spite of distributed control
| |
| | journal=[[Communications of the ACM]]
| |
| | volume=17
| |
| | issue=11
| |
| | year=1974
| |
| | pages=643–644
| |
| | doi=10.1145/361179.361202
| |
| | url=http://www.cs.utexas.edu/~EWD/ewd04xx/EWD426.PDF
| |
| }}.</ref>
| |
| He also presented the first self-stabilizing algorithms that did not rely on strong assumptions on the system. Some previous protocols used in practice did actually stabilize, but only assuming the existence of a clock that was global to the system, and assuming a known upper bound on the duration of each system transition.
| |
| It is only ten years later when [[Leslie Lamport]] pointed out the importance of Dijkstra's work that researchers <ref>{{Citation
| |
| | last1=Lamport | first1=Leslie | authorlink1=Leslie Lamport
| |
| | title=Solved problems, unsolved problems, and non-problems in concurrency
| |
| | journal=ACM Special Interest Group Operating Systems Review
| |
| | volume=19
| |
| | year=1985
| |
| | pages=34–44
| |
| | doi= 10.1145/858336.858339
| |
| | url=http://research.microsoft.com/en-us/um/people/lamport/pubs/solved-and-unsolved.pdf
| |
| | issue=4
| |
| }}.</ref>
| |
| directed their attention to this elegant fault-tolerance concept.
| |
| | |
| == Overview ==
| |
| A [[distributed algorithm]] is self-stabilizing if, starting from an arbitrary state, it is guaranteed to converge to a legitimate state and remain in a legitimate set of states thereafter. A state is legitimate if starting from this state the algorithm satisfies its specification. The property of self-stabilization enables a distributed algorithm to recover from a [[transient fault]] regardless of its nature. Moreover, a self-stabilizing algorithm does not have to be initialized as it eventually starts to behave correctly regardless of its initial state.
| |
| | |
| Dijkstra's paper, which introduces the concept of self-stabilization, presents an example in the context of a "[[token ring]]" — a network of computers ordered in a circle, such that exactly one of them is supposed to "hold a token" at any given time.
| |
| * Not holding a token is a correct state for each computer in this network, since the token can be held by another computer. However, if every computer is in the state of "not holding a token" then the network altogether is not in a correct state.
| |
| * Similarly, if more than one computer "holds a token" then this is not a correct state for the network, although it cannot be observed to be incorrect by viewing any computer individually. Since every computer can "observe" only the states of its two neighbors, it is hard for the computers to decide whether the network altogether is in a correct state.
| |
| | |
| The first self-stabilizing [[algorithm]]s did not detect errors explicitly in order to subsequently repair them. Instead, they constantly pushed the system towards a legitimate state, even without explicitly detecting error states. Since traditional methods for detecting an error<ref>{{Citation
| |
| | last1=Katz | first1=Shmuel
| |
| | last2=Perry | first2=Kenneth J.
| |
| | title=Self-stabilizing extensions for meassage-passing systems
| |
| | journal=[[Distributed Computing (journal)|Distributed Computing]]
| |
| | volume=7
| |
| | issue=1
| |
| | year=1993
| |
| | pages=17–26
| |
| | doi=10.1007/BF02278852
| |
| }}.</ref> were often very difficult and time-consuming, such a behavior was considered desirable.
| |
| (The method described in the paper cited above collects a huge amount of information from the whole network to one place; after that, it attempts to determine whether the collected global state is correct; even that determination alone can be a hard task).
| |
| | |
| === Efficiency improvements ===
| |
| More recently, researchers have presented newer methods for light-weight error detection for self-stabilizing systems using local checking.<ref name=awerbuch/><ref name=afek>{{citation
| |
| | last1 = Afek | first1 = Yehuda
| |
| | last2 = Kutten | first2 = Shay
| |
| | last3 = Yung | first3 = Moti | author3-link = Moti Yung
| |
| | doi = 10.1016/S0304-3975(96)00286-1
| |
| | issue = 1-2
| |
| | journal = [[Theoretical Computer Science (journal)|Theoretical Computer Science]]
| |
| | mr = 1478668
| |
| | pages = 199–229
| |
| | title = The local detection paradigm and its applications to self-stabilization
| |
| | url = http://iew3.technion.ac.il/~kutten/aky.ps
| |
| | volume = 186
| |
| | year = 1997}}.</ref> The term ''local'' refers to a part of a computer network. When local detection is used, a computer in a network is not required to communicate with the entire network in order to detect an error — the error can be detected by having each computer communicate only with its nearest neighbors. These local detection methods simplified the task of designing self-stabilizing algorithms considerably. This is because the error detection mechanism and the recovery mechanism can be designed separately. Newer algorithms based on these detection methods also turned out to be much more efficient. Moreover, these papers suggested rather efficient general transformers to transform non self stabilizing algorithms to become self stabilizing. The idea is to,
| |
| # Run the non self stabilizing protocol, at the same time,
| |
| # detect faults (during the execution of the given protocol) using the above mentioned detection methods,
| |
| # then, apply a (self stabilizing) "reset" protocol to return the system to some predetermined initial state, and, finally,
| |
| # restart the given (non- self stabilizing) protocol.
| |
| The combination of these 4 parts is self stabilizing. Initial self stabilizing protocols were also presented in the above papers. More efficient reset protocols were presented later, e.g.<ref name=Awerbuch2>[Baruch Awerbuch, Shay Kutten, Yishay Mansour, Boaz Patt-Shamir, George Varghese. Time optimal self-stabilizing synchronization. ACM STOC 1993: 652-661.]</ref>
| |
| | |
| Additional efficiency was introduced with the notion of time-adaptive protocols.<ref>[http://iew3.technion.ac.il/~kutten/boaz.ps Shay Kutten, Boaz Patt-Shamir: Stabilizing Time-Adaptive Protocols. Theor. Comput. Sci. 220(1): 93-111 (1999).]</ref> The idea behind these is that when only a small number of errors occurs, the recovery time can (and should) be made short. Dijkstra's original self-stabilization algorithms do not have this property.
| |
| | |
| A useful property of self-stabilizing algorithms is that they can be composed of layers if the layers do not exhibit any circular dependencies. The stabilization time of the composition is then bounded by the sum of the individual stabilization times of each layer.
| |
| | |
| === Time complexity ===
| |
| The time [[Computational complexity theory|complexity]] of a self-stabilizing algorithm is measured in (asynchronous) rounds or cycles.
| |
| * A ''round'' is a shortest execution trace in which each processor executes at least one step.
| |
| * Similarly, a ''cycle'' is a shortest execution trace in which each processor executes at least one complete iteration of its repeatedly executed list of commands.
| |
| It is also interesting to measure the output stabilization time. For that, a subset of the state variables is defined to be externally visible (the ''output''). Certain states of outputs are defined to be correct (legitimate). The set of the outputs of all the components of the system is said to have stabilized at the time that it starts to be correct, provided it stays correct indefinitely, unless additional faults occur. The output stabilization time is the time (the number of (asynchronous) ''rounds'') until the output stabilizes.<ref name=awerbuch>{{Citation
| |
| | last1=Awerbuch | first1=Baruch | authorlink1=Baruch Awerbuch
| |
| | last2=Patt-Shamir | first2=Boaz
| |
| | last3=Varghese | first3=George | authorlink3=George Varghese
| |
| | contribution=Self-stabilization by local checking and correction
| |
| | title=Proc. 32nd [[Symposium on Foundations of Computer Science]] (FOCS)
| |
| | year=1991
| |
| | pages=268–277
| |
| | doi=10.1109/SFCS.1991.185378
| |
| }}.</ref>
| |
| | |
| == Definition ==
| |
| A system is self-stabilizing if and only if:
| |
| # Starting from any state, it is guaranteed that the system will eventually reach a correct state (''convergence'').
| |
| # Given that the system is in a correct state, it is guaranteed to stay in a correct state, provided that no fault happens (''closure'').
| |
| | |
| A system is said to be ''randomized self-stabilizing'' if and only if it is self-stabilizing and the expected number of rounds needed to reach a correct state is bounded by some constant <math>k</math>.<ref>{{Citation
| |
| | last=Dolev | first=Shlomi | authorlink=Shlomi Dolev
| |
| | title=Self-Stabilization
| |
| | publisher=[[MIT Press]]
| |
| | year=2000
| |
| | isbn=0-262-04178-2
| |
| }}.</ref>
| |
| | |
| Design of self-stabilization in the above mentioned sense is well known to be a difficult job. In fact, a class of distributed algorithms do not have the property of local checking: the legitimacy of the network state cannot be evaluated by a single process. The most obvious case is Dijkstra's token-ring defined above: no process can detect whether the network state is legitimate or not in the case where more than one token is present in non-neighboring processes. This suggests that self-stabilization of a distributed system is a sort of [[group intelligence]] where each component is taking local actions, based on its local knowledge but eventually this guarantees global convergence at the end.
| |
| | |
| To help overcome the difficulty of designing self-stabilization as defined above, other types of stabilization were devised. For instance, ''weak stabilization'' is the property that a distributed system has a possibility to reach its legitimate behavior from every possible state.<ref>{{Citation
| |
| | last=Gouda | first=Mohamed | authorlink= Mohamed Gouda
| |
| | title=The Triumph and Tribulation of System Stabilization
| |
| | publisher=Proceedings of the 9th international workshop on distributed algorithms.
| |
| | year=1995
| |
| | url=http://www.cs.utexas.edu/users/gouda/papers/book%20chapters/11-whole.pdf>
| |
| }}.</ref>
| |
| Weak stabilization is easier to design as it just guarantees a ''possibility'' of convergence for some runs of the distributed system rather than convergence for every run.
| |
|
| |
| A self-stabilizing algorithm is ''silent'' if and only if it converges to a global state where the values of communication registers used by the algorithm remain fixed.<ref>[[Shlomi Dolev]], Mohamed G. Gouda, and Marco Schneider. [http://doi.acm.org/10.1145/248052.248055 Memory requirements for silent stabilization]. In PODC '96: Proceedings of the fifteenth annual ACM [[Symposium on Principles of Distributed Computing]], pages 27--34, New York, NY, USA, 1996. ACM Press. [http://citeseer.ist.psu.edu/dolev96memory.html Online extended abstract].</ref>
| |
| | |
| == Related work ==
| |
| An extension of the concept of self-stabilization is that of [[superstabilization]].<ref>{{Citation
| |
| | last1=Dolev | first1=Shlomi | authorlink1=Shlomi Dolev
| |
| | last2=Herman | first2=Ted
| |
| | title=Superstabilizing protocols for dynamic distributed systems
| |
| | journal=Chicago Journal of Theoretical Computer Science
| |
| | url=http://cjtcs.cs.uchicago.edu/articles/1997/4/contents.html
| |
| | year=1997
| |
| }}, article 4.</ref>
| |
| The intent here is to cope with dynamic distributed systems that undergo topological changes. In classical self-stabilization theory, arbitrary changes are viewed as errors where no guarantees are given until the system has stabilized again. With superstabilizing systems, there is a ''passage'' predicate that is always satisfied while the system's topology is reconfigured.
| |
| | |
| == References ==
| |
| {{reflist}}
| |
| | |
| == External links ==
| |
| * [https://github.com/hpc/libcircle libcircle] - An implementation of self-stabilization using token passing for termination.
| |
| | |
| {{DEFAULTSORT:Self-Stabilization}}
| |
| [[Category:Distributed computing problems]]
| |
| [[Category:Fault-tolerant computer systems]]
| |
| [[Category:Dutch inventions]]
| |
| | |
| {{Link FA|fr}}
| |