Communication and Synchronization Primitives for Distributed Programs

A distributed program is a collection of several processes which execute concurrently, possibly in different nodes of a distributed system, and which cooperate with each other to realize a common goal. In this paper, we present a design of communication and synchronization primitives for distributed programs. The primitives are designed such that they can be provided by a kernel of a distributed operating system. An important feature of the design is that the configuration of a process, i.e., identities of processes with which the process communicates, is specified separately from the computation performed by the process. This permits easy configuration and reconfiguration of processes. We identify different kinds of communication failures, and provide distinct mechanisms for handling them. The communication primitives are not atomic actions. To enable the construction of atomic actions, two new program components, atomic agent and manager are introduced. These are devoid of policy decisions regarding concurrency control and atomic commitment. We introduce the notion of conflicts relation using which a designer can construct either an optimistic or a pessimistic concurrency control scheme. The design also incorporates primitives for constructing nested atomic actions.     

A language and system for the construction and tuning of parallel programs

The programming of efficient parallel software typically requires extensive experimentation with program prototypes. To facilitate such experimentation, any programming system that supports rapid prototyping of parallel programs should provide high-level language primitives with which programs can be explicitly, statically, or dynamically tuned with respect to performance and reliability. Such language primitives should be able to refer conveniently to the information about the executing program and the parallel hardware required for tuning. Such information may include monitoring data about the current or previous program or even hints regarding appropriate tuning decisions. Language primitives and an associated programming system for program tuning are presented. The primitives and system have been implemented, and have been tested with several parallel applications on a network of Unix workstations.<>     

Primitives for distributed computing in a heterogeneous local areanetwork environment

Epsilon is a testbed for monitoring distributed applications involving heterogeneous computers, including microcomputers, interconnected by a local area network. Such a hardware configuration is usual but raises difficulties for the programmer. First, the interprocess communication mechanisms provided by the operating systems are rather cumbersome to use. Second, they are different from one system to another. Third, the programmer of distributed applications should not worry about system and/or network aspects that are not relevant for the application level. The authors present the solution chosen in Epsilon. A set of high-level communication primitives has been designed and implemented to provide the programmer with an interface independent of the operating system and of the underlying interprocess communications facilities. A program participating in a distributed application can be executed on any host without any change in the source code except for host names     

Formalising Java RMI with explicit code mobility

This paper presents an object-oriented, Java-like core language with primitives for distributed programming and explicit code mobility. We apply our formulation to prove the correctness of several optimisations for distributed programs. Our language captures crucial but often hidden aspects of distributed object-oriented programming, including object serialisation, dynamic class downloading and remote method invocation. It is defined in terms of an operational semantics that concisely models the behaviour of distributed programs using machinery from calculi of mobile processes. Type safety is established using invariant properties for distributed runtime configurations. We argue that primitives for explicit code mobility offer a programmer fine-grained control of type-safe code distribution, which is crucial for improving the performance and safety of distributed object-oriented applications.     

High-level design for user and component interfaces

Component-based software architecture is very important for current software engineering practice because (a) it is the basis for re-use of software at the component level, and (b) in distributed systems, the physical distribution of an application over separate computers represents a decomposition of the application. Typical e-commerce applications consist of various components sometimes belonging to different organizations, and presenting different user interfaces to various categories of users. We review in this paper the current trend in standards for inter-component communication in distributed systems, including various forms of remote procedure calls (RPC) and message passing, and paradigms for describing and implementing user interfaces in the Web environment. We discuss whether the user interface can also be described, at an abstract level, by RPC primitives. In the second part of the paper, we discuss the importance of indicating which party is responsible for making certain decisions for selecting control flow alternatives and certain parameter values. This leads to some guidelines for describing system behavior scenarios at the requirements level. We also discuss how this approach can be integrated with screen-oriented behavior definitions.     

Communication system for high-performance distributed computing

With the current advances in computer and networking technology coupled with the availability of software tools for parallel and distributed computing, there has been increased interest in high-performance distributed computing (HPDC). We envision that HPDC environments with supercomputing capabilities will be available in the near future. However, a number of issues have to be resolved before future network-based applications can fully exploit the potential of the HPDC environment. In the paper we present an architecture for a high-speed local area network and a communication system that provides HPDC applications with high bandwidth and low latency. We also characterize the message-passing primitives required in HPDC applications and develop a communication protocol that implements these primitives efficiently.     

In-kernel integration of operating system and infiniband functions for high performance computing clusters: a DSM example

The infiniband (IB) system area network (SAN) enables applications to access hardware directly from user level, reducing the overhead of user-kernel crossings during data transfer. However, distributed applications that exhibit close coupling between network and OS services may benefit from accessing IB from the kernel through IB's native verbs interface, which permits tight integration of these services. We assess this approach using a sequential-consistency distributed shared memory (DSM) system as an example. We first develop primitives that abstract the low-level communication and kernel details, and efficiently serve the application's communication, memory, and scheduling needs. Next, we combine the primitives to form a kernel DSM protocol. The approach is evaluated using our full-fledged Linux kernel DSM implementation over infiniband. We show that overheads are reduced substantially, and overall application performance is improved in terms of both absolute execution time and scalability relative to an entirely user level implementation.     

Real-time image processing on a custom computing platform

The authors explore the utility of custom computing machinery for accelerating the development, testing, and prototyping of a diverse set of image processing applications. We chose an experimental custom computing platform called Splash-2 to investigate this approach to prototyping real time image processing designs. Custom computing platforms are emerging as a class of computers that can provide near application specific computational performance. We developed a real time image processing system called VTSplash, based on the Splash-2 general-purpose platform. Splash-2 is an attached processor featuring programmable processing elements (PEs) and communication paths. The Splash-2 system uses arrays of RAM based field programmable gate arrays (FPGAs), crossbar networks, and distributed memory to accomplish the needed flexibility and performance tasks. Such platforms let designers customize specific operations for function and size, and data paths for individual applications     

A predictable real-time kernel for distributed multisensor systems

The authors present a real-time kernel developed to support a distributed multisensor system encountered in robotics applications. To ensure predictability, the kernel provides services with bounded worst-case execution times. In addition, the kernel allows the programmer to specify timing constraints for process execution and interprocess communication. The kernel uses these timing constraints both for scheduling processes and for scheduling communications. To illustrate the kernel, the authors describe a multisensor system being developed on their distributed real-time system. They present the measured performance of kernel primitives along with conclusions and remarks regarding distributed real-time systems     

A visual process connector for Unix

Upconn a tool that lets Unix programmers visually describe the connections between the processes in a distributed program and then execute the distributed program, is described. Upconn consists of several modules and can be extended by adding to a library of tools rather than by adding many special features to Upconn itself. Upconn has three main uses. First, it lets researchers study distributed processing in common Unix environments, reducing the dependence on specialized environments. Second, it can be used for rapid prototyping of distributed applications. Third, Upconn is a learning tool that can help students focus on writing distributed programs without dealing with the complexities of the communication links     

Mobile-IT Education (MIT. EDU): m-learning applications for classroom settings

Abstract In this paper, we describe the Mobile-IT Education (MIT.EDU) system, which demonstrates the potential of using a distributed mobile device architecture for rapid prototyping of wireless mobile multi-user applications for use in classroom settings. MIT.EDU is a stable, accessible system that combines inexpensive, commodity hardware, a flexible sensor/peripheral interconnection bus, and a powerful, light-weight distributed sensing, classification, and inter-process communications software architecture to facilitate the development of distributed real-time multi-modal and context-aware applications. We demonstrate the power and functionality of this platform by describing a number of MIT.EDU application deployments in educational settings. Initial evaluations of these experiments demonstrate the potential of using the system for real-world interactive m-learning applications.     

State-centric programming for sensor-actuator network systems

Distributed embedded systems such as wireless sensor and actuator networks require new programming models and software tools to support the rapid design and prototyping of sensing and control applications. Unlike centralized platforms and Web-based distributed systems, these distributed sensor-actuator network (DSAN) systems are characterized by a massive number of potentially failing nodes, limited energy and bandwidth resources, and the need to rapidly respond to sensor input. We describe a state-centric, agent-based design methodology to mediate between a system developer's mental model of physical phenomena and the distributed execution of DSAN applications. Building on the ideas of data-centric networking, sensor databases, and proximity-based group formation, we introduce the notion of collaboration groups, which abstracts common patterns in application-specific communication and resource allocation. Using a distributed tracking application with sensor networks, we'll demonstrate how state-centric programming can raise the abstraction level for application developers.     

Pipelined architecture for real-time cost-optimized extraction of visual primitives based on FPGAs

This paper presents an architecture for the extraction of visual primitives on chip: energy, orientation, disparity, and optical flow. This cost-optimized architecture processes in real time high-resolution images for real-life applications. In fact, we present a versatile architecture that may be customized for different performance requirements depending on the target application. In this case, dedicated hardware and its potential on-chip implementation on FPGA devices become an efficient solution. We have developed a multi-scale approach for the computation of the gradient-based primitives. Gradient-based methods are very popular in the literature because they provide a very competitive accuracy vs. efficiency trade-off. The hardware implementation of the system is performed using superscalar fine-grain pipelines to exploit the maximum degree of parallelism provided by the FPGA. The system reaches 350 and 270 VGA frames per second (fps) for the disparity and optical flow computations respectively in their mono-scale version and up to 32 fps for the multi-scale scheme extracting all the described features in parallel. In this work we also analyze the performance in accuracy and hardware resources of the proposed implementation.     

Using optimistic atomic broadcast in transaction processing systems

Atomic broadcast primitives are often proposed as a mechanism to allow fault-tolerant cooperation between sites in a distributed system. Unfortunately, the delay incurred before a message can be delivered makes it difficult to implement high performance, scalable applications on top of atomic broadcast primitives. Recently, a new approach has been proposed for atomic broadcast which, based on optimistic assumptions about the communication system, reduces the average delay for message delivery to the application. We develop this idea further and show how applications can take even more advantage of the optimistic assumption by overlapping the coordination phase of the atomic broadcast algorithm with the processing of delivered messages. In particular, we present a replicated database architecture that employs the new atomic broadcast primitive in such a way that communication and transaction processing are fully overlapped, providing high performance without relaxing transaction correctness.     

ES-Kit: An object-oriented distributed system

This paper describes the design, implementation, and performance of ES-Kit, a distributed object-oriented system being developed by the Experimental Systems Project at the Microelectronics and Computer Technology Corporation. The operating system consists of a kernel and a set of Public Service Objects which dynamically extend the functionality of the kernel by providing several traditional operating system services when required by application objects. Applications for the ES-Kit environment are written in GNU C++ and do not require additional language primitives for distributed execution. Initial performance results from a representative set of applications indicate that the object-oriented paradigm provides a powerful solution to distributed programming.     

ShadowObjects: A Programming Model for Service Replication in Distributed Object Systems

With the growing emphasis on distributed applications, sophisticated programming models for handling replication become important. Control replication as an issue has so far been considered in the larger context of distributed systems such as ISIS and Arjuna. We present a programming model called ShadowObjects for programming replicated services to cater to the needs of control replication in distributed object oriented systems. The ShadowObjects model provides primitives for building highly available and redundant services. Replication in ShadowObjects is encapsulated and a replica access control mechanism is provided. Messages accessing the services exported by a server object can be captured on-the-fly, and can be appropriately scheduled on the replicas. The ShadowObjects model can be used to develop applications for distributed systems.     

Graphics by a Logic Database Management System

The GEDBLOG system allows applications which manipulate graphic objects to be developed following a declarative definitional style. GEDBLOG supports the consistent design and prototyping of graphic applications through an incremental development and makes it possible to guarantee automatically that the application meets its specifications. Typical GEDBLOG applications have graphics as their characterizing element and can be found, for example, in the CAD/CAM, visual languages or graphical interface areas. The system is obtained by integrating a graphical data language in an existing logic database management system, EDBLOG, so that graphic and non-graphic information is handled in a uniform declarative way.     

Implementation of real-time distributed control for discrete event robotic systems using Petri nets

This article presents a systematic method of modeling and implementing real-time control for discrete-event robotic systems using Petri nets. Because, in complex robotic systems such as flexible manufacturing systems, the controllers are distributed according to their physical structure, it is desirable to realize real-time distributed control. In this article, the task specification of robotic processes is represented as a system control-level net. Then, based on the hierarchical approach, it is transformed into detailed subnets, which are decomposed and distributed into the local machine controllers. The implementation of real-time distributed control through communication between the system controller and the machine controllers on a microcomputer network is described for a sample robotic system. The proposed implementation method is sufficiently general, and can be used as an effective prototyping tool for consistent modeling, simulation, and real-time control of large and complex robotic systems.