Calcul du plus court chemin

Dans la section 5.4.2, nous avons décrit un algorithme qui transforme un réseau multicouche en automate à pile. L’étape suivante consiste à calculer un chemin qui minimise soit le nombre de liens, soit le nombre d’encapsulations. La méthode de calcul qui minimise le nombre de liens utilise directement l’automate à pile en sortie de l’algorithme 3, comme détaillé en section 5.4.3.1. Cependant, si nous voulons minimiser le nombre d’encapsulations, l’automate à pile doit être transformé dans le but de court-circuiter les séquences de transitions passives (i.e., sans empilement ni dépilement), comme détaillé dans la section 5.4.3.2. L’automate à pile original ou transformé (selon la fonction objectif choisie) est ensuite converti en grammaire à contexte libre. Le mot le plus court que génère cette grammaire correspond à la traceT_C du chemin le plus court (en nombre de liens ou en nombre d’encapsulations). Finalement, ayant la trace du chemin le plus court, il est aisé de retrouver le chemin lui-même, comme détaillé en section 5.4.5.

5.4.3.1 Minimiser le nombre de liens

Le nombre de symboles (ou lettres) d’un mot accepté par l’automateAR est égal au nombre de liens dans le chemin faisable qui lui correspond (chaque symbole est un protocole utilisé sur un lien). L’étape de transformation de l’automate en section 5.4.3.2 doit être ignorée. L’automateAR doit être directement converti en grammaire à contexte libre. Ensuite, le mot le plus court est généré par cette grammaire comme décrit en section 5.4.4.2. Le chemin faisable correspondant est calculé par l’algorithme 8 en page 93, comme détaillé en section 5.4.5.

5.4.3.2 Minimiser le nombre d’encapsulations

Pour ne compter que les encapsulations et désencapsulations dans un chemin faisable C, il ne faut compter que les empilements et dépilements dans la séquence de transitions qui accepte sa trace TC. L’automate A_R doit être transformé en automate A⁰_R dans lequel toutes les séquences de transitions passives sont court-circuitées. Dans ce cas, la longueur du mot le plus court accepté par A⁰_R sera égale au nombre d’encapsulations et désencapsulations nécessaires pour l’accepter, plus une constante fixée.

Soit Qa (a ∈ A) l’ensemble des états de l’automate tels que Qa = {Vx ∈ Q|x = a}, et soit A^a_R

le sous-automate induit par Qa. Par analogie avec un sous-graphe, un sous-automate induit est un multigraphe avec des arcs marqués (qui sont en fait des transitions) tel que l’ensemble des sommets est

Qa et l’ensemble des arcs est l’ensemble des transitions entre les éléments deQa. Comme il n’y a que des transitions passives entre les éléments deQ_a, toutes les séquences de transitions dans un sous-automate sont passives37. SoitP(U_x,V_x)la longueur du plus court chemin38 entreU_x etV_x. Cette longueur peut-être calculée entre chaque paire d’éléments deQ_a grâce à l’algorithme de Floyd-Warshall [44, 114]. Soit

Succ(Vx)L’ensemble des états successeurs deVx dans l’automate originalA_R, i.e.,Succ(Vx) ={Wy ∈ Q|∃(Vx,hx,α,βi,Wy)∈δ}.

L’algorithme 4 prendA_R en entrée et calcule l’automate transforméA⁰_R = (Q0,Σ⁰,Γ⁰,δ⁰,SA,z0,{DA}). L’automate A⁰_R est initialisé avec les valeurs de A_R. Ensuite, l’algorithme 4 calcule le sous-automate

Ax

R pour toute lettre de l’alphabet x∈ A(étape (1)) ainsi que la distanceP(Ux,Vx)pour chaque paire d’états (Ux,Vx) dans le sous-automate (étape (2)). Chaque chemin entre une paire d’états de A^x_R est une séquence de transitions passives car le sous-automate ne contient que des transitions passives (par construction). Si un tel chemin existe (étape (3.1)), l’algorithme crée une nouvelle transition dansδ⁰. Cette nouvelle transition ira de l’étatUx vers chaque état dansSucc(Vx)(étapes(3.1.2)et (2.1.3)). Les transitions ajoutées sont les mêmes que celles qui relient Vx à ces successeurs Wy ∈ Succ(Vx), mais

37. Par abus de langage, nous appelleronsséquences de transitions passives une séquence de transitions où il n’y a ni empilement ni dépilement.

avec une lettre en lecture indexée par le nombre de transitions passives entreUx et Vx (c’est-à-dire la longueurP(Ux,Vx)) plus1. Ces nouvelles transitions indiquent qu’il y avait dans l’automate originalAR

une séquence de transitions qui correspond à la séquence de protocolesxx . . . xde longueurP(U_x,V_x) + 1. Le symbole indexé est ajouté à l’alphabetΣ⁰ du nouvel automate (étape(3.1.1)).

Algorithme 4Transformation de l’automateA_R enA⁰_R

Entrée : L’automate à pileA_R= (Q,Σ,Γ,δ,SA,z0,{DA})

Sortie : L’automate transforméA⁰_R= (Q0,Σ⁰,Γ⁰,δ⁰,SA,z0,{DA})

Q0← Q,Σ⁰←Σ,Γ⁰ ←Γ,δ⁰←δ

Pour chaquex∈ A

(1) CalculerA^x_R

(2) Calculer la longueurP(Ux,Vx)entre chaque paire d’étatsUxet Vx dansA^x_R

(3) Pour chaqueUx∈ Qx et chaqueVx∈ Qxfaire

(3.1) SiP(U_x,V_x)<∞ /* Il y a un chemin entreU_xet V_x */ (3.1.1) Ajouter le symbolex_P(Ux,Vx)+1et x_P(Ux,Vx)+1 àΣ

(3.1.2) Pour chaqueW_y ∈Succ(V_x)\{U_x}et chaque(V_x,hx,α,βi,W_y)∈δ

Ajouter la transition(U_x,hx_P(Ux,Vx)+1,α,βi,W_y)àδ⁰

(3.1.3) Pour chaqueW_y ∈Succ(V_x)\{U_x}et chaque(V_x,hx,α,βi,W_y)∈δ

Ajouter la transition(Ux,hx_P(Ux,Vx)+1,α,βi,Wy)toδ⁰

Complexité de l’algorithme 4. Le calcul du sous-automate (étape(1)) se fait enO(|δ|+|Q|), car il suffit de parcourir l’ensemble des nœuds et des transitions de l’automate et de ne garder que les états indexés par la lettre xet les transitions entre ces états. Calculer le chemin le plus court entre chaque paire de nœuds se fait grâce à l’algorithme de Floyd-Warshall enO(|Qx|3). Si x=y, il a au maximum

|A| −1transitions entre V_xet W_y dans Q(des transitions de la forme(U_x,hx,α,αi,W_x)pour toutes les valeurs possibles deα, exceptéx, puisque la construction de l’automate interdit l’encapsulation d’un pro-tocolexdans lui-même car l’architecture Pseudo-Wire ne le permet pas – il est donc impossible d’avoir

x comme protocole courant et en même temps comme sommet de pile). Si x 6= y, il y a au plus |A|

transitions entre V_x et W_y dansQ (le dépilement(V_x,hx,y,∅i,W_y)et les empilements(V_x,hx,α,xαi,W_y)

pour toutes les valeurs deα∈Γ, exceptéx). Et comme|Succ(Vx)|<|Q|, la complexité des étapes(3.1.2)

et(3.1.3)est bornée parO(|Q| × |A|). Cependant un état ne peut appartenir qu’à un seul sous-automate, la complexité de l’algorithme 4 est bornée par O P

x∈A

|δ|+|Q|+|Qx|3+ (|Qx|2× |Q| × |A|) . De plus ∀x ∈ A,|Qx| ≤ |V|(voir l’algorithme 3 pour la construction de l’ensemble d’états Q). En consé-quence, la complexité de l’algorithme 4 est enO max |A| ×(|δ|+|Q|),|A| × |V|3,|A|2× |V|2× |Q|

, ce qui correspond à O max(|A|4× |E|,|A|3× |V|3)

dans le modèle de réseau multicouche. Le nombre de transitions dansδ⁰ est borné par|δ|+O P

x∈A(|Qx|2× |Q| × |A|), ce qui correspond àO(|A|3× |V|3)

dans le modèle de réseau multicouche.

Exemple. L’algorithme 4 transforme l’automate illustré par la figure 5.6 en l’automate illustré par la figure 5.7. Par exemple, en considérant le protocoleb, l’algorithme calcule le sous-automate induit par les étatsVb,Wb et Kb. La longueurP(Vb,Wb) = 1 est ensuite calculée. Pour court-circuiter la séquence de transitions(V_b,hb,a,ai,W_b) (W_b,hb,a,∅i,D_a), la transition(V_b,hb₂,a,∅i,D_a)est créée et ajoutée à l’au-tomate transformé.

Soit L(A_R) le langage (i.e., l’ensemble de mots) accepté par A_R, et soit L(A⁰_R)le langage accepté parA⁰_R. Enfin, soitf : Σ⁰→Σ^∗ la fonction définie par :

– Si xi=ai∈ A0 alorsf(xi) =aa . . . aa | {z } ifois – Si x_i=a_i∈ A0 alorsf(x_i) =aa . . . aa | {z } ifois

Figure^{5.7 – L’automate à pile transformé correspondant à l’automate sur la figure 5.6.}

Puis, par extension du domaine def à (Σ⁰)^∗:

f : (Σ⁰)^∗→Σ^∗

w⁰=x¹_ix²_j. . . xⁿ_k →f(w⁰) =f(x¹_i)f(x²_j). . . f(xⁿ_k)

Par souci de simplicité, nous ne ferons pas de distinction entrexetx₁ pour toutx∈ A. Nous noterons

f(L(A0

R)) le langage (ou l’ensemble des mots) accepté par A0

R transformé par f (i.e. f(L(A0 R)) =

{f(w⁰)tel que w⁰∈L(A⁰_R)}).

Il est évident quef n’est pas une bijection puisquef(x_ix_j) =f(x_i+j). Pour opérer la transformation entreL(A_R)etL(A⁰_R), Nous définissonsg: Σ^∗→(Σ⁰)^∗ telle que :

– Pour chaque w=xx . . . x | {z } ifois yy . . . y | {z } jfois . . . zz . . . z | {z } k fois ∈Σ^∗,g(w) =xiyj. . . zk.

En d’autres termes :w⁰ =g(w)est le mot le plus court dans(Σ⁰)^∗tel que f(w⁰) =w.

Les lemmes et les propositions suivantes montrent que le langage accepté par l’automate transformé

A⁰_R est «équivalent» au langage accepté par l’automate originalAR. Ici,équivalent signifie que chaque mot accepté parA0

Rpeut être associé à un mot accepté parA_R, et ceci via la fonctionf. De plus, l’auto-mate transformé a une nouvelle propriété :il y a une relation linéaire entre la longueur d’un mot accepté et le nombre minimum d’encapsulations et de désencapsulations nécessaires pour l’accepter.Cette propriété permet de trouver le mot nécessitant le nombre minimum d’encapsulations et de désencapsulations accepté par l’automate originalA_R. Cela peut-être fait simplement en calculant le mot le plus court accepté par l’automate transforméA⁰_R.

Lemme 1. Le langage f(L(A⁰_R)) accepté par A⁰_R puis transformé par f, est le même que le langage

L(A_R)accepté par A_R.

Démonstration. Nous démontrons cette égalité par double inclusion :

1. L(AR)⊆ f(L(A⁰_R)) :∀w ∈L(AR),f(w) = w (nous rappelons que x= x1). Donc f(L(AR)) =

L(AR)(1). D’un autre côté, la construction deA⁰_R par l’algorithme 4 ne supprime aucun symbole de l’alphabet, aucune transition, aucun état (que cet état soit final ou non) deA_R. DoncL(A_R)⊆

L(A0 R). Et doncf(L(A_R))⊆f(L(A0 R))(2) . De (1) et (2) Nous déduisonsL(A_R)⊆f(L(A⁰_R)). 2. L(A_R)⊇f(L(A⁰_R)) :Soitw⁰ =x1 ix2 j. . . xn

l un mot dans L(A⁰_R) et soitt⁰₁t⁰₂. . . t⁰_n+1 une séquence de transitions acceptant w⁰. Pour chaque transition t⁰_m = (U_xm−1,hx^m_k⁻¹,α,βi,Wxm)(1< m < n) de cette séquence, telle que t⁰_m∈δ⁰\δ, il y a une séquence dek−1 transitions passives dans A_R

(puisque la construction det⁰_mdansA⁰_R nécessite l’existence d’une telle séquence dansA_R). Cette séquence débute par l’état U_xm−1 et est suivie par la transition (V_xm−1,hx^m−1,α,βi,Wxm). Donc, cette séquence dansARcorrespond àf(x^m_k⁻¹). Et pour chaquet⁰_mdansA⁰_R, ou bient⁰_m∈δet donc

t⁰_mcorrespond àx^m+1_k (sik= 1), ou bient⁰_m∈δ⁰\δet donc il y a une séquence de transitions dans

AR qui correspond àf(x^m+1_k )(sik >1). Et comme, par définition,f(w⁰) =f(x¹_i)f(x²_j). . . f(xⁿ_l),

f(w0)∈L(A_R). Ainsif(L(A0

R))⊆L(A_R).

Soitw0 le mot le plus court accepté parA0

R. Soit N b^A0R

push(w0)le nombre minimum d’empilements dans une séquence de transitions acceptantw⁰dansA⁰_R. Et soitN b^A

0 R

pop(w⁰)le nombre minimum de dépilements dans une séquence de transitions acceptantw⁰ dansA⁰_R.

Lemme 2. La longueur de la plus courte séquence de transitions acceptant w⁰ dans A⁰_R est égale à

1 +N b^A 0 R push(w⁰) +N b^A 0 R pop(w⁰). De plus,N b^A 0 R pop(w⁰) =N b^A 0 R push(w⁰) + 1.

Démonstration. Tout d’abord, nous prouvons que w⁰ ne peut pas être de la forme. . . x^m_i x^m+1_j . . . avec

x^m=x^m+1. SoitUxm l’état dans lequelA⁰_Rest avant de lire le symbolex^m_i . SoitVxm+1 l’état dans lequel est A0

R après la lecture du symbolexm

i et avant la lecture du symbolex^m+1_j . Enfin soit W_y l’état dans lequel estA⁰_R après la lecture du symbolex^m+1_j .

Si xm = xm+1, alors, par construction, il y a une transition (U_xm,hxm

i+j,α,βi,W_y) (où α,β est un dépilement dey ou un empilement dex^mifx^m6=y). Alors, si nous remplaçons x^m_i x^m+1_j parx^m_i+j dans

w⁰, le mot obtenu serait plus court que w⁰ et il serait aussi accepté parA⁰_R. Donc le mot le plus court accepté parA⁰_R estw⁰ =x¹_ix²_j. . . xⁿ_k oùx^m6=x^m+1 avec(1≤m < n).

Par construction de A⁰_R, pour chaque symbole x^m_i dans le mot w⁰, il y a une transition d’empile-ment(U_xm,hxm

i ,α,xmαi,W_y) sixm

i ∈ A0 ou une transition (U_xm,hxm

i ,y,∅i,W_y) sixm

i ∈ A0. Donc toutes les transitions dans la plus courte séquence de transitions acceptant w⁰ sont des empilements ou des dépilements, excepté la première transition à partir de l’état initial (S_A,h,z₀,z₀i,U_x1)et le dépilement final (V_xn,hxn

k,z₀,∅i,D_A). Le nombre des autres dépilements est égal au nombre d’empilements (ce qui est nécessaire pour avoirz₀au sommet de la pile avant la transition finale).

Maintenant, soitwun mot accepté parA_R, soitN b^AR

push(w)le nombre minimum d’empilements dans une séquence de transitions acceptantwdansA_R, et soitN bAR

pop(w)le nombre minimum de dépilements dans une séquence de transitions acceptantwdansA_R.

Lemme 3. Pour chaque mot w∈L(A_R): – N bAR pop(w) =N b^A 0 R pop(g(w)) – N b^AR push(w) =N b^A 0 R push(g(w))

Démonstration. Soitt1t2. . . tnla séquence de transitions acceptantwdansA_Ravec un nombre minimum d’empilements et de dépilements. Pour chaque séquencetiti+1. . . tj de transitions passives suivie par un empilement ou un dépilement, il y a une transition avec le même empilement ou dépilement et le même symbole en lecture indexé parj−i+ 1. Alorsg(w)∈L(A⁰_R).

Soitt⁰₁t⁰₂. . . t⁰_n0la séquence de transitions ayant le minimum d’empilements et dépilements et acceptant

g(w)dansA0

R. Il est évident quef(g(w)) =w. Ainsi, s’il y a une séquencet00

1t00

2. . . t00

n0 qui accepteg(w)

avec moins d’empilements et de dépilements quet0

1t0

2. . . t0

n0, alors chaquet00

i ∈δ0\δpeut être remplacée par une séquence de transitions passives suivies par un empilement ou un dépilement dansA_R. Et cette séquence accepte f(g(w))(qui est égal à w) avec moins d’empilements et de dépilements que dans la séquencet₁t₂. . . t_n, ce qui contredit le fait que cette séquence minimise le nombre d’empilements et de dépilements pour accepterw.

Proposition 4. Le mot accepté par A_R qui minimise le nombre d’empilements et de dépilements est

f(w⁰), oùw⁰ est le mot le plus court (i.e., ayant le minimum de symboles) accepté par A⁰_R.

Démonstration. Par le lemme 2, le mot le plus court accepté parA⁰_R minimise le nombre d’empilements et de dépilements dansA⁰_R pour être accepté (puisque le nombre d’empilements et de dépilements croît linéairement en fonction de la longueur du mot). Soitw⁰ ce mot.

Supposons qu’il y a un mot w accepté par A_R tel que N b^AR

push(w) < N b^A

0 R

push(w⁰). Par le lemme 3,

N b^A 0 R push(g(w)) = N b^AR push(w), et donc N b^A 0 R push(g(w)) < N b^A 0 R

push(w⁰), puisque w⁰ = arg minN b^A

0 R

push. Par l’absurde,f(w⁰)est le mot qui minimise le nombre d’empilements et de dépilements dansA_R pour être accepté.

Dans le document Qualité de Service et calcul de chemins dans les réseaux inter-domaine et multicouches (Page 99-103)