Performance Analysis of Client/Server Versus Agent Based Communication in Wireless Sensor Networks

For Health Applications David Barnes1, Dr. Suresh Sankaranarayanan2 and Dr. Subra Ganesan1

1,Electrical and Computer Engineering Department, Oakland University, Rochester MI, U.S.A. dmbarnes@oakland.edu, ganesan@oakland.edu

2Intelligent Networking Group, Department of Computing, University of West Indies, Kingston, Jamaica pessuresh@hotmail.com

Abstract - This paper presents the performance results in using Client/Server and Agent based communication techniques in wireless sensor networks for health-based applications. The performance study was carried out using an environment comprised of the JADE-LEAP Agent Middleware and the Sun Microsystems SunSpot sensor hardware (via emulation). The performance studied showed that the overall throughput and individual sensor performance seems to be marginally better without the agent based middleware. However, this is misleading since in the ideal system, the entire agent would have moved from device to device rather than having to spend processing time creating a static agent / container on each sensor as was done in our study. A couple of interesting possibilities can be seen from the research carried out. The first would be to utilize a different type of sensor node that is not limited to the MIDP framework in order to allow the JADE-LEAP Pjava version to be used. Another opportunity would be to look into enhancing the MIDP version of JADE-LEAP so that it can support mobility, or finding an alternative agent middleware. Index Terms—Wireless Sensor Networks, Mesh Networks, SunSpot Sensors, JADE-LEAP Agent Middleware, Mobile Agent Technology.

I. INTRODUCTION Applications involving modern Information Technology (IT) have been a growing sector in both the research and consumer based industries. One exciting branch of this research involves the use of wireless sensor networks (WSN) to create innovations in the health sector of industry based on IT disciplines such as Telemedicine, Teleconferencing, and technology based improvements to patient care such as computerized 3-D imaging using ultrasound equipment, and laser eye surgery. WSNs provide a new approach for applications in the health and environmental industries in addition to the original military applications that brought the WSN framework into popularity. The WSN is typically comprised of multiple tiny sensor devices that provide monitoring of physical conditions such as: temperature, movement, pressure, light, and so forth. The use of a remote sensor network would allow for monitoring the condition of a patient in a quasi-static fashion by any doctor or nurse throughout the period of the patient’s treatment. In such an application, these wireless sensors could be employed to directly convey the condition of the patient to the respective doctor or nursing staff via wireless communication to a handheld device. The concept of the hospital staff having a wireless device such as a PDA or cell phone is fairly common place and provides an ideal networking model. In addition to the use

of communication between wireless devices, the patient sensor data could be transferred to any expert doctor via a wireless connection to the internet as well allowing for patient care to be performed on a global basis by the individuals best suited for providing such care. One method to provide this technology in a energy-efficient, fault tolerant approach involves the use of Mobile Agents. These mobile agents are task specific executable stand alone pieces of code that can be moved from location to location. This mobility allows for the reduction in communication cost since the processing function can be moved to the location of the data (the individual sensors performing the data collection) rather than having the data moved to a central location for processing. The agents could also be programmed to function in an efficient manner consistent with the common practices used in the medical profession and the sensor could be placed into a low power mode when activity was not required. In order to truly realize the potential for this application, it is necessary to look at the various routing techniques used in WSN transmission/reception to determine the most suitable technique or a better modified technique to be used when the Agent technology concept is taken into consideration for the health sector. With all this in mind, the remainder of this paper has been arranged in the following fashion. Section 2 provides the background on WSN and the inherent routing techniques, section 3 provides a brief introduction to mobile agents and section 4 discusses our work on agent based routing using the Sun Microsystems SunSpot sensor devices in conjunction with the JADE-LEAP Agent Middleware to create an environment suitable for comparing the performance of routing in a wireless sensor network using client / server based communication versus Agent based communication. Section 6 provides the concluding details. II. WSN BACKGROUND AND ROUTING IN WSNS Our proposed research pertains to the use of a wireless sensor network materialized in the form of a body sensor network monitoring patient status in a health application. In the light of this, we would like to briefly review some of the well known wireless sensor networks which could be conceived as a body sensor network for our application and the routing techniques of wireless sensor networks.

A. Wireless Sensor Networks(WSN)

A wireless sensor network (WSN)[1][2], is a wireless network consisting of spatially distributed autonomous sensor devices to cooperatively monitor the physical or

978-1-4244-3355-1/09/$25.00©2009 IEEE

environmental conditions, such as temperature, sound, vibration, pressure, motion or pollutants, at different locations. This development was originally motivated by military applications such as battlefield surveillance, but has reached many civilian application areas, including environment and habitat monitoring, healthcare applications, home automation, and traffic control. Each sensor node in the network is typically equipped with a radio transceiver, a small microcontroller, and an energy source (usually a small battery). The size and cost constraints on sensor nodes result in a corresponding constraint on resources such as energy, memory, computational speed, and bandwidth. All sensors in the network, as shown in Fig. 1, normally constitute a wireless ad-hoc network and as such each sensor supports a multi-hop routing algorithm. Sensor nodes may be imagined as small micro computers, extremely basic in terms of their interfaces and their components. They usually consist of a processing unit with limited computational power and limited memory, sensors (including specific conditioning circuitry), a communication device (usually radio transceivers or alternatively optical), and a power source usually in the form of a battery. These ad-hoc networks usually utilize a base station that serves as a gate way for the network and typically contain more computational, energy, and communication resources than the individual sensor nodes. These base stations are used to provide the connectivity between the sensor nodes and the end user.

Fig. 1 Wireless Sensor network

B. Routing in WSN

Plenty of routing protocols for WSN are reported in the literature [3]. Any routing protocol is closely related to the architectural model of the WSN used. In any model, there will be three main components. These are the sensor nodes functioning as sources, the sink, and the monitored events. With the exception of a few models, mobile sensors are assumed to be stationary sensor nodes. This assumption is very valid with the WSN proposed for use in a health application since there will be only a few cases where the patients with sensors will be moving. The sensed event can be dynamic or static depending on the application, in our case study of the health application the sensed events are mostly static or quasi-static in nature. Monitoring of such static or quasi static events allow the network to work in a

reactive mode, simply generating data traffic based on queries. Depending on the application of the sensor network, the data delivery can be continuous, event-driven, query-driven, and hybrid [3]. In the continuous delivery model, each sensor sends data periodically for a long duration. In event-drive and query driven models, the transmission of data is triggered when an event occurs or a query is generated by the sink. Only then the transmission of data takes place. Some networks apply a hybrid model using a combination of continuous, event-driven and query-driven data delivery methodologies. The routing protocol is again influenced by the data delivery model, especially with regard to the minimization of energy consumption and route stability. We will now review only those protocols which we think would be helpful for our research project. Data-centric routing [3] seems to be well suited in WSNs used in the health sector. In this routing, the sink sends queries to certain sensors and waits for data from the sensor. It is well known that in this direction, Directed Diffusion [3] routing is a breakthrough in data-centric routing. Many similar protocols have also been proposed either based on Directed Diffusion or following an analogous concept. Some of the hierarchical protocols proposed in the literature designate a cluster-head different from the normal sensors. While some networks have picked cluster-heads from the deployed sensors [10], in other applications a cluster head is a more powerful node than the sensor nodes in terms of energy, bandwidth, and memory. In such cases, the burden of transmission to the sink and aggregation is handled by the cluster-head. Low-Energy Adaptive Clustering Hierarchy (LEACH) [4] is one of the most popular hierarchical routing algorithms for general sensor networks. The idea is to form clusters of the sensor nodes based on the received signal strength and use local cluster heads as routers to the sink. This will save energy since the transmissions will only be done by such cluster heads rather than all sensor nodes. Threshold sensitive Energy Efficient sensor Network protocol (TEEN) [5] is a hierarchical protocol designed to be responsive to sudden changes in the sensed attributes. Responsiveness is important for time-critical applications in the health sector, in which the network operates in a reactive mode. TEEN pursues a hierarchical approach along with the use of a data-centric mechanism. The sensor network architecture is based on a hierarchical grouping where closer nodes form clusters form clusters and this process goes on the second level until the final gate way is reached. After the clusters are formed, the cluster head broadcasts two thresholds to the nodes. These are hard and soft thresholds for sensed attributes. One can adjust both the hard and soft thresholds in order to control the number of packet transmissions. However, TEEN is not a good protocol for applications in which a periodic report is needed since the user may not receive any data if the threshold is not reached. The Adaptive Threshold sensitive Energy Efficient sensor Network protocol (APTEEN) [6] is an extension of TEEN and aims at capturing periodic data collections and reacting to time-critical events. The architecture of APTEEN is the same as in TEEN. When the gate way forms the clusters, the cluster heads broadcast the attributes, the threshold values, and the transmission schedule to all nodes. Cluster

heads also perform data aggregation if needed in order to save energy. APTEEN supports three different query types: historical, to analyze past data values; one-time, to take a snapshot view of the body sensor data; and persistent, to monitor an event for a period of time. Younis et al. [7] have proposed a different hierarchical routing algorithm based on three-tier architecture. Sensors are grouped into clusters prior to network operation. The algorithm employs cluster heads, namely gateways, which are less energy constrained than sensors and assumed to know the location of sensor nodes. Gateways maintain the states of the sensors and sets up multi-hop routes for collecting sensors’ data. The sensor nodes in a cluster can be in one of four main states: sensing only, relaying only, sensing-relaying, and inactive. In the sensing state, the node probes the environment and generates data at a constant rate. In the relaying state, the node does not sense the target but its communications circuitry is on to relay the data from other active nodes. When a node is both sensing and relaying messages from other nodes, it is considered in the sensing-relaying state. Otherwise, the node is considered inactive and can turn off its sensing and communication circuitry. Utilizing the knowledge of these routing protocols, we will investigate a new routing protocol appropriate for the health monitoring application. III. MOBILE AGENTS A. Mobile Agent Technology

The mobile agents [8-17] have evolved from the Remote Procedure Call (RPC) and Remote Evaluation (REV) concepts as shown in Fig. 2. In RPC, the data is transmitted between the client and server in both directions. In REV, code is sent from the client to the server and data returned. In contrast, a mobile agent is a program (encapsulating code, data, and context) sent by a client to a server. Unlike a procedure call, it does not have to return its results to the client. It could migrate to other servers, transmit information back to its origin or migrate back to the client if appropriate. It thus has more autonomy than a simple procedure call. The difference then between mobile agents and stored procedures are that stored procedures lack many of the features common to agents such as autonomy, flexibility and mobility. Stored procedures are basically static entities – once they are uploaded to a server they belong to that server. A stored procedure cannot migrate from server to server, dragging along the incomplete transaction or calculation with it, whereas a mobile agent can and does. In short Mobile Agents are computational software processes capable of roaming wide area networks (WAN’s) such as the WWW, interacting with foreign hosts, gathering information on behalf of its owner and coming back to the starting point once the predefined duties have been completed. The advantages of mobile agents [8] are to reduce communication costs by reducing bandwidth requirements as opposed to costly network connections via client/server architectures. Mobile agents also limit the local resources requirement by returning only the required data set that the user requested which allows for increased coordination between node requests. Mobile agents also allow for asynchronous computing in which a mobile agent can be initiated and the results are posted in one’s Inbox at a later date. In summary, mobile agents provide great flexibility

for development of free market trading services as well as architectural design and provide a shift in paradigm of the design process. Taking all the above points into consideration we will investigate the routing protocol for our health application and also compare the performance of the Client/Server versus Agent based routing. IV. AGENT BASED ROUTING – OUR PROPOSAL The intention of our project is to perform a comparison of two network methodologies using emulations of the Sun Microsystems Sun SPOT device [18]. The Sun SPOT device is a small wireless sensor that is programmed almost entirely in Java. The advantage of an embedded device that utilizes the Java programming language is the ability to open the device software development to a larger portion of the research / commercial environment without requiring any specialized embedded systems development skills. Another advantage from the aspect of this project is that by utilizing the SunSpot Manager software (part of the Sun SPOT SDK package), the entire network topology can be created within an emulation environment utilizing multiple virtual machines running solely on a personal computer. The Sun SPOTS will be used to create two different scenarios. The first scenario will be to connect 4 or 5 Sun SPOT sensors in a star based network with a central cluster head coordinating the operation of the sensors via a server-client topology as shown in Fig.3. The second scenario will be to use the same 4 or 5 Sun SPOT sensor emulations and a cluster head / base station gateway with a mobile agent based middleware in place to allow a comparison of the performance of an agent based topology versus a client-server technology. The expectation is that the agent based model will show increased performance due to the decreased communication requirements of the network. This agent based topology is illustrated in Fig.4. The agent based model would allow for a ring based communication network where the agents can carry instructions and programs from node to node of the sensor network without requiring a communication link between the cluster head and each of the individual sensor nodes at all times. The agent based model will utilize the ring based network utilizing the agents to pass data through the other sensors or directly to the cluster head depending on the message type. Due to the nature of our health application the agent based model will follow the APTEEN design approach allowing for both periodic data transfer as well as event triggered communications between the nodes while minimizing the power consumption of the network. The two topologies will be emulated in the Sun SPOT World environment on a Windows based PC. The emulated sensors will utilize the same Java SQUAWK virtual machine as would be found on the true physical device. In addition the agent based software will include

Fig. 2 Evolution of Mobile agents

CH

Cluster

Sensors

the use of the JADE[19] (Java Agent Development Environment) with the LEAP add-on which adapts the JADE agents for use in smaller devices by enabling the agent kernel in a smaller run-time environment minimizing the required code foot-print needed for the agent middleware.

SunSpot Sensor

SunSpot Sensor

SunSpot Sensor

SunSpot Sensor SunSpot Sensor

Cluster Head

Fig. 3 Client-Server Model

V. IMPLEMENTATION DETAILS AND RESULTS A. Client Server Based Implementation-scenario1

To perform the implementation for the first scenario, two different JAVA applications were developed. The first application was the Client node. This application was designed to run as a SunSPOT application (Java Midlet based application) using the template provided with the SDK. This application performed the duty of the client cluster head sending a query to each of the emulated sensors requesting the current temperature data from each sensor in the network. The second application developed was based on the SPOT application template and once deployed to the sensor nodes and started, would listen for radio requests from the client and upon reception perform a temperature sensor reading and then transmit the data to the requesting Client node (providing the server side of the client / server network). The Sun SPOT SDK provides a predefined software suite providing API functions to access both the radio and the temperature sensor of the SPOT devices. These functions were used to create a Midlet with two functions: listen for radio requests for temperature data, and perform reading of the temperature data via a temperature sensor connected to the SPOT Analog To Digital (ATD) port. This voltage is converted to an integer value representing the current temperature as seen at the temperature sensor location. In

the SpotWorld Emulation environment a GUI control is provided that allows manipulating the value that is returned from the API call for the temperature sensor value. The Cluster Head node, opens a broadcast port so that it can be notified of the available sensor nodes, it then sends a request to all sensor nodes to report their temperature readings utilizing the radio and packet handling classes. The goal of this was to start a single cluster head sensor node and multiple sensor nodes so that performance measurements could be taken on the application. The agreed to measurements were Total processing time (Tp) calculated as the time taken to process the task at each sensor, and Throughput (Th) which would be the time for all the tasks over a given time T. The setup of the emulator is shown in Fig. 5. The results of running the test are summarized below.

RUN1: Time from Client Request to Response Sensor 1 : 781 milliseconds Sensor 2 : 1241 milliseconds Sensor 3: 1531 milliseconds Sensor 4: 1828 milliseconds Time from application start to all responses received: 32250 milliseconds Total Processing Time =5381 milliseconds Throughput = 5381/32250 = 16.7% RUN2: Time from Client Request to Response Sensor 1 : 0 milliseconds Sensor 2 : 375 milliseconds Sensor 3: 766 milliseconds Sensor 4: 1094 milliseconds Time from application start to all responses received: 22063 milliseconds Total Processing Time =2235 milliseconds Throughput = 2235/22063 = 10.13%

The measurements showed some variance which is attributed to the fact that the test was performed in an emulated setting so each sensor node was a separate virtual machine running inside of the Sun Microsystems Spot Emulator software and shared processing power with all emulated nodes as well as all background windows tasks. The performance values should increase when using the physical SunSpot devices.

B. Agent Based Implementation-scenario 2

To perform the implementation for the second scenario, the JADE-LEAP Agent middleware was used to create an agent platform on the sensor nodes. Each sensor node started a split container with a single agent that had a single event based behavior. This agent would simply wait for a message requesting the temperature and then call the read temperature function to get the sensor data. This data is then added to an ACL message frame and sent back to the requester. The hope was to use a mobile agent to travel to each sensor node and perform the task of gathering the temperature and then return to the cluster head node, as described previously. However, the JADE_LEAP architecture for MIDP devices does not support agent mobility at this time, and the chosen SunSpot sensors are MIDP based devices. As a result the decision was made to utilize static agents and pass the data via the FIPA standard message passing architecture. [20] Due to the nature of using wireless sensors, the messages still required the use

Fig. 4 Agent Based Model

of the onboard radios, and packet handling as a result, the performance of the overall application was slower due to adding the agent communication layer on top of the sensor radio communication layer whereas the client server scenario was to simply implement the process using the radio layer and calls to the temperature sensor function. The results of the test for scenario two are summarized below and the setup is shown in Fig. 6.

RUN1: Time from Client Request to Response Sensor 1 : 925 milliseconds Sensor 2 : 1340 milliseconds Sensor 3: 1965 milliseconds Sensor 4: 2381 milliseconds Time from application start to all responses received: 65380 milliseconds Total Processing Time =6611 milliseconds Throughput = 6611/65380 = 10.11% RUN2: Time from Client Request to Response Sensor 1 : 785 milliseconds Sensor 2 : 1115 milliseconds Sensor 3: 1506 milliseconds Sensor 4: 1934 milliseconds Time from application start to all responses received: 59863 milliseconds Total Processing Time =5340 milliseconds Throughput = 5340/59863 = 8.92%

C. Analysis of the results

Similar to the client based implementation, the results above show some discrepancy in performance due to the fact the emulation is running in virtual machines on top of the Windows operating system, so even though each sensor has its own thread, the devices are sharing processor time with the true hardware of the windows PC. As shown, the Agent based scenario appears to have a longer period between the start of the application and the collection of data from the sensor nodes, this is due to overhead of starting an agent platform on each node and registering it with the cluster head before taking the data reads. In addition the actual time for each sensor reading is longer which is due to the agent middleware layer that is running on top of the device communication layer while the client server version simply uses the device communication layer.

An analysis of the results shows that the average throughput for client server emulation was 13.42% while the average throughput for the agent based method was 9.52%. This shows that that use of static agents reduces the throughput of the application. The decreased throughput can be seen by looking at the average time it takes for the sensor responses in both applications. In the client-server version the average sensor response time from query to response is 365.25 milliseconds where as the average response time in the agent based version is 539.375 milliseconds. This delay can be attributed to the overhead of running the agent container and static agent on top of the device specific applications for reading the temperature sensor, and transmitting the data via radio.

Fig. 6 Agent Based Implementation

Fig.5. Client Server Based Implementation

VI. CONCLUSION The concept of using an Agent based communication topology for the health application is sound; however, the chosen SunSpot Sensor device is currently not capable of supporting mobility with the chosen agent middleware JADE-LEAP. The resulting performance results showed that the overall throughput and individual sensor performance was marginally better without the agent based middleware. However, this is misleading since we were forced to change the proposed architecture during the project. In the ideal system, the entire agent would have moved from device to device rather than having to spend processing time creating a static agent / container on each sensor. The maintenance of the container required processing power, and the limitation of no mobility required handling the agent messaging protocol in the same fashion as normal messages (had to be packed and transferred via the physical radio layer). Ideally, the agent code / data would have traveled from device to device resulting in slightly more time in transmission but less overhead for each of the individual devices. A couple of interesting possibilities can be seen from the research done in this exercise. The first would be to utilize a different type of sensor node that is not limited to the MIDP framework in order to allow the JADE-LEAP Pjava version to be used. The Pjava framework has been used successfully in cell phone applications and supports agent mobility. Another opportunity would be to look into enhancing the MIDP version of JADE-LEAP so that it can support mobility, or finding an alternative agent middleware. It is expected in future these things would be accomplished in sunspot emulator and Agent middleware so that our agent based architecture can be implemented. But with the existing constraints it would appear that it is better from a performance / throughput perspective to utilize the provided SunSPOT SDK libraries and use the sensors in a client / server architecture.

REFERENCES [1] John A. Stankovic, “Research Challenges for

Wireless sensor Networks”, Available from www.cs.virginia. edu/sigbed/archives/stan kovic.pdf , 2005

[2] Mohammad I and Imad M(2006),”Handbook of Sensor Networks: Compact Wireless and Wired Sensing systems”, CRC Press

[3] Akkaya K and Younis M; “A survey on routing protocols for wireless sensor networks”, Adhoc Networks(Elsvier), 3(2005), pp/ 325-349.

[4] Heinzelman A, Chandrakasan and Balakrishnan H., “Energy Efficient Communication Protocols for Wireless Microsensor Networks”, Proceedings of Hawaiian International Conference on System Science, 2000.

[5] Arati M and Agarwal DP, “TEEN : A Routing protocol for Enhanced Energy Efficiency in Wireless Sensor networks”, 1st International Workshop on Parallel and distributed Computing, Issues in wireless Networks and Mobile Computing, 2001.

[6] Arati M and Agarwal DP, “APTEEN : A Hybrid protocol for Efficient Routing and Comprehensive Information Retreival in Wireless Sensor networks”,

Proceedings of the 16th International Parallel and Distributed Processing Symposium, 2002.

[7] Younis M, et al., “Energy Aware routing cluster

based Sensor Networks”, Proceedings of the 10th IEEE/ACM Intl. Symposium on modelling, analysis and simulation of computer and telecommunication systems (MASCOTS 2002), 2002.

[8] White JE, “Mobile Agents-white Paper”, General Magic, Available from: http://www/klynch.com/ documents/agents ,1996

[9] Baldi M, et al., "Exploiting Code Mobility in Decentralized and Flexible Network Management", Proceedings of the First International Workshop on Mobile Agents, Berlin, Germany, 7-8 April 1997, pp. 13-26.

[10] Carzaniga A, et al., "Designing distributed applications with mobile code paradigms", Proceedings of the 19th International Conference on Software Engineering (ICSE'97), IEEE and ACM Sponsored, Boston, Massachusetts, USA, 17-23 May 1997, pp. 22-32

[11] Ghezzi C and Vigna G, "Mobile Code Paradigms and Technologies: A Case Study", Proceedings of the First International Workshop on Mobile Agents, Berlin, Germany, 7-8 April 1997, pp. 39-49.

[12] Puliafito A and Tomarchio O, "Advanced Network Management Functionalities through the use of Mobile Software Agents", Proceedings of 3rd International Workshop on Intelligent Agents for Telecommunication Applications (IATA'99), Stockholm (Sweden), 9 -10 August 1999, pp. 33-45.

[13] Sankaranarayanan V and Suresh S, "Policy implementation using Mobile Agents in the distributed Network Management domain", IEEE International Conference On Networking ‘ICN01’, Colmar, France, June 11-13, 2001

[14] Suresh S., “Applications of Policy and Mobile Agents in the Management of Computer Networks”, M.S (by Research) Thesis, Anna University, Chennai, India, 2001.

[15] Suresh S., “Studies in Agent based IP Traffic Congestion Management in DiffServ Networks”, PhD Thesis, University of South Australia, Adelaide, Australia, 2006.

[16] Suresh S, “Policy based Agent Architecture for Sensor based Mesh Networks- Health Care Monitoring”- Proceedings of the International Conference on High Performance Computing, Networking and Communication Systems (HPCNCS-08), Florida, USA, July 7-10 2008. Pp.75-81, ISBN:978-1-60651-004-9.

[17] Suresh S and Subra Ganesan,“A Layered Architecture for Agent based Wireless Sensor Mesh Networks- Applications in Health Care”, Accepted in International Journal for Embedded Systems and Computer Engineering, 2008

[18] Caicedo A, et al.,(2007), “SunSpot: Java Technology based Wireless Sensor Networks.

[19] Fabio G, et.al., (2003), “JADE White Paper”, Telecom Italia Lab.

[20] Fabio G, et al., (2007), “Developing MultiAgent System with JADE”, John Wiley & Sons