Operating Systems. Threads and Signals. Amir Ghavam Winter Winter Amir Ghavam

Transcription

1 Operating Systems Threads and Signals Amir Ghavam Winter

2 Traditional Process Child processes created from a parent process using fork Drawbacks Fork is expensive: Memory is copied from a parent to its children. Logically a child has a copy of the memory of the parent before the fork Communication after the fork is expensive. Inter-process communication is needed to pass information from parent to children and vice versa after the fork has been done 2

3 The Thread Model Thread Lightweight Process Multiple entries that execute the same program Using same files and devices Process Allocates resources, but has no component to execute Passive resource with a single active thread Thread exists within a process Process Threads 3

4 Threads - Motivation Faster creation 10 to 100 times faster than process creation Minimizing Context Switching Time Switching processes is a heavy task Small state compared to a process (register and stack) Shared Memory All threads within a process share the same memory and files Communicating by sharing resources Process Threads 4

5 Threads - Applications Overlapping I/O with e.g. Word Processing Independent sets of tasks Asynchronous events e.g. Networks Lots of CPU cycles, e.g. Matrix Multiplication 5

6 Thread Mechanisms Resource Sharing Communicate Synchronization Join Semaphors Pthreads: POSIX threads standardized in

7 Creation of threads pthread_create() #include <pthread.h> int pthread_create( pthread_t * thread, pthread_attr_t * attr, void * (* start_routine) (void *), void * arg); pthread_create creates a new thread of control that executes concurrently with the calling thread. 7

8 Creation of threads (Cont d) The new thread applies the function start_routine() passing it arg as the first argument The new thread terminates either explicitly by calling pthread_exit(), or implicitly, by returning from the start_routine() The latter case is equivalent to calling pthread_exit()with results returned by the start_routine() as exit code. The attr argument can be NULL in which case the default attributes will be used 8

9 Creation of threads (Cont d) Each thread has a unique identifier, within a process, of data type pthread_t On success, the identifier of the newly created thread is stored in the location pointed to by the thread argument, and a 0 value is returned On error, a non-zero error code is returned 9

10 Thread Join pthread_join() #include <pthread.h> int pthread_join( pthread_t th, void **thread_return); pthread_join suspends the execution of the calling thread until the thread identified by th terminates. This occurs by calling pthread_exit() or by being cancelled. 10

11 Thread Join (Cont d) If thread_return is not NULL, the return value of th is stored in the location pointed to by thread_return The return value of th is either the argument it gave to pthread_exit() or PTHREAD_CANCELED if th was cancelled On success, the return value of th is stored in a location pointed to by thread_return, and 0 is returned On error, a non-zero error code is returned. 11

12 Thread Self id pthread_self() #include <pthread.h> pthread_t pthread_self(void); pthread_self returns the thread identifier for the calling thread. 12

13 Thread Detach #include <pthread.h> int pthread_detach( pthread_t th); pthread_detach puts the thread th in the detached state. This guarantees that the memory resources consumed by th will be freed immediately when th terminates. This prevents other threads from synchronizing on the termination of th using pthread_join. The thread becomes non-joinable. 13

14 Thread Detach (Cont d) On success, 0 is returned. On error, a non-zero error code is returned. Example: A Thread may detach itself by executing the following combination of functions: pthread_detach(pthread_self()); 14

15 Thread Exit pthread_exit() #include <pthread.h> int pthread_exit(void *retval); pthread_exit terminates the execution of the calling thread. The retval argument is the return value of the thread. It can be consulted from another thread using pthread_join(). 15

16 Thread Example void do_something(int *num){ int i; for(i=0;i<*num;i++){ printf( doing something ); } } void do_something_else(int *num){ int i; for(i=0;i<*num;i++){ printf( doing something else ); } } 16

17 Thread Example (Cont d) #include <pthreads.h> int a=10, b= 17; main(){ } pthread_1 thread1, thread2; pthread_create(&thread1, NULL, (void*)do_something, (void*)&a); pthread_create (&thread2, NULL, (void*)do_something_else, (void*)&a); pthread_join(thread1, NULL); pthread_join(thread2, NULL); 17

18 Signals Mechanism for OS to notify processes that some event has occurred. Events Hardware, e.g. a key Software condition, e.g. timer Asynchronous: is processed immediately by the receiver process without finishing the current line of code 18

19 Signal Types 31 Types (names) in Unix (and Linux) /include/asm/signal.h /usr/include/bits/signum.h Can also be used among application processes SIGUSR1 and SIGUSR2 19

20 Signal Types (Cont d) SIGHUP SIGHUP 1 1 SIGINT SIGINT 2 2 SIGQUIT SIGQUIT 3 3 SIGILL SIGILL 4 4 SIGTRAP SIGTRAP 5 5 SIGABRT SIGABRT 6 6 SIGBUS SIGBUS 7 7 SIGFPE SIGFPE 8 8 SIGKILL SIGKILL 9 9 SIGUSR1 SIGUSR SIGSEGV SIGSEGV SIGUSR2 SIGUSR SIGPIPE SIGPIPE SIGALRM SIGALRM SIGTERM SIGTERM SIGSTKFLT SIGSTKFLT SIGCHLD SIGCHLD SIGCONT SIGCONT SIGSTOP SIGSTOP SIGTSTP SIGTSTP SIGTTIN SIGTTIN SIGTTOU SIGTTOU SIGURG SIGURG SIGXCPU SIGXCPU SIGXFSZ SIGXFSZ SIGVTALRM SIGVTALRM SIGPROF SIGPROF SIGWINCH SIGWINCH SIGIO SIGIO SIGPWR SIGPWR SIGSYS SIGSYS

21 Creating Signals Sender raises the signal using kill() #include <sys/types.h> #include <signal.h> int kill(pid_t pid, int sig); %man 2 kill %kill [ 9] <pid> 21

22 Receiving a Signal 3 Options depending on the signal s disposition Default disposition: defines what happens to the process if the program doesn t define some other behavior Ignore the signal Call a special signal handler 22

23 Receiving a Signal #include <signal.h> void (*signal(int signum, void(*sighandler)(int)))(int); SIG_IGN SIG_DFL signal(sig_alrm, SIG_IGN); 23

24 Caution with Signal handlers Avoid I/O operations and calling library and system functions from signal handlers Signal handler should perform the minimum work necessary to respond to the signal Return control to main program In most cases, just recording the occurrence of the signal The main program checks and reacts accordingly Signal handlers can be interrupted by other signals Use atomic variables (sig_atomic_t) 24

25 Signal Example #include <signal.h> static void sig_handler(int); int main(void){ int I, parent_pid, child_pid, status; /* Prepare the sig_handler routine to catch SIGUSR1 and SIGUSR2 */ if (signal(sigusr1, sig_handler)==sig_err) printf( Parent: Unable to create handler for SIGUSR1\n ); if (signal(sigusr2, sig_handler)==sig_err) printf( Parent: Unable to create handler for SIGUSR2\n ); parent_pid = getpid(); if ((child_pid = fork())==0){ kill(parent_pid, SIGUSR1); /* Raise the SIGUSR1 signal */ /* Child process begins busy wait for a signal*/ for (;;) pause(); } else { kill(child_pid, SIGUSR2); /* Parent raising SIGUSR2 signal */ printf( Parent: Terminating child ); kill(child_pid, SIGTERM); /* Parent raising SIGTERM signal */ wait (&status); /* Parent waiting for the child termination */ printf( done\n ); } } 25

26 Signal Example (Cont d) static void sig_handler (intsigno){ switch (signo){ case SIGUSR1: /* Incoming SIGUSR1 signal*/ printf( Parent: Received SIGUSR1 ); break; case SIGUSR2: /* Incoming SIGUSR2 signal*/ printf( Child: Received SIGUSR2 ); break; default: break; /* Should never get this case*/ } return; } 26