Loading…
For full conference details: http://llvm.org/devmtg/2017-10/
Back To Schedule
Wednesday, October 18 • 2:15pm - 3:15pm
Lightning Talks

Sign up or log in to save this to your schedule, view media, leave feedback and see who's attending!

Feedback form is now closed.
Porting OpenVMS using LLVM 
John Reagan
The OpenVMS operating system is being ported to x86-64 using LLVM and clang as the basis for our entire compiler suite. This lightning talk will give a brief overview of our approach, current status, and interesting obstacles encountered by using LLVM on OpenVMS itself to create the three cross-compilers to build the base OS.
Porting LeakSanitizer: A Beginner\'s Guide 
Francis Ricci
LeakSanitizer was originally designed as a replacement tool for Heap Checker from gperftools, but currently supports far fewer platforms. Porting LeakSanitizer to new platforms improves feature parity with Heap Checker and will allow a larger set of users to take advantage of LeakSanitizer\'s performance and ease-of-use. In addition, this allows LeakSanitizer to fully replace Heap Checker in the long run. This talk will use details from my experience porting LeakSanitizer to Darwin to describe the necessary steps to port LeakSanitizer to new platforms. For example: handling of thread local storage, platform-specific interceptors, suspending threads, obtaining register information, and generating a process memory map.
Code Size Optimization: Interprocedural Outlining at the IR Level 
River Riddle
Outlining finds common code sequences and extracts them to separate functions, in order to reduce code size. This talk introduces a new generic outliner interface and the IR level interprocedural outliner built on top of it. We show how outlining, with the use of relaxed equivalency, can lead to noticeable code size savings across all platforms. We discuss pros and cons, as well as how the new framework, and extensions to it, can capture many complex cases.
ThreadSanitizer APIs for external libraries 
Kuba Mracek
Besides finding data races on direct memory accesses from instrumented code, ThreadSanitizer can now be used to find races on higher-level objects. In this lightning talk, we’ll show how libraries can adopt the new ThreadSanitizer APIs to detect when their users violate threading requirements. These APIs have been recently added to upstream LLVM and are already being used by Apple system frameworks to find races against collection objects, e.g. NSMutableArray and NSMutableDictionary.
A better shell command-line autocompletion for clang 
Yuka Takahashi
This talk introduces clang’s new autocompletion feature that allows better integration of third-party programs such as UNIX shells or IDEs with clang’s command line interface. We added a new command line interface with the `--autocomplete` flag to which a shell or an IDE can pass an incomplete clang invocation. Clang then returns a list of possible flag completions and their descriptions. To improve these completions, we also extended clang’s data structures with information about the values of each flag. For example, when asking bash to autocomplete the invocation `clang -fno-sanitize-coverage=`, bash is now able to list all values that sanitize coverage accepts. Since LLVM 5.0 release, you can always get an accurate list of flags and their values, any time on any further clang version behind a highly portable interface. As a first shell implementation, we built a bash-completion plugin that uses this API, and we’re soon be bringing this feature to other shells. There are other third-party projects that are interested in using this API as well.
A CMake toolkit for migrating C++ projects to clang’s module system. 
Raphael Isemann
Clang’s module feature not only reduces compilation times, but also brings entirely new challenges to build system maintainers. They face the task to modularize the project itself and a variety of used system libraries, which often requires in-depth knowledge of operating systems, library distributions, and the compiler. To solve this problem we present our work on a CMake toolkit for modularizing C++ projects: it ships with a large variety of module maps that are automatically mounted when the corresponding system library is used by the project. It also assists with modularizing the project’s own headers and performs checks that the current module setup does not cause the build process itself to fail. And last but not least: it requires only trivial changes to integrate into real-world build systems, allowing the migration of larger projects to clang’s module system in a matter of hours. 
Debugging of optimized code: Extending the lifetime of local variables 
Wolfgang Pieb
Local variables and function parameters are often optimized away by the backend. As a result, they are either not visible during debugging at all, or only throughout parts of their lexical parent scope. In the PS4 compiler we have introduced an option that forces the various optimization passes to keep local variables and parameters around until the end of their parent scope. The talk addresses implementation, effectiveness, and performance impact of this feature.
Enabling Polyhedral optimizations in TensorFlow through Polly 
Annanay Agarwal, Michael Kruse, Brian Retford, Tobias Grosser and Ramakrishna Upadrasta
TensorFlow, a deep learning library by Google, has been widely adopted in industry and academia: with cutting edge research and numerous practical applications. Since these programs have come to be run on devices ranging from large scale clusters to hand-held mobile phones, improving efficiency for these computationally intensive programs has become of prime importance. This talk explains how polyhedral compilation, one of the most powerful transformation techniques for deeply nested loop programs, can be leveraged to speed-up deep learning kernels. Through an introduction to Polly’s transformation techniques, we will study their effect on deep learning kernels like Convolutional Neural Networks (CNNs).
An LLVM based Loop Profiler 
Shalini Jain, Kamlesh Kumar, Suresh Purini, Dibyendu Das and Ramakrishna Upadrasta
It is well understood that programs spend most of their time in loops. The application writer may want to know the measure of time-taken for each loop in large programs, so that (s)he can then focus on these loops for applying optimizations. Loop profiling is a way to calculate loop-based run-time information such as execution-time, cache-miss equations and other runtime metrics, which help us to analyze code to fix performance related issues in the code base. This is achieved by instrumenting/annotating the existing input program. There already exist loop-profilers for conventional languages like C++, Java etc., both in open-source and commercial domain. However, as far as we know, there is no such loop-profiler available for LLVM-IR; such a tool would help LLVM users analyze loops in LLVM-IR. Our work mainly focuses around developing such a generic loop profiler for LLVM-IR. It can thus be used for any language(s) which have a LLVM IR. 
Our current work proposes an LLVM based loop-profiler which works on the IR level and gives execution times, and total number of clocks for each loop. Currently, we focus on the inner-most loop(s) as well as each individual loop(s) for collecting run-time profiling data. Our profiler works on LLVM IR and inserts the instrumented code into the entry and exit blocks of each loop. [More on the website]

Introsort based sorting function for libc++ 
Divya Shanmughan and Aditya Kumar
The sorting algorithm currently employed in libc++ library uses quicksort with tail recursion elimination, as a result of which the worst case complexity turns out to be O(N^2), and the recursion stack space to be O(LogN). This talk will present the work done to reduce the worst case time complexity, by employing Intro

Speakers
avatar for Annanay Agarwal

Annanay Agarwal

Site Reliability Engineer, Media.net
My open-source journey began in 2017 with my participation in the Google Summer of Code program under the LLVM Compiler Infrastructure project. Currently, I'm employed as a Site Reliability Engineer at Media.net, and am active contributor to the JaegerTracing and OpenCensus projects... Read More →
avatar for Petr Hosek

Petr Hosek

Software Engineer, Google
I manage the team responsible for the LLVM-based toolchain used by Fuchsia operating system.
avatar for Raphael Isemann

Raphael Isemann

Mail: teemperor@gmail.com
SJ

Shalini Jain

Indian Institute of Technology, Hyderabad
avatar for Aditya Kumar

Aditya Kumar

Software Engineer, Snap Inc
I've been working on LLVM since 2012. I've contributed to modern compiler optimizations like GVNHoist, Hot Cold Splitting, Hexagon specific optimizations, clang static analyzer, libcxx, libstdc++, and graphite framework of gcc.
WP

Wolfgang Pieb

SN Systems/Sony Interactive Entertainment America
avatar for John Reagan

John Reagan

Principal Software Engineer, VMS Software Inc
Head of compiler development for OpenVMS at VMS Software Inc.John has been working on OpenVMS compilers since 1983 and has generated code for VAX, Alpha, Itanium, x86-64, MIPS, and others. John is leading the team to rehost LLVM to OpenVMS and attach most of the existing OpenVMS frontends... Read More →
avatar for Francis Ricci

Francis Ricci

Software Engineer, Facebook
RR

River Riddle

Sony Interactive Entertainment
avatar for Yuka Takahashi

Yuka Takahashi

University of Tokyo
Mail: yukatkh@gmail.com


Wednesday October 18, 2017 2:15pm - 3:15pm PDT
1 - General Session (Rm LL20ABCD)