Handlingselfishnessinreplicaallocationoveramobileadhocnetwork Bak 120831235344 Phpapp01

7/28/2019 Handlingselfishnessinreplicaallocationoveramobileadhocnetwork Bak 120831235344 Phpapp01

1/14

Handling Selfishness in Replica Allocationover a Mobile Ad Hoc Network

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

AbstractIn 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 TermsMobile 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 devicesand 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, to

maximize 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 own

batteries. 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 as

the selfish replica allocation. Simply, selfish replica allocationrefers to a nodes 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


2/14

works [18] [25] to cope with selfish nodes in the context ofreplica allocation over a MANET.

Fig. 1 illustrates an existing replica allocation scheme,DCG [12], where nodes N1; N2; . . . ; N6 maintain theirmemory space M1; M2; . . . ; M6, respectively, with the accessfrequency information in Table 1 (In Fig. 1, a straight line

denotes a wireless link, a gray rectangle denotes an originaldata item, and a white rectangle denotes a replica allocated.In Table 1, the gray colored area shows three data items thatare accessed frequently by N3 and N4 ). As shown in Fig. 1,DCG seeks to minimize the duplication of data items in agroup to achieve high data accessibility.

Let us consider the case where N3 behaves selfishly bymaintaining M03, instead of M3, to prefer the locallyfrequently accessed data for low query delay. In the originalcase, D3, D9, and D2 were allocated to N3. However, due tothe selfish behavior, D3, D5, and D2, the top three mostlocally 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 showcasesdegraded data accessibility, since N1, N2, and N4 cannotfully leverage N3s memory space as intended in coopera-tive replica sharing.

As another example, a node may be only partiallyselfish 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 M04, instead of M4. Even with only

partial 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 inFig. 1) should also be taken into account, in addition to thefully selfish nodes (e.g., N3 in Fig. 1), to properly handle theselfish replica allocation problem. We therefore need tomeasure the degree of selfishness to appropriately handlethe partially selfish nodes. Motivated by this concept ofpartial selfishness, we borrow the notion ofcredit risk (CR)[22] from economics to detect selfish nodes. Since the creditrisk 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 selfishnessof another node, to which it is connected by one or multiplehops 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. The

SCF-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 node

behavior 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 data

items 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]).



3/14

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 space

for 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, AF

ji .

The access frequency does not change.. Each node moves freely within the maximum

velocity.

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 therequester), 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. The

nodes 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 shares

part 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 selfish

nodes, 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 itsown(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 debtors 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


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 from

the 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.



4/14

world. The key strength of the SCF-tree-based replicaallocation 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 todetermine 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 Nks sharedmemory space, denoted as SSki , and the number of Nksshared data items, denoted as NDki , observed by a node Ni,are used as node-specific features.3 Note that both SSkiand NDki are Nis estimated values, since Nk, which may be

selfish 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 Niobserves that node Nk shares large SSki and ND

ki , node Nk

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

ratio ofselfishness alarm ofNk on Ni, denoted as Pki , which is

the ratio of Nis data request being not served by theexpected node Nk due to Nks 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 Niwill treat Nk as a risky node because a large Pki means thatNk cannot serve Nis requests due to selfishness in itsmemory usage. To effectively identify the expected node (s),Ni should know the (expected) status of other nodesmemory 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 ofSSki and ND

ki . Node Ni updates CR

ki 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 CRki . If the measured CR

ki exceeds ,

node Nk will be detected as a selfish node by Ni. The valueof Pki (as well as SS

ki and ND

ki ) 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 CR

ki can be

weighted 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 CR

ki may be

strongly affected by Si and ni if CRki is not normalized. By

normalizing, we obtain (3), where nCRki stands for thenormalized CRki .

nCRki

Pki

SSkiSi 1

NDkini

; where 0 1: 3

Algorithm 1 describes how to detect selfish nodes. Ateach relocation period, node Ni detects selfish nodes basedon nCRki . Each node may have its own initial value of P

ki as

a system parameter. Interestingly, the initial value of Pki canrepresent 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 ND

ki and SS

ki

accordingly. Recall that both NDki 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 nodes00: At every relocation period01: /Ni detects selfish nodes with this algorithm

/02: detection(){03: for (each connected node Nk ){04: if nCRki < 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 NDki the number of allocated replica;10: SSki the total size of allocated replica;}11: else{12: NDki 1;13: SSki the size of a data item;14: } } }

Algorithm 2. Pseudo code to update selfish features00: At every query processing time01: / 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 ;


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 item

may not reach Ni due to disconnection, not its selfishness. In the currentsolution, however, we assume that Ni cannot tell Nks 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.



5/14

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 ND

ki 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 issuesa query, Ni awaits the response from the expected node Nkduring the predefined wait time !, where ! is the expectedmaximum time taken to exchange one round of request-response message across the entire network. Whenever Nidetects the selfish behavior of Nk, it modifies P

ki , ND

ki , and

SSki accordingly. If Nk serves the query as expected,however, only Pki will be decreased, while ND

ki and SS

ki

remain unchanged. Note that, in case an unexpected node Njreplies to Nis request, Ni will modify ND

ji and SS

ji

accordingly, while not affecting Pji , Pki , ND

ki , and SS

ki . 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 P

ki , ND

ki , and/or SS

ki accordingly for

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

ki , and SS

ki 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 of

selfishness to apply real-world friendship management toreplica allocation in a MANET. We use the value of nCRkifor this purpose. Before constructing/updating the SCF-tree, node Ni eliminates selfish nodes from INi. Thus, Nichanges Gi into its own partial graph G

nsi . More formally,

we define Gnsi as the undirected graph Gnsi IN

nsi ; IL

nsi ,

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

nsi , and a finite set of communication links among

nodes N 2 INnsi , ILnsi . IL

nsi is derived by a smoothing out

operation in graph theory. For instance, if there exists a pathhNj; Na; Nb; . . . ; Nl; Nki in Gi, where Nj; Nk 2 IN

nsi and

Na; Nb; . . . ; Nl 2 INsi INi IN

nsi , Ni removes every link

containing the selfish nodes and then replaces Nj; Nkwith 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 asTSCFi . 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 Nis child nodes. Then, Nichecks 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 dto 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: checkChildnodesNi;04: return SCF-tree;}05: Procedure checkChildnodesNj{


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



6/14

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

07: for (each node Na 2 INa

j ){08: if (distance between Na and the root > d )09: continue;10: else if Na is an ancestor of Nj in T

SCFi

11: continue;12: else{ append Na to T

SCFi 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 N2sdiscretion (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, N1updates ND21, SS

21 , and P

21 accordingly (see Section 3.2).

Since we assume that a node can use some portion of its

memory space selfishly, we may divide memory space Mifor 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 Mifor only Ms, whereas a type-3 node uses Mi for Ms and Mp.Type-1 nodes Mi will be equal to Mp.

Algorithm 4 describes how to allocate replica, where IDiand Li denote an ordered set of all data items to be allocatedby Ni and the list of node ids, respectively. Note that, IDi is

sorted in descending order of Nis access frequency.Consequently, each node allocates replicas in descendingorder ofits own access frequency. This is quite different fromexisting group-based replica allocationtechniques(e.g., DCG

in [12]) where replicas are allocated based on the accessfrequency of group members. Each node Ni executes thisalgorithm at every relocation period after building its ownSCF-tree. At first, a node determines the priority forallocating replicas. The priority is based on Breadth First

Search (BFS) order of the SCF-tree.The dotted arrow in Fig. 3brepresents the priority for allocating replica. For example, inFig. 3b, N1 selects N2 as the first target of the allocation. Afterallocating 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-robinmanner. The target node will be the expected node in ourstrategy. Since a node allocates a replica to the target node inits SCF-tree once during a single relocation phase, a node hasat most one expected node for each replica. When its own Msis not full, Ni allocates replica to its Ms first. When its own Msbecomes full, the node requests replica allocation to nodes inits SCF-tree in the order of priority. In our allocation

technique, if Ms is full and Mp is not full, a node may useMp for data items of local interest temporarily. However,public data cannot be held in Ms.

Algorithm 4. Pseudo code for replica allocation00: /Ni executes this algorithm at relocation period

/01: replica_allocation(){02: Li make priorityT

SCFi ;

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: ifNk requests for the allocation of Dq13: 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 BF S;17: append the selected vertex id to Li; }18: return Li; }

19: Procedure replica_allocation_for_othersNk; Dq{20: ifNk is in TSCFi and Ni does not hold Dq{21: if (Mp is not full) allocate Dq to Mp ;22: else{=Mp is full

=


Fig. 3. SCF-tree-based replica allocation from N1s perspective.



7/14

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 nCR

hi

among the nodes which allocated replica to Mp=

27: if nCRhi > nCRki

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 Niis 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. IfNk is in the T

SCFi and Ni does not hold

the requested replica of Dq in its memory space, the replicaallocation will be accepted. IfNis Mp is not full, the replicaof Dq will be allocated to the Mp. If Nis Mp is full and Niholds 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 the

nCRhi with nCRki , where Nh is the node with the highestnCR score among the nodes that allocated replica to NisMp. If nCRhi exceeds nCR

ki , Ni replaces the replica

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

from N1s 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 replica

allocation based on its own SCF-tree, described in Fig. 3b.The depth of the SCF-tree in Fig. 3b is two. Since nCR31 andnCR41 are greater than , N1 detects N3 and N4 as selfishnodes. Therefore, N3 and N4 are excluded by N1 in thereplica allocation. Fig. 3a shows Gns1 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 appropriately

handles 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 processesthefollowing 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 Mpbased on the nCRki given by Table 2. If the highestnCRhi among the nodes which allocated replica toNi, is greater than nCR

ki , Ni replaces replica

allocated by Nh with replica requested by Nk.

In this example, each node allocates replica at itsdiscretion like N1s allocation in Fig. 3c and then each nodemaintains its memory space based on received requests forreplica allocation. For instance, N1 allocates D2, D3, and D6to N5, and N6 allocates D3, D9, and D4 to N5. In this case, N5accepts allocation request from N6 since nCR

15 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 D9and 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.


TABLE 2Example of nCRki of Each Node

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



8/14

. 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 G

nsi . Consequently, eSCF-tree

includes 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 case

of 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 T

eSCFi . To

determine 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 of

selfish 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 hops

from 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 on

the 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


TABLE 3Simulation Parameters



9/14

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 a

result, 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 nodesselfishness. 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 accessibility

performance 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 Pki . In building the SCF-tree, we use the depth d. Weselect data accessibility as the most important criterion to

determine the values of parameters.We set ! to 50 units of simulation time, since we observe

that 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 Pki 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 selfish

nodes 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 nodes 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 with

varying 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


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


10/14

nodes in DCG than in DCG, since our detection methodaugmented in DCG detects selfish nodes effectively and thedetected selfish nodes are removed from replica allocation

groups. 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 DCG

techniques show better performance thanDCG

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 on

the 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 nearby

nodes in a real hop count (e.g., N5 from the viewpoint ofN1in 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 our

techniques 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


Fig. 6. Communication cost with varying parameters.



11/14

(while outperforming DCG significantly in communicationcost). The DCG technique shows the worst performance.This can be explained as follows: the distance in hop counts

among 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, theprofit of DCG is considerably hampered by many selfishnodes, since the biconnected component becomes none-

ffective. However, in our techniques, the number ofsuccessful queries being locally served increases slightly.This is because when the number of nodes in the SCF-tree isvery 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 allocationmethods under consideration. We expect that our techni-ques perform significantly better than other techniques inthe presence of selfish nodes. Fig. 8 highlights the strengthof our methodology: in all cases, our techniques outperform

SAF, DCG, and DCG considerably, since our techniquescan detect and handle selfish nodes in replica allocationeffectively and efficiently. Among our techniques, the eSCFtechnique shows a slightly poorer performance.

Our initial intuition was that, data accessibility is stablewith relocation periods. This is confirmed by the results inFig. 8a. Fig. 8b shows that data accessibility is proportionalto the size of memory space, as expected. The performanceof our techniques improves faster than do others, since ourtechniques fully utilize the memory space of nodes. Fig. 8cshows the robustness of our techniques with respect to


Fig. 8. Data accessibility with varying parameters.

Fig. 7. Query delay with varying parameters.



12/14

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 each

other 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 the

problem of selfish behavior from thenetwork 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-paymenttechniques, each nodegivesa 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 assumethat 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 theproblem of selfishreplica 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 work

also 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 allocation

techniques 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 the

cooperative 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.


Fig. 9. Effect of communication range.



13/14

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, somestrategies 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 bandwidth

limitation 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 handle

the selfish replica allocation appropriately. The proposedstrategies are inspired by the real-world observations ineconomics in terms of credit risk and in human friendshipmanagement in terms of choosing ones friends completelyat ones own discretion. We applied the notion of credit riskfrom 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 novelreplica 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 theMEST (No. 2009-0077925) and with partial support from aKorea University Grant.

REFERENCES[1] E. Adar and B.A. Huberman, Free Riding on Gnutella, First

Monday, 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 Mobile

Ad Hoc Networks, Proc. IEEE Ann. Conf. Pervasive Computing and

Comm. Workshops, pp. 104-108, 2004.[10] M. Feldman and J. Chuang, Overcoming Free-Riding Behavior in

Peer-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 Intl 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 and

Mobile Access, pp. 2-6, 2004.[20] Y. Liu and Y. Yang, Reputation Propagation and Agreement in

Mobile 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, Whats 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 IntlConf. 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.




14/14

[27] P. Padmanabhan, L. Gruenwald, A. Vallur, and M. Atiquzzaman,A Survey of Data Replication Techniques for Mobile Ad HocNetwork Databases, The Intl 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 Data

Accessibility and Query Delay in Ad Hoc Networks, Proc. IEEEIntl 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.Intl 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.



Documents

Handlingselfishnessinreplicaallocationoveramobileadhocnetwork Bak 120831235344 Phpapp01