The Structuring of Systems Using Upcalls By David D. Clark Presented by Samuel Moffatt.

Slides:



Advertisements
Similar presentations
Categories of I/O Devices
Advertisements

Department of Computer Science and Engineering University of Washington Brian N. Bershad, Stefan Savage, Przemyslaw Pardyak, Emin Gun Sirer, Marc E. Fiuczynski,
Chorus and other Microkernels Presented by: Jonathan Tanner and Brian Doyle Articles By: Jon Udell Peter D. Varhol Dick Pountain.
Study of Hurricane and Tornado Operating Systems By Shubhanan Bakre.
Lightweight Remote Procedure Call Brian N. Bershad, Thomas E. Anderson, Edward D. Lazowska, and Henry M. Levy Presented by Alana Sweat.
CS 326 Programming Languages, Concepts and Implementation Instructor: Mircea Nicolescu Lecture 18.
ECE 526 – Network Processing Systems Design Software-based Protocol Processing Chapter 7: D. E. Comer.
04/14/2008CSCI 315 Operating Systems Design1 I/O Systems Notice: The slides for this lecture have been largely based on those accompanying the textbook.
Contiki A Lightweight and Flexible Operating System for Tiny Networked Sensors Presented by: Jeremy Schiff.
The Structuring of Systems Using Upcalls David D Clark Presented by: Prassnitha Sampath.
Scheduler Activations Effective Kernel Support for the User-Level Management of Parallelism.
© 2006 Pearson Addison-Wesley. All rights reserved4-1 Chapter 4 Data Abstraction: The Walls.
G Robert Grimm New York University Extensibility: SPIN and exokernels.
Introduction to Operating Systems – Windows process and thread management In this lecture we will cover Threads and processes in Windows Thread priority.
Programming Language Semantics Java Threads and Locks Informal Introduction The Java Specification Language Chapter 17.
I/O Hardware n Incredible variety of I/O devices n Common concepts: – Port – connection point to the computer – Bus (daisy chain or shared direct access)
1/28/2004CSCI 315 Operating Systems Design1 Operating System Structures & Processes Notice: The slides for this lecture have been largely based on those.
Chapter 11 Operating Systems
Real-Time Kernels and Operating Systems. Operating System: Software that coordinates multiple tasks in processor, including peripheral interfacing Types.
Ralf Juengling Portland State University The Structuring of Systems using Upcalls David D. Clark, “The Structuring of Systems using Upcalls”, Proc. of.
A. Frank - P. Weisberg Operating Systems Introduction to Tasks/Threads.
The Structuring of Systems Using Upcalls David D. Clark 4/26/20111Frank Sliz, CS533, Upcalls.
The Structuring of Systems Using Upcalls David D. Clark Presenter: Haitham Gad.
The Structuring of Systems Using Upcalls Paper by David D. Clark Presentation by Emerson Murphy-Hill.
Silberschatz, Galvin and Gagne ©2009 Operating System Concepts – 8 th Edition Chapter 2: Operating-System Structures Modified from the text book.
Fundamentals of Python: From First Programs Through Data Structures
Chapter 13: I/O Systems I/O Hardware Application I/O Interface
Stack Management Each process/thread has two stacks  Kernel stack  User stack Stack pointer changes when exiting/entering the kernel Q: Why is this necessary?
What is Concurrent Programming? Maram Bani Younes.
Experience with Processes and Monitors in Mesa
Rensselaer Polytechnic Institute CSCI-4210 – Operating Systems CSCI-6140 – Computer Operating Systems David Goldschmidt, Ph.D.
CHAPTER 3 TOP LEVEL VIEW OF COMPUTER FUNCTION AND INTERCONNECTION
CS533 Concepts of Operating Systems Jonathan Walpole.
DCE (distributed computing environment) DCE (distributed computing environment)
Threads in Java. History  Process is a program in execution  Has stack/heap memory  Has a program counter  Multiuser operating systems since the sixties.
Java Threads 11 Threading and Concurrent Programming in Java Introduction and Definitions D.W. Denbo Introduction and Definitions D.W. Denbo.
Chapter 101 Multiprocessor and Real- Time Scheduling Chapter 10.
CE Operating Systems Lecture 11 Windows – Object manager and process management.
CE Operating Systems Lecture 3 Overview of OS functions and structure.
Computers Operating System Essentials. Operating Systems PROGRAM HARDWARE OPERATING SYSTEM.
Operating Systems Lecture November 2015© Copyright Virtual University of Pakistan 2 Agenda for Today Review of previous lecture Hardware (I/O, memory,
1 Pthread Programming CIS450 Winter 2003 Professor Jinhua Guo.
Silberschatz, Galvin and Gagne ©2013 Operating System Concepts – 9 th Edition Chapter 4: Threads.
Brian N. Bershad, Thomas E. Anderson, Edward D. Lazowska, and Henry M. Levy. Presented by: Tim Fleck.
Chapter 13 – I/O Systems (Pgs ). Devices  Two conflicting properties A. Growing uniformity in interfaces (both h/w and s/w): e.g., USB, TWAIN.
1 VxWorks 5.4 Group A3: Wafa’ Jaffal Kathryn Bean.
The Mach System Silberschatz et al Presented By Anjana Venkat.
CS533 – Spring Jeanie M. Schwenk Experiences and Processes and Monitors with Mesa What is Mesa? “Mesa is a strongly typed, block structured programming.
Lecture 4 Mechanisms & Kernel for NOSs. Mechanisms for Network Operating Systems  Network operating systems provide three basic mechanisms that support.
Silberschatz, Galvin and Gagne ©2011 Operating System Concepts Essentials – 8 th Edition Chapter 2: The Linux System Part 3.
Silberschatz, Galvin, and Gagne  Applied Operating System Concepts Module 12: I/O Systems I/O hardwared Application I/O Interface Kernel I/O.
Presented by: JungChun Lu. Goal Propose a design methodology suitable for operating system programs which: Permits synchronous procedure call between.
Operating Systems: Summary INF1060: Introduction to Operating Systems and Data Communication.
I/O Software CS 537 – Introduction to Operating Systems.
1.3 Operating system services An operating system provide services to programs and to the users of the program. It provides an environment for the execution.
The Structuring of Systems Using Upcalls David D. Clark (Presented by John McCall)
Module 12: I/O Systems I/O hardware Application I/O Interface
The Structuring of Systems Using Upcalls David D. Clark
Operating System Concepts
13: I/O Systems I/O hardwared Application I/O Interface
Chapter 2: The Linux System Part 3
Structuring Of Systems Using Upcalls - By David D. Clark
Operating Systems Lecture 3.
Operating Systems : Overview
Chapter 13: I/O Systems I/O Hardware Application I/O Interface
Operating Systems : Overview
Structuring of Systems using Upcalls
CS703 - Advanced Operating Systems
Module 12: I/O Systems I/O hardwared Application I/O Interface
Chapter 13: I/O Systems “The two main jobs of a computer are I/O and [CPU] processing. In many cases, the main job is I/O, and the [CPU] processing is.
Presentation transcript:

The Structuring of Systems Using Upcalls By David D. Clark Presented by Samuel Moffatt

Layering  Application Organization Technique Separate functional components that interact in some hierarchical manner. There is typically only an interface to the layer above. Top down flow. Client requests services of the layer below Using a process to implement a layer is standard at this time and requires expensive interprocess communications to communicate between layers.

Layering in Operating Systems  Pros Verification Organization  Cons Upward flow not well supported  Asynchronous mechanisms, extra overhead

Upcall  A procedure call from a lower layer into the layer above. Causes control flow to go “up” Breaks “depends on” or “using” relationship of traditional layering Network protocols are designed with an upflow. Not efficiently supported at the time using interprocess communications.

Multi-task Module  “Subroutines in different tasks that collaborate with each other through shared state.” A layer.  A task is a single thread of execution with subroutine calls for up and downcalls.  Shared memory access controlled via locks.  “Intertask” communication occurs only within a layer.

Multi-task Module

Network Protocol Implementation Example

Upcall Benefits  Synchronous subroutine calls instead of asynchronous signals  Helps to support “piggybacking” of information in network protocols.  Simplicity of implementation Eliminates buffering code for signals Lower layer can ask advice of upper layer. Programmer familiarity with subroutines Hide implementation details

Upcall Problems  A failed upcall can corrupt the layer and clients of that layer.  Solution Separate data. Local data and shared data. Shared data must be made consistent and unlocked before a call. If there is an error, may destroy a task (vertical stripe) in the system but resources can be recovered and if shared data is consistent then other tasks are not affected. Cleanup methods to recover resources.

Upcall Problems  Indirect recursive call  Solutions 1. Put all variables in a consistent state before making an upcall then re-evaluate state on return. 2. Prohibit recursive downcalls. 3. Have downcall perform action directly or queue execution by task holding a required lock. Good for interrupt handlers. 4. Downcalls never perform significant actions. Only simple things, like set flags. 5. Use a special upcall to collect data instead of a downcall.

Task Scheduling  Priority of a task Uses a deadline time instead of a number sequence. Easier to understand. Mutable. Assigned each time the process is scheduled.  If a long deadline task is blocking a short deadline task the long task will be temporarily promoted.

Single Address Space  Single address space for efficiency.  Programmed with CLU which provides compile time and runtime checks to protect the address space from corruption.  Garbage collection instead of user destroying objects. No longer valid pointer protection.  The above mitigate damage on failure so debugger can still run.

Conclusions  Upcalls are useful Efficiency and simpler code.  Multi-task modules are useful in organizing the system.  “Strongly checked typesafe languages” is useful in a single address space.  Decomposing the operating system into vertical stripes representing user requests is better than using a process as a layer.  Shared memory is a good communication tool. Not using shared memory would require a task to manage state variables that were in the shared memory.