Sarah Diesburg Operating Systems CS 3430

Slides:

Advertisements

Similar presentations

1 Interprocess Communication 1. Ways of passing information 2. Guarded critical activities (e.g. updating shared data) 3. Proper sequencing in case of.

Advertisements

Mutual Exclusion – SW & HW By Oded Regev. Outline: Short review on the Bakery algorithm Short review on the Bakery algorithm Black & White Algorithm Black.

– R 7 :: 1 – 0024 Spring 2010 Parallel Programming 0024 Recitation Week 7 Spring Semester 2010.

Part 3: Safety and liveness

Handling Deadlocks n definition, wait-for graphs n fundamental causes of deadlocks n resource allocation graphs and conditions for deadlock existence n.

Ch. 7 Process Synchronization (1/2) I Background F Producer - Consumer process :  Compiler, Assembler, Loader, · · · · · · F Bounded buffer.

Mutual Exclusion By Shiran Mizrahi. Critical Section class Counter { private int value = 1; //counter starts at one public Counter(int c) { //constructor.

Concurrent Programming Problems OS Spring Concurrency pros and cons Concurrency is good for users –One of the reasons for multiprogramming Working.

1 CENG334 Introduction to Operating Systems Erol Sahin Dept of Computer Eng. Middle East Technical University Ankara, TURKEY URL:

Mutual Exclusion.

Secure Operating Systems Lesson 5: Shared Objects.

Chapter 3 The Critical Section Problem

Parallel Processing (CS526) Spring 2012(Week 6).  A parallel algorithm is a group of partitioned tasks that work with each other to solve a large problem.

Homework 6 Sarah Diesburg Operating Systems CS 3430.

CS444/CS544 Operating Systems Synchronization 2/16/2006 Prof. Searleman

Chapter 2: Processes Topics –Processes –Threads –Process Scheduling –Inter Process Communication (IPC) Reference: Operating Systems Design and Implementation.

Concurrency CS 510: Programming Languages David Walker.

Semaphores. Announcements No CS 415 Section this Friday Tom Roeder will hold office hours Homework 2 is due today.

Concurrency: Mutual Exclusion, Synchronization, Deadlock, and Starvation in Representative Operating Systems.

Chapter 2.3 : Interprocess Communication

Synchronization in Distributed Systems. Mutual Exclusion To read or update shared data, a process should enter a critical region to ensure mutual exclusion.

Race Conditions CS550 Operating Systems. Review So far, we have discussed Processes and Threads and talked about multithreading and MPI processes by example.

U NIVERSITY OF M ASSACHUSETTS, A MHERST Department of Computer Science Emery Berger University of Massachusetts, Amherst Operating Systems CMPSCI 377 Lecture.

1 CSCD 330 Network Programming Lecture 13 More Client-Server Programming Sometime in 2014 Reading: References at end of Lecture.

Semaphores. Readings r Silbershatz: Chapter 6 Mutual Exclusion in Critical Sections.

CS510 Concurrent Systems Introduction to Concurrency.

CGS 3763 Operating Systems Concepts Spring 2013 Dan C. Marinescu Office: HEC 304 Office hours: M-Wd 11: :30 AM.

CS 153 Design of Operating Systems Spring 2015 Lecture 11: Scheduling & Deadlock.

1 Processes, Threads, Race Conditions & Deadlocks Operating Systems Review.

© Janice Regan, CMPT 300, May CMPT 300 Introduction to Operating Systems Introduction to Concurrency.

© Janice Regan, CMPT 300, May CMPT 300 Introduction to Operating Systems Classical problems.

Operating Systems CMPSC 473 Mutual Exclusion Lecture 14: October 14, 2010 Instructor: Bhuvan Urgaonkar.

Operating Systems ECE344 Ashvin Goel ECE University of Toronto Mutual Exclusion.

More on Semaphores Andy Wang Operating Systems COP 4610 / CGS 5765.

Kernel Locking Techniques by Robert Love presented by Scott Price.

This Time - Deadlock Definition Conditions for deadlocks

U NIVERSITY OF M ASSACHUSETTS A MHERST Department of Computer Science Computer Systems Principles Synchronization Emery Berger and Mark Corner University.

CSE 153 Design of Operating Systems Winter 2015 Midterm Review.

CS 241 Section Week #7 (10/22/09). Topics This Section  Midterm Statistics  MP5 Forward  Classical Synchronization Problems  Problems.

CS333 Intro to Operating Systems Jonathan Walpole.

Mutual Exclusion Algorithms. Topics r Defining mutual exclusion r A centralized approach r A distributed approach r An approach assuming an organization.

Homework-6 Questions : 2,10,15,22.

Readers/Writers Problem  Multiple processes wanting to read an item, and one or more needing to write (Think of airline reservations…)  Rather than enforce.

Mutual Exclusion -- Addendum. Mutual Exclusion in Critical Sections.

Chapter 5 Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Patricia Roy Manatee.

Thread Synchronization

Operating systems Deadlocks.

Sarah Diesburg Operating Systems COP 4610

Background on the need for Synchronization

PROTOCOL CORRECTNESS Tutorial 3 Theoretical

Lecture 18: Coherence and Synchronization

Lecture 16: Readers-Writers Problem and Message Passing

Concurrency: Mutual Exclusion and Synchronization

COP 4600 Operating Systems Fall 2010

Threading And Parallel Programming Constructs

Lecture 22 Syed Mansoor Sarwar

Liveness And Performance

Operating systems Deadlocks.

Andy Wang Operating Systems COP 4610 / CGS 5765

Implementing Mutual Exclusion

Lecture 16: Readers-Writers Problem and Message Passing

CSE 153 Design of Operating Systems Winter 19

Lecture 19: Coherence and Synchronization

CSE 153 Design of Operating Systems Winter 2019

Lecture 18: Coherence and Synchronization

EECE.4810/EECE.5730 Operating Systems

Process/Thread Synchronization (Part 2)

CSE 542: Operating Systems

Operating Systems {week 10}

Sarah Diesburg Operating Systems CS 3430

Presentation transcript:

Sarah Diesburg Operating Systems CS 3430 More on Semaphores Sarah Diesburg Operating Systems CS 3430

The Pigeon Network Scenario Pigeons are good message carriers Reasonably reliable Relatively fast for less developed rural areas Can sense magnetic field lines

Here is the Story… There are two towns—Mars and Venus Mars has all male pigeons Venus has all female pigeons Each town delivers messages to the other By sending a pigeon through the shared flying path And waiting for the same pigeon to fly back as an acknowledgement

Here is the Story… Based on experience Goals of a pigeon network: Whenever both towns send messages simultaneously, the reliability drops significantly Pigeons of opposite genders decide to take excursions Goals of a pigeon network: Efficiency Fairness

Developing the Solution First we need to identify the components of the problem Second we develop the simplest solution Then optimize

Step 1: Visualization Identify Shared resources Scope of shared resources flying path Mars Venus

Step 1: Visualization Identify Shared resource: flying path Scope of the shared resource: global flying path Mars Venus

Simplest Implementation semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); P(flyingPath); // send the message V(flyingPath); flying path Mars Venus

Simplest Implementation semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); P(flyingPath); // send the message V(flyingPath); flying path Mars Venus

Simplest Implementation semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); P(flyingPath); // send the message V(flyingPath); flying path Mars Venus something you don’t see everyday…

Simplest Implementation semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); P(flyingPath); // send the message V(flyingPath); flying path Mars Venus

Simplest Implementation semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); P(flyingPath); // send the message V(flyingPath); flying path Mars Venus

Simplest Implementation semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); P(flyingPath); // send the message V(flyingPath); flying path Mars Venus

Simplest Implementation semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); P(flyingPath); // send the message V(flyingPath); flying path Mars Venus

Simplest Implementation semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); P(flyingPath); // send the message V(flyingPath); flying path Mars Venus

Simplest Implementation semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); P(flyingPath); // send the message V(flyingPath); flying path Mars Venus

Simplest Implementation + Fair - Not efficient Only one pigeon can fly at a time Venusians love to fly in groups…

Allowing Multiple Venusians in Transit Resources and scopes: flying path (global), a counter for Venusians in transit (Venus) flying path Mars Venus

Allowing Multiple Venusians in Transit semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); int VenusiansInTransit = 0; ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); int VenusiansInTransit = 0; ++VenusiansInTransit; // == 1 if (VenusiansInTransit == 1) { P(flyingPath); } // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); int VenusiansInTransit = 0; ++VenusiansInTransit; // == 2 if (VenusiansInTransit == 1) { P(flyingPath); } // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); int VenusiansInTransit = 0; ++VenusiansInTransit; // == 2 if (VenusiansInTransit == 1) { P(flyingPath); } // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); int VenusiansInTransit = 0; ++VenusiansInTransit; // == 2 if (VenusiansInTransit == 1) { P(flyingPath); } // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); int VenusiansInTransit = 0; ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); int VenusiansInTransit = 0; ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); int VenusiansInTransit = 0; ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); Sure. Date? flying path Venus Mars

Allowing Multiple Venusians in Transit Revised semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); V(VenusianLock); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); V(VenusianLock); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); V(VenusianLock); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); V(VenusianLock); Wait! flying path Venus Mars

Allowing Multiple Venusians in Transit Revised Again semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } V(VenusianLock); // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised Again semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } V(VenusianLock); // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised Again semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } V(VenusianLock); // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised Again semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } V(VenusianLock); // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised Again semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } V(VenusianLock); // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised Again semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } V(VenusianLock); // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised Again semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } V(VenusianLock); // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised Again semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } V(VenusianLock); // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised Again semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } V(VenusianLock); // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised Again semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } V(VenusianLock); // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised Again semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } V(VenusianLock); // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised Again semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } V(VenusianLock); // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised Again semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } V(VenusianLock); // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised Again semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } V(VenusianLock); // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised Again semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } V(VenusianLock); // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised Again semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } V(VenusianLock); // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised Again semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } V(VenusianLock); // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised Again semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } V(VenusianLock); // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised Again semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } V(VenusianLock); // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised Again semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } V(VenusianLock); // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised Again semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } V(VenusianLock); // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised Again semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } V(VenusianLock); // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised Again semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } V(VenusianLock); // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised Again semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } V(VenusianLock); // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised Again semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } V(VenusianLock); // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised Again semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } V(VenusianLock); // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised Again semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } V(VenusianLock); // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised Again semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } V(VenusianLock); // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised Again semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } V(VenusianLock); // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised Again semaphore flyingPath = 1; P(flyingPath); // send the message V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } V(VenusianLock); // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath); flying path Venus Mars

Allowing Multiple Venusians in Transit Revised Again Efficient for Venusians Not fair for Martians

Allowing Multiple Venusians and Martians in Transit semaphore flyingPath = 1; semaphore MartianLock = 1; int MartiansInTransit = 0; P(MartianLock); ++MartiansInTransit; if (MartiansInTransit == 1) { P(flyingPath); } V(MartianLock); // send the message --MartiansInTransit; if (MartiansInTransit == 0) { V(flyingPath); semaphore VenusianLock = 1; int VenusiansInTransit = 0; P(VenusianLock); ++VenusiansInTransit; if (VenusiansInTransit == 1) { P(flyingPath); } V(VenusianLock); // send the message --VenusiansInTransit; if (VenusiansInTransit == 0) { V(flyingPath);

Allowing Multiple Venusians and Martians in Transit Both sides can transmit efficiently One side can completely block off the traffic from the other side Fair, since both sides are equally selfish… Fortunately, pigeons do sleep Daily cycles will break a starvation condition…

Proving the Correctness Safety (mutual exclusion): At most one thread is in the critical section at any time All necessary locks are acquired at the entrance of a critical section All shared resources are protected

Proving the Correctness Liveness (progress): If more than one thread is interested in executing the critical section, some processes will eventually do so (deadlock free) Fairness (bounded waiting): Every thread that wants to execute the critical section will eventually do so (no starvation)