Assignment #2. Problem 2.1: airplane synchronization

Transcription

1 Computer Architecture and Operating Systems Course: Jacobs University Bremen Date: Dr. Jürgen Schönwälder, Alen Stojanov Deadline: Assignment #2 Problem 2.1: airplane synchronization (4 points) Imagine an airport having m with m > 2 runways and three gates. Every runway is connected to each gate using separate taxiways. Before landing an airplane, the pilot must request permission for landing. If the runway is clear (no airplane is on the runway), then the permission is granted. In order to reduce the transition of people inside the airport, it was decided that an airplane should wait on the runway for two more airplanes to arrive and afterwards the three airplanes are allowed to proceed to the gates. Write a C program airplanes that accepts the number of airplanes n and the number of runways m as command line arguments. Use POSIX threads to represent the airplanes and POSIX semaphores to handle the critical sections. When the airplane is approaching the airport, the function plane land() should be invoked, and the function plane queue() is invoked after touching down when the airplane proceeds to one of the three gates. Explain the logic behind your code up to a level that we can understand your thinking. Note that your explanation is crucial and will receive a substantial of the marks. Code without proper explanation will not give you points. Make sure your solution is free of deadlocks. Your program must handle error situations (including wrong input) in a meaningful way. Make sure your program compiles cleanly with gcc -O2 -Wall. One possible execution of airplanes might look as follows: $ airplanes 6 5 [PL]: Airplane 1 requests permission to land [PL]: Airplane 2 requests permission to land [LG]: ===> Airplane 2 has landed [PL]: Airplane 5 requests permission to land [LG]: ===> Airplane 5 has landed [LG]: ===> Airplane 1 has landed [PL]: Airplane 4 requests permission to land [LG]: ===> Airplane 4 has landed [PL]: Airplane 6 requests permission to land [LG]: ===> Airplane 6 has landed [PL]: Airplane 3 requests permission to land [PG]: Airplane 1 requests permission to proceed to the gates [PG]: Airplane 4 requests permission to proceed to the gates [PG]: Airplane 2 requests permission to proceed to the gates [GG]: ===> Airplane 2 did proceed to gate: 3 [GG]: ===> Airplane 4 did proceed to gate: 2 [GG]: ===> Airplane 1 did proceed to gate: 1 [LG]: ===> Airplane 3 has landed [PG]: Airplane 5 requests permission to proceed to the gates [PG]: Airplane 6 requests permission to proceed to the gates [PG]: Airplane 3 requests permission to proceed to the gates [GG]: ===> Airplane 3 did proceed to gate: 3 [GG]: ===> Airplane 5 did proceed to gate: 1 [GG]: ===> Airplane 6 did proceed to gate: 2

2 Solution: *============================================================================ * Name : airplanes.c * Author : Alen Stojanov * Version : 1.0 * Copyright : GNU GPL License * Description : Example in Thread Synchronization *============================================================================ #include <stdio.h> #include <stdlib.h> #include <pthread.h> #include <semaphore.h> * Data structure to represent the different planes used * in the threads. typedef struct int id; The ID of the airplane pthread_t tid; The thread ID of the airplane planes_t; sem_t runway_sem; The semaphore used for the runways sem_t queue_sem; The semaphore used for the gate queue sem_t queue_mutex; Auxiliary semaphore, to ensure that 3 planes proceed to the gates * The plane must call plane_land to get permission for landing static void plane_land(int id) printf("[pl]: Airplane %d requests permission to land\n", id); sem_wait(&runway_sem); printf("[lg]: ===> Airplane %d has landed\n", id); * The plane must call plane_queue to proceed to the gates. Meanwhile * the plane waits on the runway. static void plane_queue(int id) int sval; printf("[pg]: Airplane %d requests permission to proceed to the gates\n", id); sem_wait(&queue_sem); sem_getvalue(&queue_sem, &sval); if (sval!= 0) sem_wait(&queue_mutex); else sem_post(&queue_mutex);

3 sem_post(&queue_mutex); sem_post(&runway_sem); printf("[gg]: ===> Airplane %d did proceed to gate: %d\n", id, 3 - sval); sem_post(&queue_sem); * The simple thread function. Every airplane will try to land. * After the plane has landed, it proceeds to the gates in queue. static void* plane_function(void* args) planes_t* plane = (planes_t*)args; plane_land(plane->id); plane_queue(plane->id); * Display usage information on the stderr stream. static void usage(char** argv) fprintf(stderr, "Usage: %s num_planes num_runways\n", argv[0]); * The main function and entry point. int main(int argc, char* argv[]) int n = 0, m = 0, i, status; planes_t* planes; if (argc!= 3) usage(argv); n = atoi(argv[1]); m = atoi(argv[2]); if (n <= 0 m < 3) usage(argv); if (sem_init(&runway_sem, 0, m) sem_init(&queue_sem, 0, 3) sem_init(&queue_mutex, 0, 0)) fprintf(stderr, "%s: initialization of semaphores failed\n", argv[0]);

4 planes = (planes_t *)calloc(n, sizeof(planes_t)); if (!planes) fprintf(stderr, "%s: out of memory\n", argv[0]); for (i = 0; i < n; i++) planes[i].id = i + 1; status = pthread_create(&planes[i].tid, NULL, plane_function, (void*)&planes[i]); if (status!= 0) fprintf(stderr, "%s: pthread_create() failed: %d\n", argv[0], status); for (i = 0; i < n; i++) pthread_join( planes[i].tid, NULL); (void) free(planes); if (sem_destroy(&runway_sem) sem_destroy(&queue_sem) sem_destroy(&queue_mutex)) fprintf(stderr, "%s: destruction of semaphores failed\n", argv[0]); return EXIT_SUCCESS;

5 Problem 2.2: cigarette smoker problem (2+2+2 = 6 points) Consider a system with three smoker processes and one agent process. Each smoker continuously rolls a cigarette and then smokes it. But to roll and smoke a cigarette, the smoker needs three ingredients: tobacco, paper, and matches. One of the smoker has paper, another has tobacco, and the third has matches. The agent has an infinite supply of all three materials. The agent places two of the ingredients on the table. The smoker who has the remaining ingredient then makes and smokes a cigarette, signaling the agent on completion. The agent then puts out another two of the three ingredients, and the cycle repeats. Let us assume that the solution is given with the following constants and structures: #define NONE 0 #define MATCHES_TOBACCO 1 #define PAPER_TOBACCO 2 #define MATCHES_PAPER 3 static char *const status[] = "NONE", "MATCHES_TOBACCO", "PAPER_TOBACCO", "MATCHES_PAPER" ; typedef struct int status; pthread_mutex_t mutex; pthread_cond_t cond_empty; pthread_cond_t cond_full; table_t; static table_t table; Bellow you can find three different solutions using POSIX pthread locks and condition variables. For each of them give a detailed explanation whether the synchronization code is correct or not and why. (Do not search for syntax errors or things like that; concentrate on the usage of the pthread synchronization functions.)

6 Version #1: static void* agent_thread(void* args) while (1) while (table.status!= NONE) pthread_cond_wait(&table.cond_empty, &table.mutex); table.status = (int)((double)rand() / RAND_MAX * 3) + 1; printf("[a]: Current status of the table: [%d]: %s\n", table.status, status[table.status]); pthread_cond_broadcast(&table.cond_full); static void* smoker_thread(void* args) int req = *((int*)args); while (1) while (table.status == NONE) pthread_cond_wait(&table.cond_full, &table.mutex); if (table.status == req) table.status = NONE; printf("[s]: The smoker requiring %s is now smoking\n", status[req]); pthread_cond_broadcast(&table.cond_empty);

7 Version #2: static void* agent_thread(void* args) while (1) if (table.status!= NONE) pthread_cond_wait(&table.cond_empty, NULL); table.status = (int)((double)rand() / RAND_MAX * 3) + 1; printf("[a]: Current status of the table: [%d]: %s\n", table.status, status[table.status]); pthread_cond_broadcast(&table.cond_full); static void* smoker_thread(void* args) int req = *((int*)args); while (1) if (table.status == NONE) pthread_cond_wait(&table.cond_full, NULL); if (table.status == req) table.status = NONE; printf("[s]: The smoker requiring %s is now smoking\n", status[req]); pthread_cond_broadcast(&table.cond_empty);

8 Version #3: static void* agent_thread(void* args) while (1) while (table.status!= NONE) pthread_cond_wait(&table.cond_empty, &table.mutex); table.status = (int)((double)rand() / RAND_MAX * 3) + 1; printf("[a]: Current status of the table: [%d]: %s\n", table.status, status[table.status]); pthread_cond_broadcast(&table.cond_full); static void* smoker_thread(void* args) int broadcast = 0; int req = *((int*)args); while (1) while (table.status == NONE) pthread_cond_wait(&table.cond_full, &table.mutex); if (table.status == req) table.status = NONE; printf("[s]: The smoker requiring %s is now smoking\n", status[req]); broadcast = 1; if (broadcast) pthread_cond_broadcast(&table.cond_empty); broadcast = 0;

9 Solution: a) The first solution is correct. The agent locks the table and then waits on the condition variable cond empty until the table is empty. It then picks ingredients, signals the smokers using the condition variable cond full that the table is full and then leaves the criticial section. A smoker locks the table and then waits on the condition variable cond full until something has been put on the table. If the goods on the table matches what he is waiting for, he takes the goods by clearing the table and signals the agent using the condition variable cond empty and then leaves the critical section. b) This solution has two problems. First, the loops in which threads wait for a condition have been replaced by conditional statements. This is incorrect since a signal wakes up all threads and usually only once can proceed. Second, the pthread cond wait() requires the locked mutex as a second argument since otherwise no other process can re-enter its critical section. c) This solution has one problem. The critical section is left before calling pthread cond wait(), which is incorrect. The pthread cond wait() function is called from holding a mutex lock and the function will temporarily release the lock and re-aquire it before it returns. The other change of this solution is that the signal is sent after leaving the critical section. This, however, is not problematic and does not cause any synchronization errors.