1. Chapter 4 Process Management

2. What is a Process  A primary goals of a computer system is to perform work for the system’s users.  Process is a program in execution It is a unit of work or an activity  A program stored on disk is NOT a process A program is a Passive entity Becomes a process when it is loaded into memory and begins execution A PROCESS has:  A State  Text Section  Program counter  Context  Multiple processes can be associated with the same program– but each process represents a single sequence of actions.  In Multiprogramming: Multiple processes are executing Interleaved execution

3.  To do work each process must execute a program.  In some systems a process may execute a series of different programs ( steps of a compiler)  Of a program might consists of several distinct processes, each with a separate sequence of activities that continue at the same time.  A process is not a data object, but is represented by a data object, usually called a PCB.  Throughout it’s lifetime a process will use resources, minimally the CPU and memory, but sometimes others: files, shared I/O devices.. Etc.  If a shared resource is not available, the process must wait. A process alternates between periods of running and waiting, thus a process is considered to move through a series of distinct states.

4. Process Types  Batch: Are processes which perform a job submitted by a user as a whole. Batch processes are usually submitted with good estimates of their resource needs, and possibly with instructions which explicitly determine importance and scheduling requirements. These execute with no further interaction with the user. Job is executed without interaction Results

5.  Interactive Interactive processes are assumed to perform work on behalf of users who remain present at an interactive terminal. Usually these processes have short execution time, and resource needs. But display information about progress, and may interact with the user during execution. Interactive processes are rarely initiated with information about resource use. The user requires rapid and consistent response throughout the processes execution. Process 1 Process 2 Process 3

6. Real time: monitor and control external events and must meet rigid timing constraints. designed to interact with external events and objects such as tracing air traffic, or monitoring the status of heat sensors. resource requirements of real-time processes are generally known.

7.  Many operating systems are specialized to recognize only one type of process: IBM’s z/OS is primarily batch oriented Linux is designed for interactive  Some OS’s attempt to support two or more types of processes, but usually one type is always dominant, and the majority of resources and scheduling effort is applied to that type of process first.

8. The PCB – Process Control Block  Process name, name by which the process may be identified by users or by other processes.  Process state, a code representing the current state for this process, or a link to a queue that represents that state.  Process context (CPU state), a storage area for register contents and other information that must be saved when the process is not running.  Memory use, information about the memory allocated to this process and the current location of its program code and data.

9.  Resource use, information about other resources currently in use by this process, and any restrictions or quotas on future resource use.  Process priority, a value or set of values to help determine the relative priority to be given to this process.  Relationships, information about relationships that may exist between this process and other processes, such as those it has created.  Accounting information, records of time and other resources that have been used by this process, and who owns the process, to be used for billing or analysis.

10. Process 1 Process 2Process 3Process 4Process 5 empty Fixed Array of PCB’s New Process #6 Process 1Process 2Process 4Process 3 Linked list of PCB’s Organization of processes

11.  To perform work, a process must be able use certain resources that must be shared with other processes.  Physical resources: represent the permanent components of the computer such as processor, memory, secondary storage space, and I/O devices and are usually controlled by the operating system. By their nature, physical resources are reusable.  They are not destroyed when used, and thus may be used repeatedly.  In most cases, a resource can not be used by two processes for separate purposes. Reusable resources that can be used by only one process at a time are called serially reusable.

12. Resource Needs  Logical resources: represent resources formed by information structures stored within files or main memory. These have a shorter lifetime than physical resources Some logical resources are consumable. The are created by one process and destroyed after use by another. IE: the blocks of data in a message.

13. Resource Allocation  A responsibility of the OS is the control and allocation of resources. The OS must keep track of the status of each resource. Keep track of processes waiting for a resource that is currently in the possession on another process.  In the form of a queue  A process enters the queue by linking its PCB to the queue in some manner. Have a strategy for deciding which process to choose when allocating an available resource.

14. Process State Represents the current activity in which the process is engaged An active process is either running or waiting (minimally for the processor) Can be represented in the pcb, or by linking the pcb to a state queue RUNNINGWAITING PROCESS GAINS CONTROL OF CPU PROCESS WAITS FOR SOME RESOURCE OR EVENT Simplest model of process states

15. RUNNINGBLOCKED READY CPU assigned Time quantum expires Waiting for event or resource Event occurs or resource available Basic Process State Diagram Fig 4-3, page 10 preemption

16. INITIALREADY RUNNING SUSPENDED READY SUSPENDED BLOCKED BLOCKED TERMINAL Terminate when complete Time quantum expires New process is ready to run CPU assigned Waiting for event or resource Waiting for long term event Event occurs or resource available Process swapped back into memory Abort due to error Fig 4-4, state diagram with additional states

17.  Processes transition through many states throughout their lifetime.  The objective of multiprogramming is to have some process running at all times, so as to maximize CPU utilization  Each process will go through many cycles of alternately running and waiting.

18. P1 OS -----##########===========----##### ===========----------############## =====------################### ===--=====---======---===---==--------- ==== Ready -------- Running ###### Blocked Two issues 1) Idle time, 2) OS overhead

19. Scheduling  Throughout it’s lifetime a process spends time “waiting”, this waiting is done in some scheduling queue.  Processes waiting to be admitted into the system, are in a “job” queue.  Processes waiting for the CPU are in the ready queue.  Processes waiting for a device are in a device queue.  A Scheduler determines which process is given the resource for which it is waiting, and the selection process is “scheduling”.  When a process is “paused” the need to preserve the information stored in registers, and status flags while the processor is in use by the OS or other processes. This information is called the “context” of the process.

20. Context Switching Process1 Registers Memor y PCB process 1 PCB process 2 Process2

21. Operations on processes  In early multi programming OS such as T.H.E. and CDC Scope processes were NOT dynamic entities.  These systems provided a fixed number of permanent processes.  Number of processes were fixed at ONE per user.  Static Process Management Process 1Process3Process2 New Process

22.  Operating systems which employ Dynamic process management allow processes to be created and destroyed as needed during the operation of the system!  Minimally, there is one process for each job admitted into the system. The number of processes change only as the number of simultaneous users change.  In newer OS’s (unix), it is possible for one process to explicitly create another through the use of system calls. An individual user may have many processes. Each interactive user has a logon-session process, this in turn creates new processes to execute commands, like running a program or searching a directory.

23. P1 P2P3 P4 Parent of P2, & P3 Child of P1, Parent of P4 & sibling of P2 Child of P1 & sibling of P3 Child of P3 The creating process is called the parent process, and the new processes the child of its creator. Children of the same parent are siblings and other related terms such as grandparents, ancestor, and descendant may be used to describe this “tree” of related processes. Ancestor processes have the ability to control, delete, and change child processes The ability of processes to create new ones creates a process hierarchy.

24. Operations needed for dynamic Process creation  Create or allocate a PCB: A new PCB structure is either allocated from an existing pool of PCB’s or dynamically created.  Allocate initial memory space for the program and data: Memory is allocated to hold the program code and data.  Identify and (usually) run the program to be run: The program to execute is loaded by the relocating loader.

25. Process creation  Assign initial attributes and resource limits to the process.  Allocate initial resources to the process (if any). A child may be allocated resources directly from the operating system or may be constrained to a subset of the parent’s resources.  Establish the starting state for the process and setup or complete the PCB

26.  When a process creates a new process, two possibilities exist in terms of execution: The parent process continues to execute concurrently with its child The parent process waits until some or all of its children have terminated.  There are also two possibilities in terms of the address space of the new process: The child process is a duplicate of the parent process The child process has a program loaded into it.

27.  This can be illustrated using Unix.  A process has a text, data, and stack segment, which must be in memory. The text segment contains the program to be executed.  A process also has a system data area that contains information needed by the OS as the process executes, including storage for return addresses.  A program’s text segment is reentrant, and can be shared by multiple processes.

28. Real Memory Text Segment A & B Data Segment Process A Stack Segment Process A Data Segment Process B Stack Segment Process B

29.  If a process that is executing is a command shell, and receives a command such as that to execute an application program, the shell will respond by creating another process by calling the “fork” command.  In response, UNIX duplicates the executing process, creating two identical copies, both copies initially execute the same program, share open files and other key data. The two processes are distinguished by giving them different return codes.

30. #include int main (int argc, char *argv[]) { int pid; /*fork another process */ printf(“In the parent program forking a process\n”); pid = fork(); if (pid <0) {/* the fork failed */ printf("the fork failed\n"); exit(-1); } else if(pid == 0) {/*the child process */ printf("the child \n"); execlp("/bin/ps",“ps", NULL); } else {/* the parent */ printf("the parent \n"); wait(NULL); printf("child complete \n"); } printf("main is done\n"); return 0; } Parent Process

31. #include int main (int argc, char *argv[]) { int pid; /*fork another process */ printf(“In the parent program forking a process\n”); pid = fork(); if (pid <0) {/* the fork failed */ printf("the fork failed\n"); exit(-1); } else if(pid == 0) {/*the child process */ printf("the child \n"); execlp("/bin/ps",“ps", NULL); } else {/* the parent */ printf("the parent \n"); wait(NULL); printf("child complete \n"); } printf("main is done\n"); return 0; } #include int main (int argc, char *argv[]) { int pid; /*fork another process */ printf(“In the parent program forking a process\n”); pid = fork(); if (pid <0) {/* the fork failed */ printf("the fork failed\n"); exit(-1); } else if(pid == 0) {/*the child process */ printf("the child \n"); execlp("/bin/ps",“ps", NULL); } else {/* the parent */ printf("the parent \n"); wait(NULL); printf("child complete \n"); } printf("main is done\n"); return 0; } Parent ProcessChild Process

32. Main program /home/hayhurst- a.out in the parent program forking a process Child ProcessParent Process the child the parent PID TTY TIME CMD 23373 pts/3 00:00:00 tcsh 23842 pts/3 00:00:00 emacs 23881 pts/3 00:00:00 a.out 23882 pts/3 00:00:00 ps child complete main is done

33. Process Destruction  The destruction of a process may be invoked by a “destroy_process” system call either by the process itself or by another process. The need to terminate a process can occur for many reasons: The process itself has requested normal termination A nonrecoverable error has occurred in the process execution An operator command has terminated the process A parent process has terminated (either normally or abnormally) An authorized process has requested termination.  Destruction involves the following steps: Remove PCB from its current state queue, and other queues it may be linked to. Destroy or reassign child processes Free allocated memory and other resources Free the PCB