Declarative Path Finding in Simulated Multi-Layer Multi-

Domain Networks

Li Xuwith help of:

Freek Dijkstra, Arie Taal, Paola Grosso,

Jeroen van der Ham, Cees de Laat

System Network Engineering group

Universiteit van Amsterdam

10-06-2009QuickTime™ and aTIFF (Uncompressed) decompressorare needed to see this picture.

Research question

CAN the difficult path finding problem in multi-layer multi-domain networks be solved by using a declarative approach?

QuickTime™ and aTIFF (Uncompressed) decompressor

are needed to see this picture.

GLIF (Global Lambda Integrated Facility) 2008

Introduction

• Domain: a group of computers and devices on a network that are administered as a unit with common properties.

• Multi-layer networks: Computer networks where the configuration of the network can be changed dynamically at multiple layers.

Introduction (2)

• Multi-layer network description:– Network Description Language

– Based on ITU-T recommendations G.805 function elements and the label concept in GMPLS

– RDF/XML syntax– Technology

independent model

See Ref: [1, 2], URL: http://www.science.uva.nl/research/sne/ndl/

Path Finding (PF) in Multi-layer networks

• Differs from single-layer networks, link-constrained algorithms (e.g. Ford-Fulkerson for BGP, Dijkstra for OSPF) can not solve the problem.

• A shortest path in multi-layer networks may be looped or not be a shortest one in itself. [3]

Example of PF in multi-layer networks

QuickTime™ and aTIFF (LZW) decompressor

are needed to see this picture.

A new approach is needed!

QuickTime™ and aTIFF (LZW) decompressor

are needed to see this picture.

Example of lightpath allocation

Request 1: {VU-UvA, VU-MN}

Request 2: {VU-MN, VU-UvA}

The same result is required, regardless the order of request?StarPlane network, URL: http://www.starplane.org/

QuickTime™ and aTIFF (Uncompressed) decompressorare needed to see this picture.

Declarative Approach

• Background– Declarative programming:

a programming paradigm that expresses the logic of a computation without describing its control flow.

– Logic programming• Constraint programming (e.g. Prolog)• Dataflow programming (e.g. SAL, LabVIEW)• Domain specific languages (e.g. regex, CSS)

– Prolog: The program logic is expressed in terms of relations (rules), and execution is triggered by running queries over these relations.

Declarative Approach (2)

• Why (swi-)Prolog [4]?– NDL/RDF as a representation of multi-layer networks, just

like storing network information in a database.– ‘Query-like language’ explores the database in a declarative

syntax.– Libraries for RDF management and semantic manipulation.

They can load a RDF database stored in the triplet format:

Subject - predicate - Object

– Logical constrains in NDL can be implemented naturally in Prolog.

Declarative Approach (3)

• Reason all alternatives

• Capable of handling complex queries

• Less complexity for development and more flexibility for various of queries

e.g.

Examples

Sample queries

NDL statementsare transformed to Prolog rules

Declarative PF Algorithm

• Implement both hop-by-hop and layer-by-layer algorithms in Prolog

• hop-by-hop vs. layer-by-layer

• The result of the algorithms is a list of cross connects that need to be used to create the requested path (if exists).

• Handle multiple/complex path requests

Workflow

QuickTime™ and aTIFF (Uncompressed) decompressor

are needed to see this picture.

Prolog reasoning system

Auto load Auto load

Path FindingAlgorithm

MLMDNetwork description

Queries

Results!

?

Multi-layer Multi-domain (MLMD) Generator

• Why we need a MLMD generator?– Few real-world scenarios– Scalable simulation platform for experiments

• Goal: – generate graphs that simulate real-life multi-layer networks with

multiple technologies – transform them to dedicated network description model (NDL)

for both graphical network behavior analysis and MLMD path finding study.

• Tools we choose:– Pynt toolkit + Python Networkx + JUNG

• Original graph generation algorithm: Barabasi-Albert [5]

How to generate MLMD networks

Mapping into NDL

AD

EB

Layer0

B1

B2

B3

C4 C5

D1

D2

D3

E2

A2

AC

EF

Layer1

C1

C2

C3

E1F1

A1

Device Awith adaptationbetween 2 layers

Device DSwitchMatrix on Layer0

Device CSwitchMatrix on Layer0 & Layer1

Experiments & Results

• Generate variable size of 2-layer multi-domain networks, range from (5 nodes/layer/domain x 5 domains) to (1000 nodes/layer/domain x 50 domains)

• Randomly select 100 pairs of src/dst devices and execute the PF algorithm

• Evaluate: average time of loading NDL and find a path.

Experiments & Results (2)

MacBook pro: 1.83GHz Intel Core Duo, 2GB DDR2 memory

Table1: the number of triplets in NDL

10 20 100 200 1000 2000

5 928 1,932 9,935 19,950 99,983 199,996

10 1,858 3,862 19,858 39,987 20,011 399,878

50 9,298 19,347 99,389 199,488 999,298 1,999,298

#Nodes#Domains

26.33

6.462.571.270.620.250.08 0.13

135.81

66.33

13.1

0

20

40

60

80

100

120

140

160

50 100 200 500 1000 2000 5000 10000 20000 50000 100000

# of Nodes

T (s)

Figure1: average time to load NDL

QuickTime™ and aTIFF (Uncompressed) decompressorare needed to see this picture.

Experiments & Results (3)

0

500

1000

1500

2000

2500

3000

3500

4000

4500

5000

50 100 200 500 1000 2000 5000 10000 20000 50000 100000

# of Nodes

T (ms)

Figure2: average time to find the 1st possible path

Future work

• Introduce “labels” in PF • Compare the efficiency and scalability with

other algorithms (e.g. Imperative Python) • Dynamically load/off-load RDF database for

local/global PF• Reasoning about graphs• Declarative lightpath allocation in Grid

– Complex queries – Sequence of requests– Optimized network resource leftover

Conclusions

• Path finding in multi-layer networks is a complex problem;

• Propose a declarative solution for MLMD path finding using semantic network descriptions (NDL) and a logical reasoning system (Prolog);

• MLMD graph generator is used to generate simulated multi-layer network scenarios.

References[1]: Freek Dijkstra, Bert Andree, Karst Koyman, Jeroen van der Ham and Cees de

Laat. A Multi-Layer Network Model Based on ITU-T G.805 Computer Networks, Vol. 52, Issue 10, pp. 1927-1937, July 2008

[2]: Jeroen van der Ham, Paola Grosso, Ronald van der Pol, Andree Toonk and Cees de Laat. Using the Network Description Language in Optical Networks. In: Tenth IFIP/IEEE Symposium on Integrated Network Management, May 2007

[3]: Freek Dijkstra, Jeroen van der Ham, Paola Grosso, Cees de Laat, A Path Finding Implementation for Multi-layer Networks, Future Generation Computer Systems, Vol. 25, Issue 2, pp. 142-146, February 2009

[4]: J. Wielemaker, An overview of the SWI-Prolog programming environment,in Proceedings of the 13th International Workshop on Logic Programming Environments, F. Mesnard and A. Serebenik, Eds. Heverlee, Belgium: Katholieke Universiteit Leuven, december 2003, pp. 1-16, cW 371.

[5]: Barabasi, A. and Albert, R., Emergence of scaling in random networks, Science 286, 509-512, 1999

[6]: Fernando Kuipers, Freek Dijkstra, Path Selection in Multi-Layer Networks, Elsevier Computer Communications, Vol. 32, (Issue and publication date yet unknown), 2009, pp. 78-85

Thank you for your attention!

Questions?Contact: l.xu_at_uva.nlor via google->images->people :-)

QuickTime™ and aTIFF (Uncompressed) decompressorare needed to see this picture.

Below not used

Sample Codedevice(Dev):- rdf_db:rdf(Dev, rdf:'type', ndl:'Device').

interface(Intf):- rdf_db:rdf(Intf, rdf:'type', ndl:'Interface').

layer(Layer):- rdf_db:rdf(Layer, rdf:'type', ndl:'layer').

...

hasinterface(Dev, Intf):-rdf_db:rdf(Dev, ndl:'hasInterface', Intf).

...

%------ define layer ------%

ethlayer(X):-

rdf_db:rdf(X, ndl:'layer', ethernet:'EthernetNetworkElement').

%------ define different types of connection ------%canswitchto(X, Y):-

hasinterface(S, X),switchmatrix(S),hasinterface(S, Y),X \= Y. % X different from Y

...

%-----------path finding----------------------%simple_path(X, Y, Visited, Path ):-% ---- direct link ---- %

connection(X, Y), not( member(Y, Visited)),Path = [Y];

% ---- cross the SwitchMatrix ---- %% -------- direct switchto the dst---- % canswitchto(X, Y), not( member(Y, Visited)), Path = [Y] ;...

% ---- direct link followed by another path --- %simple_path(X, Y, Visited, Path ):-

connection(X, Z),not( member(Z, Visited) ),simple_path(Z, Y, [Z|Visited],

NPath ),%format('---1---'),Path = [Z | NPath].

...

Define rules PF Algorithm