mdh.sePublications
Change search
Link to record
Permanent link

Direct link
BETA
Publications (10 of 18) Show all publications
Campeanu, G. (2018). A Mapping Study on Microservice Architectures of Internet of Things and Cloud Computing Solutions. In: The 7th Mediterranean Conference on Embedded Computing MECO'2018: . Paper presented at The 7th Mediterranean Conference on Embedded Computing MECO'2018, 10 Jun 2018, Budva, Montenegro (pp. 1-4).
Open this publication in new window or tab >>A Mapping Study on Microservice Architectures of Internet of Things and Cloud Computing Solutions
2018 (English)In: The 7th Mediterranean Conference on Embedded Computing MECO'2018, 2018, p. 1-4Conference paper, Published paper (Refereed)
Abstract [en]

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.

Keywords
Internet of Things, microservice, cloud computing, IoT, SLR, systematic mapping study
National Category
Computer Systems
Identifiers
urn:nbn:se:mdh:diva-38965 (URN)10.1109/MECO.2018.8406008 (DOI)2-s2.0-85050684436 (Scopus ID)9781538656822 (ISBN)
Conference
The 7th Mediterranean Conference on Embedded Computing MECO'2018, 10 Jun 2018, Budva, Montenegro
Available from: 2018-04-10 Created: 2018-04-10 Last updated: 2018-08-16Bibliographically approved
Campeanu, G., Carlson, J. & Sentilles, S. (2018). Allocation Optimization for Component-based Embedded Systems with GPUs. In: 44th Euromicro Conference on Software Engineering and Advanced Applications SEAA 2018: . Paper presented at 44th Euromicro Conference on Software Engineering and Advanced Applications SEAA 2018, 29 Aug 2018, Prague, Czech Republic (pp. 101-110).
Open this publication in new window or tab >>Allocation Optimization for Component-based Embedded Systems with GPUs
2018 (English)In: 44th Euromicro Conference on Software Engineering and Advanced Applications SEAA 2018, 2018, p. 101-110Conference paper, Published paper (Refereed)
Abstract [en]

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.

Series
EUROMICRO Conference Proceedings, ISSN 1089-6503
Keywords
Optimization, component allocation, flexible component, embedded systems, CBD, component-based development, GPU
National Category
Engineering and Technology Computer Systems
Identifiers
urn:nbn:se:mdh:diva-39267 (URN)10.1109/SEAA.2018.00026 (DOI)000450238900017 ()2-s2.0-85057201129 (Scopus ID)9781538673829 (ISBN)
Conference
44th Euromicro Conference on Software Engineering and Advanced Applications SEAA 2018, 29 Aug 2018, Prague, Czech Republic
Available from: 2018-05-23 Created: 2018-05-23 Last updated: 2018-12-06Bibliographically approved
Campeanu, G. (2018). Facilitating Component Reusability in Embedded Systems with GPUs. In: The 16th International Conference on Software Engineering and Formal Methods SEFM 2018: . Paper presented at The 16th International Conference on Software Engineering and Formal Methods SEFM 2018, 27 Jun 2018, Toulouse, France (pp. 287-301).
Open this publication in new window or tab >>Facilitating Component Reusability in Embedded Systems with GPUs
2018 (English)In: The 16th International Conference on Software Engineering and Formal Methods SEFM 2018, 2018, p. 287-301Conference paper, Published paper (Refereed)
Abstract [en]

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.

Series
Lecture Notes in Computer Science, ISSN 0302-9743 ; 10886
Keywords
component instances, component, component-based development, CBD, GPU, reusability, embedded systems
National Category
Computer Systems
Identifiers
urn:nbn:se:mdh:diva-39255 (URN)10.1007/978-3-319-92970-5_18 (DOI)000445248600018 ()2-s2.0-85049017411 (Scopus ID)9783319929699 (ISBN)
Conference
The 16th International Conference on Software Engineering and Formal Methods SEFM 2018, 27 Jun 2018, Toulouse, France
Available from: 2018-05-23 Created: 2018-05-23 Last updated: 2018-10-04Bibliographically approved
Campeanu, G. (2018). GPU Support for Component-based Development of Embedded Systems. (Doctoral dissertation). Västerås: Mälardalen University
Open this publication in new window or tab >>GPU Support for Component-based Development of Embedded Systems
2018 (English)Doctoral thesis, monograph (Other academic)
Abstract [en]

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).

Place, publisher, year, edition, pages
Västerås: Mälardalen University, 2018
Series
Mälardalen University Press Dissertations, ISSN 1651-4238 ; 264
Keywords
component-based development, CBD, software component, GPU, embedded systems, allocation
National Category
Electrical Engineering, Electronic Engineering, Information Engineering Computer Systems Embedded Systems
Research subject
Computer Science
Identifiers
urn:nbn:se:mdh:diva-39895 (URN)978-91-7485-393-3 (ISBN)
Public defence
2018-09-11, Gamma, Mälardalens högskola, Västerås, 13:15 (English)
Opponent
Supervisors
Available from: 2018-07-02 Created: 2018-06-18 Last updated: 2018-09-06Bibliographically approved
Campeanu, G., Carlson, J. & Sentilles, S. (2018). Optimized Realization of Software Components with Flexible OpenCL Functionality. In: Proceedings of the 13th International Conference on Evaluation of Novel Approaches to Software Engineering, ENASE 2018, Funchal, Madeira, Portugal, March 23-24, 2018: . Paper presented at 13th International Conference on Evaluation of Novel Approaches to Software Engineering ENASE 2018, 23 Mar 2018, Madeira, Portugal (pp. 77-88).
Open this publication in new window or tab >>Optimized Realization of Software Components with Flexible OpenCL Functionality
2018 (English)In: Proceedings of the 13th International Conference on Evaluation of Novel Approaches to Software Engineering, ENASE 2018, Funchal, Madeira, Portugal, March 23-24, 2018, 2018, p. 77-88Conference paper, Published paper (Refereed)
Abstract [en]

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.

Keywords
software component, flexible component, GPU, embedded system, CBD, component-based development, component model, OpenCL
National Category
Computer Systems
Identifiers
urn:nbn:se:mdh:diva-38648 (URN)10.5220/0006691500770088 (DOI)000450506700006 ()2-s2.0-85051969301 (Scopus ID)9789897583001 (ISBN)
Conference
13th International Conference on Evaluation of Novel Approaches to Software Engineering ENASE 2018, 23 Mar 2018, Madeira, Portugal
Projects
RALF3 - Software for Embedded High Performance Architectures
Available from: 2018-03-02 Created: 2018-03-02 Last updated: 2018-12-06Bibliographically approved
Campeanu, G. & Mubeen, S. (2018). Scavenging Run-time Resources to Boost Utilization in Component-based Embedded Systems with GPUs. International Journal On Advances in Software, 11(1), 159-169
Open this publication in new window or tab >>Scavenging Run-time Resources to Boost Utilization in Component-based Embedded Systems with GPUs
2018 (English)In: International Journal On Advances in Software, ISSN 1942-2628, E-ISSN 1942-2628, Vol. 11, no 1, p. 159-169Article in journal (Refereed) Published
Abstract [en]

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.

Place, publisher, year, edition, pages
Sweden: , 2018
Keywords
embedded system, component-based software development, component-based development, CBD, model-based development, MBD, resource utilization, monitor
National Category
Engineering and Technology Computer Systems
Identifiers
urn:nbn:se:mdh:diva-40867 (URN)
Projects
RALF3 - Software for Embedded High Performance Architectures
Available from: 2018-09-11 Created: 2018-09-11 Last updated: 2018-09-11Bibliographically approved
Campeanu, G., Carlson, J. & Sentilles, S. (2017). Developing CPU-GPU Embedded Systems using Platform-Agnostic Components. In: Proceedings - 43rd Euromicro Conference on Software Engineering and Advanced Applications, SEAA 2017: . Paper presented at 43rd Euromicro Conference on Software Engineering and Advanced Applications SEAA'17, 30 Aug 2017, Vienna, Austria (pp. 176-180). , Article ID 8051345.
Open this publication in new window or tab >>Developing CPU-GPU Embedded Systems using Platform-Agnostic Components
2017 (English)In: Proceedings - 43rd Euromicro Conference on Software Engineering and Advanced Applications, SEAA 2017, 2017, p. 176-180, article id 8051345Conference paper, Published paper (Refereed)
Abstract [en]

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.

Keywords
embedded systems, GPU, CBD, component-based development, CPU-GPU embedded systems
National Category
Computer Systems
Identifiers
urn:nbn:se:mdh:diva-37012 (URN)10.1109/SEAA.2017.20 (DOI)000426074600026 ()2-s2.0-85034422676 (Scopus ID)9781538621400 (ISBN)
Conference
43rd Euromicro Conference on Software Engineering and Advanced Applications SEAA'17, 30 Aug 2017, Vienna, Austria
Projects
RALF3 - Software for Embedded High Performance Architectures
Available from: 2017-11-27 Created: 2017-11-27 Last updated: 2018-03-15Bibliographically approved
Campeanu, G., Carlson, J. & Sentilles, S. (2017). Flexible Components for Development of Embedded Systems with GPUs. In: 24th Asia-Pacific Software Engineering Conference APSEC 2017: . Paper presented at 24th Asia-Pacific Software Engineering Conference APSEC 2017, 04 Dec 2017, Nanjing, China (pp. 219-228).
Open this publication in new window or tab >>Flexible Components for Development of Embedded Systems with GPUs
2017 (English)In: 24th Asia-Pacific Software Engineering Conference APSEC 2017, 2017, p. 219-228Conference paper, Published paper (Refereed)
Abstract [en]

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.

National Category
Computer Systems
Identifiers
urn:nbn:se:mdh:diva-37070 (URN)10.1109/APSEC.2017.28 (DOI)000428733800023 ()2-s2.0-85045943595 (Scopus ID)978-1-5386-3681-7 (ISBN)
Conference
24th Asia-Pacific Software Engineering Conference APSEC 2017, 04 Dec 2017, Nanjing, China
Projects
RALF3 - Software for Embedded High Performance Architectures
Available from: 2017-10-31 Created: 2017-10-31 Last updated: 2018-05-11Bibliographically approved
Campeanu, G. & Mubeen, S. (2017). Improving Run-Time Memory Utilization of Component-based Embedded Systems with Non-Critical Functionality. In: The Twelfth International Conference on Software Engineering Advances ICSEA 2017: . Paper presented at The Twelfth International Conference on Software Engineering Advances ICSEA 2017, 08 Oct 2017, Athens, Greece.
Open this publication in new window or tab >>Improving Run-Time Memory Utilization of Component-based Embedded Systems with Non-Critical Functionality
2017 (English)In: The Twelfth International Conference on Software Engineering Advances ICSEA 2017, 2017Conference paper, Published paper (Refereed)
Abstract [en]

Many contemporary embedded systems have to deal with huge amount of data, coming from the interaction with the environment, due to their data-intensive applications. However, due to some inherent properties of these systems, such as limited energy and resources (compute and storage), 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. Component-based software development techniques and models have proven to be efficient for the development of these systems. Many component models used in the industry (e.g., Rubus, IEC 61131) allocate, at the system initialization, enough resources to satisfy the demands of the system's critical functionality. These resources are retained by the critical functionality even when they are not fully utilized. In this paper, we introduce a method that, when possible, distributes the unused memory of the critical functionality to the non-critical functionality in order to improve its performance. The method uses a monitoring solution that checks the memory utilization, and triggers the memory distribution whenever possible. As a proof of concept, we realize the proposed method in an industrial component model. As an evaluation, we use an underwater robot case study to evaluate the feasibility of the proposed solution.

Keywords
embedded system, component-based software development, model-based development, resource utilization, monitor
National Category
Embedded Systems
Identifiers
urn:nbn:se:mdh:diva-37044 (URN)
Conference
The Twelfth International Conference on Software Engineering Advances ICSEA 2017, 08 Oct 2017, Athens, Greece
Projects
RALF3 - Software for Embedded High Performance Architectures
Available from: 2017-11-20 Created: 2017-11-20 Last updated: 2017-11-20Bibliographically approved
Campeanu, G. (2017). Parallel Execution Optimization of GPU-aware Components in Embedded Systems. In: Proceedings of the International Conference on Software Engineering and Knowledge Engineering, SEKE2017: . Paper presented at The 29th International Conference on Software Engineering & Knowledge Engineering SEKE 2017, 5-7 Jul 2017, Pittsburgh, United States (pp. 135-141).
Open this publication in new window or tab >>Parallel Execution Optimization of GPU-aware Components in Embedded Systems
2017 (English)In: Proceedings of the International Conference on Software Engineering and Knowledge Engineering, SEKE2017, 2017, p. 135-141Conference paper, Published paper (Refereed)
Abstract [en]

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 challenge when processing a lot of data. GPU may improve even more the system performance by allowing multiple activities to be executed in a parallel manner. In a complex component-based application, the challenge is to decide the components to be parallel executed (onto GPU) when considering different system factors (e.g., GPU memory, GPU computation power). In the context of component-based CPU-GPU embedded systems, we propose an automatic method that provides parallel execution schemes of components with GPU capabilities. The introduced method considers hardware (e.g., available GPU memory) and software properties (e.g., required GPU memory) and communication pattern. Moreover, the method optimizes the overall system performance based on component execution times and system architecture (i.e., communication pattern). The validation uses an underwater robot example to describe the feasibility of our proposed method.

Keywords
CBD, component-based development, CPU-GPU, embedded systems, GPU-aware component, GPU component, parallel component execution, optimization
National Category
Computer Systems
Identifiers
urn:nbn:se:mdh:diva-35504 (URN)10.18293/SEKE2017-137 (DOI)2-s2.0-85029538940 (Scopus ID)1891706411 (ISBN)
Conference
The 29th International Conference on Software Engineering & Knowledge Engineering SEKE 2017, 5-7 Jul 2017, Pittsburgh, United States
Projects
RALF3 - Software for Embedded High Performance Architectures
Available from: 2017-06-09 Created: 2017-06-09 Last updated: 2017-10-05Bibliographically approved
Organisations
Identifiers
ORCID iD: ORCID iD iconorcid.org/0000-0001-9794-5497

Search in DiVA

Show all publications