# Truthful Approximation Mechanisms for Scheduling Selfish Related by nikeborome

VIEWS: 1 PAGES: 45

• pg 1
```									  Truthful Approximation
Mechanisms for Scheduling
Selfish Related Machines

Motti Sorani, Nir Andelman & Yossi Azar

Tel-Aviv University
The Classic Scheduling Problem
• Scheduling jobs on uniformly related machines
– n Jobs:   ( p1 , p2 ,.., pn )
– m machines with different speeds: s1 , s2 ,..., sm
– The objective: minimize the maximum completion time
over all machines (Makespan)
• Known to be NP-Complete
• Several approximation-algorithms
Scheduling Jobs on
Selfish Related Machines
• One-Parameter problem
• Machines are owned by rational selfish agents
Scheduling Jobs on
Selfish Related Machines
• The machine’s speed si is known to its owner only.
The secret: the cost per unit of work ti  1 / si

t1  2 / 3          t2  1             t3  1
Scheduling Jobs on
Selfish Related Machines
• Job sizes are common knowledge
• The system wants to execute the jobs while
minimizing the makespan

t1  2 / 3          t2  1                t3  1
Scheduling Jobs on
Selfish Related Machines
• Bidding

b1  1 / 2            b2  1 b3  1

t1  2 / 3                t2  1                   t3  1
Scheduling Jobs on
Selfish Related Machines
• The cost of machine i is ti  wi where wi is the total
amount of work assigned to it.
• The machines get paid. The goal of each machine
is to maximize its profit.

b1  1 / 2            b2  1 b3  1

t1  2 / 3                t2  1                   t3  1
Watching the Game
The jobs: 12,10, 7, 5, 4, 4, 3

t1  2 / 3                t2  1   t3  1
Watching the Game
The jobs: 12,10, 7, 5, 4, 4, 3
First Phase: Bidding

b1  1 / 2            b2  1 b3  1

t1  2 / 3                t2  1                   t3  1
Watching the Game
The jobs: 12,10, 7, 5, 4, 4, 3
Second Phase: The system allocates the jobs to the
machines according to their declared bids, and
simultaneously delivers the payments

Makespan=12
5                         3
10
4
12                        7
4
b1  1 / 2               b2  1 b3  1

16
15                        13

t1  2 / 3                 t2  1                     t3  1
Truthful Mechanism Design

M=(A,P)
A : Allocation
Algorithm
P : Payment

t1              t2         t3
Truthful Mechanism Design

M=(A,P)
A : Allocation
Algorithm
P : Payment

b1  t1                    b2  t2 b3  t3

t1                      t2                        t3
Mechanism Design
•   The idea: Overcome selfishness by payments
•   Mechanism M=(A,P)
•   Strategy for agent i : bi
•   The outcome of the algorithm is o(b)
•   The work allocated to agent i : wi (o(b))
•   The payment to agent i : Pi (b)
•   The profit of agent i : profit i  Pi (b)  ti wi (o(b))

Observation: Paying each agent its cost
is not truthful
Truthful Mechanism
• Dominant strategy for agent i :

profit i (bi , bi )  profit i (bi , b'i ) for all bi , b'i

• Truthfulness: truth-telling ( bi  ti ) is a dominant
strategy for each agent
• VCG is not applicable as the objective is not
utilitarian (maximize “social welfare”)

Our goal: Design a Truthful Mechanism M=(A,P)
which approximates the Minimum Makespan
Truthful Mechanism
• Consider the work assigned to agent i as a
single-variable function of bi
• Work-curve wi (bi , bi )

ti                  bi

Truthfulness <=> Monotone Algorithm
Truthful Mechanism
Theorem [Archer and Tardos]:

A mechanism is truthful and admits a voluntary
participation iff
(a) the work-curve for each agent is decreasing,

(b)   
0
wi (bi , u )du  

and the payments in this case should be

Pi (bi , bi )  bi wi (bi , bi )   wi (bi , u)du
bi
Monotone Algorithms
• Truthful Mechanism:
– Monotone Algorithm
– Payment scheme                              
Pi (bi , bi )  bi wi (bi , bi )   wi (bi , u)du
bi
• The work-curve
wi (bi , bi )
profit
cost

ti                           bi
Overbidding

wi (bi , bi )
less
profit
less
payment

slower
bi
faster   ti   x
Underbidding

wi (bi , bi )                  loss

bi
x   ti
Previous Results - Approximation
• Gonzalez et al:
2-approximation LPT greedy assignment
• Horowitz and Sahni:
FPTAS for constant number of machines
• Hochbaum and Shmoys:
PTAS for arbitrary number of machines
All these algorithms are not monotone
Previous Results – Mechanism Design
• Monotone Algorithm (not polytime)
[Archer & Tardos]:
– optimal solution
– satisfies voluntary participation

Among the optimal allocations of jobs, select
the one in which the work-vector ( w1 , w2 ,.., wm )
is lexicographically minimum.
Previous Results – Mechanism Design

Slowing down
Previous Results – Mechanism Design
• Classic approximation algorithms are not
monotone.
• Archer and Tardos:
randomized truthful 3-approximation
mechanism (truthful in expectation)
• Auletta et al:
deterministic truthful (4+ε)-approximation
mechanism for any fixed number of
machines
Notions of Truthfulness
• Truthfulness in expectation:
bidding truthfully always maximizes the agent's
expected profit

• Universal truthfulness
bidding truthfully always maximizes an agent's
profit, no matter what the other agents bid, and
no matter what are the outcomes of the
mechanism's random coin flips
Our Results
• Deterministic 5-approximation truthful
mechanism for arbitrary number of
machines
• Deterministic truthful (F)PTAS for any
fixed number of machines

We now show a simplified version for arbitrary
number of machines which achieves a
12-approximation truthful mechanism.
Valid Fractional Assignment
• Given a threshold T, treat the machines as bins
of size T/bi
• Fractional Assignment – Partition each job to
pieces, assign the pieces to the bins
• Valid Fractional Assignment
– Each bin is large enough to contain all pieces
assigned to it
– For every piece assigned to a bin, the bin is capable
of containing the entire job (which the piece belongs
to)
• T f – The smallest threshold for which a valid
fractional assignment exists.
Valid Fractional Assignment
• Example
– Jobs: 7,5,4,3,3,2
– Bids: 1/5, 1/4, 1/3
– Threshold = 2

3   2
5

4   3
7
5   3
bin size:     10              8   6
Valid Fractional Assignment
• T f can be calculated in a greedy manner
j

p    k
T  max min max{ bi p j , k 1
f
i
}
1
b
j    i

l 1 l

•   Tf   is a lower-bound to Opt
Monotonicity of Tf

• Observation:
T f (bi , bi )  T f (bi , bi ) for all   1 and i

• T f behaves in a “monotone manner”
– For any machine i which is not the fastest (i>1)
T f (bi , bi )  T f (bi ,  )  2T f (bi , bi ) for all   bi
Truthful Mechanism for arbitrary
number of Machines
• Guidelines of algorithm Monotone-RF
Init:       – Round the bids to the closest power of 4
– Sort the jobs in non-increasing order
fractional: – Calculate a valid fractional assignment and an
appropriate threshold Tf
rounding: – Assign jobs (using the rounded bids) in non-
increasing order of size, from the fastest to the
slowest (breaking ties by external ID)
• The first machine – until a threshold of 2Tf is exceeded
• Rest of the machines – until a threshold Tf is exceeded
– Return the assignment
Truthful Mechanism for arbitrary
number of Machines
2T f

Tf

fastest                slowest
…
Monotonicity of Monotone-RF
• Intuition: Assigning jobs according the rounded
bids forces non-increasing work-curves
• From now on we assume the bids are equal to
the real speeds.
• We shall show :

Slowing down => Less/Equal Amount of work
Why Rounding the Bids Helps?
• T f behaves in a “monotone manner”
– For any machine i which is not the fastest (i>1)
T f (bi , bi )  T f (bi ,  )  2T f (bi , bi ) for all   bi
• Say the rounded bid is multiplied by 4
d i  rounded bi ; vi  1 / d i

Total
work is
2T f                At most
v
f                                     Total                          2(2T f )( i )
T                                                                                 4
work is
 T vi
f
At least
T f vi
vi                                            vi / 4
Scenarios of Slowdowns
• The unique fastest behaves differently:
Rounding is not enough
T f (b1 , b1 )  T f (b1 ,  )  4T f (b1 , b1 ) for all   b1
• The bad scenario: The fastest machine
slows down one step (the rounded bid is
multiplied by 4) and some other machine
becomes the fastest
Scenarios of Slowdowns
• Solution: Double the threshold for the bin
of the unique fastest machine (2T f )
• When it slows down one step ,two cases:
– Remains the unique fastest:
• Bin size can not increase
• Jobs are allocated in the same order
– No longer the fastest: losing the doubled
threshold balances the possible increase of
the threshold.
Analysis for Partially-Full and
Empty Machines
• So far we considered full machines only
The Red Machine
slows down
new T f

Tf
• Monotone-RF is monotone. Hence a
Mechanism based on Monotone-RF and
payment scheme         
Pi (bi , bi )  bi wi (bi , bi )   wi (bi , u)du
bi
is truthful
Truthfulness - Remark
• The work-curve
Approximation Analysis
• The first bin capacity: 3T f
• T f is a lower-bound to Opt.
• Speeds were rounded to powers of 4
• A Total of 12-approximation
Guidelines for 5-Approximation
• Prefer the fastest machine already in the
rounding phase.
• Make sure the first bin is at least 4 times the
second one
– For any machine i which is not the fastest (i>1)
5 f
T (bi , bi )  T (bi ,  )  T (bi , bi ) for all   bi
f             f

4

• Speeds can be rounded to powers of 2.5
• A Total of 5-approximation
Truthful PTAS-Mechanism for Any
Fixed Number of Machines
n

p
i 1
j   1

1 2 2
[    2
, 2]
2m m

Exact Minimum-Lexicographically Solution
Truthfulness of Monotone-PTAS
• Job sizes were generated independently
from the bids
• The optimal Min. Lex. Solution is
monotone
Approximation Analysis
• Running Time is linear
• Assume we do not use machines slower

than smax
m
(1+ε)
• The assumption above adds another
• T  (1   ) Opt  (1  3 )Opt , for any   0.5
2
Guidelines for the FPTAS
• Uses any c-approximation algorithm as a black
box, generates a c(1+ε)-approximation
• Rounds the bids to powers of (1+ε)
• Calculate all possible (sorted) assignments
• Try all assignments on the given rounded bids-
vector. Pick the one with minimal makespan, or
if more than one exists, the one which is
lexicographically maximum.
Conclusions and Open Problems

• We have shown
– Deterministic 5-approximation truthful
mechanism for assigning jobs on related
machines
– A (F)PTAS truthful mechanism for any fixed
number of machines
• Is there a PTAS truthful mechanism for
arbitrary number of Machines?

```
To top