mdh.sePublications
Change search
Refine search result
1 - 20 of 20
CiteExportLink to result list
Permanent link
Cite
Citation style
  • apa
  • ieee
  • modern-language-association-8th-edition
  • vancouver
  • Other style
More styles
Language
  • de-DE
  • en-GB
  • en-US
  • fi-FI
  • nn-NO
  • nn-NB
  • sv-SE
  • Other locale
More languages
Output format
  • html
  • text
  • asciidoc
  • rtf
Rows per page
  • 5
  • 10
  • 20
  • 50
  • 100
  • 250
Sort
  • Standard (Relevance)
  • Author A-Ö
  • Author Ö-A
  • Title A-Ö
  • Title Ö-A
  • Publication type A-Ö
  • Publication type Ö-A
  • Issued (Oldest first)
  • Issued (Newest first)
  • Created (Oldest first)
  • Created (Newest first)
  • Last updated (Oldest first)
  • Last updated (Newest first)
  • Disputation date (earliest first)
  • Disputation date (latest first)
  • Standard (Relevance)
  • Author A-Ö
  • Author Ö-A
  • Title A-Ö
  • Title Ö-A
  • Publication type A-Ö
  • Publication type Ö-A
  • Issued (Oldest first)
  • Issued (Newest first)
  • Created (Oldest first)
  • Created (Newest first)
  • Last updated (Oldest first)
  • Last updated (Newest first)
  • Disputation date (earliest first)
  • Disputation date (latest first)
Select
The maximal number of hits you can export is 250. When you want to export more records please use the Create feeds function.
  • 1.
    Ahlberg, Carl
    et al.
    Mälardalen University, School of Innovation, Design and Engineering. Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Asplund, Lars
    Mälardalen University, School of Innovation, Design and Engineering. Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Campeanu, Gabriel
    Mälardalen University, School of Innovation, Design and Engineering. Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Ciccozzi, Federico
    Mälardalen University, School of Innovation, Design and Engineering. Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Ekstrand, Fredrik
    Mälardalen University, School of Innovation, Design and Engineering. Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Ekström, Mikael
    Mälardalen University, School of Innovation, Design and Engineering. Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Feljan, Juraj
    Mälardalen University, School of Innovation, Design and Engineering. Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Gustavsson, Andreas
    Mälardalen University, School of Innovation, Design and Engineering. Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Sentilles, Séverine
    Mälardalen University, School of Innovation, Design and Engineering. Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Svogor, Ivan
    FOI, University of Zagreb.
    Segerblad, Emil
    The Black Pearl: An Autonomous Underwater Vehicle2013Report (Other academic)
    Abstract [en]

    The Black Pearl is a custom made autonomous underwater vehicle developed at Mälardalen University, Sweden. It is built in a modular fashion, including its mechanics, electronics and software. After a successful participation at the RoboSub competition in 2012 and winning the prize for best craftsmanship, this year we made minor improvements to the hardware, while the focus of the robot's evolution shifted to the software part. In this paper we give an overview of how the Black Pearl is built, both from the hardware and software point of view.

  • 2.
    Campeanu, Gabriel
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems. IS (Embedded Systems).
    A Mapping Study on Microservice Architectures of Internet of Things and Cloud Computing Solutions2018In: The 7th Mediterranean Conference on Embedded Computing MECO'2018, 2018, p. 1-4Conference 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.

  • 3.
    Campeanu, Gabriel
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Facilitating Component Reusability in Embedded Systems with GPUs2018In: The 16th International Conference on Software Engineering and Formal Methods SEFM 2018, 2018, p. 287-301Conference 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.

  • 4.
    Campeanu, Gabriel
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    GPU Support for Component-based Development of Embedded Systems2018Doctoral 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).

  • 5.
    Campeanu, Gabriel
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    GPU-aware Component-based Development for Embedded Systems2016Licentiate thesis, comprehensive summary (Other academic)
    Abstract [en]

    Nowadays, more and more embedded systems are equipped with e.g., various sensors that produce large amount of data. One of the challenges of traditional (CPU-based) embedded systems is to process this considerable amount of data such that it produces the appropriate performance level demanded by embedded applications. A solution comes from the usage of a specialized processing unit such as Graphics Processing Unit (GPU). A GPU can process large amount of data thanks to its parallel processing architecture, delivering an im- proved performance outcome compared to CPU. A characteristic of the GPU is that it cannot work alone; the CPU must trigger all its activities. Today, taking advantage of the latest technology breakthrough, we can benefit of the GPU technology in the context of embedded systems by using heterogeneous CPU-GPU embedded systems.

    Component-based development has demonstrated to be a promising methology in handling software complexity. Through component models, which describe the component specification and their interaction, the methodology has been successfully used in embedded system domain. The existing component models, designed to handle CPU-based embedded systems, face challenges in developing embedded systems with GPU capabilities. For example, current so- lutions realize the communication between components with GPU capabilities via the RAM system. This introduces an undesired overhead that negatively affects the system performance.

    This Licentiate presents methods and techniques that address the component- based development of embedded systems with GPU capabilities. More concretely, we provide means for component models to explicitly address the GPU-aware component-based development by using specific artifacts. For example, the overhead introduced by the traditional way of communicating via RAM is reduced by inserting automatically generated adapters that facilitate a direct component communication over the GPU memory.

    Another contribution of the thesis is a component allocation method over the system hardware. The proposed solution offers alternative options in opti- mizing the total system performance and balancing various system properties (e.g., memory usage, GPU load). For the validation part of our proposed solutions, we use an underwater robot demonstrator equipped with GPU hardware. 

  • 6.
    Campeanu, Gabriel
    Mälardalen University, School of Innovation, Design and Engineering.
    MOBILE LEARNING - THE NEW APPROACH OF THE ELECTRONIC LEARNING BASED SYSTEMS2012In: LEVERAGING TECHNOLOGY FOR LEARNING, VOL I, 2012, p. 62-66Conference paper (Refereed)
    Abstract [en]

    As the technology evolves, new ways of learning based systems are ascending. Nowadays, there are several Mobile Learning based program which are already adopted by different institutions all over the world. The Mobile Learning based system is a derivation from the well integrated electronic learning system. The new learning approach tries to fill in several gaps which are found in the classical and electronically types of learning. In this paper, the author has the intent to analyze and present several advantages which can be found in the methodology of Mobile Learning. Among them, new ideas are pointed out such as wireless classrooms learning based systems, and industrial trainings based on mobile communication devices. Another purpose of this paper is to briefly examine the existing devices and technologies available on market, which are capable in supporting Mobile Learning as a new path of the progress derived from electronically supported learning.

  • 7.
    Campeanu, Gabriel
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Parallel Execution Optimization of GPU-aware Components in Embedded Systems2017In: Proceedings of the International Conference on Software Engineering and Knowledge Engineering, SEKE2017, 2017, p. 135-141Conference 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.

  • 8.
    Campeanu, Gabriel
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Support for high performance using heterogeneous embedded systems - A Ph.D. research proposal2013In: WCOP 2013 - Proceedings of the International Doctoral Symposium on Components and Architecture, 2013, 2013, p. 19-24Conference paper (Refereed)
    Abstract [en]

    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. 

  • 9.
    Campeanu, Gabriel
    et al.
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Carlson, Jan
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Sentilles, Séverine
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    A GPU-aware Component Model Extension for Heterogeneous Embedded Systems2015In: The Tenth International Conference on Software Engineering Advances ICSEA 2015, 2015Conference paper (Refereed)
    Abstract [en]

    One way for modern embedded systems to tackle the demand for more complex functionality requiring more computational power is to take advantage of heterogeneous hardware. These hardware platforms are constructed from the combination of different processing units including both traditional CPUs and for example Graphical Processing Units (GPUs). However, there is a lack of efficient approaches supporting software development for such systems. In particular, modern software development approaches, such as component-based development, do not provide sufficient support for heterogeneous hardware platforms. This paper presents a component model extension, which defines specific features for components with GPU capabilities. The benefits of the proposed solution include an increased system performance by accelerating the communication between GPU-aware components and the possibility to control the distribution of GPU computation resources at system level.

  • 10.
    Campeanu, Gabriel
    et al.
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Carlson, Jan
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Sentilles, Séverine
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Allocation Optimization for Component-based Embedded Systems with GPUs2018In: 44th Euromicro Conference on Software Engineering and Advanced Applications SEAA 2018, 2018, p. 101-110Conference 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.

  • 11.
    Campeanu, Gabriel
    et al.
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Carlson, Jan
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Sentilles, Séverine
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Component Allocation Optimization for Heterogeneous CPU-GPU Embedded Systems2014In: The 40th Euromicro Conference on Software Engineering and Advanced Applications SEAA 2014, Verona, 27-29 Aug. 2014, 2014, p. 229-236Conference paper (Refereed)
    Abstract [en]

    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.

  • 12.
    Campeanu, Gabriel
    et al.
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Carlson, Jan
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Sentilles, Séverine
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Developing CPU-GPU Embedded Systems using Platform-Agnostic Components2017In: Proceedings - 43rd Euromicro Conference on Software Engineering and Advanced Applications, SEAA 2017, 2017, p. 176-180, article id 8051345Conference 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.

  • 13.
    Campeanu, Gabriel
    et al.
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Carlson, Jan
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Sentilles, Séverine
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Flexible Components for Development of Embedded Systems with GPUs2017In: 24th Asia-Pacific Software Engineering Conference APSEC 2017, 2017, p. 219-228Conference 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.

  • 14.
    Campeanu, Gabriel
    et al.
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Carlson, Jan
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Sentilles, Séverine
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Optimized Realization of Software Components with Flexible OpenCL Functionality2018In: 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 (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.

  • 15.
    Campeanu, Gabriel
    et al.
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Carlson, Jan
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Séntilles, Séverine
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Mubeen, Saad
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Extending the Rubus Component Model with GPU-Aware Components2016In: Proceedings - 2016 19th International ACM SIGSOFT Symposium on Component-Based Software Engineering, CBSE 2016, 2016, p. 59-68Conference paper (Refereed)
    Abstract [en]

    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.

  • 16.
    Campeanu, Gabriel
    et al.
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Mubeen, Saad
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems. IS (Embedded Systems).
    Improving Run-Time Memory Utilization of Component-based Embedded Systems with Non-Critical Functionality2017In: The Twelfth International Conference on Software Engineering Advances ICSEA 2017, 2017Conference 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.

  • 17.
    Campeanu, Gabriel
    et al.
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Mubeen, Saad
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Scavenging Run-time Resources to Boost Utilization in Component-based Embedded Systems with GPUs2018In: International Journal On Advances in Software, ISSN 1942-2628, E-ISSN 1942-2628, Vol. 11, no 1, p. 159-169Article in journal (Refereed)
    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.

  • 18.
    Campeanu, Gabriel
    et al.
    Bombardier Transportation, Västerås, Sweden.
    Saadatmand, Mehrdad
    RISE SICS Västerås, Sweden.
    A 2-layer Component-based Allocation for Embedded Systems with GPUs2019In: Designs, ISSN 2411-9660, Vol. 3, p. 1-14Article in journal (Refereed)
    Abstract [en]

    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.

  • 19.
    Campeanu, Gabriel
    et al.
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Saadatmand, Mehrdad
    SICS Swedish ICT, Västerås, Sweden.
    A 2-layer component-based architecture for heterogeneous CPU-GPU embedded systems2016In: Advances in Intelligent Systems and Computing, Volume 448, 2016, p. 629-639Conference paper (Refereed)
    Abstract [en]

    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. The allocation of the software application onto the appropriate computation node is greatly influenced by the system information load. The allocation process is increased in difficulty when we use, instead of common CPU-based systems, complex CPU-GPU systems. This paper presents a 2-layer component-based architecture for heterogeneous embedded systems, which has the purpose to ease the software-to-hardware allocation process. The solution abstracts the CPU-GPU detailed component-based design into single software components in order to decrease the amount of information delivered to the allocator. The last part of the paper describes the activities of the allocation process while using our proposed solution, when applied on a real system demonstrator.

  • 20.
    Campeanu, Gabriel
    et al.
    Mälardalen University, School of Innovation, Design and Engineering, Embedded Systems.
    Saadatmand, Mehrdad
    Swedish Institute of Computer Science (SICS), Sweden.
    Run-Time Component Allocation in CPU-GPU Embedded Systems2017In: 32nd ACM SIGAPP Symposium On Applied Computing SAC2017, 2017, p. 1259-1265Conference paper (Refereed)
    Abstract [en]

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

1 - 20 of 20
CiteExportLink to result list
Permanent link
Cite
Citation style
  • apa
  • ieee
  • modern-language-association-8th-edition
  • vancouver
  • Other style
More styles
Language
  • de-DE
  • en-GB
  • en-US
  • fi-FI
  • nn-NO
  • nn-NB
  • sv-SE
  • Other locale
More languages
Output format
  • html
  • text
  • asciidoc
  • rtf