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 tune application at fine-grain level, 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 Ph.D. at the University of Edinburgh (1999-2004), I had been working with Prof. Michael O'Boyle to introduce iterative compilation at a fine-grain level (function, loop or instruction) to automatically find best optimization settings for large applications (rather than kernels) on rapidly evolving architectures that beat state-of-the art optimizing compilers. I had also been working with Prof. Olivier Temam to develop a fast and accurate technique to determine lower bound of the execution time of memory intensive applications by replacing all array accesses with scalars to have a stopping criterion for iterative compilation. Later, we developed a new concept to combine static and dynamic optimizations by creating self-tuning static binaries based on static code multiversioning and run-time hardware counters monitoring routines to learn run-time program behavior continuously, detect changes due to different program phases, inputs, environments (OS, architecture, virtual layers) and to dynamically react to those changes by selecting appropriately optimized code versions to improve performance, power, fault-tolerance, etc. We used this method to speed up iterative compilation by 3 orders of magnitude using a run-time low-overhead program phase detection scheme and function versioning. At the same time, I started developing an Interactive Compilation Interface (ICI) for Open64/PathScale compilers and GCC to enable continuous run-time adaptation and optimization of statically compiled programs at fine-grain level. We also developed a novel technique to characterize programs or architectures using program reaction to optimizations (transformations). I had been collaborating with my colleagues from the University of Edinburgh, UK to introduce this technique as well as statistical search and machine learning to enable optimization knowledge reuse among different programs and architectures using static and dynamic program and architecture features.

I currently work as a tenured research scientist at INRIA Saclay, France and use my research results in several EU-funded projects (HiPEAC, MilePost, SARC, GGCC and others) to move towards my long-term goal to develop and generalize automatic continuous program optimization and parallelization techniques and architecture design exploration using innovative search methods, adaptation, machine learning and knowledge reuse. This should enable realistic intelligent self-tuning systems, particularly in the presence of rapidly evolving multi-core heterogeneous architectures. I am developing publicly available software tools for GCC and Open64 compilers. I collaborate with my colleagues from the University of Edinburgh, INRIA, Ghent University, ICT, IBM, ARC, CAPS Enterprise, NXP, STMicro and others, and open to new contacts, collaborations and proposals to realize these goals.

I founded UNIDAPT Group to pioneer and promote radically new practical techniques to overcome the complexity of current and future architectures, compilers, operating systems and programming environments. We are working on creating self-tuning intelligent adaptive systems, automating and improving architecture and compiler design (particularly for future heterogeneous multi-core systems), optimizing and parallelizing applications to improve performance, power consumption, size and fault-tolerance, reduce cost and time to market based on machine learning, artificial intelligence, statistical methods and biologically inspired techniques. This is critical to be able to continue innovation in science and industry (bioinformatics, medicine, physics, chemistry, finances, gaming, etc) that demands ever-increasing computing resources while placing strict requirements on systems.

Together with the MILEPOST colleagues we are currently developing MILEPOST GCC - the first machine learning based self-tuning research compiler described more in our GCC Summit'08 paper (many thanks to Cupertino Miranda for extending Interactive Compilation Interface, Edwin Bonilla for extending machine learning techniques, Mircea Namolaru for integrating static program feature extractor to MILEPOST GCC and John Thomson for performance evaluation). We plan to release MILEPOST GCC v1.0 by the end of 2008. In the mean time, you can register your interest here to receive information about (pre)releases of the MILEPOST GCC. You can also subscribe for UNIDAPT announcements or contact me if you would like to use it for your research and collaborate on some projects.

Tuning hardwired compiler optimizations for rapidly evolving hardware makes porting an optimizing compiler for each new platform extremely challenging. Our radical approach is to develop a modular, extensible, self-tuning intelligent compiler that automatically learns the best optimization heuristics based on combining feedback-directed iterative compilation and machine learning. MILEPOST GCC is a machine learning based compiler that automatically adjusts its optimization heuristics to improve execution time, code size, or compilation time of specific programs on different architectures. Currently, we use several iterative search strategies within CCC framework to find combinations of good optimization flags to substitute GCC default optimization levels for a particular architecture (such as -O0,-O1,-O2,-O3,-Os which we will not need in the future adaptive compilers) or tune optimization passes on a function-level for a particular program. Our preliminary experimental results show that it is possible to considerably reduce execution time of various benchmarks (MiBench, MediaBench, EEMBC, SPEC) on a range of platforms (x86, x8664, IA64, ARC, Longson/Godson, etc) entirely automatically. MILEPOST GCC can be used interactively in research on adaptive computing through the Interactive Compilation Interface (we currently support optimization pass selection and reordering, plugins and event mechanism to invoke any passes on demand (such as program feature extraction pass) or tune cost-models of specific transformations within passes).