Truthful Auction for CPU Time Slots

Truthful Auction for CPU Time Slots Qiang Zhang and Minming Li Department of Computer Science, City University of Hong Kong, Tat Chee Avenue, Kowloon, Hong Kong [email protected], [email protected]

Abstract. We consider the task of designing a truthful auction mechanism for CPU time scheduling problem. There are m commodities (time slots) T = {t1 , t2 , . . . , tm } for n buyers I = {1, 2, . . . , n}. Each buyer requires a number of time slots si for its task. The valuation function of buyer i for a bundle of time slots Ti is vi (Ti ) = wi (m − t), where t is the last time slot in Ti and |Ti | = si . The utility ui of buyer i is vi (Ti )−p(Ti). It is well-known that Vickrey-Clarke-Groves (VCG) mechanism gives the incentive to bid truthfully. Although optimal social welfare is computationally feasible in CPU time scheduling problem, VCG mechanism may produce low revenue. We design an auction which also maintains the incentives for bidders to bid truthfully. In addition, we perform simulations and observe that our truthful mechanism produces more revenue than VCG on average. Keywords: Scheduling.

1

Mechanism Design, Truthful Mechanism, Auctions,

Introduction

Internet market has become an important part of today’s economy, which produces large amounts of revenue. Information or digital goods in the Internet market differ from the traditional market in some key aspects, for example, digital goods can be re-created at a marginal cost and the supply is unlimited. The pricing mechanism for digital goods also differs from that of classic economics since supply exceeds demand in the Internet market while supply is sold out in classic economics. This new economy system demands many theoretical analyses from which we can develop tools that help us determine the pricing mechanism and resource allocation. [5] gives an offline competitive auction for selling multiple digital goods where each bidder has a different private value for each digital good and bidders are willing to submit their true private values as bids. In mechanism design, such auction is called truthful auction, or incentive-compatible auction. [1] extends this concept to an online auction in which bidders are willing to bid their true valuations for each digital good. In this work, we study the auction for CPU processing time as a digital good in the Internet market. CPU time is a crucial resource and has been extensively

This work was fully supported by a grant from the Research Grants Council of the Hong Kong Special Administrative Region, China [Project No. CityU 117408].

D.T. Lee, D.Z. Chen, and S. Ying (Eds.): FAW 2010, LNCS 6213, pp. 23–34, 2010. c Springer-Verlag Berlin Heidelberg 2010

24

Q. Zhang and M. Li

studied in grid computing. Market-oriented methods have been proposed for efficient allocation of computational resources in [2,9,7]. In most of CPU time allocation models, CPU time is considered as the same goods that can reduce the computational complexity. However, in practice bidders in the same market might have different valuations for different time slots. Furthermore, we assume all bidders are task-oriented, which means the valuations of time slot allocations for bidders depend on the finish time of their jobs. We adopt the model from [4] which considers each CPU time slot as a different unit. [4] focuses on the Walrasian equilibrium price and the complexity of computing such price. In this work, we are interested in incentive-compatible mechanisms for selling CPU time in the Internet market. Truth-telling is a desirable feature which ensures behavior is predictable in auction. Information about others’ bids is irrelevant in a truthful auction so that bidders will not be motivated to spend resource on obtaining such information. It is well known that Vickrey-Clarke-Groves (VCG) mechanism [3,6,8] is a truthful auction mechanism which maximizes the social welfare. Nevertheless, VCG mechanism has many notable weaknesses, for example, VCG is computationally infeasible in many problems and the payment of VCG mechanism could be very low. We first develop a truthful auction for time slots on single CPU, in which the CPU time slots allocation mechanism is a greedy function that depends on the valuation from each bidder. We also discuss the revenue from our auction mechanism and compare it with the revenue of VCG. Finally, we extend the mechanism to selling processing time on multiple CPUs with an assumption that bidders are only allowed to submit their valuation parameters untruthfully. We proved that the proposed auction model is also incentive-compatible in multiple CPU setting. The paper is organized as follows. The CPU time scheduling problem is described in Section 2. In Section 3, we propose a new auction for selling CPU time on a single CPU. We describe the pricing and allocation mechanism. In Section 4, we prove that the auction is incentive-compatible. In Section 5, we analyze the revenue generated from our auction mechanism. We also perform simulations and compare the revenue between our mechanism and VCG. In Section 6, we extend our mechanism and develop an incentive-compatible auction for multiple CPUs. At last, we conclude our work with discussion on the results and possible future work in Section 7.

2

The CPU Time Scheduling Problem

In the CPU time scheduling problem, there is a CPU time provider and many bidders in the market. CPU time provider sells CPU time slots to bidders and each bidder would like to buy different number of CPU time slots that depends on the requirement of its job. The valuation of each bidder depends on the time slots it obtains. The CPU time scheduling problem can be formulated as follows. Assume there are n jobs announced at the time t = 1, the j th job needs time sj > 0 to complete its task and has weight wj > 0. From these environment settings, We form an exchange economy: an auctioneer sells m commodities (time slots) T = {t1 , t2 , . . . , tm } to n buyers (jobs) I = {1, 2, . . . , n}. The valuation

Truthful Auction for CPU Time Slots

25

function of buyer i for a bundle of time slots Ti is vi (Ti ) = wi (m − t), where t is the largest time-slot item in Ti and |Ti | = si . The utility ui of buyer i is vi (Ti ) − p(Ti ).

3

A Truthful Auction for Time Slots on Single CPU

In this section, we present a truthful auction mechanism for pricing time slots on single CPU with a linear valuation function for each job. As mentioned in the last section, the valuation function of buyer i for a bundle of time slots Ti is vi (Ti ) = wi (m − t), where t is the largest time-slot item in Ti and |Ti | = si . The utility ui of buyer i is vi (Ti ) − p(Ti ). The goal of the truthful auction is to give each buyer an incentive to submit its true value of w and s. The truthful auction we propose is as follows: Rank buyers according to their submitted weight w. Without loss of generality, assume that w1 ≥ w2 . . . ≥ wn . Assign time slots to buyers according to their ranks, i.e. buyer 1 takes the first s1 time slots, followed by s2 time slots assigned to buyer 2 and so on. We denote the time slots allocation as A, Kj (A) = i if and only if time slot tj is assigned to buyer i, and Bj (A) = {j + 1, j + 2, . . . , m} If the bundle of time slots assigned to buyer i is Ti (A) = {tγ , tγ+1 , . . . , tη=γ+si −1 }

(1)

where γi and ηi are the start and finish time of buyer i, respectively. In this case, the price of the bundle of time slots is wKj (A) (2) p(Ti (A)) = j∈Bηi (A)

As an example, consider four buyers bidding for 6 time slots t1 , t2 , . . . , t6 . The time span and weight are {2, 3, 1} and {9, 6, 4}. The time slots s1 and s2 will be assigned to buyer 1. By Equation 2, the price of the bundle of time slots t1 and t2 is p(T1 ) = w2 s2 + w3 s3 = 6 ∗ 3 + 4 ∗ 1 = 22. Applying the same method to buyer 2, the price of the bundle of time slots t3 , t4 , t5 is p(T2 ) = w3 s3 = 4. Because there are no more buyers, buyer 3 is charged at price 0 for its time slots t6 .

4

Truthfulness of the Auction

In this section, we prove the pricing and allocation mechanism proposed in Section 3 is incentive-compatible. From the proof, we show that there is no other bidding strategies rather than bidding truthfully which could gain more utility. Definition 1. A mechanism (f, p1 , . . . , pn ) is called incentive compatible or truthful if for every buyer i, every w1 ∈ W1 , . . . , wn ∈ Wn , every s1 ∈ S1 , . . . , sn ∈ Sn , and every wi ∈ Wi , si ∈ Si , if we denote a = f (wi , si , w−i , s−i ) and a = f (wi , si , w−i , s−i ), then vi (a) − pi (wi , si , w−i , s−i ) ≥ vi (a ) − pi (wi , si , w−i , s−i ), where Wi , Si is the set of all possible values of wi , si for buyer i, and w−i , s−i is the bid vector except buyer i.

26

Q. Zhang and M. Li

Algorithm 1. Auction mechanism for time slots on single CPU Input: A set of jobs I = {1, 2, . . . , n} with weight w and timespan s ordered by w Output: A set of prices for each job begin count timeslot = 1 ; for i = 1 to n do start timei = count timeslot; f inish timei = count timeslot + si − 1; count timeslot = count timeslot + si ; for j ← i + 1 to n do p(Ti ) = p(Ti ) + wj sj end Theorem 1. The auction mechanism in Algorithm 1 is incentive-compatible. Proof. Fix i, the valuation function vi = wi (m − t), w−i and s−i , we need to show that the utility when buyer i declares wi and si is not less than the utility when he declares a fake wi and si . If buyer i submits a wi > wi , it will possibly improve the ranking of buyer i. Suppose the original ranking of buyer i when declaring wi is k, then the new ranking is k < k by submitting wi . Let Q = {ρ, . . . , σ} where the rankings of users ρ, . . . , σ are from k + 1 to k when for buyer buyer i submits wi . Therefore, i, its completion time improves by j∈Q sj but it need to pay j∈Q wj sj more. Its utility improves by:

vi (a ) − pi (wi , si , w−i , s−i ) − (vi (a) − pi (wi , si , w−i , s−i ))

=(vi (a ) − vi (a)) − (pi (wi , si , w−i , s−i ) − pi (wi , si , w−i , s−i )) sj − wj sj =wi j∈Q

(3)

j∈Q

Because all buyers in Q has an equal or higher w than buyer i, Equation 3 will produce a non-positive result, which means the utility of buyer i will not increase if it submits a wi > wi . In the same way, if buyer i submits a wi < wi , then the new ranking is k > k. Let Q = {ρ , . . . , σ } where the rankings of users ρ , . . . , σ are from k to k −1 when buyer i submits wi . Therefore, for buyer i, its completion time delays j∈Q sj but it can pay j∈Q wj sj less. Its utility improves by:

vi (a ) − pi (wi , si , w−i , s−i ) − (vi (a) − pi (wi , si , w−i , s−i ))

=(vi (a ) − vi (a)) − (pi (wi , si , w−i , s−i ) − pi (wi , si , w−i , s−i )) sj + wj sj = − wi j∈Q

j∈Q

(4)


27

Because all buyers in Q has a less or equal value of w than buyer i, Equation 4 will produce a non positive result, which means the utility of buyer i will not increase if it submits a wi < wi . It is noted that buyer i cannot improve its utility by submitting a fake si whatever buyer i submits a wi ≥ wi or wi ≤ wi . For a fixed wi , if buyer i submits si < si , it cannot complete its task because it only obtains si slots. If buyer i submits si > si , buyer i gets more time slots but pays the same price. However, the utility ui does not increase because buyer i cannot finish its task earlier. Theorem 2. Bidding job weight and time span truthfully always gains nonnegative utility. Proof. Assume that if buyer i submits wi , si , the valuation of buyer i is vi = wi (m − β)

(5)

According to Equation 2, the price that buyer i pays is only dependent on the buyers having lower weights. p(Ti ) = wKj (A) (6) j∈Bβ (A)

Because wi ≥ wKj (A) , where j ∈ Bβ (A), the utility ui of buyer i is: ui = vi − p(Ti ) = wi (m − β) −

wKj (A) ≥ 0

(7)

j∈Bβ (A)

5

Revenue Study

After designing a truthful mechanism for pricing time slots on single CPU, it is worth evaluating how much the revenue seller may earn by our mechanism. This section presents a comparison on revenue between our mechanism and VCG, a well-known truthful mechanism. 5.1

Experimental Results

From the formula presented in Section 3, we cannot tell which mechanism can achieve higher revenue. In order to further investigate the revenue by our truthful mechanism, we perform simulations at different number of bidders when the parameters (e.g. weight and time span) are normally distributed in a certain range. First, we choose both weight and time span parameters randomly from 1 to 100. We perform simulation 100 times at each number of bidders when the number of bidders increases from 2 to 100. In each simulation, we calculate

28

Q. Zhang and M. Li

Fig. 1. Comparison of number of wins and revenue ratio between our truthful mechanism and VCG when both job weight and time span range from 1 to 100

Fig. 2. Comparison of number of wins and revenue ratio between our truthful mechanism and VCG when job weight ranges from 1 to 100 and time span ranges from 1 to 50


29

the revenues from our mechanism and VCG and compare them. We count the number of times our mechanism generating more revenue than VCG. We also compute the average revenues of our mechanism and VCG when the number of bidders are fixed. Figure 1 shows the comparison result and the average revenue ratio on our mechanism and VCG. Second, we use the same method to compare our mechanism and VCG when weights are randomly chosen from 1 to 100 and time span ranges from 1 to 50. Figure 2 shows the comparison result and the average revenue ratio on our mechanism and VCG in this setting. 5.2

More Analyses

From the previous section, we find that our mechanism can generate more revenue than VCG when the parameters(e.g. w and s) are normally distributed. In this subsection we analyze the revenue generated on two special cases. One is that the valuation wi of each buyer (job) grows with the time-span si it requires, the other is the valuations of buyers is inversely related to the time-span, i.e. the valuation wi grows while the required time-span si decreases. Case 1

a) w1 ≤ w2 ≤ w3 ≤ . . . ≤ wn−1 ≤ wn b) s1 ≤ s2 ≤ s3 ≤ . . . ≤ sn−1 ≤ sn

This scenario often happens when the valuation of job only depends on the timespan it needs. In practice, those jobs that need large amount of processing time most likely produce more value compared to other jobs. In this circumstance, our mechanism gives time slots according to the bidders’ submitted weight w, e.g. bidder n gets the first sn slots. Each bidder is charged by Equation 2, and the total revenue is: (n − 1)w1 s1 + (n − 2)w2 s2 + . . . + wn−1 sn−1

(8)

While VCG mechanism allocates time slots in a socially optimal manner, e.g. bidder n with largest w/s obtains the first tn slots. VCG mechanism charges each individual bidder the harm it causes to other bidders, e.g. bidder n is charged at price sn (w1 + w2 + . . . + wn−1 ). There are different subcases in this scenario for the VCG mechanism. We study two special subcases. The first subcase is w1 /s1 ≤ w2 /s2 ≤ w3 /s3 ≤ . . . ≤ wn−1 /sn−1 ≤ wn /sn . In this subcase, the total revenue VCG mechanism generates is: sn (w1 + w2 + . . . + wn−1 ) + sn−1 (w1 + w2 + . . . + wn−2 ) + . . . + s2 w1

(9)

We can show that the revenue from VCG mechanism is equal to or greater than our truthful mechanism. It can be proved from Equation 8 - Equation 9:

30

Q. Zhang and M. Li

(n − 1)w1 s1 + (n − 2)w2 s2 + . . . + wn−1 sn−1 − (s2 + s3 + . . . + sn )w1 − (s3 + . . . + sn )w2 − . . . − sn−1 wn =((n − 1)s1 − s2 − s3 − . . . − sn )w1 + ((n − 2)s2 − s3 − . . . − sn )w2 + . . . + (sn−1 − sn )wn−1 ≤0 Another subcase is that w1 /s1 ≥ w2 /s2 ≥ w3 /s3 ≥ . . . ≥ wn−1 /sn−1 ≥ wn /sn . In this subcase, the total revenue VCG mechanism generates is: s1 (w2 + w3 + . . . + wn ) + s2 (w3 + w4 + . . . + wn ) + . . . + sn−1 wn

(10)

The revenue comparison result is the same as subcase 1. It is because: (n − 1)w1 s1 + (n − 2)w2 s2 + . . . + wn−1 sn−1 − (w2 + w3 + . . . + wn )s1 − (w3 + w4 + . . . + wn )s2 − . . . − sn−1 wn =((n − 1)w1 − w2 − w3 − . . . − wn )s1 + ((n − 2)w2 − w3 − . . . − wn )s2 + . . . + (wn−1 − wn )sn−1 ≤0 Case 2

a) w1 ≤ w2 ≤ w3 ≤ . . . ≤ wn−1 ≤ wn b) s1 ≥ s2 ≥ s3 ≥ . . . ≥ sn−1 ≥ sn

This scenario often happens in the market when urgent jobs with high values and short timespans come into the market, while a number of jobs are being scheduled. For example, there are a lot of services that need a large amount of CPU time to process, but some customer-oriented services need to be attended promptly. This situation creates a problem of how to schedule this urgent job and how much it pays. In this case, we analyze the revenue when jobs in the market follow this pattern. Both our truthful mechanism and VCG mechanism produce the same time slots allocation and revenue formula as the first subcase in Case 1. However, the revenue from our truthful mechanism is equal to or greater than that from VCG mechanism. It is because time-span relationship differs from that in Case 1. The proof is as follows: (n − 1)w1 s1 + (n − 2)w2 s2 + . . . + wn−1 sn−1 − (w1 + w2 + . . . + wn−1 )sn − (w1 + w2 + . . . + wn−2 )sn−1 − . . . − w1 s2 =(n − 1)w1 s1 + (n − 2)w2 s2 + . . . + wn−1 sn−1 − w1 (s2 +s3 + . . .+sn−1 +sn )−w2 (s3 + s4 + . . . + sn−1 + sn ) − . . . − wn−1 sn =((n − 1)s1 − s2 − s3 − . . . − sn )w1 + ((n − 2)s2 − s3 − . . . − sn )w2 + . . . + (sn−1 − sn )wn−1 ≥0


6

31

A Truthful Auction for Time Slots on Multiple CPUs

In this section, we extend our previous result to multiple CPUs setting. We propose a mechanism for pricing time slots on multiple CPUs, and prove that the mechanism is also incentive compatible when bidders are only allowed to submit a fake weight. The problem is formulated as follows: There are k CPUs, and an auctioneer sells m commodities (time slots) T = {t1 , t2 , . . . , tm } on each CPU to n buyers (jobs) I = {1, 2, . . . , n}. Therefore, the total number of time slots is km. Let Tpq be the pth time slot on CPU q. Each buyer i needs time si to complete its task and has weight wi > 0. The valuation function of buyer i for a bundle of time slots Ti is vi (Ti ) = wi (m − t), where t is the latest time-slot item in Ti . The utility ui of buyer i is vi (Ti ) − p(Ti ). The goal of the mechanism is to give buyers an incentive to report its true value of w and s as a bid. The solution to this problem is inherited from the idea on single CPU. The buyers are ordered by their submitted weights w. Without loss of generality, assume that w1 ≥ w2 . . . ≥ wn . Assign time slots on different CPUs to buyers according to the rank of their weights. We denote the time slot allocation as A and the bundle of time slots assigned to buyer i as Ti (A) = {tpq , tp(q+1) , ...tpk , ...tp k } where |Ti (A)| = si , and p, p are the start and finish time of buyer i. Let Bi (A) be the time slots after the finish time of buyer i, i.e. Bi (A) = {p + 1, . . . , m}. We also define Mi (A) as the job index with maximum weight assigned to the ith time slots among all CPUs. The price of the bundle of time slots Ti (A) is wMj (A) (11) p(Ti (A)) = j∈Bi (A)

If the context is clear, we will omit A in equations. Suppose that there are 3 CPUs and 4 buyers, the time spans and weights are {2, 4, 5, 1} and {9, 6, 4, 5}. In this example, buyer 1 is assigned to the first time slot of CPU 1 and 2; buyer 2 is assigned to the first time slot of CPU 3 and the second time slot of CPU 1, 2 and 3; buyer 3 is assigned to the third time slot of CPU 1, 2 and 3 and the fourth time slot of CPU 1 and 2; finally, buyer 4 is assigned to the fourth time slot of CPU 3. The intuition behind Equation 11 is that the price of the bundle of time slots for each buyer is dependent on the maximum weight buyer on every time slot among all CPUs after its finish time. In this example, buyer 1 pays p(T1 ) = j∈Bi wMj = w2 + w3 + w3 = 14. Applying the same method, the payments of buyer 2, 3 and 4 are 8, 0 and 0. Theorem 3. The auction mechanism in Algorithm 2 is incentive-compatible. Proof. Fix a buyer i, the valuation function vi = wi (m − t), w−i and s−i , we show that the utility ui when buyer i declares wi is not less than the utility ui when buyer i declares a fake wi . In this proof, we do not take buyers declaring a fake s into consideration. It is because that buyer i cannot complete its task if si < si . If buyer i submits si > si , in practice, the auctioneer is able to check

32

Q. Zhang and M. Li

whether each bidder submit its s truthfully or not from the process state or log file of the CPU. Therefore, the auctioneer can inflict penalty on buyer i in that case. Algorithm 2. Auction mechanism for time-slot on multiple CPUs Input: A set of jobs I = {1, 2, . . . , n} with weight w and timespan s ordered by w, A set of time slots T = {t11 , t12 , . . . , t1k , t21 , . . . , tpk } on k CPUs Output: A set of allocation T and a set of prices P begin timeslot = 1 ; cpu = 1 ; for k ← 1 to n do for j ← 1 to sk do Tk ← Tk ∪ ttimeslot,cpu ; f inish timek = timeslot; if cpu = 1 then Mtimeslot = k ; cpu ← cpu + 1; if cpu > k then cpu = 1 ; timeslot = timeslot + 1 ; for k ← 1 to n do for j ← f inish timek + 1 to p do p(Tk ) = p(Tk ) + wMj ; end

If buyer i bids wi > wi , it will increase the ranking of buyer i. Because of the multiple CPUs, the increase on the ranking might not advance the finish time of buyer i. It is because buyer i might finish its job on different CPUs at the same time as when it bids the true value. In this case, the price and valuation of buyer i remain unchanged. Otherwise, even buyer i will finish its job earlier, it will not improve the utility of buyer i. Suppose that the finish time is β when buyer i bids truthfully and β if buyer submits wi . The valuation of buyer i improves wi (β − β ). Nonetheless, buyer i need to pay j∈{β +1,...,β} wMj more. Hence,its utility improves by:

vi (Ti ) − pi (wi , si , w−i , s−i ) − (vi (Ti ) − pi (wi , si , w−i , s−i ))

=vi (Ti ) − vi (Ti ) − (pi (wi , si , w−i , s−i ) − pi (wi , si , w−i , s−i )) =wi (β − β ) − wMj

(12)

j∈{β +1,...,β}

Because all buyers are scheduled by their submitted w, when buyer i reports a fake wi > wi , all jobs scheduled between β + 1 and β have a w ≥ wi . Therefore, Equation 12 always produces a non-positive result.


33

On the other hand, if buyer i reports wi < wi , it will lower the ranking of buyer i. The loss of ranking might not postpone the finish time of buyer i. In this case, the price and valuation of buyer i remain the same. If buyer i could accomplish its job at a time β > β and pays less, it still will not improve the utility of buyer i. Reporting wi instead of wi , the valuation of buyer i drops wi (β −β) and buyer i pays j∈{β+1,...,β } wMj less. However, its utility improves by:

vi (Ti ) − pi (wi , si , w−i , s−i ) − (vi (Ti ) − pi (wi , si , w−i , s−i ))

=vi (Ti ) − vi (Ti ) − (pi (wi , si , w−i , s−i ) − pi (wi , si , w−i , s−i )) wMj = − wi (β − β) +

(13)

j∈{β+1,...,β }

Because all buyers scheduled in time slots {β + 1, . . . , β } have weight w ≤ wi , Equation 13 will have a non-positive result, which means bidding a fake value w will not improve buyer i’s utility.

7

Conclusion and Discussion

In this paper, we present an incentive-compatible auction for selling processing time slots on single CPU. With the similar technique, we propose an auction for selling processing time slots on multiple CPUs where bidders are also willing to submit their true private values as bids. We believe our auction mechanism can generate more profit than the VCG mechanism on average. This study helps us to explore the possible truthful auction design when the CPU processing time slots is the commodity in the market. As cloud computing becomes a trend of future Internet computing, sharing or allocation of resource and computing power will be an important issue. The resource or computing power provider will not be exclusive in that market since each participant will play both roles of provider and buyer. The complexity of that market increases which leaves a question that how to design an incentive-compatible mechanism. We believe that it is a possible extension of our current work.

References 1. Bar-Yossef, Z., Hildrum, K., Wu, F.: Incentive-compatible online auctions for digital goods. In: Proceedings of the thirteenth annual ACM-SIAM symposium on Discrete algorithms, p. 970 (2002) 2. Buyya, R., Stockinger, H., Giddy, J., Abramson, D.: Economic models for management of resources in grid computing. In: Technical Track on Commercial Applications for High-Performance Computing, SPIE International Symposium on The Convergence of Information Technologies and Communications, ITCom 2001 (2001) 3. Clarke, E.: Multipart pricing of public goods. Public choice 11(1), 17–33 (1971) 4. Deng, X., Huang, L., Li, M.: On walrasian price of cpu time. Algorithmica 48(2), 159–172 (2007)

34

Q. Zhang and M. Li

5. Goldberg, A., Hartline, J., Wright, A.: Competitive auctions for multiple digital goods. In: Meyer auf der Heide, F. (ed.) ESA 2001. LNCS, vol. 2161, pp. 416–427. Springer, Heidelberg (2001) 6. Groves, T.: Incentives in teams. Econometrica: Journal of the Econometric Society, 617–631 (1973) 7. Huberman, B., Hogg, T.: Distributed computation as an economic system. The Journal of Economic Perspectives, 141–152 (1995) 8. Vickrey, W.: Counterspeculation, auctions, and competitive sealed tenders. The Journal of Finance 16(1), 8–37 (1961) 9. Walsh, W., Wellman, M., Wurman, P., MacKie-Mason, J.: Some economics of market-based distributed scheduling. In: Eighteenth International Conference on Distributed Computing Systems (1998)