Critical Sections

1
Critical Sections

• For satisfactory mutual exclusion
• no two processes in critical region at any time
• no assumptions are to be made about speed or
  number of CPUs
• no process outside critical region may be blocked
• no process to wait forever to enter critical
  region
• Solutions
• Disable interrupts
• unwise to allow processes to disable interrupts
• may not turn them on again
• more than one processor disabling interrupts
  affects only one CPU hence can still access
  shared memory
• kernel may disable interrupts

2
Fig 1 Two processes competing for memory at the
same time
Spooler Directory . . .
out 4
abc
4 5 6 7
Process A
Prog.c
Prog.n
in 7
Process B
3
Lock Variables
Initially 0 process enters critical region if
lock 0 (i) process sets lock 1 enter
critical region else if lock 1 wait until
lock 0 if process gets to (i) and is
interrupted then 2nd process sets lock 1 now
if process 2 swapped out while in critical region
process 1 restarts it will now also be in
critical region
4
Strict Alternation

• while (TRUE) while (TRUE)
• while (turn 0) while (turn 1)
• critical region() critical region()
• turn 0 turn 1
• noncritical_region() noncritical_region()
• Process0 Process1
• turn is initially 1, hence Process0 enters
  critical region meanwhile Process1 sits in loop.
  As Process0 leaves critical region , sets turn
  0 to allow Process1 to enter critical region .
• If one Process0 much slower than Process1, then
  process will not be able to re-enter critical
  region .

5
Test and Set Lock(TSL)

• Hardware solution
• Copies the old value of lock from memory to CCR
  - sets lock 1
• Compare the old value with 0
• if lock 1
• loop
• else
• enter critical region
• Note The tsl command is indivisible therefore
  cannot be interrupted part way through copying
  old value to CCR and setting lock to 1
• On leaving the critical region reset lock to 0.
• enter_region
• tsl register,lock /copy lock to register and
  set lock to 1 / cmp register,0 / was lock
  zero? / jne enter_region /if it was non zero,
  lock was set, so loop/ ret /return to caller
  critical region entered/leave_region
• move lock,0 / store a 0 in lock / ret /
  return to caller /
• This solution works!

6
Semaphores
wait(s) if sgt 0 then set s to s -
1 else block the calling process
(ie. wait on s) endif signal(s) if any
processes are waiting on s start one
of these processes else set s to s
1 endif
7
Interprocess Communication

• Signals
• Shared files i.e pipes
• Message passing
• Shared memory
• Signals
• Like an interrupt
• From user process to kernel
• e.g. CTRL C kernel sends a signal SIGINT
  terminates execution

8

• Signals are a relatively low level inter-process
  communication method which is used in UNIX. The
  signal arranges for a user defined function to be
  called, when a particular event occurs.
• Synchronous signals - frequently generated by the
  hardware when an internal error has occurred such
  as - divide by zero, illegal instruction, memory
  access violation etc. These always happen at the
  same place each time a program is run hence the
  term synchronous.
• Asynchronous signals their occurrence is
  normally random. There are three main sources of
  such signals
• Another process. The system call used to send a
  signal is kill().
• A terminal driver sends a signal when a special
  key is pressed. e.g the panic key combination in
  UNIX is CTRL-C. This sends the SIGINT which
  generates an interrupt.
• The alarm() library call which resets any
  previous setting of a timer. The kernel sends
  SIGALARM to the calling process when the time
  expires. The default action terminates the
  process.

9
Signal Program

• Example
• include ltsignal.hgt
• include ltstdio.hgt
• include ltunistd.hgt
• void ouch(int sig)
• printf("OUCH! I got signal d\n, sig)
• main()
• signal(SIGINT, ouch)
• while(1)
• printf("Hello world\n")
• sleep(1)

10
(No Transcript)
11
Inter Process Communication

• Pipes
• ls lmore
• Pipes remain alive only as long as process which
  created them
• i.e. unread data when process terminates will be
  lost
• Named Pipes
• FIFO i.e. a permanent UNIX file
• Can be opened by any number of processes for
  reading
• and writing would require access permissions.
• Message passing - communication via message
  queues
• Shared memory - area of memory shared by two or
  more processes

12
Definition A semaphore is simply A
non-negative integer, which apart from its
initialisation, can be acted on only by two
standard, atomic, non-interruptible operations,
WAIT( which decrements the value of the
semaphore) and SIGNAL (which increments the
value).
13
Semaphores

• The semaphore essentially indicates the
  availability of a resource.
• If it is greater than zero it is available, if it
  zero it is not.
• The signal operation signals that a process has
  released a resource which can now be used by a
  waiting process.
• The wait operation may allow a process access to
  the resource (s gt 0) or may cause the process to
  be blocked.
• Wait and signal are indivisible.
• When semaphore which can be only 0 or 1 is
  called a binary semaphore, otherwise it is a
  counting semaphore.

14
Semaphores

• Producer Consumer problem
• Bounded buffer
• Can be accessed by both simultaneously
• There are N slots in buffer
• e.g. a print routine sending characters to a
  printer driver

• There are essentially two requirements
• To guard against attempting to write to the
  buffer when it is full
• To prevent the consumer reading from the buffer
  when it is empty

15
Producer Consumer problem.

• Bounded buffer it has a limited size. Often
  implemented as a circular buffer. i.e. when last
  location full it starts to overwrite first
  location.
• Can be accessed by producer and consumer
  simultaneously problem!
• Initially imagine there are N slots in buffer,
  e.g. a print routine sending characters to a
  printer driver.
• There are essentially two requirements
• to guard against attempting to write to the
  buffer when it is full
• to prevent the consumer reading from the buffer
  when it is empty

16
Producer Explanation produce item
Application produces data item wait (space) If
buffer full, wait for space signal wait
(free) If buffer being used, wait for free
signal add item to buffer All clear put item in
next buffer slot signal (free) Signal that
buffer no longer in use signal (data) Signal
that data has been put in buffer Consumer wait
(data) Wait until at least one item in
buffer wait (free) If buffer being used, wait
for free signal get item from buffer All clear
get item from buffer signal (free) Signal that
buffer no longer in use signal (space) Signal
that at least one space exists in
buffer consume item Application specific
processing of item.
17
Semaphores for Mutual Exclusion

• After initialisation the semaphore is 1 as shown
  in (a) i.e there are no processes in the wait
  queue. After the first WAIT the semaphore is set
  to 0 (b). If a second process does a WAIT, the
  semaphore is not decremented further, but that
  process is blocked and put in a wait queue(c).
  Any subsequent processes that WAIT on that
  semaphore are added to the tail of the queue(d).1
• When the first process does a SIGNAL and leaves
  the critical section, one of the waiting
  processes is woken up and moved from the wait
  queue to the run queue. The value of the
  semaphore is unchanged. All waiting processes are
  then run and only when the last one leaves the
  critical section if the semaphore restored to1.

1
0
0
0
P1
P1
P2
(a) (b) (c) (d)
18
Semaphores for Synchronisation. Imagine two
processes where Process A must not pass a point
P1 in its code until process B has reached a
point P2 in its code. For example, A may require
an item at P1 which is only provided by B at
point P2.
Process A Process B
P1 ---WAIT(S)
P2 --- SIGNAL(S)

0
1
PA
(a) (b) (c)
If process A gets to P1 before B gets
to P2 then A executes a WAIT on the semaphore, It
is blocked (0 value semaphore), and put in the
wait queue. The signal changes from (b) to (c).
When B eventually gets to P2 and does a SIGNAL on
the semaphore, A will be woken up, and continue
execution. The value of the semaphore is always 0
in this case.
19
Semaphores for Synchronisation Another scenario
is that B can get to P2 before A gets to P1. In
this case the value of the semaphore is
incremented to 1.
Process A Process B
P2 --- SIGNAL(S)
P1 ---WAIT(S)
0
1
(a) (b) (c)
It changes from the state shown in (b) to (c).
Then when A does a WAIT, it is not held up, but
the semaphore is decremented, and returns to
state (b).
20
Semaphores for resource management. Resources
can be physical things like printers or can be
virtual resources such a slots in a buffer. The
semaphore is initialised to the number of
instances available. For example, suppose there
are two printers available. A semaphore P, to
control printer allocation, is initialised to 2.
2
1
0
0
P3
process1 process2 process3 WAIT
WAIT WAIT (a) (b) (c) (d)
As each process requests a printer, it does a
WAIT on the semaphore P. The first process
changes state of the semaphore to (b) and is
granted the first printer. The second process
changes the state of the semaphore to (c) and is
granted the second printer. When the third
process requests a printer and does a WAIT on the
(zero valued) semaphore, it is not allowed to
continue, as there is no printer available. It is
put to sleep (d). When one of the processes
returns a printer, it does a signal on the
semaphore, which wakes up the waiting process and
moves the state of the semaphore back to (c).
21
Deadlock

•         a circle of wait conditions exists
•         the driver of each car only sees the
  car in front no-one can see the global situation
•         the deadlock can only be broken by one
  or more cars relinquishing the space they occupy
•         it will generally require intervention
  from an outside agency (the police) to resolve
  the problem.

22
Deadlock
Example

• Airline booking using file locking
• A locks AB123 outgoing flight
• B locks AB456 return flight
• A requests AB456 return flight
• B requests AB123 outgoing flight
• Clerk(s) may nor realise the long wait is their
  fault (can only see car in front)

23
Deadlock
Consumer producer problem The normal situation
for a producer is produce item wait (space)
wait (free) add item to buffer signal
(free) signal (data)
24
Deadlock
Producer Explanation produce item wait
(free) Can enter if no process in critical
region. free 0 wait (space) Cant continue if
buffer full - blocked add item to
buffer signal (free) signal
(data) Consumer wait (data) o.k. to
proceed as buffer is full wait (free) cant
progress as free 0 Deadlock!!! get item from
buffer signal (free) signal
(space) consume item
25
Deadlock

• There are three necessary and sufficient
  conditions for deadlock to occur
• The resources involved cannot be shared only
  one process at a time can use
• a particular resource.
• 2. No preemption once a resource has been
  allocated to a process, that resource
• cannot be preempted by another process.
  Processes hold on to the resources
• they have been allocated until they release them
  voluntarily.
• 3. Processes can request additional resources at
  any time request additional
• resources at any time.
• These are necessary, but will not cause deadlock
  without
• 4. There must be a circular chain of two or more
  processes, each waiting
• for a resource held by the next process in the
  chain

26
Deadlock

• The conditions for deadlock can be explained
  using the following analogy
• 2 trains heading towards each other on the same
  track, where the processes or threads are the
  trains, and the resources are the sections of
  track.
• Condition 1 - The first condition means that you
  cannot have two trains at exactly the same place
  at the same time.
• Condition 2 - The second condition means that a
  train may not be pushed aside or otherwise
  forcibly removed from the section of track that
  it is on.
• Condition 3 - The third condition means that a
  train (which already occupies a section of track)
  can occupy another section of track by moving
  forwards.
• Condition 4 - The fourth condition occurs when
  the two trains meet head on they are both stuck
  waiting for an opportunity to move forward onto
  the section of the track occupied the other,
  while at the same time occupying the section of
  track that the other needs.

27
Deadlock

• Since these are necessary and sufficient
  conditions, the deadlock can be broken if any one
  of them is denied.
• If the trains could somehow magically pass
  through each other, then the first condition
  would be denied since the trains could occupy the
  same section of track at the same time.
• If the train could push the other down the track,
  it would be preempting the use of track that the
  other was occupying, thus denying the second
  condition.
• The third condition could be denied by forcing
  both trains to claim all sections of the track at
  once before going on to the beginning of the
  track..
• The fourth condition is denied if both trains are
  going in the same direction, since the train in
  front never needs to use a section of track
  occupied by the train behind.

28
Deadlock

• Three strategies
• Deadlock prevention
• Deadlock avoidance
• Deadlock detection
• Deadlock prevention
• Mutual exclusion not a starter
• Resource holding process requests all its
  resources at once.
• cannot proceed until it gets them all.
• Inefficient resource required late in process
• may prevent other processes proceeding
• No preemption allow operating system to take
  away resources.

29
Deadlock
Circular wait hierarchic allocation. Resource
requests in a particular order. e.g. (1) CD-ROM
(2) printer (3) plotter (4) tape drive (5)
robot arm If Process A has CD-ROM and requests
the printer while process B has the printer and
requests the CD-ROM we have deadlock. If
resources allocated in numerical order this
cannot happen.
30
Deadlock
Deadlock avoidance Predicts the possibility of a
deadlock Processes are allowed to make resource
requests but will be denied if unsafe Bankers
algorithm Banker lends funds,(all same
currency) to a number of clients Each has
declared maximum amount he will require May
request money in stages doesnt need to pay
back until he has taken the full loan Bankers
reserve is usually less than the sum of clients
demands Client requests loan has banker enough
left to make the further loans that will allow
clients to repay?
31
Bankers Algorithm
Maximum
Used
Name
Safe
Available 10
Maximum
Used
Name
Safe
Available 2
Maximum
Used
Replace Banker ?Operating system Client ?
process Funds ? resource
Name
Unsafe
Available 1
32
Deadlock Detection and Recovery

• The approach adopted by Unix and Microsoft.
  Assume that it is a low probability risk, and to
  do nothing. Simplicity but not good in life
  critical situations
• If deadlock occurs, first necessary to detect it,
  and then recover from it. The Ostrich Algorithm
  leaves it to the user to notices that nothing
  much is happening and kills one or more
  processes.
• Automatic deadlock detection uses a separate
  process to monitor if there is a circular chain
  and deduces that there is deadlock.
• One way to recover is to apply force majeure by
  killing one or more of the deadlocked processes.
  Could ask the user or to select a process at
  random to kill. o.k. for a compiler but may cause
  problems with an editor where there may be a lot
  of unsaved data which would be lost.
• In some cases like a database, killing the
  process may leave the database in an inconsistent
  state. Restarting the process could make matters
  worse.
• A solution to situations like this is to take a
  checkpoint of each process after an important
  update. A checkpoint is a snapshot of the state
  of the entire system. This is saved on disk so
  that the process can be rolled back to the latest
  check-pointed state.

33
Livelock

• Two people are trying to pass in a corridor. Both
  single step to the same side of the corridor,
  thus blocking each other. In an attempt to
  correct the situation both move to the other side
  of the corridor, blocking each other again.
• Differences in timing will normally resolve the
  situation. The difference between livelock and
  deadlock is that there is still some activity,
  but it may not be achieving anything useful.
• Ethernet is an example of livelock where two
  processes transmit data at the same time and when
  they clash, both back off and then retransmit
  after a random delay.
• On a heavily loaded network, the result will be
  that the competing machines will back off for
  longer and longer periods. As the load increases
  the network performance will drop gradually known
  as graceful degradation, where the performance is
  degraded in a graceful way rather than failing
  abruptly.

34
Deadlock

• Problems
• Each process has to pre-declare its maximum
  resource requirements. Not realistic for
  interactive systems
• The avoidance algorithm must be executed every
  time a resource request is made. For a multi-user
  system, the processing overhead would be too great

• Deadlock detection
• Operating system must retain a list of what
  resource each blocked process is waiting for and
  which process holds that resource.
• Algorithm to detect circular chains
• Recovery usually means restarting one or more
  processes
• Sometimes unblocked processes run to completion
  and release resources
• Principal cost of recovery from deadlock is time

35
The End
36
 
Interprocess Communication
 
37
Dynamic Data Exchange
Dynamic Data Exchange (DDE) system is actually a
protocol (or set of guidelines) that enables
DDE-compatible Windows applications to share data
easily with other compatible applications.
Initiate conversation
DDE Client
DDE Server
Send server command
Request server data
Receive server data
Send data to server
Close conversation
38
Object Linking and Embedding

• OLE enables you to create data (called an object)
  in an application.
• An object can be almost anything, such as a
  bitmap, an audio file, a video clip, or a
  spreadsheet.
• You can embed or link that object data to other
  data created with another application.
• Editing becomes much more convenient because you
  can then edit from within the compound document.

39
Question 7 Suggest a more appropriate name for
the signal and kill system calls.
Answer to question 7 In order to reflect their
actual usage, more appropriate names might be
trapsig for signal and sendsig for kill
40
Monitors

• Program that all processes accessing shared data
  must use
• The monitor obeys the following constraints
• Only one process can be active
• Can only access data local to the monitor
• Variables cannot be accessed from outside (data
  hiding)

Procedures
1
2
Entry queue
41
Interprocess Communication

• signals
• shared files i.e. pipes
• message passing
• shared memory
• Dynamic Data Exchange (DDE)
• Object Linking and Embedding (OLE)

• Signals
• Like an interrupt
• From user process to kernel
• e.g. CTRL C kernel sends a signal SIGINT
• terminates execution

42
Interprocess Communication
Trapping and handling signals 1 Ignore the
signal 2. Execute a special handler function 3.
apply default handling (i.e. abort) e.g.
signal(SIGFPE,handle_fpe) where handle_fpe is
the function called Sending signals kill(pid,sig
) where pid is the process identifier sig is
the signal being sent
43
Interprocess Communication
Pipes ls lmore Pipes remain alive only as long
as process which created them i.e. unread data
when process terminates will be lost Named
Pipes FIFO i.e. a permanent UNIX file Can be
opened by any number of processes for reading
and writing would require access
permissions. Message passing communication via
message queues Shared memory area of memory
shared by two or more processes
44
File and Record Locking

• Example
• Airline seat reservations
• Flight AB101 2 customers for 1 seat
• 2 clerks copy booking list to local terminals
• Customer A reserves seat
• Customer B still has original copy and also
  reserves seat overwriting customer As
  reservation.
• File locking may be used to prevent other people
  writing to a file which is open.
• There are 3 types of lock
• File lock cant do anything overkill, nobody
  can access this file, even for other actions but
  o.k when archiving etc.
• Write lock cannot modify or read. Used when
  records are being updated, ensures mutual
  exclusion. No reads to prevent partially updated
  records being read
• Read lock can read but cannot write. Gives most
  freedom. All write locks must be off.

45
File and Record Locking

• Pessimistic as described on previous slide.
• Assumes worst case
• o.k. if high chance of simultaneous access
• guaranteed what you see is what you get
• Optimistic copies file, updates it.
• on write back it locks the record and checks if
  anyone
• else is modifying the data.
• if they are then re-start the transaction
• more efficient
• more hassle if clash occurs
• may not see latest data

46
Readers-writers monitorint reader_count,
busycondition ok_to_read, ok_to_writereadercou
nt 0busy false procedure
start_read()begin if (busy then
ok_to_read.wait) reader_count ok_to_read.sig
nal /Once one reader can start they all
can/end   procedure end_read()begin reader_
count-- if (reader_count 0 then ok_to
write.signal)end   procedure
start_write()begin if ( busy or reader_count !
0 then ok_to_write.wait) busy
trueend  procedure end_write()begin busy
false if (ok_to_read.queue then
ok_to_read.signal) else ok_to_write.signalen
d