Scribd
Upload
3K views

Synchronisation Hardware

This document discusses solutions to the critical section problem in multiprocessing systems. It describes the critical section problem as n processes needing exclusive access to shared data resources. It outlines the requirements for a correct solution as mutual exclusion, progress, and bounded waiting. It then describes different types of solutions - software, hardware, operating system, and language-based. Finally, it presents examples of solutions using hardware synchronization primitives like TestAndSet and Swap instructions.

Uploaded by

Tarun
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
3K views

Synchronisation Hardware

This document discusses solutions to the critical section problem in multiprocessing systems. It describes the critical section problem as n processes needing exclusive access to shared data resources. It outlines the requirements for a correct solution as mutual exclusion, progress, and bounded waiting. It then describes different types of solutions - software, hardware, operating system, and language-based. Finally, it presents examples of solutions using hardware synchronization primitives like TestAndSet and Swap instructions.

Uploaded by

Tarun
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 17

SYNCHRONISATION

HARDWARE
TARUN KUMAR
[email protected]

Critical Section Problem

n processes competing to use some shared data.

No assumptions may be made about speeds or the number


of CPUs.

Each process has a code segment, called Critical Section


(CS), in which the shared data is accessed.

Problem ensure that when one process is executing in its


CS, no other process is allowed to execute in its CS.

CS Problem Dynamics

When a process executes code that manipulates shared


data (or resource), we say that the process is in its Critical
Section (for that shared data).
The execution of critical sections must be mutually
exclusive: at any time, only one process is allowed to
execute in its critical section (even with multiple processors).
So each process must first request permission to enter its
critical section.

CS Problem Dynamics (cont..)

The section of code implementing this request is called the


Entry Section (ES).

The critical section (CS) might be followed by a Leave/Exit


Section (LS).

The remaining code is the Remainder Section (RS).

The critical section problem is to design a protocol that the


processes can use so that their action will not depend on
the order in which their execution is interleaved (possibly on
many processors).

General structure of
process Pi (other is Pj)
do {
entry section
critical section
leave section
remainder section
} while (TRUE);

Processes may share some common variables to synchronize


their actions.

Solution to CS Problem

There are 3 requirements that must stand for a correct


solution:
1.

Mutual Exclusion

2.

Progress

3.

Bounded Waiting

We can check on all three requirements in each proposed


solution, even though the non-existence of each one of
them is enough for an incorrect solution.

Mutual Exclusion
If process Pi is executing in its critical section, then no other
processes can be executing in their critical sections.

Implications:

Critical sections better be focused and short.

Better not get into an infinite loop in there.

If a process somehow halts/waits in its critical section, it


must not interfere with other processes.

Progress
If no process is executing in its critical section and
there exist some processes that wish to enter their
critical section, then the selection of the process that
will enter the critical section next cannot be postponed
indefinitely:

If only one process wants to enter, it should be


able to.

If two or more want to enter, one of them should


succeed.

Bounded Waiting
A bound must exist 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.

Assume that each process executes at a non


zero speed.

No assumption concerning relative speed of the


n processes.

Types of solutions to CS Problem


Software solutions
algorithms whos correctness does not rely on any other
assumptions.
Hardware solutions
rely on some special machine instructions.
Operating System solutions
provide some functions and data structures to the
programmer through system/library calls.
Programming Language solutions
Linguistic constructs provided as part of a language.

Synchronization Hardware

Many systems provide hardware support for critical


section code
Uniprocessors could disable interrupts
Currently running code would execute without
preemption
Generally too inefficient on multiprocessor
systems
Operating systems using this not broadly
scalable

Synchronization Hardware (cont..)

Modern machines provide special atomic hardware


instructions
Atomic = non-interruptible
Either test memory word and set value
Or swap contents of two memory words

TestAndSet Instruction

Definition:
boolean TestAndSet (boolean *target)
{
boolean rv = *target;
*target = TRUE;
return rv;
}

Must be executed atomically

Solution using TestAndSet()

Shared Boolean variable lock, initialized to false.


Solution:
do {
while ( TestAndSet (&lock ))
; // do nothing
// critical section
lock = FALSE;
//
remainder section
} while (TRUE);

Swap Instruction

Definition:
void Swap (boolean *a, boolean *b)
{
boolean temp = *a;
*a = *b;
*b = temp:
}

Solution using Swap()

Shared Boolean variable lock initialized to FALSE ; Each


process has a local Boolean variable key
Solution:
do {
key = TRUE;
while ( key == TRUE)
Swap (&lock, &key );
// critical section
lock = FALSE;
//
remainder section
} while (TRUE);

Bounded-waiting Mutual
Exclusion with TestandSet()
do {
waiting[i] = TRUE;
key = TRUE;
while (waiting[i] && key)
key = TestAndSet(&lock);
waiting[i] = FALSE;
// critical section
j = (i + 1) % n;

while ((j != i) && !waiting[j])


j = (j + 1) % n;
if (j == i)
lock = FALSE;
else
waiting[j] = FALSE;
// remainder section
} while (TRUE);

You might also like