Synthesis of self-adaptable energy aware software for heterogeneous multicore embedded systems

https://doi.org/10.1016/j.microrel.2021.114184Get rights and content

Highlights

  • Definition of the self-adaptivity metrics for embedded systems

  • Application of developmental genetic programming to synthesis of embedded software

  • Designing of the poiwer-aware self-adaptive real-time embedded systems

Abstract

Contemporary embedded systems work in changing environments, some features (e.g., execution time, power consumption) of the system are often not completely predictable. Therefore, for systems with strong constraints, a worst-case design is applied. We observed that by enabling the self-adaptivity we may obtain highly optimized systems still guaranteeing the high quality of service. This paper presents a method of synthesis of real-time software for self-adaptive multicore systems. The method assumes that the system specification is given as a task graph. Then, the tasks are scheduled on a multicore architecture consisting of low-power and high-performance cores. We apply the developmental genetic programming to generate the self-adaptive scheduler and the initial schedule. The initial schedule is optimized, taking into consideration the power consumption, the real-time constraints as well as the self-adaptivity. The scheduler modifies the schedule during the system execution, whenever execution time of the recently finished task occurs other than assumed during the initial scheduling. We propose two models of self-adaptivity: self-optimization of power consumption and self-adaptivity of real-time scheduling. We present some experimental results for standard benchmarks, showing the advantages of our method in comparison with the worst case design used in existing approaches.

Introduction

Embedded systems are computer-based systems satisfying certain performance requirements and optimized according to the efficiency, minimal cost, power consumption, and sometimes other criteria. Classical design methods of highly optimized embedded systems are based on hardware-software co-synthesis [1]. Recently, multicore embedded processors have become an alternative to dedicated distributed architectures. Moreover, heterogeneous multicore platforms like SoC FPGAs, NXP Vybrid, TI Concerto, or ARM DynamIQ big.LITTLE support high performance and energy efficiency. However, efficient heterogeneous computing requires dedicated optimization methods for embedded software.

Since the cost of multicore architecture is fixed, the optimization is oriented on performance and energy consumption. Minimization of the power consumption is essential for battery-operated devices. Power-aware optimization is also used for the reduction of the cost of running and cooling the system. Usually, high-performance systems consume a lot of energy. Thus, the optimization of low-power real-time embedded systems considers the trade-off between the power consumption and performance. This can be performed during the runtime, using advanced technologies for power management, like DVFS (Digital Voltage and Frequency Scaling) or ARM DynamIQ [2].

Design of real-time embedded systems usually is based on the worst case time estimation of execution times for all tasks. Similarly, the expected energy efficiency is based on the worst case estimation of energy consumption. During the runtime, it may happen that the execution times of some tasks may dynamically change or may be different from estimations. It may be caused by data-dependent computations, by too pessimistic estimation or by some unpredictable events like interrupts or waiting for I/O devices. To take into consideration such cases, the idea of self-adaptivity may be used for self-optimization to increase the performance or to reduce the power consumption of the system.

Self-adaptivity is the ability of the system to adapt its behaviour in response to the environment [3]. The increasing complexity of contemporary systems makes it increasingly difficult to deal with the management of such systems. Moreover, the cost of handling the complexity of these systems also increases. These problems concern the system maintenance, the evolution of software, fault management, optimisation of certain system properties like performance, power consumption, and cost. In recent years, we may observe the increasing requirement to deal with the above issues at run-time. Therefore, the self-adaptivity may address various concerns. This work attacks two problems. First, how to automatically build self-adaptivity into the system. Second, how to assess the self-adaptability of a system.

In this paper, a novel method for the synthesis of the self-adaptive energy aware software for real-time multicore embedded systems is presented. The method assumes that the software specification is given as a task graph. The goal of the synthesis is to find the optimal schedule, assuming a distributed architecture consisting of low-power and high-performance cores. In the paper, the architecture is based on heterogeneous multicore processors supporting the ARM DynamIQ big.LITTLE technology is assumed. First, the developmental genetic programming (DGP) is used for generation of the self-adaptive task scheduler. The self-adaptivity means that the scheduler dynamically reschedules tasks whenever any task finishes its execution earlier or later than expected. The first case means that there is more time to execute the remaining tasks, so the power consumption may be reduced by moving some tasks to low-power cores. In the second case, some of the remaining tasks are moved to high-performance cores to satisfy all time constraints. Therefore, two models of the self-adaptivity are proposed: self-optimization of power consumption and self-adaptivity of real-time scheduling. This work continues our research presented in [4,5]. In comparison to our previous work, we introduce new, more appropriate, metrics. The main contribution of the presented methodology is that it defines the self-adaptivity as the additional feature of the system that is optimized. Moreover, instead of applying the worst case design, we optimize the system for average execution times. Such approach gives significantly better results while supporting a high quality of service. We present also experimental results showing the advantages and the effectiveness of our methodology.

The rest of the paper is organized as follows. In the next section, the related work is presented. In Section 3, the concept of the developmental genetic programming with respect to the synthesis of embedded software as well as supporting the self-adaptivity is described. Section 4 presents definitions of the self-adaptivity and outlines our method. In Section 5, an example and experimental results are given. Finally, the paper ends with conclusions.

Section snippets

Related work

Works related to self-adaptiveness mainly concern certain features of a software. Four classes of self-adaptive systems were defined: self-configuring, self-protecting, self-optimizing, and self-healing [6]. The main approaches concentrate on different self-adaptive methodologies like internal/external control mechanisms [7], component-based software engineering [8], model-driven methodology [9], nature-inspired engineering [10], multiagent systems [8,11], and feedback systems [12].

As far

Developmental genetic programming

Developmental Genetic Programming (DGP) [23] is based on the genetic algorithm (GA). In the DGP, a classical genetic approach was extended by adding to it the developmental stage. As a consequence of it, in DGP, the evolution is applied to develop and optimize the method of building the optimal solution, in contrast to GA, where the optimal solution itself is searched for. That is a major difference, because it allows to find the best algorithm of building a solution, which is able to modify it

Synthesis of self-adaptive scheduler

If the DGP is applied to optimize of the task scheduling in embedded systems, then the genotype will correspond to the optimized scheduling strategy while the phenotype will represent the final makespan. Usually the phenotype is implemented in the target system, this corresponds to the static schedule. In our approach, the phenotype as well as the G2P mapping function are implemented in the system. As a result, a system with self-adaptive scheduler is achieved.

Experimental results

Our method was implemented in C language and we performed some experiments on PC. In our previous work [4,25] we showed that the DGP gives better results than other known methods when power minimization is concerned. Experiments were done for real-life examples as well as for some benchmarks from PSPLIB [30]. The library contains sets of task graphs used for the evaluation of different scheduling strategies. We also showed that the self-adaptation may compensate some disruptions in the

Conclusions

In this paper, we present the novel method of automatic synthesis of self-adaptive software for real-time distributed embedded systems implemented using heterogeneous multicore processors. The developmental genetic programming was used for generation of the scheduler and optimization of the initial schedule. The goal of optimization is to find the optimal trade-off between the power consumption and the self-adaptivity capabilities. We defined two types of self-adaptiveness: self-adaptivity of

CRediT authorship contribution statement

Stanisław Deniziak: Conceptualization, Methodology, Supervision, Writing- Reviewing and Editing.

Leszek Ciopiński: software, Writing- Original draft preparation, validation.

Declaration of competing interest

The authors declare that they have no known competing financial interests or personal relationships that could have appeared to influence the work reported in this paper.

References (34)

  • H. Schmeck et al.

    Adaptivityand self-Organization in Organic Computing Systems

    ACM Trans. Auton. Adapt. Sys.

    (2010)
  • T. Vogel et al.

    Model-driven architectural monitoring and adaptation for autonomic systems

  • P. Leitao

    Holonic rationale and bio-inspiration on design of complex emergent and evolvable systems

  • P. Oreizy et al.

    An architecture-based approach to self-adaptive software

    IEEE Intell. Syst.

    (1999)
  • M.T. Higuera-Toledano et al.

    Self-Organization in Embedded Real-Time Systems

    (2012)
  • H. Gharsellaoui et al.

    Real-time reconfigurable scheduling of multiprocessor embedded systems using hybrid genetic based approach

  • K.M. Calhoun et al.

    Planning and re-planning in project and production scheduling

    OMEGA Int. J. Manag. Sci.

    (2002)
  • View full text