complete the stuents$\_$study$\_$in$\_$room$($long id$)$ function:void assess$\_$security$()//$ guard assess room security

$\{//$ details of this function are unimportant for the assignment

$//$ NOTE: we have $($own$)$ the mutex when we first enter this routine

guard$\_$state $=1$; $//$ positive means in the room

int ms $=$ rand$\_$range$($&seeds$[0],$ MIN$\_$SLEEP, MAX$\_$SLEEP$/2)$;

printf$("\backslash$tguard assessing room security for $\%3$d millisecs...

$",$ ms$)$;

millisleep$($ms$)$;

printf$("\backslash$tguard done assessing room security

$")$;

$\}$

void guard$\_$walk$\_$hallway$()//$ guard walks the hallway

$\{//$ details of this function are unimportant for the assignment

int ms $=$ rand$\_$range$($&seeds$[0],$ MIN$\_$SLEEP, MAX$\_$SLEEP$/2)$;

printf$("\backslash$tguard walking the hallway for $\%3$d millisecs...

$",$ ms$)$;

millisleep$($ms$)$;

$\}$

$//$ this function contains the main synchronization logic for the guard

void guard$\_$check$\_$room$()$

$\{$

$//$ TODO: complete this routine to execute the behavior of the guard,

$//$ with proper synchronization. You will need to determine how many

$//$ students are in the room to perform the appropriate action.

$//$ Depending on the number of students, you will either:

$//*$ properly wait to enter, if some students are there

$//*$ clear out the room, if capacity $($or more$)$ number of students

$//*$ assess the security of the room, if no students are there

$//($see function assess$\_$security$()$ above$)$

$//$ You will also need to properly maintain the global variable,

$//$ guard$\_$state. Once you have performed the appropriate action,

$//$ with proper synchronization, the guard will leave the room.

$//$ Remember, that whenever you access or change a global variable

$//($eg$.$ num$\_$students$),$ you need to insure you are doing so in a

$//$ mutually exclusive fashion, for example, by calling

$//$ semWait$($&mutex$).$

$\}$

$//$ this function contains the main synchronization logic for a student

void student$\_$study$\_$in$\_$room$($long id$)$

$\{$

$//$ TODO: complete this routine to execute the behavior of a student,

$//$ with proper synchronization. You will need to determine if the

$//$ guard is in the room. You will also need to synchronize with the

$//$ guard, to clear out the room, and, to allow a possible waiting

$//$ guard to enter. At the proper place, you will call the function

$//$ study$(),$ above. You will also need to properly maintain the

$//$ global variable, num$\_$students. When done, students leave the

$//$ room.

$\}$

$//$ guard thread function $---$ NO need to change this function $!$

void$*$ guard$($void$*$ arg$)$

$\{$

int i; $//$ loop control variable

srand$($seeds$[0])$; $//$ seed the guard thread random number generator

$//$ the guard repeatedly checks the room $($limited to num$\_$checks$)$ and

$//$ walks the hallway

for $($i $=0$; i $<$ num$\_$checks; i$++)\{$

guard$\_$check$\_$room$()$;

guard$\_$walk$\_$hallway$()$;

$\}$

return NULL; $//$ thread needs to return a void$*$

$\}$

$//$ student thread function $---$ NO need to change this function $!$

void$*$ student$($void$*$ arg$)$

$\{$

long id $=($long$)$ arg; $//$ determine thread id from arg

srand$($seeds$[$id$])$; $//$ seed this threads random number generator

$//$ repeatedly study and do something else

while $(1)\{$

student$\_$study$\_$in$\_$room$($id$)$;

do$\_$something$\_$else$($id$)$;

$\}$

return NULL; $//$ thread needs to return a void$*$

$\}$

int main$($int argc, char$**$ argv$)//$ the main function

$\{$

int n; $//$ number of student threads

pthread$\_$t cthread; $//$ guard thread

pthread$\_$t$*$ sthreads; $//$ student threads

long i; $//$ loop control variable

if $($argc $<4)\{$

fprintf$($stderr$,$ "USAGE: $\%$s num$\_$threads capacity num$\_$checks

$",$ argv$[0])$;

return $0$;

$\}$

$//$ TODO: get three input parameters, convert, and properly store

$//$using the atoi function to convert ASCII$($string in this case$)$ to integer in order to parse command line

int num$\_$threads $=$atoi$($argv$[1])$;

int capacity $=$ atoi$($argv$[2])$;

int num$\_$checks $=$ atoi$($argv$[3])$;

fprintf$("$inputs are $\%$d$,\%$d$,\%$d

$",$ num$\_$threads,capacity,num$\_$checks$)$;

$//$ TODO: allocate space for the seeds$[]$ array

$//$ NOTE: seeds$[0]$ is guard seed, seeds$[$k$]$ is the seed for student k

$//$ TODO: allocate space for the student threads array, sthreads

$//$ Initialize global variables and semaphores

guard$\_$state $=0$; $//$ not in room $($walking the hall$)$

num$\_$students $=0$; $//$ number of students in the room

semInitB$($&mutex, $1)$; $//$ initialize mutex

$//$ TODO: complete the semaphore initializations, for all your semaphores

$//$ initialize guard seed and create the guard thread

seeds$[0]=$ START$\_$SEED;

pthread$\_$create$($&cthread, NULL, guard, $($void$*)$ NULL$)$;

for $($i $=1$; i $<=$ n; i$++)\{$

$//$ TODO: create the student threads and initialize seeds$[$k$],$ for

$//$ each student k

$\}$

pthread$\_$join$($cthread$,$ NULL$)$; $//$ wait for guard thread to complete

for $($i $=0$; i $<$ n; i$++)\{$

$//$ TODO: cancel each of the student threads $($do man on pthread$\_$cancel$())$

$\}$

$//$ TODO: free up any dynamic memory you allocated

return $0$;

$\}$