OPERATING SYSTEMS 3rd Homework

Transcription

1 OPERATING SYSTEMS 3rd Homework Due on: Final Exam Day Submission: Send your homework through the In this homework, you will Learn to create threads Learn how to manage resources using semaphores Preparation see POSIX Thread Library see System V IPC Semaphores Download Task This homework studies the use of an IPC semaphore in coordinating tasks which require simultaneous multiple resource allocations, each requesting more than one of the resource. Allocate a semaphore to represent the resources of a moving company with five trucks, 15 human movers, and an insurance policy of $1 Million to be spread across all concurrent jobs. Jobs are done on a first come, first served basis. A job will go only if there are an adequate number of movers, trucks and insurance to cover the job, after all other jobs are accounted for. If the job is a go, decrement the resource count, so that all resources in use will be accounted for when the next job is requested. There are Define some jobs defined in the source code. The table specifies how many of each resource is requested per each job. The values in this table will cause contention: for example, the first job uses 4 trucks out of 5 available, making some of the others wait for a truck struct job { int numtrucks; int nummovers; int amtinsurance; jobtable[] = { { 4, 5, 250, / Use many trucks { 1, 2, 500, / Normal amts. { 3, 5, 1000, / Lots of insur { 2, 8, 250, / Many movers. ; Complete the skeleton code such that every job has been done. Code only in allowed lines.

2 / Homework 3 / This homework studies the use of an IPC semaphore in coordinating tasks which require simultaneous multiple resource allocations, each requesting more than one of the resource. Allocate a semaphore to represent the resources of a moving company with five trucks, 15 human movers, and an insurance policy of $1 Million to be spread across all concurrent jobs. Jobs are done on a first come, first served basis. A job will go only if there are an adequate number of movers, trucks and insurance to cover the job, after all other jobs are accounted for. If the job is a go, decrement the resource count, so that all resources in use will be accounted for when the next job is requested. #include <sys/types.h> / For general. #include <sys/ipc.h> / System 5 IPC defs. #include <sys/sem.h> / System 5 IPC semaphore defs. #include <pthread.h> / Posix threads. #include <stdlib.h> / Needed for delay to work properly. #include <errno.h> #include "utils.h" / for fractsleep() and printwithtime(). #define NUM_THREADS 10 / Number of simultaneous requests. #define TIME_BTWN_NEW_THREADS 0.5 / Time between intro of new request. #define RUNTIME_RANGE 5.0 / Time of longest job. / These define a single semaphore group consisting of three semaphores. All the semaphores in a group can be modified together in a single atomic operation. The first semaphore represents the number of trucks available; the second: the number of movers available; the third: the amount of insurance in $1000 units available. #define NUM_SEMS_IN_GROUP 3 #define TRUCK_SEM 0 #define MOVER_SEM 1 #define INSUR_SEM 2 // These will be used to initialize semaphores with total resources managed. #define NUM_TRUCKS 5 #define NUM_MOVERS 12 #define AMT_INSUR 1000

3 // Flags passed thru sembuf structure; wait for resource. #define WAIT 0 #define STRING_SIZE 80 #define FALSE 0 #define TRUE (!FALSE) #define STDOUT_FD 1 / Define some jobs here. This table specifies how many of each resource is requested per each job. The values in this table will cause contention: for example, the first job uses 4 trucks out of 5 available, making some of the others wait for a truck. struct job { int numtrucks; int nummovers; int amtinsurance; jobtable[] = { { 4, 5, 250, / Use many trucks { 1, 2, 500, / Normal amts. { 3, 5, 1000, / Lots of insur { 2, 8, 250, / Many movers. ; // Number of jobs in the table. int numjobs = sizeof(jobtable) / sizeof (struct job); int semid; / IPC semaphore identifier (semaphore accessed through this). extern int errno; void threadmain(void ); int main() { pthread_t threads[num_threads]; / Array of threads, one per request. int numtrucks = NUM_TRUCKS; / Needed to convert constant for semctl call. int nummovers = NUM_MOVERS; int amtinsur= AMT_INSUR; int count; // Allocate a single semaphore group with three semaphores in it. if ((semid = semget(ipc_private, NUM_SEMS_IN_GROUP, IPC_CREAT 0600)) == - 1){ perror ("semget"); exit (errno); // Initialize each semaphore in the group. Could also have used SETALL.

4 if (? ) { perror ("Error initializing semaphores"); goto cleanup; // Initialize random number generator used for time delays. srand48(time(null)); / Spawn the threads. The argument passed to threadmain is a job table index, so multiple requests can be made using the same table entry when the index wraps. Delay to model jobs being staggered instead of coming all at once. for (count = 0; count < NUM_THREADS; count++) { if (pthread_create(? ) { perror ("Error starting reader threads"); goto cleanup; fractsleep(time_btwn_new_threads); / Wait for threads to finish. for (count = 0; count < NUM_THREADS; count++) { pthread_join(?, (void )NULL); cleanup: / Delete the semaphore. This is not done automatically by the system. if (semctl(semid, 0, IPC_RMID, NULL)) { perror ("semctl IPC_RMID:"); void threadmain(void arg) { / Here is where a thread starts executing. A thread in executing this function represents a task for the moving company, and requests the resources it needs. int jobnum = (int)arg; / The argument passed in is a table index. char string[string_size]; / Local string for message composition. sprintf (string, "Job # %d requesting %d trucks, %d people, $%d000 insurance...\n", jobnum, jobtable[jobnum].numtrucks, jobtable[jobnum].nummovers, jobtable[jobnum].amtinsurance); printwithtime(string);

5 / Get the resources needed. Wait for them if necessary. if (reserve(semid, jobtable[jobnum])) { perror ("reserve"); return (NULL); sprintf (string, "Job # %d got %d trucks, %d people, %d000 insurance and is running...\n", jobnum, jobtable[jobnum].numtrucks, jobtable[jobnum].nummovers, jobtable[jobnum].amtinsurance); printwithtime(string); / Delay to simulate the time the resources are in use. fractsleep(drand48() RUNTIME_RANGE); sprintf (string, "Job # %d done; returning %d trucks, %d people, %d000 insurance...\n", jobnum, jobtable[jobnum].numtrucks, jobtable[jobnum].nummovers, jobtable[jobnum].amtinsurance); printwithtime(string); / Release resources. if (release(semid, jobtable[jobnum])) { perror ("release"); int reserve(int semid, struct job thisjob) { / Reserve resources required for a job. This wrapper function passes negative values into playwithsemaphores(), since negative values represent resource allocations. return (? ); int release(int semid, struct job thisjob) { / Release resources of a job completed. This wrapper function passes positive values into playwithsemaphores(), since positive values represent resource deallocations.

6 return (? ); static int playwithsemaphores(int semid, int numtrucks, int nummovers, int amtinsurance) { / There will be one operation per semaphore for this example. This allocates an array of semaphore operations, all of which will be carried out with a single atomic operation (system call to semop()). struct sembuf ops[num_sems_in_group]; / One operation per semaphore. Note that a negative value to ops[x].sem_op allocates a resource, while a positive value releases it. ops[0].sem_num =? ; ops[0].sem_op =? ; ops[1].sem_num =? ; ops[1].sem_op =? ; ops[2].sem_num =? ; ops[2].sem_op =? ; / All semaphore operations are to be handled in the same way. ops[0].sem_flg = ops[1].sem_flg = ops[2].sem_flg = WAIT; / "The call" that does the work. return (semop(semid, ops, NUM_SEMS_IN_GROUP));