Tutorials & Courses

This course introduces the core features and syntax of C++, along with key principles, idioms, and best practices for professional software development. It is designed to help programmers write high-quality, maintainable code from the start.

Participants will learn how to develop robust, efficient, and mature C++ applications while avoiding common pitfalls. A basic understanding of programming in any language is assumed.

Additional information such as learning objectives, prerequisites, certification and more can be found on the course page.

Upcoming Events

Past Events

This advanced course focuses on software development using the C++ programming language. It emphasizes essential principles, concepts, idioms, and best practices that enable developers to write professional, high-quality code.

Participants will gain insight into key C++ paradigms object-oriented, functional, and generic programming and learn guidelines for developing robust, efficient, maintainable, and mature C++ applications.

Additional information such as learning objectives, prerequisites, certification and more can be found on the course page.

Upcoming Events

Past Events

By the end of the workshop, participants will understand the fundamental concepts and techniques for accelerating C++ code with CUDA. They will be able to write and compile code that runs on the GPU, optimize memory transfers between CPU and GPU, and leverage parallel algorithms to simplify adding GPU acceleration.

Additionally, participants will learn to implement custom parallel algorithms through CUDA kernels, utilize concurrent CUDA streams to overlap computation with memory operations, and identify the best opportunities to integrate CUDA acceleration into existing CPU-only applications.

Additional information is available on the Nvidia DLI course homepage and the NHR@FAU course homepage.

Upcoming Events

Past Events

By the end of this workshop, participants will have a solid grasp of the essential tools and techniques for GPU-accelerating C/C++ applications using CUDA. They will be able to write GPU-executable code, leverage data parallelism, optimize memory transfers with asynchronous prefetching, and use both command-line and visual profilers to guide performance tuning. Additionally, they will know how to employ concurrent streams to increase parallelism and apply a profile-driven approach to develop or refactor CUDA applications for maximum performance.

Until March 2025, this course was offered as an official NVIDIA Deep Learning Institute (DLI) program. Its successor, Fundamentals of Accelerated Computing with Modern CUDA C++, is also offered by NHR@FAU. Due to the original course’s popularity, we continue to offer a custom, updated version that builds upon the original material.

Additional information is available on the Nvidia DLI course homepage and the NHR@FAU course homepage.

Upcoming Events

Past Events

By the end of this workshop, participants will be proficient in the core tools and techniques for GPU-accelerating Python applications using CUDA and Numba. They will learn how to accelerate NumPy ufuncs on the GPU, configure parallel execution using CUDA’s thread hierarchy, implement custom device kernels for greater performance and flexibility, and optimize memory access through coalescing and shared memory to enhance kernel efficiency.

Additional information is available on the Nvidia DLI course homepage and the NHR@FAU course homepage.

Upcoming Events

Past Events

By the end of this workshop, participants will have a foundational understanding of OpenACC, a high-level programming model for parallel computing on CPUs and GPUs. The workshop covers profiling and optimizing applications to identify performance hotspots, using OpenACC directives to offload computations to the GPU, and improving data movement between the CPU and GPU to maximize efficiency.

Additional information is available on the Nvidia DLI course homepage and the NHR@FAU course homepage.

Upcoming Events

Past Events

This advanced course explores techniques for extending single-GPU applications to utilize multiple GPUs within a single compute node. It focuses on distributing workloads across multiple accelerators, optimizing performance through overlapping computation and data transfers, and using NVIDIA Nsight Systems to analyze execution behavior and identify performance bottlenecks.

Additional information is available on the Nvidia DLI course homepage and the NHR@FAU course homepage.

Upcoming Events

Past Events

This advanced course covers multi-node programming techniques for GPU-accelerated applications and examines advanced examples, with a special emphasis on using MPI and NVSHMEM to distribute workloads efficiently.

Additional information is available on the Nvidia DLI course homepage and the NHR@FAU course homepage.

Upcoming Events

Past Events

Porting code to the GPU can yield significant speedups but often presents challenges. This advanced course introduces NVIDIA’s profiling tools to identify common performance issues during the porting process. Performance analysis is guided by straightforward, resource-based models that help developers evaluate how close their code is to the optimal performance target.

The course was previously called Performance Analysis on GPUs with NVIDIA Tools and has undergone restructuring and extension at the beginning of 2025. We offer a comprehensive GPU Performance Engineering course, along with a condensed GPU Performance Analysis module that can be incorporated into larger events.

Additional information such as learning objectives, prerequisites, certification and more can be found on the course page.

Upcoming Events

Past Events

This workshop series bundles three of our most popular GPU programming courses: Fundamentals of Accelerated Computing with CUDA C/C++, Accelerating CUDA C++ Applications with Multiple GPUs, and Scaling CUDA C++ Applications to Multiple Nodes. Their delivery is augmented with additional material connecting the individual courses, their key concepts, and the overall workflow of GPU-accelerated applications.

Please register for each part you want to attend separately.

Additional information such as learning objectives, prerequisites, certification and more can be found on the course page.

Upcoming Events

Past Events

This course provides an overview of the most common GPU programming approaches, including CUDA/ HIP, SYCL, modern C++, Thrust, OpenACC, OpenMP and Kokkos. It helps participants understand the strengths and weaknesses of each approach, enabling them to make informed decisions about which one to use for their specific applications.

Participants will get the most out of this course if they have already have prior experience in at least one GPU programming approach, but participation without any prior knowledge is also possible.

Additional information such as learning objectives, prerequisites, certification and more can be found on the course page.

Upcoming Events

This long-standing course is a collaboration between the Erlangen National High Performance Computing Center (NHR@FAU) and the Leibniz Supercomputing Center (LRZ). It is designed for students and researchers interested in programming modern HPC hardware, with a focus on large-scale parallel computing systems available in Jülich, Stuttgart, and Munich, as well as smaller clusters at Tier-2/3 centers and departmental facilities.

Additional information such as learning objectives, prerequisites, certification and more can be found on the course page.

Upcoming Events

Past Events

This course provides an introduction to the Message Passing Interface (MPI), the dominant distributed-memory programming paradigm in High Performance Computing.

Upcoming Events

Past Events

OpenMP is a widely supported standard for parallelizing shared-memory C/C++ and Fortran applications. It offers a simple, low-barrier entry to thread-based parallelization. This course introduces the fundamental concepts and constructs of OpenMP, as well as advanced topics like tasking and accelerator offloading.

Additional information such as learning objectives, prerequisites, certification and more can be found on the course page.

Upcoming Events

Past Events

Most HPC systems consist of clusters of shared-memory nodes. Efficient use of such systems requires optimizing both memory consumption and communication time. Hybrid programming combines distributed-memory parallelization across nodes (e.g., using MPI) with shared-memory parallelization within each node (e.g., using OpenMP or MPI-3.0 shared memory).

This course examines the strengths and weaknesses of various parallel programming models on clusters of shared-memory nodes, with special focus on multi-socket, multi-core systems in highly parallel environments. MPI-3.0 introduces a shared memory programming interface that complements inter-node MPI communication. This interface supports direct neighbor accesses, similar to OpenMP, and enables direct halo copies, paving the way for innovative hybrid programming models. These models are compared against hybrid MPI+OpenMP approaches and pure MPI implementations. Additionally, the course covers MPI+OpenMP offloading with GPUs. Through numerous case studies and micro-benchmarks, the course highlights performance aspects of hybrid programming. Hands-on sessions are included daily. Tools for hybrid programming such as thread and process placement support and performance analysis are demonstrated in practical “how-to” sections.

This course is a joint training event of EuroCC@GCS and EuroCC-Austria, the German and Austrian National Competence Centres for High-Performance Computing. It is organized by the HLRS in cooperation with the VSC Research Center at TU Wien and NHR@FAU.

Additional information such as learning objectives, prerequisites, certification and more can be found on the course page.

Upcoming Events

Past Events

This course covers performance engineering approaches on the CPU core level. While many developers put a lot of effort into optimizing parallelism, they often lose track of the importance of an efficient serial code first. Even worse, slow serial code tends to scale very well, hiding the fact that resources are wasted. This course conveys a thorough understanding of the interactions between software and hardware on the level of a single CPU core and the lowest memory hierarchy level, the L1 cache. It covers general computer architecture for x86 and ARM processors, an introduction to (AT&T and AArch64) assembly code, and performance analysis and engineering using the Open Source Architecture Code Analyzer (OSACA) tool in combination with the Compiler Explorer.

Additional information such as learning objectives, prerequisites, certification and more can be found on the course page.

Upcoming Events

Past Events

This course covers performance engineering approaches on the compute node level. Even application developers who are fluent in OpenMP and MPI often lack a good grasp of how much performance could at best be achieved by their code. This is because parallelism takes us only half the way to good performance. Even worse, slow serial code tends to scale very well, hiding the fact that resources are wasted. This course conveys the required knowledge to develop a thorough understanding of the interactions between software and hardware. This process must start at the core, socket, and node level, where the code gets executed that does the actual computational work. We introduce the basic architectural features and bottlenecks of modern processors and compute nodes. Pipelining, SIMD, superscalarity, caches, memory interfaces, ccNUMA, etc., are covered. A cornerstone of node-level performance analysis is the Roofline model, which is introduced in due detail and applied to various examples from computational science. We also show how simple software tools can be used to acquire knowledge about the system, run code in a reproducible way, and validate hypotheses about resource consumption. Finally, once the architectural requirements of a code are understood and correlated with performance measurements, the potential benefit of code changes can often be predicted, replacing hope-for-the-best optimizations by a scientific process.

Additional information such as learning objectives, prerequisites, certification and more can be found on the course page.

Upcoming Events

Past Events

This tutorial covers code analysis, performance modeling, and optimization for linear solvers on CPU and GPU nodes. Performance Engineering is often taught using simple loops as instructive examples for performance models and how they can guide optimization; however, full, preconditioned linear solvers comprise multiple back-to-back loops enclosed in an iteration scheme that is executed until convergence is achieved. Consequently, the concept of “optimal performance” has to account for both hardware resource efficiency and iterative solver convergence. We convey a performance engineering process that is geared towards linear iterative solvers. After introducing basic notions of hardware organization and storage for dense and sparse data structures, we show how the Roofline performance model can be applied to such solvers in predictive and diagnostic ways and how it can be used to assess the hardware efficiency of a solver, covering important corner cases such as pure memory boundedness. Then we advance to the structure of preconditioned solvers, using the Conjugate Gradient Method (CG) algorithm as a leading example. Hotspots and bottlenecks of the complete solver are identified followed by the introduction of advanced performance optimization techniques like preconditioning and cache blocking.

Additional information such as learning objectives, prerequisites, certification and more can be found on the course page.

Past Events

LIKWID stands for “Like I Knew What I’m Doing.” It is an easy to use yet powerful command line performance tool suite for the GNU/Linux operating system. While the focus of LIKWID is on x86 processors, some of the tools are portable and not limited to any specific architecture. For the upcoming release, LIKWID has been ported to ARMv7/v8 and POWER8/9 architectures as well as for Nvidia GPU co-processors.

Additional information such as learning objectives, prerequisites, certification and more can be found on the course page.

Upcoming Events

Past Events

This course covers an introduction into the molecular dynamics engine GROMACS, including fundamental commands and applications. Over five days, the participants will learn how to prepare and run simulations of biomolecular systems (e.g. including membranes and proteins) at an atomistic and coarse-grained level of resolution. Post-processing and analysis of simulation trajectories are a large part of the tutorial.

The course is usually embedded in the Bachelor programs of Biology and Integrated Life Sciences. There are five places available for people from NHR. The course will be held in person and takes place in the CIP of the Biology Department.

Interested candidates should send a short note about their background and motivation to rainer.boeckmann@fau.de.

Upcoming Events

Past Events

This course provides a short introduction to the AMBER molecular dynamics simulation suite: General workflow, system setup, simulation on NHR@FAU cluster systems (incl. GPU acceleration), and common analysis tasks on NHR@FAU systems including GPU-accelerated HPC. The following topics are covered:

1. System Setup: Model building (structure, protonation states, choice of force field/parameters), solvation + simulation box, constraints, minimisation/relaxation

2. Simulation: heating, equilibration, production run; 3. Analysis: Imaging, RMSD and fluctuations, time series of quantities (e.g. distances), probabilities (hydrogen bonds)

Upcoming Events

This workshop organized by VI-HPS and Erlangen National High Performance Computing Center will give an overview of the VI-HPS programming tools suite, explain the functionality of individual tools, and how to use them effectively and offer hands-on experience and expert assistance using the tools.

On completion participants should be familiar with common performance analysis and diagnosis techniques and how they can be employed in practice (on a range of HPC systems). Those who prepared their own application test cases will have been coached in the tuning of their measurement and analysis, and provided optimization suggestions.

Past Events

Past Events

The Python programming language has become very popular in scientific computing for various reasons. Users not only implement prototypes for numerical experiments on small scales, but also develop parallel production codes, thereby partly replacing compiled languages such as C, C++, and Fortran. However, when following this approach it is crucial to pay special attention to performance. This course teaches approaches to use Python efficiently and reasonably in a HPC environment. The first lecture gives a whirlwind tour through the Python programming language and the standard library. In the following, the lectures strongly focus on performance-related topics such as NumPy, Cython, Numba, compiled C- and Fortran extensions, profiling of Python and compiled code, parallelism using multiprocessing and mpi4py, parallel frameworks such as Dask, and efficient IO with HDF5. In addition, we will cover topics more related to software-engineering such as packaging, publishing, testing, and the semi-automated generation of documentation. Finally, basic visualization tasks using matplotlib and similar packages are discussed.

Past Events