timer.c File Reference

#include "devices/timer.h"
#include <debug.h>
#include <inttypes.h>
#include <round.h>
#include <stdio.h>
#include "threads/interrupt.h"
#include "threads/io.h"
#include "threads/synch.h"
#include "threads/thread.h"

Include dependency graph for timer.c:

Functions
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)
void	timer_init (void)
void	timer_calibrate (void)
int64_t	timer_ticks (void)
int64_t	timer_elapsed (int64_t then)
void	timer_sleep (int64_t ticks)
void	timer_msleep (int64_t ms)
void	timer_usleep (int64_t us)
void	timer_nsleep (int64_t ns)
void	timer_print_stats (void)
static void	timer_interrupt (struct intr_frame *args UNUSED)

Variables
static int64_t	ticks
static unsigned	loops_per_tick
static intr_handler_func	timer_interrupt

Function Documentation

busy_wait()

static void NO_INLINE busy_wait ( int64_t  loops )

static

                          {
    while (loops-- > 0)
        barrier ();
}

Here is the caller graph for this function:

real_time_sleep()

static void real_time_sleep ( int64_t  num, int32_t  denom  )

static

                                             {
    /* Convert NUM/DENOM seconds into timer ticks, rounding down.
 
       (NUM / DENOM) s
       ---------------------- = NUM * TIMER_FREQ / DENOM ticks.
       1 s / TIMER_FREQ ticks
       */
    int64_t ticks = num * TIMER_FREQ / denom;
 
    ASSERT (intr_get_level () == INTR_ON);
    if (ticks > 0) {
        /* We're waiting for at least one full timer tick.  Use
           timer_sleep() because it will yield the CPU to other
           processes. */
        timer_sleep (ticks);
    } 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));
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

timer_calibrate()

void timer_calibrate

(

void

)

                       {
    unsigned high_bit, test_bit;
 
    ASSERT (intr_get_level () == INTR_ON);
    printf ("Calibrating timer...  ");
 
    /* 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;
        ASSERT (loops_per_tick != 0);
    }
 
    /* Refine the next 8 bits of loops_per_tick. */
    high_bit = loops_per_tick;
    for (test_bit = high_bit >> 1; test_bit != high_bit >> 10; test_bit >>= 1)
        if (!too_many_loops (high_bit | test_bit))
            loops_per_tick |= test_bit;
 
    printf ("%'"PRIu64" loops/s.\n", (uint64_t) loops_per_tick * TIMER_FREQ);
}

Here is the call graph for this function:

Here is the caller graph for this function:

timer_elapsed()

int64_t timer_elapsed

(

int64_t

then

)

                             {
    return timer_ticks () - then;
}

Here is the call graph for this function:

Here is the caller graph for this function:

timer_init()

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_ext (0x20, timer_interrupt, "8254 Timer");
}

Here is the call graph for this function:

Here is the caller graph for this function:

timer_interrupt()

static void timer_interrupt ( struct intr_frame *args  UNUSED )

static

                                                 {
    ticks++;
    thread_tick (); // update the cpu usage for running process
 
    if (get_global_ticks() <= ticks){ // 현재 시각이 글로벌 틱보다 크면 스레드 깨우기
        thread_awake(ticks);
    }
}

Here is the call graph for this function:

timer_msleep()

void timer_msleep

(

int64_t

ms

)

                          {
    real_time_sleep (ms, 1000);
}

Here is the call graph for this function:

Here is the caller graph for this function:

timer_nsleep()

void timer_nsleep

(

int64_t

ns

)

                          {
    real_time_sleep (ns, 1000 * 1000 * 1000);
}

Here is the call graph for this function:

Here is the caller graph for this function:

timer_print_stats()

void timer_print_stats

(

void

)

                         {
    printf ("Timer: %"PRId64" ticks\n", timer_ticks ());
}

Here is the call graph for this function:

Here is the caller graph for this function:

timer_sleep()

void timer_sleep

(

int64_t

ticks

)

                            { // ticks 시간 만큼 뒤에 꺠어난다.(상대 시간 (eg. 5분))
    int64_t start = timer_ticks (); // 현재 시간(프로그램 부트 이후 시간 (eg. 12시))
 
    ASSERT (intr_get_level () == INTR_ON);
    /* 기존 코드 : busy waiting 방식
        while (timer_elapsed (start) < ticks)
            thread_yield (); 
    */
    if (timer_elapsed (start) < ticks) // 현재 시간부터의 경과 시간이 ticks 보다 작으면(깨울 때가 아님)
        thread_sleep(start + ticks); // 해당 스레드를 sleep(BLOCKED)시킨다.
        // ↳ 해당 스레드가 깨어나야할 절대 시간인 (start + ticks)를 인자로 넘긴다.
}

Here is the call graph for this function:

Here is the caller graph for this function:

timer_ticks()

int64_t timer_ticks

(

void

)

                   {
    enum intr_level old_level = intr_disable ();
    int64_t t = ticks;
    intr_set_level (old_level);
    barrier ();
    return t;
}

Here is the call graph for this function:

Here is the caller graph for this function:

timer_usleep()

void timer_usleep

(

int64_t

us

)

                          {
    real_time_sleep (us, 1000 * 1000);
}

Here is the call graph for this function:

Here is the caller graph for this function:

too_many_loops()

static bool too_many_loops ( unsigned  loops )

static

                                {
    /* Wait for a timer tick. */
    int64_t start = ticks;
    while (ticks == start)
        barrier ();
 
    /* Run LOOPS loops. */
    start = ticks;
    busy_wait (loops);
 
    /* If the tick count changed, we iterated too long. */
    barrier ();
    return start != ticks;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

loops_per_tick

unsigned loops_per_tick

static

ticks

int64_t ticks

static

timer_interrupt

intr_handler_func timer_interrupt

static