FR3016259A1 - Procede de gestion d'une unite de calcul de noeud de parite, equipement et logiciel pour la mise en oeuvre du procede - Google Patents

Abstract

Un procédé de gestion d'une unité de calcul de nœud de parité d'un décodeur de code correcteur d'erreurs susceptible de représentation par un graphe bipartite comprenant au moins un nœud de parité est proposé, le nœud de parité étant configuré pour recevoir des premier et deuxième messages en entrée, et produire un message de sortie, les éléments des messages d'entrée et de sortie du nœud de parité comprenant un symbole et un degré de fiabilité associé au symbole, les premier et deuxième messages en entrée comprenant des listes d'éléments ordonnés selon leur degré de fiabilité. Le procédé comprend : initialiser une pluralité de nbub mémoires de type FIFO avec des éléments calculés à partir de combinaisons d'éléments des premier et deuxième messages en entrée, et déterminer les valeurs du message de sortie de manière itérative.

Description

PROCEDE DE GESTION D'UNE UNITE DE CALCUL DE NOEUD DE PARITE, EQUIPEMENT ET LOGICIEL POUR LA MISE EN OEUVRE DU PROCEDE La présente invention se rapporte à un procédé de décodage de codes LDPC non binaires, et à un décodeur pour la mise en oeuvre du procédé. Les codes correcteurs d'erreurs sont très largement utilisés dans de nombreux domaines des technologies de l'information, et notamment dans les domaines de la transmission d'information entre un émetteur et un récepteur, et du stockage/lecture de l'information sur un support de stockage.

Les codes LPDC sont des codes correcteurs d'erreurs de la catégorie des codes en bloc linéaires, dont la matrice de parité a la propriété d'être creuse (en anglais, « low-density parity check matrix »), c'est-à-dire qu'elle ne contient qu'un faible nombre d'éléments non nuls en comparaison de son nombre total d'éléments. Ils peuvent en effet être caractérisés, à l'instar des codes en bloc linéaires, par une matrice dite de parité, généralement notée H. La matrice de parité H est liée à une matrice dite de génération du code, généralement notée G, par la relation : G. HT = 0 où HT désigne la matrice transposée de H. Les dimensions M x N de la matrice de parité correspondent, pour le nombre de lignes M, au nombre de contraintes de parité du code, et pour le nombre de colonnes N, à la longueur des mots de code du code considéré. Les lignes de la matrice de parité H d'un code en bloc linéaire correspondant respectivement à des contraintes de parité qui sont par construction respectées par les mots de code, l'égalité v. HT = 0 sera vérifiée pour tout mot de code y. Pour rappel, un corps de Galois GF(q) est un ensemble fini de q éléments dont tout élément peut être décrit en fonction d'un élément primitif, noté ici a. Dans la suite, les éléments du corps de Galois GF(q) seront notés fo, cro, al, ..., aq-21. Les codes LDPC dont les symboles des mots de code appartiennent au corps de Galois binaire (d'ordre 2), noté GF(2), sont dits binaires, tandis que les codes LDPC dont les symboles des mots de code appartiennent à un corps de Galois d'ordre q strictement supérieur à 2, noté GF(q), sont dits non-binaires. Ainsi, les éléments d'une matrice de parité d'un code LDPC non-binaire appartiendront à un corps de Galois GF(q) non binaire (q > 2) et les produits matriciels des équations ci-dessus seront effectués en utilisant les lois d'addition et de multiplication du corps GF(q), notées respectivement ED et 0 dans la suite.

La construction de ces codes peut aussi être déterminée par un ensemble d'équations de parité sur GF(q), où une de ces équations impliquant d, symboles de mot de code s'écrit : hi,kxk = 0, où hJ,k sont les valeurs non nulles sur la j-ième ligne de H et un mot de code est désigné par X = x2, ...,xN), avec (xk), k = 1 ...N est un symbole représenté par m = log2(q) bits notés xk(x = , -k,1 - x k,2 --- Xk,m)- Un exemple de matrice de parité H dans le corps de Galois GF(4) dont les éléments sont notés {0; a° ; a1 ; a2} de dimensions M = 3 et N = 6 est donné ci-dessous : 0 a° a° 0 a2 0 H = a1 0 0 a° 0 a2 a° 0 a2 0 0 al De nombreux algorithmes de décodage itératif de codes LDPC utilisent une représentation de la matrice de parité du code par un graphe bi-partite dit « graphe de Tanner ». Pour une matrice de parité H de dimensions M x N, cette représentation met en correspondance par le biais de branches M noeuds, dits « noeuds de parité » (en anglais « Check Node » ou « CN ») avec N noeuds, dits « noeuds de variable » (en anglais « Variable Node » ou « VN »). Chaque élément 15 non nul de la matrice de parité est représenté dans le graphe de Tanner correspondant par une branche joignant le noeud de parité correspondant à la ligne de l'élément dans la matrice H au noeud de variable correspondant à la colonne de l'élément dans la matrice H. Chaque noeud de parité du graphe représente ainsi une équation de parité déterminée par les branches qui le relient aux noeuds de 20 variables. Les noeuds de variable reçoivent des mots à décoder ou en cours de décodage. La figure 1 montre le graphe de Tanner correspondant à l'exemple de matrice de parité de dimensions M = 3 et N = 6 donné ci-dessus. Ce graphe comprend M = 3 noeuds de parité notés sur la figure CN1, CN2 et CN3, et N = 6 25 noeuds de variable notés sur la figure VN1, VN2 , VN3, VN4, VN5 et VN6. Les trois équations de parité correspondant respectivement aux trois noeuds de parité du graphe sont : a° VN2e) a° VN3® a2 VN5 = 0 pour le noeud de parité CNi, al VNie a° VN4 ®a2 VN6 = 0 pour le noeud de parité CN2, 30 a° VNie a2 VN3 ®a1 VN6 = 0 pour le noeud de parité CN3, où les opérateurs ED et désignent respectivement l'addition et la multiplication dans le corps de Galois GF(4). La représentation graphique de Tanner peut être exploitée pour la mise en oeuvre d'algorithmes dont l'efficacité a été montrée sur des modèles de graphe, tels que l'algorithme dit de « propagation de croyances » (en anglais, « belief propagation », ou « BP ») ou les algorithmes de type à passage de messages (en anglais, « message passing », ou MP). Lorsqu'il est appliqué à un graphe bipartite ayant deux différents types de noeuds, l'algorithme BP repose sur un processus itératif d'envoi de messages entre des noeuds de chaque type connectés par des branches (noeuds dits « voisins »). Des algorithmes de décodage LDPC itératif utilisant l'échange de messages entre les noeuds de parité et les noeuds de variable du graphe de Tanner i.o correspondant au code LPDC considéré ont ainsi été développés. Ces algorithmes de décodage peuvent plus généralement être mis en oeuvre ou adaptés pour le décodage de tous les codes en bloc linéaires susceptibles d'être représentés par un graphe bipartite comprenant un ensemble de noeuds de parité et un ensemble de noeuds de variable. 15 Dans le cas d'un décodage à entrées souples, les messages échangés comprennent des valeurs possibles des symboles des mots traités auxquelles sont associées des informations de vraisemblance ou de fiabilité. Par exemple, lorsque le code considéré est binaire, et que les symboles des mots de code sont à valeurs dans le corps de Galois GF(2), c'est-à-dire à valeurs binaires, les messages 20 échangés comprenant des densités de probabilité comprennent deux densités, l'une pour la valeur « 0 » et l'autre pour la valeur « 1 ». Les messages comprendront par exemple des couples de valeurs binaires auxquelles sont respectivement associées des valeurs de vraisemblance (ou de fiabilité). Lorsque le code considéré est non-binaire, et que les symboles des mots de 25 code sont à valeurs dans le corps de Galois GF(q), avec q>2, les messages échangés pourront comprendre q valeurs de fiabilité, correspondant chacune à un élément de GF(q), qui peuvent être représentées sous la forme d'un vecteur de taille q de couples (symbole, valeur de fiabilité). Un noeud de parité d'un décodeur LDPC non binaire d'un code à valeurs 30 dans le corps de Galois GF(q) reçoit ainsi d, messages en entrée et génère d, messages en sortie. Chaque message d'entrée et de sortie contient q couples de valeurs, l'une représentant un symbole, et l'autre représentant une fiabilité ou une vraisemblance associée à ce symbole. Si on utilise une implémentation directe de l'algorithme de décodage Belief Propagation (BP), une sortie est construite en 35 sélectionnant les q meilleures combinaisons parmi q à la puissance d, - 1. Cela conduit à une complexité de calcul de l'ordre de 0(q2). L'algorithme de décodage BP peut en outre être considéré dans le domaine fréquentiel. On parle alors d'algorithme BP basé sur la transformation de Fourier (en anglais, « Fourier Transform-based BP algorithm »). Le passage dans le domaine fréquentiel permet de réduire la complexité de l'algorithme BP, pour atteindre une complexité de l'ordre de 0(cl, x q x log(q)). Il reste que l'implémentation de l'algorithme BP présente un coût très élevé en termes de complexité de calcul, coût qui devient prohibitif dès lors que l'on envisage des valeurs de q supérieures à 16. Différents algorithmes ont été proposés pour palier à ce problème de i.o complexité élevée, parmi lesquels l'algorithme dit Extended Min-Sum (EMS), qui propose d'utiliser des messages tronqués en sélectionnant les nm symboles les plus fiables, nm étant choisi très inférieur à q (nm « g). Les messages sont ensuite triés avant d'être introduits au noeud de parité. Un noeud de parité est composé par une combinaison de noeuds de parité élémentaires, où chaque noeud de parité 15 élémentaire reçoit deux messages triés et contenant chacun nm couples (symbole, fiabilité) à partir desquels il génère un message de sortie contenant les nm meilleures combinaisons possibles des deux messages en entrée, le nombre total de combinaisons étant égal à nm à la puissance 2. On pourra se reporter à l'article suivant pour une description détaillée de 20 l'algorithme EMS : « Decoding algorithms for nonbinary LDPC codes over GF(q) », D. Declercq et M. Fossorier, IEEE Trans. Commun., vol. 55, n° 4, pp. 633-643, Apr. 2007. L'algorithme dit « Bubble Check », et sa version améliorée dite « L-Bubble Check », qui visent à réduire plus avant la complexité des noeuds de parité 25 élémentaires tout en gardant les mêmes performances en termes de taux d'erreurs, proposent de réduire l'espace de recherche des nm meilleures combinaisons possibles des deux messages en entrée. On pourra se reporter aux articles suivants pour une description détaillée des algorithmes Bubble Check et L-Bubble Check, respectivement : « Bubble check : a 30 simplified algorithm for elementary check node processing in extended min-sum non- binary LDPC decoders », E. Boutillon et L. Conde-Canencia, Electronics Letters, vol. 46, n° 9, p. 633 - 634, 2010, et « Design of a GF(64)-LDPC Decoder Based on the EMS Algorithm », E. Boutillon, L. Conde-Canencia, A. Al Ghouwayel, IEEE Trans. On Circuits and Systems, vol. 60, n ° 10, pp. 2644 - 2656, Octobre 2013. 35 Bien que l'algorithme Bubble-Check permette de réduire la quantité de calculs dans les noeuds de parité élémentaires, la complexité de décodage reste trop élevée pour permettre des implémentations matérielles et/ou logicielles qui soient véritablement efficaces. Un objet de la présente invention est de proposer un procédé de gestion d'une unité de calcul de noeud de parité d'un décodeur de code correcteur d'erreur susceptible de représentation par un graphe bipartite, ainsi qu'une unité de calcul de noeud de parité de décodeur de code correcteur d'erreur susceptible de représentation par un graphe bipartite. Selon un premier aspect, l'invention concerne un procédé de gestion d'une unité de calcul de noeud de parité d'un décodeur de code correcteur d'erreurs susceptible de représentation par un graphe bipartite comprenant au moins un noeud de parité, le noeud de parité étant configuré pour recevoir des premier (U) et deuxième (V) messages en entrée, et produire un message de sortie (E), les éléments des messages d'entrée et de sortie du noeud de parité comprenant un symbole et un degré de fiabilité associé au symbole, les premier et deuxième messages en entrée comprenant des listes U(i) et V(j) de longueur rim d'éléments ordonnés selon leur degré de fiabilité. Le procédé proposé comprend l'initialisation d'une pluralité de nbub mémoires de type FIFO avec des éléments calculés à partir de combinaisons selon une opération de calcul cf) (U(i), V(j)) d'éléments des premier et deuxième messages en entrée, ladite opération de calcul cf) étant telle que si ab et cd, alors cp(a,c) cp(b,d), et la détermination de valeurs du message de sortie de manière itérative. Selon le procédé proposé, une itération d'ordre m, m étant un entier supérieur ou égal à zéro, comprend la sélection parmi les éléments de sortie des mémoires de type FIFO d'un élément Ss(m) ayant le meilleur degré de fiabilité, la génération d'un élément du message de sortie (E) à partir de l'élément sélectionné Ss(m), et la mise à jour de l'index de sortie de la mémoire FIFO de laquelle l'élément sélectionné Ss(m) est issu. Le procédé proposé fournit un algorithme qui permet une implémentation plus performante d'un décodeur de code correcteur d'erreurs. Cette implémentation permet en effet un gain significatif en terme de surface de composant utilisé pour une implémentation du décodeur sur un composant de type FPGA, ainsi qu'en terme de fréquence maximum d'horloge pour l'exécution du procédé proposé. Dans une mise en oeuvre particulière du procédé proposé, nbub est égal à quatre, et les quatre mémoires de type FIFO sont initialisées avec des éléments de 4 sous-ensembles S1, S2, S3, et S4, générés en combinant les degrés de fiabilité respectivement associés aux éléments U(i) et V(j) des messages d'entrée, comme suit : S1 = [cp(U (0),V (1)); 1 E {0, ...,nm - 1}] , S2 = [cp (V (0), U(l)); 1 E {1, ...,nm - 1}] , S3 = [cp(U (1),V (1)); 1 E ft ...,nn - il] , et 54 = [cp (V (1), U(l)); 1 E 12, ...,nn - il] . Avantageusement, les 4 mémoires de type FIFO sont initialisées en fonction de leurs tailles, qui sont choisies respectivement égales à : n'n - 1, n'n n'n - 2, - 2, et 2 2 nm - 3. 2 Dans une autre mise en oeuvre particulière du procédé proposé, la génération d'un élément du message de sortie (E) à partir de l'élément sélectionné Ss(m) n'est effectuée que si le message de sortie E ne contient pas déjà ledit élément. Ceci permet d'éviter la génération de doublons dans le message de sortie (E). Dans une autre mise en oeuvre particulière du procédé proposé, le degré de fiabilité de chaque élément est représenté par un logarithme de rapport de vraisemblance (LLR). Dans une autre mise en oeuvre particulière du procédé proposé, l'opération de calcul cf) est une addition. Le procédé proposé peut avantageusement être appliqué à un décodeur de codes LDPC non binaires. Selon un deuxième aspect, il est proposé une unité de calcul de noeud de parité d'un décodeur de code correcteur d'erreurs susceptible de représentation par un graphe bipartite, le noeud de parité étant configuré pour recevoir des premier (U) et deuxième (V) messages en entrée, et produire un message de sortie (E), les éléments des messages d'entrée et de sortie du noeud de parité comprenant un symbole et un degré de fiabilité associé au symbole, les premier et deuxième messages en entrée comprenant des listes U(i) et V(j) de longueur rim d'éléments ordonnés selon leur degré de fiabilité. L'unité de calcul proposée comprend un processeur informatique couplé de manière opérationnelle à des moyens mémoire, les moyens mémoire étant configurés sous forme d'une pluralité de nbub mémoires de type FIFO, et un générateur de message de sortie, s'exécutant sur le processeur informatique. Le générateur de message de sortie est avantageusement configuré pour initialiser la pluralité de nbub mémoires de type FIFO avec des éléments calculés à partir de combinaisons selon une opération de calcul cf) (U(i), V(j)) d'éléments des premier et deuxième messages en entrée, ladite opération de calcul cf) étant telle que si ab et cd, alors cp(a,c) cp(b,d), et déterminer des valeurs du message de sortie de manière itérative, une itération d'ordre m, m étant un entier supérieur ou égal à zéro, comprenant la sélection parmi les éléments de sortie des mémoires de type FIFO d'un élément Ss(m) ayant le meilleur degré de fiabilité, la génération d'un élément du message de sortie (E) à partir de l'élément sélectionné Ss(m), et la mise à jour de l'index de sortie de la mémoire FIFO de laquelle l'élément sélectionné Ss(m) est issu.

Dans un mode de réalisation particulier de l'unité de calcul, nbub est égal à quatre, et les quatre mémoires de type FIFO sont initialisées avec des éléments de 4 sous-ensembles S1, S2, S3, et S4, générés en combinant les degrés de fiabilité respectivement associés aux éléments U(i) et V(j) des messages d'entrée, comme suit : S1 = [cp (U (0),V (1)); 1 E {0, ...,n,, - 1}] , S2 = [cp (V (0), U (1)); 1 E {1, ... , n,, - 1}] , S3 = [cp (U (1), V (1)); 1 E ft ..., n'n2 - Ill , et S4 = [cp (V (1), U (1)); 1 E 12, ...,nn z - Ill . Dans un autre mode de réalisation particulier de l'unité de calcul, la génération d'un élément du message de sortie (E) à partir de l'élément sélectionné Ss(m) n'est effectuée que si le message de sortie E ne contient pas déjà ledit élément. Ceci permet d'éviter la génération de doublons dans le message de sortie (E). Dans un autre mode de réalisation particulier de l'unité de calcul, le degré de fiabilité de chaque élément est représenté par un logarithme de rapport de vraisemblance (LLR). Dans un autre mode de réalisation particulier de l'unité de calcul, l'opération de calcul cf) est une addition. Selon un autre aspect, il est proposé un programme d'ordinateur, chargeable dans une mémoire associée à un processeur, et comprenant des portions de code pour la mise en oeuvre des étapes du procédé proposé lors de l'exécution dudit programme par le processeur, ainsi qu'un ensemble de données représentant, par exemple par voie de compression ou d'encodage, ledit programme d'ordinateur. Un autre aspect concerne un support de stockage non-transitoire d'un programme exécutable par ordinateur, comprenant un ensemble de données représentant un ou plusieurs programmes, lesdits un ou plusieurs programmes comprenant des instructions pour, lors de l'exécution desdits un ou plusieurs 30 programmes par un ordinateur comprenant une unité de traitement couplée de manière opérationnelle à des moyens mémoire et à un module d'interface entrées/sorties, conduire l'ordinateur à gérer une unité de calcul de noeud de parité selon les procédés proposés. Les procédés proposés conviennent particulièrement bien, bien que de façon 35 non exclusive, pour un noeud de parité élémentaire d'un décodeur de code correcteur d'erreurs LDPC non-binaire. Mais ils conviennent aussi pour tout noeud de parité d'un décodeur de code correcteur d'erreurs susceptible de représentation par un graphe bipartite comprenant au moins un noeud de parité. D'autres particularités et avantages de la présente invention apparaîtront dans la description ci-après d'exemples de réalisation non limitatifs, en référence aux dessins annexés, dans lesquels : La figure 1 est un schéma illustrant un graphe bipartite représentant un code correcteur d'erreurs sur lequel les procédés proposés peuvent être mis en oeuvre ; La figure 2a représente un système de décodage auquel l'invention peut s'appliquer ; Les figures 2b et 2c représentent un noeud de parité d'un décodeur de code correcteur d'erreur auquel l'invention peut s'appliquer ; Les figures 3a, 3b et 3c représentent un noeud de parité élémentaire auquel l'invention peut s'appliquer ; La figure 4 est un tableau représentant certains aspects des calculs effectués au sein d'un noeud de parité élémentaire selon l'algorithme LBubble Check ; Les figures 5a et 5b sont des tableaux représentant certains aspects des calculs effectués au sein d'un noeud de parité élémentaire selon un mode particulier du procédé proposé ; Les figures 6a et 6b sont des tableaux représentant certains aspects des calculs effectués au sein d'un noeud de parité élémentaire selon un mode particulier du procédé proposé ; La figure 7 est un diagramme illustrant certains aspects de mise en oeuvre du procédé proposé ; La figure 8 représente une architecture d'un noeud de parité élémentaire pour la mise en oeuvre du procédé proposé ; La figure 9 est un diagramme illustrant certains aspects de mise en oeuvre du procédé proposé.

Dans la description détaillée ci-après de modes de réalisation de l'invention, de nombreux détails spécifiques sont présentés pour apporter une compréhension plus complète. Néanmoins, l'homme du métier peut se rendre compte que des modes de réalisation peuvent être mis en pratique sans ces détails spécifiques. Dans d'autres cas, des caractéristiques bien connues ne sont pas décrites en détail pour éviter de compliquer inutilement la description. L'invention sera décrite ci-après dans le cadre non limitatif d'un noeud de parité d'un décodeur de code correcteur d'erreurs. La figure 2a montre un système de décodage (100) comprenant un décodeur LDPC non binaire (101) selon différents modes de réalisation. Le système (100) comprend en outre une interface entrée sortie (102), des moyens de traitement (103) et des moyens mémoire (104). Une version bruitée y' du mot de code y est reçue après transmission sur un canal de communication ou bien après lecture sur un support de stockage. lo L'acquisition du mot à décoder y' par le système (100) s'effectue par l'interface (102). La phase d'acquisition des données à décoder est suivie d'une phase de traitement de ces données, effectuée par exemple par une unité de traitement des données 105, qui pilote le décodeur LDPC non binaire 101. L'unité de traitement des données 105 peut être un ordinateur, un réseau d'ordinateurs, ou un autre appareil 15 comportant un processeur, une mémoire, une unité de stockage de données 104, et d'autres éléments matériels associés comme une interface de réseau et un lecteur de support pour lire et écrire un support de stockage amovible (non représentés sur la figure). Le support de stockage amovible peut être, par exemple, un disque compact (CD), un disque vidéo/polyvalent numérique (DVD), un disque flash, etc. Le 20 support de stockage amovible contient des instructions qui, lorsqu'elles sont exécutées par l'unité de traitement des données 105, amènent cette unité 105 à effectuer la partie acquisition et/ou traitement de données des exemples de mise en oeuvre du procédé proposé décrits dans les présentes. Le support de stockage amovible peut en outre comprendre un ou plusieurs programmes informatiques pour 25 mettre en oeuvre et pour exécuter le décodage LDPC sur le décodeur 101, puis stocker les résultats de ce décodage en mémoire 104. Certaines parties du décodeur LDPC peuvent être stockées en tant que suites ordonnées d'instructions sur une instance donnée du support de stockage amovible, un dispositif amovible ou un stockage de données local 104, à charger dans la mémoire pour être exécutées par 30 un ou plusieurs processeurs. Spécifiquement, des instructions logicielles ou un code de programme lisible par ordinateur pour effectuer des modes de réalisation peuvent être stockés, provisoirement ou en permanence, en intégralité ou en partie, sur un support lisible par ordinateur non transitoire comme un disque compact (CD), un dispositif de stockage local ou distant, une mémoire locale ou distante, une 30162 5 9 disquette, ou n'importe quel autre dispositif de stockage lisible par ordinateur. Bien que le décodeur LDPC soit décrit sous forme de programme résidant dans une mémoire, le décodeur LDPC peut être mis en oeuvre sous forme matérielle, comme un circuit intégré spécifique application (ASIC), ou sous forme d'une 5 combinaison d'éléments matériels et logiciels, comme par exemple un programme logiciel destiné à être chargé et exécuté sur un composant de type FPGA (Field Programmable Gate Array). La figure 2b illustre un exemple d'architecture du décodeur (101), qui comprend un processeur noeud de parité (110) connecté à d, processeurs noeuds de 10 variable V Ni, i = 1 ... d, (dont seuls trois (111), (112), et (113) sont représentés sur la figure) et d, banques mémoire, par exemple de type RAM, RAMi, i = 1 ... d, (dont seuls trois (114), (115), et (116) sont représentées sur la figure). Le processeur noeud de parité (110) reçoit en parallèle d, messages en entrée V2Ci, i = 1 ... d, provenant respectivement des banques mémoire RAMi, i = 1 ... d,. Il génère en sortie, soit après calculs, d, messages de sortie C2Vi, i = 1 ... d, respectivement transmis aux processeurs noeuds de variable V Ni, i = 1 ... d, (111), (112), et (113). Les processeurs noeuds de variable V Ni, i = 1 ... d, (111), (112), et (113) génèrent alors des messages V2C qui seront consignés dans les banques mémoires avant d'être fournis en entrée au processeur noeud de parité. Le noeud de parité (110), qui reçoit d, messages en entrée V2Ci, i = 1 ... dc, et génère d, messages de sortie C2Vi, i = 1 ... d, , est dit de degré d,. Comme indiqué précédemment, les messages traités par un noeud de parité comprennent des couples d'informations représentant un symbole possible et une valeur de fiabilité de cette information. Les opérations nécessaires au calcul de valeurs de fiabilité représentées par des probabilités connaissant le mot de code reçu comprenant un grand nombre de multiplications, il est courant d'utiliser une représentation de la valeur de fiabilité d'un symbole logarithmique, ce qui permet de remplacer les multiplications par des additions. Cela permet notamment d'optimiser les mises en oeuvre du décodage sur des composants dédiés (par exemple de type ASIC ou FPGA). Par exemple, on peut définir des logarithmes de rapport de vraisemblance (en anglais, « Log-Likelihood Ratio », ou « LLR »), qui correspondront à l'information de fiabilité échangée dans les messages entre les noeuds de parité et les noeuds de variable. Le rapport de vraisemblance logarithmique LLR permet de mesurer la fiabilité des symboles tout en éliminant les opérations de multiplications dans le décodeur et en procurant une meilleure immunité contre les erreurs de quantifications. Une définition des LLR utilise en dénominateur la probabilité d'un symbole de référence fixe, par exemple le symbole a°. Ainsi, si on note par 13 le symbole bruité reçu à la sortie d'un canal de transmission, la définition du LLR d'un symbole ai, i=0, q-1 est donné par l'équation ci-dessous : LLR(ai) = ln( r(cle)P ) où Pr(ailp) est la probabilité conditionnelle de a' Pr(a°1fl) sachant 13. La définition ci-dessus peut conduire à des valeurs de LLR négatives, notamment quand la probabilité de ai est inférieure à celle de a°. Cependant, pour une mise en oeuvre du procédé proposé sur une architecture numérique à point fixe, il est préférable de travailler avec des valeurs positives de LLR. Une première solution pour ce faire est d'utiliser le symbole ayant la plus petite fiabilité comme symbole de référence. Selon la définition donnée ci-dessus les symboles les plus fiables sont ceux qui ont les valeurs LLR les plus élevées. Cela conduit à élargir le nombre de bits nécessaire à la représentation des valeurs LLR, ce qui augmente la taille des mémoires requises par le décodeur. De ce point de vue, il est plus efficace de définir les LLR de sorte que les symboles les plus fiables aient les LLR les plus petits (tout en gardant des valeurs LLR toutes positives). Pour cela, on peut considérer la définition ci-dessous où l'on applique la valeur absolue aux valeurs de LLR calculées en utilisant le symbole le plus fiable comme symbole de référence. Pr(adlfl) LLR(al) = 11n( male)) I, avec ad = arg max[Pr(ailp) ; i = 0, ..., a - Ainsi le symbole le plus fiable est celui qui possède la valeur LLR la plus petite, à savoir la valeur O. Cela permet, par exemple lorsque les valeurs de LLR sont codées sur 5 bits, de s'assurer que la plus petite valeur de LLR est égale à la borne inférieure de la plage de valeurs positives représentée avec 5 bits (de 0 à 31). A l'inverse, si l'on travaille avec des valeurs positives et négatives de LLR, tout en codant ces valeurs sur 5 bits, la dynamique des LLR risque d'être moins bien représentée, étant donné que les valeurs extrêmes de LLR n'auront pas nécessairement été normalisées pour correspondre à l'une des bornes de la plage représentée avec 5 bits (de -15 à 16 par exemple) Ainsi, dans le corps de Galois GF(4), si les 4 probabilités des éléments cro, a1, a2 et a3 LLR nous donne : sont respectivement (0.2 ; 0.5 ; 0.29 ; 0.01), la première définition du LLR1 = ( log(0.2/0.2), log(0.5/0.2), log(0.29/0.2), log(0.01/0.2)) = (0 0.9163 0.6678 -2.9957). La deuxième définition nous donne : LLR2 = ( log(0.2/0.01), log(0.5/0.01), log(0.29/0.01), log(0.01/0.01)) = 5 (2.9957 3.9120 3.6636 0) (on passe de LLR1 à LLR2 en ajoutant un facteur constant de 2.9957) La troisième définition nous donne : LLR3 = ( log(0.5/0.2), log(0.5/0.5), log(0.5/0.029), log(0.5/0.01)) = (0.9163 0 0.2485 3.9120). 10 Les traitements de données au sein du processeur noeud de parité (110) peuvent être effectués conformément à l'algorithme dit « forward-backward », selon lequel un noeud de parité de degré dcest décomposé en 3. (dc - 2) noeuds de parité dits élémentaires (en anglais, « Elementary Check Node », ou « ECN »), chaque noeud de parité élémentaire recevant en entrée deux messages U et V et générant 15 en sortie un message E. La figure 2c montre un exemple d'architecture d'un processeur de noeud de parité (120) de degré d, égal à 6, comprenant 12 noeuds de parité élémentaires (121-132). Le processeur noeud de parité (120) reçoit en parallèle 6 messages V2C = 1 ... 6, et génère 6 messages de sortie C2Vi, i = 1 ... 6. 20 Chaque noeud de parité élémentaire effectue un test de parité sur ses messages d'entrée U et V pour générer un message de sortie représentant les combinaisons des messages d'entrée ayant la meilleure vraisemblance. Par exemple, dans le cas où la vraisemblance est représentée par une valeur de LLR telle que définie ci-dessus, le message de sortie E d'un noeud de parité élémentaire 25 sera obtenu par la relation suivante : E(x) = minxi,EGF(q),x,EGF(0{Kxu) + V(xv)}xueDr,-x (Eq. 1) La figure 3a illustre un noeud de parité (150a) d'un décodeur binaire. Le noeud de parité reçoit deux messages en entrée, et génère un message de sortie, qui correspond à la somme des valeurs des messages en entrée. Par souci de 30 simplification de l'exposé, on ne considère pas ici les valeurs de vraisemblance. Les messages (ou variables) d'entrée, notées U2 et V2, et le message (ou la variable) de sortie, notée E2, sont à valeurs dans GF(2), illustré sur la figure par le couple de valeurs {0,1}. Les deux combinaisons en entrée (0,0) et (1,1) produisent la valeur de sortie « 0 », conformément à la loi d'addition usuelle dans GF(2), tandis que les deux combinaisons en entrée (0,1) et (1,0) produisent la valeur de sortie « 1 ». La figure 3b illustre un noeud de parité élémentaire (150b) d'un décodeur non-binaire dont les données d'entrée et de sortie sont à valeurs dans le corps de Galois GF(64). Les variables d'entrée, notées U64 et V64, et la variable de sortie, notée E64, sont à valeurs dans un corps de Galois d'ordre 64 (noté GF(64)), illustré sur la figure par l'ensemble de valeurs {0,1, ..., 63}. La variable de sortie étant à valeurs dans GF(64), il y a 64 combinaisons en entrée valides pour chacune des 64 valeurs de sortie déterminées en fonction de la loi d'addition choisie dans GF(64). Ce qui précède peut être généralisé à un noeud de parité élémentaire d'un décodeur non-binaire dont les deux variables d'entrée Uq et Vq et la variable de sortie Eq sont à valeurs dans un corps de Galois d'ordre q, noté GF(q). Pour chacune des q valeurs possibles de la variable de sortie Eq déterminées en fonction de la loi d'addition choisie dans GF(q), il y a q combinaisons des variables d'entrée Uq et Vq. Par ailleurs, l'opération effectuée au sein du noeud de parité élémentaire ne se limite pas à l'addition. La figure 3c illustre un noeud de parité élémentaire (150c) dont les deux variables d'entrée Uq et Vq et la variable de sortie Eq sont à valeurs dans un corps de Galois d'ordre q, noté GF(q). La variable de sortie est liée aux valeurs d'entrée par une relation de parité, notée cf), de sorte que l'on a Eq = (p(Uq,V).

En référence aux figures 2b et 2c, le processeur noeud de parité (110), (120) reçoit en parallèle d, messages en entrée V2Ci,j, = 1 ... d, , effectue sur ces variables d'entrée un test de parité correspondant à l'équation Eq. 1 énoncée ci-dessus, et génère d, messages de sortie C2Vi, i = 1 ... d, respectivement transmis aux processeurs noeuds de variable VNi,j, = 1 ... d, (111), (112), et (113) correspondant.

Comme illustré à la figure 3c, le traitement des messages d'entrée au sein du processeur (110) peut être décomposé sur trois couches de traitement comprenant chacune d, - 2 noeuds de parité élémentaires (121-132). Chaque noeud de parité élémentaire (121-132) reçoit deux messages U et V contenant chacun q couples (symbole à valeurs dans GF(q), valeur de vraisemblance associée au symbole) et génère un message de sortie E contenant les q meilleures combinaisons des valeurs des deux messages d'entrée U et V, c'est-à-dire celles ayant la plus forte vraisemblance. Dans un mode de réalisation, le message E est défini par l'équation Eq. 1 ci-dessus. Cette équation correspond à l'extraction de q valeurs minimum dans la matrice, notée TE, des valeurs sommes, définie par TE[i,j] = U[i] + V[j] pour (i;j) E {0, ..., q - 1}2. Les plus petites sommes des valeurs logarithmiques de vraisemblance permettent en effet d'identifier les composantes dans GF(q) ayant la plus forte vraisemblance.

L'algorithme EMS (« Extended Min Sum ») préconise de limiter la recherche de ces valeurs minimum aux nm meilleurs symboles dans les messages entrants d'un noeud de parité élémentaire pour calculer les valeurs du message de sortie, avec nm « q. On peut alors considérer une représentation des messages d'entrée et de sortie par des vecteurs de taille nm notés respectivement U[k], V[k], et E[k].

Dans un mode de réalisation, les valeurs du message de sortie peuvent être obtenues en sélectionnant les nm plus petites valeurs parmi les Tl m 2 sommes des nm valeurs du premier message d'entrée et des nm valeurs du second message d'entrée. Cette étape de sélection de nm valeurs parmi celles calculées à partir des valeurs des messages d'entrée peut être illustrée par un tableau représentant la matrice TE, de taille nm x nm, dont les éléments TE[i,j] sont déterminés par la somme des valeurs U[i] et V[j] des messages d'entrée : TE[i,j] = U[i] + V[j] pour (i;j) E {0, ...,nm - 1}2. En outre, les valeurs de fiabilité des messages d'entrée U et V sont ordonnées dans l'ordre décroissant de fiabilité, la valeur U[0] (respectivement V[0]) correspondant à la meilleure fiabilité et la valeur U[nm] (respectivement V[nm]) à la moins bonne. Lorsque les valeurs de fiabilité correspondent à des logarithmes de rapport de vraisemblance LLR, ces valeurs sont donc ordonnées dans l'ordre croissant, la plus faible valeur de LLR représentant la meilleure fiabilité. Dans ce cas, l'algorithme EMS de mise à jour des noeuds de parité élémentaires propose un procédé itératif d'exploration des candidats de la matrice TE afin de sélectionner les nm plus petites valeurs de sortie et ainsi déterminer les valeurs du vecteur E[k] correspondant au message de sortie du noeud. Cet algorithme EMS comprend une première phase d'initialisation qui consiste à introduire les valeurs de la première colonne de TE dans un trieur de taille nm. La plus petite valeur dans le trieur est ensuite calculée et recopiée dans le vecteur E[k] de sortie. La valeur extraite du trieur et recopiée dans le vecteur de sortie est alors remplacée par son voisin de droite dans la matrice TE , qui est introduit dans le trieur. Une nouvelle itération du processus est alors effectuée en calculant la plus petite valeur dans le trieur. Pour illustrer les principes de l'algorithme EMS sur un exemple, on considère l'exemple de deux vecteurs d'entrée U64 et V64 de taille rim = 8. On suppose ainsi que l'on a dans une étape préliminaire extrait les 8 composantes parmi les 64 composantes correspondant aux valeurs possibles d'un symbole de chaque message d'entrée à valeurs dans GF(64) ayant les meilleures valeurs de vraisemblance. On suppose en outre que ces 8 meilleures LLRs pour U64 et V64 sont données par : U64 = (0,1,2,3,3,4,5,5) et V64 = (0,0,1,2,4,4,5,6). Le tableau suivant illustre les 64 candidats déterminés en fonction des vecteurs U64 et V64 : (0) (1) (2) (3) (3) (4) (5) (5) (0) 0 1 2 3 3 4 5 5 (0) 0 1 2 3 3 4 5 5 (1) 1 2 3 4 4 5 6 6 (2) 2 3 4 5 5 6 7 7 (4) 4 5 6 7 7 8 9 9 (4) 4 5 6 7 7 8 9 9 (5) 5 6 7 8 8 9 10 10 (6) 6 7 8 9 9 10 11 11 L'algorithme EMS de mise à jour des noeuds de parité élémentaires est décrit ci-après pour les exemples U64 et V64 donnés ci-dessus, pour lesquels rim est choisi égal à 8.

La mise en oeuvre de cet algorithme peut utiliser un trieur, c'est-à-dire un ensemble de rim registres mémoire dans lesquels sont consignés les rim candidats qui constituent un ensemble S de sélection à partir duquel un candidat est sélectionné, extrait du trieur puis remplacé par un autre candidat à chaque cycle itératif de l'algorithme.

La phase d'initialisation consiste comme indiqué ci-dessus à sélectionner les valeurs de la première colonne de TE, comme illustré sur le tableau ci-dessous : (0) (1) (2) (3) (3) (4) (5) (5) (0) 0 1 2 3 3 4 5 5 (0) 0 1 2 3 3 4 5 5 (1) 1 2 3 4 4 5 6 6 (2) 2 3 4 5 5 6 7 7 (4) 4 5 6 7 7 8 9 9 (4) 4 5 6 7 7 8 9 9 (5) 5 6 7 8 8 9 10 10 (6) 6 7 8 9 9 10 11 11 On détermine ainsi les éléments initiaux de l'ensemble S de sélection de taille rim avec les éléments {TE(0, j)lj = 0, ..., nm - 1}. Dans une variante permettant de diminuer les calculs nécessaires, les calculs des valeurs de TE n'ont pas été effectués au préalable, et cette phase d'initialisation comprend la détermination de chacun des éléments {TE(0, j)lj = 0, ..., nm - 1} et leur mise en mémoire dans le trieur. Elle consomme donc rim cycles de calcul. A l'issue de cette phase d'initialisation, les rim registres mémoire du trieur qui contiennent les valeurs de sélection contiennent donc les valeurs calculées de la première colonne de TE : Trieur = 0 0 1 2 4 4 5 6 Une première itération de boucle de calcul est ensuite engagée en extrayant le plus petit élément de l'ensemble S, puis en le remplaçant dans cet ensemble de sélection par le plus petit élément de la ligne de la matrice TE sur lequel l'élément extrait se trouvait. Dans l'exemple considéré, on extrait ainsi pour cette première itération l'élément TE(0,0) puis on le remplace par l'élément TE(0,1) que l'on calcule, si ce calcul n'a pas déjà été effectué. L'ensemble S est donc mis à jour et devient S = {TE(1, 0); TE(0, j) pour j = 1; ...; nm - 1} = {1 ; 0 ; 1 ; 2 ; 4 ; 4 ; 5 ; 6}. On a en outre E[0] = T1(0,0), soit E = (TI(0,0);x;x;x;x;x;x;x). L'algorithme reboucle et effectue une deuxième itération d'extraction et de remplacement dans l'ensemble S. L'élément extrait est TE(0,1) , qui est remplacé par TE(1,1). S est mis à jour et devient ITE(1,0); TE(1, 1); TE(0, j) pour j = 2; ... ; nm - 1} = {1 ;1 ;1 ;2 ;4 ;4 ;5 ;6}. On a en outre E[1] = T1(0,1), soit E = (T1(0,0); TI(0,1);x;x;x;x ;x;x).

Lors d'une troisième itération d'extraction et de remplacement dans l'ensemble S, l'élément TE(1,0) est extrait de S, et est remplacé par TE(2,0).S devient {TE(2, 0); TE(1,1); TE(0, j) pour j = 2; ... ; nm - 1} = {2 ;1 ;1 ;2 ;4 ;4 ;5 ;6}. On a en outre E[2] = T1(1,0) soit E = (T1(0,0); T1(0,1); TI(1,0);x;x;x;x;x). Lors d'une quatrième itération d'extraction et de remplacement dans i.o l'ensemble S, l'élément TE(1,1) est extrait de S, et est remplacé par TE(2,1). S devient {TE(2,0); TE(2,1); TE(0, j) pour j = 2; ...; nm - 1} = {2 ;2 ;1 ;2 ;4 ;4 ;5 ;6}. On a en outre E[3] = T1(1,1) soit E = (T1(0,0); T1(0,1); T1(1,0); Tx(1,1);x;x;x;x). Lors d'une cinquième itération d'extraction et de remplacement dans l'ensemble S, l'élément TE(0,2) est extrait de S, et est remplacé par TE(1,2). S 15 devient {TE(2,0); TE(2,1); TE(1,2); TE(0, j) pour j = 3; ... ;nm - 1} = {2 ;2 ;2 ;2 ;4 ;4 ;5 ;6}. On a en outre E[4] = Tx(0,2), soit E = (T1(0,0); T1(0,1); T1(1,0); Tx(1,1); Tx(0,2);x;x;x). Lors d'une sixième itération d'extraction et de remplacement dans l'ensemble S, l'élément TE(2,0) est extrait de S, et est remplacé par TE(3,0). S devient 20 ITE(3, 0); TE(2,1); TE(1,2); TE(0, j) pour j = 3; ... ; nm - 1} = {3 ;2 ;2 ;2 ;4 ;4 ;5 ;6}. On a en outre E[5] = T1(2,0), soit E = (T1(0,0); T1(0,1); T1(1,0); T1(1,1); T1(0,2); TI(2,0);x ;x). Lors d'une septième itération d'extraction et de remplacement dans l'ensemble S, l'élément TE(2,1) est extrait de S, et est remplacé par TE(3,1). S 25 devient {TE(3,0); TE(3,1); TE(1,2); TE(0, j) pour j = 3; ... ;nm - 1} = {3 ;3 ;2 ;2 ;4 ;4 ;5 ;6}. On a en outre E[6] = T1(2,1), soit E = (T1(0,0); T1(0,1); T1(1,0); Tx(1,1); T1(0,2); T1(2,0); Tx(2,1);x). La recherche se termine par l'extraction d'une nm-ième valeur dans l'ensemble S, la valeur extraite étant choisie comme précédemment comme la plus 30 petite valeur de l'ensemble S. L'élément TE(1,2) est ainsi extrait de S, et on a E[7] = TE(1,2) soit E = (T1(0,0); T1(0,1); T1(1,0); T1(1,1); T1(0,2); T1(2,0); T1(2,1); T1(1,2)). Le vecteur résultat de taille nm est ainsi déterminé après nm itérations du cycle de recherche et 2 x rim cycles de calcul. L'algorithme Bubble-Check permet de réduire la complexité des calculs de mise à jour des noeuds de parité élémentaires en comparaison avec l'algorithme EMS. Il exploite les propriétés suivantes des éléments de la matrice TE , dans le cas où les listes d'entrée sont ordonnées selon la valeur de LLR dans l'ordre croissant: Vj E [1, rim]et i < i', alors TE(i, j) < TE(i', j) et Vi E [1,nm]etj < j', alors TE(i, j) < TE(i, j') Pour en tirer les trois conséquences principales suivantes : - Il est possible d'exclure a priori un sous-ensemble des éléments de la matrice TE, ce qui revient à exclure une partie de la zone d'exploration de cette matrice ; - La taille de l'ensemble de sélection S peut être réduite, par exemple d'un facteur 2 ; - Des parcours prédéfinis de sélection des remplaçants de chacun des éléments de l'ensemble S initial (appelés « bulles ») peuvent être déterminés. L'algorithme L-Bubble Check apporte une amélioration à l'algorithme Bubble Check en définissant quatre parcours des « bulles » limités aux deux premières lignes et deux premières colonnes de la matrice , comme illustré sur la figure 4. Cela permet de limiter l'espace de recherche des minimums à 3 x rim combinaisons.

Pour reprendre l'exemple précédent, on considère ainsi un ensemble de sélection S' de taille nm = n'n = 4. Le sous-ensemble Excl d'éléments de la matrice 2 TE défini par Excl = {TE(i; j) pour (i; j) = {2, ... , nm - 1}2} est exclu de la zone d'exploration de la matrice TE , c'est-à-dire qu'il est déterminé au préalable qu'aucun des éléments de cette zone ne sera un candidat susceptible d'être intégré à l'ensemble de sélection S. La phase d'initialisation de l'algorithme EMS est reprise, mais avec cet ensemble de sélection deux fois plus petit. On constitue ainsi un ensemble S' de sélection de taille nm/2 en calculant les éléments {TE(i3O)1i = 0, ...,nm' - 1}.30 La phase d'initialisation consiste comme indiqué ci-dessus à sélectionner les nm' valeurs de la première colonne de TE, comme illustré sur le tableau ci-dessous : (0) (1) (2) (3) (3) (4) (5) (5) (0) 0 1 2 3 3 4 5 5 (0) 0 1 2 3 3 4 5 5 (1) 1 2 3 4 4 5 6 6 (2) 2 3 4 5 5 6 7 7 (4) 4 5 6 7 7 8 9 9 (4) 4 5 6 7 7 8 9 9 (5) 5 6 7 8 8 9 10 10 (6) 6 7 8 9 9 10 11 11 Ces nm valeurs constituent les « bulles » de l'algorithme L-Bubble-Check. Dans l'exemple ci-dessus, l'ensemble S' est donc initialisé à S' = {0; 0; 1; 2}. Le sous-ensemble Excl d'éléments de la matrice TE défini par Excl = {T (i; j) pour (i; j) = {2, ...,nen, - 1}2} (204) est exclu de la zone de parcours de la matrice TE, et on a prédéfini nm = 4 parcours (P (200, 201, 202, 203) de remplacement après extraction des éléments de S', le premier élément de chaque parcours prédéfini correspondant respectivement aux 4 éléments de l'ensemble S' initial. En référence à la figure 4, le premier élément TE(0,0) de l'ensemble S initial est aussi le premier élément d'un parcours horizontal (200) défini par le sous- ensemble P0 = {TE(0; j) pour j = {0, ..., nen, - 1}}, le deuxième élément TE(1,0) de l'ensemble S initial est aussi le premier élément d'un parcours horizontal (201) défini par le sous-ensemble P1 = {TE(1; j) pour j = {0, nm - 1}}, le troisième élément TE(2,0) de l'ensemble S initial est aussi le premier élément d'un parcours (202) défini par le sous-ensemble P2 = {TE(2; 0) u TE(i; 1) pour i = {2, ..., nm - 1}}, et le quatrième élément TE(3,0) de l'ensemble S initial est aussi le premier élément d'un parcours (203) vertical défini par le sous-ensemble P3 = {TE(i; 0) pour i = 30162 5 9 20 {n;n - 1, , nm - 1}}. On notera que les quatre parcours (P (200, 201, 202, 203) illustrés sur la figure 4 sont défini à l'intérieur de la zone non exclue du parcours, la zone exclue (204) correspondant au sous-ensemble Excl = {TE(i; j) pour (i; j) = 5 {2, ...,8}2}. Une première itération de boucle de calcul est ensuite engagée en extrayant le plus petit élément de l'ensemble S', puis en le remplaçant dans cet ensemble de sélection par l'élément immédiatement voisin de l'élément extrait dans le parcours de la matrice TE correspondant à l'élément extrait. Pour ce faire, on 10 peut par exemple calculer l'adresse de l'élément remplaçant dans l'ensemble S' conformément au parcours prédéfini correspondant à l'élément extrait de S', calculer la valeur de l'élément remplaçant en fonction de son adresse, puis mettre à jour l'ensemble S' avec l'élément remplaçant. Dans l'exemple considéré, on extrait ainsi pour cette première itération 15 l'élément TE(0,0), on calcule l'adresse de l'élément remplaçant selon le parcours P0 = {TE(0; j) pour j = {0, ...,nm - 1}}, ce qui conduit à l'adresse de l'élément TE(0,1) que l'on calcule. L'ensemble S' est ensuite mis à jour et devient S' = {TE(0, 1); TE(i, 0) pour i = 1; ...;n;n - 1} = {1 ; 0 ; 1 ; 2}. On a en outre C[0] = T1(0,0), soit C = (Tx(0,0);x;x;x;x;x;x;x) = (0;x;x;x;x;x;x;x). 20 L'algorithme reboucle et effectue une deuxième itération d'extraction et de remplacement dans l'ensemble S'. On extrait un plus petit élément de l'ensemble S', et dans l'exemple considéré l'élément extrait est TE(1,0). Le parcours correspondant à cet élément est P1 = {TE(1; j) pour j = {0, ...,nm - 1}}. On calcule donc l'adresse de l'élément voisin de l'élément extrait TE(1,0) selon ce parcours, ce qui conduit à l'élément TE(1,1), que l'on calcule. S' est mis à jour avec la valeur calculée et devient {TE(0,1); TEM 1); TE(i, 0) pour i = 2; ...; nm' - 1} = {1 ;1 ;1 ;2}. On a en outre C[1] = T1(1,0), soit C = (T1(0,0); TI(1,0);x;x;x;x;x;x) = (0; 0;x;x;x;x;x;x). Lors d'une troisième itération d'extraction et de remplacement dans l'ensemble S', l'élément TE(0,1) est extrait de S'. Le parcours correspondant à cet élément est P0 = {TE(0; j) pour j = {0, ...,nm - 1}}. On calcule donc l'adresse de l'élément voisin de l'élément extrait TE(0,1) selon ce parcours, ce qui conduit à l'élément TE(0,2), que l'on calcule. S' devient {TE(0, 2); TE(1,1); TE(i, 0) pour i = 2; ...; n;n - 1} = {2 ;1 ;1 ;2}. On a en outre C[2] = T1(0,1) soit = (Tx(0,0); Tx(1,0); Tx(0,1);x;x;x;x;x) = (0; 0; 1;x;x;x;x;x). Lors d'une quatrième itération d'extraction et de remplacement dans l'ensemble S', l'élément TE(1,1) est extrait de S'. Le parcours correspondant à cet élément est P1 = {TE(1; j) pour j = {0, ..., nm - 1}}. On calcule donc l'adresse de l'élément voisin de l'élément extrait TE(1,1) selon ce parcours, ce qui conduit à l'élément TE(1,2), que l'on calcule. S' devient {TE(0,2);TE(1,2); TE(i, 0) pour i = 2; ...; n;72 - 1} = {2 ;2 ;1 ;2}. On a en outre C[3] = 71(1,1) soit C = (Tx(0,0); T1(0,1); Tx(1,0); Tx(1,1);x;x;x;x) = (0; 0; 1; 1;x;x;x;x). Lors d'une cinquième itération d'extraction et de remplacement dans l'ensemble S', l'élément TE(2,0) est extrait de S'. Le parcours correspondant à cet élément est P2 = {TE(2; 0) u TE(i; 1) pour i = {2, ... , nm - 1}}. On calcule donc l'adresse de l'élément voisin de l'élément extrait TE(2,0) selon ce parcours, ce qui conduit à l'élément TE(2,1), que l'on calcule. S' devient {TE(0,2);TE(1,2);TE(2,1); TE(i, 0) pour i = 3; ...; n;' - 1} = {2 ;2 ;2 ;2}. On a en outre C[4] = 71(2,0) soit C = (71(0,0); 71(0,1); T1(1,0); T1(1,1); TI(2,0);x;x;x) = (0; 0; 1; 1; 1;x;x;x). Lors d'une sixième itération d'extraction et de remplacement dans l'ensemble S', l'élément TE(0,2) est extrait de S'. Le parcours correspondant à cet élément est à nouveau P0 = {TE(0; j) pour j = {0, ...,rim - 1}}. On calcule donc l'adresse de l'élément voisin de l'élément extrait TE(0,2) selon ce parcours, ce qui conduit à l'élément TE(0,3), que l'on calcule. S' devient {TE(0,3); TE(1,2); TE(2,1); TE(i, 0) pour i = 3; ...; n;,,, - 1} = {3 ;2 ;2 ;2}. On a en outre C[5] = 71(0,2) soit C = (71(0,0); 71(0,1); T1(1,0); T1(1,1); T1(2,0); Tx(0,2);x;x) = (0; 0; 1; 1; 1; 2;x;x).

Lors d'une septième itération d'extraction et de remplacement dans l'ensemble S', l'élément TE(1,2) est extrait de S'. Le parcours correspondant à cet élément est à nouveau P1 = {TE(1; j) pour j = {0, ...,rim - 1}}. On calcule donc l'adresse de l'élément voisin de l'élément extrait TE(1,2) selon ce parcours, ce qui conduit à l'élément TE(1,3), que l'on calcule. S' devient ITE(0,3); TE(1, 3); TE(2,1); TE(i, 0) pour i = 3; ...; n;,, - 1} = {3 ;3 ;2 ;2}. On a en outre C[6] = 71(1,2) soit C = (71(0,0); 71(0,1); T1(1,0); T1(1,1); T1(2,0); T1(0,2); TI(1,2);x) = (0; 0; 1; 1; 1; 2; 2;x). La recherche se termine par l'extraction d'une nm-ième valeur dans l'ensemble S', la valeur extraite étant choisie comme précédemment comme la plus petite valeur de l'ensemble S'. L'élément TE(2,1) est ainsi extrait de S', et on a C[7] = TE(2,1) soit C = (T1(0,0); T1(0,1); T1(1,0); T1(1,1); T1(2,0); T1(0,2); T1(1,2); TE(2,1)) = (0; 0; 1; 1; 1; 2; 2; 2). Le vecteur résultat de taille nm est ainsi déterminé après nm itérations du cycle de recherche et 2 x nm cycles de calcul. La figure 5a illustre un exemple de mise en oeuvre de l'algorithme proposé sur la même matrice que celle de la figure 4.

Dans un mode de réalisation, le procédé proposé définit une zone d'exclusion de parcours d'exploration de la matrice, un ensemble de sélection S" de taille 4x nm - 4, et un parcours d'exploration de la matrice pour chacun des éléments de l'ensemble de sélection. On considère le cas d'un noeud de parité élémentaire d'un décodeur LDPC non binaire, qui reçoit deux messages U et V en entrée et génère un message E en sortie. Les symboles des mots de code ainsi que les valeurs non nulles de la matrice de parité du décodeur LDPC appartiennent au corps de Galois GF(q), et chaque message d'entrée contient nm couples (symbole, fiabilité). Comme décrit ci-dessus, la fiabilité associée à un symbole dans un message est représentée par un rapport de vraisemblance logarithmique LLR à valeurs positives. Les éléments de chaque message d'entrée sont en outre ordonnés selon leur valeur de vraisemblance, par exemple en ordre croissant avec le premier élément correspondant au symbole le plus vraisemblable. On a ainsi deux messages d'entrée U et V, avec U = [U(0), ..., U(nm - 1)] et V = [V(0), ..., V(nm - 1)] où les U(i) et V(i) sont des couples U(i) = ULR) et V(i) = (Vb, VAR) avec II.FeGF(q) , VbeGF(q) , et ULR et VAR sont les LLR normalisés associés aux symboles UDF et Vb, respectivement. Les valeurs ULR et VAR vérifient respectivement : UAR = 0 et ULR 0, i = 1, ... Jim , et TIR = 0 et VIi,LR = 1, --- ,nin- Dans ce mode de réalisation, le paramètre nm est choisi inférieur à l'ordre q du corps de Galois considéré. Il sera de préférence choisi très inférieur à cet ordre (nm « g), pour satisfaire notamment les contraintes de complexité des calculs de décodage. 30162 5 9 23 La recherche des valeurs vérifiant l'équation de parité Eq. 1 énoncée ci-dessus est limitée aux nm meilleurs symboles dans les messages entrants, pour générer un message de sortie sous la forme d'un vecteur E de taille nm. On considère là encore un ensemble de sélection, noté S, de taille nm > n'n2 dans le cas 5 OÙ nm est pair, et nm > nm1 dans le cas contraire. On pourra par exemple choisir nm 2 pair (par exemple égal à 8 lorsque q est égal à 64), et nm égal à 1-1722 pour minimiser l'occupation mémoire de l'ensemble de sélection S. Le sous-ensemble Excl d'éléments de la matrice TE défini par Excl = {TE(i; j) pour (i; j) = {tn7 , ...,nm - 1}2} est exclu de la zone d'exploration de la matrice TE , c'est-à-dire qu'il est déterminé au 10 préalable qu'aucun des éléments de cet ensemble ne sera un candidat susceptible d'être intégré à l'ensemble de sélection S. La définition de cette zone d'exclusion permet de rendre les parcours définis pour les éléments de l'ensemble de sélection aussi courts que possible, étant donné que ces parcours sont définis en dehors de cette zone d'exclusion. Ces parcours 15 doivent couvrir chacun des éléments de la matrice TE qui n'appartient pas au sous- ensemble d'éléments exclus Excl. Dans ce mode de réalisation, les éléments initiaux de l'ensemble de sélection sont choisis de telle sorte que des parcours unidirectionnels puissent être définis pour chacun d'entre eux. 20 De cette manière, on s'assure que les éléments de chaque parcours sont déjà triés (soit dans le sens horizontal, soit dans le sens vertical), alors que ce n'était pas le cas dans l'exemple précédent du L-Bubble Check. On définit donc une partition de la zone d'exploration de la matrice TE en quatre sous-espaces Si, S2, S3 et S4, comme illustré sur la figure 5b. Chacun de ces sous-espaces correspond à un 25 parcours illustré sur la figure 5a. On voit donc que pour 4 bulles on aura deux parcours horizontaux (210, 211) et deux parcours verticaux (212, 213). Du fait que les valeurs des LLRs des messages d'entrée sont déjà ordonnées (par ordre croissant), les éléments de ces parcours, qui sont soit uniquement horizontaux, soit uniquement verticaux, sont aussi ordonnés. 30 On définit ainsi quatre sous-ensembles (Sk)k=1 .... d'éléments de la matrice TE qui correspondent chacun respectivement un parcours d'exploration de celle-ci. La figure 5b illustre ces quatre sous-ensembles dans le cas d'une matrice TE carrée de taille 12. Dans un mode de réalisation, les quatre sous-ensembles (Sx)k-i ..... 4 sont définis par les équations suivantes : = [U(0) + V(/); / E {0, - 1}] S2 = [V(0) + U(/); l E {1, , nm - 1}] 53 = [U(1) + V(/); l E {1, , nm - 1}] 54 = [V(1) + U(/); l E {2, ... , nm - 1}] Les quatre parcours d'exploration de la matrice TE comprennent 4 x (rim - 1) positions dans la matrice.

Dans un autre mode de réalisation du procédé proposé, illustré par les figures 6a et 6b, les quatre sous-ensembles (Sx)k-i .... ,4 auxquels sont respectivement associés des parcours des « bulles », sont définis par les équations suivantes : = [U(0) + V(/); / E {0, nm - 1}] S2 = [V(0) + U(/); l E {1, , nm - 1}] S3 = [U(1) + V(/); / E ...,-n2m - S4 = [V(1) + U(/); l E 12, - 11] Les quatre parcours d'exploration de la matrice TE comprennent 3.rim - 4 positions dans la matrice, de sorte que l'espace d'exploration est encore plus réduit. La figure 7 illustre un algorithme d'exploration (300) de la matrice TE selon un mode de réalisation particulier. Les candidats pour être sélectionné après comparaison, soit, pour reprendre la terminologie utilisée ci-dessus, les éléments de l'ensemble de sélection, sont notés dans la suite c1, c2, c3, et c4.

Les valeurs des éléments de l'ensemble de sélection sont initialisées (301) aux valeurs initiales des sous-ensembles (Sk)k=1 .. 4, qui correspondent aux éléments initiaux des parcours qu'ils définissent respectivement: c1 = S1(0), c2 = S2(0), c3 = S3(0), c4 = S4(0). Un ensemble de valeurs E correspondant au message de sortie est initialisé avec des valeurs prédéterminées. Un indice k de boucle est en outre initialisé, par exemple à la valeur 1 : k = 1. Une itération de l'algorithme est ensuite effectuée, avec la sélection (303) d'une valeur, notée C , parmi les valeurs de c1, c2, c3, et c4. Comme expliqué précédemment, les éléments c1, c2, c3, et c4 peuvent être des couples (symbole, fiabilité), auquel cas la sélection est effectuée sur la base d'un critère de valeur de la fiabilité. Autrement dit, sélectionner C e) revient à sélectionner le couple le plus fiable parmi les couples de l'ensemble de sélection, soit dans cet exemple parmi c1, c2, c3, et c4. Différentes représentations de la fiabilité peuvent être adoptées, parmi lesquelles des rapports de vraisemblance logarithmique LLRs tels que définis ci- dessus. Dans ce cas, la sélection de C e) peut consister à sélectionner le ci associé à la plus petite valeur de LLR. En variante, les éléments c1, c2, c3, et c4 manipulés par l'algorithme peuvent directement correspondre à une valeur de fiabilité, par exemple une valeur de LLR. Le message de sortie E est ensuite mis à jour (304) avec la valeur sélectionnée : E = E u {cs(k)}. L'ensemble de sélection est ensuite mis à jour (305) en remplaçant la valeur de l'élément ci sélectionné par la valeur suivante dans le sous-ensemble Si correspondant. Par exemple, si le couple sélectionné C' s(k) correspondait à l'élément Ss(m) du sous-ensemble (autrement dit du parcours) correspondant Ss, cet élément est remplacé dans l'ensemble de sélection par la valeur ou le couple de valeur correspondant à Ss(m + 1). L'indice k de boucle d'itération est ensuite comparé (306) à la valeur nm afin de vérifier si l'on effectué ou non nm itérations. Dans le cas où moins de nm itérations ont été effectuées, l'indice de boucle k est incrémenté (308) et une nouvelle itération est engagée. Dans le cas contraire, l'algorithme se termine (307). Dans un autre mode de réalisation (non représenté sur la figure 7), la sélection (303) de la meilleure valeur de fiabilité ou du couple ayant la meilleure fiabilité c..k) comprend la vérification que le candidat pour être sélectionné parmi l'ensemble des {ci} ne figure pas déjà dans l'ensemble des valeurs ou des couples précédemment sélectionnés. Si C e) figure déjà dans l'ensemble E, il n'est pas à nouveau sélectionné et est écarté en étant marqué comme candidat non valide. Le marquage d'un candidat avec le statut non valide peut être effectué de diverses manières. Par exemple, lorsque l'algorithme manipule des couples (symbole, fiabilité représentée par un LLR), la valeur LLR du couple que l'on souhaite marquer comme non valide peut être forcée à une valeur très faible, par exemple proche de ou égale à zéro. Le forçage à 0 de la valeur de LLR permet de s'assurer que l'algorithme génère une sortie triée. Autrement, puisqu'un noeud de parité élémentaire est susceptible de générer des couples non valides, un autre noeud de parité élémentaire (par exemple, en référence à la figure 2c, un noeud d'une couche inférieure) recevant ces couples comparera des couples valides avec des couples non valides. Afin de simplifier les traitements, on considère que les couples non valides sont valides pour effectuer la comparaison de l'algorithme. Par exemple, si l'on compare à une itération de l'algorithme donnée les valeurs correspondant respectivement aux valeurs des sous-ensembles S1(m1),S2(m2),S3(m3) et S4(m4), dans lesquels S3(m3) est un couple non valide, et le couple S2(m2) a la meilleure fiabilité (par exemple la plus petite valeur de LLR) parmi les quatre candidats S1(m1),S2(m2),S3(m3) et S4(m4), le noeud ECN sélectionnera et inclura dans l'ensemble de sortie le couple S2(m2). Cependant, il se peut que le couple S3(m3 + 1) soit valide (en ce sens qu'il n'a jamais encore été sélectionné pour être inclus dans l'ensemble de sortie). Si la valeur de LLR du couple S3(m3) n'est pas forcée à zéro, on ne peut pas être sûr que la fiabilité de S3(m3 + 1) est moins bonne (et donc plus grande en valeur de LLR) que celle de S2(m2). Ainsi, le forçage à 0 de la fiabilité de S3(m3) permet d'écarter le couple S3(m3) de la comparaison à effectuer pour comparer S1(m1),S2(m2),S3(m3 + 1) et S4(m4), au lieu de S1(m1),S2(m2),S3(m3) et S4 /m4)- Dans un autre mode de réalisation (non représenté sur la figure 7), la mise à jour (305) du couple ou de la valeur sélectionnée est aussi accompagnée de la mise à jour, de la même manière que la sélection, de tout couple ou valeur déclarée invalide, afin de minimiser la présence de couples non valides dans le message de sortie du noeud de parité., et ce quand bien même le couple non valide n'est pas celui qui a été sélectionné lors de la comparaison de l'itération en cours. La figure 8 présente un exemple d'architecture de noeud de parité élémentaire pour la mise en oeuvre des algorithmes d'exploration proposés. Cette architecture comporte quatre additionneurs (403a1, 403a2, 403b1, 403b2), quatre registres (406a, 406b, 406c, 406d), quatre mémoires de type FIFO (405a, 405b, 405c, 405d) et un module de comparaison (404). Les éléments des messages d'entrée U et V sont consignées dans des moyens mémoire (401, 402), par exemple de type RAM. Les éléments de chaque message d'entrée U et V sont triés selon leur fiabilité par ordre de fiabilité décroissante. Dans l'exemple représenté sur la figure 8, on considère des valeurs de fiabilité exprimées par des rapport de vraisemblance logarithmiques LLRs, qui sont donc ordonnées par ordre croissant, la plus petite valeur de LLR représentant la fiabilité la plus grande. Les messages d'entrée comportent chacun nm éléments, chaque élément comprenant un couple (symbole, LLR), ordonnés de l'élément ayant la valeur de LLR la plus petite (pour les éléments U(0) et V(0), respectivement) à un élément ayant la valeur de LLR la plus grande (les éléments U(nm) et V(nm), respectivement). Les registres (406a, 406b, 406c, 406d) stockent les éléments U(0), U(1), V(0) et V(1), respectivement. Le noeud de parité élémentaire (400) inclut un module additionneur (403a-403b) configuré pour effectuer, d'une part, les sommes (403a1, 403a2) (dans le corps de Galois GF(q) considéré) de l'élément V(j') issu de la mémoire V (402) et, respectivement, de l'élément U(0) consigné dans le premier registre (406a), et de l'élément U(1) consigné dans le deuxième registre (406b), et, d'autre part, les sommes (403b1, 403b2) (dans le corps de Galois GF(q) considéré) de l'élément U(i') issu de la mémoire U (401) et, respectivement, de l'élément V(0) consigné dans le troisième registre (406c), et de l'élément V(1) consigné dans le quatrième registre (406c). Ce module additionneur (403a, 403b) permet ainsi de générer les éléments des quatre sous-ensembles (Sk)k=1 ..... 4 définis plus haut. Les sorties de chaque additionneur (403a1, 403a2, 403b1, 403b2) de ce module alimentent respectivement quatre mémoires de type FIFO (pour First-ln, First Out) (par exemple, implémentées sous forme de mémoire RAM configurée en 4 piles FIF0s) (405a, 405b, 405c, 405d), qui implémentent donc chacune un des quatre sous-ensembles (Sk)k=1 ..... 4 définis plus haut : la première mémoire FIFO (405a), de taille au moins égale à (nm/2) - 1, recevra des valeurs U(0) + V(j') de l'ensemble S1, la deuxième mémoire FIFO (405b), de taille au moins égale à (nm/2) - 2, recevra des valeurs U(i') + V(0) de l'ensemble S2, la troisième mémoire FIFO (405c), de taille au moins égale à (nm/2) - 2, recevra des valeurs U(1) + V(j') de l'ensemble S3, et la quatrième mémoire FIFO (405d), de taille au moins égale à (nm/2) - 3, recevra des valeurs U(i') + V(1) de l'ensemble 54. Les sorties des quatre mémoires FIFO (405a, 405b, 405c, 405d) alimentent un module de comparaison (404). Dans le mode de réalisation illustré sur la figure, ce module de comparaison comprend 3 comparateurs deux-à-deux (404a, 404b, 404c), deux comparateurs deux-à-deux (404a, 404b) sélectionnant la plus petite valeur de LLR entre les sorties de première et deuxième mémoires FIFO (405a, 405b), et troisième et quatrième mémoires FIFO (405c, 405d), respectivement, et le troisième comparateur (404c) sélectionnant la plus petite valeur de LLR entre les sorties des deux premiers. Les valeurs de sortie du noeud 400 sont produites par ce troisième comparateur deux-à-deux (404c). Le noeud de parité élémentaire comprend en outre une unité de contrôle (407), configurée pour piloter notamment la lecture/écriture des mémoires d'entrée U et V (401, 402) et des mémoires FIFO (405a, 405b, 405c, 405d), le module additionneur (403a, 403b) ainsi que le module de comparaison (404). Les module de comparaison (404) effectue une comparaison et génère un élément du message de sortie E à chaque cycle de calcul de l'unité de contrôle (407), dès lors qu'il y a au moins un élément dans chaque mémoire FIFO (405a, 405b, 405c, 405d). Ainsi, à chaque cycle de calcul, le module de comparaison (404) sélectionne le symbole le plus fiable parmi ses quatre entrées et met à jour le message de sortie E. La mémoire FIFO qui contenait le symbole sélectionné est mise à jour pour présenter en entrée du comparateur (404) un nouveau couple (symbole, LLR) pour la comparaison du cycle suivant. Dans un mode de réalisation, les quatre mémoires de type FIFO reçoivent les valeurs correspondant respectivement aux quatre sous-ensembles correspondant à un parcours d'exploration de la matrice lors de la phase d'initialisation de l'algorithme. Autrement dit, on calcule au préalable les valeurs de chaque sous- ensemble, et on consigne les valeurs pré-calculées dans les mémoires de type FIFO lors de l'initialisation de l'algorithme d'exploration. En variante, on peut ne pré-calculer pour chaque sous-ensemble de sélection qu'un nombre de valeurs correspondant à la taille de la mémoire FIFO correspondante. Par exemple, en reprenant les quatre sous-ensembles (Sk)k=1 .... , auxquels sont respectivement associés des parcours des « bulles » décrits ci-dessus et définis par les équations suivantes : = [U(0) + V(/); / E {0, - 1}] S2 = [V(0) + Ki); l E {1, , nm - 1}] S3 = [U(1) + V(/); / E nn- 11] S4 = [V(1) + Ki); l E 12, ..., z- 11] , on pré-calcule les (nm/2) - 1 premières valeurs de Si_ que l'on consigne dans la première mémoire FIFO (405a) de taille choisie égale à (nm/2) - 1, on pré- calcule les (nm/2) - 2 premières valeurs de S2 que l'on consigne dans la deuxième mémoire FIFO (405b) de taille choisie égale à (nm/2) - 2, on pré-calcule les (nm/2) - 2 premières valeurs de S3 que l'on consigne dans la troisième mémoire FIFO (405c) de taille choisie égale à (nm/2) - 2, et on pré-calcule les (nm/2) - 3 premières valeurs de 54 que l'on consigne dans la quatrième mémoire FIFO (405d) de taille choisie égale à (nm/2) - 3. Ainsi, chaque itération de l'algorithme d'exploration se réduit aux seules comparaisons deux-à-deux pour sélectionner une valeur parmi les premières valeurs de sortie des quatre mémoires FIFO, l'étape de remplacement de la valeur i.o sélectionnée se limitant la mise à jour de l'index de sortie de la mémoire FIFO d'où est issue la valeur sélectionnée. Cette architecture s'avère être plus efficace qu'une architecture dans laquelle les éléments des sous-ensembles correspondant aux parcours prédéfinis des bulles ne sont pas pré-calculés. Cela peut surprendre dans la mesure où l'on effectue plus 15 d'opérations pour le pré-calcul des éléments des sous-ensembles que dans un algorithme dans lequel ces éléments sont calculés au fur et à mesure de l'exécution de l'algorithme d'exploration, pour remplacer un élément sélectionné dans une des mémoires FIF0s. Cette amélioration des performances résulte du fait que la boucle de contrôle de l'algorithme ne comprend plus d'opération de calcul d'élément de 20 remplacement de l'élément sélectionné, mais simplement une mise à jour d'index dans la mémoire FIFO dont il est issu. La boucle de contrôle de l'algorithme dans ce mode de réalisation est donc simplifiée, ce qui donne à l'architecture utilisant des mémoires de type FIFO une efficacité accrue. Le pré-calcul des éléments mis en mémoire FIFO permet en outre de réduire 25 la taille des mémoires utilisées par l'algorithme d'exploration. En effet, on peut, dans un mode de réalisation, ne plus utiliser les mémoires U (401) et V (402), et directement alimenter les mémoires FIFOs lors de la phase de pré-calcul des éléments des parcours de bulle. Bien entendu, l'architecture proposée n'est pas limitée à un mode 30 d'implémentation particulier des mémoires, et en particulier des mémoires FIF0s. Il peut en effet s'agir de moyens mémoire configurés de manière logicielle sous forme de piles de type FIFO, ou tout autre forme de configuration de moyens mémoire pour constituer des piles de type FIFO. La figure 9 illustre un algorithme de mise en oeuvre du procédé proposé 35 (500) correspondant à l'architecture décrite ci-dessus selon un mode de réalisation 30162 5 9 30 particulier. Les valeurs des nbub (nbub E N; nbub > 1) mémoires de type FIFO sont initialisées (501) aux valeurs de sous-ensembles (Sk)k=1 , .... nbub qui correspondent aux éléments de nbUb parcours (de nbUb bulles) qu'ils définissent respectivement. Un 5 indice m de boucle est en outre initialisé (502), par exemple à la valeur 1 : m = 1. Une itération de l'algorithme est ensuite effectuée, avec la sélection (503) d'une valeur, notée Ss(m), parmi les valeurs de sorties des nbub mémoires FIF0s, sur la base d'un critère relatif au degré de fiabilité correspondant. Les éléments consignés en mémoire FIFO peuvent être des couples (symbole, fiabilité), auquel cas sélectionner Ss(m) revient à sélectionner le couple le plus fiable parmi les couples valeurs de sortie de chaque mémoire FIFO. En variante, les éléments consignés en mémoire FIFO peuvent être des valeurs représentant des fiabilités (comme par exemple des rapports de vraisemblance logarithmique LLRs tels que définis ci-dessus) auquel cas la sélection de Ss(m) consiste à sélectionner l'élément de sortie correspondant à la meilleure fiabilité. En fonction de la représentation choisie pour les valeurs de fiabilité, cette sélection pourra consister en une comparaison, par exemple deux-à-deux comme expliqué ci-dessus, des éléments de sortie des mémoires FIFO pour sélectionner, par exemple, l'élément le plus petit. Le message de sortie E est ensuite mis à jour (504) avec la valeur sélectionnée : E = E u {Ss(m)}. L'indice m de boucle d'itération est ensuite comparé (505) à une valeur prédéterminée de fin de boucle itérative mmax, par exemple choisie égale à rim, afin de vérifier si l'on a effectué ou non le nombre maximum prévu d'itérations. Dans le cas où moins de mmax itérations ont été effectuées, l'indice de boucle m est incrémenté (508) et une nouvelle itération est engagée. Dans le cas contraire, l'algorithme se termine (506). L'incrémentation de l'indice d'itération est suivi ou précédé de la mise à jour de l'indice de sortie de la mémoire FIFO dont l'élément Ss(m) est issu. Par exemple, si l'élément Ss(m) sélectionné est issu de la FIFO d'indice k, FIFOk, l'indice de sortie de cette FIFOk est incrémenté de manière à ce que l'élément suivant Ss(m) dans cette FIFO soit pris en compte pour la prochaine itération de l'algorithme. Des modes de réalisation des procédés proposés peuvent être, au moins pour partie, mis en oeuvre sur pratiquement n'importe quel type d'ordinateur, indépendamment de la plate-forme utilisée. Par exemple, comme cela est représenté sur la figure 2a, un système informatique (100), comprend une unité de traitement de données (105), qui comprend un ou plusieurs processeurs, comme une unité centrale (CPU) ou un autre processeur matériel, une mémoire associée (104) (par exemple, une mémoire vive (RAM), une mémoire cache, une mémoire flash, etc.), un dispositif de stockage de données (104) (par exemple, un disque dur, un disque optique comme un CD ou un DVD, une clé de mémoire flash, etc.), et de nombreux autres éléments et fonctionnalités typiques des ordinateurs actuels (non représentés). En général, le système informatique (100) comprend au moins les moyens minimaux de traitement, d'entrée et/ou de sortie nécessaires pour mettre en pratique un ou plusieurs modes de réalisation des procédés proposés. Par exemple, le processeur (105) est apte à être configuré pour exécuter un programme d'ordinateur comprenant des portions de code pour la mise en oeuvre d'un générateur de messages de sortie, configuré pour générer des éléments du message de sortie du noeud de parité mis en oeuvre par le système (100) selon les différents mode de réalisation du procédé proposé. Bien que le noeud de parité élémentaire, et en particulier le générateur de messages de sortie, soient décrit sous la forme d'un logiciel, ils peuvent être mis en oeuvre sous forme matérielle ou sous forme d'une combinaison de matériel et d'instructions logicielles. En fonction du mode de réalisation choisi, certains actes, actions, évènements ou fonctions de chacune des méthodes décrites dans le présent document peuvent être effectués ou se produire selon un ordre différent de celui dans lequel ils ont été décrits, ou peuvent être ajoutés, fusionnés ou bien ne pas être effectués ou ne pas se produire, selon le cas. En outre, dans certains modes de réalisation, certains actes, actions ou évènements sont effectués ou se produisent concurremment et non pas successivement. Bien que décrits à travers un certain nombre d'exemples de réalisation détaillés, le procédé de gestion d'une unité de calcul de noeud de parité proposé et l'unité de calcul pour la mise en oeuvre du procédé comprennent différentes variantes, modifications et perfectionnements qui apparaîtront de façon évidente à l'homme de l'art, étant entendu que ces différentes variantes, modifications et perfectionnements font partie de la portée de l'invention, telle que définie par les revendications qui suivent. En particulier, bien que les différents modes de réalisation décrits ci-dessus mettent en oeuvre un nombre de bulles égal à 4, le procédé de gestion d'une unité de calcul de noeud de parité proposé et l'unité de calcul pour la mise en oeuvre du procédé peuvent être mis en oeuvre avec un autre nombre de bulles nbUb supérieur ou égal à deux.

En outre, bien que les différents modes de réalisation décrits ci-dessus mettent en oeuvre des opérations d'addition entre éléments de messages d'entrée, l'invention est également applicable à des opérations de calcul cf) où cf) est une fonction vérifiant la propriété suivante : si ab et cd, alors cp(a,c) cp(b,d). De même, bien que l'invention ait été décrite dans son application à des éléments d'un corps de Galois GF(q), elle est applicable aux éléments d'un ensemble muni d'au moins une loi de composition interne. De plus, différents aspects et caractéristiques décrits ci-dessus peuvent être mis en oeuvre ensemble, ou séparément, ou bien substitués les uns aux autres, et l'ensemble des différentes combinaisons et sous combinaisons des aspects et caractéristiques font partie de la portée de l'invention. En outre, il se peut que certains systèmes et équipements décrits ci-dessus n'incorporent pas la totalité des modules et fonctions décrits pour les modes de réalisation préférés.

Claims (17)

1. REVENDICATIONS1. Procédé de gestion d'une unité de calcul de noeud de parité d'un décodeur de code correcteur d'erreurs susceptible de représentation par un graphe bipartite comprenant au moins un noeud de parité, le noeud de parité étant configuré pour recevoir des premier (U) et deuxième (V) messages en entrée, et produire un message de sortie (E), les éléments des messages d'entrée et de sortie du noeud de parité comprenant un symbole et un degré de fiabilité associé au symbole, les premier et deuxième messages en entrée comprenant des listes U(i) et V(j) de longueur nm, d'éléments ordonnés selon leur degré de fiabilité, le procédé comprenant : - initialiser une pluralité de nbub mémoires de type FIFO avec des éléments calculés à partir de combinaisons selon une opération de calcul (j) (U(i), V(j)) d'éléments des premier et deuxième messages en entrée, ladite opération de calcul cp étant telle que si ab et alors (p(a,c) cp(b,d) ; et - déterminer des valeurs du message de sortie de manière itérative, une itération d'ordre m, m étant un entier supérieur ou égal à zéro, comprenant : - sélectionner parmi les éléments de sortie des mémoires de type FIFO un élément Ss(m) ayant le meilleur degré de fiabilité ; - générer un élément du message de sortie (E) à partir de l'élément sélectionné Ss(m); - mettre à jour l'index de sortie de la mémoire FIFO de laquelle l'élément sélectionné Ss(m) est issu.
2. 2. Procédé selon la revendication 1, dans lequel nbub est égal à quatre, et dans lequel les quatre mémoires de type FIFO sont initialisées avec des éléments de 4 sous-ensembles S1, S2, S3, et S4, générés en combinant les degrés de fiabilité respectivement associés aux éléments U(i) et V(j) des messages d'entrée, comme suit : S1 = o (U(0), V (1)); 1 E [0, ..., nr,' - 1)] S2 = [q) (V (0), U (1)); 1 E {1, , nm, - 1}] S3 = [cp (U (1), V (1)); 1 E {1, - 1}]54 = frp (V (1) , U (1)); 1 E 12 - ,
3. 3. Procédé selon la revendication 2, dans lequel les 4 mémoires de type FIFO sont initialisées en fonction de leurs tailles, qui sont choisies respectivement égales à : 71r1 - 1, z- 2, nt' - 2, et1-- - 3.
4. 4. Procédé selon l'une quelconque des revendications précédentes, dans lequel la génération d'un élément du message de sortie (E) à partir de l'élément sélectionné Ss(m) n'est effectuée que si le message de sortie E ne contient pas déjà ledit élément.
5. 5. Procédé selon l'une quelconque des revendications précédentes, dans lequel le degré de fiabilité de chaque élément est représenté par un logarithme de rapport de vraisemblance.
6. 6. Procédé selon l'une quelconque des revendications précédentes, dans lequel l'opération de calcul cp est une addition.
7. 7. Procédé selon l'une quelconque des revendications précédentes, dans lequel le décodeur de codes correcteur d'erreur est un décodeur de codes LDPC non binaires.
8. 8. Programme d'ordinateur, chargeable dans une mémoire associée à un processeur, et comprenant des portions de code pour la mise en oeuvre des étapes d'un procédé selon l'une quelconque des revendications 1 à 7 lors de l'exécution dudit programme par le processeur.
9. 9. Programme d'ordinateur selon la revendication 8, dans lequel des portions de code dudit programme sont obtenues par décompression ou décodage d'un ensemble de données stockées dans une mémoire.
10. 10. Support de stockage non-transitoire d'un programme exécutable par ordinateur, comprenant un ensemble de données représentant un ou plusieurs programmes, lesdits un ou plusieurs programmes comprenant des instructions pour, lors de l'exécution desdits un ou plusieurs programmes par un ordinateur comprenant une unité de traitement couplée de manière opérationnelle à des moyens mémoire et à un module d'interface entrées/sorties, conduire l'ordinateur àgérer une unité de calcul de noeud de parité selon le procédé de l'une quelconque des revendications 1 à 7.
11. 11. Unité de calcul de noeud de parité d'un décodeur de code correcteur d'erreurs susceptible de représentation par un graphe bipartite, le noeud de parité étant configuré pour recevoir des premier (U) et deuxième (V) messages en entrée, et produire un message de sortie (E), les éléments des messages d'entrée et de sortie du noeud de parité comprenant un symbole et un degré de fiabilité associé au symbole, les premier et deuxième messages en entrée comprenant des listes U(i) et V(j) de longueur nn, d'éléments ordonnés selon leur degré de fiabilité, l'unité de calcul comprenant : - un processeur informatique couplé de manière opérationnelle à des moyens mémoire, les moyens mémoire étant configurés sous forme d'une pluralité de nbUb mémoires de type FIFO ; - un générateur de message de sortie, s'exécutant sur le processeur 15 informatique et configuré pour : initialiser la pluralité de nbub mémoires de type FIFO avec des éléments calculés à partir de combinaisons selon une opération de calcul cp (U(i),V(j)) d'éléments des premier et deuxième messages en entrée, ladite opération de calcul (p étant telle que si ab et c_d, 20 alors (p(a,c) (p(b,d) ; et - déterminer des valeurs du message de sortie de manière itérative, une itération d'ordre m, m étant un entier supérieur ou égal à zéro, comprenant : o sélectionner parmi les éléments de sortie des mémoires de 25 type FIFO un élément Ss(m) ayant le meilleur degré de fiabilité ; o générer un élément du message de sortie (E) à partir de l'élément sélectionné Ss(m); o mettre à jour l'index de sortie de la mémoire FIFO de laquelle 30 l'élément sélectionné Ss(m) est issu.
12. 12. Unité de calcul selon la revendication 11, dans laquelle nbub est égal à quatre, et dans laquelle les quatre mémoires de type FIFO sont initialisées avec des éléments de 4 sous-ensembles S1, S2, S3, et S4, générés en combinant les degrés de fiabilité respectivement associés aux éléments U(i) et V(j) des messages d'entrée, 5 comme suit : Sl = [(p(U (0), V (1)); 1 E {0, ...,nm - 1)] S2 = [(p(V (0), U (1)); 1 E [1, ...,nm 1}] S3 = o(U (1),V (1)); 1 E - 111 S4 = [v(V (1), U(1)); 1 E 12, , ntn - 111 ,
13. 13. Unité de calcul selon la revendication 12, dans lequel les 4 mémoires de type FIFO sont initialisées en fonction de leurs tailles, qui sont choisies respectivement égales à : -ne - 1, 2- 2, L1-" - 2, et ntn - 3. 10
14. 14. Unité de calcul selon l'une quelconque des revendications 12 et 13, dans laquelle la génération d'un élément du message de sortie (E) à partir de l'élément sélectionné Ss(m) n'est effectuée que si le message de sortie E ne contient pas déjà ledit élément.
15. 15. Unité de calcul selon l'une quelconque des revendications 12 à 14, dans 15 laquelle le degré de fiabilité de chaque élément est représenté par un logarithme de rapport de vraisemblance.
16. 16. Unité de calcul selon l'une quelconque des revendications 12 à 15, dans laquelle l'opération de calcul 'p est une addition.
17. 17. Unité de calcul selon l'une quelconque des revendications 12 à 16, dans 20 laquelle le décodeur de codes correcteur d'erreur est un décodeur de codes LDPC non binaires.