A Work-Demand Analysis Compatible with Preemption-Aware Scheduling for Power-Aware Real-Time Tasks

Abstract

Due to the importance of slack time utilization for power-aware scheduling algorithms, we propose a work-demand analysis method called parareclamation algorithm (PRA) to increase slack time utilization of the existing real-time DVS algorithms. PRA is an online scheduling for power-aware real-time tasks under rate-monotonic (RM) policy. It can be implemented and fully compatible with preemption-aware or transition-aware scheduling algorithms without increasing their computational complexities. The key technique of the heuristics method doubles the analytical interval and turns the deferrable workload out the potential slack time. Theoretical proofs show that PRA guarantees the task deadlines in a feasible RM schedule and takes linear time and space complexities. Experimental results indicate that the proposed method combining the preemption-aware methods seamlessly reduces the energy consumption by 14% on average over their original algorithms.

1. Introduction

Power management is increasingly becoming a design factor in portable and hand-held computing/communication systems. Energy minimization is critically important for devices such as laptop computers, smartphones, PDAs, wireless sensor networks (WSNs), and other mobile or embedded computing systems simply because it leads to extended battery lifetime. The power consumption problem has been addressed in the last decade with a multidimensional effort by the introduction of engineering components and devices that consume less power, low power techniques involving the designs of VLSI/IC, computer architecture, algorithm, and compiler developments.

Recently, dynamic power management (DPM) and dynamic voltage scaling (DVS) have been employed as available techniques to reduce the energy consumption of CMOS microprocessor system. DPM changes the power state of cores on chip to lower the energy consumption according to the performance constraints. DVS involves dynamically adjusting the voltage and frequency (hence, the CPU speed). By reducing the frequency at which a component operates, a specific operation will consume less energy but may take longer to complete. Although reducing the frequency alone will reduce the average energy used by a processor over that period of time, it may not always deliver a reduction in energy consumption overall, because the power consumption is linearly dependent on the increased time and quadratically dependent on the increased/decreased voltage. In the context of dynamic voltage scaled processors, DVS in real-time systems is a problem that assigns appropriate clock speeds to a set of periodic tasks and adjusts the voltage accordingly such that no task misses its predefined deadline while the total energy savings in the system is maximized.

Many studies have proposed different real-time scheduling based on different system models [1–9], such as online and offline scheduling, handling discrete/continuous voltage levels, assuming average-case execution time (ACET), best-case execution time (BCET), or worst-case execution time (WCET) of each task, allowing intratask/intertask voltage transitions, and assuming fixed/dynamic priority assignment. These approaches have a common objective and encounter the same difficulties. Because reducing the supply voltage decreases the clock speed of processors [10], most DVS algorithms for real-time systems reduce supply voltage dynamically to the lowest possible level while satisfying the soft/hard timing constraints of each task. To satisfy the timing constraints of real-time tasks, DVS technique must utilize available slack time when adjusting voltage/speed levels. Consequently, the energy efficiency of a DVS algorithm markedly depends on the accuracy of computing available slack time.

Work-demand analysis on embedded real-time scheduling has been investigated by previous studies [3, 5–7, 11]. Pillai and Shin [7] proposed a cycle-conserving rate-monotonic (ccRM) scheduling scheme that contains offline and online algorithms. The offline algorithm computes the WCET of each task and derives the maximum speed needed to meet all tasks deadlines. It recomputes the utilization by comparing the actual time for completed tasks with WCET schedule. In other words, when a task completes early, they have to compare the used actual processor cycles to a precomputed worst-case execution time schedule. This WCET schedule is also called canonical schedule [1] whose length could be the least common multiplier of task periods. ccRM is a conservative method, as it only considers possible slack time before the next task arrival (NTA) of a current job. Gruian proposed a DVS method for offline task stretching and online slack distribution [3]. The offline part of this method consists of two separate techniques. One focuses on the intratask stochastic voltage scheduling that employs a task-execution length probability function. The second technique computes stretching factors by using a response time analysis. It is similar to Pillar and Shin’s offline technique, but instead of adopting a stretching factor for all tasks before NTA, Gruian assigns a different stretching factor to the individual task within the longest task period. Kim et al. [6] proposed a greedy online algorithm called the low-power work-demand analysis (lpWDA) that derives slack from low-priority tasks, as opposed to the method in [3, 7] that gains slack time from high-priority tasks. This algorithm also balances the gap in voltage levels between high-priority and low-priority tasks. Its analysis interval limited by the longest of task periods is longer than NTA. Thus, lpWDA gains more energy saving than the previous rate-monotonic (RM) DVS schemes applying NTA. Many slack time analysis methods considered additional assumptions [4, 11, 12]. Kim et al. proposed a preemption-aware DVS algorithm based on lpWDA, which is composed of accelerated-completion (lpWDA-AC) and delayed-preemption (lpWDA-DP) techniques to decrease the preemption times of DVS schedules [11]. lpWDA-AC attempts to avoid preemption by adjusting voltage/clock speed, such that it is higher than the lowest possible values computed using lpWDA. lpWDA-DP postpones preemption points by delaying an activated high-priority task as late as possible while guaranteeing a feasible task schedule. Both techniques reduce energy consumption more than the initial ccRM and lpWDA techniques on the assumption of context-switching overhead. Mochocki et al. in [12] also proposed a transition-aware DVS algorithm for decreasing the number of voltage/speed adjustments, called the low-power limited-demand analysis with transition overhead (lpLDAT) scheme, which accounts for both time and energy transition overhead. Its algorithm computes an efficient speed level based on average-case workload; notably, this speed can be used as a limiter. If the limiter is higher than the speed predicted by lpWDA, lpLDAT knows that lpWDA is being too aggressive and applies the limiter to the present schedule. On the assumption of transition overhead, this technique with slack time analysis also saves considerable energy when compared with that by the previous methods. He and Jia [4] developed a fixed-priority scheduling with threshold (FPPT) scheme that eliminates unnecessary context switches, thereby saving energy. FPPT assigns each task a pair of predefined priority and corresponding preemption threshold. He et al. applied a novel algorithm to compute a static slowdown factors by formulating the problem as a linear optimization problem. In addition, they considered energy consumption of a task set under different preemption threshold assignments.

Recently, experimental results obtained by Kim et al. [6] indicated that recent DVS algorithms for fixed-priority real-time tasks are less efficient than that of dynamic-priority tasks, leading to more improvements for a better DVS method. The main reason for energy inefficiency of RM DVS scheduling is that, in RM schedules, priority-based slack-stealing methods do not work as efficiently as they do in earliest-deadline first (EDF) scheduling [6]. In the EDF schedules, high-priority tasks play an efficient slack distributor of tasks because their slack can be utilized fully by tasks starting before NTA. Therefore, the energy saving achieved by EDF scheduling algorithms, such as that by the ccEDF [7], DRA, and AGR [1] is close to the theoretical lower bound [13].

2. Motivations

So far, there are a large number of studies on DVS-based RM scheduling for energy saving [1–4, 6–8, 11–14]; most existing studies are proposed for computing and predicting the length and occurrence of slack time. The reason is that the more precise estimation on the slack time, the more energy efficiency we obtain. Those methods for computing available slack time either construct a canonical schedule and compare it to current schedule or propose best-effort algorithms under empirical rules and heuristics. Those methods adopting different strategies and assumptions such as task preemption or voltage transition time on the similar models gain considerable energy saving, but few of them can be combined without difficulty to further enhance their performance. Additionally, modern processor with DVS or DPM feature must be equipped with dc-to-dc converter that varies the processor speed in appropriate levels and requires additional switching time and power [15]. It is harmful to power saving in a system when many fragments of short slack time appear. Many of those methods also propose the notions of postponing and advancing task execution for increasing the length of slack time. Their performances for accumulating a continuous slack time are not impressive due to short analysis interval adopted in the schedules. Therefore, it is necessary to study a transplantable method that can cooperate with different existing methods without modification. This idea originate from the layered architecture used in designing computer software, hardware, and communications in which system or network components are isolated in layers so that changes can be made in one layer without affecting the others. The proposed method according the notion also requires the ability to compute and accumulate the slack time solely. By applying the layered architecture, it can also pass the slack time to lower-layered methods and reveals synergy effect to enhance overall energy saving.

In this paper, we propose an online work-demand analysis called parareclamation algorithm (PRA) for RM scheduling which computes the length of potential slack in an interval which is two times longer than the longest task periods. PRA does not rely on the simulation for stochastic data which usually varies according to different applications, and can be applied to many RM scheduling algorithms with various criteria. Moreover, the proposed algorithm has a time complexity of 𝑂(𝑛) where 𝑛 is the number of tasks. In other words, it does not increase computational complexity of the existing online RM scheduling algorithms. Experimental results indicate that existing RM DVS algorithms combined with the proposed method can reduce energy consumption by 5%–21% compared with that by initial algorithms such as lpWDA and lpLDAT.

The remainder of this paper is organized as follows. Section 3 introduces the preliminaries of power-aware real-time scheduling. Section 4 introduces our technique and algorithm. Section 5 provides theorems to prove the schedulability of PRA as well as lpWDA. We present the performance evaluation in Section 6. Section 7 gives conclusions and the directions for future work.

3. Preliminaries

This paper focuses on how to obtain additional slack for existing RM DVS scheduling methods. Many slack time analysis techniques with different purposes (e.g., transition-aware and preemption-aware schemes) can utilize PRA easily; throughout this paper, these techniques are called host algorithms of PRA. This section also outlines the ideas underlying the lpWDA algorithm. Other techniques, such as the lpLDA, lpWDA-AC, lpWDA-DP [11], and lpLDAT [12] techniques, are abridged.

3.1. System Model

This paper considers preemptive hard real-time systems in which periodic real-time tasks are scheduled under an RM scheduling policy. The DVS processor used in the model operates at a finite set of supply voltage levels 𝑉={𝑣₁,…,𝑣_max}, each with an associated speed. Processor speed is normalized by 𝑆_max=1 corresponding to 𝑣_max=1, yielding a set 𝑆={𝑠₁,…,1} of speed levels. A set of 𝑛 periodic tasks is denoted by 𝑇={𝜏₁,𝜏₂,…,𝜏_𝑛}, where the tasks are assumed mutually independent. Each task 𝜏_𝑖 is described by its worst-case execution cycles 𝑤𝑐_𝑖 and average-case execution cycles 𝑎𝑐_𝑖 (𝑤𝑐_𝑖≥𝑎𝑐_𝑖). Throughout this paper, the execution cycles of each task are called work for short. Additionally, each task 𝜏_𝑖 has a shorter period length 𝑝_𝑖 (i.e., a higher priority) than that of 𝜏_𝑗 when 𝑖<𝑗, and 𝑝_𝑛 is the longest of task periods. The relative deadline 𝑑_𝑖 of 𝜏_𝑖 is assumed equal to its period length 𝑝_𝑖. Each task is invoked periodically by a job, and the 𝑘th job of task 𝜏_𝑖 is 𝜏_𝑖,𝑘. The first job of each task is assumed activated at time 𝑡=0. Each job is described by a release time, 𝑟_𝑖,𝑗, deadline, 𝑑_𝑖,𝑘, and number of cycles that have been executed 𝑒𝑥^𝑘_𝑖. The utilization 𝑈 of a task set 𝑇 is denoted by ∑_{𝜏𝑖∈𝑇}(𝑤𝑐_𝑖/𝑝_𝑖). During run time, we refer to the earliest job of each task not completed as the current job for that task, and that job is indexed with cur. The deadline of the current job for task 𝜏_𝑖 is 𝑑^cur_𝑖, and 𝑒𝑥^cur_𝑖 denotes the number of cycles that the current job of 𝜏_𝑖 has executed.

Without loss of generality, when 𝜏_𝑖 is the first scheduled task after time 𝑟_{𝑛,𝑘−1}, where 𝑖≠𝑛, the bottleneck (shortened to bn) is the next release time of 𝜏_𝑛 (i.e., the 𝑟_𝑛,𝑘). In the work-demand analysis method, available slack in the interval [bn, 𝑟_𝑛,𝑘+1) is estimated.

3.2. Low-Power Work-Demand Analysis (lpWDA)

This section briefly introduces an online DVS scheme called lpWDA [6]. Notations 𝑒^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾}, ℓ_𝛼^{𝚛𝚒𝚐𝚑𝚝}, and 𝜏_{𝚊𝚜𝚢𝚗} belong to PRA algorithm and are presented in Section 4. In line 2 of Algorithm 1, 𝜀 is an infinitesimal, and readyQ contains the currently activated tasks, and its subset, Γ^ACT_𝛼(𝑡), containing the active tasks is Γ^ACT_𝛼(𝑡)∶=𝜏_𝜅∣𝜅<𝛼,𝜏_𝜅∈𝑟𝑒𝑎𝑑𝑦𝑄.(1) In the lpWDA, the tasks in 𝑟𝑒𝑎𝑑𝑦𝑄 are scheduled according to RM priority policy. When a task is activated (released), its job 𝜏_𝛼 is moved to 𝑟𝑒𝑎𝑑𝑦𝑄, and the remaining WCET of this job is set to 𝑤𝑐_𝑖, which is 𝑊^rem_𝑖(𝑡)=𝑤𝑐_𝑖. When 𝜏_𝛼 is executed at time 𝑡, 𝑙𝑜𝑎𝑑_𝛼(𝑡) is the amount of work required to be processed in [𝑡,𝑑_𝛼).

(1) set 𝑢𝑑𝑎∶=𝑝𝛼,𝑒𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾∶=0 and 𝜏𝚊𝚜𝚢𝚗∶=∅; (2)  Compute 𝐻𝛼(𝑡)∶=∑𝜏𝑘∈𝑇𝛼𝐴𝐶𝑇(𝑡)𝑤rem𝑘(𝑡)+∑𝛼−1𝑖=1𝑢𝑑𝛼−𝜀/𝑝𝑖−(𝑡+𝜀)/𝑝𝑖⋅𝑤𝑖; (3)  When a job 𝜏𝛼 is activated, set 𝑤rem𝑘(𝑡)∶=𝑤𝛼; (4)  When a job 𝜏𝛼 is completed or preempted, UpdateLoadInfo 𝑤rem𝛼(𝑡),𝑢𝑑𝛼,𝐻𝛼(𝑡); (5)  When a job 𝜏𝛼 is scheduled for execution (6)   ∗∗∗𝑒𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾∶=𝐏𝐑𝐀(𝑡,𝑇);          //get additional slack time (7)  ∗∗∗ if   𝑟𝛼=𝜏𝚊𝚜𝚢𝚗 and ℓ𝛼𝚛𝚒𝚐𝚑𝚝<𝑒𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾   then  𝜏𝛼 has the lowest priority in readyQ(t); (8)  𝑠𝑙𝑎𝑐𝑘𝛼(𝑡)∶=  ClacSlackTime(𝑒𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾);     //get slack time (9)  set the clock frequency as 𝑓𝑐𝑙𝑘∶=𝑤rem𝛼(𝑡)/𝑠𝑙𝑎𝑐𝑘𝛼(𝑡)+𝑤rem𝛼(𝑡)⋅𝑓𝚖𝚊𝚡; (10)  𝑓𝑐𝑙𝑘∶= max𝑓𝑐𝑙𝑘,𝑓𝐴𝐶𝐿; (11)  Set the voltage accordingly;

Algorithm 1 

IpWDA (PRA with ∗∗∗). Compute the available execution time and set the voltage/clock speed for 𝜏_𝛼.

In Algorithms 1, 2, and 3 and Procedure 1, lpWDA performs in the following steps. First, the system is initialized by setting the initial upcoming deadlines (𝑢𝑑) and remaining worst-case execution (𝑤^rem) of each task. When 𝜏_𝛼 is active at time 𝑡, notation 𝑢𝑑_𝑘 of each task 𝜏_𝑘 is defined as follows [6]: 𝑢𝑑_𝑘=𝑡+𝜀𝑝_𝑘×𝑝_𝑘,(2) where 𝜀 is the infinitesimal. The jobs which are active during [𝑡,max{𝑢𝑑_𝑘(𝑡)}] will be examined for slack estimation. 𝐻_𝛼(𝑡) denotes the estimation of higher-priority work that must be executed before 𝑢𝑑_𝛼 (lines 1-2). Whenever a job 𝜏_𝛼 is completed or preempted at time 𝑡, the remaining work 𝑤^rem_𝛼(𝑡), upcoming deadline 𝑢𝑑_𝛼, and high-priority work 𝐻_𝛼(𝑡) are updated in line 4. In lines 5–8, when a job 𝜏_𝛼 is scheduled for execution at time 𝑡, Algorithm 2 computes the available slack for 𝜏_𝛼 according to 𝐻_𝛽(𝑡) and 𝐿_𝛽(𝑡) (see lines 13 and 14), where 𝑢𝑑_𝛽 is the earliest upcoming deadline with respect to 𝜏_𝛼. Notably, function 𝐿_𝛽(𝑡) computing the amount of low-priority work is performed recursively until it finds 𝜏_𝛾 with the longest of task periods and lowest priority with respect to 𝜏_𝛼. As defined in Section 3.1, the length of interval [0, bn) is 𝑝_𝛾. Then, lpWDA computes the length of slack-time stealing from low-priority tasks in the interval [𝑟_𝛼,bn) and applies the slack to the current job. Therefore, Algorithms 2 and 3 play crucial roles in slack-time analysis and dominate the run time complexity of lpWDA algorithm. Formally, to describe the slack analysis method using lpWDA, the following notations are defined: 𝑙𝑜𝑎𝑑_𝛼(𝑡): the amount of work required to be processed in interval [𝑡, 𝑑_𝛼); 𝑠𝑙𝑎𝑐𝑘_𝛼(𝑡): the available slack for 𝜏_𝛼 scheduled at time 𝑡 can be computed as follows: 𝑠𝑙𝑎𝑐𝑘_𝛼=𝑑_𝛼−𝑡−𝑙𝑜𝑎𝑑_𝛼(𝑡).(3)In (3), 𝑙𝑜𝑎𝑑_𝛼(𝑡) consists of three types of work: (1) 𝑊^rem_𝛼(𝑡), (2) 𝐻_𝛼(𝑡) from the higher-priority tasks, and (3) 𝐿_𝛼(𝑡) from the lower-priority tasks. The work required by higher-priority tasks is derived as follows: 𝐻_𝛼(𝑡)=𝐻^past_𝛼(𝑡)+𝐻^future_𝛼,(4) where 𝐻^past_𝛼(𝑡) denotes the work required by uncompleted tasks released before 𝑡, and 𝐻^future_𝛼(𝑡) denotes the work released during [𝑡,𝑑_𝛼]. We compute 𝐻^past_𝛼(𝑡) and 𝐻^future_𝛼(𝑡) as follows: 𝐻^past_𝛼(𝑡)=_{𝜏𝜅∈ΓACT𝛼(𝑡)}𝑊^rem_𝜅(𝑡),𝐻^future_𝛼(𝑡)=^𝛼−1_𝑖=1𝑑_𝛼−𝜀𝑝_𝑖−𝑡+𝜀𝑝_𝑖+1⋅𝑤𝑐_𝑖,(5) where 𝜀 is the infinitesimal. According to the above statements, the amount of work required by the scheduled task 𝜏_𝛼 can be formulated as 𝐻_𝛼(𝑡)=_{𝜏𝜅∈ΓACT𝛼(𝑡)}𝑊^rem_𝜅(𝑡)+^𝛼−1_𝑖=1𝑑_𝛼−𝜀𝑝_𝑖−𝑡+𝜀𝑝_𝑖+1⋅𝑤𝑐_𝑖,𝐿(6)_𝛼(𝑡)=𝑙𝑜𝑎𝑑_𝛽(𝑡)−𝑤^rem_𝛼(𝑡)−𝐻_𝛼(𝑡)−𝑢𝑑_𝛽(𝑡)−𝑑_𝛼⁺,(7)𝑙𝑜𝑎𝑑_𝛼(𝑡)=𝐻_𝛼(𝑡)+𝐿_𝛼(𝑡)+𝑤^rem_𝛼(𝑡),(8) where notation 𝑥⁺ stands for max(𝑥,0). Equations (6), (7), and (8) are repeated iteratively until 𝜏_𝛼 is the lowest priority task in 𝑇 (i.e., 𝐿_𝛼(𝑡)=0). Conceptually, lpWDA uses this linear-time heuristics to estimate available slack in an interval up to the upcoming deadline of lower-priority tasks.

Input: the active task 𝜏𝛼, readyQ and current time 𝑡 Output: the slack time 𝑠𝑙𝑎𝑐𝑘𝛼(𝑡) for 𝜏𝛼 (12) Identify the task 𝜏𝛽 that has the earliest upcoming deadline among tasks whose    priorities are not higher than that of 𝜏𝑎; (13) 𝐿𝛽(𝑡)∶= CalcLowerPriorityWork(τ β, 𝑡, 𝑒𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾); (14) 𝑙𝑜𝑎𝑑𝛽(𝑡)∶=𝑤rem𝛽(𝑡)+𝐻𝛽(𝑡)+𝐿𝛽(𝑡); (15) 𝑠𝑙𝑎𝑐𝑘𝛼(𝑡)∶= max0,𝑢𝑑𝛽−𝑡−𝑙𝑜𝑎𝑑𝛽; (16)  return 𝑠𝑙𝑎𝑐𝑘𝛼(𝑡);

Algorithm 2 

CalcSlackTime(additional slack 𝑒^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾}).

Input: a reference task 𝜏𝛽 and current time 𝑡 Output: the amount of lower-priority work needed to be done before 𝑢𝑑𝛽 (17) if   𝜏𝛽 is identical to 𝜏𝑛  then return 0; (18) Identify the task 𝜏𝑟 that has the earliest upcoming deadline among the tasks    whose priorities are lower than that of 𝜏𝛽; (19) 𝐿𝑟(𝑡)∶= CalcLowerPriorityWork(𝜏𝑟, t, 𝑒𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾); (20) 𝑙𝑜𝑎𝑑𝑟(𝑡)∶=𝑤rem𝛽(𝑡)+𝐻𝑟(𝑡)+𝐿𝑟(𝑡); (21)  ∗∗∗ if   𝑢𝑑𝑟 is multiple of 𝑝𝑛  then  𝑢𝑑𝑟∶=𝑢𝑑𝑟+𝑒𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾; (22) 𝐿𝛽(𝑡)∶= max0,𝑙𝑜𝑎𝑑𝑟(𝑡)−𝑤𝛽(𝑡)−𝐻𝛽(𝑡)−𝑢𝑑𝑟+𝑢𝑑𝛽; (23)  return  𝐿𝛽(𝑡);

Algorithm 3 

CalcLowerPriorityWork(additional slack 𝑒^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾}).

Input  t: current time, 𝑇𝑏=𝑇−𝜏𝑛 (1)  set 𝑏=𝑛−1,𝑒𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾𝚖𝚒𝚗←∞,𝑘=(𝑡+𝜀)/𝑝𝑛,ℓ←0, 𝑇𝖻𝗇={𝜏𝑖∣𝑖<𝑛 and 𝑝𝑖 spans astride the bn}; (2) if  𝑆𝑦𝑛𝑇𝑏,𝑘∶==0 (3)  for  𝑖∶=1  to  𝑛−1 (4)   if 𝑆𝑦𝑛𝑇𝑏−𝜏𝑖,𝑘∶==0 (5)     then continue; (6)     𝜏𝚊𝚜𝚢𝚗∶=𝜏𝑖; (7)  if  ℓ≤0  then  𝜏𝚊𝚜𝚢𝚗∶=∅; (8)  Compute the value of 𝑒𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾𝚊𝚜𝚢𝚗; (9) else if  𝑆𝑦𝑛𝑇𝑏,𝑘>0  or  𝑒𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾𝚊𝚜𝚢𝚗≤0 (10)  then Compute the values of 𝑒𝚋𝚗 and 𝑒𝑠𝑙𝑎𝑐𝑘; (11)  if  𝑒𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾𝚊𝚜𝚢𝚗≤0  then  𝑒𝙴𝚡𝚌𝚑𝚊𝚗𝚐𝚎𝚖𝚒𝚗∶= min𝑒𝖻𝗇,𝑒𝑠𝑙𝑎𝑐𝑘; (12)  else  𝑒𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾𝚖𝚒𝚗∶= min𝑒𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾𝚊𝚜𝚢𝚗,𝑒𝖻𝗇,𝑒𝑠𝑙𝑎𝑐𝑘; (13) Choose a job 𝜏𝛿∈𝑇𝖻𝗇 with ℓ𝛿𝚛𝚒𝚐𝚑𝚝≥𝑒𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾𝚖𝚒𝚗 and 𝑤𝑐𝛿≥𝑒𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾𝚖𝚒𝚗; (14) When 𝜏𝛿∈𝑟𝑒𝑎𝑑𝑦𝑄, change the priority of job 𝜏𝛿 lower than that of job 𝜏𝑛 in 𝑟𝑒𝑎𝑑𝑦𝑄; (15) Return  𝑒𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾𝚖𝚒𝚗;

Procedure 1 

PRA (time 𝑡, task set 𝑇).

3.3. Motivational Example

The proposed method is to provide lpWDA-based algorithms (e.g., lpWDA, lpLDAT, lpWDA-DP, and lpWDA-AC) with a subroutine to improve their work-demand analysis. The main advantage is that PRA can be independent of each function-specific slack analysis method. For instance, the main purpose of lpWDA-AC and lpWDA-DP techniques is to decrease context-switch overhead while that of lpLDAT is to reduce transition time and energy overhead. PRA can work together with these lpWDA-based algorithms to enhance their slack computation capability.

Example 1. Consider a periodic task set 𝑇 in Table 1, which presents the period length, WCET, and ACET of each task. Figure 1(a) presents the execution schedule under the worst-case workload in the first hyperperiod. Figure 1(b) shows the speed schedule using lpWDA algorithm for task set 𝑇 and assumes that actual work of each task equals its ACET. Before assigning 𝜏_1,1 at time 𝑡=0, lpWDA computes available slack time in an interval up to 𝑑_3,1=6 by calling Algorithm 3, recursively. However, interval [0,6) has no slack-time under the WCET schedule. If the length of the analysis interval is extended to 2×𝑝_𝑛, one unit of slack time is derived from 2×𝑝_𝑛−∑^𝑛_𝑖=1⌊2𝑝_𝑛/𝑝_𝑖⌋×𝑤𝑐_𝑖. The slack in [11,12) can be moved backward to the current scheduling point by a deferred execution of earlier work. For instance, in Figure 1(a), the slack in interval [11,12) can be exchanged with the work in interval [7,8), and then slack in interval [7,8) can be exchanged with the work in interval [4,5), and it can be exchanged once again with the work in interval [2,3). Finally, the slack in interval [2,3) can be exchanged with the work in interval [1,2). Therefore, 𝜏_1,1 is scheduled with speed 𝑆_1,1=(𝑤𝑐_𝑖/(𝑤𝑐_𝑖+1)) (Figure 1(c)). Additional slack can be reclaimed without deadline missing from the interval that is, two times longer than the longest task period. Notably, this idea actually neither moves all of the jobs of a schedule to 𝑟𝑒𝑎𝑑𝑦𝑄 (e.g., 𝑡=0) nor Exchanges the slack with work for using this slack time. However, this primitive idea does not work in some situations. For example, in Figure 1(d), when 𝑝₂ is increased to 6, slack in the interval [11,12) cannot be transferred before 𝑡=6. In fact, jobs 𝜏_1,3,𝜏_2,2, and 𝜏_3,2 are released simultaneously at time 6. The slack in interval [11,12) cannot follow this idea, because a deadline is likely to be missed by one of those three jobs. Our goal is to devise an efficient work-demand analysis method that obtains additional slack while satisfying th tasks’ deadline.

Table 1 

An example of real-time task set 𝑇.

(a)

(b)

(c)

(d)

Figure 1 

The intertask voltage scheduling examples of (a) worst-case scheduling, (b) lpWDA, (c) lpWDA + PRA, and (d) a modified worst-case schedule.

4. Work-Demand Computation

Let 𝑟_𝑛,𝑘 be the bn of 𝜏_𝑖, which is the first scheduled job at time 𝑡 where 𝑡≥𝑟_{𝑛,𝑘−1}. PRA computes the length of additional slack in the interval [bn, 𝑟_𝑛,𝑘+1). As long as the slack time can be reclaimed at a time earlier than bn, lpWDA can utilize it by postponing lower-priority task and improve energy efficiency of schedules. Why PRA focuses on slack computation in the interval [bn, 𝑟_𝑛,𝑘+1) while longer or shorter intervals? Even if all job (except 𝜏_𝑛) periods are within [bn, 𝑟_𝑛,𝑘+1) and cannot make a target slack be available for the task right side to bn, job 𝜏_𝑛 can still postpone its work for moving the slack forward and approaching bn. For example, in Figure 1(a), when the period length of 𝜏₁ is increased from 3 to 4, the slack in interval [11,12) cannot be reclaimed by postponing the work of 𝜏_1,3 or 𝜏_2,3 because it is hampered at time 8. Therefore, 𝜏_3,2 can defer its work and the slack time in [6,7) will be available. On the contrary, if one extends the additional analysis interval such that it is longer than or even several times of 𝑝_𝑛, job 𝜏_𝑛 cannot move the slack after 𝖻𝗇+𝑝_𝑛 to approach the bn and may be blocked in this interval. For an analytical interval whose length is equal to 𝑝_𝑛, it has the following advantages. After deriving the amount of slack time which will be available to the tasks nearby bn, those jobs whose period spanning astride the bn can be deferred to reclaim additional slack before bn. That is, the current job can utilize the additional slack by performing a lpWDA-based method. Notably, in an actual scheduling process, PRA does not exchange any work with slack. Instead, it only passes the length of additional slack time for current job to lpWDA and does not affect schedulability of subsequent jobs.

To present the proposed method, we define the following notations: 𝑇^𝑏=𝑇−𝜏_𝑛,(9) where 𝑏 denotes the number of tasks in the set of 𝑇^𝑏, 𝑏<𝑛, and 𝜏_𝑛 is the task with the longest period in 𝑇. A set of tasks are called synchronous at time 𝑡 if their jobs are released at time 𝑡. In an extended analysis interval [bn, 𝑟_𝑛,𝑘+1), the number of synchronization points of the tasks in 𝑇^𝑏 can be derived as follows: Syn𝑇^𝑏=𝑟,𝑘^𝑛,𝑘+1LCM𝑇^𝑏−𝑟_𝑛,𝑘LCM𝑇^𝑏,(10) where LCM(𝑇^𝑏) denotes the least common multiplier of task periods in 𝑇^𝑏. As shown in Figure 2, the first synchronization point of 𝑇^𝑏 within the interval [bn, 𝑟_𝑛,𝑘+1) is derived as 𝑡𝑇^𝑏=𝑟,𝑘^𝑛,𝑘+1LCM𝑇^𝑏×LCM𝑇^𝑏.(11) When 𝑡(𝑇^𝑏,𝑘)=𝑡∈(𝑟_𝑛,𝑘,𝑟_𝑛,𝑘+1), slack time is likely to be blocked or shrunken at time 𝑡. In Figure 3, when all tasks except 𝜏_𝑛 are synchronized at time 𝑡, a slack may not be moved backward from the right to the left side of 𝑡. In this case, slack can still be moved to the current time by postponing the execution of the work of 𝜏_𝑛. When 𝑛−1 tasks are synchronized in interval (𝖻𝗇,𝑟_𝑛,𝑘+1), we can derive Syn(𝑇^𝑏,𝑘)≥0, and their the earliest synchronization point is derived by 𝑡(𝑇^𝑛−1,𝑘). The worst-case execution time in interval (𝖻𝗇,𝑡(𝑇^𝑛−1,𝑘)) is 𝑡𝑇^𝑛−1,𝑘−𝖻𝗇×𝑈.(12) Therefore, the available slack for 𝜏_𝑛,𝑘+1 in this interval is at least 𝑡𝑇^𝑛−1,𝑘−𝖻𝗇×(1−𝑈).(13) Similarly, when {𝜏_𝑖,𝜏_𝑛}⊂𝑇^𝑛−2 and 𝜏_𝑖≠𝜏_𝑛, there are 𝑛−2 tasks that synchronize at time 𝑡(𝑇^𝑛−2,𝑘). The available slack time for 𝜏_𝑛,𝑘+1 in interval [𝖻𝗇,𝑡(𝑇^𝑛−2,𝑘)) is at least 𝑡𝑇^𝑛−2,𝑘−𝖻𝗇×1−𝑈−𝑤𝑐_𝑖𝑝_𝑖.(14) Therefore, if 𝑓 of tasks are synchronized in interval [𝖻𝗇,𝑟_𝑛,𝑘+1), the minimal available slack time for 𝜏_𝑛 in interval [𝖻𝗇,𝑡(𝑇^𝑛−𝑓,𝑘)) is denoted as 𝑒_𝑖^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾}=𝑡𝑇^𝑛−𝑓×,𝑘−𝖻𝗇1−𝑈−_{𝜏𝑖∉𝑇𝑛−𝑓∪𝜏𝑛}𝑤𝑐_𝑖𝑝_𝑖,(15) where 𝑒_𝑖^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾} denotes the estimated slack in interval [𝖻𝗇,𝑡(𝑇^𝑥,𝑘)). For example, 𝜏_𝑖 does not synchronize with other tasks in 𝑇^𝑏 (Figure 4). Therefore, one can compute the value of Syn(𝑇^𝑥=𝑇^𝑏−𝜏_𝑖,𝑘) for each 𝜏_𝑖, where 𝑥=𝑛−2 and 𝑏=𝑛−1. Suppose Syn(𝑇^𝑏−𝜏_𝑖,𝑘)>0, the earliest synchronization point of tasks in 𝑇^𝑏−𝜏_𝑖 is derived using (11).

Figure 2 

An example of task synchronization points.

Figure 3 

The task periods span astride the bn.

(a)

(b)

Figure 4 

The slack reclamation in lpWDA algorithm.

After deriving available slack time within interval [𝖻𝗇,𝑡(𝑇^𝑏,𝑘)) where 𝑏≤𝑛−1, we compute the length of the slack time which is available for the task in interval [𝖻𝗇,𝑡(𝑇^𝑏,𝑘)). We assume 𝑇^𝖻𝗇 denotes a set of tasks in which task periods go astride the bn. Let 𝜏_𝑖∈𝑇^𝖻𝗇; the lengths of left and right parts of 𝑝_𝑖 split by bn are defined as ℓ_𝑖^{𝚕𝚎𝚏𝚝} and ℓ_𝑖^{𝚛𝚒𝚐𝚑𝚝}, respectively, and the longest ℓ_𝑖^{𝚕𝚎𝚏𝚝} and ℓ_𝑖^{𝚛𝚒𝚐𝚑𝚝} are defined as ℓ^{𝚕𝚎𝚏𝚝}_𝚖𝚊𝚡 and ℓ^{𝚛𝚒𝚐𝚑𝚝}_𝚖𝚊𝚡, respectively. Additionally, we define accu^𝖻𝗇=_{𝜏𝑖∈𝑇𝖻𝗇}𝑤𝑐_𝑖(16) as the total amount of work in 𝑇^𝖻𝗇. As shown in Figure 3, the lengths of ℓ^{𝚕𝚎𝚏𝚝}_𝚖𝚊𝚡, ℓ^{𝚛𝚒𝚐𝚑𝚝}_𝚖𝚊𝚡, and accu^𝖻𝗇 limit the maximum length of slack that can be moved in interval [𝑟_{𝑛,𝑘−1}, bn). Consequently, the restriction on the length of slack time is as follows: 𝑒^𝖻𝗇=minℓ^{𝚕𝚎𝚏𝚝}_𝚖𝚊𝚡,ℓ^{𝚛𝚒𝚐𝚑𝚝}_𝚖𝚊𝚡,accu^𝖻𝗇.(17) According to the work demand in a WCET schedule, the slack time in interval [𝑟_{𝑛,𝑘−1},𝑟_𝑛,𝑘+1) is computed as follows: 𝑒^{𝑠𝑙𝑎𝑐𝑘}=2×𝑝_𝑛−_{𝜏𝑖∈𝑇}2×𝑝_𝑛𝑝_𝑖𝑤𝑐_𝑖.(18)PRA computes the length of additional slack time within interval [bn, 𝑟_𝑛,𝑘+1) by (17). It then computes the length of this slack time that can be available for the jobs in interval [𝑟_{𝑛,𝑘−1}, bn) according to (17) and (18). Finally, it changes the priority of a job that goes astride the bn when this job is moved to readyQ according to RM scheduling. In line 1 of Procedure PRA, 𝜀 denotes an infinitesimal value.

Example 2. Consider the WCET schedule shown in Figure 1(a), 𝜏_1,1 is scheduled at time 𝑡=0, we set 𝖻𝗇=6 and 𝑇^𝖻𝗇={𝜏_2,2} because the period of 𝜏_2,2 goes astride bn. Procedure PRA computes the length of available slack time from interval [6,12) as follows. When task set 𝑇²={𝜏₁,𝜏₂}, Procedure PRA computes Syn(𝑇²,1)=0. Therefore, the bottleneck caused by 𝜏₁ and 𝜏₂ is 𝑡(𝑇²−{𝜏₂,1})=9 and 𝑡(𝑇²−{𝜏₁,1})=8, respectively. Line 6 derives ℓ=2 and 𝜏_asyn=𝜏₁. Equations (14)–(17) derive 𝑒^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾}_asyn=(9−6)×(1−(11/12−1/3))=1. In line 10, the value of 𝑒_𝑛^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾}, 𝑒^𝖻𝗇, 𝑒^{𝑠𝑙𝑎𝑐𝑘}, and accu^𝖻𝗇 is 1, 1, 1, and 2, respectively. The value of 𝑒^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾}_min is 1 by line 12. Therefore, Procedure PRA returns 𝑒^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾}_min=1 to the lpWDA algorithm and passes additional slack 𝑒^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾} to CalcLowerPriorityWork() in Algorithm 3. Notably, the tasks using PRA still execute under RM priority policy except one of the jobs whose periods span astride the bn. At time 𝑡=0, when jobs 𝜏_1,1, 𝜏_2,1, and 𝜏_3,1 enter 𝑟𝑒𝑎𝑑𝑦𝑄 at time 𝑡=0, 𝜏_1,1 has the highest priority and utilizes additional slack 𝑒^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾}_min estimated by PRA. Therefore, job 𝜏_1,1 obtains one unit of time of slack and changes its voltage level from 1 to 0.5. On the contrary, if primitive lpWDA performs 𝜏_1,1 at time 𝑡=0, 𝜏_1,1 cannot obtain any slack. When lpWDA executes iteratively, the value of 𝑒^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾} does not change until 𝜏_1,1 is completed. Figure 1(c) presents the scheduling result obtained using Procedure PRA. After completing 𝜏_1,1, 𝑒^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾}_min unit of slack has been run out, primitive lpWDA continuously performs voltage scaling on the subsequent jobs of 𝜏_1,1. In the case of 𝜏_2,1, it begins after 𝜏_1,1 (𝑡=1) and obtains one unit of slack time from primitive lpWDA. Therefore, its WCET under voltage 𝑣=0.5 is changed to 𝑤𝑐_2,1=2, and actual execution time is 𝑎𝑐_2,1=1. At time 𝑡=4, job 𝜏_2,2 is released and moved to 𝑟𝑒𝑎𝑑𝑦𝑄. Its priority is changed to and lower than the remaining execution time of 𝜏_3,1 by executing line 14 in Procedure PRA. Therefore, job 𝜏_2,2 begins its work after completing the remaining work of 𝜏_3,1. Notably, PRA only changes job’s priority in 𝑇^𝖻𝗇 and does not affect the feasibility of lpWDA schedule. The correctness proof is discussed later in the next section. Table 2 shows the values of scheduling parameters. The rightmost job in 𝑟𝑒𝑎𝑑𝑦𝑄 is being executed at that time. In Algorithm 1, job 𝜏_𝛿 is a global variable. Whenever job 𝜏_𝛿 executes and 𝑒^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾}>0, Procedure PRA lowers its priority to guarantee the timing constraint of jobs 𝜏_𝑛 and 𝜏_𝛿.

Table 2 

Scheduling parameters in Example 2.

5. Correctness Proof

In this section, we prove the correctness of the schedules produced by lpWDA and PRA based on worst-case response time (WCRT) analysis and assume that the given task sets are feasible under preemptive RM scheduling. For the fixed-priority preemptive scheduling, a critical instant for a task 𝜏_𝑖 is given by a moment in which the release time of 𝜏_𝑖 coincides with all higher-priority tasks. Let 𝑊𝑅_𝑖 denote the WCRT of 𝜏_𝑖, without loss of generality, the higher-priority tasks have simultaneous release time with the job of 𝜏_𝑖.

Lemma 3. When a task set 𝑇 contains only one task 𝜏_𝛾, the available slack produced by lpWDA for 𝜏_𝛾 is 𝑠𝑙𝑎𝑐𝑘_𝛾(𝑡)=𝑑_𝛾−𝑡−𝑤𝑐_𝛾^𝑟𝑒𝑚(𝑡).(19)

Proof. By (8), the amount of work required to be processed in interval [𝑡,𝑑_𝛾) is 𝑙𝑜𝑎𝑑_𝛾(𝑡)=𝑤^rem_𝛾(𝑡).(20) According to (3), the available slack is derived as 𝑠𝑙𝑎𝑐𝑘_𝛾(𝑡)=𝑑_𝛾−𝑡−𝑙𝑜𝑎𝑑_𝛾(𝑡)=𝑑_𝛾−𝑡−𝑤^rem_𝛾(𝑡),(21) which completes the proof.

In lpWDA, the slack derived from lower-priority task is given to the highest priority job in the readyQ. In the WCET case, after applying the slack to the highest priority job, the execution cycles of lower-priority jobs are postponed and their WCRTs will be increased in the length equal to that slack.

Lemma 4. When a task set 𝑇 contains 𝑛 tasks where 𝑛≥2, the amount of work required to be processed in [𝑡,𝑑_𝛼] (𝛼≤𝑛) for the highest priority job 𝜏_𝛼 is 𝑙𝑜𝑎𝑑_𝛼(𝑡)=𝑤_𝑛^𝑟𝑒𝑚(𝑡)+𝐻_𝑛(𝑡)−𝑢𝑑_𝑛−𝑑_𝛼.(22)

Proof. Assuming that 𝑇 contains 𝑛 tasks where 𝑛≥2, we prove that this lemma form the lowest priority task (i.e., 𝜏_𝑛) to the highest priority task using mathematical induction. The case of 𝜏_𝑛 is proved separately because the third term of 𝑙𝑜𝑎𝑑_𝑛(𝑡) is different from those with 𝛼<𝑛 in (22). From (8), when 𝜏_𝛼 is the lowest priority task (i.e., 𝛼=𝑛), the workload of the tasks whose priorities lower than 𝜏_𝑛 are zero (i.e., 𝐿_𝑛(𝑡)=0). Therefore, the amount of work required to be processed at time 𝑡 is 𝑙𝑜𝑎𝑑_𝑛(𝑡)=𝑤^rem_𝑛(𝑡)+𝐻_𝑛(𝑡).(23) Because 𝜏_𝑛=𝑢𝑑_𝑛 before completing 𝜏_𝑛, we add (𝑢𝑑_𝑛−𝜏_𝑛) to (23) and derive 𝑙𝑜𝑎𝑑_𝑛(𝑡)=𝑤^rem_𝑛(𝑡)+𝐻_𝑛(𝑡)−𝑢𝑑_𝑛−𝑑_𝑛,(24) and this completes the proof of 𝜏_𝑛.
Basic Step. First, we discuss the value of 𝑙𝑜𝑎𝑑_𝑛−1(𝑡) which can be estimated under two cases: 𝑢𝑑_𝑛(𝑡)>𝑑_𝑛−1 (Case  1) and 𝑢𝑑_𝑛(𝑡)≤𝑑_𝑛−1 (Case  2).
Case  1 (𝑢𝑑_𝑛(𝑡)>𝑑_𝑛−1). If 𝑢𝑑_𝑛(𝑡) is later than 𝑑_𝑛−1, 𝑙𝑜𝑎𝑑_𝑛(𝑡) is greater than 𝑤^rem_𝑛−1(𝑡)+𝐻_𝑛−1(𝑡), that is, the work in 𝑤^rem_𝑛−1(𝑡)+𝐻_𝑛−1(𝑡) is the subset of the work in 𝑙𝑜𝑎𝑑_𝑛(𝑡). Let Δ=𝑙𝑜𝑎𝑑_𝑛(𝑡)−𝑤^rem_𝑛−1(𝑡)+𝐻_𝑛−1(𝑡), if Δ≤𝑢𝑑_𝑛(𝑡)−𝑑_𝑛−1, Δ amount of work can be processed in [𝑑_𝑛−1, 𝑢𝑑_𝑛(𝑡)], and only 𝑤^rem_𝑛−1(𝑡)+𝐻_𝑛−1(𝑡) is required to be processed before 𝑑_𝑛−1. Otherwise, Δ−(𝑢𝑑_𝑛(𝑡)−𝑑_𝑛−1) amount of work should be processed before 𝑑_𝑛−1. That is, 𝐿_𝑛−1(𝑡)=𝑙𝑜𝑎𝑑_𝑛(𝑡)−𝑤^rem_𝑛−1(𝑡)−𝐻_𝑛−1(𝑡)−𝑢𝑑_𝑛(𝑡)−𝑑_𝑛−1⁺,(25) where the notation 𝑥⁺ stands for max(𝑥,0). Substituting (23) in the above equation, we get 𝐿_𝑛−1(𝑡)=𝑤^rem_𝑛(𝑡)+𝐻_𝑛(𝑡)−𝑤^rem_𝑛−1(𝑡)−𝐻_𝑛−1(𝑡)−𝑢𝑑_𝑛(𝑡)−𝑑_𝑛−1⁺.(26) Substituting this result in 𝑙𝑜𝑎𝑑_𝑛−1(𝑡) defined in (8), we obtain 𝑙𝑜𝑎𝑑_𝑛−1(𝑡)=𝑤^rem_𝑛−1(𝑡)−𝐻_𝑛−1(𝑡)+𝑤^rem_𝑛(𝑡)+𝐻_𝑛(𝑡)−𝑤^rem_𝑛−1(𝑡)+𝐻_𝑛−1(𝑡)−𝑢𝑑_𝑛(𝑡)−𝑑_𝑛−1⁺=𝑤^rem_𝑛(𝑡)+𝐻_𝑛(𝑡)−𝑢𝑑_𝑛(𝑡)−𝑑_𝑛−1.(27)
Case  2 (𝑢𝑑_𝑛(𝑡)≤𝑑_𝑛−1). When 𝑢𝑑_𝑛(𝑡) is earlier than 𝑑_𝑛−1, 𝑙𝑜𝑎𝑑_𝑛(𝑡) must be processed before 𝑑_𝑛−1. However, the value of 𝑙𝑜𝑎𝑑_𝑛(𝑡) does not change, and the value of 𝑙𝑜𝑎𝑑_𝑛−1(𝑡) is obtained as follows: 𝐿_𝑛−1(𝑡)=𝑤^rem_𝑛(𝑡)+𝐻_𝑛(𝑡).(28)
Inductive Step. When task 𝜏₂ is considered, the value of 𝑙𝑜𝑎𝑑₂(𝑡) can be obtained as follows: 𝑙𝑜𝑎𝑑₂(𝑡)=𝑤^rem_𝑛(𝑡)+𝐻_𝑛(𝑡)−𝑢𝑑_𝑛(𝑡)−𝑑₂⁺.(29) When we consider the task with the highest priority (i.e., 𝜏₁), the amount of work of its lower-priority task is 𝐿₁(𝑡)=𝑙𝑜𝑎𝑑₂(𝑡)−𝑤^rem₁(𝑡)−𝐻₁(𝑡)−𝑢𝑑₂(𝑡)−𝑑₁⁺.(30) Substituting 𝑙𝑜𝑎𝑑₂(𝑡) in (30), we get 𝐿₁(𝑡)=𝑤^rem_𝑛+𝐻_𝑛(𝑡)−𝑢𝑑_𝑛(𝑡)−𝑑₂−𝑤^rem₁(𝑡)−𝐻₁(𝑡)−𝑢𝑑₂(𝑡)−𝑑₁⁺.(31) When all tasks release at time 𝑡, we have 𝑢𝑑₂(𝑡)=𝑑₂. Therefore, we get 𝐿₁(𝑡)=𝑤^rem_𝑛+𝐻_𝑛(𝑡)−𝑤^rem₁(𝑡)−𝐻₁(𝑡)−𝑢𝑑_𝑛(𝑡)−𝑑₁⁺.(32) By (8), substituting (32) in 𝑙𝑜𝑎𝑑₁(𝑡), we get 𝑙𝑜𝑎𝑑₁(𝑡)=𝑤^rem₁(𝑡)+𝐻₁(𝑡)+𝐿₁(𝑡)+𝑤^rem₁(𝑡)+𝐻₁(𝑡)+𝑤^rem_𝑛+𝐻_𝑛(𝑡)−𝑤^rem₁(𝑡)−𝐻₁(𝑡)−𝑢𝑑_𝑛(𝑡)−𝑑₁⁺=𝑤^rem_𝑛+𝐻_𝑛(𝑡)−𝑢𝑑_𝑛(𝑡)−𝑑₁.(33) The proof of Case  2 is similar to that of Case  1 and this completes the proof.

Lemma 5. The length of slack, that is, provided by lpWDA for the highest priority task in readyQ is at most 𝑠𝑙𝑎𝑐𝑘_𝛼(𝑡)=𝑢𝑑_𝑛(𝑡)−𝑡−𝑤_𝑛^𝑟𝑒𝑚(𝑡)−𝐻_𝑛(𝑡).(34)

Proof. Assuming that 𝜏_𝛼 has the highest priority in readyQ, this proof can be derived directly from (3), (19), and (22).

The following theorem proves the schedulability of lpWDA by using worst-case response time analysis. We consider each active job 𝜏_𝑖 in readyQ has a simultaneous release with all higher priority tasks.

Theorem 6. Given a set 𝑇 of tasks is feasible in RM schedule, the maximum response time of task 𝜏_𝛾 under lpWDA is less than or equal to its deadline.

Proof. Assuming job 𝜏_𝛼 has the highest priority in readyQ. By (8), we get 𝑊𝑅_𝛼=𝑙𝑜𝑎𝑑_𝛼 at time 𝑡=0. Due to (3) proposed by lpWDA, the deadline of 𝜏_𝛼 can be guaranteed by 𝑠𝑙𝑎𝑐𝑘_𝛼(𝑡)=𝑑_𝛼−𝑙𝑜𝑎𝑑_𝛼,(35) when 𝑡=0. Therefore, we get 𝑊𝑅_𝛼+𝑠𝑙𝑎𝑐𝑘_𝛼≤𝑑_𝛼.(36) When 𝜏_𝛼 runs out 𝑠𝑙𝑎𝑐𝑘_𝛼, all of subsequent jobs of 𝜏_𝛼 have to postpone their response times separately at most 𝑠𝑙𝑎𝑐𝑘_𝛼 unit of times comparing to those in their WCET RM schedule. Assuming 𝜏_𝛾 has lower priority than that of 𝜏_𝛼, we prove that the length of new WCRT of 𝜏_𝛾 including 𝑠𝑙𝑎𝑐𝑘_𝛼 is less than 𝑑_𝛾. In a feasible RM schedule, the WCRT of 𝜏_𝛾 is 𝑊𝑅_𝛾≤𝑤𝑐_𝛾+_𝑖<𝛾𝑝_𝛾𝑝_𝑖⋅𝑤𝑐_𝑖.(37) The new WCRT of 𝜏_𝛾 considering the length of 𝑠𝑙𝑎𝑐𝑘_𝛼 is denoted as 𝑊𝑅^new_𝛾=𝑤𝑐_𝛾+_𝑖<𝛾𝑝_𝛾𝑝_𝑖⋅𝑤𝑐_𝑖+𝑠𝑙𝑎𝑐𝑘_𝛼=𝑤𝑐_𝛾+_𝑖<𝛾𝑝_𝛾𝑝_𝑖⋅𝑤𝑐_𝑖+𝑑_𝛼−𝑡−𝑙𝑜𝑎𝑑_𝛼(𝑡).(38) Based on (22) in Lemma 4 and set 𝑡=0, we derive 𝑊𝑅^new_𝛾=𝑤𝑐_𝛾+_𝑖<𝛾𝑝_𝛾𝑝_𝑖⋅𝑤𝑐_𝑖+𝑑_𝛼−𝑤𝑐_𝛾+𝐻_𝛾(0)−𝑢𝑑_𝛾+𝑑_𝛼=_𝑖<𝛾𝑝_𝛾𝑝_𝑖⋅𝑤𝑐_𝑖−𝐻_𝛾(0)+𝑢𝑑_𝛾.(39) From the definitions of function 𝐻_𝛾(𝑡) in (4) and (5), we derive 𝑊𝑅^new_𝛾=_𝑖<𝛾𝑝_𝛾𝑝_𝑖⋅𝑤𝑐_𝑖−𝐻^past_𝛾+𝐻^future_𝛾+𝑑_𝛾=_𝑖<𝛾𝑝_𝛾𝑝_𝑖⋅𝑤𝑐_𝑖−_𝑖<𝛾𝑤𝑐_𝑖+_𝑖<𝛾𝑑_𝛾−𝜀𝑝_𝑖−1+1⋅𝑤𝑐_𝑖+𝑑_𝛾=_𝑖<𝛾𝑝_𝛾𝑝_𝑖⋅𝑤𝑐_𝑖−_𝑖<𝛾𝑑_𝛾−𝜀𝑝_𝑖+1⋅𝑤𝑐_𝑖+𝑑_𝛾,(40) and 𝜀 is the infinitesimal. Because 𝑊𝑅^new_𝛾=_𝑖<𝛾𝑝_𝛾𝑝_𝑖⋅𝑤𝑐_𝑖≤_𝑖<𝛾𝑑_𝛾−𝜀𝑝_𝑖+1⋅𝑤𝑐_𝑖,(41) we derive 𝑊𝑅^new_𝛾≤𝑑_𝛾(42) from (40) and complete the proof.

From (41) in Theorem 6, the difference between 𝑊𝑅^new_𝛾 and 𝑑_𝛾 is derived from the following corollary.

Corollary 7. For some tasks 𝜏_𝑖∈𝑇^𝖻𝗇, 𝑖<𝛾 and 𝑑_𝛾=𝖻𝗇, and 𝑝_𝛾 is not the multiple of these 𝑝_𝑖𝑠; the difference between 𝑊𝑅_𝛾^𝑛𝑒𝑤 and 𝑑_𝛾 is formulated as 𝑑_𝛾−𝑊𝑅_𝛾^𝑛𝑒𝑤=_𝑘<𝛾𝑑_𝛾−𝜀𝑝_𝑘+1⋅𝑤𝑐_𝑘−_𝑘<𝛾𝑝_𝛾𝑝_𝑘⋅𝑤𝑐_𝑘=_{𝜏𝑖∈𝑇𝖻𝗇}𝑤𝑐_𝑖.(43) Notably, 𝑊𝑅_𝛾^𝑛𝑒𝑤 presents the length of WCRT proposed by lpWDA, and therefore the slack between 𝑊𝑅_𝛾^𝑛𝑒𝑤 and 𝑑_𝛾 could be utilized by PRA.

Consider the example shown in Figure 4(a). The value of 𝑙𝑜𝑎𝑑_3,1(0) is set to the sum of 𝑤𝑐₃ and 𝐻_3,1(0) which is shown in the gray box of Figure 4(b). There are 6 time units that are required to be processed before 𝑢𝑑_3,1=8. In order to guarantee the feasible schedule of higher-priority jobs whose periods span astride 𝑢𝑑_3,1 (i.e., 𝜏_1,2 and 𝜏_2,2), lpWDA estimates how much time should be reserved for the higher-priority jobs. In this case, 𝑤𝑐_1,2+𝑤𝑐_2,2=2 is derived from (43). We investigate the difference between 𝑑_𝛾 and 𝑊𝑅^new_𝛾 to keep the deadlines of PRA jobs.

Lemma 8. Algorithm lpWDA selects an effective feasible speed for the active job in the analysis scope generated by upcoming deadlines.

Proof. Lemma 8 is derived directly from Theorem 6 and Corollary 7.

Lemma 9. Let 𝛾>𝛿, 𝑑_𝛾=𝖻𝗇 and 𝜏_𝛿∈𝑇^𝖻𝗇. When job 𝜏_𝛾 is feasible under PRA, 𝜏_𝛿 also keeps its deadline.

Proof. According to Theorem 6, we have 𝑊𝑅^new_𝛾≤𝑑_𝛾.(44) The WCRT of job 𝜏_𝛾 under PRA is changed to 𝑊𝑅^PRA_𝛾=𝑊𝑅^new_𝛾−𝑤𝑐_𝛿+𝑒^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾}_min.(45) By (45), the deadline of job 𝜏_𝛾 is still guaranteed by PRA. Additionally, the priority of job 𝜏_𝛿 is changed temporarily lower than 𝜏_𝛾, and 𝜏_𝛿 executes immediately after 𝑤𝑐_𝛾. Therefore, the WCRT of job 𝜏_𝛿 is denoted as 𝑊𝑅^PRA_𝛿=𝑊𝑅^PRA_𝛿+𝑤𝑐_𝛿=𝑊𝑅^PRA_𝛿+𝑒^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾}_min≤𝑑_𝛾+𝑒^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾}_min.(46) Due to the definition of ℓ^right_𝛿, we get 𝑑_𝛾+𝑒^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾}_min≤𝑑_𝛾+ℓ^right_𝛿(47) and complete the proof.

Lemma 9 proves that additional slack produced by PRA is shorter than the right part of 𝑝_𝛿 split by bn. Therefore, the deadline of job 𝜏_𝛿 is kept after changing the priority of 𝜏_𝛿 to the lowest priority in the readyQ. After completing 𝜏_𝛿, the schedule is performed continuously under lpWDA. The schedulability proof in interval [𝖻𝗇,𝑟_𝑛,𝑘+1) is similar to Theorem 6 except additional work 𝑒^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾} in the WCET schedule.

Lemma 10. An lpWDA schedule remains feasible when 𝑒^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾} unit of work is postponed to interval [𝖻𝗇,𝑟_𝛾,𝑘+1) using PRA.

Proof. In the interval [𝖻𝗇,𝑟_𝛾,𝑘+1), the critical instant appears in a situation that job 𝜏_𝛿 released before bn may remain incomplete at bn, while other tasks are released at bn. In accordance with (47), the maximum uncompleted work for job 𝜏_𝛿 at bn is 𝑒^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾}. Let 𝑊𝑅^′_𝛾 denote the WCRT of job 𝜏_𝛾,𝑘 in the interval [𝖻𝗇,𝑟_𝛾,𝑘+1) where 𝛾>𝛿>𝛼. According to (40) in Theorem 6, we have 𝑊𝑅^′_𝛾=_𝑖<𝛾𝑝_𝛾𝑝_𝑖⋅𝑤𝑐_𝑖−_𝑖<𝛾𝑑_𝛾−𝜀𝑝_𝑖+1⋅𝑤𝑐_𝑖+𝑑_𝛾−𝑤𝑐_𝛿+𝑒^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾}.(48)
According to line 13 in algorithm PRA, the length of available slack is 𝑒^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾}≤𝑤𝑐_𝛿. From (48), the following statement still holds: _𝑖<𝛾𝑝_𝛾𝑝_𝑖⋅𝑤𝑐_𝑖≤_𝑖<𝛾𝑑_𝛾−𝜀𝑝_𝑖+1⋅𝑤𝑐_𝑖−𝑤𝑐_𝛿+𝑒^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾}.(49) Therefore, we derive 𝑊𝑅^′_𝛾≤𝑑_𝛾,𝑘=𝑟_𝛾,𝑘+1(50) which completes the proof.

In fact, Procedure PRA focuses on providing the potential and available slack time to the lpWDA-based algorithms.

Theorem 11. Procedure  PRA provides additional slack that guarantees all task deadlines in the lpWDA.

Proof. In the interval [𝑟_{𝑛,𝑘−1},𝖻𝗇), suppose job 𝜏_𝛼 is being executed in [𝑟_{𝑛,𝑘−1},𝖻𝗇). By executing line 9 in Algorithm 1 while passing the additional slack 𝑒^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾} to the function CalcSlackTime() in the lpWDA algorithm, Algorithm 2 computes the length of the slack, which 𝜏_𝛼 can use by calling the function CalcLowerPriorityWork() recursively. When job 𝜏_𝛼 uses complete 𝑒^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾} and all of its subsequent jobs execute in their WCET, job 𝑟_{𝑛,𝑘−1} is likely to miss its deadline. However, line 14 in Procedure PRA solves this problem by changing the priority of job 𝜏_𝛿 to the lowest priority job in readyQ. Because ℓ^right_𝛿≥𝑒^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾}, according to Lemma 9, the deadline of jobs 𝜏_𝛿 and 𝜏_𝑛 is guaranteed in the interval [𝑟_{𝑛,𝑘−1},𝖻𝗇).
In the interval [𝖻𝗇,𝑟_𝑛,𝑘+1), Procedure PRA computes the length of additional slack in [𝖻𝗇,𝑟_𝑛,𝑘+1). Given that 𝜏_𝛿 has been assigned to the lowest priority in readyQ, and all deadlines before the completion time of 𝜏_𝛿 are met. Based on the completion time of 𝜏_𝛿, we divide it into two cases.
Case  1. Job 𝜏_𝛿 completes at time 𝑡^≤ and 𝑡^≤≤𝖻𝗇. In this case, the slack computed by Procedure PRA is not to be used by the jobs started before 𝑡^≤. Because 𝑒^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾} produced by Procedure PRA does not shift to the time before the bn, it has no influence on the job execution cycles after bn. Therefore, the initial lpWDA algorithm guarantees the deadline of jobs that started after the bn.
Case 2. Job 𝜏_𝛿 completes at time 𝑡^> and 𝑡^>>𝖻𝗇. When a scheduling point is at 𝑡^>, the analysis scope defined in (2) is extended up to 𝑟_𝑛,𝑘+1 by calling the Procedure CalcLowerPriorityWork() in Algorithm 3 recursively. In a feasible schedule, when slack 𝑒^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾} has been exchanged on the left side of the bn and jobs before 𝑡^> have been performed according to their WCET, the length of delayed work is not longer than 𝑒^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾}. Therefore, the length of the additional work moved in interval [𝖻𝗇,𝑟_𝑛,𝑘+1) is at most 𝑒^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾}. By Lemma 10, the additional work does not affect the feasibility of lpWDA schedule and completes the proof.

6. Performance Evaluation

In this section, we evaluate the time and energy efficiency of PRA scheme for randomly generated task sets and compare them with those of the ccRM, lpWDA and lpLDAT schemes. Both the ccRM and lpWDA are modified to account for transition time overhead. In simulations, lpWDA, and lpLDAT are called the host algorithms of PRA and cooperate with PRA to compare its performance with those of initial ccRM, lpWDA, and lpLDAT methods.

6.1. Complexity and Execution Time of Algorithms

Theorem 12. The PRA algorithm has a computational complexity of O(n) per scheduling point, where n denotes the number of tasks in the systems.

Proof. Lines 4 and 5 are completed in constant time for each iterative step according to (19) and (23). In line 8, the value of 𝑒^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾}_asyn is derived from (24)–(27), where the value of 𝑒_𝑖^{𝖤𝗑𝖼𝗁𝖺𝗇𝗀𝖾}(ℓ) in (27) needs 𝑂(𝑛) time to compute the length of slack time. In line 10, the computation of 𝑒^𝖻𝗇 and 𝑒^{𝑠𝑙𝑎𝑐𝑘} needs 𝑂(𝑛) time. Therefore, the overall time complexity is 𝑂(𝑛).

In the simulation results, for any given pair of 𝑡𝑜𝑡𝑎𝑙𝑡𝑎𝑠𝑘𝑠, 𝑈 and 𝑏𝑐/𝑤𝑐 ratio in 𝑇, 10000 task sets are generated randomly. The experiment result is the average value over the 10000-task sets. In a task set, every task period 𝑝_𝑖 (as well as deadline 𝑑_𝑖) is uniformly distributed in the range [1,100] ms. The length of each schedule is at least ten times of its tasks hyperperiod except the fourth experiment in Section 6.2. Execution time 𝑤𝑐_𝑖 of each task is assigned a real number in the range of [1, min{𝑝_𝑖−1, 90}]ms. In a task set, after assigning values to the execution time of all tasks, we give a utilization 𝑈 to the task set and rescale the 𝑝_𝑖 of each task, such that the summation of task weights (i.e., 𝑤𝑐_𝑖/𝑝_𝑖) equals the given 𝑈.

Due to the limited execution speed of embedded processors, an LCM(𝑇_𝑏) function is implemented by offline nonrecursive programs. This function is composed of 𝑙𝑐𝑚(𝑎,𝑏) and 𝑔𝑐𝑑(𝑎,𝑏) which compute the least common multiplier (LCM) and greatest common divisor (GCD), respectively. In these programs, each integer is represented by a 32-bit word. Each experiment (schedule) has a maximum of 20 tasks, and each task has an integer variable for storing the period lengths of accumulated values of an LCM. Additionally, two integers are needed to record GCD and LCM of all task periods. Therefore, each schedule requires at most 100 bytes for storing data, which include local variables.

In Figure 5, we examine the execution time required by each online algorithm, including the following algorithms:  ccRM: the ccRM algorithm from [7] is modified to account for transition overhead;  lpWDA: the lpWDA algorithm from [6] is modified to account for transition overhead;  lpLDAT: the algorithm from [12];  lpWDA-PRA: the lpWDA is the host algorithm of PRA and cooperates with Procedure PRA;  lpLDAT-PRA: the lpLDAT is the host algorithm of PRA and cooperates with Procedure PRA;  lpWDA-DP-PRA: the lpWDA-DP is a host algorithm and cooperates with Procedure PRA;  lpWDA-AC-PRA: the lpWDA-AC is a host algorithm and cooperates with Procedure PRA.

Figure 5 

Maximum execution time for the scheduling algorithms versus the number of tasks on a 100 MHz processor.

Figure 5 presents maximum execution time of each algorithm on a processor versus the number of tasks in the system. Notably, the simulation results produced by lpWDA-DP-PRA and lpWDA-AC-PRA are very close to those of lpWDA-PRA and lpLDAT-PRA, for a clear presentation of this figure, they are abridged. All algorithms executing on the simulated processor are based on ARM8 core with the highest speed (100 MHz) and voltage level. The measurement results were generated by inserting a system timer function and executing each algorithm individually. Obviously, ccRM has a significant advantage in terms of execution time when compared with that of the other online algorithms. Because the algorithms are invoked upon each release and completion, one must increase execution time of each task by two times the maximum execution time of the algorithm to account for scheduling overhead. To present the maximum execution times of these algorithms, the simulation process is as follows. First, a set of experiments performed Procedure PRA with its host algorithms (lpWDA and lpLDAT) and other initial algorithms. The functions of the system timer are used to record the duration of each algorithm, choose their longest execution times in each schedule, and accumulate execution times separately with respect to different methods. At experiment end, these accumulated execution times are divided by the number of schedules generated. PRA is an efficient online algorithm that increases in average additional execution time by less than 12% of those of their host algorithms.

6.2. Simulation Results

The following four parameters are varied in simulations: (1) number of tasks 𝑡𝑜𝑡𝑎𝑙𝑡𝑎𝑠𝑘𝑠 in 𝑇 is varied at 2–18 in two task increments; (2) utilization 𝑈 for task set is varied at 0.1–0.9; (3) the 𝑏𝑐/𝑤𝑐 ratio of BCET to WCET is varied at 0.1–0.9; and (4) the analytical interval in bound being the multiples of 𝑝_𝑛 is denoted as 𝑀^analysis_𝑝𝑛. Before performing these experiments, 10000 task sets have been generated randomly including the number of tasks in each set, task period lengths, and their worst-case execution requirements in accordance with a uniformed distribution function. Early completion time of each job in simulation (1), (2), and (4) was randomly drawn from a Gaussian distribution in the range of [BCET, WCET], where BCET/WCET = 0.1. In simulation (3), each experiment was performed by varying BCET at 10%–90% of WCET.

For all experiments, we assume that 10 frequency levels are available in the range of 10–100 MHz, with corresponding voltage levels of 1–3.3 Volts. The energy consumption caused by memory access and cache misses are ignored, and all experimental results are normalized against the same processor running at maximum speed without a DVS technique (non-DVS for short). Table 3 presents the power specification of the ARM8 processor [15].

Table 3 

Power specification.

The overhead considered in simulations is as follows.

(1) Algorithm Execution Time and Energy. The execution time overhead is referred to the simulation results in Figure 5. Energy overhead is obtained under the assumption of maximum speed 𝑆_max.

(2) Voltage Transition Time and Energy. The assumption of voltage scaling overhead is the same with that in [17]. For the voltage scaling from 𝑉_𝑑𝑑1 to 𝑉_𝑑𝑑2, the transition time is Δ𝑡≈2⋅𝐶𝐼_max⋅𝑉_𝑑𝑑2−𝑉_𝑑𝑑1,(51) where 𝐶 and 𝐼_max the charge to the capacitor and maximum output current of the converter, respectively. Transition time is at most 70 𝜇𝑠 between maximum transition [15]. The energy consumed during each transition is Δ𝐸=𝑛(1−𝜆)⋅𝐶⋅𝑉_𝑑𝑑2−𝑉_𝑑𝑑1,(52) where 𝜆 denotes the efficiency of a DC-DC converter.

(3) Context-Switch Time and Energy. Context-switch time is assumed 50 𝜇𝑠 at the highest speed 𝑆_max, as in [18].

Figures 6, 7, 8, and 9 list the energy consumption of each method. Energy consumption includes both execution duration of PRA and its host algorithms (i.e., the lpWDA and lpLDA), and the context-switch time required to switch to and from other real-time tasks. Since the range of task periods has been shortened to a scale of [1,100] ms, the difference between task periods and context-switch times or transition times is smaller than those assumed in [6, 12]. Additionally, these energy overheads arose from PRA, and its host algorithms are also taken into account, such that the experimental results are close to actual situations. In these simulations, the host algorithms cooperating with PRA are better than its initial algorithms, respectively.

Figure 6 

Energy consumption under different 𝑡𝑜𝑡𝑎𝑙𝑡𝑎𝑠𝑘.

Figure 7 

Energy consumption under different 𝑈.

Figure 8 

Energy consumption under different 𝑏𝑐/𝑤𝑐 ratio.

Figure 9 

Energy consumption under different values of 𝑀analysis𝑝𝑛

Figures 6, 7, 8, and 9 also present the results for a clairvoyant algorithm, named bound, which knows the actual execution cycle of each task beforehand and adopts the optimal speed accordingly. The length of analytical interval utilized by algorithm bound is set at least four times the length of 𝑝_𝑛 except the fourth experiment in Figure 9. This setting ensures that bound’s analytical length is longer than those utilized by other methods and equal to the length of the schedules. Every scheduling point in the entire schedule is examined when looking for the best start and finish times. The context-switch and transition overhead assumed in the bound are the same as those with other methods while its execution time is assumed zero. In fact, bound is not a practical algorithm because it is extremely time consuming when finding the suitable start, preemption, and completion times, and no algorithm can predict the exact amount of job execution cycles beforehand. Thus, bound functions a yardstick in simulations because no real DVS algorithm can achieve better performance than that of bound.

As shown in Figure 6, the lpWDA-PRA and lpLDAT-PRA method, respectively, reduces the energy consumption by at least 12% and 4% over that of primitive lpWDA and lpLDAT. The energy efficiency of lpWDA-DP-PRA is between those of lpWDA-PRA and lpLDAT-PRA, while the energy efficiency of lpWDA-AC-PRA is 6%–3% worse than those of lpWDA-PRA and lpLDAT-PRA. The difference between lpWDA-AC-PRA and lpWDA-PRA is that lpWDA-AC in lower layer tries to schedule tasks with higher speed and leaves additional slack that PRA is unaware of. Therefore, this slack time becomes a fragment of slack time that is harmful to power saving. The following series of experiments almost reveal the phenomenon that the performance of lpWDA-AC-PRA is worse than those of lpWDA-PRA and lpWDA-DP-PRA. The value of 𝑈 of each task set is assigned randomly at 10%–70% by uniform probability distribution function. The value of 𝑈 and the 𝑏𝑐/𝑤𝑐 ratio for each task set are 0.8 and 0.5, respectively. With a large U, PRA outperforms its host algorithms in a small 𝑡𝑜𝑡𝑎𝑙𝑡𝑎𝑠𝑘, consuming up to 25% and 24% less energy than lpWDA and lpLDAT, respectively. Although execution overhead of PRA is included, for a large 𝑡𝑜𝑡𝑎𝑙𝑡𝑎𝑠𝑘, PRA still outperforms its host algorithms. The reason is likely that when the number of tasks increases, the number of task synchronization points appeared in the analytical interval likely decreases and benefits slack time computation.

Experimental results in Figure 7 indicate that lpWDA-PRA and lpLDAT-PRA saved up to 25% and 4% more energy than their host algorithms. Among lpWDA-based methods, although lpWDA-DP-PRA has the best performance, it slightly outperforms lpWDA-PRA. In other words, when PRA is applied in lpWDA, the 𝑑𝑒𝑙𝑎𝑦𝑒𝑑-𝑝𝑟𝑒𝑒𝑚𝑝𝑡𝑖𝑜𝑛 (DP) technique contributes little energy saving to the host methods. In the experiment, the 𝑡𝑜𝑡𝑎𝑙𝑡𝑎𝑠𝑘 and the bc/wc ratio of each task set are 10 and 0.5, respectively. Increasing the value of 𝑈 in Figure 7 increases the energy consumption of PRA and its host algorithms. With a small 𝑈, the gain from PRA is modest, with 1% and 4% saving compared to that of the initial lpLDAT and lpWDA algorithms, respectively. Additionally, with these methods, 𝑈 is an important factor when computing the slack for deciding processor speeds. With a moderate 𝑈 value, lpWDA-PRA and lpLDAT-PRA consume at most 16% and 4% less energy than that of the initial lpWDA and lpLDAT algorithm, respectively. Therefore, PRA utilizes not only the advantages of its host algorithms but also slack belonging to the value of 1−𝑈 as possible and shifts the slack to the current job.

In Figure 8, the set of experiments varies the 𝑏𝑐/𝑤𝑐 ratio at 0.1–0.9, and the value of 𝑈 and 𝑡𝑜𝑡𝑎𝑙𝑡𝑎𝑠𝑘 is 0.8 and 10, respectively. The energy consumed by PRA is positively correlated with the 𝑏𝑐/𝑤𝑐 ratio, while their hosts are not sensitive to the 𝑏𝑐/𝑤𝑐 ratio. In this experiment, lpWDA-DP-PRA still outperforms other lpWDA-based methods but not obviously. With a low 𝑏𝑐/𝑤𝑐 ratio, PRA is the best, consuming up to 26% and 16% less energy than the lpWDA and lpLDAT, respectively. With a 𝑏𝑐/𝑤𝑐 ratio of 0.9, PRA collaborated with lpLDAT which consumes slightly more energy than the initial lpLDAT algorithm. The reason is likely that the additional saving gained by the PRA algorithm is compromised by its execution overhead.

In Figure 9, the analytical interval in bound is exactly 𝑀^analysis_𝑝𝑛 times the length of 𝑝_𝑛. The values of 𝑀^analysis_𝑝𝑛 are controlled by the simulation from 2 to 18 and the totaltask of each task set is assigned randomly at 2 to 20 tasks. For simplicity, the length of each schedule is also controlled in 𝑀^analysis_𝑝𝑛×𝑝_𝑛. When the value of 𝑀^analysis_𝑝𝑛 increases, the energy saving of bound is not obvious, and the energy consumption required by the schemes with PRA are not sensitive to 𝑀^analysis_𝑝𝑛. Notably, when 𝑀^analysis_𝑝𝑛=2, PRA and bound have equal length of analytical interval; bound gains at most 33% energy savings less than the proposed schemes. Therefore, extending the additional analysis interval, such that it is several times longer than 𝑝_𝑛 does not increase an already substantial energy saving but rather increases computing overhead during slack time analysis. There exist some limits and difficulties whenever extending analysis interval that is longer than two times of 𝑝_𝑛. Firstly, the length of the potential slack time is affected by the length of analytical interval, the values of Syn(𝑇^𝑓,𝑘) and 𝑡(𝑇^𝑓,𝑘), and by the locations of actual execution cycles of job. In Figure 3, the locations of the job workload affect the available length of slack time. Additionally, utilization of a task set influences the length of available slack time. For example, for a task set with high utilization, actual workload of many tasks may appear after 𝑡(𝑇^𝑓,𝑘) where 𝑏=𝑛 or 𝑏=𝑛−1 and cannot be exchanged with the slack. Therefore, the longer the analytical interval is, the harder the prediction of the length of additional slack becomes. For a longer interval than 𝑝_𝑛, we may need considerably more time and memory space than those required by PRA. Additionally, the length of a hyperperiod can vary from one to many times of 𝑝_𝑛 as long as one task period is changed. When an analytical interval extends up to a hyperperiod, execution time required by algorithms may change severely and adversely affect the predictability of a real-time schedule.

7. Conclusions

In this paper, we proposed the parareclamation algorithm (PRA) based on the concept of work-demand computation. This method can serve many existing RM scheduling methods as a guest algorithm. PRA cooperating with the host algorithms such as lpWDA, lpWDA-DP, lpWDA-AC, lpLDA, and lpLDAT can further decrease energy consumption without increasing time complexities. It is fully compatible not only with transition-aware (i.e., lpLDAT,) methods but also preemption-aware (i.e., lpWDA-AC and lpWDA-DP,) methods. Experimental results indicate that PRA can utilize the additional slack produced by lpWDA-AC and lpWDA-DP and reduce average energy consumption by 14% when compared with that of the initial schemes.

Acknowledgment

The authors would like to thank the National Science Council of the Republic of China, Taiwan, for financially supporting this paper under NSC 102-2221-E-025-003.