Fernando dos Santos

RoboCup Rescue as multiagent task allocation among teams: experiments with task interdependencies

This paper addresses distributed task allocation among teams of agents in a RoboCup Rescue scenario. We are primarily concerned with testing different mechanisms that formalize issues underlying implicit coordination among teams of agents. These mechanisms are developed, implemented, and evaluated using two algorithms: Swarm-GAP and LA-DCOP. The latter bases task allocation on a comparison between an agent’s capability to perform a task and the capability demanded by this task. Swarm-GAP is a probabilistic approach in which an agent selects a task using a model inspired by task allocation among social insects. Both algorithms were also compared to another one that allocates tasks in a greedy way. Departing from previous works that tackle task allocation in the rescue scenario only among fire brigades, here we consider the various actors in the RoboCup Rescue, a step forward in the direction of realizing the concept of extreme teams. Tasks are allocated to teams of agents without explicit negotiation and using only local information. Our results show that the performance of Swarm-GAP and LA-DCOP are similar and that they outperform a greedy strategy. Also, it is possible to see that using more sophisticated mechanisms for task selection does pay off in terms of score.

Optimizing Preferences within Groups: A Case Study on Travel Recommendation

This work describes a multiagent recommender system where agents work on behalf of members of a group of customers, trying to reach the best recommendation for the whole group. The goal is to model the group recommendation as a distributed constraint optimization problem, taking customer preferences into account and searching for the best solution. Experimental results show that this approach can be sucessfully applied to propose recommendations to a group of users.

An ant based algorithm for task allocation in large-scale and dynamic multiagent scenarios

This paper addresses the problem of multiagent task allocation in extreme teams. An extreme team is composed by a large number of agents with overlapping functionality operating in dynamic environments with possible inter-task constraints. We present eXtreme-Ants, an approximate algorithm for task allocation in extreme teams. The algorithm is inspired by the division of labor in social insects and in the process of recruitment for cooperative transport observed in ant colonies. Division of labor offers fast and efficient decision-making, while the recruitment ensures the allocation of tasks that require simultaneous execution. We compare eXtreme-Ants with two other algorithms for task allocation in extreme teams and we show that it achieves balanced efficiency regarding quality of the solution, communication, and computational effort.

Performance and energy efficiency analysis of HPC physics simulation applications in a cluster of ARM processors

We analyze the feasibility and energy efficiency of using an unconventional cluster of low‐power Advanced RISC Machines processors to execute two scientific parallel applications. For this purpose, we have selected two applications that present high computational and communication cost: the Ondes3D that simulates geophysical events, and the all‐pairs N‐Body that simulates astrophysical events. We compare and discuss the impact of different compilation directives and processor frequency and how they interfere in Time‐to‐Solution and Energy‐to‐Solution. Our results demonstrate that by correctly tuning the application at compile time, for the Advanced RISC Machines architecture, we can considerably reduce the execution time and the energy spent by computing simulations. Furthermore, we observe reductions of up to 54.14% in Time‐to‐Solution and gains of up to 53.65% in Energy‐to‐Solution with two cores. Additionally, we consider the impact of two processor frequency governors on these metrics. Results indicate that the powersave governor presents a smaller instantaneous power consumption. However, it spends more time executing tasks, increasing the energy needed to achieve the solution. Finally, we correlate the energy consumption with the execution time in the experimental results using Pareto. These findings suggest that it is possible to explore low‐powered clusters for high‐performance computing applications by tuning application and hardware configuration to achieve energy efficiency. Copyright

Supporting the Development of Agent-Based Simulations: A DSL for Environment Modeling

Domain-specific languages are a means of speeding up and easing software system development. Agent-based simulations are simulation systems in which autonomous entities, namely agents, are developed in order to reproduce, analyze, or predict a phenomenon under study. Despite its potential, available alternatives for agent-based modeling and simulation benefit from recurrent domain-related concepts, such as domain concerns and standard strategies for creating and initializing entities, in a limited way. Such elements, when represented in models, can potentially ease the modeling and simulation. We propose a domain-specific modeling language that provides ready-to-use concepts for these recurrent agent-based simulation elements with a modularized notation.The language is targeted to the agent-based modeling and simulation domain and is currently focused on modeling the simulated environment. A user study provides evidence that our language decreases the time needed to understand agent-based simulations.

Evaluation and Mitigation of Soft-Errors in Neural Network-Based Object Detection in Three GPU Architectures

In this paper, we evaluate the reliability of the You Only Look Once (YOLO) object detection framework. We have exposed to controlled neutron beams GPUs designed with three different architectures (Kepler, Maxwell, and Pascal) running Darknet, a Convolutional Neural Network for automotive applications, detecting objects in both Caltech and Visual Object Classes data sets. By analyzing the neural network corrupted output, we can distinguish between tolerable errors and critical errors, i.e., errors that could impact on real-time system execution.Additionally, we propose an Algorithm-Based Fault-Tolerance (ABFT) strategy to apply to the matrix multiplication kernels of neural networks able to detect and correct 50% to 60% of radiation induced corruptions. We experimentally validate our hardening solution and compare its efficiency and efficacy with the available ECC.

Model-driven agent-based simulation development: A modeling language and empirical evaluation in the adaptive traffic signal control domain

Abstract Model-driven development (MDD) is an approach for supporting the development of software systems, in which high-level modeling artifacts drive the production of time and effort-consuming low-level artifacts, such as the source code. Previous studies of the MDD effectiveness showed that it significantly increases development productivity, because the development effort is focused on the business domain rather than technical issues. However, MDD was exploited in the context of agent-based development in a limited way, and most of the existing proposals demonstrated the effectiveness of using MDD in this context by argumentation or examples, lacking disciplined empirical analyses. In this paper, we explore the use of MDD for agent-based modeling and simulation in the adaptive traffic signal control (ATSC) domain, in which autonomous agents are in charge of managing traffic light indicators to optimize traffic flow. We propose an MDD approach, composed of a modeling language and model-to-code transformations for producing runnable simulations automatically. In order to analyze the productivity gains of our MDD approach, we compared the amount of design and implementation artifacts produced using our approach and traditional simulation platforms. Results indicate that our approach reduces the workload to develop agent-based simulations in the ATSC domain.

Analyzing the criticality of transient faults-induced SDCS on GPU applications

In this paper we compare the soft-error sensitivity of parallel applications on modern Graphics Processing Units (GPUs) obtained through architectural-level fault injections and high-energy particle beam radiation experiments. Fault-injection and beam experiments provide different information and uses different transient-fault sensitivity metrics, which are hard to combine. In this paper we show how correlating beam and fault-injection data can provide a deeper understanding of the behavior of GPUs in the occurrence of transient faults. In particular, we demonstrate that commonly used architecture-level fault models (and fast injection tools) can be used to identify critical kernels and to associate some experimentally observed output errors with their causes. Additionally, we show how register file and instruction-level injections can be used to evaluate ECC efficiency in reducing the radiation-induced error rate.