ALPHORN: A TOOLBOX FOR FAULT-TOLERANT, DISTRIBUTED PROCESS CONTROL SYSTEMS

The Remote Procedure Call (RPC) is a popular paradigm for inter-process communication (IPC) between processes in different computers across the network. It is widely used in various Distributed Systems. Although it is conceptually simple and straightforward to implement, there are a lot of different and subtle issues involved which result different RPC implementations. In this paper, various distinctive RPC implementations are surveyed, analyzed and compared: Xerox Courier RPC, Xerox Cedar RPC, Sun ONC/RPC, Apollo NCA/RPC, Cambridge Mayflower Project RPC, MIT Athena Project RPC, Stanford Modula/V RPC, and Rajdoot RPC are presented. The design objectives, features provided, call semantics, orphan treatment, binding, transport protocols supported, security/authentication, data representation and application programming interface of these RPCs are examined.

A fault tolerant RPC mechanism based on IP multicasting

This paper proposes and analyzes a communication mechanism capable of supporting real-time RPC (Remote Procedure Call) which is based on the request-acknowledgment-reply semantic. As an enhanced protocol of TDMA-implemented Ethernet, the proposed CS (Communication System) dynamically schedules RPC-related messages according to their attributes, allowing a network schedule to be easily combined with a server schedule. As the RPC schedule produced by combining a server schedule and a communication schedule can obviate the waste computation time at the server, more real-time RPC requests can meet their timing constraints. Simulation results show that the RPC over the proposed CS outperforms those over the token bus and TDMA on the various network parameters, such as RPC arrival time, service time and slack.

Remote Procedure Calls (RPCs) realize client-server interactions via a request-response message-passing protocol. They simplify distributed application programming by eliminating the need for explicitly having to code the details of a remote interaction. However, none of the existing RPC implementations are designed to work properly for Delay/Disruption-Tolerant Networking (DTN) where network connectivity is periodic, intermittent, and prone to disruptions. In this paper, we present DTN- RPC, a new approach to provide RPCs for DTN environments. DTN-RPC relies on (a) control and data channels to cope with potentially short contact durations in DTN where large amounts of data cannot be transmitted, (b) explicit and implicit modes to address remote servers, (c) Non-DTN and DTN transport protocols for issuing calls and receiving results, and (d) predicates that servers check to decide whether a procedure should be executed. The implementation of DTN-RPC is based on Serval, an open-source, disruption-tolerant wireless ad-hoc networking system. Our experimental results indicate that the measured CPU and network overheads for DTN-RPC are reasonably low so that it can be executed on smartphones or routers, and that the round-trip times and the number of successful RPCs are highly satisfactory in dynamic networks with unstable links.

Remote procedure call (RPC) is the most popular paradigm used today to build distributed systems and applications. As a consequence, the term "RPC" has grown to include a range of vastly different protocols above the transport layer. A resulting problem is that programs often use different RPC protocols, cannot be interconnected directly, and building a solution for each case in a large heterogeneous environment is prohibitively expensive. We describe the design of a system that can synthesize programs (RPC agents) to accommodate RPC heterogeneities. Because of its synthesis capability, the system also facilitates the design and implementation of new RPC protocols through rapid prototyping. We have built a prototype system to validate the design and to estimate the agent development costs and cross-RPC performance. The evaluation shows that the synthesis approach provides a more general solution than existing approaches do, and with lower software development and maintenance costs, while maintaining reasonable cross-RPC performance.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

This paper explores the performance behavior of two core services of the OSF DCE, RPC (Remote Procedure Call) and threads. The RPC performance is gauged as a function of the length of argument(s) passed. We show that: DCE RPC performance behavior with or without security features is linear with the length of the messages and is comparable to that of a commonly available RPC technology once the client and server are fully bound to each other, authentication on RPCs is inexpensive, and encryption and integrity on messages do not come cheap.

Journal Article Managing Replicated Remote Procedure Call Transactions Wanlei Zhou, Wanlei Zhou Search for other works by this author on: Oxford Academic Google Scholar Andrzej Goscinski Andrzej Goscinski Search for other works by this author on: Oxford Academic Google Scholar The Computer Journal, Volume 42, Issue 7, 1999, Pages 592–608, https://doi.org/10.1093/comjnl/42.7.592 Published: 01 January 1999

Alphorn, a software environment for programming distributed computer systems, is described. Programs running on different computers, possibly of different types and running different operating systems, communicate in a client-server relationship by means of remote procedure calls. This efficient construct structures programs neatly. The paper covers distributed process control, Alphorn's object-based programming style, remote procedure calls, the service interface language, configuration, runtime and debugging, and fault tolerance support.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

Modern On-Line Data Intensive (OLDI) applications have evolved from monolithic systems to instead comprise numerous, distributed microservices interacting via Remote Procedure Calls (RPCs). Microservices face sub-millisecond (sub-ms) RPC latency goals, much tighter than their monolithic counterparts that must meet ≥ 100 ms latency targets. Sub-ms-scale threading and concurrency design effects that were once insignificant for such monolithic services can now come to dominate in the sub-ms-scale microservice regime. We investigate how threading design critically impacts microservice tail latency by developing a taxonomy of threading models--a structured understanding of the implications of how microservices manage concurrency and interact with RPC interfaces under wide-ranging loads. We develop µTune, a system that has two features: (1) a novel framework that abstracts threading model implementation from application code, and (2) an automatic load adaptation system that curtails microservice tail latency by exploiting inherent latency trade-offs revealed in our taxonomy to transition among threading models. We study µTune in the context of four OLDI applications to demonstrate up to 1.9× tail latency improvement over static threading choices and state-of-the-art adaptation techniques.

Minor versions of Network File System (NFS) version 4 newer than minor version 0 work best when Remote Procedure Call (RPC) transports can send RPC transactions in both directions on the same connection. This document describes how RPC transport endpoints capable of Remote Direct Memory Access (RDMA) convey RPCs in both directions on a single connection.

Although high performance computing has been achieved over computational Grids using various techniques, the support for high performance computing on the Grids using Remote Procedure Call (RPC) mechanisms is fairly limited. In this paper, we discuss a RPC system called GrADSolve that supports execution of parallel applications over Grid resources. GrADSolve employs powerful scheduling techniques for dynamically choosing the resources used for the execution of parallel applications and also uses robust data staging mechanisms based on the data distribution used by the end application. Experiments and results are presented to prove that GrADSolve’s data staging mechanisms can significantly reduce the overhead associated with data movement in current RPC systems.

Due to the well-known issues with Remote Procedure Calls (RPC), the rather simple idea of modifying legacy applications - that have low spatial locality to the data they need to process - to execute all of their procedures via RPC is not a feasible option. A more realistic and feasible alternative is to provide a self-management mechanism that can dynamically monitor and alter the execution of an existing application by selectively modifying certain procedures to execute remotely when it is necessary to improve spatial locality. In this paper we describe the motivations behind such a self-management mechanism, and outline an initial design. In addition, we introduce our vision for the required profiling component of these applications. As such, we introduce the Automated Legacy system Remote Procedure Call mechanism (ALRPC). It automatically converts existing monolithic C applications into a distributed system semi-automatically. Thus automation is a key criterion for successfully competing with existing remote procedure tools for legacy applications and with newer solutions such as SOAP and REST [12], [21]. ALRPC is the core component to convert monolithic applications into distributable self-adaptive RPC systems. The empirical results collected from our initial experiments show that our mechanism's level of automation outperforms existing industry strength tools and improves development time. At the same time our mechanism is able to correctly function with a significant code base and shows acceptable performance in initial tests.

Distributed procedures that use a message-passing approach communicate with one another by transferring bits of information in order to provide unique access to all available tasks. Almost every single modern computer now has a CPU with several cores, which provides additional computing capacity. Moreover, parallel execution is critical in the new age of big data to enhance performance to a reasonable threshold. Indeed, parallelization brings with it additional issues that must be tack-led. However, parallel algorithms are studied and contrasted in comparison to their consecutive equivalents. In our paper, we look at sorting the unsorted numbers in distributed systems. Multi-threaded methods and performance, along with the difficulty of defining time, affect speed as well. Following that, an experiment was conducted in which a set of algorithms was implemented as well as the data was gathered through benchmarking and testing. To establish the validity of parallelization, the data were inspected and analyzed with its associated source code. A review was carried out in order to obtain a better idea of the scope of sorting algorithms and parallel computing. In this paper, a multi-sorting threading algorithm approach has been conducted based on previous work. The primary idea behind the algorithm is simple as well as Remote Procedure Calls (RPCs) approach has been used.

We present a new abstract machine, called DCESH, which models the execution of higher-order programs running in distributed architectures. DCESH implements a native general remote higher-order function call across node boundaries. It is a modernised version of SECD enriched with specialised communication features required for implementing the remote procedure call mechanism. The key correctness result is that the termination behaviour of the remote procedure call is indistinguishable (bisimilar) to that of a local call. The correctness proofs and the requisite definitions for DCESH and other related abstract machines are formalised using Agda. We also formalise a generic transactional mechanism for transparently handling failure in DCESHs.We use the DCESH as a target architecture for compiling a conventional call-by-value functional language (Floskel) which can be annotated with node information. Conventional benchmarks show that the single-node performance of Floskel is comparable to that of OCaml, a semantically similar language, and that distribution overheads are not excessive.

Chapter 8 - Exchange Protocol/Client Encryption