[www] r332941 - Add slides and more links to videos.

Tanya Lattner via llvm-commits llvm-commits at lists.llvm.org
Mon May 21 21:02:29 PDT 2018 

Author: tbrethou
Date: Mon May 21 21:02:29 2018
New Revision: 332941

URL: http://llvm.org/viewvc/llvm-project?rev=332941&view=rev
Log:
Add slides and more links to videos.

Modified:
    www/trunk/devmtg/2017-10/index.html

Modified: www/trunk/devmtg/2017-10/index.html
URL: http://llvm.org/viewvc/llvm-project/www/trunk/devmtg/2017-10/index.html?rev=332941&r1=332940&r2=332941&view=diff
==============================================================================
--- www/trunk/devmtg/2017-10/index.html (original)
+++ www/trunk/devmtg/2017-10/index.html Mon May 21 21:02:29 2018
@@ -64,74 +64,98 @@ for future event announcements and to as
 <p>Keynotes:<br>
 
 <b><a href="#talk12">Falcon: An optimizing Java JIT
-</a></b> - <i>Philip Reames</i><br> [<a href="https://www.youtube.com/watch?v=Uqch1rjPls8&feature=youtu.be">Video</a>] [<a href="http://llvm.org/devmtg/2017-10/slides/Reames-FalconKeynote.pdf">Slides</a>]
+</a></b> - <i>Philip Reames</i> [<a href="https://www.youtube.com/watch?v=Uqch1rjPls8&feature=youtu.be">Video</a>] [<a href="http://llvm.org/devmtg/2017-10/slides/Reames-FalconKeynote.pdf">Slides</a>]<br>
 
 <b><a href="#talk21">Compiling Android userspace and Linux kernel with LLVM
-</a></b> - <i>Stephen Hines, Nick Desaulniers and Greg Hackmann</i><br>
+</a></b> - <i>Stephen Hines, Nick Desaulniers and Greg Hackmann</i>
+[<a href="https://youtu.be/6l4DtR5exwo">Video</a>] [<a href="slides/Hines-CompilingAndroidKeynote.pdf">Slides</a>]<br>
 </p>
 
 <p>Talks:<br>
 <b><a href="#talk1">Apple LLVM GPU Compiler: Embedded Dragons
-</a></b> - <i>Marcello Maggioni and Charu Chandrasekaran</i><br>
+</a></b> - <i>Marcello Maggioni and Charu Chandrasekaran</i>
+[ <a href="https://youtu.be/VFHYaH5Vr4I">Video</a> ] [ <a href="http://llvm.org/devmtg/2017-10/slides/Chandrasekaran-Maggioni-Apple%20LLVM%20GPU%20Compiler.pdf">Slides</a> ] <br>
 
 <b><a href="#talk2">Bringing link-time optimization to the embedded world: (Thin)LTO with Linker Scripts
-</a></b> - <i>Tobias Edler von Koch, Sergei Larin, Shankar Easwaran and Hemant Kulkarni</i><br>
+</a></b> - <i>Tobias Edler von Koch, Sergei Larin, Shankar Easwaran and Hemant Kulkarni</i>
+[ <a href="https://youtu.be/hhaPAKUt35E">Video</a> ] [ <a href="http://llvm.org/devmtg/2017-10/slides/LTOLinkerScriptsEdlerVonKoch.pdf">Slides</a> ]<br>
 
 <b><a href="#talk3">Advancing Clangd: Bringing persisted indexing to Clang tooling
-</a></b> - <i>Marc-Andre Laperle</i><br>
+</a></b> - <i>Marc-Andre Laperle</i>
+[ <a href="https://youtu.be/Y9JB3hlAWeA">Video</a> ] [ <a href="http://llvm.org/devmtg/2017-10/slides/Laperle-Advancing%20Clangd.pdf">Slides</a> ]<br>
 
 <b><a href="#talk4">The Further Benefits of Explicit Modularization: Modular Codegen
-</a></b> - <i>David Blaikie</i><br>
+</a></b> - <i>David Blaikie</i>
+[ <a href="https://youtu.be/lYYxDXgbUZ0">Video</a> ] [ <a href="http://llvm.org/devmtg/2017-10/slides/Blaikie-Modular%20Codegen.pdf">Slides</a> ]<br>
 
 <b><a href="#talk5">eval() in C++
-</a></b> - <i>Sean Callanan</i><br>
+</a></b> - <i>Sean Callanan</i>
+[ <a href="">Video</a> ] [ <a href="">Slides</a> ]<br>
 
 <b><a href="#talk6">The Type Sanitizer: Free Yourself from -fno-strict-aliasing
-</a></b> - <i>Hal Finkel</i><br>
+</a></b> - <i>Hal Finkel</i> 
+[ <a href="https://youtu.be/vAXJeN7k32Y">Video</a> ] [ <a href="http://llvm.org/devmtg/2017-10/slides/Finkel-The%20Type%20Sanitizer.pdf">Slides</a> ] <br><br>
 
 <b><a href="#talk7">Enabling Parallel Computing in Chapel with Clang and LLVM
-</a></b> - <i>Michael Ferguson</i><br>
+</a></b> - <i>Michael Ferguson</i>
+[ <a href="https://youtu.be/hJrYAXn2xFE">Video</a> ] [ <a href="http://llvm.org/devmtg/2017-10/slides/Ferguson-Enabling%20Parallel%20Computing%20in%20Chapel.pdf">Slides</a> ] <br>
+
 
 <b><a href="#talk8">Structure-aware fuzzing for Clang and LLVM with libprotobuf-mutator
-</a></b> - <i>Kostya Serebryany, Vitaly Buka and Matt Morehouse</i><br>
+</a></b> - <i>Kostya Serebryany, Vitaly Buka and Matt Morehouse</i>
+[ <a href="https://youtu.be/U60hC16HEDY">Video</a> ] [ <a href="http://llvm.org/devmtg/2017-10/slides/Serebryany-Structure-aware%20fuzzing%20for%20Clang%20and%20LLVM%20with%20libprotobuf-mutator.pdf">Slides</a> ] <br>
 
 <b><a href="#talk9">Adding Index‐While‐Building and Refactoring to Clang
-</a></b> - <i>Alex Lorenz and Nathan Hawes</i><br>
+</a></b> - <i>Alex Lorenz and Nathan Hawes</i>
+[ <a href="https://youtu.be/jGJhnIT-D2M">Video</a> ] [ <a href="http://llvm.org/devmtg/2017-10/slides/Lorenz-Hawes-Index%20while%20building%20and%20refactoring%20in%20Clang.pdf">Slides</a> ] <br>
 
 <b><a href="#talk10">XRay in LLVM: Function Call Tracing and Analysis
-</a></b> - <i>Dean Michael Berris</i><br>
+</a></b> - <i>Dean Michael Berris</i>
+[ <a href="">Video</a> ] [ <a href="">Slides</a> ] <br>
 
 <b><a href="#talk11">GlobalISel: Past, Present, and Future
-</a></b> - <i>Quentin Colombet and Ahmed Bougacha</i><br>
+</a></b> - <i>Quentin Colombet and Ahmed Bougacha</i>
+[ <a href="https://youtu.be/Zh4R40ZyJ2kY">Video</a> ] [ <a href="http://llvm.org/devmtg/2017-10/slides/Bougacha-Colombet-GlobalISel.pdf">Slides</a> ] <br>
 
 <b><a href="#talk13">Dominator Trees and incremental updates that transcend time
-</a></b> - <i>Jakub Kuderski</i><br>
+</a></b> - <i>Jakub Kuderski</i>
+[ <a href="">Video</a> ] [ <a href="">Slides</a> ] <br>
 
 <b><a href="#talk14">Scale, Robust and Regression-Free Loop Optimizations for Scientific Fortran and Modern C++
-</a></b> - <i>Tobias Grosser and Michael Kruse</i><br>
+</a></b> - <i>Tobias Grosser and Michael Kruse</i>
+[ <a href="https://youtu.be/A8E5KgzZPMM">Video</a> ] [ <a href="http://llvm.org/devmtg/2017-10/slides/Kruse-Regression%20Free%20Loop%20Optimizations.pdf">Slides</a> ] <br>
 
 <b><a href="#talk15">Implementing Swift Generics
-</a></b> - <i>Douglas Gregor, Slava Pestov and John McCall</i><br>
+</a></b> - <i>Douglas Gregor, Slava Pestov and John McCall</i>
+[ <a href="">Video</a> ] [ <a href="">Slides</a> ] <br>
 
 <b><a href="#talk16">lld: A Fast, Simple, and Portable Linker
-</a></b> - <i>Rui Ueyama</i><br>
+</a></b> - <i>Rui Ueyama</i>
+[ <a href="https://youtu.be/yTtWohFzS6s">Video</a> ] [ <a href="http://llvm.org/devmtg/2017-10/slides/Ueyama-lld.pdf">Slides</a> ] <br>
 
 <b><a href="#talk17">Vectorizing Loops with VPlan – Current State and Next Steps
-</a></b> - <i>Ayal Zaks and Gil Rapaport</i><br>
+</a></b> - <i>Ayal Zaks and Gil Rapaport</i>
+[ <a href="https://youtu.be/BjBSJFzYDVk">Video</a> ] [ <a href="http://llvm.org/devmtg/2017-10/slides/Zaks-Vectorizing%20Loops%20with%20VPlan.pdf">Slides</a> ] <br>
 
 <b><a href="#talk18">LLVM Compile-Time: Challenges. Improvements. Outlook.
-</a></b><br> - <i>Michael Zolotukhin</i><br>
+</a></b><br> - <i>Michael Zolotukhin</i>
+[ <a href="https://youtu.be/bYHMwyyZ6Mk">Video</a> ] [ <a href="http://llvm.org/devmtg/2017-10/slides/Zolotukhin-LLVM%20Compile%20Time.pdf">Slides</a> ] <br>
 
 <b><a href="#talk19">Challenges when building an LLVM bitcode Obfuscator
-</a></b> - <i>Serge Guelton, Adrien Guinet, Juan Manuel Martinez and Pierrick Brunet</i><br>
+</a></b> - <i>Serge Guelton, Adrien Guinet, Juan Manuel Martinez and Pierrick Brunet</i>
+[ <a href="">Video</a> ] [ <a href="">Slides</a> ] <br>
 
 <b><a href="#talk20">Building Your Product Around LLVM Releases
-</a></b> - <i>Tom Stellard</i><br>
+</a></b> - <i>Tom Stellard</i>
+[ <a href="">Video</a> ] [ <a href="">Slides</a> ] <br>
+
 </p>
+
+
 <p>
 BoFs:<br>
 <b><a href="#bof1">Storing Clang data for IDEs and static analysis
-</a></b> - <i>Marc-Andre Laperle</i><br>
+</a></b> - <i>Marc-Andre Laperle</i>
 
 <b><a href="#bof2">Source-based Code Coverage BoF
 </a></b> - <i>Eli Friedman and Vedant Kumar</i><br>
@@ -163,10 +187,11 @@ Tutorials:<br>
 
 <b><a href="#tutorial2">Tutorial: Head First into GlobalISel
 </a></b> - <i>Daniel Sanders, Aditya Nandakumar and Justin Bogner</i><br>
+[ <a href="https://youtu.be/Zh4R40ZyJ2k">Video</a> ] [ <a href="http://llvm.org/devmtg/2017-10/slides/Bogner-Nandakumar-Sanders-Head%20First%20into%20GlobalISel.pdf">Slides</a> ] <br>
 
 <b><a href="#tutorial3">Welcome to the back-end: The LLVM machine representation.
-</a></b> - <i>Matthias Braun</i><br>
-
+</a></b> - <i>Matthias Braun</i>
+[ <a href="https://youtu.be/objxlZg01D0">Video</a> ] [ <a href="http://llvm.org/devmtg/2017-10/slides/Braun-Welcome%20to%20the%20Back%20End.pdf">Slides</a> ]<br>
 </p>
 <p>
 Lightning Talks:<br>
@@ -207,19 +232,20 @@ Lightning Talks:<br>
 Student Research Competition:<br>
 
 <b><a href="#src1">VPlan + RV: A Proposal
-</a></b> - <i>Simon Moll and Sebastian Hack</i><br>
+</a></b> - <i>Simon Moll and Sebastian Hack</i>
+[ <a href="https://youtu.be/svMEphbFukw">Video</a> ] [ <a href="">Slides</a> ] <br>
 
 <b><a href="#src2">Polyhedral Value & Memory Analysis
-</a></b> - <i>Johannes Doerfert and Sebastian Hack</i><br>
+</a></b> - <i>Johannes Doerfert and Sebastian Hack</i>
+[ <a href="https://youtu.be/xSA0XLYJ-G0">Video</a> ] [ <a href="">Slides</a> ] <br>
 
 <b><a href="#src3">DLVM: A Compiler Framework for Deep Learning DSLs
-</a></b> - <i>Richard Wei, Vikram Adve and Lane Schwartz</i><br>
-
-<b><a href="#src4">Leveraging LLVM to Optimize Parallel Programs
-</a></b> - <i>William Moses</i><br>
+</a></b> - <i>Richard Wei, Vikram Adve and Lane Schwartz</i>
+[ <a href="https://youtu.be/9fdFbVBUQGs">Video</a> ] [ <a href="">Slides</a> ] <br>
 
 <b><a href="#src5">Exploiting and improving LLVM's data flow analysis using superoptimizer
-</a></b> - <i>Jubi Taneja, John Regehr</i><br>
+</a></b> - <i>Jubi Taneja, John Regehr</i>
+[ <a href="://youtu.be/WyMTa2_yNHQ">Video</a> ] [ <a href="">Slides</a> ] <br>
 
 </p>
 <p>
@@ -275,7 +301,7 @@ Posters:<br>
 <b><a id="talk1">Apple LLVM GPU Compiler: Embedded Dragons
 </a></b><br>
 <i>Marcello Maggioni and Charu Chandrasekaran</i><br>
-[Slides] [<a href="https://youtu.be/VFHYaH5Vr4I">Video</a>] <br>
+[<a href="http://llvm.org/devmtg/2017-10/slides/Chandrasekaran-Maggioni-Apple%20LLVM%20GPU%20Compiler.pdf">Slides</a>] [<a href="https://youtu.be/VFHYaH5Vr4I">Video</a>] <br>
 The adoption of LLVM to develop GPU compilers has been increasing substantially over the years, thanks to the flexibility of the LLVM framework. At Apple, we build LLVM-based GPU compilers to serve the embedded GPUs in all our products.The GPU compiler stack is fully LLVM based. In this talk, we will provide an overview of how we leverage LLVM to implement our GPU compiler: in particular we will provide details about the pipeline we use and we will describe some of the custom passes we added to the LLVM framework that we are considering to contribute to the community. Additionally, we will discuss some of the challenges we face in building a fast GPU compiler that generates performant code. 
 </p>
 
@@ -295,7 +321,7 @@ In this talk, we present a mechanism to
 <b><a id="talk3">Advancing Clangd: Bringing persisted indexing to Clang tooling
 </a></b><br>
 <i>Marc-Andre Laperle</i><br>
-[Slides] [<a href="https://youtu.be/Y9JB3hlAWeA">Video</a>]<br>
+[<a href="http://llvm.org/devmtg/2017-10/slides/Laperle-Advancing%20Clangd.pdf">Slides</a>] [<a href="https://youtu.be/Y9JB3hlAWeA">Video</a>]<br>
 Clangd aims at implementing the Language Server Protocol, a protocol that provides 
 IDEs and code editors all the language "smartness". In this talk, we will cover the new features that have been added to Clangd in the last few months and the features that are being worked on. At the center of those features is a new indexing infrastructure and file format that allows to persist information about all the source files in a code base. We will explain how this information is collected, stored and used in Clangd and how this could potentially be reused by other tools. We will also discuss what the future holds for Clangd and the various challenges such as speeding up indexing time, supporting refactoring and further code sharing between the various Clang tools. 
 This talk is targeted to anyone interested in IDE/Editor tooling as well as indexing technologies.
@@ -305,7 +331,7 @@ This talk is targeted to anyone interest
 <b><a id="talk4">The Further Benefits of Explicit Modularization: Modular Codegen
 </a></b><br>
 <i>David Blaikie</i><br>
-[Slides] [<a href="https://youtu.be/McByO0QgqCY">Video</a>] <br>
+[<a href="http://llvm.org/devmtg/2017-10/slides/Blaikie-Modular%20Codegen.pdf">Slides] [<a href="https://youtu.be/lYYxDXgbUZ0">Video</a>] <br>
 C++ Modules (backwards compatible, or yet-to-be-standardized TS) provide great compile time benefits, but ongoing work can also use the new semantic information available in an explicitly modular build graph to reduce redundant code generation and decrease object sizes. 
 <br>
 Using the Clang as an example, walk through the work necessary to support C++ (backwards compatible) modules in the build graph, demonstrate the benefits and discuss the constraints (including source/layout/layering changes necessary to support this). 
@@ -334,7 +360,7 @@ Getting it right is the tricky part. Luc
 <b><a id="talk6">The Type Sanitizer: Free Yourself from -fno-strict-aliasing
 </a></b><br>
 <i>Hal Finkel</i><br>
-[Slides] [<a href="https://youtu.be/vAXJeN7k32Y">Video</a>] <br>
+[<a href="http://llvm.org/devmtg/2017-10/slides/Finkel-The%20Type%20Sanitizer.pdf">Slides</a>] [<a href="https://youtu.be/vAXJeN7k32Y">Video</a>] <br>
 LLVM provides a metadata-driven type-based alias analysis (TBAA), designed to represent pointer aliasing restrictions from C/C++ type-based aliasing rules, and used by many frontends, that can serve as an important optimization enabler. In the context of C/C++, the programmer bears most of the responsibility for ensuring that the program obeys these rules. As you might expect, programmers often get this wrong. In fact, many programs are compiled with -fno-strict-aliasing, the flag which disables the production of TBAA metadata. LLVM has long featured an extensive set of sanitizers: instrumentation-based tools that can detect violations of the rules restricting defined program behavior. These tools have relatively-low overhead and find an impressive number of bugs. In this talk, I'll describe the type sanitizer. This new sanitizer detects violations of type-aliasing rules allowing the programmer to pinpoint and correct problematic code. I'll cover how the type sanitizer leverages existing TBAA metadata to guide its instrumentation and how it was implemented with relative ease by taking advantage of common infrastructure within compiler-rt. Finally, I'll demonstrate some results from applying the type sanitizer to widely-used open-source software.
 </p>
 
@@ -342,7 +368,7 @@ LLVM provides a metadata-driven type-bas
 <b><a id="talk7">Enabling Parallel Computing in Chapel with Clang and LLVM
 </a></b><br>
 <i>Michael Ferguson</i><br>
-[Slides] [<a href="https://youtu.be/hJrYAXn2xFE">Video</a>] <br>
+[<a href="http://llvm.org/devmtg/2017-10/slides/Ferguson-Enabling%20Parallel%20Computing%20in%20Chapel.pdf">Slides</a>] [ <a href="http://llvm.org/devmtg/2017-10/slides/Ferguson-Enabling%20Parallel%20Computing%20in%20Chapel.key"> Slides (PPT)</a>] [<a href="https://youtu.be/hJrYAXn2xFE">Video</a>] <br>
 The Chapel project includes LLVM support and it uses LLVM and Clang in some strange ways. This talk will discuss three unique ways of using LLVM/Clang in order to share our experience with other frontend authors and with Clang and LLVM developers. In particular, this talk will discuss how the Chapel compiler: uses Clang to provide easy C integration; can inline C code with the generated LLVM; and optimizes communication by using existing LLVM optimizations. 
 <br>
 Chapel is a programming language designed for productive parallel computing on large-scale systems. Chapel's design and implementation have been undertaken with portability in mind, permitting Chapel to run on multicore desktops and laptops, commodity clusters, and the cloud, in addition to the high-end supercomputers for which it was designed. Chapel's design and development are being led by Cray Inc. in collaboration with contributors from academia, computing centers, industry, and the open-source community. 
@@ -352,7 +378,7 @@ Chapel is a programming language designe
 <b><a id="talk8">Structure-aware fuzzing for Clang and LLVM with libprotobuf-mutator
 </a></b><br>
 <i>Kostya Serebryany, Vitaly Buka and Matt Morehouse</i><br>
-[Slides] [<a href="https://youtu.be/U60hC16HEDY">Video</a>] <br>
+[<a href="http://llvm.org/devmtg/2017-10/slides/Serebryany-Structure-aware%20fuzzing%20for%20Clang%20and%20LLVM%20with%20libprotobuf-mutator.pdf">Slides</a>] [<a href="https://youtu.be/U60hC16HEDY">Video</a>] <br>
 Fuzzing is an effective way of finding compiler bugs. Generation-based fuzzers (e.g. Csmith) can create valid C/C++ inputs and stress deep corners of a compiler, but such tools require huge effort and ingenuity to implement for every small subset of the input language. Coverage-guided fuzzing engines (e.g. AFL or libFuzzer) can find bugs with much less effort, but, when applied to compilers, they typically ‘scratch the surface’, i.e. find bugs in the shallow layers of the compiler (lexer, parser). The obvious next step is to combine the semantics-awareness of generation-based fuzzers with the power and simplicity of coverage-guided mutation. 
 <br>
 Protocol buffers are a widely used mechanism for describing and serializing structured data. 
@@ -365,7 +391,7 @@ We will demonstrate the initial version
 <b><a id="talk9">Adding Index‐While‐Building and Refactoring to Clang
 </a></b><br>
 <i>Alex Lorenz and Nathan Hawes</i><br>
-[Slides] [<a href="https://youtu.be/jGJhnIT-D2M">Video</a>] <br>
+[<a href="http://llvm.org/devmtg/2017-10/slides/Lorenz-Hawes-Index%20while%20building%20and%20refactoring%20in%20Clang.pdf">Slides</a>] [ <a href="http://llvm.org/devmtg/2017-10/slides/Lorenz-Hawes-Index%20while%20building%20and%20refactoring%20in%20Clang.key"> Slides (Keynote)</a> ] [<a href="https://youtu.be/jGJhnIT-D2M">Video</a>] <br>
 This talk details the Clang enhancements behind the new index‐while‐building functionality and refactoring engine introduced in Xcode 9. We first describe the new -index-store-path option, which provides indexing data as part of the compilation process without adding significantly to build times. The design, data model, and implementation of this feature are detailed for potential adopters and contributors. The second part of the talk introduces Clang's new refactoring engine, which builds on Clang's libTooling. We list the set of supported refactoring actions, illustrate how a new action can be constructed, and describe how the engine can be used by end users and adopted by IDEs. We also outline the design of the engine and describe the advanced refactoring capabilities planned for the future.
 </p>
 
@@ -381,7 +407,7 @@ Debugging high throughput, low-latency C
 <b><a id="talk11">GlobalISel: Past, Present, and Future
 </a></b><br>
 <i>Quentin Colombet and Ahmed Bougacha</i><br>
-[Slides] [<a href="https://youtu.be/McByO0QgqCY">Video</a>] <br>
+[<a href="http://llvm.org/devmtg/2017-10/slides/Bougacha-Colombet-GlobalISel.pdf">Slides</a>] [<a href="https://youtu.be/McByO0QgqCY">Video</a>] <br>
 Over the past year, we made the new global instruction selector framework (GlobalISel) a real thing. During this effort, we refined the design of and the infrastructure around the framework to make it more amenable to new contributions both for GlobalISel clients and core developers. 
 In this presentation, we will point out what changed since last year and how it impacts and improves the life of backend developers. Moreover, we will go over the performance characteristics of GlobalISel and design choices we made to meet the performance goals while not sacrificing on the core principles of GlobalISel. 
 Finally, we will sketch a plan for moving forward and hint at where more help would be appreciated. 
@@ -416,7 +442,7 @@ Finally, we will look at the new API for
 <b><a id="talk14">Scale, Robust and Regression-Free Loop Optimizations for Scientific Fortran and Modern C++
 </a></b><br>
 <i>Tobias Grosser and Michael Kruse</i><br>
-[Slides] [<a href="https://youtu.be/A8E5KgzZPMM">Video</a>] <br>
+[<a href="http://llvm.org/devmtg/2017-10/slides/Kruse-Regression%20Free%20Loop%20Optimizations.pdf">Slides</a>] [<a href="https://youtu.be/A8E5KgzZPMM">Video</a>] <br>
 Modern C++ code and large scale scientific programs pose unique challenges when 
 applying high-level loop transformations, which -- together with a push towards 
 robustness and performance-regression freedom -- have been driving the 
@@ -489,7 +515,7 @@ Swift is a safe and efficient systems la
 <b><a id="talk16">lld: A Fast, Simple, and Portable Linker
 </a></b><br>
 <i>Rui Ueyama</i><br>
-[Slides] [<a href="https://youtu.be/yTtWohFzS6s">Video</a>] <br>
+[<a href="http://llvm.org/devmtg/2017-10/slides/Ueyama-lld.pdf">Slides</a>] [<a href="https://youtu.be/yTtWohFzS6s">Video</a>] <br>
 lld is a drop-in replacement for system linkers that supports ELF (Unix), COFF (Windows) and Mach-O (macOS) in descending order of completeness. We made a significant progress over the last few years in particular for ELF, and our linker is now considered a real alternative to GNU linkers as most compatibility issues has been resolved. Some large systems, including FreeBSD, are switching from GNU ld to lld. 
 <br>
 lld is usually 10x faster than GNU bfd linker for linking large programs. Even compared to high-performance GNU gold linker, it is still more than 2x faster, yet it is massively simpler than that (26K LOC vs 164K LOC). Because of its simple design, it is easy to add a new feature, port it to a new architecture, or even port it to a new file format such as the WebAssembly object file. In this talk, I'll describe the status of the project and the internal architecture that makes lld that fast and simple.
@@ -499,7 +525,7 @@ lld is usually 10x faster than GNU bfd l
 <b><a id="talk17">Vectorizing Loops with VPlan – Current State and Next Steps
 </a></b><br>
 <i>Ayal Zaks and Gil Rapaport</i><br>
-[Slides] [<a href="https://youtu.be/BjBSJFzYDVk">Video</a>] <br>
+[<a href="http://llvm.org/devmtg/2017-10/slides/Zaks-Vectorizing%20Loops%20with%20VPlan.pdf">Slides</a>] [<a href="http://llvm.org/devmtg/2017-10/slides/Zaks-Vectorizing%20Loops%20with%20VPlan.pptx"> Slides (PPT) </a>]  [<a href="https://youtu.be/BjBSJFzYDVk">Video</a>] <br>
 The VPlan model was first introduced into LLVM’s Loop Vectorizer to record all vectorization decisions taken inside a candidate vectorized loop body, and to carry them out after selecting the best vectorization and unroll factors. This talk focuses on next steps in refactoring the Loop Vectorizer and extending the VPlan model. We describe how instruction-level aspects including def/use relations are added to VPlan, and demonstrate their use in modelling masking. In addition, we show how predication decisions can be taken based on an initial VPlan version, and how the resultant masking can be recorded in a transformed VPlan version. This is a first example of a VPlan-to-VPlan transformation, paving the way for better predication and for outer-loop vectorization. 
 <br>
 We conclude the talk by reviewing several potential directions to further extend and leverage the VPlan model, including vectorizing remainder loops, versioning vectorized loops, and SLP vectorization. 
@@ -514,7 +540,7 @@ Joint work of the Intel vectorization te
 <b><a id="talk18">LLVM Compile-Time: Challenges. Improvements. Outlook.
 </a></b><br>
 <i>Michael Zolotukhin</i><br>
-[Slides] [<a href="https://youtu.be/bYHMwyyZ6Mk">Video</a>] <br>
+[<a href="http://llvm.org/devmtg/2017-10/slides/Zolotukhin-LLVM%20Compile%20Time.pdf">Slides</a>] [<a href="https://youtu.be/bYHMwyyZ6Mk">Video</a>] <br>
 This talk discusses the open source infrastructure and methodology to stay on top of compile-time regressions. It looks at the history of regressions in the past two years, highlights the reasons for major regressions, and dives into the details how some regressions could be recovered and others prevented. Beyond providing insight into the nature of past regressions the talk points out specific areas for future compile-time improvements.
 </p>
 
@@ -573,7 +599,7 @@ In this talk, we will look at how everyo
 <b><a id="talk21">Compiling Android userspace and Linux kernel with LLVM
 </a></b><br>
 <i>Stephen Hines, Nick Desaulniers and Greg Hackmann</i><br>
-[Slides] [<a href="https://youtu.be/6l4DtR5exwo">Video</a>]<br>
+[<a href="slides/Hines-CompilingAndroidKeynote.pdf">Slides</a>] [<a href="https://youtu.be/6l4DtR5exwo">Video</a>]<br>
 A few years ago, a few \strikethrough{reckless} brave pioneers set out to switch Android to Clang/LLVM for its userland toolchain. Over the past few months, a new band of \strikethrough{willing victims} adventurers decided that it wasn’t fair to leave the kernel out, so they embarked to finish the quest of the LLVMLinux folks with the Linux kernel. This is the epic tale of their journey. From the Valley of Miscompiles to the peaks of Warning-Clean, we will share the glorious stories of their fiercest battles. 
 <br>
 This talk is for anyone interested in deploying Clang/LLVM for a large production software codebase. It will cover both userland and kernel challenges and results. We will focus on our experiences in diagnosing and resolving a multitude of issues that similar \strikethrough{knights} software engineers might encounter when transitioning other large projects. Best practices that we have discovered will also be shared, in order to help other advocates in their own quests to spread Clang/LLVM to their projects. 
@@ -584,7 +610,7 @@ This talk is for anyone interested in de
 <b><a id="bof1">Storing Clang data for IDEs and static analysis
 </a></b><br>
 <i>Marc-Andre Laperle</i><br>
-[Slides] <br>
+[<a href="http://llvm.org/devmtg/2017-10/slides/Laperle-Storing%20Clang%20Data.pdf">Slides</a>] <br>
 This discussion aims at exploring different solutions to storing information derived from parsing files using Clang. For example, tools such as Clangd, IDEs and static analyzers need to store information about an entire code base by maintaining indexes, cross-referencing files, etc. These features need to be fast and not recomputed needlessly. Topics could range from how data is modeled, what kind of file format to use and how different tools can minimize the duplication of effort. 
 </p>
 
@@ -699,7 +725,7 @@ This tutorial covers the following groun
 <b><a id="tutorial2">Tutorial: Head First into GlobalISel
 </a></b><br>
 <i>Daniel Sanders, Aditya Nandakumar and Justin Bogner</i><br>
-[Slides] [<a href=https://youtu.be/Zh4R40ZyJ2k"">Video</a>] <br>
+[<a href="http://llvm.org/devmtg/2017-10/slides/Bogner-Nandakumar-Sanders-Head%20First%20into%20GlobalISel.pdf">Slides</a>] [<a href="http://llvm.org/devmtg/2017-10/slides/Bougacha-Colombet-GlobalISel.key"> Slides (Keynote) </a>] [<a href=https://youtu.be/Zh4R40ZyJ2k"">Video</a>] <br>
 GlobalISel has been getting a lot of attention lately, and by now you're 
 probably wondering when and how you'll need to port your own favourite 
 backend. We'll ignore the when for now, but in this tutorial we'll dive 
@@ -722,7 +748,7 @@ porting your own backend to GlobalISel.
 <b><a id="tutorial3">Welcome to the back-end: The LLVM machine representation.
 </a></b><br>
 <i>Matthias Braun</i><br>
-[Slides] [<a href="https://youtu.be/objxlZg01D0">Video</a>] <br>
+[<a href="http://llvm.org/devmtg/2017-10/slides/Braun-Welcome%20to%20the%20Back%20End.pdf">Slides</a>] [<a href="https://youtu.be/objxlZg01D0">Video</a>] <br>
 This tutorial gives an introduction to the LLVM machine representation which is 
 used between instruction selection and machine code emission. After an 
 introduction the tutorial will pick representative examples across different 
@@ -883,24 +909,6 @@ To demonstrate an end-to-end system from
 
 </p>
 
-
-<p>
-<b><a id="src4">Leveraging LLVM to Optimize Parallel Programs
-</a></b><br>
-<i>William Moses</i><br>
-<i>Unfortunately this talk was unable to be presented</i>
-LLVM is an effective framework for representing and optimizing programs, both for end-users as well as researchers. When it comes to optimizing or analyzing parallel programs, however, the path forward is far from clear. 
-<br>
-As is the case for most compilers, in Clang/LLVM parallel linguistic constructs (such as those provided by OpenMP or Cilk) are treated as syntactic sugar for closures that are passed to a parallel runtime. This prevents traditional analysis and optimization from interacting with parallel programs. Remedying this situation, however, has generally thought to require an extensive reworking of compiler analyses and code transformations. 
-<br>
-Recently, we have introduced Tapir – an extension to serial compiler IR such as LLVM, that allows the compiler to analyze and optimize parallel tasks with minimal modification. We successfully implemented a prototype compiler on top of LLVM that succeeded in our original goal of permitting serial optimizations to work with parallel code and only had to change roughly 6000 lines out of LLVM’s 3 million. 
-<br>
-This success led us to kickstart “project Rhino,” in which we developed analysis and optimization specifically for parallel code. We were able to derive optimizations that exploit parallel semantics.  For example, we developed code-motion optimizations for parallel codes that are not provably safe for serial code. Unfortunately, in performing these optimizations, we found that vanilla Tapir fell short. There exist optimized forms of parallel programs that can’t be represented by Tapir. Happily, however, we were able to remedy this with a minor modification. 
-<br>
-The work was conducted in collaboration with Tao B. Schardl and Charles E. Leiserson as well as Douglas Kogut, Jiahao Li, and Bojan Serafimov.
-
-</p>
-
 
 <p>
 <b><a id="src5">Exploiting and improving LLVM's data flow analysis using superoptimizer

More information about the llvm-commits mailing list