Grigori Fursin - Personal Website

In 2004/2005 I have been working with Olivier Temam as a postdoctoral researcher and 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 make iterative optimizations practical and to speed up the iterative search by several orders of magnitude by enabling low-overhead run-time phase detection for statically compiled programs (different from SimPoints as we detect phases at run-time at function or loop-level to target complex high-level optimizations). I am developing a UNIDAPT (UNIversal aDAPTation) framework to create self-tuning binaries and libraries and enable practical continuous iterative optimizations by detecting the influence of program optimizations on performance/power consumption in a single run unlike other current feedback-directed techniques that requires multiple runs with the same dataset. This technique also enables practical run-time adaptability for statically compiled programs with any behavior (regular or irregular) for different constraints (performance, power consumption). It does not require complex run-time recompilation frameworks and thus reliable, secure and easy to debug. I am implementing this technique in GCC (and source-to-source) and have some preliminary plans to implement it in Open64. Additional information can be found in my HiPEAC'05 paper and in my talk (January, 2007) at UPC (Spain).

UNIDAPT Framework will be a part of the Continuous Collective Compilation Framework which helps automate and simplify transparent reuse of optimization knowledge among different programs and architectures. It will be used to overcome the complexity of current architectures, compilers, operating systems and programming environments, and to automate and improve architecture and compiler design (particularly for future heterogeneous multi-core systems), optimize and parallelize systems 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. We plan to release CCC Framework v1.0 before the HiPEAC'09 conference. You can subscribe for UNIDAPT announcements to know when it is released.

We are working to extend our technique with the following and would be happy for any help with developments:

provide automatic function multiversioning and keep info about hot functions of statically-compiled programs across runs in the collective database
be able to apply different optimizations on function clones (using ICI or other tools)
provide external libraries with different monitoring routines (based on timers, hardware counters, etc)
compile different function versions for architectures with different ISA and provide explicit data transfer mechanisms (on reconfigurable architectures or GPUs for example)
learn and cluster different run-time program behavior (for different program inputs, program phases, environments, reconfigurable architectures)
select only several most appropriate versions in the final self-tuning adaptive binary
reconfigure architectures at run-time based on program phases and optimization cases (performance vs power consumption)
select only several most appropriate versions for the final production self-tuning adaptive binary
provide feedback from Virtual Machines about switching context to be able to select the appropriate function for a new hardware (we briefly brainstormed this with the AMD guys during HiPEAC ACACES summer school'08)

[ UNIDAPT Framework development website ]

I now use UNIDAPT in the following projects: