Handling Selfishness in Replica Allocation over Mobile Networks

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
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
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 nodes 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: klwu@us.ibm.com.
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:
tmc@computer.org, 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
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 `
1
. `
2
. . . . . `
6
maintain their
memory space `
1
. `
2
. . . . . `
6
, 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 `
3
and `
4
). 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 `
3
behaves selfishly by
maintaining `
0
3
, instead of `
3
, to prefer the locally
frequently accessed data for low query delay. In the original
case, 1
3
, 1
9
, and 1
2
were allocated to `
3
. However, due to
the selfish behavior, 1
3
, 1
5
, and 1
2
, the top three most
locally frequently accessed items, are instead maintained in
local storage. Thus, other nodes in the same group, i.e., `
1
,
`
2
, and `
4
, are no longer able to access 1
9
. This showcases
degraded data accessibility, since `
1
, `
2
, and `
4
cannot
fully leverage `
3
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 `
4
may want to
locally hold 1
2
, one of the locally frequently accessed data
items. In this case, `
4
uses only a part of its storage for its
own frequently accessed data, while the remaining part is
for the benefit of overall data accessibility. Thus, `
4
may
decide to maintain `
0
4
, instead of `
4
. Even with only
partial selfishness, data accessibility is still degraded, since
the other nodes in the same group, i.e., `
1
, `
2
, and `
3
,
cannot access 1
10
.
We believe that the partially selfish nodes (e.g., `
4
in
Fig. 1) should also be taken into account, in addition to the
fully selfish nodes (e.g., `
3
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 the
developed selfish node detection method. They are based
on the concept of a self-centered friendship tree (SCF-tree) and
its 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 management
in the real world. In the real world, a friendship, which is a
form of social bond, is made individually [4]. For example,
although and 1 are friends, the friends of are not
always the same as the friends of 1. With the help of SCF-
tree, we aim to reduce the communication cost, while still
achieving 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 the
perspective of data replication, and recognize that
selfish replica allocation can lead to degraded data
accessibility in a MANET.
. Detecting the fully or the partially selfish nodes
effectively: We devise a selfish node detection
method that can measure the degree of selfishness.
. Allocating replica effectively: We propose a set of
replica allocation techniques that use the self-
centered friendship tree to reduce communication
cost, while achieving good data accessibility.
. Verifying the proposed strategy: The simulation
results 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 replica
allocation. The proposed detection method and the replica
allocation techniques are presented in Section 3. Section 4
evaluates the performance of our strategy. We briefly
overview related work, and conclude the paper in Sections 5
and 6, respectively.
2 PRELIMINARIES
2.1 System Model
In this paper, we assume that each node has limited local
memory space and acts as a data provider of several data
items and a data consumer. Each node holds replicas of data
items, and maintains the replicas in local memory space.
The replicas are relocated in a specific period. There are i
nodes, `
1
. `
2
. . . . . `
i
and no central server determines the
CHOI ET AL.: HANDLING SELFISHNESS IN REPLICA ALLOCATION OVER A MOBILE AD HOC NETWORK 279
TABLE 1
Access Frequency of Nodes (Excerpt from [12])
Fig. 1. Example of selfish replica allocation (excerpt from [12]).
allocation of replica. Any node freely joins and organizes an
open MANET. We model a MANET in an undirected graph
G IN. IL that consists of a finite set of nodes, IN, and a
finite set of communication links, IL, where each element is a
tuple `
,
. `
/
of nodes in the network.
To focus on the selfish replica allocation problem, we
do not consider selfishness in data forwarding throughout
this paper. We make the following assumptions, similar to
those in [12].
. Each node in a MANET has a unique identifier. All
nodes that are placed in a MANET are denoted by
` f`
1
. `
2
. . . . . `
i
g, where i is the total number
of nodes.
. All data items are of equal size, and each data item is
held by a particular node as its original node. Each
data item has a unique identifier, and the set of all
data items is denoted by 1 f1
1
. 1
2
. . . . . 1
i
g,
where i is the total number of data items.
. Each node `
i
1 i i has limited memory space
for replica and original data items. The size of the
memory space is o
i
. Each node can hold only C,
where 1 < C < i, replica in its memory space.
. Data items are not updated. This assumption is for
the sake of simplicity, i.e., we do not have to address
data consistency or currency issues. Applications
satisfying this feature include digging investigation
and weather information [12].
. Each node `
i
1 i i has its own access
frequency to data item 1
,
2 1 1 , i, 1
,
i
.
The access frequency does not change.
. Each node moves freely within the maximum
velocity.
When a node `
i
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 `
i
holds the original or
replica of the data item in its local memory. If it does not
hold the original or replica, the request will be broadcast.
1
The request is also successful when `
i
receives any reply
from at least one node connected to `
i
with one hop or
multiple hops, which holds the original or replica of the
targeted data item. Otherwise, the request, or query
processing, fails.
When a node `
i
receives a data access request, it either
1) serves the request by sending its original or replica if it
holds the target data item (the data may go through multiple
hops before reaching the requester), or 2) forwardthe request
to its neighbors if it does not hold the target data item.
2.2 Node Behavior Model
The work [23] considers only binary behavioral states for
selfish nodes from the network routing perspective: selfish
or not (i.e., forwarding data or not). As mentioned in
Section 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 for
nodes from the viewpoint of selfish replica allocation
2
:
. Type-1 node: The nodes are nonselfish nodes. The
nodes hold replicas allocated by other nodes within
the 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 their
accessibility.
. Type-3 node: The nodes are partially selfish nodes.
The nodes use their memory space partially for
allocated replicas by other nodes. Their memory
space may be divided logically into two parts: selfish
and public area. These nodes allocate replicas to
other nodes for their accessibility.
The detection of the type-3 nodes is complex, because
they are not always selfish. In some sense, a type-3 node
might be considered as nonselfish, since the node shares
part of its memory space. In this paper, however, we have
considered it as (partial) selfish, because the node also leads
to the selfish replica allocation problem, as described in
Section 1. Note that selfish and nonselfish nodes perform
the same procedure when they receive a data access
request, although they behave differently in using their
memory 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. At
a specific period, or relocation period [12], each node
executes the following procedures:
. Each node detects the selfish nodes based on credit
risk scores.
. Eachnode makes its own(partial) topologygraphand
builds its own SCF-tree by excluding selfish nodes.
. Based on SCF-tree, each node allocates replica in a
fully distributed manner.
The CR score is updated accordingly during the query
processing phase. We borrow the notion of credit risk from
economics to effectively measure the degree of selfish-
ness. In economics, credit risk is the measured risk of loss
due to a debtors nonpayment of a loan. A bank examines
the credit risk of an applicant prior to approving the loan.
The measured credit risk of the applicant indicates if he/she
is creditworthy. We take a similar approach. A node wants
to know if another node is believable, in the sense that a
replica can be paid back, or served upon request to share a
memory space in a MANET.
With the measured degree of selfishness, we propose a
novel tree that represents relationships among nodes in a
MANET, for replica allocation, termed the SCF-tree. The
SCF-tree models human friendship management in the real
1. Note that if the where-to-allocate-replica information is available to a
node during the replica allocation phase, unicast may be an efficient way in
terms of communication cost. However, unicast may not be efficient from
the viewpoint of query processing even in this case, since, if a node unicasts
a request, the request is likely to fail frequently due to the network topology
dynamics in a MANET. Thus, most research work [12] [13] [14] [32] on
replica 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 behave
differently in using memory space, although type-2 and type-3 can be easily
combined by defining the size of the shared memory space, as a continuous
scale, say, where 0 implies type-2 and the other values imply type-3.
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
crjcctcd ii:/
crjcctcd .o|nc
. 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 features
can be explained by considering the following case: A
selfish node may share part of its own memory space, or a
small number of data items, like the type-3 node. In this
case, the size of shared memory space and/or the number
of shared data items can be used to represent the degree of
selfishness. In our approach, the size of `
/
s shared
memory space, denoted as oo
/
i
, and the number of `
/
s
shared data items, denoted as `1
/
i
, observed by a node `
i
,
are used as node-specific features.
3
Note that both oo
/
i
and `1
/
i
are `
i
s estimated values, since `
/
, which may be
selfish or not, does not necessarily let `
i
know the number
of shared data items or size of the shared memory space.
The node-specific features can be used to represent the
expected value of a node. For instance, when node `
i
observes that node `
/
shares large oo
/
i
and `1
/
i
, node `
/
may be treated as a valuable node by node `
i
.
As the query processing-specific feature, we utilize the
ratio of selfishness alarm of `
/
on `
i
, denoted as 1
/
i
, which is
the ratio of `
i
s data request being not served by the
expected node `
/
due to `
/
s selfishness in its memory space
(i.e., no target data item in its memory space).
4
Thus, the
query processing-specific feature can represent the expected
risk of a node. For instance, when 1
/
i
gets larger, node `
i
will treat `
/
as a risky node because a large 1
/
i
means that
`
/
cannot serve `
i
s requests due to selfishness in its
memory usage. To effectively identify the expected node (s),
`
i
should know the (expected) status of other nodes
memory space. Our SCF-tree-based replica allocation
techniques, fortunately, support this assumption. This will
be explained in the following section. Using the described
features, we can modify (1) into (2):
C1
/
i
1
/
i
c oo
/
i
1 c `1
/
i
. where 0 c 1. 2
The system parameter, c, is used to adjust the relative
importance of oo
/
i
and `1
/
i
. Node `
i
updates C1
/
i
at every
query processing and looks it up for the connected node `
/
at
every relocation period. In addition, each node also has its
own threshold c of C1
/
i
. If the measured C1
/
i
exceeds c,
node `
/
will be detected as a selfish node by `
i
. The value
of 1
/
i
(as well as oo
/
i
and `1
/
i
) is updated at every query
processing of some item that `
i
allocates to other node(s)
during the replica allocation phase.
The effect of parameters oo
/
i
and `1
/
i
on C1
/
i
can be
weighted by taking into consideration the size of memory
space at node `
i
, o
i
, and the total number of data items
accessed by `
i
, i
i
. The rationale is that C1
/
i
may be
strongly affected by o
i
and i
i
if C1
/
i
is not normalized. By
normalizing, we obtain (3), where iC1
/
i
stands for the
normalized C1
/
i
.
iC1
/
i
1
/
i
c
oo
/
i
o
i
1 c
`1
/
i
i
i
. where 0 c 1. 3
Algorithm 1 describes how to detect selfish nodes. At
each relocation period, node `
i
detects selfish nodes based
on iC1
/
i
. Each node may have its own initial value of 1
/
i
as
a system parameter. Interestingly, the initial value of 1
/
i
can
represent the basic attitude toward strangers. For instance, if
the initial value equals zero, node `
i
always treats a new
node as a nonselfish node. Therefore, `
i
can cooperate with
strangers easily for cooperative replica sharing. Replicas of
data items are allocated by allocation techniques shown in
Section 3.4. After replica allocation, `
i
sets `1
/
i
and oo
/
i
accordingly. Recall that both `1
/
i
and oo
/
i
are estimated
values, not accurate ones. The estimated values are adjusted
at query processing time, according to Algorithm 2.
Algorithm 1. Pseudo code to detect selfish nodes
00: At every relocation period
01: /
`
i
detects selfish nodes with this algorithm
/
02: detection(){
03: for (each connected node `
/
){
04: if iC1
/
i
< c`
/
is marked as non-selfish;
05: else `
/
is marked as selfish;}
06: wait until replica allocation is done;
07: for (each connected node `
/
){
08: if `
i
has allocated replica to `
/
{
09 `1
/
i
the number of allocated replica;
10: oo
/
i
the total size of allocated replica;}
11: else{
12: `1
/
i
1;
13: oo
/
i
the size of a data item;
14: } } }
Algorithm 2. Pseudo code to update selfish features
00: At every query processing time
01: /
When `
i
issues a query
/
02: update_SF(){
03: while (during the predefined time .){
04: if (an expected node `
/
serves the query)
05: decrease 1
/
i
;
3. Either oo
/
i
or `1
/
i
is sufficient, since we assume that all data items are
of equal size. However, we stick to both factors here for a generic
application.
4. Actually, the reply from expected node `
/
holding a target data item
may not reach `
i
due to disconnection, not its selfishness. In the current
solution, however, we assume that `
i
cannot tell `
/
s selfishness from
network disconnection, since their impacts are identical to `
i
, i.e., data
inaccessibility. The identification and handling of a false alarm is one of
interesting, promising future works.
06: if (an unexpected node `
,
serves the query){
07: `1
,
i
`1
,
i
1;
08: oo
,
i
oo
,
i
(the size of a data item);
09: } }
10: if (an expected node `
/
does not serve the query){
11: increase 1
/
i
;
12: `1
/
i
`1
/
i
1;
13: oo
/
i
oo
/
i
(the size of a data item);
14: } }
As described in Algorithm 2, `
i
maintains its `1
/
i
, oo
/
i
,
and 1
/
i
during each query processing phase. When `
i
issues
a query, `
i
awaits the response from the expected node `
/
during the predefined wait time ., where . is the expected
maximum time taken to exchange one round of request-
response message across the entire network. Whenever `
i
detects the selfish behavior of `
/
, it modifies 1
/
i
, `1
/
i
, and
oo
/
i
accordingly. If `
/
serves the query as expected,
however, only 1
/
i
will be decreased, while `1
/
i
and oo
/
i
remain unchanged. Note that, in case an unexpected node `
,
replies to `
i
s request, `
i
will modify `1
,
i
and oo
,
i
accordingly, while not affecting 1
,
i
, 1
/
i
, `1
/
i
, and oo
/
i
. That
is, the reply fromunexpectednodes does not affect the selfish
features of expected nodes. Note also that `
i
may receive
multiple replies from unexpected and/or expected nodes. In
this case, `
i
modifies 1
/
i
, `1
/
i
, and/or oo
/
i
accordingly for
each reply based on Algorithm 2. If `
i
does not receive any
reply from expected node `
/
during ., it observes `
/
s
selfish behavior and modifies 1
/
i
, `1
/
i
, and oo
/
i
accordingly.
3.3 Building SCF-Tree
The SCF-tree based replica allocation techniques are
inspired by human friendship management in the real
world, where each person makes his/her own friends
forming a web and manages friendship by himself/herself.
He/she does not have to discuss these with others to
maintain the friendship. The decision is solely at his/her
discretion. The main objective of our novel replica alloca-
tion techniques is to reduce traffic overhead, while
achieving high data accessibility. If the novel replica
allocation 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 own
partial topology graph G
i
IN
i
. IL
i
, which is a component
of the graph G. G
i
consists of a finite set of the nodes
connected to `
i
and a finite set of the links, where
`
i
2 IN
i
. IN
i
IN, and IL
i
IL. Since the SCF-tree consists
of only nonselfish nodes, we need to measure the degree of
selfishness to apply real-world friendship management to
replica allocation in a MANET. We use the value of iC1
/
i
for this purpose. Before constructing/updating the SCF-
tree, node `
i
eliminates selfish nodes from IN
i
. Thus, `
i
changes G
i
into its own partial graph G
i:
i
. More formally,
we define G
i:
i
as the undirected graph G
i:
i
IN
i:
i
. IL
i:
i
,
which consists of a finite set of nonselfish nodes detected by
`
i
, IN
i:
i
, and a finite set of communication links among
nodes ` 2 IN
i:
i
, IL
i:
i
. IL
i:
i
is derived by a smoothing out
operation in graph theory. For instance, if there exists a path
h`
,
. `
o
. `
/
. . . . . `
|
. `
/
i in G
i
, where `
,
. `
/
2 IN
i:
i
and
`
o
. `
/
. . . . . `
|
2 IN
:
i
IN
i
IN
i:
i
, `
i
removes every link
containing the selfish nodes and then replaces `
,
. `
/
with a new edge (the new edge is added since we do not

consider selfishness in data forwarding).
Based on G
i:
i
, `
i
builds its own SCF-tree, denoted as
T
oC1
i
. Algorithm 3 describes how to construct the SCF-tree.
Each node has a parameter d, the depth of SCF-tree. When
`
i
builds its own SCF-tree, `
i
first appends the nodes that
are connected to `
i
by one hop to `
i
s child nodes. Then, `
i
checks recursively the child nodes of the appended nodes,
until the depth of the SCF-tree is equal to d. Fig. 2 illustrates
the network topology and some SCF-trees of `
1
and `
2
in
Fig. 1. In this example, we assume that all nodes are
nonselfish nodes for simplicity. As can be seen in Figs. 2b
and 2c, the SCF-tree may have multiple routes for some
nodes from the root node. For example, in Fig. 2b, `
1
has
two routes to `
2
when `
1
sets its own parameter d to be 4.
Since the multiple routes confer high stability [12], we
allocate more replicas to the nodes that have multiple routes
from the root node. At every relocation period, each node
updates its own SCF-tree based on the network topology of
that moment.
Algorithm 3. Pseudo code to build SCF-tree
00:/
`
i
makes SCF-tree with a parameter, depth d
/
01: constructScfTree(){
02: append `
i
to SCF-tree as the root node;
03: checkChildnodes`
i
;
04: return SCF-tree;}
05: Procedure checkChildnodes`
,
{
Fig. 2. Example of a self-centered friendship tree.
06: /
IN
o
,
is a set of nodes that are adjacent nodes to `
,
/
07: for (each node `
o
2 IN
o
,
){
08: if (distance between `
o
and the root d )
09: continue;
10: else if `
o
is an ancestor of `
,
in T
oC1
i
11: continue;
12: else{ append `
o
to T
oC1
i
as a child of `
,
;
13: checkChildnodes(`
o
); } } }
3.4 Allocating Replica
After building the SCF-tree, a node allocates replica at every
relocation period. Each node asks nonselfish nodes within
its SCF-tree to hold replica when it cannot hold replica in its
local memory space. Since the SCF-tree based replica
allocation is performed in a fully distributed manner, each
node determines replica allocation individually without any
communication with other nodes.
Since every node has its own SCF-tree, it can perform
replica allocation at its discretion. For example, in Fig. 3,
after building the SCF-tree in Fig. 3b, `
1
may ask `
2
to hold
some replicas. Note that the decision, whether to accept the
replica allocation request or not, will be made at `
2
s
discretion (if `
2
is selfish, it may not accept the replica
allocation request). Afterward, node `
1
may issue a query
for the replicas. At this time, `
1
is likely to recognize
whether the expected `
2
serves the query (i.e., nonselfish) or
not (i.e., selfish). By observing the behavior of `
2
, `
1
updates `1
2
1
, oo
2
1
, and 1
2
1
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 `
i
for replica logically into two parts: selfish area `
:
and
public area `
j
. Each node may use its own memory space
`
i
freely as `
:
and/or `
j
. In each node, `
:
will be used
for data of local interest (i.e., to reduce query delay), while
`
j
for public data is asked to hold data by other node(s)
(i.e., to improve data accessibility). A type-2 node uses `
i
for only `
:
, whereas a type-3 node uses `
i
for `
:
and `
j
.
Type-1 nodes `
i
will be equal to `
j
.
Algorithm 4 describes how to allocate replica, where ID
i
and 1
i
denote an ordered set of all data items to be allocated
by `
i
and the list of node ids, respectively. Note that, ID
i
is
sorted in descending order of `
i
s access frequency.
Consequently, each node allocates replicas in descending
order of its own access frequency. This is quite different from
existing group-basedreplica allocationtechniques (e.g., DCG
in [12]) where replicas are allocated based on the access
frequency of group members. Each node `
i
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 dottedarrowin Fig. 3b
represents the priority for allocating replica. For example, in
Fig. 3b, `
1
selects `
2
as the first target of the allocation. After
allocating a replica to the last target node (i.e., `
5
in Fig. 3b),
the first node, `
2
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 own `
:
is not full, `
i
allocates replica to its `
:
first. When its own `
:
becomes full, the node requests replica allocation to nodes in
its SCF-tree in the order of priority. In our allocation
technique, if `
:
is full and `
j
is not full, a node may use
`
j
for data items of local interest temporarily. However,
public data cannot be held in `
:
.
Algorithm 4. Pseudo code for replica allocation
00: /
`
i
executes this algorithm at relocation period
/
01: replica_allocation(){
02: 1
i
make priorityT
oC1
i
;
03: for (each data item 2 ID
i
){
04: if (`
:
is not full)
05: allocate replica of the data to `
:
;
06: else{/
`
:
is full
/
07: allocate replica of the data to the target node;
08: /
the target node is selected from 1

i
,
09: if (`
j
is not full)
10: allocate replica of the data to `
j
; } }
11: while (during a relocation period){
12: if `
/
requests for the allocation of 1
13: replica_allocation_for_others `
/
. 1
; } }
14: Procedure make_priority T
oC1
i
{
15: for (all vertices in T
oC1
i
){
16: select a vertex in T
oC1
i
in order of 11o;
17: append the selected vertex id to 1
i
; }
18: return 1
i
; }
19: Procedure replica_allocation_for_others`
/
. 1
{
20: if `
/
is in T
oC1
i
and `
i
does not hold 1
{
21: if (`
j
is not full) allocate 1
to `
j
;
22: else{,
`
j
is full
,
Fig. 3. SCF-tree-based replica allocation from `
1
s perspective.
23: if(`
i
holds any replica of local interest in `
j
)
24: replace the replica with 1
;
25: else{
26: ,
`
/
is the node with the highest iC1
/
i
among the nodes which allocated replica to `
j
,
27: if iC1
/
i
iC1
/
i
28: replace the replica requested by `

/
with 1
;
29: } } } }
During a relocation period, `
i
may receive requests for
replica allocation from any nodes within its SCF-tree. If `
i
is not a fully selfish node, `
i
shall maintain its memory
space `
j
for the requests from other nodes, say `
/
. In this
case, `
i
should determine whether to accept the replica
allocation request. If `
/
is in the T
oC1
i
and `
i
does not hold
the requested replica of 1
in its memory space, the replica

allocation will be accepted. If `
i
s `
j
is not full, the replica
of 1
will be allocated to the `

j
. If `
i
s `
j
is full and `
i
holds any replica allocated by itself in its `
j
, `
i
will
replace the replica with 1
. If `
i
does not hold any replica
allocated by itself in its `
j
and `
j
is full, `
i
compares the
iC1
/
i
with iC1
/
i
, where `
/
is the node with the highest
iC1 score among the nodes that allocated replica to `
i
s
`
j
. If iC1
/
i
exceeds iC1
/
i
, `
i
replaces the replica
requested by `
/
with 1
.
Fig. 3c shows the expected result of replica allocation
from `
1
s perspective, derived from Tables 1, 2, and Fig. 1.
Since `
1
may not know the real size of memory space at
other nodes, `
1
allocates a different number of data items to
each node. We omit the original data of each node and other
replica here, because `
1
may not know who hold the
original data and/or other replica. We assume that `
1
sets
its threshold c to 0.7. In Fig. 3c, `
1
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 iC1
3
1
and
iC1
4
1
are greater than c, `
1
detects `
3
and `
4
as selfish
nodes. Therefore, `
3
and `
4
are excluded by `
1
in the
replica allocation. Fig. 3a shows G
i:
1
that is built by `
1
prior
to constructing the SCF-tree. After its own replica alloca-
tion, `
1
expects that `
2
, `
5
, and `
6
maintain their own
memory space, like `
2
, `
5
, and `
6
in Fig. 3c, respectively.
The objective of the above-mentioned SCF-tree based
replica allocation technique is to achieve good data accessi-
bility with low communication cost in the presence of selfish
nodes. Since our replica allocation technique appropriately
handles the (partially) selfish nodes, the technique is
expected to achieve the objective. Fig. 4 illustrates the final
replica allocation results derived from Tables 1, 2, and Fig. 1.
Inmore detail, eachnode processes the followingprocedures:
1. Each node allocates replica at its discretion based on
Table 1 and Fig. 1.
2. When each node receives a request for replica
allocation from `
/
during a relocation period, it
determines whether to accept the request.
3. If the request is accepted, each node maintains its `
j
based on the iC1
/
i
given by Table 2. If the highest
iC1
/
i
among the nodes which allocated replica to
`
i
, is greater than iC1
/
i
, `
i
replaces replica
allocated by `
/
with replica requested by `
/
.
In this example, each node allocates replica at its
discretion like `
1
s allocation in Fig. 3c and then each node
maintains its memory space based on received requests for
replica allocation. For instance, `
1
allocates 1
2
, 1
3
, and 1
6
to `
5
, and `
6
allocates 1
3
, 1
9
, and 1
4
to `
5
. In this case, `
5
accepts allocation request from`
6
since iC1
1
5
is greater than
iC1
6
5
. Thus, `
5
holds 1
3
and 1
9
in its `
j
. In our allocation
technique, each node allocates replica to other nodes
considering selfishness. Thus, every node can access 1
9
and 1
10
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 nodes
within its SCF-tree at its own discretion, the proposed
allocation technique is highly expected to incur very low
communication 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 a
basic SCF-tree based technique.
. SCF-tree based replica allocation with degree of
selfishness (SCF-DS): This technique takes into
account the degree of selfishness in allocating
replicas. That is, less selfish nodes should be visited
first at the same SCF-tree level. This policy makes
more frequently accessed data items reside on less
selfish nodes.
. SCF-tree based replica allocation with closer node
(SCF-CN): This technique allocates more replicas to
the closer nodes in the SCF-tree. That is, more
replicas are allocated to the node with lower depth
within the SCF-tree.
TABLE 2
Example of iC1
/
i
of Each Node
Fig. 4. Example of SCF-tree-based replica allocation.
. Extended SCF-tree based replica allocation (eSCF):
This technique is based on an extended SCF-tree
(eSCF-tree). In this technique, `
i
builds its eSCF-
tree based on G
i
, not G
i:
i
. Consequently, eSCF-tree
includes selfish nodes, as well as nonselfish nodes.
`
i
marks the detected selfish nodes within its eSCF-
tree and allocates replicas to the nonselfish nodes in
its eSCF-tree first. After the first round, `
i
allocates
replicas to all nodes (i.e., including selfish nodes)
within its eSCF-tree in a round-robin manner. As it
will turn out in Section 4, this technique shows the
best 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 slight
changes to Algorithm 4 (mainly in the make_priority()
procedure). In the case of SCF-DS, the priority for replica
allocation is determined by the pair: (depth of SCF-tree,
iC1 ). That is, the higher priority is given to the lower
depth, and for nodes with the same depth, the replica is
allocated in ascending order of the iC1 scores. In the case
of SCF-CN, the vertex ids are appended to 1
i
repeatedly.
The number of repetitions is determined as 1 di)), where
di)) is the difference between the depth of the SCF-tree and
the depth of the vertex of interest in the SCF-tree. For
example, 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 to
the closer nodes. In the case of eSCF technique, eSCF-tree is
used for replica allocation instead of SCF-tree. Therefore, all
T
oC1
i
in Algorithm 4 should be changed into T
coC1
i
. To
determine the priority, `
i
appends nonselfish nodes to 1
i
first, and then entire nodes, including selfish nodes, to 1
i
.
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 a
velocity from 0 $ 1 (m/s) over 50 m 50 m flatland.
The movement pattern of nodes follows the random
waypoint model [5], where each node remains stationary
for a pause time and then it selects a random destination
and moves to the destination. After reaching the destina-
tion, it again stops for a pause time and repeats this
behavior. The radio communication range of each node is a
circle with a radius of 1 $ 19 (m). We suppose that there
are 40 individual pieces of data, each of the same size. In
the network, node `
i
(1 i 40 ) holds data 1
i
as the
original. The data access frequency is assumed to follow
7ij) distribution. The default relocation period is set to
256 units of simulation time which we vary from 64 to
8,192 units of simulation time. Table 3 describes the
simulation parameters.
The default number of selfish nodes is set to be 70 percent
of the entire nodes in our simulation, based on the
observation of a real application [1]. We set 75 percent of
selfish nodes to be type-3 (i.e., partially selfish) and the
remaining to be type-2 (i.e., fully selfish). Type-3 nodes
consist 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 requests
from other nodes in the replica allocation phase, thus being
expected to create significant selfishness alarm in query
processing. Type-3 nodes will accept or reject replica
allocation requests according to their local status (see
Algorithm 4 in Section 3.4), thereby causing some self-
ishness alarms in subsequent query processing.
We evaluate our strategy using the following four
performance metrics:
1. Overall selfishness alarm: This is the ratio of the
overall selfishness alarm of all nodes to all queries
that should be served by the expected node in the
entire system.
2. Communication cost: This is the total hop count of
data transmission for selfish node detection and
replica allocation/relocation, and their involved
information sharing.
3. Average query delay: This is the number of hops
from a requester node to the nearest node with the
requested data item. If the requested data item is in
the local memory of a requester, the query delay is 0.
We only consider successful queries, i.e., it is the
total delay of successful requests divided by the total
number of successful requests.
4. Data accessibility: This is the ratio of the number
of successful data requests to the total number of
data requests.
During 50,000 units of simulation time, we simulate and
compare the proposed replica allocation strategies (i.e., SCF,
SCF-DS, SCF-CN, and eSCF) with the following techniques:
. Static Access Frequency (SAF) [12]: Each node
allocates replica based only on its own access
frequency, without considering or detecting selfish
nodes. This allocation technique is expected to show
the optimal performance in terms of communication
cost, because the technique does not communicate
with 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, the
node, called coordinator, allocates replicas based on
the access frequency of the group. This technique is
known to have high data accessibility.
. Dynamic Connectivity-based Grouping with de-
tection (DCG
): The technique combines DCG with

TABLE 3
Simulation Parameters
our detection method. Initially, groups of nodes are
created according to the DCG methodology. Subse-
quently, in each group, selfish nodes are detected
based on our detection method. For the detection,
each node in a group sends its iC1 scores to the
coordinator with the lowest suffix of node identifer in
the group [13]. The coordinator excludes selfish
node(s) from the group for replica allocation. As a
result, only nonselfish nodes form a group again.
The replica allocation is only performed within the
final group without any selfish nodes. After replica
allocation, the coordinator shares the information of
replica allocation with group members for the
subsequent selfishness detection. In particular, self-
ish nodes are determined to be selfish only when all
other nodes in the group agree with the nodes
selfishness. We experimented with other approaches
to determine selfishness, including the agreement of
1) at least one and 2) the majority of nodes. We chose
to use the agreement of all other nodes experimen-
tally, since this shows the best data accessibility
performance in our experiments: our analysis
reveals that at least one node approach shows the
worst data accessibility, whereas its communication
cost and average query delay are marginally better
than that of the others.
4.2 Parameter Setting in Our Strategy
Several parameters are used in our strategy. For the
selfishness detection algorithm, we use the threshold c.
For the selfishness features update algorithm, we use the
predefined wait time . and need to initialize the selfishness
alarm 1
/
i
. In building the SCF-tree, we use the depth d. We
select 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 entire
network takes less than 50 units of simulation time in our
simulation setting. A similar reasoning is made in a prior
simulation environment [14]. We choose to use 2 as the
default depth of the (e)SCF-tree experimentally after
inspecting our simulation results. We observe that average
query delay, data accessibility, and communication cost are
insensitive to the depth of the SCF-tree. More specifically,
both average query delay and data accessibility are almost
the same with varying depths of SCF-tree, while commu-
nication cost increases marginally as the depth increases.
1
/
i
is initialized to 0 and c is set to 0.7. We pick the values
experimentally after inspecting our simulation results. In
our analysis, when 1
/
i
is initialized to 0, a node cooperates
with others easily and all techniques show the best
performance. Both average query delay and communication
cost are insensitive to c. However, all techniques that use
our detection method show the best performance in terms
of data accessibility, when c 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 with
that of DCG
to demonstrate the effectiveness of our

detection method. We expect that the overall selfishness
alarm 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 and
many reliable nodes will serve data requests from nodes.
However, recall that the selfishness alarm may also
occur due to network disconnections, i.e., false alarm (see
the footnote in Section 3.2). Actually, it is desirable to
observe truly selfish nodes to evaluate the effectiveness of
the detection method. As mentioned earlier in Section 3.2, a
data requester cannot tell an expected nodes selfishness
from network disconnection, since their impacts are
identical to the requester, i.e., no reply from the expected
node. Although the false alarm exists from the viewpoint of
nodes, we realize that the true selfishness can be identified
in the simulation results by identifying which data request
has not been served by the expected, connected node in query
processing. Obviously, the expected and connected nodes
are only involved in a true selfishness alarm, whereas the
expected but disconnected nodes in query processing may
lead to a false alarm. Therefore, we plot two additional
methods, DCG (selfishness only) and DCG
(selfishness
only) in Fig. 5. The overall selfishness alarm of DCG
(selfishness only) and DCG
(selfishness only) is obtained

by counting data requests that have not been served by the
expected, connected nodes in query processing, i.e., excluding
false 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 significantly
reduces the selfishness alarms in all cases. This can be
explained as follows: fewer selfish nodes become expected
Fig. 5. Overall selfishness alarm.
nodes in DCG
than in DCG, since our detection method

augmented in DCG
detects selfish nodes effectively and the

detected selfish nodes are removed from replica allocation
groups. Consequently, more expected nodes serve queries in
DCG
than in DCG.
As expected, the overall selfishness alarm of DCG
(selfishness only) and DCG
(selfishness only) is less than

that of DCG and DCG
, respectively. We see that, on

average, about 62 and 56 percent of the overall selfishness
alarm with DCG and DCG
are caused by node self-

ishness, not disconnections, in Fig. 5a. Clearly, Fig. 5 shows
that our detection method can reduce the overall self-
ishness alarm effectively.
4.3.2 Communication Cost
We evaluate several replica allocation techniques in terms
of communication cost. Our intuition was that our
techniques outperform DCG
, while being inferior to

SAF. This intuition is confirmed by the results in Fig. 6.
DCG
shows the worst performance in all cases, since

group members need to communicate with each other in
detecting selfish nodes and allocating/relocating replica.
We report that, on average, about 70 percent of total
communication cost in the DCG
technique is caused by
replica allocation/relocation, while about 30 percent is
caused by selfish node detection. As expected, SAF shows
the best performance, since no detection of selfish nodes or
group communication is made. Although SAF and DCG
techniques 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, our
analysis reveals that our techniques, which detect selfish
nodes, considerably outperform DCG, which does not
perform the selfishness detection procedure. This verifies
the efficacy of our fully distributed way of detecting selfish
nodes 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) show
very similar communication cost, since they are all based on
the same SCF-tree structure. Note that the consideration of
selfishness degree in the SCF-DS technique does not affect
the performance significantly, since nodes in the SCF-tree
are sufficiently nonselfish to hold allocated replicas in many
cases. Similarly, the performance of the SCF-CN technique
is similar to those of other techniques, since nodes with a
low depth of SCF-tree do not necessarily mean nearby
nodes in a real hop count (e.g., `
5
from the viewpoint of `
1
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 replica
allocations decreases with a large relocation period. As
shown in Fig. 6b, communication cost increases as local
memory size increases at first, but it decreases from a
certain memory size (around 20 in our analysis) in every
technique, except SAF. When the memory size is larger than
a certain memory size, each node holds replicas of many
data 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 space
than for DCG (or DCG
), since fewer replica relocations

have occurred in our techniques than in DCG (or DCG
):
(e)SCF-tree does not change a lot, thus resulting in fewer
replica relocations in our techniques. However, the DCG
(or DCG
) technique is vulnerable to network topology

changes: it should relocate replicas whenever topology
changes. As another reason, replicas in local selfish space
do 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, since
the cost in fetching replicas and/or in group communica-
tion will be reduced. In the DCG technique, the effective
memory space in the entire system gets reduced due to
many selfish nodes, resulting in reduced cost in fetching
replicas. In the DCG
technique, cost reduction is faster

than in DCG, since fewer nodes participate in replica
allocation. Note that the communication cost of our
techniques is relatively stable. This can be explained as
follows: the communication reduction factor is much less
than in DCG and DCG
, and the distance between

nonselfish 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 performance
in terms of query delay, since most successful queries are
served by local memory space. Our techniques show
slightly better query delay than does the DCG technique
Fig. 6. Communication cost with varying parameters.
(while outperforming DCG significantly in communication
cost). 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 longer
than that in the DCG technique. Since most successful
queries are served by group members in these techniques,
the long distance among group members affects query
delay negatively.
Among our techniques, the eSCF technique shows the
best average query delay. In the eSCF technique, nearby
selfish 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 size
of memory space increases. This intuition is confirmed by
the 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 as
well. As a result, more queries are served by nearby nodes
or locally.
Very interestingly, Fig. 7c shows that the performance of
DCG and DCG
gets worse, while the performance of our

techniques improves slightly with more selfish nodes. We
have done an in-depth analysis for this situation. We found
that, in the DCG and DCG
techniques, the number of

successful 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 for
data 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 techniques

can 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 in
Fig. 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 our
techniques fully utilize the memory space of nodes. Fig. 8c
shows the robustness of our techniques with respect to
Fig. 8. Data accessibility with varying parameters.
Fig. 7. Query delay with varying parameters.
varying percentage of selfish nodes. The profit of DCG
technique 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. In
all cases, our techniques outperform DCG and DCG
,
while SAF shows the best performance in terms of
communication cost and average query delay. As the
communication range increases, the communication cost
of all techniques increases at first, but it gets smaller from a
certain point (9 in our analysis), except SAF. When the
communication range is smaller than a certain point, the
communication cost increases as the communication range
gets larger, since the number of nodes connected to each
other increases and thus the communication cost caused by
replica relocation increases. Conversely, when the commu-
nication range is larger than a certain point, the number of
hops among connected nodes decreases. Therefore, the
communication cost caused by replica relocation decreases.
Fig. 9b shows that the average query delay of all
techniques 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, the
number of hops among connected nodes decreases. We see,
in Fig. 9c, that the data accessibility improves with the wide
range 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 in
the work [3], [24], [33]. In a closed MANET, all nodes
voluntarily participate in and organize the network.
However, in an open MANET, which we consider in this
paper, however, individual nodes may have different
objectives. In this case, some nodes can be selfish to
preserve their own resources.
Various techniques have been proposed to handle the
problemof selfish behavior fromthe network perspective. As
described in [33], techniques handling selfish nodes can be
classified into three categories: reputation-based, credit-pay-
ment, and game theory-based techniques. In reputation-based
techniques, each node observes the behaviors of others and
uses the acquired information for routing [20], [21], [28]. In
credit-payment techniques, eachnode gives a credit toothers,
as a reward for data forwarding [2], [30]. The acquired credit
is then used to send data to others. The game theory-based
techniques assume that all rational nodes can determine their
own optimal strategies to maximize their profit [11], [29]. The
game theory-based techniques want to find the Nash
Equilibrium point [26] to maximize system performance. All
these techniques focused on packet forwarding. In contrast,
this paper focuses onthe problemof selfishreplica allocation.
The work [18] introduced several trust models and trust
management schemes in a MANET that can help mitigate
selfishness in a MANET. Although the work introduces
several schemes for the detection of selfish nodes, the work
also focuses on the selfish behavior from the network
perspective, such as dropping or refusing to forward
packets. Note that traditional detection techniques in a
network domain cannot be directly applied to the selfish
replica allocation problem, since they mainly make a binary
decision: selfish or not, that is, forwarding data or not.
However, we need to consider the partial selfish behaviors
into account in the selfish replica allocation problem, as
illustrated 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), and
dynamic connectivity-based grouping. It has been reported
that DCG provides the highest data accessibility, while SAF
incurs the lowest traffic, of the three techniques. Although
DCG performs best in terms of data accessibility, it causes
the worst network traffic. Moreover, DCG does not consider
selfish nodes in a MANET.
The work [32] proposes data replication techniques that
address both query delay anddata accessibility in a MANET.
The work [32] demonstrates such a trade-off and proposes
techniques to balance it. The work [6] introduces the
cooperative caching-based data access methods, including
CachePath, CacheData, and Hybrid. Differing from all the
above-mentioned replica allocation or caching techniques,
we consider selfish nodes in a MANET.
Fig. 9. Effect of communication range.
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 in
mobile peer-to-peer networks, it assumes that all peers are
trusted and they do not cheat. Therefore, the work focuses
on encouraging peer collaboration because the work needs
not consider node misbehavior. Conversely, we focus on the
misbehavior of nodes. The work [34] introduced noncoo-
perative behaviors in a MANET. The assumption of the
work is that each node in a MANET is greedy and self-
interested, similar to our work. However, the work
addressed a different problem: whether or not the system
will enter an equilibrium state. Furthermore, the system
environment 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 be
directly applied to a MANET, since they did not consider
the constraints of a MANET such as the bandwidth
limitation for the detection of selfish nodes and system
failures due to frequent node disconnections.
6 CONCLUSION
In contrast to the network viewpoint, we have addressed
the problem of selfish nodes from the replica allocation
perspective. We term this problem selfish replica allocation.
Our work was motivated by the fact that a selfish replica
allocation could lead to overall poor data accessibility in a
MANET. We have proposed a selfish node detection
method and novel replica allocation techniques to handle
the selfish replica allocation appropriately. The proposed
strategies are inspired by the real-world observations in
economics in terms of credit risk and in human friendship
management in terms of choosing ones friends completely
at ones own discretion. We applied the notion of credit risk
from economics to detect selfish nodes. Every node in a
MANET calculates credit risk information on other con-
nected nodes individually to measure the degree of
selfishness. Since traditional replica allocation techniques
failed to consider selfish nodes, we also proposed novel
replica allocation techniques. Extensive simulation shows
that the proposed strategies outperform existing represen-
tative cooperative replica allocation techniques in terms of
data accessibility, communication cost, and query delay. We
are currently working on the impact of different mobility
patterns. We plan to identify and handle false alarms in
selfish replica allocation.
ACKNOWLEDGMENTS
This work was supported in part by the Mid-Career
Researcher Program through an NRF grant funded by the
MEST (No. 2009-0077925) and with partial support from a
Korea 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 and
Cost-Efficient Routing Protocol for Mobile Ad Hoc Networks with
Selfish 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. IEEE
Wireless Comm. and Networking, pp. 2137-2142, 2005.
[4] R.F. Baumeister and M.R. Leary, The Need to Belong: Desire for
Interpersonal 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, A
Performance 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 Data
Access 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 of
Distributed 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 for
Improving Data Accessibility, Proc. IEEE INFOCOM, pp. 1568-
1576, 2001.
[13] T. Hara and S.K. Madria, Data Replication for Improving Data
Accessibility 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 for
Data Replication in Mobile Ad Hoc Networks, IEEE Trans. Mobile
Computing, vol. 8, no. 7, pp. 950-967, July 2009.
[15] S.U. Khan and I. Ahmad, A Pure Nash Equilibrium-Based Game
Theoretical 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. Parallel
and 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 and
Distributed Systems, vol. 17, no. 12, pp. 1401-1413, Dec. 2006.
[18] H. Li and M. Singhal, Trust Management in Distributed
Systems, Computer, vol. 40, no. 2, pp. 45-53, Feb. 2007.
[19] M. Li, W.-C. Lee, and A. Sivasubramaniam, Efficient Peer-to-Peer
Information Sharing over Mobile Ad Hoc Networks, Proc. World
Wide 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. and
Networking Conf., pp. 1510-1515, 2003.
[21] S. Marti, T. Giuli, K. Lai, and M. Baker, Mitigating Routing
Misbehavior 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 of
Security Exposures in Mobile Ad Hoc Networks, Proc. European
Wireless Conf., pp. 1-6, 2002.
[24] H. Miranda and L. Rodrigues, Friends and Foes: Preventing
Selfishness in Open Mobile Ad hoc Networks, Proc. IEEE Intl
Conf. Distributed Computing Systems Workshops, pp. 440-445, 2003.
[25] A. Mondal, S.K. Madria, and M. Kitsuregawa, An Economic
Incentive Model for Encouraging Peer Collaboration in Mobile-
P2P Networks with Support for Constraint Queries, Peer-to-Peer
Networking and Applications, vol. 2, no. 3, pp. 230-251, 2009.
[26] M.J. Osborne, An Introduction to Game Theory. Oxford Univ., 2003.
[27] P. Padmanabhan, L. Gruenwald, A. Vallur, and M. Atiquzzaman,
A Survey of Data Replication Techniques for Mobile Ad Hoc
Network 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 Selfish
Nodes in DSR Based Ad-Hoc Networks, Proc. IEEE Global
Telecomm. Conf., pp. 178-182, 2002.
[29] V. Srinivasan, P. Nuggehalli, C. Chiasserini, and R. Rao,
Cooperation in Wireless Ad Hoc Networks, Proc. IEEE
INFOCOM, pp. 808-817, 2003.
[30] W. Wang, X.-Y. Li, and Y. Wang, Truthful Multicast Routing in
Selfish Wireless Networks, Proc. ACM MobiCom, pp. 245-259,
2004.
[31] S.-Y. Wu and Y.-T. Chang, A User-Centered Approach to Active
Replica 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. IEEE
Intl Symp. Reliable Distributed Systems, pp. 289-298, 2004.
[33] Y. Yoo and D.P. Agrawal, Why Does It Pay to be Selfish in a
MANET, 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 Soongsil
University in 2003. He received the MS degree
in computer science from Korea University in
2005. His research interests include mobile
computing, location-based services, XML data-
bases, and data management in mobile ad hoc
networks and sensor networks.
Kyu-Sun Shim received the BS degree in
computer science and engineering from Korea
University in 2009. His research interests in-
clude mobile/pervasive computing systems and
data management in mobile ad hoc networks
and sensor networks.
SangKeun Lee received the BS, MS, and PhD
degrees in computer science and engineering
from Korea University, South Korea, in 1994,
1996, and 1999, respectively. He was a recipient
of the Japan Society for the Promotion of
Science (JSPS) Postdoctoral Fellowship in
2000. Since 2003, he has been an associate
professor in the College of Information and
Communication, 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 in
electrical engineering from the National Taiwan
University, Taipei, and the MS and PhD degrees
in computer science from the University of
Illinois at Urbana-Champaign. He is currently a
member of the Software Tools and Techniques
Group, IBM T.J. Watson Research Center. He is
the program cochair of the 2007 IEEE Joint
Conference on E-Commerce Technology (CEC)
and Enterprise Computing, E-Commerce, and
E-Services (EEE). From 2000 to 2004, he was an associate editor of the
IEEE Transactions on Knowledge and Data Engineering. He was the
general chair of the Third International Workshop on E-Commerce and
Web-Based Information Systems (WECWIS 01). He has served as a
member of the organizing and program committees of several
conferences. 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, database
systems, and distributed computing. He has published extensively and
is the holder of many patents in these areas. He has received various
IBM awards, including an IBM Corporate Environmental Affair Excel-
lence Award, a Research Division Award, and several Invention
Achievement Awards. He is an IBM Master Inventor. He is a fellow of
the 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.

Handling Selfishness in Replica Allocation over Mobile Networks

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Handling Selfishness in Replica Allocation over Mobile Networks

Încărcat de

Drepturi de autor:

Formate disponibile

Handling Selfishness in Replica Allocation

over a Mobile Ad Hoc Network

with a new edge (the new edge is added since we do not

the target node is selected from 1

28: replace the replica requested by `

in its memory space, the replica

will be allocated to the `

): The technique combines DCG with

to demonstrate the effectiveness of our

, since many selfish

(selfishness only) is obtained

than in DCG, since our detection method

detects selfish nodes effectively and the

(selfishness only) is less than

, respectively. We see that, on

are caused by node self-

, while being inferior to

shows the worst performance in all cases, since

), since fewer replica relocations

) technique is vulnerable to network topology

technique, cost reduction is faster

, and the distance between

technique shows the worst performance.

gets worse, while the performance of our

techniques, the number of

considerably, since our techniques

S-ar putea să vă placă și