Main Goal

$$ timer$\_$alarm$($int ticks$)$

$$ System call that wakes up a process in ticks amount

of time

$$ PintOS uses busy waiting for the alarm

$$ Modify PintOS to use sleep$/$wakeup for alarm

$$ Files to modify $$ Threads$/$thread $$ Devices$/$timer

$$ Sometimes, a thread may want to wait for some time to pass, a$.$k$.$a$.$ sleep

$$ Problem: Pintos$$ implementation of sleep is very wasteful

$$ Devices$/$timer$.$c

void timer$\_$sleep $($int$64\_$t ticks$)$

$\{$

int$64\_$t start $=$ timer$\_$ticks $()$;

while $($timer$\_$elapsed $($start$)<$ ticks$)$

thread$\_$yield $()$;

$\}$

$$ Modifying timer$\_$sleep$()$

void timer$\_$sleep $($int$64\_$t ticks$)$

$\{$

$//$int$64\_$t start $=$ timer$\_$ticks $()$;

$//$ while $($timer$\_$elapsed $($start$)<$ ticks$)//$

thread$\_$yield $()$;

thread$\_$sleep$($ticks$)$; $//$ New function!

$\}$

$$ Modifying struct thread

$$ threads$/$thread$.$h

enum thread$\_$status

$\{$

THREAD$\_$RUNNING, $/*$ Running thread. $*/$

THREAD$\_$READY, $/*$ Not running but ready to run. $*/$

THREAD$\_$SLEEPING, $/*$ New state for sleeping threads $*/$

THREAD$\_$BLOCKED, $/*$ Waiting for an event to trigger. $*/$

THREAD$\_$DYING $/*$ About to be destroyed. $*/$

$\}$;

struct thread $\{...$

int$64\_$t wake$\_$time;

$$ thread$\_$sleep$()$

$$ threads$/$thread$.$c

static struct list sleeping$\_$list;

void thread$\_$sleep $($int$64\_$t ticks$)\{$

struct thread $*$cur $=$ thread$\_$current$()$;

enum intr$\_$level old$\_$level;

old$\_$level $=$ intr$\_$disable $()$;

if $($cur $!=$ idle$\_$thread$)\{$

list$\_$push$\_$back $($&sleeping$\_$list, &cur$->$elem$)$;

cur$->$status $=$ THREAD$\_$SLEEPING;

cur$->$wake$\_$time $=$ timer$\_$ticks$()+$ ticks;

schedule $()$;

$\}$

intr$\_$set$\_$level $($old$\_$level$)$;

$\}$

$$ Modifying schedule$()$

$$ Threads$/$thread$.$c

struct list$\_$elem $*$temp$,*$e $=$ list$\_$begin $($&sleeping$\_$list$)$;

int$64\_$t cur$\_$ticks $=$ timer$\_$ticks$()$;

while $($e $!=$ list$\_$end $($&sleeping$\_$list$))\{$

struct thread $*$t $=$ list$\_$entry $($e$,$ struct thread, allelem$)$;

if $($cur$\_$ticks $>=$ t$->$wake$\_$time$)\{$

list$\_$push$\_$back $($&ready$\_$list, &t$->$elem$)$; $/*$ Wake this thread up$!*/$

t$->$status $=$ THREAD$\_$READY;

temp $=$ e;

e $=$ list$\_$next $($e$)$;

list$\_$remove$($temp$)$; $/*$ Remove this thread from sleeping$\_$list $*/$

$\}$

else e $=$ list$\_$next $($e$)$;

$\}$