Many real-time application domains can benefit from flexible and open distributed architectures, such as those defined by the CORBA specification. CORBA is an architecture for distributed object computing being standardized by the OMG. Although CORBA is well-suited for conventional request/response applications, CORBA implementations are not yet suited for real-time applications due to the lack of key quality of service (QoS) features and performance optimizations. This paper makes three contributions to the design of realtime CORBA systems. First, the paper describes the design of TAO, which is our high-performance, real-time CORBAcompliant implementation that runs on a range of OS platforms with real-time features including VxWorks, Chorus, Solaris 2.x, and Windows NT. Second, it presents TAO’s realtime scheduling service that can provide QoS guarantees for deterministic real-time CORBA applications. Finally, the paper presents performance measurements that demonstrate the effects of priority inversion and non-determinism in conventional CORBA implementations and how these hazards are avoided in TAO. 1

This paper describes a pair of patterns that enhance the reuse, extensibility, and portability of object-oriented communication software by permittingnetwork services to evolve independently of the mechanisms used to establish connections used by the services. The Acceptor and Connector patterns decouple the passive and active establishment of a connection, respectively, from the service performed once the connection is established. In addition, the patterns decouple the service creation and concurrency strategies from the services themselves. 1 Introduction Connection-oriented protocols (such as TCP/IP or IPX/SPX) provide reliable delivery of data between two or more endpoints of communication. Establishing connections between endpoints involves the following two roles: ffl Passive role -- which initializes an endpoint of communication at a particular address and waits passively for the other endpoint(s) to connect with it; ffl Active role -- which actively initiates a connection t...

Abstract not found

An interface definition language (IDL) is a nontraditional language for describing interfaces between software components. IDL compilers generate "stubs" that provide separate communicating processes with the abstraction of local object invocation or procedure call. High-quality stub generation is essential for applications to benefit from componentbased designs, whether the components reside on a single computer or on multiple networked hosts. Typical IDL compilers, however, do little code optimization, incorrectly assuming that interprocess communication is always the primary bottleneck. More generally, typical IDL compilers are "rigid" and limited to supporting only a single IDL, a fixed mapping onto a target language, and a narrow range of data encodings and transport mechanisms. Flick, our new IDL compiler, is based on the insight that IDLs are true languages amenable to modern compilation techniques. Flick exploits concepts from traditional programming language compilers to br...

This paper describes the design and performance of an object-oriented communication framework being developed by the Health Imaging division of Eastman Kodak and the Electronic Radiology Laboratory at Washington University School of Medicine. The framework is designed to meet the demands of next-generation electronic medical imaging systems, which must transfer extremely large quantities of data efficiently and flexibly in a distributed environment. A novel aspect of this framework is its seamless integration of flexible high-level CORBA distributed object computing middleware with efficient low-level socket network programming mechanisms. In the paper, we outline the design goals and software architecture of our framework, describe how we resolved design challenges, and illustrate the performance of the framework over high-speed ATM networks. 1 Introduction The demand for distributed electronic medical imaging systems (EMISs) is pushed by technological advances and pulled by economic...

Abstract Developers of communication software must confront recurring design challenges involving robustness, efficiency, and extensibility. Many of these challenges are independent of the application-specific requirements. Successful developers resolve these challenges by applying appropriate design patterns. However, these patterns have traditionally been locked in the minds of expert developers or buried within complex system source code. The primary contribution of this paper is to describe a family of design patterns that underly many object-oriented communication software systems. In addition to describing each pattern separately, the paper illustrates how knowledge of the relationships and trade-offs among patterns helps guide the construction of reusable communication software frameworks. 1 Introduction Building, maintaining, and enhancing high quality communication systems is hard. Developers must have a deep understanding of many complex issues such as service initializatio...

Factory, Builder, and Service Configurator) the ACE framework components facilitate the development of communication software that may be updated and extended without modifying, recompiling, relinking, or even restarting running systems [6]. 3.1.4 Self-contained Distributed Service Components ACE provides a standard library of distributed services that are packaged as self-contained components. Although these service components are not strictly part of the ACE framework, they play two important roles: Factoring out reusable distributed application building blocks: These service components provide reusable implementations of common distributed application tasks such as naming, event routing, logging, time synchronization, and network locking; Demonstrating common use-cases of ACE: These distributed services also demonstrate how ACE components (such as Reactors, Service Configurators, Acceptors and Connectors, Active Objects, and IPC wrappers) can be used effectively to develop flexi...

This paper describes the Half-Sync/Half-Async pattern, which integrates synchronous and asynchronous I/O models to support both programming simplicity and execution efficiency in complex concurrent software systems. In this pattern, higher-level tasks use a synchronous I/O model, which simplifies concurrent programming. In contrast, lower-level tasks use an asynchronous I/O model, which enhances execution efficiency. This pattern is widely used in operating systems such as UNIX, Mach, WindowsNT, and VMS, as well as other complex concurrent systems. 1 Intent The Half-Sync/Half-Async pattern decouples synchronous I/O from asynchronous I/O in a system to simplify concurrent programming effort without degrading execution efficiency. 2 Motivation To illustrate the Half-Sync/Half-Async pattern, consider the software architecture of the BSD UNIX [1] networking subsystem shown in Figure 1. The BSD UNIX kernel coordinates I/O between asynchronous communication devices (such as network adapter...

We describe the implementation of ASSIST, a programming environment for parallel and distributed programs. Its coordination language is based of the parallel skeleton model, extended with new features to enhance expressiveness, parallel software reuse, software component integration and interfacing to external resources. The compilation process and the structure of the run-time support of ASSIST are discussed with respect to the issues introduced by the new characteristics, presenting an analysis of the first test results.

Advanced distributed interactive simulations have stringent quality of service (QoS) requirements for throughput, latency, and scalability, as well as requirements for a flexible communication infrastructure to reduce software lifecycle costs. The CORBA Event Service provides a flexible model for asynchronous communication among distributed and collocated objects. However, the standard CORBA Event Service specification lacks important features and QoS optimizations required by distributed interactive simulation systems.