OpenRFC.org Requests For Comments ... for the community
Welcome to OpenRFC
Home Full RFC index RFC humour Our technology
 
RFC 1589
A Kernel Model for Precision Timekeeping.
D. Mills. March 1994.

 
[Direct link][Download PDF version][Download text version]
 

Network Working Group D. Mills Request for Comments: 1589 University of Delaware Category: Informational March 1994 A Kernel Model for Precision Timekeeping Status of this Memo This memo provides information for the Internet community. This memo does not specify an Internet standard of any kind. Distribution of this memo is unlimited. Overview This memorandum describes an engineering model which implements a precision time-of-day function for a generic operating system. The model is based on the principles of disciplined oscillators and phase-lock loops (PLL) often found in the engineering literature. It has been implemented in the Unix kernel for several workstations, including those made by Sun Microsystems and Digital Equipment. The model changes the way the system clock is adjusted in time and frequency, as well as provides mechanisms to discipline its frequency to an external precision timing source. The model incorporates a generic system-call interface for use with the Network Time Protocol (NTP) or similar time synchronization protocol. The NTP Version 3 daemon xntpd operates with this model to provide synchronization limited in principle only by the accuracy and stability of the external timing source. This memorandum does not obsolete or update any RFC. It does not propose a standard protocol, specification or algorithm. It is intended to provoke comment, refinement and alternative implementations. While a working knowledge of NTP is not required for an understanding of the design principles or implementation of the model, it may be helpful in understanding how the model behaves in a fully functional timekeeping system. The architecture and design of NTP is described in [1], while the current NTP Version 3 protocol specification is given in RFC-1305 [2] and a subset of the protocol, the Simple Network Time Protocol (SNTP), in RFC-1361 [4]. The model has been implemented in three Unix kernels for Sun Microsystems and Digital Equipment workstations. In addition, for the Digital machines the model provides improved precision to one microsecond (us). Since these specific implementations involve modifications to licensed code, they cannot be provided directly. Inquiries should be directed to the manufacturer's representatives. However, the engineering model for these implementations, including a Mills [Page 1]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 simulator with code segments almost identical to the implementations, but not involving licensed code, is available via anonymous FTP from host louie.udel.edu in the directory pub/ntp and compressed tar archive kernel.tar.Z. The NTP Version 3 distribution can be obtained via anonymous ftp from the same host and directory in the compressed tar archive xntp3.3g.tar.Z, where the version number shown as 3.3g may be adjusted for new versions as they occur. 1. Introduction This memorandum describes a model and programming interface for generic operating system software that manages the system clock and timer functions. The model provides improved accuracy and stability for most workstations and servers using the Network Time Protocol (NTP) or similar time synchronization protocol. This memorandum describes the principles of design and implementation of the model. Related technical reports discuss the design approach, engineering analysis and performance evaluation of the model as implemented in Unix kernels for Sun Microsystems and Digital Equipment workstations. The NTP Version 3 daemon xntpd operates with these implementations to provide improved accuracy and stability, together with diminished overhead in the operating system and network. In addition, the model supports the use of external timing sources, such as precision pulse-per-second (PPS) signals and the industry standard IRIG timing signals. The NTP daemon automatically detects the presence of the new features and utilizes them when available. There are three prototype implementations of the model presented in this memorandum, one each for the Sun Microsystems SPARCstation with the SunOS 4.1.x kernel, Digital Equipment DECstation 5000 with the Ultrix 4.x kernel and Digital Equipment 3000 AXP Alpha with the OSF/1 V1.x kernel. In addition, for the DECstation 5000/240 and 3000 AXP Alpha machines, a special feature provides improved precision to 1 us (Sun 4.1.x kernels already do provide 1-us precision). Other than improving the system clock accuracy, stability and precision, these implementations do not change the operation of existing Unix system calls which manage the system clock, such as gettimeofday(), settimeofday() and adjtime(); however, if the new features are in use, the operations of gettimeofday() and adjtime() can be controlled instead by new system calls ntp_gettime() and ntp_adjtime() as described below. A detailed description of the variables and algorithms is given in the hope that similar functionality can be incorporated in Unix kernels for other machines. The algorithms involve only minor changes to the system clock and interval timer routines and include interfaces for application programs to learn the system clock status and certain statistics of the time synchronization process. Detailed Mills [Page 2]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 installation instructions are given in a specific README files included in the kernel distributions. In this memorandum, NTP Version 3 and the Unix implementation xntp3 are used as an example application of the new system calls for use by a synchronization daemon. In principle, the new system calls can be used by other protocols and implementations as well. Even in cases where the local time is maintained by periodic exchanges of messages at relatively long intervals, such as using the NIST Automated Computer Time Service, the ability to precisely adjust the system clock frequency simplifies the synchronization procedures and allows the telephone call frequency to be considerably reduced. 2. Design Approach While not strictly necessary for an understanding or implementation of the model, it may be helpful to briefly describe how NTP operates to control the system clock in a client workstation. As described in [1], the NTP protocol exchanges timestamps with one or more peers sharing a synchronization subnet to calculate the time offsets between peer clocks and the local clock. These offsets are processed by several algorithms which refine and combine the offsets to produce an ensemble average, which is then used to adjust the local clock time and frequency. The manner in which the local clock is adjusted represents the main topic of this memorandum. The goal in the enterprise is the most accurate and stable system clock possible with the available kernel software and workstation hardware. In order to understand how the new software works, it is useful to review how most Unix kernels maintain the system time. In the Unix design a hardware counter interrupts the kernel at a fixed rate: 100 Hz in the SunOS kernel, 256 Hz in the Ultrix kernel and 1024 Hz in the OSF/1 kernel. Since the Ultrix timer interval (reciprocal of the rate) does not evenly divide one second in microseconds, the Ultrix kernel adds 64 microseconds once each second, so the timescale consists of 255 advances of 3906 us plus one of 3970 us. Similarly, the OSF/1 kernel adds 576 us once each second, so its timescale consists of 1023 advances of 976 us plus one of 1552 us. 2.1. Mechanisms to Adjust Time and Frequency In most Unix kernels it is possible to slew the system clock to a new offset relative to the current time by using the adjtime() system call. To do this the clock frequency is changed by adding or subtracting a fixed amount (tickadj) at each timer interrupt (tick) for a calculated number of ticks. Since this calculation involves dividing the requested offset by tickadj, it is possible to slew to a new offset with a precision only of tickadj, which is Mills [Page 3]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 usually in the neighborhood of 5 us, but sometimes much more. This results in a roundoff error which can accumulate to an unacceptable degree, so that special provisions must be made in the clock adjustment procedures of the synchronization daemon. In order to implement a frequency-discipline function, it is necessary to provide time offset adjustments to the kernel at regular adjustment intervals using the adjtime() system call. In order to reduce the system clock jitter to the regime considered in this memorandum, it is necessary that the adjustment interval be relatively small, in the neighborhood of 1 s. However, the Unix adjtime() implementation requires each offset adjustment to complete before another one can be begun, which means that large adjustments must be amortized in possibly many adjustment intervals. The requirement to implement the adjustment interval and compensate for roundoff error considerably complicates the synchronizing daemon implementation. In the new model this scheme is replaced by another that represents the system clock as a multiple-word, precision-time variable in order to provide very precise clock adjustments. At each timer interrupt a precisely calibrated quantity is added to the kernel time variable and overflows propagated as required. The quantity is computed as in the NTP local clock model described in [3], which operates as an adaptive-parameter, first-order, type-II phase-lock loop (PLL). In principle, this PLL design can provide precision control of the system clock oscillator within 1 us and frequency to within parts in 10^11. While precisions of this order are surely well beyond the capabilities of the CPU clock oscillator used in typical workstations, they are appropriate using precision external oscillators as described below. The PLL design is identical to the one originally implemented in NTP and described in [3]. In this design the software daemon simulates the PLL using the adjtime() system call; however, the daemon implementation is considerably complicated by the considerations described above. The modified kernel routines implement the PLL in the kernel using precision time and frequency representions, so that these complications are avoided. A new system call ntp_adjtime() is called only as each new time update is determined, which in NTP occurs at intervals of from 16 s to 1024 s. In addition, doing frequency compensation in the kernel means that the system time runs true even if the daemon were to cease operation or the network paths to the primary synchronization source fail. In the new model the new ntp_adjtime() operates in a way similar to the original adjtime() system call, but does so independently Mills [Page 4]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 of adjtime(), which continues to operate in its traditional fashion. When used with NTP, it is the design intent that settimeofday() or adjtime() be used only for system time adjustments greater than +-128 ms, although the dynamic range of the new model is much larger at +-512 ms. It has been the Internet experience that the need to change the system time in increments greater than +-128 ms is extremely rare and is usually associated with a hardware or software malfunction or system reboot. The easiest way to set the time is with the settimeofday() system call; however, this can under some conditions cause the clock to jump backward. If this cannot be tolerated, adjtime() can be used to slew the clock to the new value without running backward or affecting the frequency discipline process. Once the system clock has been set within +-128 ms, the ntp_adjtime() system call is used to provide periodic updates including the time offset, maximum error, estimated error and PLL time constant. With NTP the update interval depends on the measured dispersion and time constant; however, the scheme is quite forgiving and neither moderate loss of updates nor variations in the update interval are serious. 2.2 Daemon and Application Interface Unix application programs can read the system clock using the gettimeofday() system call, which returns only the system time and timezone data. For some applications it is useful to know the maximum error of the reported time due to all causes, including clock reading errors, oscillator frequency errors and accumulated latencies on the path to a primary synchronization source. However, in the new model the PLL adjusts the system clock to compensate for its intrinsic frequency error, so that the time errors expected in normal operation will usually be much less than the maximum error. The programming interface includes a new system call ntp_gettime(), which returns the system time, as well as the maximum error and estimated error. This interface is intended to support applications that need such things, including distributed file systems, multimedia teleconferencing and other real-time applications. The programming interface also includes the new system call ntp_adjtime() mentioned previously, which can be used to read and write kernel variables for time and frequency adjustment, PLL time constant, leap-second warning and related data. In addition, the kernel adjusts the maximum error to grow by an amount equal to the oscillator frequency tolerance times the elapsed time since the last update. The default engineering parameters have been optimized for update intervals in the order Mills [Page 5]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 of 64 s. For other intervals the PLL time constant can be adjusted to optimize the dynamic response over intervals of 16-1024 s. Normally, this is automatically done by NTP. In any case, if updates are suspended, the PLL coasts at the frequency last determined, which usually results in errors increasing only to a few tens of milliseconds over a day using room-temperature quartz oscillators of typical modern workstations. While any synchronization daemon can in principle be modified to use the new system calls, the most likely will be users of the NTP Version 3 daemon xntpd. The xntpd code determines whether the new system calls are implemented and automatically reconfigures as required. When implemented, the daemon reads the frequency offset from a file and provides it and the initial time constant via ntp_adjtime(). In subsequent calls to ntp_adjtime(), only the time offset and time constant are affected. The daemon reads the frequency from the kernel using ntp_adjtime() at intervals of about one hour and writes it to a system file. This information is recovered when the daemon is restarted after reboot, for example, so the sometimes extensive training period to learn the frequency separately for each system can be avoided. 2.3. Precision Clocks for DECstation 5000/240 and 3000 AXP Alpha The stock microtime() routine in the Ultrix kernel returns system time to the precision of the timer interrupt interval, which is in the 1-4 ms range. However, in the DECstation 5000/240 and possibly other machines of that family, there is an undocumented IOASIC hardware register that counts system bus cycles at a rate of 25 MHz. The new microtime() routine for the Ultrix kernel uses this register to interpolate system time between timer interrupts. This results in a precision of 1 us for all time values obtained via the gettimeofday() and ntp_gettime() system calls. For the Digital Equipment 3000 AXP Alpha, the architecture provides a hardware Process Cycle Counter and a machine instruction rpcc to read it. This counter operates at the fundamental frequency of the CPU clock or some submultiple of it, 133.333 MHz for the 3000/400 for example. The new microtime() routine for the OSF/1 kernel uses this counter in the same fashion as the Ultrix routine. In both the Ultrix and OSF/1 kernels the gettimeofday() and ntp_gettime() system call use the new microtime() routine, which returns the actual interpolated value, but does not change the kernel time variable. Therefore, other routines that access the kernel time variable directly and do not call either gettimeofday(), ntp_gettime() or microtime() will continue their present behavior. The microtime() feature is independent of other features described here and is operative even if the kernel PLL or Mills [Page 6]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 new system calls have not been implemented. The SunOS kernel already includes a system clock with 1-us resolution; so, in principle, no microtime() routine is necessary. An existing kernel routine uniqtime() implements this function, but it is coded in the C language and is rather slow at 42-85 us per call. A replacement microtime() routine coded in assembler language is available in the NTP Version 3 distribution and is much faster at about 3 us per call. 2.4. External Time and Frequency Discipline The overall accuracy of a time synchronization subnet with respect to Coordinated Universal Time (UTC) depends on the accuracy and stability of the primary synchronization source, usually a radio or satellite receiver, and the system clock oscillator of the primary server. As discussed in [5], the traditional interface using an RS232 protocol and serial port precludes the full accuracy of the radio clock. In addition, the poor stability of typical CPU clock oscillators limits the accuracy, whether or not precision time sources are available. There are, however, several ways in which the system clock accuracy and stability can be improved to the degree limited only by the accuracy and stability of the synchronization source and the jitter of the operating system. Many radio clocks produce special signals that can be used by external equipment to precisely synchronize time and frequency. Most produce a pulse-per-second (PPS) signal that can be read via a modem-control lead of a serial port and some produce a special IRIG signal that can be read directly by a bus peripheral, such as the KSI/Odetics TPRO IRIG SBus interface, or indirectly via the audio codec of some workstations, as described in [5]. In the NTP Version 3 distribution, the PPS signal can be used to augment the less precise ASCII serial timecode to improve accuracy to the order of microseconds. Support is also included in the distribution for the TPRO interface as well as the audio codec; however, the latter requires a modified kernel audio driver contained in the bsd_audio.tar.Z distribution in the same host and directory as the NTP Version 3 distribution mentioned previously. 2.4.1. PPS Signal The NTP Version 3 distribution includes a special ppsclock module for the SunOS 4.1.x kernel that captures the PPS signal presented via a modem-control lead of a serial port. Normally, the ppsclock module produces a timestamp at each transition of the PPS signal and provides it to the synchronization daemon Mills [Page 7]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 for integration with the serial ASCII timecode, also produced by the radio clock. With the conventional PLL implementation in either the daemon or the kernel as described above, the accuracy of this scheme is limited by the intrinsic stability of the CPU clock oscillator to a millisecond or two, depending on environmental temperature variations. The ppsclock module has been modified to in addition call a new kernel routine hardpps() once each second. The kernel routine compares the timestamp with a sample of the CPU clock oscillator to develop a frequency offset estimate. This offset is used to discipline the oscillator frequency, nominally to within a few parts in 10^8, which is about two orders of magnitude better than the undisciplined oscillator. The new feature is conditionally compiled in the code described below only if the PPS_SYNC option is used in the kernel configuration file. When using the PPS signal to adjust the time, there is a problem with the SunOS implementation which is very delicate to fix. The Sun serial port interrupt routine operates at interrupt priority level 12, while the timer interrupt routine operates at priority 10. Thus, it is possible that the PPS signal interrupt can occur during the timer interrupt routine, with result that a tick increment can be missed and the returned time early by one tick. It may happen that, if the CPU clock oscillator is within a few ppm of the PPS oscillator, this condition can persist for two or more successive PPS interrupts. A useful workaround has been to use a median filter to process the PPS sample offsets. In this filter the sample offsets in a window of 20 samples are sorted by offset and the six highest and six lowest outlyers discarded. The average of the eight samples remaining becomes the output of the filter. The problem is not nearly so serious when using the PPS signal to discipline the frequency of the CPU clock oscillator. In this case the quantity of interest is the contents of the microseconds counter only, which does not depend on the kernel time variable. 2.4.2. External Clocks It is possible to replace the system clock function with an external bus peripheral. The TPRO device mentioned previously can be used to provide IRIG-synchronized time with a precision of 1 us. A driver for this device tprotime.c and header file tpro.h are included in the kernel.tar.Z distribution mentioned previously. Using this device the system clock is read directly Mills [Page 8]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 from the interface; however, the device does not record the year, so special provisions have to be made to obtain the year from the kernel time variable and initialize the driver accordingly. This feature is conditionally compiled in the code described below only if the EXT_CLOCK option is used in the kernel configuration file. While the system clock function is provided directly by the microtime() routine in the driver, the kernel time variable must be disciplined as well, since not all system timing functions use the microtime() routine. This is done by measuring the difference between the microtime() clock and kernel time variable and using the difference to adjust the kernel PLL as if the adjustment were provided by an external peer and NTP. A good deal of error checking is done in the TPRO driver, since the system clock is vulnerable to a misbehaving radio clock, IRIG signal source, interface cables and TPRO device itself. Unfortunately, there is no easy way to utilize the extensive diversity and redundancy capabilities available in the NTP synchronization daemon. In order to avoid disruptions that might occur if the TPRO time is far different from the kernel time variable, the latter is used instead of the former if the difference between the two exceeds 1000 s; presumably in that case operator intervention is required. 2.4.3. External Oscillators Even if a source of PPS or IRIG signals is not available, it is still possible to improve the stability of the system clock through the use of a specialized bus peripheral. In order to explore the benefits of such an approach, a special SBus peripheral caled HIGHBALL has been constructed. The device includes a pair of 32-bit hardware counters in Unix timeval format, together with a precision, oven-controlled quartz oscillator with a stability of a few parts in 10^9. A driver for this device hightime.c and header file high.h are included in the kernel.tar.Z distribution mentioned previously. This feature is conditionally compiled in the code described below only if the EXT_CLOCK and HIGHBALL options are used in the kernel configuration file. Unlike the external clock case, where the system clock function is provided directly by the microtime() routine in the driver, the HIGHBALL counter offsets with respect to UTC must be provided first. This is done using the ordinary kernel PLL, but controlling the counter offsets directly, rather than the Mills [Page 9]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 kernel time variable. At first, this might seem to defeat the purpose of the design, since the jitter and wander of the synchronization source will affect the counter offsets and thus the accuracy of the time. However, the jitter is much reduced by the PLL and the wander is small, especially if using a radio clock or another primary server disciplined in the same way. In practice, the scheme works to reduce the incidental wander to a few parts in 10^8, or about the same as using the PPS signal. As in the previous case, the kernel time variable must be disciplined as well, since not all system timing functions use the microtime() routine. However, the kernel PLL cannot be used for this, since it is already in use providing offsets for the HIGHBALL counters. Therefore, a special correction is calculated from the difference between the microtime() clock and the kernel time variable and used to adjust the kernel time variable at the next timer interrupt. This somewhat roundabout approach is necessary in order that the adjustment does not cause the kernel time variable to jump backwards and possibly lose or duplicate a timer event. 2.5 Other Features It is a design feature of the NTP architecture that the system clocks in a synchronization subnet are to read the same or nearly the same values before during and after a leap-second event, as declared by national standards bodies. The new model is designed to implement the leap event upon command by an ntp_adjtime() argument. The intricate and sometimes arcane details of the model and implementation are discussed in [3] and [5]. Further details are given in the technical summary later in this memorandum. 3. Technical Summary In order to more fully understand the workings of the model, a stand- alone simulator kern.c and header file timex.h are included in the kernel.tar.Z distribution mentioned previously. In addition, a complete C program kern_ntptime.c which implements the ntp_gettime() and ntp_adjtime() functions is provided, but with the vendor-specific argument-passing code deleted. Since the distribution is somewhat large, due to copious comments and ornamentation, it is impractical to include a listing of these programs in this memorandum. In any case, implementors may choose to snip portions of the simulator for use in new kernel designs, but, due to formatting conventions, this would be difficult if included in this memorandum. Mills [Page 10]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 The kern.c program is an implementation of an adaptive-parameter, first-order, type-II phase-lock loop. The system clock is implemented using a set of variables and algorithms defined in the simulator and driven by explicit offsets generated by a driver program also included in the program. The algorithms include code fragments almost identical to those in the machine-specific kernel implementations and operate in the same way, but the operations can be understood separately from any licensed source code into which these fragments may be integrated. The code fragments themselves are not derived from any licensed code. The following discussion assumes that the simulator code is available for inspection. 3.1. PLL Simulation The simulator operates in conformance with the analytical model described in [3]. The main() program operates as a driver for the fragments hardupdate(), hardclock(), second_overflow(), hardpps() and microtime(), although not all functions implemented in these fragments are simulated. The program simulates the PLL at each timer interrupt and prints a summary of critical program variables at each time update. There are three defined options in the kernel configuration file specific to each implementation. The PPS_SYNC option provides support for a pulse-per-second (PPS) signal, which is used to discipline the frequency of the CPU clock oscillator. The EXT_CLOCK option provides support for an external kernel-readable clock, such as the KSI/Odetics TPRO IRIG interface or HIGHBALL precision oscillator, both for the SBus. The TPRO option provides support for the former, while the HIGHBALL option provides support for the latter. External clocks are implemented as the microtime() clock driver, with the specific source code selected by the kernel configuration file. 3.1.1. The hardupdate() Fragment The hardupdate() fragment is called by ntp_adjtime() as each update is computed to adjust the system clock phase and frequency. Note that the time constant is in units of powers of two, so that multiplies can be done by simple shifts. The phase variable is computed as the offset divided by the time constant. Then, the time since the last update is computed and clamped to a maximum (for robustness) and to zero if initializing. The offset is multiplied (sorry about the ugly multiply) by the result and divided by the square of the time constant and then added to the frequency variable. Note that all shifts are assumed to be positive and that a shift of a signed quantity to the right requires a little dance. Mills [Page 11]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 With the defines given, the maximum time offset is determined by the size in bits of the long type (32 or 64) less the SHIFT_UPDATE scale factor (12) or at least 20 bits (signed). The scale factor is chosen so that there is no loss of significance in later steps, which may involve a right shift up to SHIFT_UPDATE bits. This results in a time adjustment range over +-512 ms. Since time_constant must be greater than or equal to zero, the maximum frequency offset is determined by the SHIFT_USEC scale factor (16) or at least 16 bits (signed). This results in a frequency adjustment range over +-31,500 ppm. In the addition step, the value of offset * mtemp is not greater than MAXPHASE * MAXSEC = 31 bits (signed), which will not overflow a long add on a 32-bit machine. There could be a loss of precision due to the right shift of up to 12 bits, since time_constant is bounded at 6. This results in a net worst-case frequency resolution of about .063 ppm, which is not significant for most quartz oscillators. The worst case could be realized only if the NTP peer misbehaves according to the protocol specification. The time_offset value is clamped upon entry. The time_phase variable is an accumulator, so is clamped to the tolerance on every call. This helps to damp transients before the oscillator frequency has been determined, as well as to satisfy the correctness assertions if the time synchronization protocol or implementation misbehaves. 3.1.2. The hardclock() Fragment The hardclock() fragment is inserted in the hardware timer interrupt routine at the point the system clock is to be incremented. Previous to this fragment the time_update variable has been initialized to the value computed by the adjtime() system call in the stock Unix kernel, normally plus/minus the tickadj value, which is usually in the order of 5 us. The time_phase variable, which represents the instantaneous phase of the system clock, is advanced by time_adj, which is calculated in the second_overflow() fragment described below. If the value of time_phase exceeds 1 us in scaled units, time_update is increased by the (signed) excess and time_phase retains the residue. Except in the case of an external oscillator such as the HIGHBALL interface, the hardclock() fragment advances the system clock by the value of tick plus time_update. However, in the case of an external oscillator, the system clock is obtained directly from the interface and time_update used to Mills [Page 12]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 discipline that interface instead. However, the system clock must still be disciplined as explained previously, so the value of clock_cpu computed by the second_overflow() fragment is used instead. 3.1.3. The second_overflow() Fragment The second_overflow() fragment is inserted at the point where the microseconds field of the system time variable is being checked for overflow. Upon overflow the maximum error time_maxerror is increased by time_tolerance to reflect the maximum time offset due to oscillator frequency error. Then, the increment time_adj to advance the kernel time variable is calculated from the (scaled) time_offset and time_freq variables updated at the last call to the hardclock() fragment. The phase adjustment is calculated as a (signed) fraction of the time_offset remaining, where the fraction is added to time_adj, then subtracted from time_offset. This technique provides a rapid convergence when offsets are high, together with good resolution when offsets are low. The frequency adjustment is the sum of the (scaled) time_freq variable, an adjustment necessary when the tick interval does not evenly divide one second fixtick and PPS frequency adjustment pps_ybar (if configured). The scheme of approximating exact multiply/divide operations with shifts produces good results, except when an exact calculation is required, such as when the PPS signal is being used to discipling the CPU clock oscillator frequency, as described below. As long as the actual oscillator frequency is a power of two in seconds, no correction is required. However, in the SunOS kernel the clock frequency is 100 Hz, which results in an error factor of 0.78. In this case the code increases time_adj by a factor of 1.25, which results in an overall error less than three percent. On rollover of the day, the leap-second state machine described below determines whether a second is to be inserted or deleted in the timescale. The microtime() routine insures that the reported time is always monotonically increasing. 3.1.4. The hardpps() Fragment The hardpps() fragment is operative only if the PPS_SYNC option is specified in the kernel configuration file. It is called from the serial port driver or equivalent interface at the on- time transition of the PPS signal. The fragment operates as a Mills [Page 13]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 first-order, type-I frequency-lock loop (FLL) controlled by the difference between the frequency represented by the pps_ybar variable and the frequency of the hardware clock oscillator. In order to avoid calling the microtime() routine more than once for each PPS transition, the interface requires the calling program to capture the system time and hardware counter contents at the on-time transition of the PPS signal and provide a pointer to the timestamp (Unix timeval) and counter contents as arguments to the hardpps() call. The hardware counter contents can be determined by saving the microseconds field of the system time, calling the microtime() routine, and subtracting the saved value. If a counter overflow has occured during the process, the resulting microseconds value will be negative, in which case the caller adds 1000000 to normalize the microseconds field. The frequency of the hardware oscillator can be determined from the difference in hardware counter readings at the beginning and end of the calibration interval divided by the duration of the interval. However, the oscillator frequency tolerance, as much as 100 ppm, may cause the difference to exceed the tick value, creating an ambiguity. In order to avoid this ambiguity, the hardware counter value at the beginning of the interval is increased by the current pps_ybar value once each second, but computed modulo the tick value. At the end of the interval, the difference between this value and the value computed from the hardware counter is used as a control signal sample for the FLL. Control signal samples which exceed the frequency tolerance are discarded, as well as samples resulting from excessive interval duration jitter. Surviving samples are then processed by a three-stage median filter. The signal which drives the FLL is derived from the median sample, while the average of differences between the other two samples is used as a measure of dispersion. If the dispersion is below the threshold pps_dispmax, the median is used to correct the pps_ybar value with a weight expressed as a shift PPS_AVG (2). In addition to the averaging function, pps_disp is increased by the amount pps_dispinc once each second. The result is that, should the dispersion be exceptionally high, or if the PPS signal fails for some reason, the pps_disp will eventually exceed pps_dispmax and raise an alarm. Initially, an approximate value for pps_ybar is not known, so the duration of the calibration interval must be kept small to avoid overflowing the tick. The time difference at the end of Mills [Page 14]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 the calibration interval is measured. If greater than a fraction tick/4, the interval is reduced by half. If less than this fraction for four successive calibration intervals, the interval is doubled. This design automatically adapts to nominal jitter in the PPS signal, as well as the value of tick. The duration of the calibration interval is set by the pps_shift variable as a shift in powers of two. The minimum value PPS_SHIFT (2) is chosen so that with the highest CPU oscillator frequency 1024 Hz and frequency tolerance 100 ppm the tick will not overflow. The maximum value PPS_SHIFTMAX (8) is chosen such that the maximum averaging time is about 1000 s as determined by measurements of Allan variance [5]. Should the PPS signal fail, the current frequency estimate pps_ybar continues to be used, so the nominal frequency remains correct subject only to the instability of the undisciplined oscillator. The procedure to save and restore the frequency estimate works as follows. When setting the frequency from a file, the time_freq value is set as the file value minus the pps_ybar value; when retrieving the frequency, the two values are added before saving in the file. This scheme provides a seamless interface should the PPS signal fail or the kernel configuration change. Note that the frequency discipline is active whether or not the synchronization daemon is active. Since all Unix systems take some time after reboot to build a running system, usually by that time the discipline process has already settled down and the initial transients due to frequency discipline have damped out. 3.1.4. External Clock Interface The external clock driver interface is implemented with two routines, microtime(), which returns the current clock time, and clock_set(), which furnishes the apparent system time derived from the kernel time variable. The latter routine is called only when the clock is set using the settimeofday() system call, but can be called from within the driver, such as when the year rolls over, for example. In the stock SunOS kernel and modified Ultrix and OSF/1 kernels, the microtime() routine returns the kernel time variable plus an interpolation between timer interrupts based on the contents of a hardware counter. In the case of an external clock, such as described above, the system clock is read directly from the hardware clock registers. Examples of external clock drivers are in the tprotime.c and hightime.c routines included in the kernel.tar.Z distribution. Mills [Page 15]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 The external clock routines return a status code which indicates whether the clock is operating correctly and the nature of the problem, if not. The return code is interpreted by the ntp_gettime() system call, which transitions the status state machine to the TIME_ERR state if an error code is returned. This is the only error checking implemented for the external clock in the present version of the code. The simulator has been used to check the PLL operation over the design envelope of +-512 ms in time error and +-100 ppm in frequency error. This confirms that no overflows occur and that the loop initially converges in about 15 minutes for timer interrupt rates from 50 Hz to 1024 Hz. The loop has a normal overshoot of a few percent and a final convergence time of several hours, depending on the initial time and frequency error. 3.2. Leap Seconds It does not seem generally useful in the user application interface to provide additional details private to the kernel and synchronization protocol, such as stratum, reference identifier, reference timestamp and so forth. It would in principle be possible for the application to independently evaluate the quality of time and project into the future how long this time might be "valid." However, to do that properly would duplicate the functionality of the synchronization protocol and require knowledge of many mundane details of the platform architecture, such as the subnet configuration, reachability status and related variables. For the curious, the ntp_adjtime() system call can be used to reveal some of these mysteries. However, the user application may need to know whether a leap second is scheduled, since this might affect interval calculations spanning the event. A leap-warning condition is determined by the synchronization protocol (if remotely synchronized), by the timecode receiver (if available), or by the operator (if awake). This condition is set by the synchronization daemon on the day the leap second is to occur (30 June or 31 December, as announced) by specifying in a ntp_adjtime() system call a clock status of either TIME_DEL, if a second is to be deleted, or TIME_INS, if a second is to be inserted. Note that, on all occasions since the inception of the leap-second scheme, there has never been a deletion occasion, nor is there likely to be one in future. If the value is TIME_DEL, the kernel adds one second to the system time immediately following second 23:59:58 and resets the clock status to TIME_OK. If the value is TIME_INS, the kernel subtracts one second from the system time immediately following second 23:59:59 and resets the clock status to TIME_OOP, in effect causing system Mills [Page 16]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 time to repeat second 59. Immediately following the repeated second, the kernel resets the clock status to TIME_OK. Depending upon the system call implementation, the reported time during a leap second may repeat (with the TIME_OOP return code set to advertise that fact) or be monotonically adjusted until system time "catches up" to reported time. With the latter scheme the reported time will be correct before and shortly after the leap second (depending on the number of microtime() calls during the leap second), but freeze or slowly advance during the leap second itself. However, Most programs will probably use the ctime() library routine to convert from timeval (seconds, microseconds) format to tm format (seconds, minutes,...). If this routine is modified to use the ntp_gettime() system call and inspect the return code, it could simply report the leap second as second 60. 3.3. Clock Status State Machine The various options possible with the system clock model described in this memorandum require a careful examination of the state transitions, status indications and recovery procedures should a crucial signal or interface fail. In this section is presented a prototype state machine designed to support leap second insertion and deletion, as well as reveal various kinds of errors in the synchronization process. The states of this machine are decoded as follows: TIME_OK If an external clock is present, it is working properly and the system clock is derived from it. If no external clock is present, the synchronization daemon is working properly and the system clock is synchronized to a radio clock or one or more peers. TIME_INS An insertion of one second in the system clock has been declared following the last second of the current day, but has not yet been executed. TIME_DEL A deletion of the last second of the current day has been declared, but not yet executed. TIME_OOP An insertion of one second in the system clock has been declared following the last second of the current day. The second is in progress, but not yet completed. Library conversion routines should interpret this second as 23:59:60. Mills [Page 17]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 TIME_BAD Either (a) the synchronization daemon has declared the protocol is not working properly, (b) all sources of outside synchronization have been lost or (c) an external clock is present and it has just become operational following a non-operational condition. TIME_ERR An external clock is present, but is in a non- operational condition. In all except the TIME_ERR state the system clock is derived from either an external clock, if present, or the kernel time variable, if not. In the TIME_ERR state the external clock is present, but not working properly, so the system clock may be derived from the kernel time variable. The following diagram indicates the normal transitions of the state machine. Not all valid transitions are shown. +--------+ +--------+ +--------+ +--------+ | | | | | | | | |TIME_BAD|---->|TIME_OK |<----|TIME_OOP|<----|TIME_INS| | | | | | | | | +--------+ +--------+ +--------+ +--------+ A A | | | | +--------+ +--------+ | | | | |TIME_ERR| |TIME_DEL| | | | | +--------+ +--------+ The state machine makes a transition once each second at an instant where the microseconds field of the kernel time variable overflows and one second is added to the seconds field. However, this condition is checked at each timer interrupt, which may not exactly coincide with the actual instant of overflow. This may lead to some interesting anomalies, such as a status indication of a leap second in progress (TIME_OOP) when actually the leap second had already expired. The following state transitions are executed automatically by the kernel: any state -> TIME_ERR This transition occurs when an external clock is present and an attempt is made to read it when in a non-operational condition. Mills [Page 18]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 TIME_INS -> TIME_OOP This transition occurs immediately following second 86,400 of the current day when an insert-second event has been declared. TIME_OOP -> TIME_OK This transition occurs immediately following second 86,401 of the current day; that is, one second after entry to the TIME_OOP state. TIME_DEL -> TIME_OK This transition occurs immediately following second 86,399 of the current day when a delete-second event has been declared. The following state transitions are executed by specific ntp_adjtime() system calls: TIME_OK -> TIME_INS This transition occurs as the result of a ntp_adjtime() system call to declare an insert-second event. TIME_OK -> TIME_DEL This transition occurs as the result of a ntp_adjtime() system call to declare a delete-second event. any state -> TIME_BAD This transition occurs as the result of a ntp_adjtime() system call to declare loss of all sources of synchronization or in other cases of error. The following table summarizes the actions just before, during and just after a leap-second event. Each line in the table shows the UTC and NTP times at the beginning of the second. The left column shows the behavior when no leap event is to occur. In the middle column the state machine is in TIME_INS at the end of UTC second 23:59:59 and the NTP time has just reached 400. The NTP time is set back one second to 399 and the machine enters TIME_OOP. At the end of the repeated second the machine enters TIME_OK and the UTC and NTP times are again in correspondence. In the right column the state machine is in TIME_DEL at the end of UTC second 23:59:58 and the NTP time has just reached 399. The NTP time is incremented, the machine enters TIME_OK and both UTC and NTP times are again in correspondence. Mills [Page 19]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 No Leap Leap Insert Leap Delete UTC NTP UTC NTP UTC NTP --------------------------------------------- 23:59:58|398 23:59:58|398 23:59:58|398 | | | 23:59:59|399 23:59:59|399 00:00:00|400 | | | 00:00:00|400 23:59:60|399 00:00:01|401 | | | 00:00:01|401 00:00:00|400 00:00:02|402 | | | 00:00:02|402 00:00:01|401 00:00:03|403 | | | To determine local midnight without fuss, the kernel code simply finds the residue of the time.tv_sec (or time.tv_sec + 1) value mod 86,400, but this requires a messy divide. Probably a better way to do this is to initialize an auxiliary counter in the settimeofday() routine using an ugly divide and increment the counter at the same time the time.tv_sec is incremented in the timer interrupt routine. For future embellishment. 4. Programming Model and Interfaces This section describes the programming model for the synchronization daemon and user application programs. The ideas are based on suggestions from Jeff Mogul and Philip Gladstone and a similar interface designed by the latter. It is important to point out that the functionality of the original Unix adjtime() system call is preserved, so that the modified kernel will work as the unmodified one, should the new features not be in use. In this case the ntp_adjtime() system call can still be used to read and write kernel variables that might be used by a synchronization daemon other than NTP, for example. 4.1. The ntp_gettime() System Call The syntax and semantics of the ntp_gettime() call are given in the following fragment of the timex.h header file. This file is identical, except for the SHIFT_HZ define, in the SunOS, Ultrix and OSF/1 kernel distributions. (The SHIFT_HZ define represents the logarithm to the base 2 of the clock oscillator frequency specific to each system type.) Note that the timex.h file calls the syscall.h system header file, which must be modified to define the SYS_ntp_gettime system call specific to each system type. The kernel distributions include directions on how to do this. Mills [Page 20]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 /* * This header file defines the Network Time Protocol (NTP) * interfaces for user and daemon application programs. These are * implemented using private system calls and data structures and * require specific kernel support. * * NAME * ntp_gettime - NTP user application interface * * SYNOPSIS * #include <sys/timex.h> * * int system call(SYS_ntp_gettime, tptr) * * int SYS_ntp_gettime defined in syscall.h header file * struct ntptimeval *tptr pointer to ntptimeval structure * * NTP user interface - used to read kernel clock values * Note: maximum error = NTP synch distance = dispersion + delay / * 2 * estimated error = NTP dispersion. */ struct ntptimeval { struct timeval time; /* current time */ long maxerror; /* maximum error (us) */ long esterror; /* estimated error (us) */ }; The ntp_gettime() system call returns three values in the ntptimeval structure: the current time in unix timeval format plus the maximum and estimated errors in microseconds. While the 32-bit long data type limits the error quantities to something more than an hour, in practice this is not significant, since the protocol itself will declare an unsynchronized condition well below that limit. In the NTP Version 3 specification, if the protocol computes either of these values in excess of 16 seconds, they are clamped to that value and the system clock declared unsynchronized. Following is a detailed description of the ntptimeval structure members. Mills [Page 21]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 struct timeval time; /* current time */ This member returns the current system time, expressed as a Unix timeval structure. The timeval structure consists of two 32-bit words; the first returns the number of seconds past 1 January 1970, while the second returns the number of microseconds. long maxerror; /* maximum error (us) */ This member returns the time_maxerror kernel variable in microseconds. See the entry for this variable in section 5 for additional information. long esterror; /* estimated error (us) */ This member returns the time_esterror kernel variable in microseconds. See the entry for this variable in section 5 for additional information. Mills [Page 22]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 4.2. The ntp_adjtime() System Call The syntax and semantics of the ntp_adjtime() call are given in the following fragment of the timex.h header file. Note that, as in the ntp_gettime() system call, the syscall.h system header file must be modified to define the SYS_ntp_adjtime system call specific to each system type. /* * NAME * ntp_adjtime - NTP daemon application interface * * SYNOPSIS * #include <sys/timex.h> * * int system call(SYS_ntp_adjtime, mode, tptr) * * int SYS_ntp_adjtime defined in syscall.h header file * struct timex *tptr pointer to timex structure * * NTP daemon interface - used to discipline kernel clock * oscillator */ struct timex { int mode; /* mode selector */ long offset; /* time offset (us) */ long frequency; /* frequency offset (scaled ppm) */ long maxerror; /* maximum error (us) */ long esterror; /* estimated error (us) */ int status; /* clock command/status */ long time_constant; /* pll time constant */ long precision; /* clock precision (us) (read only) */ long tolerance; /* clock frequency tolerance (scaled * ppm) (read only) */ /* * The following read-only structure members are implemented * only if the PPS signal discipline is configured in the * kernel. */ long ybar; /* frequency estimate (scaled ppm) */ long disp; /* dispersion estimate (scaled ppm) */ int shift; /* interval duration (s) (shift) */ long calcnt; /* calibration intervals */ long jitcnt; /* jitter limit exceeded */ long discnt; /* dispersion limit exceeded */ }; Mills [Page 23]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 The ntp_adjtime() system call is used to read and write certain time-related kernel variables summarized in this and subsequent sections. Writing these variables can only be done in superuser mode. To write a variable, the mode structure member is set with one or more bits, one of which is assigned each of the following variables in turn. The current values for all variables are returned in any case; therefore, a mode argument of zero means to return these values without changing anything. Following is a description of the timex structure members. int mode; /* mode selector */ This is a bit-coded variable selecting one or more structure members, with one bit assigned each member. If a bit is set, the value of the associated member variable is copied to the corresponding kernel variable; if not, the member is ignored. The bits are assigned as given in the following fragment of the timex.h header file. Note that the precision and tolerance are determined by the kernel and cannot be changed by ntp_adjtime(). /* * Mode codes (timex.mode) */ #define ADJ_OFFSET 0x0001 /* time offset */ #define ADJ_FREQUENCY 0x0002 /* frequency offset */ #define ADJ_MAXERROR 0x0004 /* maximum time error */ #define ADJ_ESTERROR 0x0008 /* estimated time error */ #define ADJ_STATUS 0x0010 /* clock status */ #define ADJ_TIMECONST 0x0020 /* pll time constant */ long offset; /* time offset (us) */ If selected, this member replaces the value of the time_offset kernel variable in microseconds. The absolute value must be less than MAXPHASE microseconds defined in the timex.h header file. See the entry for this variable in section 5 for additional information. If within range and the PPS signal and/or external oscillator are configured and operating properly, the clock status is automatically set to TIME_OK. Mills [Page 24]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 long time_constant; /* pll time constant */ If selected, this member replaces the value of the time_constant kernel variable. The value must be between zero and MAXTC defined in the timex.h header file. See the entry for this variable in section 5 for additional information. long frequency; /* frequency offset (scaled ppm) */ If selected, this member replaces the value of the time_frequency kernel variable. The value is in ppm, with the integer part in the high order 16 bits and fraction in the low order 16 bits. The absolute value must be in the range less than MAXFREQ ppm defined in the timex.h header file. See the entry for this variable in section 5 for additional information. long maxerror; /* maximum error (us) */ If selected, this member replaces the value of the time_maxerror kernel variable in microseconds. See the entry for this variable in section 5 for additional information. long esterror; /* estimated error (us) */ If selected, this member replaces the value of the time_esterror kernel variable in microseconds. See the entry for this variable in section 5 for additional information. int status; /* clock command/status */ If selected, this member replaces the value of the time_status kernel variable. See the entry for this variable in section 5 for additional information. In order to set this variable by ntp_adjtime(), either (a) the current clock status must be TIME_OK or (b) the member value is TIME_BAD; that is, the ntp_adjtime() call can always set the clock to the unsynchronized state or, if the clock is running correctly, can set it to any state. In any case, the ntp_adjtime() call always returns the current state in this member, so the caller can determine whether or not the request succeeded. Mills [Page 25]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 long time_constant; /* pll time constant */ If selected, this member replaces the value of the time_constant kernel variable. The value must be between zero and MAXTC defined in the timex.h header file. See the entry for this variable in section 5 for additional information. long precision; /* clock precision (us) (read only) */ This member returns the time_precision kernel variable in microseconds. The variable can be written only by the kernel. See the entry for this variable in section 5 for additional information. long tolerance; /* clock frequency tolerance (scaled ppm) */ This member returns the time_tolerance kernel variable in microseconds. The variable can be written only by the kernel. See the entry for this variable in section 5 for additional information. long ybar; /* frequency estimate (scaled ppm) */ This member returns the pps_ybar kernel variable in microseconds. The variable can be written only by the kernel. See the entry for this variable in section 5 for additional information. long disp; /* dispersion estimate (scaled ppm) */ This member returns the pps_disp kernel variable in microseconds. The variable can be written only by the kernel. See the entry for this variable in section 5 for additional information. int shift; /* interval duration (s) (shift) */ This member returns the pps_shift kernel variable in microseconds. The variable can be written only by the kernel. See the entry for this variable in section 5 for additional information. Mills [Page 26]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 long calcnt; /* calibration intervals */ This member returns the pps_calcnt kernel variable in microseconds. The variable can be written only by the kernel. See the entry for this variable in section 5 for additional information. long jitcnt; /* jitter limit exceeded */ This member returns the pps_jittcnt kernel variable in microseconds. The variable can be written only by the kernel. See the entry for this variable in section 5 for additional information. long discnt; /* dispersion limit exceeded */ This member returns the pps_discnt kernel variable in microseconds. The variable can be written only by the kernel. See the entry for this variable in section 5 for additional information. Mills [Page 27]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 4.3. Command/Status Codes The kernel routines use the system clock status variable time_status, which records whether the clock is synchronized, waiting for a leap second, etc. The value of this variable is returned as the result code by both the ntp_gettime() and ntp_adjtime() system calls. In addition, it can be explicitly read and written using the ntp_adjtime() system call, but can be written only in superuser mode. Values presently defined in the timex.h header file are as follows: /* * Clock command/status codes (timex.status) */ #define TIME_OK 0 /* clock synchronized */ #define TIME_INS 1 /* insert leap second */ #define TIME_DEL 2 /* delete leap second */ #define TIME_OOP 3 /* leap second in progress */ #define TIME_BAD 4 /* kernel clock not synchronized */ #define TIME_ERR 5 /* external oscillator not synchronized */ A detailed description of these codes as used by the leap-second state machine is given later in this memorandum. In case of a negative result code, the kernel has intercepted an invalid address or (in case of the ntp_adjtime() system call), a superuser violation. 5. Kernel Variables This section contains a list of kernel variables and a detailed description of their function, initial value, scaling and limits. 5.1. Interface Variables The following variables are read and set by the ntp_adjtime() system call. Additional automatic variables are used as temporaries as described in the code fragments. int time_status = TIME_BAD; This variable controls the state machine used to insert or delete leap seconds and show the status of the timekeeping system, PPS signal and external oscillator, if configured. Mills [Page 28]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 long time_offset = 0; This variable is used by the PLL to adjust the system time in small increments. It is scaled by (1 << SHIFT_UPDATE) (12) in microseconds. The maximum value that can be represented is about +-512 ms and the minimum value or precision is a few parts in 10^10 s. long time_constant = 0; /* pll time constant */ This variable determines the bandwidth or "stiffness" of the PLL. The value is used as a shift between zero and MAXTC (6), with the effective PLL time constant equal to a multiple of (1 << time_constant) in seconds. For room-temperature quartz oscillator the recommended default value is 2, which corresponds to a PLL time constant of about 900 s and a maximum update interval of about 64 s. The maximum update interval scales directly with the time constant, so that at the maximum time constant of 6, the update interval can be as large as 1024 s. Values of time_constant between zero and 2 can be used if quick convergence is necessary; values between 2 and 6 can be used to reduce network load, but at a modest cost in accuracy. Values above 6 are appropriate only if an external oscillator is present. long time_tolerance = MAXFREQ; /* frequency tolerance (ppm) */ This variable represents the maximum frequency error or tolerance in ppm of the particular CPU clock oscillator and is a property of the architecture; however, in principle it could change as result of the presence of external discipline signals, for instance. It is expressed as a positive number greater than zero in parts-per-million (ppm). The recommended value of MAXFREQ is 200 ppm is appropriate for room-temperature quartz oscillators used in typical workstations. However, it can change due to the operating condition of the PPS signal and/or external oscillator. With either the PPS signal or external oscillator, the recommended value for MAXFREQ is 100 ppm. Mills [Page 29]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 long time_precision = 1000000 / HZ; /* clock precision (us) */ This variable represents the maximum error in reading the system clock in microseconds. It is usually based on the number of microseconds between timer interrupts, 10000 us for the SunOS kernel, 3906 us for the Ultrix kernel, 976 us for the OSF/1 kernel. However, in cases where the time can be interpolated between timer interrupts with microsecond resolution, such as in the unmodified SunOS kernel and modified Ultrix and OSF/1 kernels, the precision is specified as 1 us. In cases where a PPS signal or external oscillator is available, the precision can depend on the operating condition of the signal or oscillator. This variable is determined by the kernel for use by the synchronization daemon, but is otherwise not used by the kernel. long time_maxerror = MAXPHASE; /* maximum error */ This variable establishes the maximum error of the indicated time relative to the primary synchronization source in microseconds. For NTP, the value is initialized by a ntp_adjtime() call to the synchronization distance, which is equal to the root dispersion plus one-half the root delay. It is increased by a small amount (time_tolerance) each second to reflect the clock frequency tolerance. This variable is computed by the synchronization daemon and the kernel, but is otherwise not used by the kernel. long time_esterror = MAXPHASE; /* estimated error */ This variable establishes the expected error of the indicated time relative to the primary synchronization source in microseconds. For NTP, the value is determined as the root dispersion, which represents the best estimate of the actual error of the system clock based on its past behavior, together with observations of multiple clocks within the peer group. This variable is computed by the synchronization daemon and returned in system calls, but is otherwise not used by the kernel. Mills [Page 30]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 5.2. Phase-Lock Loop Variables The following variables establish the state of the PLL and the residual time and frequency offset of the system clock. Additional automatic variables are used as temporaries as described in the code fragments. long time_phase = 0; /* phase offset (scaled us) */ The time_phase variable represents the phase of the kernel time variable at each tick of the clock. This variable is scaled by (1 << SHIFT_SCALE) (23) in microseconds, giving a maximum adjustment of about +-256 us/tick and a resolution less than one part in 10^12. long time_offset = 0; /* time offset (scaled us) */ The time_offset variable represents the time offset of the CPU clock oscillator. It is recalculated as each update to the system clock is received via the hardupdate() routine and at each second in the seconds_overflow routine. This variable is scaled by (1 << SHIFT_UPDATE) (12) in microseconds, giving a maximum adjustment of about +-512 ms and a resolution of a few parts in 10^10 s. long time_freq = 0; /* frequency offset (scaled ppm) */ The time_freq variable represents the frequency offset of the CPU clock oscillator. It is recalculated as each update to the system clock is received via the hardupdate() routine. It can also be set via ntp_adjtime() from a value stored in a file when the synchronization daemon is first started. It can be retrieved via ntp_adjtime() and written to the file about once per hour by the daemon. The time_freq variable is scaled by (1 << SHIFT_KF) (16) ppm, giving it a maximum value well in excess of the limit of +-256 ppm imposed by other constraints. The precision of this representation (frequency resolution) is parts in 10^11, which is adequate for all but the best external oscillators. time_adj = 0; /* tick adjust (scaled 1 / HZ) */ The time_adj variable is the adjustment added to the value of tick at each timer interrupt. It is computed once each second from the time_offset, time_freq and, if the PPS signal is present, the ps_ybar variable once each second. Mills [Page 31]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 long time_reftime = 0; /* time at last adjustment (s) */ This variable is the seconds portion of the system time on the last update received by the hardupdate() routine. It is used to compute the time_freq variable as the time since the last update increases. int fixtick = 1000000 % HZ; /* amortization factor */ In the Ultrix and OSF/1 kernels, the interval between timer interrupts does not evenly divide the number of microseconds in the second. In order that the clock runs at a precise rate, it is necessary to introduce an amortization factor into the local timescale. In the original Unix code, the value of fixtick is amortized once each second, introducing an additional source of jitter; in the new model the value is amortized at each tick of the system clock, reducing the jitter by the reciprocal of the clock oscillator frequency. This is not a new kernel variable, but a new use of an existing kernel variable. 5.3. Pulse-per-second (PPS) Frequency-Lock Loop Variables The following variables are used only if a pulse-per-second (PPS) signal is available and connected via a modem-control lead, such as produced by the optional ppsclock feature incorporated in the serial port driver. They establish the design parameters of the PPS frequency-lock loop used to discipline the CPU clock oscillator to an external PPS signal. Additional automatic variables are used as temporaries as described in the code fragments. long pps_usec; /* microseconds at last pps */ The pps_usec variable is latched from a high resolution counter or external oscillator at each PPS interrupt. In determining this value, only the hardware counter contents are used, not the contents plus the kernel time variable, as returned by the microtime() routine. long pps_ybar = 0; /* pps frequency offset estimate */ The pps_ybar variable is the average CPU clock oscillator frequency offset relative to the PPS disciplining signal. It is scaled in the same units as the time_freq variable. Mills [Page 32]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 pps_disp = MAXFREQ; /* dispersion estimate (scaled ppm) */ The pps_disp variable represents the average sample dispersion measured over the last three samples. It is scaled in the same units as the time_freq variable. pps_dispmax = MAXFREQ / 2; /* dispersion threshold */ The pps_dispmax variable is used as a dispersion threshold. If pps_disp is less than this threshold, the median sample is used to update the pps_ybar estimate; if not, the sample is discarded. pps_dispinc = MAXFREQ >> (PPS_SHIFT + 4); /* pps dispersion increment/sec */ The pps_dispinc variable is the increment to add to pps_disp once each second. It is computed such that, if no PPS samples have arrived for several calibration intervals, the value of pps_disp will exceed the pps_dispmax threshold and raise an alarm. int pps_mf[] = {0, 0, 0}; /* pps median filter */ The pps-mf[] array is used as a median filter to detect and discard jitter in the PPS signal. int pps_count = 0; /* pps calibrate interval counter */ The pps_count variable measures the length of the calibration interval used to calculate the frequency. It normally counts from zero to the value 1 << pps_shift. pps_shift = PPS_SHIFT; /* interval duration (s) (shift) */ The pps_shift variable determines the duration of the calibration interval, 1 << pps_shift s. pps_intcnt = 0; /* intervals at current duration */ The pps_intcnt variable counts the number of calibration intervals at the current interval duration. It is reset to zero after four intervals and when the interval duration is changed. long pps_calcnt = 0; /* calibration intervals */ The pps_calcnt variable counts the number of calibration intervals. Mills [Page 33]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 long pps_jitcnt = 0; /* jitter limit exceeded */ The pps_jitcnt variable counts the number of resets due to excessive jitter or frequency offset. These resets are usually due to excessive noise in the PPS signal or interface. long pps_discnt = 0; /* dispersion limit exceeded */ The pps_discnt variable counts the number of calibration intervals where the dispersion is above the pps_dispmax limit. These resets are usually due to excessive frequency wander in the PPS signal source. Mills [Page 34]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 5.4. External Oscillator Variables The following variables are used only if an external oscillator (HIGHBALL or TPRO) is present. Additional automatic variables are used as temporaries as described in the code fragments. int clock_count = 0; /* CPU clock counter */ The clock_count variable counts the seconds between adjustments to the kernel time variable to discipline it to the external clock. struct timeval clock_offset; /* HIGHBALL clock offset */ The clock_offset variable defines the offset between system time and the HIGHBALL counters. long clock_cpu = 0; /* CPU clock adjust */ The clock_cpu variable contains the offset between the system clock and the HIGHBALL clock for use in disciplining the kernel time variable. 6. Architecture Constants Following is a list of the important architecture constants that establish the response and stability of the PLL and provide maximum bounds on behavior in order to satisfy correctness assertions made in the protocol specification. Additional definitions are given in the timex.h header file. 6.1. Phase-lock loop (PLL) definitions The following defines establish the performance envelope of the PLL. They establish the maximum phase error (MAXPHASE), maximum frequency error (MAXFREQ), minimum interval between updates (MINSEC) and maximum interval between updates (MAXSEC). The intent of these bounds is to force the PLL to operate within predefined limits in order to satisfy correctness assertions of the synchronization protocol. An excursion which exceeds these bounds is clamped to the bound and operation proceeds normally. In practice, this can occur only if something has failed or is operating out of tolerance, but otherwise the PLL continues to operate in a stable mode. MAXPHASE must be set greater than or equal to CLOCK.MAX (128 ms), as defined in the NTP specification. CLOCK.MAX establishes the maximum time offset allowed before the system time is reset, Mills [Page 35]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 rather than incrementally adjusted. Here, the maximum offset is clamped to MAXPHASE only in order to prevent overflow errors due to defective programming. MAXFREQ reflects the manufacturing frequency tolerance of the CPU oscillator plus the maximum slew rate allowed by the protocol. It should be set to at least the intrinsic frequency tolerance of the oscillator plus 100 ppm for vernier frequency adjustments. If the kernel frequency discipline code is installed (PPS_SYNC), the CPU oscillator frequency is disciplined to an external source, presumably with negligible frequency error. #define MAXPHASE 512000 /* max phase error (us) */ #ifdef PPS_SYNC #define MAXFREQ 100 /* max frequency error (ppm) */ #else #define MAXFREQ 200 /* max frequency error (ppm) */ #endif /* PPS_SYNC */ #define MINSEC 16 /* min interval between updates (s) */ #define MAXSEC 1200 /* max interval between updates (s) */ 6.2. Pulse-per-second (PPS) Frequency-lock Loop (FLL) Definitions The following defines and declarations are used only if a pulse- per-second (PPS) signal is available and connected via a modem- control lead, such as produced by the optional ppsclock feature incorporated in the serial port driver. They establish the design parameters of the frequency-lock loop (FLL) used to discipline the CPU clock oscillator to the PPS oscillator. PPS_AVG is the averaging constant used to update the FLL from frequency samples measured for each calibration interval. PPS_SHIFT and PPS_SHIFTMAX are the minimum and maximem, respectively, of the calibration interval represented as a power of two. The PPS_DISPINC is the initial increment to pps_disp at each second. #define PPS_AVG 2 /* pps averaging constant (shift) */ #define PPS_SHIFT 2 /* min interval duration (s) (shift) */ #define PPS_SHIFTMAX 6 /* max interval duration (s) (shift) */ #define PPS_DISPINC 0 /* dispersion increment (us/s) */ Mills [Page 36]
RFC 1589 Kernel Model for Precision Timekeeping March 1994 6.3. External Oscillator Definitions The following definitions and declarations are used only if an external oscillator (HIGHBALL or TPRO) is configured on the system. #define CLOCK_INTERVAL 30 /* CPU clock update interval (s) */ 7. References [1] Mills, D., "Internet time synchronization: the Network Time Protocol", IEEE Trans. Communications COM-39, 10 (October 1991), 1482- 1493. Also in: Yang, Z., and T.A. Marsland (Eds.). Global States and Time in Distributed Systems, IEEE Press, Los Alamitos, CA, 91-102. [2] Mills, D., "Network Time Protocol (Version 3) specification, implementation and analysis", RFC 1305, University of Delaware, March 1992, 113 pp. [3] Mills, D., "Modelling and analysis of computer network clocks", Electrical Engineering Department Report 92-5-2, University of Delaware, May 1992, 29 pp. [4] Mills, D., "Simple Network Time Protocol (SNTP)", RFC 1361, University of Delaware, August 1992, 10 pp. [5] Mills, D., "Precision synchronizatin of computer network clocks", Electrical Engineering Department Report 93-11-1, University of Delaware, November 1993, 66 pp. Security Considerations Security issues are not discussed in this memo. Author's Address David L. Mills Electrical Engineering Department University of Delaware Newark, DE 19716 Phone: (302) 831-8247 EMail: mills@udel.edu Mills [Page 37]

   

[Home] [Full RFC index] [RFC humour] [Our technology]

Copyright © Inter-Corporate Computer & Network Services, Inc.  All rights reserved.
All trademarks and RFC contents are the property of their respective owners.