Search

Navigation and service

Training course "Improving Software Performance - Parallel Programming" @ HLRS

begin
18.Sep.2018 09:00
end
10.Dec.2018
venue
HLRS Stuttgart

Parallel programming is considered a key to improving software performance. For code development on parallel systems, application programmers need not only a thorough understanding of parallel computing system architectures and programming models like MPI or OpenMP, but also the ability to implement directives, libraries, and important parallelization concepts efficiently.

The module "Parallel Programming" will provide such knowledge and skills. In addition to covering the theoretical foundations of parallelization, the course will include concrete programming exercies that offer the opportunity to gain a deeper understanding and practical expertise. The module is ideal for programmers and developers with experience in C, C++, or Fortran.

Module Contents

  • What is HPC?
  • Performance
  • Vectorization
  • Parallelization: thinking in parallel
  • Parallelizability of software, calculations, and requirements
  • OpenMP
  • Parallel programming models: introduction to MPI (C++, Fortran)
  • Parallel programming models: advanced MPI (C++, Fortran)
  • Parallel programming models: parallel I/O
  • Parallel programming models: hybrid programming - MPI + X
  • Other parallel programming models
  • Parallelization: scaling
  • Parallelization: domain decomposition and load balancing
  • Parallelization: parallel design patterns
  • Parallelization: parallel aspects of programming languages
  • Heterogeneous computing systems and graphic cards
  • Parallel numerical libraries
  • Parallelization strategies: deciding on a programming model

Flexible Learning

The module is conducted in a blended learning format, meaning that it combines self-learning phases and classroom instruction. This approach offers flexiblility in the time required to work through the course content, so that continuing education can take place in parallel with job and family responsibilities.

Self-directed learning is complemented with regular online meetings in a virtual classroom, which take place on Monday evenings.

Time Commitment

Each module requires a time commitment of approximately 125 hours over the span of 12-14 weeks. Course time is divided as follows:

  • 8 hours per week per module, including a weekly online meeting (Monday evenings)
  • 2 classes at HLRS in Stuttgart

Training course "Introduction to C" @ JSC

begin
03.Dec.2018 09:00
end
12.Dec.2018 16:30
venue
JSC, Jülich

An introduction to the programming language C is given. This language is often used in non-numeric data processing and is also suitable for programming tasks close to the system.

This course will be given in German.

Training course "CFD mit OpenFOAM®" @ LRZ

begin
14.Jan.2019 09:00
end
18.Jan.2019 17:00
venue
LRZ Garching

Topics of this course are:

  • Introduction to batch scripting and Linux basics for OpenFOAM® usage as well as overview of case structure.
  • Lectures on theory of meshing with introduction to basic mesh structure of OpenFOAM®.
  • Introduction to snappyHexMesh and cfMesh.
  • Introduction to the theory of the finite volume method. Lectures explain spatial and temporal discretization concepts including an introduction of boundary conditions. OpenFOAM® basic application solvers simpleFoam and pisoFoam are a further key aspect.
  • Swak4Foam for enhancing simulation work flows is introduced with different hands-on sessions. The second part highlights basic code structure of OpenFOAM® for installation and compilation.
  • Introduction and remarks to parallel simulation with MPI.
  • Introduction to turbo-machinery.

Training course "Simulation on High Performance Computers - Simulation" @ HLRS

begin
21.Jan.2019
end
12.Apr.2019
venue
HLRS Stuttgart

Electric cars, quieter airplanes, more efficient power plants — achieving many of today's technological goals is inconceivable without simulation. Fields in which such simulations are being applied are highly diverse, including the automobile industry, air and space travel, meteorology, wind energy and medicine, to name just a few.

High-performance computing (HPC) has opened the door for modern simulation and computational experimentation, and increasingly plays a decisive role in product development and design. Indeed, predicting the physical behavior of products is often so challenging that it can't be done without a supercomputer At the same time, however, running simulations on HPC systems is anything but trivial, and engineers using supercomputers face a number of complex challenges in doing so.

How should simulation processes be organized and and how can they be optimized in the context of high-performance computing? The module Simulation is designed to raise awareness of problems in designing simulations and to provide a basic understanding of the foundations of this methodology. The course will approach this goal from two perspectives: 1. Why should companies — particularly small and medium-sized enterprises (SMEs) — be using simulation? 2. How can high-performance computing help you when your simulations reach the limits of what is practical on smaller computing systems?

Module Contents

  • What is simulation?
  • The philosophy of simulation: from physical problem to model to result (the model cascade
  • Atomic simulations
  • Structural mechanics
  • CFD (computational fluid dynamics)
  • Statistical simulation (Monte Carlo simulation)
  • Optical simulations
  • Numerical methods
  • Simulation as a process
  • Recognizing errors
  • Deriving requirements from simulation experiments
  • Visualization

Flexible Learning

This course module is offered in a blended learning format, combining self-learning content and exercises with traditional classroom instruction. In this way you can structure your learning flexibly, balancing the time required for your continuing education with work and family responsibilities.

Self-learning components will be complemented by regular online meetings in a virtual classroom, which will take place on Monday evenings.

Time Requirement

The time requirement for each course module is approximately 125 hours, spread over 11 weeks. It consists of:

  • approximately 10 hours per module each week, including a weekly online meeting (Monday evenings)
  • two full-day classroom meetings in Stuttgart

PRACE training course "Introduction to hybrid programming in HPC" @ LRZ

begin
28.Jan.2019 09:30
end
29.Jan.2019 16:00
venue
LRZ Garching

Most HPC systems are clusters of shared memory nodes. Such SMP nodes can be small multi-core CPUs up to large many-core CPUs. Parallel programming may combine the distributed memory parallelization on the node interconnect (e.g., with MPI) with the shared memory parallelization inside of each node (e.g., with OpenMP or MPI-3.0 shared memory). This course analyzes the strengths and weaknesses of several parallel programming models on clusters of SMP nodes. Multi-socket-multi-core systems in highly parallel environments are given special consideration. MPI-3.0 has introduced a new shared memory programming interface, which can be combined with inter-node MPI communication. It can be used for direct neighbor accesses similar to OpenMP or for direct halo copies, and enables new hybrid programming models. These models are compared with various hybrid MPI+OpenMP approaches and pure MPI. Numerous case studies and micro-benchmarks demonstrate the performance-related aspects of hybrid programming.

Hands-on sessions are included on both days. Tools for hybrid programming such as thread/process placement support and performance analysis are presented in a "how-to" section. This course provides scientific training in Computational Science, and in addition, the scientific exchange of the participants among themselves. The course is a PRACE Training Center event. It is organized by LRZ in cooperation with HLRS and RRZE.

Training course "Parallel Programming with MPI, OpenMP, and Tools" @ ZIH, Dresden

begin
04.Feb.2019 08:30
end
08.Feb.2019 12:30
venue
ZIH Dresden

The focus is on programming models MPI and OpenMP. Hands-on sessions (in C and Fortran) will allow users to immediately test and understand the basic constructs of the Message Passing Interface (MPI) and the shared memory directives of OpenMP. The last part is dedicated to tools. This course provides scientific training in Computational Science, and in addition, the scientific exchange of the participants among themselves. It is organized by ZIH in collaboration with HLRS. (Content Level: 70% for beginners, 30% advanced)

Training course "Introduction to Computational Fluid Dynamics" @ ZIMT, Uni. Siegen

begin
18.Feb.2019 09:00
end
22.Feb.2019 16:00
venue
Universität Siegen, Adolf-Reichwein-Straße 2, 57076 Siegen, Building A, Room: AR-A1007

The course deals with current numerical methods for Computational Fluid Dynamics in the context of high performance computing. An emphasis is placed on explicit methods for compressible flows, but classical numerical methods for incompressible Navier-Stokes equations are also covered. A brief introduction to turbulence modelling is also provided by the course. Additional topics are high order numerical methods for the solution of systems of partial differential equations. The last day is dedicated to parallelization.

Hands-on sessions will manifest the contents of the lectures. In most of these sessions, the application Framework APES will be used. They cover grid generation using Seeder, visualization with ParaView and the usage of the parallel CFD solver Ateles on the local HPC system.

The course is organized by HLRS, IAG (University of Stuttgart) and STS, ZIMT (University of Siegen).

PRACE training course "Node-level performance engineering" @ LRZ

begin
20.Feb.2019 09:00
end
21.Feb.2019 17:00
venue
LRZ Garching

This course teaches performance engineering approaches on the compute node level. "Performance engineering" as we define it is more than employing tools to identify hotspots and bottlenecks. It is about developing 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. Once the architectural requirements of a code are understood and correlated with performance measurements, the potential benefit of optimizations can often be predicted. We introduce a "holistic" node-level performance engineering strategy, apply it to different algorithms from computational science, and also show how an awareness of the performance features of an application may lead to notable reductions in power consumption.

The course is a PRACE Advanced Training Center event.

PRACE training course "Parallel and Scalable Machine Learning" @ JSC

begin
25.Feb.2019 09:00
end
27.Feb.2019 16:30
venue
JSC, Jülich

The course offers basics of analyzing data with machine learning and data mining algorithms in order to understand foundations of learning from large quantities of data. This course is especially oriented towards beginners that have no previous knowledge of machine learning techniques. The course consists of general methods for data analysis in order to understand clustering, classification, and regression. This includes a thorough discussion of test datasets, training datasets, and validation datasets required to learn from data with a high accuracy. Easy application examples will foster the theoretical course elements that also will illustrate problems like overfitting followed by mechanisms such as validation and regularization that prevent such problems.

The tutorial will start from a very simple application example in order to teach foundations like the role of features in data, linear separability, or decision boundaries for machine learning models. In particular this course will point to key challenges in analyzing large quantities of data sets (aka ‘big data’) in order to motivate the use of parallel and scalable machine learning algorithms that will be used in the course. The course targets specific challenges in analyzing large quantities of datasets that cannot be analyzed with traditional serial methods provided by tools such as R, SAS, or Matlab. This includes several challenges as part of the machine learning algorithms, the distribution of data, or the process of performing validation. The course will introduce selected solutions to overcome these challenges using parallel and scalable computing techniques based on the Message Passing Interface (MPI) and OpenMP that run on massively parallel High Performance Computing (HPC) platforms. The course ends with a more recent machine learning method known as deep learning that emerged as a promising disruptive approach, allowing knowledge discovery from large datasets in an unprecedented effectiveness and efficiency.

This course is a PRACE training course.

Training course "Parallel Programming of High Performance Systems" @ LRZ

begin
25.Feb.2019 09:00
end
01.Mar.2019 18:00
venue
LRZ Garching

This course, a collaboration of Erlangen Regional Computing Centre (RRZE) and LRZ, is targeted at students and scientists with interest in programming modern HPC hardware, specifically the large scale parallel computing systems available in Jülich, Stuttgart and Munich.

Each day is comprised of approximately 4 hours of lectures and 3 hours of hands-on sessions.

Day 1

  • Introduction to High Performance Computing (Weinberg)
  • Programming Environment at LRZ, Secure shell (Weinberg)
  • Handling console and GUI based interfaces (Weinberg)
  • Source code versioning with SVN and git (Martone)
  • Building programs with GNU MAKE (N.N.)

Day 2

  • Basic parallel programming models: elements of MPI and OpenMP (Weinberg)
  • Guided Tour (Weinberg)
  • Processor architectures (Hager)

Day 3

  • Principles of code optimization: unrolling, blocking, dependencies, C++ issues, bandwidth issues, performance projections (Hager)
  • Advanced MPI programming (Afzal)

Day 4

  • Parallel architectures: multi-core, multi-socket, ccNUMA, cache coherence and affinity, tools for handling memory affinity (Hager)
  • Parallel algorithms: data parallelism, domain decomposition, task parallelism, master-worker, granularity, load balancing, scalability models (Hager)
  • Advanced OpenMP programming (Weinberg)
  • Intel tools: OpenMP performance and correctness (N.N.)
  • Social Event: Pizza and Talk "Fooling the masses" by G. Hager

Day 5

  • Basics of software engineering (Navarrete)
  • Performance analysis with Score-P and Scalasca (Navarrete)
  • Performance analysis tools: Intel APS and ITAC (Iapichino)
  • Performance analysis tools: Intel VTune Amplifier amd Advisor (Iapichino)

Training course "Programming with Fortran" @ LRZ

begin
06.Mar.2019 09:00
end
08.Mar.2019 18:00
venue
LRZ Garching

This three day course is targeted at scientists with little or no knowledge of the Fortran programming language, but need it for participation in projects using a Fortran code base, for development of their own codes, and for getting acquainted with additional tools like debugger and syntax checker as well as handling of compilers and libraries. The language is for the most part treated at the level of the Fortran 95 standard; features from Fortran 2003 are limited to improvements on the elementary level. Advanced Fortran features like object-oriented programming or coarrays will be covered in a follow-on course in autumn.

To consolidate the lecture material, each day's approximately 4 hours of lecture are complemented by 3 hours of hands-on sessions.

Note: Course participants should have basic UNIX/Linux knowledge (login with secure shell, shell commands, basic programming, vi or emacs editors).

Training course "Introduction to Python" @ JSC

begin
11.Mar.2019 08:30
end
13.Mar.2019 16:30
venue
JSC, Jülich

This course gives an introduction to the programming language Python. Topics are: data types, control structures, object-oriented programming, module usage. Additionally, Python's standard library and the GUI programming with wxWidgets will be explained.

This course is given in German.

Training course "CFD with OpenFOAM®" @ HLRS

begin
11.Mar.2019 08:30
end
15.Mar.2019 15:30
venue
HLRS Stuttgart

OpenFOAM® is a widely-used open-source code and a powerful framework for solving a variety of problems mainly in the field of CFD. The five-day workshop gives an introduction to OpenFOAM® applied on CFD phenomena and is intended for beginners as well as for people with CFD background knowledge. The user will learn about case setup, meshing tools like snappyHexMesh and cfMesh. Available OpenFOAM® utilities and additional libraries like swak4Foam, that can be used for pre- and postprocessing tasks, are further aspects of this course. Additionally, basic solvers and major aspects of code structure are highlighted. Lectures and hands-on session with typical CFD examples will guide through this course including first steps in own coding. This course provides scientific training in Computational Science, and in addition, the scientific exchange of the participants among themselves.

Training course "Introduction to ParaView for the visualization of scientific data" @ JSC

begin
14.Mar.2019 09:00
end
14.Mar.2019 16:30
venue
JSC, Jülich

This course is given in German.

ParaView ist eine auf dem Visualization Toolkit (VTK) basierende Open-Source Software,  mit der wissenschaftlich-technische Datensätze analysiert und visualisiert werden können. Unterstützt werden dabei alle gängigen Betriebssysteme (z.B. Windows, Linux, MAC OS X).  Da ParaView ein paralleles Konzept verfolgt, kann es außer auf einzelnen PCs, Laptops und Workstations auch in einem parallelen Modus auf Clustern und Supercomputern eingesetzt werden und eignet sich somit zur Visualisierung von sehr großen Datensätzen. Zudem ist ParaView in der Lage, Datensätze, die auf zentralen Daten- und  Visualisierungsservern abgespeichert sind, dort zu rendern und das erzeugte Bild auf der lokalen Workstation des Endnutzers anzuzeigen, ohne dass der eigentliche Datensatz zum Benutzer transferiert werden muss (remote rendering).

Im Kurs wird der Umgang mit ParaView anhand von Beispielen demonstriert.  Das Benutzerinterface wird erläutert, typische Eingabedatenformate werden behandelt und wichtige Visualisierungsmethoden vorgestellt. Ferner wird auf die Visualisierung von zeitabhängigen Daten, die Erstellung von Animationen und auf die parallele Version von ParaView eingegangen.

PRACE training course "Advanced Topics in High Performance Computing" @ LRZ

begin
18.Mar.2019 09:00
end
21.Mar.2019 17:00
venue
LRZ Garching

In this add-on course to the parallel programming course special topics are treated in more depth, in particular performance analysis, I/O and PGAS concepts. It is provided in collaboration of Erlangen Regional Computing Centre (RRZE) and LRZ within KONWIHR.

The course is a PRACE training event.

Each day is comprised of approximately 5 hours of lectures and 2 hours of hands-on sessions.

Day 1

  • Processor-Specific Optimization (Eitzinger)

Day 2

  • Parallel I/O with MPI IO (N.N.)
  • SuperMUC Tour (Weinberg)
  • Tuning I/O on LRZ's HPC systems / I/O Profiling: Darshan tool (Mendez)

Day 3

  • Scientific Data Libraries: HDF5 / Scalable I/O library: SIONlib (Mendez)
  • Advanced OpenMP Programming (Weinberg)

Day 4

  • PGAS programming with coarray Fortran and Unified Parallel C (Bader)

Prerequisites: Good MPI and OpenMP knowledge as presented in the course "Parallel programming of High Performance Systems".

Training course "Introduction to parallel programming with MPI and OpenMP" @ JSC

begin
18.Mar.2019 09:00
end
22.Mar.2019 16:30
venue
JSC, Jülich

An introduction to the parallel programming of supercomputers is given. The focus is on the usage of the Message Passing Interface (MPI), the most often used programming model for systems with distributed memory. Furthermore, OpenMP will be presented, which is often used on shared-memory architectures.

The first four days of the course consist of lectures and short exercises. An optional fifth day is devoted to demonstrating the use of MPI and OpenMP in a larger context. To this end, starting from a simple but representative serial algorithm, a parallel version will be designed and implemented using the techniques presented in the course.

Knowledge of either C, C++ or Fortran, basic knowledge of UNIX/Linux and a UNIX standard editor (e.g. vi, emacs) is a prerequisite.

Training course "Iterative Linear Solvers and Parallelization" @ HLRS

begin
25.Mar.2019 08:30
end
29.Mar.2019 15:30
venue
HLRS Stuttgart

The focus is on iterative and parallel solvers, the parallel programming models MPI and OpenMP, and the parallel middleware PETSc. Thereby, different modern Krylov Subspace Methods (CG, GMRES, BiCGSTAB ...) as well as highly efficient preconditioning techniques are presented in the context of real life applications. Hands-on sessions (in C and Fortran) will allow users to immediately test and understand the basic constructs of iterative solvers, the Message Passing Interface (MPI) and the shared memory directives of OpenMP. This course provides scientific training in Computational Science, and in addition, the scientific exchange of the participants among themselves. It is organized by HLRS, IAG, Uni. Kassel, and SFB/TRR30.

PRACE training course "Fortran for Scientific Computing" @ HLRS

begin
01.Apr.2019 08:30
end
05.Apr.2019 15:30
venue
HLRS Stuttgart

This course is dedicated to scientists and students to learn (sequential) programming with Fortran of scientific applications. The course teaches newest Fortran standards. Hands-on sessions will allow users to immediately test and understand the language constructs. This workshop provides scientific training in Computational Science, and in addition, the scientific exchange of the participants among themselves.

This course is a PRACE training course.

PRACE training course "GPU programming with CUDA" @ JSC

begin
01.Apr.2019 09:00
end
03.Apr.2019 16:30
venue
JSC, Jülich

GPU-accelerated computing drives current scientific research. Writing fast numeric algorithms for GPUs offers high application performance by offloading compute-intensive portions of the code to an NVIDIA GPU. The course will cover basic aspects of GPU architectures and programming. Focus is on the usage of the parallel programming language CUDA-C which allows maximum control of NVIDIA GPU hardware. Examples of increasing complexity will be used to demonstrate optimization and tuning of scientific applications.

Topics covered will include:

  • Introduction to GPU/Parallel computing
  • Programming model CUDA
  • GPU libraries like CuBLAS and CuFFT
  • Tools for debugging and profiling
  • Performance optimizations

This course is a PRACE training course.

Training course "Parallelization with MPI and OpenMP" @ CSC, Goethe University Frankfurt

begin
08.Apr.2019 08:30
end
10.Apr.2019 18:00
venue
Goethe University of Frankfurt, Uni Campus Riedberg, Beistein Computer Centre

The focus is on the programming models MPI and OpenMP. Hands-on sessions (in C and Fortran) will allow users to immediately test and understand the basic constructs of the Message Passing Interface (MPI) and the shared memory directives of OpenMP. This course is organized by HKHLR and CSC, Goethe University Frankfurt in collaboration with HLRS. (Content Level: 70% for beginners, 30% advanced)

Training course "Introduction to ANSYS Fluid Dynamics (CFX, Fluent) on LRZ HPC Systems" @ LRZ

begin
08.Apr.2019 09:00
end
12.Apr.2019 17:00
venue
LRZ Garching

The focus of this 5-day course is targeted on researchers with good knowledge in the fundamentals of fluid mechanics and potentially with some first experience in Computational Fluid Dynamics (CFD). The course will focus on the introduction to the ANSYS Fluid Dynamics software packages, i.e. ANSYS CFX and ANSYS Fluent. Further, participants will be familiarized with the main steps of the typical CFD workflow, in particular with CFD preprocessing/ CFD setup creation, serial and parallel solver execution and CFD postprocessing in both CFD solver systems CFX and Fluent. Correctness of boundary conditions and CFD setup specifications, solver convergence control, solver monitoring, customization capabilities of the solvers and the post­pro­cessing as well as recommended CFD best practices are covered.

The course further focusses on the usage of the ANSYS CFD software in a typical Linux cluster environment for massively parallel computations. This includes a basic Linux primer, introduction to LRZ HPC systems and network environment, intro to the use of schedulers like Slurm and LoadLeveler, CFD remote visualization and aspects of successful CFD simulation strategies in such an HPC environment. Finally some aspects of workflow automation using Python as scripting language are targeted as well.

What participants will not learn in this course?

  • Advanced aspects of Linux and computer network infrastructure
  • Geometry creation (CAD, SpaceClaim, DM) and meshing
  • Advanced topics of CFD simulation, like e.g. acoustics, Eulerian and Lagrangian multiphase flows, combustion, radiation, FSI etc.
  • Advanced topics of CFD solver customization with User FORTRAN or User Defined Functions (UDF’s) written in C language.

Training course "Nutzung von VTK zur wissenschaftlich-technischen Visualisierung" @ JSC

begin
08.Apr.2019 09:30
end
08.Apr.2019 16:00
venue
JSC, Jülich

This course is given in German.

Der Kurs gibt eine Einführung in die Benutzung von VTK. Diese frei verfügbare Visualisierungsbibliothek stellt C++-Klassen und Wrapper für verschiedene Sprachen (z.B. Java und Tcl/Tk) bereit, die flexibel auch in bestehende Applikationen integriert werden können. Es werden Einsatzmöglichkeiten der Software für die graphische Auswertung und hochqualitative 3-D-Darstellung von verschiedenen Datentypen (2-D- und 3-D-Skalar- und -Vektorfelder auch auf nicht-orthogonaler Basis) sowie für die Visualisierung von zeitabhängigen Datenfolgen behandelt.

PRACE training course "Interactive High-Performance Computing" @ JSC

begin
09.Apr.2019 09:00
end
10.Apr.2019 16:30
venue
Jülich Supercomputing Centre

Interactive exploration and analysis of large amounts of data from scientific simulations, in-situ visualization and application control are convincing scenarios for explorative sciences. Based on the open source software Jupyter or JupyterLab, a way has been available for some time now that combines interactive with reproducible computing while at the same time meeting the challenges of support for the wide range of different software workflows.

Even on supercomputers, the method enables the creation of documents that combine live code with narrative text, mathematical equations, visualizations, interactive controls, and other extensive output. However, a number of challenges must be mastered in order to make existing workflows ready for interactive high-performance computing. With so many possibilities, it's easy to lose sight of the big picture. This course provides a detailed introduction to interactive high-performance computing.

The following topics are covered:

  • Opportunities and challenges of interactive HPC
  • Functionality and interaction of the necessary components
  • Introduction to the most important libraries
  • Coupling and control of simulations
  • Visualizing results interactively

This course is a PRACE training course.

Training course "Programming in C++" @ JSC

begin
06.May.2019 09:00
end
09.May.2019 16:30
venue
JSC, Jülich

C++ is a multi-paradigm programming language supporting procedural, object-oriented, generic and functional programming styles. This course will provide a practical introduction to C++, adhering to the latest official language standard at the time of the course.

The participants will study small example programs, each demonstrating a certain aspect of C++, and then do simple programming exercises using the lessons learned from the examples. The initial focus of the course will be to make the participants comfortable utilizing modern C++, e. g., solving small problems using the STL containers and algorithms along with lambda functions. Syntax will be explained in detail when needed. Once the participants are familiar and comfortable with the easy-to-use aspects of modern C++, the powerful abstraction mechanisms of the language, such as classes and class hierarchies, and templates will be presented at depth. It is hoped that this course will encourage fruitful application of the programming language and provide a good foundation for further learning.

It is assumed that the participants have previous programming experience in languages such as C, C++, Python, Java and Fortran. This course introduces programming in C++14 and C++17. It is not meant to be a beginners' introduction to programming.

Training course "Optimization of Scaling and Node-level Performance on Hazel Hen (Cray XC40)" @ HLRS

begin
06.May.2019 14:00
end
10.May.2019 13:00
venue
HLRS Stuttgart

In order to increase the efficiency of our users' applications on Hazel Hen, HLRS and Cray offer this workshop to enhance the node-level performance as well as scaling of the codes utilized by participants. By doing so, users can raise the volume as well as quality of their scientific findings while the costs (in terms of core hours) remain constant.

In order to achieve usable efficiency enhancements, it is important to discuss pros and cons of potential solutions. This, however, requires application as well as hardware expertise. Hence, this workshop brings together application and hardware specialists in the shape of users and machine experts.

Supported by HLRS and CRAY specialists, you will analyze the runtime behavior of your code, locate bottlenecks, design and discuss potential solutions as well as implement them. All categories of bottlenecks (CPU, memory subsystem, communication and I/O) will be addressed, according to the respective requirements. Ideally, the above steps will be repeated multiple times in order to address several bottlenecks.

If requested by participants, also lectures can be given on various topics. This is in particular true with respect to scalable I/O strategies and mechanisms (MPI-IO, NetCDF, HDF5), since I/O is the bottleneck of many HPC applications these days. By means of hands on sessions, participants can gain initial experience with lessons learned.

Training course "Advanced C++ with Focus on Software Engineering" @ HLRS

begin
14.May.2019 08:30
end
17.May.2019 16:30
venue
HLRS Stuttgart

This advanced C++ training is a course on object-oriented (OO) software design with the C++ programming language. The focus of the training are the essential OO and C++ software development principles, concepts, idioms, and best practices, which enable programmers to create professional, high-quality code. Additionally, the course gives insight into kernel development with C++. The course will not address special areas and applications of C++, such as for instance Template Meta Programming (TMP), or the quirks and curiosities of the C++ language. It rather teaches guidelines to develop mature, robust, maintainable, and efficient C++ code.

Training course "From zero to hero, Part I: Understanding and fixing on-core performance bottlenecks" @ JSC

begin
14.May.2019 09:00
end
15.May.2019 16:30
venue
JSC, Jülich

Modern HPC hardware has a lot of advanced and not easily accessible features that contribute significantly to the overall intra-node performance. However, many compute-bound HPC applications are historically grown to just use more cores and were not designed to utilize these features.

To make things worse, modern compilers cannot generate fully vectorized code automatically, unless the data structures and dependencies are very simple. As a consequence, such applications use only a low percentage of available peak performance. Hence, scientists have the additional responsibility to design generic data layouts and data access patterns. This gives the compiler a fighting chance to generate code that utilizes most of the available hardware features. Those data layouts and access patterns are vital to utilize performance from vectorization/SIMDization.

Generic algorithms like FFTs or basic linear algebra can be accelerated by using 3rd-party libraries and tools especially tuned and optimized for a multitude of different hardware configurations. But what happens if your problem does not fall into this category and 3rd-party libraries are not available? The training course sheds some light on achieving on-core performance.

We provide insights in today's CPU microarchitecture and apply this knowledge in the hands-on sessions. As example applications we use a plain vector reduction and a simple Coulomb solver. We start from basic implementations and advance to optimized versions using hardware features such as vectorization, unrolling and cache tiling to increase performance. The course also contains training on the use of open-source tools to measure and understand the achieved performance results.

Covered topics:

  • Inside a CPU: A scientists view on modern CPU microarchitecture
  • Data structures: When to use SoA, AoS and AoSoA
  • Vectorization: SIMD on JURECA, JURECA Booster and JUWELS
  • Unrolling: Loop-unrolling for out-of-order execution and instruction-level parallelism
  • Data Reuse: Register file and cache tiling
  • Compiler: When and how to use compiler optimization flags

This course is for you if you ever asked yourself one of the following questions:

  • What is the performance of my code and how fast could it actually be?
  • Why is my performance so bad?
  • Does my code use SIMD?
  • Why does my code not use SIMD and why does the compiler not help me?
  • Is my data structure optimal for this architecture?
  • Do I need to redo everything for the next machine?
  • Why is it that complicated, I thought science was the hard part?

The course consists of lectures and hands-on sessions. After each topic is presented, the participants can apply the knowledge right-away in the hands-on training. The C++ code examples are generic and advance step-by-step. Even if you do not speak C++, it will be possible to follow along and understand the underlying concepts.

In Part II of the course you will learn how to utilize these features in a performance portable way on multiple cores of a node. Furthermore, we will show how to use abstraction layers to separate the hardware-specific optimizations from the algorithm.

Training course "Scientific Visualization" @ HLRS

begin
20.May.2019 09:00
end
21.May.2019 15:30
venue
HLRS Stuttgart

This two day course is targeted at researchers with basic knowledge in numerical simulation, who would like to learn how to visualize their simulation results on the desktop but also in Augmented Reality and Virtual Environments. It will start with a short overview of scientific visualization, following a hands-on introduction to 3D desktop visualization with COVISE. On the second day, we will discuss how to build interactive 3D Models for Virtual Environments and how to set up an Augmented Reality visualization. This course provides scientific training in Computational Science, and in addition, the scientific exchange of the participants among themselves.

Training course "Introduction to the programming and usage of the supercomputing resources at Jülich" @ JSC

begin
20.May.2019 13:00
end
21.May.2019 16:30
venue
JSC, Jülich

Through the John von Neumann Institute for Computing, Research Centre Jülich provides high-performance computing resources to scientific user groups from throughout Germany and Europe. The aim of this course is to give new users of the supercomputing resources an introductory overview of the systems and their usage, and to help them in making efficient use of their allocated resources.

Training course "Introduction to Deep Learning Models" @ JSC

begin
21.May.2019 13:00
end
23.May.2019 16:30
venue
Jülich Supercomputing Centre

This course focuses on a recent machine learning method known as deep learning that emerged as a promising disruptive approach, allowing knowledge discovery from large datasets in an unprecedented effectiveness and efficiency. It is particularly relevant in research areas, which are not accessible through modelling and simulation often performed in HPC. Traditional learning, which was introduced in the 1950s and became a data-driven paradigm in the 90s, is usually based on an iterative process of feature engineering, learning, and modelling. Although successful on many tasks, the resulting models are often hard to transfer to other datasets and research areas.

This course provides an introduction into deep learning and its inherent ability to derive optimal and often quite generic problem representations from the data (aka ‘feature learning’). Concrete architectures such as Convolutional Neural Networks (CNNs) will be applied to real datasets of applications using known deep learning frameworks such as Tensorflow, Keras, or Torch. As the learning process with CNNs is extremely computational-intensive the course will cover aspects of how parallel computing can be leveraged in order to speed-up the learning process using general purpose computing on graphics processing units (GPGPUs). Hands-on exercises allow the participants to immediately turn the newly acquired skills into practice. After this course participants will have a general understanding for which problems CNN learning architectures are useful and how parallel and scalable computing is facilitating the learning process when facing big datasets.

PRACE training course "OpenMP GPU Directives for Parallel Accelerated Supercomputers - an alternative to CUDA from Cray perspective" @ HLRS

begin
22.May.2019 09:00
end
23.May.2019 16:30
venue
HLRS Stuttgart

This workshop will cover the directive-based programming model based on OpenMP v4 whose multi-vendor support allows users to portably develop applications for parallel accelerated supercomputers. It also includes comparison to the predecessor interface OpenACC v2. The workshop will also demonstrate how to use the Cray Programming Environment tools to identify application bottlenecks, facilitate the porting, provide accelerated performance feedback and to tune the ported applications. The Cray scientific libraries for accelerators will be presented, and interoperability of the directives approach with these and with CUDA will be demonstrated. Through application case studies and tutorials, users will gain direct experience of using both OpenMP and OpenACC directives in realistic applications. Users may also bring their own codes to discuss with Cray specialists or begin porting. This course provides scientific training in Computational Science, and in addition, the scientific exchange of the participants among themselves..

PRACE training course "High-performance scientific computing in C++" @ JSC

begin
27.May.2019 09:00
end
29.May.2019 16:30
venue
JSC, Jülich

Modern C++, with its support for procedural, objected oriented, generic and functional programming styles, offers many powerful abstraction mechanisms to express complexity at a high level while remaining very efficient. It is therefore the language of choice for many scientific projects. However, achieving high performance on contemporary computer hardware, with many levels of parallelism, requires understanding C++ code from a more performance centric viewpoint.

In this course, the participants will learn how to write C++ programs which better utilize typical HPC hardware resources of the present day. The course is geared towards scientists and engineers, who are already familiar with C++14, and wish to develop maintainable and fast applications. They will learn to identify and avoid performance degrading characteristics, such as unnecessary memory operations, branch mispredictions, and unintentionally strong ordering assumptions. Two powerful open source libraries to help write structured parallel applications will also be introduced:

  • Intel (R) Threading Building Blocks
  • NVIDIA Thrust

This course is a PRACE training course.

PRACE training course "High-performance computing with Python" @ JSC

begin
17.Jun.2019 09:00
end
19.Jun.2019 16:30
venue
JSC, Jülich

Python is increasingly used in high-performance computing projects. It can be used either as a high-level interface to existing HPC applications and libraries, as embedded interpreter, or directly.

This course combines lectures and hands-on sessions. We will show how Python can be used on parallel architectures and how to optimize critical parts of the kernel using various tools.

The following topics will be covered:

  • Interactive parallel programming with IPython
  • Profiling and optimization
  • High-performance NumPy
  • Just-in-time compilation with numba
  • Distributed-memory parallel programming with Python and MPI
  • Bindings to other programming languages and HPC libraries
  • Interfaces to GPUs

This course is aimed at scientists who wish to explore the productivity gains made possible by Python for HPC.

This course is a PRACE training course.

PRACE training course "VI-HPS Tuning Workshop" @ JSC

begin
24.Jun.2019 09:00
end
28.Jun.2019 16:30
venue
Jülich Supercomputing Centre

This workshop organized by VI-HPS and JSC as a PRACE training event will:

  • give an overview of the VI-HPS programming tools suite
  • explain the functionality of individual tools, and how to use them effectively
  • offer hands-on experience and expert assistance using the tools

The detailed program will be available on the VI-HPS training web site.

Presentations and hands-on sessions are planned on the following topics

  • Setting up, welcome and introduction
  • Score-P instrumentation and measurement
  • Scalasca automated trace analysis
  • TAU performance system
  • Vampir interactive trace analysis
  • Extra-P automated performance modeling
  • Paraver/Extrae/Dimemas trace analysis and performance prediction
  • MAQAO performance analysis & optimisation
  • MUST runtime error detection for MPI
  • ARCHER runtime error detection for OpenMP
  • JUBE script-based workflow execution environment
  • ... and potentially others to be added

A brief overview of the capabilities of these and associated tools is provided in the VI-HPS Tools Guide.

This course is a PRACE training course.

Training course "Cluster Workshop" @ HLRS

begin
25.Jun.2019 09:30
end
26.Jun.2019 17:00
venue
HLRS Stuttgart

Modern compute clusters have become an important part of the IT infrastructure for research and development in many companies and institutions. The procurement, operation, and efficient usage of such parallel systems introduce new and complex requirements.

To address these issues, the High-Performance Computing Center Stuttgart (HLRS) will hold a vendor-independent workshop that provides an introduction to cluster systems and the particular challenges they raise. Topics covered will include the design of compute clusters, as well as details on hardware components, operating systems, file systems, and modes of operation, as well as some examples of software solutions. Furthermore, typical problems that cluster operators encounter will be discussed, along with strategies for solving them.

As Germany's first national supercomputing center, HLRS has operated compute clusters for many years, enabling simulation for a wide range of scientific and industrial applications. We maintain constant dialogue with users and hardware providers and have accumulated a large knowledge base in cluster computing.

PRACE Training course "Node-level performance engineering" @ HLRS

begin
27.Jun.2019 09:00
end
28.Jun.2019 17:00
venue
HLRS Stuttgart

This course teaches performance engineering approaches on the compute node level. "Performance engineering" as we define it is more than employing tools to identify hotspots and bottlenecks. It is about developing 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. Once the architectural requirements of a code are understood and correlated with performance measurements, the potential benefit of optimizations can often be predicted. We introduce a "holistic" node-level performance engineering strategy, apply it to different algorithms from computational science, and also show how an awareness of the performance features of an application may lead to notable reductions in power consumption.This course provides scientific training in Computational Science, and in addition, the scientific exchange of the participants among themselves.

This course is a PRACE training course.