d/freebsd-nq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Synchronize with sys/i386/isa/clock.c revision 1.75.

Browse Source
This commit is contained in:
KATO Takenori 1997-01-30 10:44:05 +00:00
parent e10cf2fa74
commit d3e1120fab
3 changed files with 63 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
sys/pc98/cbus/clock.c
View File

@ -456,7 +456,7 @@ getit(void)
void
DELAY(int n)
{
int delta, prev_tick, tick, ticks_left, sec, usec;
int delta, prev_tick, tick, ticks_left;
#ifdef DELAYDEBUG
int getit_calls = 1;
@ -487,19 +487,30 @@ DELAY(int n)
* multiplications and divisions to scale the count take a while).
*/
prev_tick = getit();
n -= 20;
n -= 0; /* XXX actually guess no initial overhead */
/*
* Calculate (n * (timer_freq / 1e6)) without using floating point
* and without any avoidable overflows.
*/
sec = n / 1000000;
usec = n - sec * 1000000;
ticks_left = sec * timer_freq
+ usec * (timer_freq / 1000000)
+ usec * ((timer_freq % 1000000) / 1000) / 1000
+ usec * (timer_freq % 1000) / 1000000;
if (n < 0)
ticks_left = 0; /* XXX timer_freq is unsigned */
if (n <= 0)
ticks_left = 0;
else if (n < 256)
/*
* Use fixed point to avoid a slow division by 1000000.
* 39099 = 1193182 * 2^15 / 10^6 rounded to nearest.
* 2^15 is the first power of 2 that gives exact results
* for n between 0 and 256.
*/
ticks_left = ((u_int)n * 39099 + (1 << 15) - 1) >> 15;
else
/*
* Don't bother using fixed point, although gcc-2.7.2
* generates particularly poor code for the long long
* division, since even the slow way will complete long
* before the delay is up (unless we're interrupted).
*/
ticks_left = ((u_int)n * (long long)timer_freq + 999999)
/ 1000000;
while (ticks_left > 0) {
tick = getit();

31
sys/pc98/cbus/pcrtc.c
View File

@ -456,7 +456,7 @@ getit(void)
void
DELAY(int n)
{
int delta, prev_tick, tick, ticks_left, sec, usec;
int delta, prev_tick, tick, ticks_left;
#ifdef DELAYDEBUG
int getit_calls = 1;
@ -487,19 +487,30 @@ DELAY(int n)
* multiplications and divisions to scale the count take a while).
*/
prev_tick = getit();
n -= 20;
n -= 0; /* XXX actually guess no initial overhead */
/*
* Calculate (n * (timer_freq / 1e6)) without using floating point
* and without any avoidable overflows.
*/
sec = n / 1000000;
usec = n - sec * 1000000;
ticks_left = sec * timer_freq
+ usec * (timer_freq / 1000000)
+ usec * ((timer_freq % 1000000) / 1000) / 1000
+ usec * (timer_freq % 1000) / 1000000;
if (n < 0)
ticks_left = 0; /* XXX timer_freq is unsigned */
if (n <= 0)
ticks_left = 0;
else if (n < 256)
/*
* Use fixed point to avoid a slow division by 1000000.
* 39099 = 1193182 * 2^15 / 10^6 rounded to nearest.
* 2^15 is the first power of 2 that gives exact results
* for n between 0 and 256.
*/
ticks_left = ((u_int)n * 39099 + (1 << 15) - 1) >> 15;
else
/*
* Don't bother using fixed point, although gcc-2.7.2
* generates particularly poor code for the long long
* division, since even the slow way will complete long
* before the delay is up (unless we're interrupted).
*/
ticks_left = ((u_int)n * (long long)timer_freq + 999999)
/ 1000000;
while (ticks_left > 0) {
tick = getit();

31
sys/pc98/pc98/clock.c
View File

@ -456,7 +456,7 @@ getit(void)
void
DELAY(int n)
{
int delta, prev_tick, tick, ticks_left, sec, usec;
int delta, prev_tick, tick, ticks_left;
#ifdef DELAYDEBUG
int getit_calls = 1;
@ -487,19 +487,30 @@ DELAY(int n)
* multiplications and divisions to scale the count take a while).
*/
prev_tick = getit();
n -= 20;
n -= 0; /* XXX actually guess no initial overhead */
/*
* Calculate (n * (timer_freq / 1e6)) without using floating point
* and without any avoidable overflows.
*/
sec = n / 1000000;
usec = n - sec * 1000000;
ticks_left = sec * timer_freq
+ usec * (timer_freq / 1000000)
+ usec * ((timer_freq % 1000000) / 1000) / 1000
+ usec * (timer_freq % 1000) / 1000000;
if (n < 0)
ticks_left = 0; /* XXX timer_freq is unsigned */
if (n <= 0)
ticks_left = 0;
else if (n < 256)
/*
* Use fixed point to avoid a slow division by 1000000.
* 39099 = 1193182 * 2^15 / 10^6 rounded to nearest.
* 2^15 is the first power of 2 that gives exact results
* for n between 0 and 256.
*/
ticks_left = ((u_int)n * 39099 + (1 << 15) - 1) >> 15;
else
/*
* Don't bother using fixed point, although gcc-2.7.2
* generates particularly poor code for the long long
* division, since even the slow way will complete long
* before the delay is up (unless we're interrupted).
*/
ticks_left = ((u_int)n * (long long)timer_freq + 999999)
/ 1000000;
while (ticks_left > 0) {
tick = getit();