You are here: Home / Conferences / PIPS Tutorial at CGO 2011

PIPS Tutorial at CGO 2011

---

Title

 PIPS: An Interprocedural Extensible Source-to-Source Compiler Infrastructure for Code/Application Transformations and Instrumentations

List of presenters

Summary

The design of hardware platforms has to meet several constraints such as execution time, energy consumption and system cost. In the recent years, Moore's Law has made many innovative architectural designs a reality, resulting in increasingly complex and heterogeneous target systems, and soaring programming costs.

To keep up with this situation, today's compilers must handle whole applications, redefine functional boundaries regardless of the APIs used, and target different processors simultaneously, yet their development cost must remain under control.

The PIPS compiler framework was designed in 1988 at MINES ParisTech to research interprocedural parallelization. It was based on core ideas that are still relevant today. The PIPS framework:

  •  has been used to generate automatic code distribution, OpenMP-to-MPI code translation, HPF Compiler, automatic C and   Fortran to CUDA translation, code modelization for graphic IDEs,
      genetic algorithm-based optimizations, SIMD (SSE, AVX...) portable code generation and code optimization for FPGA-based accelerators.
  • provides a flexible and scriptable pass manager;
  • supports entire Fortran 77 and C applications, while handling call sites, function definitions and missing library source code;
  • is easily extensible, via text declarations of all analyses, transformations and key data structures;
  • ensures global consistency of the various analyses and transformations thanks to these declarations;
  • uses dynamic typing to support automatic consistency check, allocation / deallocation, copy, iterators and persistance for any object, however complex (the NewGen tool and runtime with XML
     back-end);
  • uses sparse linear algebra as a powerful underlying proof mechanism.

After 20 years of development and constant improvement, PIPS is a robust source-to-source compiler, providing a large set of program analyses and transformations with around 300 phases. Instead of reimplementing a source-to-source compiler instrastructure from scratch whenever a new programming technology appears, we focused on refactoring libraries, while taking advantage of PIPS extensible consistency manager, Pipsmake, to add new functionalities over time. Moreover, thanks to the source-to-source approach, transformations and analyses can be combined in any way for new purposes, and newcomers to PIPS immediately benefit from past contributions.

Recent developments in PIPS have focused on the inlining of library functions, outlining of key code parts and automatic generation of data communications and now all standard program and loop
transformations are available. Former activities include interprocedural parallelization, property instrumentation (aliasing, uninitialized variable and buffer overflow detection), code refactoring, etc.

PIPS is written mainly in C, has around 15 active contributors and its source code (456 KLOC) is available under the GPL v3 license. It can be downloaded from http://pips4u.org.

Target audience

This tutorial is relevant to people interested in GPU or FPGA-based, hardware accelerators, hardware FPGA configuration, multicore and manycore architectures, distributed code generation for scientific or MPSoC embedded computing, quickly developing a compiler for an exotic processor, and more generally to all people interested in experimenting with new program transformations, verifications and/or instrumentations.

Outline

This tutorial:

  1. Illustrates usage of PIPS analyses and passes to generate hardware accelerator code in an interactive demo.
  2. briefly presents the functionalities available in PIPS, using examples;
  3. describes key internal data structures;
  4. shows how to declare a new transformation within pipsmake;
  5. presents how to implement this transformation within the PIPS infrastructure using only a few lines of C code, thanks to Newgen-based data structures and iterators, and existing PIPS libraries.

The presentation is based on the real-life experience of people having used PIPS for less than a year, using SVN to contribute from several different geographical locations, as well as source code documentation generated by Doxygen.

Presenters's Bios

  • Corinne Ancourt got a PhD degree from University Pierre et Marie Curie in 1991 in computer science. She is currently working for MinesParisTech computer science department where she is project leader. Shecontributed to the development of new compilation techniques fordistributed memory machines and signal processing applications.
  • Serge Guelton is a third year PhD student from Telecom Bretagne and a former engineer from INRIA. His studies focus on compiler support for hybrid computing and hardware accelerators.
  • Ronan Keryell is Chief Scientist Officer and co-fonder of HPC Project. He is an expert in parallel computing, computer architecture, compilation and computer security. He is the principal architect of
    the Par4All parallelization framework and member of the PIPS project. He used to be assistant professor at Telecom Bretagne and Mines ParisTech. He graduated from ENS Paris where he got his MS and PhD in Computer Science for University Paris XI in 1992.
  • Frédérique Silber-Chaussumier is an assistant professor in the Computer Science Department at Institut Telecom/Telecom SudParis. Her research focuses on parallel programming for distributed memory architectures. She received a PhD in Computer Science from Ecole Normale Superieure de Lyon.

References

 

Document Actions

« October 2017 »
October
MoTuWeThFrSaSu
1
2345678
9101112131415
16171819202122
23242526272829
3031