Search

Navigation and service

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

begin
11.Mar.2019
end
07.Jun.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

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.

Training course "Deep Learning and GPU programming using OpenACC" @ VSC Vienna

begin
27.Mar.2019 09:00
end
29.Mar.2019 17:00
venue
VSC Vienna

NVIDIA Deep Learning Institute (DLI) offers hands-on training for developers, data scientists, and researchers looking to solve challenging problems with deep learning.

Learn how to train and deploy a neural network to solve real-world problems, how to generate effective descriptions of content within images and video clips and how to accelerate your applications with OpenACC.

The workshop combines lectures about fundamentals of Deep Learning for Computer Vision and Multiple Data Types with a lecture about Accelerated Computing with OpenACC.

The lectures are interleaved with many hands-on sessions using Jupyter Notebooks. The exercises will be done on a fully configured GPU-accelerated workstation in the cloud.

This workshop is co-organized by Nvidia, VSC (Austria), LRZ (Germany) and IT4Innovations (Czech republic). All instructors are NVIDIA certified University Ambassadors.

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 "Optimization of Scaling and Node-level Performance on Hazel Hen (Cray XC40)" @ HLRS

begin
01.Apr.2019 14:00
end
05.Apr.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 "Introduction to Semantic Patching of C programs with Coccinelle" @ LRZ

begin
04.Apr.2019 10:00
end
04.Apr.2019 17:00
venue
LRZ Garching

"Coccinelle is a program matching and transformation engine which provides the language SmPL (Semantic Patch Language) for specifying desired matches and transformations in C code. Coccinelle was initially targeted towards performing collateral evolutions in Linux. Such evolutions comprise the changes that are needed in client code in response to evolutions in library APIs, and may include modifications such as renaming a function, adding a function argument whose value is somehow context-dependent, and reorganizing a data structure. Beyond collateral evolutions, Coccinelle is successfully used (by us and others) for finding and fixing bugs in systems code." (http://coccinelle.lip6.fr/)

This training introduces the Coccinelle semantic matching engine for C programs.

Target audience are medium to advanced C programmers interested in restructuring large scale programs.

Applications in HPC will be mentioned, examples will be given.

Tentative program:

  • Invoking Coccinelle.
  • Semantic matching.
  • Semantic patching.
  • Elements of the SmPL language.
  • Simple SmPL rules.
  • Rules with inheritance.
  • Reusing rules.
  • Scripting.
  • Review of common transformations and use cases in HPC.
  • Hands-on exercises.

Contents are subject to modifications.

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.

Training course "Introduction to the LRZ Supercomputing & Machine Learning Infrastructure" @ LRZ

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

In this introductory course we will give an overview of the hardware and software services provided by the Leibniz Supercomputing Centre (LRZ) with a focus on supercomputing (HPC) as well as machine learning (ML) applications. The course opens with a (optional) introduction to GNU/Linux and a how-to of working with remote machines (using SSH). The subsequent combination of lectures, demo and hands-on sessions provides participants with the knowledge and skills necessary to efficiently utilize the LRZ supercomputing and cloud infrastructure for their own projects.

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 "Using R at LRZ" @ LRZ

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

R is a highly popular and powerful programming language for data analysis and graphics, used in many research domains. The Leibniz Supercomputing Centre (LRZ) is addressing the needs of R users by facilitating various ways of working with R on LRZ systems.

For one it is hosting a RStudio Server web service that provides an easy to use and powerful platform mostly targeted at interactive analyses. This service can, however, also be used as a gateway to the high performance computing (HPC) systems at LRZ. Additionally, R can be employed directly on the massively parallel Linux Cluster and SuperMUC-NG as well as on specialized and GPU-enhanced machine learning (ML) systems.

In this course, the different possibilities of using R at LRZ will be demonstrated. Guidelines and best practice examples for running R applications efficiently on the various systems will be provided. Special attention will be paid to different ways of parallelizing R code in order to utilize LRZ's HPC infrastructure.

Training course "Intel Artificial Intelligence Workshop" @ LRZ

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

The workshop will highlight the usage of Intel's optimized performance libraries underneath popular machine learning frameworks. It includes hands-on sessions around classical machine learning as well as deep learning on HPC systems. Besides introducing the transparent usage of performance libraries, the focus will be to empower participants to scale their deep learning (TensorFlow) application training on distributed HPC systems. The hands-on examples are written in Python.

Training course "Using Python at LRZ" @ LRZ

begin
12.Apr.2019 10:00
end
12.Apr.2019 15:00
venue
LRZ Garching

As a general-purpose programming language with a growing user-base amongst data scientists, Python is increasingly used for data analysis and machine learning applications at the Leibniz Supercomputing Centre (LRZ).

In this half-day course several techniques and best practice examples will be demonstrated - empowering participants to use Python effectively on LRZ systems like the Linux Cluster and the upcoming LRZ cloud infrastructure.

PRACE training course "Fortran for Scientific Computing" @ HLRS

begin
06.May.2019 08:30
end
10.May.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.

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 "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.

PRACE training course "HPC code optimisation workshop" @ LRZ

begin
20.May.2019 09:00
end
22.May.2019 17:00
venue
LRZ Garching

In the ever-growing complexity of computer architectures, code optimization has become the main route to keep pace with hardware advancements and effectively make use of current and upcoming High Performance Computing systems.

Have you ever asked yourself:

  • Where does the performance of my application lay?
  • What is the maximum speed-up achievable on the architecture I am using?
  • Is my implementation matching the HPC objectives?

In this workshop, we will answer these questions and provide a unique opportunity to learn techniques, methods and solutions on how to improve code, how to enable the new hardware features and how to use the roofline model to visualize the potential benefits of an optimization process.

We will begin with a description of the latest micro-processor architectures and how the developers can efficiently use modern HPC hardware, in particular the vector units via SIMD programming and AVX-512 optimization and the memory hierarchy.

The attendees are then conducted along the optimization process by means of hands-on exercises and learn how to enable vectorization using simple pragmas and more effective techniques, like changing data layout and alignment.

The work is guided by the hints from the Intel® compiler reports, and using Intel® Advisor.

NEW: this year the workshop will consist of three days. We will dedicate most of the third day to the Intel Math Kernel Library (MKL), in order to show how to gain performance through the use of libraries.

We provide also an N-body code, to support the described optimization solutions with practical hands-on.

The course is a PRACE training event.

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 "Deep Learning and GPU programming workshop" @ LRZ

begin
03.Jun.2019 09:30
end
06.Jun.2019 17:00
venue
LRZ Garching

Learn how to train and deploy a neural network to solve real-world problems, how to generate effective descriptions of content within images and video clips, how to effectively parallelize training of deep neural networks on Multi-GPUs and how to accelerate your applications with CUDA C/C++ and OpenACC.

This new 4-days workshop offered for the first time at LRZ combines lectures about fundamentals of Deep Learning for Multiple Data Types and Multi-GPUs with lectures about Accelerated Computing with CUDA C/C++ and OpenACC.

The lectures are interleaved with many hands-on sessions using Jupyter Notebooks. The exercises will be done on a fully configured GPU-accelerated workstation in the cloud.

The workshop is co-organized by LRZ and NVIDIA Deep Learning Institute (DLI) for the Partnership for Advanced Computing in Europe (PRACE). Since 2012 LRZ as part of GCS is one of currently 10 PRACE Training Centres which serve as European hubs and key drivers of advanced high-quality training for researchers working in the computational sciences.

NVIDIA DLI offers hands-on training for developers, data scientists, and researchers looking to solve challenging problems with deep learning.

All instructors are NVIDIA certified University Ambassadors.

Training course "Introduction to hybrid programming in HPC" @ TU Wien, Vienna

begin
12.Jun.2019 09:00
end
13.Jun.2019
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. This course is organized by VSC (Vienna Scientific Cluster). in cooperation with HLRS and RRZE.

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

begin
12.Jun.2019 09:00
end
14.Jun.2019 17:00
venue
LRZ Garching

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. 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, and maintainable C++ code. The following topics will be covered:

Day 1 schedule:

  • Essential Object-Oriented Design Principles

    • The core of object-oriented programming
    • The SOLID principles
  • Concepts and the STL

    • Overview of the STL
    • Proper use of the STL
  • Class Design

    • Know what your compiler does for you
    • Inside/Outside: What should (not) be inside a class?

Day 2 schedule:

  • Class Design (cont.)

    • Const Correctness
    • Interface design
    • Visibility vs. Accessibility
  • Robust Code

    • Error propagation
    • Exception Safety
    • RAII
    • Handling Legacy Code
  • Proper Use of Dynamic Inheritance

    • Non-public inheritance
    • Public inheritance

Day 3 schedule:

  • Dependency-Breaking Techniques
  • Non-Intrusive Design
  • C++11/14 Update
  • Kernel development

Contents are subject to modifications.

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.

PRACE training course "Concepts of GASPI and interoperability with other communication APIs" @ HLRS

begin
01.Jul.2019 09:00
end
02.Jul.2019 15:30
venue
HLRS Stuttgart

In this tutorial we present an asynchronous data flow programming model for Partitioned Global Address Spaces (PGAS) as an alternative to the programming model of MPI.

GASPI, which stands for Global Address Space Programming Interface, is a partitioned global address space (PGAS) API. The GASPI API is designed as a C/C++/Fortran library and focused on three key objectives: scalability, flexibility and fault tolerance. In order to achieve its much improved scaling behaviour GASPI aims at asynchronous dataflow with remote completion, rather than bulk-synchronous message exchanges. GASPI follows a single/multiple program multiple data (SPMD/MPMD) approach and offers a small, yet powerful API (see also http://www.gaspi.de and http://www.gpi-site.com).
GASPI is successfully used in academic and industrial simulation applications.

Hands-on sessions (in C and Fortran) will allow users to immediately test and understand the basic constructs of GASPI.
This course provides scientific training in Computational Science, and in addition, the scientific exchange of the participants among themselves.

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

begin
09.Jul.2019 08:30
end
12.Jul.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.

After this course, participants will:

  • have a detailed understanding of the essential OO design principles
  • have gained knowledge about fundamental C++ programming concepts and idioms
  • be able to properly design classes and class interfaces
  • know about the importance of exception safe programming
  • have gained insight into kernel development with C++
  • avoid the usual pitfalls in the context of inheritance
  • comprehend the advantages of non-intrusive design
  • understand the virtue of clean code

Training course "Deep Learning and GPU programming workshop" @ HLRS

begin
15.Jul.2019 09:00
end
17.Jul.2019 17:00
venue
HLRS Stuttgart

NVIDIA Deep Learning Institute (DLI) offers hands-on training for developers, data scientists, and researchers looking to solve challenging problems with deep learning.

Learn how to train and deploy a neural network to solve real-world problems, how to generate effective descriptions of content within images and video clips and how to accelerate your applications with OpenACC.

The workshop combines lectures about fundamentals of Deep Learning for Computer Vision and Multiple Data Types with a lecture about Accelerated Computing with OpenACC.

The lectures are interleaved with many hands-on sessions using Jupyter Notebooks. The exercises will be done on a fully configured GPU-accelerated workstation in the cloud.

This workshop is co-organized by Nvidia, VSC (Austria), LRZ (Germany) and IT4Innovations (Czech republic). All instructors are NVIDIA certified University Ambassadors.