processes and threads - university of colorado boulder ...rhan/csci_3753_spring... · multiple...

Operating Systems: A Modern Perspective, Chapter 6

Slide 6-1

Copyright © 2004 Pearson Education, Inc.

Processes and Threads

6


Slide 6-2


Announcements

• Homework Set #2 due Thursday at 11 am• Program Assignment #1 due Thursday Feb.

10 at 11 am– TA will introduce in recitation Wednesday

• Read chapters 6 and 7


Slide 6-3


What is a Process?• A process is a

program actively executing from main memory– has a Program

Counter (PC) and execution state associated with it

• CPU registers keep state

• OS keeps process state in memory

• it’s alive!– has an address space

associated with it• a limited set of

(virtual) addresses that can be accessed by the executing code

Code

Data

MainMemory

ProgramP1

binary CPUExecutionProgram

Counter (PC)

Registers

ALU

Fetch Codeand Data

Write Data

Process

Heap

Stack


Slide 6-4


How is a Process Structured in Memory?

• Run-time memory image

• Essentially code, data, stack, and heap

• Code and data loaded from executable file

• Stack grows downward, heap grows upward

User stack

Heap

Read/write .data, .bss

Read-only .init, .text, .rodata

Unallocated

Run-time memory

address 0

max address


Slide 6-5


Multiple ProcessesMain Memory

Code

Data

ProcessP1

Heap

Stack

Code

Data

ProcessP2

Heap

Stack

• Process state, e.g. ready, running, or waiting

• accounting info, e.g. process ID

• Program Counter

• CPU registers• CPU-

scheduling info, e.g. priority

• Memory management info, e.g. base and limit registers, page tables

• I/O status info, e.g. list of open files

Code

More Data,Heap, Stack

OS

PCB for P2

PCB for P1


Slide 6-6


Multiple ProcessesMain Memory

Code

Data

ProcessP1

Heap

Stack

Code

Data

ProcessP2

Heap

Stack

Code

More Data,Heap, Stack

OS

PCB for P2

PCB for P1

CPUExecution

ProgramCounter (PC)

ALU


Slide 6-7


Context Switching

ProcessManager

InterruptHandler

P1

P2

Pn

Executable Memory

Initialization1

23

45

7Interrupt

8

9

6

• Each time a process is switched out, its context must be saved, e.g. in the PCB

• Each time a process is switched in, its context is restored

• This usually requires copying of registers


Slide 6-8


Threads

• A thread is a logical flow of execution that runs within the context of a process– has its own program counter (PC), register

state, and stack– shares the memory address space with other

threads in the same process,• share the same code and data and resources (e.g.

open files)


Slide 6-9


Threads

• Why would you want multithreaded processes?– reduced context switch overhead

• In Solaris, context switching between processes is 5x slower than switching between threads

– shared resources => less memory consumption => more threads can be supported, especially for a scalable system, e.g. Web server must handle thousands of connections

– inter-thread communication is easier and faster than inter-process communication

– thread also called a lightweight process


Slide 6-10


Threads

• Process P1 is multithreaded

• Process P2 is single threaded

• The OS is multiprogrammed

• If there is preemptive timeslicing, the system is multitasked

Main Memory

CodeData

Process P1’s Address Space

Heap Code

Data

ProcessP2

Heap

Stack

Stack

PC1

Reg.State

Thread 1

Stack

PC2

Reg.State

Thread 2

Stack

PC3

Reg.State

Thread 3


Slide 6-11


Processes &Threads

Add

ress

Spa

ceA

ddre

ss S

pace

MapMap

Stac

k

State

Prog

ram

Stat

ic d

ata

Res

ourc

es

Stac

k

State

MapMap


Slide 6-12


Thread-Safe/Reentrant Code

• If two threads share and execute the same code, then the code needs to be thread-safe– the use of global variables is not thread safe– the use of static variables is not thread safe– the use of local variables is thread safe

• need to govern access to persistent data like global/static variables with locking and synchronization mechanisms

• reentrant is a special case of thread-safe:– reentrant code does not have any references to global

variables– thread-safe code protects and synchronizes access to

global variables


Slide 6-13


User-Space and Kernel Threads

• pthreads is a POSIX user space threading API– provides interface to create, delete threads in the same process– threads will synchronize with each other via this package– no need to involve the OS– implementations of pthreads API differ underneath the API

• Kernel threads are supported by the OS– kernel must be involved in switching threads– mapping of user-level threads to kernel threads is usually one-to-

one


Slide 6-14


Model of Process Execution

ReadyList

ReadyList SchedulerScheduler CPUCPU

ResourceManager

ResourceManager

ResourcesResources

Preemption or voluntary yield

NewProcess

Done

Allocate Request

job

jobjob

jobjob

“Ready”“Running”

“Blocked”


Slide 6-15


The Scheduler

Ready Process

EnqueuerEnqueuer ReadyList

ReadyList

DispatcherDispatcher ContextSwitcherContextSwitcher

ProcessDescriptorProcess

Descriptor

CPUCPU

FromOtherStates

Running Process


Slide 6-16


Invoking the Scheduler

• Need a mechanism to call the scheduler• Voluntary call

– Process blocks itself– Calls the scheduler

• Involuntary call– External force (interrupt) blocks the process– Calls the scheduler


Slide 6-17


Voluntary CPU Sharing

yield(pi.pc, pj.pc) {memory[pi.pc] = PC;PC = memory[pj.pc];

}

• pi can be “automatically” determined from the processor status registers

yield(*, pj.pc) {memory[pi.pc] = PC;PC = memory[pj.pc];

}


Slide 6-18


More on Yield

yield(*, pj.pc);. . .yield(*, pi.pc);. . .yield(*, pj.pc);. . .

• pi and pj can resume one another’s execution

• Suppose pj is the scheduler:// p_i yields to scheduleryield(*, pj.pc);// scheduler chooses pkyield(*, pk.pc);// pk yields to scheduleryield(*, pj.pc);// scheduler chooses ...


Slide 6-19


Voluntary Sharing

• Every process periodically yields to the scheduler• Relies on correct process behavior

– process can fail to yield: infinite loop either intentionally (while(1)) or due to logical error (while(!DONE))

• Malicious• Accidental

– process can yield to soon: unfairness for the “nice” processes who give up the CPU, while others do not

– process can fail to yield in time:• another process urgently needs the CPU to read incoming data

flowing into a bounded buffer, but doesn’t get the CPU in time to prevent the buffer from overflowing and dropping information

• Need a mechanism to override running process


Slide 6-20


Involuntary CPU Sharing

• Interval timer– Device to produce a periodic interrupt– Programmable period

IntervalTimer() {InterruptCount--;if(InterruptCount <= 0) {

InterruptRequest = TRUE;InterruptCount = K;

}}

SetInterval(programmableValue) {K = programmableValue:InterruptCount = K;}

}


Slide 6-21


Involuntary CPU Sharing (cont)

• Interval timer device handler– Keeps an in-memory clock up-to-date (see Chap 4 lab

exercise)– Invokes the scheduler

IntervalTimerHandler() {Time++; // update the clockTimeToSchedule--;if(TimeToSchedule <= 0) {

<invoke scheduler>;TimeToSchedule = TimeSlice;

}}


Slide 6-22


Contemporary Scheduling

• Involuntary CPU sharing – timer interrupts– Time quantum determined by interval timer –

usually fixed size for every process using the system

– Sometimes called the time slice length


Slide 6-23


Choosing a Process to Run

• Mechanism never changes• Strategy = policy the dispatcher uses to

select a process from the ready list• Different policies for different requirements

Ready Process

EnqueueEnqueue ReadyList

ReadyList

DispatchDispatch ContextSwitch

ContextSwitch

ProcessDescriptorProcess

Descriptor

CPUCPU

Running Process


Slide 6-24


Policy Considerations

• Policy can control/influence:– CPU utilization– Average time a process waits for service– Average amount of time to complete a job

• Could strive for any of:– Equitability– Favor very short or long jobs– Meet priority requirements– Meet deadlines


Slide 6-25


Optimal Scheduling• Suppose the scheduler knows each process

pi’s service time, τ(pi) -- or it can estimate each τ(pi) :

• Policy can optimize on any criteria, e.g.,– CPU utilization– Waiting time– Deadline

• To find an optimal schedule:– Have a finite, fixed # of pi– Know τ(pi) for each pi– Enumerate all schedules, then choose the best


Slide 6-26


However ...

• The τ(pi) are almost certainly just estimates• General algorithm to choose optimal

schedule is O(n2)• Other processes may arrive while these

processes are being serviced• Usually, optimal schedule is only a

theoretical benchmark – scheduling policies try to approximate an optimal schedule


Slide 6-27


Talking About Scheduling ...• Let P = {pi | 0 ≤ i < n} = set of processes• Let S(pi) ∈ {running, ready, blocked}• Let τ(pi) = Time process needs to be in

running state (the service time)• Let W(pi) = Time pi is in ready state before

first transition to running (wait time)• Let TTRnd(pi) = Time from pi first enter ready

to last exit ready (turnaround time)• Batch Throughput rate = inverse of avg TTRnd

• Timesharing response time = W(pi)


Slide 6-28


Simplified ModelPreemption or voluntary yield

ReadyList

ReadyList SchedulerScheduler CPUCPU

ResourceManager

ResourceManager

ResourcesResources

Allocate Request

NewProcess job

jobjob

jobjob

“Ready”

Done

“Running”

“Blocked”

• Simplified, but still provide analysis result• Easy to analyze performance• No issue of voluntary/involuntary sharing


Slide 6-29


Estimating CPU Utilization

ReadyList

ReadyList SchedulerScheduler CPUCPUNew

ProcessDone

Let µ = the average service rate∴ 1/ µ = the average τ(pi)

Let λ = the average rate at which processes are placed in the Ready List, arrival rate

Systemλ pi per second

Each pi uses 1/ µ units ofthe CPU


Slide 6-30


Estimating CPU UtilizationReadyList


ProcessDone

Let µ = the average service rate∴ 1/ µ = the average τ(pi)

Let λ = the average rate at which processes are placed in the Ready List, arrival rate

Let ρ = the fraction of the time that the CPU is expected to be busyρ = # pi that arrive per unit time * avg time each spends on CPUρ = λ * 1/ µ = λ/µ

• Notice must have λ < µ (i.e., ρ < 1)• What if ρ approaches 1?


Slide 6-31


Nonpreemptive Schedulers

ReadyList


Process

Blocked or preempted processes

Done

• Try to use the simplified scheduling model• Only consider running and ready states• Ignores time in blocked state:

– “New process created when it enters ready state”– “Process is destroyed when it enters blocked state”– Really just looking at “small phases” of a process

processes and threads - university of colorado boulder ...rhan/csci_3753_spring... · multiple...

Documents