+ All Categories
Home > Documents > Handling selfishness in replica allocation over a mobile ad hoc network.bak

Handling selfishness in replica allocation over a mobile ad hoc network.bak

Date post: 15-Jan-2015
Category:
Upload: ieeexploreprojects
View: 1,606 times
Download: 1 times
Share this document with a friend
Description:
 
Popular Tags:
14
Handling Selfishness in Replica Allocation over a Mobile Ad Hoc Network Jae-Ho Choi, Kyu-Sun Shim, SangKeun Lee, and Kun-Lung Wu, Fellow, IEEE Abstract—In a mobile ad hoc network, the mobility and resource constraints of mobile nodes may lead to network partitioning or performance degradation. Several data replication techniques have been proposed to minimize performance degradation. Most of them assume that all mobile nodes collaborate fully in terms of sharing their memory space. In reality, however, some nodes may selfishly decide only to cooperate partially, or not at all, with other nodes. These selfish nodes could then reduce the overall data accessibility in the network. In this paper, we examine the impact of selfish nodes in a mobile ad hoc network from the perspective of replica allocation. We term this selfish replica allocation. In particular, we develop a selfish node detection algorithm that considers partial selfishness and novel replica allocation techniques to properly cope with selfish replica allocation. The conducted simulations demonstrate the proposed approach outperforms traditional cooperative replica allocation techniques in terms of data accessibility, communication cost, and average query delay. Index Terms—Mobile ad hoc networks, degree of selfishness, selfish replica allocation. Ç 1 INTRODUCTION M OBILE ad hoc networks (MANETs) have attracted a lot of attention due to the popularity of mobile devices and the advances in wireless communication technologies [13], [14], [31]. A MANET is a peer-to-peer multihop mobile wireless network that has neither a fixed infrastructure nor a central server. Each node in a MANET acts as a router, and communicates with each other. A large variety of MANET applications have been developed [27]. For example, a MANET can be used in special situations, where installing infrastructure may be difficult, or even infeasible, such as a battlefield or a disaster area. A mobile peer-to-peer file sharing system is another interesting MANET application [9], [19]. Network partitions can occur frequently, since nodes move freely in a MANET, causing some data to be often inaccessible to some of the nodes. Hence, data accessibility is often an important performance metric in a MANET [12]. Data are usually replicated at nodes, other than the original owners, to increase data accessibility to cope with frequent network partitions. A considerable amount of research has recently been proposed for replica allocation in a MANET [12] [13] [32]. In general, replication can simultaneously improve data accessibility and reduce query delay, i.e., query response time, if the mobile nodes in a MANET together have sufficient memory space to hold both all the replicas and the original data. For example, the response time of a query can be substantially reduced, if the query accesses a data item that has a locally stored replica. However, there is often a trade-off between data accessibility and query delay, since most nodes in a MANET have only limited memory space [32]. For example, a node may hold a part of the frequently accessed data items locally to reduce its own query delay. However, if there is only limited memory space and many of the nodes hold the same replica locally, then some data items would be replaced and missing. Thus, the overall data accessibility would be decreased. Hence, to maximize data accessibility, a node should not hold the same replica that is also held by many other nodes. However, this will increase its own query delay. A node may act selfishly, i.e., using its limited resource only for its own benefit, since each node in a MANET has resource constraints, such as battery and storage limitations. A node would like to enjoy the benefits provided by the resources of other nodes, but it may not make its own resource available to help others. Such selfish behavior can potentially lead to a wide range of problems for a MANET. Existing research on selfish behaviors in a MANET mostly focus on network issues [2], [11], [20]. For example, selfish nodes may not transmit data to others to conserve their own batteries. Although network issues are important in a MANET, replica allocation is also crucial, since the ultimate goal of using a MANET is to provide data services to users. In this paper, we address the problem of selfishness in the context of replica allocation in a MANET, i.e., a selfish node may not share its own memory space to store replica for the benefit of other nodes. We can easily find such cases in a typical peer-to-peer application. For example, in Gnutella [1], nearly 70 percent of users do not share their storage for the benefit of others. The number of selfish users has increased to 85 percent of all Gnutella users over five years [10]. In this paper, we shall refer to such a problem as the selfish replica allocation. Simply, selfish replica allocation refers to a node’s noncooperative action, such that the node refuses to cooperate fully in sharing its memory space with other nodes. To our knowledge, this work is one of few 278 IEEE TRANSACTIONS ON MOBILE COMPUTING, VOL. 11, NO. 2, FEBRUARY 2012 . J.-H. Choi, K.-S. Shim, and S. Lee are with the Department of Computer Science and Engineering, Korea University, 1, 5-ka, Anam-dong, Sungbuk-ku, Seoul 136-701, South Korea. E-mail: {redcolor25, bluesks, yalphy}@korea.ac.kr. . K.-L. Wu is with the IBM T.J. Watson Research Center, 19 Skyline Drive, Hawthorne, NY 10532. E-mail: [email protected]. Manuscript received 11 Feb. 2010; revised 2 Jan. 2011; accepted 10 Jan. 2011; published online 17 Mar. 2011. For information on obtaining reprints of this article, please send e-mail to: [email protected], and reference IEEECS Log Number TMC-2010-02-0067. Digital Object Identifier no. 10.1109/TMC.2011.57. 1536-1233/12/$31.00 ß 2012 IEEE Published by the IEEE CS, CASS, ComSoc, IES, & SPS http://ieeexploreprojects.blogspot.com
Transcript
Page 1: Handling selfishness in replica allocation over a mobile ad hoc network.bak

Handling Selfishness in Replica Allocationover a Mobile Ad Hoc Network

Jae-Ho Choi, Kyu-Sun Shim, SangKeun Lee, and Kun-Lung Wu, Fellow, IEEE

Abstract—In a mobile ad hoc network, the mobility and resource constraints of mobile nodes may lead to network partitioning or

performance degradation. Several data replication techniques have been proposed to minimize performance degradation. Most of

them assume that all mobile nodes collaborate fully in terms of sharing their memory space. In reality, however, some nodes may

selfishly decide only to cooperate partially, or not at all, with other nodes. These selfish nodes could then reduce the overall data

accessibility in the network. In this paper, we examine the impact of selfish nodes in a mobile ad hoc network from the perspective of

replica allocation. We term this selfish replica allocation. In particular, we develop a selfish node detection algorithm that considers

partial selfishness and novel replica allocation techniques to properly cope with selfish replica allocation. The conducted simulations

demonstrate the proposed approach outperforms traditional cooperative replica allocation techniques in terms of data accessibility,

communication cost, and average query delay.

Index Terms—Mobile ad hoc networks, degree of selfishness, selfish replica allocation.

Ç

1 INTRODUCTION

MOBILE ad hoc networks (MANETs) have attracted a lotof attention due to the popularity of mobile devices

and the advances in wireless communication technologies[13], [14], [31]. A MANET is a peer-to-peer multihop mobilewireless network that has neither a fixed infrastructure nora central server. Each node in a MANET acts as a router,and communicates with each other. A large variety ofMANET applications have been developed [27]. Forexample, a MANET can be used in special situations,where installing infrastructure may be difficult, or eveninfeasible, such as a battlefield or a disaster area. A mobilepeer-to-peer file sharing system is another interestingMANET application [9], [19].

Network partitions can occur frequently, since nodesmove freely in a MANET, causing some data to be ofteninaccessible to some of the nodes. Hence, data accessibilityis often an important performance metric in a MANET [12].Data are usually replicated at nodes, other than the originalowners, to increase data accessibility to cope with frequentnetwork partitions. A considerable amount of research hasrecently been proposed for replica allocation in a MANET[12] [13] [32].

In general, replication can simultaneously improve dataaccessibility and reduce query delay, i.e., query responsetime, if the mobile nodes in a MANET together havesufficient memory space to hold both all the replicas andthe original data. For example, the response time of a querycan be substantially reduced, if the query accesses a data

item that has a locally stored replica. However, there isoften a trade-off between data accessibility and query delay,since most nodes in a MANET have only limited memoryspace [32]. For example, a node may hold a part of thefrequently accessed data items locally to reduce its ownquery delay. However, if there is only limited memoryspace and many of the nodes hold the same replica locally,then some data items would be replaced and missing. Thus,the overall data accessibility would be decreased. Hence, tomaximize data accessibility, a node should not hold thesame replica that is also held by many other nodes.However, this will increase its own query delay.

A node may act selfishly, i.e., using its limited resourceonly for its own benefit, since each node in a MANET hasresource constraints, such as battery and storage limitations.A node would like to enjoy the benefits provided by theresources of other nodes, but it may not make its ownresource available to help others. Such selfish behavior canpotentially lead to a wide range of problems for a MANET.Existing research on selfish behaviors in a MANET mostlyfocus on network issues [2], [11], [20]. For example, selfishnodes may not transmit data to others to conserve their ownbatteries. Although network issues are important in aMANET, replica allocation is also crucial, since the ultimategoal of using a MANET is to provide data services to users.

In this paper, we address the problem of selfishness inthe context of replica allocation in a MANET, i.e., a selfishnode may not share its own memory space to store replicafor the benefit of other nodes. We can easily find such casesin a typical peer-to-peer application. For example, inGnutella [1], nearly 70 percent of users do not share theirstorage for the benefit of others. The number of selfish usershas increased to 85 percent of all Gnutella users over fiveyears [10]. In this paper, we shall refer to such a problem asthe selfish replica allocation. Simply, selfish replica allocationrefers to a node’s noncooperative action, such that the noderefuses to cooperate fully in sharing its memory space withother nodes. To our knowledge, this work is one of few

278 IEEE TRANSACTIONS ON MOBILE COMPUTING, VOL. 11, NO. 2, FEBRUARY 2012

. J.-H. Choi, K.-S. Shim, and S. Lee are with the Department of ComputerScience and Engineering, Korea University, 1, 5-ka, Anam-dong,Sungbuk-ku, Seoul 136-701, South Korea.E-mail: {redcolor25, bluesks, yalphy}@korea.ac.kr.

. K.-L. Wu is with the IBM T.J. Watson Research Center, 19 Skyline Drive,Hawthorne, NY 10532. E-mail: [email protected].

Manuscript received 11 Feb. 2010; revised 2 Jan. 2011; accepted 10 Jan. 2011;published online 17 Mar. 2011.For information on obtaining reprints of this article, please send e-mail to:[email protected], and reference IEEECS Log Number TMC-2010-02-0067.Digital Object Identifier no. 10.1109/TMC.2011.57.

1536-1233/12/$31.00 � 2012 IEEE Published by the IEEE CS, CASS, ComSoc, IES, & SPS

http://ieeexploreprojects.blogspot.com

Page 2: Handling selfishness in replica allocation over a mobile ad hoc network.bak

works [18] [25] to cope with selfish nodes in the context of

replica allocation over a MANET.Fig. 1 illustrates an existing replica allocation scheme,

DCG [12], where nodes N1; N2; . . . ; N6 maintain their

memory space M1;M2; . . . ;M6, respectively, with the access

frequency information in Table 1 (In Fig. 1, a straight line

denotes a wireless link, a gray rectangle denotes an original

data item, and a white rectangle denotes a replica allocated.

In Table 1, the gray colored area shows three data items that

are accessed frequently by N3 and N4 ). As shown in Fig. 1,

DCG seeks to minimize the duplication of data items in a

group to achieve high data accessibility.Let us consider the case where N3 behaves “selfishly” by

maintaining M 03, instead of M3, to prefer the locally

frequently accessed data for low query delay. In the original

case, D3, D9, and D2 were allocated to N3. However, due to

the selfish behavior, D3, D5, and D2, the top three most

locally frequently accessed items, are instead maintained in

local storage. Thus, other nodes in the same group, i.e., N1,

N2, and N4, are no longer able to access D9. This showcases

degraded data accessibility, since N1, N2, and N4 cannot

fully leverage N3’s memory space as intended in coopera-

tive replica sharing.As another example, a node may be only “partially

selfish” in a MANET. For instance, node N4 may want tolocally hold D2, one of the locally frequently accessed dataitems. In this case, N4 uses only a part of its storage for itsown frequently accessed data, while the remaining part isfor the benefit of overall data accessibility. Thus, N4 maydecide to maintain M 0

4, instead of M4. Even with onlypartial selfishness, data accessibility is still degraded, sincethe other nodes in the same group, i.e., N1, N2, and N3,cannot access D10.

We believe that the partially selfish nodes (e.g., N4 in

Fig. 1) should also be taken into account, in addition to the

fully selfish nodes (e.g., N3 in Fig. 1), to properly handle the

selfish replica allocation problem. We therefore need to

measure the “degree of selfishness” to appropriately handle

the partially selfish nodes. Motivated by this concept of

“partial selfishness,” we borrow the notion of credit risk (CR)

[22] from economics to detect selfish nodes. Since the credit

risk is calculated from several selfishness features in this

paper, it can measure the degree of selfishness elaborately.

In our scheme, a node can measure the degree of selfishness

of another node, to which it is connected by one or multiple

hops in a MANET.

We devise novel replica allocation techniques with thedeveloped selfish node detection method. They are basedon the concept of a self-centered friendship tree (SCF-tree) andits variation to achieve high data accessibility with low-communication cost in the presence of selfish nodes. TheSCF-tree is inspired by our human friendship managementin the real world. In the real world, a friendship, which is aform of social bond, is made individually [4]. For example,although A and B are friends, the friends of A are notalways the same as the friends of B. With the help of SCF-tree, we aim to reduce the communication cost, while stillachieving good data accessibility. The technical contribu-tions of this paper can be summarized as follows:

. Recognizing the selfish replica allocation problem:We view a selfish node in a MANET from theperspective of data replication, and recognize thatselfish replica allocation can lead to degraded dataaccessibility in a MANET.

. Detecting the fully or the partially selfish nodeseffectively: We devise a selfish node detectionmethod that can measure the degree of selfishness.

. Allocating replica effectively: We propose a set ofreplica allocation techniques that use the self-centered friendship tree to reduce communicationcost, while achieving good data accessibility.

. Verifying the proposed strategy: The simulationresults verify the efficacy of our proposed strategy.

The remainder of this paper is organized as follows:Section 2 describes the system model and the nodebehavior model from the viewpoint of selfish replicaallocation. The proposed detection method and the replicaallocation techniques are presented in Section 3. Section 4evaluates the performance of our strategy. We brieflyoverview related work, and conclude the paper in Sections 5and 6, respectively.

2 PRELIMINARIES

2.1 System Model

In this paper, we assume that each node has limited localmemory space and acts as a data provider of several dataitems and a data consumer. Each node holds replicas of dataitems, and maintains the replicas in local memory space.The replicas are relocated in a specific period. There are mnodes, N1; N2; . . . ; Nm and no central server determines the

CHOI ET AL.: HANDLING SELFISHNESS IN REPLICA ALLOCATION OVER A MOBILE AD HOC NETWORK 279

TABLE 1Access Frequency of Nodes (Excerpt from [12])

Fig. 1. Example of selfish replica allocation (excerpt from [12]).

http://ieeexploreprojects.blogspot.com

Page 3: Handling selfishness in replica allocation over a mobile ad hoc network.bak

allocation of replica. Any node freely joins and organizes anopen MANET. We model a MANET in an undirected graphG ¼ ðIN; ILÞ that consists of a finite set of nodes, IN, and afinite set of communication links, IL, where each element is atuple ðNj;NkÞ of nodes in the network.

To focus on the selfish replica allocation problem, wedo not consider selfishness in data forwarding throughoutthis paper. We make the following assumptions, similar tothose in [12].

. Each node in a MANET has a unique identifier. Allnodes that are placed in a MANET are denoted byN ¼ fN1; N2; . . . ; Nmg, where m is the total numberof nodes.

. All data items are of equal size, and each data item isheld by a particular node as its original node. Eachdata item has a unique identifier, and the set of alldata items is denoted by D ¼ fD1; D2; . . . ; Dng,where n is the total number of data items.

. Each node Ni ð1 � i � mÞ has limited memory spacefor replica and original data items. The size of thememory space is Si. Each node can hold only C,where 1 < C < n, replica in its memory space.

. Data items are not updated. This assumption is forthe sake of simplicity, i.e., we do not have to addressdata consistency or currency issues. Applicationssatisfying this feature include digging investigationand weather information [12].

. Each node Ni ð1 � i � mÞ has its own accessfrequency to data item Dj 2 D ð1 � j � nÞ, AFj

i .The access frequency does not change.

. Each node moves freely within the maximumvelocity.

When a node Ni makes an access request to a data item(i.e., issuing a query), it checks its own memory space first.The request is successful when Ni holds the original orreplica of the data item in its local memory. If it does nothold the original or replica, the request will be broadcast.1

The request is also successful when Ni receives any replyfrom at least one node connected to Ni with one hop ormultiple hops, which holds the original or replica of thetargeted data item. Otherwise, the request, or queryprocessing, fails.

When a node Ni receives a data access request, it either1) serves the request by sending its original or replica if itholds the target data item (the data may go through multiplehops before reaching the requester), or 2) forward the requestto its neighbors if it does not hold the target data item.

2.2 Node Behavior Model

The work [23] considers only binary behavioral states forselfish nodes from the network routing perspective: selfishor not (i.e., forwarding data or not). As mentioned inSection 1, it is necessary to further consider the partial

selfish behavior to handle the selfish replica allocation.Therefore, we define three types of behavioral states fornodes from the viewpoint of selfish replica allocation2:

. Type-1 node: The nodes are nonselfish nodes. Thenodes hold replicas allocated by other nodes withinthe limits of their memory space.

. Type-2 node: The nodes are fully selfish nodes. Thenodes do not hold replicas allocated by other nodes,but allocate replicas to other nodes for theiraccessibility.

. Type-3 node: The nodes are partially selfish nodes.The nodes use their memory space partially forallocated replicas by other nodes. Their memoryspace may be divided logically into two parts: selfishand public area. These nodes allocate replicas toother nodes for their accessibility.

The detection of the type-3 nodes is complex, becausethey are not always selfish. In some sense, a type-3 nodemight be considered as nonselfish, since the node sharespart of its memory space. In this paper, however, we haveconsidered it as (partial) selfish, because the node also leadsto the selfish replica allocation problem, as described inSection 1. Note that selfish and nonselfish nodes performthe same procedure when they receive a data accessrequest, although they behave differently in using theirmemory space.

3 PROPOSED STRATEGY

3.1 Overview

Our strategy consists of three parts: 1) detecting selfishnodes, 2) building the SCF-tree, and 3) allocating replica. Ata specific period, or relocation period [12], each nodeexecutes the following procedures:

. Each node detects the selfish nodes based on creditrisk scores.

. Each node makes its own (partial) topology graph andbuilds its own SCF-tree by excluding selfish nodes.

. Based on SCF-tree, each node allocates replica in afully distributed manner.

The CR score is updated accordingly during the queryprocessing phase. We borrow the notion of credit risk fromeconomics to effectively measure the “degree of selfish-ness.” In economics, credit risk is the measured risk of lossdue to a debtor’s nonpayment of a loan. A bank examinesthe credit risk of an applicant prior to approving the loan.The measured credit risk of the applicant indicates if he/sheis creditworthy. We take a similar approach. A node wantsto know if another node is believable, in the sense that areplica can be paid back, or served upon request to share amemory space in a MANET.

With the measured degree of selfishness, we propose anovel tree that represents relationships among nodes in aMANET, for replica allocation, termed the SCF-tree. TheSCF-tree models human friendship management in the real

280 IEEE TRANSACTIONS ON MOBILE COMPUTING, VOL. 11, NO. 2, FEBRUARY 2012

1. Note that if the where-to-allocate-replica information is available to anode during the replica allocation phase, unicast may be an efficient way interms of communication cost. However, unicast may not be efficient fromthe viewpoint of query processing even in this case, since, if a node unicastsa request, the request is likely to fail frequently due to the network topologydynamics in a MANET. Thus, most research work [12] [13] [14] [32] onreplica allocation over a MANET assumes broadcast-based query proces-sing rather than a unicast-based one.

2. We separate type-2 nodes from type-3 nodes, because they behavedifferently in using memory space, although type-2 and type-3 can be easilycombined by defining the size of the shared memory space, as a continuousscale, say, where 0 implies type-2 and the other values imply type-3.

http://ieeexploreprojects.blogspot.com

Page 4: Handling selfishness in replica allocation over a mobile ad hoc network.bak

world. The key strength of the SCF-tree-based replica

allocation techniques is that it can minimize the commu-

nication cost, while achieving high data accessibility. This is

because each node detects selfishness and makes replica

allocation at its own discretion, without forming any group

or engaging in lengthy negotiations.

3.2 Detecting Selfish Node

The notion of credit risk can be described by the following

equation:

Credit Risk ¼ expected risk

expected value: ð1Þ

In our strategy, each node calculates a CR score for each

of the nodes to which it is connected. Each node shall

estimate the “degree of selfishness” for all of its connected

nodes based on the score. We first describe selfish features

that may lead to the selfish replica allocation problem to

determine both expected value and expected risk.Selfish features are divided into two categories: node-

specific and query processing-specific. Node-specific featurescan be explained by considering the following case: Aselfish node may share part of its own memory space, or asmall number of data items, like the type-3 node. In thiscase, the size of shared memory space and/or the numberof shared data items can be used to represent the degree ofselfishness. In our approach, the size of Nk’s sharedmemory space, denoted as SSki , and the number of Nk’sshared data items, denoted as NDk

i , observed by a node Ni,are used as node-specific features.3 Note that both SSkiand NDk

i are Ni’s estimated values, since Nk, which may beselfish or not, does not necessarily let Ni know the numberof shared data items or size of the shared memory space.The node-specific features can be used to represent theexpected value of a node. For instance, when node Ni

observes that node Nk shares large SSki and NDki , node Nk

may be treated as a valuable node by node Ni.As the query processing-specific feature, we utilize the

ratio of selfishness alarm of Nk on Ni, denoted as Pki , which is

the ratio of Ni’s data request being not served by theexpected node Nk due to Nk’s selfishness in its memory space(i.e., no target data item in its memory space).4 Thus, thequery processing-specific feature can represent the expectedrisk of a node. For instance, when Pk

i gets larger, node Ni

will treat Nk as a risky node because a large Pki means that

Nk cannot serve Ni’s requests due to selfishness in itsmemory usage. To effectively identify the expected node (s),Ni should know the (expected) status of other nodes’memory space. Our SCF-tree-based replica allocationtechniques, fortunately, support this assumption. This willbe explained in the following section. Using the describedfeatures, we can modify (1) into (2):

CRki ¼

Pki

� � SSki þ ð1� �Þ � NDki

; where 0 � � � 1: ð2Þ

The system parameter, �, is used to adjust the relativeimportance of SSki and NDk

i . Node Ni updates CRki at every

query processing and looks it up for the connected node Nk atevery relocation period. In addition, each node also has itsown threshold � of CRk

i . If the measured CRki exceeds �,

node Nk will be detected as a selfish node by Ni. The valueof Pk

i (as well as SSki and NDki ) is updated at every query

processing of some item that Ni allocates to other node(s)during the replica allocation phase.

The effect of parameters SSki and NDki on CRk

i can beweighted by taking into consideration the size of memoryspace at node Ni, Si, and the total number of data itemsaccessed by Ni, ni. The rationale is that CRk

i may bestrongly affected by Si and ni if CRk

i is not normalized. Bynormalizing, we obtain (3), where nCRk

i stands for thenormalized CRk

i .

nCRki ¼

Pki

� � SSkiSiþ ð1� �Þ � NDk

i

ni

; where 0 � � � 1: ð3Þ

Algorithm 1 describes how to detect selfish nodes. Ateach relocation period, node Ni detects selfish nodes basedon nCRk

i . Each node may have its own initial value of Pki as

a system parameter. Interestingly, the initial value of Pki can

represent the basic attitude toward strangers. For instance, ifthe initial value equals zero, node Ni always treats a newnode as a nonselfish node. Therefore, Ni can cooperate withstrangers easily for cooperative replica sharing. Replicas ofdata items are allocated by allocation techniques shown inSection 3.4. After replica allocation, Ni sets NDk

i and SSkiaccordingly. Recall that both NDk

i and SSki are estimatedvalues, not accurate ones. The estimated values are adjustedat query processing time, according to Algorithm 2.

Algorithm 1. Pseudo code to detect selfish nodes

00: At every relocation period

01: /�Ni detects selfish nodes with this algorithm �/

02: detection(){

03: for (each connected node Nk ){04: if ðnCRk

i < �ÞNk is marked as non-selfish;

05: else Nk is marked as selfish;}

06: wait until replica allocation is done;

07: for (each connected node Nk){

08: if ðNi has allocated replica to NkÞ{09 NDk

i ¼ the number of allocated replica;

10: SSki ¼ the total size of allocated replica;}

11: else{12: NDk

i ¼ 1;

13: SSki ¼ the size of a data item;

14: } } }

Algorithm 2. Pseudo code to update selfish features

00: At every query processing time

01: /� When Ni issues a query �/02: update_SF(){

03: while (during the predefined time !){

04: if (an expected node Nk serves the query)

05: decrease Pki ;

CHOI ET AL.: HANDLING SELFISHNESS IN REPLICA ALLOCATION OVER A MOBILE AD HOC NETWORK 281

3. Either SSki or NDki is sufficient, since we assume that all data items are

of equal size. However, we stick to both factors here for a genericapplication.

4. Actually, the reply from expected node Nk holding a target data itemmay not reach Ni due to disconnection, not its selfishness. In the currentsolution, however, we assume that Ni cannot tell Nk’s selfishness fromnetwork disconnection, since their impacts are identical to Ni, i.e., datainaccessibility. The identification and handling of a false alarm is one ofinteresting, promising future works.

http://ieeexploreprojects.blogspot.com

Page 5: Handling selfishness in replica allocation over a mobile ad hoc network.bak

06: if (an unexpected node Nj serves the query){

07: NDji ¼ ND

ji þ 1;

08: SSji ¼ SSji þ (the size of a data item);

09: } }

10: if (an expected node Nk does not serve the query){

11: increase Pki ;

12: NDki ¼ NDk

i � 1;

13: SSki ¼ SSki � (the size of a data item);

14: } }

As described in Algorithm 2, Ni maintains its NDki , SS

ki ,

and Pki during each query processing phase. When Ni issues

a query, Ni awaits the response from the expected node Nk

during the predefined wait time !, where ! is the expectedmaximum time taken to exchange one round of request-response message across the entire network. Whenever Ni

detects the selfish behavior of Nk, it modifies Pki , NDk

i , andSSki accordingly. If Nk serves the query as expected,however, only Pk

i will be decreased, while NDki and SSki

remain unchanged. Note that, in case an unexpected nodeNj

replies to Ni’s request, Ni will modify NDji and SSji

accordingly, while not affecting Pji , Pk

i , NDki , and SSki . That

is, the reply from unexpected nodes does not affect the selfishfeatures of expected nodes. Note also that Ni may receivemultiple replies from unexpected and/or expected nodes. Inthis case, Ni modifies Pk

i , NDki , and/or SSki accordingly for

each reply based on Algorithm 2. If Ni does not receive anyreply from expected node Nk during !, it observes Nk’sselfish behavior and modifies Pk

i ,NDki , and SSki accordingly.

3.3 Building SCF-Tree

The SCF-tree based replica allocation techniques areinspired by human friendship management in the realworld, where each person makes his/her own friendsforming a web and manages friendship by himself/herself.He/she does not have to discuss these with others tomaintain the friendship. The decision is solely at his/herdiscretion. The main objective of our novel replica alloca-tion techniques is to reduce traffic overhead, whileachieving high data accessibility. If the novel replicaallocation techniques can allocate replica without discus-sion with other nodes, as in a human friendship manage-ment, traffic overhead will decrease.

Prior to building the SCF-tree, each node makes its ownpartial topology graph Gi ¼ ðINi; ILiÞ, which is a component

of the graph G. Gi consists of a finite set of the nodesconnected to Ni and a finite set of the links, whereNi 2 INi; INi � IN, and ILi � IL. Since the SCF-tree consistsof only nonselfish nodes, we need to measure the degree ofselfishness to apply real-world friendship management toreplica allocation in a MANET. We use the value of nCRk

i

for this purpose. Before constructing/updating the SCF-tree, node Ni eliminates selfish nodes from INi. Thus, Ni

changes Gi into its own partial graph Gnsi . More formally,

we define Gnsi as the undirected graph Gns

i ¼ ðINnsi ; IL

nsi Þ,

which consists of a finite set of nonselfish nodes detected byNi, INns

i , and a finite set of communication links amongnodes N 2 INns

i , ILnsi . ILnsi is derived by a smoothing outoperation in graph theory. For instance, if there exists a pathhNj;Na;Nb; . . . ; Nl;Nki in Gi, where Nj;Nk 2 INns

i andNa;Nb; . . . ; Nl 2 INs

i ¼ INi � INnsi , Ni removes every link

containing the selfish nodes and then replaces ðNj;NkÞwith a new edge (the new edge is added since we do notconsider selfishness in data forwarding).

Based on Gnsi , Ni builds its own SCF-tree, denoted as

TSCFi . Algorithm 3 describes how to construct the SCF-tree.Each node has a parameter d, the depth of SCF-tree. WhenNi builds its own SCF-tree, Ni first appends the nodes thatare connected to Ni by one hop to Ni’s child nodes. Then, Ni

checks recursively the child nodes of the appended nodes,until the depth of the SCF-tree is equal to d. Fig. 2 illustratesthe network topology and some SCF-trees of N1 and N2 inFig. 1. In this example, we assume that all nodes arenonselfish nodes for simplicity. As can be seen in Figs. 2band 2c, the SCF-tree may have multiple routes for somenodes from the root node. For example, in Fig. 2b, N1 hastwo routes to N2 when N1 sets its own parameter d to be 4.Since the multiple routes confer high stability [12], weallocate more replicas to the nodes that have multiple routesfrom the root node. At every relocation period, each nodeupdates its own SCF-tree based on the network topology ofthat moment.

Algorithm 3. Pseudo code to build SCF-tree00:/�Ni makes SCF-tree with a parameter, depth d�/

01: constructScfTree(){

02: append Ni to SCF-tree as the root node;

03: checkChildnodesðNiÞ;04: return SCF-tree;}

05: Procedure checkChildnodesðNjÞ{

282 IEEE TRANSACTIONS ON MOBILE COMPUTING, VOL. 11, NO. 2, FEBRUARY 2012

Fig. 2. Example of a self-centered friendship tree.

http://ieeexploreprojects.blogspot.com

Page 6: Handling selfishness in replica allocation over a mobile ad hoc network.bak

06: /�INaj is a set of nodes that are adjacent nodes to Nj

�/

07: for (each node Na 2 INaj ){

08: if (distance between Na and the root > d )

09: continue;

10: else if ðNa is an ancestor of Nj in TSCFi Þ11: continue;

12: else{ append Na to TSCFi as a child of Nj;13: checkChildnodes(Na); } } }

3.4 Allocating Replica

After building the SCF-tree, a node allocates replica at everyrelocation period. Each node asks nonselfish nodes withinits SCF-tree to hold replica when it cannot hold replica in itslocal memory space. Since the SCF-tree based replicaallocation is performed in a fully distributed manner, eachnode determines replica allocation individually without anycommunication with other nodes.

Since every node has its own SCF-tree, it can performreplica allocation at its discretion. For example, in Fig. 3,after building the SCF-tree in Fig. 3b, N1 may ask N2 to holdsome replicas. Note that the decision, whether to accept thereplica allocation request or not, will be made at N2’sdiscretion (if N2 is selfish, it may not accept the replicaallocation request). Afterward, node N1 may issue a queryfor the replicas. At this time, N1 is likely to recognizewhether the expected N2 serves the query (i.e., nonselfish) ornot (i.e., selfish). By observing the behavior of N2, N1

updates ND21, SS2

1 , and P 21 accordingly (see Section 3.2).

Since we assume that a node can use some portion of itsmemory space selfishly, we may divide memory space Mi

for replica logically into two parts: selfish area Ms andpublic area Mp. Each node may use its own memory spaceMi freely as Ms and/or Mp. In each node, Ms will be usedfor data of local interest (i.e., to reduce query delay), whileMp for public data is asked to hold data by other node(s)(i.e., to improve data accessibility). A type-2 node uses Mi

for only Ms, whereas a type-3 node uses Mi for Ms and Mp.Type-1 node’s Mi will be equal to Mp.

Algorithm 4 describes how to allocate replica, where IDi

and Li denote an ordered set of all data items to be allocatedby Ni and the list of node ids, respectively. Note that, IDi issorted in descending order of Ni’s access frequency.Consequently, each node allocates replicas in descendingorder of its own access frequency. This is quite different fromexisting group-based replica allocation techniques (e.g., DCG

in [12]) where replicas are allocated based on the access

frequency of group members. Each node Ni executes this

algorithm at every relocation period after building its own

SCF-tree. At first, a node determines the priority for

allocating replicas. The priority is based on Breadth First

Search (BFS) order of the SCF-tree. The dotted arrow in Fig. 3b

represents the priority for allocating replica. For example, in

Fig. 3b,N1 selectsN2 as the first target of the allocation. After

allocating a replica to the last target node (i.e., N5 in Fig. 3b),

the first node, N2 will be the next target in a round-robin

manner. The target node will be the expected node in our

strategy. Since a node allocates a replica to the target node in

its SCF-tree once during a single relocation phase, a node has

at most one expected node for each replica. When its ownMs

is not full,Ni allocates replica to itsMs first. When its ownMs

becomes full, the node requests replica allocation to nodes in

its SCF-tree in the order of priority. In our allocation

technique, if Ms is full and Mp is not full, a node may use

Mp for data items of local interest temporarily. However,

public data cannot be held in Ms.

Algorithm 4. Pseudo code for replica allocation

00: /�Ni executes this algorithm at relocation period �/

01: replica_allocation(){02: Li ¼ make priorityðTSCFi Þ;03: for (each data item 2 IDi){

04: if (Ms is not full)

05: allocate replica of the data to Ms ;

06: else{/�Ms is full �/

07: allocate replica of the data to the target node;

08: /� the target node is selected from Li�=

09: if (Mp is not full)10: allocate replica of the data to Mp; } }

11: while (during a relocation period){

12: if ðNk requests for the allocation of DqÞ13: replica_allocation_for_others ðNk;DqÞ; } }

14: Procedure make_priority ðTSCFi Þ {

15: for (all vertices in TSCFi ){

16: select a vertex in TSCFi in order of BFS;

17: append the selected vertex id to Li; }18: return Li; }

19: Procedure replica_allocation_for_othersðNk;DqÞ{20: if ðNk is in TSCFi and Ni does not hold DqÞ{21: if (Mp is not full) allocate Dq to Mp ;

22: else{=�Mp is full �=

CHOI ET AL.: HANDLING SELFISHNESS IN REPLICA ALLOCATION OVER A MOBILE AD HOC NETWORK 283

Fig. 3. SCF-tree-based replica allocation from N1’s perspective.

http://ieeexploreprojects.blogspot.com

Page 7: Handling selfishness in replica allocation over a mobile ad hoc network.bak

23: if(Ni holds any replica of local interest in Mp)

24: replace the replica with Dq ;

25: else{26: =�Nh is the node with the highest nCRh

i

among the nodes which allocated replica to Mp�=

27: if ðnCRhi > nCRk

i Þ28: replace the replica requested by Nh with Dq;

29: } } } }

During a relocation period, Ni may receive requests forreplica allocation from any nodes within its SCF-tree. If Ni

is not a fully selfish node, Ni shall maintain its memoryspace Mp for the requests from other nodes, say Nk. In thiscase, Ni should determine whether to accept the replicaallocation request. If Nk is in the TSCFi and Ni does not holdthe requested replica of Dq in its memory space, the replicaallocation will be accepted. If Ni’s Mp is not full, the replicaof Dq will be allocated to the Mp. If Ni’s Mp is full and Ni

holds any replica allocated by itself in its Mp, Ni willreplace the replica with Dq. If Ni does not hold any replicaallocated by itself in its Mp and Mp is full, Ni compares thenCRh

i with nCRki , where Nh is the node with the highest

nCR score among the nodes that allocated replica to Ni’sMp. If nCRh

i exceeds nCRki , Ni replaces the replica

requested by Nh with Dq.Fig. 3c shows the expected result of replica allocation

from N1’s perspective, derived from Tables 1, 2, and Fig. 1.Since N1 may not know the real size of memory space atother nodes, N1 allocates a different number of data items toeach node. We omit the original data of each node and otherreplica here, because N1 may not know who hold theoriginal data and/or other replica. We assume that N1 setsits threshold � to 0.7. In Fig. 3c, N1 executes replicaallocation based on its own SCF-tree, described in Fig. 3b.The depth of the SCF-tree in Fig. 3b is two. Since nCR3

1 andnCR4

1 are greater than �, N1 detects N3 and N4 as selfishnodes. Therefore, N3 and N4 are excluded by N1 in thereplica allocation. Fig. 3a shows Gns

1 that is built by N1 priorto constructing the SCF-tree. After its own replica alloca-tion, N1 expects that N2, N5, and N6 maintain their ownmemory space, like M2, M5, and M6 in Fig. 3c, respectively.

The objective of the above-mentioned SCF-tree basedreplica allocation technique is to achieve good data accessi-bility with low communication cost in the presence of selfishnodes. Since our replica allocation technique appropriatelyhandles the (partially) selfish nodes, the technique isexpected to achieve the objective. Fig. 4 illustrates the finalreplica allocation results derived from Tables 1, 2, and Fig. 1.In more detail, each node processes the following procedures:

1. Each node allocates replica at its discretion based onTable 1 and Fig. 1.

2. When each node receives a request for replicaallocation from Nk during a relocation period, itdetermines whether to accept the request.

3. If the request is accepted, each node maintains its Mp

based on the nCRki given by Table 2. If the highest

nCRhi among the nodes which allocated replica to

Ni, is greater than nCRki , Ni replaces replica

allocated by Nh with replica requested by Nk.

In this example, each node allocates replica at itsdiscretion like N1’s allocation in Fig. 3c and then each nodemaintains its memory space based on received requests forreplica allocation. For instance, N1 allocates D2, D3, and D6

to N5, and N6 allocates D3, D9, and D4 to N5. In this case, N5

accepts allocation request fromN6 since nCR15 is greater than

nCR65. Thus, N5 holds D3 and D9 in its Mp. In our allocation

technique, each node allocates replica to other nodesconsidering selfishness. Thus, every node can access D9

and D10 even with the existence of selfish nodes in Fig. 4,which is contrary to the motivating case in Fig. 1. Therefore,the overall accessibility increases from 80 to 100 percent.Moreover, since each node allocates replica to the nodeswithin its SCF-tree at its own discretion, the proposedallocation technique is highly expected to incur very lowcommunication cost.

In addition to the above-mentioned one, alternative

replica allocation techniques can be developed based on

the SCF-tree structure. Thus, we propose a set of replica

allocation techniques, as follows:

. SCF-tree-based replica allocation (SCF): This tech-nique is described in Algorithm 4 and serves as abasic SCF-tree based technique.

. SCF-tree based replica allocation with degree ofselfishness (SCF-DS): This technique takes intoaccount the degree of selfishness in allocatingreplicas. That is, less selfish nodes should be visitedfirst at the same SCF-tree level. This policy makesmore frequently accessed data items reside on lessselfish nodes.

. SCF-tree based replica allocation with closer node(SCF-CN): This technique allocates more replicas tothe closer nodes in the SCF-tree. That is, morereplicas are allocated to the node with lower depthwithin the SCF-tree.

284 IEEE TRANSACTIONS ON MOBILE COMPUTING, VOL. 11, NO. 2, FEBRUARY 2012

TABLE 2Example of nCRk

i of Each Node

Fig. 4. Example of SCF-tree-based replica allocation.

http://ieeexploreprojects.blogspot.com

Page 8: Handling selfishness in replica allocation over a mobile ad hoc network.bak

. Extended SCF-tree based replica allocation (eSCF):This technique is based on an extended SCF-tree(eSCF-tree). In this technique, Ni builds its eSCF-tree based on Gi, not Gns

i . Consequently, eSCF-treeincludes selfish nodes, as well as nonselfish nodes.Ni marks the detected selfish nodes within its eSCF-tree and allocates replicas to the nonselfish nodes inits eSCF-tree first. After the first round, Ni allocatesreplicas to all nodes (i.e., including selfish nodes)within its eSCF-tree in a round-robin manner. As itwill turn out in Section 4, this technique shows thebest performance in terms of query delay.

The implementation of alternative techniques (i.e., SCF-DS, SCF-CN, and eSCF) can be easily done by making slightchanges to Algorithm 4 (mainly in the make_priority()procedure). In the case of SCF-DS, the priority for replicaallocation is determined by the pair: (depth of SCF-tree,nCR ). That is, the higher priority is given to the lowerdepth, and for nodes with the same depth, the replica isallocated in ascending order of the nCR scores. In the caseof SCF-CN, the vertex ids are appended to Li repeatedly.The number of repetitions is determined as 1þ diff , wherediff is the difference between the depth of the SCF-tree andthe depth of the vertex of interest in the SCF-tree. Forexample, in Fig. 3b, nodes in depth 1 will be repeated twice(i.e., 1þ 1), while nodes in depth 2 will be repeated once(i.e., 1+0). Consequently, more replicas are allocated tothe closer nodes. In the case of eSCF technique, eSCF-tree isused for replica allocation instead of SCF-tree. Therefore, allTSCFi in Algorithm 4 should be changed into TeSCFi . Todetermine the priority, Ni appends nonselfish nodes to Lifirst, and then entire nodes, including selfish nodes, to Li.

4 PERFORMANCE EVALUATION

4.1 Simulation Environment

Our simulation model is similar to that employed in [12].In the simulation, the number of mobile nodes is set to 40.Each node has its local memory space and moves with avelocity from 0 � 1 (m/s) over 50 ðmÞ � 50 ðmÞ flatland.The movement pattern of nodes follows the randomwaypoint model [5], where each node remains stationaryfor a pause time and then it selects a random destinationand moves to the destination. After reaching the destina-tion, it again stops for a pause time and repeats thisbehavior. The radio communication range of each node is acircle with a radius of 1 � 19 (m). We suppose that thereare 40 individual pieces of data, each of the same size. Inthe network, node Ni (1 � i � 40 ) holds data Di as theoriginal. The data access frequency is assumed to followZipf distribution. The default relocation period is set to256 units of simulation time which we vary from 64 to8,192 units of simulation time. Table 3 describes thesimulation parameters.

The default number of selfish nodes is set to be 70 percentof the entire nodes in our simulation, based on theobservation of a real application [1]. We set 75 percent ofselfish nodes to be type-3 (i.e., partially selfish) and theremaining to be type-2 (i.e., fully selfish). Type-3 nodesconsist of three groups of equal size. Each group uses 25, 50,and 75 percent of its memory space for the selfish area.

Type-2 nodes will not accept replica allocation requestsfrom other nodes in the replica allocation phase, thus beingexpected to create significant selfishness alarm in queryprocessing. Type-3 nodes will accept or reject replicaallocation requests according to their local status (seeAlgorithm 4 in Section 3.4), thereby causing some self-ishness alarms in subsequent query processing.

We evaluate our strategy using the following fourperformance metrics:

1. Overall selfishness alarm: This is the ratio of theoverall selfishness alarm of all nodes to all queriesthat should be served by the expected node in theentire system.

2. Communication cost: This is the total hop count ofdata transmission for selfish node detection andreplica allocation/relocation, and their involvedinformation sharing.

3. Average query delay: This is the number of hopsfrom a requester node to the nearest node with therequested data item. If the requested data item is inthe local memory of a requester, the query delay is 0.We only consider successful queries, i.e., it is thetotal delay of successful requests divided by the totalnumber of successful requests.

4. Data accessibility: This is the ratio of the numberof successful data requests to the total number ofdata requests.

During 50,000 units of simulation time, we simulate andcompare the proposed replica allocation strategies (i.e., SCF,SCF-DS, SCF-CN, and eSCF) with the following techniques:

. Static Access Frequency (SAF) [12]: Each nodeallocates replica based only on its own accessfrequency, without considering or detecting selfishnodes. This allocation technique is expected to showthe optimal performance in terms of communicationcost, because the technique does not communicatewith others to allocate replica.

. Dynamic Connectivity-based Grouping (DCG)[12]: DCG creates groups of nodes that are bicon-nected components in a network, without consider-ing or detecting selfish nodes. In each group, thenode, called coordinator, allocates replicas based onthe access frequency of the group. This technique isknown to have high data accessibility.

. Dynamic Connectivity-based Grouping with de-tection (DCGþ ): The technique combines DCG with

CHOI ET AL.: HANDLING SELFISHNESS IN REPLICA ALLOCATION OVER A MOBILE AD HOC NETWORK 285

TABLE 3Simulation Parameters

http://ieeexploreprojects.blogspot.com

Page 9: Handling selfishness in replica allocation over a mobile ad hoc network.bak

our detection method. Initially, groups of nodes arecreated according to the DCG methodology. Subse-quently, in each group, selfish nodes are detectedbased on our detection method. For the detection,each node in a group sends its nCR scores to thecoordinator with the lowest suffix of node identifer inthe group [13]. The coordinator excludes selfishnode(s) from the group for replica allocation. As aresult, only nonselfish nodes form a group again.The replica allocation is only performed within thefinal group without any selfish nodes. After replicaallocation, the coordinator shares the information ofreplica allocation with group members for thesubsequent selfishness detection. In particular, self-ish nodes are determined to be selfish only when allother nodes in the group agree with the node’sselfishness. We experimented with other approachesto determine selfishness, including the agreement of1) at least one and 2) the majority of nodes. We choseto use the agreement of all other nodes experimen-tally, since this shows the best data accessibilityperformance in our experiments: our analysisreveals that at least one node approach shows theworst data accessibility, whereas its communicationcost and average query delay are marginally betterthan that of the others.

4.2 Parameter Setting in Our Strategy

Several parameters are used in our strategy. For theselfishness detection algorithm, we use the threshold �.For the selfishness features update algorithm, we use thepredefined wait time ! and need to initialize the selfishnessalarm Pk

i . In building the SCF-tree, we use the depth d. Weselect data accessibility as the most important criterion todetermine the values of parameters.

We set ! to 50 units of simulation time, since we observethat one round of request-response exchanges in the entirenetwork takes less than 50 units of simulation time in oursimulation setting. A similar reasoning is made in a priorsimulation environment [14]. We choose to use 2 as thedefault depth of the (e)SCF-tree experimentally afterinspecting our simulation results. We observe that averagequery delay, data accessibility, and communication cost areinsensitive to the depth of the SCF-tree. More specifically,both average query delay and data accessibility are almostthe same with varying depths of SCF-tree, while commu-nication cost increases marginally as the depth increases.Pki is initialized to 0 and � is set to 0.7. We pick the values

experimentally after inspecting our simulation results. Inour analysis, when Pk

i is initialized to 0, a node cooperateswith others easily and all techniques show the bestperformance. Both average query delay and communicationcost are insensitive to �. However, all techniques that useour detection method show the best performance in termsof data accessibility, when � is set to 0.7.

4.3 Simulation Results

4.3.1 Effectiveness of Detection Method

We first compare the overall selfishness alarm of DCG withthat of DCGþ to demonstrate the effectiveness of ourdetection method. We expect that the overall selfishnessalarm will be reduced in query processing by detecting

selfish nodes effectively with DCGþ, since many selfishnodes will be removed from the replica allocation phase andmany reliable nodes will serve data requests from nodes.

However, recall that the selfishness alarm may alsooccur due to network disconnections, i.e., false alarm (seethe footnote in Section 3.2). Actually, it is desirable toobserve truly selfish nodes to evaluate the effectiveness ofthe detection method. As mentioned earlier in Section 3.2, adata requester cannot tell an expected node’s selfishnessfrom network disconnection, since their impacts areidentical to the requester, i.e., no reply from the expectednode. Although the false alarm exists from the viewpoint ofnodes, we realize that the true selfishness can be identifiedin the simulation results by identifying which data requesthas not been served by the expected, connected node in queryprocessing. Obviously, the expected and connected nodesare only involved in a true selfishness alarm, whereas theexpected but disconnected nodes in query processing maylead to a false alarm. Therefore, we plot two additionalmethods, DCG (selfishness only) and DCGþ (selfishnessonly) in Fig. 5. The overall selfishness alarm of DCG(selfishness only) and DCGþ (selfishness only) is obtainedby counting data requests that have not been served by theexpected, connected nodes in query processing, i.e., excludingfalse alarms caused by disconnections.

Figs. 5a and 5b present the overall selfishness alarm withvarying relocation period and the size of memory space,respectively. As expected, the DCGþ technique significantlyreduces the selfishness alarms in all cases. This can beexplained as follows: fewer selfish nodes become expected

286 IEEE TRANSACTIONS ON MOBILE COMPUTING, VOL. 11, NO. 2, FEBRUARY 2012

Fig. 5. Overall selfishness alarm.http://ieeexploreprojects.blogspot.com

Page 10: Handling selfishness in replica allocation over a mobile ad hoc network.bak

nodes in DCGþ than in DCG, since our detection methodaugmented in DCGþ detects selfish nodes effectively and thedetected selfish nodes are removed from replica allocationgroups. Consequently, more expected nodes serve queries inDCGþ than in DCG.

As expected, the overall selfishness alarm of DCG(selfishness only) and DCGþ (selfishness only) is less thanthat of DCG and DCGþ, respectively. We see that, onaverage, about 62 and 56 percent of the overall selfishnessalarm with DCG and DCGþ are caused by node self-ishness, not disconnections, in Fig. 5a. Clearly, Fig. 5 showsthat our detection method can reduce the overall self-ishness alarm effectively.

4.3.2 Communication Cost

We evaluate several replica allocation techniques in termsof communication cost. Our intuition was that ourtechniques outperform DCGþ, while being inferior toSAF. This intuition is confirmed by the results in Fig. 6.DCGþ shows the worst performance in all cases, sincegroup members need to communicate with each other indetecting selfish nodes and allocating/relocating replica.We report that, on average, about 70 percent of totalcommunication cost in the DCGþ technique is caused byreplica allocation/relocation, while about 30 percent iscaused by selfish node detection. As expected, SAF showsthe best performance, since no detection of selfish nodes orgroup communication is made. Although SAF and DCGtechniques show better performance than DCGþ in com-munication cost, they are expected to show poor perfor-mance in data accessibility in the presence of selfish nodes(which will be confirmed in Section 4.3.4). Interestingly, ouranalysis reveals that our techniques, which detect selfishnodes, considerably outperform DCG, which does notperform the selfishness detection procedure. This verifiesthe efficacy of our fully distributed way of detecting selfishnodes and allocating replica, i.e., no group communication.

There is no decisive difference among our techniques,except that the eSCF technique shows the worst behavior.The other techniques (SCF, SCF-DS, and SCF-CN) showvery similar communication cost, since they are all based onthe same SCF-tree structure. Note that the consideration ofselfishness degree in the SCF-DS technique does not affectthe performance significantly, since nodes in the SCF-treeare sufficiently nonselfish to hold allocated replicas in many

cases. Similarly, the performance of the SCF-CN techniqueis similar to those of other techniques, since nodes with alow depth of SCF-tree do not necessarily mean nearbynodes in a real hop count (e.g., N5 from the viewpoint of N1

in Fig. 3).Communication cost decreases in every technique,

except SAF, as the relocation period gets longer (Fig. 6a),since the frequency of selfish node detections and replicaallocations decreases with a large relocation period. Asshown in Fig. 6b, communication cost increases as localmemory size increases at first, but it decreases from acertain memory size (around 20 in our analysis) in everytechnique, except SAF. When the memory size is larger thana certain memory size, each node holds replicas of manydata items and thus replica relocation rarely occurs.

Fig. 6b clearly shows that communication cost of ourtechniques is less sensitive to the size of memory spacethan for DCG (or DCGþ), since fewer replica relocationshave occurred in our techniques than in DCG (or DCGþ):(e)SCF-tree does not change a lot, thus resulting in fewerreplica relocations in our techniques. However, the DCG(or DCGþ) technique is vulnerable to network topologychanges: it should relocate replicas whenever topologychanges. As another reason, replicas in local selfish spacedo not need to be reallocated in our techniques.

Fig. 6c shows that communication cost of DCG, DCGþ,and our techniques decreases with more selfish nodes, sincethe cost in fetching replicas and/or in group communica-tion will be reduced. In the DCG technique, the effectivememory space in the entire system gets reduced due tomany selfish nodes, resulting in reduced cost in fetchingreplicas. In the DCGþ technique, cost reduction is fasterthan in DCG, since fewer nodes participate in replicaallocation. Note that the communication cost of ourtechniques is relatively stable. This can be explained asfollows: the communication reduction factor is much lessthan in DCG and DCGþ, and the distance betweennonselfish nodes increases simultaneously.

4.3.3 Average Query Delay

Fig. 7 shows average query delay for various parameters.As expected, the SAF technique shows the best performancein terms of query delay, since most successful queries areserved by local memory space. Our techniques showslightly better query delay than does the DCG technique

CHOI ET AL.: HANDLING SELFISHNESS IN REPLICA ALLOCATION OVER A MOBILE AD HOC NETWORK 287

Fig. 6. Communication cost with varying parameters.

http://ieeexploreprojects.blogspot.com

Page 11: Handling selfishness in replica allocation over a mobile ad hoc network.bak

(while outperforming DCG significantly in communicationcost). The DCGþ technique shows the worst performance.This can be explained as follows: the distance in hop countsamong group members in the DCGþ technique is longerthan that in the DCG technique. Since most successfulqueries are served by group members in these techniques,the long distance among group members affects querydelay negatively.

Among our techniques, the eSCF technique shows thebest average query delay. In the eSCF technique, nearbyselfish nodes can be added to the eSCF-tree. Conse-quently, some queries are possibly served by the nearby(partially) selfish nodes, whereas only nonselfish nodes,which maybe far away, serve queries in other techniques.

Our intuition was that query delay decreases as the sizeof memory space increases. This intuition is confirmed bythe results in Fig. 7b. As the size of memory space increases,many nodes will accept replica allocation/relocation re-quests, since the size of public memory space increases aswell. As a result, more queries are served by nearby nodesor locally.

Very interestingly, Fig. 7c shows that the performance ofDCG and DCGþ gets worse, while the performance of ourtechniques improves slightly with more selfish nodes. Wehave done an in-depth analysis for this situation. We foundthat, in the DCG and DCGþ techniques, the number ofsuccessful queries being served by some (nonselfish) nodes

out of groups increases with more selfish nodes. That is, the

profit of DCG is considerably hampered by many selfish

nodes, since the biconnected component becomes none-ffective. However, in our techniques, the number of

successful queries being locally served increases slightly.

This is because when the number of nodes in the SCF-tree is

very small, the local public memory space may be used fordata items of local interest temporarily.

4.3.4 Data Accessibility

We evaluate the data accessibility of replica allocation

methods under consideration. We expect that our techni-ques perform significantly better than other techniques in

the presence of selfish nodes. Fig. 8 highlights the strength

of our methodology: in all cases, our techniques outperform

SAF, DCG, and DCGþ considerably, since our techniquescan detect and handle selfish nodes in replica allocation

effectively and efficiently. Among our techniques, the eSCF

technique shows a slightly poorer performance.Our initial intuition was that, data accessibility is stable

with relocation periods. This is confirmed by the results inFig. 8a. Fig. 8b shows that data accessibility is proportional

to the size of memory space, as expected. The performance

of our techniques improves faster than do others, since ourtechniques fully utilize the memory space of nodes. Fig. 8c

shows the robustness of our techniques with respect to

288 IEEE TRANSACTIONS ON MOBILE COMPUTING, VOL. 11, NO. 2, FEBRUARY 2012

Fig. 8. Data accessibility with varying parameters.

Fig. 7. Query delay with varying parameters.

http://ieeexploreprojects.blogspot.com

Page 12: Handling selfishness in replica allocation over a mobile ad hoc network.bak

varying percentage of selfish nodes. The profit of DCGtechnique is considerably hampered by selfish nodes,whereas the SAF technique is insensitive at all.

4.3.5 Effect of Communication Range

Finally, we examine the effect of communication range. Inall cases, our techniques outperform DCG and DCGþ,while SAF shows the best performance in terms ofcommunication cost and average query delay. As thecommunication range increases, the communication costof all techniques increases at first, but it gets smaller from acertain point (9 in our analysis), except SAF. When thecommunication range is smaller than a certain point, thecommunication cost increases as the communication rangegets larger, since the number of nodes connected to eachother increases and thus the communication cost caused byreplica relocation increases. Conversely, when the commu-nication range is larger than a certain point, the number ofhops among connected nodes decreases. Therefore, thecommunication cost caused by replica relocation decreases.

Fig. 9b shows that the average query delay of alltechniques degrades as the communication range increases,but it improves from a certain point (9 in our analysis),since when the communication range is larger than 9, thenumber of hops among connected nodes decreases. We see,in Fig. 9c, that the data accessibility improves with the widerange of communication, since more nodes become con-nected. Clearly, our techniques work best.

5 RELATED WORK

5.1 Selfish Nodes from a Network Perspective

MANETs are divided into two categories: closed and open inthe work [3], [24], [33]. In a closed MANET, all nodesvoluntarily participate in and organize the network.However, in an open MANET, which we consider in thispaper, however, individual nodes may have differentobjectives. In this case, some nodes can be selfish topreserve their own resources.

Various techniques have been proposed to handle theproblem of selfish behavior from the network perspective. Asdescribed in [33], techniques handling selfish nodes can beclassified into three categories: reputation-based, credit-pay-ment, and game theory-based techniques. In reputation-based

techniques, each node observes the behaviors of others anduses the acquired information for routing [20], [21], [28]. Incredit-payment techniques, each node gives a credit to others,as a reward for data forwarding [2], [30]. The acquired creditis then used to send data to others. The game theory-basedtechniques assume that all rational nodes can determine theirown optimal strategies to maximize their profit [11], [29]. Thegame theory-based techniques want to find the NashEquilibrium point [26] to maximize system performance. Allthese techniques focused on packet forwarding. In contrast,this paper focuses on the problem of selfish replica allocation.

The work [18] introduced several trust models and trustmanagement schemes in a MANET that can help mitigateselfishness in a MANET. Although the work introducesseveral schemes for the detection of selfish nodes, the workalso focuses on the selfish behavior from the networkperspective, such as dropping or refusing to forwardpackets. Note that traditional detection techniques in anetwork domain cannot be directly applied to the selfishreplica allocation problem, since they mainly make a binarydecision: selfish or not, that is, forwarding data or not.However, we need to consider the partial selfish behaviorsinto account in the selfish replica allocation problem, asillustrated in Section 1.

5.2 Replica Allocation and Caching Techniques

In the pioneering work [12], some effective replica allocationtechniques are suggested, including static access frequency,dynamic access frequency and neighborhood (DAFN), anddynamic connectivity-based grouping. It has been reportedthat DCG provides the highest data accessibility, while SAFincurs the lowest traffic, of the three techniques. AlthoughDCG performs best in terms of data accessibility, it causesthe worst network traffic. Moreover, DCG does not considerselfish nodes in a MANET.

The work [32] proposes data replication techniques thataddress both query delay and data accessibility in a MANET.The work [32] demonstrates such a trade-off and proposestechniques to balance it. The work [6] introduces thecooperative caching-based data access methods, includingCachePath, CacheData, and Hybrid. Differing from all theabove-mentioned replica allocation or caching techniques,we consider selfish nodes in a MANET.

CHOI ET AL.: HANDLING SELFISHNESS IN REPLICA ALLOCATION OVER A MOBILE AD HOC NETWORK 289

Fig. 9. Effect of communication range.

http://ieeexploreprojects.blogspot.com

Page 13: Handling selfishness in replica allocation over a mobile ad hoc network.bak

The work [25] proposes Conquer, a broker-based eco-nomic incentive model for mobile peer-to-peer networks.Although the work [25] considers free riders to host data inmobile peer-to-peer networks, it assumes that all peers aretrusted and they do not cheat. Therefore, the work focuseson encouraging peer collaboration because the work needsnot consider node misbehavior. Conversely, we focus on the

misbehavior of nodes. The work [34] introduced noncoo-perative behaviors in a MANET. The assumption of thework is that each node in a MANET is greedy and self-interested, similar to our work. However, the workaddressed a different problem: whether or not the systemwill enter an equilibrium state. Furthermore, the systemenvironment differs from our work.

In the research field of distributed databases, some

strategies for handling selfish behavior have been proposed[7], [8], [15], [16], [17]. However, these works cannot bedirectly applied to a MANET, since they did not considerthe constraints of a MANET such as the bandwidthlimitation for the detection of selfish nodes and systemfailures due to frequent node disconnections.

6 CONCLUSION

In contrast to the network viewpoint, we have addressedthe problem of selfish nodes from the replica allocationperspective. We term this problem selfish replica allocation.Our work was motivated by the fact that a selfish replicaallocation could lead to overall poor data accessibility in aMANET. We have proposed a selfish node detectionmethod and novel replica allocation techniques to handlethe selfish replica allocation appropriately. The proposedstrategies are inspired by the real-world observations in

economics in terms of credit risk and in human friendshipmanagement in terms of choosing one’s friends completelyat one’s own discretion. We applied the notion of credit risk

from economics to detect selfish nodes. Every node in aMANET calculates credit risk information on other con-nected nodes individually to measure the degree ofselfishness. Since traditional replica allocation techniquesfailed to consider selfish nodes, we also proposed novel

replica allocation techniques. Extensive simulation showsthat the proposed strategies outperform existing represen-tative cooperative replica allocation techniques in terms ofdata accessibility, communication cost, and query delay. Weare currently working on the impact of different mobilitypatterns. We plan to identify and handle false alarms inselfish replica allocation.

ACKNOWLEDGMENTS

This work was supported in part by the Mid-CareerResearcher Program through an NRF grant funded by the

MEST (No. 2009-0077925) and with partial support from aKorea University Grant.

REFERENCES

[1] E. Adar and B.A. Huberman, “Free Riding on Gnutella,” FirstMonday, vol. 5, no. 10, pp. 1-22, 2000.

[2] L. Anderegg and S. Eidenbenz, “Ad Hoc-VCG: A Truthful andCost-Efficient Routing Protocol for Mobile Ad Hoc Networks withSelfish Agents,” Proc. ACM MobiCom, pp. 245-259, 2003.

[3] K. Balakrishnan, J. Deng, and P.K. Varshney, “TWOACK:Preventing Selfishness in Mobile Ad Hoc Networks,” Proc. IEEEWireless Comm. and Networking, pp. 2137-2142, 2005.

[4] R.F. Baumeister and M.R. Leary, “The Need to Belong: Desire forInterpersonal Attachments as a Fundamental Human Motiva-tion,” Psychological Bull., vol. 117, no. 3, pp. 497-529, 1995.

[5] J. Broch, D.A. Maltz, D.B. Johnson, Y.-C. Hu, and J. Jetcheva, “APerformance Comparison of Multi-Hop Wireless Ad Hoc Net-work Routing Protocols,” Proc. ACM MobiCom, pp. 85-97, 1998.

[6] G. Cao, L. Yin, and C.R. Das, “Cooperative Cache-Based DataAccess in Ad Hoc Networks,” Computer, vol. 37, no. 2, pp. 32-39,Feb. 2004.

[7] B.-G. Chun, K. Chaudhuri, H. Wee, M. Barreno, C.H. Papadimi-triou, and J. Kubiatowicz, “Selfish Caching in Distributed Systems:A Game-Theoretic Analysis,” Proc. ACM Symp. Principles ofDistributed Computing, pp. 21-30, 2004.

[8] E. Damiani, S.D.C. di Vimercati, S. Paraboschi, and P. Samarati,“Managing and Sharing Servents’ Reputations in P2P Systems,”IEEE Trans. Knowledge and Data Eng., vol. 15, no. 4, pp. 840-854,July/Aug. 2003.

[9] G. Ding and B. Bhargava, “Peer-to-Peer File-Sharing over MobileAd Hoc Networks,” Proc. IEEE Ann. Conf. Pervasive Computing andComm. Workshops, pp. 104-108, 2004.

[10] M. Feldman and J. Chuang, “Overcoming Free-Riding Behavior inPeer-to-Peer Systems,” SIGecom Exchanges, vol. 5, no. 4, pp. 41-50,2005.

[11] D. Hales, “From Selfish Nodes to Cooperative Networks -Emergent Link-Based Incentives in Peer-to-Peer Networks,” Proc.IEEE Int’l Conf. Peer-to-Peer Computing, pp. 151-158, 2004.

[12] T. Hara, “Effective Replica Allocation in Ad Hoc Networks forImproving Data Accessibility,” Proc. IEEE INFOCOM, pp. 1568-1576, 2001.

[13] T. Hara and S.K. Madria, “Data Replication for Improving DataAccessibility in Ad Hoc Networks,” IEEE Trans. Mobile Computing,vol. 5, no. 11, pp. 1515-1532, Nov. 2006.

[14] T. Hara and S.K. Madria, “Consistency Management Strategies forData Replication in Mobile Ad Hoc Networks,” IEEE Trans. MobileComputing, vol. 8, no. 7, pp. 950-967, July 2009.

[15] S.U. Khan and I. Ahmad, “A Pure Nash Equilibrium-Based GameTheoretical Method for Data Replication across Multiple Servers,”IEEE Trans. Knowledge and Data Eng., vol. 21, no. 4, pp. 537-553,Apr. 2009.

[16] N. Laoutaris, G. Smaragdakis, A. Bestavros, I. Matta, and I.Stavrakakis, “Distributed Selfish Caching,” IEEE Trans. Paralleland Distributed Systems, vol. 18, no. 10, pp. 1361-1376, Oct. 2007.

[17] N. Laoutaris, O. Telelis, V. Zissimopoulos, and I. Stavrakakis,“Distributed Selfish RepLication,” IEEE Trans. Parallel andDistributed Systems, vol. 17, no. 12, pp. 1401-1413, Dec. 2006.

[18] H. Li and M. Singhal, “Trust Management in DistributedSystems,” Computer, vol. 40, no. 2, pp. 45-53, Feb. 2007.

[19] M. Li, W.-C. Lee, and A. Sivasubramaniam, “Efficient Peer-to-PeerInformation Sharing over Mobile Ad Hoc Networks,” Proc. WorldWide Web (WWW) Workshop Emerging Applications for Wireless andMobile Access, pp. 2-6, 2004.

[20] Y. Liu and Y. Yang, “Reputation Propagation and Agreement inMobile Ad-Hoc Networks,” Proc. IEEE Wireless Comm. andNetworking Conf., pp. 1510-1515, 2003.

[21] S. Marti, T. Giuli, K. Lai, and M. Baker, “Mitigating RoutingMisbehavior in Mobile Ad hoc Networks,” Proc. ACM MobiCom,pp. 255-265, 2000.

[22] L.J. Mester, “What’s the Point of Credit Scoring?” Business Rev.,pp. 3-16, Sept. 1997.

[23] P. Michiardi and R. Molva, “Simulation-Based Analysis ofSecurity Exposures in Mobile Ad Hoc Networks,” Proc. EuropeanWireless Conf., pp. 1-6, 2002.

[24] H. Miranda and L. Rodrigues, “Friends and Foes: PreventingSelfishness in Open Mobile Ad hoc Networks,” Proc. IEEE Int’lConf. Distributed Computing Systems Workshops, pp. 440-445, 2003.

[25] A. Mondal, S.K. Madria, and M. Kitsuregawa, “An EconomicIncentive Model for Encouraging Peer Collaboration in Mobile-P2P Networks with Support for Constraint Queries,” Peer-to-PeerNetworking and Applications, vol. 2, no. 3, pp. 230-251, 2009.

[26] M.J. Osborne, An Introduction to Game Theory. Oxford Univ., 2003.

290 IEEE TRANSACTIONS ON MOBILE COMPUTING, VOL. 11, NO. 2, FEBRUARY 2012

http://ieeexploreprojects.blogspot.com

Page 14: Handling selfishness in replica allocation over a mobile ad hoc network.bak

[27] P. Padmanabhan, L. Gruenwald, A. Vallur, and M. Atiquzzaman,“A Survey of Data Replication Techniques for Mobile Ad HocNetwork Databases,” The Int’l J. Very Large Data Bases, vol. 17,no. 5, pp. 1143-1164, 2008.

[28] K. Paul and D. Westhoff, “Context Aware Detection of SelfishNodes in DSR Based Ad-Hoc Networks,” Proc. IEEE GlobalTelecomm. Conf., pp. 178-182, 2002.

[29] V. Srinivasan, P. Nuggehalli, C. Chiasserini, and R. Rao,“Cooperation in Wireless Ad Hoc Networks,” Proc. IEEEINFOCOM, pp. 808-817, 2003.

[30] W. Wang, X.-Y. Li, and Y. Wang, “Truthful Multicast Routing inSelfish Wireless Networks,” Proc. ACM MobiCom, pp. 245-259,2004.

[31] S.-Y. Wu and Y.-T. Chang, “A User-Centered Approach to ActiveReplica Management in Mobile Environments,” IEEE Trans.Mobile Computing, vol. 5, no. 11, pp. 1606-1619, Nov. 2006.

[32] L. Yin and G. Cao, “Balancing the Tradeoffs between DataAccessibility and Query Delay in Ad Hoc Networks,” Proc. IEEEInt’l Symp. Reliable Distributed Systems, pp. 289-298, 2004.

[33] Y. Yoo and D.P. Agrawal, “Why Does It Pay to be Selfish in aMANET,” IEEE Wireless Comm., vol. 13, no. 6, pp. 87-97, Dec. 2006.

[34] J. Zhai, Q. Li, and X. Li, “Data Caching in Selfish Manets,” Proc.Int’l Conf. Computer Network and Mobile Computing, pp. 208-217,2005.

Jae-Ho Choi received the BS degree in com-puter science and engineering from SoongsilUniversity in 2003. He received the MS degreein computer science from Korea University in2005. His research interests include mobilecomputing, location-based services, XML data-bases, and data management in mobile ad hocnetworks and sensor networks.

Kyu-Sun Shim received the BS degree incomputer science and engineering from KoreaUniversity in 2009. His research interests in-clude mobile/pervasive computing systems anddata management in mobile ad hoc networksand sensor networks.

SangKeun Lee received the BS, MS, and PhDdegrees in computer science and engineeringfrom Korea University, South Korea, in 1994,1996, and 1999, respectively. He was a recipientof the Japan Society for the Promotion ofScience (JSPS) Postdoctoral Fellowship in2000. Since 2003, he has been an associateprofessor in the College of Information andCommunication, Korea University, South Korea.His recent research interests include mobile

Internet technologies, contextual advertising, mobile/pervasive comput-ing, XML databases, and mobile ad hoc networks.

Kun-Lung Wu received the BS degree inelectrical engineering from the National TaiwanUniversity, Taipei, and the MS and PhD degreesin computer science from the University ofIllinois at Urbana-Champaign. He is currently amember of the Software Tools and TechniquesGroup, IBM T.J. Watson Research Center. He isthe program cochair of the 2007 IEEE JointConference on E-Commerce Technology (CEC)and Enterprise Computing, E-Commerce, and

E-Services (EEE). From 2000 to 2004, he was an associate editor of theIEEE Transactions on Knowledge and Data Engineering. He was thegeneral chair of the Third International Workshop on E-Commerce andWeb-Based Information Systems (WECWIS ’01). He has served as amember of the organizing and program committees of severalconferences. He received the Best Paper Award from EEE in 2004.His recent research interests include data streams, continual queries,mobile computing, Internet technologies and applications, databasesystems, and distributed computing. He has published extensively andis the holder of many patents in these areas. He has received variousIBM awards, including an IBM Corporate Environmental Affair Excel-lence Award, a Research Division Award, and several InventionAchievement Awards. He is an IBM Master Inventor. He is a fellow ofthe IEEE and a member of the ACM.

. For more information on this or any other computing topic,please visit our Digital Library at www.computer.org/publications/dlib.

CHOI ET AL.: HANDLING SELFISHNESS IN REPLICA ALLOCATION OVER A MOBILE AD HOC NETWORK 291

http://ieeexploreprojects.blogspot.com


Recommended