Journal of Systems Architecture 54 (2008) 877–882

Contents lists available at ScienceDirect

Journal of Systems Architecture

journal homepage: www.elsevier .com/locate /sysarc

An agent based platform for task distribution in virtual environments

Antonio Coronato a,*, Giuseppe De Pietro a, Luigi Gallo a,b

a ICAR-CNR, Via Castellino 111, 80131 Napoli, Italyb Universitá degli Studi di Napoli ‘‘Parthenope”, Via Acton 38, 80133 Napoli, Italy

a r t i c l e i n f o

Article history:Received 4 July 2007Received in revised form 14 November 2007Accepted 10 January 2008Available online 14 March 2008

Keywords:Multi-agent systemTask distribution and executionContext-aware middleware

1383-7621/$ - see front matter � 2008 Elsevier B.V. Adoi:10.1016/j.sysarc.2008.01.011

* Corresponding author.E-mail addresses: coronato.a@na.icar.cnr.it (A. Coro

it (G. De Pietro), luigi.gallo@uniparthenope.it, gallo.l@

a b s t r a c t

This paper focuses on automatic mechanisms for task distribution and execution in virtual and mobileenvironments. In particular, the goal is the implementation of Utility Computing services that enableusers to submit their source code and to have their applications executed without concerning aboutresource allocation, task distribution, and load-balancing.The proposed solution consists in a distributed agent-based software infrastructure that grants a highlevel of transparency from the user point of view. As a matter of fact, accordingly with the Utility Com-puting model, the user has just to submit its tasks and their input parameters; after that, the softwareinfrastructure takes care of (1) encapsulating tasks in mobile agents; (2) distributing them in the virtualenvironment; (3) launching and controlling execution; (4) picking up results; and (5) handling comput-ing stations.Finally, it is important to note that the infrastructure is able to integrate both fixed and mobile hardwareresources to build a community of computing stations for task executions. As a consequence, such aninfrastructure can get useful computing power even from stations (mobile devices) that have always beenneglected by classic task execution platforms.

� 2008 Elsevier B.V. All rights reserved.

1. Introduction

Over the years, several computing models have been proposedin order to realize virtual environments with the aims of (i) sharingresources; (ii) providing pervasive access to services; and, (iii) real-izing collaborative environments. In particular, terms like GridComputing, Pervasive Computing, and Utility Computing have be-come of common use not only in the scientific and academic world,but also in business fields.

The Grid computing model has demonstrated to be an effectiveway to deal with very complex problems. The term ‘‘The Grid” isnow adopted to denote the virtualization of distributed computingand data resources such as processing, network bandwidth andstorage capacity to create a single system image, granting usersand applications seamless access to vast IT capabilities [1]. As a re-sult, Grids are geographically distributed environments, equippedwith shared heterogeneous services and resources accessible byusers and applications to solve complex computational problemsand to access to big storage spaces.

The goal for Pervasive computing is the development of environ-ments where highly heterogeneous hardware and software com-ponents can seamlessly and spontaneously interoperate, in order

ll rights reserved.

nato), depietro.g@na.icar.cnr.na.icar.cnr.it (L. Gallo).

to provide a variety of services to users independently of the spe-cific characteristics of the environment and of the client devices[2]. Therefore, mobile devices should come into the environmentin a natural way, as their owner moves, and transparently. Theowner will not have to carry out manual configuration operationsfor being able to approach the services and the resources, and theenvironment has to be able to self-adapt and self-configure in or-der to host incoming mobile devices.

On the other hand, Utility Computing aims at providing userswith computational power in a transparent manner, similarly tothe way in which electrical utilities supply power to their custom-ers. In this scenario, computing services are seen as ‘‘utilities” thatusers pay to access to, just as is in the case of electricity, gas, tele-communications and water [3,4].

With respect to the problem of providing users with facilitiesfor executing their programs, current applications offer access toresources but, are neither pervasive nor able to implement theUtility Computing vision. As a matter of fact, whenever a userwants to execute an own application, he has to (i) ask the environ-ment for resources; (ii) allocate tasks; (iii) launch and control exe-cutions; (iv) get results; and (v) release resources. This practice hasseveral limitations:

� user-environment interactions are very little transparent;� users have direct control of allocated resources – The user

requires (and sometimes locks) resources of the environment;

878 A. Coronato et al. / Journal of Systems Architecture 54 (2008) 877–882

� resources are handled in an insecure and inefficient way – Amalicious user could require a larger amount of resources withrespect the ones really needed or an inexpert user could under-estimate the resources really needed.

This work presents a software infrastructure that realizes a vir-tual environment, based on a Multi-Agent System (MAS), for en-abling users to directly submit tasks for execution. After havingbeen submitted, tasks are handled in a completely transparentway to users. In particular, they are encapsulated in mobile agents,which are allocated and executed by the environment. It is worthnoting that such mobile agents can also be allocated and executedon mobile devices, which become active resources for the grid, in acompletely transparent way. In addition a certain degree ofdependability has been conferred to the service in handling mobiletasks.

The rest of the paper is organized as follows. Section 2discusses some motivations, related work and contribution. Insection 3, a brief description of MiPeG architecture is reported.Section 4 describes the proposed solution. Section 5 presentssome preliminary results. Finally, Section 6 concludes thepaper.

2. Motivations and contributions

2.1. Motivations and related work

Our primary aim is to provide users with a service able toimplement the Utility Computing vision, that is providing themwith computational power in a transparent manner. In order toachieve this result, users must be able to allocate their tasks onavailable resources without the need of explicitly referring to aspecific distributed programming paradigm. Moreover, users havenot to worry about the management of resources, which have to befully handled by the environment.

In our approach we consider mobile, wireless devices as activeresources of the environment, rather than mere interface tools foraccessing services and system resources. Considering Metcalfe’slaw, which claims that usefulness of a network-based system pro-portionally grows with the square of the number of active nodes,and also considering that mobile devices capabilities have substan-tially be improved over the time, it can justifiably be stated thatmobile and wireless devices are now of interest for collaborativevirtual environments, not only as access devices, but also as activeresources [5].

Recently, some valuable efforts have been made in order tomake classic infrastructures able to support wireless technolo-gies and mobile devices. In particular, the paradigm of WirelessGrid has been proposed [6,7]. More recently, this paradigm hasevolved in the Pervasive Grid model [8], which again aims atmaking Grid environments able to integrate mobile devices,but in a pervasive way, that is seamlessly and transparently. Inaddition, services should be context-aware and somehow pro-active.

Many agent-based systems have been proposed in order to exe-cute code over distributed platform [10,11]. Among these, MAGDA[9] is most worth mentioning. MAGDA is a powerful framework forsupporting programming and execution of mobile agent based dis-tributed applications. Such a solution, by adopting a skeleton-likeapproach, hides to the programmer the difficulties of dealing withcommunication and coordination of mobile agents. Unlike MAGDA,in our system users: (i) have not to design balancing strategies thatare fully automated instead; (ii) can exploit mobile devices as ac-tive resources; (iii) have not to parallelize their sequential codein order to execute it.

2.2. Our contribution

Our contribution consists in a model and a software infrastruc-ture that enables users to distribute and execute tasks on a chang-ing group of mobile and fixed devices.

The proposed environment distinguishes from classic and wire-less ones for the following main characteristics:

� Transparent integration of mobile devices as active resources – Thisfeature requires the installation of lightweight software plug-in,which consists in an agent container, onboard the mobile device.After that, whenever the mobile device enters the environment,it becomes an active resource for the grid; in other words, theenvironment can allocate and execute tasks on it, in a com-pletely transparent way for its owner.

� Self-execution of applications – Users submit their own code andsome execution parameters. On the contrary, in classic environ-ments users require resources and then are fully in charge oflaunching execution, controlling it, picking up results andreleasing resources. Obviously, the possibility of submitting justthe code, not only ease the task for users, but also protect theenvironment from malicious and inexpert users.

� Reliable execution of tasks – Tasks are encapsulated in mobileagents that can be allocated by the environment both on fixedand mobile devices. Thanks to a cloning mechanism for agentsand a HeartBeat Monitor system (HBM) protocol for devicesand tasks, the environment is able to recover from several kindsof failures.

These features have been implemented by an application ser-vice, which has successively been integrated into a preexistentframework, named MiPeG: Middleware for Pervasive Grids [12].

3. Applicative scenario: MiPeG

MiPeG is a middleware for pervasive grid applications. It en-hances classic grid environments by providing mechanisms for:(i) integrating mobile devices in a pervasive way; (ii) providingcontext-awareness; and, (iii) handling mobile users’ sessions. Suchservices are OGSA compliant and are deployed as grid services inorder to be easily integrated in a typical grid environment.

MiPeG consists of the set of services shown in Fig. 1.It is based on the Globus Toolkit [16], which is the the-facto

standard platform for Grid applications. It also partly relies onthe JADE framework [14] to implement some mobile agent basedcomponents. It is important to note that MiPeG supports two maininteraction mechanisms: the SOAP messaging, for Web and GridServices applications, and a publish-subscribe model for more gen-eric, inter-component, asynchronous communications.

MiPeG basic services:

� Asynchronous Communication Broker – This component is incharge of dispatching asynchronous messages in the pervasivegrid. It implements the WS-BrokeredNotification specification.Moreover, it extends such a specification by classifying eventsand handling hierarchies of classes of events.

� Access & Location Service – This service provides network accessto mobile devices and locates them in the environment. Currentimplementation grants access and locates 802.11 WiFi enableddevices. It also locates RFID tagged objects [13]. Definitively, thisservice is in charge of communicating to the environment (i)incoming mobile objects, (ii) location changes for active objects,and (iii) leaving objects.

� Resource Service – This service extends standard grids mecha-nisms for registering and monitoring resources, like MDS and

Fig. 1. MiPeG architecture.

A. Coronato et al. / Journal of Systems Architecture 54 (2008) 877–882 879

Ganglia, in order to integrate in the grid mobile and wirelessresources.

� People Service – This component provides basic authenticationmechanisms and handles the list of mobile users active in theenvironment.

� Context Service – The Context Service, which relies on SemanticWeb technologies, handles the concept of context for a pervasivegrid. Current implementation of context consists of informationrelated to (i) the state of resources (both fixed and mobile) andservices; (ii) the location of mobile users; and (iii) users profiles.The service relies on ontologies and rules that enable it both toclassify several typologies of entities involved in Pervasive Grids,and to infer higher-level context information from low-levelinformation.

� Session Manager Service – This service handles sessions formobile users.

� Utility Service – This service, which will be detailed in the nextsection, provides the environment with a mechanism for sup-porting the Utility Computing model.

4. Utility service

4.1. Service architecture

The Utility Service is an application service able to dynamicallydistribute and execute user tasks on a community of either fixed ormobile resources. Users willing of executing their applications di-rectly submit their code without caring of choosing and allocatingresources of the virtual environment.

As already pointed out in the introductory section, the commonpractice that a user must follow in order to execute his own pro-grams has several limitations. To overcome such limitations, theUtility Service extends classic grids by enabling users to directlysubmit tasks for executions. After having been submitted, tasksare completely handled by the environment, which gathers the re-sults and sends them back to the user.

To achieve this objective, user tasks are encapsulated in mobileagents and then allocated in a distributed platform that controlsexecution.

As shown in Fig. 2, the Utility Service consists of the followingcomponents:

� Container – This is the run-time software environment that pro-vides the basic functionalities for executing and coordinatingmobile agents.

� Platform – This is the set of hardware nodes equipped with aContainer and able to execute tasks.

� TaskHandler – This is the hardware element that hosts the coor-dinating components. It is also the user entry point to theservice.

� Subordinate – This is an hardware node that hosts mobileagents for execution. It can be either a fixed or a mobileresource.

� Initiator – This is the hardware element used by the user to sub-mit source code for execution.

� TaskAllocation – This is the Container that handles the mobileagents hosting user tasks.

� TaskRecovery – This is the Container that stores cloned mobileagents. It is required to activate clones in case of failure of thecloned agent.

� Worker – This agent encapsulates the user’s task for executionand sends execution results to the Collector. More Workerscan be hosted by the same Subordinate.

� DeviceManager – This agent interacts with the ContextService toreceive the list and the state of available resources in the envi-ronment. In addition to this, it receives heartbeat messages fromevery Subordinate.

� Telltale – This is a software element that monitors some Subor-dinate’s parameters and communicates them to the DeviceMan-ager through heartbeat messages.

� WorkerManager – This agent coordinates Workers allocation andmigration within the environment accordingly with a schedul-ing algorithm.

� Collector – This agent receives the results from every activeWorker and collects them in the Results archive.

� Results – This is the archive that stores execution results untilthey are sent back to the user.

Whenever a user wants to execute a set of tasks, he contacts theTaskHandler and submits his code. After that, the WorkerManagerembeds such a code in mobile agents, namely Workers, into theTaskAllocation container. Before their distribution and execution,Workers are forced to create their clones in the TaskRecovery con-tainer. This is performed in order to confer a certain degree ofdependability to the service: if allocation or execution of a Workerfails, there is always a clone ready to take its place. Next, eachWorker is allocated in one or more Subordinates, where it will exe-cute its task. The Workers allocation is driven by the DeviceManag-er depending on the current state of active resources of theenvironment (the scheduling algorithm will be analysed in the sec-tion 4.2).

Fig. 2. Interfaces and architecture of the Utility Service.

Table 1Benchmark and relative speed-up values

Device Bi (ms) RSi;iþ1

D1 10 3.20D2 32 2.19D3 70 8.04D4 563 1.00

Fig. 3. Example of distribution of tasks.

880 A. Coronato et al. / Journal of Systems Architecture 54 (2008) 877–882

From now on, two main possibilities are in order: (i) the Work-er completes its execution by sending results to the Collector that,in turn, stores them in the Results archive; (ii) the Worker fails. Inthe latter case, if the Worker has failed because of the disconnec-tion of the Subordinate device, the failure is detected by theDeviceManager that does not receive heartbeats from the Telltaleanymore. As a consequence, the DeviceManager activates theWorker’s clone and requires its execution on a different Subordi-nate. If the Worker fails without involving the Subordinate device(its Telltale continues at sending heartbeat messages to theDeviceManager) the failure can be detected thanks to the Maxi-mumExecutionTime, which is the maximum time allowed to aWorker to complete its execution. Every time a Worker does notreturn to the TaskHandler within the MaximumExecutionTime,the DeviceManager kills it, activates its clone and requires its exe-cution on a different Subordinate. It is also important to note thatin the case of iterative failures of a Worker and its clones, the infra-structure is able to prevent deadlocks because of another internalparameter, namely the MaximumSessionTime, which provides allWorkers related to a launching session with a global maximumtime for execution; after that, all running Workers are killed andno clone is activated.

The multi-agent system has been entirely developed in Javaover the Java Agent DEvelopment (JADE) platform. JADE is a Java-based open source development framework aimed at developingmulti-agent systems and applications [14]. JADE-LEAP (Java AgentDEvelopment framework-Lightweight Extensible Agent Platform)is the lightweight JADE version for mobile and embedded devices.Both JADE and JADE-LEAP conform to FIPA (Foundation for Intelli-gent Physical Agents) standards for intelligent agents [15].

Users willing to submit a task have only to edit two java files:the ‘‘UserTask” class, which contains user’s source code of the taskand the ‘‘CollectorInfo” class, where the user specifies the type ofthe results that have to be collected. After a submission has beenmade, the framework creates an agent platform with all neededcontainers and agents.

It is worth noting that the software framework exhibits someautonomic behaviors. In particular, it self-manages allocation andexecution of tasks and self-recovers from nodes failures.

4.2. Scheduling Algorithm

We have defined a specific scheduling algorithm, namely DDT(Dynamic Distribution of Tasks), which aims at minimizing thetime of execution for user tasks. The objective is, in the case of mul-tiple submission of tasks, to distribute such tasks in the platformtaking care of resources state in order to achieve betterperformances.

Since resource conditions rapidly change in time (especially formobile resources), the Telltale periodically executes a benchmarkalgorithm (identical for all the devices) and sends its result (Bi,benchmark value for the resource i) to the DeviceManager. Then,the DeviceManager calculates the mobile average of the last fivevalues received for each active resource and orders such devicesaccording to these values (the slower device is the last in the list).Next, it calculates the Relative Speed-up (RSi;iþ1) for each device,which is the ratio between the benchmark execution times of thedevice i and the next device in the list (RSi;iþ1 ¼ Biþ1=Bi). The rela-tive speed-up for the slowest device is set to 1.

Fig. 4. Performance measures.

A. Coronato et al. / Journal of Systems Architecture 54 (2008) 877–882 881

Relative Speed-ups are used by the DeviceManager to choosethe device on which to send a task. The basic idea is: if a deviceexecutes the benchmark in a time that is the half of the time of an-other device, probably it will execute even the task in the half ofthe time.

Accordingly to this idea, Workers are sent on the devices as thebeads in an abacus; that is, Workers are allocated on the devicewith the highest relative speed-up till the number of Workers allo-cated (say N) is equal to the relative speed-up of the device itself.Next Worker is sent to the second device (which is the fastest ofthe relative list), then another group of N Workers is sent to theprevious device, in turn, this allocation is repeated until the num-ber of Workers on the second device becomes equal to its relativespeed-up. As the number of Workers gets equal to the relativespeed-up, the next Worker to allocate is sent to the third device.

Fig. 3 shows an example of allocation of tasks. In particular, weconsidered the case of eleven Workers to allocate in a platformcomposed of four devices. Since the relative speed-up between de-vices D1 and D2 is 3.20 (see Table 1), the algorithm allocates threeWorkers on the device D1 per every Worker allocated on the deviceD2. Differently, being the relative speed-up between devices D2and D3 equal to 2.19, only after having allocated two Workers onthe device D2, a new Worker will be allocated on the device D3.

If there are still Workers that cannot be allocated in the firstturn (that is, after having allocated Workers on all devices), theywill wait until a new device enters the environment or at leastone Worker completes its execution.

Finally, it must be noted that the list of ordered devices is recon-structed (and the benchmark executed) whenever one of the fol-lowing events occurs: a new device enters in the environment; adevice leaves the environment; a Worker concludes its execution.

This scheduling algorithm is very well suited to handle theamount and the kind of events related to the high dynamism of apervasive environment, where interactions among the systemand/or mobile devices occur in a quite chaotic way.

5. Proof-of-concept

As proof of concept we specialized the proposed model andinfrastructure in a framework called Dynamic Distributor of Tasks(DDT) with respect to a class of problems named evolutionary algo-rithms. This is a generic term used to indicate any population-based meta-heuristic optimization algorithms that use mecha-nisms inspired by biological evolution.

In practice, the problem consists in executing many times thesame algorithm with different initial conditions. In this case, thealgorithm has been implemented in Java and has been submittedto the service for execution. Together with the initial task, the sub-mitter has specified the number of replicas – number of times thesame algorithm has to be executed – and the relative initialconditions.

We have compared the execution time using the DDT algorithmwith a fair one that sends one Worker per each available device of

the environment, without taking into account any resource param-eter. The only condition is that a new Worker is sent to a deviceonly if the device has completed the execution of the previousWorker.

Preliminary experiments have been conducted using threedevices:

� ICAR1: Mobile Dual Core Intel Pentium M 1666 MHz – 512 MBRAM – Windows XP Home Edition SP2 – WiFi internetconnection.

� ICAR2: Intel Pentium III Xeon 863 MHz – 1 GB RAM – WindowsXP Professional SP2 – LAN internet connection.

� ICAR3: Intel Pentium III 497 MHz – 256 MB RAM – Windows XPProfessional SP2 – LAN internet connection.

Fig. 4a reports results when all the previous devices are active inthe environment. In particular, performance improves as the num-ber of tasks to execute grows.

Fig. 4b shows even a better improvement because, in this caseonly two devices have been considered as active resources, ICAR1and ICAR3. In this case, the DDT algorithm has allocated just fewworkers on the slowest device. As a result, this has limited the ef-fect of such a slow device on the response time of the service.

6. Conclusions

This paper proposes a distributed framework able to provideusers with Utility Computing mechanisms for distributing and exe-cuting tasks over a dynamic platform. The infrastructure is able toself-organize and self-handle its hardware nodes, which can bothbe fixed or mobile, granting a certain degree of load-balancingand dependability. Mobile agents are used for encapsulating tasks,this in order to make them able to migrate among platform nodes.

References

[1] I. Foster, C. Kesselman, The Grid: Blueprint for a New ComputingInfrastructure, Morgan Kaufman, 1999.

[2] D. Saha, A. Murkrjee, Pervasive computing: a paradigm for the 21st century,IEEE Computer (2003).

[3] Utility Computing, IBM System Journal 43, (1) (2004).[4] C. S. Yeo, R. Buyya, M. Dias de Assuno, J. Yu, A. Sulistio, S. Venugopal, M. Placek,

Utility computing on global grids, in: H. Bigdoli (Ed.), Handbook of ComputerNetworks.

[5] L.W. McKnight, J. Howinson, S. Bradner, Wireless grids, IEEE InternetComputing (2004).

[6] B. Clarke, M. Humphrey, Beyond the ‘device as portal’: meeting therequirements of wireless and mobile devices in the legion of grid computingsystem, in: International Parallel and Distributed Processing Symposium,IPDPS, 2002.

[7] N. Daves, A. Friday, O. Storz, Exploring the grid’s potential for ubiquitouscomputing, IEEE Pervasive Computing (2004).

[8] V. Hingne, A. Joshi, T. Finin, H. Kargupta, E. Houstis, Towards a pervasive grid,in: International Parallel and Distributed Processing Symposium, IPDPS, 2003.

[9] R. Aversa, B. Di Martino, N. Mazzocca, S. Venticinque, MAGDA: a mobile agentbased grid architecture, Journal of Grid Computing (2006).

[10] H. Tianfield, R. Unland, Toward self-organization in multi-agent systems andgrid computing, Multiagent and Grid Systems Journal (2005).

882 A. Coronato et al. / Journal of Systems Architecture 54 (2008) 877–882

[11] Z. Li, M. Parashar, Rudder: an agent-based infrastructure for autonomiccomposition og grid applications, Multiagent and Grid Systems Journal (2005).

[12] M. Ciampi, A. Coronato, G. De Pietro, Middleware services for pervasive grids,ISPA (2006).

[13] A. Coronato, G. De Pietro, L. Gallo, Automatic execution of tasks in MiPeG, in:Second International Conference on Advances in Grid and PervasiveComputing, GPC, 2007.

[14] F. Bellifemmine, A. Poggi, G. Rimassa, JADE – FIPA compliant agent framework,PAAM (1999).

[15] FIPA. <http://www.fipa.org/specifications/index.html>.[16] Globus Toolkit. <http://www.globus.org>.

Antonio Coronato is a Researcher at the Institute forHigh-Performance Computing and Networking (ICAR) ofthe National Research Council (CNR). He is a contractprofessor of Software Engineering at the University ofNaples ‘Federico II’. His main fields of interest are rela-ted to pervasive computing and component basedarchitectures. He is a member of the ACM.

Giuseppe De Pietro is a Senior Researcher at the Insti-tute of High Performance Computing and Networking(ICAR) of the National Research Council (CNR). He is acontract professor of Information Systems at the SecondUniversity of Naples.

His research interests cover pervasive computing,multimodal and virtual reality environments.

He is member of the IEEE.

Luigi Gallo is a Fellow Researcher at the Institute forHigh-Performance Computing and Networking (ICAR) ofthe National Research Council (CNR). He is also Ph.D.student at the University of Naples ‘Parthenope’. Hisfields of interest involve multi-agent systems and vir-tual reality environments.