It is impossible in practice to comprehensively test even small software programs due to the vastness of the reachable state space; however, modern cyber-physical systems such as aircraft require a high degree of confidence in software safety and reliability. Here we explore methods of generating test sets to effectively and efficiently explore the state space for a module based on the Traffic Collision Avoidance System (TCAS) used on commercial aircraft. A formal model of TCAS in the model-checking language NuSMV provides an output oracle. We compare test sets generated using various methods, including covering arrays, random, and a low-complexity input paradigm applied to 28 versions of the TCAS C program containing seeded errors. Faults are triggered by tests for all 28 programs using a combination of covering arrays and random input generation. Complexity-based inputs perform more efficiently than covering arrays, and can be paired with random input generation to create efficient and effective test sets. A random forest classifier identifies variable values that can be targeted to generate tests even more efficiently in future work, by combining a machine-learned fuzzing algorithm with more complex model oracles developed in model-based systems engineering (MBSE) software.

Abstract The Common Component Architecture (CCA) is a component model for high‐performance computing, developed by a grass‐roots effort of computational scientists. Although the CCA is usable with CORBA‐like distributed‐object components, its main purpose is to set forth a component model for high‐performance, parallel computing. Traditional component models are not well suited for performance and massive parallelism. We outline the design pattern for the CCA component model, discuss our strategy for language interoperability, describe the development tools we provide, and walk through an illustrative example using these tools. Performance and scalability, which are distinguishing features of CCA components, affect choices throughout design and implementation. Copyright © 2005 John Wiley & Sons, Ltd.

Abstract This work targets the emerging use of software component technology for high‐performance scientific parallel and distributed computing. While component software engineering will benefit the construction of complex science applications, its use presents several challenges to performance measurement, analysis, and optimization. The performance of a component application depends on the interaction (possibly nonlinear) of the composed component set. Furthermore, a component is a ‘binary unit of composition’ and the only information users have is the interface the component provides to the outside world. A performance engineering methodology and development approach is presented to address evaluation and optimization issues in high‐performance component environments. We describe a prototype implementation of a performance measurement infrastructure for the Common Component Architecture (CCA) system. A case study demonstrating the use of this technology for integrated measurement, monitoring, and optimization in CCA component‐based applications is given. Copyright © 2005 John Wiley & Sons, Ltd.

Summary form only given. We present a case study of performance measurement and modeling of a CCA (common component architecture) component-based application in a high performance computing environment. Component-based HPC applications allow the possibility of creating component-level performance models and synthesizing them into application performance models. However, they impose the restriction that performance measurement/monitoring needs to be done in a nonintrusive manner and at a fairly coarse-grained level. We propose a performance measurement infrastructure for HPC based loosely on recent work done for grid environments. A prototypical implementation of the infrastructure is used to collect data for three components in a scientific application and construct their performance models. Both computational and message-passing performance are addressed.

Abstract We present an overview of the Common Component Architecture (CCA) core specification and CCAFFEINE, a Sandia National Laboratories framework implementation compliant with the draft specification. CCAFFEINE stands for CCA Fast Framework Example In Need of Everything; that is, CCAFFEINE is fast, lightweight, and it aims to provide every framework service by using external, portable components instead of integrating all services into a single, heavy framework core. By fast, we mean that the CCAFFEINE glue does not get between components in a way that slows down their interactions. We present the CCAFFEINE solutions to several fundamental problems in the application of component software approaches to the construction of single program multiple data (SPMD) applications. We demonstrate the integration of components from three organizations, two within Sandia and one at Oak Ridge National Laboratory. We outline some requirements for key enabling facilities needed for a successful component approach to SPMD application building. Copyright © 2002 John Wiley & Sons, Ltd.

Describes work in progress to develop a standard for interoperability among high-performance scientific components. This research stems from the growing recognition that the scientific community needs to better manage the complexity of multidisciplinary simulations and better address scalable performance issues on parallel and distributed architectures. The driving force for this is the need for fast connections among components that perform numerically intensive work and for parallel collective interactions among components that use multiple processes or threads. This paper focuses on the areas we believe are most crucial in this context, namely an interface definition language that supports scientific abstractions for specifying component interfaces and a port connection model for specifying component interactions.

Lilith is a general purpose tool that provides a highly scalable, easy distribution of user code across a heterogeneous computing platform. By handling the details of code distribution and communication such a framework allows for the rapid development of tools for the use and management of large distributed systems. This speed-up in development not only enables the easy creation of tools as needed but also facilitates the ultimate development of more refined, hard-coded tools as well. Lilith is written in Java, providing platform independence and further facilitating rapid tool development through object reuse and ease of development. We present the user-involved objects in the Lilith Distributed Object System and the Lilith User API. We present an example of tool development, illustrating the user calls, and present results demonstrating Lilith's scalability.

This paper describes the development of a concurrentmethodology for standard cell library generation. Use of anovel physical design automation method enables a high degreeof concurrency among process, circuit, and layout development.In addition to reducing overall time-to-market, the newmethod allows optimization to occur simultaneously across thecircuit, layout, and process design spaces. The result is librarieswith improved density, circuit performance, and process yield.

Algorithms for generalized particle methods are discussed in the context of high-performance parallel distributed computing. An object-oriented framework for such methods is presented along with the implementation of several very different scientific particle-based applications using the POET framework.

Lilith is a general purpose tool to provide highly scalable, easy distribution of user code across a heterogeneous computing platform. Lilith's principal task is to span a heterogeneous tree of machines executing user-defined code in a scalable and secure fashion. Lilith will be used for controlling user processes as well as general system administrative tasks. Lilith is written in Java, taking advantage of Java's platform independence and intent to move code across networks. The design of Lilith provides hooks for experimenting with tree-spanning algorithms and security schemes. We present the Lilith Object model, security scheme, and implementation, and present timing results demonstrating Lilith's scalable behavior.

The purpose of the paper is to introduce a frame-based approach to scientific computing on distributed computing platforms. The objective of the effort is to introduce well-defined mappings between the representations of physical phenomena as mathematical structures and the computational algorithms for modeling that phenomena on high-performance parallel computing platforms. Using this approach, we identify representations that solve classes of scientific problems based on the computational structure required for solution on parallel processors. Thus, once the representation is defined for a particular problem, the mapping onto a parallel computing environment can be managed automatically in software. We demonstrate the benefits of this approach by application to a combustion modeling problem.>

A framework for VLSI design databases which supports fine-grained incremental consistency maintenance between different views of a design is presented. The framework provides for structural views of a design such as logic or circuit schematic, symbolic layout, and physical layout, and supports representation of geometric design rule constraints between design objects. A prototype interactive design system which provides a user interface to three structural view types (gate and circuit schematics, and symbolic layouts) is presented. Features of the prototype system are automatic propagation of incremental operations between views and high-speed online generation and evaluation of geometric design rule constraints.>