Techniques for truthful scheduling Rob van Stee Max Planck Institute for Informatics (MPII) Germany
Overview • Algorithmic mechanism design • Machine scheduling • Monotonicity • Monotone approximation algorithms
Approximation algorithms • Input is given (correctly) • Outputis controlled by algorithm • Problem is to get efficiently from input to output • Note: efficient means fast! (polynomial-time) • Performance measure: approximation ratio
Economics • Correct data is not directly available • Output is not controlled: agents cannot be told what to do • Algorithmic mechanism design: [NR99] • Optimize some function • Not necessarily social welfare or profit of seller / mechanism • Agents´ preferences and goal of mechanism are tied to secret data of agents
Today: One-parameter agents • Output: set of loads placed on the agents • Private data: cost per unit load • Goal of agent: maximize profit= payment – cost • Goal of mechanism: optimize some function of the loads
Machine scheduling • mrelated machines (controlled by agents) • n jobs must be assigned to the machines • Possible goals: • Minimizemaximum load (makespan) • maximizeminimum load (cover) • Max-min fairness • Minimizep-norm
Motivation for covering • Fair division: give as much as possible to the agent that gets the least • Each agent should contribute to the work: egalitarian division of chores • Some systems are only alive (productive) if all machines are alive • Jobs = batteries • Backup on parallel harddisks: backup capacity = minimum load
Cover vs. makespan 1 • Low makespan often good cover • Optimal schedules can be different! • Input optimal opt. cover makespan=18 =15 6 9 6 6 6 6 13 9 6 13 9 9 6 6 6 13 9 9
Cover vs. makespan 2 • A good approximation for makespan may be very bad for cover! Optimal makespan = optimal cover Cover of this schedule
Motivation for p-norm • Another way of allocating jobs “reasonably” • Bansal and Pruhs:“The standard way to compromise between optimizing for the average and optimizing for the worst case is to optimize the p-norm, generally for something like p = 2 or p = 3.”
Monotonicity and truthfulness • Machines are controlled by selfish agents • They report speeds to a mechanism and get assigned works wiand payments • The assignment must be monotone, else agents mightlie • (s1,…,si,….,sm) (w1,….,wi,…,wm) • (s1,…,si’,….,sm) Increase in si no decrease in wi! (w1’,….,wi’,…,wm’)
Monotonicity and truthfulness • Monotonicity is necessary and sufficient • That is, given that the allocation is monotone, truthtelling is a dominant strategy for the agents • We can define payouts based on the allocation curve (graph of allocation as a function of reported speed)
Allocation must be monotone Truth = y: save A+B by bidding x Truth = x: extra cost of A for bidding y Motivate truthfulness: payment for bidding y instead of x should be at least A+B, at most A...
Overbidding does not help Payment to agent = constant – marked area Bid x instead of true t_i: cost decreases by A, payment by A+B
Technique 1: fixed ordering of machines
Technique 1: fixed ordering of machines • Often there are multiple schedules which achieve the optimal objective value • To achieve monotonicity, we need a fixed way to choose between such schedules • [AT01]: • use a fixed ordering for the machines (independent of speeds!) • use the lexicographically minimal optimal schedule • What happens if some machine (agent) claims to be faster?
Monotonicity • If it is not the bottleneck, nothing changes • Makespan: bottleneck = machine with maximum load • Cover: bottleneck = machine with minimum load • If there existed alexicographically smaller optimal assignment with the new speed, it would have been optimal previously, a contradiction
Monotonicity Proof for makespan objective: • If machine i is bottleneck, it will get less work(objective= makespan!) or the same work • If original assignment is still the best, amount allocated to idoes not change, has load C´ (less than before) • If another assignment is now better, machine imust get less work to get a load below C´
Technique 2: randomization
Technique 2: randomization • We can use randomization in our mechanisms • Assumption: agents are risk-neutral • Profit of M with probability 1/M means expected profit 1 • Humans are more likely to say: most likely profit = 0 • Expected profit of the agents should be monotone • We get mechanisms that are truthful in expectation (not universally truthful)
Example: makespan • Idea: use fractional assignment • Calculate simple lower bound on optimal makespan • Assign jobs machine by machine (fastest first) and fill them up to makespan level • Last job on each machine may be split over two machines • Each machine gets at most two partial jobs • To get a valid assignment, we can put every split job on its first machine • Simple 2-approximation!
... But not monotone Jobs 5,4,2,1 4 2 5 rounding 5 2 2 2 1 1 Speeds 7 4 1 7 4 1 4 2.1 5 rounding 5 2 1 1.9 2 0.8 Speeds 7 3.9 1 7 3.9 1
Randomized rounding • Solution: use randomized rounding • Every partial job gets rounded to machine i with probability proportional to the fraction assigned to machine i • Each machine has at most two partial jobs, so gets at most 2 extra jobs • We have a 3-approximation for every choice of the random bits • We can show that the expected load of every machine is monotone
Randomized rounding • Randomized rounding is NOT used to improve the approximation ratio! • In fact, the approximation ratio goes up • Only use: achieve monotonicity • Dhangwatnotai et al.[2008]: • randomized PTAS for makespan and cover objectivewith the same property • PTAS = arbitrarily good approximation ratio in polynomial time • Deterministic QPTAS for makespan • QPTAS = almost but not quite polynomial time
Achieving a deterministic monotone PTAS seemed much harder • Christodoulou & Kovacs achieved this for makespan [2010] • Very complicated proof, several special cases • I will come back to this later
Technique 3: ignoring the speeds
Technique 3: ignore the speeds completely • Conflict: • mechanism wants to allocate jobs based on reported speeds • Agents may lie about speeds to get better assignments/profit • Possible solution: just ignore the agents’ bids completely • Example: machine covering [EvS 08]
Next Cover [Azar & Epstein 1997] • Input: • Guess value G • m machines sorted by speed (fastest first) • n jobs sorted by size (largest first) • Algorithm: for each machine • assign jobs in sorted order until load G is reached G
Next Cover [Azar & Epstein 1997] • If no jobs are left and some machine has load less than G, return fail • If load G is reached everywhere: • Assign remaining jobs (if any) to machine m, return success • Next Cover is a 2-approximation if value of OPT is known
Sorted Next Cover [EvS 08] • Initial guess: run LPT on identical machines, gives value A • We know: (On identical machines, LPT is a 4/3-approximation [CKW92, DFL82]) • Next Cover is a 2-approximation if value of OPT is known [AE97] • Thus, NC will succeed with guess A/2 • Do geometric search • Initial upper bound is U = 4A/3 • Initial lower bound is L = A/2 • Guess value G = (UL)1/2
Sorted Next Cover • For each guess value, we run NC • We stop the search when • We use geometric search since we want to have a bound on the ratio U/L • Geometric search is the fastest way to get this
Sorted Next Cover • Finally, we need to assign the jobs to the actual (related) machines • We use the job sets that NC creates • We assign them to machines in sorted order: fastest machine gets largest set • This ensures monotonicity
Monotonicity • The job sets do not depend on speeds • They are created for identical machines • If a machine claims to be faster than it really is, it can only get a larger set • If a machine claims to be slower than it really is, it can only get a smaller set
Approximation ratio • At most : • SNC has load on machine i • NC cannot find a cover above U on identical machines, • Optimal cover on identical machines of speed 1 is at most • Optimal cover on identical machines of speed is at most • Ratio
Approximation ratio • At most m: (complicated) proof by induction • This was the best known result if m is part of the input until WINE 2010 [CKvS10] (new ratio: 2+epsilon) • ...and the best known efficient/practical algorithm until earlier this year [O12]
Technique 4: check all possible bid vectors
Technique 4: try all possible assignments • We are given a bid vector • We want to ensure that if one bid changes, that agent does not improve • Idea (Andelman, Azar, Sorani 05): • for every possible bid vector, find best assignment • Test this assignment on actual bid vector • Use best assignment found • We need to limit the number of possible bid vectors
Monotone FPTAS [AAS05] • Round bids up geometrically • Bid = announced cost per unit load • Very high bids are cut off • Such bids correspond to extremely slow machines • These are easy to cover: only one job is needed • Maximum rounded bid is
Monotone FPTAS [AAS05] • Apply classical FPTAS to all possible bid vectors • Sort output assignment such that i th fastest machine gets i-th largest amount of work • Test all assignments on actual bids • Return the (lex. smallest) optimal one • Works for makespan [AAS05] and cover [EvS08] • Only works for constant m
Technique 5: optimize over limited set
Optimizing over a limited set • A main problem is the existence of “tiny” jobs • Usually, in a PTAS, we group jobs below a certain threshold size, and don’t use their exact size in calculations • Furthermore, we round job sizes to have only a limited number of different job sizes • Monotonicity is an exactrequirement!
Optimizing over a limited set • The PTAS for makespan [CK10] does the following. • Instead of rounding jobs, always use a fixed order to allocate them to machines • To deal with tiny jobs, these were rounded using a much finer coarsity than the rounding of machine speeds • Blocks of tiny jobs were always moved towards faster machines, which were kept filled up to makespan level • Then use dynamic programming • Special case for last machines...
Optimizing over a limited set • What about other objective functions? • Consider covering • Bottleneck machines now collect tiny jobs instead of getting rid of them • Tiny jobs means uncertain workload • Monotonicity argument breaks down
Optimizing over a limited set • We found a way to exactly represent schedules where the job size ratio on a machine can be unbounded (!) • Idea: not every job size can occur on a machine, only a polynomial number of classes • Thus we completely avoid “tiny” jobs with uncertain (rounded) size • This is sufficient to get very close to optimality: • For every optimal schedule, a “nearby” highly structured schedule exists with the above property • We look for this structured schedule using dynamic programming
New results • This works for every objective function that is a “nice” function of the loads • ELvS12 (arxiv 15 July 2012): deterministic monotone PTAS for • makespan • cover • p-norm • No special cases • No need to round speeds (!) • Objective function only goes into the dynamic program
Summary / open questions • We can approximate any nice objective that is based on the loads arbitrarily well • This basically resolves truthful one-parameter scheduling • What is the next interesting one-parameter/simple problem? • General problem: how much more difficult is it to solve (one-parameter) problems truthfully than to solve them classically? • So far only separations known for fairly difficult problems
Thank you!
