process management
Download
Skip this Video
Download Presentation
Process management

Loading in 2 Seconds...

play fullscreen
1 / 20

Process management - PowerPoint PPT Presentation


  • 211 Views
  • Uploaded on

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.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Process management' - Mia_John


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
process management

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

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
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.
      • This is known as User level context.

heap

data

text (code)

0

Process in memory

user level context
User level context

MAX

(b, *p) - main

(a) - foo

stack

int aa;

char buf[1000];

void foo() {

int a;

}

main() {

int b;

char *p;

p = new char[1000];

foo();

}

heap (p)

(char[1000])

data (aa, buf)

text (code)

0

Process memory

process context1
Process context

P1

P2

  • Contains all states necessary to run a program
    • Is the user level context sufficient?
      • Only if the system runs through one program at a time
      • The system typically needs to switch back and forth between programs.

R0 = 1

R0 = 2

R2 = R0 + 1

R2 = R0

  • 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!
slide6
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
Why is process context important?
  • To run a process correctly, the process instructions must be executed within the process context!
slide8
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
      • ……
slide9

An example PCB

Figure 3.3

os cpu abstraction
OS CPU abstraction
  • Hardware reality:
    • One CPU runs the fetch-execute algorithm
  • OS abstraction:
    • Each process has one CPU, running the fetch-execute algorithm for the process.
    • Each process executes within its context.

Load PC;

IR = MEM[PC];

While (IR != HALT) {

PC ++;

Execute IR;

IR = MEM[PC];

}

os cpu abstraction1
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 process’s context to be correct.
os cpu abstraction2
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 X’s context], [restore Y’s context] y0, y1, y2…

OS must do this to keep programs execute

within its context: Context switching

dispatching loop

Context

Switch:

Dispatcher

code

Scheduling

Dispatching Loop
  • The hardware view of the system execution: dispatching loop
    • LOOP
      • Run process
      • Save process states
      • Choose a new process to run
      • Load states for the chosen process
simple not quite
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
How Does the Dispatcher Regain Control?
  • Two ways:
    • Internal events
      • A process is waiting for I/O
      • A process is waiting for some other process
      • Yield—a process gives up CPU voluntarily
    • External events
      • Interrupts—a complete disk request
      • Timer—it’s like an alarm clock
what states should a process save
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
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
Process States
  • A process is typically in one of the three states
    • Running: has the CPU
    • Blocked: waiting for I/O or another thread
    • Ready to run: on the ready list, waiting for the CPU
ad