1 Process Description and Control Chapter 2. 2 Process A program in execution An instance of a program running on a computer The entity that can be assigned

1

Process Description and Control

Chapter 2

2

Process 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 instructions

3

Process Management

A process is a program in execution. It is a unit of work within the system. Program is a passive entity, process is an active entity.

Process needs resources to accomplish its task CPU, memory, I/O, files Initialization data

Process termination requires reclaim of any reusable resources

4

Process Management

Single-threaded process has one program counter specifying location of next instruction to execute Process executes instructions sequentially, one at a

time, until completion Multi-threaded process has one program

counter per thread Typically system has many processes, some

user, some operating system running concurrently on one or more CPUs Concurrency by multiplexing the CPUs among the

processes / threads

5

Process Elements Identifier State Priority Program counter Memory pointers Context data I/O status information Accounting information

6

Process Elements Identifier – unique to the process

State – executing/running or not running

Priority – relative to other processes

Program counter – address of next instruction in the process

Memory pointers – to program code and data

Context data – data in the registers while process is executing

I/O status information – outstanding I/O requests, I/O devices assigned to the process, files used.

Accounting information – amount of processor time & clock time used, time limits, account numbers, etc.

7

Process Control Block Contains the process elements Created and managed by the operating

system Allows support for multiple processes

8

Process Control Block

9

Trace of Process Sequence of instruction that execute for a

process Dispatcher switches the processor from

one process to another

10

Example Execution

11

Trace of Processes

I/O operation

5000 = starting address of program of Process A, with 12 instructions8000 = starting address of program of Process B, with 4 instructions, then perform I/O operation12000 = starting address of program of Process C, with 12 instructions

12

Assume OS only allows execution of 6 instructions before interrupt

Dispatcher

Dispatcher

Dispatcher

Dispatcher

5000 = starting address of dispatcher program, with 6 instructions

13

CPU Switch From Process to Process

14

Context Switch

When CPU switches to another process, the system must save the state of the old process and load the saved state for the new process

Context-switch time is overhead; the system does no useful work while switching

Time dependent on hardware support

15

Change of Process State Save context of processor including program

counter and other registers Update the process control block of the

process that is currently in the Running state Move process control block to appropriate

queue – ready; blocked; ready/suspend Select another process for execution Update the process control block of the

process selected Update memory-management data structures Restore context of the selected process

16

When to Switch a Process

Clock interruptprocess has executed for the maximum

allowable time slice I/O interrupt Memory fault

memory address is in virtual memory so it must be brought into main memory

17

When to Switch a Process

Traperror or exception occurredmay cause process to be moved to Exit state

Supervisor callsuch as file open

18

Two-State Process Model

Process may be in one of two states Running Not-running

19

Not-Running Process in a Queue

20

Processes

Not-runningReady to executeBlocked - waiting for I/O

Dispatcher cannot just select the process that has been in the queue the longest because it may be blocked

21

A Five-State Model

Running Ready Blocked New Exit

Not-running

22

A Five-State Model

Running – currently executing Ready – prepared to execute Blocked – cannot execute until some event

occurs, e.g. I/O operation New – just created, typically not loaded into MM Exit – released from the pool of executable

processes, either halt (completed) or aborted.

23

Five-State Process Model

24

Five State Model Transition

NULL----NEW: A new process is created due to any of the four reasons described in the creation of processes (New batch Job, Interactive logon, To provide service & Spawning).

NEW-----READY: Operating system moves a process from new state to ready state, when it is prepared to accept an additional process. There could be limit on number of processes to be admitted to the ready state.

READY---RUNNING: Any process can be moved from ready to running state when ever it is scheduled.

25


RUNNING----EXIT: The currently running process is terminated if it has signaled its completion or it is aborted.

RUNNING----READY:

The most commonly known situation is that currently running process has taken its share of time for execution (Time out). Also, in some events a process may have to be admitted from running to ready if a high priority process has occurred.

26


RUNNING----BLOCKED:

A process is moved to the blocked state, if it has requested some data for which it may have to wait. For example the process may have requested a resource such as data file or shared data from virtual memory, which is not ready at that time.

BLOCKED---READY:

A process is moved to the ready state, if the event for which it is waiting has occurred.

27

Five State Model TransitionThere are two more transition but are not shown for clarity.

READY----EXIT:

This is the case for example a parent process has generated a single or multiple children processes & they are in the ready state. Now during the execution of the process it may terminate any child process, therefore, it will directly go to exit state.

BLOCKED----EXIT:

Similarly as above, during the execution of a parent process any child process waiting for an event to occur may directly go to exit if the parent itself terminates.

28

Process States

29

Using Two Queues

30

Multiple Blocked Queues

31

Ready Queue And Various I/O Device Queues

32

Suspended Processes

Processor is faster than I/O so all processes could be waiting for I/O

Swap these processes to disk to free up more memory

Blocked state becomes suspend state when swapped to disk

Two new states Blocked/Suspend Ready/Suspend

33

One Suspend State

34

Reasons for Process Suspension

35

Processes and Resources

36

OS Control Structures Information about the current status of

each process and resource Tables are constructed for each entity

the operating system managesMemory tables I/O tablesFile tablesProcess tables

37

OS Control Structures

38

Memory Tables

Includes: Allocation of main memory to processes Allocation of secondary memory to

processes Protection attributes for access to shared

memory regions Information needed to manage virtual

memory

39

I/O Tables

I/O device is available or assigned Status of I/O operation Location in main memory being used as

the source or destination of the I/O transfer

40

File Tables

Existence of files Location on secondary memory Current Status Attributes Sometimes this information is maintained

by a file management system

41

Process Table

Where process is located Attributes in the process control block

ProgramDataStack

42

Process Image (in Memory)Contains temporary data (function var, return address, local var)

(optional) Memory dynamically allocated during process runtime

Contains global var

Program code

43

Process Image

44

Process Control Block Process identification

Identifiers Numeric identifiers that may be stored with the

process control block include Identifier of this process Identifier of the process that created this process (parent

process) User identifier

45

Process Control Block Processor State Information

User-Visible Registers A user-visible register is one that may be

referenced by means of the machine language that the processor executes while in user mode. Typically, there are from 8 to 32 of these registers, although some RISC implementations have over 100.

46


Control and Status RegistersThese are a variety of processor registers that are employed to control the operation of the processor. These include

Program counter: Contains the address of the next instruction to be fetched

Condition codes: Result of the most recent arithmetic or logical operation (e.g., sign, zero, carry, equal, overflow)

Status information: Includes interrupt enabled/disabled flags, execution mode

47


Stack Pointers Each process has one or more last-in-first-out

(LIFO) system stacks associated with it. A stack is used to store parameters and calling addresses for procedure and system calls. The stack pointer points to the top of the stack.

48

Process Control Block Process Control Information

Scheduling and State InformationThis is information that is needed by the operating system

to perform its scheduling function. Typical items of information:Process state: defines the readiness of the process to be scheduled for execution (e.g., running, ready, waiting, halted).Priority: One or more fields may be used to describe the scheduling priority of the process. In some systems, several values are required (e.g., default, current, highest-allowable)Scheduling-related information: This will depend on the scheduling algorithm used. Examples are the amount of time that the process has been waiting and the amount of time that the process executed the last time it was running.Event: Identity of event the process is awaiting before it can be resumed

49


Data Structuring A process may be linked to other process in a

queue, ring, or some other structure. For example, all processes in a waiting state for a particular priority level may be linked in a queue. A process may exhibit a parent-child (creator-created) relationship with another process. The process control block may contain pointers to other processes to support these structures.

50


Interprocess Communication Various flags, signals, and messages may be associated

with communication between two independent processes. Some or all of this information may be maintained in the process control block.

Process Privileges Processes are granted privileges in terms of the memory that

may be accessed and the types of instructions that may be executed. In addition, privileges may apply to the use of system utilities and services.

51


Memory Management This section may include pointers to segment and/or

page tables that describe the virtual memory assigned to this process.

Resource Ownership and Utilization Resources controlled by the process may be indicated,

such as opened files. A history of utilization of the processor or other resources may also be included; this information may be needed by the scheduler.

52

Processor State Information

Contents of processor registersUser-visible registersControl and status registersStack pointers

Program status word (PSW)contains status informationExample: the EFLAGS register on Pentium

machines

53

Process Creation Assign a unique process identifier Allocate space for the process Initialize process control block Set up appropriate linkages

Ex: add new process to linked list used for scheduling queue

Create or expand other data structuresEx: maintain an accounting file

54

Process Creation

55

Process Creation Parent process create children processes,

which, in turn create other processes, forming a tree of processes

Resource sharing Parent and children share all resources Children share subset of parent’s resources Parent and child share no resources

Execution Parent and children execute concurrently Parent waits until children terminate

56

Process Termination Process executes last statement and asks the operating

system to delete it (exit) Process’ resources are deallocated by operating system

Parent may terminate execution of children processes (abort) Child has exceeded allocated resources Task assigned to child is no longer required If parent is exiting

Some operating system do not allow child to continue if its parent terminates

All children terminated - cascading termination

57

Process Termination

Reasons for process termination

58Reasons for process termination

Process Termination

59

Cooperating Processes

Independent process cannot affect or be affected by the execution of another process

Cooperating process can affect or be affected by the execution of another process

Advantages of process cooperation Information sharing Computation speed-up Modularity Convenience

60

Interprocess Communication (IPC)

Mechanism for processes to communicate and to synchronize their actions

Message system – processes communicate with each other without resorting to shared variables

IPC facility provides two operations: send(message) – message size fixed or variable receive(message)

If P and Q wish to communicate, they need to: establish a communication link between them exchange messages via send/receive

Implementation of communication link physical (e.g., shared memory, hardware bus) logical (e.g., logical properties)

61

Direct Communication Processes must name each other explicitly:

send (P, message) – send a message to process P

receive(Q, message) – receive a message from process Q

Properties of communication link Links are established automatically A link is associated with exactly one pair of

communicating processes Between each pair there exists exactly one link The link may be unidirectional, but is usually bi-

directional

62

Indirect Communication Messages are directed and received from

mailboxes (also referred to as ports) Each mailbox has a unique id Processes can communicate only if they share a

mailbox

Properties of communication link Link established only if processes share a common

mailbox A link may be associated with many processes Each pair of processes may share several comm. links Link may be unidirectional or bi-directional

63

Indirect Communication Operations

create a new mailbox send and receive messages through mailbox destroy a mailbox

Primitives are defined as:

send(A, message) – send a message to mailbox A

receive(A, message) – receive a message from mailbox A

64

Indirect Communication Mailbox sharing

P1, P2, and P3 share mailbox A

P1, sends; P2 and P3 receive

Who gets the message?

Solutions Allow a link to be associated with at most two

processes Allow only one process at a time to execute a

receive operation Allow the system to select arbitrarily the receiver.

Sender is notified who the receiver was.

65

Synchronization Message passing may be either blocking or

non-blocking Blocking is considered synchronous

Blocking send has the sender block until the message is received

Blocking receive has the receiver block until a message is available

Non-blocking is considered asynchronous Non-blocking send has the sender send the

message and continue Non-blocking receive has the receiver receive a

valid message or null

66

Threads Concept of process – two characteristics:

Resource ownershipScheduling/execution

67

Threads Resource ownership - process includes a virtual

address space to hold the process image Scheduling/execution- follows an execution path

that may be interleaved with other processes These two characteristics are treated

independently by the operating system Dispatching is referred to as a thread or

lightweight process Resource ownership is referred to as a process

or task

68

Multithreading Operating system supports multiple threads of

execution within a single process MS-DOS supports a single thread UNIX supports multiple user processes but only

supports one thread per process Windows, Solaris, Linux, Mach, and OS/2

support multiple threads

69

70

Process

Have a virtual address space which holds the process image

Protected access to processors, other processes, files, and I/O resources

71

Thread An execution state (running, ready, etc.) Saved thread context when not running Has an execution stack Some per-thread static storage for local

variables Access to the memory and resources of its

process all threads of a process share this

72

73

Benefits of Threads

Takes less time to create a new thread than a process

Less time to terminate a thread than a process Less time to switch between two threads within

the same process Since threads within the same process share

memory and files, they can communicate with each other without invoking the kernel

74

Uses of Threads in a Single-User Multiprocessing System

Foreground to background work E.g: A spreadsheet program:

one thread display menus and read user input while another thread executes user commands and

updates the spreadsheet

Asynchronous processing E.g: protection against power failure:

One thread writes the RAM buffer to disk every minute – for periodic backup and schedules itself directly with the OS

75

Uses of Threads in a Single-User Multiprocessing System

Speed of execution Compute one batch of data while reading the next batch from a

device On multiprocessor system, multiple threads may execute

simultaneously. Thus, if one thread is blocked for an I/O, another thread may be executing.

Modular program structure Easier to design and implement (using threads) programs

involving a variety of activities or a variety of sources/destinations of I/O.

76

Threads

Suspending a process involves suspending all threads of the process since all threads share the same address space

Termination of a process, terminates all threads within the process

77

Thread States

States associated with a change in thread stateSpawn

Spawn another thread

BlockUnblockFinish

Deallocate register context and stacks

78

Example: Remote Procedure Call Using Single Thread Assume a program needs to make 2

RPCs to 2 different hosts to get the combined results.

Using single thread:The result is obtained in sequenceThe program has to wait for response from

each host/server in turn.

79

Remote Procedure Call Using Single Thread

80

Remote Procedure Call Using Two Threads

81

Multithreading

82

User-Level Threads All thread management is done by the application The kernel is not aware of the existence of threads

83

User-Level Threads

Threads library contains codes for:creating and destroying threadspassing messages and data between threadsscheduling thread executionsaving and restoring thread context

84

Kernel-Level Threads Windows is an example of this approach Kernel maintains context information for the

process and the threads Scheduling is done on a thread basis

85

User-Level Threads Advantages:

Thread switching do not require mode switching less overhead

Thread scheduling is application specific, without disturbing the underlying OS scheduler

ULTs can run on any OS, need no change to the underlying kernel to support ULT – use threads library

Disadvantages: If one thread blocks, the whole process blocks Cannot take advantage of multiprocessing – 1

process to 1 processor at a time, i.e. only 1 thread running at a time

86

Kernel-Level ThreadsThis approach overcome the two principal

drawbacks of ULT approach The kernel can simultaneously schedule

threads on different processors If one thread of a process is blocked it can

schedule another thread of the same process

The disadvantage is Transfer of control from one thread to

another thread within the same process requires mode switching

87

Combined Approaches Example is Solaris Thread creation done in the user space Bulk of scheduling and synchronization of threads

within application

88

Combined Approaches -Adv

Multiple threads within the same application can run concurrently on a number of processors.

Blocking system calls need not block theentire process.

89

Relationship Between Threads and Processes

Documents

1 Process Description and Control Chapter 2. 2 Process A program in execution An instance of a program running on a computer The entity that can be assigned