Search NASA⌕ Search

SEARCH · Search NASA

Results for “Threading”

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 1,513 records · Page 84

Characterization of Stress Relaxation, Dislocations and Crystallographic Tilt Via X-ray Microdiffraction in GaN (0001) Layers Grown by Maskless Pendeo-Epitaxy

Intrinsic stresses due to lattice mismatch and high densities of threading dislocations and extrinsic stresses resulting from the mismatch in the coefficients of thermal expansion are present in almost all III-Nitride heterostructures. Stress relaxation in the GaN layers occurs in conventional and in pendeo-epitaxial films via the formation of additional misfit dislocations, domain boundaries, elastic strain and wing tilt. Polychromatic X-ray microdiffraction, high resolution monochromatic X-ray diffraction and finite element simulations have been used to determine the distribution of strain, dislocations, sub-boundaries and crystallographic wing tilt in uncoalesced and coalesced GaN layers grown by maskless pendeo-epitaxy. An important parameter was the width-to-height ratio of the etched columns of GaN from which the lateral growth of the wings occurred. The strain and tilt across the stripes increased with the width-to-height ratio. Tilt boundaries formed in the uncoalesced GaN layers at the column/wing interfaces for samples with a large ratio. Sharper tilt boundaries were observed at the interfaces formed by the coalescence of two laterally growing wings. The wings tilted upward during cooling to room temperature for both the uncoalesced and the coalesced GaN layers. It was determined that finite element simulations that account for extrinsic stress relaxation can explain the experimental results for uncoalesced GaN layers. Relaxation of both extrinsic and intrinsic stress components in the coalesced GaN layers contribute to the observed wing tilt and the formation of sub-boundaries.

36 MATERIALS SCIENCE↗

RADIOACTIVE MATERIAL PACKAGING TORQUE REQUIREMENTS COMPLIANCE

Shipping containers used to transport radioactive material (RAM) in commerce employ a variety of closure mechanisms. Often, these closure mechanisms require a specific amount of torque be applied to a bolt, nut or other threaded fastener. It is important that the required preload is achieved so that the package testing and analysis is not invalidated for the purpose of protecting the public. Torque compliance is a means of ensuring closure preload, is a major factor in accomplishing the package functions of confinement/containment, sub-criticality, and shielding. This paper will address the importance of applying proper torque to package closures, discuss torque value nomenclature, and present one methodology to ensure torque compliance is achieved.

12 MANAGEMENT OF RADIOACTIVE AND NON-RADIOACTIVE W↗

On the Performance of an Algebraic MultigridSolver on Multicore Clusters

Algebraic multigrid (AMG) solvers have proven to be extremely efficient on distributed-memory architectures. However, when executed on modern multicore cluster architectures, we face new challenges that can significantly harm AMG's performance. We discuss our experiences on such an architecture and present a set of techniques that help users to overcome the associated problems, including thread and process pinning and correct memory associations. We have implemented most of the techniques in a MultiCore SUPport library (MCSup), which helps to map OpenMP applications to multicore machines. We present results using both an MPI-only and a hybrid MPI/OpenMP model.

97 MATHEMATICS AND COMPUTING↗

Challenges of Algebraic Multigrid across Multicore Architectures

Algebraic multigrid (AMG) is a popular solver for large-scale scientific computing and an essential component of many simulation codes. AMG has shown to be extremely efficient on distributed-memory architectures. However, when executed on modern multicore architectures, we face new challenges that can significantly deteriorate AMG's performance. We examine its performance and scalability on three disparate multicore architectures: a cluster with four AMD Opteron Quad-core processors per node (Hera), a Cray XT5 with two AMD Opteron Hex-core processors per node (Jaguar), and an IBM BlueGene/P system with a single Quad-core processor (Intrepid). We discuss our experiences on these platforms and present results using both an MPI-only and a hybrid MPI/OpenMP model. We also discuss a set of techniques that helped to overcome the associated problems, including thread and process pinning and correct memory associations.

97 MATHEMATICS AND COMPUTING↗

Crunching Large Graphs with Commodity Processors

Crunching large graphs is the basis of many emerging appli- cations, such as social network analysis and bioinformatics. Graph analytics algorithms exhibit little locality and therefore present significant performance challenges. Hardware multi- threading systems (e.g, Cray XMT) show that with enough concurrency, we can tolerate long latencies. Unfortunately, this solution is not available with commodity parts. Our goal is to develop a latency-tolerant system built out of commodity parts and mostly in software. The proposed system includes a runtime that supports a large number of lightweight contexts, full-bit synchronization and a memory manager that provides a high-latency but high-bandwidth global shared memory. This paper lays out the vision for our system, and justifies its feasibility with a performance analysis of the run- time for latency tolerance.

99 GENERAL AND MISCELLANEOUS↗

Apparatus for dispensing material

An apparatus capable of dispensing drops of material with volumes on the order of zeptoliters is described. In some embodiments of the inventive pipette the size of the droplets so dispensed is determined by the size of a hole, or channel, through a carbon shell encapsulating a reservoir that contains material to be dispensed. The channel may be formed by irradiation with an electron beam or other high-energy beam capable of focusing to a spot size less than about 5 nanometers. In some embodiments, the dispensed droplet remains attached to the pipette by a small thread of material, an atomic scale meniscus, forming a virtually free-standing droplet. In some embodiments the droplet may wet the pipette tip and take on attributes of supported drops. Methods for fabricating and using the pipette are also described.

47 OTHER INSTRUMENTATION↗

Evaluation of Simple Causal Message Logging for Large-Scale Fault Tolerant HPC Systems

The era of petascale computing brought machines with hundreds of thousands of processors. The next generation of exascale supercomputers will make available clusters with millions of processors. In those machines, mean time between failures will range from a few minutes to few tens of minutes, making the crash of a processor the common case, instead of a rarity. Parallel applications running on those large machines will need to simultaneously survive crashes and maintain high productivity. To achieve that, fault tolerance techniques will have to go beyond checkpoint/restart, which requires all processors to roll back in case of a failure. Incorporating some form of message logging will provide a framework where only a subset of processors are rolled back after a crash. In this paper, we discuss why a simple causal message logging protocol seems a promising alternative to provide fault tolerance in large supercomputers. As opposed to pessimistic message logging, it has low latency overhead, especially in collective communication operations. Besides, it saves messages when more than one thread is running per processor. Finally, we demonstrate that a simple causal message logging protocol has a faster recovery and a low performance penalty when compared to checkpoint/restart. Running NAS Parallel Benchmarks (CG, MG and BT) on 1024 processors, simple causal message logging has a latency overhead below 5%.

97 MATHEMATICS AND COMPUTING↗

Scalable in-memory RDFS closure on billions of triples.

We present an RDFS closure algorithm, specifically designed and implemented on the Cray XMT supercomputer, that obtains inference rates of 13 million inferences per second on the largest system configuration we used. The Cray XMT, with its large global memory (4TB for our experiments), permits the construction of a conceptually straightforward algorithm, fundamentally a series of operations on a shared hash table. Each thread is given a partition of triple data to process, a dedicated copy of the ontology to apply to the data, and a reference to the hash table into which it inserts inferred triples. The global nature of the hash table allows the algorithm to avoid a common obstacle for distributed memory machines: the creation of duplicate triples. On LUBM data sets ranging between 1.3 billion and 5.3 billion triples, we obtain nearly linear speedup except for two portions: file I/O, which can be ameliorated with the additional service nodes, and data structure initialization, which requires nearly constant time for runs involving 32 processors or more.

99 GENERAL AND MISCELLANEOUS↗

Analysis of the ANL Test Method for 6CVS Containment Vessels

In the fall of 2010, Argonne National Laboratory (ANL) contracted with vendors to design and build 6CVS containment vessels as part of their effort to ship Fuel Derived Mixed Fission Product material. The 6CVS design is based on the Savannah River National Laboratory's (SRNL) design for 9975 and 9977 six inch diameter containment vessels. The main difference between the designs is that the 6CVS credits the inner O-ring seal as the containment boundary while the SRNL design credits the outer O-ring seal. Since the leak test must be done with the inner O-ring in place, the containment vessel does not have a pathway for getting the helium into the vessel during the leak test. The leak testing contractor was not able to get acceptable leak rates with the specified O-ring, but they were able to pass the leak test with a slightly larger O-ring. ANL asked the SRNL to duplicate the leak test vendor's method to determine the cause of the high leak rates. The SRNL testing showed that the helium leak indications were caused by residual helium left within the 6CVS Closure Assembly by the leak test technique, and by helium permeation through the Viton O-ring seals. After SRNL completed their tests, the leak testing contractor was able to measure acceptable leak rates by using the slightly larger O-ring size, by purging helium from the lid threads, and by being very quick in getting the bell jar under a full vacuum. This paper describes the leak test vendor's test technique, and other techniques that could be have been used to successfully leak test the 6CVS's.

12 MANAGEMENT OF RADIOACTIVE AND NON-RADIOACTIVE W↗

Simulation of Large-Scale HPC Architectures

The Extreme-scale Simulator (xSim) is a recently developed performance investigation toolkit that permits running high-performance computing (HPC) applications in a controlled environment with millions of concurrent execution threads. It allows observing parallel application performance properties in a simulated extreme-scale HPC system to further assist in HPC hardware and application software co-design on the road toward multi-petascale and exascale computing. This paper presents a newly implemented network model for the xSim performance investigation toolkit that is capable of providing simulation support for a variety of HPC network architectures with the appropriate trade-off between simulation scalability and accuracy. The taken approach focuses on a scalable distributed solution with latency and bandwidth restrictions for the simulated network. Different network architectures, such as star, ring, mesh, torus, twisted torus and tree, as well as hierarchical combinations, such as to simulate network-on-chip and network-on-node, are supported. Network traffic congestion modeling is omitted to gain simulation scalability by reducing simulation accuracy.

99 GENERAL AND MISCELLANEOUS↗

CERN IT Book Fair 2009 - Special talk by Bjarne Stroustrup: "The Design of C++0x"

A draft for a revised ISO C++ standard, C++0x, has been produced. The speaker will present the background of C++, its aims, the standards process (with opinions), some of the guiding design principles (with tiny code examples), and two case studies.The case studies are initialization (a general and uniform syntax and semantics for initializers in all contexts) and concurrent support facilities (memory model, threads, locks, futures).

97 MATHEMATICS AND COMPUTING↗

High Performance Descriptive Semantic Analysis of Semantic Graph Databases

As semantic graph database technology grows to address components ranging from extant large triple stores to SPARQL endpoints over SQL-structured relational databases, it will become increasingly important to be able to understand their inherent semantic structure, whether codified in explicit ontologies or not. Our group is researching novel methods for what we call descriptive semantic analysis of RDF triplestores, to serve purposes of analysis, interpretation, visualization, and optimization. But data size and computational complexity makes it increasingly necessary to bring high performance computational resources to bear on this task. Our research group built a novel high performance hybrid system comprising computational capability for semantic graph database processing utilizing the large multi-threaded architecture of the Cray XMT platform, conventional servers, and large data stores. In this paper we describe that architecture and our methods, and present the results of our analyses of basic properties, connected components, namespace interaction, and typed paths such for the Billion Triple Challenge 2010 dataset.

99 GENERAL AND MISCELLANEOUS↗

A communication-avoiding, hybrid-parallel, rank-revealing orthogonalization method.

Orthogonalization consumes much of the run time of many iterative methods for solving sparse linear systems and eigenvalue problems. Commonly used algorithms, such as variants of Gram-Schmidt or Householder QR, have performance dominated by communication. Here, 'communication' includes both data movement between the CPU and memory, and messages between processors in parallel. Our Tall Skinny QR (TSQR) family of algorithms requires asymptotically fewer messages between processors and data movement between CPU and memory than typical orthogonalization methods, yet achieves the same accuracy as Householder QR factorization. Furthermore, in block orthogonalizations, TSQR is faster and more accurate than existing approaches for orthogonalizing the vectors within each block ('normalization'). TSQR's rank-revealing capability also makes it useful for detecting deflation in block iterative methods, for which existing approaches sacrifice performance, accuracy, or both. We have implemented a version of TSQR that exploits both distributed-memory and shared-memory parallelism, and supports real and complex arithmetic. Our implementation is optimized for the case of orthogonalizing a small number (5-20) of very long vectors. The shared-memory parallel component uses Intel's Threading Building Blocks, though its modular design supports other shared-memory programming models as well, including computation on the GPU. Our implementation achieves speedups of 2 times or more over competing orthogonalizations. It is available now in the development branch of the Trilinos software package, and will be included in the 10.8 release.

99 GENERAL AND MISCELLANEOUS↗

Comparison of open source visual analytics toolkits.

We present the results of the first stage of a two-stage evaluation of open source visual analytics packages. This stage is a broad feature comparison over a range of open source toolkits. Although we had originally intended to restrict ourselves to comparing visual analytics toolkits, we quickly found that very few were available. So we expanded our study to include information visualization, graph analysis, and statistical packages. We examine three aspects of each toolkit: visualization functions, analysis capabilities, and development environments. With respect to development environments, we look at platforms, language bindings, multi-threading/parallelism, user interface frameworks, ease of installation, documentation, and whether the package is still being actively developed.

99 GENERAL AND MISCELLANEOUS↗

GPU-based Scalable Volumetric Reconstruction for Multi-view Stereo

We present a new scalable volumetric reconstruction algorithm for multi-view stereo using a graphics processing unit (GPU). It is an effectively parallelized GPU algorithm that simultaneously uses a large number of GPU threads, each of which performs voxel carving, in order to integrate depth maps with images from multiple views. Each depth map, triangulated from pair-wise semi-dense correspondences, represents a view-dependent surface of the scene. This algorithm also provides scalability for large-scale scene reconstruction in a high resolution voxel grid by utilizing streaming and parallel computation. The output is a photo-realistic 3D scene model in a volumetric or point-based representation. We demonstrate the effectiveness and the speed of our algorithm with a synthetic scene and real urban/outdoor scenes. Our method can also be integrated with existing multi-view stereo algorithms such as PMVS2 to fill holes or gaps in textureless regions.

97 MATHEMATICS AND COMPUTING↗

Runtime Detection of C-Style Errors in UPC Code

Unified Parallel C (UPC) extends the C programming language (ISO C 99) with explicit parallel programming support for the partitioned global address space (PGAS), which provides a global memory space with localized partitions to each thread. Like its ancestor C, UPC is a low-level language that emphasizes code efficiency over safety. The absence of dynamic (and static) safety checks allows programmer oversights and software flaws that can be hard to spot. In this paper, we present an extension of a dynamic analysis tool, ROSE-Code Instrumentation and Runtime Monitor (ROSECIRM), for UPC to help programmers find C-style errors involving the global address space. Built on top of the ROSE source-to-source compiler infrastructure, the tool instruments source files with code that monitors operations and keeps track of changes to the system state. The resulting code is linked to a runtime monitor that observes the program execution and finds software defects. We describe the extensions to ROSE-CIRM that were necessary to support UPC. We discuss complications that arise from parallel code and our solutions. We test ROSE-CIRM against a runtime error detection test suite, and present performance results obtained from running error-free codes. ROSE-CIRM is released as part of the ROSE compiler under a BSD-style open source license.

97 MATHEMATICS AND COMPUTING↗

Performance study of GPUs in real-time trigger applications for HEP experiments

Graphical Processing Units (GPUs) have evolved into highly parallel, multi-threaded, multicore powerful processors with high memory bandwidth. GPUs are used in a variety of intensive computing applications. The combination of highly parallel architecture and high memory bandwidth makes GPUs a potentially promising technology for effective real-time processing for High Energy Physics (HEP) experiments. However, not much is known of their performance in real-time applications that require low latency, such as the trigger for HEP experiments. We describe an R and D project with the goal to study the performance of GPU technology for possible low latency applications, performing basic operations as well as some more advanced HEP lower-level trigger algorithms (such as fast tracking or jet finding). We present some preliminary results on timing measurements, comparing the performance of a CPU versus a GPU with NVIDIA's CUDA general-purpose parallel computing architecture, carried out at CDF's Level-2 trigger test stand. These studies will provide performance benchmarks for future studies to investigate the potential and limitations of GPUs for real-time applications in HEP experiments.

43 PARTICLE ACCELERATORS↗