truthful mechanisms for value-based scheduling in cloud ... … · truthful mechanisms for...

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

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


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.


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


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


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


iv


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


[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


[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


[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


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


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


,כלומר, תוכנה על הרצה במקביל של המשימהחסם המקבול מייצג את מגבלות ה. מקבולעליון על החסם נתון

חסם המקבול המקסימלי , ההנחה היא ש . מספר השרתים המקסימלי שניתן להקצות למשימה בכל יחידת זמן

.כפי שנהוג להניח בסביבות יישומיות, קטן בכמה סדרי גודל מקיבול הענן , מבין חסמי כל המשימות

מקרה פרטי של בעיה . Bounded Flexible Scheduling (BFS)לבעיית ה אלגוריתם קירוב לא היה ידוע ,עד עתה

. שקול לבעיית מקסום רווח עבור הקצאת משימות על שרת יחיד, בו למשימות אין חסמים על הרצה במקביל, זו

Lawler [28 ] למציאת הרווח האופטימלי , פולינומי-שזמן ריצתו פסאודו, דינמיעל תכנון ססתבמהתיאר אלגוריתם

.אלגוריתם זה ניתן להרחבה למקרה הכללילא נראה ש, אך. לבעיה זו

קירוב אשר משיג, BFSלבעיית ה לינארית רלקסציה המבוסס על פתרון ,קירובתוצאתנו הראשונה היא אלגוריתם

של

. פקטור קירוב זה שואף ל , גדול ל כאשר הפער בין . לכל ,לרווחה הכוללת

תכנון האלגוריתם מחולק לכמה . מספר יחידות הזמן ו , פולינומי במספר המשימות זמן הריצה של האלגוריתם

:שלבים

לבעיית ה " טבעית"אנו מתבוננים ברלקסציה הלינארית ה, תחילהBFS .פער השלמות של , לצערנו

ועל כן יחס הקירוב שניתן להבטיח על ידי עיגול פתרון אופטימלי לרלקסציה זו אינו , ו גדול מאודרלקסציה ז

אנו מחזקים את הרלקסציה הלינארית על ידי הוספת אוסף אילוצים , כדי להתגבר על בעיה זו. טוב דיו

.את פער השלמות הקטיןלשמטרתם נוספים

שיבוץ מחדש בשלב השני אנו מציגים אלגוריתם(Reallocation), ממיר כל פתרון לרלקסציה אשר

, כלומר ,(MND)זהה בו כל ההקצאות הן מונוטוניות לא יורדות רווחה כוללתל לפתרון בעל "הלינארית הנ

.אינו קטן כפונקציה של הזמןעד לזמן סיומה מספר השרתים אשר מוקצים למשימה

אשר נתון , של פתרון אופטימלי לרלקסציה הלינארית( פירוק)קומפוזיציה -האלגוריתם מבצע דה, לבסוף

הרווחה הכוללת כך ש, BFSלמספר קטן יחסית של פתרונות פיזיביליים לבעיית ה , MNDבצורת

ות לפחות אחד מהפתרונ, ובכך)קירוב לרווחה הכללית האופטימלית - א יהממוצעת של פתרונות אלה ה

(.קירוב- הפיזיביליים הוא

תכונה זו היא בעלת חשיבות .תכונה מעניינת של האלגוריתם היא שכל משימה אשר מוקצית רצה ללא הפסקה

משמעותית של תקשורת ומשאבי אחסון אשר נדרשים לשמירת מצבי ביניים של שכן היא חוסכת כמות , פרקטית

.מספר שרתים הרצים במקביל המשימות כאשר הן מתבצעות באופן מבוזר על פני

תוחלת התועלת של משתמשים מקבלת ערך מירבי בו, יעיל מהווה בסיס לתכנון מנגנוןהקירוב שפיתחנו אלגוריתם

לרווחה המנגנון שאנו מציגים משמר את פקטור הקירוב .האמיתיים שלהםכאשר הם מדווחים את הערכים

אנו מבצעים שיפור קל באלגוריתם ההקצאה על מנת לקבל פירוק מדוייק של פתרון , כדי להשיג תוצאה זו .הכוללת

התפלגות זו מאפשרת לנו לסמלץ ביחס להגרלת פתרון . BFSאופטימלי שבור להתפלגות מעל פתרונות חוקיים ל

היתרון של . כיהם הפרטייםשבו לשחקנים אין מניע לדווח באופן שקרי את ער, VCGמנגנון מבוסס ( בתוחלת)

המנגנון שאנו מציגים הוא שיפור זמן הריצה באופן משמעותי בהשוואה למנגנונים אחרים אשר ניתן לקבל באמצעות

. ובכך מקלים על יישום מנגנון זה במערכות מחשוב ענן, עבור בעיה זוהניתנים ליישום " שחורה-קופסא"רדוקציות

בהשוואה למנגנונים המתקבלים על ידי רדוקציות , יחידה של אלגוריתם הקירובהמנגנון שאנו מציגים דורש הפעלה

.מסתפקים בחסם פולינומי על מספר הפעמים בו מופעל אלגוריתם הקירובקופסא שחורה אשר


תקציר מורחב

מושכרים ( ים ושטחי אחסוןכגון מחשבים וירטואלי)בה משאבי חישוב , חישובית נוחהמחשוב ענן מספק פלטפורמה

ולקבל פרדיגמה זו מאפשרת למשתמשים לשכור משאבי חישוב . במודל תמחור מבוסס תועלת קצה-למשתמשי

.תוך ניצול הגמישות בקבלת משאבים וכח החישוב הרב אשר מציע הענן, שירותים לפי דרישהמגוון רחב של

. תחת שיטת תמחור מבוססת תועלתגוגל ומיקרוסופט מציעים שירותי אירוח ליישומים , זוןאמכגון , ספקי חישוב ענן

שבה משתמשים משלמים מחיר קבוע ליחידת משאב , pay-as-you-goשיטת התמחור הנפוצה ביותר היא שיטת

אך עם . המשאבים שהם מקבלים בכך שמשתמשים משלמים עבור, היתרון של שיטה זו היא בפשטותה. לפי שעה

משתמשים , כלומר. שיטה זו מתייחסת אל משאבי חישוב כאל טובין, ראשית: שיטה זו סובלת משתי חסרונות, זאת

נקח כדוגמא חברה , כדי להדגיש נקודה זו. לעומת תשלום עבור ביצועים, משלמים עבור יחידות של משאבי חישוב

כזו חברה . מסחר בבורסה ביום מסויים עד שעה לפני פתיחת יום המסחר הבאפיננסית אשר מעוניינת בניתוח נתוני

עיקר עניינה הוא סיום ניתוח נתוני המסחר לפני מועד הסיום -עבורה מעוניינת פחות באופן בו מחולקים המשאבים

הקצאה . והיכול להקצות משאבים למשימות אשר הרווחה המתקבלת עבור סיומן גב, בהינתן מידע זה, הענן .הרצוי

אינה נתמכת על ידי , אשר נותנת עדיפות למשימות בעלות ערך גבוה למשתמשים אליהן הן שייכות, ערך-מבוססת

שיטות תמחור קיימות אינן מונעות ממשתמשים קבלת כמויות משאבים בלתי , שנית. pay-as-you-goשיטות

.ע הכולל של משאביםלמשתמשים אין מניע להגיב לשינויים בביקוש וההיצ, בכך .מוגבלות

.בכמותולא באיכותאשר מתמקדות , בעבודה זו אנו מציגים שיטות הקצאה ותמחור חדשות בסביבות מחשוב ענן

למשימה המוקצים כמות המשאבים המדוייקת ביחס לשל זמן הסיום של משימה אנו מדגישים את חשיבותו, בפרט

ביחידות )הכוללת משתמשים מדווחים למערכת את כמות המשאבים , במודל הכלכלי שאנו מציגים. בכל יחידת זמן

פונקציית ערך אשר מייצגת הם מדווחים ובנוסף , לה זקוקה המשימה( של שעת עבודה של שרת או שרת וירטואלי

משתמש יכול לדווח שהוא זקוק ל , למשל .כתלות בזמן סיומה, את נכונות המשתמש לשלם עבור ביצוע המשימה

אם המשימה $ 311ו 20:11אם המשימה תסתיים לפני $ 211והוא מוכן לשלם , שעות עבודה ביחידות אלו 2111

ניתוח פיננסי וסימולציות , כגון עיבוד תמונה) אצווהמסגרת זו רלוונטית במיוחד לעבודות .20:11תסתיים לפני

של נבחרת המשאבים עבור תת קבוצהשל התזמוןהענן קובע את , סכמה זוב. סיומןאשר מתבצעות עד ל( מדעיות

אשר גישה זו מעלה נקודות מרכזיות. כתלות בנכונות המשתמשים לשלם ואילוצי הקיבול של הענן, משימותה

לדווח כגון התמודדות עם שחקנים אשר עלולים , של נושא תכנון מנגנונים ותורת המשחקים בכלל ונמצאות בבסיס

כל פתרון אלגוריתמי חייב לתת , אי לכך. על מנת להגדיל את התועלת האישית שלהם, למערכת ערכים באופן כוזב

סיום ה זמניעבור ( נכונותם לשלם, כלומר)ם האמיתיים הלשחקנים תמריצים אשר יעודדו אותם לדווח את ערכי

.משימתםשל יםאפשריה

Bounded Flexibleחדשה הנקראת בעיית ה משימותבעיית הקצאת לב העבודה הוא תכנון מנגנון יעיל ל

Scheduling (הקצאה גמישה חסומה) ,אשר ,ספק חישוב ענן , בבעיה זו. אשר נגזרת ישירות מפרדיגמת חישוב ענן

ומטרתו להקצות , מקבל אוסף משימות בעלות דרישות ופונקציות ערך רב גוניות, שרתים אחראי על ענן בעל

ההקצאה . י המשימות אשר הוקצו במלואן"סכום הערכים הנצברים ע שהיא, תוך מקסום הרווחה הכוללתמשימות

כאשר , באופן מבוזר ניתן להקצות למשימה מספר שונה של שרתים בכל יחידת זמן, כלומר, גמישהשל משימה היא


.ספי נאור בפקולטה למדעי המחשב' המחקר נעשה בהנחיית פרופ

ברצוני להודות לו על . ספי נאור' לכבוד הוא לי לעבוד תחת הנחייתו של פרופ

.על עצותיו המשכילות ועל סבלנותו, מתמשכתתמיכתו ה

שי תמך בי י. אני מחשיב כאחד ממנחי האקדמיים אותו, נשהמודה לישי מאני

.אני אסיר תודה על הידע שרכשתי מספי וישי. במשך עבודה זורבות והנחה אותי

עמם היה לי הזכות , טכניון, י המחשבם בפקולטה למדעברצוני להודות לאנשי

על , אינגלנד-לחטיבת המחקר של מיקרוסופט בניוברצוני גם להודות . לעבוד

.י שםביקורבזמן שחוויתיהנהדרת התקופה ועללהתארח אצלם ינו אותי שהזמ

אני בר מזל . שעודדו אותי והאמינו ביעל , האוהבים אני מודה למשפחתי ולחברי

.שהנכם חלק מחיי

.אשר נפטרה בטרם עת, עבודה זו מוקדשת לסבתי

.אני מודה לטכניון על התמיכה הכספית הנדיבה בהשתלמותי


ערך של -תמריצים לתזמון מבוסס-מנגנונים מתואמי

משימות במחשוב ענן

חיבור על מחקר

לשם מילוי חלקי של הדרישות לקבלת התואר

מגיסטר למדעים במדעי המחשב

יונתן יניב

מכון טכנולוגי לישראל –הוגש לסנט הטכניון

3122 אוגוסט חיפה א"תשע אב


של ערך -לתזמון מבוססתמריצים -מתואמימנגנונים

במחשוב ענןמשימות

יונתן יניב


truthful mechanisms for value-based scheduling in cloud ... … · truthful mechanisms for...

Documents