Using IPC: semaphores Interprocess communication using semaphores. Lecturer: Erick Fredj

Transcription

1 Using IPC: semaphores Interprocess communication using semaphores Lecturer: Erick Fredj

2 What is a 'semaphore'? A classical approach for restricting access to shared resources in multi-process environments A protected variable (or abstract data type) which is readable/writeable for a set of processes Use: to mutual exclude the access to a shared resource for a set of processes, e.g. reading, writing in the same memory segment

3 How does it work? Definition: critical section A part of a program which includes access to a shared resource The value of the semaphore has to be checked before entering a critical section value > 0: resource can be used value = 0: resource is used by another process

4 Example of 'how to use semaphores' P(s) = operation "decrease semaphore by 1" V(s) = operation "increase semaphore by 1" (defined according to Dijkstra: P() --> pass and V() --> release) process 1 P(s) Critical section V(s) Process 1 and 2 call function P() Only 1 (!) process could enter the critical section the other is blocked at P() process 2 P(s) Critical section V(s)

5 Using multiple semaphores Synchronization using multiple semaphores Example: The access to a shared memory segment is protected by 2 semaphores (write and read) process 1 P(write) Critical section V(read) process 2 P(read) Critical section V(write) Be careful with init values of semaphores!! write = read = 1 Not read/write two consecutive times write = 1, read = 0 Strict order write = read = 0 DEADLOCK!!

6 Different types of semaphores Depends on the Unix system Unnamed semaphores (analog to pipes) Simple semaphores used to synchronize threads or father/son processes #include <semaphore.h> sem_t sem; int sem_init(sem_t *sem, int pshared, unsigned value); int sem_post(sem_t *sem); // V(sem) int sem_wait(sem_t *sem); // P(sem) int sem_destroy(sem_t *sem); Named semaphores (analog to named pipes, i.e. FIFO)

7 Different types of semaphores Can synchronize process that do not share memory (i.e. no relation father/son) Use similar path structure as fifos (pseudo file) with access right, etc. sem_t sem_open(const char*name, int oflag,...); int sem_post(sem_t *sem); // V(sem) int sem_wait(sem_t *sem); // P(sem) int sem_close(sem_t sem); Semaphore sets: More sophisticated allowing to perform operations on a complete set with a single call... Analog control structure and operations as other IPCs (shared memory, message queues...

8 Semaphores in Unix Unix system calls for semaphore operations: Get a semaphore set identifier: semget() Semaphore control operations: semctl() Semaphore operations (P() and V()): semop(), semtimedop()

9 System call: semget() semget() get a semaphore set identifier Syntax: int semget( key_t key, int nsems, int semflag ); Example: #include <sys/types.h> #include <sys/ipc.h> #include <sys/sem.h> if(( semid =semget( 5L, 1, IPC_CREAT 0666 )) < 0 ) { perror("semget failed"); exit(-1); }

10 System call: semctl() semctl() Syntax: performs semaphore control operations, on a semaphore set or the nth semaphore of that set, e.g. retrieve and set value of a semaphore, read status, remove semaphore int semctl( int semid, int semnum, int cmd, union semun arg ); union semun { int val; /* value of SETVAL */ struct semid_ds *buf;/* buffer for IPC_STAT,IPC_SET */ ushort *array; /* array for GETALL, SETALL */ };

11 Example: #include <sys/types.h> System call: semctl() #include <sys/ipc.h> #include <sys/sem.h> /* initialize */ union semun arg; arg.val = 1; if( semctl( semid, 0, SETVAL, arg ) < 0 ) { perror("semctl SETVAL failed"); exit(-1); } /* remove semaphore 0 */ if( semctl( semid, 0, IPC_RMID, arg ) < 0 ) { perror("semctl IPC_RMID failed"); exit(-1); }

12 System call: semop() semop() performs semaphore operations (e.g. set/reset) Syntax: int semop( int semid, struct sembuf *sops, unsigned nsops ); struct sembuf { short sem_num; /* no of semaphore in this set */ int sem_op; /* operation */ ushort sem_flg; /* flags (IPC_NOWAIT, SEM_UNDO) */ };

13 System call: semop() #2 Perform P() and V()- operations: set array sops accordingly P()-operation: sem_op = -1 V()-operation: sem_op = +1 specify the number of the refered semaphore in sem_num sem_flg in sops: tells the OS if the function waits (sem_flg = 0) to reset the semaphore or should be canceled (return value = -1)...if the semaphore is 0 (sem_flg = IPC_NOWAIT)

14 System call: semop() #3 Example: #include <sys/types.h> #include <sys/ipc.h> #include <sys/sem.h> /* reset a semaphore: V-operation */ struct sembuf ops[1]; ops[0].sem_num = 0; ops[0].sem_flg = 0; ops[0].sem_op = +1; if( semop( semid, ops, 1 ) < 0 ) { perror("semop V() failed); exit(-1); }