https://www.mdu.se/

One pressing challenge of many modern embedded systems is to successfully deal with the considerable amount of data that originates from the interaction with the environment. A recent solution comes from the use of GPUs, providing a significantly improved performance for data-parallel applications. Another trend in the embedded systems domain is component-based development. However, existing component-based approaches lack specific support to develop embedded systems with GPUs. As a result, components with GPU capability need to encapsulate all the required GPU information, leading to component specialization to specific platforms, hence drastically impeding component reusability. To facilitate component-based development of embedded systems with GPUs, we introduce the concept of flexible components. This increases the design flexibility by allowing the system developer to decide component allocation (i.e., either the CPU or GPU) at a later stage of the system development, with no change to the component implementation. Furthermore, we provide means to automatically generate code for adapting flexible components corresponding to their hardware placement, as well as code for component communication. Through the introduced support, components with GPU capability are platform-independent, and can be executed, without manual adjustment, on a large variety of hardware (i.e., platforms with different GPU characteristics).

Component-based development is a software engineering paradigm that can facilitate the construction of embedded systems and tackle its complexities. The modern embedded systems have more and more demanding requirements. One way to cope with such versatile and growing set of requirements is to employ heterogeneous processing power, i.e., CPU-GPU architectures. The new CPU-GPU embedded boards deliver an increased performance but also introduce additional complexity and challenges. In this work, we address the component-to-hardware allocation for CPU-GPU embedded systems. The allocation for such systems is much complex due to the increased amount of GPU-related information. For example, while in traditional embedded systems the allocation mechanism may consider only the CPU memory usage of components to find an appropriate allocation scheme, in heterogeneous systems, the GPU memory usage needs also to be taken into account in the allocation process. This paper aims at decreasing the component-to-hardware allocation complexity by introducing a 2-layer component-based architecture for heterogeneous embedded systems. The detailed CPU-GPU information of the system is abstracted at a high-layer by compacting connected components into single units that behave as regular components. The allocator, based on the compacted information received from the high-level layer, computes, with a decreased complexity, feasible allocation schemes. In the last part of the paper, the 2-layer allocation method is evaluated using an existing embedded system demonstrator; namely, an underwater robot.

Internet of Things is a fairly new paradigm adopted by the industry, and offers the connectivity of all the devices that surround us, via wireless systems. One of the challenges of IoT relates to the required resources to store and compute the huge amount of data resulted from devices’ connections. Cloud computing is a solution to the IoT challenges; it provides on-demand resources in an easy-to-access manner. Another trend in the enterprise world is the usage of microservice architectures. Being a newly developed paradigm, and although its principles are defined, it is difficult to have a vision of the existing microservice-based research solutions. This paper, through the mapping study methodology, provides an overview of the current state-of-the-art regarding the usage of microservice architectures by IoT and cloud computing solutions. More specifically, we synthesize the data from 364 selected studies and describe the research types, number of publications and their main venues.

Platforms equipped with GPU processors help mitigating the ever-increasing computational demands of modern embedded systems. Such systems can be specifically developed by using component-based development thanks to the concept of flexible components. Through this concept, a component can be transparently executed either on a CPU or a GPU. However, this flexibility complicates the allocation process because it adds additional complexity (i.e., due to the undecided CPU or GPU execution) and constraints to consider (i.e., CPUs and GPUs properties). In this work, we address this problem by providing an optimization model for component-based embedded systems executing on both CPU and GPU. The model addresses important optimization goals, characteristic to the embedded system domain, such as memory usage, energy usage and execution time. A novelty of this work is the formal description of the optimization model, which supports the usage of mixed integer nonlinear programming to compute optimal allocation schemes. To examine the feasibility of the proposed method, we apply the optimization model on a vision system constructed using the industrial Rubus component model.

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 640x480 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, based on the application design, automatically constructs several (functional-) equivalent component instances that are all-together used to process the same data. The solution is implemented as an extension of an existing component model (i.e., Rubus) and the evaluation of the realized extension is done through the vision system of an existing underwater robot.

One pressing challenge of many modern embedded systems is to successfully deal with the considerable amount of data that originates from the interaction with the environment. A recent solution comes from the use of GPUs. Equipped with a parallel execution model, the GPU excels in parallel processing applications, providing an improved performance compared to the CPU.

Another trend in the embedded systems domain is the use of component-based development. This software engineering paradigm that promotes construction of applications through the composition of software components, has been successfully used in the development of embedded systems. However, the existing approaches provide no specific support to develop embedded systems with GPUs. As a result, components with GPU capability need to encapsulate all the required GPU information in order to be successfully executed by the GPU. This leads to component specialization to specific platforms, hence drastically impeding component reusability.

Our main goal is to facilitate component-based development of embedded systems with GPUs. We introduce the concept of flexible component which increases the flexibility to design embedded systems with GPUs, by allowing the system developer to decided where to place the component, i.e., either on the CPU or GPU. Furthermore, we provide means to automatically generate the required information for flexible components corresponding to their hardware placement, and to improve component communication. Through the introduced support, components with GPU capability are platform-independent, being capable to be executed on a large variety of hardware (i.e., platforms with different GPU characteristics). Furthermore, an optimization step is introduced, which groups connected flexible components into single entities that behave as regular components. Dealing with components that can be executed either by the CPU or GPU, we also introduce an allocation optimization method. The proposed solution, implemented using a mathematical solver, offers alternative options in optimizing particular system goals (e.g., memory and energy usage).

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 used to develop embedded systems. However, this paradigm lacks GPU support to address the specifics of these new boards. This leads to components that typically have reduced reusability, poor maintainability and portability. One way to tackle the existing shortcomings is through flexible components, i.e., platform-agnostic components that, at design time, offer the possibility to be executed either on CPU or GPU. The current realization of flexible components, i.e., as regular components with functionality tailored for the selected hardware, introduces additional overheads such as component communication overhead. In order to tackle the introduced overheads, our solution groups connected flexible components under a flexible group that conceptually behaves as a component. We introduce an algorithm to identify the existing groups in a given component-based system and the generation rules that automatically realizes groups as regular components. To evaluate the feasibility of the new concept, the flexible group is implemented using a state-of-the-practice component model (i.e., Rubus) and examined through the vision system of an underwater robot.

Many modern embedded systems with GPUs are required to process huge amount of data that is sensed from their environment. However, due to some inherent properties of these systems such as limited energy, computation and storage resources, it is important that the resources should be used in an efficient way. For example, camera sensors of a robot may provide low-resolution frames for positioning itself in an open environment and high-resolution frames to analyze detected objects. In this paper, we introduce a method that, when possible, scavenges the unused resources (i.e., memory and number of GPU computation threads) from the critical functionality and distributes them to the non-critical functionality. As a result, the overall system performance is improved without compromising the critical functionality. The method uses a monitoring solution that checks the utilization of the system resources and triggers their distribution to the non-critical functionality whenever possible. As a proof of concept, we realize the proposed method in a state-of-the-practice component model for embedded systems. As an evaluation, we use an underwater robot case study to evaluate the feasibility of the proposed solution.

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 ap- proaches 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. More- over, 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.

Today, embedded systems incorporate GPUs through a multitude of different architectures. When it comes to the development of these systems with GPUs, component-based development is ill-equipped as it does not provide support for GPUs. Instead, the component developer needs to encapsulate inside the component, besides functionality, settings and environment information that are specific to a particular GPU architecture. This binds the component this GPU architecture. Using these hardware-specific components characterized by restricted reusability, the system developer is confined to a limited design space which may negatively impact the overall system feasibility. 

In this paper, we introduce the concept of flexible components, which are components that can be executed indifferently on CPU or GPU, regardless of the architecture. Using flexible components, component developers are relieved from the side development activities (e.g., environment information) which are automatically handled by component-level mechanisms. To enhance component communications, connection elements (i.e., adapters) are generated to handle component data transmission, taking in consideration the platform characteristics. Finally, our proposed solution is evaluated by using flexible components to implement the vision system of an underwater robot, and execute it on three platforms with different GPU architectures.