Winterfeldtstr. 21, 10781 Berlin

jkim@net.t-labs.tu-berlin.de

+49 30 8353 58158

LISP Cache Emulator

The LISP Cache emulator is software that is able to emulate the
tasks of LISP xTRs and that is essentially designed to be fed
with packet-level Internet traffic. Therefore, like a real LISP
router, the emulator needs two data stores, namely the LISP
Database and the LISP Cache.

The LISP Database is a manually configured list of internal network
prefixes (EIDs), while the LISP Cache stores EID-to-RLOC mapping
when there is a request for it and removes it according to the
preconfigured expiration rule.

The emulator uses a local BGP prefixes database fed with the list
of BGP prefixes published by the iPlane Project.
This BGP prefixes database is used to group EID-to-RLOCs mappings
with the granularity of existing BGP prefixes.

Caching Locator/ID mappings: An experimental scalability analysis and its implications

Victim of its own success, the current Internet is facing scalability issues that lead the research community to explore alternative architectures. In particular, the Locator/ID Split paradigm, based on the idea of separating the identity from the location of end-systems, is gaining momentum and seems to be the most promising candidate for the future Internet architecture. A critical component of any Locator/ID Split approach, from a performance and resources consumption perspective, as well as from a security point of view, is the cache. The cache is meant to temporarily store mappings, i.e., the bindings between identifiers and locations, in order to provide routers with the knowledge of where to forward packets.

Taking as reference protocol LISP (Locator/ID Separation Protocol), the most successful proposal currently under discussion at the IETF, this paper presents a thorough analysis of such a component, including the implications of policies to increase the level of security, based on real packet-level traces. Our results prove that even a timeout as short as 60 s provides a high hit ratio and that the impact of using security policies is small. Furthermore, a thorough analysis of the scalability of such a component is provided along with the analysis of which class of applications contributes the major fraction of cache-misses.

A Local Approach to Fast Failure Recovery of LISP Ingress Tunnel Routers

LISP (Locator/ID Separation Protocol) has been proposed as a future Internet architecture in order to solve the scalability issues the current architecture is facing. LISP tunnels packets between border routers, which are the locators of the non-globally routable identifiers associated to end-hosts. In this context, the encapsulating routers, which are called Ingress Tunnel Routers (ITR) and learn dynamically identifier-to-locators mappings needed for the encapsulation, can cause severe and long lasting traffic disruption upon failure. In this paper, thanks to real traffic traces, we first explore the impact of ITR failures on ongoing traffic. Our measurements confirm that the failure of an ITR can have severe impact on traffic. We then propose and evaluate an ITR synchronization mechanism to locally protect ITRs, achieving disruptionless traffic redirection. We finally explore how to minimize the number of ITRs to synchronize in large networks.

A Deep Dive into the LISP Cache and What ISPs Should Know about It

Due to scalability issues that the current Internet is facing, the research community has re-discovered the Locator/ID Split paradigm. As the name suggests, this paradigm is based on the idea of separating the identity from the location of end-systems, in order to increase the scalability of the Internet architecture. One of the most successful proposals, currently under discussion at the IETF, is LISP (Locator/ID Separation Protocol). A critical component of LISP, from a performance and resources consumption perspective, as well as from a security point of view, is the LISP Cache. The LISP Cache is meant to temporarily store mappings, i.e., the bindings between identifiers and locations, in order to provide routers with the knowledge of where to forward packets. This paper presents a thorough analysis of such a component, based on real packet-level traces. Furthermore, the implications of policies to increase the level of security of LISP are also analyzed. Our results prove that even a timeout as short as 60 seconds provides high hit ratio and that the impact of using security policies is small.

A Deep Dive into the LISP Cache and What ISPs Should Know about It
Juhoon Kim, Luigi Iannone, Anja Feldmann, In Proceedings of the 10th IFIP International Conference on Networking. Springer, 267-278, 2011