EU Funded Research Projects

Here it is the European Commission funded research projects in which I have been involved, with brief description of what I did inside each one:

  • Framework for Real-time Embedded System based on COntRacts
    (FRESCOR, FP6/2005/IST/5-034026)
    It was worth to have a port on GNU/Linux of the software architecture conceived in the projects, and the AQuoSA middleware was selected as the mean of
    realizing FRSH contracts on such a platform. Thus, a prototype implementation of FRSH on top of AQuoSA has been realized. It acted for a while as a proof of concept that AQuoSA is usable for this purpose.

    After that, the implementation has been (and is still being) reworked, together with some of the other partners, in order to achieve better modularity and
    make all the interested ones able to use it either for their project achievements, or even beyond the scope of FRESCOR.

    During this implementation work, collaborations with other partners have been established, both for the development itself and to make them able to use the
    resulting software architecture. This involved mainly ReTiS Lab, Czech Technical University (collaboration during development), Visual Tools and
    Kaiserslautern University (users of the framework).

  • Interactive Realtime Multimedia Applications on Service Oriented Infrastructures (IRMOS, FP7/2008/ICT/214777)

    The Linux kernel already provides fixed-priority based real-time scheduling policies. Moreover, their behaviour has been recently enhanced by developers
    with some bandwidth limitation strategies. What was missing was an actual fixed priority reservation mechanism, implemented with low overhead and possibly
    with small effort, to achieve as predictable behaviour as possible, without forgetting about performances and load balancing requirements.

    The POSIX specification for the Sporadic Server scheduling, which is missing in the mainstream Linux kernel, have been selected as a possible solution to this,
    at least in the very first stage of the project. Thus, it has been implemented in the Linux kernel.
    It then has also been slightly modified and implemented again, to better cope with issues such as overhead and limited timing resolution typical for a real physical system.

    Finally, the implementation has been submitted to the Linux kernel community and has been reviewed from some of the developers. Now it is being adapted to the comment
    that they provided in order to being submitted again and maybe (who knows?!?) accepted.

  • Adaptivity and Control of Resources in Embedded Systems
    (ACTORS, FP7-ICT-216586)

    ACTORS addresses design of resource-constrained software-intensive embedded systems with high requirements on adaptivity and efficiency.

    Execution efficiency and development efficiency require abstractions on a higher level than what is provided with C and threads/priorities.
    Data-flow models such as actor models provide the proper foundation for implementation of efficient, component based, and adaptive algorithms
    for both multimedia applications in consumer electronics and industrial control systems and signal processing applications.
    In ACTORS a design methodology will be developed that combines virtualization, feedback and actors-based dataflow programming. Three demonstrators will be developed:

    • multimedia processing on cellular phone terminals,
    • embedded control, and
    • high-speed video processing for computer vision applications.

    A new scheduling class, called SCHED_DEADLINE, is being implemented in the Linux kernel.
    It implements the Earliest Deadline First (EDF) algorithm, with the Constant
    Bandwidth Server (CBS) as the resource reservation enforcer.

    Each task is characterized by a “budget” sched_runtime and a “period” sched_period, equal to its deadline. At any instant of time, the system schedules the (ready) task having
    earliest deadline. During execution, task’s budget is decreased by an amount equal to the time executed. When task’s budget reaches zero (i.e., the task executed for a time equal to
    its budget), it is stopped until the time instant of its next deadline. At that time, the task is made runnable again, its budget is refilled and a new deadline is computed. This means that the task is guaranteed a share of processor time equal to sched_runtime/sched_period every sched_period. Of course, the sum of sched_runtime/sched_period of all tasks cannot be higher than the total throughput available on the system (i.e., 100% on uniprocessor systems), otherwise the system is overloaded and task deadlines cannot be guaranteed.

    When a task tries to execute more than its budget, it is slowed down, by stopping it until the time instant of its next deadline. When, at that time, it is made runnable again, its budget is refilled and a new deadline is computed.