Performance- and Accuracy-aware Data format Optimization in numerical Codes – PADOC

The development of efficient and accurate numerical codes is a difficult
task. Indeed it requires to know perfectly the targeted micro-architecture, the
behavior of its computational units and its instruction set. But it also needs
to carefully analyze the accuracy constraints of all the data of the code and
the computing precision in order to reach a given accuracy on the
output. Usually these two criteria are handled in a separated way. And mainly
because of the lack of expertise from the developers, we observe that the
computational data are often over-sized. Therefore this does not enable to take
full advantage from the capabilities of the micro-architecture.

To improve the performance of the applications, and to reduce their execution
time, an approach consists in lowering the precision of certain well-chosen
data. This method enables to exploit the parallelism provided by certain modern
architectures, through the use of vector instructions. However deciding the data
to be tuned without impacting too much the accuracy of the result is a
complicated task, even for experts in numerical software. And this difficulty
increases with the size of the applications.

The objective of the PADOC project consists in designing tools to help
developers in adapting in an automated way the format of the floating-point data
in a numerical code. The interest is to exploit at best the computational units
of the targeted architecture, and thus to improve the performance of the code,
while guaranteeing a given accuracy threshold on the result. Some tools already
exist to address this issue. However, these tools may suffer from the following
drawbacks: First they are dependent of some input data, which are not
representative enough of the data the code will be used with. Hence the
transformations may not remain valid for other data. Second they do not consider
the targeted micro-architecture in the tuning process. This may results in codes
that do not fully benefit from its capabilities. Third they perform optimization
on the whole code, considering all the data even those for which the tuning
process will not be relevant. For a large number of data, the combinatorics is
huge, and this leads to a slowing down of the adaptation time. Therefore our
goal is to design tools to produce codes optimized for a given
micro-architecture, and robust with respect to the input data. But above all, we
aim at speeding up the process by isolating the data the most relevant in the
tuning, and thus reducing the barrier.

The design flow of the PADOC project works on an input code, and it returns an
optimized mixed precision code. In this proposal we aim at working around three
directions. The first direction consists in studying the impact of the data
format adaptation step on the performance of the code. More particularly, the
goal is to provide means to isolate in the code some parts, for which lowering
the precision of the data may lead to a high improvement in terms of
performance. The second direction is to study the impact of this adaptation on
the numerical accuracy of the computed result, and the robustness of the
optimized code with respect to the input data. The goal is here to provide means
to isolate the data of the code, whose accuracy suffer from precision adaptation
in greater or lesser extent. By doing this, we will be able to decide which part
is the more relevant for the tuning process. The goal of the third direction is
to develop the global optimization tool, and to validate it using simulation
applications, like CORSIKA. For this purpose, the main idea is to use the
knowledge in terms of accuracy and performance from previous steps, in order to
discriminate between the different parts of this code. The tuning will be thus
performed on the most relevant parts, consequently reducing the
combinatorics. In this way, we hope to demonstrate a time reduction in the
adaptation of scientific numerical codes.