Appl Intell
DOI 10.1007/s10489-017-0905-4
An improved DPOP algorithm based on breadth first search
pseudo-tree for distributed constraint optimization
Ziyu Chen1 · Zhen He1 · Chen He1
© Springer Science+Business Media New York 2017
Abstract Depth First Search (DFS) pseudo-tree is popularly used as the communication structure in complete
algorithms for solving Distributed Constraint Optimization
Problems (DCOPs) from multiagent systems. The advantage of a DFS pseudo-tree lies in its parallelism derived
from pseudo-tree branches because the nodes in different branches are relatively independent and can compute
concurrently. However, the constructed DFS pseudo-trees
in experiments often come to be chain-like and greatly
impair the performances of solving algorithms. Therefore,
we propose a new DPOP algorithm using a Breadth First
Search (BFS) pseudo-tree as the communication structure,
named BFSDPOP. Compared with a DFS pseudo-tree, a
BFS pseudo-tree is more excellent on the parallelism as
it has much more branches. Another notable advantage is
that the height of a BFS pseudo-tree is much lower than
that of a DFS pseudo-tree, which gives rise to the shorter
communication paths and less communication time. The
method of Cluster Removing is also presented to allocate
cross-edge constraints to reduce the size of the largest message in BFSDPOP. In the experiment, BFSDPOP with a
Ziyu Chen
chenziyu@cqu.edu.cn
Zhen He
hezhen127287@163.com
Chen He
hechen316@163.com
1
College of Computer Science, Chongqing University,
Chongqing, China
BFS pseudo-tree and original DPOP with a DFS pseudotree are compared on three types of problems - graph
coloring problems, meeting scheduling problems and random DCOPs. The results show that BFSDPOP outperforms
original DPOP in most cases, which proves the excellent
attributes of BFS pseudo-tree over DFS pseudo-tree.
Keywords Multiagent system · Distributed constraint
optimization · Breadth first search pseudo-tree · DPOP
1 Introduction
Presently, multiagent systems (MAS) [1] are widely
deployed in real life to accomplish distributed satisfaction
and optimization tasks. Distributed Constraint Optimization
Problems (DCOPs) [2] are a fundamental framework that
can formalize various applications related to multi-agent
cooperation such as sensor networks [3–5], meeting and task
scheduling [6, 7], power networks [8–10] and so on. DCOPs
can be considered as the extensive form of Distributed
Constraint Satisfaction Problems (DCSPs) [11] firstly formalized in [12]. A DCOP is composed of a number of
agents, each of which chooses a value from its finite domain
for its variable under some constraints. Moreover, the agents
have to cooperate with each other and coordinate their values to make all the constraints optimal. To solve DCOPs,
large amounts of distributed algorithms are proposed and
these algorithms can be divided into two categories, i.e.,
incomplete and complete. Incomplete DCOP algorithms
find a suboptimal solution in given time, including three
groups [13], i.e., local search algorithms, inference-based
Z. Chen et al.
algorithms and sampling-based algorithms. Local search
incomplete algorithms typically use local knowledge of
each agent to optimize its individual benefit and can thus
potentially get trapped in local optima [14], including. DBA
[15, 16], DSA [17], MGM [18, 19], etc. Inference-based
incomplete algorithms like Max-Sum [20] and its variants [21, 22] gather global information by propagating and
accumulating the max utilities of constraints but are more
appropriate to acyclic DCOP graphs. Recently, samplingbased incomplete algorithms like DUCT [23] and D-Gibbs
[24, 25] have been proposed to sample the search space to
approximate a function as a product of statistical inference
[13]. Summarily, incomplete algorithms require little local
computation and communication to find solutions at the cost
of sacrificing optimality.
Complete algorithms are those that guarantee to find
the optimal solution and can be further divided into two
groups: partially centralized and fully decentralized. Partially centralized algorithms [26, 27] solve sub-problems
faster but the privacy easy-leaking risk is high. Due to
their good privacy and distributed feature, fully decentralized algorithms have attracted more attention, and can
typically be divided into two subgroups: inference-based
algorithms and search-based algorithms. SynchBB [28] is a
typical search-based decentralized complete algorithm built
on a chain communication structure, adopting backtracking and branch-and-bound search strategy. However, the
synchronous execution of SynchBB wastes most computing resources. AFB [29] and ConcFB [30] were presented
to enhance concurrent computation. For higher parallelism,
Modi et al. presented an asynchronous complete algorithm
named ADOPT [31], using a Depth First Search (DFS)
pseudo-tree generated by DFS traversal as the communication structure and a best-first search strategy. Many
search algorithms based on ADOPT thrive afterward [32,
33]. BnB-ADOPT [34] is an important variant of ADOPT,
which improves search efficiency by replacing the bestfirst search strategy with a depth-first search strategy. Arc
consistency was introduced into BnB-ADOPT to achieve
better performance in [35, 36]. However, these search-based
algorithms have an exponential number of messages, which
may be a serious problem when the communication cost is
expensive.
Inspired by sum-product algorithm, Petcu and Faltings
proposed an inference-based complete algorithm named
DPOP [37] where a dynamic programming strategy and
a pseudo-tree communication structure were adopted. In
DPOP, the assignment combination utilities are sent bottomup and then the value decisions are propagated vice versa
along the pseudo-tree. It just requires a linear number of
messages and can deal with large DCOPs whose pseudotrees have low induced-width. Afterwards, Petcu and Faltings presented two improved algorithms, ODPOP [38] and
MBDPOP [39], to solve memory-bounded problems. In
addition, Vinyals et al. proposed generalizing DPOP of
exploiting Action-GDL to improve the algorithm efficiency,
where the constraint graph was transformed to a distributed
junction tree [40]. Function filtering was used in [41] to
exploit utility bounds for smaller runtimes, and branch consistency was used in [42] to deal with hard constraints and
large message size.
Our study focuses on the inference-based DPOP algorithm. Different from most research on improving its solution strategy, we catch the idea from another point, its
pseudo-tree structure. It has been acknowledged that the
generation of a pseudo-tree has a significant impact on the
performance of DPOP. It also has been proved that finding
a high-quality pseudo-tree with the minimal induced width
is a NP-hard problem. A bad pseudo-tree will greatly impair
the algorithm performance and even make the algorithm
fail by timeout or out-of-memory exceptions in the worst
case. Unfortunately, few studies have been made concerning the generation of a pseudo-tree. DFS pseudo-tree is the
most commonly used pseudo-tree structure but DFS traversal often leads to a low-quality chain-like pseudo-tree with
poor parallelism. Atlas et al. tried to construct a best-first
pseudo-tree by best-first search traversal as the communication structure of DPOP [43]. However, DCPOP in [43]
is more general and complex since it has to consider both
back-edges and cross-edges.
In the paper, we propose a pseudo-tree generated by
Breadth First Search (BFS) traversal, called BFS pseudotree, as the communication structure of DPOP. For the same
constraint graph, the height of a BFS pseudo-tree is often
much lower than that of a DFS pseudo-tree, which means
the communication path or message transmission path is
shorter and the communication time is less. A BFS pseudotree is also better than a DFS pseudo-tree on the parallelism
since the former has more branches and more agents can
compute concurrently. Compared with the best-first pseudotree in [43], a BFS pseudo-tree also has better parallelism
and can be less costly and time consuming to construct.
Besides the difference on the pseudo-tree structure, the
methods of disposing cross-edges in [43] and our proposed
BFSDPOP are also different. In [43], the cross-edge constraints are always computed by their branch-parent nodes
while the cross-edge constraints are allocated by the method
of Cluster Removing in BFSDPOP.
The rest of the paper is structured as follows. Section 2
presents the DCOP definition, pseudo-tree communication
An improved DPOP algorithm based on breadth first search pseudo-tree...
structures and notations along with DPOP and its variants. Section 3 illustrates the details of BFSDPOP and the
theoretical analysis of its advantages and disadvantages.
Section 4 gives the experimental evaluation and discussion
of the results. Finally, we conclude and give our future
research work in Section 5.
2 Background
2.1 Distributed constraint optimization problem
A DCOP is defined as a tuple A, X, D, R such that:
•
•
•
A = {A1 , . . . , Aq } is a set of agents.
X = {X1 , . . . , Xn } is a set of variables. Each variable
Xi is controlled by an agent.
D = {D1 , . . . , Dn } is a set of finite variable domains,
variable Xi taking a value in Di .
Fig. 1 The constraint graph (a)
and corresponding constraint
utilities (b) of a DCOP instance
•
R = {r1 , . . . , rm } is a set of constraints,
where a con
straint ri is any function with the scope Xi1 , . . . , Xik ,
ri : Di1 × . . . × Dik → R+ which denotes how much
utility or cost is assigned to each possible combination
of values of the involved variables.
Without loss of generality, a solution to a DCOP is an
assignment to all variables that maximizes (minimizes) the
total utilities (costs) as shown by formula (1), which are the
sum of all constraints:
X ∗ = argmax X∈D
i
ri (X∗ = argminX∈D
i
ri )
(1)
To facilitate understanding, the paper assumes that each
agent has a single variable and constraints are binary relations. Here, the term “agent” and “variable” can be used
interchangeably. A binary constraint is a constraint involving
exactly two variables, which is defined as rij :Di ×Dj → R+ .
Z. Chen et al.
It is common that a DCOP problem is visualized as a constraint graph where the nodes are the agents and the edges
are the constraints. Figure 1 shows an example of a DCOP
problem whose constraint graph and constraint utilities are
shown in Fig. 1a and b, respectively. The DCOP instance
includes 11 variables, each of which takes its value in {1, 2,
3}. In this instance, the maximal sum of all utilities is 785
and X∗ = {2, 2, 2, 2, 3, 2, 1}.
2.2 Pseudo-tree communication structures and notations
In order to solve a DCOP, DCOP algorithms must perform
on the communication structures derived from its constraint graph. A communication structure is an ordered constraint graph, which decides the agent ordering to send and
receive messages. There are three types of communication
structures: original graph, chain structure and pseudo-tree
structure. Original graph is commonly used in incomplete
algorithms to find a suboptimal solution rapidly, where
each agent can communicate with all its connected agents.
Chain structure and pseudo-tree structure are often used
in complete algorithms, where the agents make decisions
by accumulated information which is propagated with a
pre-defined order, and work cooperatively to find out the
optimal solution.
Chain structure is the earlier used communication structure in complete DCOP algorithms, where agents are prioritized to a chain. However, limited by chain structure,
the agents execute in sequence, which leads to poor efficiency. To improve the efficiency, pseudo-tree structure
was proposed as it enables agents in different branches to
Fig. 2 A DFS pseudo-tree (a)
and a BFS pseudo-tree (b)
derived from Fig. 1a
compute independently and concurrently. In [44], we gave
an overview of these different communication structures
and analyzed their effects on solving a DCOP.
A pseudo-tree is a spanning tree with non-tree edges. At
present, pseudo-tree structure is the most commonly used
communication structure. The performance of algorithm
heavily relies on the quality of constructed pseudo-tree.
Generally, a pseudo-tree can be generated by traversing the
original constraint graph using three types of strategies:
depth-first search (DFS), breadth-first search (BFS) and
best-first search. A pseudo-tree generated by DFS traversal, called a DFS pseudo-tree, is a DFS spanning tree
with back-edges which connect two nodes in the same tree
branch. A pseudo-tree generated by BFS traversal, called a
BFS pseudo-tree, is a BFS spanning tree with cross-edges
which connect two nodes in two different tree branches. A
pseudo-tree generated by best-first search traversal, called a
best-first pseudo-tree, is a best-first spanning tree with both
back-edges and cross-edges.
DFS pseudo-trees are widely used in DCOP algorithms.
Specifically, DFS starts exploration from the selected root
and recursively visits a neighbor of the current node. If all
neighbors of the current node are visited, DFS backtracks
to the previous node. Distributed DFS pseudo-tree construction algorithms can be found in [45, 46]. However, DFS
pseudo-tree has its “bottleneck” when the branches may
be very few since DFS always explores as far as possible along each branch before backtracking. Taking Fig. 1a
for example, if we select X1 as the root, the trace of DFS
would be X1 , X2 , X3 , X4 , X5 , X6 , X7 , whose corresponding DFS spanning tree only has two branches. Thus, in many
An improved DPOP algorithm based on breadth first search pseudo-tree...
cases, the constructed DFS pseudo-trees are more just like
a chain with poor parallelism. Atlas et al. used distributed
best-first search traversal to construct a best-first pseudotree for DCPOP [43], but DCPOP has to deal with backedges and cross-edges simultaneously, which makes it more
complex. Additionally, it cannot fully exploit the parallelism
coming from multiple branches like a BFS pseudo-tree.
In this paper, we propose to use a BFS pseudo-tree as the
communication structure. Compared with a DFS pseudotree and a best-first pseudo-tree, a BFS pseudo-tree has more
branches and a shorter message transmission path, which
gives rise to better parallelism and less network transmission
time. A distributed BFS pseudo-tree construction algorithm
is shown by Algorithm 1 in Section 3.1. In contrast to DFS,
BFS starts at the root node and explores the neighbors first
before moving to the next level neighbors. Figure 2 shows
an example of a DFS pseudo-tree and a BFS pseudo-tree
both derived from the constraint graph in Fig. 1a, where tree
edges and non-tree edges are shown as solid lines and dotted lines, respectively. It can be seen from Fig. 2 that the
BFS pseudo-tree has more branches and a shorter message
transmission path than the DFS pseudo-tree.
To describe a pseudo-tree and DCOP solution space,
some notations are defined as follows:
•
•
•
•
•
•
•
•
•
•
Pi − the parent of node Xi : the single higher node
directly connecting Xi through a tree edge (e.g., P2 =
X1 in both Fig. 2a and b).
P P i − the set of pseudo-parents of node Xi : the higher
nodes directly connecting Xi through back edges (e.g.,
P P 5 = {X2 , X3 } in Fig. 2a).
Ci − the set of children of node Xi : the lower nodes
directly connecting Xi through tree edges (e.g., C1 =
{X2 } in Fig. 2a and C1 = {X2 , X3 } in Fig. 2b).
P C i − the set of pseudo-children of node Xi : the lower
nodes directly connecting Xi through back edges (e.g.,
P C 3 = {X5 , X6 , X7 } in Fig. 2a).
Ni − the set of neighbors of node Xi : the neighboring nodes that directly connect Xi (e.g., N2 =
{X1 , X3 , X4 , X5 } in both Fig. 2a and b).
P N i − the set of pseudo-neighbors of node Xi : the
neighboring nodes that directly connect Xi through
non-tree edges; P N i ⊆ Ni (e.g., P N 2 = {X4 , X5 } in
Fig. 2a and P N 2 = {X3 } in Fig. 2b).
wi − the width of node Xi : the number of high-priority
neighbors (i.e., Pi and P P i ) of Xi (e.g., w5 = 3 in
Fig. 2a).
w∗ − the induced width of a pseudo-tree: the maximal width
over all agents of a pseudo-tree (e.g., w ∗ = 3 in
Fig. 2a).
E(Xi , Xj )− the edge connecting node Xi and Xj .
BE(Xi , Xj )− back-edge, a non-tree edge in a DFS
pseudo-tree, which directly connects node Xi and Xj
•
•
•
•
•
in the same branch (e.g., BE(X2 , X4 ) is a back-edge in
Fig. 2a).
CE(Xi , Xj )− cross-edge, a non-tree edge in a BFS
pseudo-tree, which directly connects node Xi and Xj
in two different branches (e.g., CE(X2 , X3 ) is a crossedge in Fig. 2b).
CT (Xi , Xj )− the constraint on edge E(Xi , Xj ), which
is a two-dimensional matrix data (e.g., CT (X1 , X2 ) is
the constraint utility in Fig. 1b).
CEC i − cross-edge cluster: a set of cross-edges connecting the mutual node Xi which is called the center
of CEC i (e.g., CEC 3 ⊆ {E(X2 , X3 ), E(X3 , X4 ),
E(X3 , X5 )} in Fig. 2b).
DI M = {dim1 , . . . , dimn }− the set of the dimensionalities in multi-dimensional data wrapped in a utility
message. dimi is the dimensionality corresponding to
node Xi with the size of |Di |.
MD S , S ⊆ DI M− the multi-dimensional data wrapped
in a utility message
that
involves the dimensionalities in
the set S. CT Xi , Xj = MD {dimi ,dimj } and the solution space of a DCOP is MD DI M (e.g., the constraint
utility in Fig. 1b can be expressed as MD {x1 ,x2 } ).
2.3 DPOP and its variants
Distributed Pseudo-tree Optimization Procedure (DPOP)
[37] is an inference-based complete algorithm using a
dynamic programming strategy and a DFS pseudo-tree as
the communication structure.
DPOP performs the following three phases in sequence.
Firstly, it performs a preprocessing phase to transform the
constraint graph of a DCOP into a DFS pseudo-tree. After
this phase, each agent Xi knows Pi , P P i , Ci and P C i .
Then, a utility propagation phase starts from the leaf agents.
In the phase, each agent joins the received utilities from
its children with local constraint utilities for its parent and
pseudo-parents, reduces its dimensionality from the joint
utilities by calculating the optimal utility for each combination of remaining dimensionalities and then propagates
the calculated utilities to its parent. Finally, a value propagation phase starts from the root agent. In the phase, each
agent selects its optimal assignment based on the utilities
calculated in the previous phase and the assignment received
from its parent, and broadcasts its assignment to its children.
The algorithm terminates when all agents have chosen their
optimal assignments.
During the utility propagation phase, UTIL messages are
sent from an agent to its parent. A UTIL message contains
the multi-dimensional utilities for each set of assignments
from the sub-problem started in the sender agent. An agent
can only send a UTIL message to its parent after receiving
the UTIL messages from all its children. During the value
propagation phase, VALUE messages are sent from an agent
Z. Chen et al.
to its children. A VALUE message carries the received
assignments and the optimal assignment of the sender agent.
DPOP requires a linear number of messages that is O(|X|)
to solve a DCOP since the number of utility and value messages are both (|X| − 1), where |X| is the number of agents.
However, the maximal message size in DPOP is exponen∗
tial in the induced width of the DFS pseudo-tree: O(d w ).
Here, d = max Di ∈D |Di |.
Many research efforts have been made to reduce the
maximal message size in DPOP. ODPOP [38] is an optimization algorithm for DPOP by replacing the utility propagation phase with a ASK/GOOD phase where each node
iteratively asks (via ASK messages) its children for valuations (goods) until it can compute suggested optimal
assignments for its ancestors. ODPOP can generate smaller
messages but more messages. MB-DPOP [39] uses the idea
of cycle-cuts [47] to deal with the high-width areas of the
pseudo-tree in DPOP. In MB-DPOP, a control parameter
k is introduced to specify the maximal amount of inference (i.e., maximal message dimensionality) and bounded
inference is performed in the areas of width higher than
k. Anyway, ODPOP and MB-DPOP both trade the number
of messages for smaller messages. Besides, Action-GDL
[40] extends Generalized Distributive Law (GDL) to solve
DCOPs by means of a distributed junction tree, which generalizes DPOP. Inspired by DCTE-based algorithms [48],
BT-IDPOPf [41] was proposed to improve DPOP by introducing cost function filtering pertaining to a global upper
bound UB on the maximum acceptable cost of any solution
and a bucket tree (BT) derived from the DFS pseudotree of a DCOP. Recently, BrC-DPOP [42] was proposed
to apply branch consistency to paths in DFS pseudo-trees
and introduce two phases, arc consistency (AC) propagation phase and branch consistency (BrC) propagation phase,
into DPOP.
3 BFSDPOP
To achieve better parallelism and higher communication
efficiency, we propose BFSDPOP using a BFS pseudotree in place of a DFS pseudo-tree in original DPOP
[37] as the communication structure. In the section, we
firstly introduce a distributed algorithm for BFS pseudotree construction and give the proofs of its feasibility (see
Section 3.1). Secondly, the solution space operations in
DPOP are analyzed and thus a method of disposing crossedges in a BFS pseudo-tree, cluster removing, is presented
(see Section 3.2). Next, an example is given to compare the
execution process on a DFS pseudo-tree with that on a BFS
pseudo-tree (see Section 3.3). Then, the BFSDPOP algorithm is detailed (see Section 3.4). Finally, the complexity
of BFSDPOP is analyzed (see Section 3.5).
3.1 BFS Pseudo-tree construction
A distributed algorithm for constructing a BFS pseudo-tree
is given in Algorithm 1.
Algorithm 1 The distributed synchronous algorithm for
constructing a BFS pseudo-tree
Procedure initialize
1: Elect the root node
2: Set
,
,
3: Set
4: if node
has at least one neighbor then
5:
if
is the root then
0
6:
Set
7:
Add
into
8:
for each node
in
do
9:
Send
to
by LAYER message
10:
end
When received LAYER message from node
11: Mark
has received a message from
12: if
1
then
13:
Set
1
14:
Set
15:
Add
into
16:
for each node
in
17:
Send
to
by LAYER message
18:
end
19:
Send ACK message to
20: else
21:
Remove
from
22:
Add
into
23: if
has received a message from each neighbor then
24:
terminate
When received ACK message from node Xy
25: Mark
has received a message from
26: if
has received a message from each neighbor then
27:
terminate
In Algorithm 1, Lx denotes the layer index of node Xx
in the constructed BFS pseudo-tree. If Xx is the root node,
then Lx = 0 (lines 5–6). A LAYER message carries the
layer index and a ACK message carries nothing. LAYER
messages are sent from a node to all its neighbors except its
parent (lines 7–10 and 15–18). ACK message is a message
acknowledgement sent from a node to its parent (line 19),
which is used to determine whether to terminate the algorithm. After it receives messages from all its neighbors, an
agent terminates execution (lines 23–24 and 26–27).
Like most distributed DFS pseudo-tree construction algorithms [45], Algorithm 1 is also executed synchronously in
a preprocessing phase. In Algorithm 1, each node learns its
position in the pseudo-tree, which is given by its knowledge
of its parent, children and pseudo-neighbors, from LAYER
An improved DPOP algorithm based on breadth first search pseudo-tree...
messages that carry its layer index and are exchanged only
with its neighbors. However, each agent in distributed DFS
pseudo-tree construction algorithms knows its position in
the pseudo-tree, which is given by its knowledge of its
parent, children, pseudo-parents and pseudo-children, by a
unique message that includes all the visiting node indices
and is circulated to all the nodes in the graph.
Proposition 1 According to Algorithm 1, the agents added
into the BFS spanning tree in the N-th cycle have the
identical layer index.
Proof Assume that there exist two agents, Xi and Xj , added
into the BFS spanning tree in the N-th cycle and the two
agents have different layer indices (i.e., Li = Lj ). It can
be inferred from line 13 that the parents of Xi and Xj
also have different layer indices in the (N − 1)-th cycle
(i.e., Li − 1 = Lj − 1 ⇔ LPi = LPj ). So the assumption holds for the (N − 1)-th cycle. By the mathematical
induction, it can be concluded that the assumption holds
for every cycle before the N-th cycle. Accordingly, the root
node has two different layer indices in the first cycle (i.e.,
Li − N + 1 = Lj − N + 1 ⇔ Lroot = Lroot ), which is contradictory. Thus, by reduction to absurdity, all agents added
into the BFS spanning tree in the N-th cycle should have the
identical layer index. Proposition 1 is proved.
Proposition 1 indicates that the newly added agents in
every cycle have the identical layer index. It manifests that
Algorithm 1 is synchronous under a multi-agent context.
Theorem 1 Algorithm 1 constructs a BFS pseudo-tree and
guarantees topology privacy.
Proof Since Algorithm 1 executes synchronously, the layer
index is increased by 1 in each cycle. From lines 8–10 and
15–18, it can be inferred that each node Xx will receive
one LAYER message with (Ly + 1) < Lx from its parent and one LAYER message with (Ly + 1) ≥ Lx from
each of its pseudo-neighbors. And so all nodes will get their
correct pseudo-tree information of parent, children, pseudoneighbors and layer index by lines 6–7, 13–15 and 21–22.
As each node sends LAYER messages to all its neighbors
except its parent and an ACK message to its parent, all nodes
will receive one message from each neighbor. Thus, each
node will meet the termination condition (lines 23–24 and
26–27) and the algorithm will terminate soundly with the
result of a BFS pseudo-tree.
Before running Algorithm 1, each node knows the topological construct in which it is involved, i.e., who are
connected to it. Algorithm 1 introduces two types of messages, LAYER messages and ACK messages, to establish a
BFS pseudo-tree. In other words, topology privacy leaking
risk comes only from the two types of messages. An ACK
message is only sent to one neighbor (connected node) of
a node (i.e., its parent) and carries nothing, so it does not
incur any privacy leak. LAYER messages are sent from a
node to all its neighbors except its parent and carry only the
layer index of the node. Thus, there is not any message communication among non-connected nodes. Compared to its
previous knowledge, each node only knows one more information about the layer indices of its neighbors. Yet, the layer
indices only help a node to label its neighbors as its parent,
children or pseudo-neighbors and cannot reveal the topological constructs of its neighbors. Therefore, after running
Algorithm 1, no node should be able to discover the existence
of topological constructs in the constraint graph unless it is
involved in the construct, which satisfies topology privacy
[46].
So, Theorem 1 is proved.
3.2 Cluster removing - method of allocating cross-edge
belonger
3.2.1 Solution space operations in DPOP-dimensionality
reduction and dimensionality union
BFSDPOP is a variant of DPOP, which only changes the
communication structure. So it is necessary to illustrate
how DPOP works out the solution assignment. In fact,
DPOP solves a DCOP by gradually reducing the dimensionalities of MD DI M which is the solution space of the
DCOP. During the process, the two operations, dimensionality reduction and dimensionality union, are utilized alternately. Dimensionality reduction reduces the size of solution
space; dimensionality union joins two multi-dimensional
data together and merges the same dimensionalities. The
two operations can be expressed as follows:
RD dimi (MD S ) = minv∈Di (MD S ) = MD S\{dimi } , dimi ∈ S (2)
B
U D (MD A , MD B ) = MD A
A∪B + MD A∪B = MD A∪B , A ∩ B = ∅
(3)
RD dimi is the operation of reducing the dimensionality
dimi . U D (MD A , MD B ) is the operation of uniting two
multi-dimensional data, MD A and MD B , where MD A
A∪B
and MD B
A∪B denote the extended multi-dimensional data
from MD A and MD B , respectively.
More precisely, the core of DPOP is the RD operation on the solution space. DFS and BFS pseudo-trees
prioritize the order of reducing dimensionality. In a DFS
pseudo-tree, all agents can reduce the dimensionality of
itself locally. However, it is different in a BFS pseudo-tree
because the dimensionalities may be incomplete. A dimensionality of multi-dimensional data can be reduced if and
only if the dimensionality is complete. To illustrate the RD
Z. Chen et al.
condition clearly, we give the definitions of Dimensionality
Completeness and Dimensionality Complete Value.
•
•
DC i − the Dimensionality Completeness of dimensionality dimi .
DCV i − the Dimensionality Complete Value of dimensionality dimi .
For DC i and DCV i , there are:
1) DCV i = |Ni |
2) DC i = DC j = 1 for MD {dimi ,dimj } of CT (Xi , Xj )
A
B
3) DC C
i = DC i + DC i for U D (MD A , MD B ) =
A
MD C , where DC i is the Dimensionality Completeness of dimi in MD A , DC B
i is the Dimensionality
Completeness of dimi in MD B and DC C
i is the Dimensionality Completeness of dimi in the united MD C
The RD condition is that RD dimi (MD S ) can be executed if and only if DC i = DCV i . DCV i is a fixed value
and DC i increases from 1 to |Ni |. When DC i increases to
|Ni |, the dimensionality of Xi meets the RD condition.
In BFSDPOP, the RD and UD operations are the same as
in DPOP. However, BFSDPOP performs these operations on
a BFS pseudo-tree where the cross-edges must be properly
disposed. Since a cross-edge connects two nodes in different
branches, the constraint on it should be computed by only
one, rather than both, of them. The constraint computation
must be properly allocated. Otherwise, the dimensionalities
of many nodes cannot meet the RD condition, which will
lead to very large message size.
3.2.2 The method of cluster removing
The method of Cluster Removing is used to dispose the constraints on cross-edges to make the maximal message size
as small as possible.
If the constraint CT (Xi , Xj ) on a non-tree edge
E(Xi , Xj ) (including a back-edge in a DFS pseudo-tree
and a cross-edge in a BFS pseudo-tree) is computed by Xi
(or Xj ), we call Xi (or Xj ) the belonger of this non-tree
edge. The dimensionality of the non-belonger of a nontree edge cannot be reduced locally and will be transmitted
upward because only the node which is the belonger of all
its connected edges satisfies the condition of locally reducing dimensionality (i.e., DC i = DCV i ). In other words,
each non-tree edge (Xi , Xj ) forms a ring with the tree edges
in the pseudo-tree and the dimensionality dimj (or dimi )
of the non-belonger is transmitted upward along the ring.
And, the reduction of the dimensionality takes place at the
highest node of the ring. To take CE(X3 , X5 ) in Fig. 2b
for example, assume that the belonger of CE (X3 , X5 )
is X3 . It can be seen that CE(X3 , X5 ) forms a ring
of (X5 , X2 , X1 , X3 ). And so the dimensionality dim5 is
transmitted upward along the ring till X1 where dim5 is
reduced.
In a DFS pseudo-tree, the non-tree edges are back-edges
and the constraints on them are always computed by pseudochildren. In a BFS pseudo-tree, the non-tree edges are crossedges and should be properly allocated. If the cross-edge
belongers are allocated randomly, the maximal dimensions
of utility message involved in the algorithm may be very
large. For example, if the belongers of CE(X5 , X6 ) and
CE(X5 , X7 ) are allocated to X5 in Fig. 2b, the dimensionality of dim6 and dim7 will both be transmitted along path
(X5 , X2 , X1 ) and (X3 , X1 ). However, if their belongers are
set to be X6 and X7 , the transmitted dimensionality along
path (X5 , X2 , X1 ) and (X3 , X1 ) will be only dim5 .
We propose the method of Cluster Removing to allocate
cross-edge belongers after a BFS pseudo-tree construction.
The pseudo-code is shown by Algorithm 2.
Algorithm 2 The cluster removing algorithm for allocating
cross-edge belonger
Procedure initialize
01: Compute
CE
and
is not allocated
02: if
is a leaf then
03: Send
and
to by CEC message
When received CEC message from
04: Mark
has received a CEC message from
05: if
has received a CEC message from each child then
06:
Select the max
from all
and
07:
if
is not the root then
08:
Send
and
to by CEC message
09:
else
10:
if
is equal to 0 then
11:
terminate
12:
for each
in
do
13:
Send
to
by ALLOCATE message
14:
end
When received ALLOCATE message from
15: if
is
then
16:
for each
do
18:
Set
belonged to
19:
end
20:
Compute
21:
Send
and
to by CEC message
22: else
23:
for each
in
do
24:
Send
to
by ALLOCATE message
25:
end
The Cluster Removing has two phases: phase 1 is
a propagation process of CEC messages from bottom
to top along the BFS pseudo-tree to find the maximal
CEC; phase 2 is a propagation process of ALLOCATE
An improved DPOP algorithm based on breadth first search pseudo-tree...
Fig. 3 The execution process of
original DPOP with the DFS
pseudo-tree in Fig. 2a
X5
X6
X4
X7
X2
X1
messages from top to bottom to allocate the belongers of crossedges in the maximal CEC.
Initially, Xi computes CEC i and the leaf agents activate
the message-driven process by sending CEC messages carrying the size and center of CEC i to their parents (lines 1–3).
Phase 1 When receiving CEC messages from all its children, Xi selects the maximal one from the received |CEC j |
and |CEC i | (lines 4–6). If it is not the root, Xi sends a CEC
message carrying the max |CEC k | and its center Xk to its
parent (lines 7–8). Otherwise, Xi terminates execution when
the received |CEC j | is 0 (lines 9–11) or broadcasts the center Xk of the max |CEC k | to its children via ALLOCATE
messages when not (lines 12–14).
Phase 2 When receiving an ALLOCATE message from its
parent, Xi first judges whether it is the center carried by
the message (line 15). If so, it allocates the cross-edges in
CEC i to its neighbors, then re-computes CEC i and sends
the size and center of CEC i to its parent via a CEC message
Fig. 4 The execution process of
BFSDPOP with the BFS
pseudo-tree in Fig. 2b
X4
(lines 16–21). Otherwise, it broadcasts ALLOCATE messages carrying the received center to its children (lines 23–25).
In fact, the Cluster Removing divides the whole crossedge set into several subsets. Each subset includes all the
cross-edges connecting the mutual node, that is, each subset is a cross-edge cluster. And, the cross-edge belongers
are allocated to the nodes that are not the cluster center so
only the cluster center is the non-belonger in each cluster.
Since each cross-edge and the tree edges form a ring along
which the dimensionality of the non-belonger is transmitted upward, the dimensionality of the cluster center is only
transmitted along the rings formed by the cross-edges in a
cross-edge cluster. So the Cluster Removing makes most
nodes meet the condition of locally reducing dimensionality. If a constraint graph is a tree, all dimensionalities can
be reduced locally and the maximal dimensions of utility
message will be only 2.
If the cross-edges are randomly allocated, the utility
message size can be very large. The Cluster Removing guarantees the maximal dimensions no more than (|CEC| + 2)
X2
X5
X6
X7
X3
X3
X1
Z. Chen et al.
(see Section 3.5). With the help of Cluster Removing, we
can easily exploit the excellent attributes of a BFS pseudotree on the parallelism and communication time without
causing too large of a utility message.
To take the BFS pseudo-tree in Fig. 2b as an example, the
execution process of the Cluster Removing is as follows:
(1) The largest CEC, CEC 5 with size 4, is selected out
by phase 1 of cycle 1;
(2) The belongers of CE (X3 ,X5 ), CE (X4 ,X5 ),
CE (X5 ,X6 ) and CE (X5 ,X7 ) are allocated to X3 ,
X4 , X6 and X7 respectively by phase 2 of cycle 1;
(3) The largest CEC, CEC 3 with size 2, is selected out
by phase 1 of cycle 2;
(4) The belongers of CE (X2 ,X3 ) and CE (X3 ,X4 ) are
allocated to X2 and X4 respectively by phase 2 of cycle 2.
Since the selected CECs are CEC 3 and CEC 5 , all dimensionalities will satisfy the dimensionality reduction condition and be reduced locally except for dim3 and dim5 . And,
dim3 and dim5 will be reduced in the root agent X1 .
3.3 Execution procedures on DFS and BFS pseudo-tree
To take the DFS pseudo-tree in Fig. 2a as an example, the
execution process of original DPOP is shown by Fig. 3.
By the Cluster Removing, the cross-edges in Fig. 2b are
divided into two CECs: CEC 5 and CEC 3 . Accordingly,
the execution process of BFSDPOP with the BFS pseudotree is given by Fig. 4.
Here, “}” denotes the operation of dimensionality union,
“ ⇒ ” represents the operation of dimensionality reduction, and “ → ” means just sending the data to the parent
with no operation. (Xi , Xj , . . .) is local constraint data,
[X i , Xj , . . .] is the received constraint data from child, and
Vi is the optimal assignment of node Xi .
It can be seen from Fig. 3 that original DPOP can perform
dimensionality reduction locally since the dimensionalities
of agents are complete (e.g., the local dimensionality completeness of X5 is 3, the dimensionality completeness sent
by X6 and X7 both are 1, and thus DC 5 = DCV 5 = 5).
However, DPOP keeps the dimensionality completeness at
the cost of sacrificing parallelism. In other words, agents
need DFS pseudo-tree structure which has poor parallelism
to guarantee dimensionality completeness in every step.
Thus, it needs 6 steps to eliminate all dimensionalities, just
performing a chain-like process. In contrast, with the help of
Cluster Removing, our method utilizes better parallelism of
BFS pseudo-tree and makes most nodes meet the condition
of locally reducing dimensionality. As seen from Fig. 4, the
leaf agents X4 , X5 , X6 and X7 send utilities concurrently
and most of them can perform dimensionality reduction
locally (e.g., X4 , X6 and X7 in Fig. 4). Consequently, our
method uses 3 serial steps to solve the problem, which is
superior to original DPOP. Besides, we can see from Figs. 3
and 4 that our method does not generate larger message than
original DPOP and their maximal message sizes are both
3-dimensional.
3.4 The BFSDPOP algorithm
The detailed procedure of BFSDPOP is shown by Algorithm 3.
Algorithm 3 BFSDPOP for distributed constraint optimization problems
executes:
BFSDPOP(X, D, R): each agent
Procedure Preprocessing
01: Generate a BFS pseudo-tree by Algorithm 1
//now
knows
and
02: Allocate cross-edge belongers by Algorithm 2
Procedure Initialize
03: Unite the local constraints to
04: if
is a leaf then
05: if
of
is reducible then
06:
Reduce the dimensionality
07: Send
to by utility message
When received UTILj from Xj
08: Unite
and
,
is the multi-dimensional
data wrapped in
09: if utility messages from all children have been received
then
10: for each
in
do
11:
if
is reducible then
12:
Reduce the dimensionality
13: end
14: if
is the root then
15: Compute
if
is reduced here
// is the optimal assignment of
16: for each
in
do
17:
Send to
by value message
18: end
19: Terminate
20: else
21: Send
to by utility message
When received VALUEj from Xj
22: Compute
if
is reduced here
23: Set
is the optimal assignment set wrapped in
is the optimal assignment of
24: if
is not a leaf then
25: for each
in
do
26:
Send to
by value message
27: end
28: Terminate execution
An improved DPOP algorithm based on breadth first search pseudo-tree...
U T I Li and V ALU E i in Algorithm 3 represent two
types of messages transmitted by Xi , utility message and
value message. The former contains multi-dimensional utility data and the latter contains a set of optimal assignments
for high-priority agents. The agents communicate by sending utility and value messages to cooperatively work out
the optimal assignments that maximize the total constraint
utility.
Preprocessing and Initializing The algorithm starts by the
preprocessing and initializing steps. In the preprocessing
step, the algorithm constructs a BFS pseudo-tree (line 1).
Then, the method of Cluster Removing is used to allocate
cross-edge belongers (line 2).
The leaf agents compute the local constraints (line 3)
and reduce their own dimensionalities locally if reducible
(lines 4–6). Then, they send the utilities to their parents (line
7). After initializing, the whole message-driven process is
activated.
UTIL Propagation The UTIL propagation process starts
from the leaves and ends at the root. Each time a utility message is received, Xi unites the received multi-dimensional
data and its local utility data (line 8) together. After receiving utility messages from all its children, Xi reduces all
reducible dimensionalities (lines 9–13). The utility data is
sent upward if Xi has parent (lines 20–21). If it is the root,
Xi obtains the optimal assignments (lines 14–15). After
sending the assignments to its children (lines 16–18), it
terminates execution (line 19).
VALUE Propagation The VALUE propagation process
starts from the root and ends at the leaves. When receiving a
value message, Xi computes the optimal assignments (line
22). The optimal assignments are sent downward continually till reaching the leaf agents (lines 23–27) and then the
algorithm terminates (line 28).
To take the DCOP in Fig. 1 as an example, assume that
X1 is the root. In the preprocessing procedure, X1 starts the
BFS pseudo-tree construction by sending a LAYER message with L1 = 0 to its neighbors, X2 and X3 . X2 and X3
set their layer indices to 1, their parents to X1 , and broadcast their layer indices to its remaining neighbors. Since
they have the same layer index, X2 and X3 add each other
into pseudo-neighbors after receiving each other’s messages. Other agents do the same. Consequently, each agent
knows its parent, children and pseudo-neighbors, and the
BFS pseudo-tree is constructed, shown as Fig. 2b.
The leaf agents, X4 , X5 , X6 and X7 , start the Cluster
Removing process by sending the sizes and the centers of
their CECs to their parents (e.g., the size of CEC 4 is 2 and
the center of CEC 4 is X4 ). The intermediate agents collect
CEC messages from their children, then select the maximal
size of CEC from the received |CEC s | and local |CEC i |,
and send a CEC message to their parents (e.g., X2 sends
a CEC message to X1 with |CEC 5 | and the center X5 ).
The root selects maximal size of CEC and broadcasts the
corresponding center to its children via ALLOCATE messages (e.g., X1 broadcasts the center X5 to X2 and X3 ). The
agent who is the center carried in an ALLOCATE message
allocates the cross-edges to its neighbors (e.g., X5 allocates
CE(X3 , X5 ), CE (X4 , X5 ), CE(X5 , X6 ) and CE(X5 , X7 )
to X3 , X4 , X6 and X7 , respectively). The procedure terminates when the root detects that the maximal size of CEC is 0.
Next, the leaf agents start the UTIL propagation process
by sending local utilities to their parents (e.g., X4 → X2 ,
X5 → X2 , X6 → X3 and X7 → X3 in Fig. 4). Notice
that X5 cannot reduce its dimensionality since DC 5 (= 1) is
less than DCV 5 (= 5). When receiving the utility messages,
X2 unites the received utilities and local constraint utilities,
then reduces its dimensionality according to the RD condition, and sends MD {X1 ,X3 ,X5 } to X1 . In contrast, X3 cannot
reduce any dimensionality and sends MD {X1 ,X3 ,X5 } to X1 .
Upon receiving the utility messages, X1 unites the utilities
from X2 and X3 , and computes optimal assignments for X1 ,
X3 and X5 .
The root starts the VALUE propagation process by broadcasting the optimal assignments to its children (e.g., X1
broadcasts V = {V1 = 2, V3 = 2, V5 = 3} to X2 and
X3 ). When receiving the optimal assignments from X1 , X2
and X3 compute the optimal assignments for their reducible
dimensionalities, then combine the assignments with the
received assignments except for their parent assignments,
and send the joint assignments to their children (e.g., X2
computes the optimal assignment for dimensionality X2 and
broadcasts V = {V2 = 2, V3 = 2, V5 = 3} to its children).
The algorithm terminates after all agents have chosen their
assignments.
3.5 Complexity analysis
The complexity of a complete DCOP algorithm depends
on the number of messages and the temporal and space
complexities of disposing a message. For inference-based
complete algorithms, the temporal and space complexities
of disposing a message both lie on the maximal message
size. DPOP, a classical inference-based algorithm, requires
a linear number of messages to solve a DCOP since the
number of utility and value messages are both (|X| − 1).
A value message contains at most (|X| − 1) assignments
while a utility message can contain exponentially many feasibility values. Thus, for DPOP, the temporal and space
complexities of disposing a message both lie on the maximal utility message size which is exponential in the induced
∗
width of the DFS pseudo-tree: O(d w ). Like DPOP, BFSDPOP executes a bottom-up utility propagation process and a
Z. Chen et al.
top-down value propagation process, and thus also requires
2(|X|−1) messages. Similarly, the temporal and space complexities of disposing a message also depend on the maximal
utility message size in BFSDPOP. Next, we prove that the
largest utility message in BFSDPOP is space-exponential in
(|CEC| +2) at most.
2(|X| − 1) messages, the temporal and space complexities
of BFSDPOP are both O(|X| · d |CEC|+2 ).
4 Experimental evaluation
4.1 Experimental configuration
Theorem 2 The largest utility message produced by Algorithm 3 is space-exponential at most in the number of
cross-edge clusters which divide all cross-edges plus 2,
i.e., the largest utility message is space-exponential in
(|CEC| +2) at most where CEC = {CEC 1 , . . . , CEC m },
CEC k = CE and CEC i ∩CEC j = ∅ (CE is the
k
set of all cross-edges in a BFS pseudo-tree, i, j, k =
0, 1, . . . , m, i = j ).
Proof If there are no cross-edges in the BFS pseudo-tree,
i.e., the BFS spanning tree, the maximal dimensions of
multi-dimensional data wrapped in a utility message are 2.
Then, we add the cross-edges to the tree one by one to
form the original constraint graph. During the process, the
cross-edge clusters are produced and expanded continually.
According to the method of Cluster Removing, only the
centers of the cross-edge clusters are not reduced locally.
So they will be transmitted upward to the lowest mutual
ancestors where they are reduced finally. That is, all dimensionalities except for the cross-edge cluster centers will be
reduced locally and will not be involved into latter multidimensional data. So the maximal dimensionality number is
the number of CEC i plus 2 at most (2 is the minimal utility
message dimensions when the pseudo-tree is a pure tree).
If two CECs do not overlap, which means the dimensionalities of the two CEC centers are transmitted upward
and finally reduced in different branches, the maximal
dimensions only add 1. For example, the maximal dimensions are 3 in Fig. 5. So the exact maximal dimensions is no
more than (|CEC| +2). Thus, Theorem 2 is proved.
According to Theorem 2, the maximal utility message
size in BFSDPOP is exponential in (|CEC| +2). Thus,
the temporal and space complexities of disposing a message are both O(d |CEC|+2 ). Since BFSDPOP exchanges
Fig. 5 An example that two CECs do not overlap
We use three DCOP problem types in our experiment: graph
coloring, meeting scheduling and general random DCOPs.
Runtime and maximal dimensions of utility messages are
adopted as the performance metrics. To prove the excellent attributes of BFS pseudo-tree over DFS pseudo-tree,
we compare BFSDPOP with original DPOP in terms of the
two metrics. To provide more detailed comparison of the
two algorithms, we also examine Phase Transition which
refers to a phenomenon of a system where some global
properties change rapidly and dramatically when a control
or order parameter goes across a critical value [49]. The
algorithms in [38] and [39] are not put into comparison
because the transformation methods from normal execution
to memory-bounded execution can also be applied to BFSDPOP. The main innovation of BFSDPOP lies in using a
BFS pseudo-tree as the communication structure and it is
more persuasive to compare the two different communication structures, BFS pseudo-tree and DFS pseudo-tree. In
[43], DCPOP was proposed using a best-first pseudo-tree as
the communication structure. However, it is with regret that
we didn’t get the source code from the authors and the given
pseudo-code is incomplete. And so DCPOP is not put into
comparison in our experiment.
For runtime, to make the experimental environment
approximate the real situation, we take the message transmission time into consideration by setting it as 50ms
between each two agents. The experiment is conducted
under win8.1×64 operating system on a notebook with an
AMD Athlon II Dual-Core M340 2.20GHz CPU and a 4GB
Memory.
4.2 Graph coloring problems
In graph coloring problems, each vertex should be colored
with a color and two adjacent vertices must have different
colors. The agents are the vertices and the domains are the
colors available. The constraint costs can be selected in { 0,
1} or {0, 10000}. The non-zero values are penalty for violating the restriction that two adjacent vertices must have
different colors. In our experiment, we set three different
colors. We vary the number of vertices from 15 to 34 and
graph density is set to be 0.2 (graph density is the ratio of the
constraint number to n ∗ (n − 1)/2, n is the number of vertices). The influence of graph density is evaluated on general
random DCOPs and not shown on graph coloring problems
An improved DPOP algorithm based on breadth first search pseudo-tree...
Fig. 6 Comparison of BFSDPOP and DPOP on runtime and the
number of vertices for graph coloring problems
since the cases are similar. We average the experimental
results over 30 DCOP instances with randomly generated
constraints and randomly generated integer constraint costs
in {0, 1}.
As can be seen in Fig. 6, with the increase of the vertex
number of graph coloring problems, the runtime also goes
up and BFSDPOP spends less time. The positive results
of BFSDPOP are due to the fact that the communication
path of a BFS pseudo-tree is shorter than that of a DFS
pseudo-tree. There are also more branches in a BFS pseudotree than those in a DFS pseudo-tree. So BFS pseudo-tree
also exceeds DFS pseudo-tree on the parallelism, which is
another influencing factor on algorithm runtime. Figure 6
also shows that the runtime of DPOP increases abruptly and
dramatically when the number of vertices goes across 28,
which indicates that DPOP experiences a Phase Transition.
In contrast to the sharp transition in DPOP, the transition of BFSDPOP is relative smooth, which indicates that
our method can utilize the parallelism of BFS pseudo-tree
to accelerate computation with the increase of the vertex
number.
The complexity of inference-based algorithms lies on
the maximal utility message size or maximal dimensions
of utility messages. As shown by Fig. 7, BFSDPOP with a
BFS pseudo-tree involves smaller maximal utility message
size than DPOP with a DFS pseudo-tree. This is owing to
the cross-edge allocation method, Cluster Removing, which
guarantees maximal dimensions no more than the number of
cross-edge clusters plus 2. Without proper allocation of the
cross-edges in a BFS pseudo-tree, the maximal dimensions
can be much larger and is equal to the total vertex number
in the worst case.
It is worth mentioning that the existing parameters (i.e.,
the vertex number and graph density) cannot totally depict
the complexity of DCOPs. In effect, those parameters can
reflect the general complexity of a DCOP in most cases, but
they fail to depict the complexity of problems with unusual
edge distributions which may lead to abnormal cases. As a
result, the experimental results shown in Fig. 7 cannot hold
the strict growing trend.
4.3 Meeting scheduling problems
A meeting scheduling problem consists of meetings,
employees to participate the meetings and time slots to hold
the meetings. Two meetings that have shared participants
should be held at different time slots. Since one participant cannot attend two meetings at the same slot, the shared
participants will be absent from one of them. The agents
3500
DPOP
BFSDPOP
3000
Runtime(ms)
2500
2000
1500
1000
500
0
4
6
8
10
12
14
16
18
Meetings
Fig. 7 Comparison of BFSDPOP and DPOP on maximal dimensions
and the number of vertices for graph coloring problems
Fig. 8 Comparison of BFSDPOP and DPOP on runtime and the
number of meetings for meeting scheduling problems
Z. Chen et al.
are meetings and the domains are the time slots to hold
the meetings [34]. The constraint costs are the shared participant number of each two meetings, which denotes the
number of absent persons. We vary the number of meetings from 5 to 18, always use 10 employees and 3 time
slots, and each meeting has 3 participants. We also average the experimental results over 30 DCOP instances with
randomly generated constraints.
The experimental results of runtime on meeting scheduling problems are shown as Fig. 8. As the number of meetings increases, the runtime increases and BFSDPOP has a
significant advantage over DPOP. It can be explained that
the larger the constraint graph is, the greater the advantages
of BFS pseudo-tree on the parallelism and communication
efficiency are.
Figure 9 shows the maximal dimensions of utility messages generated in the two algorithms. BFSDPOP with a
BFS pseudo-tree involves smaller maximal-size utility message than DPOP with a DFS pseudo-tree in most cases.
When the number of meetings is 12, the maximal-size utility message of BFSDPOP is larger than that of DPOP. In
fact, the maximal dimensions of utility messages generated
in BFSDPOP are decided by two factors: the constructed
BFS pseudo-tree and the cross-edge allocation. Algorithm
1 constructs an ordinary BFS pseudo-tree and the proposed
Cluster Removing cannot guarantee to find the optimal
cross-edge allocation solution. So BFSDPOP cannot guarantee to make the maximal message size optimal and may
be inferior to DPOP in a small number of cases. Though it
doesn’t get the optimal solution, the Cluster Removing finds
a relatively good one. The experiment proves that BFSDPOP outperforms DPOP on the maximal message size in
most cases with the help of Cluster Removing.
Fig. 10 Comparison of BFSDPOP and DPOP on runtime and the
number of agents for random DCOPs with graph density=0.2
4.4 Random DCOPs
Random DCOPs are the general form of distributed constraint optimization problems. Graph coloring, meeting
scheduling and nearly all types of DCOP application problems can be induced and transformed to be random DCOPs.
The general definition is given in Section 2.1. The constraints are two-dimensional matrixes with randomly generated cost values in the range of [0, 100]. We set the domain
size to be 3 and vary the agent number from 14 to 34 with
the increment of 1 and graph density from 0.15 to 0.60 with
the increment of 0.03. We also average the experimental
results over 30 DCOP instances with randomly generated
constraints.
14
4000
DPOP
BFSDPOP
12
DPOP
BFSDPOP
3500
3000
Runtime(ms)
Max Dimensions
10
8
6
2500
2000
1500
1000
4
500
2
4
6
8
10
12
Meetings
14
16
18
Fig. 9 Comparison of BFSDPOP and DPOP on maximal dimensions
and the number of meetings for meeting scheduling problems
0
0.1
0.15
0.2
0.25
0.3
0.35
0.4
0.45
0.5
0.55
0.6
Graph Density
Fig. 11 Comparison of BFSDPOP and DPOP on runtime and graph
density for random DCOPs with 20 agents
An improved DPOP algorithm based on breadth first search pseudo-tree...
14
DPOP
BFSDPOP
13
12
Max Dimensions
11
10
9
8
7
6
5
4
0.1
0.15
0.2
0.25
0.3
0.35
0.4
0.45
0.5
0.55
0.6
Graph Density
Fig. 12 Comparison of BFSDPOP and DPOP on maximal dimensions
and the number of agents for random DCOPs with graph density=0.2
As shown in Figs. 10 and 11, BFSDPOP with a BFS
pseudo-tree exhibits better efficiency than DPOP with
a DFS pseudo-tree on the runtime for general random
DCOPs. By comparing Figs. 10 with 11, we can find that
the curves of Fig. 11 are more regular and smooth than those
of Fig. 10. The reason is that graph density has a greater
influence on problem complexity than the agent number.
That means graph density describes the problem complexity more fully and completely. The advantage of BFSDPOP
with a BFS pseudo-tree over DPOP with a DFS pseudo-tree
on the runtime mainly attributes to the better parallelism
coming from more branches and higher communication
efficiency coming from shorter message transmission path.
For example, when a constraint graph is a simple ring with
n nodes, the DFS pseudo-tree will be a chain with height
n while the BFS pseudo-tree will be a pseudo-tree with
height n/2 + 1. So, compared with the DFS pseudo-tree,
the BFS pseudo-tree has two times the branches and halflength message transmission path. It can also be inferred
that BFSDPOP is more appropriate for the cases where the
communication time cannot be neglected, which is often the
exact situation in real scenarios.
The Phase Transitions are also observed in Fig. 10. A
Phase Transition occurs in both DPOP and BFSDPOP when
the number of agents goes across 29. Again, the Phase Transition in DPOP is much sharper than that in BFSDPOP,
which underlines the significance of parallelism.
The comparisons of BFSDPOP and DPOP on the maximal dimensions of utility messages for random DCOPs
are shown in Figs. 12 and 13. The maximal dimensions of
utility messages generated in BFSDPOP are smaller than
those in DPOP by 1 to 3 dimensions in most cases. Though
the two parameters, the agent number and graph density,
Fig. 13 Comparison of BFSDPOP and DPOP on maximal dimensions
and graph density for random DCOPs with 20 agents
cannot totally describe the problem complexity and may
result in abnormal cases, the curves still generally exhibit
regular trends which are convictive on showing the algorithm performance. It can also be inferred that BFSDPOP is
more appropriate for solving the problems with constraints
compactly clustered. In these cases, it is more likely to
reduce dimensionality locally and less dimensions should
be transmitted upward according to the Cluster Removing.
5 Conclusions and future work
In this paper we present a new complete algorithm for solving DCOPs by replacing the communication structure of a
DFS pseudo-tree with a BFS pseudo-tree in DPOP, since a
BFS pseudo-tree is more excellent than a DFS pseudo-tree
on both the communication efficiency and the parallelism.
However, the cross-edges in a BFS pseudo-tree may result
in very large utility message with improper allocation. Thus,
the Cluster Removing method is proposed to allocate the
cross-edges with the guarantee that the maximal dimensions of utility messages are no more than the number of
cross-edge clusters plus 2. By the experimental evaluation,
BFSDPOP proves to be much better than original DPOP on
runtime and also slightly prior on maximal dimensions of
utility messages.
The maximal dimensions of utility messages generated
in BFSDPOP are decided by two factors: the constructed
BFS pseudo-tree and cross-edge allocation. In the future,
we will study how to construct a good BFS pseudo-tree so
as to further reduce utility message size. It can also be seen
from the experimental results that the existing performance
metrics do not exhibit strict growing trends. It is because
the two problem parameters, the agent number and graph
Z. Chen et al.
density, can only reflect the general complexity of problems
and cannot precisely manifest the edge distributions which
depict the internal structures of problems. Given the agent
number and graph density, the complexity of DCOPs can
still vary a lot under different edge distributions. Since the
edge distribution is hard to quantify, our future work is to
describe it from the perspective of graph theory. A possible alternative is the connectivity of a graph. As a metric of
the resilience of a graph, the connectivity can also mirror
the edge distribution. A graph with higher connectivity usually exhibits better robustness and has a more uniform edge
distribution, while lower connectivity often renders a graph
to be decomposed more easily and have a more centralized
edge distribution. Thus, given the agent number and graph
density, we can employ the connectivity as an extra parameter to manifest the internal structures of problems and depict
the complexity of DCOPs more precisely.
Acknowledgments This work is partly supported by Chongqing
University Postgraduates’ Innovation Project (Project No. CYS14018),
the Fundamental Research Funds for the Central University of China
(Project No. 106112013CDJZR180013) and the Postdoctoral Science
Foundation of Chongqing in China (Project No. Xm201324).
References
1. Cerquides J, Farinelli A, Meseguer P et al (2014) A tutorial on
optimization for multi-agent systems. Comput J 57(6):799–824
2. Leite A, Fabrı́cio E, Jean-Paul A (2014) Distributed Constraint
Optimization Problems: Review and perspectives. Expert Syst
Appl 41(11):5139–5157
3. Farinelli A, Rogers A, Jennings N (2013) Agent-based decentralised coordination for sensor networks using the max-sum
algorithm. Auton Agent Multi-Agent Syst 28(3):337–380
4. Hosseini S, Basir O (2013) Target to sensor allocation: A hierarchical dynamic Distributed Constraint Optimization approach.
Comput Commun 36(9):1024–1038
5. Zivan R, Yedidsion H, Okamoto S et al (2015) Distributed constraint optimization for teams of mobile sensing agents. Auton
Agent Multi-Agent Syst 29(3):495–536
6. Sultanik E, Modi P, Regli W (2007) On modeling multiagent task
scheduling as a distributed constraint optimization problem. In:
Proceedings of the 20th international joint conference on artificial
intelligence, pp 1531–1536
7. Enembreck F, André J (2012) Distributed constraint optimization
with MULBS: a case study on collaborative meeting scheduling. J
Netw Comput Appl 35(1):164–175
8. Petcu A, Faltings B (2008) Distributed constraint optimization
applications in power networks. Int J Innov Energy Syst Power
3(1):1–12
9. Kumar A, Faltings B, Petcu A (2009) Distributed constraint optimization with structured resource constraints. In: Proceedings
of the 8th international conference on autonomous agents and
multiagent systems, pp 923–930
10. Miller S, Ramchurn S, Rogers A (2012) Optimal decentralised
dispatch of embedded generation in the smart grid. In: Proceedings of the 11th international conference on autonomous agents
and multiagent systems, pp 281–288
11. Mandiau R, Vion J, Piechowiak S et al (2014) Multi-variable
distributed backtracking with sessions. Appl Intell 41(3):736–758
12. Yokoo M, Ishida T, Durfee E et al (1992) Distributed constraint satisfaction for formalizing distributed problem solving. In:
Proceedings of the 12th international conference on distributed
computing systems, pp 614–621
13. Fioretto F, Pontelli E, Yeoh W (2016) Distributed con-straint
optimization problems and applications: A survey. arXiv preprint
arXiv:1602.06347
14. Zivan R, Okamoto S, Peled H (2014) Explorative anytime
local search for distributed constraint optimization. Artif Intell
212(4):1–26
15. Hirayama K, Yokoo M (2005) The distributed breakout algorithms. Artif Intell 161(1):89–115
16. Okamoto S, Zivan R, Nahon A (2016) Distributed breakout:
Beyond satisfaction. In: Proceedings of the 25th international joint
conference on artificial intelligence pp 447–453
17. Zhang W, Wang G, Xing Z (2005) Distributed stochastic search
and distributed breakout: properties, comparison and applications
to constraint optimization problems in sensor networks. Artif
Intell 161(1):55–87
18. Maheswaran R, Pearce J, Tambe M (2006) A family of graphicalgame-based algorithms for distributed constraint optimization
problems. Coordination of large-scale multia-gent systems, pp 127–146
19. Chapman A, Rogers A, Jennings N et al (2011) A unifying
framework for iterative approximate best-response algorithms for
distributed constraint optimization problems. Knowl Eng Rev
26(4):411–444
20. Farinelli A, Rogers A, Petcu A et al (2008) Decentralised coordination of low-power embedded devices using the max-sum
algorithm. In: Proceedings of the 7th international conference on
autonomous agents and multiagent systems, pp 639–646
21. Rogers A, Farinelli A, Stranders R et al (2011) Bounded approximate decentralised coordination via the max-sum algorithm. Artif
Intell 175(2):730–759
22. Rollon E, Larrosa J (2012) Improved bounded max-sum for distributed constraint optimization. Principles and Practice of Constraint Programming of the series Lecture Notes in Computer
Science, pp 624–632
23. Ottens B, Dimitrakakis C, Faltings B (2012) DUCT: An upper
confidence bound approach to distributed constraint optimization
problems. In: Proceedings of the 11th international conference on
autonomous agents and multiagent systems, pp 528–534
24. Nguyen DT, Yeoh W, Lau HC (2013) Distributed Gibbs: A
memory-bounded sampling-based DCOP algorithm. In: Proceedings of the 12th international conference on autonomous agents
and multiagent systems, pp 167–174
25. Fiorretto F, Campeotto F, Fiorretto L et al (2014) GD-Gibbs:
A GPU-based Sampling Algorithm for Solving Distributed Constraint Optimization Problems. In: Proceedings of the 13th international conference on autonomous agents and multiagent systems,
pp 1339–1340
26. Mailler R, Lesser V (2004) Solving distributed constraint optimization problems using cooperative mediation. In: Proceedings
of the third international joint conference on autonomous agents
and multiagent systems, pp 438–445
27. Grinshpoun T, Meisels A (2008) Completeness and performance
of the APO algorithm. J Artif Intell Res 33:223–258
28. Hirayama K, Yokoo M (1997) Distributed partial constraint satisfaction problem. Principles and Practice of Constraint Programming, pp 222–236
29. Gershman A, Meisels A, Zivan R (2009) Asynchronous forward
bounding. J Artif Intell Res 34:25–46
30. Netzer A, Grubshtein A, Meisels A (2012) Concurrent forward
bounding for distributed constraint optimization problems. Artif
Intell 193:186–216
An improved DPOP algorithm based on breadth first search pseudo-tree...
31. Modi PJ, Shen WM, Tambe M et al (2005) ADOPT: Asynchronous Distributed constraint optimization with quality guarantees. Artif Intell 161(1):149–180
32. Silaghi M, Yokoo M (2006) Nogood based asynchronous distributed
optimization (adopt-ng). In: Proceedings of the 5th international conference on autonomous agents and multiagent systems,pp 1389--396
33. Silaghi M, Yokoo M (2009) Adopt-ing: unifying asynchronous
distributed optimization with asynchronous backtracking. Auton
Agent Multi-Agent Syst 19(2):89–123
34. Yeoh W, Felner A, Koenig S (2010) BnB-ADOPT: An asynchronous branch-and-bound DCOP algorithm. Journal of Artificial Intelligence Research, pp 85–133
35. Gutierrez P, Meseguer P (2012) Improving bnb-ADOPT+ -AC. In:
Proceedings of the 11th international conference on autonomous
agents and multiagent systems, pp 273–280
36. Gutierrez P, Lee JHM, Lei KM et al (2013) Maintaining Soft Arc
Consistencies in bnb-ADOPT+ during Search. In: Principles and
practice of constraint programming of the series lecture notes in
computer science, pp 365–380
37. Petcu A, Faltings B (2005) A scalable method for multiagent constraint optimization. In: Proceedings of the 19th international joint
conference on artificial intelligence, pp 266–271
38. Petcu A, Faltings B (2006) ODPOP: An algorithm for open
distributed constraint optimization. In: Proceedings of AAAI conference on artificial intelligence, pp 703–708
39. Petcu A, Faltings B (2007) MB-DPOP: A new Memory-Bounded
algorithm for distributed optimization. In: Proceedings of the 20th
international joint conference on artificial intelligence, pp 1452–
1457
40. Vinyals M, Rodrı́guez-aguilar JA, Cerquides J (2009) Generalizing DPOP: Action-GDL, a new complete algorithm for DCOPs.
In: Proceedings of the 8th international conference on autonomous
agents and multiagent systems, pp 1239–1240
41. Brito I, Meseguer P (2010) Improving DPOP with function filtering. In: Proceedings of the 9th international conference on
autonomous agents and multiagent systems pp 141–158
42. Fioretto F, Le T, Yeoh W et al (2014) Improving DPOP with
branch consistency for solving distributed constraint optimization
problems Principles and Practice of Constraint Programming of
the series Lecture Notes in Computer Science, pp 307–323
43. Atlas J, Keith D (2007) A complete distributed constraint optimization method for non-traditional pseudotree arrangements.
In: Proceedings of the 6th international joint conference on
autonomous agents and multiagent systems, pp 741–748
44. Chen Z, Wang L, He Z et al (2015) Analysis of complete
DCOP algorithms’ communication structures. J Comput Inf Syst
11(8):2971–2979
45. Petcu A (2007) A class of algorithms for distributed constraint
optimization. Ecole Polytechnique Federale de Lausanne (EPFL),
Switzerland
46. Leaute T, Faltings B (2013) Protecting privacy through distributed
computation in multi-agent decision making. J Artif Intell Res
47(4):649–695
47. Dechter R (2003) Constraint processing. Morgan Kaufmann
48. Brito I, Meseguer P (2010) Cluster tree elimination for distributed constraint optimization with quality guarantees. Fund Inf
102(3):263–286
49. Hogg T, Huberman BA, Williams C (1996) Phase transitions and
the search problem. Artif Intell 81:115
Ziyu Chen received her M.Sc.
and Ph.D. degrees in 2002
and 2009 in computer science from Chongqing University, Chongqing, China. She
is currently a senior lecturer
in the College of Computer
Science, Chongqing University. Her main research interests include distributed artificial intelligence and machine
learning.
Zhen He received his BS
degree in computer science
and technology at Chongqing
University in 2013, and he is
currently working toward the
M.Sc. degree in computer science at Chongqing University.
Chen He received his BS
degree in mathematics and
applied mathematics at Hunan
University of Science and
Engineering in 2013, and he is
currently working toward the
M.Sc. degree in computer science at Chongqing University.