Section: New Results

Dynamic dependence analysis

We have started a research project on dynamic dependence analysis. The principle is to observe an execution of a given program and collect dependence information. This form of profiling is similar to memory profiling, except that to goal is to directly produce data dependencies. During collection, data dependencies are abstracted into dependence graphs which, in turn, give enough information to decide whether a given code portion is parallel and, if the answer is positive, precisely constrain the set of applicable program transformations. Our implementation currently uses our own profiling infrastructure to obtain data from a running program, and models the sequence of run-time data dependencies in a unique framework. The system is of course sensitive to the fact that the input data is representative of typical inputs: the conclusion it draws cannot be applied without resorting to speculation. Currently, we restrict the system to a parallelization assistant, whose result is a set of suggestion that the programmer is free to follow or ignore.

A fundamental characteristic of a parallelization assistant is the class of parallel constructions that it is able to extract from run-time data. We have designed the profiling component and the analysis algorithm such as to be able to represent the dependencies with various abstractions, from simple boolean dependencies to full dependence polyhedra. However, even the simplest dependence model provides useful hints to parallelize a given program. In this case, our tool flags every loop in the program as either intrinsically sequential, or potentially parallel. To make this widely usable, we have decided to target common parallel programing constructions, namely OpenMP directives. In turns out that our design is flexible enough to let the system also target loops that become parallel after simple privatization transformations. The result of profiling is thus a set of complete OpenMP directives, making the loop parallel but also instructing the compiler to take special measure for local data that (falsely) renders loop iterations dependent.

Because the general design of our dynamic dependence analysis system is generic and modular, we plan to develop and distribute software implementing our approach. This project, called Parwiz, has received support from INRIA under the form of an ADT (Action de Développement Technologique). The funding should let us hire an engineer for two years. Unfortunately, we have not been able to find a suitable candidate in 2011, and plan to continue the recruitment process in 2012. In the meantime, we have supervised en Argentinian student, José Cacherosky, during 4 months (from July to October 2011), as an intern with funding from the INRIA International Internships program. The goal of the internship was to extend our framework (developed mainly to work from binary programs) to another execution environment, namely the Java Virtual Machine. Most of the time has been spent on developing an instrumentation infrastructure, but José Cacherosky has also started the implementation of some of the parallelism detection algorithms. We plan to continue this work soon, and provide a tool that could work in several, very distinct environments. Finally, Fabrice Rastello, research scientist at the École Normale Supérieure de Lyon (with the INRIA team COMPSYS), has expressed interest in collaborating with us on this research project.