Engineering Papers⌕ Search

SEARCH · Engineering Papers

Results for “Static Code Analysis”

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.

At least 37 records · Page 2

Palm: Easing the Burden of Analytical Performance Modeling

Analytical (predictive) application performance models are critical for diagnosing performance-limiting resources, optimizing systems, and designing machines. Creating models, however, is difficult because they must be both accurate and concise. To ease the burden of performance modeling, we developed Palm, a modeling tool that combines top-down (human-provided) semantic insight with bottom-up static and dynamic analysis. To express insight, Palm defines a source code modeling annotation language. By coordinating models and source code, Palm's models are `first-class' and reproducible. Unlike prior work, Palm formally links models, functions, and measurements. As a result, Palm (a) uses functions to either abstract or express complexity (b) generates hierarchical models (representing an application's static and dynamic structure); and (c) automatically incorporates measurements to focus attention, represent constant behavior, and validate models. We discuss generating models for three different applications.

annotation languages↗

Performance and Architecture Lab Modeling Tool

Analytical application performance models are critical for diagnosing performance-limiting resources, optimizing systems, and designing machines. Creating models, however, is difficult. Furthermore, models are frequently expressed in forms that are hard to distribute and validate. The Performance and Architecture Lab Modeling tool, or Palm, is a modeling tool designed to make application modeling easier. Palm provides a source code modeling annotation language. Not only does the modeling language divide the modeling task into sub problems, it formally links an application's source code with its model. This link is important because a model's purpose is to capture application behavior. Furthermore, this link makes it possible to define rules for generating models according to source code organization. Palm generates hierarchical models according to well-defined rules. Given an application, a set of annotations, and a representative execution environment, Palm will generate the same model. A generated model is a an executable program whose constituent parts directly correspond to the modeled application. Palm generates models by combining top-down (human-provided) semantic insight with bottom-up static and dynamic analysis. A model's hierarchy is defined by static and dynamic source code structure. Because Palm coordinates models and source code, Palm's models are 'first-class' and reproducible. Palm automates common modeling tasks. For instance, Palm incorporates measurements to focus attention, represent constant behavior, and validate models. Palm's workflow is as follows. The workflow's input is source code annotated with Palm modeling annotations. The most important annotation models an instance of a block of code. Given annotated source code, the Palm Compiler produces executables and the Palm Monitor collects a representative performance profile. The Palm Generator synthesizes a model based on the static and dynamic mapping of annotations to program behavior. The model -- an executable program -- is a hierarchical composition of annotation functions, synthesized functions, statistics for runtime values, and performance measurements.

Tallent, Nathan↗

Detecting Data-Races in High-Performance Computing

High-performance computing is susceptible to data-race bugs. Data races occur when sequences of computed events do not happen in the intended order, a significant barrier to the integrity of parallel programs using shared-memory architectures. Many approaches to data-race detection are based on traditional static-analysis techniques that typically execute on a program’s source code or control-flow graph (the graphical representation of all possible orders of events in the execution of a program). Similar to classical data-flow analyses, such tools can produce false alarms that report spurious race conditions on error free programs. We have developed a software verification technique that requires as input only a program’s source code and can automatically detect a data-race bug which definitely exists, determine that a program is definitely data-race free, or report that it cannot determine either of the two cases.

97 MATHEMATICS AND COMPUTING↗

ExaSat: An Exascale Static Analysis Tool (ExaSat) v1.0

The ExaSAT framework automates the extraction of parameterized performance models directly from source code using compiler analysis. Its parameterized analytic model enables quantitative evaluation of a broad range of hardware design trade-offs and software optimizations on a variety of different performance metrics, with a primary focus on data movement as a metric. ExaSAT analysis provides insights in the hardware and software tradeoffs and lays the groundwork for exploring a more targeted set of design points using cycle-accurate architectural simulators and emulators.

Chan, Cy↗

Validation of the Modelling of Corrosion Driven Expansion in Grouted Waste-forms - 16125

One of the current preferred solutions for the disposal of Intermediate Level radioactive waste in the UK is grout encapsulation inside steel boxes for long term storage. These boxes are then to be entombed in a Geological Disposal Facility once one is available. However, both prior to and during geological disposal, waste contents can react with the water present in the encapsulant grout and begin to corrode. This corrosion product occupies a larger volume (by several hundred percent) than the original material and the corrosion occurs over the course of decades and centuries, long after the encapsulant grout has set and hardened. The expanding waste then creates stresses in the encapsulant causing both it and the surrounding box to deform and, in extreme circumstances, and after long times, for the structural integrity of the box to fail. This behaviour needs to be quantified before the box can be approved for use as any excessive deformation could lead to a loss of containment or, since the boxes are stacked on top of each other, to a significant accident in the stores. Due to the long timescales involved, physical testing of the phenomenon in full scale is impossible. Instead, a combination of chemical modelling and finite element analysis is used to predict the extent of the corrosion in the waste and its effect of the integrity of the box. There are a number of difficulties in modelling the corrosion-driven expansion and subsequent deformation of the boxes. Although the corrosion occurs over a very long time scale, the event is highly non-linear and dynamic. All of the material models, including the steel and grout are non-linear. The deformation is in the order of 10s of centimetres, well beyond the static elastic range. Finally, the components must be allowed to move relative to each other which involve a lot of part to part contacts. This means that simple static modelling, which would solve quite quickly, cannot be used. Instead a dynamic analysis code, LS-DYNA, has been used to expand the product over time to simulate the corrosion-driven expansion. This software is generally used for modelling car crashes or scenarios where waste containers have been dropped. The analyses therefore include a significant inertial component. This paper will detail the NNL's approach to modelling this long-term, quasi-static phenomenon in the dynamic, impact oriented software code LS-DYNA. It will cover the problems inherent in this approach, the errors that it creates as well as the tests and solutions that NNL worked on in order to overcome them and be confident that the solution could be validated. This work will ultimately be used to determine the maximum inventory which can be stored in each box based on the waste content and the potential extent of expansion as well as any modification that could be made to the box design or the processing streams that may improve the storage solution. (authors)

12 MANAGEMENT OF RADIOACTIVE AND NON-RADIOACTIVE W↗

Using CAASCADE and CrayPAT for Analysis of HPC Applications

We describe our work on integrating CAASCADE with CrayPAT to obtain both static and dynamic information on characteristics of high-performance computing (HPC) applications. CAASCADE --- Compiler-Assisted Application Source Code Analysis and Database---is a system we are developing to extract features of application from its source code by utilizing compiler plugins. CrayPAT enable us to add runtime-based information to CAASCADE's feature detection. We present results from analysis of HPC applications.

Budiardja, Reuben↗

Language Independent Static Analysis (LISA)

Software is becoming increasingly important in nearly every aspect of global society and therefore in nearly every aspect of national security as well. While there have been major advancements in recent years in formally proving properties of program source code during development, such approaches are still in the minority among development teams, and the vast majority of code in this software explosion is produced without such properties. In these cases, the source code must be analyzed in order to establish whether the properties of interest hold. Because of the volume of software being produced, automated approaches to software analysis are necessary to meet the need. However, this software boom is not occurring in just one language. There are a wide range of languages of interest in national security spaces, including well-known languages such as C, C++, Python, Java, Javascript, and many more. But recent years have produced a wide range of new languages, including Nim, (2008), Go (2009), Rust (2010), Dart (2011), Kotlin (2011), Elixir (2011), Red (2011), Julia (2012), Typescript (2012), Swift (2014), Hack (2014), Crystal (2014), Ballerina (2017) and more. Historically, automated software analyses are implemented as tools that intermingle both the analysis question at hand with target language dependencies throughout their code, making re-use of components for different analysis questions or different target languages impractical. This project seeks to explore how mission-relevant, static software analyses can be designed and constructed in a language-independent fashion, dramatically increasing the reusability of software analysis investments.

97 MATHEMATICS AND COMPUTING↗

Saloon

Saloon is a Vim plugin that simplifies Python code linter / fixer configuration and usage. Saloon's menu lets developers toggle which static analysis tools to use and delegates those changes to ALE's (Asynchronous Lint Engine) API. Since prospector (python linter aggregate) already handles multiple tools, and is integrated with ALE, most of the actual linting will initially be handled via prospector calls.

Bloss, DavidK.↗

Sandbox for Mac Malware v 1.0

This software is an analyzer for automated sandbox analysis of malware on the OS X operating system. It runs inside an OS X virtual machine to collect data about what happens when a given file is opened or run. As of August 2014, there was no sandbox software for Mac OS X malware, as it requires different methods from those used on the Windows OS (which most sandboxes are written for). This software adds OS X analysis capabilities to an existing open-source sandbox, Cuckoo Sandbox (http://cuckoosandbox.org/), which previously only worked for Windows. The analyzer itself can take many different types of files as input: the traditional Mach-O and FAT executables, .app files, zip files, Python scripts, Java archives, and web pages, as well as PDFs and other documents. While the file is running, the analyzer also simulates rudimentary human interaction with clicks and mouse movements in order to bypass the tests some malware use to see if they are being analyzed. The analyzer outputs several different kinds of data: function call traces, network captures, screenshots, and all created and modified files. This work also includes a static analysis Cuckoo module for Mach-O binary files. It extracts file structures, code library imports and exports, and signatures. This data can be used along with the analyzer results to create signatures for malware.

Walkup, Elizabeth↗

Generating and Analyzing Program Call Graphs using Ontology

Call graph or caller-callee relationships have been used for various kinds of static program analysis, performance analysis and profiling, and for program safety or security analysis such as detecting anomalies of program execution or code injection attacks. However, different tools generate call graphs in different formats, which prevents efficient reuse of call graph results. In this paper, we present an approach of using ontology and resource description framework (RDF) to create knowledge graphs for specifying call graphs to facilitate the construction of full-fledged and complex call graphs of computer programs, realizing more interoperable and scalable program analyses than conventional approaches. We create a formal ontology-based specification of call graph information to capture concepts and properties of both static and dynamic call graphs so different tools can collaboratively contribute to more comprehensive analysis results. Our experiments show that ontology enables merging of call graphs generated from different tools and flexible queries using a standard query interface. Index Terms—Callgraph, ontology, knowl

Dorta, E.↗

Risk-Informed External Hazards Analysis for Seismic and Flooding Phenomena for a Generic PWR

This report describes the activities performed during the FY2017 for the US-DOE Light Water Reactor Sustainability Risk-Informed Safety Margin Characterization (LWRS-RISMC), Industry Application #2. The scope of Industry Application #2 is to deliver a risk-informed external hazards safety analysis for a representative nuclear power plant. Following the advancements occurred during the previous FYs (toolkits identification, models development), FY2017 focused on: increasing the level of realism of the analysis; improving the tools and the coupling methodologies. In particular the following objectives were achieved: calculation of buildings pounding and their effects on components seismic fragility; development of a SAPHIRE code PRA models for 3-loops Westinghouse PWR; set-up of a methodology for performing static-dynamic PRA coupling between SAPHIRE and EMRALD codes; coupling RELAP5-3D/RAVEN for performing Best-Estimate Plus Uncertainty analysis and automatic limit surface search; and execute sample calculations for demonstrating the capabilities of the toolkit in performing a risk-informed external hazards safety analyses.

22 GENERAL STUDIES OF NUCLEAR REACTORS↗

PredCom: A Predictive Approach to Collecting Approximated Communication Traces

Communication traces collected from MPI applications are an important source of information for performance optimization as they can help analysts determine communication patterns and identify inefficiencies. However, their collection, especially at scale, is time consuming, since it usually requires running the complete target application on a large number of nodes. In this work, we present PredCom, a tool-chain to generate a predictive communication proxy based on information gathered from a few small scale runs, which allows us to extract approximate communication traces with an accuracy high enough for most analysis goals. For this, we combine LLVM passes on the original source code (to capture static program structure) with parameter prediction (to capture dynamic and scaling behavior). This approach drastically reduces the time needed for collecting the communication traces, even for traces on large numbers of MPI processes. Here, we demonstrate that PredCom generates communication traces of various applications up to 1612x faster with an accuracy loss of 0.11 on average compared to the original large-scale traces, and we show that the generated traces can be used to optimize process placement.

97 MATHEMATICS AND COMPUTING↗

Hydrogen Permeation Analysis Tool

There is a rising need for the measurement and understanding of hydrogen transport properties in materials for the energy and transportation industries. The Hydrogen Permeation Analysis Tool (HyPAT) provides a user friendly interface for batch analysis of dynamic hydrogen permeation data to calculate the transport properties permeability, solubility, and diffusivity. A built in literature database provides an easy comparison to known values. A common method for measuring these hydrogen transport properties is dynamic pressure rise permeation experiments, for example, those done in the Static Gas Absorption and Permeation (SGAP) experiment at INL. Most laboratories develop individual, in-house codes for data analysis. HyPAT provides a platform that can be adopted by other user groups for such experimental analysis and significantly reduce personnel time spent performing data analysis.

Fuerst, ThomasF↗

Neutronics Analysis of Cold Critical KRUSTY Experiments using MCNP and Serpent

Kilowatt Reactor Using Stirling Technology (KRUSTY) is a prototype designed as a proof of concept for NASA’s Kilo power program, which was funded in order to create a small reactor for various space applications such as providing power for a colony on Mars or the moon and eventually as a possible option for powering rockets on deep space missions. KRUSTY was tested at the National Criticality Experiments Research Center (NCERC) located at the Nevada National Security Site (NNSS) from November 2017, through March 2018. The experimental campaign was conducted in four phases: com ponent critical experiments, cold critical experiments, warm critical runs, and high temperature demonstration. The component critical and cold critical experiments were used to determine the worth of the beryllium oxide (BeO) reflector rings and the boron carbide (B4C) control rod disks under different conditions. These conditions were altered by the addition and subtraction of other components in the assembly. The component critical phase was performed at atmospheric pressure and had four solid support rods spanning the center core; whereas the cold critical phase had the center core placed in a vacuum chamber and eight sodium-filled heat pipes spanning the center core region. This summary discusses the static neutronic analysis completed on the cold critical phase of the campaign using MCNP ® and Serpent. These two codes were used to assess any potential differences or biases in the simulation results. Understanding these potential biases is a key step toward the final goal of being able to fully analyze the transient experiments performed during phases 3 and 4 of the campaign.

21 SPECIFIC NUCLEAR REACTORS AND ASSOCIATED PLANTS↗

The TDHF code Sky3D version 1.1

The nuclear mean-field model based on Skyrme forces or related density functionals has found widespread application to the description of nuclear ground states, collective vibrational excitations, and heavy-ion collisions. The code Sky3D solves the static or dynamic equations on a three-dimensional Cartesian mesh with isolated or periodic boundary conditions and no further symmetry assumptions. Pairing can be included in the BCS approximation for the static case. The code is implemented with a view to allow easy modifications for including additional physics or special analysis of the results.

73 NUCLEAR PHYSICS AND RADIATION PHYSICS↗

Assessment of ALEGRA Computation for Magnetostatic Configurations

Here, a closed-form solution is described here for the equilibrium configurations of the magnetic field in a simple heterogeneous domain. This problem and its solution are used for rigorous assessment of the accuracy of the ALEGRA code in the quasistatic limit. By the equilibrium configuration we understand the static condition, or the stationary states without macroscopic current. The analysis includes quite a general class of 2D solutions for which a linear isotropic metallic matrix is placed inside a stationary magnetic field approaching a constant value H i ° at infinity. The process of evolution of the magnetic fields inside and outside the inclusion and the parameters for which the quasi-static approach provides for self-consistent results is also explored. Lastly, it is demonstrated that under spatial mesh refinement, ALEGRA converges to the analytic solution for the interior of the inclusion at the expected rate, for both body-fitted and regular rectangular meshes.

71 CLASSICAL AND QUANTUM MECHANICS, GENERAL PHYSIC↗

DYNAMIC PRA OF A MULTI-UNIT PLANT

Dynamic Probabilistic Risk Analysis (PRA) methods couple stochastic methods (e.g., RAVEN, ADAPT, ADS, MCDET) with safety analysis codes (RELAP5-3D, MELCOR, MAAP) to determine risk associated to complex systems such as nuclear plants. Compared to classical PRA methods, which are based on static logic structures (e.g., Event-Trees, Fault-Trees), they can evaluate with higher resolution the safety impact of timing and sequencing of events on the accident progression. Recently, special attention has been given to nuclear plants which consist of multiple units and, in particular, on the safety impact of system dependencies, shared systems and common resources on core damage frequencies. In the literature, while classical PRA methods have been employed to model multi-unit plants, Dynamic PRA methods have never been applied to analyze a full multi-unit model. This paper presents a PRA analysis of a multi-unit plant using Dynamic PRA methods. We employ RAVEN as stochastic method coupled with RELAP5-3D. The plant under consideration consists of the three units and their associated spent fuel pools (SFPs). The studied initiating event is a seismic induced station blackout event. We will describe in detail how the multi-unit plant has been constructed and, in particular, how unit dependencies and shared resources are modeled.

97 MATHEMATICS AND COMPUTING↗

XScan: An Integrated Tool for Understanding Open Source Community-Based Scientific Code

Many scientific communities have adopted community-based models that integrate multiple components to simulate whole system dynamics. The community software projects’ complexity, stems from the integration of multiple individual software components that were developed under different application requirements and various machine architectures, has become a challenge for effective software system understanding and continuous software development. The paper presents an integrated software toolkit called X-ray Software Scanner (in abbreviation, XScan) for a better understanding of large-scale community-based scientific codes. Our software tool provides support to quickly summarize the overall information of scientific codes, including the number of lines of code, programming languages, external library dependencies, as well as architecture-dependent parallel software features. The XScan toolkit also realizes a static software analysis component to collect detailed structural information and provides an interactive visualization and analysis of the functions. We use a large-scale community-based Earth System Model to demonstrate the workflow, functions and visualization of the toolkit. We also discuss the application of advanced graph analytics techniques to assist software modular design and component refactoring.

Zheng, Weijian↗