REVIEW OF “ON THE DUALITY OF OPERATING SYSTEM STRUCTURES” Paper by Hugh C. Lauer and Roger M. Needham Presentation by Erin Chapman.

Slides:



Advertisements
Similar presentations
Concurrency Important and difficult (Ada slides copied from Ed Schonberg)
Advertisements

Microprocessors General Features To be Examined For Each Chip Jan 24 th, 2002.
1 Concurrency: Mutual Exclusion and Synchronization Chapter 5.
Concurrency, Thread and Event CS6410 Sept 6, 2011 Ji-Yong Shin.
Hugh Lauer Xerox Corporation Roger Needham Cambridge University Presented by Vidhya Priyadharshnee Palaniswamy Gnanam Spring 2011.
Concurrency: Mutual Exclusion and Synchronization Why we need Mutual Exclusion? Classical examples: Bank Transactions:Read Account (A); Compute A = A +
1 Concurrency: Mutual Exclusion and Synchronization Chapter 5.
Introduction in algorithms and applications Introduction in algorithms and applications Parallel machines and architectures Parallel machines and architectures.
1 On the Duality of Operating System Structures by Hugh C. Lauer, Xerox Corporation and Roger M. Needham, Cambridge University Presented by Scott Fletcher.
CS 584. A Parallel Programming Model We need abstractions to make it simple. The programming model needs to fit our parallel machine model. Abstractions.
1 Semaphores Special variable called a semaphore is used for signaling If a process is waiting for a signal, it is suspended until that signal is sent.
CS533 Concepts of Operating Systems Class 6 The Duality of Threads and Events.
USER LEVEL INTERPROCESS COMMUNICATION FOR SHARED MEMORY MULTIPROCESSORS Presented by Elakkiya Pandian CS 533 OPERATING SYSTEMS – SPRING 2011 Brian N. Bershad.
“Why Events are a Bad Idea (For high-concurrency servers)” Paper by Rob von Behren, Jeremy Condit and Eric Brewer, May 2003 Presentation by Loren Davis,
1 On the Duality of Operating System Structures Hugh Lauer, Xerox Roger Needham, Cambridge University Oct 1978, reprinted April 1979 Presented by David.
CS533 - Concepts of Operating Systems
On the Duality of Operating System Structures Hugh Lauer Xerox Corporation Roger Needham Cambridge University Presented by Yahia Mahmoud.
Device Management.
Communication in Distributed Systems –Part 2
Asynchronous Message Passing EE 524/CS 561 Wanliang Ma 03/08/2000.
User-Level Interprocess Communication for Shared Memory Multiprocessors Brian N. Bershad, Thomas E. Anderson, Edward D. Lazowska, and Henry M. Levy Presented.
1 I/O Management in Representative Operating Systems.
On the Duality of Operating System Structures Hugh C. Lauer Xerox Corporation Roger M. Needham Cambridge University Presented By: Ashwini Kulkarni.
Switching Techniques Student: Blidaru Catalina Elena.
1 Data Object Object Types A VHDL object consists of one of the following: –Signal, Which represents interconnection wires that connect component instantiation.
1 Data Object Object Types A VHDL object consists of one of the following: –Signal, Which represents interconnection wires that connect component instantiation.
1 Lecture 4: Threads Operating System Fall Contents Overview: Processes & Threads Benefits of Threads Thread State and Operations User Thread.
Dave Archer - CS533 - Spring On the Duality of Operating System Structures Hugh C. Lauer, Roger M. Needham.
CHAPTER 3 TOP LEVEL VIEW OF COMPUTER FUNCTION AND INTERCONNECTION
On the Duality of Operating System Structures 1. Hugh C. Lauer Xerox Corporation Palo Alto, Californi a Roger M. Needham Cambridge University Cambridge,
Concurrency: Mutual Exclusion and Synchronization Chapter 5.
- 1 - Embedded Systems - SDL Some general properties of languages 1. Synchronous vs. asynchronous languages Description of several processes in many languages.
1 Concurrency Architecture Types Tasks Synchronization –Semaphores –Monitors –Message Passing Concurrency in Ada Java Threads.
CS533 - Concepts of Operating Systems 1 On The Duality of Operating System Structures Hugh Lauer, Xerox Roger Needham, Cambridge University 1979 Presented.
Concurrency: Mutual Exclusion and Synchronization Chapter 5.
Chapter 5 Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Patricia Roy Manatee.
Processes and Process Control 1. Processes and Process Control 2. Definitions of a Process 3. Systems state vs. Process State 4. A 2 State Process Model.
Using a simple Rendez-Vous mechanism in Java
ON THE DUALITY OF OPERATING SYSTEM STRUCTURES Hugh C. Lauer and Roger M. Needham Presented by: Ali R. Butt (adapted from many slides available online and.
Middleware Services. Functions of Middleware Encapsulation Protection Concurrent processing Communication Scheduling.
Internet Protocol: Routing IP Datagrams Chapter 8.
Processes CS 6560: Operating Systems Design. 2 Von Neuman Model Both text (program) and data reside in memory Execution cycle Fetch instruction Decode.
Chapter 5 Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Patricia Roy Manatee.
System Components ● There are three main protected modules of the System  The Hardware Abstraction Layer ● A virtual machine to configure all devices.
M. Accetta, R. Baron, W. Bolosky, D. Golub, R. Rashid, A. Tevanian, and M. Young MACH: A New Kernel Foundation for UNIX Development Presenter: Wei-Lwun.
Presenting: Why Events Are A “Bad” Idea ( for high-concurrency servers) Paper by: Behren, Condit and Brewer, 2003 Presented by: Rania Elnaggar 1/30/2008.
13-1 Chapter 13 Concurrency Topics Introduction Introduction to Subprogram-Level Concurrency Semaphores Monitors Message Passing Java Threads C# Threads.
Lecture 4 Mechanisms & Kernel for NOSs. Mechanisms for Network Operating Systems  Network operating systems provide three basic mechanisms that support.
By: Rob von Behren, Jeremy Condit and Eric Brewer 2003 Presenter: Farnoosh MoshirFatemi Jan
CSE 153 Design of Operating Systems Winter 2015 Midterm Review.
Chapter 5 Concurrency: Mutual Exclusion and Synchronization Operating Systems: Internals and Design Principles, 6/E William Stallings Patricia Roy Manatee.
Channels. Models for Communications Synchronous communications – E.g. Telephone call Asynchronous communications – E.g. .
Embedded Real-Time Systems Processing interrupts Lecturer Department University.
PROCESS MANAGEMENT IN MACH
On the Duality of Operating System Structures
Concurrency, threads, and events
CS533 Concepts of Operating Systems
On the Duality of Operating System Structures
Module 2: Computer-System Structures
Threads Chapter 4.
Channels.
Hugh Lauer Xerox Corporation Roger Needham Cambridge University
Module 2: Computer-System Structures
Channels.
Channels.
On the Duality of Operating System Structures
Module 2: Computer-System Structures
Module 2: Computer-System Structures
CS533 Concepts of Operating Systems Class 4
Presentation transcript:

REVIEW OF “ON THE DUALITY OF OPERATING SYSTEM STRUCTURES” Paper by Hugh C. Lauer and Roger M. Needham Presentation by Erin Chapman

Presentation Outline  Brief overview of the ideas in the paper  The two models  Message-oriented systems  Procedure-oriented systems  Equivalence of the models  Duality mapping  Preservation of performance  Conclusions

Brief Overview

Overview  Operating System designs generally fit two types  Message-oriented systems  Procedure-oriented systems  These systems are duals of each other  Constructs have direct counterparts  Programs are logically equivalent  Performance doesn’t differ between models

Message-Oriented System The Two Models

Message-Oriented System  System for passing messages easily  Creates message queues for processes  Processes are given operations for  Sending a message  Waiting for any messages  Waiting for a particular type of message  Examining the queue  Pre-emption when message arrives at a higher priority process

Systems Have…  Specific communication paths between processes  Static number of processes  Static number of connections between processes  Processes execute in static context  No shared memory

Systems with Good Design  Process associated with a resource implements synchronization and queuing for it  If more than one process needs a data structure, pass by reference  Peripheral devices treated as processes  Static process priority  Process works on one message at a time

Environment: Structures  Messages: data structure for sending information  Message Identifiers: handle to identify a particular message  Message Channel: Identifies destination of a message  Message Port: Queue for holding messages of a certain type for a particular process

Environment: Message Transmission  SendMessage(messageChannel, messageBody)  Returns messageID  AwaitReply(messageID)  Returns messageBody  WaitForMessage({set of messagePort})  Returns (messageBody, messageID, messagePort)  SendReply(messageID, messageBody)

Environment: Processes  Process Declaration  Local data and algorithms  Message ports  Message channels for other processes  CreateProcess Operation

Procedure-Oriented System The Two Models

Procedure-Oriented System  Protection and addressing mechanism  Efficient procedure calls  Cooperation between processes done through locked data structures  Pre-emption when a higher priority process gets a lock it was waiting on

Systems Have…  Global data is protected and easily accessed  Process creation is efficient and easy  Processes have one goal but may wander through the system to do it

Systems with Good Design  Synchronization done through locks on data structures  A process will lock only small amounts at one time  Data is shared between processes  Peripherals are controlled by locks and shared memory  Processes have dynamic priorities  Global naming scheme often used

Environment: Procedures  Procedure  Algorithms  Local data  Parameters  Results

Environment: Procedure Calls  Synchronous  Asynchronous  fork procedureName(parameterList) Returns processID  join processID Returns (resultsList)

Environment: Modules and Monitors  Module: primitive unit of compilation  Procedures  Data  Monitor: special module protected by a lock  Only one process can execute it at a time  Module Instantiation  new  start

Environment: Condition Variables  Must be in a monitor  Associated queue of processes  Operations:  wait conditionVariable  signal conditionVariable

Duality Mapping Equivalence of the Models

The Duality Mapping  Process, CreateProcess  Message channels, Message  Ports  SendMessage; AwaitReply; (immediate)  Monitors, new/start  Procedure identifiers, entry  Procedure identifiers  Procedure call Message-Oriented SystemProcedure-Oriented System

The Duality Mapping  SendMessage; … AwaitReply; (delayed)  SendReply  fork; … join;  return (from procedure) Message-Oriented SystemProcedure-Oriented System

The Duality Mapping  Main loop of standard resource manager, WaitForMessage, case statement  Arms of the case statement selective  Lock, entry attribute  entry Message-Oriented SystemProcedure-Oriented System

The Duality Mapping  Waiting for messages  Condition variables, wait, signal Message-Oriented SystemProcedure-Oriented System

Similarity of the Models  Programs can be transformed using the duality mapping  Logic of program not affected by transformation  This only works if the strict model employed in the paper is used

Preservation of Performance Equivalence of the Models

Same Execution Characteristics  Execution time  Computational load  Queuing  Wait times  Execution time of system primitives

Program Unchanged by Transform  Same…  Execution speed  Amount of information stored  Amount of code  Interaction between programs doesn’t change  Total lifetime computation is the same

Conclusions

 Little empirical support  No inherent differences between the models  Choose model based on  Machine architecture  Programming environment  Eliminates some degrees of freedom in the design process

Questions?

References  Lauer, Hugh C. and Needham, Roger M., “On the Duality of Operating System Structures”, Proceedings of the Second International Symposium on Operating Systems, IR1A, Oct. 1978, reprinted in Operating Systems Review, 13, 2 April 1979, pp