A prudent amount of caching inside the network can lead to large benefits --- both in terms of access latencies and bandwidth usage. The gains are particularly high for short request-response applications like the Web. Traditional approaches towards network caching have been to place large caches at specific points in the network --- with little or no coordination between the caches. In our work, we define caching as an "active" network function, and show that much smaller caches, distributed over the network without specific regard to location, when combined with active mechanisms to guide the caching policies, can outperform location based schemes.

We compare our active networking caching scheme to two (location dependent) caching schemes ---- one that caches at transit (provider) nodes, and one that caches at stub (subscriber) nodes connected to transit nodes. Additionally, we consider the case in which caches are located in every node (like active network caches), but without the active mechanisms enabled to provide inter-cache coordination.

Effective use of a large number of relatively small caches is a non-trivial problem. In traditional (processor) cache situations, the cache replacement policy (along with cache size) determines the effectiveness of the cache. The problem of item selection at a cache is not present --- i.e. the cache does not have to make a decision about whether to cache or not to cache a particular item. However, in a distributed caching situation, we have to be careful that each of the caches do not end up replicating each other -- this would lead to thrashing and poor cache performance. On the other hand, if an item is cached too sparsely, then access latencies for that item would not decrease, and again, the cache performance would be sub par. In order to solve these problems, our mechanisms introduce a cache ``radius'' in number of hops. An item is cached only once within a given cache radius. Further, we use a modulus function to obtain even distribution of items within a path of given radius.

Network caches cache "relatively" large items (compared to the amount of space required to store the location of such an item within the network). Thus, an active node can tradeoff some of its (cache) memory to store nearby locations of items. Active nodes can keep a periodically updated list of items cached at neighbors. The cache check at any node includes checking the in-node cache, and the list of caches of neighbors. If a hit is detected at a neighboring cache -- the datagram is forwarded to the neighbor (with the same source and destination addresses). If the information about the neighbor's cache were incorrect -- the datagram is forwarded to the destination (through the neighbor's shortest path). Otherwise a cache hit is recorded at the neighbor. We can generalize this "look-around" cache check algorithm to checking nodes within any given radius. However, we constrain the look-around to within a given domain -- i.e. neighboring caches are checked if and only if the neighbor is a member of the same stub or transit domain. Note that even with the look-around scheme, the caching algorithm is stateless and backward compatible -- i.e. a mix of active and non-active nodes may exist in the network, and the active cache functions may fail at any time.

The wide area caching behavior is simulated using a network simulator --- AN-Sim. AN-Sim simulates an active network in which the network defines a finite set of functions that can be computed at each active node. AN-Sim uses %the GT-ITM topology models a locally developed graph generation package (GT-ITM) to model internetwork topology.