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.
6580196
Using design patterns to develop reusable object-oriented communication software
Despite dramatic increases in network and host performance, it remains difficult to design, implement, and reuse communication software for complex distributed systems. Examples of these systems include global personal communication systems, network management platforms, enterprise medical imaging systems, and real-time market data monitoring and analysis systems. In addition, it is often hard to directly reuse existing algorithms, detailed designs, interfaces, or implementations in these systems due to the growing heterogeneity of hardware/software architectures and the increasing diversity of operating system platforms.
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
1313476
Design and Performance of Asynchronous Method Handling for CORBA
This paper describes the design and performance of a new mechanism, called asynchronous method handling (AMH), that allows CORBA servers to process client requests asynchronously. AMH decouples the association of an incoming request from the run-time stack that received the request, without incurring the context-switching, synchronization, and data movement overhead of conventional CORBA multithreading models.This paper provides two contributions to the study of asynchrony for CORBA servers. First, it describes the design and implementation of AMH in The ACE ORB (TAO), a C++ CORBA ORB. The syntax and semantics of AMH are defined using the CORBA Interface Definition Language (IDL), the forces that guided the design of AMH are described, and the patterns and C++ idioms used to resolve these forces are presented. Second, we empirically compare a middle-tier server implemented using AMH against other CORBA server concurrency models and show the advantages of the AMH mechanism against the other models.
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.
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.
484422
A domain equation for refinement of partial systems
A reactive system can be specified by a labelled transition system, which indicates static structure, along with temporal-logic formulas, which assert dynamic behaviour. But refining the former while preserving the latter can be difficult, because:(i) Labelled transition systems are ‘total’ – characterised up to bisimulation – meaning that no new transition structure can appear in a refinement.(ii) Alternatively, a refinement criterion not based on bisimulation might generate a refined transition system that violates the temporal properties.In response, Larsen and Thomson proposed modal transition systems, which are ‘partial’, and defined a refinement criterion that preserved formulas in Hennessy–Milner logic. We show that modal transition systems are, up to a saturation condition, exactly the mixed transition systems of Dams that meet a mix condition, and we extend such systems to non-flat state sets. We then solve a domain equation over the mixed powerdomain whose solution is a bifinite domain that is universal for all saturated modal transition systems and is itself fully abstract when considered as a modal transition system. We demonstrate that many frameworks of partial systems can be translated into the domain: partial Kripke structures, partial bisimulation structures, Kripke modal transition systems, and pointer-shape-analysis graphs.
36184751
Abstract Interpretation of Small-Step Semantics
The techniques of classical abstract interpretation are extended to the big- and small-step operational semantics of higher-order and communicative languages: Well-known techniques, such as memoization, and lesser-known ones, such as abstraction on program syntax, are employed to generate finite abstract interpretations of source programs based on their formal operational semantic definitions. The result is a clear methodology for generating semantically safe (and live) abstract, regular trees for programs that do not possess obvious, finite, state-transition diagram depictions. The primary application of the research is to the validation of program properties; in particular, the application of model checking to validate safety properties in the box-mu calculus and liveness properties in the diamond-mu calculus is discussed.
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.
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.
13868346
Should UML be used for declarative programming?
Widely used in object-oriented programming, the Unified Modelling Language (UML) is largely ignored by the declarative programming community. this paper attempts to introduce the UML and provide reasons for its adoption by declarative programmers as both a design methodology and as a novel application area.