d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
d25917e856
freebsd-skq/sys/kern/kern_tc.c

594 lines
14 KiB
C
Raw Normal View History

Isolate the Timecounter internals in their own two files. Make the public interface more systematically named. Remove the alternate method, it doesn't do any good, only ruins performance. Add counters to profile the usage of the 8 access functions. Apply the beer-ware to my code. The weird +/- counts are caused by two repocopies behind the scenes: kern/kern_clock.c -> kern/kern_tc.c sys/time.h -> sys/timetc.h (thanks peter!)
2000-03-20 14:09:06 +00:00
/*
* ----------------------------------------------------------------------------
* "THE BEER-WARE LICENSE" (Revision 42):
* <phk@FreeBSD.ORG> wrote this file. As long as you retain this notice you
* can do whatever you want with this stuff. If we meet some day, and you think
* this stuff is worth it, you can buy me a beer in return. Poul-Henning Kamp
* ----------------------------------------------------------------------------
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
*
$Id$ -> $FreeBSD$
1999-08-28 01:08:13 +00:00
* $FreeBSD$
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
*/
Make even more of the PPSAPI implementations generic. FLL support in hardpps() Various magic shuffles and improved comments Style fixes from Bruce.
1999-03-11 15:09:51 +00:00
#include "opt_ntp.h"
BSD 4.4 Lite Kernel Sources
1994-05-24 10:09:53 +00:00
#include <sys/param.h>
Isolate the Timecounter internals in their own two files. Make the public interface more systematically named. Remove the alternate method, it doesn't do any good, only ruins performance. Add counters to profile the usage of the 8 access functions. Apply the beer-ware to my code. The weird +/- counts are caused by two repocopies behind the scenes: kern/kern_clock.c -> kern/kern_tc.c sys/time.h -> sys/timetc.h (thanks peter!)
2000-03-20 14:09:06 +00:00
#include <sys/timetc.h>
#include <sys/kernel.h>
#include <sys/sysctl.h>
#include <sys/systm.h>
Redo Kernel NTP PLL support, kernel side. This code is mostly taken from the 1.1 port (which was in turn taken from Dave Mills's kern.tar.Z example). A few significant differences: 1) ntp_gettime() is now a MIB variable rather than a system call. A few fiddles are done in libc to make it behave the same. 2) mono_time does not participate in the PLL adjustments. 3) A new interface has been defined (in <machine/clock.h>) for doing possibly machine-dependent things around the time of the clock update. This is used in Pentium kernels to disable interrupts, set `time', and reset the CPU cycle counter as quickly as possible to avoid jitter in microtime(). Measurements show an apparent resolution of a bit more than 8.14usec, which is reasonable given system-call overhead.
1994-09-18 20:40:01 +00:00
#include <sys/timex.h>
Make even more of the PPSAPI implementations generic. FLL support in hardpps() Various magic shuffles and improved comments Style fixes from Bruce.
1999-03-11 15:09:51 +00:00
#include <sys/timepps.h>
The improvements to clock statistics by Tor Egge Wrappered and enabled by the define BETTER_CLOCK (on by default in smpyests.h) Reviewed by: smp@csn.net Submitted by: Tor Egge <Tor.Egge@idi.ntnu.no>
1997-12-08 23:00:24 +00:00
Change the way we simulate stable storage for timecounters. If you have problems with the "calcru" messages and processes being killed for excessive cpu time, try to increase the NTIMECOUNTER #define and report your findings.
1998-10-23 10:44:52 +00:00
/*
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
* Implement a dummy timecounter which we can use until we get a real one
* in the air. This allows the console and other early stuff to use
* timeservices.
Change the way we simulate stable storage for timecounters. If you have problems with the "calcru" messages and processes being killed for excessive cpu time, try to increase the NTIMECOUNTER #define and report your findings.
1998-10-23 10:44:52 +00:00
*/
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
static unsigned
dummy_get_timecount(struct timecounter *tc)
{
static unsigned now;
return (++now);
}
static struct timecounter dummy_timecounter = {
dummy_get_timecount,
0,
~0u,
1000000,
"dummy"
};
struct timehands {
/* These fields must be initialized by the driver. */
struct timecounter *tc_counter;
int64_t tc_adjustment;
u_int64_t tc_scale;
unsigned tc_offset_count;
struct bintime tc_offset;
struct timeval tc_microtime;
struct timespec tc_nanotime;
/* Fields not to be copied in tc_windup start with tc_generation */
volatile unsigned tc_generation;
struct timehands *tc_next;
};
extern struct timehands th0;
static struct timehands th9 = { NULL, 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, 1, &th0};
static struct timehands th8 = { NULL, 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, 1, &th9};
static struct timehands th7 = { NULL, 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, 1, &th8};
static struct timehands th6 = { NULL, 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, 1, &th7};
static struct timehands th5 = { NULL, 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, 1, &th6};
static struct timehands th4 = { NULL, 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, 1, &th5};
static struct timehands th3 = { NULL, 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, 1, &th4};
static struct timehands th2 = { NULL, 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, 1, &th3};
static struct timehands th1 = { NULL, 0, 0, 0, {0, 0}, {0, 0}, {0, 0}, 1, &th2};
Explain magic number. Add magic date no explanation. Add a delta which was lost in transit yesterday which prevented other timecounters from actually being used.
2002-04-27 07:28:54 +00:00
static struct timehands th0 = {
&dummy_timecounter,
0,
18446744073709ULL, /* 2^64/1000000 */
0,
Don't screw up our uptime with historical dates.
2002-04-28 16:51:36 +00:00
{1, 0},
Explain magic number. Add magic date no explanation. Add a delta which was lost in transit yesterday which prevented other timecounters from actually being used.
2002-04-27 07:28:54 +00:00
{0, 0},
{0, 0},
1,
&th1
};
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
static struct timehands *volatile timehands = &th0;
struct timecounter *timecounter = &dummy_timecounter;
static struct timecounter *timecounters = &dummy_timecounter;
Change the way we simulate stable storage for timecounters. If you have problems with the "calcru" messages and processes being killed for excessive cpu time, try to increase the NTIMECOUNTER #define and report your findings.
1998-10-23 10:44:52 +00:00
Eradicate the variable "time" from the kernel, using various measures. "time" wasn't a atomic variable, so splfoo() protection were needed around any access to it, unless you just wanted the seconds part. Most uses of time.tv_sec now uses the new variable time_second instead. gettime() changed to getmicrotime(0. Remove a couple of unneeded splfoo() protections, the new getmicrotime() is atomic, (until Bruce sets a breakpoint in it). A couple of places needed random data, so use read_random() instead of mucking about with time which isn't random. Add a new nfs_curusec() function. Mark a couple of bogosities involving the now disappeard time variable. Update ffs_update() to avoid the weird "== &time" checks, by fixing the one remaining call that passwd &time as args. Change profiling in ncr.c to use ticks instead of time. Resolution is the same. Add new function "tvtohz()" to avoid the bogus "splfoo(), add time, call hzto() which subtracts time" sequences. Reviewed by: bde
1998-03-30 09:56:58 +00:00
time_t time_second;
Revise timercounters to use binary fixed point format internally. The binary format "bintime" is a 32.64 format, it will go to 64.64 when time_t does. The bintime format is available to consumers of time in the kernel, and is preferable where timeintervals needs to be accumulated. This change simplifies much of the magic math inside the timecounters and improves the frequency and time precision by a couple of bits. I have not been able to measure a performance difference which was not a tiny fraction of the standard deviation on the measurements.
2002-02-07 21:21:55 +00:00
struct bintime boottimebin;
Moved the definition of `boottime' and its sysctl to the correct file.
1999-09-13 14:22:27 +00:00
struct timeval boottime;
SYSCTL_STRUCT(_kern, KERN_BOOTTIME, boottime, CTLFLAG_RD,
&boottime, timeval, "System boottime");
Isolate the Timecounter internals in their own two files. Make the public interface more systematically named. Remove the alternate method, it doesn't do any good, only ruins performance. Add counters to profile the usage of the 8 access functions. Apply the beer-ware to my code. The weird +/- counts are caused by two repocopies behind the scenes: kern/kern_clock.c -> kern/kern_tc.c sys/time.h -> sys/timetc.h (thanks peter!)
2000-03-20 14:09:06 +00:00
SYSCTL_NODE(_kern, OID_AUTO, timecounter, CTLFLAG_RW, 0, "");
Various cleanup and sorting of clock reading functions. Add the two functions missing in the complete 12 function complement.
2002-04-26 10:19:29 +00:00
#define TC_STATS(foo) \
static unsigned foo; \
SYSCTL_INT(_kern_timecounter, OID_AUTO, foo, CTLFLAG_RD, & foo, 0, "")
TC_STATS(nbinuptime); TC_STATS(nnanouptime); TC_STATS(nmicrouptime);
TC_STATS(nbintime); TC_STATS(nnanotime); TC_STATS(nmicrotime);
TC_STATS(ngetbinuptime); TC_STATS(ngetnanouptime); TC_STATS(ngetmicrouptime);
TC_STATS(ngetbintime); TC_STATS(ngetnanotime); TC_STATS(ngetmicrotime);
#undef TC_STATS
Make the previous behaviour the default, add a sysctl which you can set if your hw/sw produces the "calcru negative..." message. Setting the alternate method (sysctl -w kern.timecounter.method=1) makes the the get{nano|micro}*() functions call the real thing at resulting in a measurable but minor overhead. I decided to NOT have the "calcru" change the method automatically because you should be aware of this problem if you have it. The problems currently seen, related to usleep and a few other corners are fixed for both methods.
1998-11-29 20:31:02 +00:00
Move the winding of timecounters out of hardclock and into a normal timeout loop. Limit the rate at which we wind the timecounters to approx 1000 Hz. This limits the precision of the get{bin,nano,micro}[up]time(9) functions to roughly a millisecond.
2002-04-26 12:37:36 +00:00
static void tc_windup(void);
Change the way we simulate stable storage for timecounters. If you have problems with the "calcru" messages and processes being killed for excessive cpu time, try to increase the NTIMECOUNTER #define and report your findings.
1998-10-23 10:44:52 +00:00
Some cleanups related to timecounters and weird ifdefs in <sys/time.h>. Clean up (or if antipodic: down) some of the msgbuf stuff. Use an inline function rather than a macro for timecounter delta. Maintain process "on-cpu" time as 64 bits of microseconds to avoid needless second rollover overhead. Avoid calling microuptime the second time in mi_switch() if we do not pass through _idle in cpu_switch() This should reduce our context-switch overhead a bit, in particular on pre-P5 and SMP systems. WARNING: Programs which muck about with struct proc in userland will have to be fixed. Reviewed, but found imperfect by: bde
1998-05-28 09:30:28 +00:00
static __inline unsigned
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
tc_delta(struct timehands *tc)
Some cleanups related to timecounters and weird ifdefs in <sys/time.h>. Clean up (or if antipodic: down) some of the msgbuf stuff. Use an inline function rather than a macro for timecounter delta. Maintain process "on-cpu" time as 64 bits of microseconds to avoid needless second rollover overhead. Avoid calling microuptime the second time in mi_switch() if we do not pass through _idle in cpu_switch() This should reduce our context-switch overhead a bit, in particular on pre-P5 and SMP systems. WARNING: Programs which muck about with struct proc in userland will have to be fixed. Reviewed, but found imperfect by: bde
1998-05-28 09:30:28 +00:00
{
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
return ((tc->tc_counter->tc_get_timecount(tc->tc_counter) -
tc->tc_offset_count) & tc->tc_counter->tc_counter_mask);
Some cleanups related to timecounters and weird ifdefs in <sys/time.h>. Clean up (or if antipodic: down) some of the msgbuf stuff. Use an inline function rather than a macro for timecounter delta. Maintain process "on-cpu" time as 64 bits of microseconds to avoid needless second rollover overhead. Avoid calling microuptime the second time in mi_switch() if we do not pass through _idle in cpu_switch() This should reduce our context-switch overhead a bit, in particular on pre-P5 and SMP systems. WARNING: Programs which muck about with struct proc in userland will have to be fixed. Reviewed, but found imperfect by: bde
1998-05-28 09:30:28 +00:00
}
Add two new functions, get{micro|nano}time. They are atomic, but return in essence what is in the "time" variable. gettime() is now a macro front for getmicrotime(). Various patches to use the two new functions instead of the various hacks used in their absence. Some puntuation and grammer patches from Bruce. A couple of XXX comments.
1998-03-26 20:54:05 +00:00
Revise timercounters to use binary fixed point format internally. The binary format "bintime" is a 32.64 format, it will go to 64.64 when time_t does. The bintime format is available to consumers of time in the kernel, and is preferable where timeintervals needs to be accumulated. This change simplifies much of the magic math inside the timecounters and improves the frequency and time precision by a couple of bits. I have not been able to measure a performance difference which was not a tiny fraction of the standard deviation on the measurements.
2002-02-07 21:21:55 +00:00
void
binuptime(struct bintime *bt)
{
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
struct timehands *tc;
Add a generation number to timecounters and spin if it changes under our feet when we look inside timecounter structures. Make the "sync_other" code more robust by never overwriting the tc_next field. Add counters for the bin[up]time functions. Call tc_windup() in tc_init() and switch_timecounter() to make sure we all the fields set right.
2002-02-24 20:04:07 +00:00
unsigned gen;
nbinuptime++;
do {
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
tc = timehands;
Add a generation number to timecounters and spin if it changes under our feet when we look inside timecounter structures. Make the "sync_other" code more robust by never overwriting the tc_next field. Add counters for the bin[up]time functions. Call tc_windup() in tc_init() and switch_timecounter() to make sure we all the fields set right.
2002-02-24 20:04:07 +00:00
gen = tc->tc_generation;
*bt = tc->tc_offset;
Rename tco_setscales() and tco_delta() to use the same tc_ prefix as the rest of this file.
2002-04-26 10:11:02 +00:00
bintime_addx(bt, tc->tc_scale * tc_delta(tc));
Add a generation number to timecounters and spin if it changes under our feet when we look inside timecounter structures. Make the "sync_other" code more robust by never overwriting the tc_next field. Add counters for the bin[up]time functions. Call tc_windup() in tc_init() and switch_timecounter() to make sure we all the fields set right.
2002-02-24 20:04:07 +00:00
} while (gen == 0 || gen != tc->tc_generation);
Revise timercounters to use binary fixed point format internally. The binary format "bintime" is a 32.64 format, it will go to 64.64 when time_t does. The bintime format is available to consumers of time in the kernel, and is preferable where timeintervals needs to be accumulated. This change simplifies much of the magic math inside the timecounters and improves the frequency and time precision by a couple of bits. I have not been able to measure a performance difference which was not a tiny fraction of the standard deviation on the measurements.
2002-02-07 21:21:55 +00:00
}
Various cleanup and sorting of clock reading functions. Add the two functions missing in the complete 12 function complement.
2002-04-26 10:19:29 +00:00
void
nanouptime(struct timespec *ts)
{
struct bintime bt;
nnanouptime++;
binuptime(&bt);
bintime2timespec(&bt, ts);
}
void
microuptime(struct timeval *tv)
{
struct bintime bt;
nmicrouptime++;
binuptime(&bt);
bintime2timeval(&bt, tv);
}
Revise timercounters to use binary fixed point format internally. The binary format "bintime" is a 32.64 format, it will go to 64.64 when time_t does. The bintime format is available to consumers of time in the kernel, and is preferable where timeintervals needs to be accumulated. This change simplifies much of the magic math inside the timecounters and improves the frequency and time precision by a couple of bits. I have not been able to measure a performance difference which was not a tiny fraction of the standard deviation on the measurements.
2002-02-07 21:21:55 +00:00
void
bintime(struct bintime *bt)
{
Add a generation number to timecounters and spin if it changes under our feet when we look inside timecounter structures. Make the "sync_other" code more robust by never overwriting the tc_next field. Add counters for the bin[up]time functions. Call tc_windup() in tc_init() and switch_timecounter() to make sure we all the fields set right.
2002-02-24 20:04:07 +00:00
nbintime++;
Revise timercounters to use binary fixed point format internally. The binary format "bintime" is a 32.64 format, it will go to 64.64 when time_t does. The bintime format is available to consumers of time in the kernel, and is preferable where timeintervals needs to be accumulated. This change simplifies much of the magic math inside the timecounters and improves the frequency and time precision by a couple of bits. I have not been able to measure a performance difference which was not a tiny fraction of the standard deviation on the measurements.
2002-02-07 21:21:55 +00:00
binuptime(bt);
bintime_add(bt, &boottimebin);
}
Add two new functions, get{micro|nano}time. They are atomic, but return in essence what is in the "time" variable. gettime() is now a macro front for getmicrotime(). Various patches to use the two new functions instead of the various hacks used in their absence. Some puntuation and grammer patches from Bruce. A couple of XXX comments.
1998-03-26 20:54:05 +00:00
void
Various cleanup and sorting of clock reading functions. Add the two functions missing in the complete 12 function complement.
2002-04-26 10:19:29 +00:00
nanotime(struct timespec *ts)
{
struct bintime bt;
nnanotime++;
bintime(&bt);
bintime2timespec(&bt, ts);
}
void
microtime(struct timeval *tv)
{
struct bintime bt;
nmicrotime++;
bintime(&bt);
bintime2timeval(&bt, tv);
}
void
getbinuptime(struct bintime *bt)
Add two new functions, get{micro|nano}time. They are atomic, but return in essence what is in the "time" variable. gettime() is now a macro front for getmicrotime(). Various patches to use the two new functions instead of the various hacks used in their absence. Some puntuation and grammer patches from Bruce. A couple of XXX comments.
1998-03-26 20:54:05 +00:00
{
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
struct timehands *tc;
Add a generation number to timecounters and spin if it changes under our feet when we look inside timecounter structures. Make the "sync_other" code more robust by never overwriting the tc_next field. Add counters for the bin[up]time functions. Call tc_windup() in tc_init() and switch_timecounter() to make sure we all the fields set right.
2002-02-24 20:04:07 +00:00
unsigned gen;
Add two new functions, get{micro|nano}time. They are atomic, but return in essence what is in the "time" variable. gettime() is now a macro front for getmicrotime(). Various patches to use the two new functions instead of the various hacks used in their absence. Some puntuation and grammer patches from Bruce. A couple of XXX comments.
1998-03-26 20:54:05 +00:00
Various cleanup and sorting of clock reading functions. Add the two functions missing in the complete 12 function complement.
2002-04-26 10:19:29 +00:00
ngetbinuptime++;
Add a generation number to timecounters and spin if it changes under our feet when we look inside timecounter structures. Make the "sync_other" code more robust by never overwriting the tc_next field. Add counters for the bin[up]time functions. Call tc_windup() in tc_init() and switch_timecounter() to make sure we all the fields set right.
2002-02-24 20:04:07 +00:00
do {
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
tc = timehands;
Add a generation number to timecounters and spin if it changes under our feet when we look inside timecounter structures. Make the "sync_other" code more robust by never overwriting the tc_next field. Add counters for the bin[up]time functions. Call tc_windup() in tc_init() and switch_timecounter() to make sure we all the fields set right.
2002-02-24 20:04:07 +00:00
gen = tc->tc_generation;
Various cleanup and sorting of clock reading functions. Add the two functions missing in the complete 12 function complement.
2002-04-26 10:19:29 +00:00
*bt = tc->tc_offset;
Add a generation number to timecounters and spin if it changes under our feet when we look inside timecounter structures. Make the "sync_other" code more robust by never overwriting the tc_next field. Add counters for the bin[up]time functions. Call tc_windup() in tc_init() and switch_timecounter() to make sure we all the fields set right.
2002-02-24 20:04:07 +00:00
} while (gen == 0 || gen != tc->tc_generation);
Time changes mark 2: * Figure out UTC relative to boottime. Four new functions provide time relative to boottime. * move "runtime" into struct proc. This helps fix the calcru() problem in SMP. * kill mono_time. * add timespec{add|sub|cmp} macros to time.h. (XXX: These may change!) * nanosleep, select & poll takes long sleeps one day at a time Reviewed by: bde Tested by: ache and others
1998-04-04 13:26:20 +00:00
}
void
Various cleanup and sorting of clock reading functions. Add the two functions missing in the complete 12 function complement.
2002-04-26 10:19:29 +00:00
getnanouptime(struct timespec *tsp)
Time changes mark 2: * Figure out UTC relative to boottime. Four new functions provide time relative to boottime. * move "runtime" into struct proc. This helps fix the calcru() problem in SMP. * kill mono_time. * add timespec{add|sub|cmp} macros to time.h. (XXX: These may change!) * nanosleep, select & poll takes long sleeps one day at a time Reviewed by: bde Tested by: ache and others
1998-04-04 13:26:20 +00:00
{
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
struct timehands *tc;
Add a generation number to timecounters and spin if it changes under our feet when we look inside timecounter structures. Make the "sync_other" code more robust by never overwriting the tc_next field. Add counters for the bin[up]time functions. Call tc_windup() in tc_init() and switch_timecounter() to make sure we all the fields set right.
2002-02-24 20:04:07 +00:00
unsigned gen;
Time changes mark 2: * Figure out UTC relative to boottime. Four new functions provide time relative to boottime. * move "runtime" into struct proc. This helps fix the calcru() problem in SMP. * kill mono_time. * add timespec{add|sub|cmp} macros to time.h. (XXX: These may change!) * nanosleep, select & poll takes long sleeps one day at a time Reviewed by: bde Tested by: ache and others
1998-04-04 13:26:20 +00:00
Various cleanup and sorting of clock reading functions. Add the two functions missing in the complete 12 function complement.
2002-04-26 10:19:29 +00:00
ngetnanouptime++;
Add a generation number to timecounters and spin if it changes under our feet when we look inside timecounter structures. Make the "sync_other" code more robust by never overwriting the tc_next field. Add counters for the bin[up]time functions. Call tc_windup() in tc_init() and switch_timecounter() to make sure we all the fields set right.
2002-02-24 20:04:07 +00:00
do {
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
tc = timehands;
Add a generation number to timecounters and spin if it changes under our feet when we look inside timecounter structures. Make the "sync_other" code more robust by never overwriting the tc_next field. Add counters for the bin[up]time functions. Call tc_windup() in tc_init() and switch_timecounter() to make sure we all the fields set right.
2002-02-24 20:04:07 +00:00
gen = tc->tc_generation;
Various cleanup and sorting of clock reading functions. Add the two functions missing in the complete 12 function complement.
2002-04-26 10:19:29 +00:00
bintime2timespec(&tc->tc_offset, tsp);
Add a generation number to timecounters and spin if it changes under our feet when we look inside timecounter structures. Make the "sync_other" code more robust by never overwriting the tc_next field. Add counters for the bin[up]time functions. Call tc_windup() in tc_init() and switch_timecounter() to make sure we all the fields set right.
2002-02-24 20:04:07 +00:00
} while (gen == 0 || gen != tc->tc_generation);
Time changes mark 2: * Figure out UTC relative to boottime. Four new functions provide time relative to boottime. * move "runtime" into struct proc. This helps fix the calcru() problem in SMP. * kill mono_time. * add timespec{add|sub|cmp} macros to time.h. (XXX: These may change!) * nanosleep, select & poll takes long sleeps one day at a time Reviewed by: bde Tested by: ache and others
1998-04-04 13:26:20 +00:00
}
void
s/nanoruntime/nanouptime/g s/microruntime/microuptime/g Reviewed by: bde
1998-05-17 11:53:46 +00:00
getmicrouptime(struct timeval *tvp)
Time changes mark 2: * Figure out UTC relative to boottime. Four new functions provide time relative to boottime. * move "runtime" into struct proc. This helps fix the calcru() problem in SMP. * kill mono_time. * add timespec{add|sub|cmp} macros to time.h. (XXX: These may change!) * nanosleep, select & poll takes long sleeps one day at a time Reviewed by: bde Tested by: ache and others
1998-04-04 13:26:20 +00:00
{
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
struct timehands *tc;
Add a generation number to timecounters and spin if it changes under our feet when we look inside timecounter structures. Make the "sync_other" code more robust by never overwriting the tc_next field. Add counters for the bin[up]time functions. Call tc_windup() in tc_init() and switch_timecounter() to make sure we all the fields set right.
2002-02-24 20:04:07 +00:00
unsigned gen;
Time changes mark 2: * Figure out UTC relative to boottime. Four new functions provide time relative to boottime. * move "runtime" into struct proc. This helps fix the calcru() problem in SMP. * kill mono_time. * add timespec{add|sub|cmp} macros to time.h. (XXX: These may change!) * nanosleep, select & poll takes long sleeps one day at a time Reviewed by: bde Tested by: ache and others
1998-04-04 13:26:20 +00:00
Isolate the Timecounter internals in their own two files. Make the public interface more systematically named. Remove the alternate method, it doesn't do any good, only ruins performance. Add counters to profile the usage of the 8 access functions. Apply the beer-ware to my code. The weird +/- counts are caused by two repocopies behind the scenes: kern/kern_clock.c -> kern/kern_tc.c sys/time.h -> sys/timetc.h (thanks peter!)
2000-03-20 14:09:06 +00:00
ngetmicrouptime++;
Add a generation number to timecounters and spin if it changes under our feet when we look inside timecounter structures. Make the "sync_other" code more robust by never overwriting the tc_next field. Add counters for the bin[up]time functions. Call tc_windup() in tc_init() and switch_timecounter() to make sure we all the fields set right.
2002-02-24 20:04:07 +00:00
do {
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
tc = timehands;
Add a generation number to timecounters and spin if it changes under our feet when we look inside timecounter structures. Make the "sync_other" code more robust by never overwriting the tc_next field. Add counters for the bin[up]time functions. Call tc_windup() in tc_init() and switch_timecounter() to make sure we all the fields set right.
2002-02-24 20:04:07 +00:00
gen = tc->tc_generation;
bintime2timeval(&tc->tc_offset, tvp);
} while (gen == 0 || gen != tc->tc_generation);
Add two new functions, get{micro|nano}time. They are atomic, but return in essence what is in the "time" variable. gettime() is now a macro front for getmicrotime(). Various patches to use the two new functions instead of the various hacks used in their absence. Some puntuation and grammer patches from Bruce. A couple of XXX comments.
1998-03-26 20:54:05 +00:00
}
void
Various cleanup and sorting of clock reading functions. Add the two functions missing in the complete 12 function complement.
2002-04-26 10:19:29 +00:00
getbintime(struct bintime *bt)
Add two new functions, get{micro|nano}time. They are atomic, but return in essence what is in the "time" variable. gettime() is now a macro front for getmicrotime(). Various patches to use the two new functions instead of the various hacks used in their absence. Some puntuation and grammer patches from Bruce. A couple of XXX comments.
1998-03-26 20:54:05 +00:00
{
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
struct timehands *tc;
Add a generation number to timecounters and spin if it changes under our feet when we look inside timecounter structures. Make the "sync_other" code more robust by never overwriting the tc_next field. Add counters for the bin[up]time functions. Call tc_windup() in tc_init() and switch_timecounter() to make sure we all the fields set right.
2002-02-24 20:04:07 +00:00
unsigned gen;
Add two new functions, get{micro|nano}time. They are atomic, but return in essence what is in the "time" variable. gettime() is now a macro front for getmicrotime(). Various patches to use the two new functions instead of the various hacks used in their absence. Some puntuation and grammer patches from Bruce. A couple of XXX comments.
1998-03-26 20:54:05 +00:00
Various cleanup and sorting of clock reading functions. Add the two functions missing in the complete 12 function complement.
2002-04-26 10:19:29 +00:00
ngetbintime++;
Add a generation number to timecounters and spin if it changes under our feet when we look inside timecounter structures. Make the "sync_other" code more robust by never overwriting the tc_next field. Add counters for the bin[up]time functions. Call tc_windup() in tc_init() and switch_timecounter() to make sure we all the fields set right.
2002-02-24 20:04:07 +00:00
do {
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
tc = timehands;
Add a generation number to timecounters and spin if it changes under our feet when we look inside timecounter structures. Make the "sync_other" code more robust by never overwriting the tc_next field. Add counters for the bin[up]time functions. Call tc_windup() in tc_init() and switch_timecounter() to make sure we all the fields set right.
2002-02-24 20:04:07 +00:00
gen = tc->tc_generation;
Various cleanup and sorting of clock reading functions. Add the two functions missing in the complete 12 function complement.
2002-04-26 10:19:29 +00:00
*bt = tc->tc_offset;
Add a generation number to timecounters and spin if it changes under our feet when we look inside timecounter structures. Make the "sync_other" code more robust by never overwriting the tc_next field. Add counters for the bin[up]time functions. Call tc_windup() in tc_init() and switch_timecounter() to make sure we all the fields set right.
2002-02-24 20:04:07 +00:00
} while (gen == 0 || gen != tc->tc_generation);
Various cleanup and sorting of clock reading functions. Add the two functions missing in the complete 12 function complement.
2002-04-26 10:19:29 +00:00
bintime_add(bt, &boottimebin);
Add two new functions, get{micro|nano}time. They are atomic, but return in essence what is in the "time" variable. gettime() is now a macro front for getmicrotime(). Various patches to use the two new functions instead of the various hacks used in their absence. Some puntuation and grammer patches from Bruce. A couple of XXX comments.
1998-03-26 20:54:05 +00:00
}
Add a nanotime() function so that we can start to use this call.
1998-02-15 13:55:06 +00:00
void
Various cleanup and sorting of clock reading functions. Add the two functions missing in the complete 12 function complement.
2002-04-26 10:19:29 +00:00
getnanotime(struct timespec *tsp)
Replace TOD clock code with more systematic approach. Highlights: * Simple model for underlying hardware. * Hardware basis for timekeeping can be changed on the fly. * Only one hardware clock responsible for TOD keeping. * Provides a real nanotime() function. * Time granularity: .232E-18 seconds. * Frequency granularity: .238E-12 s/s * Frequency adjustment is continuous in time. * Less overhead for frequency adjustment. * Improves xntpd performance. Reviewed by: bde, bde, bde
1998-02-20 16:36:17 +00:00
{
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
struct timehands *tc;
Various cleanup and sorting of clock reading functions. Add the two functions missing in the complete 12 function complement.
2002-04-26 10:19:29 +00:00
unsigned gen;
Replace TOD clock code with more systematic approach. Highlights: * Simple model for underlying hardware. * Hardware basis for timekeeping can be changed on the fly. * Only one hardware clock responsible for TOD keeping. * Provides a real nanotime() function. * Time granularity: .232E-18 seconds. * Frequency granularity: .238E-12 s/s * Frequency adjustment is continuous in time. * Less overhead for frequency adjustment. * Improves xntpd performance. Reviewed by: bde, bde, bde
1998-02-20 16:36:17 +00:00
Various cleanup and sorting of clock reading functions. Add the two functions missing in the complete 12 function complement.
2002-04-26 10:19:29 +00:00
ngetnanotime++;
do {
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
tc = timehands;
Various cleanup and sorting of clock reading functions. Add the two functions missing in the complete 12 function complement.
2002-04-26 10:19:29 +00:00
gen = tc->tc_generation;
*tsp = tc->tc_nanotime;
} while (gen == 0 || gen != tc->tc_generation);
Replace TOD clock code with more systematic approach. Highlights: * Simple model for underlying hardware. * Hardware basis for timekeeping can be changed on the fly. * Only one hardware clock responsible for TOD keeping. * Provides a real nanotime() function. * Time granularity: .232E-18 seconds. * Frequency granularity: .238E-12 s/s * Frequency adjustment is continuous in time. * Less overhead for frequency adjustment. * Improves xntpd performance. Reviewed by: bde, bde, bde
1998-02-20 16:36:17 +00:00
}
void
Various cleanup and sorting of clock reading functions. Add the two functions missing in the complete 12 function complement.
2002-04-26 10:19:29 +00:00
getmicrotime(struct timeval *tvp)
Replace TOD clock code with more systematic approach. Highlights: * Simple model for underlying hardware. * Hardware basis for timekeeping can be changed on the fly. * Only one hardware clock responsible for TOD keeping. * Provides a real nanotime() function. * Time granularity: .232E-18 seconds. * Frequency granularity: .238E-12 s/s * Frequency adjustment is continuous in time. * Less overhead for frequency adjustment. * Improves xntpd performance. Reviewed by: bde, bde, bde
1998-02-20 16:36:17 +00:00
{
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
struct timehands *tc;
Various cleanup and sorting of clock reading functions. Add the two functions missing in the complete 12 function complement.
2002-04-26 10:19:29 +00:00
unsigned gen;
Replace TOD clock code with more systematic approach. Highlights: * Simple model for underlying hardware. * Hardware basis for timekeeping can be changed on the fly. * Only one hardware clock responsible for TOD keeping. * Provides a real nanotime() function. * Time granularity: .232E-18 seconds. * Frequency granularity: .238E-12 s/s * Frequency adjustment is continuous in time. * Less overhead for frequency adjustment. * Improves xntpd performance. Reviewed by: bde, bde, bde
1998-02-20 16:36:17 +00:00
Various cleanup and sorting of clock reading functions. Add the two functions missing in the complete 12 function complement.
2002-04-26 10:19:29 +00:00
ngetmicrotime++;
do {
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
tc = timehands;
Various cleanup and sorting of clock reading functions. Add the two functions missing in the complete 12 function complement.
2002-04-26 10:19:29 +00:00
gen = tc->tc_generation;
*tvp = tc->tc_microtime;
} while (gen == 0 || gen != tc->tc_generation);
Replace TOD clock code with more systematic approach. Highlights: * Simple model for underlying hardware. * Hardware basis for timekeeping can be changed on the fly. * Only one hardware clock responsible for TOD keeping. * Provides a real nanotime() function. * Time granularity: .232E-18 seconds. * Frequency granularity: .238E-12 s/s * Frequency adjustment is continuous in time. * Less overhead for frequency adjustment. * Improves xntpd performance. Reviewed by: bde, bde, bde
1998-02-20 16:36:17 +00:00
}
static void
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
tc_setscales(struct timehands *tc)
Replace TOD clock code with more systematic approach. Highlights: * Simple model for underlying hardware. * Hardware basis for timekeeping can be changed on the fly. * Only one hardware clock responsible for TOD keeping. * Provides a real nanotime() function. * Time granularity: .232E-18 seconds. * Frequency granularity: .238E-12 s/s * Frequency adjustment is continuous in time. * Less overhead for frequency adjustment. * Improves xntpd performance. Reviewed by: bde, bde, bde
1998-02-20 16:36:17 +00:00
{
u_int64_t scale;
Revise timercounters to use binary fixed point format internally. The binary format "bintime" is a 32.64 format, it will go to 64.64 when time_t does. The bintime format is available to consumers of time in the kernel, and is preferable where timeintervals needs to be accumulated. This change simplifies much of the magic math inside the timecounters and improves the frequency and time precision by a couple of bits. I have not been able to measure a performance difference which was not a tiny fraction of the standard deviation on the measurements.
2002-02-07 21:21:55 +00:00
/* Sacrifice the lower bit to the deity for code clarity */
scale = 1ULL << 63;
Use better scaling factor for NTPs correction. Explain the magic.
2002-02-22 12:59:20 +00:00
/*
* We get nanoseconds with 32 bit binary fraction and want
* 64 bit binary fraction: x = a * 2^32 / 10^9 = a * 4.294967296
Improve the implementation of adjtime(2). Apply the change as a continuous slew rather than as a series of discrete steps and make it possible to adjust arbitraryly huge amounts of time in either direction. In practice this is done by hooking into the same once-per-second loop as the NTP PLL and setting a suitable frequency offset deducting the amount slewed from the remainder. If the remaining delta is larger than 1 second we slew at 5000PPM (5msec/sec), for a delta less than a second we slew at 500PPM (500usec/sec) and for the last one second period we will slew at whatever rate (less than 500PPM) it takes to eliminate the delta entirely. The old implementation stepped the clock a number of microseconds every HZ to acheive the same effect, using the same rates of change. Eliminate the global variables tickadj, tickdelta and timedelta and their various use and initializations. This removes the most significant obstacle to running timecounter and NTP housekeeping from a timeout rather than hardclock.
2002-04-15 12:23:11 +00:00
* The range is +/- 5000PPM so we can only multiply by about 850
* without overflowing. The best suitable fraction is 2199/512.
* Divide by 2 times 512 to match the temporary lower precision.
Use better scaling factor for NTPs correction. Explain the magic.
2002-02-22 12:59:20 +00:00
*/
Improve the implementation of adjtime(2). Apply the change as a continuous slew rather than as a series of discrete steps and make it possible to adjust arbitraryly huge amounts of time in either direction. In practice this is done by hooking into the same once-per-second loop as the NTP PLL and setting a suitable frequency offset deducting the amount slewed from the remainder. If the remaining delta is larger than 1 second we slew at 5000PPM (5msec/sec), for a delta less than a second we slew at 500PPM (500usec/sec) and for the last one second period we will slew at whatever rate (less than 500PPM) it takes to eliminate the delta entirely. The old implementation stepped the clock a number of microseconds every HZ to acheive the same effect, using the same rates of change. Eliminate the global variables tickadj, tickdelta and timedelta and their various use and initializations. This removes the most significant obstacle to running timecounter and NTP housekeeping from a timeout rather than hardclock.
2002-04-15 12:23:11 +00:00
scale += (tc->tc_adjustment / 1024) * 2199;
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
scale /= tc->tc_counter->tc_frequency;
Revise timercounters to use binary fixed point format internally. The binary format "bintime" is a 32.64 format, it will go to 64.64 when time_t does. The bintime format is available to consumers of time in the kernel, and is preferable where timeintervals needs to be accumulated. This change simplifies much of the magic math inside the timecounters and improves the frequency and time precision by a couple of bits. I have not been able to measure a performance difference which was not a tiny fraction of the standard deviation on the measurements.
2002-02-07 21:21:55 +00:00
tc->tc_scale = scale * 2;
Replace TOD clock code with more systematic approach. Highlights: * Simple model for underlying hardware. * Hardware basis for timekeeping can be changed on the fly. * Only one hardware clock responsible for TOD keeping. * Provides a real nanotime() function. * Time granularity: .232E-18 seconds. * Frequency granularity: .238E-12 s/s * Frequency adjustment is continuous in time. * Less overhead for frequency adjustment. * Improves xntpd performance. Reviewed by: bde, bde, bde
1998-02-20 16:36:17 +00:00
}
void
Isolate the Timecounter internals in their own two files. Make the public interface more systematically named. Remove the alternate method, it doesn't do any good, only ruins performance. Add counters to profile the usage of the 8 access functions. Apply the beer-ware to my code. The weird +/- counts are caused by two repocopies behind the scenes: kern/kern_clock.c -> kern/kern_tc.c sys/time.h -> sys/timetc.h (thanks peter!)
2000-03-20 14:09:06 +00:00
tc_init(struct timecounter *tc)
Replace TOD clock code with more systematic approach. Highlights: * Simple model for underlying hardware. * Hardware basis for timekeeping can be changed on the fly. * Only one hardware clock responsible for TOD keeping. * Provides a real nanotime() function. * Time granularity: .232E-18 seconds. * Frequency granularity: .238E-12 s/s * Frequency adjustment is continuous in time. * Less overhead for frequency adjustment. * Improves xntpd performance. Reviewed by: bde, bde, bde
1998-02-20 16:36:17 +00:00
{
Change the way we simulate stable storage for timecounters. If you have problems with the "calcru" messages and processes being killed for excessive cpu time, try to increase the NTIMECOUNTER #define and report your findings.
1998-10-23 10:44:52 +00:00
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
tc->tc_next = timecounters;
timecounters = tc;
Change the way we simulate stable storage for timecounters. If you have problems with the "calcru" messages and processes being killed for excessive cpu time, try to increase the NTIMECOUNTER #define and report your findings.
1998-10-23 10:44:52 +00:00
printf("Timecounter \"%s\" frequency %lu Hz\n",
tc->tc_name, (u_long)tc->tc_frequency);
Replace TOD clock code with more systematic approach. Highlights: * Simple model for underlying hardware. * Hardware basis for timekeeping can be changed on the fly. * Only one hardware clock responsible for TOD keeping. * Provides a real nanotime() function. * Time granularity: .232E-18 seconds. * Frequency granularity: .238E-12 s/s * Frequency adjustment is continuous in time. * Less overhead for frequency adjustment. * Improves xntpd performance. Reviewed by: bde, bde, bde
1998-02-20 16:36:17 +00:00
timecounter = tc;
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
}
u_int32_t
tc_getfrequency(void)
{
return (timehands->tc_counter->tc_frequency);
Replace TOD clock code with more systematic approach. Highlights: * Simple model for underlying hardware. * Hardware basis for timekeeping can be changed on the fly. * Only one hardware clock responsible for TOD keeping. * Provides a real nanotime() function. * Time granularity: .232E-18 seconds. * Frequency granularity: .238E-12 s/s * Frequency adjustment is continuous in time. * Less overhead for frequency adjustment. * Improves xntpd performance. Reviewed by: bde, bde, bde
1998-02-20 16:36:17 +00:00
}
void
Isolate the Timecounter internals in their own two files. Make the public interface more systematically named. Remove the alternate method, it doesn't do any good, only ruins performance. Add counters to profile the usage of the 8 access functions. Apply the beer-ware to my code. The weird +/- counts are caused by two repocopies behind the scenes: kern/kern_clock.c -> kern/kern_tc.c sys/time.h -> sys/timetc.h (thanks peter!)
2000-03-20 14:09:06 +00:00
tc_setclock(struct timespec *ts)
Add a nanotime() function so that we can start to use this call.
1998-02-15 13:55:06 +00:00
{
Time changes mark 2: * Figure out UTC relative to boottime. Four new functions provide time relative to boottime. * move "runtime" into struct proc. This helps fix the calcru() problem in SMP. * kill mono_time. * add timespec{add|sub|cmp} macros to time.h. (XXX: These may change!) * nanosleep, select & poll takes long sleeps one day at a time Reviewed by: bde Tested by: ache and others
1998-04-04 13:26:20 +00:00
struct timespec ts2;
s/nanoruntime/nanouptime/g s/microruntime/microuptime/g Reviewed by: bde
1998-05-17 11:53:46 +00:00
nanouptime(&ts2);
Time changes mark 2: * Figure out UTC relative to boottime. Four new functions provide time relative to boottime. * move "runtime" into struct proc. This helps fix the calcru() problem in SMP. * kill mono_time. * add timespec{add|sub|cmp} macros to time.h. (XXX: These may change!) * nanosleep, select & poll takes long sleeps one day at a time Reviewed by: bde Tested by: ache and others
1998-04-04 13:26:20 +00:00
boottime.tv_sec = ts->tv_sec - ts2.tv_sec;
boottime.tv_usec = (ts->tv_nsec - ts2.tv_nsec) / 1000;
if (boottime.tv_usec < 0) {
boottime.tv_usec += 1000000;
boottime.tv_sec--;
}
Revise timercounters to use binary fixed point format internally. The binary format "bintime" is a 32.64 format, it will go to 64.64 when time_t does. The bintime format is available to consumers of time in the kernel, and is preferable where timeintervals needs to be accumulated. This change simplifies much of the magic math inside the timecounters and improves the frequency and time precision by a couple of bits. I have not been able to measure a performance difference which was not a tiny fraction of the standard deviation on the measurements.
2002-02-07 21:21:55 +00:00
timeval2bintime(&boottime, &boottimebin);
Time changes mark 2: * Figure out UTC relative to boottime. Four new functions provide time relative to boottime. * move "runtime" into struct proc. This helps fix the calcru() problem in SMP. * kill mono_time. * add timespec{add|sub|cmp} macros to time.h. (XXX: These may change!) * nanosleep, select & poll takes long sleeps one day at a time Reviewed by: bde Tested by: ache and others
1998-04-04 13:26:20 +00:00
/* fiddle all the little crinkly bits around the fiords... */
Isolate the Timecounter internals in their own two files. Make the public interface more systematically named. Remove the alternate method, it doesn't do any good, only ruins performance. Add counters to profile the usage of the 8 access functions. Apply the beer-ware to my code. The weird +/- counts are caused by two repocopies behind the scenes: kern/kern_clock.c -> kern/kern_tc.c sys/time.h -> sys/timetc.h (thanks peter!)
2000-03-20 14:09:06 +00:00
tc_windup();
Add a nanotime() function so that we can start to use this call.
1998-02-15 13:55:06 +00:00
}
Replace TOD clock code with more systematic approach. Highlights: * Simple model for underlying hardware. * Hardware basis for timekeeping can be changed on the fly. * Only one hardware clock responsible for TOD keeping. * Provides a real nanotime() function. * Time granularity: .232E-18 seconds. * Frequency granularity: .238E-12 s/s * Frequency adjustment is continuous in time. * Less overhead for frequency adjustment. * Improves xntpd performance. Reviewed by: bde, bde, bde
1998-02-20 16:36:17 +00:00
Move the winding of timecounters out of hardclock and into a normal timeout loop. Limit the rate at which we wind the timecounters to approx 1000 Hz. This limits the precision of the get{bin,nano,micro}[up]time(9) functions to roughly a millisecond.
2002-04-26 12:37:36 +00:00
static void
Isolate the Timecounter internals in their own two files. Make the public interface more systematically named. Remove the alternate method, it doesn't do any good, only ruins performance. Add counters to profile the usage of the 8 access functions. Apply the beer-ware to my code. The weird +/- counts are caused by two repocopies behind the scenes: kern/kern_clock.c -> kern/kern_tc.c sys/time.h -> sys/timetc.h (thanks peter!)
2000-03-20 14:09:06 +00:00
tc_windup(void)
Replace TOD clock code with more systematic approach. Highlights: * Simple model for underlying hardware. * Hardware basis for timekeeping can be changed on the fly. * Only one hardware clock responsible for TOD keeping. * Provides a real nanotime() function. * Time granularity: .232E-18 seconds. * Frequency granularity: .238E-12 s/s * Frequency adjustment is continuous in time. * Less overhead for frequency adjustment. * Improves xntpd performance. Reviewed by: bde, bde, bde
1998-02-20 16:36:17 +00:00
{
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
struct timehands *tc, *tco;
Revise timercounters to use binary fixed point format internally. The binary format "bintime" is a 32.64 format, it will go to 64.64 when time_t does. The bintime format is available to consumers of time in the kernel, and is preferable where timeintervals needs to be accumulated. This change simplifies much of the magic math inside the timecounters and improves the frequency and time precision by a couple of bits. I have not been able to measure a performance difference which was not a tiny fraction of the standard deviation on the measurements.
2002-02-07 21:21:55 +00:00
struct bintime bt;
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
unsigned ogen, delta, ncount;
Revise timercounters to use binary fixed point format internally. The binary format "bintime" is a 32.64 format, it will go to 64.64 when time_t does. The bintime format is available to consumers of time in the kernel, and is preferable where timeintervals needs to be accumulated. This change simplifies much of the magic math inside the timecounters and improves the frequency and time precision by a couple of bits. I have not been able to measure a performance difference which was not a tiny fraction of the standard deviation on the measurements.
2002-02-07 21:21:55 +00:00
int i;
Replace TOD clock code with more systematic approach. Highlights: * Simple model for underlying hardware. * Hardware basis for timekeeping can be changed on the fly. * Only one hardware clock responsible for TOD keeping. * Provides a real nanotime() function. * Time granularity: .232E-18 seconds. * Frequency granularity: .238E-12 s/s * Frequency adjustment is continuous in time. * Less overhead for frequency adjustment. * Improves xntpd performance. Reviewed by: bde, bde, bde
1998-02-20 16:36:17 +00:00
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
ncount = 0; /* GCC is lame */
tco = timehands;
Add a generation number to timecounters and spin if it changes under our feet when we look inside timecounter structures. Make the "sync_other" code more robust by never overwriting the tc_next field. Add counters for the bin[up]time functions. Call tc_windup() in tc_init() and switch_timecounter() to make sure we all the fields set right.
2002-02-24 20:04:07 +00:00
tc = tco->tc_next;
ogen = tc->tc_generation;
tc->tc_generation = 0;
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
bcopy(tco, tc, __offsetof(struct timehands, tc_generation));
Rename tco_setscales() and tco_delta() to use the same tc_ prefix as the rest of this file.
2002-04-26 10:11:02 +00:00
delta = tc_delta(tc);
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
if (tc->tc_counter != timecounter)
ncount = timecounter->tc_get_timecount(timecounter);
Add a generation number to timecounters and spin if it changes under our feet when we look inside timecounter structures. Make the "sync_other" code more robust by never overwriting the tc_next field. Add counters for the bin[up]time functions. Call tc_windup() in tc_init() and switch_timecounter() to make sure we all the fields set right.
2002-02-24 20:04:07 +00:00
tc->tc_offset_count += delta;
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
tc->tc_offset_count &= tc->tc_counter->tc_counter_mask;
Add a generation number to timecounters and spin if it changes under our feet when we look inside timecounter structures. Make the "sync_other" code more robust by never overwriting the tc_next field. Add counters for the bin[up]time functions. Call tc_windup() in tc_init() and switch_timecounter() to make sure we all the fields set right.
2002-02-24 20:04:07 +00:00
bintime_addx(&tc->tc_offset, tc->tc_scale * delta);
Change the sign on a race-condition, so that instead of ending up several tens of milliseconds out in the future we end up the right place with a subweeniesecond error.
1998-07-04 19:12:21 +00:00
/*
* We may be inducing a tiny error here, the tc_poll_pps() may
Rename tco_setscales() and tco_delta() to use the same tc_ prefix as the rest of this file.
2002-04-26 10:11:02 +00:00
* process a latched count which happens after the tc_delta()
Change the sign on a race-condition, so that instead of ending up several tens of milliseconds out in the future we end up the right place with a subweeniesecond error.
1998-07-04 19:12:21 +00:00
* in sync_other_counter(), which would extend the previous
* counters parameters into the domain of this new one.
* Since the timewindow is very small for this, the error is
* going to be only a few weenieseconds (as Dave Mills would
* say), so lets just not talk more about it, OK ?
*/
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
if (tco->tc_counter->tc_poll_pps)
tco->tc_counter->tc_poll_pps(tco->tc_counter);
Hide the private parts of timecounter from a couple of places that don't really need to know the gory details.
2002-04-26 21:31:44 +00:00
for (i = tc->tc_offset.sec - tco->tc_offset.sec; i > 0; i--)
ntp_update_second(&tc->tc_adjustment, &tc->tc_offset.sec);
Explain magic number. Add magic date no explanation. Add a delta which was lost in transit yesterday which prevented other timecounters from actually being used.
2002-04-27 07:28:54 +00:00
if (tc->tc_counter != timecounter) {
tc->tc_counter = timecounter;
tc->tc_offset_count = ncount;
}
Hide the private parts of timecounter from a couple of places that don't really need to know the gory details.
2002-04-26 21:31:44 +00:00
tc_setscales(tc);
A bunch of BNN (Bruce Normal Nits) from bde: Bring back the softclock inlining save a couple of <<32's many white-space shuffles.
1998-03-16 10:19:12 +00:00
Revise timercounters to use binary fixed point format internally. The binary format "bintime" is a 32.64 format, it will go to 64.64 when time_t does. The bintime format is available to consumers of time in the kernel, and is preferable where timeintervals needs to be accumulated. This change simplifies much of the magic math inside the timecounters and improves the frequency and time precision by a couple of bits. I have not been able to measure a performance difference which was not a tiny fraction of the standard deviation on the measurements.
2002-02-07 21:21:55 +00:00
bt = tc->tc_offset;
bintime_add(&bt, &boottimebin);
bintime2timeval(&bt, &tc->tc_microtime);
bintime2timespec(&bt, &tc->tc_nanotime);
Add a generation number to timecounters and spin if it changes under our feet when we look inside timecounter structures. Make the "sync_other" code more robust by never overwriting the tc_next field. Add counters for the bin[up]time functions. Call tc_windup() in tc_init() and switch_timecounter() to make sure we all the fields set right.
2002-02-24 20:04:07 +00:00
ogen++;
if (ogen == 0)
ogen++;
tc->tc_generation = ogen;
Revise timercounters to use binary fixed point format internally. The binary format "bintime" is a 32.64 format, it will go to 64.64 when time_t does. The bintime format is available to consumers of time in the kernel, and is preferable where timeintervals needs to be accumulated. This change simplifies much of the magic math inside the timecounters and improves the frequency and time precision by a couple of bits. I have not been able to measure a performance difference which was not a tiny fraction of the standard deviation on the measurements.
2002-02-07 21:21:55 +00:00
time_second = tc->tc_microtime.tv_sec;
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
timehands = tc;
Replace TOD clock code with more systematic approach. Highlights: * Simple model for underlying hardware. * Hardware basis for timekeeping can be changed on the fly. * Only one hardware clock responsible for TOD keeping. * Provides a real nanotime() function. * Time granularity: .232E-18 seconds. * Frequency granularity: .238E-12 s/s * Frequency adjustment is continuous in time. * Less overhead for frequency adjustment. * Improves xntpd performance. Reviewed by: bde, bde, bde
1998-02-20 16:36:17 +00:00
}
Added a sysctl "kern.timecounter.hardware" for selecting the hardware used for timecounting. The possible values are the names of the physically present harware timecounters ("i8254" and "TSC" on i386's). Fixed some nearby bitrot in comments in <sys/time.h>. Reviewed by: phk
1999-07-18 15:07:20 +00:00
static int
Previous commit changing SYSCTL_HANDLER_ARGS violated KNF. Pointed out by: bde
2000-07-04 11:25:35 +00:00
sysctl_kern_timecounter_hardware(SYSCTL_HANDLER_ARGS)
Added a sysctl "kern.timecounter.hardware" for selecting the hardware used for timecounting. The possible values are the names of the physically present harware timecounters ("i8254" and "TSC" on i386's). Fixed some nearby bitrot in comments in <sys/time.h>. Reviewed by: phk
1999-07-18 15:07:20 +00:00
{
char newname[32];
struct timecounter *newtc, *tc;
int error;
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
tc = timecounter;
Added a sysctl "kern.timecounter.hardware" for selecting the hardware used for timecounting. The possible values are the names of the physically present harware timecounters ("i8254" and "TSC" on i386's). Fixed some nearby bitrot in comments in <sys/time.h>. Reviewed by: phk
1999-07-18 15:07:20 +00:00
strncpy(newname, tc->tc_name, sizeof(newname));
error = sysctl_handle_string(oidp, &newname[0], sizeof(newname), req);
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
if (error != 0 && req->newptr == NULL && !strcmp(newname, tc->tc_name))
return(error);
for (newtc = timecounters; newtc != NULL; newtc = newtc->tc_next) {
if (strcmp(newname, newtc->tc_name))
continue;
/* Warm up new timecounter. */
(void)newtc->tc_get_timecount(newtc);
(void)newtc->tc_get_timecount(newtc);
timecounter = newtc;
return (0);
Added a sysctl "kern.timecounter.hardware" for selecting the hardware used for timecounting. The possible values are the names of the physically present harware timecounters ("i8254" and "TSC" on i386's). Fixed some nearby bitrot in comments in <sys/time.h>. Reviewed by: phk
1999-07-18 15:07:20 +00:00
}
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
return (EINVAL);
Added a sysctl "kern.timecounter.hardware" for selecting the hardware used for timecounting. The possible values are the names of the physically present harware timecounters ("i8254" and "TSC" on i386's). Fixed some nearby bitrot in comments in <sys/time.h>. Reviewed by: phk
1999-07-18 15:07:20 +00:00
}
SYSCTL_PROC(_kern_timecounter, OID_AUTO, hardware, CTLTYPE_STRING | CTLFLAG_RW,
0, 0, sysctl_kern_timecounter_hardware, "A", "");
Make even more of the PPSAPI implementations generic. FLL support in hardpps() Various magic shuffles and improved comments Style fixes from Bruce.
1999-03-11 15:09:51 +00:00
int
pps_ioctl(u_long cmd, caddr_t data, struct pps_state *pps)
Replace TOD clock code with more systematic approach. Highlights: * Simple model for underlying hardware. * Hardware basis for timekeeping can be changed on the fly. * Only one hardware clock responsible for TOD keeping. * Provides a real nanotime() function. * Time granularity: .232E-18 seconds. * Frequency granularity: .238E-12 s/s * Frequency adjustment is continuous in time. * Less overhead for frequency adjustment. * Improves xntpd performance. Reviewed by: bde, bde, bde
1998-02-20 16:36:17 +00:00
{
Update the PPSAPI to draft-mogul-pps-api-05.txt which is the latest. NOTE: This will break building ntpd until ntpd has been upgraded to also support draft 05. People that want to build ntpd in the meantime can get patches from me.
1999-10-09 14:49:56 +00:00
pps_params_t *app;
struct pps_fetch_args *fapi;
#ifdef PPS_SYNC around "kapi" declaration to fix a -Wunused warning.
1999-10-10 16:18:36 +00:00
#ifdef PPS_SYNC
Update the PPSAPI to draft-mogul-pps-api-05.txt which is the latest. NOTE: This will break building ntpd until ntpd has been upgraded to also support draft 05. People that want to build ntpd in the meantime can get patches from me.
1999-10-09 14:49:56 +00:00
struct pps_kcbind_args *kapi;
#ifdef PPS_SYNC around "kapi" declaration to fix a -Wunused warning.
1999-10-10 16:18:36 +00:00
#endif
Update the PPSAPI to draft-mogul-pps-api-05.txt which is the latest. NOTE: This will break building ntpd until ntpd has been upgraded to also support draft 05. People that want to build ntpd in the meantime can get patches from me.
1999-10-09 14:49:56 +00:00
switch (cmd) {
case PPS_IOC_CREATE:
return (0);
case PPS_IOC_DESTROY:
return (0);
case PPS_IOC_SETPARAMS:
app = (pps_params_t *)data;
if (app->mode & ~pps->ppscap)
return (EINVAL);
pps->ppsparam = *app;
return (0);
case PPS_IOC_GETPARAMS:
app = (pps_params_t *)data;
*app = pps->ppsparam;
app->api_version = PPS_API_VERS_1;
return (0);
case PPS_IOC_GETCAP:
*(int*)data = pps->ppscap;
return (0);
case PPS_IOC_FETCH:
fapi = (struct pps_fetch_args *)data;
if (fapi->tsformat && fapi->tsformat != PPS_TSFMT_TSPEC)
return (EINVAL);
if (fapi->timeout.tv_sec || fapi->timeout.tv_nsec)
return (EOPNOTSUPP);
pps->ppsinfo.current_mode = pps->ppsparam.mode;
fapi->pps_info_buf = pps->ppsinfo;
return (0);
case PPS_IOC_KCBIND:
#ifdef PPS_SYNC
kapi = (struct pps_kcbind_args *)data;
/* XXX Only root should be able to do this */
if (kapi->tsformat && kapi->tsformat != PPS_TSFMT_TSPEC)
return (EINVAL);
if (kapi->kernel_consumer != PPS_KC_HARDPPS)
return (EINVAL);
if (kapi->edge & ~pps->ppscap)
return (EINVAL);
pps->kcmode = kapi->edge;
return (0);
#else
return (EOPNOTSUPP);
#endif
default:
return (ENOTTY);
}
Make even more of the PPSAPI implementations generic. FLL support in hardpps() Various magic shuffles and improved comments Style fixes from Bruce.
1999-03-11 15:09:51 +00:00
}
A bunch of BNN (Bruce Normal Nits) from bde: Bring back the softclock inlining save a couple of <<32's many white-space shuffles.
1998-03-16 10:19:12 +00:00
Make even more of the PPSAPI implementations generic. FLL support in hardpps() Various magic shuffles and improved comments Style fixes from Bruce.
1999-03-11 15:09:51 +00:00
void
pps_init(struct pps_state *pps)
{
pps->ppscap |= PPS_TSFMT_TSPEC;
if (pps->ppscap & PPS_CAPTUREASSERT)
pps->ppscap |= PPS_OFFSETASSERT;
if (pps->ppscap & PPS_CAPTURECLEAR)
pps->ppscap |= PPS_OFFSETCLEAR;
Replace TOD clock code with more systematic approach. Highlights: * Simple model for underlying hardware. * Hardware basis for timekeeping can be changed on the fly. * Only one hardware clock responsible for TOD keeping. * Provides a real nanotime() function. * Time granularity: .232E-18 seconds. * Frequency granularity: .238E-12 s/s * Frequency adjustment is continuous in time. * Less overhead for frequency adjustment. * Improves xntpd performance. Reviewed by: bde, bde, bde
1998-02-20 16:36:17 +00:00
}
Make even more of the PPSAPI implementations generic. FLL support in hardpps() Various magic shuffles and improved comments Style fixes from Bruce.
1999-03-11 15:09:51 +00:00
void
Simplify the RFC2783 and PPS_SYNC timestamp collection API.
2002-04-26 20:24:28 +00:00
pps_capture(struct pps_state *pps)
{
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
struct timehands *tc;
Simplify the RFC2783 and PPS_SYNC timestamp collection API.
2002-04-26 20:24:28 +00:00
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
tc = timehands;
Simplify the RFC2783 and PPS_SYNC timestamp collection API.
2002-04-26 20:24:28 +00:00
pps->captc = tc;
pps->capgen = tc->tc_generation;
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
pps->capcount = tc->tc_counter->tc_get_timecount(tc->tc_counter);
Simplify the RFC2783 and PPS_SYNC timestamp collection API.
2002-04-26 20:24:28 +00:00
}
void
pps_event(struct pps_state *pps, int event)
Replace TOD clock code with more systematic approach. Highlights: * Simple model for underlying hardware. * Hardware basis for timekeeping can be changed on the fly. * Only one hardware clock responsible for TOD keeping. * Provides a real nanotime() function. * Time granularity: .232E-18 seconds. * Frequency granularity: .238E-12 s/s * Frequency adjustment is continuous in time. * Less overhead for frequency adjustment. * Improves xntpd performance. Reviewed by: bde, bde, bde
1998-02-20 16:36:17 +00:00
{
Make even more of the PPSAPI implementations generic. FLL support in hardpps() Various magic shuffles and improved comments Style fixes from Bruce.
1999-03-11 15:09:51 +00:00
struct timespec ts, *tsp, *osp;
unsigned tcount, *pcount;
Revise timercounters to use binary fixed point format internally. The binary format "bintime" is a 32.64 format, it will go to 64.64 when time_t does. The bintime format is available to consumers of time in the kernel, and is preferable where timeintervals needs to be accumulated. This change simplifies much of the magic math inside the timecounters and improves the frequency and time precision by a couple of bits. I have not been able to measure a performance difference which was not a tiny fraction of the standard deviation on the measurements.
2002-02-07 21:21:55 +00:00
struct bintime bt;
Make even more of the PPSAPI implementations generic. FLL support in hardpps() Various magic shuffles and improved comments Style fixes from Bruce.
1999-03-11 15:09:51 +00:00
int foff, fhard;
pps_seq_t *pseq;
Simplify the RFC2783 and PPS_SYNC timestamp collection API.
2002-04-26 20:24:28 +00:00
/* If the timecounter were wound up, bail. */
if (pps->capgen != pps->capgen)
return;
Make even more of the PPSAPI implementations generic. FLL support in hardpps() Various magic shuffles and improved comments Style fixes from Bruce.
1999-03-11 15:09:51 +00:00
/* Things would be easier with arrays... */
if (event == PPS_CAPTUREASSERT) {
tsp = &pps->ppsinfo.assert_timestamp;
osp = &pps->ppsparam.assert_offset;
foff = pps->ppsparam.mode & PPS_OFFSETASSERT;
Update the PPSAPI to draft-mogul-pps-api-05.txt which is the latest. NOTE: This will break building ntpd until ntpd has been upgraded to also support draft 05. People that want to build ntpd in the meantime can get patches from me.
1999-10-09 14:49:56 +00:00
fhard = pps->kcmode & PPS_CAPTUREASSERT;
Make even more of the PPSAPI implementations generic. FLL support in hardpps() Various magic shuffles and improved comments Style fixes from Bruce.
1999-03-11 15:09:51 +00:00
pcount = &pps->ppscount[0];
pseq = &pps->ppsinfo.assert_sequence;
} else {
tsp = &pps->ppsinfo.clear_timestamp;
osp = &pps->ppsparam.clear_offset;
foff = pps->ppsparam.mode & PPS_OFFSETCLEAR;
Update the PPSAPI to draft-mogul-pps-api-05.txt which is the latest. NOTE: This will break building ntpd until ntpd has been upgraded to also support draft 05. People that want to build ntpd in the meantime can get patches from me.
1999-10-09 14:49:56 +00:00
fhard = pps->kcmode & PPS_CAPTURECLEAR;
Make even more of the PPSAPI implementations generic. FLL support in hardpps() Various magic shuffles and improved comments Style fixes from Bruce.
1999-03-11 15:09:51 +00:00
pcount = &pps->ppscount[1];
pseq = &pps->ppsinfo.clear_sequence;
}
A bunch of BNN (Bruce Normal Nits) from bde: Bring back the softclock inlining save a couple of <<32's many white-space shuffles.
1998-03-16 10:19:12 +00:00
Make even more of the PPSAPI implementations generic. FLL support in hardpps() Various magic shuffles and improved comments Style fixes from Bruce.
1999-03-11 15:09:51 +00:00
/* The timecounter changed: bail */
if (!pps->ppstc ||
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
pps->ppstc != pps->captc->tc_counter ||
pps->captc->tc_counter != timehands->tc_counter) {
pps->ppstc = pps->captc->tc_counter;
Simplify the RFC2783 and PPS_SYNC timestamp collection API.
2002-04-26 20:24:28 +00:00
*pcount = pps->capcount;
#ifdef PPS_SYNC
pps->ppscount[2] = pps->capcount;
#endif
Make even more of the PPSAPI implementations generic. FLL support in hardpps() Various magic shuffles and improved comments Style fixes from Bruce.
1999-03-11 15:09:51 +00:00
return;
}
Replace TOD clock code with more systematic approach. Highlights: * Simple model for underlying hardware. * Hardware basis for timekeeping can be changed on the fly. * Only one hardware clock responsible for TOD keeping. * Provides a real nanotime() function. * Time granularity: .232E-18 seconds. * Frequency granularity: .238E-12 s/s * Frequency adjustment is continuous in time. * Less overhead for frequency adjustment. * Improves xntpd performance. Reviewed by: bde, bde, bde
1998-02-20 16:36:17 +00:00
Make even more of the PPSAPI implementations generic. FLL support in hardpps() Various magic shuffles and improved comments Style fixes from Bruce.
1999-03-11 15:09:51 +00:00
/* Nothing really happened */
Simplify the RFC2783 and PPS_SYNC timestamp collection API.
2002-04-26 20:24:28 +00:00
if (*pcount == pps->capcount)
Make even more of the PPSAPI implementations generic. FLL support in hardpps() Various magic shuffles and improved comments Style fixes from Bruce.
1999-03-11 15:09:51 +00:00
return;
Make the previous behaviour the default, add a sysctl which you can set if your hw/sw produces the "calcru negative..." message. Setting the alternate method (sysctl -w kern.timecounter.method=1) makes the the get{nano|micro}*() functions call the real thing at resulting in a measurable but minor overhead. I decided to NOT have the "calcru" change the method automatically because you should be aware of this problem if you have it. The problems currently seen, related to usleep and a few other corners are fixed for both methods.
1998-11-29 20:31:02 +00:00
Make even more of the PPSAPI implementations generic. FLL support in hardpps() Various magic shuffles and improved comments Style fixes from Bruce.
1999-03-11 15:09:51 +00:00
/* Convert the count to timespec */
Simplify the RFC2783 and PPS_SYNC timestamp collection API.
2002-04-26 20:24:28 +00:00
tcount = pps->capcount - pps->captc->tc_offset_count;
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
tcount &= pps->captc->tc_counter->tc_counter_mask;
Simplify the RFC2783 and PPS_SYNC timestamp collection API.
2002-04-26 20:24:28 +00:00
bt = pps->captc->tc_offset;
bintime_addx(&bt, pps->captc->tc_scale * tcount);
Revise timercounters to use binary fixed point format internally. The binary format "bintime" is a 32.64 format, it will go to 64.64 when time_t does. The bintime format is available to consumers of time in the kernel, and is preferable where timeintervals needs to be accumulated. This change simplifies much of the magic math inside the timecounters and improves the frequency and time precision by a couple of bits. I have not been able to measure a performance difference which was not a tiny fraction of the standard deviation on the measurements.
2002-02-07 21:21:55 +00:00
bintime2timespec(&bt, &ts);
Make even more of the PPSAPI implementations generic. FLL support in hardpps() Various magic shuffles and improved comments Style fixes from Bruce.
1999-03-11 15:09:51 +00:00
Simplify the RFC2783 and PPS_SYNC timestamp collection API.
2002-04-26 20:24:28 +00:00
/* If the timecounter were wound up, bail. */
if (pps->capgen != pps->capgen)
return;
*pcount = pps->capcount;
Make even more of the PPSAPI implementations generic. FLL support in hardpps() Various magic shuffles and improved comments Style fixes from Bruce.
1999-03-11 15:09:51 +00:00
(*pseq)++;
*tsp = ts;
Update the PPSAPI to draft-mogul-pps-api-05.txt which is the latest. NOTE: This will break building ntpd until ntpd has been upgraded to also support draft 05. People that want to build ntpd in the meantime can get patches from me.
1999-10-09 14:49:56 +00:00
Make even more of the PPSAPI implementations generic. FLL support in hardpps() Various magic shuffles and improved comments Style fixes from Bruce.
1999-03-11 15:09:51 +00:00
if (foff) {
timespecadd(tsp, osp);
if (tsp->tv_nsec < 0) {
tsp->tv_nsec += 1000000000;
tsp->tv_sec -= 1;
}
}
#ifdef PPS_SYNC
if (fhard) {
/* magic, at its best... */
Simplify the RFC2783 and PPS_SYNC timestamp collection API.
2002-04-26 20:24:28 +00:00
tcount = pps->capcount - pps->ppscount[2];
pps->ppscount[2] = pps->capcount;
Now that the private parts of timecounters are no longer being fingered by other bits of code, split struct timecounter into two. struct timecounter contains just the bits which pertains to the hardware counter and the reading of it. struct timehands (as in "the hands on a clock") contains all the ugly bit fidling stuff. Statically compile ten timehands. This commit is the functional part. A later cosmetic patch will rename various variables and fieldnames.
2002-04-26 21:51:08 +00:00
tcount &= pps->captc->tc_counter->tc_counter_mask;
Revise timercounters to use binary fixed point format internally. The binary format "bintime" is a 32.64 format, it will go to 64.64 when time_t does. The bintime format is available to consumers of time in the kernel, and is preferable where timeintervals needs to be accumulated. This change simplifies much of the magic math inside the timecounters and improves the frequency and time precision by a couple of bits. I have not been able to measure a performance difference which was not a tiny fraction of the standard deviation on the measurements.
2002-02-07 21:21:55 +00:00
bt.sec = 0;
bt.frac = 0;
Simplify the RFC2783 and PPS_SYNC timestamp collection API.
2002-04-26 20:24:28 +00:00
bintime_addx(&bt, pps->captc->tc_scale * tcount);
Revise timercounters to use binary fixed point format internally. The binary format "bintime" is a 32.64 format, it will go to 64.64 when time_t does. The bintime format is available to consumers of time in the kernel, and is preferable where timeintervals needs to be accumulated. This change simplifies much of the magic math inside the timecounters and improves the frequency and time precision by a couple of bits. I have not been able to measure a performance difference which was not a tiny fraction of the standard deviation on the measurements.
2002-02-07 21:21:55 +00:00
bintime2timespec(&bt, &ts);
hardpps(tsp, ts.tv_nsec + 1000000000 * ts.tv_sec);
Make even more of the PPSAPI implementations generic. FLL support in hardpps() Various magic shuffles and improved comments Style fixes from Bruce.
1999-03-11 15:09:51 +00:00
}
#endif
}
Move the winding of timecounters out of hardclock and into a normal timeout loop. Limit the rate at which we wind the timecounters to approx 1000 Hz. This limits the precision of the get{bin,nano,micro}[up]time(9) functions to roughly a millisecond.
2002-04-26 12:37:36 +00:00
/*-
* Timecounters need to be updated every so often to prevent the hardware
* counter from overflowing. Updating also recalculates the cached values
* used by the get*() family of functions, so their precision depends on
* the update frequency.
* Don't update faster than approx once per millisecond, if people want
* better timestamps they should use the non-"get" functions.
*/
static int tc_tick;
SYSCTL_INT(_kern_timecounter, OID_AUTO, tick, CTLFLAG_RD, &tick, 0, "");
static void
tc_ticktock(void *dummy)
{
tc_windup();
timeout(tc_ticktock, NULL, tc_tick);
}
static void
inittimecounter(void *dummy)
{
u_int p;
if (hz > 1000)
tc_tick = (hz + 500) / 1000;
else
tc_tick = 1;
p = (tc_tick * 1000000) / hz;
printf("Timecounters tick every %d.%03u msec\n", p / 1000, p % 1000);
tc_ticktock(NULL);
}
SYSINIT(timecounter, SI_SUB_CLOCKS, SI_ORDER_FIRST, inittimecounter, NULL)
Reference in New Issue Copy Permalink