Search

This paper presents HyperCODA, the hypersonics extension to the flow solver CODA (CFD for ONERA, DLR and Airbus). Similar to the spacecraft extensions of TAU, HyperCODA extends CODA for applications at high Mach numbers, including non-ideal gas thermodynamics, gas mixtures, and chemistry. The paper discusses simulations demonstrating numerical convergence and stability properties, as well as a supersonic rocket retropropulsion maneuver. Cross-code comparisons are made against the established DLR TAU code.

Aeroelasticity simulations increase in importance for aircraft design, requiring an efficient coupling of computational fluid dynamics (CFD) with computational structure mechanics (CSM) solvers. This contribution investigates the scalability of a high-fidelity CFD-CSM toolchain on modern high-performance computing (HPC) architectures. It consists of DLR's TAU solver for fluid dynamics simulations [1], and FlowSimulator [2] components for the incorporation of precomputed structural normal mode data, as well as for the underlying mesh deformations. The computational performance of the entire simulation pipeline is evaluated using a single measurement suite, allowing to identify bottlenecks of individual components and differences in their scalability. Preliminary improvements are realized via hybrid parallelization. Although this study focuses on a specific toolchain, key findings about scalability issues are relevant for complex CFD-CSM or other coupled simulations in general.

When writing parallel software for high performance computing, a common practice is to start from a sequential variant of a program that is consecutively enriched with parallelization directives. This process – progressive parallelization – has the advantage that, at every point in time, a correct version of the program exists. However, progressive parallelization leads to an entanglement of concerns, especially, if different variants of the same functional code have to be maintained and evolved concurrently. We propose orchestration style sheets (OSS) as a novel approach to separate parallelization concerns from problem-specific code by placing them in reusable style sheets, so that concerns for different platforms are always separated, and never lead to entanglement. A weaving process automatically generates platform-specific code for required target platforms, taking semantic properties of the source code into account. Based on a scientific-computing case study for fluid mechanics, we show that OSS are an adequate way to improve maintainability and reuse of Fortran code parallelized for several different platforms.

High-order methods gain more and more attention in computational fluid dynamics. Among these, spectral element methods and discontinuous Galerkin methods introduce element-wise approximations by means of a polynomial basis. This leads to a small number of operators consuming a large portion of the runtime of CFD applications. The present paper addresses tensor-product bases which are among the most frequent in these applications. Various implementations are developed and performance tests conducted for the interpolation operator, the Helmholtz operator, and the fast diagonalization operator. For each, up to 50% of the peak performance is attained, beating matrix-matrix multiplication for every polynomial degree relevant for simulations. This extremely high efficiency of the method developed is then demonstrated on a combustion problem with 1.72 · 109 mesh points.

International audience; Numerical simulations continue to enable fast and enormous progress in science and engineering. Writing efficient numerical codes is a difficult challenge that encompasses a variety of tasks from designing the right algorithms to exploiting the full potential of a platform's architecture. Domain-specific languages (DSLs) can ease these tasks by offering the right abstractions for expressing numerical problems. With the aid of domain knowledge, efficient code can then be generated automatically from abstract expressions. In this work, we present the CFDlang DSL for expressing tensor operations that constitute the performance-critical code sections in a class of real numerical applications from fluid dynamics. We demonstrate that CFDlang can be used to generate code automatically that performs as well, if not better, than carefully hand-optimized code.

High-order methods gain increased attention in computational fluid dynamics. However, due to the time step restrictions arising from the semi-implicit time stepping for the incompressible case, the potential advantage of these methods depends critically on efficient elliptic solvers. Due to the operation counts of operators scaling with the polynomial degree p times the number of degrees of freedom n DOF , the runtime of the best available multigrid solvers scales with O ( p ⋅ n DOF ) . This scaling with p significantly lowers the applicability of high-order methods to high orders. While the operators for residual evaluation can be linearized when using static condensation, Schwarz -type smoothers require their inverses on fixed subdomains. No explicit inverse is known in the condensed case and matrix-matrix multiplications scale with p ⋅ n DOF . This paper derives a matrix-free explicit inverse for the static condensed operator in a cuboidal, Cartesian subdomain. It scales with p 3 per element, i.e. n DOF globally, and allows for a linearly scaling additive Schwarz smoother, yielding a p-multigrid cycle with an operation count of O ( n DOF ) . The resulting solver uses fewer than four iterations for all polynomial degrees to reduce the residual by ten orders and has a runtime scaling linearly with n DOF for polynomial degrees at least up to 48. Furthermore the runtime is less than one microsecond per unknown over wide parameter ranges when using one core of a CPU, leading to time-stepping for the incompressible Navier-Stokes equations using as much time for explicitly treated convection terms as for the elliptic solvers.

This paper investigates static load balancing models for CPU-GPU coupling from a computational fluid dynamics perspective. While able to generate a benefit, traditional load balancing models are found to be too inaccurate to predict the runtime of a preconditioned conjugate gradient solver. Hence, an expanded model is derived that accounts for the multi-step nature of the solver, i.e. several communication barriers per iteration. It is able to predict the runtime to a margin of 5%, rendering CPU-GPU coupling better predictable so that load balancing can be improved substantially.

The prospect of wildly heterogeneous computer systems has led to a renewed discussion of programming approaches in high-performance computing, of which computational fluid dynamics is a major field. The challenge consists in harvesting the performance of all available hardware components while retaining good programmability. In particular the use of graphic cards is an important trend. This is addressed in the present paper by devising a hybrid programming model to create a heterogeneous data-parallel computation with a single source code. The concept is demonstrated for a one-dimensional spectral-element discretization of a fluid dynamics problem. To exploit the additional hardware available when coupling GPGPU-accelerated processes with excess CPU cores, a straight-forward load balancing model for such heterogeneous environments is developed. The paper presents a large number of run time measurements and demonstrates that the achieved performance gains are close to optimal. This provides valuable information for the implementation of fluid dynamics codes on modern heterogeneous hardware.

International audience; Many numerical algorithms are naturally expressed as operations on tensors (i.e. multi-dimensional arrays). Hence, tensor expressions occur in a wide range of application domains , e.g. quantum chemistry and physics; big data analysis and machine learning; and computational fluid dynamics. Each domain, typically, has developed its own strategies for efficiently generating optimized code, supported by tools such as domain-specific languages, compilers, and libraries. However, strategies and tools are rarely portable between domains, and generic solutions typically act as " black boxes " that offer little control over code generation and optimization. As a consequence, there are application domains without adequate support for easily generating optimized code, e.g. computational fluid dynamics. In this paper we propose a generic and easily extensible intermediate language for expressing tensor computations and code transformations in a modular and generative fashion. Beyond being an intermediate language, our solution also offers meta-programming capabilities for experts in code optimization. While applications from the domain of computational fluid dynamics serve to illustrate our proposed solution, we believe that our general approach can help unify research in tensor optimizations and make solutions more portable between domains.

Plenty of novel emerging technologies are being proposed and evaluated today, mostly at the device and circuit levels. It is unclear what the impact of different new technologies at the system level will be. What is clear, however, is that new technologies will make their way into systems and will increase the already high complexity of heterogeneous parallel computing platforms, making it ever so difficult to program them. This paper discusses a programming stack for heterogeneous systems that combines and adapts well-understood principles from different areas, including capability-based operating systems, adaptive application runtimes, dataflow programming models, and model checking. We argue why we think that these principles built into the stack and the interfaces among the layers will also be applicable to future systems that integrate heterogeneous technologies. The programming stack is evaluated on a tiled heterogeneous multicore.

High-order methods gain more and more attention in computational fluid dynamics. However, the potential advantage of these methods depends critically on the availability of efficient elliptic solvers. With spectral-element methods, static condensation is a common approach to reduce the number of degree of freedoms and to improve the condition of the algebraic equations. The resulting system is block-structured and the face-based operator well suited for matrix-matrix multiplications. However, a straight-forward implementation scales super-linearly with the number of unknowns and, therefore, prohibits the application to high polynomial degrees. This paper proposes a novel factorization technique, which yields a linear operation count of just 13N multiplications, where N is the total number of unknowns. In comparison to previous work it saves a factor larger than 3 and clearly outpaces unfactored variants for all polynomial degrees. Using the new technique as a building block for a preconditioned conjugate gradient method resulted in a runtime scaling linearly with N for polynomial degrees $2 \leq p \leq 32$ . Moreover the solver proved remarkably robust for aspect ratios up to 128.

Current research in computational fluid dynamics focuses on higher-order methods. These possess a more extensive coupling between degrees of freedom, resulting in a larger runtime per degree of freedom compared to low-order methods. This work tries to tackle this issue by combining the static condensation method with tensor-product and sum factorization, leading to a well-scaling solver for the Helmholtz equation.

We propose a factorization technique for the Helmholtz operator of a static condensed, three-dimensional, cartesian spectral-element discretization, that yields linear complexity in the number of degrees of freedom. We then compare its performance to a reference implementation of the conventional, unfactorized approach. (© 2014 Wiley-VCH Verlag GmbH & Co. KGaA, Weinheim)