Transcript Declarative Path Finding in Simulated Multi

Declarative Path Finding
in Simulated Multi-Layer MultiDomain Networks
Li Xu
with help of:
Freek Dijkstra, Arie Taal, Paola Grosso,
Jeroen van der Ham, Cees de Laat
QuickTime™ and a
TIFF(Uncompressed) decompressor
are needed to see thi s picture.
System Network Engineering group
Universiteit van Amsterdam
10-06-2009
Research question
CAN the difficult path finding problem in multilayer multi-domain networks be solved by
using a declarative approach?
QuickTime™ and a
TIFF (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, linkconstrained 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) decompressor
are needed to see this picture.
Example of lightpath allocation
Request 1: {VU-UvA, VU-MN}
QuickTime™ and a
TIFF (LZW) decompressor
are needed to see this picture.
Quick Time™ a nd a
TIFF ( Un compr ess ed ) de co mp res sor
ar e n eed ed to s ee this pic tur e.
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 layerby-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
Network description
Path Finding
Algorithm
Queries
Auto load
Quic kT ime™ and a
T IFF (Uncompress ed) decompress or
are needed to s ee this pi cture.
Prolog reasoning system
Auto load
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: BarabasiAlbert [5]
How to generate MLMD networks
Mapping into NDL
F1
F
E1
C2
A
C1
A1
C
C3
Device C
SwitchMatrix on
Layer0 & Layer1
Layer1
E2
B1
A
A2
B
B2
Device A
with adaptation
between 2 layers
B3
D1
C4
C5
E
D
D3
E
D2
Layer0
Device D
SwitchMatrix on Layer0
Experiments & Results
• Generate variable size of 2-layer multidomain 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 ,9 3 2
9 ,9 3 5
1 9 ,9 5 0
9 9 ,9 8 3
1 9 9 ,9 9 6
10
1 ,8 5 8
3 ,8 6 2
1 9 ,8 5 8
3 9 ,9 8 7
2 0 ,0 1 1
3 9 9 ,8 7 8
50
9 ,2 9 8
1 9 ,3 4 7
9 9 ,3 8 9
1 9 9 ,4 8 8
9 9 9 ,2 9 8
1 ,9 9 9 ,2 9 8
Table1: the number of triplets
in NDL
160
140
135.81
120
T (s)
100
QuickTime™ and a
TIFF (Uncompressed) decompressor
are needed to see this picture.
80
66.33
60
40
26.33
20
MacBook pro:
1.83GHz Intel Core Duo,
2GB DDR2 memory
0.08
0.13
0.25
0.62
1.27
2.57
6.46
13.1
0
50
100
200
500
1000
2000
5000
10000
20000
50000
# of Nodes
Figure1: average time to load NDL
100000
Experiments & Results (3)
5000
4500
4000
3500
T (ms)
3000
2500
2000
1500
1000
500
0
50
100
200
500
1000
2000
5000
10000
20000
50000
# of Nodes
Figure2: average time to find the 1st possible path
100000
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!
QuickT ime™ and a
T IFF (Uncompressed) decompressor
are needed to see t his picture.
Questions?
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').
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
...
Define rules
%-----------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].
...
PF Algorithm