Process management

Information maintained by OS for process

management
process context

process control block

OS virtualization of CPU for each process.

Context switching

Dispatching loop

Process

a program in execution

We should know about processes by now.

How does the OS correctly run multiple processes concurrently?

What kind of information to be kept? What does the OS have to do in order to run processes correctly.

Process context

MAX stack

Contains all states necessary to run a program

The information the process needs to do the job: code, data, stack, heap.

heap

data

This is known as User level context.

0

text (code)

Process in memory

User level contextMAX

int aa; char buf[1000]; void foo() { int a; } main() { int b; char *p; p = new char[1000]; foo(); }

(b, *p) - main

(a) - foo

stack

heap (p) (char[1000]) data (aa, buf)

text (code) 0

Process memory

Process context
P1 P2

Contains all states necessary to run a program

R0 = 1

R0 = 2

Is the user level context sufficient?

R2 = R0 + 1

R2 = R0

Only if the system runs through one program at a time The system typically needs to switch back and forth between programs.

R2 in P1 is wrong. How to make It correct? Save R0 in P1 before switching

Restore R0 in P1 when switching from P2 to P1. Registers should be a part of process context: the register context!

Process context:

User level context

Code, data, stack, heap

Register context (R0, R1,, PC, stack pointer, PSW, etc). What else?

OS resources. E.g open files, signal related data structures, etc.

Why is process context important?

To run a process correctly, the process instructions must be executed within the process context!

Where is the process context stored?

User level context is in memory. Other context information is stored in a data structure called process control block. The OS has a process control block table. For each process, there is one entry in the table. Process control block also contains other information that the OS needs to manage the processes.

Process status (running, waiting, etc) Process priority

An example PCB

Figure 3.3

OS CPU abstraction

Hardware reality:

One CPU runs the fetchexecute algorithm

OS abstraction:

Load PC; IR = MEM[PC]; While (IR != HALT) { PC ++; Execute IR; IR = MEM[PC]; }

Each process has one CPU, running the fetchexecute algorithm for the process. Each process executes within its context.

OS CPU abstraction

What does the OS have to do?

Embed the process instruction sequence into hardware instruction sequence.

Process X instructions: x0, x1, x2, . Process Y instructions: y0, y1, y2, Process Z instructions: z0, z1, z2,

Hardware instructions? x0, x1, x2, y0, y1, y2, z0, z1, z2, x3, x4, x5, Does this embedding work? No!! Instructions in a process should only be executed within the processs context to be correct.

OS CPU abstraction
Process X instructions: x0, x1, x2, . Process Y instructions: y0, y1, y2, Process Z instructions: z0, z1, z2,

x0, x1, x2, [store Xs context], [restore Ys context] y0, y1, y2

OS must do this to keep programs execute within its context: Context switching

Dispatching Loop

The hardware view of the system execution: dispatching loop

LOOP

Context Switch: Dispatcher code

Run process Save process states Choose a new process to run Load states for the chosen process

Scheduling

Simple? Not Quite

How does the dispatcher (OS) regain control after a process starts running? What states should a process save? How does the dispatcher choose the next thread?

How Does the Dispatcher Regain Control?

Two ways:
1.

Internal events

A process is waiting for I/O A process is waiting for some other process Yielda process gives up CPU voluntarily

2.

External events

Interruptsa complete disk request Timerits like an alarm clock

What States Should a process save?

Anything that the next process may trash

Program counter Registers Etc.

How Does the Dispatcher Choose the Next process?

The dispatcher keeps a list of processes that are ready to run If no processes are ready

Dispatcher just loops

Otherwise, the dispatcher uses a scheduling algorithm to find the next process.

Process States

A process is typically in one of the three states

1.

2.

3.

Running: has the CPU Blocked: waiting for I/O or another thread Ready to run: on the ready list, waiting for the CPU

Figure 3.2