1. Introduction
In the online load balancing problem, we have a group of machines . Each machine has a speed , which is the amount of work it processes in one unit of time. There is a sequence of online jobs , arriving in an arbitrary order. Each job has a size , which is the amount of work it must be processed before completed. In other words, the processing time of job on machine is given by . Upon the arrival of a job, the scheduling algorithm must decide immediately which machine the job goes to, with the objective of minimizing the makespan, i.e., the maximum completion time on any machine. The problem is often referred to as the online load balancing problem Aspnes et al. (1997); Berman et al. (2000). In this paper, we consider the nonpreemptive and nonmigrate setting, i.e., once a job is scheduled on a machine, it must be processed continuously on this machine until it is finished.
The problem has been extensively studied for decades. For identical machines (a special case when for all ), a competitive algorithm was proposed by Graham Graham (1969), which is later improved to competitive by Fleischer and Wahl Fleischer and Wahl (2000). For related machines, the current best competitive ratio is for randomized algorithms and for deterministic algorithms Berman et al. (2000). The problem in which jobs have arbitrary nonzero arrival times has also been studied Chen and Vestjens (1997); Noga and Seiden (2001); Huang et al. (2018).
The game theory setting of this problem is also wellstudied. In this setting, each job is controlled by a selfish agent, whose objective is to finish its own job as early as possible. The agent is the only one who knows the size of the job, and for its own interest, it may misreport the size of the job. In the mechanism design community, we are interested in load balancing algorithms that are
truthful, i.e., every job optimizes its own objective by telling the truth. Existing truthful mechanisms often charge the jobs for being processed. In this case, the objective of each job is to minimize its own total cost, which is the completion time of the job plus the payment.The Greedy algorithm Aspnes et al. (1997) is a classic truthful mechanism (with competitive ratio ), which assigns each online job to the machine that finishes the earliest, with tie broken by machine identity. Since the schedule minimizes the completion time of each online job, the mechanism is truthful. Recently, an competitive truthful mechanism is proposed by Feldman et al. Feldman et al. (2017). The main idea is to set dynamic prices on the machines such that the selfish behaviors of jobs result in a schedule similar to the one produced by SlowFit Aspnes et al. (1997), an competitive (nontruthful) algorithm for the online load balancing problem on related machines.
Another wellstudied game theory model for load balancing assumes that the jobs are given offline, while the machines are controlled by selfish agents, with the speed being its only private information Christodoulou and Kovács (2013); Epstein et al. (2016). To guarantee truthfulness of machines, a scheduling mechanism pays the machines for working Andelman et al. (2005); Kovács (2005) (otherwise all machines will misreport a speed of to get rid of any assignment). Each machine aims at maximizing the payment it receives, minus its own makespan, which is the time by which all jobs assigned to it are finished. It has been shown that as long as the scheduling algorithm is monotone, there exists a payment function such that the mechanism is truthful Andelman et al. (2005). Roughly speaking, monotonicity requires that, if a machine claims a higher speed, then its workload (or makespan) does not decrease.
A natural and interesting question is, if both the machines and jobs are controlled by selfish agents, is it possible to design a truthful mechanism with bounded competitive ratio?
In this paper, we make a few steps towards solving this question. We first show some simple mechanisms that are truthful for both the jobs and machines, but have large competitive ratios, e.g., . In order to improve the competitive ratio, we relax the truthfulness of machines to wellbehavior of the schedule, which guarantees a different kind of monotonicity with respect to speeds of machines.
1.1. Wellbehaved Schedules
The concept of “wellbehaved schedule” was first studied by Epstein et al. Epstein et al. (2016) for the case when related machines are controlled by selfish agents. A wellbehaved schedule guarantees that a machine has workload no smaller than that of any slower machine. Note that wellbehavior is closely related to truthfulness. Imagine two machines with speeds . If the schedule is not wellbehaved, i.e., the faster machine has workload less than that of the slower machine, then the faster machine has incentive to lie. More specifically, if the faster machine claims speed , then its workload becomes larger: the identities of the two machines are swapped. Therefore the mechanism is not monotone, and not truthful.
Without knowing the future jobs to arrive, it is very difficult (or maybe impossible) to achieve a monotone schedule with small competitive ratio. Since monotonicity is defined on the set of online jobs, which the algorithm is oblivious of, the natural candidate algorithm must somehow adopt independent assignment of jobs, i.e., the assignment of any two jobs are independent. However, to guarantee a bounded competitive ratio, the assignments of jobs must be correlated, e.g., if a machine receives many jobs, then the next one should avoid going to this machine.
On the other hand, wellbehavior is a more approachable measurement of the schedule. Indeed, since a wellbehaved schedule guarantees that no matter what jobs may arrive, the faster machines receive more jobs than slower machines, without knowing what jobs may arrival, the riskaverse machines have no incentive to lie.
Unfortunately, existing truthful mechanisms Aspnes et al. (1997); Feldman et al. (2017) against strategic jobs are not wellbehaved. As a simple example, let us consider the Greedy algorithm Aspnes et al. (1997). Imagine that we have two machines with speed and , respectively, where is arbitrarily small. Let there be two jobs, the first one with size and the second one with size . Then the slower machine has workload , while the faster machine has workload , much smaller than the workload of the slower machine. Actually, as we will show later, being wellbehaved is difficult: any wellbehaved algorithm has competitive ratio .
1.2. Our Results
In this paper, we consider a stronger definition of wellbehaved schedules. We call a schedule wellbehaved if the makespan (the total workload divided by the speed) of a machine is no smaller than that of any slower machines. Note that under this definition, a faster machine gets more workload than proportional to its speed. As a consequence, it is more likely for the machines to be truthful, given that the payment function are defined as in Andelman et al. (2005).
First, we show that being wellbehaved is difficult, even under the weaker version Epstein et al. (2016). We show that there exists a sequence of online jobs on a group of machines such that any wellbehaved schedule performs badly.
[Hardness of WellBehaved Schedule] Wellbehaved algorithms have competitive ratios .
On the other hand, we show that if we relax the requirement of wellbehavior slightly, i.e., we require a machine to have a no smaller makespan than machine only if , then a much smaller competitive ratio can be obtained. We propose such kind of “almost wellbehaved” scheduling algorithm that is truthful for online jobs, and achieves a competitive ratio of . Moreover, we show that the competitive ratio improves to if the online jobs have similar sizes.
There exists an competitive algorithm that is truthful for jobs, and produces an almost wellbehaved schedule for any online jobs. Moreover, the competitive ratio improves to when for all jobs .
Besides being almost wellbehaved, our mechanism (detailed description in Section 4) has several other desirable properties.
First, our mechanism is fair in the sense that if two machines have the same speed, then their workload differs by at most one job. Our mechanism guarantees that a job is assigned to a machine only when the machine has the minimum workload among all machines with the same speed. Indeed, since we break tie randomly, the machines with the same speed have the same expected makespan. Such fairness is essentially the same with the notion of envyfree up to any item in resource allocation literature when all agents have the same entitlement Caragiannis et al. (2016); Plaut and Rougligarden (2018). Second, our mechanism is anonymous. In our mechanism, we guarantee that the schedule produced is determined only by the speeds submitted by the machines, which means that if a machine changes its identity, the resulting schedule remains unchanged. As a consequence, our mechanism is also symmetric, i.e., if two machines swap their speeds, then the resulting workloads will also be swapped. We note that anonymity and symmetry are also important properties in the cooperative game theory and facility location literature Nisan et al. (2007), which keeps the system stable, and are necessary conditions for Shapley value Shapley (1953) or Nash’s bargaining solution Nash Jr (1950); Moulin (1991).
Our Technique.
To guarantee that the makespan of a faster machine is not smaller than that of a slower machine, we assign each online job to a machine only if the wellbehavior is maintained. In other words, we maintain the invariant that the makespans of machines are nondecreasing with respect to the speeds, and we assign job to machine only if after the assignment, the makespan of machine is not larger than that of any faster machine.
Two questions arise. First, how can we make the mechanism truthful for online jobs, given that sometimes we assign a job to a machine other than the one that finishes the job the earliest? Second, is the competitive ratio of the algorithm bounded?
To answer the first question, we use the technique of dynamic posted pricing Hartline and Roughgarden (2009); Feldman et al. (2017). We show that depending on the current makespans of machines, we can set prices on the machines (which is the charging to the jobs) such that the selfish behaviors of online jobs result in a wellbehaved schedule. As a simple example, suppose there are two machines with speeds and , and the current makespan of machine is while machine has makespan . We set a price on machine and price on machine . Then if the next job has size , its cost when going to machine is , which is no larger than , the cost when going to machine . On the other hand, if , then going to machine has a strictly smaller cost. Hence the next job goes to machine only if its size is at most , which implies that the resulting schedule remains wellbehaved.
For the second question, in contrast to the hardness result, we show that if we only impose the monotonicity on the makespans of machines whose speeds differ by a factor of , then a much better competitive ratio can be obtained. The main idea is similar to the analysis of the Greedy algorithm Aspnes et al. (1997). We show that the makespans of machines with speeds and differ by at most , as otherwise (by the way we set the dynamic prices) the jobs will stop going to the faster machines. Combining this idea with the fact that machines with speed less than , where is the maximum speed of a machine, has little contribution to the whole schedule, we can show that the makespan of our schedule is bounded by .
Interestingly, as illustrating examples, we show that our mechanism is indeed truthful in some cases.
Our mechanism is also truthful for machines when , or when online jobs have unit size.
As far as we know, our work is the first result that achieves truthfulness for an online load balancing problem in which both the jobs and machines are controlled by selfish agents. A natural and fascinating open question is whether there exist nontrivial mechanisms that are truthful for both jobs and machines in general, and achieve a competitive ratio .
1.3. Other Related Work
Truthful Mechanism for Selfish Machines.
The work of scheduling mechanisms against selfish machines was initiated by Nisan and Ronen Nisan and Ronen (1999), in which the case of unrelated machines is studied. They propose a truthful mechanism (which adopts independent assignments of jobs) that is competitive, and show that no truthful mechanism can do better than competitive. The hardness result has been improved to for or more machines Christodoulou et al. (2009), and to when the number of machines tends to Koutsoupias and Vidali (2013).
On the other hand, the problem on related machines is much easier. Constant competitive truthful mechanisms are proposed in Andelman et al. (2005); Kovács (2005), and the stateoftheart mechanisms are the deterministic PTAS by Christodoulou and Kovács Christodoulou and Kovács (2013), and by Epstein et al. Epstein et al. (2016).
Truthful Mechanism for Selfish Online Jobs.
The Greedy algorithm is the most wellknown online load balancing mechanism that is truthful against selfish online jobs. The algorithm has been shown to be competitive on identical machines Graham (1969); competitive on related machines, and competitive on unrelated machines Aspnes et al. (1997). Recently, a constant competitive truthful mechanism that adopts dynamic posted prices on machines is proposed Feldman et al. (2017).
Hardness of Online Load Balancing.
In contrast to the PTAS on related machines obtained when all jobs are given offline, due to the nature of unknown future, it is impossible to achieve any competitive ratio strictly smaller than , even on two identical machines, and when both machines and all jobs are truthful: imagine jobs of size , followed by another job with size . On related machines, it is shown in Berman et al. (2000) that no deterministic algorithm can achieve a competitive ratio smaller than , and no randomized algorithm can do better than competitive.
2. Preliminaries
In this paper, we use to denote the set of online jobs to be scheduled on related machines . Let be the size of job , and be the speed of machine . The size is the only private information of job . Without loss of generality (by scaling) we assume that the minimum speed of a machine and the smallest size of an online job are both . Let denote , for any positive integer . We use to denote .
We assume all jobs arrive onebyone at time . There is no deadline or weight on the jobs. Each job must be assigned to some machine immediately upon its arrival. The objective is to assign jobs to machines to minimize the makespan. In the following, we use workload on a machine to denote the total size of jobs assigned to the machine; makespan on the machine to denote its workload divided by its speed.
Selfish Agents.
In our problem, we assume that the jobs are controlled by independent selfish agents, who is the only person that knows the size of the job. The objective of a selfish job is to minimize its own completion time plus payments to the mechanism. For the case when machines are also controlled by selfish agents, we assume that only the agent knows the speed of the machine, and its objective is to maximize (payment  makespan), where the payment is determined by the mechanism based on the final schedule.
Mechanism.
We consider mechanisms that operate in two phases. In phase, machines submit their speeds to the mechanism before any job arrives. In the case when machines are selfish, the reported speed might be different from the true value. The mechanism then announces the speeds of machines (which might not be equal to the speeds submitted). In phase, each online job arrives and submits a size to the mechanism. Each online job is informed of the announced speeds of machines, and the current schedule. Based on the size of the job, the mechanism decides immediately which machine the job goes to, together with a charging to the job. After assigning all jobs, the mechanism decides a payment to every machine.
We call a mechanism truthful if and only if every job maximizes its own utility by telling the truth, i.e., their true sizes. We call a mechanism wellbehaved if the makespan of a machine is no smaller than that of any slower machine. Throughout this paper, we use ALG and OPT to represent the makespan of our mechanism and the offline optimal makespan, respectively.
In the remaining part of this paper, we assume that before the machines submit their speeds, we fix a random ordering of machines that is used to break tie (when multiple machines with the same speed have the same makespan).
2.1. Monotone Schedule
It is shown in Andelman et al. (2005) that for the case when machines are controlled by selfish agents, the scheduling mechanism is truthful if and only if the schedule is monotone.
Definition (Monotone).
Consider any machine , and fix the speeds of all other machines arbitrarily. A scheduling mechanism is monotone if the workload of machine is nondecreasing w.r.t. the speed of machine .
More specifically, let be the workload of the machine when the claimed speed is , i.e., processing one unit of job requires units of time. Let
(1) 
be the payment function to the machine. It can be shown that if is nondecreasing, then the mechanism (with payment function (1)) is truthful Andelman et al. (2005). For completeness, we give a short proof here.
Lemma
The mechanism is truthful if is nonincreasing.
Proof.
Let be the true speed of the machine and . It suffices to show that maximizes the utility function . We show that , we have .
If (claim to be faster than truth), then we have
where the inequality comes from the fact that , .
Similarly for (claim to be slower than truth), then
where the inequality comes from for all . ∎
3. Naïve Algorithms
In this section, we present two simple scheduling mechanisms that are truthful for both the jobs and the machines. Basically, these mechanisms are two extreme cases, with one allocating all jobs on a single machine and the other allocating all jobs uniformly. As we will see, the competitive ratios of the mechanisms are very large.
We first propose a simple VCGstyle mechanism that employs payments to machines but no charging to jobs. The assignment of jobs is trivial: we assign all online jobs to the machine with the highest claimed speed.
Mechanism .
Let be the speeds claimed by machines, where we break tie by the prefixed ordering. We assign all jobs to machine , and set the payment to the machine be , where is the processing time claimed by job . For truthtelling machines and jobs, we have for all and for all .
Truthfulness of .
Observe that the schedule does not depend on the sizes of online jobs, and thus is truthful for jobs (misreporting the size is not beneficial). The mechanism is also truthful for the machines, as all jobs are processed as a grand bundle, with size . A machine is willing to process the bundle only if its actual processing time on the bundle is less than the payment. Since the payment is determined by the second highest speed, the mechanism (which is actually a second price auction) is truthful for machines (bidders).
Competitive Ratio of .
Since all jobs are assigned to machine with the highest speed , ALG is the makespan of machine . On the other hand, since for all , the processing time of any job on machine is the smallest among all machines. Hence in the optimal schedule, the summation of makespans of all machines is at least ALG. Therefore we have .
Another simple truthful mechanism works as follows. Regardless of the speeds submitted by the machines, the mechanism announces for all machine , and assigns each online job to the machine that finishes the job the earliest. In other words, the mechanism runs the Greedy algorithm on identical machines.
Truthfulness of .
Obviously, the mechanism is truthful for online jobs, as the completion time of every job is minimized, and there is no charging to the jobs. The mechanism is also truthful for the machines, as the speeds submitted by machines are irrelevant to the schedule.
Competitive Ratio of .
Consider the optimal schedule (with makespan OPT). Imagine that we keep the same schedule but change the speeds of all machines to . Let be the resulting makespan, and . Then we have , as the makespan of every machine is increased by a factor at most . Since Greedy is competitive for load balancing on identical machines, we have .
As it appears to be, since we totally ignore the speeds of machines, the competitive ratio is determined by how different the speeds of machines are.
4. A WellBehaved Mechanism
As we have shown in the previous section, to achieve complete truthfulness, we may have to (somehow) ignore the speeds of the machines, or the sizes of online jobs. However, such kind of algorithms usually suffer from huge competitive ratios.
In this section, we focus on a more approachable measurement of schedules, the wellbehavior. As we have shown in Section 1, since the machines are oblivious of the online jobs, a wellbehaved mechanism (somehow) guarantees that the riskaverse rational selfish machines have no incentive to lie.
4.1. Hardness of Wellbehaved Schedules
We first prove in this section that, while it seems natural and easy, it is actually impossible for a wellbehaved scheduling algorithm to achieve an competitive ratio in the online setting. Moreover, our hardness result holds even when jobs and machines are truthful, and for the weaker definition of wellbehavior as given in Epstein et al. (2016) (faster machines have no smaller workload).
Proof of Theorem 1.2: Consider a set of machines with speeds , where . Let there be online jobs with different sizes . Obviously, the optimal schedule completes all jobs before time by assigning the job of size to machine .
However, we show that if the jobs arrive in increasing order of sizes, then any wellbehaved schedule has makespan at least , which yields a hardness result on the competitive ratio on any wellbehaved scheduling algorithm.
We prove by induction on the jobs that the number of jobs on the machines that receive at least one job, is strictly increasing w.r.t. the speed. Note that the statement implies that at the end of the algorithm, the number of jobs on the fastest machine is at least , as otherwise the total number of jobs assigned is at most . The statement trivially holds when there is no job, and after the first job arrives.
Suppose the statement holds true before job arrives.
We show that the statement holds true after assigning job , given that the previous schedule is wellbehaved. Suppose job is assigned to machine . It suffices to show that after the assignment, the number of jobs on machine is smaller than that of machine . Assume the contrary and let be the number of jobs on both machines. Then the total workload of machine is at least , while the workload on machine is upper bounded by
In other words, the workload (and also the makespan) of machine is strictly less than that of machine , which contradicts the definition of wellbehaved schedule.
4.2. Rounded Speeds
Observe that wellbehavior sometime is not necessary to achieve a truthful mechanism. For example, recall the mechanism proposed in Section 3. Since the final schedule is irrelevant to the speeds, wellbehavior is not needed to achieve truthfulness. However, such kind of "speed insensitive" schedules often suffer from bad competitive ratios. Nevertheless, this idea inspires us to develop a schedule that is almost wellbehaved, with a limited speed insensitivity. By relaxing the requirements slightly, we show that we can dramatically improve the competitive ratio, from to for the general case and to for the case when the sizes of online jobs are bounded.
Recall that mechanism has a competitive ratio proportional to the difference of machine speeds. The main idea behind the design of our new algorithm is, instead of ignoring the speeds completely, to achieve a competitive ratio, we only regard a set of machines identical if their speeds are similar, e.g., differ by a multiplicative factor of . This idea motivates the design of the following mechanism , where is short for “posted prices for roundeddown speeds”.
Mechanism .
For every speed submitted by machine , we round down to the largest power of . In other words, if , then the mechanism announces . We order the machines in nondecreasing order of rounded speeds:
, where we break tie by the prefixed ordering. At any moment, depending on the current makespans of machines, we set a price
on every machine (that is independent of the incoming job). When a new job arrives, it goes to the machine that minimizes its own cost, i.e., behaves selfishly. At the end, let the payment to machines be defined as in Equation (1).Although we have not specified how we set the prices on the machines, we know that as long as the posted prices do not depend on the size of the new job, the mechanism is truthful for jobs (misreporting the size is not beneficial). From now on, we assume that every machine has speed equals to some power of .
In the following, we show that

there is a way for mechanism to set prices on machines such that the resulting schedule is wellbehaved: machine with higher speed has no smaller makespan;

the scheduling algorithm is competitive.
For ease of discussion, we give some necessary definitions first.
Definition .
For any job , let be the makespan of machine before job arrives; let be the makespan of machine at the end. Similarly, let be the price on machine before job arrives.
By definition, each online job goes to machine that minimizes the cost . We assume that the jobs are indexed by . Thus denotes the makespan of machine after assigning job .
As mechanism does not know when the online sequence of jobs stops, we maintain a wellbehaved schedule at all time. In other words, for any job and for any two machines and with , we have .
4.3. Dynamic Prices on Machines
In this section, we show how mechanism sets dynamic prices on machines such that (1) the prices are independent of the new job; (2) the resulting schedule is wellbehaved.
Consider the moment before job arrives. First, if there are multiple machines with the same speed, then except for the one with minimum makespan (break tie by the prefixed ordering), we set the prices on other machines to be infinity. In other words, we never assign the next job to these machines. For convenience of discussion, we assume w.l.o.g. that the speeds of all machines are different when the next job arrives.
Let . For each machine , define
We set the price on machine to be .
Note that by definition, the price depends only on the recurrent makespans of machines, which is irrelevant to the size of the new job. In our mechanism, the price of going to machine is , while the price of going to machine , where , is more expensive than going to machine . Intuitively, the prices on the machines incentivize the jobs to go to faster machines, unless the makespan of a slower machine is much smaller.
Example.
Suppose there are machines, which speed , and . Let the online jobs have size , , , (ordered by the arrival order). By definition initially all prices on the machines are . Thus the first job goes to the third machine (with speed ), resulting in a makespan of . Before the second job arrives, the prices on the machines are , and . Thus the second job (with size ) still goes to the third machine, as the objective is , strictly smaller than and , the objective when it goes to the first and second machine, respectively. Then the prices are updated to , and , and thus the third job (with size ) goes to second machine. After that, the prices become , and , and the last job (with size ) goes to the second machine. It is easy to see that the schedule the algorithm produces at every step is wellbehaved.
Lemma
The above dynamic prices on machines result in a schedule that is wellbehaved, if jobs behave selfishly.
Proof.
We prove the lemma by induction on the jobs: we show that as long as the schedule is wellbehaved, then after assigning the new job, the schedule remains wellbehaved.
By definition, the schedule is wellbehaved when there is no job. Now suppose that the schedule is wellbehaved before job arrives. We show that after assigning job to the machine with minimum cost, the schedule remains wellbehaved.
Suppose job (of size ) goes to machine . It suffices to show that after the assignment, the makespan of machine is no larger than that of machine , which is , as this is the only place where wellbehavior may cease to hold.
Given that minimizes the cost of job , we have
which is equivalent to
where the equality holds by definition of .
Rearranging the inequality, we have . In other words, after assigning the new job to machine , the makespan of is still no larger than that of . Hence the schedule remains wellbehaved after assigning the new job. ∎
Note that we can only prove that job goes to a machine without violating the wellbehavior of the schedule. As there are possibly many candidate machines job can go to without violating this property, the actual assignment depends on the makespans of all machines. More specifically, mechanism cannot guarantee that the new job will be assigned to the fastest or slowest candidate machine (which makes the analysis more difficult).
4.4. Competitive Ratio
In this section, we bound the competitive ratio of mechanism by . As we will show later in Lemma 4.4, the competitive ratio can also be upper bounded by , where is the maximum size of an online job (recall that the minimum size of online jobs is scaled to ). Thus we can upper bound the competitive ratio by .
Consider the final schedule produced by mechanism , after assigning all jobs. Recall that OPT is the optimal makespan and ALG is the makespan of mechanism . Let be the optimal makespan when the speeds of all machines are rounded down to powers of . Then immediately we have , as the optimal schedule before the rounding gives a feasible schedule with makespan at most after the rounding. Thus it suffices to show that . In the following, we assume that all machines have their speeds rounded down to powers of .
For convenience of discussion, we order the machines such that . Since the schedule is wellbehaved, we also have . Then we have . Let the speed of the fastest machine be .
Proof Outline.
We first show that the makespans of any two machines with speed and differ by at any moment (Lemma 4.4). Intuitively, if the makespan of the faster machine is larger than that of the slower machine, then the price our mechanism sets on the faster machine is higher than the price on the slower machine. Then we show that some job assigned to the faster machine has a strictly smaller objective when assigned to the slower machine, which is a contradiction. Equipped with this property, it suffices to show that only difference speeds matters: if a machine is times slower than the fastest machine, then its contribution to the total workload is negligible.
Let be the set of machines with speed , and be the machines with speed at least .
We prove the following lemma, which is crucial for the proof of the competitive ratio.
Lemma
Suppose for all machine , for some , then for all machine , we have .
Proof.
It suffices to consider the nontrivial case when . Moreover, as we have for all machine , it suffices to consider the machines in . Let be the jobs that contribute to the last increase of makespan on machines in . In other words, before the first job in arrives, the makespan of each machine is at most .
Observe that the total size of the jobs in is at least , while the total size of jobs the optimal schedule processes on machines is at most . Hence we know that in , at least one of the jobs in , say job , is processed on some machine not in . Since the processing time of job on machines in is at most , and the machines not in have speeds at most , we have .
Now consider the time when job arrives.
By definition, in our mechanism job is assigned to some machine . Moreover, we have
Let be the machine with minimum makespan before job arrives. If then we are done, as the makespans of machines do not decrease.
Assume the contrary that . Then we have
(2) 
Recall that for any machine , we have
and the price on machine is . Hence the price on machine is at most larger than that of machine .
Recall that the cost of going to machine is given by
On the other hand, the cost of going to machine is at most
where the last inequality holds by Inequality (2).
Thus we have a contradiction, as the cost is strictly smaller when job goes to machine while the mechanism assigns job to machine . ∎
Lemma
The scheduling algorithm is competitive.
Proof.
Recall that and contains the machines with highest speed. For all , we have , as no job has processing time strictly larger than on the fastest machines. By applying Lemma 4.4 recursively, all machines in (which are those of speed at least ) have completion time at least .
If , then the total size of all jobs is at least . On the other hand, as the optimal solution finishes all jobs within makespan , the total size of jobs is upper bounded by
Hence we have , which implies , as desired. ∎
In the following, we show that if the online jobs have bounded sizes, i.e., for all job , then the competitive ratio of mechanism improves to .
Let be the maximum size of an online job.
Lemma
The competitive ratio of the algorithm is .
Proof.
We first show that the difference in makespan between two machines of similar speed are bounded (in terms of ).
First, observe that for any , the makespans of any two machines in differ by at most . For any machine and , we have
as otherwise the last job that goes to machine should have been assigned to machine .
As before, suppose that . Let , and be the slowest machine that has nonzero workload. Suppose , then any machine with speed at least has makespan at least
Let be the highest speed of a machine that is slower than , where . Then we have
Now we consider the optimal schedules.
If in the optimal solution any job is scheduled on a machine with speed slower than , then we have , which implies
Otherwise we know that the optimal solution also schedules jobs only on machines with speed at least , which implies , as otherwise the optimal solution cannot finish all jobs. If the optimal solution schedules some job on a machine with speed , then we have ; otherwise we have (since all machines of speed at least has makespan at least ). In both cases, we have . ∎
Finally, by the design of mechanism , it is easy to see that satisfies the following properties. Let be the set of jobs assigned to machine at the end of the mechanism. A mechanism is fair if for any two machines and such that , where is the last job assigned to ; is anonymous if the scheduling depends only on the configuration of machine speeds. In other words, if a machine submits speed while the configuration is given by , then the jobs assigned to the machine is given by , where is the set of jobs assigned to machine according to permutation .
Lemma
Mechanism is fair and anonymous.
5. Truthfulness for Machines
Although wellbehavior is important on its own behalf, as it guarantees fairness, anonymity and symmetry (see the paragraph above and Section 1.2) between machines, in this section, we show that wellbehavior is indeed useful towards achieving truthfulness against selfish machines. We show several cases for which our mechanism is truthful for both selfish jobs and machines. Recall that the machines are oblivious of the online jobs. Given that there are many cases under which the mechanism is monotone, selfish machines are more likely to be truthful, so as to get rid of the risk of a decrease in the utility.
Recall that to achieve truthfulness for machines, it suffices to show that the mechanism is monotone Andelman et al. (2005). First, we show that when the online jobs have unit size, then mechanism is monotone.
Lemma
Mechanism is truthful when jobs have unit size.
Proof.
Suppose for some machine . Note that as long as , the schedule remains the same. Hence it suffices to show that if the claimed speed of machine increases from to , the number of jobs assigned to it does not decrease. Assume for the sack of contradiction that machine is assigned jobs with speed but assigned less than jobs with speed . Moreover, we can assume w.l.o.g. that the th job assigned to machine when is the last job of the whole sequence (otherwise we can remove the later jobs to achieve a smaller counterexample).
In the following, we order the machines by their speeds: .
First, observe that for any job and any machine , we have , as otherwise the last job that goes to machine should have been assigned to machine .
Since the makespan of machine when is at most , the workload on any machine in is at most
In other words, the workload on any machine in decreases after machine claims a higher speed.
In the following, we show that the number of jobs assigned to any machine with speed at most does not increase.
First, for any machine in , its makespan when is at least , which is larger than , the upper bound on its makespan when claims speed . It remains to consider machines with speed at most . Fix any machine with speed . We show that its workload does not increase.
Consider the moment when the th job goes to machine when . Since the job goes to machine instead of , we have
where is an upper bound on the difference between the prices of machine and . Hence we have
In other words, when , the number of jobs on machine is at least . On the other hand, when , the number of jobs on machine is at most . Observe that
If , then machine is not assigned any job when (hence its workload does not increase); otherwise
In both cases, the number of jobs assigned to machine does not increase when machine claims a higher speed. ∎
Finally, we show that our mechanism is truthful for the case . However, instead of rounding the machine speeds to powers of , in the following proof, we assume that the speeds of machines are rounded down to powers of .
Lemma
Mechanism is truthful when .
Proof.
As before, we prove that the mechanism is monotone. Recall that by scaling we can assume that the slower machine has speed . It suffices to show that if the speed of the slower machine is increased, then its load does not decrease. The case when we increase the speed of the faster machine is equivalent to the case when we decrease the speed of the slower machine.
The case when the machines have the same speed is relatively easier. Let be the makespans (workloads) on the two machines. Suppose we increase the speed of one of the machine to , then its workload is at least , which is at least if . If , then the last job, which is of size at least , must be assigned to the faster machine. Thus the workload of the faster machine is at least .
Now suppose that the speed of machine is , while the speed of machine is , where . We prove that for every job assigned to machine when , if it is not assigned to machine when , then the workload on the machine is no smaller than its original workload after the assignment, which implies that the workload does not decrease.
Let be the size of the job and consider the moment when the job arrives, when . Let and be the makespans of the two machines, where . Since the job is assigned to machine , we have .
Let and be defined similarly, when . Since is not assigned to machine after the increase, we have . Then we have
where in the second inequality we use . Hence at any moment, the workload of machine when is no smaller than its workload when . ∎
6. Conclusion
In this paper, we study wellbehaved mechanisms for online strategic jobs. We first present two mechanisms that are truthful for selfish jobs and machines, with competitive ratios and , respectively. Then we consider wellbehaved schedules and show that any wellbehaved mechanism must have a competitive ratio at least .
We propose an almost wellbehaved dynamic postedprice mechanism that is truthful for the jobs and has a competitive ratio of . When the sizes of all jobs are bounded, the competitive ratio of our mechanism improves to be constant. Finally, we show that when all jobs have unit size or there are only two machines, our mechanism is actually truthful against selfish machines.
We expect our algorithm and analysis to shed some lights on the design of competitive mechanisms that are truthful for both the selfish jobs and selfish machines. It is also interesting to improve the ratio of for almost wellbehaved mechanisms.
References
 (1)
 Andelman et al. (2005) Nir Andelman, Yossi Azar, and Motti Sorani. 2005. Truthful Approximation Mechanisms for Scheduling Selfish Related Machines. In STACS (Lecture Notes in Computer Science), Vol. 3404. Springer, 69–82.
 Aspnes et al. (1997) James Aspnes, Yossi Azar, Amos Fiat, Serge A. Plotkin, and Orli Waarts. 1997. Online routing of virtual circuits with applications to load balancing and machine scheduling. J. ACM 44, 3 (1997), 486–504.
 Berman et al. (2000) Piotr Berman, Moses Charikar, and Marek Karpinski. 2000. OnLine Load Balancing for Related Machines. J. Algorithms 35, 1 (2000), 108–121.
 Caragiannis et al. (2016) Ioannis Caragiannis, David Kurokawa, Hervé Moulin, Ariel D Procaccia, Nisarg Shah, and Junxing Wang. 2016. The unreasonable fairness of maximum Nash welfare. In EC. ACM, 305–322.
 Chen and Vestjens (1997) Bo Chen and Arjen P. A. Vestjens. 1997. Scheduling on identical machines: How good is LPT in an online setting? Operations Research Letters 21, 4 (1997), 165–169.
 Christodoulou et al. (2009) George Christodoulou, Elias Koutsoupias, and Angelina Vidali. 2009. A Lower Bound for Scheduling Mechanisms. Algorithmica 55, 4 (2009), 729–740.
 Christodoulou and Kovács (2013) George Christodoulou and Annamária Kovács. 2013. A Deterministic Truthful PTAS for Scheduling Related Machines. SIAM J. Comput. 42, 4 (2013), 1572–1595.
 Dutot et al. (2011) PierreFrançois Dutot, Fanny Pascual, Krzysztof Rzadca, and Denis Trystram. 2011. Approximation Algorithms for the Multiorganization Scheduling Problem. IEEE Trans. Parallel Distrib. Syst. 22, 11 (2011), 1888–1895.
 Epstein et al. (2016) Leah Epstein, Asaf Levin, and Rob van Stee. 2016. A Unified Approach to Truthful Scheduling on Related Machines. Math. Oper. Res. 41, 1 (2016), 332–351.
 Feldman et al. (2017) Michal Feldman, Amos Fiat, and Alan Roytman. 2017. Makespan Minimization via Posted Prices. In EC. ACM, 405–422.
 Fleischer and Wahl (2000) Rudolf Fleischer and Michaela Wahl. 2000. Online Scheduling Revisited. In ESA (Lecture Notes in Computer Science), Vol. 1879. Springer, 202–210.
 Graham (1969) Ronald L. Graham. 1969. Bounds on Multiprocessing Timing Anomalies. SIAM Journal of Applied Mathematics 17, 2 (1969), 416–429.
 Hartline and Roughgarden (2009) Jason D. Hartline and Tim Roughgarden. 2009. Simple versus optimal mechanisms. In EC. ACM, 225–234.
 Huang et al. (2018) Zhiyi Huang, Ning Kang, Zhihao Gavin Tang, Xiaowei Wu, and Yuhao Zhang. 2018. Online Makespan Minimization: The Power of Restart. In APPROXRANDOM (LIPIcs), Vol. 116. Schloss Dagstuhl  LeibnizZentrum fuer Informatik, 14:1–14:19.
 Koutsoupias and Vidali (2013) Elias Koutsoupias and Angelina Vidali. 2013. A Lower Bound of 1+ for Truthful Scheduling Mechanisms. Algorithmica 66, 1 (2013), 211–223.
 Kovács (2005) Annamária Kovács. 2005. Fast Monotone 3Approximation Algorithm for Scheduling Related Machines. In ESA (Lecture Notes in Computer Science), Vol. 3669. Springer, 616–627.
 Moulin (1991) Hervi Moulin. 1991. Axioms of cooperative decision making. Number 15. Cambridge university press.
 Nash Jr (1950) John F Nash Jr. 1950. The bargaining problem. Econometrica: Journal of the Econometric Society (1950), 155–162.
 Nisan and Ronen (1999) Noam Nisan and Amir Ronen. 1999. Algorithmic Mechanism Design (Extended Abstract). In STOC. ACM, 129–140.
 Nisan et al. (2007) Noam Nisan, Tim Roughgarden, Eva Tardos, and Vijay V Vazirani. 2007. Algorithmic game theory. Cambridge University Press.
 Noga and Seiden (2001) John Noga and Steven S. Seiden. 2001. An optimal online algorithm for scheduling two machines with release times. Theoretical Computer Science 268, 1 (2001), 133–143.
 Plaut and Rougligarden (2018) Benjamin Plaut and Tim Rougligarden. 2018. Almost envyfreeness with general valuations. In SODA. Society for Industrial and Applied Mathematics, 2584–2603.
 Shapley (1953) Lloyd S Shapley. 1953. A value for nperson games. Contributions to the Theory of Games 2, 28 (1953), 307–317.
 Skowron and Rzadca (2013) Piotr Skowron and Krzysztof Rzadca. 2013. Nonmonetary fair scheduling: a cooperative game theory approach. In SPAA. ACM, 288–297.
Comments
There are no comments yet.