Facilitating Mixed Language Programming in Distrbuted Systems

An approach for facilitating mixed language programming in distributed systems is presented. It is based on adding a generic remote procedure call facility to each language, and the use of a type system to describe procedural interfaces, as well as data to be transferred between procedures. This type scheme also specifies a machine-independent representation for all data. By defining standard mappings for each programming language, the data conversions required for cross-langauge calls may be performed, automatically in most cases, by active agents that provide the interface between program components written in different languages. When necessary, explicit control of the conversation is possible. A prototype implementation of a system based on this approach has been constructed on a collection of machines running Berkeley UNIX®.     

NRMI: Natural and Efficient Middleware

We present natural remote method invocation (NRMI): a middleware mechanism that provides a fully general implementation of call-by-copy-restore semantics for arbitrary linked data structures, used as parameters in remote procedure calls. Call-by-copy-restore offers a more natural programming model for distributed systems than traditional call-by-copy middleware, enabling remote calls to behave much like local calls. We discuss in depth the effects of calling semantics for middleware, describe when and why NRMI is more convenient to use than standard middleware, and present three implementations of NRMI in distinct settings, showing the generality of the approach.     

An overview of the Nexus distributed operating system design

Nexus is a distributed operating system designed to support experimental research in fault-tolerance techniques and object-oriented programming in distributed systems. The Nexus programming environment consists of objects, which are instances of abstract data types. Inheritance of types and multiple implementations for a type are supported by the system. Operations on objects are invoked, based on the remote-procedure-call paradigm and executed as atomic actions with provisions for application-controlled checkpointing and restart within actions. Nexus also supports parallel remote procedure calls. Interobject communication and location transparency in accessing objects is supported by the Nexus kernel     

基于XML-RPC企业分布式数据处理

XML—RPC是基于XML，HTTP，可跨平台，并允许复杂的数据结构传递、处理、返回的RPC。针对目前企业中流行采用的集中式数据处理系统存在的问题，提出了采用基本XML—RPC实现分布式数据处理系统，目的在于让企业信息系统简单、高效、易扩充，并保证系统的动态平衡和容错性。     

Integrating Computing Resources on Multiple Grid-Enabled Job Scheduling Systems Through a Grid RPC System

We present a framework for a parallel programming model by remote procedure calls, which bridge large-scale computing resource pools managed by multiple Grid-enabled job scheduling systems. With this system, the user can exploit not only remote servers and clusters, but also the computing resources provided by Grid-enabled job scheduling systems located on different sites. This framework requires a Grid remote procedure call (RPC) system to decouple the computation in a remote node from the Grid RPC mechanism and uses document-based communication rather than connection-based communication. We implemented the proposed framework as an extension of the OmniRPC system, which is a Grid RPC system for parallel programming. We designed a general interface to easily adapt the OmniRPC system to various Grid-enabled job scheduling systems, including XtremWeb, CyberGRIP, Condor and Grid Engine. We show the preliminary performance of these implementations using a phylogenetic application. We found that the proposed system can achieve approximately the same performance as OmniRPC and can handle interruptions in worker programs on remote nodes. Yoshihiro Nakajima is a Research Fellow of the Japan Society for the Promotion of Science     

Elements of a distributed programming system

A previous paper proposed and described a high-level, application-independent framework for the construction of distributed systems within a resource-sharing computer network. The framework implements a simple procedure call model in which distant processes invoke procedures in one another by exchanging the necessary arguments and results. The present paper explores some of the ways in which this simple model might be extended to provide the programmer with a more comprehensive distributed programming system. Among the extensions proposed are coroutine linkages and other forms of communication between caller and callee, the propagation of notices and requests up the thread of control that results from nested procedure calls, the reading and writing of data objects within the remote program, and the creation and manipulation of arbitrarily complex process hierarchies and more general inter-process control paths.     

Transaction processing using remote procedure calls (RPC) for a heterogeneous distributed clinical information system

The Johns Hopkins Hospital is developing a distributed clinical information system that integrates functionally several UNIX, IBM MVS/CICS and MUMPS computer systems. Distributed application development is accomplished by interprocess communications across Ethernet using remote procedure calls. The remote procedure call (RPC) protocol provides a standard approach to the development of distributed applications using the metaphor of a subroutine call. The Sun Microsystems RPC and XDR (external data representation) protocols have been implemented in these environments. The systems, the distributed model, RPC implementations and applications examples are discussed.     

Component-based APIs for versioning and distributed applications

Operating system application programming interfaces (APIs) are typically monolithic procedural interfaces that address a single machine's requirements. This design limits evolutionary development and complicates application development for distributed systems. Current APIs tend to be large, rigid, and focus on a single host machine. Component-based APIs could solve these problems through strong versioning capabilities and support for distributed applications. Ideally, obsolete API calls should be deleted, and calls with modified semantics (but unmodified parameters and return values) would remain the same. However, since the OS must continue to support legacy applications, obsolete calls cannot be deleted, and new call semantics are best introduced through new calls. In addition, typical OS APIs do not adequately address the needs of distributed applications: they have support for intermachine communication but lack high-level support for accessing remote OS resources. The primary omission is a uniform method for naming remote resources, such as windows, files, and synchronization objects     

DMODULA: A distributed programming language

This paper presents an overview of a distributed programming language calledDMODULA,which is intended for the programming in a distributed environment.DMODULA develops module concepts of its ancestor,MODULA-2,and providesfeatures of generic and remote procedure calls.DMODULA has been implemented onthe ZOZ system,a distributed microcomputer system consisting of several LSI-11microcomputers,which was designed and implemented at Nanjing University in 1982.     

Modules,objects and distributed programming: Issues in RPC and remote object invocation

Distributed programming can be greatly simplified by language support for distributed communication, such as that provided by remote procedure call (RPC) or remote object invocation. This paper examines design and implementation issues in these systems, and focuses on the influence of the communication system on a distributed program. To make the discussion concrete, we introduce a single application as implemented in two environments: Modula-2+, an extension of Modula-2 with RPC, and Emerald, an object-based language that supports remote object invocation. We show that small differences in the implementation of the communication system can have a significant impact on how distributed applications are structured.     

A platform independent distributed IPC mechanism in support of programming heterogeneous distributed systems

Interprocess communication (IPC) is a well-known technique commonly used by programs running on homogeneous distributed systems. However, it cannot be used readily and efficiently by programs running on heterogeneous distributed systems. This is because it must be given a uniform interface either by a set of middleware or more efficiently properly ported to the kernel of all varieties of open source and closed source proprietary operating systems running on heterogeneous nodes of distributed systems. This is particularly problematic to achieve when the kernel code of closed source operating systems are inaccessible to third parties. We propose an alternative nonproprietary approach to enable the use of IPC in heterogeneous distributed systems by wrapping IPC calls from the kernel of closed source operating systems, and converting them into equivalent IPC calls that are efficiently implemented inside the kernel code of open source operating systems. To show the superiority of our approach, we developed a wrapper for converting MS-Windows IPC calls into equivalent Linux IPC calls and benched our approach on a hybrid computer cluster running both types of operating systems.     

Data Refinement of Remote Procedures

Recently the action systems formalism for parallel and distributed systems has been extended with the procedure mechanism. This gives us a very general framework for describing different communication paradigms for action systems, e.g. remote procedure calls. Action systems come with a design methodology based on the refinement calculus. Data refinement is a powerful technique for refining action systems. In this paper we will develop a theory and proof rules for the refinement of action systems that communicate via remote procedures based on the data refinement approach. The proof rules we develop are compositional so that modular refinement of action systems is supported. As an example we will especially study the atomicity refinement of actions. This is an important refinement strategy, as it potentially increases the degree of parallelism in an action system. Received February 1999 / Accepted in revised form July 2000     

Experience with remote procedure calls in a real-time control system

This paper describes several years' practical experience with remote procedure calls as a primary tool for application software in a large and complex distributed real-time process control system. We motivate the use of remote procedure calls as an effective technique for the use of local area networks, describe our implementation and discuss its advantages and disadvantages.     

Java-centric distributed computing

The Java language and platform provide a base for distributed computing that changes several conventional assumptions. In particular, the Java Virtual Machine allows a group of Java-enabled machines to be treated as a homogeneous group rather than a heterogeneous group, despite possible differences in the machine architectures and underlying operating systems. Java also makes it possible to safely and dynamically load code in a running Java process. Together, these features allow a system to invoke methods on remote objects, which can move code associated with language-level objects from the calling process to the process called and vice versa. Combining these qualities with a language-centric design not only significantly simplifies traditional RPC systems, it adds functionality that was previously not possible. We designed Java Remote Method Invocation (RMI) to support pure-Java distributed objects in a seamless manner. RMI allows calls to be made between Java objects in different virtual machines, even on different physical machines     

Event‐driven asynchronous method calls with the D‐Bus message system

The use of inter‐process communication can yield many benefits for event‐driven desktop software. However, inter‐process communication (IPC) research has traditionally been focused on calculation‐oriented distributed computing. This article shows that existing IPC solutions are a poor fit for the constraints imposed by event‐driven programming. Our novel solution is built on top of the D‐Bus system, which enjoys increased practical usage, but is still scantily researched. We focus on efficient handling of asynchronous D‐Bus method calls, in a fashion similar to how Hypertext Transfer Protocol requests are treated in Asynchronous JavaScript and XML Web applications. This is supplemented with two design patterns that simplify processing of results for many kinds of asynchronous operations in event‐driven software, besides just D‐Bus calls. Our approach is shown to be more appropriate for event‐driven applications than traditional remote procedure call systems in aspects as diverse as interactivity, threading complexity and electrical power usage. Copyright © 2013 John Wiley & Sons, Ltd.     

Atomic Remote Procedure Call

Remote procedure call (RPC) is a programming primitive that makes building distributed programs easier. Atomicity, whkh implies totality and serializability, has been recognized as an important property to assure consistency in spite of computing node crashes. We have implemented an atomk remote procedure call mechanism which provides users a simple and reliable language primitive. Concurrency is controlled by attaching a call graph path identifier to each message representing a procedure call. Procedures keep their last accepted calling message paths to compare against incoming message paths. Only calls that can be serialized are accepted. Associated states of static variables are saved in backup processors on procedure entry and restored to corresponding variables in case of procedure crash. Detailed concurrency control and recovery algorithms are given, and illustrated with examples.     

Remote database access in the distributed computing environment

This paper describes the design, implementation and testing of a set of software modules that are used for remote database access in a distributed computing environment. The goal of our research and development is to implement a client server model using Structured Query Language (SQL) functions in the Open Software Foundation's (OSF) distributed computing environment (DCE). This design is compared with another which simply uses the sockets application programming interface (API), running over the transmission control protocol/internet protocol (TCP/IP), and is implemented in subroutines that act similar to the remote procedure call (RPC) generated stub code. The prototypes for the remote SQL access project are implemented using an IBM RISC System/6000 (the client) running the AIX operating system and an IBM AS/400 (the server) running the OS/400 operating system. We selected the AS/400 for its database abilities, and the RISC System/6000 since the DCE software is available for it.     

Parallel distributed seismic migration

We report significant speed-up for seismic migration running in parallel on networkconnected IBM RISC/6000 workstations, A sustained performance of 15 MFLOP is obtained on a single-entry-level model 320, and speed-ups as high as 5 are obtained for six workstations connected by Ethernet or token ring. Our parallel software uses remote procedure calls provided by NCS (Network Computing System). We have run over a dozen workstations in parallel, but speed-ups become limited by network data rate. Fiber-optic communication should allow much greater speed-ups, and we describe our preliminary results with the fiberoptic serial link adapter of the RISC/6000. We also present a simple theoretical model that agrees well with our measurements and allows speed-up to be predicted from a knowledge of the ratio of computation to communication, which can be determined empirically before the program is parallellzed. We conclude with a brief discussion of alternative software approaches and programming models for network-connected parallel systems. In particular, our program was recently ported to PVM and Linda, and preliminary measurements yield speed-ups very close to those described here.     

LVT: a layered verification technique for distributed computing systems

This paper presents a layered verification technique, called LVT, for the verification of distributed computing systems with multiple component layers. Each lower layer in such a system provides services in support of functionality of the higher layer. By taking a very general view of programming languages as interfaces of systems, LVT treats each layer in a distributed computing system as a distributed programming language. Each relatively higher‐level language in the computing system is implemented in terms of a lower‐level language. The verification of each layer in a distributed computing system can then be viewed as the verification of implementation correctness for a distributed language. This paper also presents the application of LVT to the verification of a distributed computing system, which has three layers: a small high‐level distributed programming language; a multiple processor architecture consisting of an instruction set and system calls for inter‐process message passing; and a network interface. Programs in the high‐level language are implemented by a compiler mapping from the language layer to the multiprocessor layer. System calls are implemented by network services. LVT and its application demonstrate that the correct execution of a distributed program, most notably its inter‐process communication, is verifiable through layers. The verified layers guarantee the correctness of (1) the compiled code that makes reference to operating system calls, (2) the operating system calls in terms of network calls, and (3) the network calls in terms of network transmission steps. The specification and verification involved are carried out by using the Cambridge Higher Order Logic (HOL) theorem proving system. Copyright © 1999 John Wiley & Sons, Ltd.     

基于Web远程文件管理系统的java实现

为了实现远程文件管理系统的跨操作系统运行,设计了一套基于Java Socket的远程文件类应用程序接口(API),并在此基础上实现了一个图形界面的Client/Server结构的远程文件管理系统。这套API在形式上类似于SunJDK本地文件类,开发人员使用这套API能方便快速地实现能满足自身需要的远程文件管理系统。