Some of the topics of my research include:
Obviously, one of the best places to start looking for the results of my research is the publications page. It will give you all the information needed for locating the publications.
These are the abstracts (1 page) of the Ph.D. text:
The full text of the dissertation can be found here with the errata (both in English), the following is the abstract:The last decade has seen an enormous leap in digital processing: processing units are becoming increasingly faster and are being equipped with more memory. Whenever statements like these are being made, Moore's Law is quoted: The speed of a processor doubles every 18 months. Unfortunately, a similar speedup is not present for memory. This discrepancy results in the processor-memory bottleneck: a fast processor is no longer able to fetch the required data to keep itself fully occupied. Still, a number of production properties assure that these devices are becoming more cheap. As a result, digital processing is now present at every level of society.
One of the core domains in which this evolution has become prominent only recently, are the field of devices that are not dependent on the power grid. These devices with an independent power supply have different design constraints. When the algorithms are being ported to these platforms, considerations like code re-sue and raw performance are less important when compared to energy dissipation of the devices during the algorithm run: a user will mind if he needs to re-charge his cell phone every eight hours; the overall usability of the device will be dependent on the time between re-charges.
In order to design an energy efficient system, these energy considerations need to be taken into account in every step of the design: from the initial system specification until the implementation of the software that will run on these devices.
Due to the availability of ever more performant digital signal processors (DSPs) on the one hand and more complex algorithms on the other hand, research into the efficient implementation of dynamic memory is required. Especially since dynamic memory is one of the core components of these current-day algorithms. In contrast with static memory, it is no longer possible to predict the memory requirements at compile-time. The dynamic memory usage is largely determined by the environment, from parameters set by the user of the apparatus to properties of the physical environment where the device running the software is used. The developer has absolutely no control over these settings.
This dissertation mainly focusses on the efficient implementation of dynamic data structures for multimedia applications on embedded systems. A dynamic data structure is a software concept that allows a program to retrieve data without the need of specifying the size of the structure at start-up: a program can incrementally request more memory from the system (and free it again).
In order to be able to evaluate the different implementation alternatives, we take the used memory, the number of accesses and the behaviour of the memory usage over time into account. These factors are combined into a function that represents a relative value of the energy dissipation (or power consumption).
In this thesis, we propose a library of often used data-types to choose from. Next to this, we discuss the development and use of a tool that enables the user to transform source code in such a way that the afore mentioned metrics can be obtained.
Furthermore, we discuss and apply an approach to implement dynamic data types, using abstract derived classes . This approach enables the user to compose complex layered data structures with a minimum of lines of code. All this is done in a simple and straightforward fashion.
Even though the implementation of the dynamic data types is very important, an application cannot be efficient if it stores too much data for too long a time. In order to avoid this, we propose to apply a number of techniques that are used to optimise static data types much earlier in the design optimisation. We want to refine the number of dynamic data types before we refine the implementation of the (remaining) data types. Only if the number of dynamic data-types is reduced to a minimum, can the application be efficient.
Finally, we link these dynamic data-type focussed issues with the subsequent step in the global optimisation flow and provide a seamless integration with the design and refinement of dynamic memory allocators, a system component that keeps track of the used physical memory.
All these techniques are applied on two multimedia applications. The first application is the initialisation of a 3D reconstruction algorithm Since a large part of the subsequent processing phases has similar pieces to this initialisation, the application of the our techniques will have a profound influence on the performance as well as on the estimated memory consumption. The second application is a simple game engine. Even though these algorithms are completely different, we can show that the problems that occur are comparable.
Last update: