Grigori Fursin - Personal Website

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. At the same time I had been developing Edinburgh Optimizing Software - a toolset for iterative optimizations and performance prediction on a loop-level for various platforms and languages. Due to simple component java client/server architecture it is easy to compile this framework on such architectures as x86 (Linux, Windows), Itanium, PowerPC, UltraSparc, Alpha, etc (though gcc 3.x is required to compile Transformation Server on Linux; so far there is no limit on the compiler for Windows). It supports PAPI library for the collection of hardware counters information on a procedure or loop level.

Though I do not support it anymore, it is still used in several M.S. and Ph.D. projects, and for teaching purposes. You can download it here (under GPL license):

EOS tar-ball with all servers, tools and clients (including source code)
eos.tar.gz [6Mb] (2006.Jan.27)

In order to make this toolset easily portable and flexible, a client/server architecture is used as shown in the following figure:

It consists of autonomous components such as servers, clients and a shared network file system. These components communicate with each other over the network using data files on the shared file system and using standard telnet protocol as shown by arrows in the above figure. Servers perform various analysis and optimisation tasks on the target platform, while the client is a Graphical User Interface (GUI) application that enables users to interact with servers remotely. A client is platform independent and can access various platforms, obtain and present results in a convenient way. This software architecture is flexible since it is easy to update the software and add new tools without the need to stop and restart all components. It supports auto error and fault recovery as servers can be restarted and the analysis and optimisation process can continue from the last correct state.

This toolset contains the following components:

EOS Run Server ( readme )

This server is used to enable and ease portability between different platforms. It is platform dependent and is used to execute applications and obtain their run-time parameters. It is written in C and uses low-level OS calls. It is one of the only servers that needs to be recomiled on each new platforms - most of the remaining software is written in Java and thus portable across platforms.

EOS Compilation Server ( readme, server.cfg, server_f77.cfg )

This server deals with a program project management: compile programs, recompile only necessary parts of big projects, visualizes program loop structure, executes additional support tools, etc ...

EOS Transformation Server ( readme )

This server enables source-to-source transformations for Fortran (and partially for C) programs. I implemented the following transformations: array padding, loop tiling and unrolling. I started implemented additional transformations but didn't have enough time to thoroughtly test them: loop interchange, loop strip-mining, loop splitting, loop distribution and array global index reordering. This server uses Octave library (Fortran, C, C++, Java front-ends) which was originally developed by Prof. Nigel Topham

EOS Application Checking (Preliminary Analysis) Server ( readme, server.cfg )

This server is mainly used to collect various profiling information for a whole program or on a procedure or loop levels.

EOS Memory Problem Checker (Performance Prediction) Server ( readme, server.cfg )

This server predicts memory upper-bound performance and is used to guide iterative optimizations and to quickly calculate prefetch distances at run-time. This server uses an additional tool I developed in 2002 for dynamic program instrumentation on Intel processors similar to ATOM. I use 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. More information can be found in my PhD thesis, CPC'01 and CPC'04 papers.

EOS Search (Iterative Compilation) Server ( readme, server.cfg, server_f77.cfg )

This is the main server to apply iterative optimizations for Fortran programs on a loop level. The following search strategies have been implemented:

simple "one by one" (with hill-climbing)

random

grid

parallel (when all loops are optimized at the same time and later interference between loops is analyzed)

More information can be found in my PhD thesis and LCPC'02 paper.

Static and dynamic program instrumentation tool
When I started working on iterative optimizations in 1999, I experimented a lot with Alpha platform and used ATOM tool for my research on performance prediction to dynamically instrument programs. Gradually I moved to Intel and AMD platforms, and in 2001 started developing a new tool for dynamic instrumentation of programs similar to ATOM and working on Linux and Windows. I used it for my research on memory upper-bound performance prediction and for calculating prefetching distances. I 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. I didn't have time during PhD to finish developments and recently found a new tool called Pin that performs dynamic instrumentation of programs on Intel platforms. It is well supported, so I stop my developments and strongly suggest for those who still use my dynamic instrumentation tool, to gradually move to Pin.
Program project handling ( description )

EOS Client ( readme, client.cfg, client_platform0.cfg )

This is a simple and intuitive GUI environment for iterative optimizations.

Based on my previous experience on iterative optimizations, I started building Interactive Compilation Interface (ICI) for PathScale EKOPath compiler in 2004 to improve its optimization heuristic, enable fine-grain program optimizations for different constraints (performance, code size, power consumption, DSE, different ISAs, etc) and unify optimization knowledge reuse among different programs and architectures using statistical and machine learning techniques (our paper from SMART'07, our presentation from HiPEAC GCC Tutorial'07). Recently, this project got support from several universities and companies, and we are now building a new ICI for the GCC with the help of a HiPEAC engineer. We expect that using ICI will help cleaning up GCC and turn it into component-based pluggable compiler with easily extendable and automatically tunable optimization heuristic.

I now use ICI in most of my projects: