An $O(n^{2})$ Algorithm for Computing Optimal Continuous Voltage Schedules

Energy efficiency is always a primary concern for chip designers not only for the sake of prolonging the lifetime of batteries which are the major power supply of portable electronic devices but also for the environmental protection purpose when large facilities like data centers are involved. Currently, processors capable of operating at a range of frequencies are already available, such as Intel’s SpeedStep technology and AMD’s PowerNow technology. The capability of the processor to change voltages is often referred to in the literature as DVS (Dynamic Voltage Scaling) techniques. For DVS processors, since energy consumption is at least a quadratic function of the supply voltage (which is proportional to CPU speed), it saves energy to let the processor run at the lowest possible speed while still satisfying all the timing constraints, rather than running at full speed and then switching to idle.

One of the earliest theoretical models for DVS was introduced by Yao, Demers and Shenker Yao95 in 1995. They assumed that the processor can run at any speed and each job has an arrival time and a deadline. They gave a characterization of the minimum-energy schedule (MES) and an $O(n^{3})$ algorithm for computing it which is later improved to $O(n^{2}\log n)$ by Li06 . No special assumption was made on the power consumption function except convexity. Several online heuristics were also considered including the Average Rate Heuristic (AVR) and Optimal Available Heuristic (OPA). Under the common assumption of power function $P(s)=s^{\alpha}$, they showed that AVR has a competitive ratio of $2^{\alpha-1}\alpha^{\alpha}$ for all job sets. Thus its energy consumption is at most a constant times the minimum required. Later on, under various related models and assumptions, more algorithms for energy-efficient scheduling have been proposed.

Bansal et al. Bansal04 further investigated the online heuristics for the model proposed by Yao95 and proved that the heuristic OPA has a tight competitive ratio of $\alpha^{\alpha}$ for all job sets. For the temperature model where the temperature of the processor is not allowed to exceed a certain thermal threshold, they showed how to solve it within any error bound in polynomial time. Recently, Bansal et al. Bansal08 showed that the competitive analysis of AVR heuristic given in Yao95 is essentially tight. Quan and Hu Quan01 considered scheduling jobs with fixed priorities and characterized the optimal schedule through transformations to MES Yao95 . Yun and Kim Yun03 later on showed the NP-hardness to compute the optimal schedule.

Pruhs et al. Pruhs04 studied the problem of minimizing the average flow time of a sequence of jobs when a fixed amount of energy is available and gave a polynomial time offline algorithm for unit-size jobs. Bunde Bunde06 extended this problem to the multiprocessor scenario and gave some nice results for unit-size jobs. Chan et al. Soda07 investigated a slightly more realistic model where the maximum speed is bounded. They proposed an online algorithm which is $O(1)$-competitive in both energy consumption and throughput. More work on the speed bounded model can be found in ICALP08 TAMC07 ISAAC07 .

Ishihara and Yasuura Ishihara98 initiated the research on discrete DVS problem where a CPU can only run at a set of given speeds. They solved the case when the processor is only allowed to run at two different speeds. Kwon and Kim Kwon03 extended it to the general discrete DVS model where the processor is allowed to run at speeds chosen from a finite speed set. They gave an $O(n^{3})$ algorithm for this problem based on the MES algorithm in Yao95 , which is later improved in Li05 to $O(dn\log n)$ where $d$ is the allowed number of speeds.

When the CPU can only change speed gradually instead of instantly, Qu98 discussed about some special cases that can be solved optimally in polynomial time. Later, Wu et al. Wu09 extended the polynomial solvability to jobs with agreeable deadlines. Irani et al. Irani03 investigated an extended scenario where the processor can be put into a low-power sleep state when idle. A certain amount of energy is needed when the processor changes from the sleep state to the active state. The technique of switching processors from idle to sleep and back to idle is called Dynamic Power Management (DPM) which is the other major technique for energy efficiency. They gave an offline algorithm that achieves 2-approximation and online algorithms with constant competitive ratios. Recently, Albers and Antoniadis SODA12 proved the NP-hardness of the above problem and also showed some lower bounds of the approximation ratio. Pruhs et al. Pruhs10 introduced profit into DVS scheduling. They assume that the profit obtained from a job is a function on its finishing time and on the other hand money needs to be paid to buy energy to execute jobs. They give a lower bound on how good an online algorithm can be and also give a constant competitive ratio online algorithm in the resource augmentation setting. A survey on algorithmic problems in power management for DVS by Irani and Pruhs can be found in Irani05 . Most recent surveys by Albers can be found in Albers10 Albers11b .

In LiB06 , the authors showed that the optimal schedule for tree structured jobs can be computed in $O(n^{2})$ time. In this paper, we prove that the optimal schedule for general jobs can also be computed in $O(n^{2})$ time, improving upon the previously best known $O(n^{2}\log n)$ result Li06 . The remaining paper is organized as follows. Section 2 will give the problem formulation. Section 3 will discuss the linear implementation of an important tool — the s-schedule used in the algorithm in Li06 . Then we use the linear implementation to improve the calculation of the optimal schedule in Section 4. In Section 5, we give improvements in the computation complexity of the optimal schedule for the discrete model. Finally, we conclude the paper in Section 6.

We consider the single processor setting. A job set $J=\{j_{1},j_{2},\ldots,j_{n}\}$ over $[0,1]$ is given where each job $j_{k}$ is characterized by three parameters: arrival time $a_{k}$, deadline $b_{k}$, and workload $R_{k}$. Here workload means the required number of CPU cycles. We also refer to $[a_{k},b_{k}]\subseteq[0,1]$ as the interval of $j_{k}$. A schedule $S$ for $J$ is a pair of functions $(s(t),job(t))$ which defines the processor speed and the job being executed at time $t$ respectively. Both functions are assumed to be piecewise continuous with finitely many discontinuities. A feasible schedule must give each job its required workload between its arrival time and deadline with perhaps intermittent execution. We assume that the power $P$, or energy consumed per unit time, is $P(s)=s^{\alpha}$ ($\alpha\geq 2$) where $s$ is the processor speed. The total energy consumed by a schedule $S$ is $E(S)=\int_{0}^{1}P(s(t))dt$. The goal of the min-energy feasibility scheduling problem is to find a feasible schedule that minimizes $E(S)$ for any given job set $J$. We refer to this problem as the continuous DVS scheduling problem.

For the continuous DVS scheduling problem, the optimal schedule $S_{opt}$ is characterized by using the notion of a critical interval for $J$, which is an interval $I$ in which a group of jobs must be scheduled at maximum constant speed $g(I)$ in any optimal schedule for $J$. The algorithm MES in Yao95 proceeds by identifying such a critical interval $I$, scheduling those ‘critical’ jobs at speed $g(I)$ over $I$, then constructing a subproblem for the remaining jobs and solving it recursively. The details are given below.

An interval $I^{\ast}$ achieving maximum $g(I)$ over all possible intervals $I$ defines a critical interval for the current job set. It is known that the subset of jobs $J_{I^{\ast}}$ can be feasibly scheduled at speed $g(I^{\ast})$ over $I^{\ast}$ by the earliest deadline first (EDF) principle. That is, at any time $t$, a job which is waiting to be executed and having earliest deadline will be executed during $[t,t+\epsilon]$. The interval $I^{\ast}$ is then removed from $[0,1]$; all the remaining job intervals $[a_{k},b_{k}]$ are updated to reflect the removal, and the algorithm recurses. We denote the optimal schedule which guarantees feasibility and consumes minimum energy in the continuous DVS model as OPT.

The authors in Li06 later observed that in fact the critical intervals do not need to be located one after another. Instead, one can use a concept called $s$-schedule defined below to do bipartition on jobs which gradually approaches the optimal speed curve.

It is easy to see that the $s$-schedule for $n$ jobs contains at most $2n$ $s$-execution intervals, since the end of each execution interval (including an idle interval) corresponds to the moment when either a job is finished or a new job arrives. Also, the $s$-schedule can be computed in $O(n\log n)$ time by using a priority queue to keep all jobs currently available, prioritized by their deadlines. In the next section, we will show that the $s$-schedule can be computed in linear time.

In this work, we assume that the underlying computational model is the unit-cost RAM model with word size $\Theta(\log n)$. This model is assumed only for the purpose of using a special union-find algorithm by Gabow and Tarjan Gabow1983 .

We make the following two assumptions:

• •

  the jobs are already sorted according to their deadlines;

• •

  for each job $j_{k}$, we know the rank of $a_{k}$ in the arrival time set $\{a_{1},a_{2},\ldots,a_{n}\}$.

Because of the first assumption and without loss of generality, we assume that $b_{1}\leq b_{2}\leq\ldots\leq b_{n}$. Algorithm 1 schedules the jobs in the order of their deadlines. When scheduling job $k$, the algorithm tries to search for an earliest available time interval and schedule the job in it, and then repeat the process until all the workload of the job is scheduled or unable to find such a time interval before the deadline. A more detailed discussion of the algorithm is given below.

Let $T$ be $\{a_{1},a_{2},\ldots,a_{n},1,1+\epsilon\}$. Note that the times “$1$” and “$1+\epsilon$” (where $\epsilon$ is any fixed positive constant) are included in $T$ for simplifying the presentation of the algorithm. Denote the size of $T$ by $m$. Denote $t_{i}$ to be the $i$-th smallest element in $T$. Note that the rank of any $a_{k}$ in $T$ is known. During the running of the algorithm, we will maintain the following data structure:

If $[t_{i},t_{i+1})$ is fully occupied, then $e_{i}$ is $t_{i+1}$. Note that such a time $e_{i}$ always exists during the running of the algorithm, which will be shown later when we discuss how to maintain $e_{i}$. At the beginning of the algorithm, we assume that the processor is idle for the whole time period. That means $e_{i}=t_{i}$ for $1\leq i<m$ (see line 1 of Algorithm 1).

Before we analyze the algorithm, we need to define an important concept called canonical time interval.

Note that a non-empty canonical time interval is always idle based on the definition of $e_{p}$. Any arrival time $a_{k}$ will not lie inside any canonical time interval but it is possible that $a_{k}$ will touch any of the two ending points, i.e., for any $1\leq p<m$, we have either $a_{k}\leq e_{p}$ or $a_{k}\geq t_{p+1}$. Therefore, if we want to search for a time interval to run a job at or after time $a_{k}$, then we should always look for the earliest non-empty canonical time interval $[e_{p},t_{p+1})$ where $e_{p}\geq a_{k}$.

In Algorithm 1, a variable $r$ is used to track the workload to be scheduled. Lines 1-1 try to schedule $j_{k}$ as early as possible if $r>0$. Line 1 tries to search for an earliest non-empty canonical time interval $[e_{p},t_{p+1})$ no earlier than the arrival time of $j_{k}$ (i.e., $e_{p}\geq a_{k}$). Such a $p$ always exists because there is always a non-empty canonical time interval $[1,1+\epsilon)$. Line 1-1 means that, if $e_{p}$ is not earlier than the deadline of $j_{k}$, then the job cannot be finished. Line 1 sets a value of $u$, whose meaning is that $[e_{p},u)$ can be used to schedule the job. The value of $u$ is no later than the deadline of $j_{k}$. Lines 1-1 process the case when the remaining workload of $j_{k}$ cannot be finished in the time interval $[e_{p},u)$. Lines 1-1 process the case when the remaining workload of $j_{k}$ can be finished in the time interval $[e_{p},u)$. In the first case, line 1 updates $e_{p}$ to $u$ because the time interval $[t_{p},u)$ is occupied and $[u,t_{p+1})$ is idle. In the second case, a time of $r/s$ is occupied by $j_{k}$ after the time $e_{p}$, so $e_{p}$ is increased by $r/s$.

The most critical part of the algorithm is Line 1, which can be implemented efficiently by the following folklore method using a special union-find algorithm developed by Gabow and Tarjan Gabow1983 (see also the discussion of the decremental marked ancestor problem AlstrupHR1998 ). At the beginning, there is a set $\{i\}$ for each $1\leq i<m$. The name of a set is the largest element of the set. Whenever $e_{p}$ is updated to $t_{p+1}$ (i.e., there is not any idle time in the interval $[t_{p},t_{p+1})$), we make a union of the set containing $p$ and the set containing $p+1$, and set the name of this set to be the name of the set containing $p+1$. After the union, the two old sets are destroyed. In this way, a set is always an interval of integers. For a set whose elements are $\{q,q+1,\ldots,p\}$, the semantic meaning is that, $[t_{q},e_{p})$ is fully scheduled but $[e_{p},t_{p+1})$ is idle. Therefore, to search for an earliest non-empty canonical time interval beginning at or after time $t_{i}$, we can find the set containing $i$, and let $p$ be the name of the set, then $[e_{p},t_{p+1})$ is the required time interval.

Now, we we analyze the time complexity of the algorithm.

Since these unions and finds are operated on the sets of integer intervals, such an interval union-find problem can be solved in $O(m+n)$ time in the unit-cost RAM model using Gabow and Tarjan’s algorithm Gabow1983 . Note that $m=O(n)$, so the total time complexity is $O(n)$. Theorem 3.1 holds.

If the union-find algorithm is implemented in the pointer machine model BenAmram1995 using the classical algorithm of Tarjan Tarjan1975 , the complexity of our $s$-schedule algorithm will become $O(n\alpha(n))$ where $\alpha(n)$ is the one-parameter inverse Ackermann function.

Note that, the number of finds can be further reduced with a more careful implementation of the algorithm as follows (but the asymptotic complexity will not change):

• •

  Whenever the algorithm schedules a job $j_{k}$ to run at a time interval $[e_{p},b_{k})$, the algorithm no longer needs to proceed to line 1 for the same job, because there will not be any idle time interval available before the deadline.

• •

  For each job $j_{k}$, the first time to find a non-empty canonical time interval requires one find operation. In any of the later times to search for earliest non-empty canonical time intervals for the same job, there must be a union operation just performed. The $p$ that determines the earliest non-empty canonical time interval $[e_{p},t_{p+1})$ is just the name of that new set after that union, so a find operation is not necessary in this case. Note that the find operations that accompany the unions are still required.

Using the above implementation, the number of finds to search for earliest non-empty canonical time intervals can be reduced to $n$. Along with the $m-2$ finds for unions, the total number of finds of this improved implementation is at most $(m-2)+n$.

We will first take a brief look at the previous best known DVS algorithm of Li, Yao and Yao Li06 . As in Li06 , Define the “support” $U$ of $J$ to be the union of all job intervals in $J$. Define $\textrm{avr}(J)$, the “average rate” of $J$ to be the total workload of $J$ divided by $|U|$. According to Lemma 9 in Li06 , using $s=\textrm{avr}(J)$ to do an $s$-schedule will generate two nonempty subsets of jobs requiring speed at least $s$ or less than $s$ respectively in the optimal schedule unless the optimal speed for $J$ is a constant $s$. The algorithm will recursively do the scheduling based on the two subsets of jobs. Therefore, at most $n$ calls of $s$-schedules on a job set with at most $n$ jobs are needed before we obtain the optimal schedule for the whole job set. The most time-consuming part of their algorithm is the $s$-schedules.

To apply our improved $s$-schedule algorithm for solving the continuous DVS scheduling problem, we need to make sure that the ranks of the deadlines and arrival times are known before each $s$-schedule call. It can be done in the following way: Before the first call, sort the deadlines and arrival times and obtain the ranks. In each of the subsequent calls, in order to get the new ranks within the two subsets of jobs, a counting sort algorithm can be used to sort the old ranks in linear time. Therefore, the time to obtain the ranks is at most $O(n^{2})$ for the whole algorithm. Based on the improved computation of $s$-schedules, the total time complexity of the DVS problem is now $O(n^{2})$, improving the previous $O(n^{2}\log n)$ algorithm of Li06 by a factor of $O(\log n)$. We have the following theorem.

For the discrete DVS scheduling problem, we have an $O(n\log n)$ algorithm to calculate the optimal schedule by doing binary testing on the given $d$ speed levels, improving upon the previously best known $O(dn\log n)$ Li05 . To be specific, given the input job set with size $n$ and a set of speeds $\{s_{1},s_{2},\ldots,s_{d}\}$, we first choose the speed $s_{d/2}$ to bi-partition the job set into two subsets. Then within each subset, we again choose the middle speed level to do the bi-partition. We recursively do the bi-partition until all the speed levels are handled. In the recursion tree thus built, we claim that the re-sorting for subproblems on the same level can be done in $O(n)$ time which implies that the total time needed is $O(n\log d+n\log n)=O(n\log\max\{d,n\})$. The claim can be shown in the following way. Based on the initial sorting, we can assign a new label to each job specifying which subgroup it belongs to when doing bi-partitioning. Then a linear scan can produce the sorted list for each subgroup.

In this paper, we improve the time for computing the optimal continuous DVS schedule from $O(n^{2}\log n)$ to $O(n^{2})$. The major improvement happens in the computation of s-schedules. Originally, the s-schedule computation is done in an online fashion where the execution time is allocated from the beginning to the end sequentially and the time assigned to a certain job can be gradually decided. While in this work, we allocate execution time to jobs in an offline fashion. When jobs are sorted by deadlines, job $j_{i}$’s execution time is totally decided before we go on to consider $j_{i+1}$. Then by using a suitable data structure and conducting a careful analysis, the computation time for s-schedules improves from $O(n\log n)$ to $O(n)$. We also design an algorithm to improve the computation of the optimal schedule for the discrete model from $O(dn\log n)$ to $O(n\log\max\{d,n\})$.