FRESCOR

PROJECT OVERVIEW

Most embedded systems have timing requirements imposed by their interaction with a physical environment that changes with time. Reconfigurable architectures are a promising technology for embedded systems because they provide the adaptivity and dynamicity that a complex application with Quality of Service requirements demands. However, little work has been done in modeling and handling the timing requirements in embedded systems based on reconfigurable architectures.

Real-time scheduling theory provides solutions to the problem of being able to design systems that have predictable timing behavior and that can show evidence that their behavior meets all the timing requirements. However, to make the transition of this theory into accepted engineering practice, there are some gaps that need to be filled:

• Proper abstractions. The design methodology should take care of transforming the high-level timing requirements into the low-level RTOS primitives in a transparent way. It should be able to measure and estimate timing properties with little intervention from the developer, and apply automatic realtime analysis, as well as provide performance and quality of service estimations. It should provide fault detection and protection from faults in other components with high-level constructs. Its middleware layers should not hide away those implementation and hardware-specific details that are essential to have the ability to reason about the timing behavior.

• These methods and tools need to be closely integrated into the design process.

The solution to this problem should also look into the future in embedded systems development, when we will find a majority of systems based on reconfigurable or multiprocessor architectures, and with applications having strong needs for adaptation and reconfiguration as well.

What we propose in this project is to work towards filling those gaps by providing a well-engineered flexible resource scheduling framework that supports the following issues:

• RTOS implementation of high-level real-time services, with built-in analysis, that are platform and scheduler independent

• high-level quality of service management that adapts itself to the application-domain concepts of quality, requesting the required information from the underlying system in a transparent way.

• temporal encapsulation of subsystems, to support the composability of independently developed components.

• full view of resource protection (processors, networks, busses, memory, power, ...)

• dynamic adaptation to the reconfigurable capabilities of the underlying hardware architecture

This framework would become an enabling technology designed for providing the underlying resource scheduling support for component-based design methodologies for reconfigurable architectures. In this way, the support could be well integrated into the full design process of embedded systems, and used by the embedded systems developers through the appropriate abstractions.

In this framework, reconfiguration must be applied at several layers in the system:

• Reconfigurable processing modules. The ability of a processing node to reconfigure its own hardware architecture must be taken into account in the modeling of timing requirements from the different components. The system may use the timing requirements for making configuration decisions.

• Reconfigurable distributed architecture. The distributed nature of the application makes it necessary to take into account distributed reconfiguration strategies, dynamically adapting the system timing requirements to the available processors and networks. This is especially important in wireless environments where nodes may dynamically enter or leave the system.