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 649 records · Page 36

A Monte Carlo neutron transport code for eigenvalue calculations on a dual-GPU system and CUDA environment

Monte Carlo (MC) method is able to accurately calculate eigenvalues in reactor analysis. Its lengthy computation time can be reduced by general-purpose computing on Graphics Processing Units (GPU), one of the latest parallel computing techniques under development. The method of porting a regular transport code to GPU is usually very straightforward due to the 'embarrassingly parallel' nature of MC code. However, the situation becomes different for eigenvalue calculation in that it will be performed on a generation-by-generation basis and the thread coordination should be explicitly taken care of. This paper presents our effort to develop such a GPU-based MC code in Compute Unified Device Architecture (CUDA) environment. The code is able to perform eigenvalue calculation under simple geometries on a multi-GPU system. The specifics of algorithm design, including thread organization and memory management were described in detail. The original CPU version of the code was tested on an Intel Xeon X5660 2.8 GHz CPU, and the adapted GPU version was tested on NVIDIA Tesla M2090 GPUs. Double-precision floating point format was used throughout the calculation. The result showed that a speedup of 7.0 and 33.3 were obtained for a bare spherical core and a binary slab system respectively. The speedup factor was further increased by a factor of {approx}2 on a dual GPU system. The upper limit of device-level parallelism was analyzed, and a possible method to enhance the thread-level parallelism was proposed. (authors)

22 GENERAL STUDIES OF NUCLEAR REACTORS↗

Performance study of atomic tally methods for GPU-accelerated Monte Carlo dose calculation - 25352

Over the past several years, the graphics processing unit (GPU) technology has rapidly gained ground in scientific computing due to its outstanding performance and programmability. GPU implementation of Monte Carlo radiation transport for dose calculations has been reported by many investigators. The majority of these studies adopted single-precision floating point format because of the higher peak floating point operations per second (FLOPS) the GPUs can deliver than double-precision. It has been known that calculation using single-precision is more prone to numerical round-off errors, especially when a single tally data is accumulated 'atomically' and repeatedly by thousands of GPU threads. To mitigate this problem, the least intrusive solution in theory is to replace the single-precision atomic-add tally function with a double-precision version. However, the complexity lies in the fact that some GPUs (Nvidia GPUs prior to the Pascal generation; all current AMD GPUs) do not readily offer such double-precision function at hardware level, and that software emulation is too slow to use if not optimized properly. This paper discusses several atomic-add tally methods with reduced numerical errors used throughout ARCHER development. The original software-based compare-and-swap method (CAS) was shown to be inefficient due to high intra-warp thread contention, whereas the improved software-based warp-aggregated method (WAG) and Kahan summation method (KAS) eliminated the thread contention and performed very well on Kepler and Maxwell GPUs, being more than 13 times faster than CAS in our tests. The hardware-based (HB) double-precision atomic-add feature available on Pascal and Volta GPUs exceeded software emulation and offered the best performance universally, so did WIB, a combination of WAG and HB methods. It was also shown that in a single-precision dose engine, KAS managed to maintain high reliability when the single-precision atomic-add tally underestimated the dose by 25%. (authors)

61 RADIATION PROTECTION AND DOSIMETRY↗

A Comparison of Shared Memory Parallel Programming Models

The dominant parallel programming models for shared memory computers, Pthreads and OpenMP, are both thread-centric in that they are based on explicit management of tasks and enforce data dependencies and output ordering through task management. By comparison, the Cray XMT programming model is data-centric where the primary concern of the programmer is managing data dependencies, allowing threads to progress in a data flow fashion. The XMT implements this programming model by associating tag bits with each word of memory, affording efficient fine grained data synchronization independent of the number of processors or how tasks are scheduled. When task management is implicit and synchronization is abundant, efficient, and easy to use, programmers have viable alternatives to traditional thread-centric algorithms. In this paper we compare the amount of available parallelism relative to the amount of work in a variety of different algorithms and data structures when synchronization does not need to be rationed, as well as identify opportunities for platform and performance portability of the data-centric programming model on multi-core processors.

99 GENERAL AND MISCELLANEOUS↗

Kokkos: Enabling manycore performance portability through polymorphic memory access patterns

The manycore revolution can be characterized by increasing thread counts, decreasing memory per thread, and diversity of continually evolving manycore architectures. High performance computing (HPC) applications and libraries must exploit increasingly finer levels of parallelism within their codes to sustain scalability on these devices. We found that a major obstacle to performance portability is the diverse and conflicting set of constraints on memory access patterns across devices. Contemporary portable programming models address manycore parallelism (e.g., OpenMP, OpenACC, OpenCL) but fail to address memory access patterns. The Kokkos C++ library enables applications and domain libraries to achieve performance portability on diverse manycore architectures by unifying abstractions for both fine-grain data parallelism and memory access patterns. In this paper we describe Kokkos’ abstractions, summarize its application programmer interface (API), present performance results for unit-test kernels and mini-applications, and outline an incremental strategy for migrating legacy C++ codes to Kokkos. Furthermore, the Kokkos library is under active research and development to incorporate capabilities from new generations of manycore architectures, and to address a growing list of applications and domain libraries.

97 MATHEMATICS AND COMPUTING↗

Synthesis of Armchair Graphene Nanoribbons on Germanium-on-Silicon

The synthesis of graphene nanoribbons on complementary metal– oxide–semiconductor-compatible substrates is a significant challenge hindering their integration into commercial semiconductor electronics. Here, the bottom-up synthesis of armchair graphene nanoribbons on epilayers of Ge on Si(001) via chemical vapor deposition is demonstrated. The synthesis leverages the previous discovery that graphene crystal growth can be driven with an extreme shape anisotropy on Ge(001) surfaces to directly form nanoribbons. However, compared to nanoribbon synthesis on Ge(001), synthesis on Ge/Si(001) is complicated by the possibility of Si diffusion to the Ge surface and the presence of threading dislocations. Herein, we demonstrate that similar to Ge(001), armchair nanoribbons with faceted edges and sub-10 nm widths can indeed be grown on Ge/Si(001). The nanoribbon synthesis proceeds faster than the diffusion of Si to the Ge surface if a sufficiently thick Ge epilayer is used (e.g., 3 μm), thereby avoiding competing reactions that form SiC. Moreover, threading dislocations in the Ge epilayer are not observed to affect the nucleation or anisotropic growth kinetics of the nanoribbons. Furthermore, these results demonstrate that previous successes in graphene nanoribbon synthesis on Ge(001) can be extended to Si(001) by using epilayers of Ge, motivating the future exploration of this promising platform for hybrid semiconducting graphene/Si electronics.

37 INORGANIC, ORGANIC, PHYSICAL, AND ANALYTICAL CH↗

DeepLynx Ecosystem 2025

Poor data integration and governance continue to plague complex engineering projects, resulting in missed cost, schedule, and performance targets. Departments operate in isolated systems with manual data exchange, creating fragmented information that compounds errors and leads to significant delays and cost overruns. The DeepLynx ecosystem addresses these challenges through an open-source, modular data management platform that transforms fragmented project data into an integrated digital thread. Built on a federated microservice architecture, the ecosystem comprises seven specialized tools centered around DeepLynx Nexus, a unified data catalog with hierarchical organization and graph-based navigation capabilities. The ecosystem includes: DeepLynx Stream for real-time timeseries data ingestion from industrial sources; DeepLynx Ingest for governed data uploads with formal review workflows; DeepLynx Lattice for ontology-based entity and relationship extraction; DeepLynx Run for workflow orchestration and secure AI/ML compute; DeepLynx Visualize for 3D digital twin visualization; and DeepLynx Insight for AI-assisted document analysis with traceable, grounded responses. Deployable in cloud, on-premise, or hybrid environments using containerized Docker applications and Helm charts, the DeepLynx ecosystem provides flexible infrastructure that adapts to organizational requirements. By consolidating project data into a unified data lake with role-based access controls and OAuth2 authentication, DeepLynx enables digital thread and digital twin capabilities that improve decision-making, reduce risk, and support complex engineering workflows throughout the project lifecycle.

42 - ENGINEERING↗

Structure and Function of Microbial Metal-Reduction Proteins

In this project, we proposed (i) identification of metal-reduction genes, (ii) development of new threading techniques and (iii) fold recognition and structure prediction of metal-reduction proteins. However, due to the reduction of the budget, we revised our plan to focus on two specific aims of (i) developing a new threading-based protein structure prediction method, and (ii) developing an expert system for protein structure prediction.

59 BASIC BIOLOGICAL SCIENCES↗

Repairable and Reconfigurable Structured Liquid Circuits

The advance of printed electronics is significantly bolstered by the development of liquid-state electronics that overcome the inherent limitations in flexibility and reconfigurability of solid-state electronics. By integrating the biocompatibility and conductivity of sulfonated polyaniline (S-PANI) and phytic acid (PA) with the reconfigurability of structured liquids, highly conductive all-liquid threads are developed. The dense packing and overlap of PA/S-PANI complexes at an oil/water interface promotes in-plane electron transport, and standard four-point probe measurements of PA/S-PANI interfacial assemblies demonstrate enhanced electrical properties. Notably, the rapid jetting of the ink phase into the matrix phase allows for liquid threads to be printed, enabling the fabrication of large-scale, conductive pathways between two electrodes and liquid circuits. Upon mechanical cleavage of the liquid wires, circuits can be broken, but will easily self-repair using an electric field, making this motif useful in the design of switches as well as restoring conductive pathways in series or in parallel. In conclusion, the demonstrated flexibility and reconfigurability these PA/S-PANI wires possess hold significant promise for their practical use in the design of flexible and adaptive bioelectronics that can be repaired on demand, signifying a transformative step in the evolution of liquid electronic materials.

36 MATERIALS SCIENCE↗

Resonant acoustic monitoring of damage in plug‐screw feeders

Abstract Plug‐screw feeders are critical in many industrial processes for compressing slurry materials via a rotating plug‐screw feeder. Over time, increasing plug‐screw feeder wear will eventually lead to catastrophic mechanical failure. Early detection of the wear state can prevent unplanned catastrophic failures resulting in operational shut‐downs, costly repairs, and most importantly the health and safety of workers. We present a theoretical basis for a noninvasive, in operando acoustic resonant technique to monitor the wear state of plug‐screw feeders. The technique is based on tracking the resonant acoustic modes of the plug‐screw feeder, which are sensitive to the plug‐screw feeder geometry, material, and operating conditions. We implemented a multivariate polynomial model to estimate the plug‐screw feeder wear state using multiple acoustic resonances by simulating the acoustic resonant modes for two categories of wear (tip and thread damage) that are common in plug‐screw feeders. Fitting multiple resonances to the polynomial model, we demonstrate accurate estimation of the total mass loss, as well as characterization of the type of damage (i.e., tip vs. thread). Current approaches for monitoring plug‐screw feeder wear rely on shutting down the operation and visually inspecting the plug‐screw feeder. The presented acoustic technique offers a noninvasive, in operando measurement approach that mitigates unplanned catastrophic failures. The acoustic resonance technique presented in the paper has a broad range of industrial applications including the Pharmaceutical, Mining, Integrated Biorefineries (IBR), and Additive Manufacturing industries, to name a few.

36 MATERIALS SCIENCE↗

Large language model evaluation for high–performance computing software development

We apply AI-assisted large language model (LLM) capabilities of GPT-3 targeting high-performance computing (HPC) kernels for (i) code generation, and (ii) auto-parallelization of serial code in C ++, Fortran, Python and Julia. Our scope includes the following fundamental numerical kernels: AXPY, GEMV, GEMM, SpMV, Jacobi Stencil, and CG, and language/programming models: (1) C++ (e.g., OpenMP [including offload], OpenACC, Kokkos, SyCL, CUDA, and HIP), (2) Fortran (e.g., OpenMP [including offload] and OpenACC), (3) Python (e.g., numpy, Numba, cuPy, and pyCUDA), and (4) Julia (e.g., Threads, CUDA.jl, AMDGPU.jl, and KernelAbstractions.jl). Kernel implementations are generated using GitHub Copilot capabilities powered by the GPT-based OpenAI Codex available in Visual Studio Code given simple + + prompt variants. To quantify and compare the generated results, we propose a proficiency metric around the initial 10 suggestions given for each prompt. For auto-parallelization, we use ChatGPT interactively giving simple prompts as in a dialogue with another human including simple “prompt engineering” follow ups. Results suggest that correct outputs for C++ correlate with the adoption and maturity of programming models. For example, OpenMP and CUDA score really high, whereas HIP is still lacking. We found that prompts from either a targeted language such as Fortran or the more general-purpose Python can benefit from adding language keywords, while Julia prompts perform acceptably well for its Threads and CUDA.jl programming models. Finally, we expect to provide an initial quantifiable point of reference for code generation in each programming model using a state-of-the-art LLM. Overall, understanding the convergence of LLMs, AI, and HPC is crucial due to its rapidly evolving nature and how it is redefining human-computer interactions.

97 MATHEMATICS AND COMPUTING↗

Porting DMRG++ Scientific Application to OpenPOWER

With the rapidly changing microprocessor designs and architectural diversity (multi-cores, many-cores, accelerators) for the next generation HPC systems, scientific applications must adapt to the hardware, to exploit the different types of parallelism and resources available in the architecture. To get the benefit of all the in-node hardware threads, it is important to use a single programming model to map and coordinate the available work to the different heterogeneous execution units in the node (e.g., multi-core hardware threads (latency optimized), accelerators (bandwidth optimized), etc.).Our goal is to show that we can manage the node complexity of these systems by using OpenMP for in-node parallelization by exploiting different “programming styles” supported by OpenMP 4.5 to program CPU cores and accelerators. Finding out the suitable programming-style (e.g., SPMD style, multi-level tasks, accelerator programming, nested parallelism, or a combination of these) using the latest features of OpenMP to maximize performance and achieve performance portability across heterogeneous and homogeneous systems is still an open research problem.We developed a mini-application, Kronecker Product (KP), from the original DMRG++ application (sparse matrix algebra) computational motif to experiment with different OpenMP programming styles on an OpenPOWER architecture and present their results in this paper.

Chatterjee, Ronnie↗

Optimization of Condensed Matter Physics Application with OpenMP Tasking Model

The Density Matrix Renormalization Group (DMRG++) is a condensed matter physics application used to study superconductivity properties of materials. It’s main computations consist of calculating hamiltonian matrix which requires sparse matrix-vector multiplications. This paper presents task-based parallelization and optimization strategies of the Hamiltonian algorithm. The algorithm is implemented as a mini-application in C++ and parallelized with OpenMP. The optimization leverages tasking features, such as dependencies or priorities included in the OpenMP standard 4.5. The code refactoring targets performance as much as programmability. The optimized version achieves a speedup of 8.0× with 8 threads and 20.5× with 40 threads on a Power9 computing node while reducing the memory consumption to 90 MB with respect to the original code, by adding less than ten OpenMP directives.

Criado, Joel↗

Roofline model toolkit: A practical tool for architectural and program analysis

We present preliminary results of the Roofline Toolkit for multicore, many core, and accelerated architectures. This paper focuses on the processor architecture characterization engine, a collection of portable instrumented micro benchmarks implemented with Message Passing Interface (MPI), and OpenMP used to express thread-level parallelism. These benchmarks are specialized to quantify the behavior of different architectural features. Compared to previous work on performance characterization, these microbenchmarks focus on capturing the performance of each level of the memory hierarchy, along with thread-level parallelism, instruction-level parallelism and explicit SIMD parallelism, measured in the context of the compilers and run-time environments. We also measure sustained PCIe throughput with four GPU memory managed mechanisms. By combining results from the architecture characterization with the Roofline model based solely on architectural specifications, this work offers insights for performance prediction of current and future architectures and their software systems. To that end, we instrument three applications and plot their resultant performance on the corresponding Roofline model when run on a Blue Gene/Q architecture.

97 MATHEMATICS AND COMPUTING↗

Comparative Performance Analysis of Coarse Solvers for Algebraic Multigrid on Multicore and Manycore Architectures

In this paper, we study the performance of a two-level algebraic-multigrid algorithm, with a focus on the impact of the coarse-grid solver on performance. We consider two algorithms for solving the coarse-space systems: the preconditioned conjugate gradient method and a new robust HSS-embedded low-rank sparse-factorization algorithm. Our test data comes from the SPE Comparative Solution Project for oil-reservoir simulations. We contrast the performance of our code on one 12-core socket of a Cray XC30 machine with performance on a 60-core Intel Xeon Phi coprocessor. To obtain top performance, we optimized the code to take full advantage of fine-grained parallelism and made it thread-friendly for high thread count. We also developed a bounds-and-bottlenecks performance model of the solver which we used to guide us through the optimization effort, and also carried out performance tuning in the solver’s large parameter space. Finally, as a result, significant speedups were obtained on both machines.

97 MATHEMATICS AND COMPUTING↗

GraphTango: A Hybrid Representation Format for Efficient Streaming Graph Updates and Analysis

Abstract Streaming graph processing performs batched updates and analytics on a time-evolving graph. The underlying representation format of the graph largely determines the throughputs of these updates and analytics phases. Existing representation formats usually employ variations of hash tables or adjacency lists. However, a recent study showed that the adjacency-list-based approaches perform poorly on heavy-tailed graphs, and the hash table-based approaches suffer on short-tailed graphs. We propose GraphTango, a hybrid representation format that provides excellent update and analytics throughput regardless of the graph’s degree distribution. GraphTango dynamically switches among three different formats based on a vertex’s degree: (i) Low-degree vertices store the edges directly with the neighborhood metadata, confining accesses to a single cache line, (2) Medium-degree vertices use adjacency lists, and (3) High-degree vertices use hash tables as well as adjacency lists. In this case, the adjacency list provides fast traversal during the analytics phase, while the hash table provides constant-time lookups during the update phase. We further optimized the performance by designing an open-addressing-based hash table that fully utilizes every fetched cache line. In addition, we developed a thread-local lock-free memory pool that allows fast growing/shrinking of the adjacency lists and hash tables in a multi-threaded environment. We evaluated GraphTango with the help of the SAGA-Bench framework and compared it with four other representation formats: Stinger, Degree-aware Robin Hood Hashing, and two adjacency list-based formats with different workload balancing scheme. On average, GraphTango provides 4.5x higher insertion throughput, 3.2x higher deletion throughput, and 1.1x higher analytics throughput over the next best format. Furthermore, we integrated GraphTango with the state-of-the-art graph processing frameworks DZiG and RisGraph. Compared to the vanilla DZiG and vanilla RisGraph , [ GraphTango + DZiG ] and [ GraphTango + RisGraph ] reduces the average batch processing time by 2.3x and 1.5x, respectively.

Ahmed, Alif↗

A Common Tracking Software Project

Abstract The reconstruction of the trajectories of charged particles, or track reconstruction, is a key computational challenge for particle and nuclear physics experiments. While the tuning of track reconstruction algorithms can depend strongly on details of the detector geometry, the algorithms currently in use by experiments share many common features. At the same time, the intense environment of the High-Luminosity LHC accelerator and other future experiments is expected to put even greater computational stress on track reconstruction software, motivating the development of more performant algorithms. We present here A Common Tracking Software (ACTS) toolkit, which draws on the experience with track reconstruction algorithms in the ATLAS experiment and presents them in an experiment-independent and framework-independent toolkit. It provides a set of high-level track reconstruction tools which are agnostic to the details of the detection technologies and magnetic field configuration and tested for strict thread-safety to support multi-threaded event processing. We discuss the conceptual design and technical implementation of ACTS, selected applications and performance of ACTS, and the lessons learned.

97 MATHEMATICS AND COMPUTING↗

High compressive energy absorption and shape recovery behavior of additively manufactured textile-inspired cylindrical braided metamaterials

Mechanical metamaterials (MMs) are engineered structures with unique mechanical properties that arise from their unique spatial arrangement or lattice-like structure. The most commonly designed MMs such as honeycomb and re-entrant auxetics are prone to failure at the sharp corners and weak joints due to the increased stress concentration under deformation. To mitigate this challenge, braided MM structures involving intertwining threads of nylon—forming curved unit cells—have been studied. These textile-inspired cylindrical braided metamaterials (CBMMs) with contrasting unit cells, namely diamond and regular CBMMs, were fabricated by 3D printing. The layer-by-layer deposited structure built by fused filament fabrication delivered an assembly of overlapped threads that are fused at the contact point. To understand deformation behavior of these MMs, finite element models were developed for various load scenarios including quasi-static compression, cyclic and creep loads at room temperature. Stress distribution, deformation mechanisms, and failure modes were analyzed and validated by experiments to analyze the geometries and associated performance. The diamond CBMMs showed stress softening at 30 % compressive strain, withstanding a load of ∼440 N, whereas the regular CBMMs at 50 % strain experienced ∼250 N. The diamond CBMMs delivered higher creep resistance under sustained load and better energy absorption under cyclic loading than the regular CBMMs. The latter, however, exhibited 94 % shape recovery in contrast to 88 % recovery in former prototype during their first cyclic load. In conclusion, this study helps design mechanical lightweight devices that endure significant sustained load and exhibit enhanced energy absorption and shape recovery characteristics in cyclic loading.

Creep↗

Effect of an in-situ thermal annealing on the structural properties of self-assembled GaSb/GaAs quantum dots

The effect of the application of a thermal annealing on the structural properties of GaSb/GaAs quantum dots (QDs) is analyzed by aberration corrected high-angle annular dark-field scanning transmission electron microscopy (HAADF-STEM) and electron energy loss spectroscopy (EELS). Our results show that the GaSb/GaAs QDs are more elongated after the annealing, and that the interfaces are less abrupt due to the Sb diffusion. We have also found a strong reduction in the misfit dislocation density with the annealing. The analysis by EELS of a threading dislocation has shown that the dislocation core is rich in Sb. In addition, the region of the GaAs substrate delimited by the threading dislocation is shown to be Sb-rich as well. An enhanced diffusion of Sb due to a mechanism assisted by the dislocation movement is discussed.

36 MATERIALS SCIENCE↗