Truthful Approximation Mechanisms for Scheduling Selfish Related

Document Sample
Truthful Approximation Mechanisms for Scheduling Selfish Related Powered By Docstoc
					  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
           Scenario: gradual slowdown




                         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
Monotonicity by Gradual Slowdown
• 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
• The chunks add multiplicative overhead of
  (1+ε)
• The assumption above adds another
  multiplicative overhead of (1+ε)
• 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
  made by the black box
• 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?