## Section: Research Program

### Mathematical Tools

All compilers have to deal with *sets* and relations. In classical
compilers, these sets are finite: the set of statements of a program, the set
of its variables, its abstract syntax tree (AST), its control-flow graph
(CFG), and many others. It is only in the first phase of compilation,
parsing, that one has to deal with infinite objects, regular and context-free
languages, and those are represented by finite grammars, and are processed by
a symbolic algorithm, `yacc` or one of its clones.

When tackling parallel programs and parallel compilation, it was soon
realized that this position was no longer tenable. Since it makes no
sense to ask whether a statement can be executed in parallel with itself,
one has to consider sets of operations, which may be so large as to
forbid an extensive representation, or even be infinite. The same is true
for dependence sets, for memory cells, for communication sets, and for
many other objects a parallel compiler has to consider. The representation
is to be *symbolic*, and all necessary algorithms have to be promoted
to symbolic versions.

Such symbolic representations have to be efficient – the formula representing a set has to be much smaller than the set itself – and effective – the operations one needs, union, intersection, emptiness tests and many others – have to be feasible and fast. As an aside, note that progress in algorithm design has blurred the distinction between polynomially-solvable and NP-complete problems, and between decidable and undecidable questions. For instance SAT, SMT, and ILP software tools solve efficiently many NP-complete problems, and the Z3 tool is able to “solve” many instances of the undecidable Hilbert's 10th problem.

Since the times of Pip and of the Polylib, Compsys has been active in the implementation of basic mathematical tools for program analysis and synthesis. Pip is still developed by Paul Feautrier and Cédric Bastoul, while the Polylib is now taken care of by the Inria Camus project, which introduced Ehrhart polynomials. These tools are still in use world-wide and they also have been reimplemented many times with (sometimes slight) improvements, e.g., as part of the Parma Polylib, of Sven Verdoolaege's Isl and Barvinok libraries, or of the Jollylib of Reservoir Labs. Other groups also made a lot of efforts towards the democratization of the use of polyhedral techniques, in particular the Alchemy Inria project, with Cloog and the development of Graphite in GCC, and Sadayappan's group in the USA, with the development of U. Bondhugula's Pluto prototype compiler. The same effort is made through the PPCG prototype compiler (for GPU) and Pencil (directives-based language on top of PPCG).

After 2009, Compsys continued to focus on the introduction of concepts and
techniques to extend the polytope model, with a shift toward tools that may
prepare the future. For instance, PoCo and C2fsm are able to parse
general programs, not just SCoPs (static control programs), while the efficient
handling of Boolean affine formulas [13] is a prerequisite for
the construction of non-convex approximations. Euclidean lattices provide an
efficient abstraction for the representation of spatial phenomena, and the
construction of *critical lattices* as embedded in the tool Cl@k is a
first step towards memory optimization in stream languages and may be useful in
other situations. Our work on Chuba introduced a new element-wise array
reuse analysis and the possibility of handling approximations. Our work on the
analysis of while loops is both an extension of the polytope model itself
(i.e., beyond SCoPs) and of its applications, here links with program
termination and worst-case execution time (WCET) tools.

A recent example of this extension idea is the proposal by Paul Feautrier to use polynomials for program analysis and optimization [14]. The associated tools are based on Handelman and Schweighofer theorems, the polynomial analogue of Farkas lemma. While this is definitely work in progress, with many unsolved questions, it has the potential of greatly enlarging the set of tractable programs.

As a last remark, observe that a common motif of these developments is the transformation of finite algorithms into symbolic algorithms, able to solve very large or even infinite instances. For instance, PIP is a symbolic extension of the Simplex; our work on memory allocation is a symbolic extension of the familiar register allocation problem; loop scheduling extends DAG scheduling. Many other algorithms await their symbolic transformation: a case in point is resource-constrained scheduling.