Seminar Topics & Project Ideas On Computer Science Electronics Electrical Mechanical Engineering Civil MBA Medicine Nursing Science Physics Mathematics Chemistry ppt pdf doc presentation downloads and Abstract

Full Version: Cooperative Caching in Wireless P2P Networks: Design, Implementation, and Evaluation
You're currently viewing a stripped down version of our content. View the full version with proper formatting.
Abstract
Some recent studies have shown that cooperative cache can improve the system performance in wireless P2P networkssuch as ad hoc networks and mesh networks. However, all these studies are at a very high level, leaving many design andimplementation issues unanswered. In this paper, we present our design and implementation of cooperative cache in wireless P2Pnetworks, and propose solutions to find the best place to cache the data. We propose a novel asymmetric cooperative cache approach,where the data requests are transmitted to the cache layer on every node, but the data replies are only transmitted to the cache layer atthe intermediate nodes that need to cache the data. This solution not only reduces the overhead of copying data between the userspace and the kernel space, it also allows data pipelines to reduce the end-to-end delay. We also study the effects of different MAClayers, such as 802.11-based ad hoc networks and multi-interface-multichannel-based mesh networks, on the performance ofcooperative cache. Our results show that the asymmetric approach outperforms the symmetric approach in traditional 802.11-basedad hoc networks by removing most of the processing overhead. In mesh networks, the asymmetric approach can significantly reducethe data access delay compared to the symmetric approach due to data pipelines.Index Terms—Wireless networks, P2P networks, cooperative cache.
INTRODUCTION
WIRELESS P2P networks, such as ad hoc network, meshnetworks, and sensor networks, have received considerableattention due to their potential applications incivilian and military environments. For example, in abattlefield, a wireless P2P network may consist of severalcommanding officers and a group of soldiers. Each officerhas a relatively powerful data center, and the soldiers needto access the data centers to get various data such as thedetailed geographic information, enemy information, andnew commands. The neighboring soldiers tend to havesimilar missions and thus share common interests. If onesoldier has accessed a data item from the data center, it isquite possible that nearby soldiers access the same datasome time later. It will save a large amount of batterypower, bandwidth, and time if later accesses to the samedata are served by the nearby soldier who has the datainstead of the far away data center. As another example,people in the same residential area may access the Internetthrough a wireless P2P network, e.g., the Roofnet [3]. After one node downloads a MP3 audio or video file, otherpeople can get the file from this node instead of the faraway Web server.Through these examples, we can see that if nodes areable to collaborate with each other, bandwidth and powercan be saved, and delay can be reduced. Actually,cooperative caching [5], [16], [23], [24], which allows thesharing and coordination of cached data among multiplenodes, has been applied to improve the system performancein wireless P2P networks. However, these techniques [5],[16], [23], [24] are only evaluated by simulations andstudied at a very high level, leaving many design andimplementation issues unanswered.There have been several implementations of wireless adhoc routing protocols. In [22], Royer and Perkins suggestedmodifications to the existing kernel code to implementAODV. By extending ARP, Desilva and Das [7] presentedanother kernel implementation of AODV. Dynamic SourceRouting (DSR) [12] has been implemented by the Monarchproject in FreeBSD. This implementation was entirely inkernel and made extensive modifications in the kernel IPstack. In [2], Barr et al. addressed issues on system-levelsupport for ad hoc routing protocols. In [13], the authorsexplored several system issues regarding the design andimplementation of routing protocols for ad hoc networks.They found that the current operating system was insufficientfor supporting on-demand or reactive routing protocols,and presented a generic API to augment the currentrouting architecture. However, none of them has lookedinto cooperative caching in wireless P2P networks.Although cooperative cache has been implemented bymany researchers [6], [9], these implementations are in theWeb environment, and all these implementations are at thesystem level.


Download full report
http://mcn.cse.psu.edu/paper/jizhao/tpds09.pdf
[attachment=14088]
Cooperative Caching in Wireless P2P Networks: Design, Implementation And Evaluation
Abstract:-

Some recent studies have shown that cooperative cache can improve the system performance in wireless P2P networks such as ad hoc networks and mesh networks. However, all these studies are at a very high level, leaving many design and implementation issues unanswered. In this paper, we present our design and implementation of cooperative cache in wireless P2P networks, and propose solutions to find the best place to cache the data. We propose a novel asymmetric cooperative cache approach, where the data requests are transmitted to the cache layer on every node, but the data replies are only transmitted to the cache layer at the intermediate nodes that need to cache the data. This solution not only reduces the overhead of copying data between the user space and the kernel space, it also allows data pipelines to reduce the end-to-end delay. We also study the effects of different MAC layers, such as 802.11-based ad hoc networks and multi-interface-multichannel-based mesh networks, on the performance of cooperative cache. Our results show that the asymmetric approach outperforms the symmetric approach in traditional 802.11-based ad hoc networks by removing most of the processing overhead. In mesh networks, the asymmetric approach can significantly reduce the data access delay compared to the symmetric approach due to data pipelines.
Existing System:-
Existing cache network although cooperative cache has been implemented by many researchers, these implementations are in the Web environment, and all these implementations are at the system level. As a result, none of them deals with the multiple hop routing problems and cannot address the on-demand nature of the ad hoc routing protocols. To realize the benefit of cooperative cache, intermediate nodes along the routing path need to check every passing-by packet to see if the cached data match the data request. This certainly cannot be satisfied by the existing ad hoc routing protocols.
Proposed System:-
In this project, we present our design and implementation of cooperative cache in wireless P2P networks. Through real implementations, we identify important design issues and propose an asymmetric approach to reduce the overhead of copying data between the user space and the kernel space, and hence to reduce the data processing delay.
The proposed algorithm well considers the caching overhead and adapts the cache node selection strategy to maximize the caching benefit on different MAC layers. Our results show that the asymmetric approach outperforms the symmetric approach in traditional 802.11- based ad hoc networks by removing most of the processing overhead.
Algorithm Used:-
A greedy cache placement algorithm.
Algorithm Details
The proposed algorithm well considers the caching overhead and adapts the cache node selection strategy to maximize the caching benefit on different MAC layers. Our results show that the asymmetric approach outperforms the symmetric approach in traditional 802.11- based ad hoc networks by removing most of the processing overhead. In mesh networks, the asymmetric approach can significantly reduce the data access delay compared to the symmetric approach due to data pipelines.
Modules:-
1. Cooperative Caching Module:
Fig: Caching P2P network.
See Fig Suppose node N1 requests a data item 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 and DSR (Dynamic Source Routing)) 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.
2. Cache and routing module:
There is no de facto routing protocol for wireless P2P networks currently. Implementing cooperative cache at the network layer requires these cache and routing modules to be tightly coupled, and the routing module has to be modified to add caching functionality. However, to integrate cooperative cache with different routing protocols will involve tremendous amount of work
Fig. . Layered design. (a) The request Data flow and (b) the reply Data flow.
There are two options for the layered design. One naïve solution uses cross-layer information, where the application passes data request to the routing layer, which can be used to match the local cached data. However, this solution not only violates the layered design, but also adds significant complexity to the routing protocol which now needs to maintain a local cache table.
3. Asymmetric Approach Module:
Our asymmetric caching approach has three phases
Phase1: Forwarding the request message.
After a request message is generated by the application, it is passed down to the cache layer. To send the request message to the next hop, the cache layer wraps the original request message with a new destination address, which is the next hop to reach the data server (real destination). Here, we assume that the cache layer can access the routing table and find out the next hop to reach the data center. This can be easily accomplished if the routing protocol is based on DSR or AODV. In this way, the packet is received and processed hop by hop by all nodes on the path from the requester to the data server.
Phase 2: Determining the caching nodes.
When a request message reaches the data server (the real data center or the intermediate node that has coached the requested data), the cache manager decides the caching nodes on the forwarding path, which will be presented in . Then, the ids of these caching nodes are added to a list called Cache List, which is encapsulated in the cache layer header.
Phase 3: Forwarding the data reply. Unlike the data
Request, the data reply only needs to be processed by those nodes that need to cache the data. To deliver the data only to those that will cache the data, tunneling techniques are used. The data reply is encapsulated by the cache manager and tunneled only to those nodes appearing in Cache List.
4. Cache routing simulation module:
There are two routing protocol used:
Ad-hoc On-demand Distance Vector (AODV) routing protocol
Dynamic Source Routing (DSR)
The data server needs to measure the benefit of caching a data item on an intermediate node and use it to decide whether to cache the data. After an intermediate node (Ni) caches a data item, node (Ni) can serve later requests using the cached data, instead of forwarding the requests to the data server, saving the communication overhead between node(Ni) and the data center. However, caching data at node (Ni) increases the delay of returning the data to the current requester, because it adds extra processing delay at Ni, and the data reassembly at node (Ni) may affect possible pipelines.
System Requirements:
Hardware Requirements:

PROCESSOR : PENTIUM IV 2.6 GHz
RAM : 512 MB DD RAM
MONITOR : 15” COLOR
HARD DISK : 20 GB
FLOPPY DRIVE : 1.44 MB
CDDRIVE : LG 52X
KEYBOARD : STANDARD 102 KEYS
MOUSE : 3 BUTTONS
Software Requirements:
Front End : Java, JFC (Swing)
Backend : MS-Access (Data Base)
Tools Used : Eclipse 3.3
Operating System : Windows XP/
Cooperative Caching in Wireless P2P Networks: Design, Implementation,
and Evaluation


[attachment=26396]
INTRODUCTION

There have been several implementations of wireless ad
hoc routing protocols. In [22], Royer and Perkins suggested
modifications to the existing kernel code to implement
AODV. By extending ARP, Desilva and Das [7] presented
another kernel implementation of AODV. Dynamic Source
Routing (DSR) [12] has been implemented by the Monarch
project in FreeBSD. This implementation was entirely in
kernel and made extensive modifications in the kernel IP
stack. In [2], Barr et al. addressed issues on system-level
support for ad hoc routing protocols.

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

Fig. 1 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.

System Implementation

Architecture Overview

Fig. 5 shows the architecture of our cooperative cache
middleware, which consists of three parts: Cooperative
Cache Supporting Library (CCSL), Cooperative Cache
Daemon (CCD), and Cooperative Cache Agent (CCA).
CCSL is the core component to provide primitive
operations of the cooperative cache, e.g., checking passingby
packets, recording data access history, and cache read/
write/replacement primitives. A data cache buffer is
maintained at every node to store the cached data items.
There is an interface between CCSL and the routing daemon,
from which CCSL obtains the routing distance to a certain
node. All these primitive cache operations are enclosed as
CCSL API to provide a uniform interface to the upper layer.
CCD is the component that implements different cooperative
cache mechanisms, namely, CacheData, CachePath, and
HybirdCache. There is one cache daemon for each cooperative
cache scheme. It extends the basic CCSL API to
accomplish the characteristic of each scheme.

CONCLUSIONS

In this paper,wepresented our design and implementation of
cooperative cache in wireless P2P networks, and proposed
solutions to find the best place to cache the data. In our
asymmetric approach, data request packets are transmitted to
the cache layeronevery node; however, the data reply packets
are only transmitted to the cache layer on the intermediate
nodes which need to cache the data. This solution not only
reduces the overhead of copying data between the user space
and the kernel space, but also allows data pipeline to reduce
the end-to-end delay. We have developed a prototype to
demonstrate the advantage of the asymmetric approach.
Since our prototype is at a small scale, we evaluate our design
foralarge-scalenetworkthroughsimulations.