15114120
Designing an Efficient and Scalable Server-side Asynchrony Model for CORBA
When the Asynchronous Method Invocation (AMI) model was introduced into the CORBA specification, client applications benefited from the ability to invoke non-blocking two-way requests. In particular, AMI improved the scalability of clients by removing the restrictions associated with Synchronous Method Invocations (SMI). Server request handling remained synchronous, however, which minimized the benefits of AMI for middle-tier servers, such as firewall gateways and front-end database servers.This paper describes our strategy for implementing a scalable server-side asynchrony model for CORBA. We first outline the key design challenges faced when developing an Asynchronous Method Handling (AMH) model for CORBA and then describe how we are resolving these challenges in TAO, our high-performance, real-time CORBA ORB. In general, AMH-based CORBA servers provide more scalability than existing concurrency models, with only a moderate increase in programming complexity. Although targeted for CORBA, similar techniques can also be used in other method-oriented middleware, such as COM+ and Java RMI.
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.
6974153
Integrating publisher/subscriber services in component middleware for distributed real-time and embedded systems
Although component-based software development has widespread acceptance in the enterprise business and desktop application domains, developers of distributed real-time and embedded (DRE) systems have encountered limitations with the available component middleware platforms, such as the CORBA Component Model (CCM) and the Java 2 Enterprise Edition (J2EE). These limitations often preclude developers of DRE systems from fully exploiting the benefits of component software. In particular, component middleware platforms lack standards-based publisher/subscriber communication mechanisms that support key quality-of-service (QoS) requirements, such as low latency, bounded jitter, and end-to-end operation priority propagation. QoS-enabled publisher/subscriber services are available in object middleware platforms, such as Real-time CORBA, but such services have not been integrated into component middleware due to a number of development and configuration challenges.This paper provides three contributions to the integration of publisher/subscriber services in component middleware. First, we outline key challenges associated with integrating publisher/subscriber services into component middleware. Second, we describe a methodology for resolving these challenges based on software patterns. Third, we describe a pattern-oriented component middleware platform that we have developed to integrate publisher/subscriber services into component middleware applications.
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.
6993185
Metric-driven analysis and feedback systems for enabling empirically guided software development
The authors summarize the goals of metric-driven analysis and feedback systems and describe a prototype system, Amadeus, which defines abstract interfaces and embodies architectural principles for these types of systems. Metric-driven analysis and feedback systems enable developers to define empirically guided processes for software development and maintenance. The authors provide an overview of the Amadeus system operation, including an example of the empirically guided process, a description of the system characteristics, an explanation of the system conceptual operation, and a summary of the users' view of the system. The centerpiece of the system is a pro-active server, which interprets scripts and coordinates event monitoring and agent activation. Amadeus provides an extensible framework for adding new empirically based analysis techniques.<<ETX>>
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
7037195
Comparing Completeness Properties of Static Analyses and Their Logics
Static analyses calculate abstract states, and their logics validate properties of the abstract states. We place into perspective the variety of forwards, backwards, functional, and logical completeness used in abstract-interpretation-based static analysis by giving examples and by proving equivalences, implications, and independences. We expose two fundamental Galois connections that underlie the logics for static analyses and reveal a new completeness variant, O-completeness. We also show that the key concept underlying logical completeness is covering, which we use to relate the various forms of completeness.
42747855
Action Semantics-Directed Prototyping
We present a methodology for compiler synthesis based on Mosses-Watt's action semantics. Each action in action semantics notation is assigned specific ''analysis functions'', such as a typing function and a binding-time function. When a language is given an action semantics, the typing and binding-time functions for the individual actions compose into typing and binding-time analyses for the language; these are implemented as the type checker and static semantics processor, respectively, in the synthesized compiler. Other analyses can be similarly formalized and implemented. We show a sample language semantics and its synthesized compiler, and we describe the compiler synthesizer that we have developed.
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:
37519260
Trace-Based Abstract Interpretation of Operational Semantics
We present trace-based abstract interpretation, a unification of severallines of research on applying Cousot-Cousot-style abstract interpretation a.i. tooperational semantics definitions (such as flowchart, big-step, and small-step semantics)that express a program‘s semantics as a concrete computation tree of trace paths. Aprogram‘s trace-based a.i. is also a computation tree whose nodes contain abstractions ofstate and whose paths simulate the paths in the program‘s concrete computation tree.Using such computation trees, we provide a simple explanation of the central concept of collecting semantics, and we distinguish concrete from abstract collectingsemantics and state-based from path-based collecting semantics. We also expose therelationship between collecting semantics extraction and results garnered from flow-analytic and model-checking-based analysis techniques. We adapt concepts fromconcurrency theory to formalize “safe” and “live” a.i.‘s for computation trees; in particular, coinduction techniques help extend fundamental results to infinite computation trees.Problems specific to the various operational semantics methodologies are discussed: Big-step semantics cannot express divergence, so we employ a mixture of induction andcoinduction in response; small-step semantics generate sequences of programconfigurations unbounded in size, so we abstractly interpret source language syntax.Applications of trace-based a.i. to data-flow analysis, model checking, closure analysis,and concurrency theory are demonstrated.
16028114
Modal Transition Systems: A Foundation for Three-Valued Program Analysis
We present Kripke modal transition systems (Kripke MTSs), a generalization of modal transition systems [27, 26], as a foundation for three-valued program analysis. The semantics of Kripke MTSs are presented by means of a mixed power domain of states; soundness and consistency are proved. Two major applications, model checking partial state spaces and three-valued program shape analysis, are presented as evidence of the suitability of Kripke MTSs as a foundation for three-valued analyses.