Abstract — A large class of problems in multiagent systems can be solved by distributed constraint optimization (DCOP). Several algorithms have been created to solve these problems, however, no extensive evaluation of current DCOP algorithms on live networks exists in the literature. This paper uses DCOPolis—a framework for comparing and deploying DCOP software in heterogeneous environments—to contribute an analysis of two state-of-the-art DCOP algorithms solving a number of different problem types. Then, we use this empirical validation to evaluate the use of both cycle-based runtime and concurrent constraint checks. I.

Abstract. Distributed constraint reasoning (DCR) has recently generated much interest due to its ability to solve many real world problems without centralizing all of the information. Many DCR algorithms, however, are prone to failure if even a single agent fails, creating a situation with not only a central point of failure, but with n-points of failure! There are three main contributions of this work. First, we define the robust DCR problem space in terms of communications failures, agent failures and observability of failed agents. Then we describe two new types of algorithm modifications and show where they and other algorithms fit into this problem space. Finally, we analyze these algorithms and discuss what future work is needed in this area. 1

We propose a way to define the most expensive operation to be used in evaluations of complexity and efficiency for simulated distributed constraint reasoning (DCR) algorithms. We also report experiments showing that the cost associated with a constraint check, even within the same algorithm, depends on the problem size. The DCR research has seen heated debate regarding the correct way to evaluate efficiency of simulated algorithms. DCR has to accommodate two established practices coming from very different fields: distributed computing and constraint reasoning. The efficiency of distributed algorithms is typically evaluated in terms of the network load and overall computation time, while many (synchronous) algorithms are evaluated in terms of the number of rounds that they require. Constraint reasoning research evaluates efficiency in terms of constraint checks and visited search-tree nodes. We argue that an algorithm has to be evaluated from the point of view of specific operating points, namely of possible or targeted application scenarios. We then show how to report efficiency for a given operating point based on simulation. Additionally, new experiments we report here show the fact that the cost of a constraint check varies with the size of the problem, and we discuss the implications of this phenomenon.

Here we show how to ensure a constant cost for the computation-unit in graphs depicting the number of (sequential) computation-units at different problem sizes. This is needed for a meaningful evaluation of scalability and efficiency, specially for distributed computations where it is an assumption of the measurement. We report empirical evaluation with ADOPT revealing that the computation cost associated with a constraint check (commonly used – and assumed constant – in ENCCCs evaluations) actually varies with the problem size, by orders of magnitude. This flaw makes it difficult to interpret such skewed graphs. We searched for methods to fix this problem and report a solution. We started from the hypothesis that the variation of the cost associated with a constraint-check is due to the fact that the most inner cycles of some common constraint solvers like ADOPT do not consist of constraint checks, but of processing search contexts (i.e., other data structures). We therefore propose computation-units based on a basket of weighted constraint-checks and context processing operations. Experimental evaluation shows that we obtain a constant cost of the computation-unit, proving the correctness of our hypothesis and offering a better methodology for efficiency and scalability evaluation.

Modern distributed systems are under threat from a surprising source: the willful failure by their own users. These failures are not due to chance, nor are they maliciously motivated. Rather, these failures are rationally motivated. Despite evidence of rationally motivated failure in real systems, there has been surprisingly little work on rational behavior in the context of system fault tolerance. This thesis describes a form of defensive design used to build distributed systems that are robust to rationally motivated failure. Our approach proactively prevents rationally motivated failure by addressing the underlying failure cause. This approach differs markedly from traditional distributed system techniques of dealing with failure, which reactively seek to recover from an expressed failure. This thesis makes four main contributions toward understanding and designing for rationally motivated failure. This thesis... •...formalizes faithfulness as the metric by which to judge an algorithm’s tolerance to rationally motivated failure. A proof of specification faithfulness is a certification that

Abstract Scheduling meetings among agents can be represented as a game- the Meetings Scheduling Game (MSG). In its simplest form, the two-person MSG is shown to have a price of anarchy (PoA) which is bounded by 0.5. The paper defines the Cost of Cooperation (CoC) for meetings scheduling games, with respect to different global objective functions. For an “egalitarian ” objective, that maximizes the minimal gain among all participating agents, the CoC is non positive for all agents. This makes the MSG a cooperation game. The concepts are defined and examples are given within the context of the MSG. A game may be revised by adding a mediator (or with a slight change of its mechanism) so that it behaves as a cooperation game. Thus, rational participants can cooperate (by taking part in a distributed optimization protocol) and receive a payoff which will be at least as high as the worst gain expected by a game theoretic equilibrium point. 1

Distributed peer-to-peer file-sharing systems rely on voluntary contribution of resources (files and bandwidth) from the individual peers. However, individual rationality and self-interest result in free-riding behavior at the expense of collective welfare. Empirical studies have shown this free-riding to be prevalent. To overcome this, filesharing systems have implemented various mechanisms to improve the sharing of files and bandwidth, with varying results. Although most systems show improvement in cooperation from the peers through these mechanisms, theoretical analysis has shown all these mechanisms are still susceptible to manipulation from peers that improve their own utility at the expense of others. Similar problems arise in distributed systems in general. Recently Distributed Algorithmic Mechanism Design (DAMD), an application of Game Theory and Economics in distributed computing, has been proposed as a method to offer incentives in distributed systems, motivating peers to cooperate with the system. In this survey, we give an overview of DAMD and investigate how it can be applied to file-sharing systems. Additionally, we present an overview of recent literature

Abstract not found

We describe here a structured system for distributed mechanism design appropriate for the Internet applications. In our approach the players dynamically form a network in which they know neither their neighbours nor the size of the network and interact to jointly take decisions. The only assumption concerning the underlying communication layer is that for each pair of processes there is a path of neighbours connecting them. This allows us to deal with arbitrary network topologies. We also discuss the implementation of this system which consists of a sequence of layers. The lower layers deal with the operations relevant for distributed computing only, while the upper layers are concerned only with communication among players, including broadcasting and multicasting, and distributed decision making. This yields a highly flexible distributed system whose specific applications are realized as instances of its top layer. This design is implemented in Java. The system supports fault-tolerance and can be augmented by a provision for distributed policing the purpose of which is to exclude ‘dishonest ’ players. Also, it can be used for repeated creation of dynamically formed networks of players interested in a joint decision making implemented by means of a tax-based mechanism. We illustrate its flexibility by discussing a number of implemented examples.