You are here: Home / Related Projects

Related Projects

Many research prototypes have been developped to test new compilation techniques for Fortran, C, C++ and Java over the past 30 years. These techniques include loop vectorization, loop parallelization, whole program compilation, code distribution, various analyses, just-in-time compilation, heterogeneous code generation,... The lists below are not exhaustive. They are strongly biased towards Fortran and C compilation techniques and they are organized chronologically because large prototype compilers would have to be cited many times if a topic classification were used. Please, let us know of other projects which should be included below.


Current source-to-source compiler prototypes

  • Cetus (Purdue) - "a compiler infrastructure for the source-to-source transformation of software programs. It currently supports ANSI C and is under development to support C++".
  • Graphite (INRIA Saclay): a gcc plug-in (see also PoCC)
  • LooPo, Polyhedral Loop Parallelizer (Passau)
  • Open64 (Intel research compiler)
  • OSCAR (Waseda University, Tokyo)
  • PIPS (MINES ParisTech): parallelization infrastructure, whole program parallelization, for Fortran 77, Fortran 89, C89 and C99
  • PoCC: the Polyhedral Compiler Collection (INRIA). "PoCC is a flexible source-to-source iterative and model-driven compiler, embedding most of the state-of-the-art tools for polyhedral compilation."
  • Rose (LLNL): ROSE is an open source compiler infrastructure to build source-to-source program transformation and analysis tools for large-scale Fortran 77/95/2003, C, C++, OpenMP, and UPC applications. The intended users of ROSE could be either experienced compiler researchers or library and tool developers who may have minimal compiler experience. ROSE is particularly well suited for building custom tools for static analysis, program optimization, arbitrary program transformation, domain-specific optimizations, complex loop optimizations, performance analysis, and cyber-security.
  • Spear-DE (Thales): interactive iterative compilation and simulation

Current compiler research projects

Historical prototypes

  • Parafrase (CSRD/UIUC): Fortran
  • Parafrase-2
  • Parascope (Rice University): Fortran
  • Polaris (CSRD/UIUC, Texas A&M University): Fortran
  • PTRAN, PTRAN-2 (Watson Research Center/IBM)
  • SUIF (Stanford): whole program parallelzation, Fortran and C

Past compiler research projects

  • Adaptor (GMD): automatic distributed code generation.
  • Advanced Parallelizing Compiler (APC) (Waseda):
  • Annaï (ETH/NEC Switzerland):
  • Bouclette (LIP/ENS-Lyon): research prototype for loop transformations.
  • CAPTools (Greenwich)
  • COINS Compiler Infrastructure (2002-2010: Hosei Univeristy, The University of Electro-Communications, Tokyo Institute of Technology, Mitsubishi Research Institute & al.): COINS (COmpiler INfraStructure) is a project to develop a compiler infrastructure which may be used as a base for constructing various compilers such as research compilers, educational compilers, and production compilers. COINS has two levels of intermediate representation, HIR: High-level Intermediate Representation, and LIR: Low-level Intermediate Representation. The infrastructure is composed of many components, such as front-ends, back-ends, various kind of optimizing and parallelizing modules. Optimizations and parallelizations are applied to HIR or LIR. Compiler developers can construct a compiler by selecting appropriate components. They may add their own components or modify some existing components to add new features to their compiler. The main aim of the project is to help compiler developers build good compilers in relatively short term and accelerate the development of compiler technology. New compiling techniques can be implemented by adding or modifying a component without writing the rest of the compiler. For example, a compiler for a new machine can be built by adding a new code generator without developing the front-end. A compiler for a new language can be built by adding a new front-end without developing the back-end. Basic modules for code optimization and parallelization are available. Evaluation of compiling techniques becomes easy by comparing results based on the same infrastructure.
  • Compaan , (Delft/Berkeley) (see also GSRC): Compaan is an effort to compile Nested Loop Programs written in Matlab into a Process Network description.
  • D System (CRPC/Rice University): automatic distributed code generation.
  • EPPP (CRIM Montreal)
  • Fortran D95 at Rice University (see D System)
  • FPT, the Fortran Parallel Transformer (Ghent, Belgium)
  • McCAT Compiler (McGill)
  • National Compiler Infrastructure (NCI) , SUIF (PGI, Stanford University)
  • Nestor , automatic loop nest parallelization (ENS-Lyon/LIP)
  • NPIC , New Patz Interprocedural Compiler, Michael Hind (pointer analysis, conditional constant propagation, object-oriented design)
  • Omega, Petit (Maryland)
  • Opera (Strasbourg)
  • PAF, Paralléliseur de Programme Fortran, Systematic Construction of Parallel and Distribued Programs (PRISM/UVSQ)
  • Paradigm (CSRD and Northwestern University). Distributed memory message passing machines such as the IBM SP-2, the Intel Paragon, and the Thinking Machines CM-5 offer significant advantages over shared-memory multiprocessors in terms of cost and scalability. Unfortunately, to extract all that computational power from these machines, users have to write efficient software for them, which is an extremely laborious process. One major reason for this difficulty is the absence of a single global shared address space. As a result, the programmer himself has to manually distribute code and data on processors, and manage communication among tasks explicitly. Clearly, there is a need for efficient parallel programming support on these machines. The PARADIGM compiler project addresses that problem by developing an automated means to convert sequential programs, automatically parallelizing them by compiler dependence analysis, and compiling them for efficient execution on distributed memory machines.
  • Pandore ( PAMPA /IRISA)
  • Petit, see Omega entry (UMD)
  • PFC, RN (Rice)
  • Ptolemy , (Berkeley). The Ptolemy projects studies modeling, simulation, and design of concurrent, real-time, embedded systems.
  • Prepare (Esprit Project/IRISA)
  • PROMIS compiler (UIUC-UCI). PROMIS is an advanced multilingual and retargetable parallelizing and optimizing compiler under development at the University of Illinois at Urbana-Champaign and the University of California-Irvine. Both the basic research work and the development of the prototype compiler are based on a radically different design methodology, in contrast to the design approaches used by virtually all commercial and experimental compilers.
  • Sage++, also used by the CAPS project
  • Superb (Bonn)
  • Tiny, Nascent (OGI)
  • TransTOOL (LIP/ENS-Lyon)
  • Trimaran (NYU, HP, UIUC) Compiler optimization and performance monitoring infrastructure with emphasis on Explicitly Parallel Instruction Computing (EPIC). TRIMARAN is co-developed by the CAR Group of HP-Labs, the IMPACT Group of the University of Illinois and the ReaCT-ILP Laboratory of New York University.
  • Vienna Fortran Compilation System (VFCS) (University of Vienna)
  • ...
  • WPP (Whole Program Parallelizer) Real World Computing Partnership Multi-Processor Computing Hitachi Laboratory (Hitachi)

We use the daVinci graph viewer in PIPS.


See also Microsoft Research, Oregon State University (OSU).

Advanced commercial compilers and parallelizing preprocessors include:

Free production compiler

  • gcc: the GNU compiler collection (parallelization and vectorization)
  • LLVM: The LLVM Project is a collection of modular and reusable compiler and toolchain technologies. Despite its name, LLVM has little to do with traditional virtual machines, though it does provide helpful libraries that can be used to build them. LLVM began as a research project at the University of Illinois, with the goal of providing a modern, SSA-based compilation strategy capable of supporting both static and dynamic compilation of arbitrary programming languages. Since then, LLVM has grown to be an umbrella project consisting of a number of different subprojects, many of which are being used in production by a wide variety of commercial and open source projects as well as being widely used in academic research. Code in the LLVM project is licensed under the "UIUC" BSD-Style license.

Useful libraries:

  • APRON interface and libraries: generic interface for abstract numerical domains (it includes several polyhedral libraries)
  • C3 Linear: polyhedral library, polyhedron list library, polynomial library (sparse representation, integer overflow control)
  • PIP: Parametric Integer Programming
  • Polylib: polyhedral library, includes PIP algorithm, dense representation
  • PPL (Parma Polyhedric Library)
  • Omega library: Presburger arithmetic

Related areas include:

Document Actions

« July 2024 »