Operating System-Chap 2-Eng

Hệ Điều Hành
(Nguyên lý các hệ điều hành)
Đỗ Quốc Huy
huydq@soict.hust.edu.vn
Bộ môn Khoa Học Máy Tính
Viện Công Nghệ Thông Tin và Truyền Thông
Chapter 2 Process Management
① Process’s definition
Process (review)
lA running program
l Provided resources (CPU, memory, I/O devices. . .) to complete its task
l Resources are provided at:
l The process creating time
l While running
lThe system includes many processes running at the same time
l OS’s process: Perform system instruction code
l User’s process: Perform user’s code
lProcess may contain one or more threads
lOS’s roles:
l Guarantee process and thread activities
l Create/deltete process (user, system)
l Process scheduling
l Provide synchronization mechanism, communication and prevent deadlock
among processes
① Process
② Thread
③ CPU scheduling
④ Critical resource and process
synchronization
⑤ Deadlock and solutions
1. Process
1.1. Notion of process
l Notion of process
l Process Scheduling
l Operations on process
l Process cooperation
l Inter-process communication
1. Process
* System’s state
l Processor: Registers’ values
l Memory: Content of memory block
l Peripheral devices: Devices’ status
l Program’s executing ⇒ system’s state changing
l Change discretely, follow each executed instruction
l Process: a sequence of system’s state changing

l Begin with start state
l Change from state to state is done according to requirement in
user’s program
Process is the execution of a program

1. Process
Process >< program

l Program: passive object (content of a file on disk)
l Program’s code: machine instruction (CD2190EA...)
l Data:
l Variable stored and used in memory
l Global variable
l Dynamic allocation variable (malloc, new,..)
l Stack variable (function’s parameter, local variable)
l Dynamic linked library (DLL)
l Not compiled and lined with program
When program is running, minimum resource requirement
l Memory for program’s code and data
l Processor’s registers used for program execution
l Process: active object (instruction pointer, set of resources)
A program can be
l Part of process’s state
l One program, many process ( different data set)
Example: gcc hello.c || gcc baitap.c
l Call to many process
1. Process
Compile and run a program

Static library
(libc,streams…)
Segments
Source code Binary file(.o file)
Code
Data
Other segment
Data
Executing file(.o file)
Format is depend on OS
Process’s address Code
space
1. Process
Compile and run a program

l The OS creates a process and allocate a memory area for it
l System program loader/exec
l Read and interprets the executive file (file’s header)
l Set up address space for process to store code and data from
executive file
l Put command’s paramenters, environment variable (argc, argv, envp)
into stack
l Set proper values for processor’s registerand call "_start()" (OS’s
fucntion)
l Program begins to run at "_start()". This function call to main()
(program’s functions)
⇒”Process" is running, not mention ”program" anymore
l When main() function end, OS call to "_exit()" to cancel the
process and take back resources
1. Process
Process’s state
When executing, process change its state
l New Process is being initialized
l Ready Process is waiting for its turn to use physical
processor
l Running Process’s instructions are being executed
l Waiting Process is waiting for an event to appear (I/O
operation completion)
l Terminated Process finish its job
Process’s state is part of process current’s activity
1. Process
Process’s states changing flowchart (Silberschatz 2002)
System that has only one processor

l Only one process in running state
l Many processes in ready or waiting state
1. Process
Process Control Block (PCB)

l Each process is presented in the system by a process control block
l PCB: an information structure allows identify only one process
l Process state
l Process counter
l CPU’s registers
l Information for process
scheduling
l Information for memory
management
l Inforamtion of usable resources
l Statistic information
l Pointer to another PCB
l ...
1. Process
Process List
1. Process
Single-thread process and Multi-thread process
l Single-thread process : A running process with only one

executed thread
Have one thread of executive instruction
⇒ Allow executing only one task at a moment
l Multi-thread process : Process with more than one executed

thread
⇒ Allow more than one task to be done at a moment
1. Process
1.2. Process Scheduling
l Notion of process
1. Process
Introduction
Objective Maximize CPU’s usage time

⇒ Need many processes in the system
Problem CPU switching between processes
⇒ Need a queue for processes
Single processor system

⇒ One process running
⇒ Other processes have to wait until processor is free
1. Process
Process queue I
The system have many queues for processes
l Job-queue Set of processes in the system
l Ready-Queue Set of processes exist in the memory, ready to run
l Device queues Set of processes waiting for an I/O device. Queues for
each device are different
1. Process
Process queue II
l Process moves between different queues
New process Ready queue Terminate
End of processor usage time slice
Child Create child process

process
running
I/O device 1 I/O request to
finish device 1
Queue for device 1
I/O device n I/O request to
finish device n
Queue for device n
l Newly created process is putted in ready queue and wait until it’s selected to
execute
1. Process
Process queue III
l Process selected and running

①process issue an I / O request, and then be placed in an I / O queue
②process create a new sub-process and wait for its termination
③process removed forcibly from the CPU, as a result of an interrupt, and be
put back in the ready queue
l In case (1&2) after the waiting event is finished,
l Process eventually switches from waiting state to ready state
l Process is then put back to ready queue
l Process continues this cycle (ready, running, waiting) until it terminates.
l it is removed from all queues
l its PCB and resources deallocated
1. Process
Scheduler
*Selection process is carried out by the appropriate scheduler

l Job scheduler; Long-term scheduler
l CPU scheduler; Short-term scheduler
1. Process
Job Scheduler
l Select processes from process queue stored in disk and put into memory
to execute
l Not frequently (seconds/minutes)
l Control the degree of the multi-programming (number of processin
memory)
l When the degree of multi-programming is stable, the scheduler may
need to be invoked when a process leaves the system
l Job selection problem

l I/O bound process: use less CPU time
l CPU bound process: use more CPU time
l Should select good process mix of both
⇒ I/O bound process: ready queue is empty, waste CPU
⇒ CPU bound: device queue is empty, device is wasted
1. Process
CPU Scheduler
* Selects from processes that are ready to execute, and allocates the
CPU to one of them
l Frequently work (example: at least 100ms/once)
l A process may execute for only a few milliseconds before
waiting for an I/O request
l Select new process that is ready
l the short-term scheduler must be fast
l 10ms to decide ⇒10/(110)=9% CPU time is wasted
l Process selection problem (CPU scheduler)
1. Process
Process swapping (Medium-term scheduler)
l Task
l Removes processes from memory, reduces the degree of
multiprogramming
l Process can be reintroduced into memory and its execution can be
continued where it left off
l Objective: Free memory, make an wider unused memory area
1. Process
Context switch
l Switch CPU from one process to another process
l Save the state of the old process and loading the saved
state for the new process
lincludes the value of the CPU registers, the process state
and memory-management information
l Take time and CPU cannot do anything while switching
l Depend on the support of the hardware
l More complex the operating system, the more work must be
done during a context switch
1. Process
Context switch
l Occurs when an intterupt signal appear( timely interrupt) or when process issue
a system call (to perform I/O)
l CPU switching diagram(Silberschatz 2002)
lCPU switch from this process to another process (switch the running process)
1. Process
1.3. Operations on process
l Notion of process
1. Process
1.3. Operation on process
Operations on process
l Process Creation
l Process Termination
1. Process
Process Creation
l Process may create several new processes (CreateProcess(), fork())
l The creating process: parent-process
l The new process: child-process
l Child-process may create new process ⇒ Tree of process
l Resource allocation
l Child process receive resource from the OS
l Child process receive resource from parent-process
l All of the resource
l a subset of the resources of the parent process (to prevent
process from creating too many child process)
o When a process creates a new process, two possibilities exist in
terms of execution:
l The parent continues to execute concurrently with its children
l The parent waits until some or all of its children have terminated
1. Process
Process Termination
l Finishes executing its final statement and asks the OS to delete (exit)
l Return data to parent process
l Allocated resources are returned to the system
l Parent process may terminate the execution of child process
l Parent must know child process’s id ⇒ child process has to send its id
to parent process when created
l Use the system call (abort)
l Parent process terminate child process when
l The child has exceeded its usage of some of the resources
l The task assigned to the child is no longer required
l The parent is exiting, and the operating system does not allow a child to
continue
l ⇒Cascading termination. Example: turn off computer
1. Process
Some functions with process in WIN32 API
l CreateProcess(. . .)
l LPCTSTR Name of the execution program
l LPTSTR Command line paramenter
l LPSECURITY_ATTRIBUTES A pointer to process security attribute structure
l LPSECURITY_ATTRIBUTES A pointer to thread security attribute structure
l BOOL allow process inherit devices (TRUE/FALSE)
l DWORD process creation flag (Example: CREATE_NEW_CONSOLE)
l LPVOID Pointer to environment block
l LPCTSTR full path to program
l LPSTARTUPINFO info structure for new process
l LPPROCESS_INFORMATION Information of new process
l TerminateProcess(HANDLE hProcess, UINT uExitCode)
l hProcess A handle to the process to be terminated
l uExitCode process termination code
l WaitForSingleObject(HANDLE hHandle, DWORD dwMs)
l hHandle Object handle
l dwMs Waiting time (INFINITE)
1. Process
1.4 Process cooperation
l Notion of process
1. Process
1.4. Process cooperation
Processes’ relation classification

l Sequential processes
l The start point of one process lie after the finish point of the other process
l Parallel processes
l The start point of one process lie between the start and finish point of the
other process
l Independence: Not affect or affected by other running process in the system
l Cooperation: affect or affected by other running process in the system
l Cooperation in order to
l Information sharing
l Computation speedup
l Modularity
l Increase the convenience
l Process collaborate require mechanism that allow process to
l Communicate with one another
l Synchronize their actions
1. Process
Producer - Consumer Problem I
• The system includes 2 processes

• Producer creates product
• Consumer consumes created product
• Application
• Print program (producer) creates characters that are consumed by printer driver
(consumer)
• Compiler (producer) creates assembly code, Assembler (consumer/producer)
consumes assembly code and generate object module which is consumed by the
exec/loader (consumer)
1. Process
Producer - Consumer Problem II

• Producer ande Consumer work simultaneously
Use the sharing Buffer which store product filled in by producer and taken out
by consumer
• IN Next empty place in buffer
• OUT First filled place in the buffer.
• Counter Number of products in the buffer
• Producer and Consumer must be synchronized
• Consumer does not try to consume a product that was not created
• Unlimited size buffer
When buffer is empty, Consumer need to wait
Producer can put product into buffer without waiting
• Limited size buffer
• When Buffer is empty, Consumer need to wait
• Producer need to wait if the Buffer is full
1. Process
Producer - Consumer Problem II

Producer
while(1) {
/*produce an item in nextProduced*/
while (Counter == BUFFER_SIZE) ; /*do nothing*/
Buffer[IN] = nextProduced;
IN = (IN + 1) % BUFFER_SIZE;
Counter++;
}
Consumer
while(1){
while(Counter == 0) ; /*do nothing*/
nextConsumed = Buffer[OUT];
OUT =(OUT + 1) % BUFFER_SIZE;
Counter--; /*consume the item in nextConsumed*/
}
1. Process
1.5 Inter-process communication
l Notion of process
1. Process
Communicate between process

• Memory sharing model Process A
• Process share a common memory area Sharing Area
• Implementation code are written explicitly by Process B
application programmer
• Example: Producer-Consumer problem
Kernel
• Inter-process communication model Process A M

• A mechanism allow processes to communicate and Sharing Area
synchronize Process B M
• Often used in distributed system where processes lie
on different computers (chat)
• Guaranteed by message passing system
Kernel M
1. Process
Message passing system

• Allow processes to communicate without sharing variable
• Require two basic operations
• Send (msg) msg has fixed or variable size
• Receive (msg)
• If 2 processes P and Q want to communicate, they need to
• Establish a communication link (physical/logical) between them
• Exchange messages via operations: send/receive
1. Process
Direct Communication
l Each process that wants to communicate must explicitly name

the recipient or sender of the communication
l send (P, message) – Send a message to process P
l receive(Q, message) – Receive a message from process Q
l The properties of a communication link
l A link is established automatically
l A link is associated with exactly two processes
l Exactly one link exists between each pair of processes
l Link can be one direction but often two directions
1. Process
Indirect Communication
l Messages are sent to and received from mailboxes, or ports
l Each mailbox has a unique identification
l Two processes can communicate only if they share a mailbox
l Communication link’s properties
l Established only if both members of the pair have a shared mailbox
l A link may be associated with more than two processes
l Each pair of communicating processes may have many links
l Each link corresponding to one mailbox
l A link can be either one or two direction
l Operations:
l Create a new mailbox
l Send and receive messages through the mailbox
l send(A, msg): send a msg to mailbox A
l receive(A, msg): Receuve a msg from mailbox A
l Delete a mailbox
1. Process
Synchronization
l Message passing may be either blocking or nonblocking-
l Blocking synchronous communication
l Non-blocking asynchronous communication
l send() and receive() can be blocking or non-blocking
l Blocking send sending process is blocked until the message is
received by the receiving process or by the mailbox
l Non-blocking send The sending process sends the message and
resumes operation
l Blocking receive The receiver blocks until a message is available
l Non-blocking receive The receiver retrieves either a valid message or

a null
1. Process
Buffering
• Messages exchanged by communicating processes reside in a
temporary queue
• A queue can be implemented in three ways
• Zero capacity: maximum length 0 => the link cannot have any messages
waiting in it
• sender must block until the recipient receives the message
• Bounded capacity
• Queue has finite length n ⇒ store at most n messages
• If the queue is not full, message is placed in the queue and the sender can
continue execution without waiting
• If the link is full, the sender must block until space is available in the queue
• Unbound capacity
• The sender never blocks
1. Process
Windows XP Message Passing

1. Process
Communication in Client - Server Systems with Sockets

• Socket is defined as an endpoint for communication,
• Each process has one socket
• Made up of an IP address and a port number. E.g.: 161.25.19.8:1625
• IP Address: Computer address in the network
• Port: identifies a specific process
• Types of sockets
• Stream Socket: Based on TCP/IP protocol → Reliable data transfer
• Datagram Socket: based on UDP/IP protocol → Unreliable data transfer
• Win32 API: Winsock
• Windows Sockets Application Programming Interface
1. Process
Winsock API 32 functions
socket()Tạo socket truyền dữ liệu

bind() Định danh cho socket vừa tạo (gán cho một cổng)
listen() Lắng nghe một kết nối
accept() Chấp nhận một kết nối
connect() kết nối với server.
send() Gửi dữ liệu với stream socket.
sendto() Gửi dữ liệu với datagram socket.
receive() Nhận dữ liệu với stream socket.
recvfrom() Nhận dữ liệu với datagram socket.
closesocket() Kết thúc một socket đã tồn tại.
..........
1. Process
Homework
Use Winsock to make a Client-Server program
Chat program.
..........
① Process
② Thread
③ CPU scheduling
synchronization
2. Thread
2.1. Introduction
l Introduction
l Multithreading model
l Thread implementation with Windows
l Multithreading problem
2. Thread
2.1. Introduction
2. Thread
2.1. Introduction
Example: Vector computation
l Large size vector computing

For (k = 0;k < n;k++) {
a[k] = b[k]*c[k];
}
With multi processors system
2. Thread
2.1. Introduction
Example: Chat
Process P Msg receiving problem Process Q

While (1) { l Blocking Recieve While (1) {
ReadLine(Msg); l Non-blocking Receive Receive(P,Msg);
Send(Q,Msg); PrintLine(Msg);
Receive(Q,Msg); ReadLine(Msg);
PrintLine(Msg); Solution Send(P,Msg);
} Concurrently perform }
Receive & Send
2. Thread
2.1. Introduction
Program - Process - Thread
l Program: Sequence of instructions, variables,..

l Process: Running program: Stack, devices, processor,..
l Thread: A running program in process context
l Multi-processor → Multi threads, each thread runs on one processor
l Different in term of registers’ values, stack’s content
2. Thread
2.1. Introduction
Single-threaded and multi-threaded process

l Traditional operating system(MS-DOS, UNIX)
l Process has one controlling thread (heavyweight process)
l Modern operating system (Windows, Linux)
l Process may have many threads
l Perform many task at a single time
2. Thread
2.1. Introduction
Example: Word processor (Tanenbaum 2001)

2. Thread
2.1. Introduction
Notion of thread
l Basic CPU using unit, consists of

l Thread ID
l Program Counter
l Registers
l Stack space
l Sharing between threads in the same process
l Code segment
l Data segment (global objects)
l Other OS’s resources (opening file…)
l Thread can run same code segment with different context
(Register set, program counter, stack)
l LWP: Lightweight Process
l A process has at least one thread
2. Thread
2.1. Introduction
Distinguishing between process and thread
Process Thread
Has code/data/heap and other segments No separating code or heap segment
Has at least one thread Not stand alone but must be inside a
process
Threads in the same process share Many threads can exist at the same time
code/data/heap, devices but have in each process. First thread is the main
separated stack and registers thread and own process’s stack
Create and switch process operations are Create and switch thread operations are
expansive inexpensive
Good protection due to own address Common address space, need to protect
space
When process terminated, resources are Thread terminated, its stack is returned
returned and threads have to terminated
2. Thread
2.1. Introduction
Benefits
l Responsiveness
l allow a program to continue running even if part of it is blocked or is
performing a long operation
l Example: A multi-threaded Web browser
l One thread interactives with user
l One thread downloads data
l Resource sharing
l threads share the memory and the resources of the process
l Good for parallel algorithms (share data structures)
l Threads communicate via sharing memory
l Allow application to have many threads act in the same address space
l Economy
l Create, switch, terminate threads is less expensive than process
l Utilization of multiprocessor architectures
l each thread may be running in parallel on a different processor.
2. Thread
2.1. Introduction
Benefit of multithreading-> example
Tính toán trên vector

Vector computing Multi-threading model
for (k = 0;k < n;k++) { void fn(a,b)
a[k] = b[k]*c[k]; for(k = a; k < b; k ++){
} a[k] = b[k] ∗ c[k];
}
void main(){
CreateThread(fn(0, n/4));
CreateThread(fn(n/4, n/2));
CreateThread(fn(n/2, 3n/4));
CreateThread(fn(3n/4, n));
}
2. Thread
2.1. Introduction
Thread implementation
User space Kernel space

2. Thread
2.1. Introduction
User -Level Threads
l Thread management is done by application

l Kernel does not know about thread existence
l Process scheduling like a single unit
l Each process is assigned with a single state
l Ready, waiting, running,..
l User threads are supported above the kernel and are implemented by a
thread library
l Library support creation, scheduling and management..
l Advantage
l Fast to create and manage
l Disadvantage
l if a thread perform blocking system call , the entire process will be
blocked ⇒ Cannot make use of multi-thread.
2. Thread
2.1. Introduction
Kernel - Level threads
l Kernel keeps information of process and threads

l Threads management is performed by kernel
l No thread management code inside application
l Thread scheduling is done by kernel
l Disadvantage:
l Slow in thread creation and management
l Advantage:
l One thread perform system call (e.g. I/O request), other
threads are not affected
l In a multiprocessor environment, the kernel can schedule
threads on different processors
l Operating system support kernel thread: Windows
NT/2000/XP, Linux, OS/2,..
2. Thread
2.2.Multi-threading model
l Introduction
2. Thread
Introduction
l Many systems provide support for both user and kernel

threads -> different multithreading models
2. Thread
Many-to-One Model
l Maps many user-level threads to
one kernel thread.
l Thread management is done in
user space
l Efficient
l the entire process will block if a
thread makes a blocking system
call
l multiple threads are unable to
run in parallel on multi
processors
l implemented on operating systems
that do not support kernel threads
use the many-to-one model
2. Thread
One-to-one Model
l Maps each user thread to a kernel thread

l Allow another thread to run when a thread makes a blocking system call
l Creating a user thread requires creating the corresponding kernel thread
l the overhead of creating kernel threads can burden the performance
of an application
l ⇒ restrict the number of threads supported by the system
l Implemented in Window NT/2000/XP
2. Thread
Many-to-Many Model
l Multiplexes many user-level threads to a

smaller or equal number of kernel threads
l Number of kernel threads: specific to
either a particular application or a
particular machine
l E.g.: on multiprocessor -> more
kernel thread than on uniprocessor
l Combine advantages of previous models
l Developers can create as many user
threads as necessary
l kernel threads can run in parallel on
a multiprocessor
l when a thread performs a blocking
system call, the kernel can schedule
another thread for execution
l Supported in: UNIX
2. Thread
2.3. Thread implementation with Windows
l Introduction
2. Thread
Functions with thread in WIN32 API

l HANDLE CreateThread(. . .);
l LPSECURITY_ATTRIBUTESlpThreadAttributes,
⇒A pointer to a SECURITY_ATTRIBUTES structure that determines whether
the returned handle can be inherited by child processes
l DWORD dwStackSize,
⇒The initial size of the stack, in bytes
l LPTHREAD_START_ROUTINE lpStartAddress,
⇒ pointer to the application-defined function to be executed by the thread
l LPVOID lpParameter,
⇒A pointer to a variable to be passed to the thread
l DWORD dwCreationFlags,
⇒The flags that control the creation of the thread
l CREATE_SUSPENDED : thread is created in a suspended state
l 0: thread runs immediately after creation
l LPDWORD lpThreadId
⇒pointer to a variable that receives the thread identifier
l Return value: handle to the new thread or NULL if the function fails
2. Thread
Example
#include <windows.h>
#include <stdio.h>
void Routine(int *n){
printf("My argument is %d\n", &n);
}
int main(){
int i, P[5]; DWORD Id;
HANDLE hHandles[5];
for (i=0;i < 5;i++) {
P[i] = i;
hHandles[i] = CreateThread(NULL,0,
(LPTHREAD_START_ROUTINE)Routine,&P[i],0,&Id);
printf("Thread %d was created\n",Id);
}
for (i=0;i < 5;i++) WaitForSingleObject(hHandles[i],INFINITE);
return 0;
}
2. Thread
Thread in Windows XP
Thread includes
l Thread ID
l Registers
l user stack used in user mode,
kernel stack used in kernel mode.
l Separated memory area used by
runtime and dynamic linked
library
Executive thread block

Kernel thread block
Thread environment block
2. Thread
2.4. Multithreading problem
l Introduction
2. Thread
Example
#include <stdio.h>
int x = 0, y = 1;
void T1(){
while(1){ x = y + 1; printf("%4d", x); }
}
void T2(){
while(1){ y = 2; y = y * 2; }
}
int main(){
HANDLE h1, h2; DWORD Id;
h1=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)T1,NULL,0,&Id);
WaitForSingleObject(h1,INFINITE);
return 0;
}
2. Thread
Explanation
Thread T1 Thread T2
x=y+1
y=2
x=y+1
y=y*2
x=y+1
The result of parallel running

threads depends on the order of
accessing the sharing variable
t
① Process
② Thread
③ CPU scheduling
synchronization
3. CPU scheduling
3.1. Basic Concepts
lBasic Concepts
lScheduling Criteria
lScheduling algorithms
lMulti-processor scheduling
3. CPU scheduling
3.1. Basic Concepts
Introduction
l System has one processor → Only one process is running at a time
l Process is executed until it must wait, typically for the completion of some
I/O request
l Simple system: CPU is not be used ⇒ Waste CPU time
l Multiprogramming system: try to use this time productively, give CPU for
another process
l Several ready processes are kept inside memory at one time
l When one process has to wait, OS takes the CPU away and gives the
CPU to another process
l Scheduling is a fundamental operating-system function
l Switch CPU between process → exploit the system more efficiently
3. CPU scheduling
3.1. Basic Concepts
CPU-I/0 Burst Cycle

l Process execution consists of a cycle of
CPU execution and I/O wait
l begins with a CPU burst
l followed by an I/O burst
l CPU burst → I/O burst → CPU burst → I/O
burst → . . .
l End: the last CPU burst will end with a
system request to terminate execution
l Process classification
l Based on distribution of CPU & I/O burst
l CPU-bound program might have a few
very long
l I/O-bound program would typically have
many very short CPU bursts
l help us select an appropriate CPU-
scheduling algorithm
3. CPU scheduling
3.1. Basic Concepts
CPU Scheduler
l CPU idle -> select one process from ready queue to be executed
l Process in ready queue
l FIFO queue, Priority queue, Simple linked list . . .
l CPU scheduling decisions may take place when
1) Process switches from the running state to the waiting state (I/O request)
2) Process switches from the running state to the ready state (out of CPU usage
time→ time interrupt)
3) Process switches from the waiting state to the ready state (e.g. completion of
I/O)
4) Process terminates
l Note
l Case 1&4 ⇒ non-preemptive scheduling scheme
l Other cases ⇒ preemptive scheduling scheme
3. CPU scheduling
3.1. Basic Concepts
Preemptive and non-preemptive Scheduling

l Non-preemptive scheduling
l Process keeps the CPU until it releases the CPU either by
l terminating
l switching to the waiting state
l does not require the special hardware (timer)
l Example: DOS, Win 3.1, Macintosh
l Non-preemptive scheduling
l Process only allowed to run in specified period
l End of period, time interrupt appear, dispatcher is invoked to decide to
resume process or select another process
l Protect CPU from “CPU hungry" processes
l Sharing data problem
l Process 1 updating data and the CPU is taken
l Process 2 executed and read data which is not completely update
l Example: Multiprogramming OS WinNT, UNIX
3. CPU scheduling
3.2. Scheduling Criteria
lBasic Concepts
3. CPU scheduling
Scheduling Criteria I
l CPU utilization
l keep the CPU as busy as possible
l should range from 40 percent (for a lightly loaded system) to 90 percent (for a heavily
used system)
l Throughput
l number of processes completed per time unit
l Long process: 1 process/hour
l Short processes: 10 processes/second
l Turnaround time
l Interval from the time of submission of a process to the time of completion
l Can be the sum of
l periods spent waiting to get into memory
l waiting in the ready queue
l executing on the CPU
l doing I/O
3. CPU scheduling
Scheduling Criteria II
l Waiting time
l sum of the periods spent waiting in the ready queue
l CPU-scheduling algorithm does not affect the amount of time during which a
process executes or does I/O; it affects only the amount of time that a process
spends waiting in the ready queue
l Response time
l time from the submission of a request until the first response is produced
l process can produce some output fairly early
l continue computing new results while previous results are being output to
the user
l Assumption: Consider one CPU burst (ms) per process

l Measure: Average waiting time
3. CPU scheduling
3.3. Scheduling algorithms
lBasic Concepts
3. CPU scheduling
FCFS: First Come, First Served

l Rule: process that requests the CPU first is allocated the CPU first
Process own CPU until it terminates or blocks for I/O request
l Example Process Burst Time
l Pros and cons

l Simple, easy to implement
l Short process has to wait like short process
l If P1 executed last?
3. CPU scheduling
SJF: Shortest Job First

l Rule: associates with each process the length of the latter's next CPU burst
l process that has the smallest next CPU burst
l Two methods
l Non-preemptive
l preemptive (SRTF: Shortest Remaining Time First)
l Example
Process Burst Time Arrival Time
l Pros and Cons

l SJF (SRTF) is optimal: Average waiting time is minimum
l It’s not possible to predict the length of next CPU burst
l Predict based on previous one
3. CPU scheduling
Priority Scheduling
l Each process is attached with a priority value (a number)
l CPU is allocated to the process with the highest priority
l SJF: priority (p) is the inverse of the (predicted) next CPU burst
l Two method
l Non-preemptive
l Preemptive
l Example Process Burst Time Arrival Time
l “Starvation“ problem: low-priority process has to wait indefinitely (even

forever)
l Solution: increase priority by the time process wait in the system
3. CPU scheduling
Round Robin Scheduling

l Rule
l Each process is given a time quantum (time slice) τ to be executed
l When time’s up processor is preemptive and process is placed in the last
position of ready queue
l If there are n process, longest waiting time is (n − 1)τ
l Example Process Burst Time
quantum τ = 4
l Problem: select τ
l τ large: FCFS
l τ small: CPU is switched frequently
l Commonly τ = 10-100ms
3. CPU scheduling
Multilevel Queue Scheduling

l Partitions the ready queue into several separate queue
l Processes are permanently assigned to one queue
l Based on some property of the process, such as memory size, process priority,
or process type..
l Each queue has its own scheduling algorithm
l There must be scheduling among the queues
l Commonly implemented as fixed-priority preemptive scheduling
l Processes in lower priority queue only executed if higher priority queues
are empty
l High priority process preemptive CPU from lower priority process
l Starvation is possible
l Time slice between the queues
l foreground process, queue 80% CPU time for RR
l background process queue, 20% CPU time for FCFS
3. CPU scheduling
Multilevel Queue Scheduling (Example)

3. CPU scheduling
Multilevel Feedback Queue

l Allows a process to move between queues
l separate processes with different CPU-burst characteristics
l If a process uses too much CPU time ->moved to a lower-priority queue
l I/O-bound and interactive processes in the higher-priority queues
l process that waits too long in a lower- priority queue may be moved to a
higher-priority queue
l Prevent “starvation”
l multilevel feedback queue scheduler is defined by the following parameters:
l number of queues
l scheduling algorithm for each queue
l method used to determine when to upgrade/demote a process to a
higher/lower priority queue
l method used to determine which queue a process will enter when that process
needs service
3. CPU scheduling
Multilevel Feedback Queue

l Example
3. CPU scheduling
3.4. Multi-processor scheduling
lBasic Concepts
3. CPU scheduling
3.4. Multi-processor scheduling
Problem
l the scheduling problem is correspondingly more complex
l Load sharing
l separate queue for each processor
l one processor could be idle, with an empty queue, while another processor
was very busy
l use a common ready queue
l common ready queue’s problems :
→two processors do not choose the same process or
→processes are lost from the queue
l asymmetric multiprocessing
l only one processor accesses the system’s queue -> no sharing problem
l I/O-bound processes may bottleneck on the one CPU that is performing all of
the operations
3. CPU scheduling
Homework
lWrite program to simulate multilevel feedback

queue
① Process
② Thread
③ CPU scheduling
④ Critical resource and process synchronization
4. Critical resource and process synchronization
lCritical resource
lInternal lock method
lTest and Set method
lSemaphore mechanism
lProcess synchronization example
lMonitor
4.1 Critical resource
Example
#include <stdio.h>
int x = 0, y = 1;
void T1(){
while(1){ x = y + 1; printf("%4d", x); }
}
void T2(){
while(1){ y = 2; y = y * 2; }
}
int main(){
HANDLE h1, h2; DWORD Id;
return 0;
}
Results
producer-consumer I
• Two processes in the system

• Producer creates products
• Consumer consumes created product
• Producer and Consumer must be synchronized.
• Do not create product when there is no space left
• Do not consume product when there is none
Producer-Consumer Problem II
Producer Consumer
while(1) { while(1){
/*produce an item in while(Counter == 0) ;
nextProduced*/ /*do nothing*/
while (Counter == BUFFER_SIZE) ; nextConsumed = Buffer[OUT];
/*do nothing*/ OUT =(OUT + 1) % BUFFER_SIZE;
Buffer[IN] = nextProduced; Counter--; /*consume the item in
IN = (IN + 1) % BUFFER_SIZE; nextConsumed*/
Counter++; }
}
Nhận xét
l Producer creates one product
l Consumer consumes one product
⇒Number of product inside Buffer does not change
Definition
Resource
Everything that is required for process’s execution
Critical resource
l Resource that is limited of sharing capability
l Required concurrently by processes
l Can be either physical devices or sharing data
Problem
Sharing critical resource may not guarantee data completeness
⇒ Require process synchronization mechanism
Race condition
l Situation where the results of many processes access the

sharing data depend of the order of these actions
l Make program’s result undefinable
l Prevent race condition by synchronize concurrent running
processes
l Only one process can access sharing data at a time
l Variable counter in Producer-Consumer problem
l The code segment that access sharing data in the
process have to be executed in a defined order
l E.g.: x←y+1 instruction in Thread T1 only both two
instruction of Thread T2 are done
Critical section
l The part of the program where the shared memory is

accessed is called the critical region or critical section
l When there are more than one process use critical

resource then we have to synchronize them
l Object: guarantee that no more than one process can
stay inside critical section
Conditions to have a good solution
l Mutual Exclusion: Critical resource does not have to serve the

number of process more than its capability at any time
l If process Pi is executing in its critical section, then no
other processes can be executing in their critical sections
l Progress: If critical resource still able to serve and there are
process want to be executed in critical section then this process
can use critical resource
l Bounded Waiting: There exists a bound on the number of times
that other processes are allowed to enter their critical sections
after a process has made a request to enter its critical section
and before that request is granted
Rule
l There are two processes P1&P2 concurrently running

l Sharing the same critical resource
l Each process put the critical section at begin and the remainder
section is next
l Process must ask before enter the critical section {entry section}
l Process perform {exit section} after exiting from critical section
l Program structure
Methods’ classification
l Low level method

l Variable lock
l Test and set
l Semaphore
l High level method

l Monitor
lCritical resource
lVariable lock method
lMonitor
4.2 Variable lock
Principle
sharing
memory area
Critical
Resource
l Each process use one byte in the sharing memory area as a lock
l Process enter critical section, lock (byte lock = true)
l Process exit from critical section, unlock (byte lock= false)
l Process want to enter critical section: check other process’s lock byte ‘s
status
l Locking ⇒ Wait
l Not lock ⇒ Have the right to enter critical section
4.2 Variable lock
Algorithm
l Share var C1,C2 Boolean // sharing variable used as lock

l Initialization C1 = C2 = false // Critical resource is free
Process P1 Process P2
Process P1’s critical section Process P2’s critical section
Process P1’s remaining section Process P2’s remaining section

4.2 Variable lock
Algorithm
l Share var C1,C2 Boolean // sharing variable used as lock

l Initialization C1 = C2 = false // Critical resource is free
Process P1’s critical section Process P2’s critical section
Process P1’s remaining section Process P2’s remaining section

4.2 Variable lock
Remark
l Not properly synchronize

l Two processes request resource at the same time
lMutual exclusion problem (Case 1)
lProgressive problem (Case 2)
l Reason: The following actions are done separately
l Check the right to enter critical section
l Set the right to enter critical section
4.2 Variable lock
Dekker’s algorithm
l Utilize turn variable to show process with priority
Process P1’s critical section P2’s critical section
P1’s remaining section P2s remaining section

4.2 Variable lock
Remark
l Synchronize properly for all cases

l No hardware support requirement -> implement in any
languages
l Complex when the number of processes and resources
increase
l “busy waiting” before enter critical section
l When waiting, process has to check the right to enter the critical
section => Waste processor’s time
lCritical resource
lMonitor
4.3 Test anh Set
Principle
l Utilize hardware support
l Hardware provides uninterruptible instructions
l Test and change the content of aword
boolean TestAndSet(VAR boolean target) {
boolean rv = target;
target = true;
return rv;
}
l Swap the content of two different words
void Swap(VAR boolean , VAR boolean b) {
boolean temp = a;
a = b;
b = temp;
}
l instruction is executed atomically
l Code block is uninterruptible when executing
l When called at the same time, done in any order
4.3 Test anh Set
Algorithm with TestAndSet instruction

l Sharing variable Boolean: Lock: resource’s status:
l Locked (Lock=true)
l Free (Lock=false)
l Initialization: Lock = false ⇒ Resource is free
l Algorithm for process Pi
Process P’s critical section
P’s remaining section

4.3 Test anh Set
Algorithm with Swap instruction

l Sharing variable Lock shows the resource’s status
l Local variable for each process: Key: Boolean
l Initialization: Lock = false ⇒ Resource is free
l Algorithm for process Pi
Process P’s critical section
P’s remaining section

4.3 Test anh Set
Remark
l Simple, complexity is not increase when number of processes

and critical resource increase
l “busy waiting” before enter critical section
l When waiting, process has to check if sharing resource is
free or not => Waste processor’s time
l No bounded waiting guarantee
l The next process entering critical section is depend on the
resource release time of currently resource-using process
⇒ Need to be solved
lCritical resource
lMonitor
4.4. Semaphore mechanism
Semaphore
• An integer variable, initialize by resource sharing capability

• Number of available resources (e.g. 3 printers)
• Number of resource’s unit (10 empty slots in buffer)
• Can only be changed by 2 operation P and V
• Operation P(S) (wait(S))
• Operation V(S) (signal(S))
• P and V are uninterruptible instructions

Semaphore usage I
• n-process critical-section problem
• processes share a semaphore, mutex
• initialized to 1.
• Each process Pi is organized as
Semaphore usage II
• The order of execution inside processes:

• PI with a statement S1 , P2 with a statement S2.
• require that S2 be executed only after S1 has completed
P1 and P2 share a common semaphore synch, initialized to 0,
Code for each process
Process 1 Process 2
S1; wait (synch) ;
signal (synch) ; S2;
{ Remainder code}} { Remainder code}}
To overcome the need for busy waiting
Use 2 operations
• Block() Temporarily suspend running process
• Wakeup(P) Resume process P suspended by block() operation
• When a process executes the wait operation and semaphore value is not
positive
• it must wait. (block itself -> not busy waiting)
• block operation places a process into a waiting queue associated with
the semaphore,
• Process’s state is switched to the waiting
• Control is transferred to the CPU scheduler,
• process that is blocked, waiting on a semaphore S, restarted when
some other process executes a signal operation.
• The process is restarted by a wakeup operation
• changes the process from the waiting state to the ready state.
• process is then placed in the ready queue.
Semaphore implementation
Insert process to Get process from

Synchronization example
running
P1
running
P2
running
P3 t
Semaphore S
S.Value = 1
S.Ptr NULL
running
P1 P1→P(S)
running
P2
running
P3 t
Semaphore S
S.Value = 0
S.Ptr NULL
running
P1 P1→P(S)
block
P2 P2→P(S)
running
P3 t
Semaphore S
S.Value = -1
S.Ptr PCB2
running
P1 P1→P(S)
block
P2 P2→P(S)
block
P3 P3→P(S) t
Semaphore S
S.Value = -2
S.Ptr PCB2 PCB3

running
P1 P1→P(S) P1→V(S)
running
P2 P2→P(S)
block
P3 P3→P(S) t
Semaphore S
S.Value = -1
S.Ptr PCB3
running
P1 P1→P(S) P1→V(S)
running
P2 P2→P(S) P2→V(S)
running
P3 P3→P(S) t
Semaphore S
S.Value = 0
S.Ptr NULL
running
P1 P1→P(S) P1→V(S)
running
P2 P2→P(S) P2→V(S)
running
P3 P3→P(S) P3→V(S)
t
Semaphore S
S.Value = 1
S.Ptr NULL
running
P1 P1→P(S) P1→V(S)
running
P2 P2→P(S) P2→V(S)
running
P3 P3→P(S) P3→V(S)
t
Semaphore S
S.Value = 1
S.Ptr NULL
Remark
l Easy to apply for complex system

l No busy waiting
l The effectiveness is depend on user
P(S) V(S) P(S)

{Critical section} {Critical section} {Critical section}
V(S) P(S) P(S)
Correct Wrong order Wrong command

synchronize
Remark
l P(S) and V(S) is nonshareable

⇒P(S) and V(S) are 2 critical resource
⇒Need synchronization
l Uniprocessor system: Forbid interrupt when perform wait(),
signal()
l Multiprocessor system
lNot possible to forbid interrupt on other processors
lUse variable lock method ⇒ busy waiting, however
waiting time is short (10 commands)
Semaphore object in WIN32 API
l CreateSemaphore(. . .) : Create a Semaphore

l LPSECURITY_ATTRIBUTES lpSemaphoreAttributes
⇒ pointer to a SECURITY_ATTRIBUTES structure, handle can be inherited?
l LONG InitialCount, ⇒ initial count for Semaphore object
l LONG MaximumCount, ⇒ maximum count for Semaphore object
l LPCTSTR lpName ⇒ Name of Semaphore object
Example: CreateSemaphore(NULL,0,1,NULL);
l Return HANDLE of Semaphore object or NULL
l WaitForSingleObject(HANDLE h, DWORD time)
l ReleaseSemaphore (. . .)
l HANDLE hSemaphore, ⇐ handle for a Semaphore object
l LONG lReleaseCount, ⇐ increase semaphore object’s current count
l LPLONG lpPreviousCount ⇐ pointer to a variable to receive the previous count
l Example: ReleaseSemaphore(S, 1, NULL);
Example
Example
lCritical resource
lProcess synchronization examples
lMonitor
4.5. Process synchronization examples
lProducer-Consumer problem
lDining Philosophers problem
lReaders-Writers
lSleeping Barber
lBathroom Problem
Producer-consumer problem
while(1){
while(1) {
while(Counter == 0) ;
/*produce an item in Buffer*/
/*do nothing*/
while (Counter == BUFFER_SIZE) ;
nextConsumed = Buffer[OUT];
/*do nothing*/
OUT =(OUT + 1) % BUFFER_SIZE;
Buffer[IN] = nextProduced;
Counter--; /*consume the item in
IN = (IN + 1) % BUFFER_SIZE;
nextConsumed*/
Counter++;
}
}
Producer Consumer
Producer-Consumer problem
while(1){
while(1) { if(Counter == 0) block();
/*produce an in Buffer */ /*do nothing*/
if(Counter==SIZE) block(); nextConsumed = Buffer[OUT];
/*do nothing*/ OUT =(OUT + 1) % BUFFER_SIZE;
Buffer[IN] = nextProduced; Counter--;
IN = (IN + 1) % BUFFER_SIZE; if(Counter==SIZE-1) wakeup(Producer);
Counter++; /*consume the item in Buffer*/
if(Counter==1) wakeup(Consumer); }
}
Producer Consumer
Readers and Writers problem
l Many Readers processes access the database at the same time

l Several Writers processes update the database
l Allow unlimited Readers to access the database
l One Reader process is accessing the database, new Reader
process can access the database
l (Writers processes has to stay in waiting queue)
l Allow only one Writer process to update the database at a time
l Non-preemptive problem. Process stays inside critical section
without being interrupted
Sleeping barber
l N waiting chair for client

l Barber can cut for one client at a
time
l No client, barber go to sleep
l When client comes
l If barber is sleeping ⇒ wake him up
l If barber is working
l Empty chair exists ⇒ sit and wait
l No empty chair left ⇒ Go away
Bathroom Problem
lA bathroom is to be used by both men and women, but not at the

same time
lIf the bathroom is empty, then anyone can enter
lIf the bathroom is occupied, then only a person of the same sex as
the occupant(s) may enter
lThe number of people that may be in the bathroom at the same time
is limited
l Problem implementation require to satisfy constraints

l 2 types of process: male() và female()
l Each process enter the Bathroom in a random period of time
Dining philosopher problem

Classical synchronization problem, show the situation where many processes share
resources
l 5 philosophers having dinner at a round

table
l In front each person is a disk of
spaghetti
l Between two disk is a fork
l Philosopher do 2 things :Eat and Think
l Each person need two forks to eat
l Take only one fork at a time
l Take the left fork then the right fork
l Finish eating, return the fork to original
place
Dining philosopher problem: Simple method
l Each fork is a critical resource, synchronized by a semaphore fork[i]

l Semaphore fork[5] = {1, 1, 1, 1, 1};
l Algorithm for philosopher Pi
{Eat}
{Thinks}
l If all the philosophers want to eat

l Take the left fork (call to: wait(fork[i]))
l Wait for the right fork (call to: wait(fork[(i+1)%5]))
⇒ deadlock
Dining philosopher problem – Solution 1
l Allow only one philosopher to take the fork at a time

l Semaphore mutex ← 1;
l Algorithm for philosopher Pi
{Eat}
{Thinks}
l It’s possible to allow 2 non-close philosopher to eat at a time (P1: eats, P2:
owns mutex⇒ P3 waits)
Dining philosopher problem – Solution 1

l Philosopher take the forks with different order
l Even id philosopher take the even id fork first
l Odd id philosopher take the odd id fork first
{Eat}
{Thinks}
l Solve the deadlock problem

True problem ?
lCritical resource
lProcess synchronization examples
lMonitor
4.6 Monitor
Introduction
l Special data type, proposed by HOARE

1974 Sharing variables declarations
l Combines of procedures, local data,
initialization code
l Process can only access variables via
procedures of Monitor
l Only one process can work with
Monitor at a time
l Other processes have to wait
l Allow process to wait inside Monitor
l Utilize condition variable
Initialization code
Monitor’s syntax
4.6 Monitor
Model
4.6 Monitor
Condition Variable
Actually name of a queue

Declare: condition x,y;
Only used by 2 operations
wait() Called by Monitor’s procedures (syntax x.wait() or wait(x)).
Allow process to be blocked until activated by other process
via signal() procedure
signal() Called by Monitor’s procedures (syntax x.signal() or
signal(x)). Activate a process waiting at x variable queue.
If no waiting process then the operation is skipped
4.6 Monitor
Model
4.6 Monitor
Monitor’s usage: sharing a resource
Process’s structure
User’s partt
Using resource
Initialization part
4.6 Monitor
Producer – Consumer problem
Item = New product

Put Item into Buffer
{Take Item from Buffer}
{Use Item}
① Process
② Thread
③ CPU scheduling
④ Critical resource and process synchronization
5.Dead lock and solutions
5.1. Deadlock conception
l Deadlock conception
l Conditions for resource deadlocks
l Solutions for deadlock
l Deadlock prevention
l Deadlock avoidance
l Deadlock detection and recovery
Deadlock conception
l System combines of concurrently running processes, sharing resources

l Resources have different types (e.g.: CPU, memory,..).
l Each type of resource may has many unit (e.g.: 2 CPUs, 5 printers..)
l Each process is combines of sequences of continuous operations

l Require resource: if resource is not available (being used by other
processes) ⇒ process has to wait
l Utilize resource as required (printing, input data...)
l Release allocated resources
l When processes share at least 2 resources, system may “in danger”

Deadlock conception
l Example: Two processes in the system P1 & P2

l P1 & P2 share 2 resources R1 & R2
l R1 is synchronized by semaphore S1 (S1 ← 1)
l R2 is synchronized by semaphore S2 (S2 ← 1)
l Code for P1 and P2
P(S1)
P(S2)
{ Use R1&R2 }
V(S1)
V(S2)
Example
Process P1 Process P1 Process P2

P(S1)
P(S2)
{ Use R1&R2 }
V(S1)
V(S2)
Process P2
P(S1)
P(S2)
{ Use R1&R2 }
V(S1) t
V(S2) S1 = 1 S2 = 1
Example

P(S1)
P(S1)
P(S2)
{ Use R1&R2 }
V(S1)
V(S2)
Process P2
P(S1)
P(S2)
{ Use R1&R2 }
V(S1) t
V(S2) S1 = 0 S2 = 1
Example

P(S1)
P(S1)
P(S2)
{ Use R1&R2 } P(S1)
P2 block()
V(S1) Enter queue for R1
V(S2)
Process P2
P(S1)
P(S2)
{ Use R1&R2 }
V(S1) t
V(S2) S1 = -1 S2 = 1
Example

P(S1)
P(S1)
P(S2)
{ Use R1&R2 } P(S1)
P2 block()
V(S1) P(S2)
Enter queue for R1
V(S2)
Process P2
P(S1)
P(S2)
{ Use R1&R2 }
V(S1) t
V(S2) S1 = -1 S2 = 0
Example

P(S1)
P(S1)
P(S2)
{ Use R1&R2 } P(S1)
V(S1) P(S2)
V(S2) Use R1&R2
Process P2 V(S1)
wakeup(P2)
P(S1)
P(S2)
{ Use R1&R2 }
V(S1) t
V(S2) S1 = 0 S2 = 0
Example

P(S1)
P(S1)
P(S2)
{ Use R1&R2 } P(S1)
V(S1) P(S2)
V(S2) Use R1&R2
Process P2 V(S1)
P(S2)
wakeup(P2)
P(S1) P2 block()
P(S2) Enter queue for R2
{ Use R1&R2 }
V(S1) t
V(S2) S1 = 0 S2 = -1
Example

P(S1)
P(S1)
P(S2)
{ Use R1&R2 } P(S1)
V(S1) P(S2)
V(S2) Use R1&R2
Process P2 V(S1)
P(S2)
P(S1) V(S1)
P(S2) wakeup(P2)
{ Use R1&R2 }
V(S1) t
V(S2) S1 = 0 S2 = 0
Example

P(S1)
P(S1)
P(S2)
{ Use R1&R2 } P(S1)
V(S1) P(S2)
V(S2) Use R1&R2
Process P2 V(S1)
P(S2)
P(S1) V(S2)
Use R1&R2
P(S2) wakeup(P2)
{ Use R1&R2 }
V(S1) t
V(S2) S1 = 0 S2 = 0
Example

P(S1)
P(S2)
{ Use R1&R2 }
V(S1)
V(S2)
Process P2
P(S2)
P(S1)
{ Use R1&R2 }
V(S1) t
V(S2) S1 = 1 S2 = 1
Example

P(S1)
P(S1)
P(S2)
{ Use R1&R2 }
V(S1)
V(S2)
Process P2
P(S2)
P(S1)
{ Use R1&R2 }
V(S1) t
V(S2) S1 = 0 S2 = 1
Example

P(S1)
P(S1)
P(S2)
{ Use R1&R2 } P(S2)
V(S1)
V(S2)
Process P2
P(S2)
P(S1)
{ Use R1&R2 }
V(S1) t
V(S2) S1 = 0 S2 = 0
Example

P(S1)
P(S1)
P(S2)
{ Use R1&R2 } P(S2)
V(S1) P(S2)
V(S2) P1 block()
Enter queue for R2
Process P2
P(S2)
P(S1)
{ Use R1&R2 }
V(S1) t
V(S2) S1 = 0 S2 = -1
Example

P(S1)
P(S1)
P(S2)
{ Use R1&R2 } P(S2)
V(S1) P(S2)
V(S2) P1 block()
P(S1)
Enter queue for R2
Process P2 P2 block()
Enter queue for R1
P(S2)
P(S1)
{ Use R1&R2 }
V(S1) t
V(S2) S1 = -1 S2 = -1
Example

P(S1)
P(S1)
P(S2)
{ Use R1&R2 } P(S2)
V(S1) P(S2)
V(S2) P1 block()
P(S1)
Enter queue for R2
Process P2 P2 block()
Enter queue for R1
P(S2)
Deadlock
P(S1)
{ Use R1&R2 }
V(S1) t
V(S2) S1 = -1 S2 = -1
Definition
A set of processes is deadlocked if each

process in the set is waiting for an event
that only another process in the set can
cause
5.2. Conditions for resource deadlocks
Conditions
4 conditions, must occur at the same time
l Critical resource
l Resource is used in a non-shareable model
l Only one process can use resource at a time
l Other process request to use resource ⇒ request must be
postponed until resource is released
l Wait before enter the critical section
l Process can not enter critical section has to wait in queue
l Still own resources while waiting
l No resource reallocation system
l Resource is non-preemptive
l Resource is released only by currently using process after this process
finished its task
l Circular waiting
l Set of processes {P0, P2, . . . , Pn} waiting in a order: P0 → R1 → P1; P1
→ R2 → P2; . . . Pn−1 → Rn →Pn; Pn → R0 → P0
l Circular waiting create nonstop loop
Example: Dining philosopher problem
l Critical resource
l Wait before enter critical section
l Non-preemptive resource
l Circular waiting
5.3. Solutions for deadlock
5.3. Solutions for deadlock
Methods
l Prevention
l Apply methods to guarantee that the system never has deadlock
l Expensive
l Apply for system that deadlock happens frequently and once it happen
the cost is high
l Avoidance
l Check each process’s resource request and reject request if this request
may lead to deadlock
l Require extra information
l Apply for system that deadlock happens least frequently and once it
happen the cost is high
l Allow the system work normally ⇒ deadlock may happen
l Periodically check if deadlock is happening
l If deadlock apply methods to remove deadlock
l Apply for system that deadlock happens least frequently and once it
happen the cost is low
5.4. Deadlock prevention
Rule
Attack 1 of 4 required conditions for deadlock to appear
Critical resource
Wait before entering critical section
Non-preemptive resource
Circular wait
Critical resource condition
l Reduce the system’s critical degree

l Shareable resource(read-only ffile): accessed simultaneously
l Non-shareable resource: Cannot be accessed simultaneously
l SPOOL mechanism(Simultaneous peripheral operation on-line)
l Do not allocate resource when it’s not necessary
l A limited number of processes can request resourcen
l Only process printer daemon work

with printer ⇒ Deadlock for
resource printer is canceled
l Not any resource can be used

with SPOOL
Wait before entering critical section condition
Rule: Make sure one process request resource only when it doesn’t own
any other resources
l Prior allocate
l processes request all their resources before starting execution and
only run when required resources are allocated
l Effectiveness of resource utilization is low
l Process only use resource at the last cycle?
l Total requested resource higher than the system’s capability?
l Resource release
l Process releases all resource before apply(re-apply) new resource
l Process execution’s speed is low
l Must guarantee that data kept in temporary release resource
won’t be lost
Wait before entering critical section condition - Example
l Process combines of 2 phases

l Copy data from tape to a file in the disk
l Arrange the data in file and bring to printer
phase 1 phase 2
Tape
l Prior allocation method

l Request both tape, file and printer
l Waste printer in first phase, tape in the second phase
Wait before entering critical section condition - Example
l Process combines of 2 phases

l Copy data from tape to a file in the disk
l Arrange the data in file and bring to printer
phase 1 phase 2
Tape
l Prior allocation method

l Request both tape, file and printer
l Waste printer in first phase, tape in the second phase
l Resource release method
l Request tape and file for phase 1
l Release tape and file
l Request file and printer for phase 2
No preemption resource condition

Rule: allow process to preempt resource when it’s necessary
l Process Pi apply for resource Rj
l Rj is available: allocate Rj to Pi
l Rj not available: (Rj is being used by process Pk)
l Pk is waiting for another resource
l Preempt Rj from Pk and allocate to Pi as requested
l Add Rj into the list of needing resource of Pk
l Pk is execution again when
l Receive the needing resource
l Take back resource Rj
l Pk is running
l Pi has to wait (no resource release)
l Allow resource preempt only when it’s necessary
No preemption resource condition

Rule: allow preemptive when it’s necessary
l Only applied for resources that can be store and recover easily
l (CPU, memory space)
l Difficult to apply for resource like printer
l One process is preempted many time ?

Circular wait condition
l provide a global numbering of all type of resources

l R = {R1, R2, . . . Rn} Set of resources
l Construct an ordering function f : R → N
l Function f is constructed based on the order of resource
utilization
f(Tape) = 1
f(Disk) = 5
f(Printer) = 12
l Process can only request resource in an increasing order
l Process holding resource type Rk can only request resource type Rj
satisfy f(Rj) > f(Rk)
l Process requests resource Rk has to release all resource Ri satisfy
condition f(Ri) ≥ f(Rk)
Circular wait condition

l Process can only request resource in an increasing order
l Process holding resource type Rk can only request resource type Rj
satisfy f(Rj) > f(Rk)
l Process requests resource Rk has to release all resource Ri satisfy
condition f(Ri) ≥ f(Rk)
l Prove
l Suppose deadlock happen between processes {P1, P2, . . . Pm}
l R1 → P1 → R2 → P2 ⇒ f(R1) < f(R2)
l R2 → P2 → R3 → P3 ⇒ f(R2) < f(R3) . . .
l Rm → Pm → R1 → P1 ⇒ f(Rm) < f(R1)
l f(R1) < f(R2) < . . . < f(Rm) < f(R1) ⇒invalid
5.5. Deadlock avoidance
Example
P1 P(S1) P(S2) S1 = 01
Request R1 t
P2 P(S2) P(S1) S2 = 1
Example
P1 P(S1) P(S2) S1 = 0
use R1 t
Request R2
P2 P(S2) P(S1) S2 = 1
Example
P1 P(S1) P(S2) S1 = 0
use R1 t
Use R2 Request R1
P2 P(S2) P(S1) S2 = 0
Example
P1 P(S1) P(S2) S1 = -1
DeadLock
use R1 Request R2 t
Use R2 request R1
P2 P(S2) P(S1) S2 = -1
0
Example
P1 P(S1) P(S2) S1 = 0
Block(P2)
use R1 Request R2 t
Request R2
P2 P(S2) P(S1) S2 = 1
Example
P1 P(S1) P(S2) S1 = 0
Block(P2)
use R1 use R2 t
Request R2
P2 P(S2) P(S1) S2 = 0
Conclude:
If processes’ orders of request/release resources are known
in advance, the system could make a resource allocation
decision (accept or block) for all request to let deadlock not
occur.
Rule
l Must know in advance information of processes and resources

l Process has to declare the maximum amount of each resources type
that is required for execution
l Decision is made based on the result of Resource-Allocation State check
l Resource allocation state is defined by following parameters
l Number of resource unit available in the system
l Number of resource unit allocated for each process
l Number of maximum resource unit each process may request
l If system is safe, request is accepted
l Perform checking every time a resource request is received
l Objective: Guarantee the system’s always in safe state
l At the beginning (resource is not allocated), system is safe
l Only allocate resource when safety is guaranteed
⇒ System changes from current safety state to another safety state
Safe state
The system’s state is safe when
l It’s possible to provide resource for each process (to

maximum requirement) follow an order such that
deadlock will not occur
l A safe sequence of all processes is existed

Safe sequence
Set of process P={P1, P2, . . . , Pn} is safe if

l For each process Pi, each resource request in future is accepted due to
l The amount of available resource in the system
l Resource is currently occupied by process Pj(j < i)
In safe sequence, when Pi request for resource
l If not accept immediately, Pi wait until Pj terminates (j < i)
l When Pj terminate and release resource, Pi receives required
resource, executives, releases allocated resource and terminate
l When Pj terminate and release resource ⇒ Pi+1 will receive resource
and able to finish. . .
l All the processes in the safe sequence is able to finish
Example
Consider a system includes

l 3 processes P1, P2, P3 and one resource R has 12 units
l (P1, P2, P3) may request maximum (10, 4, 9) unit of resource R
l At time t0, (P1, P2, P3) allocated (5, 2, 2) unit of resource R
l At current time (t0), is the system safe?
l System allocate (5 + 2 + 2) units => 3 units remain
l (P1, P2, P3) may request (5, 2, 7) units
l With current 3 units, all request of P2 is acceptable ⇒ P2 guaranteed
to finish and will release 2 unit of R after finished
l With 3 + 2 units, P1 guaranteed to finish and will release 5 units
l With 3 + 2 + 5 unit P3 guaranteed to finish
l At time t0, P1, P2, P3 are guaranteed to finish ⇒ system is safe with safe
sequence (P2, P1, P3)
Example
Consider a system includes
l 3 processes P1, P2, P3 and one resource R has 12 units
l (P1, P2, P3) may request maximum (10, 4, 9) unit of resource R
l At time t0, (P1, P2, P3) allocated (5, 2, 2) unit of resource R
l A time t1, P3 request and allocated 1 resource unit. Is the system safe?
l With current 2 units, all request of P2 is acceptable ⇒ P2 guaranteed
to finish and will release 2 unit of R after finished
l When P2 finished, the amount of available resource in the system is 4
l With 4 resource unit, P1 and P3 both have to wait when apply for 5
more resource unit
l Hence, system is not safe with (P1, P3)
l Remark: At time t1, if P3 has to wait when request for 1 more resource
unit, deadlock will be removed
Example
l Conclude
l System is safe ⇒ Processes are able to finish
⇒ no deadlock
l System is not safe ⇒ Deadlock may occur
l Method
l Verify all resource request
l If the system is still safe after allocate resource ⇒ allocate
l If not ⇒ process has to wait
l The banker algorithm
The banker algorithm: Introduction
l Good for systems have resources with many units

l New appearing process has to declare the maximum unit of each
resource type
l Not larger than the total amount of the system
l When one process request for resource, system verify if it’s safe to
accept this requirement
l If system still safe ⇒ Allocate resource for process
l Not safe ⇒ wait
Algorithm’s data I
System
n number of process in the system
m number of resource type in the system
Data structures
Available Vector with length m represents the number of available
resource in the system. (Available[3] = 8 ⇒?)
Max Matrix n ∗m represents each process maximums request for
each type of resource. (Max[2,3] = 5 ⇒?)
Allocation Matrix n ∗m represents amount of resource allocated for
processes (Allocation[2,3] = 2 ⇒?)
Need Matrix n ∗m represents amount of resource is needed for each
process Need[2,3] = 3 ⇒?)
Need[i][j] = Max[i][j] - Allocation[i][j]
Algorithm ‘s data I
Rule
l X, Y are vectors with length n
l X ≤ Y ⇔ X[i] ≤ Y[i] ∀i = 1, 2, . . . , n
l Each row of Max,Need,Allocation is processed like vector
l Algorithm calculated on vectors
l Local structures
Work vector with length m represents how much each resource
still available
Finish vector with Boolean type, length m represents if a process
is guaranteed to finish or not
Algorithm for safety checking

BOOL Safe(Current Resource-Allocation State){
Work←Available
for (i : 1 → n) Finish[i]←false
flag← true
While(flag){
flag←false
for (i : 1 → n)
if(Finish[i]=false AND Need[i] ≤Work){
Finish[i]← true
Work ← Work+Allocation[i]
flag← true
}//endif
}//endwhile
for (i : 1 → n) if (Finish[i]=false)return false
return true;
}//End function
Example
l Consider system with 5 processes P0, P1, P2, P3, P4 and 3 resources R0, R1, R2
l R0 has 10 units, R1 has 5 units, R2 has 7 units
l Maximum resource requirement and allocated resource for each process
R0 R1 R2 R0 R1 R2
P0 7 5 3 P0 0 1 0
P1 3 2 2 P1 2 0 0
P2 9 0 2 P2 3 0 2
P3 2 2 2 P3 2 1 1
P4 4 3 3 P4 0 0 2
Max Allocation
l Is the system safe?
l P1 requests 1 unit of R0 and 2 unit of R2?
l P4 requests 3 unit of R0 and 3 unit of R1?
l P0 requests 2 unit of R1. allocate?
Example: Check for safety

l Number of available resource in the system Available(R0, R1, R2) =(3, 3, 2)
l Remaining request of each process (Need = Max - Allocation)
R0 R1 R2 R0 R1 R2 R0 R1 R2
P0 7 5 3 P0 0 1 0 P0 7 4 3
P1 3 2 2 P1 2 0 0 P1 1 2 2
P2 9 0 2 P2 3 0 2 P2 6 0 0
P3 2 2 2 P3 2 1 1 P3 0 1 1
P4 4 3 3 P4 0 0 2 P4 4 3 1
Max Allocation Need

R0 R1 R2 R0 R1 R2 R0 R1 R2
P0 7 5 3 P0 0 1 0 P0 7 4 3
P1 3 2 2 P1 2 0 0 P1 1 2 2
P2 9 0 2 P2 3 0 2 P2 6 0 0
P3 2 2 2 P3 2 1 1 P3 0 1 1
P4 4 3 3 P4 0 0 2 P4 4 3 1
Max Allocation Need
Process P0 P1 P2 P3 P4
Finish FF FTF FTF FF F
Work (7,4,3)
(3,3,2)
(5,3,2)

R0 R1 R2 R0 R1 R2 R0 R1 R2
P0 7 5 3 P0 0 1 0 P0 7 4 3
P1 3 2 2 P1 2 0 0 P1 1 2 2
P2 9 0 2 P2 3 0 2 P2 6 0 0
P3 2 2 2 P3 2 1 1 P3 0 1 1
P4 4 3 3 P4 0 0 2 P4 4 3 1
Max Allocation Need
Finish FFT T T T
System is safe
TF
(P1, P3, P4, P0, P2)
Work (7,4,5)
(10,5,7)
(7,5,5)
Algorithm for resource request

l Request[i] Resource requesting vector of process Pi
l Request[3,2] = 2: P3 requests 2 units of resource R2
l When Pi make a resource request, the system checks
① if(Request[i]>Need[i])
Error(Request higher than declared number)
② if(Request[i]>Available)
Block(Not enough resource, process has to wait)
③ Set the new resource allocation for the system
l Available = Available - Request[i]
l Allocation[i] = Allocation[i] + Request[i]
l Need[i] = Need[i] - Request[i]
④ Allocate resource based on the result of new system safety check
if(Safe(New Resource Allocation State))
Allocate resource for Pi as requested
else
Pi has to wait
Recover former state (Available, Allocation,Need)
Example: P1 request (1, 0, 2)

l Request[1]≤Available ((1, 0, 2) ≤ (3, 3, 2)) ⇒ It’s possible to allocate
l If allocate resource: Available = ( 2 , 3, 0)
R0 R1 R2 R0 R1 R2
P0 0 1 0 P0 7 4 3
P1 3 0 2 P1 0 2 0
P2 3 0 2 P2 6 0 0
P3 2 1 1 P3 0 1 1
P4 0 0 2 P4 4 3 1
Allocation Need
Finish F F F F F
Work (2,3,0)

R0 R1 R2 R0 R1 R2
P0 0 1 0 P0 7 4 3
P1 3 0 2 P1 0 2 0
P2 3 0 2 P2 6 0 0
P3 2 1 1 P3 0 1 1
P4 0 0 2 P4 4 3 1
Allocation Need
Finish F FF F F F
Work (2,3,0)

R0 R1 R2 R0 R1 R2
P0 0 1 0 P0 7 4 3
P1 3 0 2 P1 0 2 0
P2 3 0 2 P2 6 0 0
P3 2 1 1 P3 0 1 1
P4 0 0 2 P4 4 3 1
Allocation Need
Finish F T FF F F
Work (5,3,2)

R0 R1 R2 R0 R1 R2
P0 0 1 0 P0 7 4 3
P1 3 0 2 P1 0 2 0
P2 3 0 2 P2 6 0 0
P3 2 1 1 P3 0 1 1
P4 0 0 2 P4 4 3 1
Allocation Need
Finish F T F F F
Work (5,3,2)

R0 R1 R2 R0 R1 R2
P0 0 1 0 P0 7 4 3
P1 3 0 2 P1 0 2 0
P2 3 0 2 P2 6 0 0
P3 2 1 1 P3 0 1 1
P4 0 0 2 P4 4 3 1
Allocation Need
Finish F T F T F
Work (7,4,3)

R0 R1 R2 R0 R1 R2
P0 0 1 0 P0 7 4 3
P1 3 0 2 P1 0 2 0
P2 3 0 2 P2 6 0 0
P3 2 1 1 P3 0 1 1
P4 0 0 2 P4 4 3 1
Allocation Need
Finish F T F T T
Work (7,4,5)

R0 R1 R2 R0 R1 R2
P0 0 1 0 P0 7 4 3
P1 3 0 2 P1 0 2 0
P2 3 0 2 P2 6 0 0
P3 2 1 1 P3 0 1 1
P4 0 0 2 P4 4 3 1
Allocation Need
Finish T T F T T
Work (7,5,5)

R0 R1 R2 R0 R1 R2
P0 0 1 0 P0 7 4 3
P1 3 0 2 P1 0 2 0
P2 3 0 2 P2 6 0 0
P3 2 1 1 P3 0 1 1
P4 0 0 2 P4 4 3 1
Allocation Need
Finish T T T T T Request is accepted

Work (10,5,7)
Example: (continue)
l P4 request 3 units of R0 and 3 units of R2
l Request[4] = (3, 0, 3)
l Available = (2, 3, 0)
⇒ Resource is not enough, P4 has to wait
l P0 request 2 units of R1
l If allocate: Available = (2 , 1, 0)
l Perform Safe algorithm
⇒ All processes may not finish
⇒ if accepted, system may be unsafe
⇒ Resource is sufficient but do not allocate, P0 has to wait
5.6. Deadlock detection and recovery
Introduction
l Rule
l Do not apply deadlock prevention or avoidance method, allow
deadlock to occur
l Timely check if the system has deadlock or not if yes then find a
solution
l To function properly, system has to provide
l Algorithm to check if the system is deadlock or not
l Algorithm to recorver from deadlock
l Deadlock detection
l Algorithm for showing the deadlock
l Deadlock recovery
l Terminate process
l Resource preemptive
Algorithm to point out deadlock: Introduction

l Apply for system that has resource types with many units
l Similar to banker algorithms
l Data structures
l Available Vector with length m: Available resource in the system
l Allocation Matrix n ∗ m: Resources allocated to processes
l Request Matrix n ∗ m: Resources requested by processes
l Local structures
l Work Vector with length m: available resource
l Finish Vector with length n: process is able to finish or not
l Rule
l ≤ relations between Vectors
l Rows in matrix n ∗ m are processed similar to vectors
Algorithm to point out deadlock

BOOL Deadlock(Current Resource-Allocation State){
Work←Available
for (i : 1 → n)
if(Allocation[i]≠0) Finish[i]←false
else Finish[i]←true; //Allocation = 0 not in waiting circular
flag← true
While(flag){
flag←false
for (i : 1 → n)
if (Finish[i] = false AND Request[i] ≤ Work){
Finish[i]← true
Work ← Work+Allocation[i]
flag← true
}//endif
}//endwhile
for (i : 1 → n) if (Finish[i] = false) return true;
return false; //Finish[i] = false, process Pi is in deadlock
}//End function
Example
l 5 processes P0, P1, P2, P3, P4; 3 resources R0, R1, R2
l Resource R0 has 7 units, R1 has 2 units, R2 has 6 units
l Resource allocation status at time t0
R0 R1 R2 R0 R1 R2
P0 0 1 0 P0 0 0 0
P1 2 0 0 P1 2 0 2
P2 3 0 3 P2 0 0 0
P3 2 1 1 P3 1 0 0
P4 0 0 2 P4 6 0 2
Allocation Request
l Available resource (R0, R1, R2) =(0, 0, 0)
Example
R0 R1 R2 R0 R1 R2
P0 0 1 0 P0 0 0 0
P1 2 0 0 P1 2 0 2
P2 3 0 3 P2 0 0 0
P3 2 1 1 P3 1 0 0
P4 0 0 2 P4 6 0 2
Allocation Request
Finish F F F F F
Work (0,0,0)
Example
R0 R1 R2 R0 R1 R2
P0 0 1 0 P0 0 0 0
P1 2 0 0 P1 2 0 2
P2 3 0 3 P2 0 0 0
P3 2 1 1 P3 1 0 0
P4 0 0 2 P4 6 0 2
Allocation Request
Finish T FF F F F
Work (0,1,0)
Example
R0 R1 R2 R0 R1 R2
P0 0 1 0 P0 0 0 0
P1 2 0 0 P1 2 0 2
P2 3 0 3 P2 0 0 0
P3 2 1 1 P3 1 0 0
P4 0 0 2 P4 6 0 2
Allocation Request
Finish T F T F F
Work (3,1,3)
Example
R0 R1 R2 R0 R1 R2
P0 0 1 0 P0 0 0 0
P1 2 0 0 P1 2 0 2
P2 3 0 2 P2 0 0 0
P3 2 1 1 P3 1 0 0
P4 0 0 2 P4 6 0 2
Allocation Request
Finish T F T T FF
Work (5,2,4)
Example
R0 R1 R2 R0 R1 R2
P0 0 1 0 P0 0 0 0
P1 2 0 0 P1 2 0 2
P2 3 0 2 P2 0 0 0
P3 2 1 1 P3 1 0 0
P4 0 0 2 P4 6 0 2
Allocation Request
Finish T FF T T F
Work (5,2,4)
Example
R0 R1 R2 R0 R1 R2
P0 0 1 0 P0 0 0 0
P1 2 0 0 P1 2 0 2
P2 3 0 2 P2 0 0 0
P3 2 1 1 P3 1 0 0
P4 0 0 2 P4 6 0 2
Allocation Request
Finish T T T T F
Work (7,2,4)
Example
R0 R1 R2 R0 R1 R2
P0 0 1 0 P0 0 0 0
P1 2 0 0 P1 2 0 2
P2 3 0 2 P2 0 0 0
P3 2 1 1 P3 1 0 0
P4 0 0 2 P4 6 0 2
Allocation Request
System has no deadlock
Finish T T T T T (P0, P2, P3, P1, P4)
Work (7,2,6)
Example
l At time t1: P2 request 1 more resource unit of R2
l Resource allocation status
R0 R1 R2 R0 R1 R2
P0 0 1 0 P0 0 0 0
P1 2 0 0 P1 2 0 2
P2 3 0 3 P2 0 0 1
P3 2 1 1 P3 1 0 0
P4 0 0 2 P4 6 0 2
Allocation Request

Example
R0 R1 R2 R0 R1 R2
P0 0 1 0 P0 0 0 0
P1 2 0 0 P1 2 0 2
P2 3 0 3 P2 0 0 1
P3 2 1 1 P3 1 0 0
P4 0 0 2 P4 6 0 2
Allocation Request
Finish F F F F F
Work (0,0,0)
Example
R0 R1 R2 R0 R1 R2
P0 0 1 0 P0 0 0 0
P1 2 0 0 P1 2 0 2
P2 3 0 3 P2 0 0 1
P3 2 1 1 P3 1 0 0
P4 0 0 2 P4 6 0 2
Allocation Request
Finish T FF F FF FF
Work (0,1,0)
Example
R0 R1 R2 R0 R1 R2
P0 0 1 0 P0 0 0 0
P1 2 0 0 P1 2 0 2
P2 3 0 2 P2 0 0 1
P3 2 1 1 P3 1 0 0
P4 0 0 2 P4 6 0 2
Allocation Request
Finish T FF F FF FF
Work (0,1,0)
P0 may finish but the system is deadlock.

Processes are waiting for each other(P1, P2, P3, P4)
Deadlock recorvery: Process termination method

Rule: Terminate processes in deadlock and take back allocated resource
l Terminate all processes
l Quick to eliminate deadlock
l Too expensive
l Killed processes may be almost finished
l Terminate processes consequently until deadlock is removed
l After process is terminated, check if deadlock is still exist or not
l Deadlock checking algorithm complexity is m ∗ n2
l Need to point out the order of process to be terminated
l Process’s priority
l Process’s turn around time, how long until process finish
l Resources that process is holding, need to finish
l ...
l Process termination’s problem
l Process is updating file ⇒ File is not complete
l Process is using printer ⇒ Reset printer’s status
Deadlock recorvery: Resource preemption method

Preempt continuously several resources from a deadlocked processes and give to
other processes until deadlock is removed
Need to consider:
① Victim’s selection
l Which resource and which process is selectedd?
l Preemptation ‘s order for smallest cost
l Amount of holding resource, usage time. . .
② Rollback
l Rollback to a safe state before and restart
l Require to store state of running process
③ Starvation
l One process is preempted many times ⇒ infinite waiting
l Solution: record the number of times that process is preempted
Another solution ?

Operating System-Chap 2-Eng

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Operating System-Chap 2-Eng

Uploaded by

Copyright:

Available Formats

Hệ Điều Hành

(Nguyên lý các hệ điều hành)

l Process: a sequence of system’s state changing

Process is the execution of a program

Process >< program

Compile and run a program

Source code Binary file(.o file)

Compile and run a program

Process’s states changing flowchart (Silberschatz 2002)

System that has only one processor

Process Control Block (PCB)

Single-thread process and Multi-thread process

l Single-thread process : A running process with only one

l Multi-thread process : Process with more than one executed

Objective Maximize CPU’s usage time

Single processor system

End of processor usage time slice

Child Create child process

Process queue III

l Process selected and running

*Selection process is carried out by the appropriate scheduler

l Job selection problem

Process swapping (Medium-term scheduler)

Processes’ relation classification

Producer - Consumer Problem I

• The system includes 2 processes

Producer - Consumer Problem II

Producer - Consumer Problem II

Communicate between process

• Inter-process communication model Process A M

Message passing system

l Each process that wants to communicate must explicitly name

l Non-blocking receive The receiver retrieves either a valid message or

Windows XP Message Passing

Communication in Client - Server Systems with Sockets

Winsock API 32 functions

socket()Tạo socket truyền dữ liệu

Use Winsock to make a Client-Server program

Example: Vector computation

l Large size vector computing

Process P Msg receiving problem Process Q

Program - Process - Thread

l Program: Sequence of instructions, variables,..

Single-threaded and multi-threaded process

Example: Word processor (Tanenbaum 2001)

l Basic CPU using unit, consists of

Distinguishing between process and thread

Has code/data/heap and other segments No separating code or heap segment

Benefit of multithreading-> example

Tính toán trên vector

User space Kernel space

User -Level Threads

l Thread management is done by application

Kernel - Level threads

l Kernel keeps information of process and threads

l Many systems provide support for both user and kernel

l Maps each user thread to a kernel thread

l Multiplexes many user-level threads to a

Functions with thread in WIN32 API

Executive thread block

The result of parallel running

CPU-I/0 Burst Cycle

Preemptive and non-preemptive Scheduling