A dynamic scheduling algorithm for energy harvesting embedded systems

Abstract

Energy harvesting embedded systems are embedded systems that integrate with energy harvesting modules. In this kind of systems, service tasks and energy harvesting tasks must be scheduled efficiently to keep the whole system working properly as long as possible. In this paper, we model an energy harvesting embedded system with an energy model, a task model, and a resource model and propose a dynamic task scheduling algorithm. The proposed algorithm is based on dynamic voltage and frequency scaling technique and dynamically concentrates all disperse free time together to harvest energy. We validate the efficiency and effectiveness of the proposed algorithm under both energy-constraint and non-energy-constraint situations with the Yartiss simulation tool.

1 Introduction

In embedding systems, the energy is usually provided with batteries, and the requirements of real time and many extensive smart functions make embedding systems consume more and more energy [1]. If we run the embedding systems arbitrarily, the energy would run out very quickly; this would shorten the working time of smart devices. The techniques of dynamic voltage and frequency scaling (DVFS) [2] and dynamic power management (DPM) [3] could decrease the power consumption of embedding systems whereas satisfying the time constraints. However, once deployed, the embedded application will run a long time, and the energy of the battery will run out finally. Besides replacement of the battery, the embedded systems can harvest energy from the external environment [4], such as sunshine [5], wind [6], and vibration [7]. By applying these energy harvesting techniques [8, 9], the working time of embedded systems can be increased. While harvesting energy from the environment, both the harvest and storage of energy need processing time, and this needs to reschedule the processor and thus interrupts the working tasks. So, an energy harvesting embedded system is an embedded system with different kinds of energy harvesting modules inside.

In energy harvesting embedded systems [10], one needs to schedule tasks between harvesting tasks with working tasks, and the aim is to keep the energy of embedded systems in a reasonable level, while providing normal working services at the same time. During the scheduling of the tasks in energy harvesting embedded systems, both the energy output and storage units are the physical environment and the change of status is a continuous physical process [11]. The physical process provides much information for the computing environment, and the decision-making process of the computing environment affects the physical environment too. According to interaction and fusion [12] of the computing and physical environment, one can allocate the resources efficiently and thus optimize the performance of the whole system.

In this paper, we study the problem of task scheduling in energy harvesting embedded systems. In an energy harvesting embedded system, the system needs to harvest energy from the external environment during free or idle time. We model an energy harvesting embedded system with an energy model, a task model, and a resource model and propose a dynamic task scheduling algorithm. Based on dynamic voltage and frequency scaling techniques, the proposed algorithm concentrates all disperse free time together to harvest energy by dynamically scheduling harvesting tasks and service tasks.

The rest of the paper is organized as follows. In Section 1.2, we review related works about scheduling algorithms in embedded systems. In Section 1.3, we propose a model for energy harvesting embedded systems. In Section 1.4, we propose a dynamic task scheduling algorithm. Experiments and conclusions are given in Sections 1.5 and 2, respectively.

2 Related works

In this section, we review related works about scheduling algorithms in embedded systems, especially focus on energy saving and energy harvesting scheduling algorithms.

2.1 Energy saving scheduling algorithms

Energy saving task scheduling is a key research in embedded systems and sensor networks. The techniques of energy saving scheduling can be classified into traditional scheduling method and utility-based scheduling method. Traditional energy-saving scheduling methods [13, 14] can be applied to the simple task-arrival mode, such as period tasks, but it cannot assure the arrival tasks to be scheduled in real time.

In general, every completion of a task would bring some utility, and the utility depends on the running time of the task. The longer the running time, the smaller the utility is. Jensen et al. [15] proposed a time/utility function to describe the relationship between the running time and the utility of a task, and their aim is to maximize the total utility by finishing all tasks as quickly as possible. References [16–18] studied how to get the maximal utility with limited energy. In addition, in order to satisfy the utility acquirement and the energy budget, Wu et al. [19] proposed a unimodal arbitrary arrival with energy bounds algorithm (EBUA), and the EBUA solved the problem of task scheduling based on unimodal arbitrary arrival model.

2.2 Energy harvesting scheduling algorithms

The task scheduling problem in energy harvesting embedded systems was first proposed by Allavena and Mossé in [20], and then some algorithms for solving this problem were proposed. The lazy scheduling algorithm (LSA) proposed by Moser et al. [21] adjusts the worst-case execution time by adjusting frequency of the CPU according to tasks’ energy consumption. The LSA is based on a strong assumption that the worst-case execution time of a task is related with its energy consumption directly, and this assumption is impractical [22]. Chandarli et al. [23] proposed an ALAP scheduling algorithm, and it was a fixed-priority scheduling policy that delayed the executions of jobs as long as possible. Abdeddaïm et al. [24] proposed an ASAP algorithm, and this algorithm scheduled tasks as soon as possible when there was available energy in the battery and suspended execution to replenish the energy needed to execute one time unit. Under constraints of energy and time, ASAP is proved to be optimal.

In addition, in order to get better system performance and less energy consumption, some scheduling algorithms [25, 26] take dynamic voltage frequency scaling into consideration. The EA-DVFS algorithm [25], proposed by Liu et al., adjusts the CPU frequency by the remaining energy of the system. If there is not enough energy to run the task, then it decreases the CPU frequency; otherwise, it runs the task with maximal CPU frequency. The HA-DVFS algorithm [26] optimizes the system performance and improves the energy utilization further based on the EA-DVFS algorithm. However, in some real-time embedded systems with high reliability, DVFS and related algorithms can extend the running time of tasks, affect the run-time attribute of the system, and thus decrease its reliability.

3 Energy harvesting embedded system model

In this section, we model the embedded system with an energy model, a task model, and a resource model.

3.1 The energy model

In this paper, we applied the system-level energy model proposed by Martin [27] in his doctoral thesis. We let the CPU value be 1, if it runs with maximal speed. So, the amount of computation is also the number of clock period under maximal speed. We assume that the embedded system supports DVFS and the CPU has d discrete speeds (or frequencies) f _i (1 ≤ i ≤ d). The CPU speed f _i means that the CPU runs f _i clock periods per second. When the CPU runs with speed f, the energy consumption can be described as

$$ \mathrm{P}\mathrm{C}={S}_3{f}^3+{S}_2{f}^2+{S}_1f+{S}_0, $$

(1)

where S ₃, S ₂, S ₁, and S ₀ are constants.

In the above model, the system-level energy consumption includes dynamic energy consumption, static energy consumption, and the energy consumed by other components. So, when the system runs with frequency f, the energy consumption of every clock period is

$$ E(f)={S}_3{f}^2+{S}_2f+{S}_1+\frac{S_0}{f} $$

(2)

3.2 The task model

We assume that the embedded system is a preemptive real-time system and the task set is Γ = {τ ₁, ⋯, τ _n }. Every arrival task is an instance of its corresponding task, and the jth instance of task τ _i is denoted as τ _i,j . In a unimodal arrival model, each task is related with one tuple < a _i , P _i  >, and the tuple means that the maximal number of arrival instances is a _i in any sliding window P _i . The periodic real-time task mode is a special case of the unimodal arrival model, where the value a _i equals to 1.

We use U _i (⋅) to denote the time/utility function of the task τ _i , and thus, U _i (⋅) is the time/utility function of any instance of τ _i . If τ _i,j finishes with time t, then the utility is U _i (t). In addition, we define the beginning time of U _i with the arrival time of τ _i and define the ending time of U _i with the sum of its beginning time and the length of the sliding window P _i We let the number of clock periods be c _i and the relative deadline be D _i , and both computations of c _i and D _i can be found in [19].

3.3 The resource model

We define the sharing resource set except for the CPU as SR = {SR₁, SR₂, ⋯ SR _r , where each sharing resource SR _i can be shared among all tasks but can only be accessed by one task at one time. Once some task has been authorized to access sharing resource, then this task executes a critical section. After executing of the critical section, the task releases the sharing resource. We denote the jth critical section of task τ _i as z _i,j , then the amount of computation is c _cs (z _i,j ) and the accessed resource is denoted as s(z _i,j ) ∈ SR. In addition, let N _cs (τ _i ) be the number of critical sections for τ _i , and the total amount of computation for τ _i under all non-critical sections be c _ns (τ _i ), then the amount of computation for task τ _i is

$$ {c}_i={c}_{ns}\left({\tau}_i\right)+{\displaystyle \sum_{j=1}^{N_{cs}\left({\tau}_i\right)}{c}_{cs}\left({z}_{i,j}\right)}. $$

(3)

The critical sections of a task can be nested, that is for critical sections z _i,j and z _i,k of task τ _i , we can have z _i,j  ⊂ z _i,k , z _i,k  ⊂ z _i,j , or z _i,j  ∩ z _i,k  = null.

4 Dynamic task scheduling algorithm

In this section, we propose a dynamic resource scheduling algorithm. Here, “dynamic” means that the energy harvesting module is activated dynamically to maximize the harvested energy, and at the same time, the normal services cannot be disturbed. For convenience, we denote τ _i,j as τ _i in the following sections. The dynamic scheduling algorithm preserves the computing ability for the following tasks, and for each τ _i , constraints the number of instances in any sliding window to be capacity(τ _i ). In addition, we keep the running speed in the critical section to be equal to the static frequency, and thus, the dynamic algorithm can acquire the speed in the non-critical section according to the current running status. In order to describe the proposed algorithm, we define some parameters and functions first:

• ${c}_{ns}^r\left({\tau}_i,t\right)$ is the remaining computing ability in the non-critical section of task τ _i at time t.

• ${c}_{cs}^r\left({z}_{i,j},t\right)$ is the remaining computing ability in critical section z _i,j at time t.

• EET(τ _i , t) is the required estimating time for the remaining part of task τ _i at time t, which can be computed with the remaining computing ability, the running speed in the non-critical section, and the static running speed in the critical section.

• EEC(τ _i , t) is the estimation of the required energy of task τ _i at time t, which can be computed with the remaining computing ability, the running speed in the non-critical section, the static running speed in the critical section, and the energy consumption defined in Section 1.2.1.

• UER(τ _i , t) is the estimated ratio of utility to the energy of task τ _i starting from time t, while it is not blocked, that is UER(τ _i , t) = U _i (t + EET(τ _i , t))/EEC(τ _i , t).

• UER′(τ _i , t) is the maximal speed of task τ _i starting from time t, while it is not blocked.

• queue is the waiting queue of arrival tasks.

• recordtime(τ _i ) is the starting time of the sliding window of task τ _i , which initializes to be 1.

• RC(τ _i , t) returns the number of instances, which can be accepted in the future, of task τ _i at time t, and it equals to capacity(τ _i ) minus the accepted number of instances of task τ _i in the current sliding window.

• checkfeasible(τ _i , t) checks whether or not the current sliding window can accept new instances of task τ _i at time t, and if queue = null, t − recordtime(τ _i ) ≥ D _i or RC(τ _i , t) > 0, then this is the idle rate of task τ _i at time t, which can be computed by the following equation:

  $$ 1-\left({\displaystyle {\sum}_{r=1}^i}\left(\frac{c_{ns}\left({\tau}_r\right)}{\eta_{ns}\left({\tau}_r\right)\cdot {D}_r}+{\displaystyle {\sum}_{k=1}^{N_{cs}\left({\tau}_r\right)}}\frac{c_{cs}\left({z}_{r,k}\right)}{\eta_{cs}\left({z}_{r,k}\right)\cdot {D}_r}\right)+\frac{B_i}{D_i}\right). $$

• 1. runningstate(τ _i , t) reflects the running status of task τ _i at time t, which returns true if τ _i is selected to run as a candidate task before t, and false, otherwise.

• 2. f(τ _i , t) is the current running speed of task τ _i at time t, which can be computed by Theorem 1.

• 3. increaseslu(τ _i , sl, t) increases the idle rate of task τ _i at time t, that is SLU(τ _i , t) = SLU(τ _i , t) + sl/D _i .

• 4. decreaseslu(τ _i , sl, t) decreases the idle rate of task τ _i at time t, that is SLU(τ _i , t) = SLU(τ _i , t) + sl/D _i .

• 5. selectcandidate(t) selects a candidate task to run.

• 6. resource(τ _i , t) is the resource accessed by task τ _i at time t, which is effective when τ _i is in the critical sections, and returns null otherwise.

Theorem 1. If τ _i is selected to run as a candidate task at time t, then resource(τ _i , t) returns null, and the running speed of τ _i in the previous non-critical section is f(τ _i , t). In order to satisfy the schedulability of task τ _i , the current running speed is

$$ f\left({\tau}_i,t\right)={c}_{ns}^r\left({\tau}_i,t\right)/\frac{c_{ns}^r\left({\tau}_i,t\right)}{f\left({\tau}_i,{t}^{\prime}\right)}+\underset{\forall j\ge i}{ \min}\left\{SLU\left({\tau}_j,t\right)\times {D}_j\right\}\Big). $$

(4)

Proof. As can be seen from the assumption, the task τ _i runs in the critical section, so we have ${c}_{ns}^r\left({\tau}_i,t\right)={c}_{ns}^r\left({\tau}_i,{t}^{\prime}\right)$. At time t, the available free time for the task τ _i is min_∀ j <i {SLU(τ _i , t) × D _j }. At the same time, we have

$$ \frac{c_{ns}^r\left({\tau}_i,{t}^{\prime}\right)}{f\left({\tau}_i,{t}^{\prime}\right)}+{ \min}_{\forall j\le i}\left\{SLU\left({\tau}_j,t\right)\times {D}_j\right\}=\frac{c_{ns}^r\left({\tau}_i,t\right)}{f\left({\tau}_i,{t}^{\prime}\right)}. $$

So, we can get the following result

$$ f\left({\tau}_i,t\right)={c}_{ns}^r\left({\tau}_i,t\right)/\Big(\frac{c_{ns}^r\left({\tau}_i,t\right)}{f\left({\tau}_i,{t}^{\prime}\right)}+{ \min}_{\forall j\ge i}\left\{SLU\left({\tau}_j,t\right)\times {D}_j\right\}. $$

Algorithm 1 describes the proposed dynamic DVFS algorithm. Line 3 rectifies the accepted number of instances in the current sliding window; line 5 selects a candidate task to run; and line 6 adjusts the running speed of the candidate task (details are in Algorithm 2). If a new sliding window is opened (line 10), we use line 11 to initialize the parameters and preserve the computing ability for the following tasks. When a new task arrives, line 14 restricts the number of the following tasks by adjusting RC(τ _i , t). From lines 11 to 13, we see that every sliding window of task τ _i can have capacity(τ _i ) instances at most. Lines 15 to 17 reselect a candidate task and compute its running speed.

The aim of Algorithm 2 is to decrease the energy consumption by releasing/recycling free time and maximize the total utility. When a candidate task starts to run, lines 1 and 2 recycle the free time between the maximal blocking time with the practical blocking time. When the resource occupied by task τ _i at time t is null (line 3), line 4 computes the running speed of the candidate task in non-critical sections, line 5 selects the running speed for task τ _i at time t, and line 6 is equal to ∀ j ≥ i{SLU(τ _j , t) × D _j . When we have the running speed of the candidate task, the available time of the task would be deducted (line 8) or released (line 10). Finally, we use line 12 to assure that the running speed of the candidate task in the critical section is equal to its static running speed.

5 Experiments

5.1 Experimental setup

In this experiments, we compare our proposed algorithm with the ASAP and ALAP algorithms and use the simulation tool Yartiss [28] to implement these algorithms. Yartiss provides a simulation framework, and this framework can execute massive tasks of different algorithms with different parameters. We let the output of energy harvesting unit be equal to the energy supply rate e _bat of the system, and every time unit provides several energy units. The energy consumption of a task is linear, and every task consumes E _i /C _i energy units per time unit. In order to evaluate the performance of algorithms, we compare our proposed algorithm with the ASAP and ALAP algorithms under both energy-constraint and non-energy constraint situations. Under energy constraints, we evaluate the performance of algorithms by increasing the number of tasks; and under non-energy constraints, we design six application scenes with different amount of batteries and let P _h  = e _bat = 15, E _min = 0, and the running time Duration = 2550.

In simulation experiments, we use the following six metrics:

• 1) Average busy period is the average period of the CPU under simulation. The longer the average busy period, the higher the utility of the CPU is.

• 2) Average idle period is the average period of the CPU while it is free. Under energy constraints, it includes free time and relaxed time. The longer the average idle period, the higher the average energy level is, and thus, the lower energy constraints the system has.

• 3) Average overhead is the average time required to execute a task under simulation. The bigger the average overhead, the more likely the task will be missed before the stopping time.

• 4) Average preemption is the ratio of the preempted tasks to total tasks. The bigger the average preemption, the more context switches it has, and thus, the heavier the overhead is. The heavy overhead will decrease the performance of the whole system and make the scheduling algorithm unpracticable.

• 5) Average energy level is the average energy percent of batteries. The higher the average energy level, the lower energy constraints the system has.

• 6) Average battery switch mode is the ratio of battery switch modes to total tasks. The more the average battery switch mode, the lower the energy utility is. Low energy utility would make the system work un-properly.

5.2 Experimental results

We compare our proposed algorithm with the ASAP and ALAP algorithms under both the non-energy-constraint and the energy-constraint situations, and the results are in Figs. 1, 2, 3, 4, 5, 6, 7, 8, 9, and 10.

Fig. 1

Average busy period under non-energy constraints

Fig. 2

Average idle period under non-energy constraints

Fig. 3

Average overhead under non-energy constraints

Fig. 4

Average preemption under non-energy constraints

Fig. 5

Average busy period under energy constraints

Fig. 6

Average idle period under energy constraints

Fig. 7

Average overhead under energy constraints

Fig. 8

Average energy level under energy constraints

Fig. 9

Average preemption under energy constraints

Fig. 10

Average battery switch mode under energy constraints

Under non-energy constraints, the comparisons of average busy period, average idle period, average overhead, and average preemption are in Figs. 1, 2, 3, and 4, respectively. The ALAP algorithm postpones the execution of tasks as long as possible, and it generates massive free time, so both the average busy period and idle period are minimum. However, with the increase of the number of tasks, the average overhead of the ALAP algorithm increases obviously. The ASAP algorithm executes tasks as soon as possible, and it is equal to the scheduling of fixed-priority preemption. Our algorithm is based on fixed-priority preemption, and increases the threshold of preemption, so it has similar average busy period, average idle period, and average overhead to the ASAP algorithm. In addition, with the introduction of preemption threshold, our algorithm avoids the tasks with high priorities preempted, while keeping these tasks finished in time. So, our algorithm has the least number of preemptions.

Under energy constraints, the comparisons of average busy period, average idle period, average overhead, average energy level, average preemption, and average battery switch mode are in Figs. 5, 6, 7, 8, 9, and 10, respectively. As we can see from these figures, our algorithm has the least preemption too. The reason is that the ASAP algorithm judges preemption after every execution time unit and our algorithm runs tasks concentratedly. When the energy is not enough, our algorithm concentrates all available relaxed time to harvest energy, which reduces the preemptions caused by lacking energy. Our algorithm reduces the battery switch mode, uses the relaxed time to harvest energy, and then maximizes the busy period and idle period. So, our algorithm provides higher energy level and decreases the energy constraints of the system. The overheads of all the above algorithms tend to be identical. Our algorithm keeps the battery being on charge or discharge mode all the time and has less battery switch mode than the ASAP algorithm.

6 Conclusions

In energy harvesting embedded systems, the system needs to harvest energy from the external environment during free or idle time and schedule service tasks and energy harvesting tasks to keep the whole system working properly as long as possible. In this paper, we study the problem of task scheduling in energy harvesting embedded systems. We model an energy harvesting embedded system with an energy model, a task model, and a resource model and propose a dynamic task scheduling algorithm. Based on the dynamic voltage and frequency scaling techniques, the proposed algorithm concentrates all disperse free time together to harvest energy by dynamically scheduling harvesting tasks and service tasks. In the future, we will build a real energy harvesting embedded system, which implements the proposed algorithm. Currently, we only do some simulation experiments to validate the effectiveness of the proposed algorithm theoretically, and real improvement of lifetime on a real system will be our future work too.