Search

We demonstrate live-updating ptychographic reconstruction with ePIE, an iterative ptychography method, during ongoing data acquisition. The reconstruction starts with a small subset of the total data, and as the acquisition proceeds the data used for reconstruction is extended. This creates a live-updating view of object and illumination that allows monitoring the ongoing experiment and adjusting parameters with quick turn-around. This is particularly advantageous for long-running acquisitions. We show that such a gradual reconstruction yields interpretable results already with a small subset of the data. We show simulated live processing with various scan patterns, parallelized reconstruction, and real-world live processing at the hard X-ray ptychographic nanoanalytical microscope PtyNAMi at the PETRA III beamline.

Scanning coherent X-ray microscopy (ptychography) has gained considerable interest during the last decade since the performance of this indirect imaging technique does not necessarily rely on the quality of the X-ray optics and, in principle, can achieve highest spatial resolution in X-ray imaging. The method can be easily extended to 3D by adding standard tomographic reconstruction schemes. However, the tomographic reconstruction is often applied in a subsequent step using a sequence of aligned ptychographic 2D projections. In this contribution, we outline current developments of a GPU-accelerated framework for direct 3D ptychography, coupling 2D ptychography and tomography. The program utilizes a custom GPU-accelerated framework for ptychography that offers three distinct ptychographic reconstruction algorithms. The tomographic reconstruction runs simultaneously and uses numerical routines of the ASTRA Toolbox. This parallel-computing approach results in a high performance increase considerably reducing the reconstruction time of 3D ptychographic datasets.

In high-energy physics, we want to simulate complex physical processes that require computational resources of the fastest HPC systems in the world. In order to fully use the computational resources, software that is maintainable, performant and extensible is required. To achieve these goals, automated testing is essential. Modern Julia HEP software is modularized into sub-packages to improve maintainability and extensibility. This creates new challenges for automated testing. Unit tests and integration tests are required. If the code of one package is changed, unit tests ensure that the package is still working, whereas integration tests ensure that in dependent packages no functionality break is caused by the change. Using the QED.jl [1] project as an example, I will demonstrate how we implemented unit and integration tests for the main QED.jl package and its sub-packages. [1] https://github.com/QEDjl-project/QED.jl

The alpaka library is a header-only C++17 abstraction library for accelerator development. Its aim is to provide performance portability across accelerators through the abstraction (not hiding!) of the underlying levels of parallelism.

The inventors of the Julia programming language proclaim, that one can use high-level syntax to solve demanding numerical tasks. In order to evaluate this claim, we present possible applications of Julia by using it for the implementation of our Monte-Carlo event generator for laser-matter interaction. Especially the possible deployment of modern GPUs for demanding computing tasks during several stages of the event generation is discussed. In order to elaborate on these GPU capabilities, we show benchmarks of Julia's main programming interface for NVIDIA CUDA GPUs, namely `CUDA.jl`, and compare them with native CUDA-C++ implementations. Finally, Julia's capabilities for high-level abstraction for computations on heterogenous architectures are discussed and compared to low-level solutions like the `alpaka` library for C++.

The description of scattering processes in high-energy physics is usually done with Feynman Diagrams. The number of Feynman Diagrams that can be generated for a given process explodes factorially with the number of particles. We discuss a possible approach enabling the calculation of higher-multiplicity scattering processes. We propose representing the calculation for a process as a directed acyclic graph (DAG) of small computation tasks. Using Julia, we can optimize this graph using subgraph replacement strategies together with an optimization algorithm. Finally, efficient code targeting arbitrary heterogeneous HPC systems can be generated from the optimized DAG.

The alpaka library is a header-only C++17 abstraction library for development across hardware accelerators (CPUs, GPUs, FPGAs). Its aim is to provide performance portability across accelerators through the abstraction (not hiding!) of the underlying levels of parallelism. In this talk we will show the concepts behind alpaka, how it is mapped to the various underlying hardware models, and show the features introduced over the last year. In addition, we will also (shortly) present the software ecosystem surrounding alpaka.

Ptychography is a computational imaging method used to numerically retrieve the projection of an object from a set of measured diffraction patterns. Each diffraction pattern represents a partially overlapping area of the object. The corresponding inverse problem, i.e. the image reconstruction, can be solved by projection-based or gradient-based algorithms. However, existing implementations are usually optimized for a specific system and therefore difficult to port to new systems. To solve this problem, we will be introducing the alpaka library with a generic C++ interface to implement an algorithm one time and execute it on different target platforms, like CPUs and GPUs from different vendors. First, we ported an existing algorithm, implemented in CUDA C++, to alpaka to demonstrate the workflow and advantages. Then, we implemented another algorithm from scratch to obtain the software requirements for an easy and fast development cycle of alpaka based image reconstruction applications.

The alpaka library is a header-only C++17 abstraction library for accelerator development. Its aim is to provide performance portability across accelerators through the abstraction (not hiding!) of the underlying levels of parallelism.

The alpaka library is a header-only C++14 abstraction library for accelerator development. Its aim is to provide performance portability across accelerators through the abstraction (not hiding!) of the underlying levels of parallelism.

Jupyter Notebooks are omnipresent in the modern scientist's and engineer's toolbox just as CUDA C++ is in accelerated computing. We present the first implementation of a CUDA C++ enabled read-eval-print-loop (REPL) that allows to interactively "script" the popular CUDA C++ runtime syntax in Notebooks. With our novel implementation, based on LLVM, Clang and CERN's C++ interpreter Cling, the modern CUDA C++ developer can work as interactively and productively as (I)Python developers while keeping all the benefits of the vast C++ computing and library ecosystem coupled with first-class performance.

Alpaka (Abstraction Library for Parallel Kernel Acceleration) provides a library and tools for programming compute accelerators on a device agnostic level. This online tutorial will give an introduction to Alpaka combined with online exercises.

PIConGPU is an open source, multi-platform particle-in-cell code scaling to the fastest supercomputers in the TOP500 list. We present the architecture, novel developments, and workflows that enable high-precision, fast turn-around computations on Exascale-machines. Furthermore, we present our strategies to handle extreme data flows from thousands of GPUs for analysis with in situ processing and open data formats (openPMD). PIConGPU is since recently furthermore natively controlled by a Python Jupyter interface and we research just-in-time kernel generation for C++ with our Cling-CUDA extensions.

Dockerfiles which provide environments for building and running Cupla applications.

We are less than three years apart from the first, double precision Exa-Flop/s supercomputers. Already today, our scientific software stacks are facing the challenge to run efficiently on a potpourri of architectures. But the real troubles might await us at the choke points of extreme data rates, where traditional workflows of data acquisition, filtering, processing and subsequent long-term storage might not be able to be sustained anymore. How would you like to express your scientific algorithms in a world where Flop/s are increasingly cheap, yet hard to achieve, but data movement and especially data at rest is increasingly in-proportionally expensive? Would you be OK to throw data away and measure twice? Can we in situ compute results with a different prepared question instead of waiting for an always-full and quickly-purged filesystem? How do we ensure reproducibility? How large a mix of programming languages and double-implementations of algorithms can we burden before we are running out of developers (due to lack of maintainability)? This talk will present our vision for the next years of data-driven scientific computing. Based on our experience with single-source, performance-portable C++ HPC libraries, we will present zero-overhead C++ abstractions that spare code-duplication. Together with light-weight code coupling, possible directions for analyzing resulting data rates are discussed on examples from laser-driven particle accelerator research. With such meta-programming approaches, an underestimated risk lies in cutbacks for both development workflows and user interactivity at runtime, which we want to openly change with interactive Cling-assisted execution in modern environments such as Jupyter, for which we recently enabled CUDA C++ capabilities.