Interprocess communication

As computing devices become ubiquitous and increasingly mobile, it is becoming apparent that the directed peerto-peer communication model has shortcomings for many forms of distributed interprocess communication. Undirected communication, including content-based messaging, is becoming increasingly common. This paper examines the issues involved in supporting content-based messaging to both mobile devices and users using a combination of connected and mobile (possibly disconnected) devices. These issues include persistence, multi-client shared subscriptions, non-destructive notification receipt, and notification expiry. The discussion is placed in the context of the development of a proxy-server to provide disconnectedness support for the Elvin content-based messaging service.

Orca is a language for programming parallel applications on distributed computing systems. Although processors in such systems communicate only through message passing and not through shared memory, Orca provides a communication model based on logically shared data. Programmers can define abstract data types and create instances (objects) of these types, which may be shared among processes. All operations on shared objects are executed atomically. Orca's shared objects are implemented by replicating them in the local memories of the processors. Read operations use the local copies of the object, without doing any interprocess communication. Write operations update all copies using an efficient reliable broadcast protocol. In this paper, we briefly describe the language and its implementation and then report on our experiences in using Orca for three parallel applications: the Traveling Salesman Problem, the All-pairs Shortest Paths problem, and Successive Overrelaxation. These applications have different needs for shared data: TSP greatly benefits from the support for shared data; ASP benefits from the use of broadcast communication, even though it is hidden in the implementation; SOR merely requires point-to-point communication, but still can be implemented in the language by simulating message passing. We discuss how these applications are programmed in Orca and we give the most interesting portions of the Orca code. Also, we include performance measurements for these programs on a distributed system consisting of 10 MC68020s connected by an Ethernet. These measurements show that significant speedups are obtained for all three programs.

Thoth is a real-time operating system which is designed to be portable over a large set of machines. It is currently running on two minicomputers with quite different architectures. Both the system and application programs which use it are written in a high-level language. Because the system is implemented by the same software on different hardware, it has the same interface to user programs. Hence, application programs which use Thoth are highly portable. Thoth encourages structuring programs as networks of communicating processes by providing efficient interprocess communication primitives.

The performance of large software systems based on a server-slave architecture depends heavily on the design of the interprocess communication (IPC) protocol. In this paper different approaches of the logical structure of the protocol of the IPC communication are proposed and analyzed. The term of a logical protocol unit (LPU) is defined. All basic actions of the software system are logically grouped into units and transferred jointly via the interprocess communication facilities of the underlying operating system. An algorithm is given for the calculation of specific LPUs.

Abstract. Agent communication is one of the key issues in multi-agent systems. Traditional interprocess communication formalisms are usually considered insufficient for this purpose because of their lack of expressiveness; thus, in most proposals for multi-agent architectures, an Agent Communication Language (ACL) is designed to provide for agent communication. However, a universally accepted standard for ACLs is still missing. Agent communication in open societies of heterogeneous agents poses requirements on ACLs ...

This paper describes interprocess communication and process dispatching on the Intel 432. The primary assets of the facility are its generality and its usefulness in a wide range of applications. The conceptual model, supporting mechanisms, available interfaces, current implementations, and absolute and comparative performance are described.

A unified facility for interprocess communication and processor dispatching on the Intel 432 is described. The facility is based on a queuing and binding mechanism called a port. The goals and motivations for ports, both abstract and implementation views of them, and their absolute and comparative performance are described.

This paper describes interprocess communication and process dispatching on the Intel 432. The primary assets of the facility are its generality and its usefulness in a wide range of applications. The conceptual model, supporting mechanisms, available interfaces, current implementations, and absolute and comparative performance are described. The Intel 432 is an object-based multiprocessor. There are two processor types: General Data Processors (GDPs) and Interface Processors (IPs). These processors provide several operating system functions in hardware by defining and using a number of processor-recognized objects and high-level instructions. In particular, they use several types of processor-recognized objects to provide a unified structure for both interprocess communication and process dispatching. One of the prime motivations for providing this level of hardware support is to improve efficiency of these facilities over similar facilities implemented in software. With greater eff...

A unified facility for interprocess communication and processor dispatching on the Intel 432 is described. The facility is based on a queuing and binding mechanism called a port. The goals and motivations for ports, both abstract and implementation views of them, and their absolute and comparative performance are described.

structure called a monitor synchronizes access to shared data in shared-memory architectures, whereas °This work wa._ partially supported by National Science rent prograrnming mechanisnts of the tirrw (monitor:_. F,,uudatiou Krant ('CR-9121875. r_wssage-passing, and rernote oi)orations) a.s to make tThis w,,rk wa._ _upported by the Applied Mathematical S,:i-it a fo_lrt, h model, lt differs from the other menials in ,'m'_._ _ubpr,,Kr;tu_,,f the ()trice of E_ergy Ftesearch, II ..q.

Deterministic execution offers many benefits for debugging, fault tolerance, and security. Current methods of executing parallel programs deterministically, however, often incur high costs, allow misbehaved software to defeat repeatability, and transform time-dependent races into input-or path-dependent races without eliminating them. We introduce a new parallel programming model addressing these issues, and use Determinator, a proof-of-concept OS, to demonstrate the model's practicality. Determinator's microkernel API provides only "shared-nothing" address spaces and deterministic interprocess communication primitives to make execution of all unprivileged code-well-behaved or notprecisely repeatable. Atop this microkernel, Determinator's user-level runtime adapts optimistic replication techniques to offer a private workspace model for both thread-level and process-level parallel programing. This model avoids the introduction of read/write data races, and converts write/write races into reliably-detected conflicts. Coarse-grained parallel benchmarks perform and scale comparably to nondeterministic systems, on both multicore PCs and across nodes in a distributed cluster.

Many fault-tolerant and intrusion-tolerant systems require the ability to execute unsafe programs in a realistic environment without leaving permanent damages. Virtual machine technology meets this requirement perfectly because it provides an execution environment that is both realistic and isolated. In this paper, we introduce an OS level virtual machine architecture for Windows applications called Feather-weight Virtual Machine (FVM), under which virtual machines share as many resources of the host machine as possible while still isolated from one another and from the host machine. The key technique behind FVM is namespace virtualization, which isolates virtual machines by renaming resources at the OS system call interface. Through a copy-on-write scheme, FVM allows multiple virtual machines to physically share resources but logically isolate their resources from each other. A main technical challenge in FVM is how to achieve strong isolation among different virtual machines and the host machine, due to numerous namespaces and interprocess communication mechanisms on Windows. Experimental results demonstrate that FVM is more flexible and scalable, requires less system resource, incurs lower start-up and run-time performance overhead than existing hardware-level virtual machine technologies, and thus makes a compelling building block for security and fault-tolerant applications.

This paper describes the parallel extension of the mask tuning scheme for texture feature extraction. Unlike other parallel systems in which specific parallel computer archi- tectures are required, our parallel solution to increase pro- cessing speed is examined by introducing the concept of remote procedure call(RPC) in distributed systems for Io- cal or remote interprocess communication. Based on our previous

Process models for multimedia computing must allow applications to adapt their pattern of execution as resources become scarce or abundant. As processes adapt, it is natural to express their desired performance in terms of a processing rate of application-defined data units or events. We propose a process model wherein processes execute according to a general rate specification of x process executions every y time units. In addition, a separate parameter is used to specify the desired response time for the completion of each execution. In all cases the real-time performance of a rate-based process is predictable. The model is general enough to encompass or extend many of the existing models proposed for multimedia systems. Our model of rate-based execution is described along with an implementation that detects when processes should adapt their execution rate and minimizes latency in interprocess communication.

Rapid Prototyping has been proposed as a means to reduce development time and costs of real-time systems. Our approach uses a heterogeneous, tightly coupled multiprocessor system based on off-the-shelf components as target architecture for an executable prototype, which is generatedfrom the specification in an automated design process. Here, too, we aim to use existing tools and languages. But interface and communication synthesis, while being the key requirement of an automated translation of a abstract specification to a distributed system, is not yet state-of-the-art. The sensitivity of the overall performance of multiprocessor systems to overhead and latency introduced by communication on the other hand calls for an efficient interprocess communication (IPC). This paper presents concept and implementation of IPC functions which, implementing the message queue semantics of the specification language SDL, links the standard components of our multiprocessor system in an efficient manner, while at the same time providing the interface synthesis needed by the automated generation of a rapid prototype. The experiences gained when implementing a non-trivial, real-world CAN controller and monitor application on our rapid prototyping environment, are described as a first proof of concept.

Rapid Prototyping has been proposed as a means to reduce development time and costs of real-time systems. Our approach uses a heterogeneous, tightly coupled multiprocessor system based on off-the-shelf components as target architecture for an executable prototype, which is generatedfrom the specification in an automated design process. Here, too, we aim to use existing tools and languages. But interface and communication synthesis, while being the key requirement of an automated translation of a abstract specification to a distributed system, is not yet state-of-the-art. The sensitivity of the overall performance of multiprocessor systems to overhead and latency introduced by communication on the other hand calls for an efficient interprocess communication (IPC). This paper presents concept and implementation of IPC functions which, implementing the message queue semantics of the specification language SDL, links the standard components of our multiprocessor system in an efficient manner, while at the same time providing the interface synthesis needed by the automated generation of a rapid prototype. The experiences gained when implementing a non-trivial, real-world CAN controller and monitor application on our rapid prototyping environment, are described as a first proof of concept.

We describe a multiprocessor system that attempts to enhance the system performance by incorporating into its architecture a number of key. operating system concepts. In particular:-the scheduling and synchronization of concurrent activities are built in at the hardware level,-the interprocess communication functions are performed in hardware, and,-a coupling between the scheduling and communication functions is provided which allows efficient implementation of parallel systems that is precluded when'the scheduling and communication functions are realized in software.

We present Delta Prolog, a distributed logic programming language that extends Prolog to include AND-parallelism (in a single processor or across a network of processors), interprocess communication via message passing with two-way pattern matching, interprocess synchronization with simultaneous message passing, and distributed backtracking among a family of processes. The extension is achieved, at the language level, by just two additional types of goals-events and splits. The implementation is written part in Prolog and part in C, with a small number of core primitives, to help portability. It is still experimental and expected to evolve. In this work we present the language's distinguishing features, describe its semantics, exhibit programs and analyse their behaviour, examine the implementation, and mention conclusions, advantages of the approach and the next developments.

The last decade has introduced various affordable computing platforms to the parallel computing community. Distributed shared-memory systems and clusters built with commercial-off-the-shelf (COTS) parts and interconnected with high-performance networks have proven to be serious alternatives to expensive supercomputers in terms of both performance and cost. HP's new AlphaServer ES80 is an example of distributed shared-memory systems, while SCI and Myrinet are the two most widely used high-performance interconnects in building parallel-computing clusters. In this study, we experimentally compare the performance of these parallel computer systems. The emphasis is pointing out the strengths and weakness of the HP's AlphaServer ES80 in comparison with highperformance SCI and Myrinet clusters. We evaluated the systems in terms of sustainable memory bandwidth, interprocess communication and overall parallel computation performance using various widelyaccepted benchmarks such as STREAM, PALLAS PMB-MP1, and NAS2.3 parallel suite. It was observed that the HP's AlphaServer ES80, executing Linux, provides remarkable computing power while its communication subsystem cannot handle heavy loads of small messages as effectively.

The overall goal of the proposed research is to develop parallel algorithms for solving medium to small size dense systems of linear equations. It appears that efficient collective communications lead to dense matrix factorization algorithms that can fully utilise the communication bandwidth of a 3-D cube of processes.