Gabriel Campeanu

Extending the Rubus Component Model with GPU-Aware Components

To support the complex functionality expected of modern embedded systems, the trend is to supplement CPUs with Graphical Processing Units (GPUs), thus creating heterogeneous embedded systems. However, taking full advantage of GPUs increases the complexity of the development and requires dedicated support, and no such support exists in the component models currently available. The only solution today is to completely encapsulate all GPU-specific information and operations within the components, which increases the communication overhead and reduces component reusability, thus significantly limiting the applicability of component-based development to heterogeneous embedded systems. In this paper, we propose to extend Rubus, an industrial component model for embedded systems, with dedicated support for GPUs. We introduce new constructs, including GPU ports and automatically generated adapters to facilitate seamless component communication over the heterogeneous processing units, regardless of whether the components use the CPU, GPU, or both. A running example is used for the problem description, the proposed extension, and to evaluate our solution.

Component Allocation Optimization for Heterogeneous CPU-GPU Embedded Systems

In a quest to improve system performance, embedded systems are today increasingly relying on heterogeneous platforms that combine different types of processing units such as CPUs, GPUs and FPGAs. However, having better hardware capability alone does not guarantee higher performance, how functionality is allocated onto the appropriate processing units strongly impacts the system performance as well. Yet, with this increase in hardware complexity, finding suitable allocation schemes is becoming a challenge as many new constraints and requirements must now be taken into consideration. In this paper, we present a formal model for allocation optimization of embedded systems which contains a mix of CPU and GPU processing nodes. The allocation takes into consideration the software and hardware architectures, the system requirements and criteria upon which the allocation should be optimized. In its current version, optimized allocation schemes are generated through an integer programming technique to balance the system resource utilization and to optimize the system performance using the GPU resources.

Developing CPU-GPU Embedded Systems Using Platform-Agnostic Components

Nowadays, there are many embedded systems with different architectures that have incorporated GPUs. However, it is difficult to develop CPU-GPU embedded systems using component-based development (CBD), since existing CBD approaches have no support for GPU development. In this context, when targeting a particular CPU-GPU platform, the component developer is forced to construct hardware-specific components, which are problematic to (re-)use in different contexts. Moreover, hard-coding specific GPU-usage characteristics (e.g., the number of utilized GPU threads) inside the component is not possible without making detailed assumptions about the system in which the component is used, which conflicts with separation-of-concerns CBD principle.The paper presents a solution to allow component-based development of platform-agnostic CPU-GPU embedded systems through: i) high-level API, ii) adapters, and iii) code template. The API abstracts the specifics of the different platforms, while the adapters externalize hardware-specific activities outside components. We also raise the decision regarding the GPU-usage specifications, from the component to the system level. Furthermore, to minimize the development effort, we provide a code template that contains ready-made code fragments required for GPU development. As a case study, we examine the feasibility of our solution applied on a component-based vision system of an underwater robot.

Parallel Execution Optimization of GPU-aware Components in Embedded Systems.

Many embedded systems process huge amount of data that comes from the interaction with the environment. The Graphics Processing Unit (GPU) is a modern embedded solution that tackles the efficiency ...

Facilitating Component Reusability in Embedded Systems with GPUs.

One way to fulfill the increased requirements (e.g., performance) of modern embedded systems is through the usage of GPUs. The existing embedded platforms that contain GPUs bring several challenges when developing applications using the component-based development methodology. With no specific GPU support, the component developer needs to encapsulate inside the component, all the information related to the GPU, including the settings regarding the GPU resources (e.g., number of used GPU threads). This way of developing components with GPU capability makes them specific to particular contexts, which negatively impacts the reusability aspect. For example, a component that is constructed to filter 640\(\,\times \,\)480 pixel frames may produce erroneous results when reused in a context that deals with higher resolution frames. We propose a solution that facilitates the reusability of components with GPU capabilities. The solution automatically constructs several (functional-) equivalent component instances that are all-together used to process the same data. The solution is implemented as a state-of-the-practice component model (i.e., Rubus) and the evaluation of the realized extension is done through the vision system of an existing underwater robot.

Optimized Realization of Software Components with Flexible OpenCL Functionality.

Today, the newly available embedded boards with GPUs provide a solution to satisfy the ever-increasing requirements of modern embedded systems. Component-based development is a well-known paradigm ...

Run-time component allocation in CPU-GPU embedded systems

Nowadays, many of the modern embedded applications such as vehicles and robots, interact with the environment and receive huge amount of data through various sensors such as cameras and radars. The challenge of processing large amount of data, within an acceptable performance, is solved by employing embedded systems that incorporate complementary attributes of CPUs and Graphics Processing Units (GPUs), i.e., sequential and parallel execution models. Component-based development (CBD) is a software engineering methodology that augments the applications development through reuse of software blocks known as components. In developing a CPU-GPU embedded application using CBD, allocation of components to different processing units of the platform is an important activity which can affect the overall performance of the system. In this context, there is also often the need to support and achieve run-time component allocation due to various factors and situations that can happen during system execution, such as switching off parts of the system for energy saving. In this paper, we provide a solution that dynamically allocates components using various system information such as the available resources (e.g., available GPU memory) and the software behavior (e.g., in terms of GPU memory usage). The novelty of our work is a formal allocation model that considers GPU system characteristics computed on-the-fly through software monitoring solutions. For the presentation and validation of our solution, we utilize an existing underwater robot demonstrator.

A 2-Layer Component-based Architecture for Heterogeneous CPU-GPU Embedded Systems

Traditional embedded systems are evolving into heterogeneous systems in order to address new and more demanding software requirements. Modern embedded systems are constructed by combining different computation units, such as traditional CPUs with Graphics Processing Units (GPUs). Adding GPUs to conventional CPU-based embedded systems enhances the computation power but also increases the complexity in developing software applications. A method that can help to tackle and address the software complexity issue of heterogeneous systems is component-based development.

Support for high performance using heterogeneous embedded systems: a Ph.D. research proposal

Nowadays it is more common to build embedded systems on a heterogeneous platform, i.e. a platform containing different computational units such as mCPU, GPU and FPGA. This enables better performance, but also introduces additional complexity with respect to the software deployment. For complex systems it is not obvious which deployment is the best. For different constraints and requirements, different deployment configuration can be optimal. To address this problem, an approach is to model the system, including both software and hardware parts, with specification of extra-functional properties. The deployment can be then modeled and an (semi)optimal solution can be provided. In this paper we present an overview of our planned research on software modeling and software deployment of heterogeneous embedded systems, which enables assisting the developer in designing this type of systems.