Operating Systems, laboratory exercises. List 2.

Transcription

1 Operating Systems, laboratory exercises. List 2. Subject: Creating processes and threads with UNIX/Linux API functions. 1. Creating a process with UNIX API function. To create a new process from running process (in a way similar to launching shell script from running shell script) UNIX programmer can use C-language function fork() available in UNIX/Linux Application Programmer s Interface defined by POSIX standard. Typical implementation of the creating a new process with this function looks like this: #include <sys/types.h> /* Important header file with some types */ #include <unistd.h> pid_t justpid, mypid, myparentpid; /* pid_t is defined in types.h */ /* Fork new process: */ justpid = fork(); /* New process is created at this moment */ if ( justpid < 0 ) /* If return from fork() is negative error */ /* Error occurred - no child process. */ fprintf( stderr, "Fork failed." ); /* Error message to stderr */ return 1; if ( justpid == 0 ) /* Child process */ /* To get PID of this process */ myparentpid = getppid(); /* To get the PID of parent process PPID */ /* Rest of the code which runs as child process. */ else /* Parent process - the value returned by fork() is child's PID */ myparentpid = getppid(); /* Rest of the code which runs as parent process. */ The newly created child process as a binary image in memory is created as a clone of his parent. That means it inherits the copies of all variables created in parent (justpid, mypid, myparentpid in example given above) with their values at the moment of invoking fork() function. The same is true as far as the functions implemented in parent program (main() function in this case) is concerned. To compile a simple C-language program (like the one shown above) programmers can invoke gcc utility from command line: >gcc source_file.c o executable_file 1

2 To exchange the binary code of the child process with something else than code of the main (parent) program, programmer can use the function from the exec() family, which loads given binary file as the image of the child: justpid = fork(); if ( justpid == 0 ) /* Child process */ /* Loading new code (program) for child process and starting it */ execlp( "./ex_2-2b", "ex_2-2b", NULL ); else /* Parent process */ Different strategies can be applied when several related processes are working together. For example: they can run independently and each of them does its own work, or parent can wait for its child processes doing nothing, then making use of results given by child processes. This second strategy is implemented with wait() function used in parent process. The appropriate code in simplest variant can look as follows: justpid = fork(); if ( justpid == 0 ) /* Child process */ printf( "[CHILD]: Child %d started.\n", getpid() ); else /* Parent process waits for the end of child process: */ wait ( NULL ); printf( "[PARENT]: Child %d finished.\n", justpid ); Some interesting observations can be performed with following example program: #include <sys/types.h> #include <sys/wait.h> #include <unistd.h> pid_t justpid, mypid, myparentpid; int exitstatus; /* fork new process */ justpid = fork(); if ( justpid < 0 ) /* Error occurred - no child process. */ fprintf( stderr, "Fork failed." ); return 1; if ( justpid == 0 ) /* Child process. */ 2

3 myparentpid = getppid(); printf( "[CHILD]: PID = %d PPID = %d\n", mypid, myparentpid ); /* Blind loop - signal like SIGINT is needed to exit from process. */ while ( 1 ) /* Empty loop - child process "works" */ ; else /* Parent process - the value returned by fork() is child's PID. */ myparentpid = getppid(); printf( "[PARENT]: PID = %d PPID = %d Child's PID = %d\n", \ mypid, myparentpid, justpid ); /* Wait for particular child process end. */ waitpid( justpid, &exitstatus, 0 ); if( WIFEXITED(exitStatus) ) printf( "[PARENT]: Child process with PID = %d exited \ with status %d\n", justpid, WEXITSTATUS(exitStatus) ); if( WIFSIGNALED(exitStatus) ) printf( "[PARENT]: Child process with PID = %d terminated \ by signal %d\n", justpid, WTERMSIG(exitStatus) ); /* Then we can do something more (reminder section). */ while ( 1 ) /* Empty loop - parent process "works" */ ; 2. Creating a lightweight process (thread) with UNIX API functions. To create a thread according to POSIX standard programmer can use C-language function pthread_create() available in pthread library of UNIX Application Programmer s Interface. This time preparation and appropriate initialization of environment needed to keep thread alive under its parent process control is necessary. So the functions pthread_attr_init()and pthread_attr_setscope() should be invoked before. Typical implementation of the creating two new threads looks like this: #include <sys/types.h> #include <pthread.h> void *threadcode1() /* The code which should be run as thread #1 */ void *threadcode2() /* The code which should be run as thread #2 */ pthread_t threadid1, threadid2; pthread_attr_t threadattr1, threadattr2; 3

4 /* Preparation the environment for both threads: */ pthread_attr_init( &threadattr1 ); pthread_attr_setscope( &threadattr1, PTHREAD_SCOPE_PROCESS ); pthread_attr_init( &threadattr2 ); pthread_attr_setscope( &threadattr2, PTHREAD_SCOPE_PROCESS ); /* Creation of the threads: */ pthread_create( &threadid1, &threadattr1, threadcode1, NULL ); pthread_create( &threadid2, &threadattr2, threadcode2, NULL ); /* Rest of the main process program */ To compile the program and link the pthread library programmer should invoke gcc utility from command line this way: >gcc source_file.c o executable_file lpthread Please notice that there s no space between l switch and name of the linked library. The pthread_attr_setscope() function is important, because it sets the strategy of time sharing between the threads and main process. When setting PTHREAD_SCOPE_PROCESS predefined value programmer decides, that thread rivals for CPU time from the pool given by operating system to its main, parent process. The value PTHREAD_SCOPE_SYSTEM forces the thread to rival with all the processes running in operating system (sometimes it can be a better strategy). Without setting this attribute the thread will not be given the CPU time unless the parent process will give it up by himself (waiting for I/O operation for example). 3. Simple inter-process communication with signals. To send a signal from the application programmer can use the kill() function, which works like the kill shell command sends the signal of given number to process identified by its PID. Programmer can also use signal() function to attach the functions (handlers) for given signals which will be working instead of default ones, except signal 9 (SIGKILL) which cannot be re-programmed and always kills the process immediately. Typical implementation looks like this: #include <sys/types.h> #include <signal.h> #include <unistd.h> unsigned long i = 0; /* Public variable, accessible for all functions */ /* Custom SIGINT (Ctrl+C) signal handler */ void myint( int signo ) if( signo == SIGINT ) printf( "Process %d killed after %ld iterations.\n", getpid(), i ); exit( 0 ); signal( SIGINT, myint ); /* Setting a new handler for SIGINT */ 4

5 printf( "Process %d started.\n", getpid() ); /* Blind loop - SIGINT signal aborts */ while ( 1 ) i++; /* No output by printf() etc. CPU oriented process */ Try to run the program like given above (model of a CPU-oriented process) in foreground and kill him using Ctrl+C to send SIGINT signal, then run it in background and use the kill SIGINT <PID> command after checking the PID value. In fact terminating process needs some support from the parent of terminated process to avoid indicating it as zombie. So proper implementation of signal handler should look more or less like this: #include <sys/types.h> #include <sys/wait.h> #include <errno.h> #include <signal.h> #include <unistd.h> /* Custom signal handler */ void mysignal( int signo ) if( signo == SIGTERM ) printf( "Process %d killed by SIGTERM.\n", getpid() ); exit( 0 ); /* exit() termitanes the process */ if( signo == SIGINT ) printf( "Process %d killed by SIGINT.\n", getpid() ); exit( 0 ); /* SIGCHLD needs some support for terminated process */ if( signo == SIGCHLD ) int saved_errno; saved_errno = errno; while ( waitpid( (pid_t)-1, 0, WNOHANG ) > 0 ) errno = saved_errno; printf( "Process %d received SIGCHLD.\n", getpid() ); pid_t justpid, mypid, myparentpid; /* Setting custom handler for SIGTERM, SIGINT and SIGCHLD */ signal( SIGTERM, mysignal ); signal( SIGINT, mysignal ); signal( SIGCHLD, mysignal ); justpid = fork(); /* New process is created at this moment */ if( justpid < 0 ) fprintf( stderr, "Fork failed.\n" ); return( 1 ); 5

6 if ( justpid == 0 ) /* Child process */ myparentpid = getppid(); printf( "Child works with PID %d\n", mypid ); do while( 1 ); else /* Parent process */ myparentpid = getppid(); signal( SIGINT, mysignal ); printf( "Parent works with PID %d\n", mypid ); do while( 1 ); 6

7 Exercise 1. Read the manual (man) about the fork(), getpid(), getppid() UNIX/Linux API functions. Then write a program which creates one child process, and then both parent and child are running in blind loops displaying their PIDs and PPIDs. This way you will have the models of typical I/O-oriented processes. Perform some observations, how the CPU time is shared between these two processes and how they are reacting for Ctrl+C (SIGINT) or default SIGTERM signal (sent from command line by kill shell command when running in background can be some fun). The output screen may look like this: [PARENT]: PID 2374, PPID 2360 [PARENT]: PID 2374, PPID 2360 [CHILD]: PID 2375, PPID 2374 [PARENT]: PID 2374, PPID 2360 [CHILD]: PID 2375, PPID 2374 [CHILD]: PID 2375, PPID 2374 [PARENT]: PID 2374, PPID 2360 Exercise 2. Read the manual about the wait() and exec() families of functions. Then write a program which creates one child process, loads new binary code (compiled from other source) for the child, and then parent waits (without using CPU nor I/O) until child finishes his task (counting from 1 to 10 and displaying counter status for example). The output screen may look like this: [PARENT]: PID 2421, waits for child with PID 2422 [CHILD]: PID 2421, starts counting: [CHILD]: i = 1 [CHILD]: i = 2 [CHILD]: i = 10 [PARENT]: Child with PID 2422 finished and unloaded. Exercise 3. Read the manual about the kill() and signal() families of functions. Then write a program which creates one child process, then both parent and child are running in blind loops incrementing their own copies of counter declared as public (global) variable without displaying it (models of a CPU-oriented process) until SIGINT signal (Ctrl+C) kills them both. The custom handler for SIGINT signal should display the value of counter and exit from process. The output screen may look like this: [PARENT]: PID 8519, starts counting. [CHILD]: PID 8520, PPID 8519 starts counting. Process 8519 killed, i = Process 8520 killed, i = Perform several experiments with different periods of running time and try to make some conclusions about quality of time-sharing multitasking in your operating system: are the processes treated more or less equally by short time scheduler and dispatcher or not? 7

8 Exercise 4. Read the manual about the pthread_attr_init(), pthread_attr_setscope() and pthread_create() functions. Then write the program which creates two threads playing the game: first of them increments the common variable in the blind loop (global variables this time are not cloned, but accessible in one instance for main process and threads), the second thread decrements the same variable. Both of them should also count the numbers of their iterations, the same should do the main process (three different counters). All of them should be CPU-oriented (that means working without any output to terminal). The end of the game will be caused by SIGINT signal. The custom handler of SIGINT should display the final value of the common variable (which thread is the winner?) and numbers of iterations for threads and main process. The output screen may look like this: [MAIN]: PID = 8902, i = [MAIN]: main segment iterations: [MAIN]: incrthread iterations: [MAIN]: decrthread iterations: [ Perform several experiments with different periods of running time and try to make some conclusions whether the threads and main process are treated more or less equally. Try to use both PTHREAD_SCOPE_PROCESS and PTHREAD_SCOPE_SYSTEM settings. 8