| <!--#include virtual="../../header.incl" --> |
| |
| <div class="www_sectiontitle">HPC summer school 2017</div> |
| |
| <ul> |
| <li><b>What</b>: Analysis and transformations of HPC codes using Clang/LLVM</li> |
| <li><b>When</b>: June 12-16, 2017</li> |
| <li><b>Where</b>: Paris, France</li> |
| <li><b><a href="http://www-hpc.cea.fr/SummerSchools/SummerSchools2017-CS.htm">Web site</a></b></li> |
| </ul> |
| |
| <div class="www_sectiontitle">Lectures</div> |
| <p> |
| <ul> |
| <li><b>Introduction to LLVM - David Chisnall (Cambridge University)</b> |
| <p> |
| This course will cover the design decisions involved in designing a modern |
| compiler intermediate representation, with a specific focus on the design |
| decisions made by LLVM IR and the affects that these have on the design of a |
| compiler. We will explore the structure of the LLVM optimization pipeline, the |
| relationship between analysis and transformation to produce optimization. |
| </p> |
| <p> |
| The course will investigate the tradeoffs between ahead-of-time (AoT) and |
| just-in-time (JIT) compilation, in particular with regard to feedback-driven |
| optimization. We will use a simple language incorporating an interpreter and |
| LLVM-based compiler as a case study, with exercises to extend this language and |
| explore the different execution modes. |
| </p> |
| <p> |
| The course has the following aims for students:<ul> |
| <li> To understand modern compiler intermediate representations, including SSA form</li> |
| <li> To understand the structure of a modern compiler pipeline</li> |
| <li> To gain practical experience generating and transforming LLVM IR</li> |
| </ul> |
| </p> |
| <p> |
| [<a href="http://www.cl.cam.ac.uk/~dc552/L25.html">Background reading</a>] |
| [<a href="1-Davis-Chisnall-LLVM-2017.pdf">Slides</a>] |
| [<a href="http://compilerteaching.org/paris2017/">Exercises</a>] |
| </p> |
| </li> |
| |
| <li><b>Code Transformation and Analysis Using Clang and LLVM - Hal Finkel (Argonne National Laboratory)</b> |
| <p> |
| This series of lectures will cover code transformation and analysis |
| using components of the LLVM compiler infrastructure. LLVM's C/C++ |
| frontend, Clang, supports not only compiling source code for execution |
| (i.e. transforming it into LLVM's intermediate representation (IR)), |
| but also features a powerful source-level static analysis framework. |
| This can be coupled with Clang's rewriting and tooling functionalities |
| to create sophisticated source -to-source transformation tools. |
| </p> |
| <p> |
| For some use cases, runtime checking must supplement static reasoning. |
| In some cases, for example, Clang's undefined-behavior sanitizer, these |
| checks much be inserted very early in the code-generation process. In |
| other cases, such as the address and thread sanitizers, the checks can |
| be inserted after the code undergoes optimizing transformations. |
| Runtime checks are associated with corresponding runtime-library |
| functionality in LLVM's compiler-rt project. |
| </p> |
| <p> |
| At the conclusion of the lecture series, students will understand Clang's |
| static-analysis, rewriting, and tooling infrastructures well enough to create |
| novel analyses for the stand-alone analyzer, analysis-based warnings for |
| regular compilation, and source-to-source rewriting tools. Students will |
| understand how Clang's undefined-behavior sanitizer works and how Clang's |
| code-generation can be extended to create runtime checks. Finally, students |
| will understand how the address and thread sanitizers work, both the IR-level |
| transformations and the runtime-library components. Students will be able to |
| create their own tools based on this model. |
| </p> |
| <p> |
| [<a href="2-Hal-Finkel-LLVM-2017.pdf">Slides</a>] |
| [<a href="https://github.com/hfinkel/llvm-ss-2017">Exercises</a>] |
| </p> |
| </li> |
| |
| <li><b>Generation of Optimization of Parallel Code in LLVM - Tobias Gosser (ETH Zurich)</b> |
| <p> |
| The generation of parallel code is important for the fast execution of |
| classical high-performance applications such as weather prediction, but |
| also modern applications such as image processing, machine learning, and |
| biology simulations. The LLVM compiler infrastructure enables the |
| automatic introduction and generation of parallel code through |
| SIMDization, automatic parallelization, as well as automatic GPU code, |
| generation. In this course, we learn about the fundamental building |
| blocks that enable the generation and optimization of parallel program |
| code. Starting off from learning about the SIMD instruction set |
| extensions of LLVM we learn how to write our own SIMD accelerated vector |
| code generator that can generate fast vector code for all LLVM supported |
| architectures. We then look into different approaches to model |
| parallelism at the source language level, at the compiler IR level, and |
| -- using Polly -- how to model parallelism with an abstract geometric |
| representation based on integer polyhedra. Using these representations we |
| discuss how parallelism information can be derived, how transformations |
| to expose parallelism can be applied, and finally how fast parallel code |
| can be generated. In the last part of this course, we discuss GPU code |
| generation and learn how LLVM can be used to generate GPU accelerated |
| code for AMD and NVIDIA systems, discuss the available CUDA and OpenCL |
| extensions, and learn how Polly ACC can fully automatically perform GPU |
| offloading. We conclude with an overview how these techniques allow for |
| the automatic optimization of high-level languages such as Julia. |
| </p> |
| <p> |
| [<a href="3-Tobias-Grosser-2017-day1.pdf">Slides - day 1</a>] |
| [<a href="3-Tobias-Grosser-2017-day2.pdf">Slides - day 2</a>] |
| [<a href="https://github.com/tobig/llvm-summer-school-2017">Exercises</a>] |
| </p> |
| </li> |
| </ul> |
| </p> |
| |
| <!-- *********************************************************************** --> |
| <hr> |
| |
| <!--#include virtual="../../footer.incl" --> |