Raffaele Quitadamo

Autonomic communication services: a new challenge for software agents

The continuous growth in ubiquitous and mobile network connectivity, together with the increasing number of networked devices populating our everyday environments, call for a deep rethinking of traditional communication and service architectures. The emerging area of autonomic communication addresses such challenging issues by trying to identify novel flexible network architectures, and by conceiving novel conceptual and practical tools for the design, development, and execution of “autonomic” (i.e., self-organizing, self-adaptive and context-aware) communication services. In this paper, after having introduced the general concepts behind autonomic communication and autonomic communication services, we analyze the key issue of defining suitable “component” models for autonomic communication services, and discuss the strict relation between such models and agent models. On this basis, we survey and compare different approaches, and eventually try to synthesize the key desirable characteristics that one should expect from a general-purpose component model for autonomic communication services. The key message we will try to deliver is that current research in software agents and multi-agent systems have the potential for playing a major role in inspiring and driving the identification of such a model, and more in general for influencing and advancing the whole area of autonomic communication.

An Adaptive and Efficient Peer-to-Peer Service-Oriented Architecture for MANET Environments with Agile Computing

Realizing adaptive and efficient peer-to-peer service-oriented architectures for MANET environments is a challenging problem. In particular, robust and efficient service discovery and service migration are critical in the constantly changing and bandwidth limited MANET environments. In these scenarios, service migration lays the foundation for self-adaptive architectures. This paper describes the agile computing approach to peer-to-peer service discovery and service migration and provides a performance evaluation of these functions in the context of the agile computing middleware. The experimental results presented in the paper show that applications built on top of the agile computing middleware are capable of opportunistically exploiting transient computing resources in the MANET environment.

Enabling Java mobile computing on the IBM Jikes research virtual machine

Todays complex applications must face the distribution of data and code among different network nodes. Java is a wide-spread language that allows developers to build complex software, even distributed, but it cannot handle the migration of computations (i.e. threads), due to intrinsic limitations of many traditional JVMs. After analyzing the approaches in literature, this paper presents our research work on the IBM Jikes Research Virtual Machine: exploiting some of its innovative VM techniques, we implemented an extension of its scheduler that allows applications to easily capture the state of a running thread and makes it possible to restore it elsewhere (i.e. on a different hardware or software architecture, but still with a version of JikesRVM installed). Our thread serialization mechanism provides support for both proactive and reactive migration of single- and multi-threaded Java applications. With respect to previous approaches, we implemented the mobility framework without recompiling a previous JVM source code, but simply extending its functionalities with a full Java package.

Mobile JikesRVM: A framework to support transparent Java thread migration

Todays complex applications must face the distribution of data and code among different network nodes. Computation in distributed contexts is demanding increasingly powerful languages and execution environments, able to provide programmers with appropriate abstractions and tools. Java is a wide-spread language that allows developers to build complex software, even distributed, but it cannot handle the migration of computations (i.e. threads), due to intrinsic limitations of many traditional JVMs. After analyzing the approaches in the literature, this paper presents our thread migration framework (called Mobile JikesRVM), implemented on top of the IBM Jikes Research Virtual Machine (RVM): exploiting some of the innovative techniques in the JikesRVM, we implemented an extension of its scheduler that allows applications to easily capture the state of a running thread and makes it possible to restore it elsewhere (i.e. on a different hardware architecture or operating system), but still with a version of the framework installed). Our thread serialization mechanism provides support for both proactive and reactive migration, available also for multi-threaded Java applications, and tools to deal with the problems of resource relocation management. With respect to previous approaches, we implemented Mobile JikesRVM without recompiling its JVM (Java Virtual Machine) source code, but simply extending JikesRVM functionalities with a full Java package to be imported when thread migration is needed.

Supporting a Territorial Emergency Scenario with Services and Agents: A Case Study Comparison

Territorial emergency scenarios imply several interesting issues with regard to the development of distributed applications and systems. From complexity to dynamism and unpredictability, these issues must be faced with appropriate paradigms and tools, which must grant flexibility and adaptability. In this paper, we apply concepts and abstractions from the service-oriented computing paradigm and from software agents to support the management of territorial emergencies. Rather than making a theoretical comparison, we analyze a proper case study and show where the advantages and drawbacks of the two paradigms are more evident. From these considerations, we conclude that agents better suit this scenario, but need still to learn from the emerging paradigm of SOC

The PIM: an innovative robot coordination model based on Java thread migration

There is a growing demand to apply multi-robot systems to address many current problems ranging from search and rescue to distributed surveillance to coordination of small satellites in space. Solving these problems effectively requires that teams of robots coordinate effectively. Many of the algorithms for coordination are based on the so-called centralized paradigm, where a central controlling authority is responsible for coordinating the entire team of robots. Unfortunately, centralized approaches often fall short when dealing with rapidly changing situations, unreliability of communications, and failure of robots, especially in hostile environments. Distributed approaches, in an effort to address such issues, tend to introduce complex negotiation or market-based strategies for distributed task execution, sometimes resulting in cumbersome programming models and suboptimal solutions. In this paper, we introduce the readers to the PIM (Process Integrated Mechanism) approach to multi-robot coordination grounded in research on Java thread migration. The core idea of the PIM is to retain the perspective of the single controlling authority but abandon the notion that it must have a fixed location within the system. Instead, the single coordinating thread is rapidly moved among the team members. The PIM leverages on Java thread mobility to preserve the optimality of the centralized approach, while effectively addressing most of its weaknesses (e.g. sluggish response to dynamic conditions, communication difficulties, and a single point of failure). A prototype implementation of such a model is presented on top of the Mobile JikesRVM framework for Java thread migration, along with some preliminary performance results.

Strong agent mobility for aglets based on the IBM JikesRVM

Mobility enables agents to migrate among several hosts, becoming active entities of networks. Java is today one of the most exploited languages to build mobile agent systems, thanks to its object-oriented support, portability and network facilities. Nevertheless, Java does not support strong mobility, i.e., the mobility of threads along with their execution state; thus developers cannot develop agents as real mobile entities. This paper reports our approach for Java thread strong migration, based on the IBM Jikes Research Virtual Machine, presenting our results and proposing an enrichment of the Aglets mobile agent platform in order to exploit strong agent mobility.

Comparing Service-Oriented Computing and Agent-Oriented Programming towards integration

Service Oriented Computing (SOC) and Agent Oriented Programming (AOP) are two promising paradigms exploited in the development of distributed systems. In fact, even if starting from different conceptual abstractions, both paradigms try to face unpredictability and complexity in wide and open distributed scenarios. In this context, they exhibit both strengths and weaknesses. The aim of this paper is to propose a comparison between these two paradigms, performed with regard to some issues peculiar of the development of distributed systems that developers must face: space decomposition, interactions among distributed components, reusability/customization, interoperability and security. Of course the purpose of this paper is not to define the “best paradigm”, rather the paper aims at providing developers with critical knowledge about advantages and limitations of the two paradigms. Finally, the need for a smart integration of the two paradigms is pointed out, which will lead to exploit the advantages of both in a joint way. Therefore, we briefly survey some proposals in this direction and report some considerations about them.

Tackling complexity of distributed systems: Towards an integration of service-oriented computing and agent-oriented programming

The development of distributed systems poses different issues that developers must carefully take into consideration. Web services and (mobile) agents are two promising paradigms that are increasingly exploited in distributed systems design: they both try, albeit with very different conceptual abstractions, to govern unpredictability and complexity in wide-open distributed scenarios. In this paper, we compare the two approaches with regard to different aspects. Our aim is to provide developers with critical knowledge about the advantages of the two paradigms, stressing also the need for an intelligent integration of the two approaches.

Collaboration-Driven Role Suggestion for Agents

Thanks to their capabilities of being autonomous, proactive and reactive, software agents are today a powerful paradigm to develop complex systems, which typically involve several interacting agents. In those systems, interactions must be carefully designed and must be smartly managed at run-time. A good paradigm to deal with interaction and run-time situations is represented by the concept of role, which has been exploited in different approaches. In this paper we investigate the adoption of overhearing, a paradigm to deal with cooperating agents, in order to improve the adoption of roles. The approach presented here can be adopted to support the agent decisions regarding the role to assume and its use