Angelo Furfaro

An Agent Infrastructure over HLA for Distributed Simulation of Reconfigurable Systems and its Application to UAV Coordination

This paper proposes an agent infrastructure (Theatre) centered on Java for distributed simulations over High-Level Architecture/RunTime Infrastructure (HLA/RTI). The architecture rests on actors (agents) as the basic building blocks. Actors have a public message interface and encapsulate a state of local variables and a behavior patterned as a finite state machine. Actors interact with one another by asynchronous message passing. At the system level, theatres are used as the execution platforms for actors. Theatres naturally map on to HLA federates. Actors can migrate between theatres for load-balancing concerns, or in response to (re)configuration operations of dynamic structure systems. The paper introduces Theatre and demonstrates its application to a complex simulation model based on unmanned aerial vehicles (UAVs). The case study is an open agent-based distributed model where mobile agents follow communication patterns established at runtime.

Modelling and simulation of complex manufacturing systems using statechart-based actors

Abstract This paper describes a multi-agent architecture based on the actors computational model, for the distributed simulation of discrete event systems whose entities have a complex dynamic behaviour. Complexity is dealt with by exploiting statechart-based actors which constitute the basic building blocks of a model. Actors are lightweight reactive autonomous agents that communicate to one another by asynchronous message passing. The thread-less character of actors saves memory space and fosters efficient execution. The behaviour of actors is specified through “distilled statecharts” that enable hierarchical and modular specifications. Distributed simulation is achieved by partitioning a system model among a set of logical processes (theatres). Timing management and inter-theatre communications rest in a case on the High Level Architecture services. The paper illustrates the practical application of the proposed modelling and simulation methodology by specifying and analysing a complex manufacturing system.

Exploiting agents for modelling and simulation of coverage control protocols in large sensor networks

A sensor network is composed of low-cost, low-power nodes densely deployable over a (possibly in-hospitable) territory in order to monitor the state of the environment, e.g. temperature, sound, radiation and so forth. Sensors have the ability to self-organize into an interconnected network and to cooperate for collecting, aggregating and disseminating information to end users. Major challenges in dealing with sensor networks are the strong limitations imposed by finite onboard power capacity. This paper proposes a lightweight actor infrastructure that is well-suited to modelling and simulation of complex sensor networks and, more in general, of multi-agent systems. This infrastructure is exploited for designing and implementing an efficient actor-based distributed simulation model for studying specific aspects of large wireless sensor networks. The paper proposes and compares the performances of two protocols for the coverage control problem that achieve their objective as an emergent property. In particular, one of the two protocols adopts a novel approach based on an evolutionary game. Distributed simulation of the achieved actor-based models is characterized by good execution performances witnessed by reported experimental results.

MADAMS: A software architecture for the management of networked measurement services

MADAMS (Management Architecture for Distributed meAsureMent Services) is a novel service-based software framework designed for publishing, retrieving, configuring, setting up, monitoring and executing distributed measurement services over the Internet. The basic building block is the measurement service, i.e. a software object properly configured and made remote accessible across a network. A measurement service corresponds either to a single (virtual or physical) instrument, or to a collection of measurement services abstracting a test method. Service attributes include the graphical interface which supports user interactions. MADAMS is especially tuned to: (i) defining a common way to manage and use distributed measurement services, (ii) introducing a data-exchange layer for inter-instrument communications, (iii) exploiting a design pattern which separates definition of service functionalities from distribution concerns. This paper introduces MADAMS, outlines its current implementation which depends on Java/Jini, and shows its application to a demand monitoring-control measurement system.

A service-based architecture for dynamically reconfigurable workflows

In the last few years, business process management systems have been employed for handling information systems of ever increasing complexity. As a consequence, the adoption of modelling languages enabling smooth and seamless transitions among the various phases of the process lifecycle, the ability of exploiting coordination schema over distributed execution contexts and the support for dynamic evolution and reconfiguration have become software engineering issues of great importance. This paper proposes the use of PN-Engine, a decentralized Petri nets execution engine, as a business process enactment engine. PN-Engine, which is based on the Jini service architecture, supports the decentralized execution of process models specified as Petri nets (PNs) enhanced with modular constructs and offers suitable mechanisms for dealing with the aforementioned design issues. PN-Engine allows to deploy and enact a new version of an existing process model without requiring the stopping/removal of older instances that are still running. The paper presents a novel approach enabling a decentralized migration procedure where concurrent portions of older instances migrate asynchronously to the new process model. Advantages of the proposed approach are demonstrated by means of an example concerning a workflow for a wine-production process.

Multimedia synchronization based on aspect oriented programming

Abstract This paper describes an approach centered on aspect oriented programming (AOP) for controlling the synchronization of distributed multimedia systems. AOP fosters separation of concerns between application objects and synchronization aspects, which naturally arise as cross-cutting concerns. Aspect modularization and encapsulation contribute to re-usability and maintenance of both application components and control mechanisms. The paper illustrates the use of AOP technologies through the construction and evaluation of a real-time quality of service (QoS) filter regulating the QoS at the receiver-side of a multimedia system over the Internet. Aspects are programmed using AspectJ. Particular aspects are exploited for testing the temporal behavior of the synchronized system. Execution experiments make use of Java Media Framework which provides the presentation system.

Towards Security as a Service (SecaaS): On the modeling of Security Services for Cloud Computing

The security of software services accessible via the Internet has always been a crosscutting non-functional requirement of uttermost importance. The recent advent of the Cloud Computing paradigm and its wide diffusion has given birth to new challenges towards the securing of existing Cloud services, by properly accounting the issues related to their delivery models and their usage patterns, and has opened the way to the new concept of Security as a Service(SecaaS), i.e. the ability of developing reusable software services which can be composed with standard Cloud services in order to offer them the suitable security features. In this context, there is a strong need for methods and tools for the modeling of security concerns, as well as for evaluation techniques, for supporting both the comparison of different design choices and the analysis of their impact on the behavior of new services before their actual realization. This paper proposes a meta-model for supporting the modeling of Security Services in a Cloud Computing environment as well as an approach for guiding the identification and the integration of security services within the standard Cloud delivery models. The proposal is exemplified through a case study.

Model checking time-dependent system specifications using Time Stream Petri Nets and Uppaal

Abstract This paper describes an approach to modeling and analysis of time-dependent system specifications which is based on the Time Stream Petri Nets (TSPNs) formalism. The work argues that although TSPNs were originally proposed for modeling multimedia/hypermedia systems, they are well suited for expressing timing constraints in general time-dependent systems. The approach is assisted by some developed tools based on model checking in terms of U ppaal timed automata, which permit behavioural analysis and in particular schedulability analysis of task executions in real-time specifications. Property analysis rests on the construction of a (hopefully finite) zone state graph of a TSPN model and its efficient traversal by U ppaal verifier, which in turn represents an effective approach for dealing with infinite computations in a compact way. The paper introduces the TSPN formalism and focuses on the implemented structural translation onto U ppaal which is assisted by a library of reusable template processes. The modeling/analysis techniques are demonstrated by two examples. The first example deals with project management, i.e. the exhaustive analysis of general CPM/PERT project models where an activity duration is expressed by a time interval. The second example is related to a thoroughly analysis of the temporal behaviour of a complex embedded real-time system with timing constraints. An indication of on-going and future work is, finally, given in the conclusions. Soundness of the structural translation is shown by a formal proof reported in appendix.

HLA_ACTOR_REPAST: An approach to distributing RePast models for high-performance simulations☆

Abstract RePast is a popular agent toolkit with proven capabilities to fulfil the modelling challenges of large multi-agent systems (MASs). The toolkit, though, is normally used on a standalone workstation and therefore its practical use can be constrained (in space and time) by the limited available computing resources. This paper proposes an original approach – HLA_ACTOR_REPAST – aimed to distributing RePast models for high-performance simulation of complex scalable models. Novel in HLA_ACTOR_REPAST is an exploitation of a lean actor infrastructure implemented in Java. Actors bring to RePast agents such features as migration, location-transparent naming, efficient communications, and a control-centric framework. Actors can be orchestrated by an in-the-large custom control structure which is in charge of ensuring the necessary message causality constraints. Distribution and time management concerns depend on the IEEE standard HLA middleware. The paper first discusses details of the software engineering process underlying the development of HLA_ACTOR_REPAST. The mapping techniques, assisted by Java text annotations and aspect-oriented programming, try to minimize “code intrusions” in the original model and favour model transparency. The paper then furnishes some experimental data which witness the good performance results achieved by applying HLA_ACTOR_REPAST to a distributed version of a classic MAS benchmark model.

A development methodology for embedded systems based on RT-DEVS

This work is concerned with modelling, analysis and implementation of embedded control systems using RT-DEVS, i.e. a specialization of classic discrete event system specification (DEVS) for real-time. RT-DEVS favours model continuity, i.e. the possibility of using the same model for property analysis (by simulation or model checking) and for real time execution. Special case tools are reported in the literature for RT-DEVS model analysis and design. In this work, temporal analysis of a model exploits a translation in Uppaal timed automata for exhaustive verification. For large models a simulator was realized in Java which directly stems from RT-DEVS operational semantics. The same concerns are at the basis of a real-time executive. The paper describes the proposed RT-DEVS development methodology and clarifies its implementation status. The approach is demonstrated by applying it to an embedded system example which is analyzed through model checking and implemented in Java. Finally, research directions which deserve further work are indicated.