SEARCH · Search NASA
Search indexed NASA NTRS and DOE OSTI research on propulsion, heat transfer, battery materials and energy systems. Follow report and document links to the original sources.
Quote a phrase for an exact phrase match. Source license links do not imply unrestricted reuse.
Topics addressed cover: identification of large space structure dynamics; special-purpose architectures for computational fluid dynamics; fault-tolerant processor architectures; data flow techniques; software specification and verification tools; management of software development; software environment for concurrent computing; and parallel algorithms and architectures for the solution of partial differential equations.
Compositional proof systems not only enable the stepwise development of concurrent processes but also provide a basis to alleviate the state explosion problem associated with model checking. An assume-guarantee style of specification and reasoning has long been advocated to achieve compositionality. However, this style of reasoning is often non-trivial, typically requiring human input to determine appropriate assumptions. In this paper, we present novel assume- guarantee rules in the setting of finite labelled transition systems with blocking communication. We show how these rules can be applied in an iterative and fully automated fashion within a framework based on learning.
This paper investigates implementations of process algebras which are suitable for modeling concurrent real-time systems. It suggests an approach for efficiently implementing real-time semantics using dynamic priorities. For this purpose a proces algebra with dynamic priority is defined, whose semantics corresponds one-to-one to traditional real-time semantics. The advantage of the dynamic-priority approach is that it drastically reduces the state-space sizes of the systems in question while preserving all properties of their functional and real-time behavior. The utility of the technique is demonstrated by a case study which deals with the formal modeling and verification of the SCSI-2 bus-protocol. The case study is carried out in the Concurrency Workbench of North Carolina, an automated verification tool in which the process algebra with dynamic priority is implemented. It turns out that the state space of the bus-protocol model is about an order of magnitude smaller than the one resulting from real-time semantics. The accuracy of the model is proved by applying model checking for verifying several mandatory properties of the bus protocol.
A pressure ratio to thermal environments (PRatTlE.pl) program is a Perl language code that estimates heating at requested body point locations by scaling the heating at a reference location times a pressure ratio factor. The pressure ratio factor is the ratio of the local pressure at the reference point and the requested point from CFD (computational fluid dynamics) solutions. This innovation provides pressure ratio-based thermal environments in an automated and traceable method. Previously, the pressure ratio methodology was implemented via a Microsoft Excel spreadsheet and macro scripts. PRatTlE is able to calculate heating environments for 150 body points in less than two minutes. PRatTlE is coded in Perl programming language, is command-line-driven, and has been successfully executed on both the HP and Linux platforms. It supports multiple concurrent runs. PRatTlE contains error trapping and input file format verification, which allows clear visibility into the input data structure and intermediate calculations.
Delay-insensitive VLSI systems have a certain appeal on the ground due to difficulties with clocks; they are even more attractive in space. We answer the question, is it possible to control state explosion arising from various sources during automatic verification (model checking) of delay-insensitive systems? State explosion due to concurrency is handled by introducing a partial-order representation for systems, and defining system correctness as a simple relation between two partial orders on the same set of system events (a graph problem). State explosion due to nondeterminism (chiefly arbitration) is handled when the system to be verified has a clean, finite recurrence structure. Backwards branching is a further optimization. The heart of this approach is the ability, during model checking, to discover a compact finite presentation of the verified system without prior composition of system components. The fully-implemented POM verification system has polynomial space and time performance on traditional asynchronous-circuit benchmarks that are exponential in space and time for other verification systems. We also sketch the generalization of this approach to handle delay-constrained VLSI systems.
Compositional verification and abstraction are the key techniques to address the state explosion problem associated with model checking of concurrent software. A promising compositional approach is to prove properties of a system by checking properties of its components in an assume-guarantee style. This article proposes a framework for performing abstraction and assume-guarantee reasoning of concurrent C code in an incremental and fully automated fashion. The framework uses predicate abstraction to extract and refine finite state models of software and it uses an automata learning algorithm to incrementally construct assumptions for the compositional verification of the abstract models. The framework can be instantiated with different assume-guarantee rules. We have implemented our approach in the COMFORT reasoning framework and we show how COMFORT out-performs several previous software model checking approaches when checking safety properties of non-trivial concurrent programs.
A reactive program is one which engages in an ongoing interaction with its environment. A system which is controlled by an embedded reactive program is called a reactive system. Examples of reactive systems are aircraft flight management systems, bank automatic teller machine (ATM) networks, airline reservation systems, and computer operating systems. Reactive systems are often naturally modeled (for logical design purposes) as a composition of autonomous processes which progress concurrently and which communicate to share information and/or to coordinate activities. Formal (i.e., mathematical) frameworks for system verification are tools used to increase the users' confidence that a system design satisfies its specification. A framework for reactive system verification includes formal languages for system modeling and for behavior specification and decision procedures and/or proof-systems for verifying that the system model satisfies the system specifications. Using the Ostroff framework for reactive system verification, an approach to achieving fault-tolerant communication between transputers was shown to be effective. The key components of the design, the decoupler processes, may be viewed as discrete-event-controllers introduced to constrain system behavior such that system specifications are satisfied. The Ostroff framework was also effective. The expressiveness of the modeling language permitted construction of a faithful model of the transputer network. The relevant specifications were readily expressed in the specification language. The set of decision procedures provided was adequate to verify the specifications of interest. The need for improved support for system behavior visualization is emphasized.
The key to implementing self-diagnosing design is a systems engineering task focused on design for testability concurrent with design for functionality. The design for testability process described here is the product of several years of DOD study and experience. Its application to the space station has begun on Work Package II under NASA and McDonnell direction. Other work package teams are being briefed by Harris Corporation with the hope of convincing them to embrace the process. For the purpose of this discussion the term testability is used to describe the systems engineering process by which designers can assure themselves and their reviewers that their designs are TESTABLE, that is they will support the downstream process of determining their functionality. Due to the complexity and density of present-day state-of-the-art designs, such as pipeline processors and high-speed integrated circuit technology, testability feature design is a critical requirement of the functional design process. A systematic approach to Space systems test and checkout as well as fault detection fault isolation reconfiguration (FDFIR) will minimize operational costs and maximize operational efficiency. An effective design for the testability program must be implemented by all contractors to insure meeting this objective. The process is well understood and technology is here to support it.
The results of aircrafts and spacecrafts flight tests are reported. It is shown that the problems of Digital Flight Control Systems (DFCS) are the problems of systems whose complexity has exceeded the reach of the intellectual tools employed. It is also shown that intuition, experience, and techniques derived from mechanical and analog systems are insufficient for complex, integrated, digital systems. Formal Methods (FM) of computer science can offer DFCS systematic techniques for the construction of trustworthy software, including: techniques for the precise specification of requirements and the development of designs; systematic approaches to the design and structuring of distributed and concurrent systems; fault tolerance algorithms; and systematic methods of testing and analytic methods of verification.
Following successful completion of the space suit Portable Life Support System (PLSS) 1.0 development and testing in 2011, the second system-level prototype, PLSS 2.0, was developed in 2012 to continue the maturation of the advanced PLSS design which is intended to reduce consumables, improve reliability and robustness, and incorporate additional sensing and functional capabilities over the current Space Shuttle/International Space Station Extravehicular Mobility Unit (EMU) PLSS. PLSS 2.0 represents the first attempt at a packaged design comprising first generation or later component prototypes and medium fidelity interfaces within a flight-like representative volume. Pre-Installation Acceptance (PIA) is carryover terminology from the Space Shuttle Program referring to the series of test sequences used to verify functionality of the EMU PLSS prior to installation into the Space Shuttle airlock for launch. As applied to the PLSS 2.0 development and testing effort, PIA testing designated the series of 27 independent test sequences devised to verify component and subsystem functionality, perform in situ instrument calibrations, generate mapping data to define set-points for control algorithms, evaluate hardware performance against advanced PLSS design requirements, and provide quantitative and qualitative feedback on evolving design requirements and performance specifications. PLSS 2.0 PIA testing was carried out from 3/20/13 - 3/15/14 using a variety of test configurations to perform test sequences that ranged from stand-alone component testing to system-level testing, with evaluations becoming increasingly integrated as the test series progressed. Each of the 27 test sequences was vetted independently, with verification of basic functionality required before completion. Because PLSS 2.0 design requirements were evolving concurrently with PLSS 2.0 PIA testing, the requirements were used as guidelines to assess performance during the tests; after the completion of PIA testing, test data served to improve the fidelity and maturity of design requirements as well as plans for future advanced PLSS functional testing.
Following successful completion of the space suit Portable Life Support System (PLSS) 1.0 development and testing in 2011, the second system-level prototype, PLSS 2.0, was developed in 2012 to continue the maturation of the advanced PLSS design. This advanced PLSS is intended to reduce consumables, improve reliability and robustness, and incorporate additional sensing and functional capabilities over the current Space Shuttle/International Space Station Extravehicular Mobility Unit (EMU) PLSS. PLSS 2.0 represents the first attempt at a packaged design comprising first generation or later component prototypes and medium fidelity interfaces within a flight-like representative volume. Pre-Installation Acceptance (PIA) is carryover terminology from the Space Shuttle Program referring to the series of test sequences used to verify functionality of the EMU PLSS prior to installation into the Space Shuttle airlock for launch. As applied to the PLSS 2.0 development and testing effort, PIA testing designated the series of 27 independent test sequences devised to verify component and subsystem functionality, perform in situ instrument calibrations, generate mapping data, define set-points, evaluate control algorithms, evaluate hardware performance against advanced PLSS design requirements, and provide quantitative and qualitative feedback on evolving design requirements and performance specifications. PLSS 2.0 PIA testing was carried out in 2013 and 2014 using a variety of test configurations to perform test sequences that ranged from stand-alone component testing to system-level testing, with evaluations becoming increasingly integrated as the test series progressed. Each of the 27 test sequences was vetted independently, with verification of basic functionality required before completion. Because PLSS 2.0 design requirements were evolving concurrently with PLSS 2.0 PIA testing, the requirements were used as guidelines to assess performance during the tests; after the completion of PIA testing, test data served to improve the fidelity and maturity of design requirements as well as plans for future advanced PLSS functional testing.
This work presents a runtime verification approach implemented in the tool MESA (MEssage-based System Analysis) which allows for using concurrent monitors to check for properties specified in data parameterized temporal logic and state machines. The tool is implemented as an internal Scala DSL. We employ the actor programming model to implement MESA where monitors are captured by concurrent actors that communicate via messaging. The paper presents a case study in which MESA is used to effectively monitor a large number of flights from live US airspace data streams. We also perform an empirical study by conducting experiments using monitoring systems with different num- bers of concurrent monitors and different layers of indexing on the data contained in events. The paper describes the experiments, evaluates the results, and discusses challenges faced during the study. The evaluation shows the value of combining concurrency with indexing to handle data rich events.
The current trend of multi-core and multi-processor computing is causing a paradigm shift from inherently sequential to highly concurrent and parallel applications. Certain thread interleavings, data input values, or combinations of both often cause errors in the system. Systematic verification techniques such as explicit state model checking and symbolic execution are extensively used to detect errors in such systems [7, 9]. Explicit state model checking enumerates possible thread schedules and input data values of a program in order to check for errors [3, 9]. To partially mitigate the state space explosion from data input values, symbolic execution techniques substitute data input values with symbolic values [5, 7, 6]. Explicit state model checking and symbolic execution techniques used in conjunction with exhaustive search techniques such as depth-first search are unable to detect errors in medium to large-sized concurrent programs because the number of behaviors caused by data and thread non-determinism is extremely large. We present an overview of abstraction-guided symbolic execution for concurrent programs that detects errors manifested by a combination of thread schedules and data values [8]. The technique generates a set of key program locations relevant in testing the reachability of the target locations. The symbolic execution is then guided along these locations in an attempt to generate a feasible execution path to the error state. This allows the execution to focus in parts of the behavior space more likely to contain an error.
A review of STS-1 processing is presented as a reference for Shuttle processing time and the magnitude of the associated modifications, discrepancies, technical requirements, and ground systems activities. STS-1 processing provided the basis from which a plan to perform operational turnaround was established. Turnaround processing for Launch and Landing are treated separately to depict more clearly the progress made to reduce turnaround time and manhours expended. Turnaround time was reduced from 187 days for STS-2 to 60 days for STS-7 and landing turnaround was reduced from 14 days to 5 days. Modifications were reduced from 114 to 51. Requirements changes for launch readiness verification were reduced from 536 to 107. Special tests or inspections were reduced from 292 to 52. Anomalies resolved concurrent with processing were reduced from 13,000 to 4,000. Integration in the Vehicle Assembly Building (VAB) is about 10 percent of the flow, and Launch Pad operations comprise 40 percent of the turnaround. The work force has matured and has demonstrated the capability to perform planned and contingency operations. The turnaround program is fast approaching the goal of becoming operational.
This report describes a novel test generation technique for distributed systems. Utilizing formal models and formal verification tools, spe cifically the Symbolic Analysis Laboratory (SAL) tool-suite from SRI, we present techniques to generate concurrent test vectors for distrib uted systems. These are initially explored within an informal test validation context and later extended to achieve full MC/DC coverage of the TTEthernet protocol operating within a system-centric context.
Moving off the planet will be a defining moment of this century as landing on the Moon was in the last. For that to happen for humans to go where humans cannot go-- simulation is the sole solution. NASA supports simulation for life-cycle activities: design, analysis, test, checkout, operations, review and training. We contemplate time spans of a century and more, teams dispersed to different planets and the need for systems that endure or adapt as missions, teams and technology change. Without imagination such goals are impossible. But with imagination we can go outside our present perception of reality to think about and take action on what has been, is and, especially, what might be. Consciously maturing an imagined, possibly workable, idea through framing it to optimization to design, and building the product provides us with a new approach to innovation and simulation fidelity. We address options, analyze, test and make improvements in how we think and work. Each step includes increasingly exact information about costs, schedule, who will be needed, where, when and how. NASA i integrating such thinking into its Exploration Product Realization Hierarchy for simulation and analysis, test and verification, and stimulus response goals. Technically NASA follows a timeline of studies, analysis, definition, design, development and operations with concurrent documentation. We have matched this Product Realization Hierarchy with a continuum from image to realization that incorporates commitment, current and needed research and communication to ensure superior and creative problem solving as well as advances in simulation. One result is a new approach to collaborative systems. Another is a distributed observer network prototyped using game engine technology bringing advanced 3-D simulation of a simulation to the desktop enabling people to develop shared consensus of its meaning. Much of the value of simulation comes from developing in people their ability to make good decisions and reflexes supporting impressive achievement. Synthesizing imagination systematically into our work - and thus our success - is a challenge. NASA engineers have inventive minds, and the task is determining how best to enable them to devise the simulation and other innovations that will make a story so clear and so intellectually sound that people can carry out the mission for 50-100 years. This demands skills and knowledge traditionally under-respected and under-represented in technology organizations. But we are beginning to see that the process encourages efficiency and enables us to attain more effective results. We have to elicit imaginative, intelligent and effective ways to make better use than ever of the minds we have and will have available. We have to accept the challenge to accomplish tasks among dispersed interdisciplinary teams who must overcome changing priorities and technology, time and distance in order to maximize interactivity and innovation as never before. Attention to the process of innovation is a practical means to increase the efficiency of our intelligence. We have an obligation to reexamine and improve the process by which we approach and exercise innovation as we accept the charge to move off the planet.
We propose an approach to formally verify Plural specifications based on access permissions and typestates, by model-checking automatically generated abstract state-machines. Our exhaustive approach captures all the possible behaviors of abstract concurrent programs implementing the specification. We describe the formal methodology employed by our technique and provide an example as proof of concept for the state-machine construction rules. The implementation of a fully automated algorithm to generate and verify models, currently underway, provides model checking support for the Plural tool, which currently supports only program verification via data flow analysis (DFA).
The Forced Flow Flame spreading Test (FFFT) is a study of flame spreading over solid fuels in very low-speed air flows. The FFFT experiment is part of research entitled Solid Inflammability Boundary at Low Speeds, (SIBAL) intended for operations on the Space Station. In the FFFT experiment, a series of 15 experiments conducted aboard the space shuttle during the United States Microgravity Payload (USMP-3) mission provided information about the structure and spreading characteristics of flames in low-speed, concurrent flows. The test samples included flat sheets of cellulose and cast cylinders of cellulose, burned in air at velocities of approximately 1 to 8 cm/sec. The test results have been successfully compared to theoretical predictions of the SIBAL program, a fundamentally based numerical simulation of concurrent flow flame spread. Additionally, some guidance for the design characteristics of the SIBAL flight experiment have been obtained including some verification of the theoretical predictions of flame size versus the required size of the SIBAL flow duct, and the effect of the presence of thermocouples in the vicinity of near-limit flames in microgravity.