Mobile-agent-based collaborative sensor fusion

Available online at www.sciencedirect.com

Information Fusion 9 (2008) 399–411 www.elsevier.com/locate/inffus

Mobile-agent-based collaborative sensor fusion Pratik K. Biswas

a,*

, Hairong Qi b, Yingyue Xu

c

a

Telcordia Technologies, Piscataway, NJ 08854, United States University of Tennessee, Knoxville, TN 37996, United States Intelligent Automation Inc., Rockville, MD 20855, United States b

c

Received 17 November 2006; received in revised form 22 July 2007; accepted 7 September 2007 Available online 19 September 2007

Abstract Information fusion can assist in the development of sensor network applications by merging capabilities, raw data and decisions from multiple sensors through distributed and collaborative integration algorithms. In this paper, we introduce a multi-layered, middlewaredriven, multi-agent, interoperable architecture for distributed sensor networks that bridges the gap between the programmable application layer consisting of software agents and the physical layer consisting of sensor nodes. We adopt an energy-efficient, fault-tolerant approach for collaborative information processing among multiple sensor nodes using a mobile-agent-based computing model. In this model the sink/base-station deploys mobile agents that migrate from node to node following a certain itinerary, either pre-determined or determined on-the-fly, and fuse the information/data locally at each node. This way, the intelligence is distributed throughout the network edge and communication cost is reduced to make the sensor network energy-efficient. We evaluate the performance of our mobileagent-based approach as well as that of the traditional client/server-based computing model, vis-a`-vis energy consumption and execution time, through both analytical study and simulation. We draw important conclusions based on our findings. Finally, we consider a collaborative target classification application, supported by our architectural framework, to illustrate the efficacy of the mobile-agent-based computing model.  2007 Elsevier B.V. All rights reserved. Keywords: Sensor networks; Agent-based systems; Collaborative information processing; Interoperable agent model; Mobile agents

1. Introduction RECENT advances in the fields of micro electro mechanical system (MEMS) and wireless communication technologies have directed research towards the development of a new generation network system – the sensor network [1–4]. It is composed of small sensor nodes integrating the capabilities of sensing, computing, communication, and even mobility (if necessary). According to [1,2], each sensor node is made up of five components, the battery power source, sensors, CPU, memory, and a communication module. It may also contain a global positioning system (GPS) receiver that allows it to determine its current *

Corresponding author. Tel.: +1 732 699 4298. E-mail addresses: [email protected] (P.K. Biswas), [email protected] (H. Qi), [email protected] (Y. Xu). 1566-2535/$ - see front matter  2007 Elsevier B.V. All rights reserved. doi:10.1016/j.inffus.2007.09.001

location. Large amounts of these small-size and low-cost sensor nodes can be rapidly deployed to a region of interest and form a loosely-coupled distributed networking system, in which collaboration among multiple sensor nodes is essential in order to compensate for each other’s limited sensing and processing capabilities, extremely constrained energy resources, and to improve the reliability of the decision making process. Sensor networks have found wide applicability in areas such as mission-critical applications related to national security, medical monitoring, environmental monitoring, intelligent transportation, industrial production, hazardous process control, etc. Agent-based systems [5] represent a new software technology that has emerged from merging two technologies, namely, artificial intelligence (AI) and object-oriented distributed computing. Agents are intelligent, autonomous, software components capable of interacting with others

400

P.K. Biswas et al. / Information Fusion 9 (2008) 399–411

within an application, attaining a common goal and thereby contributing to the resolution of given problems. An agent can have some or all of the following characteristics, namely, autonomy, communication, mobility, learning and cooperation. Compliancy to Foundation of Intelligent Physical Agents (FIPA) standards [6–8] makes these agent-based systems interoperable. A multi-agent platform is a software infrastructure that acts as an environment for agents’ deployment and execution. For small devices, the platforms are lightweight due to the resource constraints. According to how many services are executed on the device, multi-agent platforms can be classified in the following three categories [11], portal platforms that do not execute the agents on the small devices, surrogate platforms that execute the agents partially on the devices, and embedded platforms that execute the agents entirely within the devices. In this paper, we consider sensor nodes as embedded multi-agent platforms. We present a multi-layered architecture for sensor networks that would allow interoperable, software agent-based applications to reside on top of a network of distributed, interactive and adaptive sensor nodes that process data in real time. We develop a mobile-agentbased information fusion framework for collaborative information processing and show its effectiveness through analytical study and simulation. In this context, we distinguish collaborative processing from distributed processing in that collaborative processing is conducted among a cluster of geographically close sensor nodes in order to reduce communication cost and energy consumption. Broadly speaking, there are two main computing models for collaborative information processing in sensor networks. They differ primarily in two aspects: what is transferred over the network and where has the fusion taken place. In the traditional client/server-based computing paradigm [9,12,14–17], all the sensor nodes send raw data to a processing center, where the information is fused centrally based on the data received, as illustrated in Fig. 1a. In some applications where the size of the raw data is very large, the clients can perform some local processing and send a compressed version of the raw data or simply the local processing results to the processing center, as illustrated in Fig. 1b. Sometimes, the fusion can be carried out hierarchically with multiple levels of processing centers as illustrated in Fig. 1c to solve scalability problems. In sensor networks, these approaches may not be very effective as the data volumes being integrated are much larger while the communication bandwidth for wireless network

is much lower and the power resource on each sensor is extremely limited. In the mobile-agent-based computing paradigm [12–17], the transfer unit is the software agent itself and fusion is conducted at each individual sensor node. This paradigm is based on three intrinsic agent characteristics, namely, autonomy, communication, and mobility. This model is sometimes advantageous for collaborative information processing in sensor networks from the following perspectives: (1) scalability: the performance of the network is not affected when the number of sensor nodes is increased, (2) reliability: mobile agents can be sent when the network connection is alive and return results when the connection is re-established, (3) extensibility and task-adaptability: mobile agents can be programmed to carry different taskspecific integration processes which extend the functionality of the network, (4) energy-awareness: the itinerary of the mobile agent can be dynamically determined based on both the information gain and energy constraints, and (5) progressive accuracy: a mobile agent can partially integrate results as it visits more nodes, improving the accuracy of the integrated result at each visited node (assuming the agent follows the path based on the information gain). Consequently it can terminate its itinerary and return to its source when it is satisfied with the outcome of the partial integration. This also saves both network bandwidth and computation time by avoiding unnecessary migrations. Mobile agents are generally more efficient than stationary agents, if data sizes are much larger than code sizes (sizes of these agents). Fig. 2 illustrates the differences between the two paradigms. The rest of the paper is organized as follows: In Section 2, we discuss related work. In Section 3, we describe the sensor network architecture from perspectives of physical and software abstractions. This description facilitates further discussion on the agent-based information processing framework in Section 4. In Section 5, we extensively evaluate the two computing models in supporting collaborative processing in sensor networks. In Section 6, we provide a case-study to demonstrate the effectiveness of the mobileagent-based computing model. Finally, we conclude with a summary in Section 7. 2. Related work The literature on wireless sensor networks goes back a long way. The work in [1–4] captures the essence, surveys current research and presents the future challenges in the

Processing center (server) Local processing Sensor node (client)

Fig. 1. Variants of client/server-based computing model.

P.K. Biswas et al. / Information Fusion 9 (2008) 399–411

Node 1 Server Node

Client Node

data transfer (high overhead)

Node 1

Node 1

Agent

Agent

Client Node

Client Node

401

Agent Node 2 Agent migration

Node 2

Node 2

Local integration

Continue Migration or Return

Control daemon

time Fig. 2. Comparison between (a) the client/server-based paradigm and (b) the mobile-agent-based paradigm.

field of sensor networks. However, the focus of this paper is not on wireless sensor networks in general but on the application of mobile agents in sensor fusion. Accordingly, we have only discussed literature here that intersects the fields of intelligent agents and wireless sensor networks. Agent-based related work falls under the following four categories: (a) agent-based network management approaches [10], (b) multi-agent platforms on small devices [11], (c) agent-based sensor networks and applications [12– 19] and (d) agents in wireless ad hoc networks [20]. The client-server and mobile-agent-based approaches were evaluated by Baldi and Picco [10] for an example network monitoring application in terms of total traffic and the traffic concentrated at the NMS (network management system). The mobile-agent-based framework was found to be disadvantageous. However, the work lacked in presenting experimental analysis and was not specifically addressed to wireless sensor networks. An overview of multi-agent platforms, created for use on small devices, was presented by Carabelea et al. [11], who also reviewed the main characteristics and architectural concepts for each such platform. These platforms were meant for wireless embedded computing in general and not for sensor networks or sensor network applications in particular. Not every one of them was FIPA-compliant. The distributed services concept was introduced by Lim [12] for information dissemination in self-organizing sensor networks. Specifically, three fundamental services were proposed, namely, service lookup, sensor node composition and dynamic adaptation. The distributed services layer had access to the sensor data through sensor agents. A sensor agent was associated with every sensor node or sensor data source. However, the sensor agents were not FIPA-compliant and the sensor network application was not necessarily agent-based. The use of a mobile-agent-based computing model, for collaborative signal and information processing in a distributed sensor network, was suggested by Qi et al. [13]. The performance of the mobile-agent-based computing model, vis-a`-vis the traditional client/server-based computa-

tional model, was also evaluated through analytical study and simulation. The results of using different routing and MAC protocols, for the various distributed computing paradigms employed in sensor networks, were compared by Xu and Qi [14]. This study also covered larger deployment areas. An agent-oriented middleware, for information processing in sensor networks, was briefly described by Biswas et al. [15,16]. This middleware in [15] used a language named CCL, originally developed for the management of UUVs (unmanned underwater vehicles), for tracking targets with sensor networks. A short summary of the current research has been presented in [17] by Biswas, Qi and Xu. Agilla, a middleware for sensor networks, was proposed by Chien-Liang et al. [18]. It provided a mobile-agent-based paradigm for programming within wireless sensor networks. Some aspects, regarding the construction of adaptive, self-organizing network of sensor agents through the contract net protocol, were outlined by Knoll [19]. A performance model of these networks was also developed for analyzing the throughput of the sensing tasks, based on a variety of network and agent parameters. MARP: A multi-agent routing protocol, was recommended by Choudhury et al. [20], for mobile wireless ad hoc networks. However, MARP was not applied to any real-time sensor network applications. In this paper we have extended the sensor network architecture, presented in [15,16], by extending the agent framework and by providing performance evaluations of the supported computational models. This paper is also an extension of the work, presented in [17]. Here, we have expanded and formalized our analysis and demonstrated the usefulness of our approach for information processing in sensor networks through a collaborative target classification application. 3. Sensor network architecture We present a multi-layered architecture for sensor networks that can support interoperable multi-agent applica-

402

P.K. Biswas et al. / Information Fusion 9 (2008) 399–411

tions. We describe the architecture from the aspects of both physical and software abstractions.

based and provides services for both sensor nodes and software agents.

3.1. Physical architecture

4. Information fusion framework for sensor network applications

At the physical level, the sensor network consists of stationary and mobile, wireless and wired nodes with datacentric as well as IP-centric routing protocols. We consider the following types of nodes: Sensor nodes (SN): These are the smart sensors, palmtops, laptops, single board computers, mobile robots, RF relay links, etc. that communicate wirelessly. Cluster head nodes (CHN): These are the sensor nodes that act as hierarchical or ad hoc cluster heads, based on application necessities. In the ad hoc mode, any node can become a cluster head. Region management stations (RMS): These are more powerful desktop workstations that have wireless links to the sensor nodes and are also directly connected to the wired network. They manage a sub-network of sensor nodes, representing an application defined geographical region. They are analogous to base-stations in regular wireless networks. 3.2. Software architecture with middleware components Architecturally, the sensor network software consists of two components, namely, sensor node software and region management station (RMS) software. Each of these consists of at least an operating system (OS) and a middleware. The OS in the sensor node is tailored to its application specific needs. The sensor node software also contains a sensor manager that manages and measures the local sensor data and provides an interface to the middleware for accessing the sensor information. The interface contributes to the ontology(set of representational terms) for sensor nodes. The RMS software additionally provides data mining and management facilities over the regional sensor data and a code repository of useful task executables (tracking and classification algorithms, etc.) that can be ported to the sensor nodes on demand. The following middleware provides the distributed service layer for the sensor networks. Sensor node middleware: It coordinates the integration of the sensor node with the rest of the network. It is made up of the local controller, management module (also manages sensor manager), communication module, mobility module, task-specific algorithms, directory facilitator (lookup services), and other downloaded executables. It is software agent-based and FIPA-compliant. It provides an embedded agent platform. Region management station (RMS) middleware: It coordinates the integration of the sensor nodes of a region with the rest of the network. It consists of a management module (also performs data management), communication module, and controller synthesizer. It is software agent-

In this section, we formally define an agent-based framework that can be useful for collaborative information processing in sensor networks. The framework facilitates the integration of the hardware agents of the physical environment with the software agents of the application through two main agent characteristics, namely, communication and mobility. The framework supports both the computing models for collaborative information processing. 4.1. Interoperable agent model for sensor network applications The Interoperable agent model [15,16] provides an information networking architecture for a sensor network application. We have extended this model in this paper. In this model, a sensor network application involves the following eight types of software agents: Sensor agent (SA): The SA is a FIPA-compliant cognitive agent that resides on a sensor node and has access to the data source of a sensor node in that region. It performs the role of the sensor manager and makes the sensor information of the represented sensor node available to the sensor network application. The sensor agent registers itself with the agent management system (AMS) agent of the node on which it resides. In our architecture, there is a sensor agent for every sensor node. Agent management system (AMS): The main task of AMS is management of agents, i.e., registration, authentication, security and mobility [6]. AMS can also be extended to support clustering and teaming. It is a FIPA-compliant platform agent. Directory facilitator (DF): The main task of DF is to provide lookup and advertising services for the application [6]. DF is an agent, which helps other agents find appropriate partners for a particular conversation. It is a FIPAcompliant platform agent. Agent communication channel (ACC): ACC is a message routing agent, which delivers messages as requested by their senders [6]. It can support both local and remote communications. It is a FIPA-compliant platform agent. Controller synthesizer (CS): Its main task is to translate and help refine application specifications into node controllers, such that the node behavior is consistent with the application-specific global network behavior. Data manager (DM): Its main task is to manage and mine the regional sensor data. Application agent (AA): The AA is a FIPA-compliant static or mobile agent that is specific to the application. It can possibly communicate, move, cooperate, reason, adapt, learn, and perform other application specific tasks. Fig. 3 illustrates the data structure of a mobile application

P.K. Biswas et al. / Information Fusion 9 (2008) 399–411

Fig. 3. Mobile agent structure.

agent. It consists of four components, namely, ‘‘identification’’ to uniquely identify the mobile agent, ‘‘data space’’ to store intermediate integration results, ‘‘service knowhow’’ that hosts different integration algorithms, and ‘‘itinerary’’ that the mobile agent follows during migration. Interface agent (IA): The IA assists users in formulating requirements, maps them into requests to other agents for further processing and provides users with answers from the application agents. In our model, it acts closely with controller synthesizer (CS) to translate and refine application specifications to controllers for local nodes. Of all the eight types of agents, the sensor node may host SA, AMS, ACC, DF and AA, while the RMS mainly hosts ACC, AMS (extended responsibilities), DM, CS, IA and AA. Fig. 4 illustrates the interrelationship among different agents in our agent model. The arrows indicate the directions of the communicative exchanges. 4.2. Communication framework Our architectural framework includes peer-to-peer type communication between software agents [7]. It supports both local and remote communications and uses wireless transmission as the transport mechanism for remote communication between sensor nodes. The agent to agent communication, also known as the agent-based messaging paradigm, provides a universal messaging language with a consistent speech-act based, uniform messaging interface for exchanging information, statically or dynamically, among software entities. Agent communication is guided by Interaction Protocols (request-inform, subscription, advertisement, etc.). Agents can communicate directly or indirectly through the ACC. A simple model for agent communication involves at least two parties: a sending agent that generates the infor-

ACC

ACC

IA

AA DM

AMS DF

CS

AA AMS SA

RMS Sensing Device

Sensor Node

Fig. 4. Interrelationship among different types of agents.

403

mation and transmits it and a receiving agent that receives the message and uses the information. The agents can be located at the same host or communicate wirelessly between remote nodes. The information that is exchanged between the communicating parties may be formally coded into a universally understood agent communication language (ACL) with a speech-act based interface. The sending agent on generating this ACL coded message string invokes the message() method of the recipient and passes the string through it (FIPA framework). The receiving agent on receiving this message decodes the information and then performs the necessary actions. In case of a bidirectional communication, it may communicate the result back to the sender by reciprocating the same process. Agent communication, under this paradigm, is accomplished through the use of three components: Agent communication language (ACL), content language, and ontology. For our agent communication framework, we have used FIPA ACL as the communication language, XML as the content language and a Sensor Node API based ontology for sensor network applications. Fig. 5 shows a simple DTD (Document Type Definitions) together with the Sensor Node API. These can constitute an ontology for sensor network applications. Fig. 6 illustrates code snippets for agent communication between a tracking and a sensor agent regarding target detection. 4.3. Mobility framework Our architectural framework supports agent mobility based on FIPA’s agent management specifications [8]. Agent mobility refers to a software agent’s ability to move from one host machine to another. A simple model for agent mobility works the following way: The source initiates the transfer. The agent suspends its activities on the source. The system captures the entire agent state (does not include the run time stack) and transfers it together with the code to the destination following a predetermined itinerary or according to the agent’s own determination. Once the agent is received at the new location, the agent’s state is automatically restored. The agent resumes its activities on the destination. On completion, the agent may or may not return to the host, as per its intentions. Migration of a software agent from source to destination may trigger updates for the service provider agents (AMS and DF). 4.3.1. Mobile agent’s itinerary Itinerary can be determined either statically or dynamically. That is, it can be calculated either before the agent is dispatched or while the agent is migrating. Dynamic itinerary planning is more flexible, and can adapt to environmental changes (sensor ups and downs) in real time. However, since the itinerary is calculated on the fly, it also consumes more computation time and more power of the local sensor node. On the other hand, although static itinerary cannot adapt to the network change, it is able to save

404

P.K. Biswas et al. / Information Fusion 9 (2008) 399–411


“http// www.DTDRepositories.org www.DTDRepositories.org/SN.dtd”> ”>
class attr attr attr attr attr attr attr attr attr attr attr attr attr attr attr

Sensor_Node ID Time Frequency Amplitude Position Temparature Pressure DataCollectionMode DataMeasurementCount IsTargetDetected IsPowerFail IsSensorFail HasMoved HasRecharged HasAborted

Fig. 5. A simple DTD file with definitions required to obtain sensor node data.

(request

(inform :sender TA1@RMS ~(Tracking Agent) :receiver SA1@SN1 ~(Sensor Agent) :ontology http// www.DTDRepositories.org/SN.dtd :protocol Fipa-Request :language XML :content

:sender SA1@SN1 ~(Sensor Agent) :receiver TA1@RMS ~(Tracking Agent) :ontology SensorNode :protocol Fipa-Request :language XML :content

) )

Fig. 6. (Left) An ACL(XML) message from tracking agent to sensor agent. (right) An ACL(XML) message from sensor agent to tracking agent.

on both computation time and power since the itinerary only needs to be calculated once. Computation-efficiency, energy-efficiency, and flexibility are three conflicting objectives that cannot always be satisfied at the same time. We study the problem of optimally planning the itinerary for mobile agents within the context of collaborative processing for sensor network applications, where computation time and energy consumption are the two major concerns. In a sensor network, where a large number of nodes are deployed, redundancies in the sensor readouts can also be used to provide error tolerances. Furthermore, a mobile agent, migrating around the sensor network and accumulating sensor readouts, can return to the processing center directly without finishing the entire trip, if the accuracy of the result has reached the requirement of a certain task. We present a simplified sub-optimal solution that determines the agent itinerary (next node) on-the-fly based on three parameters obtained in real time, the remaining energy on board the sensor node which is the potential next hop of the mobile agent, the signal energy sensed at the potential next hop, and the geographical distance between possible neighbors. Note that when the packet size is the same, the communication cost is proportional to the distance between the source and the destination, which can

be calculated using the longitude and latitude information exchanged between nodes. The DF on each sensor node is responsible for exchanging information, through ACC, with the DFs of its neighbors when the node is initially activated and when dramatic changes have occurred to any of these three parameters (mentioned above). Therefore, the DF on each node (source) is able to calculate the cost for migrating to each neighboring node (destination). Fig. 7 illustrates the structure of packets transferred by the DF. 4.4. Computing models Our multi-agent framework, for information processing in sensor network applications, supports both types of computational models, namely, remote (static) communication between different nodes (between agents located at different nodes), as well as agent mobility with local communication at the same host/node. In the client/serverbased computing model, the SAs located at the constituent

Node ID

Longitude

Latitude

Remaining Energy

Signal Energy

Fig. 7. Packet structure maintained by the DF.

P.K. Biswas et al. / Information Fusion 9 (2008) 399–411

sensor nodes communicate remotely with the agents in cluster-heads or RMS (DM). In the mobile-agent-based computing model, the AAs move from node to node and communicate locally with the SAs, residing on the same hosts. We evaluate the performances of these two models in the next section. 5. Performance evaluation of different computing paradigms for collaborative processing In this section, we evaluate the performance of the mobile-agent-based computing model, vis-a`-vis the client/ server-based model through both mathematical analysis and simulation. We need to realize that the mobile-agentbased computing model might not always perform better than the client/server-based computing model since mobile agents also introduce overhead, which mainly comes from the agent creation, dispatch and receiving time. However, for the client/server-based computing model, there will be increased queuing delays as the number of clients increases. As a result, it may cause longer processing delays and more potential drops at the server side. Unfortunately, in sensor networks, the number of nodes could be hundreds or even thousands.

405

where the time used to transfer the agents is ttrans = (m + n)sa/vn since it takes nsa/vn for the m mobile agents to migrate among the n sensor nodes simultaneously and it takes msa/vn additional time for the processing center (RMS) to receive the agents in sequence after they finish the migration, the agent overhead time is toh = 2(m + n)oa as it takes 2moa for the AMS to dispatch and receive m mobile agents and 2noa for all the local nodes to send and receive each mobile agent, and the time used to execute the processing code locally is tproc = (m + n)sa/vd. In order to obtain a more realistic estimation for the data transfer time, we develop simulation models to obtain ttrans. Similar to the formulation of the execution time, the energy consumption for the two computing models depends on three components, energy consumed in data transfer (etrans), overhead processing (eoh), and data processing (eproc). Since no matter where the processing is taken place, be it at the local sensor node or the processing center RMS, the energy consumed for data processing for the entire sensor network is the same for both computing models, we choose to ignore eproc. For the same reason, we do not include the energy used for sensing either. The model used to calculate the energy usage is ecs ¼ etrancs þ 2mnpprocessor of ema ¼ etranma þ 2mðn þ 1Þpprocessor oa

5.1. Performance metrics We choose to use two metrics, the execution time and the energy consumption, to evaluate the performances of the client/server-based and mobile-agent-based computing models in collaborative processing. The execution time is the time spent to finish a processing task. It consists of three components, ttrans for time spent in data transfer and receiving, toh for overhead time, and tproc for processing time. A few factors that can affect the execution time include the network transfer rate vn, the data processing rate vd, the message size sf (the size of raw data each node/ SA collects), the mobile agent (AA) size (sa), the overhead of message access of (the time used to read/parse, generate/write a message), the overhead of mobile agent oa, the number of sensor nodes (SAs) p, the number of mobile agents (AAs) m, and the number of sensor nodes n that each agent migrates to (the processing center RMS is not included). Notice that p = mn. For the client/server-based computing, the total execution time using the client/server-based model is tcs ¼ mnsf =vn þ 2mnof þ mnsf =vd

ð1Þ

where the data transfer time is ttrans = mnsf/vn, the overhead time is toh = 2mnof (assuming the time used to read and write the message is the same), and the data processing time is tproc = mnsf/vd. For the mobile-agent-based computing, the total execution time using the mobile-agentbased model is: tma ¼ ðm þ nÞsa =vn þ 2ðm þ nÞoa þ ðm þ nÞsa =vd

ð2Þ

where etrancs and etranma are obtained from simulation, pprocessor is the power consumption of the node processor in full load. 5.2. Experimental results We design four experiments to evaluate the effects of four parameters (p, m, sf/sa, and of/oa) on the execution time and energy consumption for the two computing models. The experiments are conducted using ns-2 [25] simulations. In each experiment, we only change one parameter value but keep the others fixed. The following default values are adopted throughout the simulation unless otherwise specified: n 10

m 1

Sf 10 Kb

Sa 1 Kb

Of 0.0125 s

Oa 0.05 s

In each simulation, the nodes are randomly deployed in an area of 10 · 10 m2. We use 802.11 as the MAC layer protocol, DSDV as the routing protocol, 0.6 W as the transmission power and 0.3 W as the receiving power. The selections of the specific MAC and routing protocols have been made based on related work in [14,24]. We simulate FIPA-compliant agent communication and mobility (Section 4) by populating the parameters in the ns2 configuration files with data/costs from a FIPA-compliant implementation. We define traffic patterns, in these files, based on FIPA-compliant message exchanges and agent movements. For message exchanges, we write each

406

P.K. Biswas et al. / Information Fusion 9 (2008) 399–411

ACL(XML) message into a file and measure the message size by the file size. Likewise, when an agent migrates from one node to another, it is wrapped and sent as a binary stream. The size of the file/stream, frequency of transmission, etc., form the traffic patterns for our simulations. From the simulation results, we have the following observations: First, we observe from Fig. 8 that the execution time using both paradigms grows as the number of nodes increases. But the client/server-based model grows much faster than the mobile-agent-based model. This is because as the number of nodes increases, the RMS (base station) has to deal with more connections requested by the clients at the same time, which elongates the execution time. On the other hand, the mobile-agent-based model is less influenced by the number of nodes, as there are fewer connections at one time for the mobile-agent-based model. The simulation also shows that, for p < 17, the client/serverbased model performs a little better than the mobile-

agent-based model. This happens because the mobileagent-based model needs more connections than the client/server-based model in order to send and receive mobile agents. Another reason is that the overhead of the mobile agent surpasses the overhead of the client/server-based model. As for the total energy consumption, the mobileagent-based computing model almost always consumes less energy, because the amount of data transmitted is much reduced, thus saving the total energy. In the second experiment, we fix the number of nodes at 100 and assume that each agent migrates to the same number of nodes, to evaluate the effect of the number of mobile agents. The performance curve from the client/server-based computing model should be constant since the change in the number of mobile agents would not affect its performance. We observe from Fig. 9 that the mobile-agentbased model always has less execution time and energy usage than the client/server-based model as the node number is large. The execution time of the mobile-agent-based model decreases as the number of mobile agents increases

Fig. 8. The effect of the number of nodes (top: execution time, bottom: energy consumption).

Fig. 9. The effect of the number of mobile agents (top: execution time, bottom: energy consumption).

P.K. Biswas et al. / Information Fusion 9 (2008) 399–411

407

and reaches the lowest point when there are five agents. Subsequently, the execution time begins to increase. This is because more mobile agents will reduce the number of nodes each agent migrates to, thus reducing the execution time. But more mobile agents also cause more connections and overheads. In the third experiment, we change the size of the data file sf, but fix the other parameters and let sa = 1 K, p = 15, in order to study the effect of the message (raw data) size vs. the mobile agent size. We observe from Fig. 10 that the execution time and energy consumption using the mobile-agent-based computing model are constant because data are located at the local nodes; only a fixed amount of results are transferred. When the data size is less than 21 Kb, the client/server-based computing model has less execution time than that of the mobile-agent-based model. However, the larger the data size, the more advantageous the mobile-agent-based paradigm. This is because as sf increases, more data need to be transferred, thereby

increasing the time used by the client/server-based model. The energy consumption shows similar pattern. In the last experiment, we fix all other parameters in the network, but change the overhead ratio of/oa. We see from Fig. 11 that when the ratio is greater than 1, the client/server-based model starts to perform worse than the mobileagent-based model as larger the of, the longer the execution time. In this study, that client/server paradigm always consumes more energy. The simulation results show that the mobile-agent-based model does not always perform better than the client/server-based model and in different scenarios, the energy consumption is usually the more contingent resource. However, in the context of sensor networks with hundreds or even thousands of nodes, unreliable communication links, and reduced bandwidth, the mobile-agent-based computing approach provides solutions to energy-efficient collaborative processing with less execution time. On the other hand, when the number of nodes in a network is small, the mobile-agent-based paradigm suffers longer net-

Fig. 10. The effect of the message (data file) size vs. mobile agent size (top: execution time, bottom: energy consumption).

Fig. 11. The effect of the overhead of file access vs. that of the mobile agent (top: execution time, bottom: energy consumption).

408

P.K. Biswas et al. / Information Fusion 9 (2008) 399–411

work latency because of its bigger overhead. We summarize our observations through the following statements: Statement V.1: The mobile-agent-based computing model tends to use less execution time and energy than the client/ server-based computing model when the number of nodes is large. For example, under the simulation condition used in this paper, when p > = 17, the statement holds. Statement V.2: For the mobile-agent-based computing model, for a certain network setup, there exists an optimal number of mobile agents that yields the shortest execution time and the lowest energy consumption. For example, under the simulation condition used in this paper, when m = 5, the statement holds. Statement V.3: When the message (raw data) size is relatively large compared to the mobile agent size, the mobileagent-based computing model is faster and more energy-efficient than the client/server-based computing model. For example, under the simulation condition used in this paper, when sf/sa > = 21, the statement holds. Statement V.4: When the overhead of file access is larger than the overhead of agent handling, the mobile-agent-based computing model is faster and more energy-efficient than the client/server-based computing model. For example, under the simulation condition used in this paper, when of/oa > = 1, the statement holds. 6. Case study: collaborative target classification In this section, we take collaborative target classification as an example to show how the mobile-agent-based computing model can support collaborative information fusion within the context of our sensor network architecture. In order to use the mobile-agent-based computing model, there are three components that need to be realized first. These are the following:

confidence range for target class ‘‘diesel truck’’ and the second row indicates the confidence range for ‘‘SUV’’. The confidence itself can be modeled by different stochastic distributions, the simplest of which would be a uniform distribution, where equal weight could be put on each confidence value within the confidence range. Other appropriate distributions could be a Gaussian (more weight on the central confidence within the confidence range) or a Rayleigh (more weight on the low confidence within the confidence range). A 1-D array can serve as an appropriate data structure to represent the confidence range. Different resolution of processing determines the size of the array. We always assume the confidence ranges between 0 and 1. If the processing resolution is 0.05 and there are three possible targets, then the size of the 1-D array is (1/0.05 + 1) · 3 = 63 units of floating points. 6.2. The integration algorithm The integration algorithm needs to be both effective and simple for purposes of energy efficiency and real-time response. A good algorithm is the overlap function, which was first proposed by Prasad et al. [21]. It is similar to a histogram function, where according to the confidence range generated from multiple SAs, the overlap function accumulates the number of nodes (SAs) with the same confidence values. Fig. 12 illustrates the construction of overlap function for a set of 6 sensor nodes (SAs) when the uniform distribution is used. The horizontal axis represents the confidence value, ranging from 0 to 1. The vertical axis represents the number of sensors with the same confidence value. For example, from the figure we can see that there are four sensor nodes (s1, s2, s3, and s6) with their confidence ranges falling within 0.5 and 0.6.

• the format of the local processing result, • an integration algorithm that can fuse local processing results from node to node, and • an algorithm to determine the mobile agent itinerary.

4

3

6.1. Format of the local processing result Overlap function

A reasonable choice of the format for local result is a confidence range. It indicates how certain the SA on the local node is about the local processing result based on data collected from the local sensor. For example, in case of target classification application, the confidence range is the range of classification confidence over each possible target class. The SA output might be expressed as ‘‘I am 40–70% sure that the target just went by me is a diesel truck, 20–30% sure that the target is a SUV’’. The confidence range can then be represented as a matrix using the lowest belief and the highest belief for each possible target class. In the confidence matrix, the first row indicates the

2

1

0

A

B

s1 s2

-1

s3 s4

-2 s5 s6

-3 0

0.2

0.4 0.6 Abstract interval estimate

0.8

1

Fig. 12. Overlapping function examples with uniform distribution.

P.K. Biswas et al. / Information Fusion 9 (2008) 399–411

The integrated information lies within regions over which the maximal peaks of the overlap function occur with the largest spread. For example, in Fig. 12, region [A, B] indicates the integrated information. The original proposal [21] for generating and analyzing the overlap function is centralized and can only take place at the processing center (RMS). A distributed integration of the overlap function has been developed [22] for the mobileagent-based computing model such that at each stop of the itinerary, a partially integrated result can be generated from previously migrated sensor node outputs and the accuracy of the information derived from this result can be used to justify if the mobile agent (AA) needs to continue with its migration. The distributed method would generate the same output as the centralized method if the mobile agent finishes its itinerary.

4

4

4

3

3

3

2

2

2

1

1

1

0

0

1. The overlap function has its highest peaks ranging from [n  f, n], where n is the number of nodes, f = b(n  1)/ 3c is the maximum number of faulty sensor nodes that the sensor network can tolerate, according to the Byzantine Generals Problem [23]. 2. The accuracy (multiplication between the height of the highest peak in the overlap function, the width or spread of the peak, and the confidence value at the center of the peak), calculated from the intermediate integration result at each sensor node, has to be equal to or greater than 0.5. 3. Both 1 and 2 have to be satisfied in two adjacent migrations excluding the first sensor node. The itinerary of mobile agent (AA) is critical in saving energy and effectively achieving the required accuracy. Fig. 13 shows the step-by-step integration result as the mobile agent migrates among nodes s1 to s6. In Fig. 13a, the mobile agent itinerary is from s1 to s6 in sequence. We can see that the mobile agent (AA) can actually terminate the migration after the third stop (s3) when all the criteria have been satisfied. Following is a detailed explanation of how the three criteria described above have been applied to terminate the mobile agent itinerary. • At stop 1, the mobile agent only integrates sensor s1’s input, that is, n = 1, therefore, f = 0 according to the Byzantine General’s problem. We observe that the high-

0.5 s1

1

0

0

0.5 s1,s2

1

0

4

4

4

3

3

3

2

2

2

1

1

1

0

0

6.3. Algorithm for mobile agent itinerary For the collaborative target classification application, the mobile agent itinerary needs to be optimal in terms of the migration costs, energy consumption and accuracy. In Section 4.3.1, we have discussed the dynamic itinerary problem for mobile agent. Another protocol needs to be developed in order to decide whether or not the mobile agent (AA) should stop its migration. The protocol includes the following three criteria [13]:

409

0.5 s1,s2,s3,s4

1

0

0

0.5 s1,s2,s3,s4,s5

1

0

4

4

4

3

3

3

2

2

2

1

1

1

0

0

0.5 s4

1

0

0

0.5 s4,s5

1

0

4

4

4

3

3

3

2

2

2

1

1

1

0

0

0.5 s4,s5,s1,s2

1

0

0

0.5 s4,s5,s1,s2,s3

(a) s1→s2→s3→s4→s5→s6

1

0

0

0

0

0

0.5 s1,s2,s3

1

0.5 1 s1,s2,s3,s4,s5,s6

0.5 s4,s5,s1

1

0.5 1 s4,s5,s1,s2,s3,s6

(b)s4→s5→s1→s2→s3→s6

Fig. 13. Partially integrated overlap function generated by the mobile agent with different integration order.

est peak of the overlap function is at 1 which is within [1-0, 1], therefore, the first criterion is satisfied. The ‘‘accuracy’’ is calculated, according to the definition, as 1 · 5 · 0.5 = 2.5 > 0.5, therefore, the second criterion is satisfied. However, since this is only the first stop, the agent needs to continue its migration. • At stop 2, the mobile agent integrates both s1 and s2’s inputs, that is, n = 2, therefore, f = 0. We again observe that the highest peak of the overlap function is at 2 which is within [2-0, 2], therefore, the first criterion is satisfied. The ‘‘accuracy’’ is calculated, according to the definition, as 2 · 3 · 0.55 = 3.3 > 0.5, therefore, the second criterion is satisfied. However, the third criterion still is not satisfied, and the agent continues its migration.

410

P.K. Biswas et al. / Information Fusion 9 (2008) 399–411

• At stop 3, the mobile agent integrates s1, s2, and s3’s inputs, that is n = 3, therefore f = 0. We observe that the highest peak of the overlap function is at 3 which is within [3-0, 3], therefore, the first criterion is satisfied. The ‘‘accuracy’’ is calculated, according to the definition, as 3 · 3 · 0.55 = 4.95 > 0.5, therefore, the second criterion is satisfied. Because both criteria 1 and 2 have been satisfied for two consecutive migrations, the agent can stop its regular itinerary and return to the base with its integration result. On the other hand, in Fig. 13b, we intentionally change the itinerary and hence the order of integration. We observe that the agent can stop only after the fifth integration. We again detail the decision process as follows: • At stop 1, n = 1, f = 0, accuracy = 1 · 5 · 0.7 = 3.5 > 0.5, therefore, both criteria 1 and 2 are satisfied, but not for criterion 3. • At stop 2, n = 2, f = 0, but the highest peak of the overlap function is at 1 which is NOT within [2-0, 2], therefore, the first criterion is NOT satisfied. • At stop 3, n = 3, f = 0. Again, the highest peak of the overlap function is at 2 which is NOT within [3-0, 3], therefore, the first criterion is NOT satisfied. • At stop 4, n = 4, f = 1. The highest peak of the overlap function is at 3 which is within [4-1, 4], therefore the first criterion is satisfied. The ‘‘accuracy’’ is equal to 3 · 1 · 0.6 = 1.8 > 0.5, which satisfies the second criterion. However, the third criterion is still unsatisfied. • At stop 5, n = 5, f = 1. The highest peak of the overlap function is at 4 which is within [5-1, 5], therefore the first criterion is satisfied. The ‘‘accuracy’’ is equal to 4 · 1 · 0.6 = 2.4 > 0.5, which satisfies the second criterion. Because both criteria 1 and 2 have been satisfied at two consecutive stops, the agent can terminate its migration and return to the dispatcher. In summary, this mobile agent itinerary determination algorithm would consist of the following two main steps: 1. If the current node is not RMS, then the mobile agent (AA) would apply the protocol for partial integration to determine the accuracy of the integrated results. If the protocol is satisfied, then the mobile agent (AA) would terminate its itinerary and return to RMS. 2. If the current node is RMS or if the protocol is not satisfied at the current node, then the mobile agent (AA) would determine the next destination node, as outlined in Section 4.3.1, and continue on its path. Fig. 14 shows the complete algorithm for mobile agent itinerary determination, underlying the above-mentioned high-level steps. As discussed earlier, it combines the algorithm for next destination node determination with the protocol for termination of agent migration based on partial integration.

set Current Node = RMS set Done = False set Adjacent Node Count = 0 set First Node = False while ((Current Node /= RMS) || (!Done)) do if ((Current Node = = RMS) then calculate Moving Costdestination for each neighbor node, /* Moving Costdestination = f(Distance, Sensor Energy, Signal Strength) */ migrate to the node with the least value for Moving Costdestination set Current Node = Destination Node /* node to which mobile agent (AA) migrates to */ set Adjacent Node Count = 0 set First Node = True elseif ((AccuracyCurrent Node < 0.5) || (max(foverlap (Current Node)) < n-f || max(foverlap (Current Node)) > n) || ((First Node) && (AccuracyCurrent Node >= 0.5) && (n-f <= max(foverlap (Current Node)) <= n))) then /* Either Partial Integration Protocol is not satisfied at the current node */ /* Or Partial Integration Protocol is satisfied at the very first stop/hop (to be excluded) */ calculate Moving Costdestination for each neighbor node, /* Moving Costdestination = f(Distance, Sensor Energy, Signal Strength) */ migrate to the node with the least value for Moving Costdestination set Current Node = Destination Node /* node to which mobile agent (AA) migrates to */ set Adjacent Node Count = 0 set First Node = False elseif ((!First Node) && (AccuracyCurrent Node >= 0.5) && (n-f <= max(foverlap (Current Node)) <= n) && (Adjacent Node Count < 1)) then /* Partial Integration Protocol is satisfied at the first adjacent node */ calculate Moving Costdestination for each neighbor node /* Moving Costdestination = f(Distance, Sensor Energy, Signal Strength) */ migrate to the node with the least value for Moving Costdestination set Current Node = Destination Node /* node to which mobile agent (AA) migrates to */ set Adjacent Node Count = Adjacent Node Count + 1 else /* Partial Integration Protocol is satisfied consecutively at the second adjacent migration */ migrate to RMS set Current Node = RMS set Done = True endif endwhile

Fig. 14. An algorithm for mobile agent itinerary determination.

7. Conclusions In this paper, we have presented a multi-layered, middleware-driven, agent-based architecture for supporting mobile-agent-based collaborative processing in sensor networks. The proposed architecture nicely bridges the gap between the software agents and the physical sensor nodes. We have compared the performance of the mobile-agentbased computing model with that of the traditional client/server-based computing model. We can now conclude that in the context of sensor networks, mobile-agent-based collaborative fusion is advantageous over client/serverbased model due to the amount of sensor nodes deployed and the degree of collaboration needed. References [1] G.J. Pottie, Wireless sensor networks, Proceedings of the IEEE Information Theory Workshop (June) (1998) 139–140. [2] I.F. Akyildiz, W. Su, Y. Sankarasubramaniam, E. Cayirci, Wireless sensor networks: a survey, Computer Networks 38 (2002) 393–422. [3] H. Qi, S. Iyengar, K. Chakrabarty, Distributed sensor networks - a review of recent research, Journal of the Franklin Institute 338 (6) (2001) 655–668, Short Survey. [4] D. Estrin, R. Govindan, J. Heidemann, S. Kumar, Next century challenges: scalable coordination in sensor networks, in: Proceedings of the Fifth Annual International Conference on Mobile Computing

P.K. Biswas et al. / Information Fusion 9 (2008) 399–411

[5] [6]

[7]

[8] [9]

[10]

[11]

[12]

[13]

[14]

[15]

and Networks (MobiCOM’99), Seattle, Washington, August 1999, pp. 263-270. N.R. Jennings, An agent-based approach for complex software systems, Communications of the ACM (April) (2001) 35–41. FIPA 97 Specification Part 1: Agent management, Version 2.0, Foundation for Intelligent Physical Agents, 1998, also available from . FIPA 97 Specification Part 2: Agent communication language, Version 2.0, Foundation for Intelligent Physical Agents, 1998, also available from . FIPA 98 Specification 11 V1.0: Agent management support for mobility specification, 1998, also available from . C. Srisathapornphat, C. Jaikaeo, C. Shen, Sensor information networking architecture, in: Proceedings of the 2000 International Workshop on Parallel Processing, Toronto, Canada, August 21–24, 2000, pp. 23–31. M. Baldi, G.P. Picco, Evaluating the tradeoffs of mobile code design paradigms in network management applications, in: Proceedings of the International Conference on Software Engineering (ICSE’98), IEEE Computer Society Press, Silver Spring, MD, 1998. C. Carabelea, O. Boissier, F. Ramparany, Benefits and requirements of using muti-agent systems on smart devices, LNCS 2790, SpringerVerlag, 2003, pp. 1091–1098. A. Lim, Distributed services for information dissemination in selforganizing sensor networks, special issue on distributed sensor networks for real-time systems with adaptive reconfiguration, Journal of Franklin Institute 338 (2001) 707–727. H. Qi, Y. Xu, X. Wang, Mobile-agent-based collaborative signal and information processing in sensor networks, Proceedings of the IEEE 91 (8) (2003) 1172–1183. Y. Xu, H. Qi, Distributed computing paradigms for collaborative signal and information processing in sensor networks, Journal of Parallel and Distributed Computing 64 (8) (2004) 945–959. P.K. Biswas, S. Phoha, A., Middleware-driven architecture for information dissemination in distributed sensor networks, in: Proceedings of the IEEE International Conference on Intelligent Sensors, Sensor Networks and Information Processing (ISSNIP 2004), Melbourne, Australia, December 14–17, 2004, pp. 605–610.

411

[16] P.K. Biswas, M. Schmiedekamp, S. Phoha, An agent-oriented information processing architecture for sensor network applications, International Journal of Ad Hoc and Ubiquitous Computing (IJAHUC), Interscience 1(3) pp. 110–125. [17] P.K. Biswas, H. Qi, Y. Xu, A Mobile-Agent-Based Collaborative Framework for Sensor Network Applications, in: Proceedings of the Third IEEE International Conference on Mobile Ad-hoc and Sensor Systems (MASS‘06/IST-WSN’06 Workshop), Vancouver, BC, October 9–12, 2006, pp. 650–655. [18] F. Chien-Liang, R. Gruia-Catalin, L. Chenyang, Rapid Development and Flexible Deployment of Adaptive Wireless Sensor Network Applications, in: Proceedings of the 24th International Conference on Distributed Computing Systems (ICDCS’05), Columbus, Ohio, June 6–10, 2005, pp. 653–662. [19] A.C. Knoll, Distributed contract networks of sensor agents with adaptive reconfiguration: modeling, simulation, implementation and experiments, Journal of the Franklin Institute 338 (6) (2001) 669–705. [20] R.R. Choudhury, K. Paul, S. Bandyopadhyay, .R. Choudhury, K. Paul, S. Bandyopadhyay, MARP: a multi-agent routing protocol for mobile wireless Ad Hoc networks, Autonomous Agents and MultiAgent Systems, vol. 8, Kluwer Academic Publishers, 2004, pp. 47–68. [21] L. Prasad, S.S. Iyengar, R.L. Rao, Fault-tolerant sensor integration using multi-resolution decomposition, Physical Review E 49 (4) (1994) 3452–3461. [22] H. Qi, S.S. Iyengar, K. Chakrabarty, multi-resolution data integration using mobile agents in distributed sensor networks, IEEE Transactions on Systems, Man, and Cybernetics Part C: Applications and Reviews 31 (3) (2001) 383–391. [23] L. Lamport, R. Shostak, M. Pease, The byzantine generals problem, ACM Transactions Programming Languages and Systems 4 (3) (1982) 382–401. [24] V.B. Misˇic´, J. Misˇic´, Sensing with one or with four? A comparison of two IEEE 802.15.x protocols for use in sensor networks, International Journal of Distributed Sensor Networks 3 (1) (2007) 87–104. [25] The Network Simulator – ns-2, , 2006.