A Distributed Solution Protocol that Computes an

A Distributed Solution Protocol that Computes an Upper Bound for the Generalized Mutual Assignment Problem Katsutoshi Hirayama Faculty of Maritime Sciences, Kobe University 5-1-1 Fukaeminami-machi, Higashinada-ku, Kobe 658-0022, JAPAN Email: [email protected], URL: http://www.kobe-u.ac.jp/hirayama/

Abstract. The generalized mutual assignment problem (GMAP) is the combinatorial optimization (maximization) problem that can describe various distributed problem solving tasks. Recently, we have presented a communication protocol for this problem that enables the agents to find a feasible solution along with a lower bound. This paper provides a new protocol, called DisLRPU , where the agents are engaged in computing an upper bound rather than searching a feasible solution. Furthermore, to efficiently seek for a smaller upper bound using DisLRPU , we present two simple strategies, called κ-sampling and lastsnap, and evaluate their performance empirically on benchmark instances.

1 Introduction In distributed problem solving there have been many problems that can be formulated as combinatorial optimization problems, such as those involved in distributed planning/scheduling, distributed task allocation, combinatorial auction and so forth. These problems typically consist of multiple agents that have mutually-related subproblems and a common goal that can be described as a global objective function. Several solution protocols have been proposed for solving those problems, but in our view they can be divided into the following three categories. The first is a centralized solution protocol, where the agents send all of the subproblems to a server which then solves the entire problem by using a particular solver and delivers a solution to each agent. An example of this protocol can be found in multirobot systems that try to optimize task allocations to multiple robots [6]. The centralized solution protocol is very easy to realize and might have lower costs in terms of time and messages. However, for some applications embedded in open environments, the operation of gathering all the subproblems in the server may cause a security or privacy issue and the cost of building and running the server. The second category is a decentralized solution protocol. In this protocol, each agent rather than the server is equipped with a solver and the server plays the role of a coordinator to facilitate communication among the entire solving processes. A relation between the agents and the server in this protocol reminds us of that between an orchestra and a conductor. An example of this protocol can be found in distributed scheduling. For example, Kutanoglu and Wu have presented an auction based protocol for the resource

scheduling problem, in which the agents solve the problem in a distributed fashion under the coordination of the auctioneer [12]. Similar approaches have been proposed for the nonlinear programming problem [1] and the supply chain optimization problem [18]. Although the decentralized solution protocol allows the agents to keep their subproblems private, the server can obtain all of the information on solving processes whereby the server may guess the entire problem. Furthermore, the protocol still needs a server that requires tedious maintenance. The third category is a distributed solution protocol. Unlike the other protocols, this protocol does not need a server because the agents themselves try to solve the entire problem through peer-to-peer local communication. It is noteworthy that with this protocol, every agent knows neither what the entire problem is nor how the entire solving processes are run. Recently, this type of protocol has been proposed for solving the distributed partial constraint satisfaction problem [8] and the distributed constraint optimization problem [13, 16, 20]. Although the distributed solution protocol currently has some limitation mainly in its efficiency, we believe that it is one of the promising directions of distributed problem solving because it is well suited to optimization tasks in open environments. The author has presented the Generalized Mutual Assignment Problem (GMAP) [10] which adapts the Generalized Assignment Problem (GAP) to the multi-agent context. The GAP is a NP-hard combinatorial optimization problem whose goal is to find an assignment of jobs to agents maximizing a total sum of profits (or minimizing a total sum of costs) subject to capacity constraints on individual agents. The GAP is typically described as the integer programming problem and thus there have been a lot of studies on this topic in operations research [2, 14, 17, 19, 21]. On the other hand, the GMAP is the distributed problem in which each agent in the GAP has a set of jobs and tries to achieve the goal of the GAP. To put it another way, in the GMAP the agents themselves try to generate an optimal solution of the GAP from a non-optimal (and sometimes infeasible) solution of it. The author has also provided a distributed solution protocol for the GMAP [10]. The agents in this protocol repeatedly solve their individual Lagrangean relaxation problems and Lagrangean dual problems while each of them performs local communication of its tentative solution. Although this protocol can find a feasible solution to a GMAP instance, the solution found is not always optimal. In other words this protocol only finds a solution providing a lower bound of the optimal value. To clarify this fact, we call this protocol DisLRPL in this paper. In this paper we propose a new distributed solution protocol, called DisLRPU , for the GMAP that can compute an upper bound of the optimal value. It is quite important to compute an upper bound for the maximization problem since, with an upper bound, we can assess the quality of a feasible solution even if not knowing the exact optimal value and may be able to enhance the performance of branch and bound algorithms. Therefore, we consider that a protocol computing an upper bound can become a key component of future complete or heuristic GMAP protocols. The remainder of this paper proceeds as follows. Section 2 briefly describes the formulation of GMAP and its Lagrangean relaxation problem. Section 3 presents a new protocol DisLRPU . Since DisLRPU and DisLRPL have the same core procedure, we

first describe this core procedure followed by the one called Collecttree that computes an upper bound. Then, in this section, we introduce two simple strategies, κ-sampling and lastsnap, in order to get a smaller upper bound. These strategies concern how to invoke Collecttree from the core procedure. Section 4 provides the experimental results that show the performance of κ-sampling and lastsnap, and finally Section 5 concludes this work.

2 GMAP A GMAP instance consists of multiple agents each having a finite set of jobs that are to be assigned. The agents as a whole solve the following integer programming problem, denoted as GAP. GAP (decide xkj , ∀k ∈ A, ∀j ∈ J) :

pkj xkj max. k∈A j∈J

s. t.




xkj = 1, ∀j ∈ J,

(1)

wkj xkj ≤ ck , ∀k ∈ A,

(2)

xkj ∈ {0, 1}, ∀k ∈ A, ∀j ∈ J,

(3)

k∈A


j∈J

where A = {1, ..., m} is a set of agents; J = {1, ..., n} is a set of jobs; pkj and wkj are the profit and amount of resource required, respectively, when agent k selects job j; ck is the capacity, i.e., the amount of available resource, of agent k. xkj is a decision variable whose value is set to 1 when agent k selects job j and 0 otherwise. The goal of the agents is to find a job assignment that maximizes the total sum of profits such that (1) each job is assigned to exactly one agent (denoted as assignment constraints), (2) the total amount of resource required for each agent does not exceed its capacity (denoted as knapsack constraints), and (3) each job is assigned or not assigned to an agent (denoted as 01 constraints). We refer to the maximal total sum of profits as the optimal value and the assignment that provides the optimal value as the optimal solution. We can obtain the following Lagrangean relaxation problem LGAP(µ) by dualizing the assignment constraints of GAP [4]. LGAP(µ) (decide xkj , ∀k ∈ A, ∀j ∈ J) :  



max. pkj xkj + µj 1 − xkj k∈A j∈J

s. t.




j∈J

wkj xkj ≤ ck , ∀k ∈ A,

j∈J

xkj ∈ {0, 1}, ∀k ∈ A, ∀j ∈ J,

k∈A

where µj is a real-valued parameter called a Lagrange multiplier for (the assignment constraint of) job j. Note that the vector µ = (µ1 , µ2 , . . . , µn ) is called a Lagrange multiplier vector. Based on the idea of Lagrangean decomposition [7], we can divide this problem into a set of subproblems {LGMP k (µ)|k ∈ A}, where each subproblem LGMP k (µ) of agent k is as follows. LGMP k (µ) (decide xkj , ∀j ∈ Rk ) :  

1 − xkj max. pkj xkj + µj |Sj | j∈Rk j∈Rk
s. t. wkj xkj ≤ ck , j∈Rk

xkj ∈ {0, 1}, ∀j ∈ Rk , where Rk is a set of jobs that may be assigned to agent k and Sj is a set of agents to whom job j may be assigned. We can assume that Sj = ∅ because a job with an empty Sj does not have to be considered in the problem. Note that j ∈ Rk ⇔ k ∈ Sj holds for any agent k and any job j. When we consider that agent k decides the value of xkj for ∀j ∈ Rk (in other words, the agent that may be assigned job j has a right to decide whether it will undertake the job or not), agent k is able to solve LGMP k (µ) completely by itself since LGMP k (µ) includes only k’s decision variables. For your reference some illustrative examples of the GMAP formulation have been provided in [10]. Regarding the relation between the entire problem and a set of subproblems, the following properties are very useful in designing a distributed solution protocol for the GMAP [10]. Property 1. For any value for µ, a total sum of the optimal values of {LGMP k (µ)|k ∈ A} provides an upper bound of the optimal value of GAP. Property 2. For any value for µ, if  all of the optimal solutions to {LGMP k (µ)|k ∈ A} satisfy the assignment constraints, i∈A xij = 1, ∀j ∈ J, then these optimal solutions constitute an optimal solution to GAP. To distinguish the optimality of GAP from that of {LGMP k (µ), we will refer to the optimal value of GAP as the global optimal value and the optimal solution to GAP as the global optimal solution.

3 DisLRPU The author has proposed DisLRPL for finding a feasible solution of GMAP [10]. This section first provides its core procedure, called DisLRP, which is also used in DisLRPU . Then, it provides the detail of DisLRPU as well as the strategies for finding a smaller upper bound.

3.1

DisLRP: Core Procedure

Following DisLRP, the agents as a whole behave as follows. 1. For any job j, the agents initialize Lagrange multiplier µj by zero. Also, they set a value of a counter, called round, to one. 2. Each agent k solves LGMP k (µ) for current values of µ. Then, it sends an optimal solution of the current problem to its neighbors. Neighbors of agent k is denoted by  j∈Rk Sj \ {k}, meaning a union of other agents to which each job j in Rk may be assigned. 3. After receiving all of the messages from its neighbors, each agent k increases the value of round by one and checks if all of the assignment constraints for the jobs in Rk are satisfied. If this is true for all of the agents, the entire processes should be terminated because Property 2 suggests that a global optimal solution is found at that time. Otherwise, for each job j whose assignment constraint is not satisfied, the agents in Sj update µj to a certain value. Then, all of the agents go into Step 2. Thus, after initializing a Lagrange multiplier vector, the agents repeats Steps 2 and 3 until a global optimal solution is found. The round roughly measures how many times the agents repeat these steps. We provide some notes on each step as shown below. – At Steps 1 and 3, it is all of the agents in Sj that initialize and update Lagrange multiplier µj . Actually, these agents own multiple copies of µj that are supposed to keep a common value. – At Step 2 LGMP k (µ) for some values of µ is equivalent to the 0-1 knapsack problem. The 0-1 knapsack problem is a relatively “easy” NP-hard problem [4] and thus we can expect an “efficient” complete method even for relatively large instances [15]. We should notice that DisLRP does not specify the method for the 01 knapsack problem except that it must be complete. That is, the agents are allowed to use various complete methods which can be homogeneous or heterogeneous. – At Step 3, in order to check all of the assignment constraints are satisfied in every agent, we use the termination detection procedure of the distributed breakout algorithm [9] that is designed to solve distributed constraint satisfaction problem [22, 23]. However, this procedure is not a must for DisLRPU since its goal is to find an upper bound rather than a global optimal solution. – At Step 3 each agent in Sj updates µj by a well known subgradient optimization method [4]. More specifically, an agent in Sj first computes subgradient gj as gj = 1 −




xij ,

i∈Sj

using the values of decision variables received from neighbors. Then, it changes (t) (t+1) the multiplier from µj (the value at round t) to µj (the value at round t + 1) as follows: (t+1)

µj

(t)

← µj − l(t)

gj , |Sj |

where l(t) is a positive scalar step size which may vary as the round proceeds and |Sj | is the number of agents to whom job j may be assigned. In order to force multiple copies of µj , which are distributed among the agents in Sj , to keep a common value, the agents in Sj should use the same initial value to µj and the same value to l(t) at any round t. 3.2

Basic Idea

At Step 2 in DisLRP, the agents solve their individual LGMP k (µ) to find their optimal solutions as well as optimal values. According to Property 1 a total sum of these optimal values provides an upper bound of the global optimal value, but unfortunately, nobody knows the total sum in DisLRP. It must be easy for centralize/decentralized solution protocols to compute the total sum because they do not hesitate to use the server. However, for a distributed solution protocol like DisLRP, we need some mechanism to compute such global information. DisLRPU is a distributed solution protocol that extends DisLRP so that each agent can take a snapshot of a global state, in other words, collect all of the optimal values at a certain round, for computing the total sum. The literature on distributed algorithms has suggested several methods to take a snapshot of a global state. One naive method is for each agent to broadcast its data to the others. On the other hand, more sophisticated method has been proposed by Chandy and Lamport [3]. Any method could be used for our purpose, but in this work we adopt a method called Collecttree [11] because it is efficient and its implementation is relatively easy. Although DisLRPU may be just a combination of the existing technologies (DisLRP and Collecttree ), we would like to point out that it is the very first distributed solution protocol that can compute an upper bound for the GMAP. 3.3

Computing an Upper Bound with Collecttree

In DisLRPU we assume a spanning tree has been constructed over a network of agents N = (A, E), where A is a set of agents and E is a set of undirected links. A link represents the possibility of a one-hop communication between a pair of agents. Since an agent in DisLRP can directly send messages to its neighbors, we consider that there is a directed link from an agent to any of its neighbors. With the definition of neighbors provided in Section 3.1, there is always an opposite directed link between the two agents and therefore we consider it as an undirected link. A spanning tree of a network is a subnetwork which has a tree structure and consists of the same set of nodes as the entire network. For a network N of agents in DisLRP, such a spanning tree certainly exists since N is always connected. It is known that the efficiency of many distributed algorithms can be improved by using a spanning tree [11]. DisLRPU also exploits a spanning tree to efficiently collect all of the optimal values at a certain round. To do that, we have to construct a spanning tree before starting DisLRPU , but fortunately, there is an efficient distributed algorithm for its construction. For example, GHS algorithm constructs a minimum-weight spanning tree with O(|A| log |A| + |E|) message complexity [5]. In DisLRPU , the agents use Collecttree to compute a total sum of the optimal values at a certain round t. As Collecttree proceeds, each optimal value traverses over

UBL(t)={(1,1)} DAT(t)=nil (t,{(1,1)})

(t,{(2,2)}) 2 UBL(t)={(2,2)} DAT(t)=nil

1

(t,{(1,1)})

(t,{(3,3)}) 3 UBL(t)={(3,3)} DAT(t)=nil

Fig. 1. Snapshot at round t

a spanning tree. We should point out that this traversal does not disrupt the DisLRP process. More specifically, when an agent tries to send its new optimal solution via a message, the agent adds, if necessary, a set of optimal values currently traversed to the message. An agent received this message performs the usual DisLRP process as well as the Collecttree process detailed in this section. In the description below we will use the term Session t to denote a series of the Collecttree processes over the agents for computing a total sum of the optimal values at round t. Agent k involved in Session t uses the following variables. Tk : a set of agents who are in k’s neighbors and connected to k by spanning tree links UBL(t) : a set of optimal values at round t DAT (t) : a set of optimal values at round t computed by the agents whose distances from k over a spanning tree are at a certain value SCL(t) : a set of agents in Tk to which k will not send messages of Session t (t) RCLk : a set of agents in Tk from which k will not wait for messages of Session t With these variables agent k involved in Session t works as follows. Note that in the following description the DisLRP process, which runs independently, is omitted. Round t This is the round at which the agents start Session t by sending their individual optimal values. More specifically, agent k solves its Lagrangean relaxation problem LGMP k (µ) under current values of µ at round t and computes the optimal value o(t) . Then, it initializes UBL(t) by {(k, o(t) )} and DAT (t) by ∅ and sends (t, UBL(t) ) toward each agent in Tk . Figure 1 shows an example on a network, where a node is an agent and a thick link is a spanning tree link while a thin one is a normal link. Note that in this example we identify an agent’s optimal value at round t with an ID number of the agent. Round t + 1 When agent k receives (t, Mk
), where t is a session name and Mk
is a body of the message (i.e., UBL(t) ), from agent k  in Tk , it updates DAT (t) by DAT (t) ∪Mk
. Consequently, after k finishes processing all messages from the agents in

UBL(t)={(1,1)} DAT(t)={(2,2),(3,3)} M (for 2) = DAT(t)\{(2,2)} = {(3,3)} M (for 3) = DAT(t)\{(3,3)} = {(2,2)} 1

2

3

UBL(t)={(2,2)} DAT(t)={(1,1)} M (for 1) = DAT(t)\{(1,1)} = nil

UBL(t)={(3,3)} DAT(t)={(1,1)} M (for 1) = DAT(t)\{(1,1)} = nil

UBL(t)={(1,1),(2,2),(3,3)} DAT(t)= nil (t,{(3,3)})

1

(t,{(2,2)})

(t,#)

(t,#) 2

3

UBL(t)={(2,2),(1,1)} DAT(t)= nil SCL(t)={1}

UBL(t)={(3,3),(1,1)} DAT(t)= nil SCL(t)={1}

Fig. 2. Snapshots at round t + 1

Tk , DAT (t) contains all of the optimal values at round t computed by the agents whose distances from k over a spanning tree are one. In the description below we assume k receives all these messages and DAT (t) contains complete data. For each agent k in Tk , let M be DAT (t) \ Mk

, where Mk

is a body of the message that was received from k . Figure 2 (top) shows the result so far. If M is ∅, it means that k  is the only agent whose distance from k over a spanning tree is one. In this case, agent k obviously does not have any optimal value at round t to be transmitted to k and therefore will send (t, #) to agent k , where t is a session name and # is a symbol meaning transmission completed. On the other hand, if M is not ∅, there is at least one agent other than k whose distance from k over a spanning tree is one. In this case, agent k needs to transmit M to agent k and therefore will send (t, M ) to agent k . It must be noted that, in the above, once agent k sends (t, #) to agent k , there is no more optimal value at round t to be transmitted from k to k . Agent k, therefore,

UBL(t)={(1,1),(2,2),(3,3)} DAT(t)= nil RCL(t)={2,3} SCL(t)={2,3} (t,#)

1

2

(t,#)

3

UBL(t)={(2,2),(1,1),(3,3)} DAT(t)= nil SCL(t)={1}

UBL(t)={(3,3),(1,1),(2,2)} DAT(t)= nil SCL(t)={1}

Fig. 3. Snapshot at round t + 2

adds k to SCL(t) . On the other hand, agent k , who receives (t, #) from k, adds k to its RCL(t) as we shall see later. After sending those messages, agent k updates UBL(t) by UBL(t) ∪DAT (t) , initializes DAT (t) by ∅, and waits for messages from neighbors. Figure 2 (bottom) illustrates a snapshot at this point in time. Round t + t
(t
≥ 2) When agent k receives (t, Mk
) from agent k in Tk \ RCL(t) , it proceeds as follows depending on the value of Mk
. If Mk
is #, it means that there is no more optimal value at round t to be transmitted via k  . Agent k, therefore, adds k to RCL(t) , whereby k will be left out from a set of agents from which k will wait for messages of Session t. Consequently, if RCL(t) grows to include all agents in Tk , it means that k has received all of the optimal values at round t and those optimal values have been kept in UBL(t) . Therefore, agent k is able to compute the upper bound at round t by summing up those optimal values at that time. The important point to note is that with this procedure each agent can detect the fact that it receives all of the optimal values by using only local information. On the other hand, if Mk
is not #, agent k updates DAT (t) by DAT (t) ∪ Mk
as we mentioned before. After agent k finishes processing all messages from the agents in Tk \ RCL(t) , DAT (t) contains all of the optimal values at round t computed by the agents whose distances from k over a spanning tree are t . Again, for each agent k in Tk \ SCL(t) , let M be DAT (t) \ Mk

. If M is ∅, it means that the agents who originate Mk

are the only agent whose distance from k over a spanning tree is t . In this case, agent k obviously does not have any optimal value at round t to be transmitted to k and therefore will send (t, #) to agent k . In addition, agent k adds k to SCL(t) . On the other hand, if M is not ∅, there is at least one agent other than k whose distance from k over a spanning tree is t . Thus, since agent k needs to transmit M to agent k , it will send (t, M ) to k  .








"
$
!




 





 

          
 
               
     
 
   
 
   ¾     !         # #     %& 
 &  &
'        
  

Fig. 4. DisLRPU : init procedure

After sending those messages, agent k updates UBL(t) by UBL(t) ∪DAT (t) , initializes DAT (t) by ∅, and waits for messages from neighbors. Figure 3 shows a snapshot at this point in time. To compute an upper bound at a certain round, Collecttree requires O(n2 ) messages since every optimal value is transmitted once over each link of a spanning tree. However, in DisLRPU , messages involved in DisLRP and Collecttree are not sent separately but rather sent as one merged message. Accordingly, Collecttree does not increase the number of messages but the size of individual messages. On the other hand, it is clear that Collecttree requires O(n) rounds to compute an upper bound at a certain round. However, we should notice that while Collecttree is running for the upper bound at round t, DisLRP can proceed as usual (i.e., each agent continues to solve its problem at round t + 1, t + 2, . . .). Thus, Collecttree does not increase the number of rounds as well. 3.4

Finding a Smaller Upper Bound

While an upper bound at a certain round can be computed with Collecttree , it should be closer to the global optimal value and hopefully be minimized. One ideal strategy for finding a smaller upper bound is to call Collecttree every round and choose a minimum value among those computed upper bounds. However, Collecttree increases the size of individual messages, and furthermore, its consecutive calls may yield an extremely large-sized message and force each agent to create a lot of working variables, such as UBL(t) or DAT (t) , that are temporally used for individual working sessions. Therefore, in this work, we use the following strategies in order to find a smaller upper bound efficiently: κ-sampling, in which each agent calls Collecttree every κ rounds and chooses a minimum value, as the best upper bound, among those computed. Note that κ, whose value is common to all agents, ranges over positive integers; lastsnap, in which each agent calls Collecttree only at the last round and chooses a computed upper bound as the best one. We should notice that DisLRPU is forced to be terminated at a certain round, called a cutOffRound, even if it has not yet discovered an global optimal solution. Accord-


   





   
 
 


              
    


  

 
 

 

¼

        " #       

¼

¼

¼

¼

¼

¼

¼



 








 

 


 


¼   





     !   



 
  
   
   
    
   
    
 

         
 
  

   
 
         $    

 

 

 

¼

"

         %  &

#

  $    



¼

¼

¼

            


  

  $



Fig. 5. DisLRPU : message processing procedure

ingly, these strategies work properly. The effects of these strategies will be examined in Section 4. The details of DisLRPU , where Collecttree is embedded into DisLRP, are shown in Figures 4-6. It must be noted that these procedures are designed to allow each agent to call Collecttree at consecutive rounds.

4 Experiments The purpose of this section is to show the empirical performance of κ-sampling and lastsnap. We made GMAP instances out of the GAP benchmark instances in the OR-Library1 . More specifically, for a GAP instance, we consider the problem where the agents themselves try to generate an optimal solution from a non-optimal solution. Actually, this problem can be considered a GMAP instance where each agent tries to (re)assign optimally each of its jobs, which were assigned improperly, to any of the agents. It is clear that Sj should be A for any job j (i.e., any job may be assigned to any agent) in this case. Considering that j ∈ Rk ⇔ k ∈ Sj holds for any agent k ∈ A and any job j ∈ J, we can lead to that Rk should be J for any agent k. This means that for any agent k its Lagrangean relaxation problem LGMP k (µ) includes all of the jobs. This GMAP instance is called a complete instance for which a lower bound found by DisLRPL was likely to be poor [10]. 1

http://people.brunel.ac.uk/˜mastjjb/jeb/orlib/gapinfo.html








"
#
!







"
#
!







"
#
!












 


 
   
   




  


 
 


      
    ¾   


   
       
 !  
 


 

      
   $     %%  $ 
 ¼¼   ¼¼     
     


 

¼¼

 







& ¼¼ '  $  ¼¼     

    ¼¼     

¼¼  ¼¼  & ('     ¼¼   ¼¼  ¼¼  & '  

  



  

     





 

        

  $ ) * %%  $  & 
 '


     
   


  &

' 





































¼¼

¼¼

¼¼






    
   +        &,    &, ,  
 
 *    ¼¼

¼¼






 



, 
 , ¼¼ ' , '  ¼¼  











¼¼

Fig. 6. DisLRPU : localcomp procedure

Experiments were conducted on the discrete event simulator that simulates the behavior of DisLRPU . In the simulator we used CPLEX8.1 for each agent to solve a series of 0-1 knapsack problem instances. On the parameter setting for DisLRPU , step size l(t) was set to 1 all over the rounds and cutOffRound ranged over {20n, 40n, 60n, 80n, 100n}, where n is the total number of jobs. Table 1 shows, for each instance, the best upper bound for the agents with κsampling (κ ∈ {1, 5, 10, 20} ) or lastsnap to find until the number of rounds reaches to a cutOffRound of 100n. The Pr.ID column shows an instance indicated by cmni, where m is a single/double-digit number representing the number of agents, n is a double-digit number representing the number of jobs, and i is an instance identifier, while the opt column shows the global optimal value of the corresponding instance. Note that although a computed upper bound, which is a total sum of optimal values of all LGMP k (µ), may actually be fractional, we rounded it down to the nearest integer since all the profits of each instance are integral. We can see from this table that both κsampling where κ ranges over the values more than 1 and lastsnap were finding almost

Table 1. Best upper bound when cutOffRound is 100n

Pr.ID c520-1 c530-1 c832-1 c840-1 c848-1 c1030-1 c1040-1 c1050-1 c1060-1

1 439 659 762 944 1134 710 958 1139 1451

κ-samp 5 10 439 439 659 659 762 762 944 944 1134 1134 710 710 958 959 1139 1139 1451 1451

20 439 659 762 944 1134 710 959 1139 1451

last 439 659 762 944 1135 710 959 1139 1451

opt 434 656 761 942 1133 709 958 1139 1451

Table 2. cutOffRound vs. best upper bound for c848-1 20n 40n 60n 1-samp 1137 1134 1134 20-samp 1138 1134 1134 1138 1135 1135 last

80n 1134 1134 1134

100n 1134 1134 1135

the same upper bound as 1-sampling, where each agent calls Collecttree every round. Furthermore, they found tight bounds in many instances, even though our experiments may still be limited to relatively small instances. Although we are not going to insist that our experiments were thorough enough, they seem to suggest that DisLRPU can provide a good upper bound even if it does not call Collecttree every round. On the other hand, Table 2 shows the best upper bound found by 1-sampling, 20sampling, and lastsnap for an instance of c848-1 when we varied the value of cutOffRound. This is clearly one typical example. We can see that the best bound found by either strategy may quickly converge to a stable value. We should, however, notice that κ-sampling does have the anytime characteristic, which means a characteristic that the bounds can be improved as cutOffRound increases, while lastsnap does not.

5 Conclusion In this paper we presented a new distributed solution protocol called DisLRPU , which incorporates Collecttree into DisLRP, in order to compute an upper bound of the optimal value for the GMAP. Then, we provided two simple strategies called κ-sampling and lastsnap for finding a smaller upper bound. These two strategies were empirically evaluated on GMAP instances derived from GAP benchmark instances. Our experimental results suggested that DisLRPU can provide a good upper bound even if it does not call Collecttree every round, and furthermore, κ-sampling does have the anytime characteristic while lastsnap does not. Although DisLRPU may be just a combination of the

existing technologies, it is the very first distributed solution protocol that can compute an upper bound for the GMAP and we believe that it will become a key component of future complete or heuristic GMAP protocols. Future work may include to extend DisLRP such that it has a viable tactics that computes a tighter upper bound and a Lagrangean heuristic [4] that transforms an infeasible solution into a feasible one.

References 1. I. P. Androulakis and G. V. Reklaitis. Approaches to asynchronous decentralized decision making. Computers and Chemical Engineering 23 (1999) 341–355 2. D. G. Cattrysse and L. N. Van Wassenhove. A survey of algorithms for the generalized assignment problem. European J. of Operational Research 60 (1992) 260–272 3. K. Chandy and L. Lamport. Distributed snapshots: determining global states of distributed systems. ACM Trans. on Computer Systems 3(1) (1985) 63–75 4. M. L. Fisher. The Lagrangian relaxation method for solving integer programming problems. Management Science 27(1) (1981) 1–18 5. R. G. Gallager, P. A. Humblet, and P. M. Spira. A distributed algorithm for minimum-weight spanning tree. ACM Trans. on Programming Languages and Systems 5(1) (1983) 66–77 6. B. P. Gerkey and M. J Matari´c. A formal analysis and taxonomy of task allocation in multirobot systems. Intl. J. of Robotics Research 23(9) (2004) 939–954 7. M. Guignard and S. Kim. Lagrangean decomposition: a model yielding stronger Lagrangean bounds. Mathematical Programming 39 (1987) 215–228. 8. K. Hirayama and M. Yokoo. Distributed partial constraint satisfaction problem. Proc. 3rd CP 1997 (1997) 222–236 9. K. Hirayama and M. Yokoo. The distributed breakout algorithms. Artificial Intelligence 161(1-2) (2005) 89–115 10. K. Hirayama. Distributed Lagrangean relaxation protocol for the generalized mutual assignment problem. Proc. the First International Workshop on Distributed and Speculative Constraint Processing (2005) 55–69 11. T. Kameda and M. Yamashita. Distributed algorithms. Kindaikagakusha (1994) (in Japanese) 12. E. Kutanoglu and S. D. Wu. On combinatorial auction and Lagrangian relaxation for distributed resource scheduling. IIE Transactions, 31(9) (1999) 813–826 13. R. Mailler and V. Lesser. Solving distributed constraint optimization problems using cooperative mediation. Proc. 3rd AAMAS 2004 (2004) 438–445 14. S. Martello and P. Toth. Knapsack problems: algorithms and computer implementations. John Wiley & Sons (1990) 15. S. Martello, D. Pisinger, and P. Toth. New trends in exact algorithms for the 0-1 knapsack problem. European J. of Operational Research 123 (2000) 325–332 16. P. J. Modi, W. M. Shen, M. Tambe, and M. Yokoo. An asynchronous complete method for distributed constraint optimization. Proc. 2nd AAMAS 2003 (2003) 161–168 17. R. M. Nauss. The generalized assignment problem. In: J. K. Karlof (ed.), Integer Programming: Theory and Practice, CRC Press (2006) 39–55 18. T. Nishi, M. Konishi, and S. Hasebe An autonomous decentralized supply chain planning system for multi-stage production processes. J. of Intelligent Manufacturing 16 (2005) 259– 275 19. I. H. Osman. Heuristics for the generalised assignment problem: simulated annealing and tabu search approaches. OR Spektrum 17 (1995) 211–225

20. A. Petcu and B. Faltings. A scalable method for multiagent constraint optimization. Proc. 19th IJCAI 2005 (2005) 266–271 21. M. Yagiura and T. Ibaraki. Generalized Assignment Problem. In: T. F. Gonzalez (ed.), Handbook of Approximation Algorithms and Metaheuristics, Chapman & Hall/CRC in the Computer & Information Science Series (2006) 22. M. Yokoo, E. H. Durfee, T. Ishida, and K. Kuwabara. The distributed constraint satisfaction problem: formalization and algorithms. IEEE Trans. on Knowledge and Data Engineering 10(5) (1998) 673–685 23. M. Yokoo. Distributed constraint satisfaction: foundation of cooperation in multi-agent systems. Springer (2001)