Get documents about "Declarative Path Finding in Simulated Multi-Layer Multi-Domain
Document Sample
Declarative Path Finding
in Simulated Multi-Layer Multi-
Domain Networks
Li Xu
with help of:
Freek Dijkstra, Arie Taal, Paola Grosso,
Jeroen van der Ham, Cees de Laat
System Network Engineering group
Universiteit van Amsterdam
QuickT ime™ and a
T IF F (Uncom pressed) decompressor
are needed to see t his pict ure.
10-06-2009
Research question
CAN the difficult path finding problem in multi-
layer multi-domain networks be solved by
using a declarative approach?
QuickTime™ an d a
TIFF (Uncompressed) decompressor
are need ed 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 a
TIFF (LZW) decomp resso r
are need ed to see this picture.
Example of lightpath allocation
Request 1: {VU-UvA, VU-MN}
QuickTime™ and aQu i ckTi m e™ a nd a
TIFF (LZW) decompressor
TIFF (Un co mp res se d) de c omp res so r
a re ne ed ed to se e th is pi c tu re.
are neede d to see this picture.
Request 2: {VU-MN, VU-UvA}
StarPlane network, URL: http://www.starplane.org/
?
The same result is required, regardless the order of request
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
e.g.
• Less complexity for development and
more flexibility for various of queries
Examples
NDL statements
are transformed
to Prolog rules
Sample queries
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
?
MLMD Path Finding
Network description Algorithm
Queries
Auto load Auto load
Quic kTime™ and a
TIFF (Uncompress ed) decompres sor
Results!
are needed to see this picture.
Prolog reasoning system
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
F1 F
C2
E1 E
A1 C1 C C3
Device C
A SwitchMatrix on
Layer0 & Layer1 Layer1
E2 E
B1 B3 D3
A2
B D1 D
C4 C5
A B2 D2
Layer0
Device A
Device D
with adaptation
SwitchMatrix on Layer0
between 2 layers
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)
#Nodes
#Domains 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
Table1: the number of triplets 160
in NDL
140
1 3 5 .8 1
120
100
T (s)
80
6 6 .3 3
QuickTime™ and a 60
TIF F (U ncompressed) decompressor
are needed to see this picture.
40
2 6 .3 3
20
6 .4 6
0 .1 3 0 .2 5 0 .6 2 1 .2 7 2 .5 7 1 3 .1
MacBook pro: 0
0 .0 8
1.83GHz Intel Core Duo, 50 100 200 500 1000 2000 5000 1 0 0 00 2 0 0 00 5 0 0 00 1 0 0 00 0
# of Nodes
2GB DDR2 memory
Figure1: average time to load NDL
Experiments & Results (3)
5000
4500
4000
3500
3000
T (ms)
2500
2000
1500
1000
500
0
50 100 200 500 1000 2000 5000 10000 20000 50000 100000
# of Nodes
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!
QuickTime™ and a
Questions?
TIF F (Uncompressed) decompressor
are needed to see this picture.
Contact: l.xu_at_uva.nl
or via google->images->people :-)
Below not used
Sample Code
device(Dev):- rdf_db:rdf(Dev, rdf:'type', ndl:'Device'). %-----------path finding----------------------%
simple_path(X, Y, Visited, Path ):-
interface(Intf):- rdf_db:rdf(Intf, rdf:'type', ndl:'Interface'). % ---- direct link ---- %
connection(X, Y),
layer(Layer):- rdf_db:rdf(Layer, rdf:'type', ndl:'layer'). not( member(Y, Visited)),
Path = [Y]
... ;
% ---- cross the SwitchMatrix ---- %
hasinterface(Dev, Intf):- % -------- direct switchto the dst---- %
rdf_db:rdf(Dev, ndl:'hasInterface', Intf). canswitchto(X, Y),
not( member(Y, Visited)),
... Path = [Y]
%------ define layer ------% ;
...
ethlayer(X):-
rdf_db:rdf(X, ndl:'layer', ethernet:'EthernetNetworkElement'). % ---- direct link followed by another path --- %
simple_path(X, Y, Visited, Path ):-
%------ define different types of connection ------% connection(X, Z),
canswitchto(X, Y):- not( member(Z, Visited) ),
hasinterface(S, X), simple_path(Z, Y, [Z|Visited],
switchmatrix(S), NPath ),
hasinterface(S, Y), %format('---1---'),
X \= Y. % X different from Y Path = [Z | NPath].
... ...
Define rules PF Algorithm
