pintos-doxygen/html/mlfqs-block_8c_source.html

/** Checks that recent_cpu and priorities are updated for blocked

   threads.


   The main thread sleeps for 25 seconds, spins for 5 seconds,

   then releases a lock.  The "block" thread spins for 20 seconds

   then attempts to acquire the lock, which will block for 10

   seconds (until the main thread releases it).  If recent_cpu

   decays properly while the "block" thread sleeps, then the

   block thread should be immediately scheduled when the main

   thread releases the lock. */


#include <stdio.h>

#include "tests/threads/tests.h"

#include "threads/init.h"

#include "threads/malloc.h"

#include "threads/synch.h"

#include "threads/thread.h"

#include "devices/timer.h"


static void block_thread (void *lock_);


void

test_mlfqs_block (void)

{

  int64_t start_time;

  struct lock lock;


  ASSERT (thread_mlfqs);


  msg ("Main thread acquiring lock.");

  lock_init (&lock);

  lock_acquire (&lock);


  msg ("Main thread creating block thread, sleeping 25 seconds...");

  thread_create ("block", PRI_DEFAULT, block_thread, &lock);

  timer_sleep (25 * TIMER_FREQ);


  msg ("Main thread spinning for 5 seconds...");

  start_time = timer_ticks ();

  while (timer_elapsed (start_time) < 5 * TIMER_FREQ)

    continue;


  msg ("Main thread releasing lock.");

  lock_release (&lock);


  msg ("Block thread should have already acquired lock.");

}


static void

block_thread (void *lock_)

{

  struct lock *lock = lock_;

  int64_t start_time;


  msg ("Block thread spinning for 20 seconds...");

  start_time = timer_ticks ();

  while (timer_elapsed (start_time) < 20 * TIMER_FREQ)

    continue;


  msg ("Block thread acquiring lock...");

  lock_acquire (lock);


  msg ("...got it.");

}

ASSERT
#define ASSERT(CONDITION)
This is outside the header guard so that debug.h may be included multiple times with different settin...
Definition: debug.h:31

init.h

msg
void msg(const char *format,...)
Definition: lib.c:28

malloc.h

test_mlfqs_block
void test_mlfqs_block(void)
Definition: mlfqs-block.c:23

block_thread
static void block_thread(void *lock_)
Checks that recent_cpu and priorities are updated for blocked threads.
Definition: mlfqs-block.c:50

start_time
static int64_t start_time
Starts 60 threads that each sleep for 10 seconds, then spin in a tight loop for 60 seconds,...
Definition: mlfqs-load-60.c:108

int64_t
signed long long int int64_t
Definition: stdint.h:16

lock
Lock.
Definition: synch.h:22

lock_release
void lock_release(struct lock *lock)
Releases LOCK, which must be owned by the current thread.
Definition: synch.c:229

lock_init
void lock_init(struct lock *lock)
Initializes LOCK.
Definition: synch.c:176

lock_acquire
void lock_acquire(struct lock *lock)
Acquires LOCK, sleeping until it becomes available if necessary.
Definition: synch.c:193

synch.h

tests.h

thread_mlfqs
bool thread_mlfqs
If false (default), use round-robin scheduler.
Definition: thread.c:60

thread_create
tid_t thread_create(const char *name, int priority, thread_func *function, void *aux)
Creates a new kernel thread named NAME with the given initial PRIORITY, which executes FUNCTION passi...
Definition: thread.c:166

thread.h

PRI_DEFAULT
#define PRI_DEFAULT
Default priority.
Definition: thread.h:24

timer_ticks
int64_t timer_ticks(void)
Returns the number of timer ticks since the OS booted.
Definition: timer.c:71

timer_elapsed
int64_t timer_elapsed(int64_t then)
Returns the number of timer ticks elapsed since THEN, which should be a value once returned by timer_...
Definition: timer.c:82

timer_sleep
void timer_sleep(int64_t ticks)
Sleeps for approximately TICKS timer ticks.
Definition: timer.c:90

timer.h

TIMER_FREQ
#define TIMER_FREQ
Number of timer interrupts per second.
Definition: timer.h:8