Current innovations in science and industry demand ever-increasing computing resources while placing strict requirements on system performance, power consumption, size, response, reliability, portability and design time. Both embedded and large-scale systems tend to evolve toward complex heterogeneous multi-chip systems with dramatically increased design, test and optimization time. Optimizing compilers play a key role in producing executable codes quickly and automatically while satisfying all the above requirements for a broad range of programs and architectures. However, for many years, state-of-the-art compilers fail to deliver satisfactory levels of performance on new systems due to necessarily simplistic hardware models, fixed and black-box optimization heuristics, inability to fine-tune application, highly dynamic behavior of the system and inability to adapt to varying program and system behavior at run time with low overhead. This suggests that current system design and program optimization technologies are reaching their limits and should be revisited to keep pace with rapidly evolving hardware.

During my PhD at the University of Edinburgh (1999-2004), together with Prof. Michael O'Boyle, we introduced iterative compilation (iterative program optimizations) at a fine-grain (function, loop or instruction level) for applications of any size (rather than just kernels) to automatically find best optimization settings on rapidly evolving architectures that beat state-of-the art optimizing compilers. Later I have been working with Prof. Olivier Temam at INRIA to make iterative optimizations practical and developed a technique that speeded up the iterative search by 3 orders of magnitude and enabled low-overhead run-time adaptation. We also developed a novel technique to characterize programs using reactions to transformations. The results of these projects are now used in several EU-funded projects (MILEPOST, SARC, GGCC).

I started developing FCO framework in 2003-2005 to enable continuous optimizations and knowledge reuse, however in 2006 I moved all these developments to the Continuous Collective Compilation Framework within MILEPOST project that is now supported by several universities and companies. You may want to look at my current research and software developments within UNIDAPT Group.

---

Additional information about FCO and its components:

[ FCO PathScale CVS with patches ] [ FCO Open64 CVS with patches ]
[ FCO license ]
[ FCO readme ]
[ FCO tech info ]

• PathScale Interactive Compilation Interface

  In 2004 I started developing an Interactive Compilation Interface (ICI) for the PathScale EKOPath compiler to improve its optimization heuristic, enable fine-grain program optimizations for different constraints and unify optimization knowledge reuse among different programs and architectures using statistical and machine learning techniques.

  [ Open64 ICI development website ] [ PathScale ICI development website ]

  [ Open64 ICI CVS with patches ] [ PathScale ICI CVS with patches ]

  [ paper from SMART'07, presentation from HiPEAC GCC Tutorial'07 ]

• Modified benchmarks to automate iterative optimization research
  • MiBench
  • Polyhedron Benchmarks
  • SPEC95, 2000, 2006
  • Various Kernels

  Automating experiments is an important part of iterative optimizations - we have to run hundreds of thousands of experiments! I modified all the above benchmarks to automatically run within our continuous optimization framework. Several key issues are: possibility to easily switch between different compilers (gcc, PathScale, Intel, etc), possibility to change compiler flags for benchmarks (for global optimizations), possibility to validate compiler optimizations, etc. Here you can find an example of prepared mgrid and tiffmedian benchmarks for FCO.

• Modified PathOpt tool to search for best compiler flags

  Though since 1999 I have been mainly targeting fine-grain program optimizations, searching for the best compiler flags still remains an important issue. If you are looking for tools to search for the best compiler flags for programs, I suggest you to look at the PathOpt and PathOpt2 tools from the PathScale Compiler available since 2003, or ESTO from IBM. PathOpt is a free tool within commercial open-source compiler from QLogic (PathScale) to iteratively search for the best compiler flags. We switched to this tool in 2003 and currently use it for our research since it is easily configurable, works with any languages, does not require project modifications, has many basic search strategies (random, one by one, all but one), easily extendable.

  At some point I had to develop a FCOOpt tool to enable reliable iterative optimizations on top of GCC, PathScale, Intel and IBM compilers. This tool transforms program, checks that the binary changed, runs transformed program several time to check execution time variance and compares all program outputs to verify transformations. It also collects information about hardware counters using PAPI library and is connected to new machine learning drivers to search for best optimizations.

• Iterative Continuous Optimization Drivers and various support tools

  During my PhD and as a postdoc I developed many support drivers and different search strategies for FCO to find best compiler flags or tune program at fine-grain (procedure, loop, instruction) level. Some information about these tools is available in a brief FCO readme.

• Multiple datasets

  We created 20 different datasets per program for MiBench benchmark to evaluate enable a more realistic benchmarking and practical iterative optimizations.

[ MiDatasets development website ]

I use Interactive Compilation Interface in most of my projects:

• Iterative optimizations
• Machine Learning to speed up optimizations
• Program run-time adaptation for scalar systems
• Program run-time adaptation and parallelization for heterogeneous systems
• CCC - Continuous Collective Compilation
• Design Space Exploration