City University of Hong Kong
香港城市大學
Optimizations of Power Allocation
能量最優化问题的研究
Submitted to
Department of Computer Science
电脑科學系
In Partial Fulfillment of the Requirements
For the Degree of Doctor of Philosophy
哲学博士學位
by
Weiwei Wu
吴巍煒
July 2011
二零一一年七月
Acknowledgments
I take this opportunity to thank my advisor Dr. Minming Li. It is him whom
brings me to the theory research. During the four years, he tries all his best to help
me on my study and also job/post-doc hunting. I am grateful that he could let me
work on my own pace and even find topics out of my own interests. With his encouragement, I gradually gain my confidence on independent research. I could not
have completed the dissertation without his kind supervision in the past years.
I should thank my supervisor Prof. Enhong Chen. Although my research area is
different with his field, he gave me enough space and supported my choosing of research topics. He always have nice patient on me and is willing to help me. I also
thank his students in Hefei, who show their respects and willing to share me their
findings. Also, I should thank Prof Frances Yao who writes me her recommendation
letter even when she is busy. I am appreciated to get the chance discussing in seminars with Prof. Jianping Wang, Guoliang Xin, Xiaohua jia and the students in CityU.
Especially I want to thank my friends Hong Zhou, Deguo Xia, Yalin Yang and the
people who work and play closely with me in Hefei.
Last but not least, I would like to express my gratitude to my classmates who
study together with me, my roommates Wanyong Tian, Xianwei Sun, Zhifang Li,
Xingliang Ni who help each other in the life, my labmates Jin Wang, Yan Li, Xiumin
Wang, Shucheng Liu who fight together in the PhD studies.
ii
Abstract
The number of mobile users (devices) reaches 5 billion in year 2010. Due to the
great number of devices and the fact that all the devices are equipped with limited
battery (power), designing algorithms to save the energy usage on a single device or
properly utilize the power to maximize
receives many concerns.
the date throughput of the mobile system
We theoretically study several scheduling/allocation
problems to optimize the power usage on a device and the system. We provide a
thorough study on approximation algorithms (or exact) to compute the (optimal)
power allocation on a single device and online algorithms with optimal competitive
ratio to maximize the throughput on a mobile system.
Dynamic voltage scaling technique provides the capability for processors to adjust the speed and control the energy consumption. We study the pessimistic accelerate model where the acceleration rate of the processor speed is at most
and jobs
cannot be executed during the speed transition period. The objective is to find a min
‐energy (optimal) schedule that finishes every job within its deadline. The aligned
jobs where earlier released jobs have earlier deadlines are studied. We start by investigating a special case where all jobs have a common arrival time and design an
algorithm to compute the optimal schedule based on some nice properties of
the optimal schedule. Then, we study the general aligned jobs and obtain an
algorithm to compute the optimal schedule by using the algorithm for the common
arrival time case as a building block. Because our algorithm relies on the computation of the optimal schedule in the ideal model (
), in order to achieve
complexity, we improve the complexity of computing the optimal schedule in the
ideal model for aligned jobs from the currently best known
to
.
We then turn to the power allocation problem on the multi‐machine system (or
devices on the mobile networks). The limited power, dynamic status and interfeiii
rences are all serious concerns of the wireless channels. Apart from considering the
physical characteristics, another important direction is to study the selfish behaviors
of the users (e.g. transmitters). We study the online power allocation problem on the
time varying channels to maximize the global gains of the network with interference.
Besides the physical constraints, by treating each user as an individual agent (player)
in a game theoretical view, we simultaneously capture the selfish behavior of the
users. The users are allowed to cheat on their private value (power budget) to increase their own utility. We aim at maximizing the global gains of the network while
ensuring that each agent optimizes its own utility by reporting its true power budget
(admits truthful mechanism). Let the channel quality of all users be varying over
time in range
and it equals 0 when that user is not allowed to transmit any
data in that time. We derive a general lower bound
‐competitive for any
randomized algorithm using Yao’s minimax principle. We further propose a randomized online algorithm which not only admits truthful mechanism but also is
proved
‐competitive in expectation and hence optimal with respect to the
asymptotic competitive ratio.
iv
Table of Contents
Acknowledgments..........................................................................................................ii
Abstract ........................................................................................................................ iii
Table of Contents ........................................................................................................... v
List of Figures ..............................................................................................................vii
1
2
Introduction ............................................................................................................. 8
1.1
Related work ........................................................................................... 11
1.2
Our contributions .................................................................................... 14
1.3
Organizations .......................................................................................... 15
Power optimization on a device: dynamic voltage scaling ................................... 16
2.1
Model and Notation ................................................................................ 16
2.2
Optimal schedules for job set with common arrival time ....................... 17
2.3
Optimal schedules for aligned jobs ......................................................... 28
2.3.1
Ideal model....................................................................................... 28
2.3.2
Accelerate Model ............................................................................. 35
2.3.3
Basic properties ................................................................................ 36
2.3.4
2.4
3
time algorithm to compute
........................................ 38
Conclusion .............................................................................................. 56
Power allocation on a system: truthfulness and competitiveness ......................... 58
3.1
3.2
3.3
Preliminaries ........................................................................................... 58
3.1.1
The model ........................................................................................ 58
3.1.2
Mechanism Design........................................................................... 59
3.1.3
Online Mechanism Design ............................................................... 60
A Randomized Online Mechanism ......................................................... 61
3.2.1
Fixed Channel Gain model (FCG) ................................................... 61
3.2.2
Randomized Allocation for General Model ..................................... 63
is Truthful in Expectation ............................................................. 64
v
4
3.4
General Lower Bound ............................................................................. 69
3.5
Performance Analysis Of
3.5.1
Analysis of
3.5.2
Extend to
........................................................... 72
in fixed channel model ................................ 72
in General Model .............................................. 91
Conclusion ............................................................................................................ 93
4.1
Our contribution and innovations ........................................................... 93
4.2
Future work ............................................................................................. 94
List of Papers Published during PhD Study ................................................................. 95
References .................................................................................................................... 96
vi
List of Figures
Figure 1 : The transformation when
Figure 2 : Removing
. .................................................. 19
............................................................................. 19
Figure 3 : Postpone procedure. ............................................................................ 23
Figure 4 : An example that shows the choice of blocks. ...................................... 25
Figure 5 : An example that shows the GDP
and GUP
for job set
. ........ 31
Figure 6. Virtual canyon....................................................................................... 36
Figure 7 : Possible cases of the separation‐time. .............................................. 41
Figure 8 : An example that shows schedule
in monotone‐interval
.45
Figure 9. An example for Algorithm 4: ................................................................ 46
Figure 10 : The schedule
restricted in the interval between two local‐
peaks. ........................................................................................................... 52
vii
1
Introduction
In recent years, tremendous growth of portable electronic devices is seen due to
advances in processor, memory and communication technologies. The number of
mobile users (devices) reaches 5 billion in year 2010. Due to the great number of
devices and the fact that all the devices are equipped with limited battery (power),
designing algorithms to save the energy usage on a single device or properly utilize the power to maximize
the date throughput of the mobile system receives many
concerns. We theoretically study several scheduling/allocation problems to optimize the power usage on a device and the system.
We provide a thorough study on approximation algorithms (or exact) to compute
the (optimal) power allocation on a single device and online algorithms with optimal
competitive ratio to maximize the throughput on a mobile system.
Energy-efficiency has become the first-class design constraint besides the traditional time and space requirements. Portable devices (like laptops and mobiles)
equipped with capacity limited batteries are popular in our daily life. Two facts
make the energy problem more important. First, the battery capacity is increasing
with a rate less than that of power consumption of the processors. Second, the accumulated heat due to energy consumption will reach a thermal wall and challenge
the designers of electronic devices. For a single device, since such the devices are
often powered by batteries, energy‐efficient execution of jobs to prolong battery
lifetime becomes quite important. For the mobile network, the limited power of devices challenges the maximization of the data throughput of the whole system.
Power optimization on a single device:
Currently, processors capable of operating at a range of voltages and frequencies
are already available (e.g. Intel’s SpeedStep technology and AMD’s PowerNow
technology). The capability of the processor to adjust voltages is often referred to in
the literature as DVS (Dynamic Voltage Scaling) techniques. Since energy consump8
tion is at least a quadratic function of the supply voltage (hence CPU speed), it saves
energy to run the processor at the lowest possible constant speed while still meeting
all the timing constraints, rather than running at full speed and then switching to idle.
Approximately, the speed is a cubic root of the power, which is known as cube‐
root‐rule. Dynamic voltage scaling technique is widely adopted by modern processor manufacturers, e.g., Intel, AMD, and IBM. The first theoretical study was initiated decades ago by Yao et al. [43], where they made the standard generalization,
a speed to power function
. Usually,
is 2 or 3 according to the
cube‐root‐rule of the processors. From then on, lots of studies are triggered in
this field. It is usually formulated as a dual objective problem. That is, while conserving the energy, it also needs to satisfy some QoS metric. When all jobs are required to be completed before deadlines, the metric is called deadline feasibility.
There are also works trying to simultaneously minimize the response time of the
jobs, namely, flow. Each job has a release time
, deadline
and workload
.
The energy consumption is the integration of power function over all time . The
goal is to minimize the energy usage while satisfying all the timing constraints of
jobs. A schedule consists of the speed scaling policy to determine what speed to run
at time
and the job selection policy to decide which job to run at that time. This
model is referred to as ideal model in the literature. [43] gave a polynomial time algorithm to compute the minimum‐energy schedule (MES). Several online heuristics were also considered including the Average Rate Heuristic (AVR) and Optimal
Available Heuristic (OPA).
If the processor can run at arbitrary speeds, then based on how fast the voltage
can be changed, there are different models.
Ideal Model: It is assumed that the voltage/speed of the processor can be
changed to any other value without any extra/physical cost or delay. This model
provides an ideal fundamental benchmark and has been widely studied.
Accelerate Model: It is assumed that the voltage/speed change has some delay.
In practice, the processor’s acceleration capacity is limited. For example, in the low
power ARM microprocessor system (lpARM) [15], the clock frequency transition
9
takes approximately
(1350 cycles) from 10MHz to 100MHz. Equation (EQ1)
in [15] pointed out that the delay for transition from one voltage to another voltage
is proportional to the difference of these two voltages. Within this scope, there are
two variations. In the optimistic model, the processor can execute jobs during the
speed transition time, while in the pessimistic model, the execution of jobs in the
transition time is not allowed [45]. In this work, we consider processors with
DC‐DC converter having efficiency 1. In other words, we assume the transition do
not consume energy according to Equation (EQ2) in [15]. For the accelerate model,
there are little theoretical studies to the best of our knowledge, except that the single
task problem was studied by Hong et al. in [24] and Lin et al. in [45]. In [24], they
showed that the speed function that minimizes the energy is of some restricted
shapes even when considering a single task. They also gave some empirical studies
based on several real‐life applications. In [45], the authors studied both the optimistic model and pessimistic model, but still for the single task problem. They
showed that to reduce the energy, the speed function should accelerate as fast as
possible.
Power allocation on a mobile system:
We then study the power allocation problem raised on the mobile system (multi
‐machine system) instead of a single device. The problems on mobile system are
essentially different from that of the single device or traditional wired channels because of its inherent nature, such as limited power, dynamic status and interferences.
The transmitters (e.g. mobiles) are usually equipped with limited battery which
cannot be recharged anytime. The quality of the channel between the transmitter and
receiver may be varying over time. Furthermore, the transmitter’s gain rate depends
not only on its own state/parameter but also on other users’ states. Another important
direction that gains much attention is to study the selfish behaviors of the users (e.g.
transmitters). In this work, we study the power allocation problem on the time varying channels to maximize the global gains of the network with interference. Moreover, besides the physical constraints, we simultaneously capture the selfish behavior
10
of the transmitters. By treating each transmitter as an individual agent (player), in a
game‐theoretical view, we aim at maximizing the global gains of the network
while ensuring that each agent optimizes its own utility. The global optimization
problem, which is referred to as Dynamic Channel Gain (DCG) model in this work,
can be formulated as follows. There are
transmitters
transmit to a base station over a common bandwidth of
budget for the transmitter
(limited power) is denoted as
is discredited into T different time slots. Denoted by
who
hertz. The initial power
. The continuous time
(quantized version) the
channel gain coefficient of the transmitter
at time slot . The transmitter
should adapt/allocate its transmission power
according to its own channel state
and its remaining power budget. The global objective of the system is to cooperatively maximize the total data transmission rate (sum‐rate maximization) of all
users, subject to the power budget constraints,
(1)
Besides the global objective, we simultaneously formulate the local behavior of
the users. Adopting the schema of mechanism design in the algorithmic game theory
[1], each user is treated as an individual agent, which wants to optimize its own utility
. In this work, we consider the interests of users to minimize their own work-
load. A user could increase its own utility by cheating on its initial power budget (a
parameter only known by the user itself). The problem is thus to motivate the users
to tell their true power budgets (true‐telling should be a dominant strategy) while
maximize the global gain of the network.
1.1 Related work
Dynamic voltage scaling: In recent years, there are many works on the impact of
11
DVS technology. For the ideal model, Yao et al. first studied the energy‐efficient
job scheduling to achieve deadline feasibility in their seminal paper [43]. They proposed an
time algorithm YDS to compute the optimal off‐line schedule.
They showed that AVR has a competitive ratio of
for all job sets, thus its
energy consumption is at most a constant times the minimum required. Later on, the
running time is improved to
by Li et al. [36]. Another metric, the re-
sponse time/flow, was examined by Pruhs et al. in [38] with bounded energy consumption. It is first formulated as a linear single objective (energy+flow) optimization problem by Albers et al. in [2] . This was then specifically studied in
[14],[33],[20,[9],[10] under different assumptions. Chan et al. [21] investigated the
model where the maximum speed is bounded. They proposed an online algorithm
which is
‐competitive in both energy consumption and throughput. More
works on the speed bounded model can be found in [9][23][34]. Ishihara and Yasuura [28] 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 [30] 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 algorithm for this problem based on the MES algorithm in
[43]. Later, [35] improved the computation time to
where
is the
number of supported voltages. A survey on algorithmic problems in power management for DVS can be found in [29][48].
Later on, under various related models and assumptions, more algorithms for
energy‐efficient scheduling have been proposed. Bansal et.al. [11] further investigated the online heuristics for the model proposed by [43] and proved that the heuristic OPA has a tight competitive ratio of
for all job sets. When the CPU can
only change speed gradually instead of instantly, [24] discussed about some special
cases that can be solved optimally in polynomial time. Aside from the above DVS
models, there are also other extensions. For example, Gaujal and Navet [49] studied
online deadline scheduling with constant delay in speed change. Irani et.al. [27] in12
vestigated 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. They gave an offline algorithm that
achieves 2‐approximation and online algorithms with constant competitive ratios.
Irani and Pruhs [29] gave a survey on algorithmic problems in power management
for DVS. More works on various aspects of DVS scheduling can be found in
[2][7][37].
Dynamic power allocation: For the power allocation problem on channels, the offline version of our global objective (sum‐rate maximization) is quite similar to the
well studied problem of assigning transmission powers to orthogonal frequency
bands (whereby users share a common spectrum and can interfere with each other)
to maximize the overall data throughput in a multi‐user network (see [26] and the
references therein). The game theoretical concepts are also adopted to such a spectrum management problem whereby users maximize their individual rates in a distributed manner ([47][41][19][32][40][39]). For the online version of the power allocation problem, Buchbinder et. al. [17] studied the single transmitter case using
competitive analysis [16]. They propose a deterministic online algorithm that can be
‐ competitive where
proved to be
channel gain and
is the maximum value of the
is the minimum one. Their algorithm is in fact optimal since
‐competitive for any deterministic
they further show a lower bound of
algorithm. The multi‐user case is later studied in [18], where they provided a randomized
‐competitive (in expectation) algorithm. Note that the
‐competitive lower bound by [17] for any deterministic algorithm still holds for the
multi‐user case. But there is still a gap between the upper bound and lower bound
for randomized algorithms, i.e. we do not know whether randomization can help in
closing such a gap.
13
1.2 Our contributions
Dynamic voltage scaling: We first study the pessimistic accelerate model to minimize the energy consumption. The QoS metric is deadline feasibility. The input is
an aligned job set
with
jobs, where jobs with earlier arrival times have earlier
deadlines. The processor can execute a job with arbitrary speed but the absolute acceleration rate is at most
, and the processor has no capability to execute jobs
during the transition of voltage. The objective is to find a min‐energy schedule that
finishes all jobs before their deadlines. We first consider a special case of aligned
jobs where all the jobs arrive at time 0. We call this kind of job set common arrival
time instance. We prove that the optimal schedule should decelerate as fast as possible and the speed curve is non‐increasing. Combining with other properties we
observe, we construct an
time algorithm to compute the optimal schedule.
Then we turn to the general aligned jobs to study the optimal schedule
. The
algorithm for the common arrival time instance is adopted as an elementary procedure to compute
. Most of the properties for the common arrival time in-
stance can be extended to general aligned jobs. By comparing
timal schedule
and
of
with the op-
in the ideal model, we first prove that the speed curves of
match during some “peak"s. Then we show that the speed curve
between adjacent “peak"s can be computed directly. The whole computa-
tion takes
time since we improve the computation of
(optimal solu-
tion of the ideal model) for aligned jobs from currently best known
to
. Our work makes a further step in the theoretical study of accelerate model
and may shed some light on solving the problem for the general job set.
Dynamic power allocation: For the power allocation problem on multi‐user system (mobile system) instead of individual machine, our results are as follows. One
contribution of this work is to answer the question above by showing that the randomized algorithm in [18] for multi‐user case is also optimal. We derive a match14
ing lower bound of
‐competitive for any randomized algorithm. However,
with respect to the individual behavior, the algorithm in [18] cannot be directly extended to admit a truthful mechanism (an example is illustrated in Section 3.3). We
adopt their idea and propose a new randomized algorithm (by allocating the time
slots randomly) with provable optimal competitive ratio. Our algorithm not only
admits a truthful mechanism (each users optimizes its own expected utilities by reporting the true power budget) but also has
‐competitive ratio in expecta-
tion with respect to the global sum‐rate maximization objective.
1.3 Organizations
The organization of this work is as follows. We study the speed scaling problems in Section 2. We then turn to the power allocation problem in a mobile system
instead of a single device in Section 3. Section 4 concludes our work. The details of
the structure for each section are presented below.
We review the ideal model and the pessimistic accelerate model in Section 2.1.
In Section 2.2, we study the pessimistic accelerate model and focus on a special but
significant case where all jobs are released at the beginning. We then turn to the
general aligned jobs that have arbitrary arrival time in Section 2.3. Finally we conclude the work in Section 2.4.
In Section 3.1, we formulate power allocation model in the mobile system and
introduce the truthful online mechanism design in game theory. In Section 3.2, we
describe our randomized online algorithm. The truthfulness of the algorithm is verified in Section 3.3. Section 3.4 provides the general lower bound for any randomized algorithm. Section 3.5 analyzes the performance of our randomized algorithm
and shows its optimal competitiveness. Section 3.6 is the concluding remarks.
15
2 Power optimization on a device: dynamic voltage scaling
2.1 Model and Notation
In this section, we review the ideal model proposed in [43] and the pessimistic
accelerate model.
The input job instance we consider in this work is an aligned job set
where each job
(abbreviated as
and
has an arrival time
, a deadline
respectively), and the amount of workload
arrival times and the deadlines follow the same order, i.e.,
. The
and
.
In the ideal model, the processor can change its speed to any value instantaneously without any delay. The power function is assumed to be
.
A schedule
needs to determine what speed and which job to execute at time .
We use
to denote the speed took by schedule
for short if the context is clear. We use
at time
and write it as
to represent the index of the job
being executed at time . Jobs are preemptive. The processor has the capability to
resume the formerly suspended jobs. We take the deadline feasibility as the QoS
metric, i.e., a job is available after its arrival time and need to be completed before
its
deadline.
A
feasible
schedule
must
, where
satisfy
if
the
and
The energy consumption is the power integrated over time:
timing
constraint
otherwise.
.
The objective is to minimize the total energy consumption while satisfying the deadline feasibility.
In the pessimistic accelerate model, the processor cannot change the voltage instantaneously. The acceleration rate is at most
, i.e., the first derivative of speed
function satisfies
. Moreover, no jobs can be executed during the transi-
tion interval with
and there is always some job being executed when
16
and
. The energy is the power integrated over the time where
and
, thus
. With such constraints, a
feasible schedule is a schedule where all jobs are completed before deadlines and the
. In a feasible schedule
speed function satisfies
al interval where the jobs run at the same speed as a
, we denote the maxim. Note that there is an ac-
celeration interval (the time used for acceleration) between adjacent blocks because
changing the speeds needs some time, during which no workload is executed. The
optimal schedule is the one with the minimum energy consumption among all feasible schedules.
Let
schedule
say
and
. The workload executed in interval
is denoted as
. If a job
is embedded in interval
by
has
, we
. For simplicity, when we say “the first" time
(or interval), we mean the earliest time (or interval) on the time axis in left‐to‐
right order. Using the similar definition as [35], we say
tight arrival time respectively) in schedule
if
is the deadline (or arrival time
respectively) of the job that is executed at
in
where
time at least
. Let
(or
respectively)
denote the workload of the jobs that have arrival
and have deadline at most
fine the intensity
is a tight deadline (or
, i.e.
of the time interval
. Deto be
.
2.2 Optimal schedules for job set with common arrival time
For the jobs that have common arrival time, we assume w.l.o.g they are available at the beginning, namely
for
. In the following, we will derive a
series of properties of the optimal schedule which help us design a polynomial algorithm to compute the optimal schedule. The intuition behind the proofs is shown below. Comparing with the optimal schedule for the ideal model, when the speed decelerates from a faster speed to a slower speed, some time will be lost in the accelerate model. The optimal solution is composed of blocks and the speed is non‐
17
increasing (The speed between every two blocks is decreasing). To find all the
blocks, we search some “tight" points where the deceleration should begin at this
point of time, because at least one job’s deadline would be missed if the deceleration
was delayed further. There are at most
blocks to be computed which finally gives
time algorithm.
an
We assume that “optimal schedule" mentioned in a lemma satisfies all the previous lemmas in the same section. We abuse the notation between closed interval
and open interval
Lemma 1.
if the context is clear.
Given a feasible schedule
terval
with speed function
is all for acceleration purpose (i.e.
and
. Then the schedule
Proof:
ning
shift
)
left by
defined be-
time, is feasible and con-
.
First, we show that
is a feasible schedule. In
and before deadline
finished after
for
with speed function
low, which shifts the workload
sumes the same energy as
, assume that in-
,
. Since
, suppose that job
is available at the begin-
and no work is executed in
’s execution interval left by
is
, when we
time, the resulting schedule is still feasible.
Similarly by shifting interval
left by
, the resulting schedule
is
feasible. Moreover, after the execution is shifted, there is no workload being ex, thus the energy consumed in
ecuted after
since the speed profile to execute the workload
has the same energy consumption as
Lemma 2.
is zero. Finally,
does not change,
. The lemma is then proved.
□
In the optimal schedule, the speed function will accelerate as fast as
possible, i.e., either
or
.
18
Figure 1 : The transformation when
Proof:
.
We only need to remove the possibility of
Figure 1, when
. As shown in
, we prove that another schedule which accelerates as
fast as possible will cost less or equal energy. Suppose that
leration interval where
in interval
is the first acce-
, we can set the acceleration rate as
. Since the target speed is not changed, this obviously implies
. Then no matter what the speed function in
is, it can be shifted left by
time. This transformation will remove the acceleration rate
in
and ensure that the resulting schedule incurs no more energy by Lemma 1.
Similarly we can handle the case
. By repeatedly applying this
transformation, we can ensure
or
in
for the optimal
schedule. □
Lemma 3.
In the optimal schedule, the speed function
Figure 2 : Removing
Proof:
It suffices to remove the possibility
some intervals with
.
. If on the contrary there are
, suppose that the first interval with
as shown in Figure 2. Assume that
, i.e.
is non‐increasing.
is the nearest time after
. Let the speed in block
19
is
be
where
. Note that
the speed before
is non‐increasing. We can further suppose that the speed in
’s adjacent block
is
where
. We will show that there exists an-
with less energy. The method is to merge
other feasible schedule
with
and previous adjacent blocks if necessary into a new block
in
and let
. The merging process guarantees that the new block executes
the same amount of workload as the participating merging blocks. The merging
process goes from right to left and stops when the last unmerged block before
has a higher speed than the speed of the new block. Suppose that the new speed in
is
, we first show that the energy in
cases
and
, where
, then the workload
speed) in
is the speed in the start time
. First, if
is done in a single block
(a unique
. Note that such a new schedule is feasible (because jobs are finished
earlier in the new schedule) and the speed in
according to the convexity of
if
is non‐increasing. Moreover,
, the new schedule consumes less energy. Second,
, then the workload
in
is decreased by discussing two
is done with a unique speed in block
which also leads to a better schedule.
to
Notice that we have postponed the first interval where
Then we discuss the following two cases:
for
for
.
and
.
If
for
, the first interval where
celeration interval
in
and we can apply the analysis again to gradually postpone
the first interval
until the time
less energy where
. This finally results in a schedule with
only exists in some rightmost interval
need not accelerate because there is no workload after
moved the possibility
If
. Note that
. Thus we have re-
.
for
, let
is the ac-
, two subcases should be considered. If
be the symmetric time point of
(Figure 2(b)). Note that
by vertical line
. We can then shift the speed function
20
in
left by
time. This removes the possibility
in
. Then
we can recursively handle the first interval with
in
. If
, let
be the symmetric time point of
(Figure 2(c)). We then shift the speed function
Then
by vertical line
in
will be the first interval where
left by
. Hence, by applying the
analysis again we can gradually postpone the first interval with
rightmost interval
. Since there is no workload after
to the
, we can remove the
. This finishes the proof. □
final acceleration interval
Lemma 4.
time.
There exists an optimal schedule where the jobs are completed in EDF
(Earliest Deadline First) order.
Proof:
Suppose that
is the first job which violates the EDF order, which
. Notice
means all jobs are finished in the order
that jobs between
and
in
have deadlines larger than
show that executing jobs in the order
obtained from
by swapping
. We will
, which is
and
, and using the same speed func-
tion is still a feasible schedule. Obviously, jobs
can be finished before
deadlines. Moreover, since the speed function does not change, the completion time
of job
in
is the same as that of job
nished at a time not later than
tween
in
and
(
in
. That is,
). Furthermore, in
is fi, jobs be-
are finished before deadline because they are finished before
. Thus the new schedule is feasible and the energy remains the same.
Then by applying the similar adjustment gradually, we can obtain an optimal schedule with the completion time in EDF order.
Lemma 5. In the optimal schedule
□
, job
is executed in one speed
.
Proof: This lemma is a special case of Lemma 15 and therefore we postpone the
proof to Lemma 15. □
21
Fact 1.
jobs sorted by deadlines, suppose that job ’s workload is
Given
and it is originally executed for
1 is executed for
time with
). If in another schedule, job
time and jobs
time where
are respectively executed for
and the speeds satisfy
where
, then we have
.
Proof.
We remark that
can be non‐integer. Define
. It is suffi-
cient to prove
divided into
sume that
parts
. The workload
can be
where
. As-
. Let
is executed for
and
time where
. Note that
. We examine the difference
The second equality holds because
.
and
. The third
and
equality holds because
,
for all
.
Now
it
suffices
for
us
to
prove
the
following
inequality
. To show this, we will
prove that
. Define
It is sufficient to show
when
.
22
.
which will imply
We have
for all real
because
when
. Since
, we only need to show
increases as
. By
increases
, we have
because
.
This finishes the proof. □
Lemma 6. There exists an optimal schedule
, where the finishing time
of
) is a tight deadline.
each block (where
Figure 3 : Postpone procedure.
Proof.
Suppose on the contrary that
’s completion time
is the first such time
point which is not a tight deadline. Then for all the blocks that are before
their completion times are tight deadlines. We assume that
of the nearest block before
We prove that the jobs in
,
is the completion time
. If such a time point does not exist, we set
.
can be done with lower speed and longer length
which leads to less energy. We start with the simplest case. As shown in Figure 3(a),
in the new schedule
completion time of
with speed function
that is drawn in dashed line, the
is postponed to its deadline
Meanwhile, we ensure that the blocks after
23
(postponed by
time).
will keep their completion time un-
changed. To achieve this, jobs
compared with that in
miss deadlines in
. We first consider the case that
is feasible, i.e. no jobs
. Notice that with such an assumption, the speed allocation in
is unique after
speed
will be done in slightly larger speed
’s completion time is postponed to its deadline (because the
can be determined). We will prove that such a schedule consumes less
energy by using Fact 1. Suppose that the blocks after
in
workload
and the executed workloads are
is executed by
and
(
respectively while
) time in
obviously hold where
, the length of time executing
load
length of executing
than
have execution time
by
and
. Then the conditions
and
in
denote the work-
, and the difference of the
, respectively. The energy used by
by
is less
. Thus it remains to prove that
.
To see this, consider the time
and
. We have
, which is the first intersection between
. Note that at the final time
In the interval
,
, the speed
.
uses more time for speed transition than
as
. Thus the length for executing jobs (the length of intervals with
in
) in
is larger than that of
. Furthermore, the difference be. Hence we have
tween these two lengths is exactly
.
Now we consider the general case, where some jobs miss deadlines if
is
postponed to its deadline as we do above. Notice that our transformation in Figure
3(a) also makes sense when we only postpone the execution of
amount of time less than
time less than
. Thus we first postpone the execution of
which exactly makes a job
If
, let
by a
finish exactly at its deadline
and guarantee all the other jobs finished by their deadlines. If
schedule before
by any small
, we fix the
, and keep on dealing with the speed curve in
.
, we take another transformation as shown in Figure 3 (b). Note that we as-
sign an acceleration interval immediately after time
24
. Such a transformation also
ensures a better schedule where the proof is quite similar to the simplest case. Then
we first deal with the curve in
fixed speed
speed
at
to make it satisfy the lemma (also arriving at a
), and then deal with the curve in
with starting
to make it satisfy the lemma.
Thus step by step, we can ensure that
is exactly one job’s deadline and com-
pletion time, namely tight deadline, in the optimal schedule. □
Theorem 1.
In the optimal schedule,
1) The first block is the interval
and
which maximizes
where
, i.e. the maximum speed in the optimal sche-
dule is
.
2) Suppose that block
speed in block
is
where
.
has speed
and finishes at
’s deadline, then the
Figure 4 : An example that shows the choice of blocks.
Proof.
Figure 4 shows an example. We first prove 1). According to Lemma 6, the finish
time of the optimal schedule’s block is one job’s deadline. Thus for the first block in
the optimal schedule, if the finish time is
is
where
’s deadline, then the speed of this block
according to the EDF schedule in Lemma 4.
25
We prove that the first block of the optimal schedule achieves the maximum possible
value
where
. Let
. We suppose on
the contrary that the first block finishes at
. If
’s deadline where
, since the speed curve of the optimal schedule is
non‐increasing by Lemma 3, the total workload finished before
and hence less than
will
with a total workload
should be finished before
ty of the optimal schedule. If
will be at most
. Therefore some jobs in
miss deadlines because all jobs in
less than
. Note that
. This is a contradiction to the feasibili-
, the total workload finished before
is also
, again a contradiction.
We prove 2) by induction. Assume as the induction hypothesis that the
block of the optimal schedule has speed
and finishes at job
. We will prove that the speed of the
’s deadline where
block in the optimal sche-
dule achieves the maximum value
where
. Since there is a transition interval with
after block ’s finish time
, if block
speed
of
block
finishes at
’s deadline, then the
satisfies
by
where
Lemma
6.
Assume
that
. Suppose on the contrary
that the
block of the optimal schedule finishes at
.
’s deadline where
Write
and
. We have
. If
,
since the speed curve of the optimal schedule is non‐increasing (Lemma 3), the
total workload finished between
will be at most
which is less than
. Thus some jobs in
26
will miss
deadlines by a similar analysis with the proof of 1). Therefore, it contradicts the feasibility of the optimal schedule. If
, the total workload finished between
is also less than
which again leads to a contradic-
tion. Therefore, the
Theorem 2.
block must finish at
. This finishes the proof. □
The optimal schedule can be computed by Algorithm 1 in
.
Proof.
Algorithm 1 is a direct implementation of Theorem 1.. Steps 2‐4 compute the
first block. The two loops in Steps 6‐10 compute the remaining blocks. By keeping
the information of the summation on the computed jobs, the optimal schedule can be
computed in
□
time.
Algorithm 1. CRT_schedule
;
1.
2.
;
;
3.
be
4. Let the block with speed
;
;
5.
While
do{
;
6.
7.
;
8. Let the block with speed
;
9.
10.
be
;
}
27
;
2.3 Optimal schedules for aligned jobs
2.3.1
Ideal model
In the ideal model, the acceleration rate is infinity
rithm YDS in [43] to compute
. We review the Algo-
as shown in Algorithm 2. The algorithm tries
every possible pair of arrival time and deadline to find an interval with largest intensity (called critical interval), schedule the jobs embedded in the critical interval and
then repeatedly deal with the remaining jobs. Their algorithm has a complexity
, which was then proved to
in [36].
Algorithm 2. YDS Schedule for the Ideal Model
The algorithm repeats the following steps until all jobs are scheduled:
(1) Let
be the maximum intensity time interval.
(2) The processor will run at speed
schedule all the jobs with
during
in EDF order.
(3) Then the instance is modified as if the time in
ist.
That
is,
all
and
deadlines
are
, and all arrival times
did not exchanged
to
are changed to
.
We first show that the optimal schedule for aligned jobs in the ideal model can
be computed in
time. The proof is based on two key observations. First, the
faster search for a critical special time (called descending‐time/ascending‐time in
this work). Second, some intervals/jobs can be independently picked out and then
iteratively handled. In the proof, we use
to denote the solution returned by
Algorithm 2.
Theorem 3.
The optimal schedule for aligned jobs in the ideal model can be com-
28
puted in
time.
Given an interval
called
average
, all the fully embedded jobs’ workload over
density
of
,
.
which
is
is
denoted
as
Let
and
. We define a special kind of time as follows.
Definition
1.
A
time
is
where
time at which
then
called
down-point
. Further, if
if
is the latest
has the highest average density among all other intervals,
is the global ‐ down ‐ point (shorted as GDP) of
, i.e.
.
We
define
to
be
descending ‐ time
a
(and
correspondingly
in
OPT
if
ascending ‐ time
if
). The following is a basic property.
Lemma 7.
If
is a descending‐time in
in
with
Proof.
, then OPT never executes jobs
.
It is proved in [35] that every descending‐time in
line (suppose that the job finished at this time is
is a tight dead-
) if the schedule follows EDF or-
der. On the other hand EDF schedule for aligned jobs generates no preemption.
cannot be executed before
Therefore, jobs with
deadlines are larger than
.
since their
□
We first derive some properties of GDP, comparing with the speed in OPT over
. Figure 5 shows an example. The height of the dashed line is the value
over the interval that is covered by the line.
Lemma
8.
If
time
is
the
GDP
29
of
,
then
and
Proof.
.
Firstly, if on the contrary
sume time
, then we as-
is the nearest descending ‐ time after
when
.
. Since
workload
, which implies
We
have
is a descending ‐ time, all the
belongs to jobs with
by Lemma 7. Thus
. We have
.
Thus
has average density at least as that of
dicts the definition of
and
is later than
, this contra-
.
Secondly, if on the contrary
is the nearest block before
, we assume
which has speed larger than
in OPT.
Such a block exists because otherwise
which
implies
. According to
the choice of
, we have
. All jobs with
should be executed in
in OPT by Lemma 7. Thus
. By the definition of GDP, every time before
average
density
at
most
.
has
Thus
. We
have
30
.
Again a contradiction. Hence, the lemma is then proved. □
Lemma 8 implies that GDP
is a descending‐time in OPT. We remark that a
normal down‐point is not necessarily a descending‐time in OPT. Since each descending time is one job’s deadline by [35], it is sufficient to compute the average
density in interval
all the
values, the GDP
for all deadlines
in order to find the GDP. Among
equals the latest deadline that achieves the maximum
density,
.
and GUP
Figure 5 : An example that shows the GDP
for job set
.
On the other hand, if we symmetrically compute the average density over
in right‐to‐left order, we could define the up ‐ point
where
have a global‐up‐point (GUP)
which has
. Similar to Lemma 8, we
of
which corresponds to an
ascending‐time in OPT. Moreover,
. The fol-
lowing property is useful for our algorithm to iteratively compute OPT.
Lemma 9.
In the optimal schedule, jobs that are executed in
31
have dead-
line at most
. Moreover, for jobs
scale the arrival time
to be
where
and
, if we re‐
, then OPT for the modified job set is the same as
OPT for the original job set.
Proof.
It is sufficient to prove that the optimal schedule
in
with
never executes jobs
. This is true by Lemma 7 since
is a descending‐time.
□
Note that this property holds symmetrically for a GUP .
Lemma 10. In the optimal schedule, jobs that are executed in
rival time at least
. Moreover, for jobs
‐scale the deadline
to be
where
have ar-
and
, if we re
, then OPT for the modified job set is the same as
OPT for the original job set.
By these observations, Algorithm 3 will pick out some sub‐intervals in which
OPT only executes jobs embedded in these sub‐intervals. In each iteration, by
computing a pair of GDP/GUP time, the original interval/job‐set is partitioned into
at most three intervals/job‐sets. Then it iteratively computes the optimal schedule
for the three subsets. The algorithm terminates when the re‐scaled job‐set has
and
. We then prove the following lemma which implies that if
and
, then it is equivalent to finding a block in OPT.
Lemma 11. For aligned job set
, if
all jobs with speed
Proof.
interval
and
, then OPT executes
.
It suffices to prove that there is no descending‐time/ascending‐time in
when
and
. We prove it by contradiction.
Suppose on the contrary that such a time exists, then we assume block
in
first (earliest) block that has speed
the nearest peak after
tween
(
can possibly be
have speed at most
. Let
is the
be
itself). First, all blocks beaccording to the choice of
. Second, we will prove that OPT has speed exactly
32
in the
interval
. We suppose on the contrary that there exists at least one block
between
with speed less than
. Then the workload
. By symmetrically applying Lem-
ma 7, all workload
belongs to jobs with
. We
have
which implies
, a contradiction.
is exactly a block with speed
Thus the interval
OPT. Then we have
in
. By Lemma 7,
all workload in
belongs to jobs with
. We have
which indicates
by the definition of GDP. In this way, we successfully obtain a contradiction and arshould be one block in
rive at the conclusion that
and
.
when
□
Now we can show that Algorithm 3 computes the optimal schedule for aligned
jobs in
time. Steps 4‐9 show the re‐scaling procedure. In both cases
(e.g. Figure 5) and
, the job set
is divided into three subsets
with adjusted arrival times and deadlines. Notice that
is not
possible because a time cannot be both a descending‐time and an ascending‐time.
By Lemma 9 and Lemma 10, the optimal schedule computed for the re‐scaled job
sets can directly combine into the optimal schedule for the original job set. Note that
for the re‐scaled jobs, the algorithm terminates when
and
.
Because this corresponds to the discovery of a block in OPT by Lemma 11.
Now we analyze the running time of Algorithm 3. Looking for GDP and GUP
33
(Step 2) in one job set needs at most
time because there are at most
as-
cending/descending times. We can organize all the job sets we deal with by a tree
reflecting the subset relation between job sets. In this way, a leaf in the tree
represents a block (the number of blocks is at most
partition is done on the leaf due to the reason
) in OPT because no further
and
. While the
number of nodes in the tree is the total number of different job sets for which we
need to find GDP and GUP. We know that the number of nodes in a tree is twice the
number of leaves in the tree minus 1. Furthermore, by Lemma 11, every job set only
needs to be dealt once. Therefore, the running time of Algorithm 3 is
34
.
Algorithm 3.
;
1.
;
2. Find a GDP
and a GUP
.
/* Compute the schedule for the minimal interval*/
If(
and
)
3. Execute all jobs with speed
in EDF order.
Else /* Otherwise, re‐scale the jobs into three subsets*/
{ If(
){
4.
where we adjust
5.
where we adjust
6.
;
;
;
}
If(
){
7.
;
8.
;
9.
where we adjust
and
;
}
}
/* Iteratively compute over the subset
10.
2.3.2
;
;
if they are not empty*/
;
Accelerate Model
In this section, we study the optimal schedule for the general aligned jobs. Note
that jobs with common arrival time is a special case of aligned jobs. We first extend
some of its basic properties in Subsection 2.3.3. We will compute the optimal schedule for aligned jobs by adopting Algorithm 1 as a building block. We use
denote the optimal schedule where
is the maximum acceleration rate.
35
to
Given
a
block
,
we
denote
the
corresponding
interval
as
. We define virtual canyon to be a block with length 0. Next, we
derive some properties of
2.3.3
.
Basic properties
Lemma 12. There is an optimal schedule where jobs are executed in EDF order.
The proof for the extension is similar as Lemma 4.
, the speed function will accelerate as
Lemma 13. In the optimal schedule
fast as possible, i.e., either
or
.
Proof.
If there exists an acceleration interval
with
as shown in
Figure 6, then we can construct a virtual canyon
between
and let the
and
be
and
respectively. If
acceleration rate in
due to this transformation, then we replace the curve below
, and enby a segment with speed 0. This can remove the possibility
sure that the schedule is feasible and the energy does not increase. □
Figure 6. Virtual canyon.
Unlike Lemma 3,
Among
all
cannot be eliminated in
the
blocks,
we
define
and
Reversely,
the
block
the
.
block
where
to be peak.
and
where
is called canyon.
We say
is down ‐ edge ‐ time if
36
or
. For example, both the start time and finish time of a
peak are down‐edge‐times. Note that for jobs with common arrival time,
is
non‐increasing, thus the finish time of a block is a down‐edge‐time. The following lemma extends Lemma 6 to consider the aligned jobs.
Lemma 14.
In the optimal schedule
, every down‐edge‐time is either a
tight deadline or a tight arrival time.
Proof.
We first show that down‐edge‐time
is a tight deadline when
. In the optimal schedule, assume block
down‐edge‐time . Suppose on the contrary that the job executed at time
the job be
) has a deadline
has a
(Let
. We will prove that the energy can be reduced
which contradicts the optimality. Note that the definition of down‐edge‐time implies the existence of a canyon which has finish time (assume to be
Then the speed function
in interval
) larger than .
is non‐increasing. This allows us to
apply the similar transformation as in the proof of Lemma 6. The method is also to
gradually postpone the completion time of
edge‐times in
, which will finally ensure all down‐
are tight deadlines (or tight arrival times symmetrically). Since
all the jobs that are executed originally after time
are now executed with larger
speed and executed later after the postpone procedure, this will not violate the timing constraint (both for arrival time and deadline). Thus in this case we can ensure
that
is a tight deadline. For the other type of down‐edge‐time, we can similarly
show that it is a tight arrival time. This finishes the proof.
Lemma 15.
In the optimal schedule
, each job
block, and this block is the lowest one in interval
Proof.
If a job
□
is executed only in one
.
is executed in several blocks, we can see that these executions
must form a continuous interval if we remove all the acceleration intervals, because
for aligned jobs no preemption will happen since the schedule follows EDF order by
37
Lemma 12.
W.l.o.g. we assume that
,
executes
in two adjacent blocks
is a down ‐ edge ‐ time (in this case
, and
). This contradicts
Lemma 14 because at time
,
. Thus every job
speed less than
and there is another block
and
.
is not executed in the lowest block over-
. Without loss of generality, we can assume that
with speed
with
can only be executed in one block in
Moreover, assume that on the contrary
lapping
executes job
is executed in
on the right of
with
. Then there exists a down‐edge‐time
in the interval
which is a tight deadline or equivalently a job’s
deadline and completion time (Let this job be
tion because
; if
deadline before
, then
). If
, then it is a contradic-
is executed after
. According to Lemma 12,
but has a
should be executed before
since the input job set is an aligned job set, a contradiction. □
2.3.4
time algorithm to compute
To find the optimal schedule, our method is to identify some special blocks belonging to
. After enough blocks are selected, the remaining interval of
can be easily computed. To be more specific, we compare
, which is the optimal schedule for the special case
schedule
with
, namely
the ideal model. We observe that the block with the highest speed (we call it global
‐peak) of
Lemma 16.
Proof:
Then in
can be computed first.
executes the same as
Suppose that
in the first critical interval.
is the first critical interval computed by Algorithm 2.
, all jobs with
are executed in speed
this lemma by investigating two properties of
38
.
. We prove
The first property is: in
than
. For any job,
Lemma 15. Let
runs it in a unique block (speed) according to
be the job with the largest speed
and it belongs to block
contrary that
‐times of
, no jobs need to be executed with speed larger
in
. We suppose on the
. Because the two down‐edge
are exactly a tight deadline and a tight arrival time, the interval of
will have a larger intensity than
because the job set under investigation
is an aligned job set, a contradiction. Thus the first property is true.
The second property is: for any job with
speed
,
cannot run it with
. According to Algorithm 2, the first critical interval
all (and only) jobs with
execute
. Note that when all the jobs with
run in EDF order and with speed
, the workload
are finished exactly
at . If any one of these jobs runs with a lower speed than
in
, then
to ensure that the remaining workload satisfies the timing constraint, some jobs must
have a speed
. This contradicts the first property above.
The combination of the two properties indicates that
with
of
at speed exactly
in interval
runs all/only jobs
. This is the same as that
. Therefore, the lemma is true. □
After we have fixed the first block (global‐peak) of
, a natural question
is whether we can apply the same proof of Lemma 16 to select other blocks. For
example, in the remaining interval of
, does the block with maximum inten-
sity have the same schedule as that of
show that some other blocks in
? Although this is not true, we will
can be proved to be the same as
. The
key observation is that by appropriately dividing the whole interval into two sub‐
intervals, the block with the maximum intensity inside one of the sub‐intervals in
can be proved to be the same as
. Our partition of intervals is based
on a monotone‐interval defined below.
Definition 2. Given a schedule, we define the sub‐interval where the speed func39
tion/curve is strictly non‐increasing or non‐decreasing to be a monotone ‐
interval.
Here and in the following, by “strictly non‐increasing" we mean non‐
increasing but not constant; similarly by “strictly non‐decreasing" we mean non
‐decreasing but not constant. Since the speed in
is at most
outside the global‐peak
, there exists a monotone‐interval immediately after time
(non‐increasing curve) and symmetrically before time
At time
and
, the speeds are respectively
In the following, we will study a schedule
)
and
.
(non ‐ increasing
). Suppose that
two curves
and
(only specifying speeds in interval
monotone ‐ interval
with
(non‐decreasing curve).
speed
with
is the first (earliest) intersection of the
with
. Figure 8 shows
an example. We will compare the speed curve of
with that of
based
is a separation‐time of
w.r.t
on the definition below.
Definition 3.
In interval
, we say
if their speed curves totally overlap in interval
where
Fact 2.
and separate at
.
If there exists a schedule
lowest block in
z
1).
z
2). Block
z
3).
be
(let the lowest/latest block and the second
and
) satisfying the following properties,
.
executes all jobs with
restricted
to
.
is
feasible
for
all
jobs
with
and only executes these jobs. The down‐edge‐times in
40
are tight deadlines.
Then, let
be the separation‐time of
z
a)
z
b) the speed curve of
z
c)
w.r.t
and
, we have
.
in interval
is strictly non‐decreasing.
executes all jobs with
before time
and time
is a down‐ edge‐time with
.
executes a job
Furthermore,
with
at time
.
Proof.
Figure 7 : Possible cases of the separation‐time.
As shown in Figure 7, suppose that
has blocks
in
left‐to‐right order. We first remove the possibility that
nearest peak after
in
. We can see that if
a speed curve strictly non‐increasing in
. Let
, then
be the
cannot have
because otherwise some job will
miss deadline. Therefore, there exists a canyon (or virtual canyon) after
, and we assume that
. In this case,
which contradicts “
removed the possibility
in
is the first block after this canyon. We have
executes the workload
is a tight arrival time in
later than that in
". Till now, we have
.
Now we prove the second part of property a). First,
41
has a monotone‐
interval (non‐increasing) after time , from the analysis above, we know that the
separation‐time of
w.r.t
satisfies
. We then discuss case by
, we have
case. If
of separation‐time. If
by the definition
, obviously
. For the
, we suppose on the con-
remaining case that
trary that
. We assume that the block containing
Note that the workload
because
need to be finished before time
is
.
in
,
is a tight deadline according to condition 3). This implies that
cannot be strictly non‐increasing in
because otherwise some jobs will miss
deadlines. Thus we assume
to be the first canyon after
to be the nearest block after
. Note that
and a tight arrival time. However,
restricted to
. Thus
and block
should be a down‐edge‐time
executes
later than that in
cannot be a tight arrival time due to condition 3),
a contradiction.
For property b), since
or
by property a). Suppose on the contrary that there exists a
with speed
block (let it be
, then
and
) such that
and
decreasing in
If
is a separation‐time, we have
is strictly non‐
. Two subcases should be discussed.
is a down‐edge‐time and hence also a tight deadline according
to Lemma 14. However, we note that the speed of the block
in
larger than the speed of all the blocks between
. Therefore,
is finished earlier in
ecuted in
. By condition 3), time
dicts Lemma 14. If
, then
in
is
than the corresponding workload excannot be a tight deadline which contra-
is a tight arrival time and
42
is a tight deadline
by Lemma 14.
belongs to the jobs with
has speed smaller than that in
the timing constraints in
in
in interval
decreasing in
. Furthermore,
is strictly non‐
. We now prove property c). The above analysis shows that the
in
is the canyon with speed
since
contains separation‐time . Assume that
. Suppose that
has speed
at block
. We can further remove the possibility
otherwise
(assume to be
must have a speed curve that coincides
where
nearest canyon after
that
. Thus some jobs will violate
which contradicts condition 3).
The above analysis shows that
with
. However,
and
) in
is executed later
and this contradicts that
We will discuss the two cases that
First, if
is a tight arrival time.
and
, then there exists a block
and
is after the canyon
is doing workload faster than
be
in
. We have
jobs with
with
in
, then
but they are doing the same
is a down‐edge‐time. Let the
. Interval
cannot execute the
. However, the workload
and with larger speed in
dition 3)), time
.
(Otherwise
amount of workload, a contradiction). Thus
speed in
. Because
. There exists a tight arrival time
) immediately after . The workload
(starting from time
. Note
than that in
is executed later
. By the feasibility of
(con-
cannot be a tight arrival time, which is a contradiction. Second, if
, we can remove the possibility of
cause otherwise there exists a block
. Be-
immediately after
where
is a
tight arrival time. However, this is impossible since all jobs with
is
executed after
is
and thus one of the jobs with
43
or
the first job executed in
dicts the fact that
in
(ties can be arbitrarily broken). This contra-
is a tight arrival time. Thus the only case that remains is
. Note that
is a down‐edge‐time in
cannot be ex-
this case and should be a tight arrival time. Thus jobs with
ecuted at
in
. In other words,
at time
can only execute the job with
. Therefore, all jobs with
because
are executed before
executes the jobs in EDF order. This finishes the proof of prop-
□
erty c).
satisfying the three conditions in Fact 2,
Fact 3.
If there exists a schedule
let
be the maximum intensity block in
, then
Proof.
among the remaining interval
has the same schedule as
in interval
.
into two sub‐intervals
has divided the interval
and
. By properties b) and c) in Fact 2, the speed curve of
in interval
(
) is strictly non‐decreasing, where is the separation‐time of
w.r.t
. Moreover,
is a down‐edge‐time and
in
job with
executes the
and all jobs with
in
.
, there exists at least one peak
Since
among the interval
in
. W.l.o.g we assume peak
to be
the interval with maximum speed among
in
. We will examine the
and
in the interval
.
schedule
We know that
If
is a tight arrival time and
, since
is a tight deadline by Lemma 14.
executes all/only jobs with
(otherwise violating Lemma 14), this implies that
larger than that in
mum intensity block in
jobs with
in
has an intensity in
. This contradicts the condition that “
". If
is the maxi-
, then since the total workload of
is exactly
,
all these jobs with a speed less than
cannot complete
. Therefore,
, if
. Now we
look at
restricted to the interval
in part of
, then in order to finish all the workload of jobs with
44
uses a speed less than
,
must use a speed higher than
dicts the definition of
in some other part of
. Hence,
in interval
, which contra-
will execute all/only jobs with
and the speed is exactly
. This ends the proof. □
in
same as the schedule
. This is the
Next we present Algorithm 4 which can compute a schedule
satisfying
the three conditions in Fact 2. This algorithm repeatedly calls Algorithm 1 to handle
several blocks in
. Blocks in
dexed as 0,1,2,…. We use
starting from the global‐peak are into denote the speed of
outputs a monotone‐interval starting at time
the speed at
should be
where
by Algorithm 4 and
)), where
is the current block being handled. The algorithm teris less than
. Figure 8
is the schedule with monotone‐interval computed
is the un‐handled interval in
Figure 8 : An example that shows schedule
Lemma 17. Algorithm 4 computes a schedule
curve in
(which equals
. It
according to Lemma 16. Let
minates when the lowest speed in
shows an example, where
in
time.
45
.
in monotone‐interval
.
with a non‐increasing speed
Figure 9. An example for Algorithm 4.
In the first iteration, we have
and
.
. Thus interval
selected
is the
will be handled
and job 2 adjusted. Since there is only one block in the
with
, the finish time of the second lowest block is still
computed schedule
.
is still
In the second iteration,
. Thus interval
is the selected
handled with
dule
. Job 2 is recovered.
will be
and jobs 2,5 adjusted. For the computed sche-
, the finish time of the second lowest block is
as shown in
(c).
In the third iteration, job 5 is recovered.
is the selected
is set to be
. Thus
dled with jobs 5,6 adjusted. The new computed schedule
speed less than
.
will be hanhas lowest
as shown in (d). Therefore, Algorithm 4 ter-
minates here.
Proof.
The concept of Algorithm 4 is to utilize Algorithm 1 to handle the
blocks (common arrival time job instance by appropriate rescaling) in
.
46
Figure 9 shows an example. Let
and
be the current interval that is handled
be the computed schedule in the current iteration where
non‐increasing. Let
be the finish time of the second lowest block in
the next iteration, if
handled
block
is
where
in
,
the
. In
is the first un‐
algorithm
will
set
in Step 4. The schedule computed
in
is fixed as part of
interval after
starting speed
. We would like to further compute a monotone‐
(it is non‐increasing in this case) in the next iteration, which has
and satisfies that every down‐edge‐time is a tight deadline
(property 3) of Fact 2). Remember that Algorithm 1
outputs a non‐increasing
speed curve and every down‐edge‐time is a tight deadline. Thus we utilize Algorithm 1 to generate such a schedule. Two properties should be guaranteed. The
computed schedule by Step 10 should be not only non‐increasing but also feasible
for the jobs’ timing constraints. To ensure that Algorithm 1 generates a non‐
increasing speed curve, we choose the
1 will handle interval
after
in the next iteration. After the adjust procedure
Steps 7‐9, all jobs have
Algorithm 1 with starting speed
(Step 5) and hence Algorithm
. All these jobs will be the input for
at time
47
. Their arrival time will be adjusted
to be the same (at time
note
that
only
) while computing. For Algorithm 1 with adjusted jobs, we
when
there
exists
a
time
with
should it output a schedule violating the “non‐
increasing" requirement. According to the choice of
,
has speed
and
. Note that in
from the last iteration, the lowest block (let it be
with original deadline
) may execute jobs
. These jobs will be recovered in Step 3. In Step 8,
these jobs will be adjusted and there may be more jobs with deadline
having their deadlines adjusted to
jobs have
. If originally all these
, they are obviously executed before time
in
and
thus
for
and
for
adjusted jobs originally have
. If some
, then
is at
least the total workload of these jobs, because jobs with
are not
executed after time
. Thus
in
by applying Lemma 15 for
the adjusted jobs also satisfy
by similar reasons,
which implies that the computed schedule in
is non‐increasing.
Since Algorithm 1 handles the special case where every job has common arrival
time, we have to modify the arrival time of the input jobs with
and
to be
(common arrival time, Step 7). The computed schedule has
a non‐increasing speed curve in
and each down‐edge‐time is a tight
deadline. We need to show that the schedule is still feasible for the input before
modification (where
and
). This can be verified since
the computed schedule can be considered as a process to postpone the jobs’ execution time until each down‐edge‐time is a tight deadline as shown in Lemma 6.
48
With the starting speed
, jobs in the computed schedule with
modified input is executed with larger speed than that of
in
. Thus
jobs in the computed schedule with modified input begin to execute later than that of
and hence still feasible for the non‐modified input.
We finally examine the running time for this algorithm. Suppose that in iteration
,
jobs are involved and the resulting schedule computed in the current block
consists of
blocks, then the time needed to do this computation is
;
jobs will have their schedule fixed and no longer be in-
furthermore, at least
volved in the future computation. Since every job can only fix their schedule once,
we conclude that the total time needed will be
where
.
running time. □
This implies the
), we define local‐peak to be the
Among the un‐handled interval (e.g.
peak which has the local maximal intensity in
. For example, in
,
is the local‐peak (Figure 8). The following lemma shows that the schedules
and
are the same in local‐peaks.
Lemma 18.
The schedule of local‐peaks in
is the same as
.
Proof.
Algorithm 4 (Figure 9 shows an example) results in a schedule
tone‐interval
in mono-
by Lemma 17. It suffices to prove that the computed schedule
satisfies Fact 3.. Thus we only need to verify the three conditions in Fact 2.
Condition
1)
holds
since
the
algorithm
terminates
when
. It remains to show conditions 2) and 3). In a single
iteration handling the block
pose that
, let the computed schedule be
is the lowest block in
. We sup-
. The way of adjusting jobs implies
that all jobs with
are executed in the lowest block
49
. Furthermore, the recover procedure (Steps 3‐5) ensures that at each iteration (and hence the final iteration), this property holds. Therefore, condition 2) is
true. For condition 3), we let
let
be the second lowest block. No jobs with
ecuted in
executed in
jobs with
be the lowest block after the final iteration and
because
will be ex-
is a tight deadline and all such jobs are
due to the adjust procedure. On the other hand, since all involved
are recovered before the schedule for them in
computed, the final schedule
is
must be feasible for them as the original input.
And each down‐edge‐time is a tight deadline by the property of Algorithm 1.
Hence, condition 3) is also true, which implies the correctness of the lemma. □
50
Algorithm 4.
Input:
: Schedule computed by YDS.
Starting speed at time
: computed peak (it can be the global‐peak or local‐peak).
.
Output:
, a monotone‐interval starting from
/* Let
be the current interval being handled. Let
.
:
and its corresponding schedule.
denotes the lowest speed in the computed
be the the computed schedule for current interval
.
is the first un‐handled block in
.*/
1.
;
;
2. In
, index the blocks from the peak
While(
If(
;
;
;
.
as
in the left to right order.
){/*recover procedure*/
){
3. For jobs that are executed in the lowest block of
4. Reset
to be the speed of
in time
, recover their arrival time/deadline to the original value.
;
}
5. Select
to be the block after
in
with i.e.
and
; if such a block does not exist, then let
6. Set
){ /*adjust procedure*/
7. Adjust
to be
;
8. Adjust
to be
;
9. Backup the original value of
} /*handle interval
in
and
with starting speed
;
*/
10. Call Algorithm 1 to compute a schedule
for jobs involved in Steps 7‐9 according to common arrival time
.
found in Step 6 has speed 0, then we make
positive speed and insert a virtual canyon at time
12. Reset
.
;
For (every job with
11. If the
; Reset
accelerate with rate
after the last time with
.
to be the lowest positive speed in the computed
.
){
If(
13.
; Return
.}
Else{
14. Let
be the finish time of the second lowest (including the virtual canyon inserted in Step 11) block in
15.
16. Reset
(
restricted in interval
).
.}
}
Note that there is a monotone‐interval respectively before and after the computed global‐peak or local‐peaks. We can repeatedly call Algorithm 4 (a symmetric version of Algorithm 4 can be used to compute a monotone‐interval before a
“peak") until no such peak exists in the un‐handled intervals. Then the schedule
of the remaining intervals (all intervals between the adjacent peaks computed in Al51
.
gorithm 6) can be uniquely computed as shown in Lemma 19.
Lemma 19.
in intervals between two (local‐)peaks
The schedule of
found by Algorithm 6 can be computed by Algorithm 5. Notice that in Algorithm 5,
“down‐edge‐time" means the corresponding point on the speed curve at the
down‐edge‐time.
Figure 10 : The schedule
restricted in the interval between two local‐peaks.
Proof： Figure 10 shows an example. We need to compute the optimal schedule in
the interval between two adjacent peaks
that are computed in Algo-
rithm 6. W.l.o.g assume Algorithm 6 finds
monotone‐interval
notone‐interval
handling the blocks in
. After
first and then computes
in
is found, Algorithm 6 will compute a mo-
and schedule
by calling Algorithm 1 symmetrically
. We first prove that these two curves intersect each
other (Notice that there are no un‐handled intervals now). Otherwise without loss
of generality, we assume that the speed curve of
Then, we have
tion after
between
‐handled interval
time
is above that of
. Therefore, since
and
, we must have
.
is the first intersec. This implies an un
, a contradiction. Assume the two speed curves intersect at
(If they intersect at a line segment, we can pick any point on the line seg-
ment as ). Note that the speed curves in
52
and
are respectively non‐
increasing and non‐decreasing. The down‐edge‐times in
(or
) are
tight deadlines (or tight arrival times symmetrically) according to property 3) of
Fact 2. Suppose that
has a separation‐time
cally a separation‐time
w.r.t
, then
w.r.t
. We have
and symmetri. (E.g. if otherwise
has part of speed curve between interval
the speed curve of
that is below
. This implies that there exists at least a time with
where
, contradicting the property b) in Fact 2.)
(E.g. if otherwise
It is also easy to see that
paration the speed function of
must go down at
, then after se-
by property c) of Fact 2.
However this contradicts property b) of Fact 2). By property b) of Fact 2, we know
that the speed curve in
increasing in
. Thus in
should be non‐decreasing in
and non‐
. Therefore, it should be a line with constant speed in interval
, interval
with a constant speed is the lowest block
between the two peaks. This block will execute all jobs with
by
Lemma 15. The speed for this lowest block is unique. Because otherwise if
has two possible speeds
and
with
for this block and the whole speed
both complete the workload
curves in
will complete less workload in total than that with
We note that once the speed
‐time
and
, then the one with speed
, a contradiction.
in this lowest block is determined, the separation
are hence known. We can compute this speed by dividing the
speed into several ranges so that speeds in the same range need to finish the same set
of jobs. Then we search from the lowest speed range to the highest speed range. If
the maximum speed in a range (the execution time is also longest in the range) cannot finish the jobs that should be executed by this range, then we move on to the
next range until this condition does not hold. Then there is no need to move the
speed into higher regions because the ability to execute jobs grows more than the
workload of the new jobs added into the region. According to the existence and uni-
53
queness of the desired speed, we can just calculate it in the current region by solving
some equation to achieve exact feasibility. The details are shown in Algorithm 5.
□
Algorithm 5.
Computing the Optimal Schedule between Two Adjacent Peaks
Input:
, the two adjacent peaks found in Algorithm 6
, the two schedules computed by Algorithm 4. Choose one of the intersection
point as
.
in interval
Output: schedule of
.
on
1. For each down‐edge‐time
in
or on
in
,
let the point with the same speed on the other curve be . If there are more than one such
point, let
be the one minimizing
; if there are no such point, we do not consider line
segment originating from .
2. Sort all the segments
by increasing order of their speed (denoted by
) into
(Duplicate segments are treated as one). The end points are relabeled
so that
is always on
and
is always on
.
3. Find schedule
to
For(
as follows.
)
4. Let
.
If(
){
5. Let
speed
be the schedule that executes all jobs with
in interval
.(The parameters can be calculated as
;
;
)
6. break;
}
}
7. The optimal schedule in interval
is (
restricted to
restricted to
).
54
with
;
Theorem 4. Algorithm 6 computes
for aligned jobs in
time.
Proof.
The algorithm tries to find the global‐peak and local‐peak gradually, until
none of them exists. The global‐peak is easy to compute. Note that we need to
compute
for searching. To find the local‐peak iteratively, we compute the
monotone‐interval (Algorithm 4) adjacent to the peak that is found. For the sub‐
intervals excluding the computed monotone‐interval, the maximum peak in
of those sub‐intervals are the local‐peaks. After all such peaks are found, the
computed monotone‐intervals from adjacent computed peaks will intersect each
other and therefore Algorithm 5‐rest can be used.
The correctness of the algorithm follows naturally from the analysis in this section.
Now we focus on the running time of the algorithm. By using Theorem 3.,
can be computed in
time. Suppose that there are
one call of Algorithm 4. The time for this call will be
jobs to be handled by
as shown in Lemma 17.
On the other hand, every job will only be involved in two such calls (backward and
forward). Therefore, the total running time of executing Algorithm 4 in Algorithm 6
is
because
. Next, we analyze the execution of Algorithm 5 in Al-
gorithm 6. Notice that the jobs and down‐edge‐times involved in the calls of Algorithm 5 are disjoint. So we can first partition the jobs in
groups according to which call it is involved in. Suppose that
times and
down‐edge‐
jobs are involved in a certain call of Algorithm 5. Then the running
time of this call will be
. Since
can see that the total time for executing Algorithm 5 is also
compute
time into different
in
time.
55
and
, we
. Thus we can
Algorithm 6. Computing the Optimal Schedule for Aligned Jobs
Input: Aligned job set
Output:
1. Compute
.
be the global‐peak in
2. Let the maximum intensity block in
.
3. Index the global‐peak as an un‐handled peak.
While(there is a peak [L,R] un‐handled)
4. Let
execute jobs the same way as
in
.
5. Call Algorithm 4 to compute the monotone‐interval starting from
symmetrically a monotone‐interval ending at
6. If there are local‐peaks in
(and also
).
in the un‐handled interval on either side of
the monotone‐intervals, then index the local‐peaks as un‐handled peaks.
}
7. Compute the
for all the intervals between adjacent peaks found in the pre-
vious while loop using Algorithm 5.
2.4 Conclusion
In this section we study the energy‐efficient dynamic voltage scaling problem
and mainly focus on the pessimistic accelerate model and aligned jobs. All jobs are
required to be completed before deadlines and the objective is to minimize the energy. We start by examining the properties for the special case where jobs are released
at the same time. We show that the optimal schedule can be computed in
.
Based on this result, we study the general aligned jobs. The algorithm for jobs with
common arrival time is adopted as an elementary procedure to compute the optimal
schedule for general aligned jobs. By repeatedly computing heuristic schedules that
is non‐increasing, we fix some peaks of the optimal schedule first. This makes the
optimal schedule in the remaining interval easier to compute. The complexity of the
56
algorithm is
since we improve the computation of the optimal schedule for
aligned jobs in the ideal model to
. The computation of optimal schedules for
general job set under the pessimistic accelerate model remains as an open problem.
57
3 Power allocation on a system: truthfulness and competitiveness
3.1 Preliminaries
3.1.1
The model
The general model, which is referred to as Dynamic Channel Gain (DCG) model
in this work, contains
transmitters
who transmit to a single
hertz. The initial power
receiver (base station) over a common bandwidth of
budget for transmitter
is denoted as
,
is the power budgets
for all users. The continuous time is discretized into different time slots
. The channel gain coefficient of transmitter
time
for short) is denoted by
nonzero gain and
(quantized version).
denotes the largest one.
at time slot
(or
denotes smallest
indicates that transmitter
is not allowed to transmit at time slot . The channel gains of all transmitters at time
is denoted by a vector
.
gain of all transmitters over every time slot. Transmitter
mission power according to
as
is the channel
should adapt its trans-
, where the power adapted at time slot
is denoted
. Treating the signal transmission of other users as interfering noise signals, the
signal to noise ratio (SNR) of transmitter
where the common bandwidth
at time slot
is defined as follows:
is normalized to 1. Define function
, which is proportional to the maximum achievable data transmission rate of transmitter
at time slot .
The global objective of the system is to cooperatively maximize the total data
58
transmission rate (sum‐rate maximization), subject to the power budget constraints.
So the DCG model is formulated as follows
(2)
3.1.2
Mechanism Design
In the terminology of mechanism design, each transmitter (user) is treated as an
agent (player). For each user , the true value
(also called the type of the agent)
is taken to be the reciprocal of its initial power budget, that is
(we assume
only transmitter
, which we
knows
). Each user
will report some value
call the user’s bid, to the mechanism instead of
the user . Let
bids, where
. Let
be all users excluding
denote the vector of true values, and
the vector of
denotes all users’ bids excluding user .
A mechanism
is defined by an output algorithm
payment functions
and a vector of
. The mechanism’s output algorithm
,
which is a power allocation algorithm for the general optimization problem (3),
takes the bids of users ( ) and the channel gains ( ) as the input. The outcomes of
is denoted as
, which satisfies the constraints
, for all . The mechanism tries to maximize a social welfare function
. In this work,
is the total data transmission rate of all the
users.
(3)
A mechanism
is called ‐approximation if for any bids , we have
, where
is the optimal
achievable data transmission rate.
Before describing the payment function of the mechanism, we introduce the cost
59
of each user first. As in the seminal work of [1], for a user
cost function
we use a quasi linear
, where
come of output algorithm
caused by the outcome
,
is the out-
is the work load of user
. In this work
is the number of time slots used for
transmitting data by user . Formally,
. In order to compen-
sate the cost, the mechanism needs to make a payment
(depending on the
bids of users and the channel gains) to the user . The utility function (the function a
user
wants
to
maximize)
of
.
the true value
user
is
given
by
is truthful if for each user , bidding
will maximize his utility function (truth telling is a dominant
strategy). Formally, that means for all
, for all
and
, we have
.
3.1.3
Online Mechanism Design
In an online settings of the problem, user
declares her bid (power budget)
to the mechanism before the first time slot (notes that the bids cannot be changed
after their declaration). The channel gains
are not available to users until time .
Hence, the output algorithm should act in an online manner. That means for every
time slot , the mechanism should decide
for all
at time
and cannot reallo-
cate the power of any user. The online payment will be made at each time slot and
cannot be a negative value (which means that always the user makes a payment to
the mechanism).
Let
denote the channel gains of the first
mechanism
time slots. An online
‐ competitive, if for all
is called
, where
and
,
is the offline optimal after time .
is a truthful online mechanism, if for any
, for all ,
and
, we have
.
A randomized online mechanism
is called
60
‐ competitive, if
, where the expectation is taken over the randomized
online output algorithm
. For a randomized (online) mechanism
, there are two
versions of truthfulness. The stronger version is universally truthful, which requires
the mechanism to be truthful when fixing all the random bits. The weaker version is
truthful in expectation, which only requires that for each agent, reporting its true
type will maximize its own expected utility. In this work, we will consider the truthfulness in expectation.
3.2 A Randomized Online Mechanism
In this section, we will introduce a randomized online mechanism
for the general model, which motivates the truth telling of every
user. The output algorithm
(Randomized Allocation) is a randomized online
algorithm for the general problem (3) and is described in Section 3.2.2. The payment
function
will be given in Section 3.3, where the truthfulness of
is consi-
dered.
3.2.1
Fixed Channel Gain model (FCG)
Before describing the mechanism, we will first consider a special case of the general model, in which the channel gain
can be either 0 or a fixed value
. That
means the channel for a transmitter is either available or non‐available at a specific
time slot. We refer to
as the set of users that have positive channel gains and are
“allowed" to transmit at time
cient to convey
(
). In the FCG model,
. The FCG model is hence (
is suffi-
is also normalized to 1)
(4)
As mentioned in [18][26], the optimal power allocation for the FCG model is a
TDMA solution, where there is exactly one transmitter transmitting data at a specific
61
time slot. Formally, the feasible TDMA solution set can be defined as follows
Thanks to the TDMA property of the optimal solution, we could separate the procedure of time slots allocation from power allocation of each transmitter.
We refer to
as the power allocation schema of all
users in the first
time slots. Let the integer
assigned to user
by time
in an integral assignment. Let
of fractional time slots assigned to user
(
denote the number of time slots
denote the amount
in a fractional assignment. Let
) denote the ratio between
(
) and the power budget
of user .
We propose a randomized online algorithm
(presented in Algorithm
FBalance) to solve the FCG model. The general idea of
time , we first allocate the time slot
to a specific user
is as follows. At
(only one user is al-
lowed to get time slot ) in a randomized manner (according to a fractional assignment of time slot
by the water‐filling procedure defined in step 2‐5), by which
the user with smaller ratio
slot
get the time slot with higher probability. Once a time
is assigned to a user , the user
invests the amount of power for time
according to the power allocation strategy in [17]. For each time , the value
each round of the water‐filling procedure can be computed in
water‐filling procedure loops at most
in
time and the
rounds (Since in each round at least
one extra user is added to user set
). Clearly the algorithm runs in polynomial time.
Note that we set all
in the initialization.
62
Algorithm FBalance
Input: users’ power budget and users
that are allowed to transmit
Output: time allocation and power allocation
1. Let
denote the set of users who have the smallest ratio
in
.
is available, invoke all the following.
2. Once time slot
//Water‐filling procedure
3. WHILE (time slot
(fractional quantified) is not exhausted) {
to users in
Fractionally assign time slot
in
increase to the same level , where
est ratio in the user set of
Move the users in
so as to make the ratio
of all users
is as large as possible but at most the low-
.
whose ratio equals to
to set
.
}
4. For all ,
5. Assign time slot
3.2.2
, set
and
.
to user
with probability
.
Randomized Allocation for General Model
In order to handle the general case, where the channel gain
(we denote the range as
lies in the range of
for short), we adapt the algorithm in
[17]. The general idea is as follows. The range of gain value
levels,
is divided into
. For each time slot , the users
with gain value in the same level are grouped. The ratio between the maximum and
minimum possible gain values in the group is at most 2. Then we choose at random
a group of users with gain level
as
and the gain values of all these users are treated
. So the problem reduces to FCG model. This reduction will not lose too
much competitive ratio, which will be verified latter. At last we apply
the group of users. The details of the output algorithm
rithm RAlloc.
63
to
is described in Algo-
Algorithm RAlloc
Input: users’ power budget and channel gain at each time slot
Output: time allocation and power allocation
1. Invoke the following procedure once the time slot
2. Choose
from
uniformly.
. // All users with gain values in level
3. Set
. // The fixed channel gain
4. Set
3.3
is available.
is Truthful in Expectation
In this section, we will show that the proposed mechanism
is truthful in
expectation, where we mainly use the monotone theorem for one parameter mechanism in [1] and its extension to online mechanism [5]. We first illustrate an example for
Algorithm Balance in [18] to show that their algorithm does not satisfy the monotone theorem in [1], thus does not admit a truthful mechanism.
To be self-contained, we present Algorithm Balance below.
Algorithm Balance
Input: users’ power budget and users
that are allowed to transmit
Output: time allocation and power allocation
1. Let
denote the set of users who have the smallest ratio
2. Once time slot
3. Allocate time slot
in
.
is available, invoke all the following.
to a user in
whose ratio
would be the minimum one after
assignment.
4. For all ,
, set
6. The user who got time slot
and
.
invests the power according to the strategy in [17].
The example is an instance with three users and eight time slots. The power
budgets for all three users are
. The users allowed to transmit
64
at each time slot
are given as follows
Note that the ties are broke arbitrarily. The outcome of algorithm Balance in [18] is as
follows: user
gets the set of time slots
gets the set of time slots
and user
, user
gets the set of time slots
. So the workloads of all the users in Balance are
.
respectively
Then consider the case that we increase the power budget of user
). The outcome of Balance will be as follows: user
, user
gets the set of time slots
and user
a little (set
gets the set of time slots
gets the set of time slots
. Since user
. The workloads of all the users change to
can get less workload by declaring a greater power budget, the algorithm Balance is
not monotone and it can not lead to a truthful mechanism by Theorem 5 as shown below.
Definition 4.
[Monotone Algorithm]
An online output algorithm A is monotone if, for every
,
,
and
,
where
is the work load of user
gains by time
is
, and
is the bids of all the users.
Theorem 5. [1][5] The online output algorithm
chanism
algorithm
if and only if
and
admits an online truthful me-
is monotone. Moreover, a monotone online
admits an online truthful mechanism that satisfies voluntary participa-
tion, which means
all ,
when the status of channel
and
, if and only if
. The payment function
, the payment to user
can be
at time , is
65
for
which is a non‐negative value.
The above results of characterization of truthful online mechanism help us get rid
of the payment issue, and allow us to concentrate on the problem of output algorithm’s monotone property.
Notes: There is still a problem with the payment calculation, which involves calculation of
an integral of the output of output algorithm (may be hard to solve). Keep in mind we are
seeking a mechanism truthful in expectation, a random sampling strategy, which implement
an unbiased estimator for the integral, is enough to achieve our goal [4]. So we can ignore
the payment issue at ease.
In the following, we will show that
is an online monotone output algo-
rithm (in expectation), and hence
is a truthful online mechanism with
payment described above.
Firstly, we will prove that
is an online monotone algorithm in the fixed
channel gain scenario, then extend the result to
for the general model.
Lemma 20. The randomized online algorithm
tation). Formally, for all
where
and
,
,
is monotone (in expec-
and
, we have
stand for the declared power budgets of user
and other users,
stands for the sets of users which are allowed to transmit data by time
and
is the fixed channel gain.
Proof.
Assume that a specific user
change her bidding from
(other users
The amount of fractional time slots assigned to user
denoted as
(
(
to
.
) is
), the corresponding ratio is denoted as
).
As described in Algorithm
with probability of
, time slot
is assigned to user
. So it is easy to see that
66
is the expectation of
the amount of time slots assigned to user
(
) after time slot , which means
. Since the amount of
To establish the lemma, we only have to show
time slots are not changed (
and the bids of users except
, which means
or
in case of
)
are also not changed, it is enough to show
, for all
(in fact we also have
).
In the following, the proof is going on with an induction.
As the induction basis, before the first time slot is available, we have
clearly, the lemma holds.
With the hypothesis of
, We will prove that
, for all
. Consider the first case, that user
. By the
induction hypothesis,
the lemma holds.
Then we consider the second case that user
. Note that the situation where
can be handled following the way in the first case and will be ignored in the
discussion of the second case. So in the following, we have
and
.
and
We define
We will show that
The user set
by
.
. Suppose, for contradiction,
is given by
.
. By the algorithm, it
holds that
(5)
67
(a) If
, we have
(6)
where the first inequality follows by the definition of
lows by the assumption of
. The second inequality fol-
. The third inequality follows by the hypothesis of
. The last equality follows by (5), which leads to contradiction
.
with
(b) If
, we have
(7)
where the first inequality follows since
. The remaining inequalities and
equality hold by the same deduction in (6). The result also contradicts with
.
.
By (a) and (b), we indeed have
we have
. For all
,
), we have
Then for all ,
and
and
,
(which means
. The first equality holds by the
property of FBalance. The second inequality is the induction hypothesis. So for all
,
holds.
This completes the induction and also the proof of the lemma.
Lemma 21.
Formally, for all
where
and
is randomized online monotone algorithm (in expectation).
,
and
, we have
stand for the declared power budgets of user
68
and other users,
stands for the channel status by time .
Proof.
We use
to represent the set of users with chan-
nel gains in the ‐th level at time .
is defined as an ‐tuple
,
which can be considered as a sub‐instance (by time ) of the problem.
It is not hard to see that
where
sub ‐ instance.
is the work load caused by the
Note
that
both
th
and
are random variables.
By Lemma 20, we have
Combining the above results, we have the following theorem.
Theorem 6.
is a randomized online truthful mechanism.
3.4 General Lower Bound
In [17], the authors proved that for a special case of the general model, which
contains only one transmitter, the lower bound for any deterministic online algorithm is
. Obviously, this is also a lower bound for the general model.
In this section, with Yao’s minimax principle [46], we strengthen their result and
prove that
is a lower bound for both deterministic and randomized online
algorithms. This result in turn shows that the randomized algorithm proposed in [18]
is optimal competitive.
69
Theorem 7.
The competitive ratio of any randomized (or deterministic) online al-
gorithm for the one user case of general model (3) (refer to [17]for details) is at least
. This is also a lower bound for the general model.
Proof.
Let
be the set of all possible input instances of the problem,
be a rando-
mized algorithm of the problem which can be treated as corresponding to a distribution over
all the deterministic algorithm
any distribution
of the problem. Yao’s minimax principle shows that for
and a ‐competitive randomized algorithm
over
the following
inequality holds,
.
So, we would achieve a lower bound of
by bounding the max value of
In the following, we will specify a distribution
over a designed input set
and give an upper bound of the above formula.
Given a parameter
The input set
. Let
consists of
, which implies
instances
.
. Each instance consists of
one or more sub‐sequences. A sub‐sequence is a sequence of time slots with length
where
is large enough so that
, for all constant
an instance consisting of only one such sub‐sequence with channel gain
followed by a sub‐sequence with channel gain
Now, we specify the distribution
instance
,
over
. The
.
,
is
is
.
. Let
denote the probability of
. The distribution is given by
Note that
.
on any instance of
For a deterministic algorithm
can be described by a vector
, the process strategy of
, where
denote the proportion of the user’s total power invested on the sub‐sequence with
channel gain
. Let
denote the power budget of the user, so the profit (through-
70
put of data transmission rate) obtained by algorithm
. Note that
most
So, for all
from such a sub‐sequence is at
.
, we have
The expectation of the ratio between result of algorithm A and OPT over distribution
is
For any , we have
Recall that
and
, so we have
71
Take the limit by setting
, we have
, thus we have
That is
The proof is completed.
□
3.5 Performance Analysis Of
In this section, we focus on the worst case analysis of the online algorithm
and derive an upper bound matching the general lower bound given by Section 3.4. Thus combining the result in Section 3.3,
not only admits a truthful me-
chanism but also is in fact optimal competitive.
We derive a constant competitive ratio of
for the fixed channel model
first, then we apply the result to the analysis of
’s competitive ratio in the
general model.
3.5.1
Analysis of
For simplicity, the superscript
in fixed channel model
of
,
,
,
and
are ignored, since
in the following analysis we do not need to specify which specific time slot arrives.
Let
be the th highest ratio among all
have an allocation vector
. So for a fractional assignment we
such that
. An
allocation vector is called a max‐min fair allocation if the allocation vector is lexicographically maximal. Some results in [18] are used in this section, which are
listed below.
Theorem 8.
(Theorem 1 in [18]) In an optimal TDMA solution of the general
model (3), the optimal offline fractional allocation vector
72
is a max‐min fair allocation vector.
The theorem above states the property of optimal fractional allocation restricted
in TDMS solution. The intuition of proof behind it was that users that have a higher
ratio and contains a time that can be allocated to users that have lower ratio can be
redistributed as balance as possible.
In the following we consider a special case that all users’ power budgets are
. So we only concern with the amount of slots assigned to
equal to some value
each user (
or
) instead of the ratio (
or
). Then we will extend the results
to the arbitrary budgets case as in [18].
For any , let
denote the set of users who got at least
time slots in the optimal fractional allocation (max‐min fair allocation). Let
be the set of slots that are fractionally assigned to users in
. We have the fol-
lowing lemma,
Lemma 22.
side
(Lemma 1 in [18]) Any slot in
. Therefore, each slot in
cannot be allocated to users out-
is fully allocated to only users in
.
In order to be distinguished from optimal offline solution, we refer to
as the notation of
( ) used in
, so as
and
We update Lemma 4 in [18] slightly to fit our algorithm
lowing form. W.l.o.g we set
Lemma 23.
Proof.
For any
for all
, we have
(
)
.
to be the fol-
.
.
In fact, to prove Lemma 23 we can exactly follow the identical deduction in the
proof of lemma 4 in [18] except for eliminating all the flooring operations. Thus it is sufficient to renew Lemma 3 in [18] to the following intermediate property, whereby we use different proof.
73
For all
, we have
New proof is as follows. Let
be a specific allocation schema that imple-
ments the offline optimal fractional max‐min fair allocation. Let
of users satisfying
fying
for all
for all
and
be the set
be the set of users satis-
. We have
. Recall that
by a frac-
denotes the set of time slots that are fractionally allocated to users in
tional optimal allocation. By Lemma 22 the time slots in
users outside
by
cannot be assigned to
. So the amount of time slots, which are assigned to users in
but assigned to users in
by
, is at least
.
just finished the allocation of time slot , all
When the algorithm
users fractionally assigned a specific time slot
the amount of time slots
have the lowest workload level. So
is no more than
. Otherwise, there must be
some time slot , which can be assigned to users in
more than
) but was assigned to users in
users to be greater than
(with workload level no
and cause the workload of such
. This contradicts with the property of
.
So we have
.
for all user
The first inequality holds since
Since
, we also have
74
in
.
So
.
By the definition of
,
, we have
.
Thus, we complete the proof of the lemma
.
□
After finishing the citation of previous results, we will come to the main results
of this section in the following. To analyze the performance of
in expec-
tation, we would like to show that the competitive ratio between the global profit of
in expectation and optimal global profit of an integral allocation can be
bounded by a constant (Theorem 9).
To achieve the above final goal, we would first introduce an intermediate result
which gives a lower bound of the expected offline optimal profit given the time slots
assignment schema induced by
instead of the global profit of
in expectation. The intermediate result is formulated as follows
(8)
where
is the fixed channel gain. Note that
signed to user
by
is the number of time slots as-
which is a random variable.
is the integral op-
timal max‐min fair allocation. For simplicity, from this point on the users are rearranged such that for the ‐th user,
.
75
The proof is quite involved. At first, we tried to bound the ratio between expected
profits
and
, where
fractional
profits
. We would like to achieve the final
bound by holding the bridge between the fractional profits and fractional optimal
profits. Unfortunately, we failed to bound the ratio between the expected profits and
the fractional profits in the case of
(which is implied by Lemma 26). To
overcome this problem, we separate the users into two different sets. Let
be the set of users who were assigned at least 1 time
. Let
slot (fractional quantity) by
be the set
of users who were assigned less than 1 time slot (fractional quantity) by
So we have
.
.
We will show in Lemma 24 that the ratio between
can be bounded by a constant. Following the deduction in [18], it is not hard to see
that the profits obtained by
through the users in
can be bounded by
the profits obtained by fractional optimal solution through the first
users
). However, as mentioned
with highest work load (
,.
above, it is hard to establish such relationship in the case of user set
Instead, we will show in Lemma 26 that the profits among users
(
)
can
be
bounded
by
the
summation
which can be further bounded by the integral optimal profits of the remaining
users instead of the fractional optimal
profits, given the condition that the amount of time slots assigned to these users in
the integral optimal allocation can be bounded by the corresponding amount of time
slots in fractional optimal allocation. The details are shown in Lemma 28 and 29.
76
Base on the above discussion the problem is nearly solved, except that the profits of
the first
users
is still the profits of frac-
tional optimal solution, we have to convert it to the profits of integral optimal solution, in order to be consistent with that of the remaining users. To achieve this, we
need to tackle a complicated case that tie
(
1
occurs in the boundary
). We settle this issue in Lemma 27.
In the following we begin to present all the detailed proof.
Lemma 24.
Proof.
Let
be the proportion of time slot
being assigned to user
’s fractional assignment. This is also the probability that user
time slot . So
and
. The user set
rated into two parts,
in
get the
is further sepa-
and
, where
is a parameter to be decided later.
So we have
(9)
The two terms will be handled separately. The first one is tackled by applying Chebyshev Inequality, while the second one by bounding the small probability
.
Let
user
1
be a random variable, where
by
and
when time slot
otherwise. So we have
Tie means that more than one user are assigned the same amount of time slots.
77
was assigned to
and
follows the binomial distribution
with parameters of
.
Furthermore, since the assignment of different time slots is independent once all the
values
are fixed,
follows a generalized binomial distribution.
Since the expectation and variance of
exist,
,
by Chebyshev Inequality, we have
That is
Since
, we have
Choose
along with
For
, where
. And since
is another parameter which will be decided
, we have
, it holds that
The last inequality holds since
for user
From the above, we get the following inequality for
78
in the set of
.
(10)
Let
. Now we can handle the first term of (9) as following
(11)
(12)
(13)
Equality (11) follows by the definition of expectation, where
equality (12) holds since the function
last inequality (13) follows by
is an integer. In-
is monotone increasing. The
and (10).
Then, we come to the second term of (9)
(14)
(15)
79
The equality (14) holds since the function
is monotone increasing.
The equality (15) follows by
Concerning with
.
, we have
(16)
for users in
The last equality holds since
. So we have
(17)
Since the function
is monotone increasing, we also have
(18)
(19)
The inequality (18) holds since
.
Combining (15), (17) and (19), we have
80
Accompany with (13), we have
To get the minimum value of
, we set
. In this case
This completes the proof.
We have bounded the profits obtained by the users in
the profits obtained by the users in
by Lemma 25, 26 and 27.
. First, we prepare three important properties
Lemma 25 establishes the relationship between the frac-
tional time slots assignment of offline optimal solution and
Lemma 25.
For all
solution.
, we have
Proof.
By Lemma 23, for all
of
we have
. Combining with the definition
So
For all
. We will go on with
, it is true that
81
Since the offline optimal allocation
is a max‐min fair allocation, we have
. It is easy to see that
So for all
, we have
The proof is completed.
by
By the following lemma we bound
.
Lemma 26. For all
,
(Recall that, for the left hand side of the inequality, we have rearranged the users
such that for the ‐th user,
Proof.
. So for all
, user
We have the following deducing process
(20)
(21)
(22)
(23)
82
is in
.)
(24)
The inequalities (20) and (21) follow by (15) and (16) in Lemma 24. By expanding the function of
, we have
Combining with
.
, inequality (22) holds. Inequality (23) follows by
for users in
. The last inequality follows by Lemma 25.
To establish the relationship between profits obtained by fractional optimal solution and profits obtained by integral optimal solution, we introduce the following
notations.
Let
be the set of
users corresponding to
the set of time slots which are assigned to the user in
lution
. Let
be a subset of
by the integral optimal so-
by the fractional optimal solution. Let
be the complement set of
For all
be
, where more than one half of the time slot in
is assigned to the users in
Lemma 27.
. Let
.
, if
, where
is a parameter, then we
have
Proof.
Let
,
ing the time slots in
Let
ing to
, ...,
be the fractional optimal allocation when assign-
to the users in
.
be the amount of time slots in
being assigned to the user correspond-
by the integral optimal solution
slots in
timal solution
. Let
being assigned to the user corresponding to
. By the definition of
, we have
83
be the amount of time
by the integral op. So
The second inequality holds since all time slots in
the amount of time slots assigned to the users in
. The last inequality holds since
and
by fractional optimal allocation
is the fractional optimal allocation and
is an integral allocation over user set
Since
will be covered by doubling
.
, we have
.
So
That is
It holds that
84
and
The second inequality holds since
is an integer. The last inequality holds since
.
By the definition, the time slots in
contribute to the users outside
than one half. It holds that
chosen as
. So the parameter of
more
can be
.
Now we are ready to combine the above results to derive the final competitive ratio
by distinguishing the following two different cases using an integer
, we define
as the smallest integer such that
and
and
Lemma 28.
Proof.
If
. Since
. The two cases are
.
, then we have
Firstly, let us consider the users with higher work load. By Lemma 24, it
holds that
85
Considering
, we have the following derivation.
(25)
(26)
(27)
(28)
Since the fractional optimal max‐min fair allocation
coordinate in the allocation vector, we have
ty of function
minimizes the largest
, together with monotonici-
, the inequality (25) holds. The inequality (26) follows
by applying Lemma 23. Inequalities (27) and (28) can be derived similarly as in
Lemma 25. Thus we have
(29)
86
(30)
(31)
The inequality (30) follows since
and the function
. And since
monotone increasing. The last inequality holds since
, it holds that
is
. So we have
(32)
The last inequality holds by Lemma 27 (Choose
).
Now, consider the users with lower work load.
(33)
The first inequality holds by Lemma 26, the second inequality holds by
. Since
is strictly lager than
by the definition of
, by
Lemma 22, we know that the time slots assigned to the users corresponding to
, ...,
,
cannot be assigned to other users. Thus
holds. So we have
(34)
The first inequality holds since
is an integer and for
87
the profit is 0.
Finally, we obtain the competitive ratio by the following derivation.
(35)
(36)
Inequality (35) follows by (32) and (33). Inequality (36) follows by (34). The proof
is completed.
Lemma 29. If
Proof.
, then we have
Firstly, let us consider the users in
88
.
(37)
The first inequality follows by (29) in Lemma 28 and the second inequality follows
by applying Lemma 27 (take
as
). Consider the users in
.
By Lemma 26, we have
(38)
By Lemma 22, for
, we can only move time slots from the user
corresponding to
such that
to the users corresponding to
.
We also have
, so at most
time slots can be assigned to users corresponding to
, ...,
. Thus for the integral optimal allocation
, we have
. Following (34) in Lemma 28 we have
(39)
89
Combining (37), (38) and (39) we have
This completes the proof.
Combining Lemma 28 and Lemma 29, we derive the intermediate result mentioned earlier in (8). Further combining the results in [17], which provides a constant
competitive ratio
for the online power allocation problem for each individual user,
we derive the following theorem. (The proof is nearly identical to the Theorem 2 in
[18], so we omit it.)
Theorem 9.
is randomized online algorithm with constant competitive
ratio for fixed channel gain model.
As for the arbitrary budgets case, following the way in [18], we can easily extend
the above results by splitting each user into several virtual users with equal budgets.
90
3.5.2
Extend to
in General Model
With the results for
in FCG model, we prove the following theorem
without much effort.
Theorem 10.
The randomized online algorithm
‐
is
competitive for the general DCG model.
Proof:
Recall the notation used in Lemma 21:
users with channel gains in the
‐th level.
is the set of
is an ‐tuple
, which
can be considered as a sub‐instance (before and at time ) of the problem.
Let
be the expected profit of
. Let
level sub‐instance. So
rithm
applied to
‐th
is the profit (or expected profit) of algo-
‐th level sub‐instance only (ignoring users belonging to
other levels at each time slot). Let
denote the offline optimal alloca-
tion/algorithm for the general model. Let
denote the offline optimal allo-
cation for the fixed channel gain model. Let
. Let
be the channel status of
be the constant competitive ratio of
be the profit obtained by
transmitting over a channel with gain values in the range
from users
. So we have
(40)
(41)
(42)
(43)
(44)
91
The equality (40) follows since
equality (41), notes that
mized
chooses the different levels uniformly. For
deals with the ‐th level by applying the rando-
to all users belonging to ‐th level with fixed channel gain
. The inequality (42) holds since
is
‐competitive. The inequali-
ty (43) holds since the manipulation of fixing the channel gain to
for all users
in ‐th level will lose at most a factor of 2 in terms of competitive ratio, meanwhile
uses all the power but
may use only
partial power for users belonging to ‐th level. The inequality (44) holds since
invests all the power budgets over users belonging to ‐th level,
but
tion of
may only invest partial of the power budgets. By the defini, we have the last equality. Thus we complete the proof.
92
4
Conclusion
4.1
Our contribution and innovations
There are billions of users who use the mobile devices (system) in the daily life.
Theoretically examining the power allocation problem of the devices and the system has great potential applications. We exactly focus on such optimization problems in this work.
First，in a device view, we study the energy minimization problem on the devices. What we are concerning about is called dynamic voltage scaling (DVS) technology. It is widely implemented to save energy on the processors. To optimize the
energy, we should allocate the speed and determine the job to execute at a specific
time. All jobs should be finished during their lifetime. We improve the time complexity to compute the optimal schedule for ideal model to O(n 2 ) time. Our faster
algorithm depends on some observations of the optimal schedule and a faster
searching of some special times which should change speeds. This is further used to
derive an O(n 2 ) time algorithm for the more practical accelerate model for aligned
jobs. The problem in this model is much more complicated since even few jobs will
make the optimal schedule difficult to calculate, involving the solving of equations
since job could have various speeds in OPT.
Then we focus on the power allocation problem raised on the mobile system.
The objective is to maximize the throughput limited by the power budget. Traditionally, this is just an optimization problem considering various constraints, such as
user interference which bring great complexity to the system. Besides these formulations, we would like to capture the selfish behaviour of the users. Treating each
user as individual player, we adopt the game theory to study their cheating behaviours. Users are allowed to cheat on their private value, power budget, to increase
their own utilities. Adopting the mechanism design in game theory, we maximize the
throughput with respect to global objective and also ensure each user has no incentive to cheat to the system. Our randomized mechanism is truthful and
H
O(log ) -competitive. For the lower bound side, we improve the previous best reh
93
sult to derive Ω(log
H
) -competitive for any randomized algorithm. Such a result
h
also implies that our mechanism successfully avoid the negative effect of truthfulness to the system’s global profits. The constraint of truthfulness in fact limits the
searching space of competitive algorithms in finite small spaces (which has some
monotone property). Our Method is to design a randomized algorithm which tries to
balance the work load of the users. The analysis is hence probabilistic and more involved.
4.2
Future work
Possible directions of future work are as follows. The NP-completeness of the
accelerate model for most general jobs is open. Design exact or approximation algorithms for such a model should adopt some new ideas.
For the mobile system, we consider the users whose utilities are to minimize
their working time slots (to minimize their workload and prolong the lifetime of the
batteries). Another natural formulation is that users want to maximize their own
throughput. This would make the problem fit into VCG scheme. Optimal offline algorithm for this model is truthful however it needs exponential time, and one direction is to design a competitive algorithm.
94
List of Papers Published during PhD Study
1.Weiwei Wu,MinmingLiandEnhongChen, 
"OptimalTreeStructuresforGroupKeyTreeManagementConsideringInsertion
andDeletionCost",2009,Theoretical Computer Science (TCS).

2.Weiwei Wu,MinmingLiandEnhongChen,
"Min-EnergySchedulingforAlignedJobsinAccelerateModel",2011,Theoretical Computer Science(TCS).

3.Yu-KiChan,MinmingLi,Weiwei Wu, 
"OptimalTreeStructurewithLoyalUsersandBatchUpdates",2010,Journal of Combinatorial Optimization(JOCO).
4.Weiwei Wu,MinmingLiandEnhongChen,
"OptimalTreeStructuresforGroupKeyTreeManagementConsideringInsertion
andDeletionCost",the14thAnnualInternationalComputingandCombinatorics
Conference,(COCOON2008),June27-29,Dalian,P.R.China,2008.

5. Weiwei Wu,MinmingLiandEnhongChen,
"OptimalKeyTreeStructureforDeletingTwoorMoreLeaves",the19thInternationalSymposiumonAlgorithmsandComputation,(ISAAC 2008)December15-17,
GoldCoast,Australia,2008.

6.Weiwei Wu,MinmingLiandEnhongChen,
"Min-EnergySchedulingforAlignedJobsinAccelerateModel",the20thInternationalSymposiumonAlgorithmsand
Computation,(ISAAC2009)December16-18,Honolulu,Hawaii,USA,2009.

7. Weiwei Wu,WanyongTian,MinmingLi,ChunJasonXue,andEnhongChen,
"SingleandMultipleDeviceDSA/SRFProblem,ComplexitiesandOnlineAlgorithms",the21thInternationalSymposiumonAlgorithmsandComputation,
(ISAAC2010)December14-17,JezuIsland,Korea,2010.
95
References
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
Archer, A. and E. Tardos, Truthful mechanisms for one-parameter agents.
42nd Annual Symposium on Foundations of Computer Science, Proceedings,
2001: p. 482-491.
Albers, S. and H. Fujiwara, Energy-efficient algorithms for flow time
minimization. ACM Trans. Algorithms, 2007. 3(4): p. 49.
AlEnawy, T.A. and H. Aydin, On Energy-Constrained Real-Time Scheduling,
in Proceedings of the 16th Euromicro Conference on Real-Time Systems.
2004, IEEE Computer Society. p. 165-174.
Archer, A., et al., An approximate truthful mechanism for combinatorial
auctions with single parameter agents, in Proceedings of the fourteenth
annual ACM-SIAM symposium on Discrete algorithms. 2003, Society for
Industrial and Applied Mathematics: Baltimore, Maryland. p. 205-214.
Auletta, V., et al., On designing truthful mechanisms for online scheduling.
Theoretical Computer Science, 2009. 410(36): p. 3348-3356.
Aydin, H., V. Devadas, and D. Zhu, System-Level Energy Management for
Periodic Real-Time Tasks, in Proceedings of the 27th IEEE International
Real-Time Systems Symposium. 2006, IEEE Computer Society. p. 313-322.
Bambha, N.K., et al., Hybrid global/local search strategies for dynamic
voltage scaling in embedded multiprocessors, in Proceedings of the ninth
international symposium on Hardware/software codesign. 2001, ACM:
Copenhagen, Denmark. p. 243-248.
Bansal, N., et al., Average rate speed scaling, in Proceedings of the 8th Latin
American conference on Theoretical informatics. 2008, Springer-Verlag:
B\&\#250;zios, Brazil. p. 240-251.
Bansal, N., et al., Scheduling for Speed Bounded Processors, in Proceedings
of the 35th international colloquium on Automata, Languages and
Programming, Part I. 2008, Springer-Verlag: Reykjavik, Iceland. p. 409-420.
Bansal, N., H.-L. Chan, and K. Pruhs, Speed scaling with an arbitrary power
function, in Proceedings of the twentieth Annual ACM-SIAM Symposium on
Discrete Algorithms. 2009, Society for Industrial and Applied Mathematics:
New York, New York. p. 693-701.
Bansal, N., T. Kimbrel, and K. Pruhs, Speed scaling to manage energy and
temperature. J. ACM, 2007. 54(1): p. 1-39.
Baptiste, P., An O(n4) algorithm for preemptive scheduling of a single
machine to minimize the number of late jobs. Operations Research Letters,
1999. 24(4): p. 175-180.
Bini, E., G. Buttazzo, and G. Lipari. Speed modulation in energy-aware
real-time systems. in Real-Time Systems, 2005. (ECRTS 2005). Proceedings.
96
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
17th Euromicro Conference on. 2005.
Bansal, N., K. Pruhs, and C. Stein, Speed scaling for weighted flow time, in
Proceedings of the eighteenth annual ACM-SIAM symposium on Discrete
algorithms. 2007, Society for Industrial and Applied Mathematics: New
Orleans, Louisiana. p. 805-813.
Burd, T.D. and R.W. Brodersen, Design issues for dynamic voltage scaling,
in Proceedings of the 2000 international symposium on Low power
electronics and design. 2000, ACM: Rapallo, Italy. p. 9-14.
Borodin, A. and R. El-Yaniv, Online computation and competitive analysis.
1st pbk. ed. 2005, Cambridge Eng. ; New York: Cambridge University Press.
xviii, 414 p.
Buchbinder, N., et al., Dynamic Power Allocation Under Arbitrary Varying
Channels - An Online Approach. Ieee Infocom 2009 - Ieee Conference on
Computer Communications, Vols 1-5, 2009: p. 145-153 3015.
Buchbinder, N., et al., Dynamic power allocation under arbitrary varying
channels - the multi-user case, in Proceedings of the 29th conference on
Information communications. 2010, IEEE Press: San Diego, California, USA.
p. 2402-2410.
Chung, S.T., et al., A game-theoretic approach to power allocation in
frequency-selective Gaussian interference channels. 2003 Ieee International
Symposium on Information Theory - Proceedings, 2003: p. 316-316 491.
Chan, H.-L., et al., Nonclairvoyant Speed Scaling for Flow and Energy.
Algorithmica, 2010: p. 1-11.
Chan, H.-L., et al., Energy efficient online deadline scheduling, in
Proceedings of the eighteenth annual ACM-SIAM symposium on Discrete
algorithms. 2007, Society for Industrial and Applied Mathematics: New
Orleans, Louisiana. p. 795-804.
Kihwan, C., R. Soma, and M. Pedram, Fine-grained dynamic voltage and
frequency scaling for precise energy and performance tradeoff based on the
ratio of off-chip access to on-chip computation times. Computer-Aided
Design of Integrated Circuits and Systems, IEEE Transactions on, 2005.
24(1): p. 18-28.
Chan, J.W.-T., et al., Online deadline scheduling with bounded energy
efficiency, in Proceedings of the 4th international conference on Theory and
applications of models of computation. 2007, Springer-Verlag: Shanghai,
China. p. 416-427.
Hong, I., et al., Synthesis Techniques for Low-Power Hard Real-Time
Systems on Variable Voltage Processors, in Proceedings of the IEEE
Real-Time Systems Symposium. 1998, IEEE Computer Society. p. 178.
Hsu, C.-H. and W.-C. Feng. Effective dynamic voltage scaling through
CPU-boundedness detection. in In Workshop on Power Aware Computing
Systems. 2004.
Hayashi, S. and Z.Q. Luo, Spectrum Management for Interference-Limited
Multiuser Communication Systems. Ieee Transactions on Information Theory,
97
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
2009. 55(3): p. 1153-1175.
Irani, S., S. Shukla, and R. Gupta, Algorithms for power savings. ACM Trans.
Algorithms, 2007. 3(4): p. 41.
Ishihara, T. and H. Yasuura, Voltage scheduling problem for dynamically
variable voltage processors, in Proceedings of the 1998 international
symposium on Low power electronics and design. 1998, ACM: Monterey,
California, United States. p. 197-202.
Irani, S. and K.R. Pruhs, Algorithmic problems in power management.
SIGACT News, 2005. 36(2): p. 63-76.
Kwon, W.-C. and T. Kim, Optimal voltage allocation techniques for
dynamically variable voltage processors, in Proceedings of the 40th annual
Design Automation Conference. 2003, ACM: Anaheim, CA, USA. p.
125-130.
Kalyanasundaram, B. and K. Pruhs, Dynamic Spectrum Allocation: The
Impotency of Duration Notification, in Proceedings of the 20th Conference
on Foundations of Software Technology and Theoretical Computer Science.
2000, Springer-Verlag. p. 421-428.
Luo, Z.Q. and J.S. Pang, Analysis of iterative waterfilling algorithm for
multiuser power control in digital subscriber lines. Eurasip Journal on
Applied Signal Processing, 2006: p. -.
Lam, T.-W., et al., Speed Scaling Functions for Flow Time Scheduling Based
on Active Job Count, in Algorithms - ESA 2008, D. Halperin and K.
Mehlhorn, Editors. 2008, Springer Berlin / Heidelberg. p. 647-659.
Lam, T.-W., et al., Energy Efficient Deadline Scheduling in Two Processor
Systems, in Algorithms and Computation, T. Tokuyama, Editor. 2007,
Springer Berlin / Heidelberg. p. 476-487.
Li, M. and F.F. Yao, An Efficient Algorithm for Computing Optimal Discrete
Voltage Schedules. SIAM J. Comput., 2005. 35(3): p. 658-671.
Li, M., A.C. Yao, and F.F. Yao, Discrete and continuous min-energy
schedules for variable voltage processors. Proceedings of the National
Academy of Sciences of the United States of America, 2006. 103(11): p.
3983-3987.
Marinoni, M. and G. Buttazzo. Adaptive DVS management through elastic
scheduling. in Emerging Technologies and Factory Automation, 2005. ETFA
2005. 10th IEEE Conference on. 2005.
Pruhs, K., P. Uthaisombut, and G. Woeginger, Getting the best response for
your erg. ACM Trans. Algorithms, 2008. 4(3): p. 1-17.
Scutari, G., D.P. Palomar, and S. Barbarossa, Optimal linear precoding
strategies for wideband non-cooperative systems based on game theory Part II: Algorithms. Ieee Transactions on Signal Processing, 2008. 56(3): p.
1250-1267.
Scutari, G., D.P. Palomar, and S. Barbarossa, Optimal linear precoding
strategies for wideband noncooperative systems based on game theory - Part
I: Nash equilibria. Ieee Transactions on Signal Processing, 2008. 56(3): p.
98
41.
42.
43.
44.
45.
46.
47.
48.
49.
1230-1249.
Song, K.B., et al., Dynamic spectrum management for next-generation DSL
systems. Ieee Communications Magazine, 2002. 40(10): p. 101-109.
Seth, K., et al. FAST: frequency-aware static timing analysis. in Real-Time
Systems Symposium, 2003. RTSS 2003. 24th IEEE. 2003.
Yao, F., A. Demers, and S. Shenker, A scheduling model for reduced CPU
energy, in Proceedings of the 36th Annual Symposium on Foundations of
Computer Science. 1995, IEEE Computer Society. p. 374.
Chuan-Yue, Y., C. Jian-Jia, and K. Tei-Wei. Preemption Control for
Energy-Efficient Task Scheduling in Systems with a DVS Processor and
Non-DVS Devices. in Embedded and Real-Time Computing Systems and
Applications, 2007. RTCSA 2007. 13th IEEE International Conference on.
2007.
Lin, Y. and Q. Gang, Analysis of energy reduction on dynamic voltage
scaling-enabled systems. Computer-Aided Design of Integrated Circuits and
Systems, IEEE Transactions on, 2005. 24(12): p. 1827-1837.
Yao, A.C.-C., Probabilistic computations: Toward a unified measure of
complexity, in Proceedings of the 18th Annual Symposium on Foundations of
Computer Science. 1977, IEEE Computer Society. p. 222-227.
Yu, W., G. Ginis, and J.M. Cioffi, Distributed multiuser power control for
digital subscriber lines. Ieee Journal on Selected Areas in Communications,
2002. 20(5): p. 1105-1115.
Albers, S. , Energy-efficient Algorithms, Communications of the ACM,,
2010, 53(5)
Gaujal B., Navet N. , Dyanamic voltage scaling under EDF revisited,
Real-Time Systems, 2007, 37(1) p. 77-97.
99