For full conference details, see the website: http://llvm.org/devmtg/2019-10/
Back To Schedule
Tuesday, October 22 • 10:20am - 12:15pm
Student Research Competition

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

Cross-Translation Unit Optimization via Annotated Headers
William S. Moses
LLVM automatically derives facts that are only used while the respective translation unit, or LLVM module, is processed (i.e. constant function, error-throwing, etc). This is true both in standard compilation but also link-time-optimization (LTO) in which the module is (partially) merged with others in the same project at link time. LTO is able to take advantage of this to optimize functions calls to outside the translation unit. However, LTO doesn't solve the problem for two reasons of practicality: LTO comes with a nontrivial compile-time investment; and many libraries upon which a program could depend, do not ship with LTO information, simply headers and binaries. In this extended abstract, we solve the problem by generating annotated versions of the source code that also include this derived information. Such an approach has the benefits of both worlds: allowing optimizations previously limited to LTO without running LTO and only providing headers. Such headers are created by modifying Clang to understand three custom attributes to represent arbitrary LLVM function attributes and modifying LLVM to emit C-compatible headers with the aforementioned attribute. Finally, we test the approach experimentally on the DOE RSBench proxy application and verify that it provides the expected speedups.

Quantifying Dataflow Analysis with Gradients in LLVM
Abhishek Shah
Dataflow Analysis has been used in the secure software development cycle for exploit analysis, identifying privacy violations, and guided fuzzing. One approach, dynamic taint tracking, tracks dataflow between a set of source and sink variables with binary taint labels but suffers from high false positives/negatives due its imprecise propagation rules. To address this, we introduce a new theoretically grounded approach, Proximal Gradient Analysis (PGA), to track more accurate and fine-grained dataflow information than dynamic taint tracking. This information is captured in the form of a gradient, which precisely quantifies dataflows (magnitude and direction) between program variables. Because programs contain many discontinous operations (e.g. bitwise operations), we use proximal gradients, a mathematical generalization of gradients for discontinuous functions, to apply the chain rule from calculus to accurately compose and propagate gradients over a program's discontinuous functions with minimal error. 
We implement PGA as a new type of code sanitizer in the LLVM Framework based on the existing dynamic taint tracking sanitizer DataFlowSanitizer. Our main contributions are to use non-smooth calculus for dataflow tracking in real-world programs with PGA and to implement our PGA framework for automatically computing and tracking proximal gradients as an LLVM Sanitizer.

Floating Point Consistency In the Wild: A practical evaluation of how compiler optimizations affect high performance floating point code
Jack J Garzella
Using the FLiT compilation tool, we evaluate Physics-related high-performance codebases, by recompiling each one with LLVM, GCC, and Intel, at every optimization level and all sorts of FP-related flags.

Static Analysis of OpenMP data mapping for target offloading
Prithayan Barua
OpenMP offers directives for offloading computations from CPU hosts to accelerator devices such as GPUs. A key underlying challenge is in efficiently managing the movement of data across the host and the accelerator. We have developed a static analysis tool to address this challenge. The first component is an LLVM analysis pass to interpret the semantics of the OpenMP map clause and deduce the data transfers introduced by them. The second component of our tool is an interprocedural data flow analysis, developed on top of LLVM memory SSA to capture the use-def information of Array variables. Our tool computes how the OpenMP data mapping clauses modify the use-def chains of the baseline program. And finally, it validates if the data mapping in the OpenMP program respects the original use-def chains of the baseline sequential program. Our tool reports diagnostics, to help the developer debug and understand the usage of map clauses in their application. We evaluated our tool over some standard benchmarks and also show its effectiveness by detecting commonly reported bugs.


William S. Moses

Massachusetts Institute of Technology

Abhishek Shah

Columbia University

Jack J Garzella

University of Utah

Prithayan Barua

Georgia Institute of Technology

Tuesday October 22, 2019 10:20am - 12:15pm PDT
Breakout Room-1 (LL21AB)