Implementing Remote Procedure Calls

1. Implementing Remote Procedure Calls Andrew Birrell and Bruce Nelson Slide Set by Phil Howard and others

2. Why?

3. Consider #include <stdio.h> int main() { printf("hello world!\n"); return 0; }

4. What Happens main main printf glibc kernel IO kernel update_window X update_display kernel IO kernel

5. But what if Laptop Linux Box X Client X Server Console Window main

6. What Happens Laptop Linux Box main main X Client printf glibc update_display X kernel IO kernel kernel IO kernel update_window X update_display

7. How do you do this? • Fork/Join? • SendMessage/AwaitReply? • Virtual Shared Memory? • Remote Procedure Call?

8. Remote Procedure Call (RPC)

9. What's Involved in RPC • Remote Procedure Call should look and feel like local call • Remote Procedure Call should be independent of where it executes • Remote Procedure Call should be "efficient"

10. Issues • Finding the callee • Passing data • Implementation • Exceptions • Optimizations

11. Finding the Callee(Binding) • Where - Either server has known static address - Or client broadcasts request - Or use central database of interfaces • What - Servers export named interfaces - Clients request a particular interface - Need Globally Unique Identifiers for interfaces

12. Interfaces • Type • - Like object oriented programming interfaces • - Method names, parameter and result types • - Underlying functionality is hidden • Instance • - Which specific provider of this type

13. Binding • Callee exports an interface via a network accessible database. Callee RPCRuntime Server Stub Server Database ExportInterface ExportInterface UpdateDatabase

14. Binding • Caller binds by specifying the type of the interface in a database query • Selects from a list of instances returned Caller User User Stub RPCRuntime Database Who’s available? ImportInterface ImportInterface QueryDatabase InterfaceInfo InterfaceInfo InterfaceInfo AvailableInterfaces

15. Issues • Finding the callee • Passing data • Implementation • Exceptions • Optimizations

16. Passing Data • Can't use the stack! • Can't use shared memory! • Generally use message passing

17. Passing Data #include <stdio.h> int main() { union { unsigned long stuff1; unsigned char stuff2[4]; } my_var; my_var.stuff1 = 0x12345678; printf("%X %X %X %X\n", my_var.stuff2[0], my_var.stuff2[1], my_var.stuff2[2], my_var.stuff2[3]); return 0; }

18. Passing Data What's the output? • 12 34 56 78 • or • 78 56 34 12

19. Passing data Build a message that includes: • Who and what's being called • Identity of the caller • Data values in known byte order • Using an intermediate data representation

20. Issues • Finding the callee • Passing data • Implementation • Exceptions • Optimizations

21. Implementation foo(a,&b) foo(int a, int *b) return;

22. Implementation • foo(int a; int *b) • { • build_msg(a,b); • send_msg(); • wait_for_reply(); • get_from_msg(&b); • } • do_foo(msg_t msg) • { • int a,b; • get_from_msg(&a,&b); • foo(a,&b); • build_msg(b); • send_reply(); • }

23. Implementation • Function prototype is (almost) all that's needed to build the client stub • Also need binding information • Function prototype is (almost) all that's needed to build server stuff • Also need method to wait for message

24. Implementation Caller User User Stub RPCRuntime Network Send packet Procedure call Packarguments Transmit packet(s) Unpackresult(s) Receive packet(s) procedure return Receive packet Callee RPCRuntime Server Stub Server Network Receive packet Unpackarguments Procedure call Receivepacket(s) Transmitpacket(s) Packresult(s) Send packet Procedure return

25. Implementation • Clients • Threaded • Servers • Event Driven

26. Issues • Finding the callee • Passing data • Implementation • Exceptions • Optimizations

27. Exceptions • What can happen in "normal" procedures? • Procedure generates an exception • Procedure infinite loops • Procedure generates wrong results

28. Exceptions • What can happen in "remote" procedures? • Client stub generates exception • Transmission failure • knowable failure • unknowable failure • Remote procedure generates an exception • Remote procedure infinite loops • Remote procedure generates wrong results

29. Issues • Finding the callee • Passing data • Implementation • Exceptions • Optimizations

30. Optimizations • Servers maintain no state on clients • No penalty for a large number of clients • Messages must be ack'd • for short calls, result serves as ack • for frequent calls, next call ack's last result • for long requests, only last request message gets ack'd • for long results, only last result message gets ack'd • Bound to "closest" server • Minimum transmission delay

31. Protocol-Level Optimizations Caller Callee User RPCRuntime Server RPCRuntime Procedure call Call[Ids, packet=0] Receivepacket 0 Transmit first packet Ack[Ids, packet=0] Transmit ack Receive ack Call[Ids, packet=1] Transmit next packet Receivepacket 1 Procedure call Call[Ids, packet=1, needAck] Retransmit next packet Receivepacket 1 Ack[Ids, packet=1] Transmit ack Receive ack Result[Ids] procedure return Receiveresult Transmitresult procedure return Result[Ids, needAck] Receiveresult Transmit ackrequest Ack[Ids] Transmit ack Receive ack

32. Conclusion • Remote Procedure Call should look and feel like local call • Remote Procedure Call should be independent of where it executes • Remote Procedure Call should be "efficient"