In-situ, steerable, hardware-independent and data-structure agnostic visualization with ISAAC

We showcase the C++ template library ISAAC [1,2] for in-situ visualization of simulations or other high rate data sources running distributed on modern HPC systems. As most in-situ visualization solutions suffer from the problem that the simulation data needs to be converted to visualization specific data structures, ISAAC implements a data structure agnostic raycasting algorithm using C++ templates and C++ meta programming. With this ISAAC is not only able to visualize nearly arbitrary simulation data without the need of deep copying or converting it beforehand, but is also capable to use the very same computation device as the simulation itself.

Using the same computation device as the simulation usually limits the scope of usable hardware as modern many-core devices require programming models optimized for the specific hardware, e.g. CUDA for NVIDIA devices, to achieve optimum performance. In order to circumvent this problem ISAAC is based on the abstract kernel interface library Alpaka [3,4], which defines a redundant parallel hierarchy model for many-core architectures that serves as a front end to underlying models such as CUDA, OpenMP or Thread Building Blocks. With this, the ISAAC software renderer can run in-situ on almost every platform currently available.

Not all simulation data is perfectly suited for direct visualization but sometimes requires transformation. ISAAC thus introduces so called Functor Chains, which are very simple precompiled, but at runtime selectable, functions used for local domain transformations of the original simulation data performed before the data is streamed to the raycasting algorithm.

ISAAC is capable of scaling up to Petascale systems using the IceT library. It is not intended for highly specialized visualization but instead renders the classical representation as glowing gas or as iso surfaces. Aside from the obligatory transfer functions for the classification ISAAC also supports an arbitrary amount of random clipping planes useful for a deeper look into the simulated volumes.

ISAAC includes an interface for simulations to send arbitrary live meta data with the live preview and to receive live steering data. The whole communication layer of ISAAC is intentionally based only on open and widely used standards such as Websockets, RTP Streams and especially the open-standard format JSON.

ISAAC provides a server running on the head or login node of the HPC system, which creates the video streams from the visualization and forwards them together with the meta data to a freely selectable number of clients. The video stream created by the server can be received from arbitrary clients such as VLC or even streaming platforms like Twitch. Furthermore, each client can steer the simulations. ISAAC itself introduces a platform-independent HTML5 client, which can be adjusted to the needs of specific simulations easily.

Since every part of ISAAC is open source and makes use of the openly documented JSON communication protocol, it is easily possible to implement new clients or to extend the visualization core itself for simulation-specific features. ISAAC is designed to be as language-, framework-, data-format- and platform-agnostic as possible.

In order to demonstrate the real time capabilities of ISAA we will showcase a live visualization of the GPU-accelerated plasma simulation PIConGPU [5,6]. We show that we can achieve more than ten frames per seconds using 64 GPUs on the Hypnos cluster at Helmholtz-Zentrum Dresden – Rossendorf running both the simulation and visualization simultaneously.

[1] A. Matthes, In-situ Visualisierung und Streaming von Plasmasimulationsdaten, Technical University Dresden (2016)
[2] https://github.com/ComputationalRadiationPhysics/isaac
[3] E. Zenker et al., Alpaka - An Abstraction Library for Parallel Kernel Acceleration, http://arxiv.org/abs/1602.08477 (2016)
[4] https://github.com/ComputationalRadiationPhysics/alpaka
[5] M. Bussmann et al., Radiative Signatures of the Relativistic Kelvin-Helmholtz Instability, Proceedings of the International Conference on High Performance Computing, Networking, Storage and Analysis, SC'15, 5, 1 (2013)
[6] https://github.com/ComputationalRadiationPhysics/picongpu