Developments

From UNIDAPT.org

We have been developing tools to support our compiler and architecture research on intelligent adaptive computing systems since 1999. We believe, that current way of disseminating novel techniques only through publications without providing tools to verify and replicate results or with incompatible unstable prototypes is intended mainly to claim the authorship of the idea in a niche research area, but often do not help the community to use these techniques immediately in a collaborative research to continue addressing global challenges. After getting fed up using multiple incompatible research tools, unsupported third-party software and unstable beta versions, we decided to develop open-source research tools with common API to enable collaborative and replicable R&D and avoid duplicating developments. These activities are now supported by academia and industry while allowing the whole IT community to profit from common tools and focus on innovative research.

We are developing the following collaborative open-source tools:

• Collective Tuning Center / Collective Optimization Repository, cTuning Compiler Collection and MILEPOST GCC/MILEPOST Framework (collaborative open-source tools and repositories for code/architecture characterization and optimization) - we are moving empirical automatic performance tuning, iterative optimization (compilation), statistical and machine learning techniques to real production compilers and computing systems, and started the whole system parametrization and abstraction to enable future self-tuning, adaptive computing systems. We are designing Collective Tuning Center (cTuning.org) and continue development of the first publicly available machine learning enabled self-tuning compiler based on automatic correlation between program features, run-time behavior and optimizations (MILEPOST GCC (with MILEPOST colleagues) and cTuning CC) focusing at the moment on improving program execution time, code size, compilation time, power consumption and enabling run-time adaptation. Though this system is still in a preliminary state, we showed for the first time how to substitute the whole human-tuned state-of-the-art optimization heuristic of a production compiler with the automatically learned one across multiple programs and architectures using empirical iterative and collective optimization, program features and predictive modeling. cTuning enables sharing of benchmarks, datasets, optimization cases through unified web-services and tools with common APIs to be able to predict better optimizations or architecture designs provided there is enough information collected in the repository from multiple users. cTuning/MILEPOST technology revolutionizes code and architecture design and optimization, helps to reduce power consumption and time to market for new computing systems, and is now used by major companies and in large US, EU and other international R&D projects. All developed tools have been released as open-source to the community to continue collaborative R&D to automate and simplify code and architecture design and optimization, enable sharing of optimization cases and improve the quality of academic research. cTuning/MILEPOST technology opens up many research opportunities, so it's an on-going, evolving project with many R&D topics available. Current collaborative projects include automating fine-grain/polyhedral optimizations, parallelization and run-time optimization and adaptation using statistical and machine learning techniques.

• Interactive Compilation Interface - common API and light-weighted plugin system to transform production-quality compilers with state-of-the-art transformations into powerful collaborative research tools with minimal changes to avoid building new research compiler infrastructure from scratch. Finally, after nearly 6 years, similar plugin system will be included in mainline GCC 4.5 - we already moved some of the ICI features to the mainline and are working on full ICI/mainline GCC synchronization now!
• Continuous Collective Compilation Framework - collaborative framework to enable transparent collection and statistical analysis of heterogeneous optimization information from multiple users (computer architectures, programs, datasets, run-time behavior, etc) to enable collective optimization for performance, code size, power, etc.
• 'Collective Benchmark/MiDataSets - benchmark with multiple datasets to enable realistic program and architecture optimizations, run-time adaptation and performance evaluation.
• UNIDAPT (2004-now) - framework to statically enable run-time optimizations and create self-tuning adaptive binaries and libraries for heterogeneous multi-core systems based on static multi-versioning and dynamic adaptation to continuously improve performance, power, fault-tolerance, etc. Now static binaries can automatically learn from the past experience and adapt/react to various environments, run-time behavior and contentions that is important to improve efficiency and cost of various computing systems. Since 2007 it is being actively extended by Google Inc. for data centers (cloud computing).

Current design of our Collective Optimization Framework (http://cTuning.org):

Collaboration:

• Intel, Université de Versailles-Saint-Quentin-en-Yvelines (France), GENCI, CEA, ICT (China), CAPS Enterprise, University of Edinburgh (UK), IBM, STMicroelectronics, UIUC (USA), UPC (Spain), Ghent University (Belgium) ...
• If you are interested to help us develop common research tools with unified APIs (compilers, architecture simulators, run-time environments, etc) you are very welcome to join our cTuning effort.

Archive:

Past Grigori Fursin's developments:

• MILEPOST Framework (2006-now) - infrastructure that combines MILEPOST GCC, CCC Framework and UNIDAPT Framework to tune compiler optimization heuristic or find "good" program optimizations or architectural configurations for reconfigurable processors entirely automatically based on program static and dynamic features using statistical and machine learning techniques (predictive modeling).

• Memory performance analysis and prediction tool (1999-2003) - beta version for Linux and Windows has been released within EOS framework but I didn't have enough time during my PhD to extend it (FUR2004, FOTP2004, FOTP2001). We are interested to implement it now within GCC Interactive Compilation Interface.
  • used to guide iterative optimizations
  • used to quickly calculate prefetch distances at run-time
  • used to dynamically instrument all program memory instructions and enable self-modifcation/self-removal of these instructions to quickly collect and analyze memory access traces.

• • In Memory performance analysis and prediction tool, Grigori introduced a novel and simple approach to quickly detect realistic code performance upper-bound by converting array accesses to scalars in various ways on assembler level without preserving the semantics of the code while avoiding code crashing to be able to directly compare original and transformed programs. We compare our approach with the simulator and hardware counters on Alpha platform. This novel concept helps application developers to raplidly determine parts of the code that will benefit or not from further optimizations or how much performance gain can be potentially obtained from memory optimizations.
    Later, we extended this technique and developed several ways to modify code on assembler level without preserving semantics to detect parts of the code which can benefit from memory optimizations. We developed several tools for x86 and Alpha such as assembler code analyzer with instrumentation and instruction modifier/removal, and evaluated technique on various small kernels and many large SPEC applications. We also show that focusing on code optimizations that reduce cache misses on out of order architecture using hardware counters can be totally misleading and our approach provides more realistic upper bound.
    This novel concept has been used in EU FP5 MHAOTEU project and is now being extended in academia and industry for application characterization, reaction of the code to various instruction modifications/removals and to guide manual or iterative feedback-directed optimizations.

• Static and dynamic program instrumentation tool (1999-2003) - beta version for Linux and Windows has been released within EOS framework but Grigori didn't have enough time during PhD to extend it (FUR2004). We are interested to implement it now within GCC Interactive Compilation Interface. When we started working on iterative compilation in 1999, we worked a lot with Alpha platform and used the ATOM tool for research on performance prediction to dynamically instrument programs. Gradually we moved to Intel and AMD platforms, and in 2001 started developing a new tool for dynamic program instrumentation similar to ATOM that could work both on Linux and Windows. We used it for my research on memory upper-bound performance prediction and for calculating prefetching distances. We also used this tool to dynamically instrument all program memory instructions and enable self-modification/self-removal of these instructions to quickly collect and analyze memory access traces. Grigori didn't have enough time during PhD to finish developments and later found a new tool PIN that does the same but has a full support for Intel platforms. We also plan to enable static program instrumentation in the GCC Interactive Compilation Interface Interactive Compilation Interface.

• Edinburgh Optimizing Software (EOS Framework) (1999-2003) - Grigori developed this framework during his PhD to introduce iterative feedback-directed compilation at a fine-grain level (function, loop or instruction) for applications of any size rather than just kernels. We also used my "Memory performance analysis and prediction tool" and "Static and dynamic program instrumentation tool" to quickly detect parts of a code that may or may not benefit from further time-consuming optimizations.

• Framework for Continuous Optimization (FCO) (2003-2006) - Grigori developed this framework together with PathScale/Open64 Interactive Compilation Interface to move away from my source-to-source transformation tools and reuse production quality compilers as a research infrastructure. This framework has been used in a number of international projects to select fine-grain optimization and parameters such as loop tiling, unrolling, prefetching, loop distribution and fusion, array padding, vectorization, etc. Based on its success Grigori moved all my developments into public domain and started developing Continuous Collective Compilation Framework and Interactive Compilation Interface for GCC. They are currently used in various international projects including MILEPOST to predict good optimizations using machine learning based on program static and dynamic features.