The LLVM Compiler Infrastructure Project (original) (raw)

Site Map:
Download!
Search this Site
Useful Links
Release Emails
Maintained by the
llvm-admin team

2019 LLVM Developers' Meeting - Bay Area

About

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.

What can you can expect at an LLVM Developers' Meeting?

Technical Talks

These 20-30 minute talks cover all topics from core infrastructure talks, to project's using LLVM's infrastructure. Attendees will take away technical information that could be pertinent to their project or general interest.

Tutorials

Tutorials are 50-60 minute sessions that dive down deep into a technical topic. Expect in depth examples and explanations.

Lightning Talks

These are fast 5 minute talks that give you a taste of a project or topic. Attendees will hear a wide range of topics and probably leave wanting to learn more.

Panels

Panel sessions are guided discussions about a specific topic. The panel consists of ~3 developers who discuss a topic through prepared questions from a moderator. The audience is also given the opportunity to ask questions of the panel.

Student Research Competition

Students present their research using LLVM or related subproject. These are usually 20 minute technical presentations with Q&A. The audience will vote at the end for the winning presentation and paper.

Poster Session

An hour long poster session where selected posted are on display.

Round Table Discussions

Informal and impromptu discussions on a specific topic. During the conference there are set time slots where groups can organize to discuss a problem or topic.

Evening Reception

After a full day if technical talks and discussions, join your fellow attendees for an evening reception to continue the conversation and meet even more attendees.

What types of people attend?

• Active developers of projects in the LLVM Umbrella (LLVM core, Clang, LLDB, libc++, compiler_rt, klee, lld, etc).
• Anyone interested in using these as part of another project.
• Students and Researchers
• Compiler, programming language, and runtime enthusiasts.
• Those interested in using compiler and toolchain technology in novel and interesting ways.

The LLVM Developers' Meeting strives to be the best conference to meet other LLVM developers and users.

For future announcements or questions: Please sign up for the LLVM Developers' Meeting list.

Women in Compilers and Tools Workshop

The LLVM Foundation will host a half day Women in Compilers and Tools Workshop held the day before the 2019 LLVM Developers’ Meeting - Bay Area. The workshop will be held at the Fairmont Hotel on October 21st from 12:30-5:30PM and includes a cocktail reception.

This event aims to connect women in the field of compilers and tools and provide them with ideas and techniques to overcome barriers or enhance their careers. It also is open to anyone (not just women) who are interested in increasing diversity within the LLVM community, their workplace or university.

More details will be coming soon but registration is open.

Program

The online schedule may be found here: https://llvmdevmtg2019.sched.com. Bookmark this on your mobile device.

Keynotes

• Generating Optimized Code with GlobalISel - Volkan Keles, Daniel Sanders [ Video ] [ Slides ]
• Even Better C++ Performance and Productivity: Enhancing Clang to Support Just-in-Time Compilation of Templates - Hal Finkel [ Video ] [ Slides ]

Technical Talks

• Using LLVM's portable SIMD with Zig - Shawn Landden [ Video ] [ Slides ]
• Code-Generation for the Arm M-profile Vector Extension - Sjoerd Meijer, Sam Parker [ Video ] [ Slides ]
• Alive2: Verifying Existing Optimizations - Nuno Lopes, John Regehr [ Video ] [ Slides ]
• The clang constexpr interpreter - Nandor Licker [ Videos ] [ Slides ]
• Souper-Charging Peepholes with Target Machine Info - Min-Yih Hsu [ Video ] [ Slides ]
• Transitioning the Networking Software Toolchain to Clang/LLVM - Ivan Baev, Jeremy Stenglein, Bharathi Seshadri [ Video ] [ Slides ]
• Link Time Optimization For Swift - Jin Lin [ Video ] [ Slides ]
• Hot Cold Splitting Optimization Pass In LLVM - Aditya Kumar [ Videos ] [ Slides ]
• Making UB hurt less: security mitigations through automatic variable initialization - JF Bastien [ Video ] [ Slides ]
• Propeller: Profile Guided Large Scale Performance Enhancing Relinker - Sriraman Tallam [ Video ] [ Slides ]
• From C++ for OpenCL to C++ for accelerator devices - Anastasia Stulova [ Video ] [ Slides ]
• LLVM-Canon: Shooting for Clear Diffs - Michal Paszkowski [ Video ] [ Slides ]
• Better C++ debugging using Clang Modules in LLDB - Raphael Isemann [ Video ] [ Slides ]
• Ownership SSA and Semantic SIL - Michael Gottesman [ Video ] [ Slides ]
• arm64e: An ABI for Pointer Authentication - Ahmed Bougacha, John McCall [ Video ] [ Slides ]
• Porting by a 1000 Patches: Bringing Swift to Windows - Saleem Abdulrasool [ Video] [ Slides ]
• The Penultimate Challange: Constructing bug reports in the Clang Static Analyzer - Kristóóf Umann [ Video ] [ Slides ]
• Address Spaces in LLVM - Matt Arsenault [ Video ] [ Slides ]
• An MLIR Dialect for High-Level Optimization of Fortran - Eric Schweitz [ Video ] [ Slides ]
• Loop-transformation #pragmas in the front-end - Michael Kruse [ Video ] [ Slides ]
• Optimizing builds on Windows: some practical considerations - Alexandre Ganea [ Video ] [ Slides ]
• LLVM-Reduce for testcase reduction - Diego Treviño Ferrer [ Video ] [ Slides ]
• Memoro: Scaling an LLVM-based Heap profiler - Thierry Treyer [ Video ] [ Slides ]
• The Attributor: A Versatile Inter-procedural Fixpoint Iteration Framework - Johannes Doerfert [ Video ] [ Slides ]
• LLVM Tutorials: How to write Beginner-Friendly, Inclusive Tutorials - Meike Baumgärtner, Dmitri Gribenko [ Videos ] [ Slides ]
• Maturing an LLVM backend: Lessons learned from the RISC-V target - Alex Bradbury [Video ] [ Slides ]

Tutorials

• Getting Started With LLVM: Basics - Jessica Paquette, Florian Hahn [ Video ] [ Slides ]
• ASTImporter: Merging Clang ASTs - Gábor Márton [ Videos ] [ Slides ]
• Developing the Clang Static Analyzer - Artem Dergachev [ Video ] [ Slides ]
• Writing an LLVM Pass: 101 - Andrzej Warzynski [ Video ] [ Slides ]
• Writing Loop Optimizations in LLVM - Kit Barton, Ettore Tiotto, Hal Finkel, Michael Kruse, Johannes Doerfert [ Video ] [ Slides ]
• The Attributor: A Versatile Inter-procedural Fixpoint Iteration Framework - Johannes Doerfert [ Video ] [ Slides ]
• Getting Started with the LLVM Testing Infrastructure - Brian Homerding, Michael Kruse [ Video ] [ Slides ]
• An overview of Clang - Sven van Haastregt, Anastasia Stulova [ Video ] [ Slides ]
• An overview of LLVM - Eric Christopher, Sanjoy Das, Johannes Doerfert [ Video ] [ Slides ]
• How to Contribute to LLVM - Chris Bieneman, Kit Barton [ Video ] [ Slides ]
• My First Clang Warning - Dmitri Gribenko, Meike Baumgartner [ Video ] [ Slides ]

Student Research Competition

• Cross-Translation Unit Optimization via Annotated Headers - William S. Moses [ Video ] [ Slides ]
• Quantifying Dataflow Analysis with Gradients in LLVM - Abhishek Shah [ Video ] [ Slides ]
• Floating Point Consistency in the Wild: A practical evaluation of how compiler optimizations affect high performance floating point code - Jack J Garzella [ Video ] [ Slides ]
• Static Analysis of OpenMP Data Mapping for Target Offloading - Prithayan Barua [ Video ] [ Slides ]

Panels

• Panel: Inter-procedural Optimization (IPO) - Teresa Johnson, Philip Reames, Chandler Carruth, Johannes Doerfert [ Video ]
• The Loop Optimization Working Group - Kit Barton, Michael Kruse, TBD [ Video ]

Birds of a Feather

• LLDB - Jonas Devlieghere
• Towards Better Code Generator Design and Unification for a Stack Machine - Leonid Kholodov, Dmitry Borisenkov
• Debug Info - Adrian Prantl

Lightning Talks

• GWP-ASan: Zero-Cost Detection of MEmory Safety Bugs in Production - Matt Morehouse [ Video ] [ Slides ]
• When 3 Memory Models Aren’t Enough – OpenVMS on x86 - John Reagan [ Videos ] [ Slides ]
• FileCheck: learning arithmetic - Thomas Preud'homme [ Video ] [ Slides ]
• -Wall Found Programming Errors and Engineering Effort to Enable Across a Large Codebase - Aditya Kumar [ Video ] [ Slides ]
• Handling 1000s of OpenCL builtin functions in Clang - Sven van Haastregt [ Video ] [ Slides ]
• NEC SX-Aurora as a Scalable Vector Playground - Simon Moll [ Video ] [ Slides ]
• Implementing Machine Code Optimizations for RISC-V - Lewis Revill [ Videos ] [ Slides ]
• Optimization Remarks Update - Francis Visoiu Mistrih [ Videos ] [ Slides ]
• Supporting Regular and Thin LTO with a Single LTO Bitcode Format - Matthew Voss [ Video ] [ Slides ]
• Transitioning Apple’s Downstream llvm-project Repositories to the Monorepo - Alex Lorenz [ Video ] [ Slides ]
• A Unified Debug Server For Deeply Embedded Systems and LLDB - Simon Cook [ Video ] [ Slides ]
• State of LLDB and Deeply Embedded RISC-V - Simon Cook [ Videos ] [ Slides ]
• Supporting a Vendor ABI Variant in Clang - Paul Robinson [ Video ] [ Slides ]
• Speculative Compilation in ORC JIT - Praveen Velliengiri [ Videos ] [ Slides ]
• Optimization Remarks for Human Beings - William Bundy
• Improving the Optimized Debugging Experience - Orlando Cazalet-Hyams [ Video ] [ Slides ]
• Improving your TableGen Descriptions - Javed Absar [ Video ] [ Slides ]
• Loom: Weaving Instrumentation for Program Analysis - Brian Kidney [ Video ] [ Slides ]
• Clang Interface Stubs: Syntax Directed Stub Library Generation. - Puyan Lotfi [ Video ] [ Slides ]
• Flang Update - Steve Scalpone [ Video ] [ Slides ]
• Lowering tale: Supporting 64 bit pointers in RISCV 32 bit LLVM backend - Reshabh Sharma [ Video ] [ Slides ]
• Virtual Function Elimination in LLVM - Oliver Stannard [ Videos ] [ Slides ]
• Making a Language Cross Platform: Libraries and Tooling - Gwen Mittertreiner [ Video ] [ Slides ]
• Grafter - A use case to implement an embedded DSL in C++ and perform source to source traversal fusion transformation using Clang - Laith Sakka [ Video ] [ Slides ]

Posters

• TON Labs Backend for TON Blockchain - Dmitry Borisenkov, Dmitry Shtukenberg, Leonid Kholodov
• LLVM Build Times Using a Program Repository - Rusell Gallop, Phil Camp
• RISC-V Bit Manipulation Support in the Clang/LLVM Toolchain - Scott Egerton, Paolo Savini
• Attributor, a Framework for Interprocedural Information Deduction - Johannes Doerfert, Hideto Ueno, Stefan Stipanovic
• Overflows Be Gone: Checked C for Memory Safety - Mandeep Singh Grang
• Cross-Translation Unit Optimization via Annotated Headers - William S. Moses
• Quantifying Dataflow Analysis with Gradients in LLVM - Abhishek Shah
• Floating Point Consistency in the Wild: A practical evaluation of how compiler optimizations affect high performance floating point code - Jack J Garzella
• Static Analysis of OpenMP Data Mapping for Target Offloading - Prithayan Barua
• NEC SX-Aurora as a Scalable Vector Playground - Kazuhisa Ishizaka
• A Unified Debug Server For Deeply Embedded Systems and LLDB - Simon Cook
• Speculative Compilation in ORC JIT - Praveen Velliengiri
• Loom: Weaving Instrumentation for Program Analysis - Brian Kidney
• Lowering tale: Supporting 64 bit pointers in RISCV 32 bit LLVM backend - Reshabh Sharma

Round Tables

Round Table Registration

Round tables are informal get togethers where attendees talk about a specific subject. Each group will be given a round table and a flip chart to discuss and brainstorm ideas on a specific topic. If you are interested in organizing a round table discussion, please use the link above.

Round tables may be arranged during the conference, but it is better to schedule in advance so it appears ahead of time on the online schedule. During the conference we will attempt to put the topics online, but we will also list them on a flip chart outside the room where you can add it yourself.

Tuesday, Oct 22, 10:20-11:30

• MLIR meets LLVM: MLIR (Multi-Level IR) has been recently accepted as a sub-project in LLVM. Let's talk about what it means, what are the opportunities for LLVM users, and future evolution for the project.
• Well-defined C++ APIs for LLVM libraries: This Round Table is for users of the LLVM C++ APIs. We will discuss next steps for formalizing the C++ APIs within LLVM, how to reduce the number of symbols exported by LLVM shared libraries, the feasibility of a stabilizing parts of the API and other related topics.

Tuesday, Oct 22, 11:30-12:40

• Discuss llvm-libc: A good number of people have expressed interest in llvm-libc during the discussion on the RFC thread. We would like to get everyone interested in this new project to get together and discuss the direction in which we would like to take it forward.
• VPlan: Next Steps There are a number of features people are working on and we need to make sure we don't duplicate efforts and have a common understanding of the overall design.
• sourcekit-lsp and clangd Discuss topics related to implementing the language server protocol, code indexing, editor support, build system integration, etc. in clangd and sourcekit-lsp.
• Debug Info for optimized code: Do you want to discuss implementation details for representing optimized code debug info? Do you have a question about LiveDebugValues? Do you wonder what's up with entry values? Or do you just wonder how to make your pass debug-info invariant?

Tuesday, Oct 22 2:00-3:10

• Flang: Discuss flang, old flang, and Fortran

Tuesday, Oct 22 3:10-4:20

• Improving LLVM's buildbot instance: http://lab.llvm.org:8011/console is a mess. It has too many builders, yet is missing builders for some platforms. It's slow to load, many of the builders are perma-red, many take hours to cycle, the buildbot page itself is slow to load, etc. Can we improve this?
• OpenMP in LLVM: Opportunity to discuss anything OpenMP related that happens under the LLVM umbrella
• Challenges using LLVM for GPU compilation: Canonicalization vs. GPUs: Type mutation, Control flow mutation (and that graphics shaders are more sensitive to this.), Divergence/reconvergence sensitivity, Address-space awareness
• End-to-end Testing Discussion of end-to-end testing; what kinds of tests we want; logistics
• Security Hardening Features in clang: We will discuss the status of security hardening features in clang, (e.g. -fstack-clash-protection, -D_FORTIFY_SOURCE, and others) look at how clang compares to gcc and talk about future work in this area.
• LLVM for Embedded Baremetal Targets: We will discuss how to build and test LLVM based toolchains that work for Baremetal targets.

Tuesday, Oct 22, 4:40-5:50

• SYCL: Let's talk about SYCL -- the programming model, the open standard, the effort to add SYCL support to clang, etc.
• Upstreaming SYCL C++: SYCL is a single-source C++ standard from Khronos Group (OpenGL, Vulkan, OpenCL, SPIR...) for heterogeneous computing targeting various accelerators (CPU, GPU, DSP, FPGA...). There are several implementations available and one has even started to be upstreamed into Clang/LLVM: https://github.com/intel/llvm
  This is a huge collaborative effort and a great opportunity to have wide & strong support for modern C++ on a wide range of accelerators from many vendors. Come to learn about SYCL, how to help reviewing the patches, how it interacts with existing off-loading support, OpenMP, OpenCL, CUDA, address spaces, SPIR-V...
• Loop Optimizations in LLVM: Discuss current problems, progress and future plans for optimizing loops, existing passes and new passes and analysis being worked on.
• full restrict support in llvm: Now that patches for full restrict are available, this roundtable gives a chance to discuss the design and the patches in person.

Wednesday, Oct 23 10:45-11:55

• Complex Types in LLVM: A discussion on supporting native complex types in LLVM IR for performance and diagnostics.
• Development practices to help avoid security vulnerabilities in llvm: The goal for this round table is to explore what development practices the LLVM community could consider adopting to reduce the probability of security vulnerabilities in some or all of its components.Let's get together at this round table to discuss which development practices - and to which degree - could be good to adopt for which LLVM components. A few examples that could kick off the discussion are: • Using static analyzers. • Using code standard checkers (e.g. clang-tidy -checks=cert-*,bugprone-*,llvm-*). • Using fuzzers more extensively (oss-fuzz does fuzzing on some LLVM components, but do bug reports get reacted on?). • Requiring full code coverage by unit tests on code that is newly added. • Making certain build options on by default (e.g. stack protection). Many of these techniques require buy-in from the whole community to get accepted - a round-table discussion is hopefully a first step towards understanding cost/benefit tradeoffs.
• CMake in LLVM: Discuss the current state of CMake and future areas for improvement.

Wednesday, Oct 23 11:55-12:30

• Interpreting C++: "C++ JITs and REPLs are useful in number of areas such as education and science. The LLDB's expression evaluator, Cling and ClangJIT are based on Clang and its incremental processing facility. The C++ interpreters target to solve different sets of issues, however they share common requirements.
  We would like to use the round table to discuss common requirements when interpreting C++. We would like to invite developers and users interested in interpreting C++. We would like to discuss a possible way forward for implementing JIT and REPL support infrastructure in Clang and LLVM."
• LLVM Releases: Discuss the current release process and possible areas for improvement.
• Vector Predication: Support for predicated SIMD/vector in LLVM is lacking. At this table, we are discussing concrete steps to change that.

Wednesday, Oct 23 1:45-2:55

• Floating point: Discussions related to FENV_ACCESS support, fast math, FMA, complex, etc.
• ClangBuiltLinux: Building the Linux kernel with Clang and LLVM utils

Wednesday, Oct 23 2:55-4:00

• GitHub Next-step: bug-tracker (GitHub issues?) & workflows (pre-merge testing, pull-request, etc.): "We're almost on GitHub! It is a good opportunity to brainstorm on possible evolutions of the workflow and the infrastructure. There are opportunities around being able to run builds and test on code before pushing, and the possibility of using pull-requests either for the purpose of pre-merge testing or for code reviews! Also is bugzilla still providing what we want to track issues? Should we consider GitHub issues? Are there other options?"
• ASTImporter: Discuss future work and direction of ASTImporter
• State of the GN build: LLVM's GN build is an (unsupported!) faster alternative to the CMake build. Try it out, learn about the current state, wallow in build system arcana.
• Clang Static Analyzer: Let's talk about where we are and how we want to move forward with the Static Analyzer.

Wednesday, Oct 23 5:00-5:35

• GSoC: LLVM Google Summer of Code: organization, ideas, projects, etc.
• Scalable Vector Extension: Discuss current progress and forward plans for both SVE and RiscV implementations, focusing on agreed IR representations more than looking at each back-end independently.

Wednesday, Oct 23 5:35-6:10

Travel Grants for Students

The LLVM Foundation sponsors student travel to attend the LLVM Developers' Meeting. Travel grants cover some or all of travel related expenses. This program is open to full time undergraduate and graduate students.

To apply for a travel grant, please fill out this form by August 16th.

Logistics

We have reserved a block of rooms at the Fairmont a block away from the San Jose convention center at a $309.00/night rate. Please use this link for your reservation. Guest rooms will be available on a first come, first serve basis until October 1, 2019.

Code of Conduct

The LLVM Foundation is dedicated to providing an inclusive and safe experience for everyone. We do not tolerate harassment of participants in any form. By registering for this event, we expect you to have read and agree to the LLVM Code of Conduct.

Contact

To contact the organizer, email Tanya Lattner

Diamond Sponsors:

Platinum Sponsors:

Gold Sponsors:

Corporate Supporters

Thank you to our sponsors!