Distributed algorithmic mechanism design for scheduling on unrelated machines

J. Parallel Distrib. Comput. 71 (2011) 397–406

Contents lists available at ScienceDirect

J. Parallel Distrib. Comput. journal homepage: www.elsevier.com/locate/jpdc

Distributed algorithmic mechanism design for scheduling on unrelated machines✩ Thomas E. Carroll a , Daniel Grosu b,∗ a

Pacific Northwest National Lab, 902 Battelle Boulevard, Richland, WA 99352, USA

b

Department of Computer Science, Wayne State University, Detroit, MI 48202, USA

article

info

Article history: Received 18 January 2010 Received in revised form 29 October 2010 Accepted 6 November 2010 Available online 18 November 2010 Keywords: Algorithmic mechanism design Scheduling on unrelated machines Truthful mechanism Distributed computation

abstract In classical mechanism design the outcome of the mechanism is computed by a trusted central party. In this paper, we consider the design of distributed mechanisms in which the outcome is computed by the agents themselves. We propose Distributed MinWork (DMW), a mechanism for solving the problem of scheduling on unrelated machines. We show that DMW is a faithful implementation of the MinWork mechanism, which was proposed by Nisan and Ronen in their seminal work (Nisan and Ronen (2001) [30]). We show that in addition to being faithful, DMW protects the anonymity of the losing agents and the privacy of their bids. Furthermore, we show that DMW is efficient as it has polynomial communication and computation costs. © 2010 Elsevier Inc. All rights reserved.

1. Introduction The Internet has emerged as the global platform for computation and communication offering nearly unlimited resources that can be utilized to solve a vast array of problems. The Internet resources are controlled and operated by a multitude of selfinterested, independent parties. These parties may manipulate the protocols in their own benefit and their selfish behavior may lead to degraded performance and reduced efficiency. Solving such problems involving selfish agents is the subject of mechanism design theory (also called implementation theory) [32]. This theory focuses on designing protocols in which the agents are given incentives (e.g., payments) so that their selfish behavior results in the desired outcome. In this setting, each participating agent has a privately known function called valuation which quantifies its benefit or loss. An agent reports a bid to a centralized mechanism; the bid may not be the agent’s true valuation. The mechanism chooses an outcome that maximizes (minimizes) a given objective function and makes payments to the agents. The valuations and payments are expressed in some common unit of currency. The payments are designed and used to motivate the agents to

✩ This research was supported in part by NSF grant DGE-0654014. This paper is a revised and significantly extended version of Carroll and Grosu (2005) [8,9] presented at PODC 2005 and I-SPAN 2005. ∗ Corresponding author. E-mail addresses: [email protected] (T.E. Carroll), [email protected] (D. Grosu).

0743-7315/$ – see front matter © 2010 Elsevier Inc. All rights reserved. doi:10.1016/j.jpdc.2010.11.004

report their true valuations. Mechanisms in which agents maximize their utility by reporting their true valuations are called truthful or strategyproof mechanisms. Reporting the true valuations leads to an optimal value for the objective function. The goal of each agent is to maximize the sum of its valuation and payment. A good general introduction to mechanism design is Chapter 9 of [31]. Traditionally, we were solely concerned with computational tractability, but now we must also address incentive compatibility. This led to the development of algorithmic mechanism design (AMD) [30]. The AMD model assumes a centralized trusted party which computes the outcomes of the mechanism. This model cannot be always used to solve problems that are inherently distributed, thus creating the necessity of distributed implementations. Distributed Algorithmic Mechanism Design (DAMD) [18] has the same objectives as AMD, but in addition the model is characterized by the distribution of the agents, information, and computation. In DAMD agents themselves determine the outcome of the mechanism and thus, create new opportunities for the agents to manipulate the protocols. Any distributed implementation must address protocol manipulation in addition to the issues arising from AMD. In their seminal paper, Nisan and Ronen proposed a truthful scheduling mechanism called MinWork [30]. The objective of MinWork is to allocate a set of tasks to a set of agents such that the completion time of the last assignment is minimized. It assumes a trusted central administrator with which the agents freely communicate. The administrator accepts the agents’ bids and computes the schedule as a function of the bids. The problem

398

T.E. Carroll, D. Grosu / J. Parallel Distrib. Comput. 71 (2011) 397–406

associated with this approach is that the administrator must be trusted by all parties and has limited scalability and reliability. In this work, we design a distributed variant of MinWork which we call Distributed MinWork (DMW). DMW does not use a central trusted administrator, but instead, the agents themselves compute the schedule and payments. For each task needing assignment, we execute a distributed Vickrey auction and the winner of the auction is assigned the task. In DMW, an agent encodes its bid in the degree of a randomly chosen polynomial. A consequence of this is that the bid value must be discrete and from a known set. DMW is a faithful distributed implementation of MinWork, i.e., rational agents maximize their utility by following the prescribed protocol. In addition to guaranteeing faithfulness, which is the main goal of our design, DMW determines the outcome without disclosing the identities of the losing agents and their bids. DMW has polynomial communication and computation costs. Feigenbaum and Shenker [19] presented several open problems related to DAMD. The design of DMW provides insights into few of these problems. Even though the solutions are specific to the context of scheduling, they will help advance the research on distributed algorithmic mechanism design. 1.1. Related work In their seminal paper, Nisan and Ronen [30] introduced algorithmic mechanism design (AMD), which bridged computational tractability with incentive compatibility. In their work, they used the celebrated Vickrey–Clarke–Groves (VCG) mechanism [15,21,38] for solving several standard problems in computer science including shortest path in a graph and scheduling on unrelated machines. They proposed a polynomial-time mechanism called MinWork, which is a n-approximation (where n is the number of agents) to the scheduling on unrelated machines problem. In the same work, the authors designed a randomized 7/4-approximation mechanism for scheduling on two machines. Mu’alem and Schapira [28] generalized the randomized mechanism proposed in [30] to n machines. Christodoulou et al. [12] showed that the lower bound on the approximation ratio of √ truthful mechanisms for scheduling on unrelated machines is 1 + 2. Archer and Tardos [4] designed a 3-approximation randomized mechanism that solves the scheduling on related machines problem that is truthful in expectation only. Their mechanism is characterized as being frugal which means that the payments are small by some measure [5]. Auletta et al. [6] proposed a deterministic truthful mechanism that is a (4 + ϵ )-approximation (for any fixed ϵ > 0) for a fixed number of machines. Andelman et al. [1] improved on the result by proposing a (4 + ϵ )-approximation mechanism for an arbitrary number of machines. Kovács [25,26] further improved the approximation ratio to 3 and later to 2.8. Andelman and Mansour [2] gave a 2-approximation ex post Nash mechanism for this scheduling problem. Dhangwatnotai et al. [16] designed a monotone randomized PTAS that gives a polynomialtime truthful in expectation mechanism for scheduling on related machines. Recently, Christodoulou and Kovács [13] provided a truthful deterministic PTAS. Grosu and Chronopoulos [20] designed a truthful mechanism for load balancing in distributed systems where the agents are modeled as M /M /1 queues. Carroll and Grosu [10,11] devised truthful mechanisms for divisible load scheduling. Angel et al. [3] investigated selfish tasks scheduling (each task is modeled as an agent) and proposed a truthful (2 − 1/n)-approximation mechanism to solve the problem. AMD assumes a central administrator with which all agents freely communicate. Distributed algorithmic mechanism design (DAMD) has the same objectives as AMD, but assumes the agents, information, and computation to be distributed throughout the

network [19]. Feigenbaum et al. [17,18] initiated the study of DAMD for cost sharing in multicast trees and lowest-cost unicast routing. Mitchell and Teague [27] extended the multicast cost sharing mechanism by considering a new model where the nodes are controlled by the strategic agents and are permitted to deviate from the protocol. Cheating is detected through the use of digital signatures and when detected, results in heavy fines. The fines are so overwhelmingly large that it dwarfs any potential profit earned from cheating and it readily deters risk-averse and riskneutral agents from cheating. Ng et al. [29] broadens DAMD to envision competing distributed mechanisms in an open marketplace. They proposed that all future protocols and infrastructure must explicitly address selfinterested parties as part of the strategyproof computing (SPC) paradigm. Characteristic to SPC is the fact that the protocols and the infrastructure are open to maintain competition and flexibility and to support future innovations. The protocols are periodically verified to ensure that they implement a strategyproof mechanism. The problem of verifying the strategyproofness of mechanisms in such open environments has been investigated in [22]. Shneidman and Parkes [36] studied the problem of creating distributed system specifications that are faithfully implemented in systems composed of rational nodes. A faithful implementation guarantees that no node will deviate from the specifications and receive increased utility. They suggested a set of methods to obtain faithfulness. One of the methods suggested is cryptography, the approach that we employ in this work. Parkes and Shneidman [33] considered distributed mechanism implementations and proposed a set of principles that can be used to develop faithful implementations. The implementations assume the existence of a center and are not fully distributed. The faithfulness of the BitTorrent peer-to-peer file sharing protocol is examined in [37]. Brandt and Sandholm [7] investigated the possibility of obtaining unconditional full privacy in sealedbid auctions (i.e., privacy that does not rely on intractability assumptions or on trusted third parties). Their impossibility result is that the second-price sealed bid auction for more than two bidders cannot be emulated by a fully private protocol. 1.2. Contributions We propose a distributed scheduling mechanism, called Distributed MinWork (DMW), which is a distributed implementation of the centralized scheduling mechanism proposed in [30]. The agents themselves compute the allocation and payment functions by participating in a set of parallel and independent distributed Vickrey auctions. There is an auction for each task to be assigned. The winner of the ith auction is assigned the ith task. DMW is based on the ideas presented in [23] where a distributed (M + 1)-st auction is implemented by a set of auctioneers. DMW is different from the protocol presented in [23] in that the outcome of the distributed auction is computed by the agents themselves and not by a set of trusted auctioneers. In DMW an agent encodes its bid in the degree of a randomly chosen polynomial. The bid must be a discrete value, larger than 0 and less than a maximum value that is dependent on both the total number of participants and the maximum possible number of faulty participants. Once the bid is encoded, the agent communicates shares of it directly to the other agents. The shares are used by each agent as input to a degree resolution procedure [14]. By determining the degree, an agent is able to determine the winner, the first-price bid, and the secondprice bid. The identities and the bids of the losing agents are not revealed when fewer than a given number of agents collude. This is a direct consequence of using a threshold-based secret sharing scheme in the design of DMW. DMW is a faithful implementation

T.E. Carroll, D. Grosu / J. Parallel Distrib. Comput. 71 (2011) 397–406

399

Table 1 Comparison of the communication and computational costs of MinWork (centralized mechanism) and DMW (distributed mechanism), where m is the number of tasks, n is the number of machines, and p is a random prime number used in the cryptographic primitives involved in DMW.

MinWork DMW

Communication cost

Computational cost

Θ (mn) Θ (mn2 )

Θ (mn) O(mn2 log p)

of MinWork. In a faithful implementation, the agents participating in a distributed mechanism maximize their utility by following the prescribed protocol [36]. Faithfulness is characterized by ex post Nash equilibrium. Even though a faithful implementation of MinWork can be obtained using the distributed VCG mechanism in [33], their design assumes the existence of a center that participates in the mechanism execution, and thus, it is not fully distributed. DMW is a fully distributed faithful mechanism. We introduce and define a new property of distributed mechanisms called strong voluntary participation. In a strong voluntary participation mechanism an agent that follows the prescribed protocol never incurs a loss. We prove that DMW is a strong voluntary participation mechanism. Finally, we show that DMW has polynomial communication and computational costs. We give the communication and computational costs of MinWork and DMW in Table 1. This is a direct result of considering a set of distributed auctions as it is efficient in terms of computation and communication when compared to existing secure function evaluation procedures. Considering the scheduling on unrelated machines problem, the design of DMW provides insight into Open Problem 10, 11 and 12 presented in [19]. Regarding Open Problem 10, the centralized MinWork can be simply distributed among obedient nodes. By using cryptographic techniques, we are able to develop a distributed mechanism with a much more realistic strategic model that tolerates strategic and adversarial nodes. Regarding Open Problem 11, DMW tolerates protocol deviations. As long as the number of agents obeying the protocol remains above a threshold, the mechanism is computable. If the number of agents drops below the threshold, the mechanism cannot be resolved. Regarding Open Problem 12, DMW protects the privacy of the agents (see Theorem 10). It is, however, imperfect since it reveals some information such as the winning user and the first-price and second-price bids. The disclosure of this information is intrinsic to the scheduling problem. 1.3. Organization The paper is structured as follows. In Section 2, we present the theory and primitives on which our distributed scheduling mechanism is based. In Section 3, we present and detail our proposed mechanism. In Section 4, we show the properties of the mechanism and its complexity. In Section 5, we draw conclusions and present future directions. 2. Preliminaries 2.1. The scheduling problem We consider the problem of scheduling m ≥ 1 independent tasks T 1 , T 2 , . . . , T m on n ≥ 1 agents (machines) A1 , A2 , . . . , An . Each task T j is characterized by its processing requirement of r j j units of time. Each agent Ai can process task T j at speed si > 0. j

j

Thus, task T j would take ti = r j /si time to be processed by Ai . A schedule S is a partition of the set of tasks indices into disjoint sets Si , i = 1, . . . , n. Partition Si contains the indices corresponding to all the tasks allocated to Ai . The goal is to obtain

Fig. 1. A mechanism with allocation function S(y) and agent Ai bidding yi and receiving payment Pi .

a schedule S maximizing (minimizing) a given objective function (e.g., minimizing the makespan, minimizing the sum of completion times). In the scheduling literature, this problem is known as scheduling on unrelated machines [34]. 2.2. Centralized scheduling mechanisms In this section, we define the concept of a centralized mechanism, the mechanism design problem and the desirable properties of a mechanism. Definition 1 (Centralized Mechanism). A centralized mechanism consists of the following three components: 1. The type space: 2 = 21 × 22 × · · · × 2n . 2. The allocation function: S(y) = {S1 (y), S2 (y), . . . , Sn (y)}. This function has as input the vector of agents’ bids y = {y1 , y2 , . . . , yn }, where y ∈ 2, and returns an output S ∈ S . 3. The payment function: P (y) = {P1 (y), P2 (y), . . . , Pn (y)}, where Pi (y) is the payment handed by the mechanism to agent Ai . We depict a mechanism in Fig. 1. The role of the mechanism designer is to design these two functions such that the mechanism satisfies some desirable properties. Definition 2 (Centralized Mechanism Design Problem). The problem of designing a scheduling mechanism is characterized by: 1. A feasible set 2 = 21 × 22 × · · · × 2n of types, where 2i is Ai ’s set of types. 2. A finite set S of allowed outputs. The output is a schedule S(y) = {S1 (y), S2 (y), . . . , Sn (y)}, where S(y) ∈ S , is computed according to the bids, y = {y1 , y2 , . . . , yn } , y ∈ 2.  1agents’ Here, yi = yi , y2i , . . . , ym is the vector of values (bids) i reported by agent Ai to the mechanism. 3. Each agent Ai (i = 1, . . . , n) has for each task T j a privately j known parameter ti ∈ 2i (j = 1, . . . , m) called the true value which represents the time required by agent Ai to execute task T j . The preferences of agent Ai are given by a function called ∑ j valuation Vi (S(y), ti ) = − j∈Si (y) ti (i.e., the negation of the total time it takes  to complete all tasks assigned to it). Here ti = ti1 , ti2 , . . . , tim . 4. Each agent’s goal is to maximize its utility. The utility of agent Ai is Ui (y, ti ) = Pi (y) + Vi (S(y), ti ), where Pi is the payment handed by the mechanism to agent Ai . 5. The goal of the mechanism is to select a schedule S that ∑ j minimizes the makespan, Cmax = maxi j∈Si (y) ti . j

An agent Ai may report a value (bid) yi for a task T j different from j ti .

its true value The true value characterizes the actual processing capacity of agent Ai . The goal of a truthful scheduling mechanism is to give incentives to agents such that it is beneficial for them to report their true values. We now define the concept of truthful mechanism.

400

T.E. Carroll, D. Grosu / J. Parallel Distrib. Comput. 71 (2011) 397–406

Definition 3 (Truthful Mechanism). A mechanism is truthful or strategyproof if Ui ({y−i , ti } , ti ) ≥ Ui (y, ti ), for every agent Ai of type ti , bid yi ̸= ti , and the bids y−i = {y1 , y2 , . . . , yi−1 , yi+1 , . . . , yn } of the other agents (i.e., truth-telling is a dominant strategy). Another useful property for mechanisms is voluntary participation. An agent willingly participates in these mechanisms in hope of profit. Definition 4 (Voluntary Participation). We say that a mechanism satisfies the voluntary participation condition if Ui ({y−i , ti } , ti ) ≥ 0 for every agent Ai of type ti , and the bids y−i = {y1 , y2 , . . . , yi−1 , yi+1 , . . . , yn } (i.e., truthful agents never incur a loss). Nisan and Ronen [30] designed the truthful MinWork mechanism for scheduling tasks on unrelated machines (processors), where the machines are rational. MinWork is a centralized scheduling mechanism that minimizes the total work done and is a n-approximation mechanism for the problem of minimizing the makespan. We formally present the mechanism in the following. Definition 5 (MinWork Mechanism [30]). The mechanism that gives an approximate solution to the scheduling on unrelated machines problem is defined by the following components: (i) The type space: 2 = 21 × 22 × · · · × 2n , where 2i is the set of possible values of the time required by agent Ai to execute each task T j , j = 1, 2, . . . , m. (ii) The allocation function: each task is allocated to the agent who is able to execute the task in a minimum amount of time. The allocation is random when there is more than one agent with minimum type. (iii) The payment function for agent Ai given by: Pi (y) =

− j∈Si (y)

j

min yi′ . i′ ̸=i

(1)

The MinWork mechanism can be viewed as running a set of parallel and independent Vickrey auctions, one for each task. In this paper, we design a distributed mechanism that retains the allocation and payment policies of MinWork. 2.3. Distributed scheduling mechanisms Distributed mechanisms differ from centralized mechanisms in that the agents can manipulate not only the inputs but also the underlying algorithm. Agents can implement a protocol different from the one specified by the mechanism designer. In this paper, we say that the agents follow a different strategy from the one suggested by the mechanism designer. Definition 6 (Distributed Mechanism Design Problem [36]). The problem of designing a distributed scheduling mechanism is characterized by: 1. The finite strategy space X = X1 × X2 × · · · × Xn , where Xi is Ai ’s set of feasible strategies. 2. A suggested strategy χsuggest ∈ X which implements the distributed algorithm. 3. Each agent Ai (i = 1, . . . , n) has for each task T j a privately j known parameter ti ∈ 2i (j = 1, . . . , m) called the true value which represents the time required by agent Ai to execute task T j . 4. A finite set S of allowed outputs. The output is a schedule S(χ(t)) = {S1 (χ(t)), S2 (χ(t)), . . . , Sn (χ(t))}, S(χ(t)) ∈ S , computed according to the agents’ strategies, χ(t) = {χ1 (t1 ), χ2 (t2 ), . . . , χn (tn )}. Here χi (ti ) = {χi (ti1 ), χi (ti2 ), . . . , χi (tim )} is the vector of Ai ’s strategies, where χi : 2i → Xi and t1 = {ti1 , ti2 , . . . , tin }.

5. The preferences of agent Ai are given by a function called val∑ j uation Vi (S(χ(t)), ti ) = − j∈Si (χ(t)) ti . Each agent’s goal is to maximize its utility. The utility of agent Ai is Ui (χ(t), ti ) = Pi (χ(t)) + Vi (S(χ(t)), ti ), where Pi is the payment handed by the mechanism to agent Ai . 6. The goal of the mechanism is to select a schedule S that minimizes the makespan. Unlike centralized mechanisms, the agents themselves implement the mechanism which provides new ways to manipulate the mechanism. Truthfulness considers only the inputs to the mechanism; it assumes that the algorithm is executed by a trusted administrator that has no interest in manipulating the outcome. In a distributed mechanism even if an agent Ai bids truthfully, it can still manipulate the outcome by implementing any strategy . Consequently, truthfulness is not a strong enough χi ̸= χsuggest i concept in the context of distributed mechanism implementations. Distributed mechanisms should provide incentives such that agents are better off only by implementing the suggested strategy. This property is referred to as faithfulness. Now we give a formal description of a distributed mechanism and its associated concepts. Definition 7 (Distributed Mechanism [36]). A distributed mechanism consists of the following components: 1. The strategy space: X = X1 × X2 × · · · ×  Xn , where Xi is Ai ’s set of feasible strategies. Denote by χ = χ1 , χ2 , . . . , χn the strategy profile where Ai plays χi ∈ Xi . 2. The suggested strategy: χsuggest ∈ X. This is the strategy specified by the mechanism designer. 3. The allocation function: S(χ(t)) = {S1 (χ(t)), S2 (χ(t)), . . . , Sn (χ(t))}, where Si (χ(t)) is the output specific to Ai . The function S takes as input the strategy χ(t) and computes the output such that S ∈ S . 4. The payment function: P (χ(t)) = {P1 (χ(t)), P2 (χ(t)), . . . , Pn (χ(t))}, where Pi (χ(t)) is the payment handed to agent Ai . Notice that centralized and distributed mechanisms differ in the inputs to the allocation and payment functions. Specifically, S(·) and P(·) are functions of bids in the former and strategies in the latter. In the centralized case we desire strategyproof mechanisms since they require very weak knowledge assumptions. Since the equilibrium concept is the dominant strategy equilibrium, there is no need for the agents to know the types of the other agents. More than this the rationality assumption does not need to be common knowledge. In this paper, we adopt ex post Nash equilibrium, a solution concept that requires a stronger knowledge assumption, that is, the rationality of the participants is common knowledge. Ex post Nash equilibrium is more suitable than dominant strategy equilibrium in a distributed setting since now the agents themselves compute the outcome of the mechanism and may deviate arbitrarily from the specification of the mechanism. Definition 8 (Ex Post Nash Equilibrium). A strategy χ is an ex post Nash equilibrium if it satisfies Ui (χ(t), ti ) ≥ Ui ({χ−i (t−i ), χ′i (ti )}, ti ), for all agents Ai , χi ̸= χ′i , all true values ti , and all true values t−i of other agents. In an ex post Nash equilibrium no agent has an incentive to deviate from its strategy even if it knows the private information of the other agents. The standard Nash equilibrium is not realistic for our setting since it requires any agent to have knowledge of the private information of all the other agents. In the distributed case we desire mechanisms with the following property.

T.E. Carroll, D. Grosu / J. Parallel Distrib. Comput. 71 (2011) 397–406

Definition 9 (Faithfulness [36]). A distributed mechanism is a faithful implementation of output S ∈ S if suggested strategy χsuggest is an ex post Nash equilibrium (i.e., it satisfies Ui (χsuggest (t), ti ) ≥ suggest , all true (t−i ), χi (ti )}, ti ), for all agents Ai , χi ̸= χsuggest Ui ({χ−i i values ti , and all true values t−i of other agents). In other words a faithful implementation guarantees that an agent obtains the maximum utility when it follows the suggested strategy. Voluntary participation needs to be extended to operate in the context of distributed mechanisms. We call this extension strong voluntary participation. Definition 10 (Strong Voluntary Participation). A distributed mechanism satisfies the strong voluntary participation condition when Ui

   (ti ) , ti ≥ 0, χ−i (t−i ), χsuggest i suggest

for every agent Ai , Ai ’s suggested strategy χi strategies χ−i , and true values t.

, all other agents’

In a strong voluntary participation mechanism an agent that follows the suggested strategy never incurs a loss. 2.4. Polynomial degree resolution In our distributed mechanism each agent encodes its bid in the degree of a random polynomial. The agents will determine the winning bid by performing a polynomial degree resolution procedure based on Lagrange interpolation. In the following we present the basic concepts related to polynomial degree resolution. Definition 11 (Lagrange Interpolation). Let f be a polynomial of degree d, f (x) = a0 + a1 x + · · · + ad xd , where a0 , a1 , . . . , ad ∈ Z∗p and Z∗p is the multiplicative group of integers modulo p. The s-th Lagrange interpolation of f , denoted by f (s) (0), is defined as: f (s) (0) =

s − j =1

f (αj )

∏ i̸=j

αi αi − αj

(2)

where α1 , . . . , αs ∈ Z∗p are distinct, non-zero interpolation points. We can determine the degree of f as the least s that satisfies f (s) (0) = f (0). If s = d then the d-th interpolation always satisfies f (d) (0) = f (0). If s > d and assuming random picking of the polynomial coefficients from Z∗p then the degree resolution mistakenly succeeds with probability 1p . This probability is very small assuming a very large prime p. An efficient algorithm for computing f (s) (0) is given below [14]. f (α ) Step 1: ψk = ∏ (αk−α ) , for k = 1, . . . , s. k i∏ ̸=k i s Step 2: φ(0) = k=1 (αk ). ∑s ψ Step 3: f (s) (0) = φ(0) k=1 α k . k

If we assume that the cost of multiplication operation is equal to the cost of computing the multiplicative inverse, it is obvious that the computational complexity of the algorithm is Θ (s2 ). In our proposed mechanism we will use a distributed version of this algorithm. In the distributed version, each agent Ai broadcasts ψi /αi to the other agents. The rest of the computation is performed locally by each agent. 3. The distributed scheduling mechanism The MinWork mechanism proposed in [30] requires a trusted central administrator to which each agent reports its bid. Based on the bids received, the central administrator computes the allocation and informs the agents about it. This approach has several drawbacks. First, the administrator must be trusted by all the agents that it will properly accept bids and compute the resulting schedule. This is problematic when several autonomous

401

administrative domains must cooperate to choose an administrator. Second, it offers limited scalability. The administrator is a bottleneck; it performs most of the computations and it is an endpoint for all communications. Third, the administrator is a single point of failure and thus, provides limited reliability. Distributed scheduling mechanisms do not suffer from these problems since there is no central administrator involved in making the allocation and payment decisions. Instead, the agents interact to decide the schedule and the payments. Distributed scheduling mechanisms must ensure that agents’ private information is not exposed or used to manipulate the outcome. We propose a distributed scheduling mechanism called Distributed MinWork (DMW). To design DMW we exploit the fact that MinWork can be viewed as running a set of parallel and independent Vickrey auctions, one for each task. The design of DMW is based on the ideas presented in [23] where a distributed (M + 1)-st auction is implemented by a set of auctioneers. DMW is different from the protocol presented in [23] in that the outcome of the distributed auction is computed by the agents themselves, thus, eliminating the need for a set of trusted auctioneers. The design of distributed (M + 1)-st auction presented in [23] relies on a secret sharing protocol in which the information is encoded in the degree of the polynomial. This is different from the standard secret sharing protocols [35], in which the information is encoded in the free term of a polynomial. In DMW, an agent encodes its bid in the degree of a randomly chosen polynomial. The benefit is that the polynomials can be summed and degree resolution on the sum of the polynomials reveals the maximum bid while concealing the other bids. Since we desire to find the smallest bid, we encode the bids in the polynomials such that the degree is inversely related to the bid, i.e., small bids are encoded in large-degree polynomials and vice versa. The bid is a discrete value greater than zero and less than the number of operational agents (i.e., the difference between the total number of participants and the maximum number of faulty agents). Since we are using a secret sharing technique based on the threshold trust model it is important to increase its resilience. This is achieved by adding the maximum number of faulty agents denoted by c to the bids before encoding them. At least c agents are required to collude in order to expose any bids. If fewer agents collude, no bids are exposed. DMW is executed in four phases. In the first phase, called Initialization, the parameters required by the cryptographic primitives together with the set of pseudonyms and the set of possible discrete bids are published. In the second phase, called Bidding, each agent determines its bids for each task and encodes them in the degree of randomly chosen polynomials. Then, each agent computes its commitments and shares based on the randomly chosen polynomials and the published pseudonyms. The agents exchange the shares and publish their commitments. In the next phase, called Allocating tasks, the agents verify that the shares they received are consistent with the published commitments. It the commitments hold then the shares are used in a degree resolution procedure based on Lagrange interpolation (presented in Section 2.4) which determines the highest bid and the winning agent. The second highest bid is determined by applying the degree resolution procedure again, this time, excluding the winner agent’s bid from the procedure. Then, the winning agent and the corresponding task are included in the schedule. In the last phase, called Payments each agent computes its payment by summing the second-price bids corresponding to its allocated tasks and request it from the payment infrastructure. Fig. 2 shows the messages exchanged by the participants in the protocol. In the following we describe the Distributed MinWork (DMW) mechanism. Notation. The following notation is used in describing DMW.

• p, q are large primes such that q | p − 1. • All operations, unless indicated, are (mod p). • z1 , z2 ∈ Z∗p are distinct generators of order q.

402

T.E. Carroll, D. Grosu / J. Parallel Distrib. Comput. 71 (2011) 397–406

Fig. 2. The sequence of messages exchanged among participants. A solid arrow represents a point-to-point message transmission; a dashed arrow represents a published message (e.g., broadcasting).

  • T 1 , T 2 , . . . , T m is the set of m tasks, where T j is task j. • {A1 , A2 , . . . , An } is the set of n agents, where Ai is agent i. • A = {α1 , α2 , . . . , αn } is the set of pseudonyms, where αi ∈ Z∗p is a pseudonym for Ai such that αi ̸= αk for all i ̸= k. • c is the maximum number of faulty agents, where c < n. If the number of faulty agents exceeds c, the mechanism does not guarantee its properties. • W = {w1 , w2 , . . . , wk } is the set of discrete bid values such that 0 < w1 < w2 < · · · < wk−1 < wk < n − c + 1. We assume the existence of a payment infrastructure to which all agents have access. The description of the payment infrastructure is out of the scope of this paper. We also assume the existence of a communication infrastructure composed of a broadcast channel and of private channels among the agents. Distributed MinWork mechanism (DMW): Phase I: Initialization. I. 1 The parameters p, q, z1 , z2 , c , A, and W are published. Phase II: Bidding. For each task T j (j = 1, . . . , m): j II. 1 Agent Ai (i = 1, . . . , n) determines its bid yi ∈ W , and chooses the following random polynomials: j τi

j

ei (x) =

− ℓ=1

j gi

(x) =

σ − ℓ=1

ai,ℓ xℓ j

j ci,ℓ xℓ

j σ −τi

j

fi (x) =

− ℓ=1

j hi

(x) =

σ − ℓ=1

j

bi,ℓ xℓ j

(3)

j

j

j

j

(4)

i,τi

j

j

j

j

i,σ −τi

xσ

= vij,2 x2 + vij,3 x3 + · · · + vij,σ xσ . j In the rest of the paper, we consider vi,1 = 0.

(5)

II. 3 Agent Ai publishes its commitments j



j

j

j



j



j

j

j



j



Oi = Oi,1 , Oi,2 , . . . , Oi,σ Qi = Qi,1 , Qi,2 , . . . , Qi,σ j

j

j

Ri = Ri,1 , Ri,2 , . . . , Ri,σ where

j

vi,1

j

Oi,1 = (z1 )

j

(6)



j

(z2 )ci,1 , . . . , Oji,σ j

= (z1 )vi,σ (z2 )ci,σ , j

Qi,1 = (z1 )

aij,1

i

di i j,τ +1 j

Qi,τ i +1 = (z2 ) j

Ri,1 = (z1 )

= (z1 )

j

ai j j,τ i

i

(z2 )dj,1 , . . . , Qi,τ j = (z1 )

j

bi,1

di i j,τ j

(z2 )

i

, . . . , Qi,σ = (z2 )dj,σ , j

(z2 )di,1 , . . . , Rj

j

gi (αk ), and hi (αk ) to agent Ak (k = 1, . . . , n), who

j

+ · · · + aj j b j

j

j di,ℓ xℓ

j

ei (x)fi (x) = ai,1 bi,1 x2 + ai,1 bi,2 + ai,2 bi,1 x3

and

where σ = wk + c + 1 and τi = σ − yi . j j II. 2 Agent Ai securely transmits the shares ei (αk ), fi (αk ), j

keeps the shares private. We represent the product j j ei (x)fi (x) by the following  expression: 

b

j i,τ −σ i

d

(z2 )

j

i,τi −σ

j j i,τ −σ i

,

j

d

j

R

j

i,τi −σ +1

= (z2 )

j i,τ −σ +1 i

j

, . . . , Rji,σ = (z2 )di,σ .

,

T.E. Carroll, D. Grosu / J. Parallel Distrib. Comput. 71 (2011) 397–406

II. 4 Agents implicitly synchronize at this point; they cannot continue until all shares are transmitted and commitments published. In the following phase of the protocol, the commitments are verified against their associated bids, thus preventing bid manipulation and agents repudiating their bids, both of which are properties of the auction protocol. Phase III: Allocating Tasks. The agents compute the auction outcome for each task T j (j = 1, . . . , m). III. 1 Ai (i = 1, . . . , n) verifies that the shares it received from Ak (k = 1, . . . , n) are consistent with the corresponding commitments by verifying the identity j

j

ek (αi )fk (αi )

(z1 )

(z2 )

j

gk (αi )

=

σ  ∏ ℓ=1

j Ok,ℓ

(αi )ℓ

.

(7)

Similarly, Ai checks the following: j

σ  ∏

j

(z1 )ek (αi ) (z2 )hk (αi ) = Γi,j k = j

ℓ=1

σ  ∏

j

(z1 )fk (αi ) (z2 )hk (αi ) = Φij,k =

ℓ=1

j

Qk,ℓ j

Rk,l

(αi )ℓ

(αi )ℓ

(8)

.

(9)

The computation of (7)–(9) verify that the polynomials of Ak are of degree at most σ and that the j j constant coefficients are zero (i.e., ak,0 = bk,0 = j

j

ck,0 = dk,0 = 0). Computing (8) and (9) may seem redundant in light of (7), but the results are used to validate computations occurring later in the protocol. If an agent is unable to validate the shares, it aborts the protocol. III. 2 If the commitments hold, Ai publishes

Λi = (z1 )E (αi ) and Ψi = (z2 )H (αi ) , (10) ∑n j j where E (αi ) = ℓ=1 eℓ (αi ) and ∑n j j H (αi ) = ℓ=1 hℓ (αi ). j j Any entity can verify that Λi and Ψi are proper j

j

j

j

by checking the following equality n ∏

ℓ=1

j

j

j

Γi,ℓ = Λi Ψi

(11)

(and Λi Ψi = (z1 )E (αi ) (z2 )H (αi ) ). j

j

j

j

j

The smallest element τ∗ ∈ {w ∈ W | σ − w} is computed such that j

τ∗ ∏ j (τ j ) (Λjk )ρk = (z1 )(Ei ) ∗ (0) = 1, (12) k=1 ∏ αk where ρk = i̸=k∈A αi −αk (mod q). The first-price

403

III. 3 There is at least one agent A∗ where j

(f∗j )(y∗ ) (0) = 0,

(14)

which proves its bid is the lowest. The Lagrange j

interpolation (f∗ )(y∗ ) (0) is computed using the distributed algorithm presented in Section 2.4. If more than one agent satisfies (14), the agent with the smallest pseudonym wins. j III. 4 The second-price bid, y∗∗ , is determined by excludj j ing the bid of agent A∗ from Λi and Ψi such that j

j

j

j

Λi =

Λi j

(z1 )e∗ (αi )

Ψi

j

and Ψi =

j

(z2 )h∗ (αi )

.

(15)

All agents publish these values. The agents verify that these values are consistent with the commitments in (11) (excluding agent A∗ ’s values) and j then they compute y∗∗ by (12). III. 5 The schedule S = {S1 , S2, . . . , Sn } is obtained by computing Si = Si ∪ T j , where agent Ai is the winner of task T j . Phase IV: Payments. IV. 1 As the auction for task T j (j = 1, . . . , m) completes, the payment to agent Ai (i = 1, . . . , n) is ∑ j computed as Pi = j∈Si y∗∗ , which is the sum of the second-price bids of the tasks allocated to Ai . Each agent computes the payments and submits the values to the payment infrastructure. The payment infrastructure issues the payment to Ai if the participating agents agree on Pi ; otherwise, no payment is dispensed. 4. Properties and complexity In this section, we study the properties and the complexity of DMW. We provide proofs for the theorems characterizing the properties of DMW. The first property we investigate is faithfulness (Definition 9). Selfish-but-agreeable agents will not deviate from a distributed mechanism that is faithful. An agent is selfish-butagreeable if it only deviates from the algorithm when the action strictly improves its welfare [27]. It is difficult to prove faithfulness by directly applying Definition 9. The following theorem proved in [36] decomposes faithfulness into a set of conditions that are simpler to show. Theorem 1 (Faithfulness [36]). A distributed mechanism is a faithful implementation of outcome S when it conforms to the following three conditions: 1. The corresponding centralized mechanism is truthful. 2. The distributed mechanism has strong communication compatibility. 3. The distributed mechanism has strong algorithm compatibility.

bid is given by y∗ = σ − τ∗ . The Lagrange interpo-

DMW is a distributed implementation of MinWork. Note that the MinWork mechanism is truthful:

lation (Ei )(τ∗ ) (0) is computed using the distributed algorithm presented in Section 2.4.

Theorem 2. The MinWork mechanism is truthful.

j

j

j

j

j

Proof. [30] gives the proof of MinWork’s truthfulness.

Φk,ℓ ,

It is thus left to show that the mechanism has strong communication and algorithm compatibility (see below for formal definitions). As we will see, the first property is vacuously satisfied in our setting, and therefore, one only needs to prove the latter. We use the techniques described in [36] for proving strong communication and algorithm compatibility. In the following the suggested strategy (χsuggest ) refers to the strategy given in the specification of DMW. The suggested strategy χsuggest can be decomposed into three actions: (i) information-revelation action, (ii) message-passing action, and (iii) computational action.

The subset of y∗ agents resolve the winners by j j j disclosing f1 (αk ), . . . , fn (αk ) for k = 1, . . . , y∗ . Any agent can verify the disclosures by checking the following equality

(z1 )F (αk ) Ψij = j

n ∏

ℓ=1 F j (αk )

j

(13)

(z1 ) (z2 )H (αk ) = (z1 )F (αk ) Ψij ) where ∑ j n F j (αk ) = ℓ=1 fℓ (αk ). The agent aborts the pro(and

j

j

tocol if the equality cannot be ascertained.



404

T.E. Carroll, D. Grosu / J. Parallel Distrib. Comput. 71 (2011) 397–406

Definition 12 (Information-revelation Action [36]). An action is an information-revelation action when the only effect is to reveal consistent type information to some other agents. In other words the information revelation actions are actions equivalent to revealing the (truthful or untruthful) type in the centralized mechanism case. Showing that the corresponding centralized mechanism is truthful guarantees that the agents do not have incentives to deviate from the suggested informationrevelation actions. Definition 13 (Message Passing Action [36]). An action is a messaging passing action when the only effect is to send a message that is received from another agent to one or more agents; i.e., an agent forwards messages to others. Definition 14 (Strong Communication Compatibility) [36]). A distributed mechanism exhibits strong communication compatibility when an agent Ai cannot increase its utility by deviating from the specified message-passing scheme, regardless of its other computational or information revelation actions, when the others are following the suggested strategy. Theorem 3. DMW exhibits strong communication compatibility. Proof. By assumption, the underlying network and communication protocols are obedient. Furthermore, DMW does not employ agents forwarding messages. Hence, DMW vacuously satisfies Theorem 3.  We now show that DMW has strong algorithm compatibility. Definition 15 (Computational Action [36]). An action is a computational action when it can affect the outcome of a distributed mechanism and it is not a message passing action. Definition 16 (Strong Algorithm Compatibility [36]). A distributed mechanism exhibits strong algorithm compatibility when an agent Ai cannot increase its utility by deviating from the specified computational actions, regardless of its other messaging-passing or information revelation actions, when the others are following the suggested strategy. Theorem 4. DMW exhibits strong algorithm compatibility. j

Proof. Let agent Ai bid yi for task T j . Assume that if Ai follows the suggested strategy specified in the design of DMW, it receives utility Ui (χ(t), ti ) ≥ 0. Agent Ak (k ̸= i) follows its specified action as required by the definition. We now investigate the ways in which Ai deviates from the protocol. Starting with Phase II: Bidding, if Ai incorrectly computes its shares or commitments, the protocol will be aborted by one of the other agents when verifying them for consistency by computing (7)–(9). Consequently, suggest Ui ({χ−i (t−i ), χi (ti )}, ti ) = 0, where χi ̸= χsuggest is a devii ating strategy. If Ai neglects to send the commitments, the other n − 1 agents will abort the protocol. If Ai fails to send the shares to all the others, an agent not receiving its share will abort the suggest protocol. In either case, Ui ({χ−i (t−i ), χi (ti )}, ti ) = 0. In Phase j

j

III: Allocating Tasks any miscomputing of Λi and Ψi will result in them failing the consistency check (11). If Ai fails to transmit conj j j sistent Λi and Ψi and the degree τ∗ = n, then the first-price bid suggest resolution fails, resulting in protocol termination and Ui ({χ−i

(t−i ), χi (ti )}, ti ) = 0. In the cases where τ∗j < n, resolution is unsuggest affected and thus, Ui ({χ−i (t−i ), χi (ti )}, ti ) = Ui (χsuggest (t), ti ). If during winner identification Ai transmits its share when not needed, it receives the same amount of utility as if it had not; suggest i.e., Ui ({χ−i (t−i ), χi (ti )}, ti ) = Ui (χsuggest (t), ti ). If it neglects

to send its share or sends inconsistent shares, any of the other properly functioning agents, can transmit their shares. Similar to first-price bid resolution, Ai interferes with second-degree bid resj olution when t∗∗ = n; otherwise, it does no harm. In Phase IV: Payments, if Ai submits incorrect values or fails to submit any values it receives zero utility as the result of protocol termination. Thus, an agent cannot obtain higher utility by deviating from the strategy suggested in the DMW specification.  Theorem 5. DMW is faithful. Proof. The faithfulness of DMW is derived directly from Theorems 1–4.  The next property we discuss is strong voluntary participation (Definition 10). Direct application of Definition 10 in proving the property is difficult. In the following we decompose it into a set of easily proven conditions. Definition 17 (Voluntary Communication Participation). A distributed mechanism is a voluntary communication participation mechanism if truthful agent Ai receives non-negative utility when it follows the suggested strategy, independent of the others’ messaging passing actions. Definition 18 (Voluntary Algorithm Participation). A distributed mechanism is a voluntary algorithm participation mechanism if truthful agent Ai receives non-negative utility when it follows the suggested strategy, independent of the others’ computational actions. Theorem 6 (Strong Voluntary Participation). A distributed mechanism is a strong voluntary participation mechanism when it satisfies the following conditions: 1. The centralized mechanism satisfies the voluntary participation conditions. 2. The distributed mechanism satisfies the voluntary communication participation condition. 3. The distributed mechanism satisfies the voluntary algorithm participation conditions. Proof. To prove strong voluntary participation, we assume that Ai is following the suggested strategy and it is truthful. If all the parties are following the suggested strategy, then Ai will not incur a loss due to the first condition. From the other two conditions, we know that Ai will incur no loss when  the others are  deviating from the suggested strategy. Thus, Ui ( χ−i (t−i ), χ(t) , ti ) ≥ 0.  Using Theorem 6 we now prove that DMW satisfies the strong voluntary participation condition. Theorem 7. DMW satisfies the voluntary communication participation condition. Proof. We assumed that the underlying network and associated protocols are obedient. DMW does not employ the forwarding of messages by any nodes. Therefore, DMW satisfies the voluntary communication participation condition.  Theorem 8. DMW satisfies the voluntary algorithm participation condition. Proof. To prove that DMW is a voluntary algorithm participation mechanism, we must show that no matter what computational actions the others employ, truthful agent Ai will incur no loss if it follows its suggested strategy. If an agent Aj , j ̸= i, sends inconsistent shares to Ai , then Ai will terminate the protocol, resulting in Ui = 0. If Aj transmitted consistent shares to Ai , but transmits inconsistent shares to Ak , k ̸= j ̸= i, then Ai will

T.E. Carroll, D. Grosu / J. Parallel Distrib. Comput. 71 (2011) 397–406 j

j

terminate the protocol when verifying Λk and Ψk for consistency. j

j

In determining the winner, if Ai transmits invalid f1 (αi ), . . . , fn (αi ), it will be detected by Ai when performing the consistency check, and it will terminate the protocol. If too few agents disclose their shares, then the protocol deadlocks and Ai will terminate it. If too many agents disclose shares, the protocol proceeds unhindered. In any case which results in protocol termination, Ui = 0. If Aj submits incorrect values for determining the second-price bid, Ai will detect the situation and terminate the protocol, concluding in Ui = 0. If agent Aj submits the incorrect second-price bid to the payment infrastructure, the infrastructure will detect the conflict and will issue no payments. Since Ai is able to detect any computational action that is not supported by the suggested strategy, it can terminate the protocol when it detects them and realize Ui = 0. Therefore, Ai will not incur a loss when the other agents implement a strategy different from the suggested strategy.  Theorem 9. DMW satisfies the strong voluntary participation condition. Proof. Theorems 7 and 8 show that DMW satisfies conditions 2 and 3 of Theorem 6. Condition 1 of Theorem 6 is also satisfied since the corresponding centralized mechanism (Minwork) is a voluntary participation mechanism. Therefore, DMW is a strong voluntary participation mechanism.  Theorem 10 (Privacy). DMW protects the anonymity of the losing agents and the privacy of their bids when fewer than c agents collude. Proof. The privacy of the identities and the bids is protected using a secret sharing scheme. More than c agents must collude in order to expose the bids. Additionally, the number of colluding agents necessary to successfully expose bids is inversely proportional to the bid value; i.e., more colluding agents are required to violate the privacy of lower (better) bids.  Remark. It is ideal to conceal the winner’s identity, the firstprice, and the second-price bids. The disclosure of the winner and the second-price is intrinsic to the distributed scheduling problem. The risk of divulging the winner is mitigated by using pseudonyms to hide the real identities. The risk of disclosing the second-price bid is small as the information must be divulged to a third-party to receive payment. The disclosure of the first-price is a deficiency of the auction protocol that poses the greatest risk. The risk is mitigated as the agents cannot leverage the information to improve their positions during mechanism execution as all bids are submitted and committed before revelations. The knowledge of first and second-highest bid can be exploited only if the same set of jobs is scheduled repeatedly using repeated executions of DMW. Theorem 11 (Communication Complexity). The communication complexity of DMW for m tasks and n agents is Θ (mn2 ). Proof. When publishing messages we assume no explicit broadcast facilities and that it is implemented using point-to-point message transmissions. For each task, we observe that Bidding phase requires each agent to transmit a share to each of the other n − 1 agents for a cost of Θ (n(n − 1)). Next, each agent publishes its commitments of size Θ (n) for a cost of Θ (n(n − 1)). Communication in support of winner identification dominates the cost of Allocating Tasks phase. Since wk = max W is proportional to n, this phase requires Θ (n(n − 1)) transmissions. Since there are m tasks, the   overall communication cost is Θ mn2 .  Remark. The communication complexity of DMW is a factor n greater than the communication complexity of MinWork. Each of n agents transmits a bid of m values to the mechanism in the bidding phase of MinWork, resulting in Θ (mn) point-to-point messages. The communication costs of bidding dominates all other phases and thus, the communication complexity of MinWork is Θ (mn).

405

Theorem 12 (Computational Complexity). The computational com  plexity of DMW for m tasks, for each of n agents, is O mn2 log p . Proof. In Bidding phase, an agent computes Θ (mn) shares by j repeatedly applying Horner’s Rule [24] to solve (3). Since τi ≤ n ∀ i, j, each share requires O(n) multiplications and, for m tasks, results in computational cost O(mn2 ). We assume that integer exponentiation xz is performed by (right-to-left) binary decomposition [24] with computational cost   Θ (log z ). In Allocating Tasks, each agent has costs O n2 log p for (7)–(9); we specify





the total cost of this phase across all m tasks as O mn2 log p . The summation and exponentiation in (10) results in cost O (m (n + log p)). Total cost of the multiplications in (11) for n agents as Θ mn2 . It costs an agent O (n (n + log q)) to compute (12) for one task; the total cost of computing (12) for all tasks is O (mn (n + log q)). Eq. (13) results in total costs  Θ (mn (n + log p)). An agent computes (14) for one task in O n2 ; the total cost over all tasks is O mn2 . The total cost of (15) is O (m log p). Computing the secondprice bid is similar to the costs of computing the first-price bid. Payments results in cost Θ (m).Thus, the total computational cost per each agent for m tasks is O mn2 log p . 





Remark. The computational complexity of DMW is a factor Θ (n log p) greater than the computational complexity of MinWork. MinWork searches the m vectors of n bids for the first-price and second-price bids in time Θ (mn) and then sums the second-price bids in time Θ (m). Therefore, the computational complexity of MinWork is Θ (mn). 5. Conclusion We proposed DMW, a distributed mechanism for job scheduling on unrelated machines. The agents execute a distributed Vickrey auction for each of the tasks to determine the allocation and the payment. We showed that our proposed mechanism is a faithful implementation of the truthful MinWork and thus, agents will adhere to the distributed protocol in order to maximize their utility. Furthermore, we showed that the mechanism preserves the privacy of the losing agents by not revealing their identities or their bids. Lastly, we showed that it is polynomial in terms of communication and complexity costs. Future work includes implementing DMW in a simulated distributed environment and designing distributed versions of other centralized mechanisms. Of particular interest is designing distributed versions of the centralized mechanism for scheduling on related machines proposed in [4] and of the corresponding scheduling algorithms [1,25]. The difficulty arises when privacy and other traditional cryptographic goals are considered when designing distributed mechanisms. Acknowledgments The authors wish to express their thanks to the editor and the anonymous referees for their helpful and constructive suggestions, which considerably improved the quality of the paper. References [1] N. Andelman, Y. Azar, M. Sorani, Truthful approximation mechanism for scheduling selfish related machines, in: Proc. of the 22nd International Symp. on Theoretical Aspects of Comp. Sci., STACS’05, 2005, pp. 69–82. [2] N. Andelman, Y. Mansour, A sufficient condition for truthfulness with single parameter agents, in: Proc. of the 7th ACM Conf. on Electronic Commerce, EC’06, 2006, pp. 8–17. [3] E. Angel, E. Bampis, F. Pascual, Truthful algorithms for scheduling selfish tasks on parallel machines, in: Proc. of the 1st Workshop on Internet and Network Economics, WINE’05, December 2005, pp. 698–707.

406

T.E. Carroll, D. Grosu / J. Parallel Distrib. Comput. 71 (2011) 397–406

[4] A. Archer, E. Tardos, Truthful mechanism for one-parameter agents, in: Proc. of the 42nd IEEE Symp. on Foundations of Computer Science, FOCS’01, October 2001, pp. 482–491. [5] A. Archer, E. Tardos, Frugal path mechanisms, in: Proc. of the 13th Annual ACM–SIAM Symp. on Discrete Algorithms, SODA’02, January 2002 pp. 991–999. [6] V. Auletta, R.D. Prisco, P. Penna, G. Persiano, Deterministic truthful approximation mechanisms for scheduling related machines, in: Proc. of the 21st International Symp. on Theortical Aspects of Comp. Sci., STACS’04, 2004, pp. 608–619. [7] F. Brandt, T. Sandholm, On the existence of unconditionally privacy-preserving auction protocols, ACM Transactions on Information and System Security 11 (2) (2008) Article 10. [8] T.E. Carroll, D. Grosu, Brief announcement: distributed algorithmic mechanism design for scheduling, in: Proc. of the 24th ACM Symposium on Principles of Distributed Computing, PODC 2005, July 2005, p. 128. [9] T.E. Carroll, D. Grosu, Distributed algorithmic mechanism design for scheduling on unrelated machines, in: Proc. of the 8th International Symposium on Parallel Architectures, Algorithms, and Networks, I-SPAN 2005, IEEE Computer Society Press, 2005, pp. 194–199. [10] T.E. Carroll, D. Grosu, A strategyproof mechanism for scheduling divisible loads in tree networks, in: Proc. of the 20th IEEE Int’l Parallel and Distributed Processing Symp., IPDPS’06, April 2006. [11] T.E. Carroll, D. Grosu, Strategyproof mechanisms for scheduling divisible loads in bus-networked distributed systems, IEEE Transactions on Parallel and Distributed Systems 19 (8) (2008) 1124–1135. [12] G. Christodoulou, E. Koutsoupias, A. Vidali, A lower bound for scheduling mechanisms, Algorithmica 55 (4) (2009) 729–740. [13] G. Christodoulou, A. Kovács, A deterministic truthful ptas for scheduling related machines, in: Proc. of the 21st Annual ACM–SIAM Symposium on Discrete Algorithms, 2010, pp. 1005–1016. [14] A.T. Chronopoulos, D. Grosu, H. Kikuchi, A new efficient polynomial degree resolution protocol and its application to the (M + 1)-st price private auction, in: Proc. of the 2nd International Conference on Applied Cryptography and Network Security—Technical Track, ACNS’04, Yellow Mountain, China, June 8–11 2004, pp. 358–367. [15] E. Clarke, Multipart pricing of public goods, Public Choice 8 (1971) 17–33. [16] P. Dhangwatnotai, S. Dobzinski, S. Dughmi, T. Roughgarden, Truthful approximation schemes for single-parameter agents, in: Proc. of the 49th IEEE Symp. on Foundations of Computer Science, FOCS’08, October 2008, pp. 15–24. [17] J. Feigenbaum, C. Papadimitriou, R. Sami, S. Shenker, A BGP-based mechanism for lowest-cost routing, in: Proc. of the 21st ACM Symp. on Principles of Distributed Computing, PODC’04, July 2002, pp. 173–182. [18] J. Feigenbaum, C.H. Papadimitriou, S. Shenker, Sharing the cost of multicast transmissions, Journal of Computer and System Sciences 63 (1) (2001) 21–41. [19] J. Feigenbaum, S. Shenker, Distributed algorithmic mechanism design: recent results and future directions, in: Proc. of the 6th ACM Workshop on Discrete Algorithms and Methods for Mobile Computing and Communications, September 2002, pp. 1–13. [20] D. Grosu, A.T. Chronopoulos, Algorithmic mechanism design for load balancing in distributed systems, IEEE Transactions on Systems, Man and Cybernetics, Part B (Cybernetics) 34 (1) (2004) 77–84. [21] T. Groves, Incentive in teams, Econometrica 41 (4) (1973) 617–631. [22] L. Kang, D.C. Parkes, Passive verification of the strategyproofness of mechanisms in open environments, in: Proc. of the 8th International Conference on Electronic Commerce, ICEC’06, 2006, pp. 19–30. [23] H. Kikuchi, (M + 1)st-price auction protocol, in: Proc. of the 5th International Conference on Financial Cryptography, FC’01, Springer-Verlag, 2002, pp. 351–363. [24] D.E. Knuth, The Art of Computer Programming, vol. 2, Addison-Wesley, 1998. [25] A. Kovács, Fast monotone 3-approximation algorithm for scheduling related machines, in: Proc. of the 13th Annual European Symp. on Algorithms, ESA’05, 2005, pp. 616–627.

[26] A. Kovács, Fast algorithms for two scheduling problems, Ph.D. Thesis, Universitat des Saarlandes, 2007. [27] J.C. Mitchell, V. Teague, Autonomous nodes and distributed mechanisms, in: Proc. of the Mext-NSF-JSPS International Symp. on Software Security— Theories and Systems, November 2003, pp. 58–83. [28] A. Mu’alem, M. Schapira, Setting lower bounds on truthfulness, in: Proc. of the 18th Annual ACM–SIAM Symposium on Discrete Algorithms, January 2007, pp. 1143–1152. [29] C. Ng, D.C. Parkes, M. Seltzer, Strategyproof computing: systems infrastructures for self-interested parties, in: 1st Workshop on Economics of Peer-toPeer Systems, June 5–6 2003. [30] N. Nisan, A. Ronen, Algorithmic mechanism design, Games and Economic Behavior 35 (1) (2001) 166–196. [31] N. Nisan, T. Roughgarden, E. Tardos, V.V. Vazirani, Algorithmic Game Theory, Cambridge University Press, New York, NY, 2007. [32] M.J. Osborne, A. Rubinstein, A Course in Game Theory, MIT Press, Cambridge, Mass, 1994. [33] D.C. Parkes, J. Shneidman, Distributed implementations of Vickrey–Clarke– Groves mechanisms, in: Proc. 3rd Int. Joint Conf. on Autonomous Agents and Multi Agent Systems, 2004, pp. 261–268. [34] M. Pinedo, Scheduling: Theory, Algorithms, and Systems, Prentice-Hall, Englewood Cliff, NJ, 1995. [35] A. Shamir, How to share a secret, Communications of the ACM (1979) 612–613. [36] J. Shneidman, D.C. Parkes, Specification faithfulness in networks with rational nodes, in: Proc. 23rd ACM Symp. on Principles of Distributed Computing, PODC’04, 2004, pp. 88–97. [37] J. Shneidman, D.C. Parkes, L. Massoulie, Faithfulness in internet algorithms, in: Proc. ACM SIGCOMM Workshop on Practice and Theory of Incentices and Game Theory in Networked Systems, PINS’04, 2004, pp. 220–227. [38] W. Vickrey, Counterspeculation, auctions, and competitive sealed tenders, Journal of Finance 16 (1) (1961) 8–37.

Thomas E. Carroll received his Bachelors of Science in Chemistry and Bachelors of Science in Computer Science degrees in 2001, his Masters of Science in Computer Science degree in 2006, and his Ph.D. degree in Computer Science in 2009. The degrees were awarded from Wayne State University, Detroit, Michigan, USA. Currently, he is employed at Pacific Northwest National Lab. His research interests are incentive-centered design for resource allocation in distributed computer systems, game theory, and network security. He is a member of the IEEE.

Daniel Grosu received the Diploma in engineering (automatic control and industrial informatics) from the Technical University of Iasi, Romania, in 1994 and the M.Sc. and Ph.D. degrees in computer science from the University of Texas at San Antonio in 2002 and 2003, respectively. Currently, he is an associate professor in the Department of Computer Science, Wayne State University, Detroit. His research interests include distributed systems and algorithms, resource allocation, computer security and topics at the border of computer science, game theory and economics. He has published more than 60 peer-reviewed papers in the above areas. He has served on the program and steering committees of several international meetings in parallel and distributed computing. He is a member of the ACM and a senior member of the IEEE and the IEEE Computer Society.