X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?p=pintos-anon;a=blobdiff_plain;f=src%2Fdevices%2Ftimer.c;h=c97667f56bfcd5d9bd70862c7ff3ca2047f8f706;hp=3724abf944ab4fbf7d53936cdbe822a2a7b9a5a5;hb=f1f2dc8de9e336d83383692d4478bb14a3dafc11;hpb=a40483c415f3b61066ddcc4890c0aedfca723f26 diff --git a/src/devices/timer.c b/src/devices/timer.c index 3724abf..c97667f 100644 --- a/src/devices/timer.c +++ b/src/devices/timer.c @@ -3,8 +3,9 @@ #include #include #include +#include "devices/pit.h" #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,12 +17,8 @@ #error TIMER_FREQ <= 1000 recommended #endif -/* Number of timer ticks that a process gets before being - preempted. */ -#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(). */ @@ -31,22 +28,15 @@ 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 - corresponding interrupt. */ +/* Sets up the timer to interrupt TIMER_FREQ times per second, + and registers the corresponding interrupt. */ void timer_init (void) { - /* 8254 input frequency divided by TIMER_FREQ, rounded to - nearest. */ - uint16_t count = (1193180 + TIMER_FREQ / 2) / TIMER_FREQ; - - outb (0x43, 0x34); /* CW: counter 0, LSB then MSB, mode 2, binary. */ - outb (0x40, count & 0xff); - outb (0x40, count >> 8); - - intr_register (0x20, 0, INTR_OFF, timer_interrupt, "8254 Timer"); + pit_configure_channel (0, 2, TIMER_FREQ); + intr_register_ext (0x20, timer_interrupt, "8254 Timer"); } /* Calibrates loops_per_tick, used to implement brief delays. */ @@ -61,8 +51,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; @@ -80,6 +73,7 @@ timer_ticks (void) enum intr_level old_level = intr_disable (); int64_t t = ticks; intr_set_level (old_level); + barrier (); return t; } @@ -91,7 +85,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) { @@ -102,32 +97,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. */ @@ -136,8 +173,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 @@ -145,18 +180,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; } @@ -171,7 +205,7 @@ static void NO_INLINE busy_wait (int64_t loops) { while (loops-- > 0) - continue; + barrier (); } /* Sleep for approximately NUM/DENOM seconds. */ @@ -197,10 +231,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)); +}