Chapter 3 Processes

1. Chapter 3 Processes

2. Processes • Early computers allowed only one program to be executed at a time • This program had complete control of the system and had access to all the system’s resources • Contemporary computer systems allow multiple programs • To be loaded into memory and executed concurrently • Required firmer control and more compartmentalization of the various programs • Resulted in the notion of a process • i.e., A program in execution • The unit of work in a modern time-sharing system

3. Processes (cont.) • The main concern of an OS is the execution of user programs • Also needs to take care of various system tasks that are better left outside the kernel itself • A system consists of a collection of processes • Operating-system processes executing system code • User processes executing user code • All these processes can execute concurrently • With the CPU multiplexed among processes • The operating system can make the computer more productive

4. Process Concept • A batch system executes jobs • A time-shared system has user programs • Even on a single-user system, a user may be able to run several programs at one time • A word processor, a Web browser, and an e-mail package • Even if a user can execute only one program at a time on an embedded device that does not support multitasking • The OS may need to support its own internal programmed activities, like memory management • All these activities are similar in many respects • All of them are called processes

5. The Process • A process is a program in execution • A process is more than the program code • The code is sometimes known as the text section • Also includes the current activity, as represented by the value of the program counter • The contents of the processor’s registers • Generally also includes the process stack • Contains temporary data such as function parameters, return addresses, and local variables • And a data section containing global variables • May also include a heap • Memory dynamically allocated during process run time • The structure of a process in memory

6. The Process (cont.) • A program by itself is not a process • Only a passive entity • e.g., A file containing a list of instructions stored on disk, often called an executable file

7. The Process (cont.) • A process is an active entity • With a program counter specifying the next instruction to execute • And a set of associated resources • A program becomes a process when an executable file is loaded into memory • Double-clicking an icon denoting the executable file • Entering the name of the executable file on the command line as in prog.exe or a.out • Two processes may be associated with the same program • Considered two separate execution sequences

8. The Process (cont.) • Several users may be running different copies of the mail program • Or the same user may invoke many copies of the web browser program • Each of these is a separate process • The text sections are equivalent • The data, heap, and stack sections vary • Also common to have a process that spawns many processes as it runs • A process itself can be an execution environment for other code • The Java programming environment • In most circumstances, an executable Java program is executed within the Java virtual machine (JVM)

9. The Process (cont.) • The JVM executes as a process that interprets the loaded Java code • Takes actions via native machine instructions on behalf of that code • e.g., To run the compiled Java program Program.class java Program • The command java runs the JVM as an ordinary process • In turns executes the Java program Program in the virtual machine • The concept is the same as simulation • The code is not written for a different instruction set • It is written in the Java language

10. Process State • As a process executes, it changes state • The state of a process is defined in part by the current activity of that process • May be in one of the following states • New: The process is being created • Running: Instructions are being executed • Waiting: The process is waiting for some event to occur, like an I/O completion or reception of a signal • Ready: The process is waiting to be assigned to a processor • Terminated: The process has finished execution • These names vary across operating systems • The above states are found on all systems • Certain OSes also more finely delineate process states

11. Process State (cont.) • Only one process can be running on any processor at any instant • Many processes may be ready and waiting • The state diagram of these states

12. Process Control Block • Each process is represented in the OS by a process control block (PCB) • Also called a task control block

13. Process Control Block (cont.) • A PCB contains many pieces of information associated with a specific process • Process state • May be new, ready, running, waiting, halted, etc. • Program counter • Indicates the address of the next instruction to be executed for this process • CPU registers • Vary in number and type, depending on the computer architecture • Accumulators, index registers, stack pointers, and general-purpose registers, plus any condition-code information

14. Process Control Block (cont.) • Along with the program counter, this state information must be saved when an interrupt occurs to allow the process to be continued correctly afterward • CPU-scheduling information • Includes a process priority, pointers to scheduling queues, and any other scheduling parameters • Memory-management information • May include items like the value of the base and limit registers and the page tables, or the segment tables • Depending on the memory system used by the operating system • Accounting information • Includes the amount of CPU and real time used, time limits, account numbers, job or process numbers, etc.

15. Process Control Block (cont.) • I/O status information • Includes the list of I/O devices allocated to the process, a list of open files, and so on • The PCB simply serves as the repository • For any information that may vary from process to process

16. Process Control Block (cont.)

17. PROCESS REPRESENTATION IN LINUX • The process control block in the Linux operating system • Represented by the C structure task_struct • Found in the <linux/sched.h> include file in the kernel source-code directory • Contains all the necessary information for representing a process • Including the state of the process, scheduling and memory-management information, list of open files • Pointers to the process’s parent and a list of its children and siblings • A process’s parent is the process that created it • Its children are any processes that it creates • Its siblings are children with the same parent process

18. PROCESS REPRESENTATION IN LINUX (cont.) long state; /* state of the process */ struct sched_entity se; /* scheduling information */ struct task_struct *parent; /* this process’s parent */ struct list_head children; /* this process’s children */ struct files_struct *files; /* list of open files */ struct mm_struct *mm; /* address space of this process */ • e.g., The state of a process is represented by the field long state in this structure • Within the Linux kernel • All active processes are represented using a doubly linked list of task_struct • The kernel maintains a pointer current to the process currently executing on the system

19. PROCESS REPRESENTATION IN LINUX (cont.) • e.g., The system would like to change the state of the process currently running to the value new state • If current is a pointer to the process currently executing, its state is changed with current->state = new_state;

20. Threads • A process is a program that performs a single thread of execution • e.g., When a process is running a word-processor program, a single thread of instructions is being executed • This single thread of control allows the process to perform only one task at a time • The user cannot simultaneously type in characters and run the spell checker within the same process • Most modern OSes have extended to allow a process to have multiple threads of execution • Thus to perform more than one task at a time

21. Threads (cont.) • Especially beneficial on multicore systems, where multiple threads can run in parallel • The PCB is expanded to include information for each thread • Other changes throughout the system are also needed to support threads

22. Process Scheduling • The objective of multiprogramming is to have some process running at all times • To maximize CPU utilization • The objective of time sharing is to switch the CPU among processes so frequently • Users can interact with each program while it is running • The process scheduler selects an available process for program execution on the CPU • Possibly from a set of several available processes • For a single-processor system, there will never be more than one running process • If there are more processes, the rest will have to wait until the CPU is free and can be rescheduled

23. Scheduling Queues • As processes enter the system • Put into a job queue • Consists of all processes in the system • The processes are residing in main memory and are ready and waiting to execute • Kept on a list called the ready queue • Generally stored as a linked list • A ready-queue header contains pointers to the first and final PCBs in the list • Each PCB includes a pointer field that points to the next PCB in the ready queue • The system also includes other queues

24. Scheduling Queues (cont.) • When a process is allocated the CPU, it executes for a while and eventually quits • Interrupted, or waits for the occurrence of a particular event • e.g., The completion of an I/O request • The process makes an I/O request to a shared device, such as a disk • There are many processes in the system • The disk may be busy with the I/O request of some other process • The process therefore may have to wait for the disk • The list of processes waiting for a particular I/O device is called a device queue • Each device has its own device queue

25. Scheduling Queues (cont.)

26. Scheduling Queues (cont.) • A common representation of process scheduling is a queueing diagram • Each rectangular box represents a queue • Two types of queues are present • The ready queue and a set of device queues • The circles represent the resources that serve the queues • The arrows indicate the flow of processes in the system • A new process is initially put in the ready queue • Waits there until it is selected for execution, or dispatched

27. Scheduling Queues (cont.) • Once the process is allocated the CPU and is executing • The process could issue an I/O request • Then be placed in an I/O queue • The process could create a new child process • Wait for the child’s termination • The process could be removed forcibly from the CPU, as a result of an interrupt • Then be put back in the ready queue • The process eventually switches from the waiting state to the ready state • Then put back in the ready queue

28. Scheduling Queues (cont.) • A process continues this cycle until it terminates • Removed from all queues • Has its PCB and resources deallocated

29. Schedulers • A process migrates among the various scheduling queues throughout its lifetime • The operating system must select processes from these queues in some fashion • For scheduling purposes • The selection is carried out by the proper scheduler • In a batch system • More processes are submitted than can be executed immediately • Spooled to a mass-storage device, typically a disk • Kept for later execution • The long-term scheduler, or job scheduler, selects processes from this pool

30. Schedulers (cont.) • Loads them into memory for execution • The short-term scheduler, or CPU scheduler, selects from among the processes ready to execute • Allocates the CPU to one of them • The primary distinction between these two schedulers lies in frequency of execution • The short-term scheduler must select a new process for the CPU frequently • A process may execute for only a few milliseconds before waiting for an I/O request • The short-term scheduler often executes at least once every 100 milliseconds • The short-term scheduler must be fast

31. Schedulers (cont.) • If the scheduler takes 10 milliseconds to decide to execute a process for 100 milliseconds • 10/(100 + 10) = 9 percent of the CPU is being used, wasted, simply for scheduling the work • The long-term scheduler executes much less frequently • Minutes may separate the creation of one new process and the next • The long-term scheduler controls the degree of multiprogramming • The number of processes in memory • If the degree of multiprogramming is stable

32. Schedulers (cont.) • The average rate of process creation must be equal to the average departure rate of processes leaving • The long-term scheduler may need to be invoked only when a process leaves the system • The long-term scheduler can afford to take more time to decide which process should be selected for execution • The long-term scheduler make a careful selection • Most processes can be described as either I/O bound or CPU bound • An I/O-bound process spends more of its time doing I/O than it spends doing computations

33. Schedulers (cont.) • A CPU-bound process generates I/O requests infrequently, using more of its time doing computations • The long-term scheduler select a good process mix of I/O-bound and CPU-bound processes • If all processes are I/O bound • The ready queue will almost always be empty • The short-term scheduler will have little to do • If all processes are CPU bound • The I/O waiting queue will almost always be empty • Devices will go unused • Again the system will be unbalanced • The system with the best performance will have a combination of CPU- and I/O-bound processes

34. Schedulers (cont.) • On some systems, the long-term scheduler may be absent or minimal • Time-sharing systems like the UNIX system often have no long-term scheduler • Simply put every new process in memory for the short-term scheduler • The stability of these systems depends either on a physical limitation • e.g., The number of available terminals • Or on the self-adjusting nature of human users • If performance declines to unacceptable levels on a multiuser system, some users will simply quit • These systems may introduce an additional, intermediate level of scheduling

35. Schedulers (cont.) • This medium-term scheduler can remove a process from memory • From active contention for the CPU • Reduce the degree of multiprogramming • The process can be reintroduced into memory • The execution can be continued where it left off • This scheme is called swapping • The process is swapped out and later swapped in by the medium-term scheduler • Swapping may be necessary to improve the process mix • Or a change in memory requirements has overcommitted available memory, requiring memory to be freed up

36. Schedulers (cont.)

37. Context Switch • Interrupts cause the OS to change a CPU • From its current task and to run a kernel routine • Happen frequently on general-purpose systems • When an interrupt occurs, the system needs to save the current context of the running process • Can restore that context when its processing is done • Essentially suspending the process and resuming it • The context is represented in the PCB of the process • Includes the value of the CPU registers, the process state and memory-management information

38. Context Switch (cont.) • Switching the CPU to another process requires performing a state save of the current process • Be it in kernel or user mode • Then a state restore of a different process • Known as a context switch • When a contexts witch occurs, the kernel saves the context of the old process in its PCB • Loads the saved context of the new process scheduled to run • Context-switch time is pure overhead • The system does no useful work while switching • Switching speed varies from machine to machine

39. Context Switch (cont.) • Depending on the memory speed, the number of registers that must be copied • And the existence of special instructions, like a single instruction to load or store all registers • A typical speed is a few milliseconds • Context-switch times are highly dependent on hardware support • The more complex the operating system • The greater the amount of work that must be done during a context switch

40. Process Creation • The processes in most systems can execute concurrently • May be created and deleted dynamically • The systems must provide a mechanism for process creation and termination • During the course of execution, a process may create several new processes • The creating process is called a parent process • The new processes are called a children process • Each of these new processes may in turn create other processes • Forming a tree of processes

41. Process Creation (cont.) • Most OSes identify processes according to a unique process identifier or pid • Including UNIX, Linux, and Windows • Typically an integer number • The pid provides a unique value for each process in the system • Can be used as an index to access various attributes of a process within the kernel • A typical process tree for the Linux system • The init process serves as the root parent process for all user processes • Always has a pid of 1

42. Process Creation (cont.) • Once the system has booted, the init process can also create various user processes • e.g., A web or print server, an ssh server, and so on • Two children of init • kthreadd and sshd • The kthreadd process is responsible for creating additional processes • Perform tasks on behalf of the kernel • In this situation, khelper and pdflush • The sshd process is responsible for managing clients that connect to the system • By using ssh, short for secure shell • The login process is responsible for managing clients that directly log onto the system

43. Process Creation (cont.) • A client has logged on and is using the bash shell • Assigned pid 8416 • Using the bash command-line interface • Created the process ps and the emacs editor • On UNIX and Linux systems • Can obtain a listing of processes by using the ps command ps –el • The command will list complete information for all processes currently active in the system • Easy to construct a process tree • by recursively tracing parent processes all the way to the init process

44. Process Creation (cont.)

45. Process Creation (cont.) • When a process creates a child process • The child process will need certain resources to accomplish its task • CPU time, memory, files, I/O devices • A child process may be able to obtain its resources directly from the operating system • Or may be constrained to a subset of the resources of the parent process • The parent may have to partition its resources among its children • Or may be able to share some resources among several of its children • e.g., Memory or files

46. Process Creation (cont.) • Restricting a child process to a subset of the parent’s resources prevents any process from • Overloading the system by creating too many child processes • The parent process may also pass along initialization data to the child process • i.e., Input • Consider a process whose function is to display the contents of a file on the screen of a terminal • When the process is created, it will get the name of the file as an input from its parent process • Using that file name, it will open the file and write the contents out • May also get the name of the output device

47. Process Creation (cont.) • Alternatively, some operating systems pass resources to child processes • The new process may get two open files, the input file and the terminal device • May simply transfer the datum between the two • When a process creates a new process • The parent continues to execute concurrently with its children • Or the parent waits until some or all of its children have terminated • Also two address-space possibilities for the new process

48. Process Creation (cont.) • The child process is a duplicate of the parent • Has the same program and data as the parent • Or the child process has a new program loaded into it • In UNIX, A new process is created by the fork() call • The new process consists of a copy of the address space of the original process • This mechanism allows the parent process to communicate easily with its child process • Both processes continue execution at the instruction after the fork(),with one difference • The return code for the fork() is zero for the child process

49. Process Creation (cont.) • The nonzero pid of the child is returned to the parent • After a fork() system call • One of the two processes typically uses the exec() system call • To replace the process’s memory space with a new program • The exec() system call loads a binary file into memory and starts its execution • Destroying the memory image of the program containing the exec() system call • The two processes are able to communicate and then go their separate ways • The parent can then create more children • Or if it has nothing else to do while the child runs

50. Process Creation (cont.) • Can issue a wait() system call to move itself off the ready queue until the termination of the child • The call to exec() overlays the process’s address space with a new program • The call to exec() does not return control unless an error occurs • The C program for the above UNIX calls • Have two different processes running copies of the same program • The only difference is that the return value pid for the child process is zero • That for the parent is an integer value greater than zero, i.e., the actual pid of the child process