Remote Procedure Calls Adam Smith, Rodrigo Groppa, and Peter Tonner.

Slides:



Advertisements
Similar presentations
1 Communication in Distributed Systems REKs adaptation of Tanenbaums Distributed Systems Chapter 2.
Advertisements

RPC Robert Grimm New York University Remote Procedure Calls.
Remote Procedure Call (RPC)
Remote Procedure Call Design issues Implementation RPC programming
U NIVERSITY OF M ASSACHUSETTS, A MHERST Department of Computer Science Emery Berger University of Massachusetts Amherst Operating Systems CMPSCI 377 Lecture.
Tam Vu Remote Procedure Call CISC 879 – Spring 03 Tam Vu March 06, 03.
Copyright © 2001 Qusay H. Mahmoud RMI – Remote Method Invocation Introduction What is RMI? RMI System Architecture How does RMI work? Distributed Garbage.
Remote Procedure CallCS-4513, D-Term Remote Procedure Call CS-4513 Distributed Computing Systems (Slides include materials from Operating System.
Implementing Remote Procedure Calls Andrew Birrell and Bruce Nelson Presented by Kai Cong.
Implementing Remote Procedure Calls Authored by: Andrew D. Birrel and Bruce Jay Nelson Presented by: Terry, Jae, Denny.
Slide 1 Client / Server Paradigm. Slide 2 Outline: Client / Server Paradigm Client / Server Model of Interaction Server Design Issues C/ S Points of Interaction.
G Robert Grimm New York University Lightweight RPC.
CS533 Concepts of Operating Systems Class 8 Remote Procedure Call & LRPC.
Tutorials 2 A programmer can use two approaches when designing a distributed application. Describe what are they? Communication-Oriented Design Begin with.
CS533 - Concepts of Operating Systems 1 Remote Procedure Calls - Alan West.
Implementing Remote Procedure Calls Authors: Andrew D. Birrell and Bruce Jay Nelson Xerox Palo Alto Research Center Presenter: Jim Santmyer Thanks to:
Remote Procedure Calls (RPC) Presenter: Benyah Shaparenko CS 614, 2/24/2004.
IPv6 Mobility David Bush. Correspondent Node Operation DEF: Correspondent node is any node that is trying to communicate with a mobile node. This node.
Remote Procedure Calls (RPC) - Swati Agarwal. RPC – an overview Request / reply mechanism Procedure call – disjoint address space clientserver computation.
Outcomes What is RPC? The difference between conventional procedure call and RPC? Understand the function of client and server stubs How many steps could.
Implementing Remote Procedure Calls an introduction to the fundamentals of RPCs, made during the advent of the technology. what is an RPC? what different.
16: Distributed Systems1 DISTRIBUTED SYSTEM STRUCTURES NETWORK OPERATING SYSTEMS The users are aware of the physical structure of the network. Each site.
Remote Procedure Calls. 2 Client/Server Paradigm Common model for structuring distributed computations A server is a program (or collection of programs)
.NET Mobile Application Development Remote Procedure Call.
Remote Procedure Calls Taiyang Chen 10/06/2009. Overview Remote Procedure Call (RPC): procedure call across the network Lightweight Remote Procedure Call.
The OSI Model A layered framework for the design of network systems that allows communication across all types of computer systems regardless of their.
1 Lightweight Remote Procedure Call Brian N. Bershad, Thomas E. Anderson, Edward D. Lazowska and Henry M. Levy Presented by: Karthika Kothapally.
CS510 Concurrent Systems Jonathan Walpole. Lightweight Remote Procedure Call (LRPC)
Implementing Remote Procedure Calls ANDREW D. BIRRELL and BRUCE JAY NELSON Presented by Tony Bock.
By Andrew D. Birrell and Bruce Jay Nelson Presented By: Abdussalam Alawini Reviewed By Prof. Jonathon Walpole.
6.1. Transport Control Protocol (TCP) It is the most widely used transport protocol in the world. Provides reliable end to end connection between two hosts.
+ A Short Java RMI Tutorial Usman Saleem
CS 390- Unix Programming Environment CS 390 Unix Programming Environment Topics to be covered: Distributed Computing Fundamentals.
 Communication Tasks  Protocols  Protocol Architecture  Characteristics of a Protocol.
Remote Procedure Call An Effective Primitive for Distributed Computing Seth James Nielson.
Implementing Remote Procedure Calls Authored by Andrew D. Birrell and Bruce Jay Nelson Xerox Palo Alto Research Center Presented by Lars Larsson.
MODULE I NETWORKING CONCEPTS.
The Socket Interface Chapter 21. Application Program Interface (API) Interface used between application programs and TCP/IP protocols Interface used between.
 Remote Procedure Call (RPC) is a high-level model for client-sever communication.  It provides the programmers with a familiar mechanism for building.
Tanenbaum & Van Steen, Distributed Systems: Principles and Paradigms, 2e, (c) 2007 Prentice-Hall, Inc. All rights reserved RPC Tanenbaum.
By Andrew D. Birrell and Bruce Jay Nelson Adapted from an earlier presentation by Abdussalam Alawini.
GLOBAL EDGE SOFTWERE LTD1 R EMOTE F ILE S HARING - Ardhanareesh Aradhyamath.
Remote Procedure Call and Serialization BY: AARON MCKAY.
09/14/05 1 Implementing Remote Procedure Calls* Birrell, A. D. and Nelson, B. J. Presented by Emil Constantinescu *ACM Trans. Comput. Syst. 2, 1 (Feb.
Lecture 4 Mechanisms & Kernel for NOSs. Mechanisms for Network Operating Systems  Network operating systems provide three basic mechanisms that support.
Manish Kumar,MSRITSoftware Architecture1 Remote procedure call Client/server architecture.
5. The Transport Layer 5.1 Role of Transport Layer It bridge the gab between applications and the network layer. Provides reliable cost-effective data.
Computer Science Lecture 3, page 1 CS677: Distributed OS Last Class: Communication in Distributed Systems Structured or unstructured? Addressing? Blocking/non-blocking?
Implementing Remote Procedure Calls Andrew D. Birrell and Bruce Jay Nelson 1894 Xerox Palo Alto Research Center EECS 582 – W16.
Implementing Remote Procedure Calls Andrew D. Birrell and Bruce Jay Nelson Xerox Palo Alto Research Center Published: ACM Transactions on Computer Systems,
4343 X2 – The Transport Layer Tanenbaum Ch.6.
Implementing Remote Procedure Call Landon Cox February 12, 2016.
© Oxford University Press 2011 DISTRIBUTED COMPUTING Sunita Mahajan Sunita Mahajan, Principal, Institute of Computer Science, MET League of Colleges, Mumbai.
Topic 4: Distributed Objects Dr. Ayman Srour Faculty of Applied Engineering and Urban Planning University of Palestine.
Prof. Leonardo Mostarda University of Camerino
CS533 Concepts of Operating Systems
Implementing Remote Procedure Calls
Module 4 Remote Login.
Implementing RPC by Birrell & Nelson
Switching Techniques In large networks there might be multiple paths linking sender and receiver. Information may be switched as it travels through various.
Congestion Control, Internet transport protocols: udp
Programming Models for Distributed Application
DISTRIBUTED COMPUTING
Lecture 4: RPC Remote Procedure Call Coulouris et al: Chapter 5
Lecture 4: RPC Remote Procedure Call CDK: Chapter 5
Switching Techniques.
Remote Procedure Call Hank Levy 1.
Remote Procedure Call Hank Levy 1.
Remote Procedure Call Hank Levy 1.
Last Class: Communication in Distributed Systems
Presentation transcript:

Remote Procedure Calls Adam Smith, Rodrigo Groppa, and Peter Tonner

Outline I. Introduction II. Binding III. Packet Level Protocol IV. Performance V. Status And Discussions

Introduction

def: Remote Procedure Calls Procedure call that executes remotely (in this paper) single threaded – caller waits for return of function Abstraction of message passing Simple syntax and simple semantics – user should not be concerned with implementation

Environment (old computers) Cedar programming environment Dorados – 24 bit virtual address space – 80 Mb disk Mesa, Smalltalk, InterLisp PUP protocol family

Aims “Make distributed computation easy” Make remote programming nearly as easy as making local procedure calls Keep efficiency within 5 times the network latency Use secure communication with encryption

Fundamental Decisions RPC vs Message Passing – same problems, same solutions – Mesa: based on procedural control flow Fork adds no significant complexity No shared address space – requires extension of address space with network location – out of solution scope

Terms of RPC Caller and callee Interface Modules – list of functions with parameter and return types Export – define functions Import – use functions of an interface Program Modules

Structure User, User Stub, RPCRuntime, Server, Server Stub Stub – Pack and unpack arguments and results RPCRuntime – exists on both machines – transmit messages from caller to callee

More Structure

II. Binding Naming – specify what a client should be bound to by the RPC Runtime Location – Caller locates callee and invokes a procedure

Naming Check whether an importer is connecting to an appropriate exporter Type – specify the interface of a callee – think Java/C# classes Instance – implements the Type interface

Locating an Appropriate Exporter RPCRuntime links caller and callee modules – stores machine locations in a Grapevine database Exporter (implementing an interface) calls ExportInterface – stores interface and procedure callback Importer (uses an interface instance) calls ImportInterface – must include interface type – instance identifier is optional

Exporting and Importing

Packet Level Transport Protocol

Requirements They believe there are performance gains available if they were to design and implement a transport protocol specially for RPC, because of the nature of the system they were creating. They believed that performance could possibly be improved by a factor of ten.

Requirements One aim they emphasized in their protocol design was minimizing the amount of real- time taken between initiating a call and getting results. With protocols for large amount of data transfer this isn’t important because so much time will be spent transferring the data. They also wanted to minimize the load given to a server by a large number of users.

Requirements They wanted their machines to be able to handle a large number of clients, and it wouldn’t be feasible to require a large amount of state info or costly connection handshaking for this situation.

Requirements They wanted to guarantee that if the call returns to the user that the user can be certain that the procedure in the server has been executed precisely once. Otherwise, he could expect an exception to have been reported and the procedure would have been executed either once or not at all, without being informed of which actually happened.

Requirements There is no upper bound on how long it will wait for results. Calls will be aborted if there is a communication problem or a crash, but not if the server stops or loops. They did this to mirror how local procedure calls work.

Simple Calls To make a call, the caller sends a call packet containing a call identifier, data specifying the desired procedure, and the arguments. When the callee machine receives this packet, the appropriate procedure is invoked. When the procedure returns, a result packet containing the same call identifier, and the results, is sent back to the caller.

Simple Calls

Complicated Calls

Exception Handling in Mesa Exceptions are called signals, and when an exception is raised, the runtime system dynamically scans the call stack to determine if there is a catch phrase for the exception. If there is, then the catch phrase code is executed, and data pertaining when it was raised is given. The catch may return to where the exception was raised, or it may terminate and jump back.

Exception Handling by RPC package The RPC package uses the way Mesa handles exceptions as a model. The protocol allows the process on the server machine to send exception packets in place of result packets. This allows the caller machine to raise an exception in the appropriate process. The results (if any) can be sent back to the callee machine, and the process can proceed normally.

Exception Handling by RPC package If the catch code terminates then the callee machine is so notified, which then unwinds the appropriate procedure activations. In addition to exceptions raised by the callee, the RPC runtime may raise a call failed exception if there is some communication difficulty.

Use of Processes Since forking processes is normally a costly event, they took extra care whilst building this package to keep that cost as low as possible. The first step to reaching this goal is the fact that they used idle server processes to remove the costs of process creation. As soon as a call is received by a callee, it may be handled.

Use of Processes Each packet contains a process identifier for both source and destination. In packets from the caller machine, the source process identifier is the calling process. In packets from the callee machine, the source process identifier is the server process handling the call.

Use of Processes A process wanting to make a call makes the first packet of the call, guesses a value for the destination process identifier, and sets the source to be itself. It then sends the packet and waits. The callee receives this and tells a server process to handle the packet and make a response packet. The destination process identifier in this packet will be that of the process waiting in the caller machine. When the response arrives in the caller machine, it is passed directly to the calling process.

Optimizations They use subsequent packets for implicit acknowledgment of previous packets, they attempt to minimize the costs of maintaining their connections, they avoid costs of establishing and terminating connections, and they reduce the number of process switches involved in a call.

Other Optimizations When transmitting and receiving RPC packets they bypass the software layers that correspond to the normal layers of a protocol hierarchy in the case of local calls. They modified the network-driver software to treat RPC packets as a special case. They want RPC to be a special case and they want it to be the dominant communication protocol. Many other options for optimization were avoided.

Security Their RPC package and protocol uses Grapevine as an authentication service and use the federal data encryption standard. This gives full end-to-end encryption of calls and results. These encryption techniques provide protection from eavesdropping, and detect attempts at modification, replay, or creation of calls.

Results Figures in microseconds.

Status Project was still its early stages at time of writing. RPC isn’t a suitable replacement for certain situations. Use Multicast/broadcast instead