Tout comme pour la partie précédente, nous présentons ici de nombreuses simulations, permettant cette fois-ci d’observer les temps de calculs nécessaires au décodage, en fonction de P , k, len, ou encore de la probabilité d’effacements du canal. Nous avons vu précédemment que le décodage était divisé en deux étapes : les calculs effectués à la réception des paquets, et les calculs effectués par l’algorithme de décodage itératif : les simulations que nous présentons ici concernent cette deuxième étape.
Afin de comparer des codes de différents paramètre k, n et P , nous avons choisi de présenter les différents temps d’exécution en fonction de la probabilité d’effacements sur le canal, p. Ainsi, nous pouvons superposer plusieurs courbes correspondant à des codes différents et observer l’influence du paramétrage de ces codes sur différentes métriques : pour un code de longueur n et une probabilité de pertes p, on aura environ e = p ∗ n paquets effacés, et donc e = p ∗ n à réparer par le décodage.
Rappelons l’équation représentant le temps de calcul du décodage en fonction des différents paramètres de notre code P , k et len :
Chapitre 2 : Fauxtraut 2.4 Simulations
On sait qu’il est impossible lors de l’algorithme de décodage itératif de décoder plus de n − k paquets. On peut cependant réécrire cette équation, pour faire apparaître e ≤ n − k, ce qui donne alors
O(e ∗ max(|P |, 2) ∗ len) (2.7) ou bien la réécrire en utilisant le taux de perte du canal p, dont va dépendre le nombre de paquets effacés à corriger e = p ∗ n :
O(p ∗ n ∗ max(|P |, 2) ∗ len) (2.8)
Enfin, nous pouvons préciser encore plus cette équation, en y faisant apparaître distinctement le nombre de paquets sources k et le nombre de paquets codes n − k d’un bloc :
O(p ∗ ((k + 1) ∗ |P | + (n − k) ∗ 2) ∗ len) (2.9)
Complexité du décodage : influence de la taille des paquets len
Dans un premier temps, nous présentons des simulations pour le décodage pour différents paramétrages de notre code, en faisant varier la taille des paquets len, qui a une influence directe sur le temps d’exécution du décodage.
Cette première figure représente donc les temps nécessaires au décodage pour un code de dimension 1001 et de longueur 2002, avec P = [91, 92, 101, 103, 109, 113, 121, 131, 139], pour les-quels on a fait varier la taille des paquets len, prenant des valeurs parmi [5000, 10000, 15000, 20000] octets. On observe ici que le temps de calcul augment linéairement avec la taille des paquets : en effet, chaque fois qu’on Xore un paquet, on effectue en réalité len Xors binaires. Par consé-quent, le temps de calcul du décodage sera proportionnel à la taille len des paquets. La fi-gure ci-dessous représente le même type de simulations que la fifi-gure précédente, mais pour P = [197, 199, 200, 201, 203]. On remarque là-aussi que le temps de calcul du décodage est bien proportionnel à la taille des paquets len.
Chapitre 2 : Fauxtraut 2.4 Simulations
Enfin, nous présentons une dernière simulation basée sur le même principe que pour les figures précédentes, mais pour une dimension k = 2002, pour obtenir un code de rendement R = 2002/3003 = 2/3. Là-aussi, le temps de calcul est proportionnel à len pour un nombre d’effacements e = p ∗ n fixé.
Ces trois figures combinées nous permettent donc d’observer que le temps de calcul du décodage est bien proportionnel à la taille des paquets, toutes choses égales par ailleurs : pour un même paramétrage de notre code (P , k et n − k fixés), et pour un taux de perte p, on aura à réparer e = p ∗ n paquets, et plus ces paquets auront une taille len importante, plus le décodage prendra du temps. Le temps de calcul du décodage progresse donc bien linéairement avec la taille des paquets qui constituent nos blocs.
Complexité du décodage : influence du paramètre P
Les simulations que nous présentons ci-dessous permettent d’observer l’influence du para-mètre P , et notamment de son cardinal |P | sur le temps d’exécution de l’algorithme de décodage. Rappelons que P est un ensemble de nombres premiers entre eux que partagent l’émetteur et le récepteur, et donc on déduit la matrice génératrice de notre code, et donc les combinaisons linéaires à effectuer pour encoder ou décoder nos blocs. Ces simulations ont été réalisées de la manière suivante :
Chapitre 2 : Fauxtraut 2.4 Simulations
— Chaque courbe correspond à un paramétrage du code, pour des paquets de taille len = 10000octets et une longueur n − k = 1001.
— Pour chaque courbe, nous choisissons un ensemble P dont la somme vaut toujours 1001, et pour lesquels nous avons bien vérifié qu’ils ne contiennent que des nombres premiers entre eux.
La figure ci-dessus représente donc des simulations de décodage pour k = 1001, n − k = 1001, n = 2002, et donc un rendement R = k/n = 1001/2002 = 1/2. Elle se lit de la manière suivante : pour une probabilité de perte p = 0.2, des paquets de taille len = 10000octets et un paramétrage de notre code P = [332, 333, 335] et k = 1001, le décodage de e = p ∗ n prend environ 1.2millisecondes.
On peut remarquer que le temps de calcul progresse avec le cardinal de P : en effet, pour chaque source réparé, on doit alors Xorer celui-ci dans les |P | + 1 nœuds contraintes lui corres-pondant.
On peut aussi observer que le temps de calcul progresse avec le nombre d’effacements à corriger, tant que l’algorithme itératif parvient à corriger tous les paquets effacés. Une fois que le taux de perte devient trop important pour que l’algorithme de décodage parvienne à réparer des paquets, le temps de calcul diminue alors rapidement : ceci arrive quand le taux de pertes dépasse 0.37 pour P = [91, 92, 101, 103, 109, 113, 121, 131, 139], et quand il dépasse 0.45 pour P = [499, 501]. On pourrait croire ici que la capacité de correction du code correspondant à P = [91, 92, 101, 103, 109, 113, 121, 131, 139] est moins bonne que pour [499, 501] (puisque le temps de calcul pour P = [499, 501] reste grand pour des valeurs de p supérieures à 0.5), mais nous verrons par la suite qu’il n’en est rien, et que c’est même l’inverse.
Les figures suivantes représentent les mêmes simulations que la figure précédente, pour lesquels nous avons fait varier k et donc le rendement du code R, qui prend des valeurs parmi R ∈ [2/3, 3/4, 4/5, 5/6] : elles permettent de confirmer les observations faites pour la première courbe (rendement R = 1/2). En effet, on remarque que le temps de calcul du décodage ne dépend pas de k la dimension du code, mais de e = p ∗ n, le nombre approximatif d’effacements du bloc. Ainsi, pour chaque paramétrage (k, n) de nos codes, on observe que le temps de calcul est maximal quand p s’approche de la valeur (n − k)/n : ceci correspondant bien à la situation ou le bloc a subi à peu près autant d’effacements que le nombre de paquets de redondance. Notre code correcteur n’étant pas un code MDS, cette situation arrive en réalité quand p est légèrement plus petit que (n − k)/n.
Chapitre 2 : Fauxtraut 2.4 Simulations
Les calculs effectués par le décodage de notre code consistant majoritairement à Xorer des paquets entre eux, nous présentons de plus une courbe sur laquelle figure le nombre de Xors moyens effectués lors du décodage d’un bloc : suivant la puissance de calcul de la machine utilisée pour décoder un bloc, les Xors prendront plus ou moins de temps, alors que leur nombre
Chapitre 2 : Fauxtraut 2.4 Simulations
restera le même. Il est donc intéressant de présenter le nombre Xors moyen à effectuer lors du décodage. Ces simulations correspondent aux mêmes simulations effectuées pour les courbes précédentes, mais ne représentent donc pas le temps de calcul, mais le nombre de Xors effectués au cours du décodage.
On remarque que cette figure représente des courbes qui se superposent presque exactement avec les courbes de la figure () : le temps de calcul est donc bien proportionnel au nombre de Xors effectués lors du décodage (modulo les calculs nécessaires à l’algorithme, tels que le parcourt de listes, le retrait d’éléments d’une liste, ou l’incrémentation de compteurs).
Complexité du décodage : influence des paramètres k et n
Dans cette partie, nous présentons des simulations permettant d’observer l’influence de la longueur n de notre code sur la durée du décodage. Rappelons que le paramètre n représente le nombre total de paquets (sources et codes) d’un bloc envoyé par l’émetteur, et que n = k + (n − k) = k + P P CM (P ) + 1 : notre code nous impose de fixer le nombre de paquets codes n − k = Σ(P ) + 1, et pour faire varier n la taille de nos blocs, nous devons donc faire varier k le nombre de paquets sources.
Comme pour les simulations présentées précédemment, nous fixons tous les autres para-mètres du code, et faisons donc varier n, en faisant en réalité varier k.
Chapitre 2 : Fauxtraut 2.4 Simulations
Analyses des résultats
Chapitre 2 : Fauxtraut 2.4 Simulations
Figure 2.17 –
Figure 2.18 –
Figure 2.19 – Temps d’exécution du décodage en fonction de la probabilité d’effacements pour différents P
Chapitre 2 : Fauxtraut 2.4 Simulations