09-10-2012, 04:36 PM
Cooperative Caching in Wireless P2P Networks
Cooperative Caching In Wireless P2P NetWorks Design,Implementation And Evaluation.pdf (Size: 2.94 MB / Downloads: 40)
INTRODUCTION
WIRELESS P2P networks, such as ad hoc network, mesh
networks, and sensor networks, have received considerable
attention due to their potential applications in
civilian and military environments. For example, in a
battlefield, a wireless P2P network may consist of several
commanding officers and a group of soldiers. Each officer
has a relatively powerful data center, and the soldiers need
to access the data centers to get various data such as the
detailed geographic information, enemy information, and
new commands. The neighboring soldiers tend to have
similar missions and thus share common interests. If one
soldier has accessed a data item from the data center, it is
quite possible that nearby soldiers access the same data
some time later. It will save a large amount of battery
power, bandwidth, and time if later accesses to the same
data are served by the nearby soldier who has the data
instead of the far away data center. As another example,
people in the same residential area may access the Internet
through a wireless P2P network, e.g., the Roofnet [3]. After
one node downloads a MP3 audio or video file, other
people can get the file from this node instead of the far
away Web server.
Through these examples, we can see that if nodes are
able to collaborate with each other, bandwidth and power
can be saved, and delay can be reduced. Actually,
cooperative caching [5], [16], [23], [24], which allows the
sharing and coordination of cached data among multiple
nodes, has been applied to improve the system performance
in wireless P2P networks. However, these techniques [5],
[16], [23], [24] are only evaluated by simulations and
studied at a very high level, leaving many design and
implementation issues unanswered.
DESIGN AND IMPLEMENTATION OF COOPERATIVE CACHING
In this section, we first present the basic ideas of the three
cooperative caching schemes proposed in [24]: CachePath,
CacheData, and HybridCache. Then, we discuss some
design issues and present our design and implementation
of cooperative cache in wireless P2P networks.
Cooperative Caching Schemes
illustrates the CachePath concept. Suppose node N1
requests a data item di from N0. When N3 forwards di to
N1;N3 knows that N1 has a copy of the data. Later, if N2
requests di;N3 knows that the data source N0 is three hops
away whereas N1 is only one hop away. Thus, N3 forwards
the request to N1 instead of N4. Many routing algorithms
(such as AODV [20] and DSR [12]) provide the hop count
information between the source and destination. Caching
the data path for each data item reduces bandwidth and
power consumption because nodes can obtain the data
using fewer hops. However, mapping data items and
caching nodes increase routing overhead, and the following
techniques are used to improve CachePath’s performance.
In CachePath, a node need not record the path information
of all passing data. Rather, it only records the data path
when it is closer to the caching node than the data source.
For example, when N0 forwards di to the destination node
N1 along the path N5 N4 N3;N4 and N5 won’t cache di
path information because they are closer to the data source
than the caching node N1. In general, a node caches the data
path only when the caching node is very close. The
closeness can be defined as a function of the node’s distance
to the data source, its distance to the caching node, route
stability, and the data update rate. Intuitively, if the network
is relatively stable, the data update rate is low, and its
distance to the caching node is much shorter than its
distance to the data source, then the routing node should
cache the data path.
A Map Quest Application
We wrote a simple map quest application to demo our
cooperative cache functions. This map quest application can
be divided into two parts: map center and map client. All
maps are originally saved in the map center. Once the map
center receives a map query request, the requested map is
retrieved and sent back to the requester.
Fig. 8a shows the graphic user interface (GUI) of a map
client. After the user clicks the map request, the request
message is sent to a specially designed Cooperative
Caching Java Agent (CCJA) at this node. As a protocol
translator, the CCJA translates the received map request
message to the format used in Cooperative Cache
Daemon (CCD). If the requested map is returned back
to the CCD of the requesting node, the CCD forwards the
received reply message together with the replied map to
the corresponding CCJA. Then, the CCJA constructs a
map reply message and sends it to the map client. Fig. 8b
shows a map displayed by a client.