Publications
The generation of efficient sequential code for synchronous data-flow languages raises two
intertwined issues: control and memory optimization. While the former has been extensively
studied, for instance in the compilation of LUSTRE and SIGNAL, the latter has only been addressed
in a restricted manner. Yet, memory optimization becomes a pressing issue when arrays are added to
such languages.
This article presents a two-level solution to the memory optimization problem. It combines a
compile-time optimization algorithm, reminiscent of register allocation, paired with language
annotations on the source given by the designer. Annotations express in-place modifications and
control where allocation is performed. Moreover, they allow external functions performing in-place
modifications to be safely imported. Soundness of annotations is guaranteed by a semilinear type
system and additional scheduling constraints. A key feature is that annotations for well-typed
programs do not change the semantics of the language: removing them may lead to less efficient
code but will not alter the semantics.
The method has been implemented in a new compiler for a LUSTRE-like synchronous language extended
with hierarchical automata and arrays. Experiments show that the proposed approach removes most of
the unnecessary array copies, resulting in faster code that uses less memory.
The topic of reusable software in robotics is now largely addressed. Components based architectures, where components are independent units that can be reused accross applications, have become more popular. As a consequence, a long list of middlewares and integration tools is available in the community, often in the form of open-source projects. However, these projects are generally self contained with little reuse between them. This paper presents a software engineering approach that intends to grant middleware independance to robotic software components so that a clear separation of concerns is achieved between highly reusable algorithmic parts and integration frameworks. Such a decoupling let middlewares be used interchangeably, while fully benefitting from their specific, individual features. This work has been integrated into a new version of the open-source GenoM component generator tool: GenoM3.