You are on page 1of 53

Operating Systems

Chapter 2: Processes and Threads

Instr: Yusuf Altunel IKU Department of Computer Engineering (212) 498 42 10

2.1 2.2 2.3 2.4 2.5 Processes Threads Interprocess communication Classical IPC problems Scheduling

The Process Model

Software is organized
into a number of sequential processes

Each process has its own CPU In reality CPU

switches back and forth from process to process

A process will perform its computation There is a need for timing mechanism
to prevent some processes
making the CPU too much busy

Since the time needed for each process

is not uniform

The Process Model

a. Multiprogramming of four programs b. Conceptual model of 4 independent, sequential processes c. Only one program active at any instant

Process Creation
Principal events result in process creation 1. System initialization 2. User request to create a new process 3. Initiation of a batch job

Process Termination
Conditions terminate processes: 1. Normal exit
voluntary voluntary involuntary involuntary

2. Error exit 3. Fatal error 4. Killed by another process

Process Hierarchies
Parent creates a child process,
child processes can create their own process Forms a hierarchy
UNIX calls this a "process group"

has no process hierarchy concept all processes are treated equally

Process States

using the CPU

no CPU is available Ready to run, but temporarily stopped to let another process run

Cannot run even if the CPU is available Unable to run until some external event happens


Lowest layer of process-structured OS handles interrupts, scheduling Starts and stops the processes
when it is necessary

Process Implementation
Process Table
Maintained by OS
to implement the processes

Each entry is reserved for one process Contains information about

Process state Program counter Stack pointer Memory allocation Status of its open files Accounting and scheduling information etc.

Exact fields vary from system to system


Process Table Entry

Process Management
Registers Program Counter Program Status Word Stack Pointer Process State Priority Scheduling parameters Process id Parent process Process group Signals Time when process started CPU Time used Childrens CPU time Time of next alarm 11

Memory Management
Pointer to text segment Pointer to data segment

File Management
Root directory Working directory File descriptions User ID Group ID

Fields of a process table entry

Interrupt Handling

Skeleton of what lowest level of OS does when an interrupt occurs


Comparing Thread vs. Process

(a) Three processes each has one thread (b) One process with three threads

Processes Processes vs. Threads Threads

Process items shared

by all threads in a process

Thread items are private to each thread


Thread Usage: Word Processor

A word processor with three threads


Strategy to Implement Threads

Managing in user Space
OS is not aware of threads Compiler is responsible
to create and manage threads

When a thread is about to block

it chooses and starts its successor before stopping

Managing in Kernel Space

the operating system
is aware of the existence of multiple threads per process

when a thread blocks,

the operating system chooses
the next one to run, either from the same process or a different one

Implementing Threads in User Space

A user-level threads package


Implementing Threads in the Kernel

A threads package managed by the kernel


Pros and Cons

User space
Switching threads is much faster

When thread is blocked
e.g., waiting for I/O or a page fault to be handled

the kernel blocks the entire process

Kernel space
When thread is blocked Having the chance to execute the next

Switching is slower

Interprocess Communication
Processes need
to communicate with others

UNIX command to
Concatenate three files (Process 1) Select all lines containing the word tree (Process 2)

cat chapter1 chapter2 chapter3 | grep tree The first process should
concatenate three files and send the resulting file
to the second process

Second process
will get the concatenated files and finds those lines including the word tree

Race Conditions
Processes often share a common storage
In main memory or a shared file

Race condition
Two or more processes ready To read or write a shared data The final result depends on who runs precisely when

Mutual Exclusion
Critical region
part of a program where shared area is to be accessed

... Slot 4 Slot 5 Slot 6

Process A Process B


Shared area
Shared file Shared memory Variable etc.

Slot 7 ...

Shared Area

To avoid race conditions:

No two processes are ever at the critical region at the same time


Mutual exclusion:
Shared area
must be prevented against access by more than one process
at the same time


Mutual Exclusion Conditions

conditions of mutual exclusion:

No two processes simultaneously

in critical region


No assumptions made
about speeds or numbers of CPUs


No process running outside its critical region

may block another process


No process must
wait forever to enter its critical region

Critical Regions

Mutual exclusion using critical regions


Solving the Race Conditions

Busy Waiting
Disabling Interrupts Lock Variables Strict Alternation Petersons Solution The TSL (Test and Lock) Instruction

Sleep and Wakeup Semaphores Mutexes


Busy Waiting (Disabling Interrupts)

Disable all interrupts
just after entering CR

Re-enable them
just before leaving CR

User will get the power

to turn system interrupts off

Ends the system

if forget to turn on again

System with multi-processor

Turning interrupts
will affect only one processor

Other processors will be able

to access to shared area

Busy Waiting (Lock Variables)

Use a lock variable to
Set to 1 when the process enter CR If it is already 1
the process just waits until it becomes 0

When the process exits CR,

resets the lock to 0

The lock variable itself is shared Access to lock variable
creates another Race Condition

Busy Waiting (Strict Alternation)

Enter CR and set a variable to 1 If another process wants to enter CR
keep checking the variable
until it becomes 0

The process resets the variable to 0

when exits the CR

Second process will enter to CR

when it understand the variable became 0

Not Good
Similar problems to previous solutions Keeps the CPU busy If the waiting process is slower
the first process may not allow the second process to enter CR

Busy Waiting (Peterson's Solution )

Keep an array
to show which processs turn is it

Keep a variable (turn)

to show whose turn is it

The process entering CR
Sets the array element
Process 0 element 0; Process 1 element 1, etc.

Set turn to its process number At leaving CR, reset the array element

A second process will be blocked

until the array element is reset

Busy Waiting (TSL Instruction)

TSL (Test and Lock) instruction:
TSL RX,LOCK Indivisible block of operation
reads the lock into register RX stores a nonzero value at the lock

Help from hardware is taken

Use a shared variable flag When flag is 0
any process may set it to 1
using TSL instructions

enter to CR after finishing execution reset the flag

When flag is 1
any process wants to enter CR should wait

Busy Waiting: Disadvantages

Continuously check the status
Wastes CPU time

Has unexpected results

Priority inversion problem
A process L with lower priority enters its CR A process H with higher priority blocks L and start execution At a point H needs to enter CR But L has already entered H keeps CPU continuously checking L has lower priority,
never has a chance to leave CR

Sleep and Wakeup

System call
causes a process to be blocked

System call
causes a blocked process to be awakened and start execution

If WAKEUP signal is lost

(signal sent when the process is not asleep yet) Processes might go to sleep
and never wakeup

Counts number of wakeups
saved for future use

Solves the lost wakeup problem a semaphore:

could have the value 0
indicating that no wakeups were saved if one or more wakeups were pending

some positive value

Atomic operations:
Checking the value, changing it, and possibly going to sleep

two atomic operations: down

if semaphore value is greater than 0
it decrements the value the process is put to sleep

If the value is 0

increments the value of the semaphore If one or more processes were sleeping on that semaphore
one of them is chosen by the system (e.g., at random) and is allowed to complete its down. the semaphore will still be 0, but there will be one fewer process sleeping on it

after an up on a semaphore with processes sleeping on it,


Solving Race Cond with Semaphores

uses three semaphores:
one called full
for counting the number of slots that are full initially 0

one called empty

for counting the number of slots that are empty initially equal to number of slots in the shared area

one called mutex

to make sure the producer and consumer do not access the buffer at the same time initially set to 1

Each process
does a mutex down
just before entering its critical region

and an up
just after leaving it

full and empty are used for synchronization


A mutex is a variable
can be in one of two states:
unlocked (0) locked (1)

only 1 bit is required to represent it, but in practice an integer often is used

When a thread (or process) needs access to a critical region

it calls mutex_lock.

If the mutex is current unlocked

meaning that the critical region is available the call succeeds
and the calling thread is free to enter the critical region.

if the mutex is already locked,

the calling thread is blocked
until the thread in the critical region is finished and calls mutex_unlock.

If multiple threads are blocked on the mutex,

one of them is chosen at random and allowed to acquire the lock.

Process Scheduling
Operating system (OS) must decide
when more than one process is runnable

OS part to decide which process is run

Scheduling algorithm:
The algorithm to decide
which process will run first

A good algorithm should have the criteria:

Each process must get its fair share of CPU

Keep the CPU busy as much as possible

Response time
Minimize the response time for interactive users

Minimize the time batch users must wait for output

Maximize the number of jobs processed per hour


Bursts of CPU usage alternate with periods of I/O wait

a CPU-bound process an I/O bound process

Scheduling Algorithms
First-Come First-Served Shortest Job First Shortest Remaining Time Next Three level scheduling Round Robin Scheduling Priority Scheduling Multiple Queues Shortest Process Next Guaranteed Scheduling Lottery Scheduling Fair-Share Scheduling

FirstFirst-Come First-Served First The simplest algorithm Processes use the CPU
in the order they request it.

There is a single process queue. When the first job enters the system
it is started immediately allowed to run as long as it wants to.

If new jobs come in

they are put onto the end of the queue.

When the running process is blocked

the first process on the queue runs next.

When a blocked process becomes ready

it is placed on the end of the queue.

Shortest Job First

the process execution time must be known Especially useful in batch processing systems Run the first process that will take shortest time Then continue with the next one

An example of shortest job first scheduling


Shortest Remaining Time Next

The scheduler chooses the process
whose remaining run time is the shortest

The remaining time must be known When a new job arrives

its total time is compared to the current process' remaining time

If the new job needs less time

the current process is suspended and the new job started.

This scheme allows

new short jobs to get good service.

Three level scheduling

First level of scheduling:
Called as admission scheduler Jobs arrived at the system
are initially placed in an input queue stored on the disk.

Decides which jobs to admit to the system. A typical algorithm might be

to look for a mix of compute-bound jobs and I/O bound jobs.

Alternatively, short jobs could be admitted quickly

Second level of scheduling

called as the memory scheduler. determines which processes are kept in memory
and which on the disk.

Third level of scheduling

Called as the CPU scheduler Any suitable algorithm can be used here picking one of the ready processes in main memory to run next

Three level scheduling

Three level scheduling


Round Robin Scheduling

One of the
Oldest Simplest Fairest Most widely used
Current Process Next Process

Each process
assigned a time interval
called quantum

Current Process

Next Process

when the time ends

the process is blocked the next process is switched

Priority Scheduling
Each process assigned a priority The processes with highest in priority run first To prevent higher priority processes to run infinitively
Decrease the priority at each clock tick

It is often convenient to
Group processes into priority classes Apply
priority scheduling between classes and round robin within each class


Multiple Queues
To decrease the swap processes Create priority queues
1 quanta 2 quanta 4 quanta 8 quanta ... to to to to the the the the processes processes processes processes in in in in 1st priority queue 2nd priority queue 3rd priority queue 4th priority queue

Whenever a process used up all quanta allocated to

it will be moved to the next priority queue

Guaranteed Scheduling
If there are n processes
each will receive about 1/n of the CPU power.

Keep track of
how much CPU each process has had since its creation.

Then compute
the amount of CPU used by each process

Compute the ratio of

actual CPU time consumed to CPU time entitled.

A ratio of 0.5:
a process has only had half of what it should have had,

A ratio of 2.0:
a process has had twice as much as it was entitled to.

Run the process with the lowest ratio

until its ratio has moved above its closest competitor

Lottery Scheduling
Give processes lottery tickets To schedule
a lottery ticket is chosen at random, schedule the process holding that ticket

For 50 lotteries per second each process will get
20 msec of CPU time on average

Lottery scheduling can be used

to solve difficult scheduling problems

FairFair-Share Scheduling
To consider who is the process owner Example: round robin, equal priorities,
user 1 has 9 processes user 2 has 1 process user 1 will get
90% of the CPU and

user 2 will get

only 10% of it.

Allocate user a fraction of the CPU time

pick processes so that equilize the CPU time used by the users.

If two users using the system

They will get 50% of the CPU of each no matter how many processes
they have in existence.

Scheduling Threads
When several processes each have multiple threads
we have two levels of parallelism present: processes and threads.

Scheduling in such systems differs depending on

whether user-level threads or kernel-level threads or both are supported.


User Level Threads

Possible scheduling of user-level threads

50-msec process quantum threads run 5 msec/CPU burst

KernelKernel-Level Threads

Possible scheduling of kernel-level threads

50-msec process quantum threads run 5 msec/CPU burst

End of Chapter 2
Processes and Threads