1. University of Pennsylvania 9/12/00CSE 3801 Multiprogramming CSE 380 Lecture Note 3

2. University of Pennsylvania 9/12/00CSE 3802 Concurrent Processes: fork(), wait() To see how processes can be used in application and how they are implemented, we study at how processes are created and manipulated in UNIX. Important source of info on UNIX is “man.” UNIX supports multiprogramming, so there will be many processes in existence at any given time. –Processes are created in UNIX with the fork() system call. –When a process P creates a process Q, Q is called the child of P and P is called the parent of Q. So, processes are organized as a "family tree."

3. University of Pennsylvania 9/12/00CSE 3803 UNIX Process Control At the root of the family tree of a UNIX system is the special process init: –created as part of the bootstrapping procedure –process-id = 1 –among other things, init spawns a child to listen to each terminal, so that a user may log on. –do "man init” learn more about it UNIX provides a number of system calls for process control including: –fork - used to create a new process –exec - to change the program a process is executing –exit - used by a process to terminate itself normally –abort - used by a process to terminate itself abnormally –kill - used by one process to kill or signal another –wait - to wait for termination of a child process –sleep - suspend execution for a specified time interval –getpid - get process id –getppid - get parent process id

4. University of Pennsylvania 9/12/00CSE 3804 The Fork System Call The fork() system call creates a "clone" of the calling process. Identical in every respect except (1) the parent process is returned a non-zero value (namely, the process id of the child) and (2) the child process is returned zero. The process id returned to the parent can be used by parent in a wait or kill system call. Typical usage of fork(): pid_t pid; pid = fork(); if (pid == 0) { /* code to be executed by child process */ } else { /* code executed by parent process */ } ------------ fork() -----------------> ----------------->

5. University of Pennsylvania 9/12/00CSE 3805 More on fork()  child process is an exact copy of parent except for value returned by the fork() call  other items copied not depicted (e.g. contents of CPU registers)  in practice, text segment is shared  child process begins its execution by returning from the fork() call! ParentChild text stack data text stack data Open file table etc.

6. University of Pennsylvania 9/12/00CSE 3806 Example of spawn using fork 1. #include 2. Main(){ 3. pid_t pid; 4. printf(“Just one process so far\n”); 5. pid = fork(); 6. if (pid = 0) 7. printf(“I’m the child\n”); 8. else if (pid > 0) 9. printf(“The parent, ch pid =%d\n”, 10. pid); 11. else 12. printf(“Fork returned error code\n”); 13. }

7. University of Pennsylvania 9/12/00CSE 3807 Why fork()? Often used in conjunction with exec or execve (the real system call) #include pid_t pid; if ( ( pid = fork() ) == 0 ) { execl( "/usr/games/tetris","tetris", "-easy",0 ) } else { wait( &status ) }

8. University of Pennsylvania 9/12/00CSE 3808 exec System Call A family of routines, execl, execv,..., all eventually make a call to execve. execlp( program_name, arg1, arg2,..., 0 )  text and data segments of current process replaced with those of program_name  stack reinitialized with parameters  open file table of current process remains intact  as in example, program_name is actually path name of executable file containing program Note: unlike subroutine call, there is no return after this call. That is, the process calling exec is gone forever!

9. University of Pennsylvania 9/12/00CSE 3809 Parent-Child Synchronization exit( status ) - executed by a child process when it wants to terminate. Makes status (an integer) available to parent. wait( &status ): return pid_t - suspends execution of process until *some* child process terminates –status indicates reason for termination –return value is process-id of terminated child

10. University of Pennsylvania 9/12/00CSE 38010 Process Termination Besides being able to terminate itself with exit, a process can be killed by another process using kill: –kill( pid, sig ) - sends signal sig to process with process- id pid. One signal is SIGKILL which means terminate the target process immediately. When a process terminates, all the resources it owns are reclaimed by the system: –“process control block” reclaimed –its memory is deallocated –all open files closed and Open File Table reclaimed. Note: a process can kill another process only if: –it belongs to the same user –super user

11. University of Pennsylvania 9/12/00CSE 38011 How shell executes a command This is how the command interpreter (the “shell”) executes your commands. when you type a command, the shell forks a clone of itself the child process makes an exec call, which causes it to stop executing the shell and start executing your command the parent process, still running the shell, waits for the child to terminate fork wait exec exit parent child shell command ….

12. University of Pennsylvania 9/12/00CSE 38012 Background Processing You may be aware that shell has capability of managing several concurrent processes. Example: % longjob & % jobs [1] running longjob % executes longjob in background mode. Notice the shell returns right away without waiting for longjob to finish. There are also fg, bf, and CTL-Z. How does shell do this? while (1) { /* main command loop */ /* print prompt */ /* read command */ if ( ( pid = fork() ) == 0 ) { execl( cmd, … ); } else { /* store pid in a table */ }

13. University of Pennsylvania 9/12/00CSE 38013 Multiprogramming (multiple processes) For each process, the O.S. maintains a data structure, called the process control block (PCB). The PCB provides a way of accessing all information relevant to a process: –This data is either contained directly in the PCB, or else the PCB contains pointers to other system tables. Processes (PCBs) are manipulated by two main components of the process subsystem in order to achieve the effects of multiprogramming: –Scheduler: determines the order by which processes will gain access to the CPU. Efficiency and fair-play are issues here. –Dispatcher: actually allocates CPU to process next in line as determined by the scheduler.

14. University of Pennsylvania 9/12/00CSE 38014 The Process Control Block (PCB) The PCB typically contains the following types of information: Process status (or state): new, ready to run, user running, kernel running, waiting, halted –Program counter: where in program the process is executing –CPU registers: contents of general-purpose register stack pointer, PSW, index registers –Memory Management info: segment base and limit registers, page table, location of pages on disk, process size –User ID, Group ID, Process ID, Parent PID,... –Event Descriptor: when process is in the “sleep” or waiting state –Scheduling info: process priority, size of CPU quantum, length of current CPU burst

15. University of Pennsylvania 9/12/00CSE 38015 PCB (cont.) –List of pending signals –Accounting info: process execution time, resource utilization –Real and Effective User IDs: determine various privileges allowed the process such as file access rights –More timers: record time process has spent executing in user and Kernel mode –Array indicating how process wishes to react to signals –System call info: arguments, return value, error field for current system call –Pending I/O operation info: amount of data to transfer, addr in user memory, file offset,... –Current directory and root: file system environment of process –Open file table: records files process has open

16. University of Pennsylvania 9/12/00CSE 38016 PCB in Unix In UNIX, the notion of a PCB is split in two: –Process Table entry The process table contains an entry for every process in system. Table is of fixed size (tunable) –User Area Extension of a process table entry. Created along with the creation of an actual process. These two structures point to each other!

17. University of Pennsylvania 9/12/00CSE 38017 Process States & Transitions user running kernel running ready to run asleep sys call or interrupt return interrupt interrupt return block/sleep wakeup context switch permissible schedule process

18. University of Pennsylvania 9/12/00CSE 38018 Context Switching Let us first review the user/system mode distinction. When system starts (during system bootstrapping or boot) it is in system mode. This is process 0 in V.2, which creates process 1 (init). This process execs /etc/init and is then executing in user mode. Process 1, like any user process, continues executing in user mode until one of the following: –interrupt by an asynchronous device like timer, disk, or terminal –the process makes a system call by executing an instruction to cause a software interrupt Occurrence of such an event causes the CPU to switch to system mode and begin execution appropriate interrupt handler.

19. University of Pennsylvania 9/12/00CSE 38019 When to context switch Typically, hardware automatically saves the user PC and PSW when interrupt occurs, and takes new PC and PSW from interrupt vector. Interrupt handler may simply perform its function and then return to the same process that was interrupted (restoring the PC and PSW from the stack). Alternatively, may no longer be appropriate to resume execution of process that was running because:  process has used up its current CPU quantum  process has requested I/O and must wait for results  process has asked to be suspended (sleep) for some amount of time  a signal or error requires process be destroyed (killed)  a “higher priority” process should be given the CPU In such a situation, a context switch is performed to install appropriate info for running a new process.

20. University of Pennsylvania 9/12/00CSE 38020 Mechanics of a Context Switch 1copy contents of CPU registers (general-purpose, SP, PC, PSW, etc.) into a save area in the PCB of running process 2change status of running process from “running” to “waiting” (or “ready”) 3change a system variable running-process to point to the PCB of new process to run 4copy info from register save area in PCB of new process into CPU registers Note:  context switching is pure overhead and should be done as fast as possible  often hardware-assisted - special instructions for steps 1 and 4  determining new process to run accomplished by consulting scheduler queues  step 4 will start execution of new process - known as dispatching.

21. University of Pennsylvania 9/12/00CSE 38021 MULTIPROGRAMMING Through CONTEXT SWITCHING executing process Aprocess B i/o request, timeout,... waiting save A’s state restore B’s state dispatch save B’s state restore A’s state