* Copyright (c) 1982, 1986, 1991 The Regents of the University of California.
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by the University of
* California, Berkeley and its contributors.
* 4. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* from: @(#)kern_clock.c 7.16 (Berkeley) 5/9/91
* $Id: kern_clock.c,v 1.15 1994/04/02 08:39:20 davidg Exp $
/* Portions of this software are covered by the following: */
/******************************************************************************
* Copyright (c) David L. Mills 1993, 1994 *
* Permission to use, copy, modify, and distribute this software and its *
* documentation for any purpose and without fee is hereby granted, provided *
* that the above copyright notice appears in all copies and that both the *
* copyright notice and this permission notice appear in supporting *
* documentation, and that the name University of Delaware not be used in *
* advertising or publicity pertaining to distribution of the software *
* without specific, written prior permission. The University of Delaware *
* makes no representations about the suitability this software for any *
* purpose. It is provided "as is" without express or implied warranty. *
*****************************************************************************/
static void gatherstats(clockframe
*);
struct callout
*callfree
, *callout
, calltodo
;
* Clock handling routines.
* This code is written to operate with two timers which run
* independently of each other. The main clock, running at hz
* times per second, is used to do scheduling and timeout calculations.
* The second timer does resource utilization estimation statistically
* based on the state of the machine phz times a second. Both functions
* can be performed by a single clock (ie hz == phz), however the
* statistics will be much more prone to errors. Ideally a machine
* would have separate clocks measuring time spent in user state, system
* state, interrupt state, and idle state. These clocks would allow a non-
* approximate measure of resource utilization.
* time of day, system/user timing, timeouts, profiling on separate timers
* allocate more timeout table slots when table overflows.
* Bump a timeval by a small number of usec's.
#define BUMPTIME(t, usec) { \
register struct timeval *tp = (t); \
if (tp->tv_usec >= 1000000) { \
tp->tv_usec -= 1000000; \
* Phase-lock loop (PLL) definitions
* The following variables are read and set by the ntp_adjtime() system
* time_state shows the state of the system clock, with values defined
* in the timex.h header file.
* time_status shows the status of the system clock, with bits defined
* in the timex.h header file.
* time_offset is used by the PLL to adjust the system time in small
* time_constant determines the bandwidth or "stiffness" of the PLL.
* time_tolerance determines maximum frequency error or tolerance of the
* 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.
* time_precision is usually equal to the kernel tick variable; however,
* in cases where a precision clock counter or external clock is
* available, the resolution can be much less than this and depend on
* whether the external clock is working or not.
* time_maxerror is initialized by a ntp_adjtime() call and increased by
* the kernel once each second to reflect the maximum error
* time_esterror is set and read by the ntp_adjtime() call, but
* otherwise not used by the kernel.
int time_status
= STA_UNSYNC
; /* clock status bits */
int time_state
= TIME_OK
; /* clock state */
long time_offset
= 0; /* time offset (us) */
long time_constant
= 0; /* pll time constant */
long time_tolerance
= MAXFREQ
; /* frequency tolerance (scaled ppm) */
long time_precision
= 1; /* clock precision (us) */
long time_maxerror
= MAXPHASE
; /* maximum error (us) */
long time_esterror
= MAXPHASE
; /* estimated error (us) */
* The following variables establish the state of the PLL and the
* residual time and frequency offset of the local clock. The scale
* factors are defined in the timex.h header file.
* time_phase and time_freq are the phase increment and the frequency
* increment, respectively, of the kernel time variable at each tick of
* time_freq is set via ntp_adjtime() from a value stored in a file when
* the synchronization daemon is first started. Its value is retrieved
* via ntp_adjtime() and written to the file about once per hour by the
* time_adj is the adjustment added to the value of tick at each timer
* interrupt and is recomputed at each timer interrupt.
* time_reftime is the second's portion of the system time on the last
* call to ntp_adjtime(). It is used to adjust the time_freq variable
* and to increase the time_maxerror as the time since last update
long time_phase
= 0; /* phase offset (scaled us) */
long time_freq
= 0; /* frequency offset (scaled ppm) */
long time_adj
= 0; /* tick adjust (scaled 1 / hz) */
long time_reftime
= 0; /* time at last adjustment (s) */
* The following variables are used only if the if the kernel PPS
* discipline code is configured (PPS_SYNC). The scale factors are
* defined in the timex.h header file.
* pps_time contains the time at each calibration interval, as read by
* pps_offset is the time offset produced by the time median filter
* pps_tf[], while pps_jitter is the dispersion measured by this
* pps_freq is the frequency offset produced by the frequency median
* filter pps_ff[], while pps_stabil is the dispersion measured by
* pps_usec is latched from a high resolution counter or external clock
* at pps_time. Here we want the hardware counter contents only, not the
* contents plus the time_tv.usec as usual.
* pps_valid counts the number of seconds since the last PPS update. It
* is used as a watchdog timer to disable the PPS discipline should the
* pps_glitch counts the number of seconds since the beginning of an
* offset burst more than tick/2 from current nominal offset. It is used
* mainly to suppress error bursts due to priority conflicts between the
* PPS interrupt and timer interrupt.
* pps_count counts the seconds of the calibration interval, the
* duration of which is pps_shift in powers of two.
* pps_intcnt counts the calibration intervals for use in the interval-
* adaptation algorithm. It's just too complicated for words.
struct timeval pps_time
; /* kernel time at last interval */
long pps_offset
= 0; /* pps time offset (us) */
long pps_jitter
= MAXTIME
; /* pps time dispersion (jitter) (us) */
long pps_tf
[] = {0, 0, 0}; /* pps time offset median filter (us) */
long pps_freq
= 0; /* frequency offset (scaled ppm) */
long pps_stabil
= MAXFREQ
; /* frequency dispersion (scaled ppm) */
long pps_ff
[] = {0, 0, 0}; /* frequency offset median filter */
long pps_usec
= 0; /* microsec counter at last interval */
long pps_valid
= PPS_VALID
; /* pps signal watchdog counter */
int pps_glitch
= 0; /* pps signal glitch counter */
int pps_count
= 0; /* calibration interval counter (s) */
int pps_shift
= PPS_SHIFT
; /* interval duration (s) (shift) */
int pps_intcnt
= 0; /* intervals at current duration */
* PPS signal quality monitors
* pps_jitcnt counts the seconds that have been discarded because the
* jitter measured by the time median filter exceeds the limit MAXTIME
* pps_calcnt counts the frequency calibration intervals, which are
* variable from 4 s to 256 s.
* pps_errcnt counts the calibration intervals which have been discarded
* because the wander exceeds the limit MAXFREQ (100 ppm) or where the
* calibration interval jitter exceeds two ticks.
* pps_stbcnt counts the calibration intervals that have been discarded
* because the frequency wander exceeds the limit MAXFREQ / 4 (25 us).
long pps_jitcnt
= 0; /* jitter limit exceeded */
long pps_calcnt
= 0; /* calibration intervals */
long pps_errcnt
= 0; /* calibration errors */
long pps_stbcnt
= 0; /* stability limit exceeded */
/* XXX none of this stuff works under FreeBSD */
* External clock definitions
* The following definitions and declarations are used only if an
* external clock (HIGHBALL or TPRO) is configured on the system.
#define CLOCK_INTERVAL 30 /* CPU clock update interval (s) */
* The clock_count variable is set to CLOCK_INTERVAL at each PPS
* interrupt and decremented once each second.
int clock_count
= 0; /* CPU clock counter */
* The clock_offset and clock_cpu variables are used by the HIGHBALL
* interface. The clock_offset variable defines the offset between
* system time and the HIGBALL counters. The clock_cpu variable contains
* the offset between the system clock and the HIGHBALL clock for use in
* disciplining the kernel time variable.
extern struct timeval clock_offset
; /* Highball clock offset */
long clock_cpu
= 0; /* CPU clock adjust */
* hardupdate() - local clock update
* This routine is called by ntp_adjtime() to update the local clock
* phase and frequency. This is used to implement an adaptive-parameter,
* first-order, type-II phase-lock loop. The code computes new time and
* frequency offsets each time it is called. The hardclock() routine
* amortizes these offsets at each tick interrupt. If the kernel PPS
* discipline code is configured (PPS_SYNC), the PPS signal itself
* determines the new time offset, instead of the calling argument.
* Presumably, calls to ntp_adjtime() occur only when the caller
* believes the local clock is valid within some bound (+-128 ms with
* NTP). If the caller's time is far different than the PPS time, an
* argument will ensue, and it's not clear who will lose.
* For default SHIFT_UPDATE = 12, the offset is limited to +-512 ms, the
* maximum interval between updates is 4096 s and the maximum frequency
* offset is +-31.25 ms/s.
* Note: splclock() is in effect.
if (!(time_status
& STA_PLL
) && !(time_status
& STA_PPSTIME
))
if (time_status
& STA_PPSTIME
&& time_status
& STA_PPSSIGNAL
)
time_offset
= MAXPHASE
<< SHIFT_UPDATE
; else if (ltemp
< -MAXPHASE
)
time_offset
= -(MAXPHASE
<< SHIFT_UPDATE
); time_offset
= ltemp
<< SHIFT_UPDATE
; mtemp
= time
.tv_sec
- time_reftime
; time_reftime
= time
.tv_sec
; /* ugly multiply should be replaced */
time_freq
-= (-ltemp
* mtemp
) >> (time_constant
+ time_constant
+ SHIFT_KF
- SHIFT_USEC
); time_freq
+= (ltemp
* mtemp
) >> (time_constant
+ time_constant
+ SHIFT_KF
- SHIFT_USEC
); if (time_freq
> time_tolerance
)
time_freq
= time_tolerance
; else if (time_freq
< -time_tolerance
)
time_freq
= -time_tolerance
; * The hz hardware interval timer.
* We update the events relating to real time.
* If this timer is also being used to gather statistics,
* we run through the statistics gathering routine as well.
register struct callout
*p1
;
register struct proc
*p
= curproc
;
register struct pstats
*pstats
= 0;
register struct rusage
*ru
;
register struct vmspace
*vm
;
long ltemp
, time_update
= 0;
* Update real-time timeout queue.
* At front of queue are some number of events which are ``due''.
* The time to these is <= 0 and if negative represents the
* number of ticks which have passed since it was supposed to happen.
* The rest of the q elements (times > 0) are events yet to happen,
* where the time for each is given as a delta from the previous.
* Decrementing just the first of these serves to decrement the time
* Curproc (now in p) is null if no process is running.
* We assume that curproc is set in user mode!
* Charge the time out based on the mode the cpu is in.
* Here again we fudge for the lack of proper interval timers
* assuming that the current state has been around at least
if (CLKF_USERMODE(&frame
)) {
if (pstats
->p_prof
.pr_scale
)
* CPU was in user state. Increment
* user time counter, and process process-virtual time
BUMPTIME(&p
->p_utime
, tick
);
if (timerisset(&pstats
->p_timer
[ITIMER_VIRTUAL
].it_value
) &&
itimerdecr(&pstats
->p_timer
[ITIMER_VIRTUAL
], tick
) == 0)
* CPU was in system state.
BUMPTIME(&p
->p_stime
, tick
);
/* bump the resource usage of integral space use */
if (p
&& pstats
&& (ru
= &pstats
->p_ru
) && (vm
= p
->p_vmspace
)) {
ru
->ru_ixrss
+= vm
->vm_tsize
* NBPG
/ 1024; ru
->ru_idrss
+= vm
->vm_dsize
* NBPG
/ 1024; ru
->ru_isrss
+= vm
->vm_ssize
* NBPG
/ 1024; if ((vm
->vm_pmap
.pm_stats
.resident_count
* NBPG
/ 1024) >
vm
->vm_pmap
.pm_stats
.resident_count
* NBPG
/ 1024; * If the cpu is currently scheduled to a process, then
* charge it with resource utilization for a tick, updating
* statistics which run in (user+system) virtual time,
* such as the cpu time limit and profiling timers.
* This assumes that the current process has been running
if ((p
->p_utime
.tv_sec
+p
->p_stime
.tv_sec
+1) >
p
->p_rlimit
[RLIMIT_CPU
].rlim_cur
) { if (p
->p_rlimit
[RLIMIT_CPU
].rlim_cur
<
p
->p_rlimit
[RLIMIT_CPU
].rlim_max
) p
->p_rlimit
[RLIMIT_CPU
].rlim_cur
+= 5; if (timerisset(&pstats
->p_timer
[ITIMER_PROF
].it_value
) &&
itimerdecr(&pstats
->p_timer
[ITIMER_PROF
], tick
) == 0)
* We adjust the priority of the current process.
* The priority of a process gets worse as it accumulates
* CPU time. The cpu usage estimator (p_cpu) is increased here
* and the formula for computing priorities (in kern_synch.c)
* will compute a different value each time the p_cpu increases
* by 4. The cpu usage estimator ramps up quite quickly when
* the process is running (linearly), and decays away
* exponentially, * at a rate which is proportionally slower
* when the system is busy. The basic principal is that the
* system will 90% forget that a process used a lot of CPU
* time in 5*loadav seconds. This causes the system to favor
* processes which haven't run much recently, and to
* round-robin among other processes.
* If the alternate clock has not made itself known then
* we must gather the statistics.
* Increment the time-of-day, and schedule
* processing of the callouts at a very low cpu priority,
* so we don't keep the relatively high clock interrupt
* priority any longer than necessary.
time_update
= tick
- tickdelta
; time_update
= tick
+ tickdelta
; * Compute the phase adjustment. If the low-order bits
* (time_phase) of the update overflow, bump the high-order bits
if (time_phase
<= -FINEUSEC
) {
ltemp
= -time_phase
>> SHIFT_SCALE
; time_phase
+= ltemp
<< SHIFT_SCALE
; else if (time_phase
>= FINEUSEC
) {
ltemp
= time_phase
>> SHIFT_SCALE
; time_phase
-= ltemp
<< SHIFT_SCALE
; time
.tv_usec
+= time_update
; * On rollover of the second the phase adjustment to be used for
* the next second is calculated. Also, the maximum error is
* increased by the tolerance. If the PPS frequency discipline
* code is present, the phase is increased to compensate for the
* CPU clock oscillator frequency error.
* With SHIFT_SCALE = 23, the maximum frequency adjustment is
* +-256 us per tick, or 25.6 ms/s at a clock frequency of 100
* Hz. The time contribution is shifted right a minimum of two
* bits, while the frequency contribution is a right shift.
* Thus, overflow is prevented if the frequency contribution is
* limited to half the maximum or 15.625 ms/s.
if (time
.tv_usec
>= 1000000) {
time_maxerror
+= time_tolerance
>> SHIFT_USEC
; (SHIFT_KG
+ time_constant
);
(SHIFT_SCALE
- SHIFT_HZ
- SHIFT_UPDATE
);
(SHIFT_KG
+ time_constant
);
(SHIFT_SCALE
- SHIFT_HZ
- SHIFT_UPDATE
);
* Gnaw on the watchdog counter and update the frequency
* computed by the pll and the PPS signal.
if (pps_valid
== PPS_VALID
) {
time_status
&= ~(STA_PPSSIGNAL
| STA_PPSJITTER
| STA_PPSWANDER
| STA_PPSERROR
); ltemp
= time_freq
+ pps_freq
; (SHIFT_USEC
+ SHIFT_HZ
- SHIFT_SCALE
);
(SHIFT_USEC
+ SHIFT_HZ
- SHIFT_SCALE
);
* When the CPU clock oscillator frequency is not a
* power of two in Hz, the SHIFT_HZ is only an
* approximate scale factor. In the SunOS kernel, this
* results in a PLL gain factor of 1/1.28 = 0.78 what it
* should be. In the following code the overall gain is
* increased by a factor of 1.25, which results in a
* residual error less than 3 percent.
/* Same thing applies for FreeBSD --GAW */
time_adj
-= -time_adj
>> 2; time_adj
+= time_adj
>> 2; /* XXX - this is really bogus, but can't be fixed until
xntpd's idea of the system clock is fixed to know how
the user wants leap seconds handled; in the mean time,
we assume that users of NTP are running without proper
leap second support (this is now the default anyway) */
* Leap second processing. If in leap-insert state at
* the end of the day, the system clock is set back one
* second; if in leap-delete state, the system clock is
* set ahead one second. The microtime() routine or
* external clock driver will insure that reported time
* is always monotonic. The ugly divides should be
if (time_status
& STA_INS
)
else if (time_status
& STA_DEL
)
if (time
.tv_sec
% 86400 == 0) {
if ((time
.tv_sec
+ 1) % 86400 == 0) {
if (!(time_status
& (STA_INS
| STA_DEL
)))
if (CLKF_BASEPRI(&frame
)) {
* Save the overhead of a software interrupt;
* it will happen as soon as we return, so do it now.
softclock(CLKF_USERMODE(&frame
));
int dk_ndrive
= DK_NDRIVE
;
* Gather statistics on resource utilization.
* We make a gross assumption: that the system has been in the
* state it is in (user state, kernel state, interrupt state,
* or idle state) for the entire last time interval, and
* update statistics accordingly.
* Determine what state the cpu is in.
if (CLKF_USERMODE(framep
)) {
if (curproc
->p_nice
> NZERO
)
* CPU was in system state. If profiling kernel
* increment a counter. If no process is running
* then this is a system tick if we were running
* at a non-zero IPL (in a driver). If a process is running,
* then we charge it with system time even if we were
* at a non-zero IPL, since the system often runs
* this way during processing of system calls.
* This is approximate, but the lack of true interval
* timers makes doing anything else difficult.
if (curproc
== NULL
&& CLKF_BASEPRI(framep
))
#if defined(GPROF) && !defined(GUPROF)
s
= (u_long
) CLKF_PC(framep
) - (u_long
) s_lowpc
; if (profiling
< 2 && s
< s_textsize
)
kcount
[s
/ (HISTFRACTION
* sizeof (*kcount
))]++; * We maintain statistics shown by user-level statistics
* programs: the amount of time in each cpu state, and
* the amount of time each of DK_NDRIVE ``drives'' is busy.
for (s
= 0; s
< DK_NDRIVE
; s
++)
* Software priority level clock interrupt.
* Run periodic events from timeout queue.
register struct callout
*p1
;
register timeout_func_t func
;
if ((p1
= calltodo
.c_next
) == 0 || p1
->c_time
> 0) {
arg
= p1
->c_arg
; func
= p1
->c_func
; a
= p1
->c_time
; calltodo
.c_next
= p1
->c_next
; * If no process to work with, we're finished.
if (curproc
== 0) return;
* If trapped user-mode and profiling, give it
register struct proc
*p
= curproc
;
if (p
->p_stats
->p_prof
.pr_scale
)
profile_tick(p
, unused was
&frame
);
* Check to see if process has accumulated
* more than 10 minutes of user time. If so
* reduce priority to give others a chance.
if (p
->p_ucred
->cr_uid
&& p
->p_nice
== NZERO
&&
p
->p_utime
.tv_sec
> 10 * 60) { * Arrange that (*func)(arg) is called in t/hz seconds.
register struct callout
*p1
, *p2
, *pnew
;
register int s
= splhigh();
panic("timeout table overflow");
for (p1
= &calltodo
; (p2
= p1
->c_next
) && p2
->c_time
< t
; p1
= p2
)
* untimeout is called to remove a function timeout call
* from the callout structure.
register struct callout
*p1
, *p2
;
for (p1
= &calltodo
; (p2
= p1
->c_next
) != 0; p1
= p2
) {
if (p2
->c_func
== func
&& p2
->c_arg
== arg
) {
if (p2
->c_next
&& p2
->c_time
> 0)
p2
->c_next
->c_time
+= p2
->c_time
; * Compute number of hz until specified time.
* Used to compute third argument to timeout() from an
register unsigned long ticks
;
* If the number of usecs in the whole seconds part of the time
* difference fits in a long, then the total number of usecs will
* fit in an unsigned long. Compute the total and convert it to
* ticks, rounding up and adding 1 to allow for the current tick
* to expire. Rounding also depends on unsigned long arithmetic
* Otherwise, if the number of ticks in the whole seconds part of
* the time difference fits in a long, then convert the parts to
* ticks separately and add, using similar rounding methods and
* overflow avoidance. This method would work in the previous
* case but it is slightly slower and assumes that hz is integral.
* Otherwise, round the time difference down to the maximum
* Maximum value for any timeout in 10ms ticks is 248 days.
sec
= tv
->tv_sec
- time
.tv_sec
; usec
= tv
->tv_usec
- time
.tv_usec
; printf("hzto: negative time difference %ld sec %ld usec\n",
} else if (sec
<= LONG_MAX
/ 1000000)
ticks
= (sec
* 1000000 + (unsigned long)usec
+ (tick
- 1)) else if (sec
<= LONG_MAX
/ hz
)
+ ((unsigned long)usec
+ (tick
- 1)) / tick
+ 1;
#define CLOCK_T_MAX INT_MAX /* XXX should be ULONG_MAX */
* hardpps() - discipline CPU clock oscillator to external pps signal
* This routine is called at each PPS interrupt in order to discipline
* the CPU clock oscillator to the PPS signal. It integrates successive
* phase differences between the two oscillators and calculates the
* frequency offset. This is used in hardclock() to discipline the CPU
* clock oscillator so that intrinsic frequency error is cancelled out.
* The code requires the caller to capture the time and hardware
* counter value at the designated PPS signal transition.
struct timeval
*tvp
; /* time at PPS */
long usec
; /* hardware counter at PPS */
long u_usec
, v_usec
, bigtick
;
* During the calibration interval adjust the starting time when
* the tick overflows. At the end of the interval compute the
* duration of the interval and the difference of the hardware
* counters at the beginning and end of the interval. This code
* is deliciously complicated by the fact valid differences may
* exceed the value of tick when using long calibration
* intervals and small ticks. Note that the counter can be
* greater than tick if caught at just the wrong instant, but
* the values returned and used here are correct.
bigtick
= (long)tick
<< SHIFT_USEC
; pps_usec
-= ntp_pll
.ybar
; if (pps_count
< (1 << pps_shift
))
u_usec
= usec
<< SHIFT_USEC
; v_usec
= pps_usec
- u_usec
; if (v_usec
>= bigtick
>> 1)
if (v_usec
< -(bigtick
>> 1))
v_usec
= -(-v_usec
>> ntp_pll
.shift
); v_usec
= v_usec
>> ntp_pll
.shift
; cal_sec
-= pps_time
.tv_sec
; cal_usec
-= pps_time
.tv_usec
; * Check for lost interrupts, noise, excessive jitter and
* excessive frequency error. The number of timer ticks during
* the interval may vary +-1 tick. Add to this a margin of one
* tick for the PPS signal jitter and maximum frequency
* deviation. If the limits are exceeded, the calibration
* interval is reset to the minimum and we start over.
u_usec
= (long)tick
<< 1; if (!((cal_sec
== -1 && cal_usec
> (1000000 - u_usec
))
|| (cal_sec
== 0 && cal_usec
< u_usec
))
|| v_usec
> ntp_pll
.tolerance
|| v_usec
< -ntp_pll
.tolerance
) {
ntp_pll
.shift
= NTP_PLL
.SHIFT
; pps_dispinc
= PPS_DISPINC
; * A three-stage median filter is used to help deglitch the pps
* signal. The median sample becomes the offset estimate; the
* difference between the other two samples becomes the
if (pps_mf
[0] > pps_mf
[1]) {
if (pps_mf
[1] > pps_mf
[2]) {
u_usec
= pps_mf
[1]; /* 0 1 2 */ v_usec
= pps_mf
[0] - pps_mf
[2]; } else if (pps_mf
[2] > pps_mf
[0]) {
u_usec
= pps_mf
[0]; /* 2 0 1 */ v_usec
= pps_mf
[2] - pps_mf
[1]; u_usec
= pps_mf
[2]; /* 0 2 1 */ v_usec
= pps_mf
[0] - pps_mf
[1]; if (pps_mf
[1] < pps_mf
[2]) {
u_usec
= pps_mf
[1]; /* 2 1 0 */ v_usec
= pps_mf
[2] - pps_mf
[0]; } else if (pps_mf
[2] < pps_mf
[0]) {
u_usec
= pps_mf
[0]; /* 1 0 2 */ v_usec
= pps_mf
[1] - pps_mf
[2]; u_usec
= pps_mf
[2]; /* 1 2 0 */ v_usec
= pps_mf
[1] - pps_mf
[0]; * Here the dispersion average is updated. If it is less than
* the threshold pps_dispmax, the frequency average is updated
* as well, but clamped to the tolerance.
v_usec
= (v_usec
>> 1) - ntp_pll
.disp
; ntp_pll
.disp
-= -v_usec
>> PPS_AVG
; ntp_pll
.disp
+= v_usec
>> PPS_AVG
; if (ntp_pll
.disp
> pps_dispmax
) {
ntp_pll
.ybar
-= -u_usec
>> PPS_AVG
; if (ntp_pll
.ybar
< -ntp_pll
.tolerance
)
ntp_pll
.ybar
= -ntp_pll
.tolerance
; ntp_pll
.ybar
+= u_usec
>> PPS_AVG
; if (ntp_pll
.ybar
> ntp_pll
.tolerance
)
ntp_pll
.ybar
= ntp_pll
.tolerance
; * Here the calibration interval is adjusted. If the maximum
* time difference is greater than tick/4, reduce the interval
* by half. If this is not the case for four consecutive
* intervals, double the interval.
if (u_usec
<< ntp_pll
.shift
> bigtick
>> 2) {
if (ntp_pll
.shift
> NTP_PLL
.SHIFT
) {
} else if (ntp_pll
.intcnt
>= 4) {
if (ntp_pll
.shift
< NTP_PLL
.SHIFTMAX
) {
projects / unix-history / blob