206871371
Meta-programming techniques for distributed real-time and embedded systems
This paper provides two contributions to the study of mechanisms for reducing the life-cycle costs of distributed real-time and embedded (DRE) systems. First, we present a mechanism-called a Quality Connector-that enables applications to specify the qualities of service that they require from their infrastructure, and then manages the operations that optimize the middleware to implement those requirements. Second, we show how Quality Connectors are being applied in practice to allocate communication resources automatically for real-time CORBA event propagation. Although middleware that configures itself in response to quality of service (QoS) requests has been investigated and applied in general-purpose computing contexts, we believe that the present work is among the first to put such capabilities into mission-critical DRE systems with stringent QoS requirements.
10426622
Object-Oriented Components for High-speed Network Programming
This paper makes two contributions to the development and evaluation of object-oriented communication software. First, it reports performance results from benchmarking several network programming mechanisms (such as sockets and CORBA) on Ethernet and ATM networks. These results illustrate that developers of bandwidth-intensive and delay-sensitive applications (such as interactive medical imaging or teleconferencing) must evaluate their performance requirements and the efficiency of their communication infrastructure carefully before adopting a distributed object solution. Second, the paper describes the software architecture and design principles of the ACE object-oriented network programming components. These components encapsulate UNIX and Windows NT network programming interfaces (such as sockets, TLI, and named pipes) with C++ wrappers. Developers of object-oriented communication software have traditionally had to choose between high-performance, lower-level interfaces provided by sockets or TLI or less efficient, higher-level interfaces provided by communication frameworks like CORBA or DCE. ACE represents a midpoint in the solution space by improving the correctness, programming simplicity, portability, and reusability of performance-sensitive communication software.
2701566
Evaluating policies and mechanisms to support distributed real-time applications with CORBA
To be an effective platform for performance-sensitive real-time systems, commodity-off-the-shelf (COTS) distributed object computing (DOC) middleware must support application quality of service (QoS) requirements end-to-end. However, conventional COTS DOC middleware does not provide this support, which makes it unsuited for applications with stringent latency, determinism, and priority preservation requirements. It is essential, therefore, to develop standards-based, COTS DOC middleware that permits the specification, allocation, and enforcement of application QoS requirements end-to-end. 
 
The real-time CORBA and messaging specifications in the CORBA 2.4 standard are important steps towards defining standards-based, COTS DOC middleware that can deliver end-to-end QoS support at multiple levels in distributed and embedded real-time systems. These specifications still lack sufficient detail, however, to portably configure and control processor, communication, and memory resources for applications with stringent QoS requirements. 
 
This paper provides four contributions to research on real-time DOC middleware. First, we illustrate how the CORBA 2.4 real-time and messaging specifications provide a starting point to address the needs of an important class of applications with stringent real-time requirements. Second, we illustrate how the CORBA 2.4 specifications are not sufficient to solve all the issues within this application domain. Third, we describe how we have implemented portions of these specifications, as well as several enhancements, using TAO, which is our open-source real-time CORBA ORB. Finally, we evaluate the performance of TAO empirically to illustrate how its features address the QoS requirements for certain classes of real-time applications. Copyright © 2001 John Wiley & Sons, Ltd.
1561734
The Design and Performance of a Real-Time CORBA Scheduling Service
There is increasing demandto extend CORBA middleware to support applications with stringentquality of service (QoS) requirements. However, conventionalCORBA middleware does not define standard features to dynamicallyschedule operations for applications that possess deterministicreal-time requirements. This paper presents three contributionsto the study of real-time CORBA operation scheduling strategies.First, we document our evolution from static to dynamic schedulingfor applications with deterministic real-time requirements. Second,we describe the flexible scheduling service framework in ourreal-time CORBA implementation, TAO, which supports core schedulingstrategies efficiently. Third, we present results from empiricalbenchmarks that quantify the behavior of these scheduling strategiesand assess the overhead of dynamic scheduling in TAO. Our empiricalresults using TAO show that dynamic scheduling of CORBA operationscan be deterministic and can achieve acceptable latency for operations,even with moderate levels of queueing.
8854332
The design of the TAO real-time object request broker
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 real-time CORBA systems. First, the paper describes the design of TAO, which is our high-performance, real-time CORBA 2.0-compliant 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 real-time 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.
29229734
Policies and patterns for high-performance, real-time object request brokers
Middleware is becoming increasingly important for building flexible communication systems that reduce software development cycle time and effort. Unfortunately, conventional middleware implementations of CORBA have historically lacked the efficiency, predictability, and scalability required by real-time systems. A decade of intensive R&D on design techniques and optimization principle patterns has recently converged, however, to yield high-performance and real-time middleware that can meet end-to-end Quality of Service (QoS) requirements for real-time systems. This tutorial outlines recent advances in real-time middleware, focusing on the policies and patterns in Real-time CORBA. Real-time CORBA defines a standard set of interfaces and capabilities to manage CPU, network, and memory resources predictably and efficiently end-to-end. This tutorial will illustrate via real world examples the key features and policies in the Real-time CORBA programming model. It will also describe the patterns that can be applied in ORB architectures to minimize priority inversion and non-determinism, associate client requests with servants in constant time, and implement standard and custom middleware protocols using small memory footprints. The patterns and optimizations covered in the tutorial are based on TAO, which is a widely used open-source real-time ORB that supports end-to-end QoS guarantees over a range of networks and embedded system interconnects. TAO is currently deployed at Boeing, Lockheed, Lucent, Motorola, Nokia, Nortel, Raytheon, SAIC, and Siemens, where it is used for real-time avionics, simulations, and telecommunications systems. Source code, documentation, and technical papers on TAO are available at www.cs.wustl.edu/~schmidt/TAO.html. Douglas Schmidt is an Associate Professor in the Electrical and Computer Engineering Department at the University of California, Irvine. Previously, he was Director of the Center for Distributed Object Computing and an Associate Professor of Department of Computer Science and the Department of Radiology at Washington University in St. Louis, Missouri, USA.His research focuses on design patterns, implementation, and experimental analysis of object-oriented frameworks that facilitate the development of high-performance, real-time distributed object computing systems on parallel processing platforms running over high-speed networks and embedded system interconnects. Proceedings of the Third International Symposium on Distributed-Objects and Applications (DOA’01) 0-7695-1300-X/01 $10.00 © 2001 IEEE Dr. Schmidt is an internationally recognized expert on distributed object computing and has published widely in top IEEE, ACM, IFIP, and USENIX technical conferences and journals on topics ranging from high-performance communication software systems and parallel processing for high-speed networking protocols to real-time distributed object computing with CORBA and object-oriented design patterns. Proceedings of the Third International Symposium on Distributed-Objects and Applications (DOA’01) 0-7695-1300-X/01 $10.00 © 2001 IEEE
6204500
Underapproximating Predicate Transformers
We study the underapproximation of the predicate transformers used to give semantics to the modalities in dynamic and temporal logic. Because predicate transformers operate on state sets, we define appropriate powerdomains for sound approximation. We study four such domains — two are based on “set inclusion” approximation, and two are based on “quantification” approximation — and we apply the domains to synthesize the most precise, underapproximating $\widetilde{pre}$ and pre transformers, in the latter case, introducing a focus operation. We also show why the expected abstractions of post and $\widetilde{post}$ are unsound, and we use the powerdomains to guide us to correct, sound underapproximations.
207196655
Programming language semantics
A programming language possesses syntax and semantics. Syntax refers to the spelling of the language’s programs, and semantics refers to the meanings of the programs. A language’s syntax is formalized by a grammar or syntax chart; such formalizations are found in the back of language manuals. A language’s semantics should be formalized, too, and this is the topic of this chapter. Before we begin, we might ask, “What do we gain by formalizing the semantics of a programming language?” Consider the related question, “What was gained when language syntax was formalized with BNF?” • A language’s syntax definition standardizes the official syntax. This is crucial to users, who require a guide to writing syntactically correct programs, and to implementors, who must write a correct parser for the language’s compiler. • The syntax definition permits a formal analysis of its properties, such as whether the definition is LL(k), LR(k), or ambiguous. • The syntax definition can be used as input to a compiler front-end generating tool, such as YACC; it becomes, in effect, the implementation. We derive similar benefits from a formal semantics definition: • The semantics definition standardizes the official semanticsof the language. This is crucial to users, who require a guide to understanding the programs that they write, and to implementors, who must write a correct code generator for the language’s compiler. • The semantics definition permits a formal analysis of its properties, such as whether the definition is strongly typed, block structured, uses single-threaded data structures, is parallelizable, etc. • The semantics definition can be used as input to a compiler back-end generating tool [26, 31]; it becomes, in effect, the implementation. Programming-language syntax was studied intensively in the 1960’s and 1970’s, and programming language semantics is undergoing similar intensive study. Unlike the acceptance of BNF as the standard for syntax definition, it is unlikely that a single definition method will take hold for semantics—semantics is harder to formalize than syntax, and it has a wider variety of applications. Semantics-definition methods fall roughly into three groups:
602812
Autonomous behavior-based exploration of office environments
Besides safe motion control the gain of environmental knowledge is a key for a reliable home or office service robot. When being set into a completely unknown environment the robot has to be able to derive a certain abstract internal representation of this world without any user interaction. This knowledge enables the robot to know how to get from its actual place in one room to a target position in another room as a prerequisite for transportation tasks for example. In this context, the combination of a behavior-based motion control system and an abstract topological map based on geometric representations of rooms seems promising. As the concept of motion and exploration behaviors facilitates to compete with noisy sensor information and geometrically imprecise maps, it has been used to develop completely autonomous exploration strategies for deriving topological representations of common indoor environments. The only prescribed world knowledge is the fact that these environments are composed of rectangular entities (rooms) which are connected by openings (doors). The developed system has successfully been tested in simulation and reality.
207550710
Induction, Domains, Calculi: Strachey's Contributions to Programming-Language Engineering
In collaboration with his colleagues at Oxford, Christopher Strachey pioneered the analysis of programming languages in terms of semantic features. Three of Strachey's contributions—inductive definition of semantics, semantic-domain definitions, and calculi for semantic description—are presented, and their consequences on languages research are described. Strachey's impact, present and future, on the computer programming “mainstream” is also outlined.
7376459
State transition machines for lambda calculus expressions
The process of compiler generation from formal definitions of the lambdacalculus is studied. The compiling schemes developed utilize as an object language the set of state transition machines (STMs): automata-like transition sets using first order arguments. An intermediate definition form, the STM_interpreter, is defined and treated as central to the formulation of state transition code. Three compiling schemes are produced: one derived directly from an STM-interpreter; one formulated from a version of Landin's SECD-machine; and one defined through meaning preserving transformations upon a denotational definition of the lambda-calculus itself. The results are compared and some tentative conclusions are made regarding the utility of compiler generation with the use of the STM forms.