2 UNIX interprocess communications

Transcription

1 Parallel Programming Slide UNIX interprocess communications exchange of information between cooperating processes synchronization of cooperating processes communication mechanisms shared memory pipes (named / unnamed pipes, fifo files) messages (message queues, message passing interface library) mailbox systems sockets remote procedure call etc. synchronization mechanisms file locks (read-lock, write-lock) semaphores monitors etc.

2 Parallel Programming Slide Process creation and termination program: collection of statements and data generally stored on a hard disk marked as "executable" in the i-node the contents of the file fulfills the requirements of the operating system for executables (a.out format, elf format, etc.) executing a program 1. the kernel creates a process, i.e. it creates an environment which can be used to run the program 2. each process consists of three areas instruction segment user data segment system data segment 3. the program will be used to initialize the instruction and user data segment

3 Parallel Programming Slide when the initialization is finished there is no further connection between process and program 5. a process can request more resources (memory, files, etc.) several parallel processes can be initialized with the same program the operating system can save memory if such processes share the same instruction segment (the processes wouldn't discover the sharing because the instruction segment is read-only) among others the system data segment contains the following information current directory file descriptor table accumulated CPU time process and group ID of the parent process a process isn't allowed to manipulate its system data segment directly several system functions are needed for these tasks

4 Parallel Programming Slide 2-4 the operating system creates a process if this is requested by another process the requesting process is called parent process the new created process is called child process the child process inherits most of the environment of its parent process (e.g., open files, shared memory segments, etc.) each process identifies itself with a unique process ID (PID) each process (with the exception of the init process) has a parent (identified by a parent process ID, PPID) the init process is root of the process hierarchy (if a parent process terminates before its child processes terminate, init becomes parent of the orphan processes, i.e. the parent process ID of such processes is 1) each process belongs to a process group (identified by a process group ID, PGID) (e.g., someone can put all processes of a database management system into one group)

5 Parallel Programming Slide 2-5 each process group has a process group leader (a process is process group leader if its process ID and process group ID are identical) every process of a process group has a process group ID which is identical with the process ID of the process group leader some system calls have effects on all members of a process group (e.g., all processes of a process group can be killed in this way) each process can change its process group ID to become process group leader itself (e.g., you can create 20 processes in four different process groups) generally the output of a process appears on the screen which has been used to start the process group leader (i.e., the output of all members of a process group will interfere with each other) the device driver of the display sends all interrupt (<Ctrl-c>), quit (<Ctrl-\>), and hangup signals (<Ctrl-Break>) to all processes of a process group (possibly all processes will be terminated in this way if they haven't taken precautions (e.g., ignore hangups) and haven't changed their process group ID)

6 Parallel Programming Slide 2-6 creating a new process with fork ( ) the child process is mainly a copy of the parent process (look at the manual page if you want to know how the environment for the child process differs from that one of the parent) fork ( ) returns the process ID of the child process to the parent process fork ( ) returns 0 to the child process fork ( ) returns -1 to the parent process and no child process is created if an error has occurred (e.g., the limit on the total number of processes under execution by a single user would be exceeded) normally the child process overloads itself with another program using one of the exec ( ) functions the parent process waits until the child process terminates (wait () function) or performs other work fork ( ) is a very expensive system function because possibly large data segments must be copied

7 Parallel Programming Slide 2-7 waiting for the termination of a child process with wait ( ) wait ( ) returns the process ID of the terminated child process wait ( ) can store the exit-value of the child process if it is called with a pointer parameter if a child process terminates before its parent process has called wait ( ) it becomes a zombie process the instruction, user data, and system data segments are released the child process still occupies an entry in the process table the entry in the process table will be cleared if the parent process calls wait ( ) the zombie has left the system (rebooting a system always clears all zombies) terminating a process with exit ( ) terminate a process and return an exit-value to the parent process if the process has still active child processes the childs will not be terminated but they get a new parent process: the init process

8 Parallel Programming Slide 2-8 the following concurrent courses are possible 1) the parent process waits for its child process before the child process terminates (fork1.c, fork2.c) parent fork waitpid wait blocked child exit 2) the child process terminates before its parent process waits for its termination (fork3.c) parent fork waitpid wait child exit zombie 3) the parent process doesn't wait for its child process and terminates before the child process terminates (fork4.c) parent fork return in main exit child "init" becomes parent exit

9 Parallel Programming Slide 2-9 4) the parent process doesn't wait for its child process and terminates later than its child process (fork5.c) parent fork return in main exit child exit zombie the child process doesn't permanently remain a zombie process

10 Parallel Programming Slide 2-10 example to demonstrate the general structure of process creation and termination (fork1.c) #include <stdio.h> #include <stdlib.h> #include <sys/types.h> #include <sys/wait.h> #include <unistd.h> #include <errno.h> int eval_wait_stat (int stat); int main (void) pid_t parent_pid, child_pid, /* process ID's */ fork_pid, wait_pid, parent_grp, child_grp; /* process groups */ int child_stat; /* return status of child */ parent_pid = getpid (); parent_grp = getpgrp (); printf ("\nparent process: process ID: %ld group ID: %ld\n", (long) parent_pid, (long) parent_grp); fork_pid = fork (); switch (fork_pid) case -1: /* error: no process created */ perror ("fork failed"); exit (EXIT_FAILURE); break; case 0: /* child process */ child_pid = getpid (); child_grp = getpgrp (); printf ("Child process: process ID: %ld group ID: %ld " "parent process ID: %ld\n", (long) child_pid, (long) child_grp, (long) getppid ()); printf ("Child process: terminate with \"exit\"-value: %d\n", EXIT_SUCCESS); exit (EXIT_SUCCESS); break; default: /* parent process */ printf ("Parent process: child process with ID %ld created.\n", (long) fork_pid); wait_pid = wait (&child_stat); if (wait_pid == -1) perror ("wait"); exit (EXIT_FAILURE); else printf ("Parent process: child process %ld has terminated.\n", (long) wait_pid); eval_wait_stat (child_stat); return EXIT_SUCCESS;

11 Parallel Programming Slide 2-11 int eval_wait_stat (int stat) int return_val; if (WIFEXITED (stat)!= 0) printf ("\t\tchild has terminated with status %d.\n", WEXITSTATUS (stat)); return_val = 0; if (WIFSIGNALED (stat)!= 0) printf ("\t\tchild has been terminated using signal %d.\n", WTERMSIG (stat)); return_val = 0; if (WIFSTOPPED (stat)!= 0) printf ("\t\tchild has been stopped using signal %d.\n", WSTOPSIG (stat)); return_val = 1; #if defined(sunos) &&!defined(_posix_c_source) if (WIFCONTINUED (stat)!= 0) printf ("\t\tchild has continued.\n"); return_val = 1; #endif return return_val; Exercise 2-1) Implement a program which creates three concurrent processes. Each child process terminates itself after displaying its PID, GID, and PPID and sleeping a short time. The parent process should wait for its child processes. 2-2) Implement a program which creates a process which creates a process and so on. Create a hierarchy of three processes. Each process should display its PID, GID, and PPID. Each parent should wait for its child process. 2-3) Modify excercise 2-1 in a way that each child process creates its own process group. Show the differences in solution 2-1 and 2-3 if you type <Ctrl-c>.

12 Parallel Programming Slide 2-12 overloading a process with an exec ( ) function the child process overloads itself with a new program process 1 fork process1 process 2 exec process 2* 1) create a new process (mainly a copy of the parent process) 2) when the child process overloads itself with a new program it has its individual instruction and data segments exec ( ) functions differ in the following areas: searching for the program absolute pathname searching all directories specified in the environment variable PATH

13 Parallel Programming Slide 2-13 passing the environment for the new program inheritance (automatically) explicitly passing a new one (manually) passing the "command line" arguments explicit list appearing in the exec ( ) call as a vector (array like argv) system call passing passing the searching for arguments environment the program execl list automatically absolute path execv vector automatically absolute path execle list manually absolute path execve vector manually absolute path execlp list automatically PATH execvp vector automatically PATH l v e p explicit list of command line arguments vector of command line arguments (necessary if the number of arguments is unknown at compile time) explicitly passing a new environment searching for the program using environment variable PATH

14 Parallel Programming Slide 2-14 most often the functions execlp ( ) and execvp ( ) are used it's not necessary to fork a program before using an exec ( ) function (Many large programs execute in sequential steps (e.g., a compiler). If one step has finished the process can overload itself with the program for the next step. Generally the steps must be independent of each other or they have to use temporary files to communicate with each other because the user data segment will be re-initialized with the new program.) the first argument (arg0) of an explicit list or vector of command line arguments is always the program name the last argument of an explicit list or vector of command line arguments is always NULL

15 Parallel Programming Slide 2-15 example to demonstrate the use of an exec ( ) function (forkexec.c)... int main (void) pid_t fork_pid, wait_pid; /* process ID's */ int child_stat, /* return status of child */ ret_val; /* return value of a function */ fork_pid = fork (); switch (fork_pid) case -1: /* error: no process created */ perror ("fork failed"); exit (EXIT_FAILURE); break; case 0: /* child process */ ret_val = execl ("/bin/ls", "ls", "-al", NULL); if (ret_val == -1) perror ("execl failed"); exit (EXIT_FAILURE); break; default: /* parent process */ printf ("Parent process: child process with ID %ld created.\n", (long) fork_pid); wait_pid = wait (&child_stat); if (wait_pid == -1) perror ("wait"); exit (EXIT_FAILURE); else printf ("Parent process: child process %ld has terminated.\n", (long) wait_pid); eval_wait_stat (child_stat); return EXIT_SUCCESS;... Exercise 2-4: Implement a very small shell. The program should allow the input of a new program name and its arguments. When the input is finished, it will run the program with an exec ( ) function where the program will be searched using the environment variable PATH. Afterwards your program should "ask" for new input.

16 Parallel Programming Slide Shared Memory efficient data exchange between parallel processes (normally the fastest possibility to exchange data between processes) processes must take care of the data consistency (e.g., access synchronization via semaphores) implemented in main memory different interfaces are available memory-mapped files (mmap) System V IPC shared memory POSIX IPC shared memory overview of application programming interfaces System V IPC UNIX mmap POSIX IPC create memory area in operating system table attach memory to virtual address space detach memory from virtual address space remove memory area from operating system table shmget () open () lseek () write () shm_open () lseek () write () shmat () mmap () mmap () shmdt () munmap () munmap () shmctl () close () unlink () close () shm_unlink () (you can create a new file with a specified size if you change the position of the file pointer with lseek () to the position for the required file size and use write () to write an arbitrary character at the current position of the file pointer.)

17 Parallel Programming Slide 2-17 shared memory using memory-mapped files overview virtual memory of process 1 file view 1 file view 2 virtual memory of process 2 physical memory file mapping object file on disk file view 2 basic operations obtain a file descriptor by opening a regular disk file call mmap ( ) with the file descriptor and further parameters to map the file to virtual memory examine or modify the contents of the file via normal memory references you can map different parts of the file to different locations in the virtual memory if you use several mmap-calls

18 Parallel Programming Slide 2-18 direct file access vs. mmap pseudocode for direct file access fd = open (...); lseek (fd, offset, SEEK_SET); read (fd, buf, len); use/modify data in buf pseudocode for file access via mmap ( ) struct xyz... *buf; fd = open (...); buf = (struct xyz *) mmap (..., len,..., fd, offset); use/modify data in structure buf mmap is better integrated into the concepts of UNIX than System V IPC because it uses files uses the same naming schemes as files use (i.e. pathnames) because the shared objects are files uses normal system calls to create or delete the shared objects (open () / shm_open (), unlink () / shm_unlink ()) uses normal system calls to change ownership or permissions (chown (), chmod ()) shared objects are nonvolatile, i.e. they survive a power cut or reboot of the computer (provided that the memory has been flushed to disk) slower than System V IPC because it depends on disk accesses

19 Parallel Programming Slide 2-19 POSIX IPC similar to mmap ( ), i.e., based on files in the file system supports two functions: shm_open ( ) and shm_unlink ( ) (they only provide an API to support the POSIX IPC name abstraction, i.e., they are mainly replacements for open ( ) and unlink ( ) the real mapping must still be done with mmap ( ))

20 Parallel Programming Slide 2-20 shared memory using System V IPC completely implemented in main memory allows efficient data transfers between concurrent processes requires a key value to fetch the proper identifier of the desired IPC resource several processes can attach a common memory area in main memory to their own data segments at the same time basic operations 1) create / open a shared memory segment (shmget) 2) attach the shared memory to the data segment (shmat) 3) communicate via shared memory with other processes 4) detach the shared memory (shmdt) 5) close / remove the shared memory segment (shmctl) shared memory accesses can be controlled (shmctl) (permissions, locking / unlocking,...) new shared memory segments don't occupy main memory (they only occupy an entry in the shared memory table of the operating system) main memory will be occupied when the first process attaches the shared memory segment to its own data segment accesses to shared memory must be synchronized (generally with semaphores)

21 Parallel Programming Slide 2-21 controlling shared memory accesses with shmctl ( ) int shmctl (int shmid, int cmd, struct shmid_ds *buf) shmid cmd handle for the shared memory segment (return value from shmget ( )) command to execute IPC_SET set permissions IPC_RMID remove shared memory entry etc. have a look at the manual page buf pointer to a data structure if you want to read / set members of the data structure associated with shmid operating system dependent data structure struct shmid_ds struct ipc_perm shm_perm; /* operation permission struct */ int shm_segsz; /* size of segment in bytes */ struct anon_map *shm_amp; /* segment anon_map pointer */ ushort shm_lkcnt; /* # of times it is being locked */ pid_t shm_lpid; /* pid of last shmop */ pid_t shm_cpid; /* pid of creator */ ulong shm_nattch; /* used only for shminfo */ ulong shm_cnattch; /* used only for shminfo */ time_t shm_atime; /* last shmat time */ long shm_pad1; /* reserved for time_t expansion */ time_t shm_dtime; /* last shmdt time */ long shm_pad2; /* reserved for time_t expansion */ time_t shm_ctime; /* last change time */ long shm_pad3; /* reserved for time_t expansion */ long shm_pad4[4]; /* reserve area */ ; each shared memory segment must be explicitly removed from the shared memory table (IPC_RMID)

22 Parallel Programming Slide 2-22 get a shared memory identifier with shmget ( ) create / open a shared memory segment and return a handle int shmget (key_t key, int size, int shmflg) key user defined arbitrary unique positive numerical key or IPC_PRIVATE (if you use IPC_PRIVATE other programs don't know the key so that they can't use the shared memory segment; a user defined key can be defined as symbolic constant, command line option,...) size size of the shared memory segment shmflg access permissions and flags (a shared memory segment is without any value if you don't set proper access permissions; the default is that not even the owner has any access permissions) flags IPC_CREAT IPC_EXCL create a new shared memory segment if it doesn't already exist create a new shared memory segment exclusively, i.e. return an error if a shmid already exists for key

23 Parallel Programming Slide 2-23 shared memory operations attach a shared memory segment to the data segment of the calling process void *shmat (int shmid, void *shmaddr, int shmflg) shmid identifier for the shared memory segment shmaddr (void *) 0 if the system is allowed to choose an address (have a look at the manual page) shmflg generally access permissions (have a look at the manual page) detach a shared memory segment int shmdt (void *shmaddr) shmaddr address of the shared memory a shared memory segment is available until you remove it you can check with ipcs -m which segments are available if necessary you must remove all shared memory segments manually which you have created before you logout (use "ipcrm -m <shmid>" or "ipcrm shm <shmid>" (Linux))

24 Parallel Programming Slide 2-24 example: shared memory access without synchronization One process displays a character n times on a display. Another one can change the character which should be displayed and the number of repetitions. If a context switch occurs between reading the character and the repetition counter, the last character will be displayed with a new repetition. common header file for both programs (shm_definitions.h) /* Common data structures and macros. This example is based on a * program in "Brown, Ch.: UNIX - Distributed Programming. Prentice * Hall, 1994." * * * File: shm_definitions.h Author: S. Gross * Date: * */ struct shared_seg char c; /* character to print */ int frq; /* frequency of character */ ; #define SEGSIZE (sizeof (struct shared_seg)) #define SHM_KEY ((key_t) 0x5678) /* arbitrary value */ #define SHM_PERM (0600) /* access permissions */

25 Parallel Programming Slide 2-25 program to display the character (shm_output_2.c) /* The program reads every five seconds a "char" and "frequency" * from a shared memory segment and displays the "char" "frequency" * times on a line. The contents of the shared memory segment can * be modified with the program "shm_change_contents". * * The shared memory segment will be removed from the operating * system table when this program terminates. * * Please perform the following actions: * * 1) Start this program with "shm_output_2" in one window. * * 2) Change the contents of the shared memory segment in another * window with the commands: * * shm_change_contents d 60 * shm_change_contents m 20 * shm_change_contents t 70 * etc. * * The old character will be displayed with the new frequency * if you change the contents between "reading the character" * and "reading the frequency". You get an inconsistent data * item because the access to the shared memory area isn't * synchronized. You will always display a character with the * correct frequency if you protect the modification of the * shared memory with semaphores. * * 5) Stop "shm_output_2" with "shm_change_contents q 0". * * 6) Check with "ipcs -m" that the shared memory segment has * been removed from the operating system table. * * The source code depends on the X/Open version.... /* starting with Linux 2.2.x the macro "_SVID_SOURCE" must be defined * for "System V IPC" */ #ifdef Linux #define _SVID_SOURCE #endif #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/types.h> #include <sys/ipc.h> #include <sys/shm.h> #include <unistd.h> #include <errno.h> #include "shm_definitions.h" /* definition of shm segment */ #define SLEEP_TIME 2 /* 2 seconds */ #define ESHMGET 1 /* error calling "shmget()" */ #define ESHMAT 2 /* error calling "shmat()" */ #define ESHMDT 3 /* error calling "shmdt()" */ #define ESHMCTL 4 /* error calling "shmctl()" */

26 Parallel Programming Slide 2-26 int main (int argc, char *argv[]) struct shared_seg *shm_adr; /* address of shm segment */ struct shmid_ds shmbuf; /* for shmctl */ int shm_id, /* ID of shm segment */ shm_frq, /* temporary value */ i; /* loop variable */ char shm_c; /* temporary value */ shm_id = shmget (SHM_KEY, SEGSIZE, IPC_CREAT SHM_PERM); if (shm_id < 0) fprintf (stderr, "%s: shmget failed: %s\n", argv[0], strerror (errno)); exit (ESHMGET); /* let the system choose an appropriate address */ shm_adr = (struct shared_seg *) shmat (shm_id, NULL, SHM_PERM); if (shm_adr < (struct shared_seg *) 0) fprintf (stderr, "%s: shmat failed: %s\n", argv[0], strerror (errno)); exit (ESHMAT); /* initialize the shared memory segment */ shm_adr->c = 'x'; shm_adr->frq = 70; /* display a new line every "2 * SLEEP_TIME" seconds */ while ((shm_adr->c!= 'q') && (shm_adr->frq > 0)) shm_c = shm_adr->c; printf ("Got the character. I'll read the frequency in %d s\n", SLEEP_TIME); sleep (SLEEP_TIME); /* allow shm inconsistency */ shm_frq = shm_adr->frq; for (i = 0; i < shm_frq; ++i) putchar (shm_c); putchar ('\n'); sleep (SLEEP_TIME); /* release the shared memory segment */ #ifdef XPG3... #else if (shmdt (shm_adr) < 0) fprintf (stderr, "%s: shmdt failed: %s\n", argv[0], strerror (errno)); exit (ESHMDT); #endif if (shmctl (shm_id, IPC_RMID, &shmbuf) < 0) fprintf (stderr, "%s: shmctl failed: %s\n", argv[0], strerror (errno)); exit (ESHMCTL); return EXIT_SUCCESS;

27 Parallel Programming Slide 2-27 program to change the values (shm_change_contents.c)... int main (int argc, char *argv[]) struct shared_seg *shm_adr; /* address of shm segment */ int shm_id; /* ID of shm segment */ if (argc!= 3) fprintf (stderr, "\nthis program changes the \"char\" and " "\"frequency\" in a shared memory segment.\n" "The \"char\" will be displayed \"frequency\" times " "on a line.\n\n"); fprintf (stderr, "Usage: %s <char> <frequency>\n\n", argv[0]); exit (EXIT_FAILURE); shm_id = shmget (SHM_KEY, SEGSIZE, IPC_CREAT SHM_PERM); if (shm_id < 0) fprintf (stderr, "%s: shmget failed: %s\n", argv[0], strerror (errno)); exit (ESHMGET); /* let the system choose an appropriate address */ shm_adr = (struct shared_seg *) shmat (shm_id, NULL, SHM_PERM); if (shm_adr < (struct shared_seg *) 0) fprintf (stderr, "%s: shmat failed: %s\n", argv[0], strerror (errno)); exit (ESHMAT); /* change the contents of the shared memory segment */ shm_adr->c = argv[1][0]; shm_adr->frq = atoi (argv[2]); /* detach the shared memory segment */ #ifdef XPG3 if (shmdt ((char *) shm_adr) < 0) fprintf (stderr, "%s: shmdt failed: %s\n", argv[0], strerror (errno)); exit (ESHMDT); #else if (shmdt (shm_adr) < 0) fprintf (stderr, "%s: shmdt failed: %s\n", argv[0], strerror (errno)); exit (ESHMDT); #endif return EXIT_SUCCESS; every character will always be displayed with the correct repetition if all accesses to the shared memory are synchronized with semaphores

28 Parallel Programming Slide Semaphores different interfaces are available System V IPC semaphores completely implemented in main memory require a key value to fetch the proper identifier of the desired IPC resource POSIX IPC semaphores unnamed semaphores completely implemented in main memory correspond to Dijkstra's semaphores #define SEM_INITVAL 1... sem_t s /* semaphore */... sem_init (&s, TRUE, SEM_INITVAL);... sem_wait (&s); /* one-to-one correspondence to P(s) */... sem_post (&s); /* one-to-one correspondence to V(s) */... named semaphores: based on files in the file system

29 Parallel Programming Slide 2-29 overview of application programming interfaces POSIX named semaphores POSIX unnamed semaphores System V semaphores create semaphore sem_open () sem_init () semget () initialize at creation time at creation time semctl () P ( ) sem_wait () sem_timedwait () sem_trywait () sem_wait () sem_timedwait () sem_trywait () semop () V ( ) sem_post () sem_post () semop () read value sem_getvalue () sem_getvalue () semctl () remove semaphore sem_close () sem_unlink () sem_destroy () semctl ()

30 Parallel Programming Slide 2-30 System V semaphores are very powerful the semaphore value can be incremented / decremented with arbitrary values a decrement operation takes place if the semaphore value is at least as high as the subtrahend the process blocks until the subtraction can be performed it's allowed to perform operations on several semaphores within one function call the operation is indivisible, i.e., for decrement operations the semaphore values of all semaphores must be at least as high as the subtrahends the process blocks until all operations can take place at the same time it's allowed to perform some operations on semaphore values and additionally wait for other semaphore values to become zero the operation is indivisible, i.e., for decrement operations the semaphore values of all semaphores must be at least as high as the subtrahends the process blocks until all operations can be performed at the same time and the requested semaphore values are zero a process can request that it won't be blocked if the semaphore operation can't be performed immediately

31 Parallel Programming Slide 2-31 a process can request that the system keeps track of all semaphore operations and undoes all operations if the process exits representation of semaphores each semaphore is represented by the following data structure struct sem ushort semval; /* current value, nonnegative */ pid_t sempid; /* PID of last operation */ /* perhaps more operating system dependent variables */ ; semaphores are combined in semaphore sets (even for a single semaphore a semaphore set must be created / initialized) a semaphore set is represented by the following data structure (operating system dependent) struct semid_ds struct ipc_perm sem_perm; /* operation permission struct */ struct sem *sem_base; /* ptr to first semaphore in set */ ushort sem_nsems; /* # of semaphores in set */ time_t sem_otime; /* last semop time */ long sem_pad1; /* reserved for time_t expansion */ time_t sem_ctime; /* last change time */ long sem_pad2; /* time_t expansion */ long sem_pad3[4]; /* reserve area */ ; such a structure will be identified with a semaphore ID (semid)

32 Parallel Programming Slide 2-32 entire data structure for semaphores pool of semaphore sets (struct semid_ds *) semaphore set (struct semid_ds) array of semaphores (struct sem) sem_perm sem_base... sem_perm sem_base... (struct semid_ds *) NULL (struct semid_ds *) NULL semval sempid semncnt semzcnt semval sempid semncnt semzcnt semval sempid semncnt semzcnt semval sempid semncnt semzcnt semaphore 0 semaphore n semaphore 0 semaphore k semid will be used as index into the array of semaphore sets very memory efficient as long as there are very few or no semaphores in use basic operations 1) create / initialize a semaphore set with semaphores (semget, semctl) 2) use the semaphore(s) (semop, semctl) 3) remove the semaphore set (semctl)

33 Parallel Programming Slide 2-33 controlling semaphores with semctl ( ) read / modify semaphore values modify access permissions remove a semaphore set etc. (have a look at the manual page for more details) int semctl (int semid, int semnum, int cmd, union semun arg) semid handle for semphore set (return value from semget ( )) semnum number of semaphore within the set cmd command to execute GETVAL return semaphore value SETVAL set semaphore value GETALL return all semaphore values SETALL set all semaphore values IPC_SET set permissions IPC_RMID remove semaphore set etc. have a look at the manual page arg depending on cmd union semun int val; /* e.g., for SETVAL */ struct semid_ds *buf; /* e.g., for IPC_SET */ ushort *array; /* e.g., for SETALL */ ; return value depends on cmd (have a look at the manual page)

34 Parallel Programming Slide 2-34 the data structures for semaphores must be explicitly removed (IPC_RMID) a semaphore set is available until you remove it you can check with ipcs -s which semaphore sets are available if necessary you must remove all semaphore sets manually which you have created before you logout (use "ipcrm -s <semid>" or "ipcrm sem <semid>" (Linux)) get an identifier for a semaphore set with semget ( ) int semget (key_t key, int nsems, int semflg) key user defined arbitrary unique positive numerical key or IPC_PRIVATE (if you use IPC_PRIVATE other programs don't know the key so that they can't use the semaphore set; a user defined key can be defined as symbolic constant, command line option,...) nsems number of semaphores in set semflg access permissions and flags flags IPC_CREAT IPC_EXCL create a new semaphore set if it doesn't already exist create a new semaphore set exclusively, i.e. return an error if a semid already exists for key

35 Parallel Programming Slide 2-35 performing semaphore operations with semop ( ) all operations are indivisible, i.e. all operations are performed in one step int semop (int semid, struct sembuf *sops, size_t nsops) struct sembuf ushort sem_num; /* number of semaphore in set */ short sem_op; /* operation */ short sem_flg; /* flags */ semop (int semid, struct sembuf *sops, size_t nsops) handle for semaphore set array of semaphore operations number of operations in the array sem_num sem_op sem_flg number of semaphore to operate on operations: < 0: corresponds to P() operation > 0: corresponds to V() operation = 0: wait until count equals 0 IPC_NOWAIT SEM_UNDO 0

36 Parallel Programming Slide 2-36 it's operating system dependent how many operations are allowed in a single semop ( ) call sem_op > 0 increment semaphore value by sem_op sem_op < 0 sem_op = 0 decrement semaphore value by sem_op if possible (possibly the process will be blocked until operation is possible) wait until the semaphore value equals zero allowed values for sem_flg: IPC_NOWAIT can be used for every single operation (if any operation with IPC_NOWAIT cannot be performed, semop ( ) performs no operation at all and returns -1) SEM_UNDO the operating system keeps track of this operation and is able to undo all operations if the process exits Attention: Don't use this flag if processes are only running for some time and performing a different number of P ( ) and V ( ) operations (e.g., the P ( ) operation is in one process and the corresponding V ( ) operation in another one) 0 in most cases the default (if a process terminates due to a failure it can possibly block resources for other processes which use the same semaphore set)

37 Parallel Programming Slide 2-37 example: implementation und usage of Dijkstra's P ( ) and V ( ) operation with System V semaphores (sem_implement_p_v.c)... #define SEM_KEY IPC_PRIVATE /* create private semaphore */ #define SEM_PERM 0600 /* access permissions */ typedef int semaphore; /* semaphore (handle) type */ #if (_SEM_SEMUN_UNDEFINED == 1) defined(sunos) defined(cygwin) typedef union semun int val; /* cmd: SETVAL */ struct semid_ds *buf; /* cmd: IPC_STAT, IPC_SET */ ushort *array; /* cmd: GETALL, SETALL */ semunion; #endif semaphore init_sem (int value); /* create/initialize semaphore */ void rel_sem (semaphore sem); /* release semaphore */ void P (semaphore sem); /* semaphore operations */ void V (semaphore sem); int main (int argc, char *argv[]) semaphore s;... srand ((unsigned int) time ((time_t) NULL)); s = init_sem (1); /* create sem with value 1 */ for (i = 0; i < MAX_CHILD; ++i) child_pid[i] = fork (); switch (child_pid[i]) case -1: /* error: no process created */... case 0: /* child process */ alarm (LIFETIME); /* force process termination */ while (1) /* simulate some normal work */ P (s); /* simulate some critical work */ V (s); break; default: /* parent process */ if (i == (MAX_CHILD - 1)) /* all childs created? */ /* yes -> wait for termination */... printf ("All child processes have terminated.\n"); rel_sem (s); /* end switch */ /* end for */ return EXIT_SUCCESS;

38 Parallel Programming Slide 2-38 semaphore init_sem (int value) union semun arg; /* parameter for semctl */ int semid; /* semaphore handle */ semid = semget (SEM_KEY, 1, IPC_CREAT SEM_PERM); if (semid == -1) fprintf (stderr, "init_sem: semget failed: %s\n", strerror (errno)); exit (ESEMGET); arg.val = value; if (semctl (semid, 0, SETVAL, arg) == -1) fprintf (stderr, "init_sem: semctl failed: %s\n", strerror (errno)); exit (ESEMCTL); return semid; void rel_sem (semaphore sem) union semun tmp; /* for Linux up to 2.0.x */ if (semctl (sem, 0, IPC_RMID, tmp) == -1) fprintf (stderr, "rel_sem: semctl failed: %s\n", strerror (errno)); exit (ESEMCTL); void P (semaphore sem) struct sembuf tmp; tmp.sem_num = 0; tmp.sem_op = -1; tmp.sem_flg = 0; if (semop (sem, &tmp, (size_t) 1) == -1) fprintf (stderr, "P: semop failed: %s\n", strerror (errno)); exit (ESEMOP); void V (semaphore sem) struct sembuf tmp; tmp.sem_num = 0; tmp.sem_op = 1; tmp.sem_flg = 0; if (semop (sem, &tmp, (size_t) 1) == -1) fprintf (stderr, "V: semop failed: %s\n", strerror (errno)); exit (ESEMOP);

39 Parallel Programming Slide 2-39 System V IPC can be configured via operating system parameters SHMMNI maximum number of identifiers for shared memory segments SHMMAX maximum size of a shared memory segment in bytes SEMMNI SEMMSL SEMOPM MSGMNI maximum number of identifiers for semaphore sets maximum number of semaphores per set maximum number of operations per semop-call maximum number of identifiers for message queues MSGMNB maximum number of bytes of messages on message queue MSGTQL maximum number of messages on a message queue Linux 2.6.x specifies these values in the following files /usr/include/linux/shm.h /usr/include/linux/sem.h /usr/include/linux/msg.h it's necessary to create a new kernel if you change any value use "/sbin/sysctl -a grep -e shm -e sem" to read current values presumably Solaris defines these values in the following module files shmsys semsys msgsys (these files are stored in directory "/kernel/sys" (32-bit operating system) and "/kernel/sys/sparcv9" or "/kernel/sys/amd64" (64-bit operating systems))

40 Parallel Programming Slide 2-40 up to Solaris 9 all values can be changed via /etc/system (try "man -s 4 system") e.g.: set shmsys:shminfo_shmmni = <value> set semsys:seminfo_semmni = <value> it's necessary to reboot the system if you change any value the following command displays all current values (try "man sysdef") /usr/sbin/sysdef /usr/xpg4/bin/grep -e SHM -e SEM (Everything is different for Solaris 10 or newer which introduced "containers" and "process specific resources". Try "man prctl", "man getrctl", or "man rctladm". You can display the current values with "rctladm -l" instead of "sysdef" in older Solaris versions. The advantage of the new concept is that you can change the values on a per process basis and that you don t have to reboot if you change the values.)

41 Parallel Programming Slide 2-41 Exercise 2-5: Implement a solution for the dining philosophers problem. Don't use the above simulation! Use all of the power of System V semaphores, i.e. take all necessary forks in one operation #define N 5 semaphore fork [N]; int main (void) int i; for (i = 0; i < N; ++i) fork [i] = init_sem (1); /* all forks are free */ COBEGIN philosopher (0);...; philosopher (N-1); COEND; void philosopher (int i) while (1) philosopher is thinking; P (fork [i]); /* right fork */ P (fork [(i + 1) % N]); /* left fork */ philosopher is eating; V (fork [i]); V (fork [(i + 1) % N]);