Miguel Santana

FlexWare: a retargetable, embedded-software development environment

Effective embedded software development tools are essential to better exploit the inherent capabilities of these processors. We developed the FlexWare embedded software development environment in response to this need, focusing essentially on the performance and retargetability of our tools. Our benchmarks demonstrate that, despite the wide range of processors we cover, we have achieved state-of-the-art embedded software-tool performance and functionality. Moreover, we demonstrate their wide range of retargetability, ranging from simple microcontrollers to complex multimedia DSPs and network processors.

A retargetable register allocation framework for embedded processors

This paper describes the FlexCC2 register allocation framework. FlexCC2 is an optimizing retargetable C compiler for embedded processors, and in particular for DSP processors. Embedded processors often contain features such as irregular and constrained register sets that complicate register allocation, making traditional methods inefficient. In this paper, we present a register allocation framework specifically tailored for embedded processor specificities. This framework has been integrated in the FlexCC2 production compiler and is used by FlexCC2 customers.

Towards a Component-Based Observation of MPSoC

Motivated by the increasing heterogeneity and complexity of MPSoC systems, we propose a component-based generic approach for MPSoC observation. We show that components help in observing all software levels from system to application. We present the EMBera prototype and relate our experience in implementing it on two different platforms: a Linux-based 16-core SMP machine and a 5-core embedded system developed by STMicroelectronics.

Am embedded system case study: the firm ware development environment for a multimedia audio processor

This paper outlines a case study at SGS-Thomson Microelectronicson the development of a firmware development environment in co-operationwith Thomson Consumer Electronics Components. Theenviornment is for an embedded processor used for audiodecompression algorithms including: MPEG2, Dolby AC-3 Surround,and Dolby Pro-logic. The enabling component of the firmwareenvironment is a retargetable compiler which maps high-levelalgorithms onto the embedded processor. Although compilation is thecritical technology, this experience has shown that it is insufficient andthat other supporting design tools are also important. For this project,that environment includes an instruction-set simulator, a source-leveldebugger, a custom linker, and a compiler validation strategy. Themethodologies are outlined in this paper with an emphasis on thelessons learned in this hardware-software team development.

Analysis and Tracing of Applications Based on Software Transactional Memory on Multicore Architectures

Transactional Memory (TM) is a new programming paradigm that offers an alternative to traditional lock-based concurrency mechanisms. It offers a higher-level programming interface and promises to greatly simplify the development of correct concurrent applications on multicore architectures. However, simplicity often comes with an important performance deterioration and given the variety of TM implementations it is still a challenge to know what kind of applications can really take advantage of TM. In order to gain some insight on these issues, helping developers to understand and improve the performance of TM applications, we propose a generic approach for collecting and tracing relevant information about transactions. Our solution can be applied to different Software Transactional Memory (STM) libraries and applications as it does not modify neither the target application nor the STM library source codes. We show that the collected information can be helpful in order to comprehend the performance of TM applications.

FlexCC2: An Optimizing Retargetable C Compiler for DSP Processors

The design of efficient compilers for embedded processors has emerged with the growing importance of embedded application-specific processors and DSPs in consumer, multimedia and communication applications. We present in this paper the FlexCC2 compiler. FlexCC2 is a retargetable compiler for embedded processors, part of the FlexWare embedded software development environment. Application specific processors often contain specific and dedicated features like specific instructions that traditional compilers hardly accommodate. In this context, compilers able to produce high quality code, both in size and performance while being easily retargetable and able to use processor specific instructions represent a particular competitive differentiation. FlexCC2 offers such a differentiation to its users.

Efficiently rewriting large multimedia application execution traces with few event sequences

The analysis of multimedia application traces can reveal important information to enhance program execution comprehension. However typical size of traces can be in gigabytes, which hinders their effective exploitation by application developers. In this paper, we study the problem of finding a set of sequences of events that allows a reduced-size rewriting of the original trace. These sequences of events, that we call blocks, can simplify the exploration of large execution traces by allowing application developers to see an abstraction instead of low-level events. The problem of computing such set of blocks is NP-hard and naive approaches lead to prohibitive running times that prevent analysing real world traces. We propose a novel algorithm that directly mines the set of blocks. Our experiments show that our algorithm can analyse real traces of up to two hours of video. We also show experimentally the quality of the set of blocks proposed, and the interest of the rewriting to understand actual trace data.

A fully-non-transparent approach to the code location problem

In the context of embedded systems such as cell-phones, PDA or cars and planes software, optimizations of code are required because of timing and memory constraints imposed. Many problems arise when trying to debug optimized code. One of them is the irrelevance of the mapping between the source code and the optimized target program: the Code Location Problem. This paper proposes a solution to this problem in the case of highly optimized code in the context of embedded systems. Two approaches exist: non-transparent and transparent debugging. Our approach is non-transparent. The idea is to reveal the execution of the optimized program to the user so the latter understands the mapping to the source code in spite of transformations applied to the program. We do not emulate the execution of the unoptimized program. We make good use of the programmers knowledge of its development platform. Standard debuggers do not provide the required mechanisms while compilers do not provide the relevant debug information. We propose a novel method to maintain accurate debug information when optimizing at compilation and we experiment this method on the MMDSP+ C compiler and the IDBug debugger.

Debugging component-based embedded applications

With the advent of parallel architectures in the domain of embedded systems, developing applications fully adapted to their underlying platform becomes more and more complicated. Finding and fixing bugs in such environments is even trickier. Furthermore, current complex applications cannot be developed from scratch, only based on programming language primitives. They have to follow advanced programming models and their execution will be driven by the APIs of the key underlying libraries. In this paper, we propose a new approach for source-level debuggers. Going beyond their long-established ability to support sequential programming languages, we describe the functionalities a debugger should be able to provide to debug embedded and parallel component-based applications. Then we demonstrate our solution to this problem with a debugger targeting the component framework used on an MPSoC platform. We also explain the development challenges we faced during the implementation of this GDB-based debugger and illustrate its efficiency though a case study of an image processing application.

A Generic Component-Based Approach to MPSoC Observation

Observing the execution of MPSoC is a key activity in debugging and optimizing embedded applications. However, providing suitable observation tools becomes a real challenge with the fast evolution of embedded platforms. We propose a generic component-based approach which allows for partial and configurable MPSoC observation. Genericity is obtained by encapsulating specific embedded features and exporting a generic observation API. Partial observation is achieved by instantiating and attaching observation components only to the entities of interest: application modules, HW components or different levels of the SW stack. Configurability is related to the possibility to organize and parametrize observation treatments (data collection, filtering, storing) according to the target system. The approach has been validated in several application and platform contexts including an embedded platform built by STMicroelectronics.