Continuous Clock Synchronization in Wireless Real-Time Applications
Michael Mock
GMD - German National Research
Center for Information Technology
D-53754 St. Augustin
[email protected]
Edgar Nett
University of Magdeburg
Institute for Distributed Systems
Universitätsplatz 2
D-39106 Magdeburg
[email protected]
Reiner Frings
GMD - German National Research
Center for Information Technology
D-53754 St. Augustin
[email protected]
Spiro Trikaliotis
University of Magdeburg
Institute for Distributed Systems
Universitätsplatz 2
D-39106 Magdeburg
[email protected]
Abstract
Continuous clock synchronization avoids unpredict-able instantaneous corrections of clock values. This is usually achieved by spreading the clock correction over the synchronization interval. In the context of wireless real-time applications, a protocol achieving continuous clock synchronization must tolerate message losses and should have a low overhead in terms of the number of messages. This paper presents a clock synchronization protocol for continuous clock synchronization in wireless real-time applications. It extends the IEEE 802.11 stan-dard for wireless local area networks. It uses the same number of messages as the instantaneous clock synchro-nization of the standard does, but provides continuous clock synchronization, and improves the precision by ex-ploiting the tightness of the communication medium, and tolerates message losses. Due to message losses, syn-chronization intervals are of non-predictable length. Hence, the clock correction can not be simply spread over the synchronization interval. Instead, continuous clock synchronization is achieved based on an advanced algo-rithm adjusting the clock rates. We present the design of the protocol, its mathematical analysis, and measure-ments of a driver level implementation of the protocol on Windows NT.
1. Introduction
Supporting closely coupled, distributed real-time ap-plications is a new challenge for the design of wireless communication protocols. Example applications are found in the area of cooperating mobile autonomous systems that act under real-time constraints imposed by their lo-comotion, e.g. experimental traffic control systems based on car-to-car communication and cooperative robotic sys-tems. For practical reasons, the development of real-time communication protocols should be based on the IEEE 802.11 standard for wireless communication in local area networks [2].
The IEEE 802.11 standard includes a simple mas-ter/slave protocol for clock synchronization, which, how-ever, achieves only limited precision and is based on in-stantaneous synchronization. This approach has well-known drawbacks with respect to distributed real-time applications: An instantaneous forward correction causes gaps in the local time, leading to a faulty local interval measurement, and an instantaneous backward correction additionally causes negative interval measurements. Con-tinuous synchronization avoids these drawbacks by spreading the correction over the next synchronization period and applying it continuously. In [4
,
10], a
generalapproach for achieving continuous correction in any round-based clock synchronization protocol is shown. However, message losses in the wireless environment can lead for some systems to miss some rounds, thus making this basic approach not applicable. In [12], the authors show how a discrete clock can be converted into a con-tinuous one. This approach even works with message losses. Anyway, they do not deal with the message deliv-ery variance, which is dealt with in [11], but not the mes-sage losses. Our paper investigates on the effects of both in regards to continuous clocks.
Fault-tolerant algorithms for clock synchronization [3,6,7] cope with message losses by introducing redun-dancy in form of extra messages. This would be a possible approach for guaranteeing that every system participates in each round, hence being a base for continuous clock synchronization. However, these protocols are implicitly designed for wired communication links that offer a suffi-ciently high bandwidth and a considerable reliability with respect to message delivery. In contrast to that, the wire-less link has relatively low bandwidth and a poor reliabil-ity. Furthermore, these protocols do not comply with the IEEE 802.11 standard, which prescribes a simple, non-redundant master/slave based structure for the clock syn-chronization protocol. Hence, achieving continuous clock synchronization in this environment must cope with the fact that systems may not participate in every synchroniza-tion round, leading to synchronizasynchroniza-tion intervals of non-predictable length.
In [11,12], the authors show how to achieve good pre-cision in arbitrary networks. The main scope of our paper is not to invite a new sophisticated sync protocol, but we try to design a high-precision protocol especially tailored for the wireless environment with inherent message losses. [12] deals with message losses and continuous clocks, too, but it cannot benefit from information about the time from the past, while our protocol will do in our environment. [11] handles the question how to deal with the message delivery variance, but the solution there is not adequate for our environment because the network traffic might become very high. Our protocol explores the specific properties of the wireless environment to achieve this goal with much less costs. As for the IEEE protocol, it should
be possible to put our protocol on-chip to achieve this goal even better.
Our protocol adopts the master/slave structure of the IEEE 802.11 clock synchronization protocol and achieves continuous clock synchronization by using a rate-based correction algorithm. Each system is equipped with a physical clock. These clocks can have different clock rates. On each slave system, a virtual clock is calculated from its physical clocks by applying a linear correction term. Thus, the clock rates of the virtual clocks can be adjusted to match the rate of the physical master clock. Correction terms are derived from the clock synchroniza-tion protocol that exploits the tightness of the broadcast medium. Since the rates of the virtual clocks are adjusted during the protocol such that large gaps between the vir-tual clocks and the master clock are avoided, the negative effects of missing a synchronization round are alleviated.
The exchange of time information among the included nodes in our protocol is described in detail in [8], while the clock adjustment on the nodes and the resulting fault-tolerance properties are described in this paper.
The paper is organized as follows: Section 2 introduces our basic protocol as described in [8]. The rate-based cor-rection algorithm used in the protocol is presented in sec-tion 3. In Secsec-tion 4, we analyze the precision achieved by the protocol, and we compare that result with a measure-ment of an implemeasure-mentation in a Windows NT NDIS driver for Lucent WaveLAN cards in Section 5. Conclusions are given in section 6.
2. The clock synchronization protocol
This section summarizes the operation of our protocol (see [8] for a more detailed description). The IEEE 802.11 standard already provides a master/slave clock synchronization mechanism for the so-called infrastruc-ture networks. A special fixed node, the access point, is used as clock master. It periodically sends a high-priority message ("beacon frame"). This beacon frame includes a time-stamp of the access point's local clock that serves for synchronizing the clocks of all slaves.
The synchronization protocol works as follows (see Fig. 1): the master takes its local time-stamp (t1) and broadcasts it (t2). All slaves physically receive this mes-sage at their network interface cards (NICs) at t3 and
ad-just their local clocks (t4). The precision that can be achieved is bounded by the variance of the time-critical path. In this approach the time-critical path is the time between the master takes its time-stamp and the slaves adjust their local clocks (t1 to t4). In the IEEE protocol, instantaneous correction is applied, so the resulting clocks cannot be guaranteed to be continuous.
t1 t2 t3 t4
m a s te r s la v e
tim e Figure 1. Time-critical path of IEEE clock
synchroni-zation.
Our protocol increases the precision of the IEEE 802.11 clock synchronization protocol by exploiting the broadcast property of the wireless communication me-dium. As in [1,7], we assume that message reception is tight, i.e., if any two receivers receive the same frame, they receive it approximately at the same time. As Fig. 2 shows, we achieve a higher precision by reducing the time-critical path with the following procedure (that we have already applied in our clock synchronization proto-col for the CAN-bus [1]):
t1 t2 t3 t4
master slave
time
ts t5 t6
Figure 2. Clock synchronization with a reduced time-critical path (t3 to ts).
The master prepares an indication message (t1) and broadcasts it (t2). The transmission delay of this message is irrelevant for the precision of the clock synchronization, the protocol only assumes that message reception is tight.
Each slave (and the master) receives the indication message (t3) and takes a local time-stamp (ts). Calculating and adjusting new slave clock values (t4) is not needed at this time, thus we can assume that the delay of an interrupt routine that time-stamps the reception of an indication message is bounded and has a small variance.
The master sends its own time-stamp for the last indi-cation message (t5) and each slave compares the master time-stamp with its own time-stamp for the reception of
the last indication message, computes the difference and adjusts its local clock (t6).
The waste of bandwidth (two messages per synchroni-zation) can be reduced by an additional modification: the master time-stamp for the last indication message now serves as new indication message, so we have only one synchronization message to be sent per synchronization period.
Let us now consider the fault-tolerance properties of the protocol in the context of the IEEE 802.11 standard. Applying the protocol in this context means that the ac-cess point works as master, and that the beacon frame includes the time-stamp of the reception of the previous beacon frame. As in the IEEE 802.11 standard, we con-sider the access point to be stable. However, the problem of message losses still has to be tackled. The number of message losses is considerably higher than for wired local area networks, because the wireless medium is unshielded and thus exposed to external interference. Exploiting the tightness of message reception for synchronizing the clocks relies on analyzing the contents of the time-stamp message that refers to the reception of an earlier (indica-tion) message. Thus, any fault-tolerant variation of the protocol still requires the successful reception of at least two different messages at the slave station. However, we can omit the requirement that these two messages must be consecutive. We assume OD (“omission degree”) to be an upper bound on number of consecutive messages that can get lost on the medium. In order to tolerate up to OD con-secutive message losses, the time-stamp values for the last n (with n=OD+1) synchronization messages are included in each synchronization message. Thus, on the reception of a synchronization message, a client can synchronize its local clock with the master clock if it has received at least one of the preceding n synchronization messages.
In greater detail: Let smi denote the i-th synchroniza-tion message being sent by the master. Let tmi denote the time-stamp of the master and ti the time-stamp of the slave for the reception of that message. Then, each syn-chronization message contains, besides its sequence num-ber i, the values of tmi-n, tmi-n+1, tmi-n+2, …, and tmi-1. Sup-pose that the last synchronization message received by the slave is smj at the slave time tj. If the slave now receives smi, and if i-j≤n, then the value of tmj is included in smi
and the slave can adjust its local clock based on the pair (tj, tmj). The adjustment of the local clock achieves con-tinuous synchronization by changing virtual clock rates. The next section shows how this adjustment is calculated.
3. The time-adjustment algorithm
The clock synchronization protocol described so far delivers correction values as input for the time adjustment. In this section, the rate-based algorithm for adjusting the virtual clocks of the slaves is explained. Each node is equipped with a physical clock. The physical clock pcp of a node p consists of an oscillator which periodically gen-erates events and a counter which counts these events. Let us assume that events are generated at a high frequency allowing us to ignore the discreteness of the physical clock in the rest of this section. This physical clock is not adjustable in any way, i.e., it’s value cannot be set back or forth and the frequency is fixed. Many existing clocks behave that way.
Two physical clocks tend to drift away from each other, i.e., the difference between their clock values |pcp(t)-pcq(t)| at some point of real time t grows un-bounded as t grows. For describing the effects of the drift, we introduce the term drift rate, which gives a value showing how the physical clock behaves with respect to real time, i.e., the drift rate drp of node p’s clock is de-fined by |(pcp(t2)-pcp(t1))/(t2-t1)-1|. The clock’s manufac-turer specifies the maximum drift rate of the clock, i.e., a δp such that drp ≤ δp. In general, the actual drift rate of a physical clock is a constant.
In order to get clock values on a slave that are syn-chronized with the physical clock of the master, we intro-duce the notion of a virtual clock as a function from physical clock values to virtual clock values. Since the virtual clock intends to correct the drift rate of the physi-cal clock of the slave such that it resembles the physiphysi-cal clock of the master, and for reasons of simplicity, the function is a linear transformation. The parameters of that transformation can be corrected with every new synchro-nization, thus making the behavior of the virtual clock more and more close to the master clock. Thus, adjusting the virtual clock on a slave station means changing the mapping from physical to virtual clock values. Now,
con-tinuous clock synchronization just means that the virtual clock’s function should be steady, i.e., changing the pa-rameter of the virtual clock must be done in such a way that there are not gaps in the resulting overall function.
In the remainder of the section, we explain how pa-rameters for the virtual clock are computed. Each slave tries to mimic the behavior of the master clock. MC is the function describing the master clock at a slave. Since a physical clock’s drift rate is a constant, this function is a linear function, i.e., its graph is a straight line. Let SC be the virtual clock of a slave that is corrected at every syn-chronization point.
Fig. 3 shows the master clock (MC) and the virtual clock of a slave (SC) in dependency of the slave’s physi-cal clock. Now, we consider the physiphysi-cal slave time ti-1, when the slave has just received the synchronization mes-sage smi-1 as described in section 2.
ti-1 t*i ti SCi-1 SC*i tj tj+k tmj+k tmj P P‘ MC SC‘i Vi rt ua l clo ck Physical clock of slave Ti-1 T* i Q Q‘
Figure 3. The time adjustment
The values tmj, tmj+k contained in that message indi-cate the master time-stamps for the synchronization mes-sages smj and smj+k, respectively, tj, tj+k indicate the cor-responding time-stamps on the slave’s physical clock. ti is the next synchronization point which might not be known at this time. t*i is some physical time between ti-1 and ti (see below). Ti-1 and T*i are the corresponding virtual times of the slave clock for physical times ti-1 and t*i , re-spectively.
In Fig. 3 the virtual clock of the slave consists of three parts, SCi-1, SC*i and SC'i. At time ti-1 we have to calculate SC*i and SC'i . SCi-1 is the currently valid virtual slave time calculated at a former synchronization point. SC*i and SC'i are computed in three steps:
First we calculate MC which is defined by P and P’ corresponding to two former synchronization points (see Fig. 3). Next we define t*i such that SC*i can be derived from Q and Q’. t*i should be defined in a way that SC*i smoothly approaches MC and the clock rate does not be-come negative. Finally we set SC'i = MC for the interval [t*i , ti].
More precisely we look how to calculate MC, SC*i and SC'i. At time ti-1 we have two master clock time stamps available (tmj and tmj+k) and also the corresponding slave clock time stamps (tj and tj+k) respectively, for 0 ≤ j < j+k < i-1. Then, MC is simply the line going through the points P'(tj,tmj) and P(tj+k,tmj+k), i.e., the equations tmj=MC(tj) and tmj+k=MC(tj+k) define MC. Let: SC*i(t) := m*i t + b*i and SC'i(t) := mi t + bi.
To compute SC*i and SC'i we have to calculate m*i , b*i , mi and bi .
For SC*i we have to know the coordinates of Q'(ti-1,Ti-1) and Q(t*i ,T*i). ti-1 is known since it’s the cur-rent (physical) time. Ti-1 = SCi-1(ti-1) is the current virtual time. Define t*i = ti-1+bcorrect where bcorrect > 0 is an a priori known protocol parameter and T* = MC(ti *i). It fol-lows that we can calculate m*i and b*i by
m* = (Ti * - Ti i-1)/(t* - ti i-1) and b* = Ti i-1 - m* ti i-1. Since SC'i = MC, we observe that SC'i is defined by P'(tj,tmj) and P(tj+k,tmj+k). We get
mi = (tmj+k - tmj)/(tj+k - tj) and bi = tmj+k - mi tj+k .
4. Achieved precision
The precision of a set of synchronized clocks is the maximum deviation of the clock values of all clocks at any time. In [5] a lower bound on the achievable precision is given. Since the clocks are drifting away without syn-chronization, one cannot guarantee any precision without limiting the number of message losses. For this, we as-sume that no more than OD (=omission degree) consecu-tive synchronization messages are lost.
There are essentially two things that affect the preci-sion of a synchronization algorithm: The inaccuracy in determining each other’s clocks, and the clock drift be-tween the synchronization points. The clock drift is caused by the non-zero drift rates of the clocks, while the inaccuracy in determining each other’s clocks is primarily caused by the variance of the time-critical path. For this section, let δ be the maximum variance of the time-critical path possible (the so-called jitter). Furthermore, let ∆t be the time difference on the physical clock of a slave p be-tween the two timestamps it uses to adjust its clock. Due to the jitter, the calculated master clock MC differs from the actual master clock. First, it should be determined which is the highest and the lowest possible gradient with that jitter.
Let P'(tj,tmj) and P(tj+k,tmj+k) be the two points used to determine the master clock (see the notation introduced in Fig. 3 in the previous section). If the jitter was zero, the slave could determine these two points exactly. However, the actual parameter used for the calculation for tj lies in the range [tj-½δ, tj+½δ], resulting in a jitter of δ. The same applies to tmj, tj+k, and tmj+k. Thus, the resulting points P'(tj,tmj) and P(tj+k,tmj+k) lie anywhere inside the grayed areas of Fig. 4. Then, the gradient of the resulting straight line is at least the gradient mlow of Glow and at most the gradient mhigh of Ghigh. The gradient mhigh can be calculated by
mhigh = (tmj+k+½δ-(tmj-½δ)) / (tj+k-½δ-(tj+½δ)) = (∆T+δ)/(∆t-δ),
mlow by mlow = (tmj+k-½δ-(tmj+½δ)) / (tj+k+½δ-(tj-½δ)) = (∆T-δ)/(∆t+δ)
½δ ½δ P‘ P ∆t ∆T MC Ghigh Glow ½δ ½δ Vi rt ua l cl oc k Physical clock of slave ½δ ½δ ½δ ½δ tmj+k tmj tj tj+k
Figure 4. Error due to jitter on calculating MC
Now we are able to calculate the resulting precision of this protocol. Let tq be the latest point in time at which a synchronization can occur (see Fig. 5). It holds tq = ti + MAX for some MAX > 0 that is derived from OD and the synchronization interval (details are given in the next paragraph). Obviously, the maximum difference be-tween any two clocks only can be achieved at tq, since until that time, the clocks have been drifting away from each other, while after tq, the clocks are moving towards due to the synchronization algorithm. Thus, the precision Π is Π = Ghigh(tq) - Glow(tq). tq Π Vi rt ua l cl oc k Physical clock of slave tmj+ k tmj tj tj+k
Figre 5. Calculating the precision of the protocol
The value MAX, i.e., the maximum time between two synchronizations, can be calculated as follows. With every received synchronization message on a slave, a synchroni-zation can occur provided that no more than OD consecu-tive messages are lost. Fig. 6 shows the rounds of the pro-tocol. Assume that in round n, a synchronization message is received by a slave. This message must have been re-ceived until time (n+1)INT provided that INT is the
length of the synchronization interval. On the other hand, at most the messages of the rounds n-1 to n-OD can be lost, because else, more than OD messages were lost. So, the previous received message cannot be older than the message of round n-OD-1, which was not received before time (n-OD-1)INT. So, the maximum time MAX between two consecutive synchronizations is MAX = (n+1)INT - (n-OD-1)INT = (OD+2)INT.
n-2 n-1 n n+1
n-OD-1 n-OD n-OD+1
OD Slots
(n-OD-1)⋅INT (n+1)⋅INT
Figure 6. Determining the time between synchronizations
Setting
Ghigh(t) = mhigh t + bhigh and Glow(t) = mlow t + blow in the formula for the precision, the precision is deter-mined by
Π = (mhigh-mlow) tq + (bhigh-blow).
The values of mhigh and mlow are known from above, so it remains to calculate bhigh-blow. It’s
bhigh = tmj+k+½δ - mhigh(tj+k-½δ) and since P has to be on the lines, so
bhigh-blow = ½δ ( 2 + mhigh + mlow) + (mhigh + mlow)tj+k. Putting this result into the above formula, the precision is Π = (mhigh-mlow) MAX + ½δ(2+mhigh+mlow).
Further, mhigh-mlow = ∆T+δ
∆t-δ - ∆T-δ ∆t+δ =
2δ(∆T+∆t) (∆t)²-δ² ≤ 2δ∆t(ρ+2)
(∆t)²-δ² ,
and mhigh+mlow = ∆T+δ
∆t-δ + ∆T-δ ∆t+δ ≤ 2(∆t)²(1+ρ)+2δ² (∆t)²-δ² . We get the result that the precision of this protocol is
Π ≤ 2δ∆t(ρ+2)
(∆t)²-δ² (OD+2)INT + δ(1+ (∆t)²(1+ρ)+δ² (∆t)²-δ² ).
5. Discussion and Measurements
In this section, we discuss the achieved precision of the protocol and compare it with measured results of our im-plementation. We start by reporting some basic values (e.g. jitter) occurring in our implementation environment. These values are needed to fill the formula for the
preci-sion obtained in the previous section. Furthermore, we measure the actual precision obtained by our implementa-tion. Recall that the calculated precision holds for the worst case message loss assumptions. The measured pre-cision turns out to be better. This is discussed in detail later on.
The measurement environment depicted in Fig. 7 is de-scribed in greater detail in [8]. The stations are connected to a central monitoring station via dedicated connections on the parallel ports. This station scans for any incoming event in a busy loop, takes a time-stamp and logs the event. We measured a resolution of about 5 µs for distrib-uted events in this environment, thus it can be used to measure deviations in message reception and deviations of clocks with a high accuracy.
Global Tim e-stamper SUT
W ireless LA N NIC
Parallel port cable
Figure 7. Measurement environment.
All measurement results are reported in detail in [9]. We measured a maximum jitter of about 43 µs, and a maximum deviation of about 150 µs (see Fig. 8) for our implementation, where we let the clocks synchronize for some time and measured the precision as described above. The synchronization interval was 1 s, we used a second timestamp which is not older than 10 s for calculating the master clock, i.e., ∆t = 10 s, and OD=8, and the used physical clocks had a drift rate of about 2⋅10-5.
-100 -50 0 50 100 150 0 50 100 150 200 250 300 350 400 450 500 elapsed time [s] d eviat io n [ µ s]
our protocol, precision = 150 µs master clock
Figure 8. Deviation of master clock and slave clock.
As we will see now, that value complies with the ana-lytical result from the previous section. Putting ∆t =10 s, OD=8, ρ = 2⋅10-5, and a jitter of 50 µs into the formula from the previous section, we get a precision of about 300 µs, while the experimentally determined maximum deviation is lower. This is not surprising because the ana-lytical result is a worst-case result. The worst case of mes-sage loss is expressed by the omission degree OD.
Fig. 9 (with ∆t = 10 s and INT = 1 s fixed, OD vari-able, all other parameters as above) shows the linear de-pendency of the calculated precision from the parameter OD. Of course, the correct value for OD cannot be freely chosen, but is determined by the transmission characteris-tics of the wireless media in a given working environment. However, this figure can be interpreted to indicate how well the theoretical and the measured results fit together. Although the measured protocol is running with OD=8 (i.e., can tolerate up to 8 consecutive message losses), it exhibits a measured precision of 150 µs. This reflects the fact that in the normal case, no or at most one message is lost (setting OD hypothetically to 0 or 1 yields a calcu-lated precision of 140 µs or 160 µs, respectively).
0 100 200 300 400 500 600 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 OD P räz is io n [ µ s]
Figure 9. Precision in dependency of omission degree OD
Finally, we discuss the properties of the precision for-mula derived in the previous section using the actual val-ues determined above. The aim is to derive feasible valval-ues for the protocol parameters ∆t as introduced in section 3 and the synchronization interval. Fig. 10 shows the preci-sion in dependency of the time difference ∆t.
0 100 200 300 400 500 600 700 800 900 1000 1100 1200 1300 1400 1500 1600 1700 1800 1900 2000 2100 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 ∆t [s] P recisio n [ µ s]
Figure 10. Precision in dependency of elapsed time
We see that with ∆t = 1 s, we only get a very poor pre-cision of 2.1 ms. The reason for this poor result is the nu-merical instability of the used calculations with low ∆t (observe that ∆t is always part of the denominator of the formula). Yet, a growing ∆t leads to a far better precision soon, i.e., ∆t = 3 s gives a precision of less than 800 µs, for example. Calculating the limes of the formula, we see that the precision cannot get better (e.g. lower) than Πmin =2δ=100 µs. With this in mind and looking at Fig. 10, it seems that ∆t = 10 s giving a precision of approx. 300 µs be a good trade-off between effort (e.g., initialization time needed to be able to guarantee that precision) and the achieved result.
Now, let us consider how the size of the synchroniza-tion interval affects the precision. Table 1 shows the pre-cision in dependency of the synchronization interval INT (with ∆t = 10 s fixed).
INT Precision INT Precision 10 ms 102 µs 1 s 300 µs 50 ms 110 µs 2 s 500 µs 100 ms 120 µs 5 s 1.100 µs 500 ms 200 µs 10 s 2.100 µs
Table 1. Precision in dependency of INT
We see that a large interval INT leads to a poor preci-sion, while an interval of 1 s or lower results in a precision no more than 3 times away from the lowest possible preci-sion of 100 µs. Again, INT = 1 s (or slightly less) seems
to be a reasonable trade-off between effort (i.e., network traffic) and result here.
6. Conclusion
We have designed and implemented a clock synchroni-zation protocol for wireless LANs that extends the IEEE 802.11 standard with continuous, high precision clock synchronization. The protocol exploits the tightness of the underlying broadcast medium and applies an advanced algorithm for rate-based correction of virtual clocks. We analyzed the precision of the protocol under worst case assumptions with respect to message losses and compared the analytical result with our protocol implementation.
Our protocol is specifically designed for our wireless environment, to be able to work with little network traffic, resulting in a continuous clock with high precision. It ex-ploits the knowledge of the deviation of a slave’s clock from the master’s clock from the past and now, resulting in an improved precision in the long run.
We have tested our protocol in an environment we were given by a cooperation contract with Lucent Technologies, providing us the device driver sources for their PCMCIA WaveLAN cards. At that implementation level, we measured a precision of about 150 µs. From our analysis, we derive that the achievable precision is bounded by the double of the message receiving’s jitter. Even if no message was lost at all, the best achievable precision in our environment is 140 µs. Hence, it would be interesting to implement the protocol on-chip to reduce the jitter, leading to an even increased precision. This implementation is not very difficult since only the time-critical part of the protocol has to be implemented on-chip (see Fig. 2). All calculations that relate to the rate-based time adjustment are not on that path and can be done on another level, i.e., in the device driver.
7. References
[1] M. Gergeleit, and H. Streich, “Implementing a Distributed High-Resolution Real-Time Clock using the CAN-Bus”,
1st international CAN-Conference 94, Mainz, 13.-14.09.,
CAN in Automation e.V., Erlangen 1994.
[2] IEEE, “Wireless LAN Medium Access Control (MAC) and Physical Layer (PHY) specifications”, IEEE Std. 802.11-1997, November 1997.
[3] H. Kopetz, and W. Ochsenreiter, “Clock Synchronization in Distributed Real-Time Systems”, IEEE Transactions on Computers, Vol. C-36, No. 8, August 1987, pp. 933-940. [4] L. Lamport, and P. Melliar-Smith, “Synchronizing Clocks
in the Presence of Faults”, Journal of the ACM 32(1), January 1985, pp. 52-78.
[5] J. Lundelius, and N. Lynch, “An upper and lower bound for clock synchronization”, Inf. Control 62, 1984, pp. 190-204.
[6] J. Lundelius Welch, and N. Lynch, “A New Fault-Tolerant Algorithm for Clock Synchronization”, Inf. Computing 77, 1988, pp.1-36.
[7] P. Veríssimo, and L. Rodrigues, “A posteriori Agreement for Fault-tolerant Clock Synchronization on Broadcast Networks”, 22th Int. Symp. on Fault-Tolerant Computing, Boston, July 1992.
[8] M. Mock, R. Frings, E. Nett, and S. Trikaliotis, “Clock Synchronization for Wireless Local Area Networks”, 12th Euromicro Conference on Real-Time Systems (ECRTS), Stockholm, June 2000.
[9] S. R. Trikaliotis, “Uhrensynchronisation in einem lokalen Funknetzwerk”, diploma thesis, University of Bonn, February 2000.
[10] T. K. Srikanth, and S. Toueg, “Optimal clock synchroniza-tion“, Journal of the ACM 34(3), July 1987, pp. 626-645. [11] F. Cristian, “Probabilistic Clock Synchronization“,
Dis-tributed Computing 3, 1989, pp. 146-158.
[12] F. Schmuck, and F. Cristian, “Continuous Clock Amortiza-tion Need Not Affect the Precision of a Clock Synchroni-zation Algorithm“, Proceedings of the Ninth Annual ACM Symposium on Principles of Distributed Computing, Que-bec, August 1990, pp. 131-143.
