Truthful Mechanisms for Value-Based Scheduling in Cloud Computing Jonathan Yaniv Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
Truthful Mechanisms for
Value-Based Scheduling in
Cloud Computing
Jonathan Yaniv
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
Truthful Mechanisms for
Value-Based Scheduling in
Cloud Computing
Research Thesis
Submitted in partial fulfillment of the requirements
for the degree of Master of Science in Computer Science
Jonathan Yaniv
Submitted to the Senate of
the Technion — Israel Institute of Technology
Av 5771 Haifa August 2011
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
The research thesis was done under the supervision of Prof. Seffi Naor in
the Computer Science Department.
It is an honor working under the supervision of Prof. Seffi Naor. I wish to
thank Seffi for his continuing support, wise advice and patience.
I owe a great deal of gratitude to Ishai Menache, who I also consider as one
of my advisors. Ishai constantly supported and guided me throughout this
work. I am grateful for all that I have learned from both Seffi and Ishai.
I would like to thank the people at the Computer Science Department,
Technion, whom I had the privilege of working with. I would also like to
thank Microsoft Research New England, for inviting me and for the
wonderful time I had while visiting them.
Last but certainly not least, I wish to thank my loving family and friends,
for inspiring me and believing in me. I am lucky to have you all in my life.
This work is dedicated to my grandmother, who left us before her time.
The generous financial support of the Technion is gratefully acknowledged.
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
Contents
Abstract 1
Abbreviations and Notation 2
1 Introduction 3
1.1 Background and Motivation . . . . . . . . . . . . . . . . . . . 3
1.2 New Results in Thesis . . . . . . . . . . . . . . . . . . . . . . 4
2 Preliminaries 7
2.1 Approximation Algorithms . . . . . . . . . . . . . . . . . . . 7
2.1.1 Basic Terminology . . . . . . . . . . . . . . . . . . . . 7
2.1.2 Related Work . . . . . . . . . . . . . . . . . . . . . . . 9
2.2 Algorithmic Mechanism Design . . . . . . . . . . . . . . . . . 16
2.2.1 Basic Terminology . . . . . . . . . . . . . . . . . . . . 16
2.2.2 Related Work . . . . . . . . . . . . . . . . . . . . . . . 17
3 The Bounded Flexible Scheduling (BFS) Problem 21
3.1 Definitions and Notation . . . . . . . . . . . . . . . . . . . . . 21
3.2 NP-Hardness of BFS . . . . . . . . . . . . . . . . . . . . . . . 23
3.3 Solving the Unbounded Case . . . . . . . . . . . . . . . . . . 23
4 An Approximation Algorithm for BFS 27
4.1 Deadline Valuation Functions . . . . . . . . . . . . . . . . . . 27
4.1.1 LP Formulation of BFS with Deadline Valuation Func. 28
4.1.2 The Canonical MND Form . . . . . . . . . . . . . . . 30
4.2 General Monotone Valuation Functions . . . . . . . . . . . . 33
4.3 General Valuation Functions . . . . . . . . . . . . . . . . . . . 35
i
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
4.4 Decomposing a Fractional Optimal MND Solution . . . . . . 36
5 A Truthful-in-Expectation Mechanism for BFS 39
5.1 The Fractional VCG Mechanism . . . . . . . . . . . . . . . . 40
5.2 A New Efficient Mechanism . . . . . . . . . . . . . . . . . . . 40
6 Conclusions and Future Work 42
Appendix 48
ii
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
List of Figures
3.1 An example of a mapping. . . . . . . . . . . . . . . . . . . . 23
4.1 A fractional solution OPT ∗ verifying the integrality gap of
the natual relaxation of (IP). . . . . . . . . . . . . . . . . . . 28
4.2 Resolving an (a, b)-violation generated by j. . . . . . . . . . 33
iii
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
iv
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
Abstract
Cloud computing provides an attractive computation platform, in which
computing resources (e.g., virtual machines, storage capacity) are rented to
end-users under a utility pricing model. The most common pricing offering
is a pay-as-you-go scheme, in which users are charged a fixed price per unit
resource per hour. While this scheme is simple to implement, it does not
support value-based scheduling, where users assign a value to their job and
the cloud’s goal is to schedule jobs to maximize aggregate value under job
demand and capacity constraints.
In this work, we introduce a novel pricing and allocation approach for
batch jobs (e.g., image processing, financial analytics, scientific simulations)
on cloud systems. In our economic model, users submit jobs with a value
function that specifies willingness to pay as a function of job due dates.
The cloud provider in response allocates a subset of these jobs, taking into
advantage the flexibility of allocating resources to jobs in the cloud environ-
ment. Focusing on social-welfare as the system objective (especially relevant
for private or in-house clouds), we construct a resource allocation algorithm
which obtains a small approximation factor that approaches 2 as the number
of servers increases, assuming that user valuations are known. An appealing
property of our scheme is that jobs are allocated non-preemptively, i.e., jobs
run in one shot without interruption. This property has practical signifi-
cance, as it avoids significant network and storage resources. Based on this
algorithm, we then design an efficient truthful-in-expectation mechanism,
which significantly improves the running complexity of black-box reduction
mechanisms that can be applied to the problem, thereby facilitating its im-
plementation in real systems.
1
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
Abbreviations and Notation
BFS — The Bounded Flexible Scheduling problem.
α — The approximation factor of our algorithm.
aj — An allocation of a job j.
C — Number of servers.
Dj — The demand of job j.
kj — The parallelization bound of job j.
k — Maximal parallelization bound: maxj kj.j — An index of a job (player).
n — Number of jobs.
T — Number of time slots.
vj — The valuation function of job j.
xj — The completed fraction of job j.
yj — A mapping of servers per time unit to job j.
J — The set of jobs 1, 2, . . . , n.T — The set of time slots 1, 2, . . . , T.
2
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
Chapter 1
Introduction
1.1 Background and Motivation
Cloud computing offers easily accessible computing resources of variable
size and capabilities. This paradigm allows applications to rent computing
resources and services on-demand, benefiting from the allocation flexibility
and the economy of scale of large data centers.
Cloud computing providers, such as Amazon, Google and Microsoft, are
offering cloud hosting of user applications under a utility pricing model.
The most common purchasing options are pay-as-you-go (or on-demand)
schemes, in which users pay per-unit resource (e.g., a virtual machine) per-
unit time (e.g., per hour). The advantage of this pricing approach is in its
simplicity, in the sense that user pay for the resources they get. However,
such an approach suffers from two shortcomings. First, the user pays for
computation as if it were a tangible commodity, rather than paying for de-
sired performance. To exemplify this point, consider a finance firm which
has to process the daily stock exchange data with a deadline of an hour
before the next trading day. Such a firm does not care about allocation
of servers over time as long as the job is finished by its due date. At the
same time, the cloud can deliver higher value to users by knowing user-
centric valuation for the limited resources being contended for. This form
of value-based scheduling, however, is not supported by pay-as-you-go pric-
ing. Second, current pricing schemes lack feedback signals that prevents
users from submitting unbounded amounts of work. Thus, users are not
incentivized to respond to variations in resource demand and supply.
3
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
In this work, we propose a novel pricing model for cloud environments,
which focuses on quality rather than quantity. Specifically, we incorporate
the significance of the completion time of a job, rather than the exact number
of servers that the job gets at any given time. In our economic model,
customers specify the overall amount of resources (server or virtual machine
hours) which they require for their job, and how much they are willing to
pay for these resources as a function of due date. For example, a particular
customer may specify that she needs a total of 1000 server hours, and is
willing to pay $100 if she gets them by 5pm and $200 if she gets them by
2pm. This framework is especially relevant for batch jobs (e.g., financial
analytics, image processing, search index updates) that are carried out until
completion. Under our scheme, the cloud determines the scheduling of the
resources according to given submitted jobs, the users’ willingness to pay
and its own capacity constraints. This entire approach raises fundamental
mechanism design and incentive compatibility issues, as users may try to
game the system by reporting false value and potentially increasing their
utility. Hence, any algorithmic solution has to self enforce the users to report
their true values (or willingness to pay) for the different job due dates.
Pricing in shared computing systems such as cloud computing can have
diverse objectives, such as maximizing profits, or optimizing system-related
metrics (e.g., delay or throughput). Our focus in this work is on maximizing
the social welfare, i.e., the sum of users’ values. This objective is especially
relevant for private or in-house clouds, such as a government cloud, or en-
terprize computing clusters.
1.2 New Results in Thesis
We design an efficient truthful-in-expectation mechanism for a new schedul-
ing problem, called the Bounded Flexible Scheduling (BFS) problem, which
is directly motivated by the cloud computing paradigm. A cloud containing
C servers receives a set of job requests with heterogeneous demand and val-
ues per deadline (or due date), where the objective is maximizing the social
welfare, i.e., the sum of the values of the scheduled jobs. The scheduling of a
job is flexible, i.e., it can be allocated a different number of servers per time
unit and in a possibly preemptive (non-contiguous) manner, under paral-
lelism thresholds. The parallelism threshold represents the job’s limitations
4
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
on parallelized execution. For every job j, we denote by kj the maximum
number of servers that can be allocated to job j in any given time unit. The
maximal parallelism thresholds across jobs, denoted by k, is assumed to be
much smaller than the cloud capacity C, as typical in practical settings.
No approximation algorithm is known for the BFS problem. When re-
laxing the parallelism bounds on jobs, our model coincides with the problem
of maximizing the profit of preemptively scheduling jobs on a single server.
Lawler [28] gives an optimal solution in pseudo-polynomial time via dynamic
programming to this problem, implying an FPTAS for it. However, his al-
gorithm cannot be extended to the case where parallelization is bounded.
Our first result is an LP-based approximation algorithm for BFS that
gives an approximation factor of α ,(
1 + CC−k
)(1 + ε) to the optimal social
welfare for every ε > 0. With the gap between k and C being large, the ap-
proximation factor approaches 2. The running time of the algorithm, apart
from solving the linear program, is polynomial in the number of jobs, the
number of time slots and 1ε . The design of the algorithm proceeds through
several steps. We first consider the natural LP formulation for the BFS
problem. Unfortunately, this LP has a very large integrality gap. Thus,
we strengthen this LP by incorporating additional constraints that decrease
the integrality gap. We proceed by defining a reallocation algorithm that
converts any solution of the LP to a value-equivalent canonical form named
MND, in which the number of servers allocated per job does not decrease
over the execution period of the job. Our approximation algorithm then
decomposes the optimal solution, given in MND form, to a relatively small
number of feasible BFS solutions, with their average social welfare being an
α-approximation (thus, at least one of them is an α-approximation). An ap-
pealing property of our scheme is that jobs are allocated non-preemptively,
i.e., jobs run in one shot without interruption. This property has practi-
cal significance, as it avoids significant network and storage resources for
checkpointing intermediate state of jobs that are distributed across multiple
servers running in parallel.
The approximation algorithm that we develop is essential for construct-
ing an efficient truthful-in-expectation mechanism that preserves the α-
approximation. To obtain this result, we slightly modify the approximation
algorithm to get an exact decomposition of an optimal fractional solution.
This decomposition is then used to simulate (in expectation) a “fractional”
5
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
VCG mechanism, which we prove to be truthful. The main advantage of
our mechanism is that the allocation rule requires only a single execution of
the approximation algorithm, whereas known black-box reductions that can
be applied invoke the approximation algorithm many times, while providing
only a polynomial bound on the number of invocations. At the end of the
Chapter 5, we discuss the process of computing of the charged payments.
6
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
Chapter 2
Preliminaries
2.1 Approximation Algorithms
2.1.1 Basic Terminology
Combinatorial Optimization. The field of combinatorial optimization
studies the problem of finding an optimal object out of a finite set of objects.
For a combinatorial optimization problem P, we denote by I the set of
possible inputs to P and by O (I) the finite set of outputs matching an
input instance I ∈ I. Denote by O =⋃I∈I O (I) the set of all outputs.
Every output is associated with a value set by an objective function f :
O → R. We denote by OPT (I) the optimal value of an output matching I.
In a maximization problem, the goal is to return an output maximizing the
objective function over the set of possible outputs, whereas in a minimization
problem the goal is to minimize the objective function.
NP-Hardness and Approximation Algorithms. We say that an opti-
mization problem can be solved in polynomial time if there is an algorithm
A and some polynomial q : N → N that given an input I returns an op-
timal value for I in a total time bounded by q. We distinguish between
three cases: An algorithm runs in strongly polynomial time if the number of
steps performed by the algorithm is at most q (n), where n is the number of
integers in I, assuming every arithmetic operation takes a single step. An
algorithm runs in weakly polynomial time when the bound on the running
time is q (|I|), where |I| is the size of representing I as a binary string. When
7
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
the running time of the algorithm is polynomial in the unary representation
of I, the algorithm is said to run in pseudo-polynomial time.
An NP-hard optimization problem is a problem that cannot be solved
in polynomial time unless P = NP . For NP-hard problems, one possible
approach is to develop polynomial-time algorithms that return a nearly op-
timal solution, i.e., an approximate solution. Algorithms that have some
guarantee on the value of their output for any possible input are called ap-
proximation algorithms. An α-approximation algorithm is an algorithm that
guarantees a multiplicative loss of at most α compared to the optimal value.
Specifically, for a maximization problem, the returned output has a value
of at least 1α · OPT (I), whereas for a minimization problem, the value is
at most α · OPT (I). A randomized algorithm is an α-approximation if its
expected value for every input is an α-approximation to the optimal value.
A polynomial time approximation scheme (PTAS), given a constant ε >
0, returns an (1 + ε)-approximation in time polynomial in |I|. When the
running time is polynomial in both |I| and 1ε , the approximation algorithm
is called a fully polynomial time approximation scheme (FPTAS).
Integer and Linear Programming. Many discrete combinatorial op-
timization problems can be formulated as integer programs (IP). Given a
matrix A ∈ Rm×n, a vector b ∈ Rm and an objective target vector w ∈ Rn,
a 0, 1-integer program has the following form:
min /maxn∑i=1
wixi
s.t. Ax ≤ bxi ∈ 0, 1 ∀i
A vector x is feasible if it does not violate any of the linear constraints.
Solving integer programs is NP-hard. Hence, we often consider a relaxed
formulation called a linear program (LP), that has the following form:
min /max
n∑i=1
wixi
s.t. Ax ≤ b0 ≤ xi ≤ 1 ∀i
8
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
Linear programs can be solved in polynomial time using the Ellipsoid method.
Note that unlike in integer programming, entries of a feasible solution of a
linear program may be fractional (when A, b, w consists of rational numbers,
an optimal solution is always rational) and that any solution to the integer
program is a feasible solution to its linear relaxation, thus the value of the
optimal solution to the integer program is as least as good of the optimal
solution to its linear relaxation.
Many approximation algorithms are based on rounding a solution to
a linear relaxation, i.e., converting it into an approximate solution to the
original problem. However, not every linear relaxation can help us construct
a good approximation algorithm. Denote by OPT ∗ (I) the optimal value of
the linear program corresponding to an input I (with a corresponding matrix
A and corresponding vectors b,w). For a maximization problem, we define
the integrality gap matching a linear relaxation as follows:
maxI∈I
OPT ∗ (I)
OPT (I)
(2.1)
For a minimization problem, the fraction in (2.1) is inversed. The integrality
gap gives a lower bound on the factor achieved by an approximation algo-
rithm by rounding a fractional optimal solution. However, even when the
integrality gap of a linear relaxation is high, the gap may be decreased by
adding gap-reducing constraints.
2.1.2 Related Work
We focus our discussion on previous work in the field of scheduling and
allocation algorithms, as well as other related problems, such as the knapsack
problem and the general assignment problem (GAP).
2.1.2.1 Knapsack Problems
Knapsack. Knapsack is a specific sub-case of the problem we consider
later, therefore we pay extra attention to it. In the knapsack problem, we are
given a knapsack with weight capacity W and n items 1, 2, . . . , n, each item
j of weight wj ∈ R+ and a matching profit pj ∈ R+. The goal is to choose
a subset of the n items maximizing their total profit, without exceeding the
weight capacity W . Knapsack is a well known NP-hard problem that can be
9
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
solved in pseudo-polynomial time via dynamic programming [38]. Denote
by P (j, w) the optimal profit when the weight of the knapsack is w and the
available items are 1, 2, . . . , j. Under this notation, our goal is to calculate
P (n,W ). Notice that for j, w > 0:
P (j, w) =
P (j − 1, w) wj > w
max P (j − 1, w) , pj + P (j − 1, w − wj) wj ≤ w(2.2)
and P (j, w) = 0 for j = 0 or w ≤ 0. We can calculate the values P (j, w)
by filling out row by row an (n+ 1) × (W + 1) matrix corresponding to
these values. The complexity of this algorithm is O (nW ), which is pseudo-
polynomial. In section 3.3, we describe a known reduction that transforms
this algorithm into an FPTAS for the knapsack problem (see also [38]).
We present an additional known approximation algorithm for the knap-
sack problem, based on the LP relaxation of its corresponding integer pro-
gram. Although the approximation factor of this algorithm is only 2, the
observations made here will give further intuition in later sections. Define
a binary variable xj ∈ 0, 1 for every item j denoting whether item j was
taken or not. The integer program for the knapsack problem is as follows:
maxn∑j=1
pjxj
s.t.n∑j=1
wjxj ≤W
xj ∈ 0, 1 ∀j
Since this IP cannot be solved efficiently, we relax the last constraint by
replacing it with 0 ≤ xj ≤ 1 for every item j. Notice that the following
greedy algorithm defines an optimal fractional solution, denoted by OPT ∗:
Take items (possibly fractionally) according to pw in descending order.
Claim 2.1.1. There is a 2-approximation algorithm for the knapsack prob-
lem, bounding the integrality gap of LP.
Proof. Assume without loss of generality that:
p1w1≥ p2w2≥ · · · ≥ pn
wn(2.3)
10
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
and that all the items are smaller than the weight capacity W (or else we can
disregard them). Denote by ` the last item chosen by the greedy algorithm.
Notice that only ` can be fractionally chosen. Therefore, there is some c ≤ 1
such that:
p (OPT ∗) =
`−1∑j=1
pj
+ c · p` (2.4)
Denote by OPT the optimal solution to the knapsack problem. Obviously,
p (OPT ∗) ≥ p (OPT ). Consider two possible integer solutions: 1. Items
a1, . . . , a`−1 2. The item a`. Both are feasible solutions, and:`−1∑j=1
pj
+ p` ≥ p (OPT ∗) ≥ p (OPT ) (2.5)
Therefore, the best of the two solutions is a 2-approximation to OPT .
The algorithm in Claim 2.1.1 gives an upper bound on the integrality
gap of LP. We now show how to give a lower bound to this integrality gap.
Claim 2.1.2. The integrality gap of the knapsack’s LP is 2.
Proof. Consider a knapsack instance with two items with profit 1 and sizesW2 ,
W2 + ε for some ε > 0. Notice that an integral solution can take only
one of the items and gain 1, however an optimal fractional solution can
gain almost 2 by taking the first item and most of the second item. As ε
decreases, the profit of the optimal fractional solution approaches 2.
A slight variation of the knapsack problem, more relevant to us, is the
restricted-weights knapsack problem, in which all item weights are upper
bounded by weight k. For this specific case, we improve the 2-approximation
algorithm for the knapsack problem.
Claim 2.1.3. When wj ≤ k for every item j, there is an WW−k -approximation
algorithm for the knapsack problem.
Proof. Let ` denote the number of items chosen by the greedy algorithm,
as before. We claim that taking the first ` − 1 items gives the desired
approximation. First notice that if the `-th item was taken completely, we
11
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
have an optimal integer solution. Otherwise, the weight of the first ` − 1
items is at least W − k. Thus:
`−1∑j=1
pj =
`−1∑j=1
pjwj· wj ≥
p`w`·`−1∑j=1
wj ≥p`w`
(W − k) ≥ p` ·W − kk
(2.6)
And therefore:
`−1∑j=1
pj = p (OPT ∗)− c · p` ≥ p (OPT ∗)− k
W − k·`−1∑j=1
pj (2.7)
Rearranging the last inequality gives us:
`−1∑j=1
pj ≥W − kW
· p (OPT ∗) (2.8)
We note that a matching lower bound to the integrality gap can be
similarly constructed. The full details will be given in the context of the
linear program we construct for our problem (Section 4.1.1).
Knapsack Generalizations. Chekuri and Khanna [12] give a PTAS for
the multiple knapsack problem (MKP), in which there are m knapsacks with
different weight capacities. When also assuming that the weights of an
item can differ from bin to bin, we get the general assignment problem
(GAP). Shmoys and Tardos [37] give a polynomial algorithm that given a
target profit P , either determines that there is no feasible GAP solution
that obtains a profit of P , or gives a solution that obtains a profit of P but
violates the weight capacities by a factor of at most 2. Cohen et al. [15] give a
connection between approximating knapsack and approximating GAP. They
give a greedy algorithm, such that plugging in a knapsack α-approximation
algorithm to it results in an (α+ 1)-approximation to GAP, using a residual
profit concept. Many other variations of the knapsack problem have been
studied (see [24] for a complete study).
12
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
Minimum Knapsack. Similar to the maximization version of the knap-
sack problem, we are given n items [n] = 1, 2, . . . , n, each item j of weight
wj ∈ R+ and a matching cost cj ∈ R+. This time, the goal is to choose
a subset of the n items of minimal cost, such that their weight exceeds a
minimum weight demand of D. The integer programming formulation of
the problem is as follows:
minn∑j=1
cjxj (2.9)
s.t.n∑j=1
wjxj ≥ D (2.10)
xj ∈ 0, 1 ∀j (2.11)
Unlike the maximization version, the integrality gap of the natural LP re-
laxation (relaxing the last constraints to ∀j, 0 ≤ xj ≤ 1) is at least D. To
see this, consider two items with weights D−1, D and costs 0, 1 respectively.
The IP solution takes both items, incurring a cost of 1. However, an optimal
solution to LP can take the first item and only 1D of the second item, verifying
the lower bound of D. Therefore, an LP-rounding approximation algorithm
for this problem must be based on a better linear program, i.e., one with a
lower integrality gap. To reduce the integrality gap, we add a set of gap-
decreasing constraints called the knapsack cover (KC) inequalities. Consider
some set A ⊆ [n] with w (A) =∑
j∈Awj < D, and let D (A) = D − w (A)
be the residual demand of A. For j 6∈ A, define wAj = min wj , D (A). Any
feasible solution to the minimum knapsack problem must remain feasible
when restricted to jobs [n] \A, weights wAj and a desired demand of D (A).
This gives us the following constraints:∑j 6∈A
wAj xj ≥ D (A) ∀A ⊆ [n] , w (A) < D (2.12)
Notice that the previous example giving us the integrality gap of D is no
longer feasible, since it violates the constraint matching the item of size
D − 1 (for D > 1). As it turns out, the integrality gap after adding the
knapsack cover inequalities is at most 2 [11]. This gives an example of how
adding additional constraints can strengthen a linear relaxation.
13
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
2.1.2.2 Scheduling Algorithms
In the basic setting of scheduling algorithms, there are n jobs and m servers.
Every job j is usually associated with a weight wj and a processing time
pij on every machine i. Jobs are often given with matching release times rjand deadlines dj . We denote by Cj the completion time of job j. The goal
of the scheduling algorithm can vary from weight maximization, makespan
minimization (i.e., minimize maxj Cj), minimizing the weighted flow time
(∑
j wjCj) and more.
Weight Maximization. Different interesting variations of the basic set-
tings include identical machines, where the processing time pij of a job is
equal on all machines and related machines, where the processing time of
a job is of the form pij =pjsi
where si is the speed of machine i. When
processing times are arbitrary, the machines are called unrelated.
When job weights are identical, Bar Noy et al. [5] give a greedy 2-
approximation algorithm. They go over the machines one by one and for
each machine allocate jobs according to the following greedy rule: Out of
all available jobs at a time t (i.e., have not been allocated already and can
be allocated at time t without violating their deadline), take the job that
minimizes the completion time when allocated at time t. In the case of k
identical machines, the same algorithm obtains a tight bound of(1+ 1
k )k
(1+ 1k )
k−1.
For the case of arbitrary weights, [5] achieve a 2-approximation for the
single server case and a 3-approximation for unrelated machines, assuming
that the input is integral and polynomially bounded. Their algorithm de-
composes a fractional optimal solution into a relatively small set of feasible
solutions, with their average profit being a 2-approximation (thus, at least
one of the solutions is a 2-approximation). We note that without assuming
that the input is polynomially bounded, the approximation factors increase
to 3 and 4, respectively. These results have later been improved by [32]
to a (2 + ε)-approximation for both cases, using the local ratio technique.
We note that both algorithms apply to a broader case, where every job is
associated with a set of intervals in which it can be allocated (instead of a re-
lease time and deadline). This case is usually referred to as the Job Interval
Scheduling Problem (JISP). [14] give an ≈ 1.582-approximation algorithm
for JISP when job weights are identical, and improve their bounds when the
14
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
number of options for each job is limited. We note that discrete versions of
several scheduling problems can be viewed as special cases of GAP, therefore
the GAP approximation bounds apply to them.
A different interesting model is one where jobs are given with widths bjsuch that the total width of scheduled jobs at any time must not exceed
a bound B. Philips et al. [34] give a 6-approximation algorithm based
on the decomposition technique used in [5] to the case where jobs have
multiple options (possible intervals) in which they can be allocated. Using
the local ratio technique, [32] improve the approximation factor to 5 (when
time windows are allowed, the approximation factor is 5 (1 + ε)) and give
a 3-approximation when each job has a single option in which is can be
allocated. For the single-option case, Calinescu et al. [10] give a (2 + ε)-
approximation algorithm. When all widths are at most B2 , they give a
simpler algorithm that obtains an approximation factor of 2.
The simplest setting of scheduling algorithms of JISP with a single server
where every job has a single option, reduces to finding a maximum indepen-
dent set in interval graphs. This problem is known to be tractable, since
interval graphs are perfect [20]. Bar Noy et al. [32] give a simple efficient
implementation of solving this problem.
Lawler [28] considered the preemptive version of the single server schedul-
ing problem, where jobs do not need to be scheduled continuously. We fully
discuss Lawler’s algorithm in Section 3.3, as it is well related to our model.
Other Objective Functions. Another objective function which has re-
ceived much attention is the makespan minimization objective. When pro-
cessing times are identical and there are no deadlines, there is a simple
greedy algorithm that gives a 2-approximation: Go over the jobs and allo-
cate each job to the least busy machine in the current state. By sorting the
objects first by their processing time in non-increasing order, the approxi-
mation factor can be improved to 43 [38]. PTAS algorithms for related and
identical machines are also known [23, 19, 38]. For unrelated machines, the
best known approximation factor is 2 and there is no(32 − ε
)-approximation
unless P = NP . We refer the reader to [8] for a comprehensive study on
various models that can be efficiently solved, and to [25] for an extensive
survey on interval scheduling with various objective functions.
15
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
2.2 Algorithmic Mechanism Design
2.2.1 Basic Terminology
Mechanism Design is a sub-field of economic theory which has received re-
cent attention from computer scientists. In its algorithmic aspect, the goal
is to design computationally efficient choice mechanisms, such as auctions
or resource allocation, while optimizing an objective function. Some ex-
amples of objective functions include the social welfare, which is the total
value gained by users, or the total profit accrued by the mechanism. The
difficulty of algorithmic mechanism design is that unlike classic algorithmic
design, participants act rationally in a game theoretic sense and may deviate
in order to maximize their personal utilities. Since participants’ preferences
are usually kept private from the mechanism, we search for efficient mecha-
nisms that implement certain strategic properties to deal with participants’
incentives, e.g., incentivize users to truthfully report their preferences, while
attempting to optimize an objective function.
Mechanism. In the basic setting, there are n participants called players,
typically denoted by the index set 1, 2, . . . , n. Every player j holds a
private type vj taken out of a known type space Vj . The player reports to a
mechanism a type bj ∈ Vj , which in standard literature is called the bid or
the reported type of the player, and in general may differ from the player’s
true type. In single-parameter domains, the type of a player consists of a
single scalar. Otherwise, the domain is called a multi-parameter domain.
Let V = V1 × · · · × Vn denote the space of all valid types and let O denote
the set of all possible outcomes of the mechanism.
A mechanism M = (f, p) consists of an allocation rule f : V → O and
a pricing rule pj : V → R for every player j. The mechanism, given a
reported type vector b = (b1, . . . , bn), computes an outcome o = f (b) and
charges pj (b) from j. Each player j strives to maximize its utility:
uj (b) = vj (o)− pj (b) (2.13)
where vj (o) denotes the value gained by player j under the outcome o.
16
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
Incentive-Compatibility. An incentive compatible mechanism sets pay-
ments such that truth telling is a dominant strategy for all players. Defi-
nitions of incentive compatible (truthful) mechanisms vary with respect to
the strength of the equilibria induced by the mechanism. For a vector v,
denote by v−j the vector v restricted to players other than j and denote V−jaccordingly.
A deterministic mechanism is truthful if for any player j, reporting its
true type maximizes her utility. That is, given any reported value bj ∈ Vjand any v−j ∈ V−j , with vj ∈ Vj being the true type of player j, we have:
uj ((vj , v−j)) ≥ uj ((bj , v−j)) (2.14)
A randomized mechanism is truthful-in-expectation if for any player j,
reporting its true type maximizes the expected value of uj (b). That is,
(2.14) holds in expectation. A weaker notion of truthfulness, in which truth-
telling is a Bayes-Nash equilibrium, is called Bayesian Incentive Compati-
bility (BIC). Here, every player draws her type out of a unique distribution
which is known to the mechanism. A mechanism is BIC if the expected
utility of every player is maximized when truthfully reporting her type, as-
suming other players draw their values from their matching distributions
and also report their types truthfully.
Individual Rationality. Another desired property is that players do not
lose by participating in the mechanism. A mechanism is individually rational
(IR) if uj (v) does not receive negative values when player j bids truthfully,
for every j and type vector v ∈ V . Specifically, non-allocated players will
always be charged 0.
2.2.2 Related Work
An extensive amount of work has been carried out in the field of algorithmic
mechanism design, starting with the seminal paper of Nisan and Ronen [30]
(see [31] for a survey book). Prior to their paper, mechanism design received
much attention by economists who focused on exact solutions or characteri-
zations of truthful mechanisms, mostly under Bayesian settings and usually
while ignoring time or communication complexity issues. Myerson, in his
celebrated paper [29], gave a strong characterization of implementable al-
17
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
location rules (i.e., allocation rules for which there exists a payment rule
making the mechanism truthful) for single item auctions under bayesian
settings: For the mechanism to be truthful, the underlying allocation rule
must be monotone. Formally, if we consider some player i and fix the bids
of the rest of the players, the expected allocation of player i increases as a
function of her bid bi. Denote by fi the allocation of player i when allocating
by f (fi (b) ∈ [0, 1]). When the price functions take the following form:
pi (bi, b−i) = hi (b−i) + bi · fi (bi, b−i)−bi∫0
fi (u, b−i) du (2.15)
for some function hi independent of bi, then monotonicity is a sufficient
condition for constructing a truthful mechanism. This result has been later
extended by Archer and Tardos [1] for a large class of single-parameter
problems. Moreover, for every monotone allocation rule f , there is a unique
payment rule p such that M = (f, p) is truthful and unallocated players
always pay 0.
Compared to single-parameter domains, much less is known about the
characterization of implementable allocation rules for multi-parameter prob-
lems. Rochet [35] gave an equivalent property to monotonicity called cyclic
monotonicity, which is a necessary and sufficient condition for truthfulness.
Yet, it is unclear how to use this property to easily construct truthful mech-
anisms from it and only few successful efforts are known (for example, [27]).
Saks and Yu [36] showed that for deterministic settings, cyclic monotonicity
is equivalent to a simpler property called weak monotonicity, which condi-
tions only on cycles of length 2 (see also [2]). However, this result is not
valid for randomized mechanisms [7].
Efficient payment computation is also a fundamental task of efficient
mechanism design. The individually rational version of the VCG mechanism,
for instance, requires n + 1 calculations of the optimization function [31].
Recently, Babaioff et al. [4] designed a randomized implicit payment scheme
that requires only a single execution of the optimization algorithm. Yet, it
is only individually rational in expectation, and with small probability the
mechanism might pay players a relatively large payment.
18
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
Black-Box Reductions. The ”holy grail” of algorithmic mechanism de-
sign is finding a black-box reduction that can turn any (approximation)
algorithm into a truthful (approximation) mechanism. The VCG mecha-
nism, which we present in Section 5.1, constructs a truthful mechanism for
any utilitarian objective function (e.g., sum of players’ utilities) that can be
optimally calculated. However, when the underlying optimization problem
is NP-hard, VCG turns out to be inefficient. Recent lower bounds [33, 17]
on deterministic and universally truthful mechanisms (a slightly weaker ver-
sion of truthfulness) rule out the possibility of finding a black-box reduction
in these domains. Nevertheless, the question of finding a reduction from
randomized mechanisms to algorithmic design remains an open question.
Several black-box reductions have been suggested for large classes of
problems. Lavi and Swamy [26] construct a truthful-in-expectation mech-
anism for packing problems that are solved through LP-based approxima-
tion algorithms. Their reduction maintains the approximation factor of the
original algorithm, but for their reduction to work, the approximation algo-
rithm must bound the integrality gap of the ”natural” LP for the problem
- and this is not always possible. Dughmi and Roughgarden [18] prove
that packing problems that admit an FPTAS can be turned into a truthful-
in-expectation mechanism which is also an FPTAS. Recently, Hartline and
Lucier [22] showed that any approximation algorithm for a single-parameter
problem can be transformed into a Bayesian Incentive-Compatible (BIC)
mechanism. This result has been improved since then by [21, 6] for multi-
parameter settings.
Connecting Between Truthfulness and Scheduling. Nisan and Ro-
nen [30] were the first to consider scheduling problems that take into account
players’ incentives. They gave an m-approximation for makespan minimiza-
tion in the setting of scheduling on unrelated jobs, where m is the number
of servers. Unlike in our model, the players in this setting are actually the
servers and not the job owners. They gave a lower bound of 2 on determin-
istic truthful mechanisms and conjectured that the lower bound is actually
m, a conjecture that was proved to be correct for anonymous machines [3].
Archer and Tardos [1] gave a randomized 3-approximation algorithm
when the servers are related and noted that when the goal is minimizing the
sum of completion times, the optimization problem can be solved efficiently,
19
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
and therefore its corresponding VCG mechanism is efficient. Recently, a de-
terministic truthful PTAS mechanism for the case of related machines has
been constructed by Christodoulou and Kovacs [13], matching the approxi-
mation factor of the optimization problem. Lavi and Swamy [27] constructed
several mechanisms for makespan minimization when all job sizes are either
low or high, based on the cyclic monotonicity property.
Market-Based Resource Allocation. Market-oriented mechanisms have
long been considered as means for resource allocation in shared computing
systems, often focusing on the empirical valuation of mechanisms. Grid
computing environments, for example, enable the sharing, selection and
aggregation of computing resources owned by resource providers that are
geographically distributed, so as to perform large-scale computations. The
market-like behavior of consumers and providers encourages the use of eco-
nomic models to achieve equilibria (i.e., service supply equals the level of
demand). In recent years, researchers suggested an alternative approach to
resource management systems of emphasizing user utilities, as opposed to
commonly used mechanisms driven by system-centric objectives. Specifi-
cally, for grid environments, Buyya et al. [9] proposed utility-based mech-
anisms for resource management, also in the presence of grid brokers. The
main conecpt they use is that the value of processing applications must
depend on their deadlines, implying that similar applications with different
deadlines should be treated differently. Similar concepts have been discussed
regarding cluster computing enviroments [39].
20
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
Chapter 3
The Bounded Flexible
Scheduling (BFS) Problem
3.1 Definitions and Notation
In the Bounded Flexible Scheduling (BFS) problem, a cloud provider is in
charge of a cloud containing a fixed number of C servers. The cloud provider
receives requests from n clients, denoted by J = 1, 2, . . . n, where each
client has a job that needs to be executed. We will often refer to a client
either as a player or by the job belonging to her. The cloud provider can
choose to reject some of the job requests, for instance if allocating other jobs
increases its gain. In this model, the cloud can gain only by fully completing
a job. That is, partially completing a job is considered as if the job hasn’t
been processed and thus the cloud provider does not gain from it. We assume
that the time axis is divided into T discrete time slots T = 1, 2, . . . T.Every job j is described by a tuple 〈Dj , kj , vj〉. The first parameter
Dj , the demand of job j, is the total amount of demand units required
to complete the job, where a demand unit corresponds to a single server
being assigned to the job for a single time slot. Parallel execution of a job
is allowed, that is, the job can be executed on several servers in parallel.
In this model we assume that the additional overhead due to parallelism is
negligible. However, parallel execution of a job is limited by a threshold kj ,
which is the maximal number of servers that can be simultaneously assigned
to job j in a single time slot. We assume that k , maxj kj is substantially
21
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
smaller than the total capacity C, i.e., k C, as typically assumed in
practical settings.
Let vj : T → R+,0 be the valuation function of job j. That is, vj (t)
is the value gained by the owner of job j if job j is completed at time t.
The goal is to maximize the sum of values of the jobs that are scheduled
by the cloud. Naturally, the valuation function vj(t) can be assumed to be
monotonically non-increasing in t. Nevertheless, we will later discuss the
case where this assumption is relaxed and vj is any general function. Three
families of valuation functions will be of specific interest to us:
• Deadline Valuation Functions: Here, players are interested only
in their job being completed until a particular deadline (due date).
Formally, vj (t) is a step function, which is equal to a constant scalar
vj until the deadline dj , and 0 afterwards.
• General Monotone Valuation Functions: The functions vj(t) are
arbitrary monotonically non-increasing functions.
• General Valuation Functions: The functions vj(t) are arbitrary
functions.
For simplicity of notation, when discussing the case of general (monotone)
valuation functions, we will set dj = T for every player. Define Tj =
t ∈ T : t ≤ dj as the set of time slots in which job j can be executed
and Jt = j ∈ J : t ≤ dj as the set of jobs that can be executed at time t.
A mapping yj : Tj → [0, kj ] is an assignment of servers to job j per
time unit, which does not violate the parallelism threshold kj1. A mapping
which fully executes job j is called an allocation. Formally, an allocation
aj : Tj → [0, kj ] is a mapping for job j with∑
t aj (t) = Dj . Denote by Ajthe set of allocations aj which fully execute job j and let A =
⋃nj=1Aj . Let
s (yj) = min t : yj (t) > 0 and e (yj) = max t : yj (t) > 0 denote the start
and end times of a mapping yj , respectively. Specifically, for an allocation
aj , e (aj) is the time in which job j is completed when the job is allocated
according to aj , and vj (e (aj)) is the value gained by the owner of job j.
We will often use vj (aj) instead of vj (e (aj)) to shorten notations.
1For tractability, we assume that the assignment yj is a continuous decision variable.In practice, non-integer allocations will have to be translated to integer ones, for exampleby processor sharing within each time interval. The precise ways of how to implementsuch techniques are beyond the scope of the present paper.
22
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
Figure 3.1: An example of a mapping.
3.2 NP-Hardness of BFS
The BFS problem can be viewed as a generalization of the knapsack problem,
which is a well known NP-complete problem. Recall that in the knapsack
problem, we are given a knapsack with weight capacity W and n items
1, 2, . . . , n, each item j of weight wj ∈ R+ and a matching profit pj ∈ R+.
The goal is to choose a subset of the n items maximizing their total profit,
without exceeding the weight capacity W .
We give a reduction from optimally solving knapsack, with the weight
capacity being k, to optimally solving BFS. Consider a BFS instance with
T = 1 and the following jobs: Every item j in the knapsack instance is
converted to a single job j with Dj = wj and vj = pj (since T = 1, the
valuation function reduces to a single scalar). Let P =∑
j pj denote the
total profit of all items. To this BFS instance, we add C − k jobs with unit
demand (D = 1) and a value larger than P . An optimal BFS solution must
take these C−k jobs and allocate the knapsack jobs according to an optimal
solution to the knapsack instance.
3.3 Solving the Unbounded Case
When there are no parallelization bounds, the BFS model reduces to the
problem of preemptive scheduling on a single server.
Preemptive Scheduling on a Single Server (PSSS). In the classic
formulation of this problem (denoted as 1|pmtn, rj |∑wjUj in scheduling
literature), there are n jobs [n] = 1, 2, . . . , n, each job j of size Dj , weight
23
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
wj , release date rj and deadline dj . The server can run in each time slot
only one job and can execute jobs preemptively. The goal is to schedule a
subset of the jobs that maximizes the total weight of scheduled jobs, where
scheduled jobs must meet their matching deadlines and can be scheduled
only after their release dates.
First note that we can construct a simple feasibility test for a subset
S of jobs (i.e., to verify whether S can be scheduled without violating re-
lease/deadline constraints) using a preemptive version of the well-known
Earliest Due Date (EDD) rule: In every time slot t, out of the uncompleted
jobs released before t, allocate the job with the earliest deadline.
Claim 3.3.1. A subset S of jobs if feasible (i.e., can be allocated without
violating release or deadline constraints) if and only if its preemptive EDD
form is feasible.
Proof. It is enough to show how to transform a feasible scheduling of S
into preemptive EDD form. Recall that T denotes the set of all time slots.
Let F : T → S denote the feasible (preemptive) scheduling of S and let
EDD : T → S denote the EDD scheduling of S. Let t be the earliest time
slot in which F and EDD differ. Define j = F (t) and j′ = EDD (t).
Notice that rj ≤ t by the feasibility of F and that rj′ ≤ t by the definition
of the preemptive EDD rule. Moreover, since t is the first time slot in which
F and EDD differ, both jobs j, j′ haven’t been completed before time t in
both schedulings. Therefore, we have: dj′ ≤ dj , since EDD chose j′ over
j, and F (t′) = j for some time t′ > t. If we replace F (t) and F (t′), the
resulting scheduling will remain feasible. We continue this process until F
is of preemptive EDD form.
Lawler [28] gives a dynamic-programming algorithm that solves PSSS
in O(nk2W
)time and O
(k2W
)space, where k is the number of distinct
release dates andW is the sum of all weights. His algorithm assumes that the
weights are integers, however any other parameter is not required to be an
integer. Note that the running time of the algorithm is pseudo-polynomial,
thus considered inefficient. Nevertheless, we will later show how to transform
this algorithm into an FPTAS for PSSS. Meanwhile, we present a simplified
version of Lawler’s algorithm for the case where all of the release dates are
identical (and without loss of generality, equal to 1) that runs in O (nW ).
24
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
FPTAS(ε)1. Let K = εwmax
n .2. Define new weights: w′j =
⌊wj
K
⌋.
3. Find an optimal solution S′ with weights w′j using the pseudo-polynomialalgorithm and return it.
Theorem 3.3.2. PSSS with identical release dates can be optimally solved
in O (nW ) time.
Proof. Assume that jobs are ordered by their deadlines in ascending order,
that is: d1 ≤ d2 ≤ · · · ≤ dn. Notice that when all release times are identical,
there is always an optimal solution in which there are no idle time slots. For
a subset S of jobs let w (S) =∑
j∈S wj and let c (S) be the completion time
of the last job in S according to its preemptive EDD order. Let Fj be the
set of all feasible subsets S ⊆ [j]. Define:
Cj (w) = min c (S) : S ∈ Fj , w (S) ≥ w (3.1)
That is, Cj (w) is the earliest completion time of a feasible subset S ⊆ [j] in
its preemptive EDD schedule, with profit of at least w. If no such feasible
S exists, we define Cj (w) =∞. Consider a set S realizing the value Cj (w).
If j 6∈ S then Cj (w) = Cj−1 (w). Otherwise, the minimal completion time
of such a subset S is Dj +Cj−1 (w − wj), and this set is feasible only if the
last expression is at most dj . To summarize:
Cj (w) =
Cj−1 (w) Dj + Cj−1 (w − wj) > dj
min Cj−1 (w) , Dj + Cj−1 (w − wj) otherwise
(3.2)
With Cj(w) = 1, the first time slot, if w ≤ 0. Thus, we can calculate in
O (nW ) time all of the values Cj (w). The algorithm will return the maximal
value of w for which Cn (w) <∞.
From Pseudo-Polynomial Algorithms to FPTAS. As mentioned,
pseudo-polynomial algorithms are considered inefficient. However, we can
easily transform the pseudo-polynomial algorithm into an FPTAS for the
problem. Let wmax = maxj wj be the maximal weight of a job. The
25
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
algorithm FPTAS(ε) runs the pseudo-polynomial algorithm with weights
scaled down by K = εwmaxn and rounded down to the nearest integer (this
will cause us to incur a small loss compared to the optimal solution).
Claim 3.3.3. Let OPT be the optimal solution with weights wj. Then:
w(S′)≥ (1− ε)w (OPT ) (3.3)
Proof. First, we assume that every job can be singly scheduled (or else, we
can remove such jobs from the instance). By the definition of w′j :
∀j K · w′j ≤ wj ≤ K(w′j + 1
)(3.4)
and by the optimality of S′ under weights w′j , w′ (S′) ≥ w′ (OPT ). Now:
w(S′)≥ K · w′
(S′)≥ K · w′ (OPT ) =
∑j∈OPT
Kw′j ≥∑
j∈OPT(wj −K)
≥ w (OPT )−Kn = w (OPT )− εwmax ≥ (1− ε) · w (OPT )
because w (OPT ) ≥ wmax by the assumption made at the beginning.
Applying this transformation to our dynamic-programming algorithm
gives an FPTAS that runs in O(nWK
)= O
(n nWεwmax
)= O
(n3
ε
)time, since
W ≤ n · wmax. This result can be extended to a truthful-in-expectation
mechanism for the unbounded case which is also an FPTAS, by a result of
Dughmi and Roughgarden:
Theorem 3.3.4 ([18]). Every binary packing problem of polynomial dimen-
sion that admits an FPTAS also admits a truthful-in-expectation mechanism
that is an FPTAS, with expected polynomial running time.
Unfortunately, these results cannot be extended to the case where par-
allelized execution of jobs is bounded. The ideas behind the dynamic pro-
gramming algorithm cannot be applied when limiting the jobs (informally,
after dividing every time slot into C sub-slots, the parallelization bounds
add constraints which cancel out the “nice” recursive structure of an opti-
mal solution, which allowed us to find it efficiently). In the next chapter, we
give a new approximation algorithm to the BFS problem, while decreasing
the approximation factor by a multiplicative factor of(
1 + CC−k
). Note that
for large-scale clouds, the multiplicative loss approaches 2.
26
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
Chapter 4
An Approximation
Algorithm for BFS
In this chapter we present an algorithm for BFS that approximates the social
welfare, i.e., the sum of values gained by the players. When discussing the
approximation algorithm, we assume that players bid truthfully. In Chapter
5, we describe a payment scheme that gives players an incentive to bid
truthfully. This justifies the assumption made here.
This chapter proceeds as follows: We begin by describing an LP relax-
ation for the case of deadline valuation functions and continue by present-
ing a canonical solution form in which all mappings are Monotone Non-
Decreasing (MND) mappings (see Section 4.1.2 for formal definition). This
result is then generalized to the case of general monotone valuation func-
tions (Section 4.2). We also show that the case of general valuation functions
can be reduced to the case of general monotone valuation functions (Section
4.3). Finally, we give a decomposition algorithm (Section 4.4) which yields
an α-approximation to the optimal social welfare of BFS.
4.1 Deadline Valuation Functions
We begin by defining an LP relaxation for the case of deadline valuation
functions. In Section 4.3, we show how to extend the LP to deal with
general valuation functions.
27
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
Figure 4.1: A fractional solution OPT ∗ verifying the integrality gap of thenatual relaxation of (IP).
4.1.1 LP Formulation of BFS with Deadline Valuation Func.
Consider the following IP. Every variable yj (t) for t ∈ Tj in (IP) denotes the
number of servers assigned to j at time t. We use yj to denote the mapping
induced by the variables yj (t)t∈Tj and xj as a binary variable indicating
whether job j has been fully allocated or not at all.
(IP) maxn∑j=1
vjxj
s.t.∑t∈Tj
yj (t) = Dj · xj ∀j ∈ J (4.1)
∑j∈Jt
yj (t) ≤ C ∀t ∈ T (4.2)
0 ≤ yj (t) ≤ kj ∀j ∈ J , t ∈ Tj (4.3)
xj ∈ 0, 1 ∀j ∈ J (4.4)
Constraints (4.1),(4.2) and (4.3) are job demand, capacity and paralleliza-
tion constraints.
We first relax the constraints xj ∈ 0, 1 to 0 ≤ xj ≤ 1 for every j ∈ J .
The integrality gap of the resulting linear program can be as high as Ω (n).
To see this, consider the following instance: There are nC jobs with kj = 1
for every job j which are divided into n sets S0, . . . , Sn−1, each of size C. A
job j ∈ Si requests Dj = 2i demand units which need to be completed before
time 2i. Formally, vj = 1 and dj = 2i. An optimal integral solution can
gain at most C, since any completed job must receive a demand unit at time
t = 1. Yet, the optimal fractional solution gains C + C·(n−1)2 by mapping
28
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
the jobs as follows (see Figure 4.1): For jobs j ∈ S0 we set yj (1) = 1, thus
completing them fully. For jobs j ∈ Si with i ≥ 1, we set yj (t) = 1 for
t ∈(2i−1, 2i
]and yj (t) = 0 otherwise, and by that completing half of job j
before t = 2i.
Thus, we add the following set of constraints to the linear program:
yj (t) ≤ kjxj ∀j ∈ J , t ∈ Tj (4.5)
Intuitively, these constraints “prevent” us from getting bad mappings which
do not correspond to feasible allocations. For instance, consider the example
from the previous paragraph. The mappings of jobs j ∈ Si for i ≥ 1 violate
constraints of type (4.5), since for t ∈(2i−1, 2i
]we have yj (t) = 1 yet xj = 1
2 .
Such mappings cannot be extended to feasible allocations. That is, if we
would have extended the mapping yj (disregarding capacity constraints) by
dividing every entry in yj by xj , we would have exceeded the parallelization
threshold of job j. Henceforth, we refer to the linear program, including the
constraints in (4.5), as (LP-D).
The integrality gap of (LP-D) is at least CC−k . To see this, consider a
BFS instance with n jobs in which C = kn − δ for some k and some small
δ > 0. For every job j set Dj = kj = k and vj = 1. Any BFS solution can
schedule at most n − 1 jobs. Yet, an optimal fractional solution to (LP-D)
can fully allocate n − 1 jobs and fractionally allocate a(1− δ
k
)-fraction of
the last job, gaining n− δk . Thus, the integrality gap is bounded below by:
n− δk
n− 1=kn− δkn− k
=C
C − k + δ(4.6)
This bound approaches CC−k as δ decreases.
In the appendix we present further insights on the choice of (4.5), by
considering an alternative formulation of BFS as a configuration LP and
showing its equivalence to (LP-D). In fact, (LP-D) can be viewed as an
efficient way of implementing the configuration LP. The remainder of this
chapter is dedicated to constructing an approximation algorithm which gives
an upper bound to the integrality gap of:
inf
(1 +
C
C − k
)(1 + ε) : ε > 0
= 1 +
C
C − k(4.7)
29
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
Reallocate(y)1. While y contains non-MND mappings
1.1. Let j be a job generating a maximal(a, b)-violation according to .1.2. ReallocationStep(y, j, a, b)
ReallocationStep(y, j, a, b)1. Let j′ be a job such that yj′ (a) < yj′ (b)2. Tmax =
t ∈ [a, b] : yj′ (t) = yj′ (b)
3. δ = max
yj′ (t) : t ∈ [a, b] \ Tmax
4. ∆ = min
yj(a)−yj(b)1+|Tmax| ,
yj′ (b)−yj′ (a)1+|Tmax| , yj′ (b)− δ
5. Reallocate as follows:
5.1. yj′ (t)← yj′ (t)−∆ for every t ∈ Tmax
5.2. yj′ (a)← yj′ (a) + ∆ · |Tmax|5.3. yj (a)← yj (a)−∆ · |Tmax|5.4. yj (t)← yj (t) + ∆ for every t ∈ Tmax
4.1.2 The Canonical MND Form
We now present a canonical solution form of solutions for (LP-D), in which
all of the mappings are monotonically non decreasing (defined next). This
canonical form will allow us to construct an approximation algorithm for
BFS with a good approximation factor.
Definition 4.1.1. A monotonically non-decreasing (MND) mapping (allo-
cation) yj : Tj → [0, kj ] is a mapping (allocation) which is monotonically
non-decreasing in the interval [s (yj) , e (yj)].
MND mappings propose implementational advantages, such as the al-
location algorithm being non-preemptive, as well as theoretical advantages
which will allow us to construct a good approximation algorithm for BFS.
We first present the main result of this subsection:
Theorem 4.1.2. There is a poly(n, T ) time algorithm that transforms any
feasible solution y of (LP-D) to an equivalent solution that obtains the same
social welfare as y, in which all mappings are MND mappings.
This theorem is a result of the following reallocation algorithm. Let y be
a feasible solution to (LP-D). To simplify arguments, we add an additional
“idle” job which is allocated whenever there are free servers. This allows us
30
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
to assume without loss of generality that in every time slot, all C servers are
in use. We present a reallocation algorithm that transforms the mappings in
y to MND mappings. The reallocation algorithm will swap between assign-
ments of jobs to servers, without changing the completed fraction of every
job (xj), such that no completion time of a job will be delayed. Since the
valuation functions are deadline valuation functions, the social welfare of the
resulting solution will be equal to the social welfare matching y. Specifically,
an optimal solution to (LP-D) will remain optimal.
We introduce some definitions and notations prior to the description of
the reallocation algorithm. Denote by Ay (t) = j : yj (t) > 0 the set of
jobs active at time t in y.
Definition 4.1.3. A job j ∈ Ay (b) generates an (a, b)-violation if a < b and
yj (a) > yj (b). Violations are weakly ordered according to a binary relation
over T × T , such that:
(a, b) (a′, b′
)⇔ b < b′ or
(b = b′
)∧(a ≤ a′
)(4.8)
Note that there can be several maximal pairs (a, b) according to .
Given a solution y to (LP-D), our goal is to eliminate all (a, b)-violations
in y and consequently remain with only MND mappings, keeping y a feasible
solution to (LP-D). The reallocation algorithm works as follows: In every
step we try to eliminate one of the maximal (a, b)-violations, according to
the order induced by . Let j be the job generating this maximal (a, b)-
violation. The main observation is that there must be some job j′ with
yj′ (a) < yj′ (b), since in every time slot all C servers are in use. We apply a
reallocation step, which tries to eliminate this violation by shifting workload
of job j from a to later time slots (b in particular), and by doing the opposite
to j′. To be precise, we increase yj in time slots in Tmax (line 2) by a value
∆ > 0 (line 4), and increase yj′ (a) by the amount we decreased from other
variables. We note that if we do not decrease yj′ for all time slots in Tmax,
we will generate (a, b)-violations for a < a and therefore the reallocation
algorithm may not stop.
We choose ∆ such that after calling the reallocation step either: 1.
yj (a) = yj (b) 2. yj′ (a) = yj′ (b) 3. The size of Tmax increases. In the
second case, if the (a, b)-violation hasn’t been resolved, there must be a
different job j′′ ∈ Ay (b) with yj′′ (a) < yj′′ (b), and therefore we can call
31
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
the reallocation step again. In the third case, we simply expand Tmax and
recalculate ∆. The reallocation algorithm repeatedly applies the realloca-
tion step, choosing the maximal (a, b)-violation under , until all mappings
become MND mappings. The following claim guarantees the correctness of
the reallocation algorithm.
Claim 4.1.4. Let y be a feasible solution of (LP-D) and let j be a job
generating a maximal (a, b)-violation over . Denote by y the vector y after
calling ReallocationStep(y, j, a, b) and let(a, b)
be the maximal violation in
y over . Then:
1. y is a feasible solution of (LP-D).
2.(a, b) (a, b)
3. No new (a, b)-violations are added to y.
Proof. Denote by yj , yj the mappings of j before and after the reallocation
step, and denote yj′ , yj′ similarly. By the choice of (a, b), for every t ∈ (a, b]
there is no (t, b)-violation and thus:
∀t ∈ (a, b] yj (t) ≤ yj (b) (4.9)
∀t ∈ (a, b] yj′ (t) ≤ yj′ (b) (4.10)
By the construction of the reallocation step, since we reduce yj′ by ∆ for
every time slot in Tmax and halt when one the strong inequalities reach
equality or when the size of Tmax increases, we have:
∀t ∈ [a, b] yj (t) ≤ yj (a) (4.11)
∀t ∈ [a, b] yj′ (t) ≤ yj′ (b) (4.12)
Since by the choice of ∆, for every t ∈ Tmax we have yj (t) + ∆ ≤ yj (a) −∆|Tmax| (and similarly for (4.12)). The reallocation step only decreases
yj (a) , yj′ (b) and keeps xj , xj′ fixed, thus both j, j′ do not violate any con-
straint of type (4.5) in y, which proves 1 since we started with a feasible
solution of (LP-D).
By the maximality of (a, b) and since yj (a) , yj′ (b) are upper bounds on
the entries of yj , yj′ in [a, b], we couldn’t have created any(a, b)
-violation
32
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
Figure 4.2: Resolving an (a, b)-violation generated by j.
for b < b. Consider the second type of violations which might have been
caused, i.e., an (a, b)-violation for a < a. By (4.12), j′ does not generate
such a violation. Since b ∈ Tmax and by (4.9), the same goes for j, proving
2 and 3.
To show that the reallocation algorithm converges in poly (n, T ) time, con-
sider a potential function which is the total number of violations. The
reallocation algorithm resolves at least one violation after at most nT calls
to the reallocation step. Since the maximal initial number of such viola-
tions is bounded by O(nT 2
)and since a reallocation step can be efficiently
implemented, the time complexity is poly (n, T ).
Note. The running time of our algorithms depend on T . Since the output
size is Θ (nT ), our algorithms are polynomial in the size of the output.
4.2 General Monotone Valuation Functions
The linear program for the case of general monotone valuation functions will
be similar in spirit to the one described for deadline valuation functions. As
we will soon see, a fractional solution will induce a distribution over end
times. To keep the integrality gap low, every end time will be associated with
a mapping corresponding to a feasible allocation, as before. The simplest
way to obtain such solutions will be to split every player into T subplayers,
one for each end time, each associated with a deadline valuation function.
Formally, every player j will be substituted by T subplayers j1, j2, . . . jT ,
all with the same demand and parallelization threshold as j. For ease of
33
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
notation, we denote by yej (t) the variables in the linear program matching
subplayer je, and use similar superscript notations henceforth. For every
subplayer je, we set vej = vj (e) and dej = e. Finally, we add an additional
set of constraints, limiting the distribution of j over end times to 1. The
linear program (LP) is described below:
(LP) maxn∑j=1
∑e∈T
vejxej
s.t.∑t≤dej
yej (t) = Dj · xej ∀je (4.13)
∑je
yej (t) ≤ C ∀t ∈ T (4.14)
∑e∈Tj
xej ≤ 1 ∀j ∈ J (4.15)
yej (t) ≤ kjxej ∀je, t ≤ dej (4.16)
0 ≤ yej (t) ≤ kj ∀je, t ≤ dej (4.17)
Every solution to BFS is a feasible solution to this relaxed linear program:
A job j allocated according to an allocation aj matches the subplayer je(aj).
Note that the reallocation algorithm can be applied here, transforming map-
pings of subplayers to be MND mappings. The reallocation algorithm does
not change the values xej , thus it will not cause us to violate (4.15).
Notice that up until now we did not use the assumption that all of the
valuation functions are monotonically non-increasing. Note that none of
the constraints in (LP) prevent a fractional solution from matching some
mapping y to an end time later than e(y). When the valuation functions are
monotonically non-increasing, a fractional solution will have no intention
in doing so. Yet, when discussing general valuation functions, a fractional
solution may gain from some allocation more than the value a feasible BFS
solution would have gained. In spite of this, we show in the next section that
this can be resolved even when the valuation functions are non-monotone.
From this point on, we refer to (LP) as the relaxed linear program for
general valuation functions, after adding (4.15). When applying results to
deadline valuation functions settings, every player j will be viewed as a
single subplayer jdj (making (4.15) redundant).
34
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
4.3 General Valuation Functions
Even though in natural settings valuation functions are monotonically non-
increasing, as the value gained by users from their job being completed
usually decreases over time, we show that this assumption is not mandatory.
We reduce the case of general valuation functions to the former setting,
where the valuation functions are monotonically non-increasing. Practically
speaking, if a job is completed in some time t with the valuation function
receiving a higher value at a time later than t, we can simply delay the job
until that time. For the sake of completeness, we show that both models are
equivalent in a theoretical perspective.
Every non-monotone valuation function vj will be lifted to break non-
monotonicity violations. Formally, we substitute every valuation function
vj with a new valutaion function vj defined as follows:
vj (t) = maxt′≥t
vj(t′)
(4.18)
Recall that the value gained by a user allocated according to an allocation
aj is defined by the latest time slot in which j is allocated, that is, vj (aj) =
vj (e (aj)). Let y be a vector of mappings obtained by solving (LP) with the
valuation functions vj . We show how to transform it into a value-equivalent
vector under the original valuation functions vj . As in Section 4.1.2, we
simplify arguments by adding an “idle” job which is allocated in all of the
free spaces, thus we assume that the capacity is full in every time slot.
Consider some mapping yj (or equivalently, a mapping matching a sub-
player je) such that vj (yj) < vj (yj). Let t = e (yj) and let:
t = arg maxt′≥t
vj(t′)
(4.19)
Rewriting the assumption, we get vj (t) < vj (t). By the definition of t,
yj (t) > yj (t) = 0. Hence, since the capacity is full in every time slot,
there must be some job j′ with yj′ (t) < yj′ (t) ≤ kj′ . Let δ > 0 be a small
enough value. We decrease both yj (t) and yj′ (t) by δ and increase yj (t)
and yj′ (t) by δ. Notice that we can choose a small enough value δ such that
no parallelization bound is violated and the end time of j′ does not change.
Reapplying this step gives us the desired reduction.
35
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
Coloring Algorithm(S)1. Sort the MND allocations a ∈ S according to e (a) in descending order.2. For every MND allocation a in this order
2.1 Color a in some color c such that c remains a feasible integral solution.
4.4 Decomposing a Fractional Optimal MND So-
lution
The approximation algorithm presented in this section constructs a set of
feasible solutions to BFS out of a fractional optimal solution to (LP) given in
the canonical MND form. The algorithm is similar to the coloring algorithm
used in [5, 34] for the weighted job interval scheduling problem. The first
step of the algorithm constructs a multiset S ⊂⋃nj=1Aj of allocations out
of an optimal fractional solution given in MND form and then divides the
allocations in S into a set of feasible solutions to BFS.
Step I: Construction of S. Let N be a large number to be deter-
mined later. Consider a job j which is substituted by a set of subplayers
j1, j2, . . . , jT (or a single subplayer jdj for the case of deadline valuation
functions). Let y be an optimal solution of (LP) after applying the realloca-
tion algorithm. For every subplayer je, let aej be the allocation corresponding
to yej , defined as follows :
aej (t) =yej (t)
xej∀t ∈ Tj (4.20)
Note that aej is an allocation by the definition of xej and by (4.5). We
construct S as follows: Let xej denote the value xej rounded up to the nearest
integer multiplication of 1N . For every subplayer je, we add Nxej copies of
aej to S.
Step II: Coloring Allocations. The coloring algorithm (described above)
colors copies of MND allocations in S such that any set of allocations
with identical color will induce a feasible integral solution to BFS. Let
1, 2, ..., COL denote the set of colors used by the coloring algorithm. We use
a ∈ c to represent that an allocation a is colored in color c. Given a color c,
36
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
let c (t) =∑
a∈c a (t) denote the total load of MND allocations colored in c
at time t. The following two claims prove that the number of colors used is
relatively small. This allows us to construct an α-approximation algorithm
in Theorem 4.4.3.
Claim 4.4.1. Consider an iteration after some allocation a ∈ S is colored.
Then, for every color c, c (t) is monotonically non-decreasing in the range
[1, e (a)].
Proof. By induction. Initially, ∀t, c (t) = 0 for every color c. Consider an
iteration where a is colored. By the induction hypothesis, c (t) is monoton-
ically non decreasing for every color c in the range [1, e (a)] (the induction
hypothesis guarantees that c (t) is monotonically non decreasing for a pos-
sibly larger range, since we color allocations in decreasing order of e (·)).Since a is an MND allocation, coloring a with some color c keeps c (t) non
decreasing in [1, e (a)].
Claim 4.4.2. The coloring algorithm succeeds when:
COL = N ·(
1 +C
C − k
)(1 +
nT
N
)(4.21)
Proof. It is enough to show that when coloring an MND allocation, there is
always a free color. Consider an iteration of the coloring algorithm where
some allocation a ∈ Aj is colored. The number of allocations in S∩Aj other
than a is at most N ·(1 + T
N
)− 1, since the number of different allocations
corresponding to j is at most T (the number of subplayers), and therefore
this is the maximal number of colors which cannot be used due to collision
between allocations matching the same job. Now consider some color c in
which a cannot be colored due to capacity constraints. By the monotonicity
of both c (t) and a, we must have c (e (a)) ≥ C − kj ≥ C − k. The total
workload of instances in S at any time t is at most:
N ·∑je
aej (t) · xej ≤ N ·∑je
aej (t) ·(xej +
1
N
)≤ CN+knT ≤ CN ·
(1 +
nT
N
)(4.22)
since aej (t) ≤ k for every je, t. Thus, the number of colors in which a cannot
be colored due to capacity constraints is at most CNC−k
(1 + nT
N
).
37
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
Theorem 4.4.3. There is a poly(n, T, 1ε
)time approximation algorithm
that given an optimal solution to (LP) returns an
α ,
(1 +
C
C − k
)(1 + ε) (4.23)
approximation to the BFS problem for every ε > 0.
Proof. Let y∗ be an optimal solution of (LP) after applying the reallocation
algorithm and let OPT ∗ be the optimal social welfare matching y∗. We
construct a multiset S as described in Step I and decompose S into COL
solutions for BFS according to Step II, with a total value of:
N ·∑je
vj(aej)· xej ≥ N ·OPT ∗ (4.24)
Set N = nTε (and therefore COL = Nα). The running time of the col-
oring algorithm is polynomially bounded by n,N, T and thus polynomially
bounded by n, T, 1ε . The algorithm will allocate jobs according to the allo-
cations colored by the best color c, in terms of social welfare. Denote by
Alg the social welfare gained by this algorithm. Since:
Alg ≥ N ·OPT ∗
COL=OPT ∗
α(4.25)
We get an α-approximation. We note that for deadline valuation functions,
by applying similar arguments to the ones given in Claim 4.4.2 we can show
that taking N = nε suffices.
38
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
Chapter 5
A Truthful-in-Expectation
Mechanism for BFS
Up until now we have assumed that players report their true valuation func-
tions to the cloud provider and that prices are charged accordingly. However,
in reality, players are rational and thus may choose to untruthfully report
a valuation function bj which differs from their true valuation function vj if
they may gain from it.
In this chapter, we construct an efficient mechanism that charges pay-
ments from players such that reporting their valuation function untruthfully
cannot benefit them. We assume that players truthfully report the job pa-
rameters Dj and kj , however they may choose to falsely report their val-
uation functions. We follow along the lines of [26] in order to construct a
truthful-in-expectation mechanism for the BFS problem.
First, we describe in Section 5.1 a truthful mechanism that may fraction-
ally allocate jobs, which is used as part of the black-box reduction in [26]
and is also a fundamental base of our constructed mechanism. We then con-
struct an efficient truthful-in-expectation mechanism for the BFS problem
(Section 5.2) that significantlly improves the complexity of the mechanism
over black-box reductions guarantees. Finally, we discuss the process of
calculating the charged payments.
39
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
5.1 The Fractional VCG Mechanism
We start by giving a truthful, individually rational mechanism that can
return a fractional feasible allocation, that is, allocate fractions of jobs ac-
cording to (LP). Consider the following fractional mechanism:
1. Given reported types bj : T → R+,0, Solve (LP) and get an optimal
solution y∗. Let o ∈ O be the outcome matching y∗ and let OPT ∗ be
the social welfare when jobs are allocated according to y∗.
2. Charge pj (b) = hj (o−j) −∑
i 6=j bi (oi) from every player j, where hjis any function independent of oj .
This is the well known VCG mechanism. Recall that (LP) maximizes the
social welfare, i.e., the sum of values gained by all players. Players gain
gj (v) = OPT ∗ − hj (o−j) by bidding truthfully and therefore the mech-
anism is optimal, since deviating can only decrease∑
i vi (o). Note that
by dividing both valuation functions and charged prices by some constant,
the fractional VCG mechanism remains truthful. This will be useful later
on. Individual rationality of the fractional VCG mechanism is obtained by
setting the functions hj according to Clarke’s pivot rule [31].
5.2 A New Efficient Mechanism
Lavi and Swamy [26] give a black-box reduction for combinatorial auction
packing problems from constructing a truthful-in-expectation mechanism to
finding an approximation algorithm that verifies an integrality gap of the
“natural” LP for the problem. Their reduction finds an exact decomposition
of the optimal fractional solution (scaled down by some constant β) into a
distribution over feasible integer solutions. By sampling a solution out of this
distribution and charging payments according to the fractional VCG mech-
anism (scaled down by β), they obtain truthfulness-in-expectation. The
downside of the reduction given in [26] is that the approximation algorithm
A is used as a separation oracle for an additional linear program used as
part of the reduction, making their construction inefficient. We follow along
the lines of [26] in order to construct a truthful-in-expectation mechanism
for the BFS problem, and show how to achieve the same results as [26] by
calling our approximation algorithm once.
40
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
Recall that the algorithm from Theorem 4.4.3 constructs a set of feasible
solutions to BFS out of an optimal solution to LP. Ideally, we would have
wanted to replace the exact decomposition found by [26] with the output
of our decomposition algorithm (by drawing one of the colors uniformly).
However, this does not work since our decomposition is not an exact one,
because the values xej have been rounded up to xej prior to the construction
of S. To overcome this issue, we use a simple alternative technique to round
the entries in x to integer multiplications of 1N . We construct a vector
x such that E[xej
]= xej for every subplayer je, as follows: Assume that
xej = qN + r for q ∈ N and 0 ≤ r < 1
N . Then, set xej = q+1N with probability
N · r and xej = qN otherwise. Note that E
[xej
]= xej as required. Now, we
construct S out of x and call the coloring algorithm. By uniformly drawing
one of the colors c and scheduling jobs according to the allocations colored
in c, we obtain an expected welfare of: E[
NCOL
∑je vj x
ej
]= OPT ∗
α . By
charging fractional VCG prices, scaled down by α, we obtain truthfulness-
in-expectation. Notice that this mechanism is not individually rational, since
unallocated jobs may be charged. Lavi and Swamy [26] solve this problem
by showing how to modify the pricing rule so that the mechanism will be
individually rational. Notice that the number of colors used by the coloring
algorithm must always be COL, even though it is an upper bound on the
number of colors needed. Otherwise, players might benefit from reporting
their valuation functions untruthfully by effecting the number of solutions.
Theorem 5.2.1. There is a truthful-in-expectation, individually rational
mechanism for BFS that provides an expected α-approximation of the opti-
mal social welfare.
Finally, we discuss the process of computing the payments pj (b). Note
that to directly calculate the payments charged by VCG, one must solve a
linear program for every player j. [4] describes an implicit pricing scheme
that requires only a single invocation of the approximation algorithm to con-
struct both an allocation rule and pricing rules of a truthful-in-expectation
mechanism. This result can be plugged into our mechanism, thus decreasing
the number of calls to our approximation algorithm to one. However, their
scheme induces a mechanism that is only individually rational in expecta-
tion (specifically, it may charge negative prices) and causes a multiplicative
(constant) loss to social welfare.
41
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
Chapter 6
Conclusions and Future
Work
In this work we introduce a novel incentive compatible mechanism for schedul-
ing batch applications in cloud computing environments. The advantage
of our mechanism compared to current cloud pricing schemes is twofold:
First, it gives the cloud the flexibility of allocating jobs a variable amount
of resources which can be exploited for better utilization, including dealing
with congestion. Second, the user reports true values for completing its job
within various due dates. We show that true reports can be used in turn
to maximize the system efficiency, by employing a computationally efficient
allocation mechanism. The scope of this work can be extended in several
ways:
• Profit Maximization. The mechanism we design gives an approxi-
mation factor of α to the social welfare. The social welfare objective
function is a well studied objective function in the field of mechanism
design and in our context is mostly relevant for in-house or private
clouds. Nevertheless, it is of great interest to consider the objective
of maximizing profits (total revenue), which is naturally the goal of
commercial offerings of cloud services. It is known that VCG based
mechanisms give poor performance when the goal is profit maximiza-
tion [31] and that no good worst-case bound can be found for profit
maximization. The problem of constructing truthful mechanisms for
multi-parameter domains with the objective being profit maximiza-
42
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
tion is a fundamental open question. Even so, this problem may be
simpler in our model. Another possible direction is to make further
assumptions on the users, as in the Bayesian setting.
• Different Allocation Models. An important extension from a
practical perspective is to support more involved parallel computa-
tion models, e.g., MapReduce [16]. The difficulty in models such as
MapReduce is that the parallelism threshold varies throughout the
execution of the job, and often execution times are not known in ad-
vance. Moreover, MapReduce tasks consist of phases, which must
be executed sequentially (i.e., a phase cannot start before the former
phase has been completed). This significantly complicates the model,
and it is interesting to see whether good approximation algorithms can
be constructed for such problems.
• Online Version. It is of interest to examine the applicability of our
pricing approach in an online setup, where resources are requested
on-demand, without a preliminary provisioning phase.
• Implementation. We give a theoretical worst-case analysis to the
performance of our mechanism. Yet, the mechanism may perform
even better in practical settings. Comparing the value-based model to
payment schemes that are currently implemented may lead to further
insights on price setting in cloud computing environments.
Overall, we believe that ”pay-per-performance” pricing schemes will gain
prominence in future cloud offerings, as they include obvious advantages for
both the cloud and end-users. Consequently, incentive compatible mecha-
nisms and corresponding algorithmic techniques, such as the ones suggested
in this work, will play a major role in the design of cloud computing pricing.
43
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
Bibliography
[1] Aaron Archer and Eva Tardos. Truthful mechanisms for one-parameter
agents. In FOCS, pages 482–491, 2001.
[2] Aaron Archer and Robert Kleinberg. Characterizing truthful mecha-
nisms with convex type spaces. SIGecom Exchanges, 7(3), 2008.
[3] Itai Ashlagi, Shahar Dobzinski, and Ron Lavi. An optimal lower bound
for anonymous scheduling mechanisms. In EC, pages 169–176, 2009.
[4] Moshe Babaioff, Robert Kleinberg, and Aleksandrs Slivkins. Truthful
mechanisms with implicit payment computation. In EC, pages 43–52,
2010.
[5] Amotz Bar-Noy, Sudipto Guha, Joseph Naor, and Baruch Schieber. Ap-
proximating the throughput of multiple machines in real-time schedul-
ing. SIAM Journal of Computing, 31(2):331–352, 2001.
[6] Xiaohui Bei and Zhiyi Huang. Bayesian incentive compatibility via
fractional assignments. In SODA, 2011.
[7] Sushil Bikhchandani, Shurojit Chatterji, Ron Lavi, Ahuva Mualem,
Noam Nisam, and Arunava Sen. Weak monotonicity character-
izes deterministic dominant strategy implementations. Econometrica,
74:1109–1132, 2006.
[8] Peter Brucker. Scheduling Algorithms. Springer, 4th edition, 2004.
[9] Rajkumar Buyya, David Abramson, and Srikumar Venugopal. The grid
economy. Proceedings of the IEEE, 93(3):698–714, 2005.
44
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
[10] Gruia Calinescu, Amit Chakrabarti, Howard J. Karloff, and Yuval Ra-
bani. Improved approximation algorithms for resource allocation. In
IPCO, pages 401–414, 2002.
[11] Robert D. Carr, Lisa K. Fleischer, Vitus J. Leung, and Cynthia A.
Phillips. Strengthening integrality gaps for capacitated network design
and covering problems. In SODA, pages 106–115, 2000.
[12] Chandra Chekuri and Sanjeev Khanna. A ptas for the multiple knap-
sack problem. In SPDA, 2000.
[13] George Christodoulou and Annamaria Kovacs. A deterministic truthful
ptas for scheduling related machines. In SODA, pages 1005–1016, 2010.
[14] Julia Chuzhoy, Rafail Ostrovsky, and Yuval Rabani. Approximation
algorithms for the job interval selection problem and related scheduling
problems. Mathematics of Operations Research, 31(4):730–738, 2006.
[15] Reuven Cohen, Liran Katzir, and Danny Raz. An efficient approx-
imation for the generalized assignment problem. Inf. Process. Lett.,
100(4):162–166, 2006.
[16] Jeffrey Dean and Sanjay Ghemawat. Mapreduce: simplified data pro-
cessing on large clusters. In OSDI, 2004.
[17] Shahar Dobzinski. An impossibility result for truthful combinatorial
auctions with submodular valuations. In STOC, 2011.
[18] Shaddin Dughmi and Tim Roughgarden. Black-box randomized re-
ductions in algorithmic mechanism design. In FOCS, pages 775–784,
2010.
[19] Leah Epstein and Jiri Sgall. Approximation schemes for scheduling
on uniformly related and identical parallel machines. Algorithmica,
39(1):43–57, 2004.
[20] Martin Charles Golumbic. Algorithmic graph theory and perfect graphs.
Academic Press, 1980.
[21] Jason D. Hartline, Robert Kleinberg, and Azarakhsh Malekian.
Bayesian incentive compatibility via matchings. In SODA, 2011.
45
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
[22] Jason D. Hartline and Brendan Lucier. Bayesian algorithmic mecha-
nism design. In STOC, pages 301–310, 2010.
[23] Dorit S. Hochbaum and David B. Shmoys. A polynomial approximation
scheme for scheduling on uniform processors: using the dual approxi-
mation approach. SIAM Journal of Computing, 17(3):539–551, 1988.
[24] Hans Kellerer, Ulrich Pferschy, and David Pisinger. Knapsack problems.
Springer, 5th edition, 2007.
[25] Antoon W. J. Kolen, Jan Karel Lenstra, Christos H. Papadimitriou, and
Frits C. C. Spieksma. Interval scheduling: A survey. Naval Research
Logistics, 54(5):530–543, 2007.
[26] Ron Lavi and Chaitanya Swamy. Truthful and near-optimal mechanism
design via linear programming. In FOCS, pages 595–604, 2005.
[27] Ron Lavi and Chaitanya Swamy. Truthful mechanism design for multi-
dimensional scheduling via cycle monotonicity. In EC, 2007.
[28] Eugene L. Lawler. A dynamic programming algorithm for preemptive
scheduling of a single machine to minimize the number of late jobs.
Annals of Operation Research, 26:125–133, 1991.
[29] Roger Myerson. Optimal auction design. In Mathematics of Operations
Research, volume 6, pages 58–73, 1981.
[30] Noam Nisan and Amir Ronen. Algorithmic mechanism design. In
STOC, 1999.
[31] Noam Nisan, Tim Roughgarden, Eva Tardos, and Vijay V. Vazirani.
Algorithmic game theory. Cambridge University Press, 2007.
[32] Amotz Bar Noy, Reuven Bar Yehuda, Ari Freund, Joseph Naor, and
Baruch Schieber. A unified approach to approximating resource alloca-
tion and scheduling. 48:1069–1090, September 2001.
[33] Christos H. Papadimitriou, Michael Shapira, and Yaron Singer. On the
hardness of being truthful. In FOCS, pages 250–259, 2008.
[34] Cynthia A. Phillips, R. N. Uma, and Joel Wein. Off-line admission
control for general scheduling problems. In SODA, pages 879–888, 2000.
46
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
[35] Jean Charles Rochet. A necessary and sufficient condition for rational-
izability in a quasi-linear context. Journal of Mathematical Economics,
16(2):191–200, 1987.
[36] Michael Saks and Lan Yu. Weak monotonicity suffices for truthfulness
on convex domains. In EC, pages 286–293, 2005.
[37] David Shmoys and Eva Tardos. An approximation algorithm for the
generalized assignment problem. Mathematical Programming, 62:461–
474, 1993.
[38] Vijay V. Vazirani. Approximation Algorithms. Springer, 2001.
[39] Chee S. Yeo and Rajkumar Buyya. A taxonomy of market-based re-
source management systems for utility-driven cluster computing. Soft-
ware Practice and Experience, 36(13):1381–1419, 2006.
47
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
Appendix
The Configuration LP: A different view of the LP
Formulation
We present further insights on the choice of (4.5). An alternative formulation
of BFS is its representation as a configuration LP. For every job j and every
allocation aj ∈ Aj we have a variable zj (aj) representing whether job j has
been fully allocated according to aj or not. The configuration LP is defined
as follows:
max
n∑j=1
∑aj∈Aj
vj · zj (aj) (CONF-LP-D)
s.t.∑aj∈Aj
zj (aj) ≤ 1 ∀j ∈ J
∑j:t≤dj
∑aj∈Aj
aj (t) · zj (aj) ≤ C ∀t ∈ T
zj (aj) ≥ 0 ∀j ∈ J , aj ∈ Aj
The first constraints allow us to choose at most one allocation per job and the
second constraints are capacity constraints. Note that since allocations are
defined over the reals, the number of allocations in a set Aj is uncountable.
However, the following proposition shows that (LP-D), is actually an efficient
representation of (CONF-LP-D).
Proposition. The optimal fractional social welfares of (LP-D) and (CONF-
LP-D) are equal.
Proof. Consider a solution y of the relaxed linear program and recall that
48
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
xj = 1Dj
∑t yj (t). For every job j we construct an allocation aj matching the
values yj (t) by setting: aj (t) =yj(t)xj
. This gives us a feasible allocation,
since∑
t aj (t) = Dj and aj (t) ≤ kj for every t ∈ Tj by (4.5). Now, set
zj (aj) = xj and zj (a) = 0 for every a ∈ Aj \ aj. It is easy to see that z
is a feasible solution of the configuration LP.
In the opposite direction, consider a solution z of the configuration LP.
Define for every t ∈ Tj :
aj (t) =
∑a∈Aj
zj (a) · a (t)
xj
where xj =∑
a∈Ajzj (a). Notice that aj is a feasible allocation, since
aj (t) ≤ kj for every t ∈ Tj and since:
∑t∈Tj
aj (t) =
∑t∈Tj
∑a∈Aj
zj (a) · a (t)
xj
=
∑a∈Aj
zj (a) ·∑
t∈Tj a (t)
xj= Dj
By the definition of aj , the total capacity taken by aj is identical to the
capacity taken by allocations according to z. Moreover, the contribution
of aj to the objective function is the sum of contributions by allocations
in Aj . To conclude, we translate aj to its matching vector yj by setting
yj (t) = aj (t) · xj for every t ∈ Tj .
49
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
,כלומר, תוכנה על הרצה במקביל של המשימהחסם המקבול מייצג את מגבלות ה. מקבולעליון על החסם נתון
חסם המקבול המקסימלי , ההנחה היא ש . מספר השרתים המקסימלי שניתן להקצות למשימה בכל יחידת זמן
.כפי שנהוג להניח בסביבות יישומיות, קטן בכמה סדרי גודל מקיבול הענן , מבין חסמי כל המשימות
מקרה פרטי של בעיה . Bounded Flexible Scheduling (BFS)לבעיית ה אלגוריתם קירוב לא היה ידוע ,עד עתה
. שקול לבעיית מקסום רווח עבור הקצאת משימות על שרת יחיד, בו למשימות אין חסמים על הרצה במקביל, זו
Lawler [28 ] למציאת הרווח האופטימלי , פולינומי-שזמן ריצתו פסאודו, דינמיעל תכנון ססתבמהתיאר אלגוריתם
.אלגוריתם זה ניתן להרחבה למקרה הכללילא נראה ש, אך. לבעיה זו
קירוב אשר משיג, BFSלבעיית ה לינארית רלקסציה המבוסס על פתרון ,קירובתוצאתנו הראשונה היא אלגוריתם
של
. פקטור קירוב זה שואף ל , גדול ל כאשר הפער בין . לכל ,לרווחה הכוללת
תכנון האלגוריתם מחולק לכמה . מספר יחידות הזמן ו , פולינומי במספר המשימות זמן הריצה של האלגוריתם
:שלבים
לבעיית ה " טבעית"אנו מתבוננים ברלקסציה הלינארית ה, תחילהBFS .פער השלמות של , לצערנו
ועל כן יחס הקירוב שניתן להבטיח על ידי עיגול פתרון אופטימלי לרלקסציה זו אינו , ו גדול מאודרלקסציה ז
אנו מחזקים את הרלקסציה הלינארית על ידי הוספת אוסף אילוצים , כדי להתגבר על בעיה זו. טוב דיו
.את פער השלמות הקטיןלשמטרתם נוספים
שיבוץ מחדש בשלב השני אנו מציגים אלגוריתם(Reallocation), ממיר כל פתרון לרלקסציה אשר
, כלומר ,(MND)זהה בו כל ההקצאות הן מונוטוניות לא יורדות רווחה כוללתל לפתרון בעל "הלינארית הנ
.אינו קטן כפונקציה של הזמןעד לזמן סיומה מספר השרתים אשר מוקצים למשימה
אשר נתון , של פתרון אופטימלי לרלקסציה הלינארית( פירוק)קומפוזיציה -האלגוריתם מבצע דה, לבסוף
הרווחה הכוללת כך ש, BFSלמספר קטן יחסית של פתרונות פיזיביליים לבעיית ה , MNDבצורת
ות לפחות אחד מהפתרונ, ובכך)קירוב לרווחה הכללית האופטימלית - א יהממוצעת של פתרונות אלה ה
(.קירוב- הפיזיביליים הוא
תכונה זו היא בעלת חשיבות .תכונה מעניינת של האלגוריתם היא שכל משימה אשר מוקצית רצה ללא הפסקה
משמעותית של תקשורת ומשאבי אחסון אשר נדרשים לשמירת מצבי ביניים של שכן היא חוסכת כמות , פרקטית
.מספר שרתים הרצים במקביל המשימות כאשר הן מתבצעות באופן מבוזר על פני
תוחלת התועלת של משתמשים מקבלת ערך מירבי בו, יעיל מהווה בסיס לתכנון מנגנוןהקירוב שפיתחנו אלגוריתם
לרווחה המנגנון שאנו מציגים משמר את פקטור הקירוב .האמיתיים שלהםכאשר הם מדווחים את הערכים
אנו מבצעים שיפור קל באלגוריתם ההקצאה על מנת לקבל פירוק מדוייק של פתרון , כדי להשיג תוצאה זו .הכוללת
התפלגות זו מאפשרת לנו לסמלץ ביחס להגרלת פתרון . BFSאופטימלי שבור להתפלגות מעל פתרונות חוקיים ל
היתרון של . כיהם הפרטייםשבו לשחקנים אין מניע לדווח באופן שקרי את ער, VCGמנגנון מבוסס ( בתוחלת)
המנגנון שאנו מציגים הוא שיפור זמן הריצה באופן משמעותי בהשוואה למנגנונים אחרים אשר ניתן לקבל באמצעות
. ובכך מקלים על יישום מנגנון זה במערכות מחשוב ענן, עבור בעיה זוהניתנים ליישום " שחורה-קופסא"רדוקציות
בהשוואה למנגנונים המתקבלים על ידי רדוקציות , יחידה של אלגוריתם הקירובהמנגנון שאנו מציגים דורש הפעלה
.מסתפקים בחסם פולינומי על מספר הפעמים בו מופעל אלגוריתם הקירובקופסא שחורה אשר
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
תקציר מורחב
מושכרים ( ים ושטחי אחסוןכגון מחשבים וירטואלי)בה משאבי חישוב , חישובית נוחהמחשוב ענן מספק פלטפורמה
ולקבל פרדיגמה זו מאפשרת למשתמשים לשכור משאבי חישוב . במודל תמחור מבוסס תועלת קצה-למשתמשי
.תוך ניצול הגמישות בקבלת משאבים וכח החישוב הרב אשר מציע הענן, שירותים לפי דרישהמגוון רחב של
. תחת שיטת תמחור מבוססת תועלתגוגל ומיקרוסופט מציעים שירותי אירוח ליישומים , זוןאמכגון , ספקי חישוב ענן
שבה משתמשים משלמים מחיר קבוע ליחידת משאב , pay-as-you-goשיטת התמחור הנפוצה ביותר היא שיטת
אך עם . המשאבים שהם מקבלים בכך שמשתמשים משלמים עבור, היתרון של שיטה זו היא בפשטותה. לפי שעה
משתמשים , כלומר. שיטה זו מתייחסת אל משאבי חישוב כאל טובין, ראשית: שיטה זו סובלת משתי חסרונות, זאת
נקח כדוגמא חברה , כדי להדגיש נקודה זו. לעומת תשלום עבור ביצועים, משלמים עבור יחידות של משאבי חישוב
כזו חברה . מסחר בבורסה ביום מסויים עד שעה לפני פתיחת יום המסחר הבאפיננסית אשר מעוניינת בניתוח נתוני
עיקר עניינה הוא סיום ניתוח נתוני המסחר לפני מועד הסיום -עבורה מעוניינת פחות באופן בו מחולקים המשאבים
הקצאה . והיכול להקצות משאבים למשימות אשר הרווחה המתקבלת עבור סיומן גב, בהינתן מידע זה, הענן .הרצוי
אינה נתמכת על ידי , אשר נותנת עדיפות למשימות בעלות ערך גבוה למשתמשים אליהן הן שייכות, ערך-מבוססת
שיטות תמחור קיימות אינן מונעות ממשתמשים קבלת כמויות משאבים בלתי , שנית. pay-as-you-goשיטות
.ע הכולל של משאביםלמשתמשים אין מניע להגיב לשינויים בביקוש וההיצ, בכך .מוגבלות
.בכמותולא באיכותאשר מתמקדות , בעבודה זו אנו מציגים שיטות הקצאה ותמחור חדשות בסביבות מחשוב ענן
למשימה המוקצים כמות המשאבים המדוייקת ביחס לשל זמן הסיום של משימה אנו מדגישים את חשיבותו, בפרט
ביחידות )הכוללת משתמשים מדווחים למערכת את כמות המשאבים , במודל הכלכלי שאנו מציגים. בכל יחידת זמן
פונקציית ערך אשר מייצגת הם מדווחים ובנוסף , לה זקוקה המשימה( של שעת עבודה של שרת או שרת וירטואלי
משתמש יכול לדווח שהוא זקוק ל , למשל .כתלות בזמן סיומה, את נכונות המשתמש לשלם עבור ביצוע המשימה
אם המשימה $ 311ו 20:11אם המשימה תסתיים לפני $ 211והוא מוכן לשלם , שעות עבודה ביחידות אלו 2111
ניתוח פיננסי וסימולציות , כגון עיבוד תמונה) אצווהמסגרת זו רלוונטית במיוחד לעבודות .20:11תסתיים לפני
של נבחרת המשאבים עבור תת קבוצהשל התזמוןהענן קובע את , סכמה זוב. סיומןאשר מתבצעות עד ל( מדעיות
אשר גישה זו מעלה נקודות מרכזיות. כתלות בנכונות המשתמשים לשלם ואילוצי הקיבול של הענן, משימותה
לדווח כגון התמודדות עם שחקנים אשר עלולים , של נושא תכנון מנגנונים ותורת המשחקים בכלל ונמצאות בבסיס
כל פתרון אלגוריתמי חייב לתת , אי לכך. על מנת להגדיל את התועלת האישית שלהם, למערכת ערכים באופן כוזב
סיום ה זמניעבור ( נכונותם לשלם, כלומר)ם האמיתיים הלשחקנים תמריצים אשר יעודדו אותם לדווח את ערכי
.משימתםשל יםאפשריה
Bounded Flexibleחדשה הנקראת בעיית ה משימותבעיית הקצאת לב העבודה הוא תכנון מנגנון יעיל ל
Scheduling (הקצאה גמישה חסומה) ,אשר ,ספק חישוב ענן , בבעיה זו. אשר נגזרת ישירות מפרדיגמת חישוב ענן
ומטרתו להקצות , מקבל אוסף משימות בעלות דרישות ופונקציות ערך רב גוניות, שרתים אחראי על ענן בעל
ההקצאה . י המשימות אשר הוקצו במלואן"סכום הערכים הנצברים ע שהיא, תוך מקסום הרווחה הכוללתמשימות
כאשר , באופן מבוזר ניתן להקצות למשימה מספר שונה של שרתים בכל יחידת זמן, כלומר, גמישהשל משימה היא
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
.ספי נאור בפקולטה למדעי המחשב' המחקר נעשה בהנחיית פרופ
ברצוני להודות לו על . ספי נאור' לכבוד הוא לי לעבוד תחת הנחייתו של פרופ
.על עצותיו המשכילות ועל סבלנותו, מתמשכתתמיכתו ה
שי תמך בי י. אני מחשיב כאחד ממנחי האקדמיים אותו, נשהמודה לישי מאני
.אני אסיר תודה על הידע שרכשתי מספי וישי. במשך עבודה זורבות והנחה אותי
עמם היה לי הזכות , טכניון, י המחשבם בפקולטה למדעברצוני להודות לאנשי
על , אינגלנד-לחטיבת המחקר של מיקרוסופט בניוברצוני גם להודות . לעבוד
.י שםביקורבזמן שחוויתיהנהדרת התקופה ועללהתארח אצלם ינו אותי שהזמ
אני בר מזל . שעודדו אותי והאמינו ביעל , האוהבים אני מודה למשפחתי ולחברי
.שהנכם חלק מחיי
.אשר נפטרה בטרם עת, עבודה זו מוקדשת לסבתי
.אני מודה לטכניון על התמיכה הכספית הנדיבה בהשתלמותי
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
ערך של -תמריצים לתזמון מבוסס-מנגנונים מתואמי
משימות במחשוב ענן
חיבור על מחקר
לשם מילוי חלקי של הדרישות לקבלת התואר
מגיסטר למדעים במדעי המחשב
יונתן יניב
מכון טכנולוגי לישראל –הוגש לסנט הטכניון
3122 אוגוסט חיפה א"תשע אב
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011
של ערך -לתזמון מבוססתמריצים -מתואמימנגנונים
במחשוב ענןמשימות
יונתן יניב
Technion - Computer Science Department - M.Sc. Thesis MSC-2011-12 - 2011