This tutorial is targeted at researchers and practitioners interested in building efficient domain specific languages (DSLs) and program generators. Lightweight Modular Staging (LMS) is a pragmatic approach to runtime code generation in Scala, and Delite is a compiler framework for embedded DSLs that simplifies the process of implementing DSLs for parallel computation and heterogeneous targets. This tutorial provides an overview of the technology stack, demonstrates use-cases where it has been successfully applied and guides the attendees step-by-step through creation of simple generators and DSLs.
- High-level overview of LLVM & Clang
- Will include how to get started coding on LLVM & Clang
- Overview of core design elements, data structures, APIs, and patterns used in the codebase
- High-level testing strategy for LLVM & Clang using tools like Clang’s ‘-verify’, opt, llc, FileCheck, and GoogleTest
- Process of submitting a patch, code review, and community interactions
- How to add an optimization pass to LLVM
- Tutorial on the LLVM IR both in the abstract and at the level of internal APIs
- Basic APIs and data structures needed to implement, test, and wire a new pass into the compiler.
- Overview of the relationship between transform and analysis passes.
- Overview of the different kinds of transformation passes, how they interact, and what they can and can’t do
- Actually add a transformation pass and an analysis pass to the compiler that depend on each other and exercise this machinery.
- Includes authoring relevant tests for each component
- High-level overview of the architecture of an LLVM backend, with an emphasis on modifying or enhancing existing backends rather than adding a new one
- Detailed review of where things are: from SelectionDAG to FastISel to the register allocator
- Detailed review of exactly how a backend’s tablegen works, and how to make changes there and debug things
- Add a target-independent SelectionDAG combine to the code generator
- Include detailed walk through of the relevant DAG combine interfaces.
- Add a target-specific DAG combine with special consideration of legalization
- Add support for a new instruction pattern to a backend
- Every bit of performance matters, and how the LLVM coding standard helps here
Assorted Mixed Greens with Poached Pear, Sweet Onion Mustard Dressing on the side.
Chicken Breast with Mushrooms topped with Cream Sauce.
Salmon with Capers topped with Lemon-Butter Sauce.
Strawberry or Chocolate Mousse
This workshop will cover design and implementation of Halide, a domain-specific language and compiler for image processing and stencil computation, for people interested in using and building on it as a highly configurable code generator. As a language now in widespread production use, Halide is an interesting and high-impact platform for research on program transformation and code generation; as a language with explicit algebraic control over a wide range of loop synthesis and code generation strategies, it is a powerful backend for other languages and systems, especially those including stencil computation.
- The Halide programming model
- Halide’s model of scheduling for loop synthesis
- Examples of program transformation and synthesis via Halide schedules
- Code generation in Halide
- Mapping to the GPU and heterogeneous parallel execution via Halide schedules
- Hands-on session with Halide, focussed on scheduling and code generation
In this tutorial, the attendees will have the opportunity to delve into the topic of application auto-tuning, presented by developers and performance engineers from the Auto-Tune project. This tutorial will provide a practical perspective to auto-tuning, exemplifying with use cases how to best harness and tailor performance analysers to tune real applications.
In recent years, Field-Programmable Gate Arrays have become extremely powerful computational platforms that can efficiently solve many complex problems. Modern FPGAs comprise effectively millions of programmable elements, signal processing elements and high-speed interfaces, all of which are necessary to deliver a complete solution. The power of FPGAs is unlocked via low-level programming languages such as VHDL and Verilog, which allow designers to explicitly specify the behavior of each programmable element. While these languages provide a means to create highly efficient logic circuits, they are akin to “assembly language” programming for modern processors. This is a serious limiting factor for both productivity and the adoption of FPGAs on a wider scale.
In this tutorial, we use the OpenCL language to explore techniques that allow us to program FPGAs at a level of abstraction closer to traditional software-centric approaches. OpenCL is an industry standard parallel language based on ‘C’ that offers numerous advantages that enable designers to take full advantage of the capabilities offered by FPGAs, while providing a high-level design entry language that is familiar to a wide range of programmers.
The challenge of mapping a ‘C’ based language to FPGAs is that these languages all have implicit assumptions that the underlying architecture executing these programs is a processor based architecture. Processors are characterized by a sequence of instructions that control a datapath that manipulates data values stored in a memory. Conversely, FPGA architectures are more suited to implementing spatial computing circuits where data flows in a pipelined fashion from one functional unit to the next until computations are complete. Data can be transferred efficiently by wires, registers or FIFOs without always resorting to external storage. This tutorial will explore compiler optimizations and code generation techniques that can transform sequential programs into efficient streaming dataflow circuits for FPGAs. We will examine specific case studies of DSP filters, image processing and mathematical computations to demonstrate how these techniques can be applied to real world examples.
This tutorial will cover the usage of OpenTuner, a open source framework for building domain-specific multi-objective program autotuners. OpenTuner supports fully customizable configuration representations, an extensible technique representation to allow for domain-specific techniques, and an easy to use interface for communicating with the tuned program. A key capability inside OpenTuner is the use of ensembles of disparate search techniques simultaneously. Techniques which perform well will receive larger testing budgets and techniques which perform poorly will be disabled. OpenTuner has been used by a number of different projects to build domain specific autotuners.
The topics covered in the workshop will be:
- Overview of autotuning: including a history of past autotuning projects and how autotuning is used today
- Machine learning primer: empirical search, model based techniques, and which technique is right for you
- OpenTuner framework: how is it designed and how you should use it
- Examples of using opentuner: presentations by current users of opentuner
- What makes a good search space representation: the secret sauce of autotuning
- How to go about autotuning your system with OpenTuner
- Hands-on session with OpenTuner
This tutorial will discuss an open-source framework for creating Pintools, which are analysis tools for the dynamic binary instrumentation tool named Pin, named Pin++. Pin++ is an object-oriented framework that uses template meta-programming to implement Pintools. The goal of Pin++ is to simplify programming a Pintool and promote reuse of its components across different Pintools. Our results show that Pintools implemented using Pin++ can have a 54% reduction in complexity, increase in its modularity, and up to 60% reduction in instrumentation overhead.
This tutorial will focus on the following key concepts in Pin++:
- It will discuss the challenges of implement a Pintool using the traditional approach.
- It will discuss how Pin++ addresses existing challenges when authoring Pintools.
- Using hands-on examples, it will discuss how to implement basic Pintools using Pin++ so the audience can begin exploring how to apply Pin++ to their existing problems.
Classic Caesar Salad with Dressing on the side.
Seafood Kebab with Salsa Fresca
Tomatoes alla Parmigiana
This tutorial will present the DynamoRIO tool platform and describe how to use its API to build custom tools that utilize dynamic code manipulation for instrumentation, profiling, analysis, optimization, introspection, security, and more. The DynamoRIO tool platform was first released to the public in June 2002 and has since been used by many researchers to develop systems ranging from taint tracking to prefetch optimization. DynamoRIO is publicly available in open source form and targets Windows, Linux, and Mac on x86 and Linux on ARM.
The tutorial will cover the following topics:
- DynamoRIO API: an overview of the full range of DynamoRIO’s powerful API, which abstracts away the details of the underlying infrastructure and allows the tool builder to concentrate on analyzing or modifying the application’s runtime code stream. It includes both high-level features for quick prototyping and low-level features for full control over instrumentation.
- DynamoRIO system overview: a brief description of how DynamoRIO works under the covers.
- Description of tools provided with the DynamoRIO package, including the Dr. Memory memory debugging tool, the DrCov code coverage tool, and the DrStrace Windows system call tracing tool.
- Sample tool starting points for building new tools
- Advanced topics when building sophisticated tools
The tutorial will cover the following topics:
- Graal: a new high-performance dynamic compiler for Java written in Java
- Introduction to the Graal intermediate representation, and how it simplifies speculative optimizations
- Graal API: Separation of the compiler from the VM
- Snippets: expressing high-level semantics in low-level Java code
- Integration of the compiler with an application/library – and how that can help your research project.
- Using Graal for static analysis
- Graal as a compiler for dynamic programming languages
- Project Sumatra: Compiling for the GPU