LLVM Developers' Meeting

Table of Contents

About

The LLVM Foundation announces the ninth annual bay area LLVM Developers’ Meeting will be held October 29th and 30th in San Jose, CA.

This year the conference will be 2 full days that include technical talks, BoFs, hacker’s lab, tutorials, and a poster session. Attendance will be capped at 350.

The meeting serves as a forum for LLVM, Clang, LLDB, and other LLVM project developers and users to get acquainted, learn how LLVM is used, and exchange ideas about LLVM and its potential applications. More broadly, we believe the event will be of particular interest to the following people:

Please sign up for the LLVM Developers’ Meeting list for future announcements and to ask questions.

You may also contact the organizer, Tanya Lattner.

Program

Talk Abstracts

WebAssembly: Here Be Dragons

Jf Bastien - Google, Dan Gohman - Mozilla [Slides] [Video]
WebAssembly is a tale of four browser vendors, seeking new languages and capabilities while staying fast, secure and portable. The old JavaScript wizard still has many spells under its belt, but it seeks a companion on its quest to reach VM utopia. WebAssembly is that companion. In this quest, mad alchemist Dan and jester JF will detail their exploration of LLVM-land. You'll get to witness firsthand their exploration of ISel and MI, hear of their wondrous encounter with MC, and gasp at the Spell of Restructuring wherein SSA+CFG is transmuted into regs+AST. Will our adventurers conquer the Target and capture the virtual ISA? Join us in this exciting tale to which *you* are the hero!

A Proposal for Global Instruction Selection

Quentin Colombet - Apple [Slides] [Video]
Our existing instruction selection framework, SelectionDAGISel (SDISel), has some fundamental limitations, including, but not limited to, slow compile time, basic block only scope, and monolithic approach. Over the years, we spent a lot of effort to workaround these limitations with more target hooks and more optimizations passes (e.g., CodeGenPrepare, ConstantHoisting) with their own problems (inaccurate heuristic, have to predict what the instruction selector will do, etc.) and limitations. We believe that it is time to come up with a new instruction selection framework, global-isel, that will solve these problems while offering new opportunities to improve our code generation. In this talk, we will present our plan to bring global-isel to LLVM.

Input Space Splitting for OpenCL

Johannes Doerfert - Saarland University [Slides] [Video]
OpenCL programs are prone to memory and control flow divergence. When implementing OpenCL for machines with explicit SIMD instructions, compilers can usually generate more efficient code if they can prove non-divergence of memory and branch instructions. To this end, they leverage a so-called divergence analysis. However, in practice divergence is often input-dependent and exhibited for some, but not all inputs. Hence, static analyses fail to prove non-divergence. To obtain good performance, developers can manually split the input space, however this is a tedious and error prone task. In this talk we present a new OpenCL to CPU compiler pipeline that addresses this problem by automatically ensuring divergence free control flow through program specialization.

Profile-based Indirect Call Promotion

Ivan Baev - QuIC [Slides] [Video]
Indirect call promotion (ICP) is the second most profitable profile-based optimization according to a recent study. This talk will present LLVM ICP pass that iterates over all indirect call sites in the module and selectively transforms them. We will discuss how subsequent optimizations in the compiler pipeline may benefit from ICP.

Beyond Sanitizers: guided fuzzing and security hardening

Kostya Serebryany - Google [Slides] [Video]
The Sanitizers (AddressSanitizer and friends) allow you to find many stability and security bugs in C++ code, but they are only as good as your tests are. In this talk we will show how to improve your test coverage with guided fuzzing (libFuzzer) and how to protect your applications in production even if some bugs are still there (Control Flow Integrity and SafeStack).

Automated performance-tracking of LLVM-generated code

Kristof Beyls - ARM [Slides] [Video]
Ensuring that top-of-trunk consistently generates high-quality code remains harder than it should be. Continuous integration (CI) setups that track correctness of top-of-trunk work pretty well today since they automatically report correctness regressions with low false positive rate to committers. In comparison, the output generated by CI setups that track performance require far more human effort to interpret. In this talk, I'll describe why I think effective performance tracking is hard and what problems need solving, with a focus on our real world experiences and observations.

A Heterogeneous Execution Engine for LLVM

Christos Margiolas - University of Edinburgh [Slides] [Video]
Hexe, which stands for Heterogeneous Execution Engine, is an new compiler component that integrates with the LLVM infrastructure. It targets efficient computation on heterogeneous platforms by allowing the automatic offloading of workloads on computational accelerators, such as Graphics Processing Units (GPUs) or Digital Signal Processors(DSPs). The workloads we consider for offloading are either explicitly annotated by the programmer or automatically detected by static compiler analysis and runtime checks. Our infrastructure operates at the level of LLVM intermediate representation and effectively supports multiple source languages.

Swift's High-Level IR: A Case Study of Complementing LLVM IR with Language-Specific Optimization

Joseph Groff - Apple Inc., Chris Lattner - Apple Inc. [Slides] [Video]
The Swift programming language is built on LLVM and uses LLVM IR and the LLVM backend for code generation, but it also contains a new high-level IR called SIL to model the semantics of the language (and perform optimizations) at a higher level. In this talk, we discuss the motivations and applications of SIL, including high-level semantic analyses and transformations such as flow-dependent diagnostics, devirtualization, specialization, reference counting optimization, and TBAA, and we compare SIL's design with that of LLVM IR.

Typeless Pointers in LLVM IR

David Blaikie - Google Inc. [Slides] [Video]
In an effort to simplify and canonicalize LLVM IR surrounding pointer expressions, the type information from pointers is being removed. Hear about the current changes, utilities for updating your test cases, as well as current open questions and future work.

LLVM Performance Improvements and Headroom

Gerolf Hoflehner - Apple [Slides] [Video]
While LLVM is known for very fast compile-time, many developers in the community also push for improving run-time performance of generated code. This talk highlights this year's performance gains on AArch64 in key benchmarks like SPEC2006, Kernels and also the llvm test suite. While progress has been impressive more work needs to be done. Therefore we will discuss future performance headroom which involves both expanding existing and architecting new optimizations.

Optimizing LLVM for GPGPU

Jingyue Wu - Google Inc. [Video]
This talk presents Google's effort of optimizing LLVM for CUDA. When we started this effort, LLVM was well-tuned for CPUs but there had been little public work on improving its GPU performance. We developed, tuned, and augmented several general and CUDA-specific optimization passes. As a result, our LLVM-based compiler generates better code than nvcc on key end-to-end internal benchmarks and is on par with nvcc on a variety of open-source benchmarks.

Exception handling in LLVM, from Itanium to MSVC

Reid Kleckner - Google, David Majnemer - Google [Slides] [Video]
This talk covers the design and implementation of MSVC-compatible exception handling in Clang and LLVM. Unlike the Itanium C++ exception handling model, the Windows exception handling model is not designed around successive unwinding. As a result, the existing LLVM landingpad instruction is insufficient for expressing how Windows exceptions should be handled. To support Windows exceptions, we added the new token type and a family of new EH pad instructions to LLVM. This talk describes the final design of the new representation and the tradeoffs we made along the way.

OpenMP GPU/Accelerator support Coming of Age in Clang

Michael Wong - IBM, Alexey Bataev - Intel [Slides] [Video]
GPU/Accelerator computing will be the basis for the future of Exacale computing through the DOE's CORAL project. It is also the basis for future features for C++ Std's SG14's Games Development/Low Latency/Real Time/Graphics Study Group. However, llvm currently lacks a unified platform-neutral infrastructure for offloading to GPUs/Accelerators, which severely limits clang/llvm usage in these hugely important application domains. For the past several years, a number of contributors from AMD, Argonne National Lab., IBM, Intel, Texas Instruments, University of Houston and many others have come together to deliver OpenMP support to clang.

An update on Clang-based C++ Tooling

Daniel Jasper - Google, Manuel Klimek - Google [Slides] [Video]
This talk is going to give an update of the C++ tooling we are building on top of clang. Among others, it will focus on clang-tidy, a tool to statically analyze source code to diagnose and fix typical programming errors like style violations, interface misuse, or bugs. We'll give an update on the direction this project is taking, new checks that are being integrated and challenges we are facing. In a live demo, we'll show how we can fix specific problems throughout LLVM's own codebase. We'll also show how a new check can be added in a matter of minutes and how other Clang-based tools can help with its development.

LLVM for a managed language: what we've learned

Sanjoy Das - Azul Systems, Philip Reames - Azul Systems [Slides] [Video]
For a little over a year we have been working towards a production quality, state of the art LLVM based JIT compiler for Java. This talk focuses on what we've learned about LLVM's strengths and weaknesses as an optimization framework for Java-like languages. We will discuss interesting challenges in efficiently implementing Java's semantics within LLVM IR, and how we've been growing LLVM towards being a more effective compiler for managed languages.

Throttling Automatic Vectorization: When Less Is More

Vasileios Porpodas - University of Cambridge [Slides] [Video]
SIMD vectors are widely adopted in modern general purpose processors as they can boost performance and energy efficiency for certain applications. Compiler-based automatic vectorization is one approach for generating code that makes efficient use of the SIMD units, and has the benefit of avoiding hand development and platform-specific optimizations. The Superword-Level Parallelism (SLP) vectorization algorithm is the most well-known implementation of automatic vectorization when starting from straight-line scalar code, and is implemented in several major compilers. In this work we propose a solution to overcome this limitation by introducing Throttled SLP (TSLP), a novel vectorization algorithm that finds the optimal graph to vectorize, forcing vectorization to stop earlier whenever this is beneficial.

LLVM back end for HHVM/PHP

Brett Simmers - Facebook, Inc., Maksim Panchenko - Facebook, Inc. [Slides] [Video]
The Hip-Hop Virtual Machine (HHVM) is a JIT compiler for executing PHP programs. It is used by some of the world's largest websites such as facebook.com and wikipedia.org, among many others. At Facebook we have frequently been asked why we don't use LLVM as a back end for HHVM. Inspired by the success of Apple's FTL we implemented an alternative back end using LLVM. In this talk we will share what it took to hook LLVM in to HHVM from conception to running limited production traffic. We will cover changes to our internal IR and modifications we had to make to LLVM.

LoopVersioning LICM

Ashutosh Nema - AMD [Slides] [Video]
Loop invariant code motion is an important compiler optimization and it moves invariant instructions out of a loop without affecting the semantics of a program. For safety it ensures the alias dependencies before moving invariant out of loop. In some cases memory aliasing may make this optimization ineffective. This results in possible missed opportunities in speeding up applications. LoopVersioning LICM is a step to exploit those missed opportunities where memory aliasing may make LICM optimization ineffective.

Compiling large, real-world codebases with clang on Windows

Hans Wennborg - Google Inc., Nico Weber - Google Inc. [Slides] [Video]
llvm 3.7 is the first release that can build large projects such as Chromium on Windows without having to fall back to Visual Studio's compiler for a single translation unit. This talk gives an overview of the work done to get to this state: It covers language extensions clang needed to learn to parse Microsoft's headers and dark corners of the Microsoft ABI, with a focus on work done in the last year. Much of the Windows support was developed in tight collaboration between the Chromium and LLVM projects.

Debug Info: From Metadata to Modules

Duncan Exon Smith - Apple, Adrian Prantl - Apple [Slides] [Video]
The efficiency of debug info in LLVM and Clang improved dramatically this year. This talk is about what it took to get here and what work remains. We'll talk about how Metadata was redesigned to make the debug info IR memory-efficient (with a human-readable assembly syntax). We'll go into the implications for other Metadata graphs, and what a more expressive Metadata future could look like. We'll also include an overview of what's left to scale debug info for LTO.

Advances in Loop Analysis Frameworks and Optimizations

Adam Nemet - Apple Inc., Michael Zolotukhin - Apple Inc. [Slides] [Video]
The talk will survey recent advances in loop analysis frameworks to support optimizations like unrolling, distribution, loop-aware load-elimination and multi-versioning. A significant part of our contribution was to rethink and re-design existing analysis frameworks to make them both more powerful and more widely accessible. The major part of this talk will focus on introducing these analysis frameworks and how they are used by optimizations. We will also discuss how they integrate with other analysis passes and outline ideas for their future evolution.

Tutorial Abstracts

Tutorial: Building, Testing and Debugging a Simple out-of-tree LLVM Pass

Serge Guelton - Quarkslab, Adrien Guinet - Quarkslab [Slides] [Video]
This tutorial aims at providing solid ground to develop out-of-tree LLVM passes. It presents all the required building blocks, starting from scratch: cmake integration, llvm pass management, opt / clang integration. It presents the core IR concepts through two simple obfuscating passes: the SSA form, the CFG, PHI nodes, IRBuilder etc. We also take a quick tour on analysis integration through dominators. Finally, it showcases how to use cl and lit to parametrize and test the toy passes developed in the tutorial.

Tutorial: Creating an SPMD Vectorizer for OpenCL with LLVM

Pierre-Andre Saulais - Codeplay Software [Slides] [Video]
Processors such as CPUs or DSPs often feature SIMD instructions, but are not designed to efficiently support Single Program Multiple Data (SPMD) execution models such as OpenCL. The design of a compiler for such a target therefore needs some form of vectorization to generate the most optimal code for this kind of data-parallel execution model. This tutorial looks at how to create an SPMD vectorizer that targets CPU-like architectures for use with heterogeneous compute frameworks.

Tutorial: Polly - Optimistic Loop Nest Optimizations with Schedule Trees

Tobias Grosser - ETH Zurich, Johannes Doerfert - Saarland University [Slides] [Video]
Polly is an advanced LLVM loop nest optimizer that provides precise memory access analyses and implements on top of them advanced loop optimizations based on a memory-access focused program model. In the first part of this tutorial we introduce the audience to integer set based schedule trees as a way to model loop programs. The second part of this tutorial is focused on Polly's new optimistic optimization infrastructure that enables non-statically provable transformations to be performed optimistically.

Tutorial/BoF: Living Downstream Without Drowning

Paul Robinson - Sony Computer Entertainment, Michael Edwards - Sony Computer Entertainment [Slides] [Video]
Have you made changes to your copy of an llvm.org project? Not planning to contribute them back to the open-source project right away? Then you are LIVING DOWNSTREAM. Have you noticed that there are actually quite a lot of changes made to the upstream projects? Clang + LLVM together see an average of 50 commits every day. This is a FLOOD. Are you seeing lots of conflicts or test failures when you merge from upstream? Spending too much time patching things back together before you can make any progress on your project? Then you are DROWNING!

Reception

The reception will be held on Thursday, October 29 from 6PM-10PM at SP2 Communal Bar & Restaurant. A reception ticket is required to attend this event. Drinks and food will be provided.

SP2 Communal Bar & Restaurant 72 N Almaden Ave. San Jose, CA 95110

Hotel

San Jose Marriott 301 South Market Street San Jose, CA 95113

We have negotiated a room block for our attendees:

LLVM Foundation Developers Meeting

Start date: 10/28/15 End date: 10/31/15 Last day to book: 10/7/15 Marriott hotel(s) offering your special group rate:

San Jose Marriott for 229.00 USD per night Book your group rate for the LLVM Foundation Developers Meeting.

Parking

You can find parking at the San Jose Marriott (valet only) and the San Jose Convention Center.

Rates: San Jose Marriott Valet parking:

San Jose Convention Center Parking: $1 per 20 min, $20 daily maximum Monday - Sunday, special rates as posted at facility may apply during special event.