ARTSS

Accelerated Based Real Time Smoke Simulator

The evaluation of life safety in buildings in case of fire is often based on smoke spread calculations. Recent simulation models – in general, based on computational fluid dynamics (CFD) – often require long execution times even on high performance computing (HPC) systems. In the design phase of a building, the long execution time is not an issue.

In application scenarios, like steering of technical systems or educational purposes, where a real-time prediction is needed, these models can not be applied.

This is due to the fact, that the speedup of the calculation time is limited by the parallel performance of the processing unit. Therefore it is feasible to use a processing unit which is specialized in handling parallel tasks simultaneously. In terms of computer hardware the graphics processing unit (GPU) delivers the best parallel performance. However, simulation models must be adopted, in terms of algorithms and implementation, to GPUs in order to leverage their performance.

The objective of the ARTSS project is therefore to create a real-time CFD solver using the parallel performance of GPUs.

ARTSS is a CFD code simulating buoyancy-driven turbulent smoke spread based on finite differences and a large eddy simulation (LES) turbulence model. The open source code is portable on CPU and GPU and successfully verified using unit, analytical and semi-analytical tests.

Current efforts are to further validate ARTSS with experimental scenarios relevant for fire protection.

Figure 1: ARTSS speed streamlines in m/s of the flow around the cube in the x-y-plane z = 0 m (top) and in the x-z-plane at y = 0.01 m (bottom)

The code is written in the object-oriented programming language C++ and the pragma-based programming model OpenACC. ARTSS is based on JuROr, which was originally developed within the ORPHEUS project (funded by BMBF) by Dr. Anne Küsters.

Speedup Analysis

The performance indicator for ARTSS are the cell updates per second (CUPS)

$\textrm{CUPS} := \dfrac{\text{number of cells} \times \text{number of time steps}}{\text{runtime}}\text{.}$

Using a GPU as opposed to a reference architecture such as one or multiple CPU
cores leads to the following definition for the speedup

$\textrm{S} := \dfrac{t_{ref}}{t_{par}} = \dfrac{\text{CUPS}_{\text{par}}}{\text{CUPS}_{\text{ref}}}$

Figure 2 shows JuROr’s performance in MCUPS for the various resolutions comparing the serial (in light gray), multicore (in gray) and GPU-parallel versions (in black) on the Intel Xeon Broadwell E5-2623 v4 (BDW) and NVIDIA Pascal P100 (PCIe, 12 GB), respectively. The speedup of the GPU version is shown on top of the bars. For 2048x2048 inner cells, the speedup amounts 29x for the GPU-parallel compared to the serial CPU version.

Figure 2: McDermott (2003) test case: ARTSS's cell updates per second for various resolutions (2D) compared for BDW (serial and multicore) and P100 (GPU-parallel)

Articles

• Anne Severt. Real-Time Simulation and Prognosis of Smoke Propagation in Compartments Using a GPU. Dissertation, Bergische Universität Wuppertal, 2018
• My Linh Würzburger. Dynamic Domain Adaption for Smoke Simulation in JuROr. Masterarbeit, FH Aachen, 2019
• My Linh Würzburger. Untersuchung des Rot-Schwarz Gauß-Seidel-Verfahrens für Diffusionsprobleme bezüglich Parallelisierung auf einer GPU. Bachelorarbeit, FH Aachen, 2016.