## Section: New Results

### Program termination and worst-case computational complexity

Participants : Christophe Alias, Laure Gonnord [ Former ATER in Compsys, now MCF Lille ] , Paul Feautrier, Alain Darte.

Our current work on program termination arose when trying to transform while loops into do loops (i.e., loops with a bounded number of iterations) so that HLS tools can accept them. Some HLS tools indeed need this information either for unrolling loops, for pipelining them, or for scheduling, at a higher-level, several pipelined designs including loops. Determining the maximal number of iterations of a while loop is a particular case of determining the worst-case computational complexity (WCCC) of a function or subroutine, which is, briefly speaking, an upper-bound on the number of elementary computations that it performs. It is an abstract and architecture-independent view of the well-known worst-case execution time (WCET). Knowledge of WCET is a key information for embedded systems, as it allows the construction of a schedule and the verification that real-time constraints are met. The WCCC and WCET problems are obviously connected to the termination problem: a piece of code that does not terminate has no WCCC and no WCET.

The standard method for proving the termination of a flowchart program is to exhibit a ranking function [21] , i.e., a function from the program states to a well-founded set, which strictly decreases at each program step. A standard method to automatically generate such a function is to compute invariants )approximation of all possible values of program variables) for each program point and to search for a ranking in a restricted class of functions that can be handled with linear programming techniques. Previous algorithms based on affine rankings either are applicable only to simple loops (i.e., single-node flowcharts) and rely on enumeration, or are not complete in the sense that they are not guaranteed to find a ranking in the class of functions they consider, if one exists.

Our first contribution is to propose an efficient algorithm to compute ranking
functions, reinvesting most of the techniques from [20] to
schedule static loops. It can handle flowcharts of arbitrary structure, the
class of candidate rankings it explores is larger, and our method, although
greedy, is provably complete. We have built a complete software suite which
first uses the `c2fsm` tool to convert the C source into a counter automaton.
The Aspic tool is then responsible for computing invariants as polyhedral
approximations. Finally, they are given to RanK which constructs a ranking
(if any) using Pip. Thanks to this toolchain, our method is able to handle
every program whose control can be translated into a counter automaton. This
roughly covers programs whose control depends on integer variables exclusively,
using conditionals, do loops and while loops whose tests are affine
expressions on variables. Furthermore, it is easy to approximate programs
which are outside this class by familiar techniques, like ignoring non-affine
tests or variables with too complex a behavior. Termination of the approximate
program entails termination of the original program, but the converse is not
true.

Our second contribution is to show how to use the ranking functions we generate to get upper bounds for the computational complexity (number of transitions) of the source program, again for flowcharts of arbitrary structure. This estimate is a polynomial, which means that we can handle programs with more than linear complexity. RanK computes the WCCC using the Ehrhart polynomial module of the Polylib.

This method can be extended in several interesting directions: