Operating Systems
Lecture #8: Critical Sections
Written by David Goodwin
based on the lecture series of Dr. Dayou Li
and the book Understanding Operating Systems 4th ed.
by I.M.Flynn and A.McIver McHoes (2006)
Department of Computer Science and Technology,
University of Bedfordshire.
Operating Systems, 2013
18th March 2013
Outline
Lecture #8 Critical
Sections
David Goodwin
University of
Bedfordshire
critical sections
management functions
1 critical sections
interesting problems
2 management functions
3 interesting problems
Operating Systems
25
Lecture #8 Critical
Sections
David Goodwin
University of
Bedfordshire
critical sections
3
management functions
critical sections
interesting problems
Operating Systems
25
Introduction - a problem
Lecture #8 Critical
Sections
David Goodwin
University of
Bedfordshire
critical sections
4
management functions
interesting problems
ˆ Problem
ˆ If a process is updating a data structure and another process
is allowed to run before the updating completes, the result
may be inconsistent
ˆ Example 1 (Incorrect result):
ˆ Two processes A and B both run ++x which contains the
following three instructions:
ld x, r1
addi #1, r1
st r1, x
ˆ A is pre-empted by B after the 1st instruction is executed
ˆ B finished after its three instruction are executed
ˆ Switch back to A
Operating Systems
25
Introduction - a problem
Lecture #8 Critical
Sections
David Goodwin
University of
Bedfordshire
critical sections
ˆ Effect: x increments for B
5
management functions
interesting problems
Operating Systems
25
ˆ Net effect: x does not increment for A
CRITICAL SECTIONS
Lecture #8 Critical
Sections
David Goodwin
University of
Bedfordshire
ˆ The common element in all synchronisation schemes is to
allow a process to finish work on a critical section
critical sections
6
management functions
ˆ Also not allowing other processes to have access to it before
the critical section of the program has completed.
interesting problems
ˆ This is called a critical section because its execution must
be handled as a unit.
ˆ The processes within a critical section can’t be interleaved
without threatening the integrity of the operation.
ˆ Definition
ˆ Race conditions: the correctness of result depends on the
relative timing among two or more processes sharing the
same resource
ˆ Critical section: code embodies race conditions
Operating Systems
25
Lecture #8 Critical
Sections
David Goodwin
University of
Bedfordshire
critical sections
management functions 7
interesting problems
Operating Systems
25
management functions
MANAGEMENT FUNCTIONS
Lecture #8 Critical
Sections
David Goodwin
University of
Bedfordshire
critical sections
management functions 8
interesting problems
ˆ Interrupt control
ˆ Interrupt: the processor interrupts a process to stop it when
the time slot assigned to the process is due to end
ˆ If interruption occurs at critical section, the problem
mentioned earlier takes place
ˆ Protection of critical sections from being interrupted:
ˆ Disable interrupts
ˆ Interrupt priority levels: higher level interrupts are allowed
and lower ones are blocked
ˆ Problems:
ˆ An erroneous process may never re-enable if it disables
interrupt
ˆ Clock interrupt may be lost
ˆ Preventing multi-processes waiting for critical sections at the
same time
Operating Systems
25
MANAGEMENT FUNCTIONS
Lecture #8 Critical
Sections
David Goodwin
University of
Bedfordshire
critical sections
management functions 9
interesting problems
ˆ Atomic instructions
ˆ Atomic instruction is indivisible
ˆ Instruction ++x is not an atomic instruction as it consists of
three instructions
ˆ Building atomicity of a relative large code section using
mutual exclusion (also known as mutex lock [MUTual
EXclusion])
ˆ Example 2 (Test-and-set):
mutex lock:
tas lock
blt mutex lock
ret
ˆ Process A tries to get a lock for a memory location
ˆ It tests to see if it can get the lock by running tas
ˆ If the lock is used by another process then it follows branch
of less than (blt) to go back loop and try again
ˆ Otherwise, it gets the lock and returns (ret)
Operating Systems
25
Test-and-set
Lecture #8 Critical
Sections
David Goodwin
University of
Bedfordshire
critical sections
management functions 10
interesting problems
ˆ Test-and-set (TS)
ˆ In single machine cycle, tests to see if the “key” is available
ˆ if it is, sets it to unavailable
ˆ Key is a single bit in a storage location that is zero (if free) or
one (if busy).
ˆ Process (p1) test the condition code using TS, before
entering critical section.
ˆ if no other process is in the critical section, then p1 may
enter, key is set from zero to one (busy)
ˆ if p1 finds the busy code, then it’s placed in a waiting loop,
where it continues to test the key.
ˆ unless first-come first-served was set up, some processes
could be favoured over others
ˆ waiting processes remain in un-productive,
resource-consuming wait loops, known as busy-waiting
Operating Systems
25
WAIT and SIGNAL
Lecture #8 Critical
Sections
David Goodwin
University of
Bedfordshire
critical sections
management functions 11
ˆ WAIT and SIGNAL
ˆ modification of test-and-set, designed to remove busy-waiting
ˆ WAIT
ˆ Activated when process encounters a busy condition
ˆ sets process’s process control block to blacked state and links
interesting problems
it to the queue of processes waiting
ˆ process scheduler selects another process for execution
ˆ SIGNAL
ˆ Activated when a process exits the critical section and
condition code is “free”.
ˆ checks queue of processes waiting to enter and selects one,
setting it to READY state
ˆ WAIT and SIGNAL operations free processes from busy
waiting, returning control to the OS.
Operating Systems
25
Peterson’s algorithm
Lecture #8 Critical
Sections
David Goodwin
University of
Bedfordshire
critical sections
management functions 12
interesting problems
Operating Systems
25
ˆ Peterson’s algorithm
ˆ Two competing processes to take turns in using a shared
resource, using only shared memory for communication
ˆ If one is not interested in using the resource, the other can
use it even when it is not its turn
ˆ Example 3 (Peterson’s code with processes A and B):
int turn;
int want [2];
void mutex lock (int who) who test the lock
{
int other;
other = 1 – who;
want [who] = 1;
turn = other;
while (want[other]t̂urn 6= who);
}
Peterson’s algorithm
Lecture #8 Critical
Sections
David Goodwin
University of
Bedfordshire
ˆ A and B can never be in the critical section at the same time:
critical sections
management functions 13
interesting problems
If A is in its critical section, then either want[1] is false
(meaning B has left its critical section) or turn is 0 (meaning
B is just now trying to enter the critical section, but
graciously waiting). In both cases, B cannot be in critical
section when A is in critical section.
ˆ A process cannot immediately re-enter the critical section if
the other process has set its flag to say that it would like to
enter its critical section.
ˆ a process will not wait longer than one turn for entrance to
the critical section: After giving priority to the other process,
this process will run to completion and set its flag to 0,
thereby allowing the other process to enter the critical section.
Operating Systems
25
Semaphores
Lecture #8 Critical
Sections
David Goodwin
University of
Bedfordshire
critical sections
management functions 14
interesting problems
ˆ Semaphores
ˆ A semaphore is originally a signalling device used in railway to
protect a section of rail track
ˆ In OS it is a protected variable or abstract data type for
restricting access to shared resources such as shared memory
in a multi-process environment
ˆ An OS controls a semaphore by two operations:
ˆ up(semaphore s):
s = s+1
ˆ down(semaphore s):
s = 0 if s==0,
s = s-1if s>0
Operating Systems
25
Semaphores
Lecture #8 Critical
Sections
David Goodwin
University of
Bedfordshire
ˆ A semephore is a non-negative integer variable used as a flag.
ˆ In OS a semephoe performs a similar function to railway
critical sections
management functions 15
device:
ˆ it signals if and when a resource is free and can be used by a
interesting problems
process
ˆ “up” operation, V(s)
ˆ fetch, increment, and store sequence
ˆ like tests-and-set, must be performed as a single indivisible
action to avoid deadlocks
ˆ s cannot be accessed by other processes during the operation
ˆ “down” operation, P(s)
ˆ test, fetch, decrement, and store sequence
ˆ like tests-and-set, must be performed as a single indivisible
action to avoid deadlocks
Operating Systems
25
Semaphores
Lecture #8 Critical
Sections
ˆ Example 3: Four processes P1 to P4 share the same resource
David Goodwin
University of
Bedfordshire
and OS runs a semaphore
ˆ P3 is placed in WAIT state on state 4
ˆ states 6 and 8, when a process exits the critical section, value
critical sections
management functions 16
of s is reset to 1 (free), this triggers one of the blocked
processes, entering into the critical section, resetting s the 0
(busy).
ˆ state 7, P1 and P2 are not trying to do processing.
interesting problems
State
0
1
2
3
4
5
6
7
8
9
Operating Systems
25
calling process
operation
in critical section
P1
P1
P2
P3
P4
P2
P(s)
V(s)
P(s)
P(s)
P(s)
V(s)
P1
P3
P4
V(s)
V(s)
P2
P2
P2
P3
P3
P4
blocked
P3
P3, P4
P4
P4
value of s
1
0
1
0
0
0
0
0
0
1
Monitors
Lecture #8 Critical
Sections
David Goodwin
University of
Bedfordshire
critical sections
management functions 17
interesting problems
ˆ Monitors
ˆ The idea comes from
physical monitors – you can
only display something at a
time on your computer’s
monitor
ˆ Implementing semaphore
using monitor
ˆ When a process occupies
the monitor, OS executes
down() to block and stop
Other processes to access
to the monitor
ˆ When a process is leaves,
OS executes up(), to
allow one of processes
blocked to use the
monitor
Operating Systems
25
Lecture #8 Critical
Sections
David Goodwin
University of
Bedfordshire
critical sections
management functions
interesting problems
Operating Systems
18
25
interesting problems
INTERESTING PROBLEMS - starvation
Lecture #8 Critical
Sections
David Goodwin
University of
Bedfordshire
ˆ Dining philosophers problem (also known as starvation
critical sections
management functions
interesting problems
19
problem)
ˆ The scenario:
ˆ Five philosophers sit at a round table and in the centre lies a
plate of spaghetti that is available to everyone
ˆ There are chopsticks on the table – one between each
philosopher
philosophers can have three status
ˆ The
ˆ
ˆ
ˆ
Operating Systems
25
Think (because they are philosophers)
Eat (as they are hungry) and
Wait (two chopsticks are need to eat spaghetti but only five
available)
INTERESTING PROBLEMS - starvation
Lecture #8 Critical
Sections
David Goodwin
University of
Bedfordshire
critical sections
management functions
interesting problems
Operating Systems
20
25
ˆ The problem
ˆ P1 picks C1 and C5 and starts to eat, P3 follows P1 by
picking up C2 and C3, P2 has to wait even if he is hungry
(because no chopsticks beside him is available
ˆ P3 finished eating and resuming thinking, P1 is still eating,
although C2 becomes available for P2, he is not allowed to
pick it up – this is because otherwise it will soon end up with
each philosopher holding one chopstick (no one can eat)
INTERESTING PROBLEMS - starvation
Lecture #8 Critical
Sections
David Goodwin
University of
Bedfordshire
ˆ
critical sections
management functions
interesting problems
21
ˆ P2 has to wait for C1 which is held by P1
ˆ For some reason, P3 becomes hungry again, so he simply
picks up C2 and C3 and eat
ˆ Poor P2 has no chopstick available at all
ˆ Now P1 decides to think and C1 becomes available to P2,
however, P2 is not allowed to pick up C1 because C2 is not
available
ˆ P2 has to wait for C2 which is held by P3
ˆ As long as P1 and P3 alternate their use of chopsticks
(resources) P2 will never have an opportunity to eat
Operating Systems
25
INTERESTING PROBLEMS - starvation
Lecture #8 Critical
Sections
David Goodwin
University of
Bedfordshire
critical sections
management functions
interesting problems
22
ˆ Controlling philosophers
ˆ Three groups: thinking (T), hungry (H), and eating (E)
ˆ If philo i is H and neither of his neighbour is E, then he can
become E
ˆ If he returns to T, OS tests his neighbours to see if they want
to change to E
ˆ Code:
Operating Systems
25
INTERESTING PROBLEMS - producercustomer
Lecture #8 Critical
Sections
David Goodwin
University of
Bedfordshire
critical sections
management functions
interesting problems
23
ˆ Producer-customer problem
ˆ One process who produces data is called a producer
ˆ The other process who uses the data is called a customer
ˆ The producer can produce data at the time when the
customer has no intention to use or the amount of data is
more than enough for the customer for using at a time
ˆ Solution
ˆ Develop a buffer in between the producer and the customer
ˆ Both can access it but not at the same time
Operating Systems
25
INTERESTING PROBLEMS - producercustomer
Lecture #8 Critical
Sections
David Goodwin
University of
Bedfordshire
critical sections
management functions
interesting problems
24
ˆ Producer-customer problem
ˆ CPU can generate output data much faster than a printer can
print in
ˆ need a buffer to temporarily store data from CPU, retrieved
at an appropriate speed by the printer
ˆ buffer can only hold a finite amount of data
ˆ synchronisation process must delay the CPU from generating
more data while the buffer is full (and also preventing the
printer from retrieving data when the buffer is empty)
ˆ Implemented by two counting sememphores, one to indicte
number of full positions in buffer, one to indicate the number
of empty positions in buffer.
ˆ a third semephore (mutex) will ensure mutual exclusion
Operating Systems
25
INTERESTING PROBLEMS - producercustomer
Lecture #8 Critical
Sections
ˆ Code
David Goodwin
University of
Bedfordshire
critical sections
management functions
interesting problems
Operating Systems
25
25