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.
7872163
Closed and Logical Relations for Over- and Under-Approximation of Powersets
We redevelop and extend Dams’s results on over- and under-approximation with higher-order Galois connections:
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.
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.
105294
Structure-Preserving Binary Relations for Program Abstraction
An abstraction is a property-preserving contraction of a program's model into a smaller one that is suitable for automated analysis. An abstraction must be sound, and ideally, complete. Soundness and completeness arguments are intimately connected to the abstraction process, and approaches based on homomorphisms and Galois connections are commonly employed to define abstractions and prove their soundness and completeness.This paper develops Mycroft and Jones's proposal that an abstraction should be stated as a form of structure-preserving binary relation. Mycroft-Jones-style relations are defined, developed, and employed in characterizations of the homomorphism and Galois-connection approaches to abstraction.
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.
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.
7153761
Total quality of service provisioning in middleware and applications
Abstract Commercial off-the-shelf (COTS) middleware, such as real-time CORBA, is gaining acceptance in the distributed real-time and embedded (DRE) community. Existing COTS specifications, however, do not effectively separate quality of service (QoS) policy configurations and adaptations from application functionality. DRE application developers therefore often intersperse code that provisions resources for QoS guarantees and program adaptation mechanisms throughout DRE applications, making it hard to configure, validate, modify, and evolve complex DRE applications. This paper illustrates how (1) standard component-based middleware can be enhanced to flexibly compose static QoS provisioning policies with application logic, (2) adaptive middleware capabilities enable developers to abstract and encapsulate reusable dynamic QoS provisioning and adaptive behaviors, and (3) component-based middleware and adaptive middleware capabilities can be integrated to provide a total QoS provisioning solution for DRE applications.
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>>
26327948
Ultra-large-scale systems
Scale changes everything. The trend in the design and development of software-intensive systems today is toward scale that increases in every measurable way. Lines of code, complexity, dependency, communication, bandwidth, memory, datasets, and many other measures for our systems continue to reach and exceed the limits of our ability to produce high-quality systems for all purposes.These systems will be unbounded, integrating internet-scale resources. They will serve diverse stakeholders with competing objectives and at the same time be constrained by policy, regulation, and the behaviors of their users. The lines between development, acquisition, and operations will blur: ULS systems will not die; they will be too large to be replaced and will be inextricably connected to the day-to-day mission. Rather, they will continue to evolve over time with behavior often more emergent than planned. Because complete specifications will not be achievable, sufficient assurance will have to do. ULS systems present "wicked problems," ones for which each attempt to create a solution changes the problem. Some of these characteristics appear in conventional systems, but in ULS systems they will dominate.