Mutual exclusion addendum
This presentation is the property of its rightful owner.
Sponsored Links
1 / 43

Mutual Exclusion -- Addendum PowerPoint PPT Presentation


  • 56 Views
  • Uploaded on
  • Presentation posted in: General

Mutual Exclusion -- Addendum. Mutual Exclusion in Critical Sections. RoadMap. Today there are libraries that provide application programmers with semaphores Semaphores are used by programmers to provide for critical sections

Download Presentation

Mutual Exclusion -- Addendum

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Mutual exclusion addendum

Mutual Exclusion -- Addendum


Mutual exclusion in critical sections

Mutual Exclusion in Critical Sections


Roadmap

RoadMap

  • Today there are libraries that provide application programmers with semaphores

  • Semaphores are used by programmers to provide for critical sections

  • Let’s first talk about semaphores and then the OS support for them.


What is a semaphore

What is a semaphore?

  • A semaphore is an integer variable with the following three operations.

    • Initialize: You can initialize the semaphore to any non-negative value.

    • Decrement: The downoperation

      • Semaphore value > 0: Decrement by 1.

      • Semaphore value == 0: If value is 0, the process blocks (gets put into queue). It is said to be sleeping on the semaphore..

    • Increment:The up operation.

      • Semaphore value ==0 and some processes are sleeping on the semaphore, one is unblocked. Otherwise, value is incremented.


What is a semaphore1

What is a Semaphore?

  • Use downbefore entering a critical section

  • Use upafter finishing with a critical section i.e.,

  • Example: Assume S is initialized to 1.

    ………

    down(S);

    //critical section

    up(S);


Using semaphores

Using Semaphores

Process P0

Process P1

………………..

down(S);

//critical section

up(S);

………………..

………………..

down(S);

//critical section

up(S);

………………..


Using semaphores1

Using Semaphores

Process P0Process P1

down(S); down(S);

critical section critical section

up(S); up(S);

  • Initialize the semaphore variable, S, to 1

    • Why not zero?


Using semaphores2

Using Semaphores

Process P0Process P1

down(S); down(S);

critical section critical section

up(S); up(S);

  • Now what would happen if P0executes the down operation?

    • The semaphore Sis currently 1.

    • It becomes 0 and P0 enters the critical section


Using semaphores3

Using Semaphores

Process P0Process P1

down(S); down(S);

critical section critical section

up(S); up(S);

  • Now what would happen if P1executes the down operation?

    • The semaphore Sis currently 0

    • P1 blocks


Using semaphores4

Using Semaphores

Process P0Process P1

down(S); down(S);

critical section critical section

up(S); up(S);

  • Assume now that P0is done with the critical section

  • It calls the up function

    • P1 is unblocked

    • If there was no process waiting to enter the critical section the value of s would become one


Using semaphores5

Using Semaphores

  • What happens if there are three processes: P0,P1,P2

  • Assume P0 enters its critical section

  • If P1 and P2execute the down operation they will block

  • When P0leaves the critical section then P1is unblocked allowing P1 to enter its critical section

    • P2 is still blocked

  • What if P0 wants to enter its critical section again when P1is in it?


Using semaphores6

Using Semaphores

  • What if we want to allow 10 processes to use a critical section?

  • How would we initialize a semaphore, s?


Semaphore

Semaphore

  • Binary Semaphore: Value is either 0 or 1

    • Often referred to as a mutex

  • Counting Semaphore: Value ranges from 0 to N where N can be any integer number


Deadlock

Deadlock

  • Deadlock– Two or more processes are waiting indefinitely for an event that can be caused by only one of the waiting processes

  • Something to watch for


Deadlock1

Deadlock

  • Example: Let S and Q be two semaphores initialized to one

    Process P0 Process P1

    down(S); down(Q);

    down(Q); down(S);

    …… ….

    up(S); up(Q);

    up(Q); up(S);


Implementation

Implementation

  • With each semaphore there is an associated waiting queue. Each entry in a waiting queue has two data items:

    • value (of type integer)

    • pointer to next record in the list


Implementation1

Implementation

  • A semaphore can be defined as a C struct along these lines:

    typedefstruct {

    int value;

    struct process *list;

    } semaphore


Implementation2

Implementation

  • down() operation can be defined as

    down(semaphore *S) {

    S->value--;

    if (S->value < 0) {

    add this process to S->list;

    block();

    }

    }

  • The block() operation suspends the process that invokes it.


Implementation3

Implementation

  • up() operation can be defined as

    up(semaphore *S) {

    S->value++;

    if (S->value <= 0) {

    remove process P from S->list;

    wakeup(P);

    }

    }

  • The wakeup() operation sends a signal that represents an event that the invoking process is no longer in the critical section


Implementation4

Implementation

  • BTW, the implementation just described is how Linux implements semaphores

  • The up and down operations represent require access to a critical section which is the semaphore variable

  • Need hardware/OS support e.g.,

    • Hardware support e.g.,TSL.

    • Signals


Synchronization hardware

Synchronization Hardware

  • Any solution to the critical section problem requires a lock

  • Process must acquire a lock before entering a critical section

  • Process must release the lock when it exists the critical section.

  • We will present a hardware solution

while (true) {

acquire lock

critical section

release lock

other

}


Test and lock instruction tsl

Test and Lock Instruction (TSL)

  • Many computers have the following type of instruction: TSL REGISTER, LOCK

  • One use of this instruction is to provide a lock for a critical regionsuch code that operations on a semaphore variable


Using the tsl instruction

Using the TSL Instruction


Mutual exclusion addendum

TSL

enter_region: leave_region:

TSL Register, Lock move Lock, #0

CMP Register, #0 RET

JNE enter_region

RET //to caller

  • TSL Register, Lock

    • Reads LOCK into register REGISTER

    • Stores a nonzero value at the memory location LOCK

    • The operations of reading the word and storing it are guaranteed to be indivisible


Mutual exclusion addendum

TSL

enter_region: leave_region:

TSL Register, Lock move Lock, #0

CMP Register, #0 RET

JNE enter_region

RET //to caller

  • TSL Register, Lock

    • The CPU executing the TSL instruction locks the memory bus to prohibit other CPUs from accessing memory until the TSL instruction is done


Mutual exclusion addendum

TSL

enter_region: leave_region:

TSL Register, Lock move Lock, #0

CMP Register, #0 RET

JNE enter_region

RET //to caller

  • CMP Register, #0

    • Compare register value with 0

  • JNE Enter_Region

    • If Register value is not 0 then go to the start of enter region


Mutual exclusion addendum

TSL

enter_region: leave region:

TSL Register, Lock move Lock, #0

CMP Register, #0 RET

JNE enter_region

RET //to caller

  • Return to caller only if Register value is 0


Mutual exclusion addendum

TSL

enter_region: leave_region:

TSL Register, Lock move Lock, #0

CMP Register, #0 RET

JNE enter_region

RET //to caller

  • Before entering its critical region, a process calls enter_region

  • What if LOCK is 1?

    • Busy wait until lock is 0

  • When leaving the critical section, a process calls leave_region


Using tsl

Using TSL

enter_region: leave_region:

TSL Register, Lock move Lock, #0

CMP Register, #0 RET

JNE enter_region

RET //to caller

  • Assume two processes: P0 and P1

  • LOCK is initialized to zero


Using tsl1

Using TSL

enter_region: leave_region:

TSL Register, Lock move Lock, #0

CMP Register, #0 RET

JNE enter_region

RET //to caller

  • Assume that P0 wants to enter the critical section

  • It executes the TSL instruction.

    • The register value is 0 which reflects the value of LOCK

    • LOCK is set to 1


Using tsl2

Using TSL

enter_region: leave_region:

TSL Register, Lock move Lock, #0

CMP Register, #0 RET

JNE enter_region

RET //to caller

  • Now P1 wants to enter the critical section; It executes the TSL instruction

    • The register value is 1 which reflects the value of LOCK

    • P1 cannot enter the critical section

    • It repeats the TSL instruction and comparison operation until it can get into the critical section


Using tsl3

Using TSL

enter_region: leave_region:

TSL Register, Lock move Lock, #0

CMP Register, #0 RET

JNE enter_region

RET //to caller

  • P0 is done with the critical section

    • LOCK becomes 0


Using tsl4

Using TSL

Enter_region: leave_region:

TSL Register, Lock move Lock, #0

CMP Register, #0 RET

JNE enter_region

RET //to caller

  • The next time P1 executes the TSL instruction and comparison operation it finds that the register value (which reflects LOCK) is zero. It can now enter the critical section.


Implementing tsl

Implementing TSL

  • Implementing atomic TSL instructions on multiprocessors is not trivial.

  • This is a subject for a computer architecture course


Signals

Signals

  • A signal is used in UNIX systems to notify a process that a particular event has occurred

    • A signal is generated by the occurrence of a particular event

    • A generated signal is delivered to a process

    • Once delivered, the signal must be handled

  • A signal process is used to associate computation with a signal


Signals1

Signals

  • Example

    • <control> <C> is entered

    • This causes an event to be generated to a running process that is in the foreground

    • When that process receives the event it executes a signal handler which terminates the process


Signals2

Signals

  • Two possible handlers

    • Default signal handler: Provided by kernel

    • User-defined signal handler: Provided by user and overrides the default

  • What if a process has multiple threads?

    • How a signal is handled depends on the type of signal. Options

      • Deliver the signal to the thread to which the signal applies

      • Deliver the signal to every thread in the process

      • Deliver the signal to certain threads in the process

      • Assign a specific threa to receive all signals for the process


Semaphore implementation

Semaphore Implementation

  • When the up is executed a blocked process is woken up. This is done using signals

  • Semaphore operations are critical sections – use TSL.


Questions

Questions

How are multiple processes prevented from being in the critical section ?

Why different than disabling interrupts?

Which is better in a multicore system?

Disabling interrupts or TSL test?


Question

Question

  • Assume that instead of a TSL instruction there is an instruction to swap the contents of a register and memory word in a single indivisible action.

    • Can you write a enter_regionroutine based on this


Mars pathfinder

Mars PathFinder

  • Priority Inversion: Scheduling problem when lower-priority process holds a lock needed by higher-priority process

  • Now back to the Mars Pathfinder problem

    • High priority task was taking longer than expected to complete its work

    • The task was forced to wait for a shared resource that was being held by a lower-priority process

    • Lower-priority process was being pre-empted by a medium priority process

    • Scheduler detected problem and would reset


Mars pathfinder1

Mars PathFinder

  • The fix

    • The OS had a global variable to enable priority inheritance on all semaphores

    • It was off

    • It was set to on and then everything worked


Summary

Summary

  • Defined race condition

  • Examined different solutions


  • Login