PROCESS MANAGMENT 1 Processes and Process Control Blocks

PROCESS MANAGMENT 1

Processes and Process Control Blocks �Process can be defined as the followings: ØA program in execution Ø An instance of a program running on a computer. Ø The entity that can be assigned to and executed on a processor. ØA unit of activity characterized by the execution of a sequence of instructions, a current state, and an associated set of system resources. 2

Process… �A batch system executes jobs, whereas a timeshared system has user programs, or tasks. � Even on a single-user system, such as Microsoft Windows and Macintosh OS, a user may be able to run several programs at one time: a word processor, web browser, and email package. 3

Process… �Even if the user can execute only one program at a time, the operating system may need to support its own internal programmed activities, such as memory management. 4

Process… OS can manage the execution of applications so that: �Resources are made available to multiple applications. �The physical processor is switched among multiple applications so all will appear to be progressing. �The processor and I/O devices can be used efficiently. 5

Process… �Two essential elements of a process are program code(which may be shared with other processes that are executing the same program) and a set of data associated with that code. �At any given point in time, while the program is executing, this process can be uniquely characterized by a number of elements, including the following: 6

Process… The information in the list is stored in a data structure, typically called a process control block (PCB), that is created and managed by the OS and uniquely identifies a process. 7

Process… �Accounting information: This information includes the amount of CPU and real time used, time limits, account numbers, job or process numbers, and so on. �status information: The information includes the list of I/O devices allocated to this process, a list of open files(Active files) , and so on. 8

Process… �The process control block is the key tool that enables the OS to support multiple processes and to provide for multiprocessing. �When a process is interrupted, the current values of the program counter and the processor registers (context data) are saved in the appropriate fields of the corresponding process control block, and the state of the process is changed to some other value, such as blocked or ready. 9

Process States �We can characterize the behavior of an individual process by listing the sequence of instructions that execute for that process. � Such a listing is referred to as a trace of the process. �We can characterize behavior of the processor by showing how the traces of the various processes are interleaved. �A small dispatcher program is used to switch the processor from one process to another. 10

A two state process model � The operating system’s principal responsibility is controlling the execution of processes; this includes determining the interleaving pattern for execution and allocating resources to processes. 11

Process States … The Creation and Termination of Processes �When a new process is to be added to those currently being managed, the OS builds the data structures that are used to manage the process and allocates address space in main memory to the process. �When one process spawns another, the former is referred to as the parent process, and the spawned process is referred to as the child process. 12

Process States … �Reasons for job creation 13

Process States … � Any computer system must provide a means for a process to indicate its completion. � A batch job should include a Halt instruction or an explicit OS service call for termination. � In the former case, the Halt instruction will generate an interrupt to alert the OS that a process has completed. � For an interactive application, the action of the user will indicate when the process is completed. � On a personal computer or workstation, a user may quit an application (e. g. , word processing or spreadsheet). � All of these actions ultimately result in a service request to the OS to terminate the requesting process. 14

A five state model �Five state process model 15

Process States … �Running: The process that is currently being executed � Ready: A process that is prepared to execute when given the opportunity. �Blocked/Waiting: A process that cannot execute until some event occurs, such as the completion of an I/O operation. 16

Process States … �New: A process that has just been created but has not yet been admitted to the pool of executable processes by the OS. Typically, a new process has not yet been loaded into main memory, although its process control block has been created. �Terminated: A process that has been released from the pool of executable processes by the OS, either because it halted or because it aborted for some reason. 17

Process States… q The new process will terminate, usually due to one of the following conditions: 1. Normal exit (voluntary). 2. Error exit (voluntary). 3. Fatal error (involuntary). 4. Killed by another process(involuntary). 18

Process States … 19

Process States… � Process can be executed in one of the following modes: ØUser mode ØKernel mode � Considerations of memory protection and privileged instructions lead to the concept of modes of operation. � A user program executes in a user mode, in which certain areas of memory are protected from the user’s use and in which certain instructions may not be executed. � The monitor executes in a system mode, or called kernel mode, in which privileged instructions may be executed and in which protected areas of memory may be accessed. 20

OS Control Structures � If the OS is to manage processes and resources, it must have information about the current status of each process and resource. � Although the details will differ from one OS to another, fundamentally, all operating systems maintain information in these four categories. v. Memory tables v. I/O tables v. File tables and v. Process tables 21

OS Control… � To manage and control a process the OS must know first where the process is located; second, it must know the attributes of the process that are necessary for its management (e. g. , process ID and process state). � A process includes a set of programs to be executed, data, stack, and attributes. We can refer to this collection as the process image. 22

Process/context Switching At some time, a running process is interrupted and the OS assigns another process to the Running state and turns control over to that process. � A process switch may occur any time that the OS has gained control from the currently running process. � 23

Process/context Switching � First, let us consider system interrupts. � Actually, we can distinguish, as many systems do, two kinds of system interrupts, one of which is simply referred to as an interrupt, and the other as a trap. � The former is due to some sort of event that is external to and independent of the currently running process, such as the completion of an I/O operation. � The latter relates to an error or exception condition generated within the currently running process, such as an illegal file access attempt. 24

Cooperating Processes � The concurrent processes executing in the operating system may be either independent processes or cooperating processes. � A process is independent if it cannot affect or be affected by the other processes executing in the system. � Clearly, any process that does not share any data (temporary or persistent) with any other process is independent. � On the other hand, a process is cooperating if it can affect or be affected by the other processes executing in the system. � Clearly, any process that shares data with other processes is a cooperating process. 25

Cooperating Processes… We may want to provide an environment that allows process cooperation for several reasons: � Information sharing: Since several users may be interested in the same piece of information(for instance, a shared file), we must provide an environment to allow concurrent access to these types of resources. � Computation speedup: If we want a particular task to run faster, we must break it into subtasks, each of which will be executing in parallel with the others. Such a speedup can be achieved only if the computer has multiple processing elements (such as CPU or I/O channels). 26

Cooperating Processes… �Modularity: We may want to construct the system in a modular fashion, dividing the system functions into separate processes or threads. �Convenience: Even an individual user may have many tasks on which to work at one time. For instance, a user may be editing, printing, and compiling in parallel. 27

Cooperating Processes… � To illustrate the concept of cooperating processes, let us consider the producer-consumer problem, which is a common paradigm for cooperating processes. � A producer process produces information that is consumed by a consumer process. � For example, a print program produces characters that are consumed by the printer driver. � A compiler may produce assembly code, which is consumed by an assembler. The assembler, in turn, may produce object modules, which are consumed by the loader. 28

Threads The concept of a process as embodying two characteristics: � Resource ownership: A process includes a virtual address space to hold the process image; recall that the process image is the collection of program, data, stack, and attributes defined in the process control block. From time to time, a process may be allocated control or ownership of resources. The OS performs a protection function to prevent unwanted interference between processes with respect to resources. � Scheduling/execution: The execution of a process follows an execution path(trace) through one or more programs. This execution may be interleaved with that of other processes. � Thus, a process has an execution state and a dispatching priority and is the entity that is scheduled and dispatched by the OS. 29

Threads… �These two characteristics are independent and could be treated independently by the OS. �To distinguish the two characteristics, the unit of dispatching is usually referred to as a thread or lightweight process, while the unit of resource ownership is usually still referred to as a process or task. 30

Threads… � Processes do not share resources well q high context switching overhead � Idea: Separate concurrency from protection � Multithreading: a single program made up of a number of different concurrent activities � A thread (or lightweight process) q basic unit of CPU utilization; it consists of: program counter, register set and stack space q A thread shares the following with peer threads: code section, data section and OS resources (open files, signals) q. No protection between threads q. Collectively called a task. � Heavyweight process is a task with one thread. 31

Threads… 32

Threads… 1. 2. 3. Benefits of Multithreaded programming Responsiveness Resource Sharing Economy: It is much more time consuming to create and manage processes that threads. Eg. In Solaris, creating a process is thirty times slower than creating thread and context switching is five times slower. 4. Utilization of Multiprocessor Architectures 33

Threads… Multithreading �Multithreading refers to the ability of an OS to support multiple, concurrent paths of execution within a single process. �In a multithreaded environment, a process is defined as the unit of resource allocation and a unit of protection. 34

Threads… Thread State �State shared by all threads in process/addr space q Contents of memory (global variables, heap) q I/O state (file system, network connections, etc) �State “private” to each thread q Kept in TCB (Thread Control Block) q CPU registers (including, program counter) q Execution stack q Parameters, Temporary variables q return PCs are kept while called procedures are executing 35

Threads… �Thread context switch still requires a register set switch, but no memory management related work!! �Thread states – q ready, blocked, running, terminated �Threads share CPU and only one thread can run at a time. �No protection among threads. 36

Threads… Types of threads q. Kernel Supported Threads (Mach and OS/2) q. User Level Threads q. Hybrid approach implements both user-level and kernel-supported threads (Solaris 2) 37

Threads… Kernel Threads �Supported by the Kernel 1. v Native threads supported directly by the kernel v Every thread can run or block independently �Downside of kernel threads: a bit expensive v Need to make a crossing into kernel mode to schedule �Examples v Windows XP/2000, Solaris, Linux, Tru 64 UNIX, Mac OS X, Mach, OS/2 38

Threads… 2. User Level Threads � Supported above the kernel, at the user level. via a set of library calls v. Thread management done by user-level threads library § User program provides scheduler and thread package v. May have several user threads per kernel thread v. User threads may be scheduled non-premptively relative to each other (only switch on yield()) � Advantages v. Cheap, Fast v. Threads do not need to call OS and cause interrupts to kernel � Disadv: If kernel is single threaded, system call from any thread can block the entire task. � Example thread libraries: v POSIX Pthreads, Win 32 threads, Java threads 39

Threads… Multithreading Models �There are three common ways of establishing relationship between user threads and kernel threads v. Many – to – one v. One – to – one v. Many – to – many 40

Threads… 1. � Many – to – one model Maps many user level threads to one kernel thread • Efficient • The entire process may block if a thread make a blocking system call • Examples: üSolaris Green Threads üGNU Portable Threads 41

Threads… 2. One – to – One model � Each user thread maps to a kernel thread � Creating kernel threads for each user can burden the performance of an application: Most OS limit the number of threads Example: � ü Windows NT/XP/2000; Linux; Solaris 9 and later 42

Threads… 3. Many – to – Many Model � Allows many user level threads to be mapped to many kernel threads � Allows the OS to create a sufficient number of kernel threads ü Solaris prior to version 9 ü Windows NT/2000 with the Thread. Fiber package 43

Interprocess Communication (IPC) � Separate address space isolates processes • High Creation/Memory Overhead; (Relatively) High Context-Switch Overhead � Mechanism for processes to communicate and synchronize actions. �Via shared memory - Accomplished by mapping addresses to common DRAM �Read and Write through memory �Via Messaging system - processes communicate without resorting to shared variables. �send() and receive() messages �Can be used over the network! �Messaging system and shared memory not mutually exclusive can be used simultaneously within a single OS or a single process. 44

Shared Memory Communicatrion � Communication occurs by “simply” reading/writing to shared address page v. Really low overhead communication v. Introduces complex synchronization problems 45

Cooperating Processes via Message Passing �IPC facility provides two operations. send (message) - message size can be fixed or variable receive (message) �If processes P and Q wish to communicate, need to: they �establish a communication link between them �exchange messages via send/receive �Fixed vs. Variable size message �Fixed message size – straightforward physical implementation, programming task is difficult due to fragmentation �Variable message size - simpler programming, more complex physical implementation. 46

Direct Communication �Sender and Receiver processes must name each other explicitly: q send(P, message) - send a message to process P q receive(Q, message) - receive a message from process Q �Properties of communication link: q Links are established automatically. q A link is associated with exactly one pair of communicating processes. q Exactly one link between each pair. q Link may be unidirectional, usually bidirectional. 47

Indirect Communication �Messages are directed to and received from mailboxes (also called ports) q Unique ID for every mailbox. q Processes can communicate only if they share a mailbox. send(A, message) /* send message to mailbox A */ receive(A, message) /* receive message from mailbox A */ �Properties of communication link q Link established only if processes share a common mailbox. q Link can be associated with many processes. q Pair of processes may share several communication links q Links may be unidirectional or bidirectional 48

Indirect Communication using Mailboxes 49

Mailbox … � Operations qcreate a new mailbox qsend/receive messages through mailbox qdestroy a mailbox � Issue: Mailbox sharing q. P 1, P 2 and P 3 share mailbox A. q. P 1 sends message, P 2 and P 3 receive… who gets message? ? � Possible Solutions qdisallow links between more than 2 processes qallow only one process at a time to execute receive operation qallow system to arbitrarily select receiver and then notify sender. 50

Message Buffering � Link has some capacity - determine the number of messages that can reside temporarily in it. � Queue of messages attached to link q. Zero-capacity Queues: 0 messages § sender waits for receiver (synchronization is called rendezvous) q. Bounded capacity Queues: Finite length of n messages § sender waits if link is full q. Unbounded capacity Queues: Infinite queue length § sender never waits 51

Message Problems - Exception Conditions �Lost Messages • OS guarantees retransmission • sender is responsible for detecting it using timeouts • sender gets an exception �Scrambled Messages • Message arrives from sender P to receiver Q, but information in message is corrupted due to noise in communication channel. • Solution �need error detection mechanism, e. g. CHECKSUM �need error correction mechanism, e. g. retransmission 52

Producer-Consumer Problem �Paradigm for cooperating processes; • producer process produces information that is consumed by a consumer process. �We need buffer of items that can be filled by producer and emptied by consumer. �Unbounded-buffer places no practical limit on the size of the buffer. Consumer may wait, producer never waits. �Bounded-buffer assumes that there is a fixed buffer size. Consumer waits for new item, producer waits if buffer is full. �Producer and Consumer must synchronize. 53

Bounded Buffer using messaging � Producer repeat … produce an item in nextp; … send(consumer, nextp); until false; � Consumer repeat receive(producer, nextc); … consume item from nextc; … until false; 54

Bounded-buffer - Shared Memory Solution �Shared data var n; type item = …. ; var buffer: array[0. . n-1] of item; in, out: 0. . n-1; in =0; out= 0; /* shared buffer = circular array */ /* Buffer empty if in == out */ /* Buffer full if (in+1) mod n == out */ /* noop means “do nothing” */ 55

Bounded Buffer - Shared Memory Solution �Producer process - creates filled buffers repeat … produce an item in nextp … while (( in+1) mod n = = out) do noop; buffer[in] = nextp; in= (in+1 )mod n; until false; 56

Bounded Buffer - Shared Memory Solution �Consumer process - Empties filled buffers repeat while (in = =out) do noop; nextc = buffer[out] ; out= out+1 mod n; … consume the next item in nextc … until false 57