SEARCH · Engineering Papers

Results for “Execution”

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.

SourceResearch connectionFrom yearThrough year

Quote a phrase for an exact phrase match. Source license links do not imply unrestricted reuse.

At least 91 records · Page 5

All sources NASA NTRS DOE OSTI

NASA NTRS1989

Monitoring The Execution Of A VAX Image

Computer program PROCSCAN developed to monitor profile of executable image during execution. Purpose to identify routines in which program is spending most of its time. PROSCAN very useful first step in optimization of program. PROSCAN samples program counter of executing image and compares its value to table of entry-point addresses to determine which subroutine is executing. Written in C (77 percent), Assembler (13 percent), and FORTRAN 77 (10 percent).

Scott, Peter J.↗

NASA NTRS1989

Performance impacts of look-ahead execution in the conversation scheme

The look-ahead execution approach, which allows participant processes that exist early to exit from a conversation before other participants finish their conversation activities, is presented here as a fundamental approach to reducing the synchronization overhead. Queuing network models are developed for systems operating under the basic conversation execution scheme and systems operating under the look-ahead execution scheme. Based on the models, various performance indicators such as the system throughput, the average number of processors idling inside a conversation due to the synchronization required, and the average time spent in conversation are evaluated numerically for different application environments. The results provide insights into the extent of benefits provided by the look-ahead execution approach.

Kim, K. H.↗

NASA NTRS1990

Technology for Space Station Evolution. Executive summary and overview

NASA's Office of Aeronautics and Space Technology (OAST) conducted a workshop on technology for space station evolution 16-19 Jan. 1990. The purpose of this workshop was to collect and clarify Space Station Freedom technology requirements for evolution and to describe technologies that can potentially fill those requirements. These proceedings are organized into an Executive Summary and Overview and five volumes containing the technology discipline presentations. The Executive Summary and Overview contains an executive summary for the workshop, the technology discipline summary packages, and the keynote address. The executive summary provides a synopsis of the events and results of the workshop and the technology discipline summary packages.

Source record↗

NASA NTRS1993

Application of compiler-assisted multiple instruction rollback recovery to speculative execution

Speculative execution is a method to increase instruction level parallelism which can be exploited by both super-scalar and VLIW architectures. The key to a successful general speculation strategy is a repair mechanism to handle mispredicted branches and accurate reporting of exceptions for speculated instructions. Multiple instruction rollback is a technique developed for recovery from transient processor failure. Many of the difficulties encountered during recovery from branch misprediction or from instruction re-execution due to exception in a speculative execution architecture are similar to those encountered during multiple instruction rollback. The applicability of a recently developed compiler-assisted multiple instruction rollback scheme to aid in speculative execution repair is investigated. Extensions to the compiler-assisted scheme to support branch and exception repair are presented along with performance measurements across ten application programs.

Alewine, N. J.↗

NASA NTRS1987

Design and evaluation of executable assertions for concurrent error detection

System level concurrent detection of errors due to hardware faults can be accomplished by introducing software redundancy in the form of executable assertions into a program to monitor the correct operation of the system during its execution. This paper attempts to formalize the use of executable assertions for the purpose of concurrent error detection, and discusses a transformation approach to the design of assertion statements. The second part deals with the effectiveness of the error detection technique. A fault simulation method for the evaluation of the reliability of the assertion statements is described. This scheme was used to study the effectiveness of a nontrivial program in providing protection against faults in the underlying system. The experimental results shows that the use of executable assertions provides an effective approach to achieve concurrent error detection.

Hua, Kien A.↗

NASA NTRS1993

Application of compiler-assisted multiple instruction rollback recovery to speculative execution

Alewine, N. J.↗

NASA NTRS2000

Executing Temporal Networks With Uncertainty

Simple Temporal Networks (STNs) have proved useful in applications that involve metric time. However, many applications involve events whose timing is uncertain in the sense that it is not controlled by the execution agent. In this paper we consider execution algorithms for temporal networks with events of uncertain duration. We present two such algorithms. The first retains maximum flexibility, but requires potentially costly updates during execution. The second surrenders some flexibility in order to obtain a fast execution comparable to that available for ordinary STNs.

Morris, Paul↗

NASA NTRS1994

Performance Metrics for Monitoring Parallel Program Executions

Existing tools for debugging performance of parallel programs either provide graphical representations of program execution or profiles of program executions. However, for performance debugging tools to be useful, such information has to be augmented with information that highlights the cause of poor program performance. Identifying the cause of poor performance necessitates the need for not only determining the significance of various performance problems on the execution time of the program, but also needs to consider the effect of interprocessor communications of individual source level data structures. In this paper, we present a suite of normalized indices which provide a convenient mechanism for focusing on a region of code with poor performance and highlights the cause of the problem in terms of processors, procedures and data structure interactions. All the indices are generated from trace files augmented with data structure information.. Further, we show with the help of examples from the NAS benchmark suite that the indices help in detecting potential cause of poor performance, based on augmented execution traces obtained by monitoring the program.

Sarukkai, Sekkar R.↗

NASA NTRS2003

Generalized Symbolic Execution for Model Checking and Testing

Modern software systems, which often are concurrent and manipulate complex data structures must be extremely reliable. We present a novel framework based on symbolic execution, for automated checking of such systems. We provide a two-fold generalization of traditional symbolic execution based approaches: one, we define a program instrumentation, which enables standard model checkers to perform symbolic execution; two, we give a novel symbolic execution algorithm that handles dynamically allocated structures (e.g., lists and trees), method preconditions (e.g., acyclicity of lists), data (e.g., integers and strings) and concurrency. The program instrumentation enables a model checker to automatically explore program heap configurations (using a systematic treatment of aliasing) and manipulate logical formulae on program data values (using a decision procedure). We illustrate two applications of our framework: checking correctness of multi-threaded programs that take inputs from unbounded domains with complex structure and generation of non-isomorphic test inputs that satisfy a testing criterion. Our implementation for Java uses the Java PathFinder model checker.

Khurshid, Sarfraz↗

NASA NTRS2003

Interleaved Observation Execution and Rescheduling on Earth Observing Systems

Observation scheduling for Earth orbiting satellites solves the following problem: given a set of requests for images of the Earth, a set of instruments for acquiring those images distributed on a collecting of orbiting satellites, and a set of temporal and resource constraints, generate a set of assignments of instruments and viewing times to those requests that satisfy those constraints. Observation scheduling is often construed as a constrained optimization problem with the objective of maximizing the overall utility of the science data acquired. The utility of an image is typically based on the intrinsic importance of acquiring it (for example, its importance in meeting a mission or science campaign objective) as well as the expected value of the data given current viewing conditions (for example, if the image is occluded by clouds, its value is usually diminished). Currently, science observation scheduling for Earth Observing Systems is done on the ground, for periods covering a day or more. Schedules are uplinked to the satellites and are executed rigorously. An alternative to this scenario is to do some of the decision-making about what images are to be acquired on-board. The principal argument for this capability is that the desirability of making an observation can change dynamically, because of changes in meteorological conditions (e.g. cloud cover), unforeseen events such as fires, floods, or volcanic eruptions, or un-expected changes in satellite or ground station capability. Furthermore, since satellites can only communicate with the ground between 5% to 10% of the time, it may be infeasible to make the desired changes to the schedule on the ground, and uplink the revisions in time for the on-board system to execute them. Examples of scenarios that motivate an on-board capability for revising schedules include the following. First, if a desired visual scene is completely obscured by clouds, then there is little point in taking it. In this case, satellite resources, such as power and storage space can be better utilized taking another image that is higher quality. Second, if an unexpected but important event occurs (such as a fire, flood, or volcanic eruption), there may be good reason to take images of it, instead of expending satellite resources on some of the lower priority scheduled observations. Finally, if there is unexpected loss of capability, it may be impossible to carry out the schedule of planned observations. For example, if a ground station goes down temporarily, a satellite may not be able to free up enough storage space to continue with the remaining schedule of observations. This paper describes an approach for interleaving execution of observation schedules with dynamic schedule revision based on changes to the expected utility of the acquired images. We describe the problem in detail, formulate an algorithm for interleaving schedule revision and execution, and discuss refinements to the algorithm based on the need for search efficiency. We summarize with a brief discussion of the tests performed on the system.

Khatib, Lina↗

NASA NTRS1998

Fast Transformation of Temporal Plans for Efficient Execution

Temporal plans permit significant flexibility in specifying the occurrence time of events. Plan execution can make good use of that flexibility. However, the advantage of execution flexibility is counterbalanced by the cost during execution of propagating the time of occurrence of events throughout the flexible plan. To minimize execution latency, this propagation needs to be very efficient. Previous work showed that every temporal plan can be reformulated as a dispatchable plan, i.e., one for which propagation to immediate neighbors is sufficient. A simple algorithm was given that finds a dispatchable plan with a minimum number of edges in cubic time and quadratic space. In this paper, we focus on the efficiency of the reformulation process, and improve on that result. A new algorithm is presented that uses linear space and has time complexity equivalent to Johnson s algorithm for all-pairs shortest-path problems. Experimental evidence confirms the practical effectiveness of the new algorithm. For example, on a large commercial application, the performance is improved by at least two orders of magnitude. We further show that the dispatchable plan, already minimal in the total number of edges, can also be made minimal in the maximum number of edges incoming or outgoing at any node.

Tsamardinos, Ioannis↗

NASA NTRS2004

Model-based Executive Control through Reactive Planning for Autonomous Rovers

This paper reports on the design and implementation of a real-time executive for a mobile rover that uses a model-based, declarative approach. The control system is based on the Intelligent Distributed Execution Architecture (IDEA), an approach to planning and execution that provides a unified representational and computational framework for an autonomous agent. The basic hypothesis of IDEA is that a large control system can be structured as a collection of interacting agents, each with the same fundamental structure. We show that planning and real-time response are compatible if the executive minimizes the size of the planning problem. We detail the implementation of this approach on an exploration rover (Gromit an RWI ATRV Junior at NASA Ames) presenting different IDEA controllers of the same domain and comparing them with more classical approaches. We demonstrate that the approach is scalable to complex coordination of functional modules needed for autonomous navigation and exploration.

Finzi, Alberto↗

NASA NTRS1993

(abstract) An Ada Language Modular Telerobot Task Execution System

A telerobotic task execution system is described which has been developed for space flight applications. The Modular Telerobot Task Execution System (MOTES) provides the remote site task execution capability in a local-remote telerobotic system. The system provides supervised autonomous control, shared control, and teleoperation for a redundant manipulator. The system is capable of nominal task execution as well as monitoring and reflex motion.

robots telerobotics teleoperator autonomous contro↗

NASA NTRS2007

Decision-Tree Formulation With Order-1 Lateral Execution

A compact symbolic formulation enables mapping of an arbitrarily complex decision tree of a certain type into a highly computationally efficient multidimensional software object. The type of decision trees to which this formulation applies is that known in the art as the Boolean class of balanced decision trees. Parallel lateral slices of an object created by means of this formulation can be executed in constant time considerably less time than would otherwise be required. Decision trees of various forms are incorporated into almost all large software systems. A decision tree is a way of hierarchically solving a problem, proceeding through a set of true/false responses to a conclusion. By definition, a decision tree has a tree-like structure, wherein each internal node denotes a test on an attribute, each branch from an internal node represents an outcome of a test, and leaf nodes represent classes or class distributions that, in turn represent possible conclusions. The drawback of decision trees is that execution of them can be computationally expensive (and, hence, time-consuming) because each non-leaf node must be examined to determine whether to progress deeper into a tree structure or to examine an alternative. The present formulation was conceived as an efficient means of representing a decision tree and executing it in as little time as possible. The formulation involves the use of a set of symbolic algorithms to transform a decision tree into a multi-dimensional object, the rank of which equals the number of lateral non-leaf nodes. The tree can then be executed in constant time by means of an order-one table lookup. The sequence of operations performed by the algorithms is summarized as follows: 1. Determination of whether the tree under consideration can be encoded by means of this formulation. 2. Extraction of decision variables. 3. Symbolic optimization of the decision tree to minimize its form. 4. Expansion and transformation of all nested conjunctive-disjunctive paths to a flattened conjunctive form composed only of equality checks when possible. If each reduced conjunctive form contains only equality checks and all of these forms use the same variables, then the decision tree can be reduced to an order-one operation through a table lookup. The speedup to order one is accomplished by distributing each decision variable over a surface of a multidimensional object by mapping the equality constant to an index

James, Mark↗

NASA NTRS2010

Coordinating "Execute" Data for ISS and Space Shuttle

The Joint Execute Package Development and Integration tool is a Web utility program that provides an integrated capability to generate and manage messages and execute package data for members of a space shuttle and the International Space Station (ISS). (An execute package consists of flight plans, short-term plans, procedure updates, data needed to operate the space-shuttle and ISS systems, in-flight maintenance procedures, inventory-stowage data, software upgrades, flight notes, scripts for publicized events, and other instructions.) This program is a third-generation "execute"-package Web tool, built on experience gained from two programs used previously to support realtime operations. This program provides integration and synchronization between the space-shuttle and ISS teams during joint operations. Hundreds of messages per week must be uplinked as "joint" messages; that is, messages for crewmembers of both spacecraft. The program includes configuration-management components that ensure that the same message goes to both crews and spacecraft, effectively eliminating the potential for error in manual direction of messages. The program also controls the format and layout of the crews Web pages, ensuring consistency between uplinks. If the crews Web pages were edited manually, hyperlink and formatting errors would be common.

Whitney, Greg↗

NASA NTRS2012

Real-Time Projection to Verify Plan Success During Execution

The Mission Data System provides a framework for modeling complex systems in terms of system behaviors and goals that express intent. Complex activity plans can be represented as goal networks that express the coordination of goals on different state variables of the system. Real-time projection extends the ability of this system to verify plan achievability (all goals can be satisfied over the entire plan) into the execution domain so that the system is able to continuously re-verify a plan as it is executed, and as the states of the system change in response to goals and the environment. Previous versions were able to detect and respond to goal violations when they actually occur during execution. This new capability enables the prediction of future goal failures; specifically, goals that were previously found to be achievable but are no longer achievable due to unanticipated faults or environmental conditions. Early detection of such situations enables operators or an autonomous fault response capability to deal with the problem at a point that maximizes the available options. For example, this system has been applied to the problem of managing battery energy on a lunar rover as it is used to explore the Moon. Astronauts drive the rover to waypoints and conduct science observations according to a plan that is scheduled and verified to be achievable with the energy resources available. As the astronauts execute this plan, the system uses this new capability to continuously re-verify the plan as energy is consumed to ensure that the battery will never be depleted below safe levels across the entire plan.

Wagner, David A.↗

NASA NTRS2013

Embedding Temporal Constraints For Coordinated Execution in Habitat Automation

Future NASA plans call for long-duration deep space missions with human crews. Because of light-time delay and other considerations, increased autonomy will be needed. This will necessitate integration of tools in such areas as anomaly detection, diagnosis, planning, and execution. In this paper we investigate an approach that integrates planning and execution by embedding planner-derived temporal constraints in an execution procedure. To avoid the need for propagation, we convert the temporal constraints to dispatchable form. We handle some uncertainty in the durations without it affecting the execution; larger variations may cause activities to be skipped.

Morris, Paul↗

NASA NTRS2013

Influence of UAS Pilot Communication and Execution Delay on Controller's Acceptability Ratings of UAS-ATC Interactions

Successful integration of UAS in the NAS will require that UAS interactions with the air traffic management system be similar to interactions between manned aircraft and air traffic management. For example, UAS response times to air traffic controller (ATCo) clearances should be equivalent to those that are currently found to be acceptable with manned aircraft. Prior studies have examined communication delays with manned aircraft. Unfortunately, there is no analogous body of research for UAS. The goal of the present study was to determine how UAS pilot communication and execution delays affect ATCos' acceptability ratings of UAS pilot responses when the UAS is operating in the NAS. Eight radar-certified controllers managed traffic in a modified ZLA sector with one UAS flying in it. In separate scenarios, the UAS pilot verbal communication and execution delays were either short (1.5 s) or long (5 s) and either constant or variable. The ATCo acceptability of UAS pilot communication and execution delays were measured subjectively via post trial ratings. UAS verbal pilot communication delay, were rated as acceptable 92% of the time when the delay was short. This acceptability level decreased to 64% when the delay was long. UAS pilot execution delay had less of an influence on ATCo acceptability ratings in the present stimulation. Implications of these findings for UAS in the NAS integration are discussed.

communication↗