2019 LLVM

Event is now over

Checkout some of our upcoming events over here.

2019 LLVM Banner
April 8-9, 2019
Le Plaza Brussels, Brussels, Belgium

The LLVM developers' meeting is a bi-annual 2 day gathering of the entire LLVM Project community. The conference is organized by the LLVM Foundation and many volunteers within the LLVM community. Developers and users of LLVM, Clang, and related subprojects will enjoy attending interesting talks, impromptu discussions, and networking with the many members of our community. Whether you are a new to the LLVM project or a long time member, there is something for each attendee.

Khronos Related Sessions

SYCL compiler: zero-cost abstraction and type safety for heterogeneous computing

Speaker: Andrew Savonichev, Intel
Session, Slides and Video

Abstract:
SYCL is an abstraction layer for C++, that allows a developer to write heterogeneous programs in a "single source" model, where host and device code are written in the same file. Utilizing modern C++ features, SYCL provides a way to develop type-safe and efficient programs for various accelerator devices.

Although SYCL is designed as "extension-free" standard C++ API, there is a need to have some compiler extensions to enable C++ code execution on accelerators. SYCL compiler is responsible for "extracting" device part of code and compiling it to SPIR-V format or device native binary. In addition to that, compiler should also emit auxiliary information, which is used by SYCL runtime to run a device code via OpenCL API.

This talk will go over technical details of the SYCL compiler, and the changes we need to make in order to bring full support for SYCL into upstream LLVM and Clang as described in the RFC: https://lists.llvm.org/pipermail/cfe-dev/2019-January/060811.html

RFC: Reference OpenCL Runtime library for LLVM

Speakers: Andrew Savonichev, Intel, Alexey Sachkov, Intel
Session, Slides and Video

LLVM is used as a foundation for majority of OpenCL compilers, thanks to excellent support of OpenCL C language in Clang frontend, and modularity of LLVM. Unfortunately, a compiler is not the only component that is required to develop using OpenCL: users need a runtime library that implements the OpenCL API. While there are several implementations of OpenCL runtime exist, both open and proprietary, they do not have a community wide adoption. This leads to fragmentation and effort duplication across OpenCL community, and negatively impacts OpenCL ecosystem in general.

The purpose of this BoF is to bring all parties interested in getting a reference OpenCL Runtime implementation in LLVM, that is designed to be easily extendable to support various accelerator devices (CPU/GPU/FPGA/DSP) and allow users and compiler developers to rapidly prototype OpenCL specific functionality in LLVM and Clang.

Handling massive concurrency: Development of a programming model for GPU and CPU

Speaker: Matthias Liedtke, SAP
Session, Slides and Video

For efficient parallel execution it is necessary to write massively concurrent algorithms and to optimize memory access. In this session we show our approach of a programming model that is able to execute the same concurrent algorithm efficiently on GPUs and CPUs: Similar to OpenMP it allows the programmer to describe concurrency and memory access declaratively but hides complexity like memory transfers between the CPU and the GPU. In comparison to OpenMP our model provides a higher level of expressiveness which enables us to reach a performance comparable to OpenCL/CUDA.


LLVM on AVR - textual IR as a powerful tool for making "impossible" compilers 

Speaker: Carl Peto, Swift for Arduino/Petosoft
Session, Slides and Video

To be demonstrated on stage and available to use and test, I have built a prototype compiler for the a subset of the Swift language onto the Arduino UNO platform, which is a radically different use for the language. Despite the Swift compiler and front end having limited support for such a different back end.

Key to the success was separation of the first part of the compilation into textual LLVM IR (using a standard toolchain), followed by compilation from LLVM IR files into machine code using a custom built llc. This approach improves debugging, especially of deployed product, and separation of concerns. Ultimately it could be used as a template for other "impossible" compilers such as Swift to WebAssembly, Go to OpenGL shaders and more.

Sponsors