X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?p=pintos-anon;a=blobdiff_plain;f=src%2Fdevices%2Ftimer.c;h=70234a808844e425d8309f6cd04c09ce11ad230e;hp=9e1b4989c833b62cfcaa5a66032c1cae1124fec0;hb=cc5c971c3cc498d528a2f74f4dc2f8e27a690311;hpb=9a23b07779a919205f9a355c81b67b629e929575 diff --git a/src/devices/timer.c b/src/devices/timer.c index 9e1b498..70234a8 100644 --- a/src/devices/timer.c +++ b/src/devices/timer.c @@ -5,6 +5,7 @@ #include #include "threads/interrupt.h" #include "threads/io.h" +#include "threads/synch.h" #include "threads/thread.h" /* See [8254] for hardware details of the 8254 timer chip. */ @@ -16,11 +17,8 @@ #error TIMER_FREQ <= 1000 recommended #endif -/* Number of time ticks to elapse between process yields. */ -#define TIME_SLICE 1 - /* Number of timer ticks since OS booted. */ -static volatile int64_t ticks; +static int64_t ticks; /* Number of loops per timer tick. Initialized by timer_calibrate(). */ @@ -30,6 +28,7 @@ static intr_handler_func timer_interrupt; static bool too_many_loops (unsigned loops); static void busy_wait (int64_t loops); static void real_time_sleep (int64_t num, int32_t denom); +static void real_time_delay (int64_t num, int32_t denom); /* Sets up the 8254 Programmable Interval Timer (PIT) to interrupt PIT_FREQ times per second, and registers the @@ -45,7 +44,7 @@ timer_init (void) outb (0x40, count & 0xff); outb (0x40, count >> 8); - intr_register (0x20, 0, INTR_OFF, timer_interrupt, "8254 Timer"); + intr_register_ext (0x20, timer_interrupt, "8254 Timer"); } /* Calibrates loops_per_tick, used to implement brief delays. */ @@ -60,8 +59,11 @@ timer_calibrate (void) /* Approximate loops_per_tick as the largest power-of-two still less than one timer tick. */ loops_per_tick = 1u << 10; - while (!too_many_loops (loops_per_tick << 1)) - loops_per_tick <<= 1; + while (!too_many_loops (loops_per_tick << 1)) + { + loops_per_tick <<= 1; + ASSERT (loops_per_tick != 0); + } /* Refine the next 8 bits of loops_per_tick. */ high_bit = loops_per_tick; @@ -79,6 +81,7 @@ timer_ticks (void) enum intr_level old_level = intr_disable (); int64_t t = ticks; intr_set_level (old_level); + barrier (); return t; } @@ -90,7 +93,8 @@ timer_elapsed (int64_t then) return timer_ticks () - then; } -/* Suspends execution for approximately TICKS timer ticks. */ +/* Sleeps for approximately TICKS timer ticks. Interrupts must + be turned on. */ void timer_sleep (int64_t ticks) { @@ -101,32 +105,74 @@ timer_sleep (int64_t ticks) thread_yield (); } -/* Suspends execution for approximately MS milliseconds. */ +/* Sleeps for approximately MS milliseconds. Interrupts must be + turned on. */ void timer_msleep (int64_t ms) { real_time_sleep (ms, 1000); } -/* Suspends execution for approximately US microseconds. */ +/* Sleeps for approximately US microseconds. Interrupts must be + turned on. */ void timer_usleep (int64_t us) { real_time_sleep (us, 1000 * 1000); } -/* Suspends execution for approximately NS nanoseconds. */ +/* Sleeps for approximately NS nanoseconds. Interrupts must be + turned on. */ void timer_nsleep (int64_t ns) { real_time_sleep (ns, 1000 * 1000 * 1000); } +/* Busy-waits for approximately MS milliseconds. Interrupts need + not be turned on. + + Busy waiting wastes CPU cycles, and busy waiting with + interrupts off for the interval between timer ticks or longer + will cause timer ticks to be lost. Thus, use timer_msleep() + instead if interrupts are enabled. */ +void +timer_mdelay (int64_t ms) +{ + real_time_delay (ms, 1000); +} + +/* Sleeps for approximately US microseconds. Interrupts need not + be turned on. + + Busy waiting wastes CPU cycles, and busy waiting with + interrupts off for the interval between timer ticks or longer + will cause timer ticks to be lost. Thus, use timer_usleep() + instead if interrupts are enabled. */ +void +timer_udelay (int64_t us) +{ + real_time_delay (us, 1000 * 1000); +} + +/* Sleeps execution for approximately NS nanoseconds. Interrupts + need not be turned on. + + Busy waiting wastes CPU cycles, and busy waiting with + interrupts off for the interval between timer ticks or longer + will cause timer ticks to be lost. Thus, use timer_nsleep() + instead if interrupts are enabled.*/ +void +timer_ndelay (int64_t ns) +{ + real_time_delay (ns, 1000 * 1000 * 1000); +} + /* Prints timer statistics. */ void timer_print_stats (void) { - printf ("Timer: %"PRId64" ticks\n", ticks); + printf ("Timer: %"PRId64" ticks\n", timer_ticks ()); } /* Timer interrupt handler. */ @@ -135,8 +181,6 @@ timer_interrupt (struct intr_frame *args UNUSED) { ticks++; thread_tick (); - if (ticks % TIME_SLICE == 0) - intr_yield_on_return (); } /* Returns true if LOOPS iterations waits for more than one timer @@ -144,18 +188,17 @@ timer_interrupt (struct intr_frame *args UNUSED) static bool too_many_loops (unsigned loops) { - int64_t start; - /* Wait for a timer tick. */ - start = ticks; + int64_t start = ticks; while (ticks == start) - continue; + barrier (); /* Run LOOPS loops. */ start = ticks; busy_wait (loops); /* If the tick count changed, we iterated too long. */ + barrier (); return start != ticks; } @@ -170,7 +213,7 @@ static void NO_INLINE busy_wait (int64_t loops) { while (loops-- > 0) - continue; + barrier (); } /* Sleep for approximately NUM/DENOM seconds. */ @@ -196,10 +239,17 @@ real_time_sleep (int64_t num, int32_t denom) else { /* Otherwise, use a busy-wait loop for more accurate - sub-tick timing. We scale the numerator and denominator - down by 1000 to avoid the possibility of overflow. */ - ASSERT (denom % 1000 == 0); - busy_wait (loops_per_tick * num / 1000 * TIMER_FREQ / (denom / 1000)); + sub-tick timing. */ + real_time_delay (num, denom); } } +/* Busy-wait for approximately NUM/DENOM seconds. */ +static void +real_time_delay (int64_t num, int32_t denom) +{ + /* Scale the numerator and denominator down by 1000 to avoid + the possibility of overflow. */ + ASSERT (denom % 1000 == 0); + busy_wait (loops_per_tick * num / 1000 * TIMER_FREQ / (denom / 1000)); +}