K. H. (Kane) Kim

A distributed fault tolerant architecture for nuclear reactor and other critical process control applications

A distributed fault tolerant system for process control that is based on an enhancement of the distributed recovery block (DRB) is described. Fault tolerance provisions in the system cover software faults by use of the DRB; hardware faults by means of replication and the DRB; system software faults by means of replication, loose coupling, periodic status messages, and a restart capability; and network faults by means of replication and diverse interconnection paths. Maintainability is enhanced through an automated restart capability and logging function resident on a system supervisor node. The system, called the extended distributed recovery block, or EDRB, has been implemented and integrated into a chemical processing system.<<ETX>>

RMMC programming model and support execution engine in the TMO programming scheme

While the conventional remote method invocation mechanism has been considered for a long time as the primary approach for facilitating interactions among real-time objects, a multicast support mechanism has been recognized in recent years as an attractive supplement, if not a favored approach, in many applications. One highly promising concrete formulation of a multicast mechanism and an associated programming model is the real-time multicast and memory-replication channel (RMMC). This paper presents an API set designed for facilitating easy use of RMMCs and a middleware subsystem devised to support RMMCs. An experimental study performed to validate the RMMC support facility and check the performance of a TMO-structured multimedia application which uses an RMMC, is also discussed.

An implementation model for time-triggered message-triggered object support mechanisms in CORBA-compliant COTS platforms

Object-oriented analysis and design methodologies have become popular in development of non-real-time business data processing applications. However, conventional object-oriented techniques have had minimal impacts on development of real-time applications mainly because these techniques do not explicitly address key characteristics of real-time systems, in particular timing requirements. The Time-triggered Message-triggered Object (TMO) structuring is in our view the most natural extension of the object-oriented design and implementation techniques which allows the system designer to explicitly specify timing characteristics of data and function components of an object. To facilitate TMO-based design of real-time systems in the most cost-effective manner it is essential to provide execution support mechanisms in well-established commercial software/hardware platforms compliant with industry standards. In this paper, we present an implementation model for TMO support mechanisms in CORBA-compliant commercial-off-the-self (COTS) platforms. We first introduce a natural and simple mapping between TMOs and CORBA objects. Then, we identify the services to be provided by the TMO support subsystem and an efficient way these services should be implemented. The rest of the paper discusses an implementation of the proposed model realized on top of the Windows NT operating system and the Orbix object request.

Efficient Adaptations of the Non-Blocking Buffer for Event Message Communication between Real-Time Threads

Enabling message communication among concurrent computing threads without relying on mutual exclusion (i.e., locking) is highly desirable in real-time computing systems. This paper presents a refined version of the Non-Blocking Buffer (NBB), which is a lock-free interaction mechanism that enables efficient event-message communication between a single producer thread and a single consumer thread. The NBB scheme presented here contains improvements over the previous version in two aspects. First, application designers now have the flexibility of choosing the consumers retry strategy for the case when the buffer is empty but the producer is in the middle of inserting an item. Second, in the refined version the producer inserts pointers to data items into the buffer whereas the consumer obtains copies of the items. This design is consistent with the fact that shared heap management must be avoided to enable fully lock-free interaction between the producer and the consumer. This paper also discusses the approaches based on the NBB mechanism for supporting all conceivable producer-consumer scenarios.

Architecture of ROAFTS/Solaris: a Solaris-based middleware for real-time object-oriented adaptive fault tolerance support

Middleware implementation of various critical services required by large scale and complex real time applications on top of COTS operating system is currently an approach of growing interests. Its main goal is to enable significant reduction application system design separating the concerns of the application designer for the application functionality from the concerns for application independent system issues. The paper presents the middleware architecture named the Real-time Object-oriented Adaptive Fault Tolerance Support (ROAFTS) and a prototype implementation ROAFTS/Solaris realized on top of both a COTS operating systems, Solaris, and a COTS CORBA complaint ORB, Orbix. ROAFTS supports distributed real time applications, each structured as a network of Time-triggered Message-triggered Objects (TMOs), and the TMO is a major extension of a conventional object for use in hard real time applications. The major components of ROAFTS include a TMO support manager for supporting the execution of TMOs, a generic fault tolerance server, and a network surveillance manager (NSM) which provides the generic fault tolerance server with fast fault detection notices. The generic fault tolerance server and the NSM themselves have been structured as TMOs. A discussion on an effective use of CORBA standards for moderate precision real time applications to run on COTS operating systems is also presented.

Realization of an Adaptive Distributed Sound System Based on Global-Time-Based Coordination and Listener Localization

This paper discusses the benefits of exploiting 1) the principle of global-time-based coordination of distributed computing actions (TCoDA) and 2) a high-level component-/object-based programming approach in developing real-time embedded computing software. The benefits are discussed in the context of a concrete case study. A new major type of distributed multimedia processing applications, called Adaptive Distributed Sound Systems (ADSSs), is presented here to show the compelling nature of the TCoDA exploitation. High-quality ADSSs impose stringent real-time distributed computing requirements. They require a global-time base with precision better than 100 mus. For efficient implementation, the TMO programming scheme and associated tools are shown to be highly useful. In addition, a prototype TMO-based ADSS has been developed and its most important quality attributes have been empirically evaluated. The prototype ADSS has also turned out to be a cost-effective tool for assessing the quality of service of a TMO execution engine.

Time-triggered message-triggered object modeling of a distributed real-time control application for its real-time simulation

The time-triggered message-triggered object (TMO) has been devised as the basic component model for high level distributed real time programming as well as real time application system/subsystem design and modeling. One of the strengths of the TMO is its facilitation of multi-phased top-down modeling of real time distributed computing application systems. TMO-structured models are capable of representing both a real time control system and its controlled facilities (composed of sensors, actuators, and monitored infrastructure) in a uniform fashion. Also, TMO-structured real time simulation models can be generated in attractively simple forms and they can be executed to enable examination of not only the logical accuracy of a real time control system being developed but also the correctness of its timing behavior. A case study of such simulation modeling has been conducted in the context of constructing a real time simulator of a real time control system called the safety injection system (SIS) which is a subsystem of a nuclear power plant. In the course of this case study, some tools that support efficient real time simulation have been developed. The refined modeling steps, the support tools developed, and the cost-effectiveness confirmed in the course of this case study are the main subjects discussed.

Techniques for implementing support middleware for the PSTR scheme for real-time object replication

The primary-shadow TMO replication (PSTR) scheme is an active real-time object replication scheme formulated by the first author several years ago. PSTR is a powerful scheme in that it facilitates real-time forward recovery while prolonging the life-time of real-time application systems and it is applicable to a broad range of real-time distributed computing application systems. A middleware subsystem supporting the PSTR scheme has been designed as a part of the middleware architecture that is named ROAFTS and has been evolving since several years ago. ROAFTS is a middleware system which is layered above a commercial-off-the-shelf operating system kernel and functions as the core of a reliable execution engine for fault-tolerant distributed real-time applications. The applications supported by ROAFTS are structured as networks of real-time objects, named time-triggered message-triggered objects (TMOs). The techniques for middleware-based implementation of the PSTR scheme have been improved in recent years. The ROAFTS middleware structure is reviewed first and then the improved implementation techniques are discussed. An analysis of the recovery time bounds achievable with the middleware prototype has also been conducted and some core results are presented

Issues in realization of an execution time analyzer for distributed real-time objects

An issue that the real-time software research community has long recognized as an important technological challenge but has not shown much progress in meeting the challenge is to guarantee response times of real-time distributed systems. Two basic problems must be addressed to effectively meet this challenge: establishment of the distributed real-time program structure and the system infrastructure structure that enable systematic analysis of the worst-case time behavior of the application systems; and development of tools which perform automated analysis of the worst-case time behavior while leaving only minimal work to the designers. Research on the first problems has produced some useful results in recent years. Time is thus ripe for tackling the second problem on the basis of those recent developments in handling the first problem. This paper describes a desirable systematic timing analysis process which builds upon the recent results in the first problem area. An outline of a desirable analysis tool is also presented.

TMO-structured cluster-based real-time management of location data on massive volume of moving items

A major challenge in the field of location based service (LBS) system engineering, is to establish a highly scalable system architecture which can be instantiated in moderate-size configurations handling thousands of moving items as well as in upper-end configurations handling millions of moving items. We are exploring an approach of using a cluster of database server nodes and effecting efficient distributed and parallel computing in both real-time update of location records of moving items and processing of location-related queries. The approach of developing efficient middleware which is layered on a cluster of nodes running commercial off-the-shelf database servers, has been adopted. The middleware design is substantially based on the TMO scheme for real-time distributed object programming and real-time distributed computing system design, which enables low-overhead coordination of distributed computations and highly abstract distributed programming styles.