FR2831971A1

FR2831971A1 - Procede de memorisation de donnees avec correction d'erreur

Info

Publication number: FR2831971A1
Application number: FR0208626A
Authority: FR
Inventors: Michel Nicolaidis
Original assignee: Iroc Technologies SA
Current assignee: Iroc Technologies SA
Priority date: 2001-11-02
Filing date: 2002-07-09
Publication date: 2003-05-09
Also published as: WO2003038620A2; WO2003038620A3; FR2831971A3; EP1573541A2; US20050028061A1; US7124348B2

Abstract

L'invention concerne un procédé de mémorisation de données permettant des détections et corrections d'erreur dans une mémoire organisée pour lire et écrire des mots d'un premier nombre (m) de bits et éventuellement pour modifier une partie seulement d'un tel mot, comprenant les étapes suivantes :associer un code de détection et de correction d'erreur à un groupe d'un deuxième nombre k >= 1 de mots; etassocier à chaque écriture une opération de vérification et, s'il y a lieu, de correction d'erreur dans le groupe de mots associé au mot dans lequel on réalise une opération d'écriture totale ou partielle.

Description

PROCÉDÉ DE MÉMORISATION DE DONNÉES AVEC CORRECTION D'ERREUR
La présente invention concerne l'organisation d'une mémoire associée à des moyens de correction d'erreur.

Etant donné la miniaturisation actuelle des circuits intégrés et notamment des circuits de mémoire, les points mémoire assurent la mémorisation de bits de données en agissant sur un nombre de porteurs de charge de plus en plus petit. En conséquence, chaque point mémoire est de plus en plus susceptible d'être affecté d'une erreur, c'est-à-dire d'une inversion de la donnée mémorisée (passage de 0 à 1 ou de 1 à 0), notamment par suite d'une irradiation par des particules. Pour remédier à cet inconvénient on a développé des codes de correction d'erreur, chaque mot mémoire étant associé à un code de correction d'erreur. Quand on lit le contenu d'un mot et le code de correction d'erreur associé, et que l'on calcule un syndrome entre le mot mémorisé et le code de correction d'erreur, ce syndrome permet de déterminer si le mot est affecté d'une erreur ou non, de déterminer l'emplacement de l'erreur et de corriger cette erreur.

Des exemples de codes de correction d'erreur connus sont le code de Hamming et le code de Reed-Solomon. On notera que l'on distingue les simples codes de détection d'erreur, par exemple l'association à un mot d'un bit de parité, qui

permettent de détecter l'existence d'une erreur, des codes de correction d'erreur qui permettent de déterminer l'emplacement de l'erreur et donc de la corriger.

Un inconvénient évident de l'utilisation de codes de correction d'erreur réside dans la quantité de bits qu'ils nécessitent. Par exemple, pour des mots de plus de quatre bits, un code de Hamming nécessite n+1 bits pour permettre la correction d'une erreur, et seulement d'une erreur, dans un mot de 2n bits. Ceci signifie que, pour un mot de huit (23) bits, il faudra quatre bits de code, et même cinq bits si l'on ajoute au code de correction d'erreur un code de parité. Pour un mot de 64 (25) bits, il faudra cinq ou six bits de code de correction d'erreur. Il est clair que la surface relative occupée par la partie de la mémoire allouée au code de correction d'erreur dépend de la longueur des mots mémorisés et diminue quand cette longueur augmente.

Par contre, de nombreuses mémoires sont prévues pour faire des opérations sur des mots relativement courts.

D'autre part, on utilise souvent dans les mémoires des organisations dans lesquelles il est possible de changer seulement une portion d'un mot. C'est ce que l'on appelle des opérations masquables, c'est-à-dire que l'on prévoit un masque lors d'une opération d'écriture pour n'affecter que certains des bits d'un mot. Il se pose alors un problème qui est que le code de correction d'erreur du mot modifié ne correspond plus à ce mot.

Ceci amène à associer un code de correction d'erreur à chaque bit d'un mot, ce qui nécessite comme on l'a vu ci-dessus une utilisation de mots de code extrêmement longs par rapport aux mots mémorisés.

Ainsi, un objet de la présente invention est de prévoir une organisation de mémoire associée à un système de correction d'erreur dans laquelle on puisse utiliser des mots de courte longueur tout en utilisant un nombre de bits de code de correction d'erreur raisonnable, sans augmenter excessivement la complexité ou la consommation du circuit.

Un autre objet de la présente invention est de prévoir une organisation de mémoire dans laquelle on puisse réaliser des opérations masquables et utiliser de façon simple un système de correction d'erreur.

Pour atteindre ces objets, la présente invention prévoit un procédé de mémorisation de données permettant des détections et corrections d'erreur dans une mémoire organisée pour lire et écrire des mots d'un premier nombre (m) de bits et éventuellement pour modifier une partie seulement d'un tel mot, comprenant les étapes suivantes : associer un code de détection et de correction d'erreur à un groupe d'un deuxième nombre k > l de mots ; et associer à chaque écriture une opération de vérification et, s'il y a lieu, de correction d'erreur dans le groupe de mots associé au mot dans lequel on réalise une opération d'écriture totale ou partielle.

Selon un mode de réalisation de la présente invention, chaque mot est un mot long de M bits comprenant un troisième nombre déterminé r > l de mots élémentaires à m bits.

Selon un mode de réalisation de la présente invention, un code de détection d'erreur est associé à chaque mot ; chaque opération d'écriture est précédée d'une lecture du mot considéré et de son code de détection d'erreur ; et en cas d'erreur, le groupe de mots et le code de correction d'erreur sont lus en vue de la correction des erreurs et de la modification du code de correction d'erreur.

Selon un mode de réalisation de la présente invention, chaque opération d'écriture d'une partie d'un mot long et de son code est précédée d'une lecture du mot long et de son code, et le nouveau code du mot long est calculé à partir des valeurs à écrire dans la partie en écriture du mot long et des valeurs lues des autres parties du mot long, et est écrit dans la mémoire.

Selon un mode de réalisation de la présente invention, les codes sont lus et écrits dans une mémoire distincte de la

mémoire de données, et le cycle de la mémoire de codes est décalé dans le temps par rapport au cycle de la mémoire de mots.

Selon un mode de réalisation de la présente invention, le mot long lu et le code lu sont utilisés pour détecter et corriger les erreurs éventuelles dans le mot long lu, et en cas de détection et de correction d'erreurs dans le mot long lu, le code est recalculé à partir des valeurs à écrire dans une partie du mot long et des valeurs lues corrigées des autres parties du mot long, et les valeurs lues corrigées des autres parties du mot long, ou le code recalculé, sont réécrits dans la mémoire ou la mémoire distincte des codes.

Selon un mode de réalisation de la présente invention, la mémoire est une mémoire à deux accès, dont le premier permet d'effectuer au moins des opérations de lecture et le deuxième permet d'effectuer au moins des opérations d'écriture, chaque opération de lecture étant effectuée par l'un des accès et chaque opération d'écriture étant remplacée par une opération de lecture effectuée par un accès et par une opération d'écriture effectuée par l'autre accès.

Selon un mode de réalisation de la présente invention, pendant chaque opération d'écriture dans une partie d'un mot long, on lit simultanément les autres parties du mot long, et on calcule le nouveau code en utilisant les valeurs écrites dans les parties en écriture du mot long et les valeurs lues dans les autres parties du mot long.

Selon un mode de réalisation de la présente invention, on procède successivement à la lecture d'un mot, l'écriture d'une partie à remplacer de ce mot, la lecture du code du mot, l'écriture du code du nouveau mot, la vérification du mot lu, le système étant interrompu et l'écriture du mot étant reprise si la vérification du mot lu indique une erreur.

Selon un mode de réalisation de la présente invention, on effectue une écriture dans seulement au moins un bit d'un

mot, ou dans seulement les m bits d'un mot élémentaire d'un mot long, et le procédé comprend les étapes suivantes : lire simultanément avec l'écriture les autres bits du groupe de mots, calculer les codes de correction d'erreur pour ces autres bits et pour toutes les valeurs possibles des positions de bits dans lesquelles on écrit, et déterminer celle des valeurs possibles pour laquelle on obtient une erreur minimale et si cette erreur minimale est nulle, considérer que l'écriture a réussi et calculer un nouveau code de correction d'erreur ; si cette erreur minimale est non nulle, corriger les bits en erreur aux positions autres que celles où on a écrit et calculer un nouveau code de correction d'erreur.

Selon un mode de réalisation de la présente invention, le procédé est appliqué à un mot constituant à lui seul le mot long.

Selon un mode de réalisation de la présente invention, des erreurs sont susceptibles de survenir dans un seul mot d'un groupe de mots, et un code de détection d'erreur est associé à chaque mot, alors, le code de correction d'erreur est calculé sous forme d'un OU Exclusif des codes de correction d'erreur de chaque mot.

Selon un mode de réalisation de la présente invention, on effectue une écriture dans seulement au moins un bit d'un mot d'un mot long, et on associe au mot long un code de calcul susceptible de reconstituer les bits du mot dans lequel on écrit à partir des valeurs des autres mots du mot long et un code de correction capable de corriger des erreurs éventuelles dans le mot long comprenant le mot reconstitué, ces erreurs éventuelles comprenant les erreurs affectant un des mots du mot long ainsi que les erreurs induites par ces erreurs dans le mot reconstitué.

La présente invention vise aussi une mémoire pour la mise en oeuvre du procédé selon l'invention comprenant des

moyens pour simultanément écrire dans des portions d'un mot ou dans un mot élémentaire d'un mot long et lire le reste des bits du mot long ou du groupe de mots.

La présente invention prévoit aussi une mémoire pour la mise en oeuvre du procédé comprenant des moyens pour simultanément écrire dans des portions d'un mot ou dans un mot élémentaire d'un mot long et lire le reste des bits du mot long ou du groupe de mots.

Ces objets, caractéristiques et avantages, ainsi que d'autres de la présente invention seront exposés en détail dans la description suivante de modes de réalisation particuliers faite à titre non-limitatif en relation avec les figures jointes parmi lesquelles : les figures 1 à 3 illustrent des structures de blocs mémoire selon la présente invention.

Comme le représente la figure 1, étant donné une mémoire prévue pour lire et écrire normalement des mots de m bits, la présente invention prévoit d'associer à un groupe de k mots, c'est-à-dire un ensemble de k. m bits, un code de correction d'erreur unique EC. Ainsi, on utilise un code de correction d'erreur pour un ensemble de k. m bits et non plus k codes de correction d'erreur dont chacun correspond à un ensemble de m bits. Comme on le déduira des exemples numériques donnés cidessus, ceci réduit beaucoup la dimension occupée en mémoire pour la correction d'erreur. Bien entendu, ceci se fait au prix d'une légère augmentation de la surface occupée par les moyens de calcul du code de correction d'erreur. Néanmoins cette augmentation est négligeable puisque les mêmes moyens de calcul sont utilisés et déterminent les codes de correction pour tous les blocs mémoire.

En outre, selon un mode de réalisation de la présente invention, on adjoint à chaque mot de m bits, un code de détection d'erreur ED, par exemple, dans le cas où il ne peut pas y avoir plus d'une erreur par mot, un simple bit de parité.

Selon une variante de la présente invention, illustrée en figure 2, dans le cas de mots courts, par exemple des mots de 4 bits (m=4), on groupera de préférence les mots courts en mots longs de r. m = M bits (par exemple 64 bits) et on associera un code de détection d'erreur, par exemple un code de parité, ED, seulement à chaque mot long. k mots longs seront alors assemblés en un groupe de mots de k. M bits auquel est associé un code de correction d'erreur EC.

Dans la suite de la présente description, sauf indication spécifique, le terme"mot"pourra être interprété comme désignant un mot court ou un mot long.

Par exemple, si dans un système on est supposé utiliser une mémoire dont le mot est de 4 bits, on doit prévoir 3 bits supplémentaires par mot pour implémenter le code de Hamming. Pour réduire ce coût, on a intérêt à introduire des mots longs et à maximiser leur taille pour minimiser le coût du code, mais on ne veut pas utiliser des mots longs de très grande taille pour éviter une consommation très élevée lors d'une lecture. On peut choisir par exemple des mots longs de 64 bits (r = 16). Ensuite, on peut choisir des groupes d'une taille encore plus grande (par exemple des groupes de 4 mots longs). Dans ce cas, on va associer un bit de parité par mot long, et un code de Hamming (9 bits) par groupe de mots. Ceci donne un coût égal à 1/64 + 9/256 = 9, 75% au lieu de 75% pour un code de Hamming par mot de 4 bits.

Le nombre de bits d'un mot d'une mémoire est généralement déterminé selon des contraintes fonctionnelles et de vitesse d'opération du système dans lequel la mémoire est insérée. Pour la mise en oeuvre de la présente invention, on va modifier la mémoire pour augmenter la taille du mot qu'on va pouvoir lire lors d'un cycle de lecture. On obtient ainsi des mots longs composés de r mots de m bits que l'on pourra lire en un seul cycle. Ainsi, quand le système active un cycle de lecture destiné à un mot de m bits, on va lire un mot long de r. m bits qui contient le mot court auquel la lecture est

destinée, on va fournir au système ce mot de m bits, et on va utiliser localement le mot long de r. m bits pour les besoins de détection et/ou de correction des erreurs.

Une mémoire normalement prévue pour des mots de m bits ne peut pas faire des lectures sur r mots de m bits, ce qui est nécessaire si on veut utiliser des mots longs. Il faut donc modifier la mémoire ce qui entraîne normalement un rallongement du temps de conception du système. Néanmoins, on trouve de plus en plus, dans des générateurs de mémoire connus, des mémoires à opérations masquables. On peut alors choisir une telle mémoire utilisant des mots de r. m bits, de façon à pouvoir faire la lecture sur le mot long, ainsi que des opérations d'écriture masquable qui permettront d'écrire sur les m bits d'un mot court ou sur un sous-ensemble de ces bits dans le cas où la mémoire d'origine permet de faire des opérations masquables sur un sousensemble des m bits du mot.

LECTURE D'UN MOT
Pour la lecture d'un mot (court ou long), on procède de façon usuelle, à savoir que l'on commence par analyser son code de détection d'erreur. Dans la majorité des cas, il n'y aura pas d'erreur et le mot est lu normalement. S'il y a une erreur, on lit tous les mots du groupe de mots et on identifie la position de l'erreur en calculant le syndrome avec le code de correction d'erreur. L'erreur est alors corrigée à la position indiquée. On évite ainsi de lire un groupe complet à chaque lecture et, en temps normal, une lecture n'est pas plus longue qu'avec une organisation de mémoire classique.

On pourra préférer ne pas adjoindre de bit de détection d'erreur à chaque mot afin de sauvegarder de l'espace mémoire et on lira systématiquement un groupe de mots et le code de correction d'erreur à chaque lecture.

ECRITURE D'UN MOT
Le problème est un peu plus complexe lors d'une écriture. En effet, à chaque écriture d'un nouveau mot, il faut modifier le code de correction d'erreur du groupe de mots pour adapter ce code de correction d'erreur au mot modifié du groupe de mots. On va proposer ci-après deux modes de réalisation de l'invention pour résoudre ce problème.

Premier mode de réalisation d'une écriture
Avant chaque écriture, on commence par lire le mot considéré, et on examine si son code de détection ED indique une erreur ou non. S'il y a une erreur, on commence par corriger le mot lu en utilisant le code correcteur d'erreur du groupe de la façon indiquée ci-dessus en relation avec l'opération de lecture. Ensuite, le mot lu initial ou le mot lu corrigé ayant été mémorisé temporairement dans un registre, on calcule le nouveau code de correction d'erreur.

Une première façon de calculer le nouveau code de correction d'erreur consiste à tenir compte de la comparaison entre chaque bit du mot initial ou du mot corrigé et chaque bit du mot nouvellement écrit ainsi que de l'ancienne valeur du code. Ceci peut être fait de façon classique par des réseaux de portes OU Exclusif (XOR). On notera que ce procédé convient que l'on réécrive un mot complet à la place du mot préexistant ou que l'on réécrive seulement quelques bits d'un mot (écriture masquée).

Dans le cas où le groupe contient un seul mot court ou long, et où l'opération d'écriture s'effectue sur un sousensemble de bits du mot (opération masquable) ou du mot long (opération masquable ou non masquable), on peut n'utiliser que le code correcteur d'erreur qui sert alors également de code détecteur d'erreur. Toujours dans le cas où le groupe contient un seul mot, le calcul du nouveau code se fait d'une deuxième façon, directement à partir des valeurs des bits écrits et des valeurs des bits non affectés par l'écriture (non écrits). On

doit dans ce cas corriger, s'il y a lieu, les bits non écrits du mot lu. La correction sera faite en utilisant le mot lu et son code. On effectue cette correction afin de calculer le nouveau code en utilisant des valeurs correctes dans les bits non écrits du mot lu.

L'opération de modification du code de correction d'erreur de cette deuxième façon nécessite que l'on procède à une lecture (d'un mot ou d'une partie non écrite d'un mot) avant chaque écriture.

En pratique l'utilisation d'un cycle de lecture avant une écriture n'est dans de nombreux cas pas une pénalité car de nombreuses mémoires prévoient systématiquement la réalisation d'une lecture avant une écriture ou emploient un cycle mort après ou avant chaque écriture.

Ainsi, certaines mémoires, par exemple des mémoires cache, utilisent de façon standard un cycle de lecture avant un cycle d'écriture. Dans ce cas, les techniques présentées n'introduisent pas de réduction des performances du système. D'autre part, lire plusieurs mots avant une écriture est intéressant parce qu'on peut stocker ces mots dans un tampon et, si par la suite on vient de lire un de ces mots, on pourra faire une lecture très rapide en lisant le mot dans le tampon. On pourra aussi écrire plusieurs mots dans le tampon avant d'écrire tout le mot long dans la mémoire. Cette technique est souvent utilisée pour augmenter la vitesse des opérations de lecture ou d'écriture. Ainsi, les impératifs de réduction du coût du code se combinent avec des impératifs d'augmentation de la vitesse.

Dans certaines mémoires, par exemple des mémoires DRAM, le cycle comportant une lecture suivie d'une écriture existe de façon standard pour des raisons propres au fonctionnement de la mémoire.

Dans d'autres mémoires, on est obligé d'ajouter un cycle de lecture avant chaque écriture.

Selon un aspect de la présente invention, on modifie le fonctionnement de la mémoire pour pouvoir lire et écrire

séquentiellement un mot ou une partie de celui-ci dans le même cycle d'accès mémoire. Ceci est possible, car, le mot étant sélectionné au début du cycle, on active d'abord les amplificateurs de lecture pour pouvoir lire le mot, et on active ensuite les amplificateurs d'écriture de tous les bits du mot ou d'une partie de ceux-ci, pour effectuer une écriture non masquable ou masquable. Cette modification élimine le cycle de lecture qui doit précéder un cycle d'écriture, mais la durée du cycle sera prolongée.

Selon une variante de ce premier mode de réalisation de la présente invention, dans le cas où l'on suppose qu'il ne peut pas y avoir plus d'un mot affecté d'erreurs dans un groupe de k mots de m bits, plutôt que d'utiliser un code de correction d'erreur associé aux k. m bits, on pourra calculer un code de correction d'erreur pour chaque mot de m bits, et prendre comme code de correction d'erreur du groupe de mots la fonction OU Exclusif (XOR) des k codes calculés. L'indication des mots dans lesquels existera l'erreur éventuelle sera donnée par le code de détection d'erreur (ED) associé à chaque mot. Bien entendu, dans ce cas, si plus d'un code de détection d'erreur associé à plus d'un mot indique une erreur, on saura que l'on est en présence d'une erreur non corrigeable.

Optimisation de la synchronisation lecture-écriture du premier mode de réalisation
La présente invention vise également à optimiser la vitesse de lecture/écriture. Dans ce qui précède, on a indiqué que pour effectuer une opération d'écriture dans certains bits d'un mot, on effectue les actions de la liste suivante.

1) lire le mot existant, (on rappellera que dans le présent texte le terme"mot"désigne un mot court ou un mot long),
2) lire le code de correction d'erreur, par abréviation "code", de ce mot,
3) corriger les erreurs du mot lu, s'il y en a,

4) modifier le mot lu en remplaçant par de nouvelles valeurs les valeurs des bits en positions d'écriture,
5) calculer le code du mot modifié (nouveau code),
6) écrire les nouvelles valeurs dans les bits en écriture du mot, ou écrire le mot modifié en totalité,
7) écrire le nouveau code.

On voit que le mot est lu, modifié et écrit (actions 1,4 et 6). Comme la modification consiste à substituer, à une partie du mot lu, des données prêtes préalablement, il n'y a pas de délai induit par la modification. Néanmoins, le mot lu doit être vérifié par son code et corrigé en cas de détection d'erreur. Ces opérations nécessitent un temps pour être accomplies et peuvent introduire un délai supplémentaire entre l'opération de lecture et celle d'écriture. Ceci est particulièrement vrai si on accomplit la lecture et l'écriture dans le même cycle, car les données sont écrites immédiatement après la lecture. D'autre part, quand la lecture et l'écriture sont accomplies dans deux cycles successifs, on pourra avoir un certain temps disponible entre l'instant de lecture des données et l'instant d'écriture (par exemple les données peuvent être disponibles avant la fin du cycle de lecture). Toutefois, selon le type de mémoire ce temps peut être très court, voir même nul. Par exemple, dans certains types de mémoires, les données à écrire doivent être placées aux entrées de la mémoire pendant une certaine période de temps, avant le début du cycle de l'écriture (set-up time).

Selon un aspect de la présente invention, en vue d'éliminer le délai supplémentaire induit par la correction des données, on va écrire le mot modifié (ou les valeurs des bits modifiés) avant la fin de la vérification et correction des données lues. Cette vérification sera effectuée en parallèle avec l'écriture et en cas de détection d'erreur, on réécrit les données lues corrigées. Evidemment, pendant cette nouvelle écriture, on remplace dans le mot corrigé les valeurs des bits en positions d'écriture par les nouvelles valeurs à écrire dans ces positions. De cette manière, dans la plupart des cas, c'est-à-

dire quand il n'y a pas d'erreur, les opérations successives de lecture et d'écriture seront effectuées sans délai supplémentaire, et un cycle supplémentaire d'écriture est rajouté uniquement en cas de détection d'erreur. On peut alors générer un signal pour indiquer au système que la mémoire n'est pas accessible. Le système peut réagir à ce signal en se mettant par exemple dans un cycle d'attente. Notons néanmoins que l'écriture du mot correct n'est pas indispensable car l'erreur sera détectée et corrigée la prochaine fois que nous allons lire le mot, du moment que l'on a calculé correctement et mémorisé le nouveau code de correction.

On observe aussi un délai introduit pour le calcul du code du mot modifié. Ce calcul doit se faire de façon systématique, c'est-à-dire à chaque cycle de lecture/écriture. Nous avons vu que pour chaque écriture dans la mémoire on doit effectuer une lecture du code suivie d'une écriture du nouveau code (actions 2 et 7). Le temps disponible entre la lecture du code et son écriture risque d'être insuffisant pour calculer le nouveau code. Afin d'éviter de dégrader la vitesse de fonctionnement, on doit préparer le nouveau code à l'avance, c'est-àdire avant de lire le code précédent. Cette contrainte amène à utiliser la deuxième façon de calculer le code, c'est-à-dire à calculer le nouveau code à partir de la valeur des bits à écrire dans les positions en écriture du mot lu et de la valeur des autres positions du mot lu. En effet, la première façon de calculer le nouveau code utilise le code lu pour calculer le code à écrire, et introduit un délai entre le moment où on lit le code et le moment où le nouveau code est prêt pour son écriture. Par contre, la deuxième façon de calculer le nouveau code calcule le code à écrire à partir des bits à écrire dans le mot et des bits lus dans les positions non écrites du mot. On peut alors lire le mot et commencer le calcul du nouveau code avant de lire l'ancien code du mot.

On utilise des mémoires séparées (c'est-à-dire commandables indépendamment en lecture/écriture) pour les mots de

données et pour les codes de correction d'erreur correspondants.

Dans la mémoire de code, les opérations seront décalées dans le temps par rapport aux opérations dans la mémoire de mots. De cette façon, on a le temps de calculer au préalable le nouveau code et d'effectuer l'écriture du nouveau code, sans introduire de délai entre la lecture de l'ancien code et l'écriture du nouveau.

De cette manière, la durée du cycle de la mémoire du code ne sera pas affectée. Par contre, ce décalage entre les cycles des deux mémoires peut retarder la correction des erreurs dans le mot et dans son code, car le code est lu avec un retard par rapport à la lecture du mot correspondant. Notons néanmoins que le retard dans la lecture du code ne sera pas entièrement rajouté au temps nécessaire pour effectuer la correction du mot. En effet, les calculs requis pour la correction du mot lu peuvent commencer avant la lecture du code, car la première partie de ces calculs n'utilise que le mot lu. En fait, la correction commence habituellement par le calcul du code du mot lu pour le comparer ensuite avec le code de ce mot stocké dans la mémoire de code. Il reste néanmoins que la correction du mot peut introduire un retard sur la lecture.

Nous avons deux types de lecture : les lectures introduites avant une écriture pour permettre le calcul du nouveau code, et les lectures effectuées dans un cycle normal de lecture. Dans le premier cas, on peut éviter le retard introduit par la correction des erreurs en utilisant la technique décrite précédemment pour éviter le retard dans l'écriture du mot. En utilisant cette technique, on va calculer le code avant de corriger une erreur éventuelle dans le mot lu, et on va l'écrire dans la mémoire du code sans attendre la correction du mot. On corrige en parallèle le mot lu, et seulement dans la situation rare où on aura détecté et corrigé une erreur, on recalcule le code en utilisant des données correctes et on le réécrit dans la mémoire du code. On active dans ce cas un signal qui indique au système que la mémoire n'est pas accessible. Dans un cycle nor-

mal de lecture, ce retard peut être évité en utilisant la technique exposée dans la demande de brevet français NO 01/10735. Selon cette technique, les données lues sont immédiatement utilisées par le système, sans attendre la correction d'erreurs éventuelles. En parallèle, on effectue le contrôle et la correction des données lues et seulement si une erreur est détectée, on arrête le fonctionnement du système et on propage les données lues corrigées jusqu'aux parties du système contaminées par les données lues erronées.

Selon une autre variante du premier mode de réalisation, on utilise une mémoire à deux accès : le premier accès permettant de faire des lectures et le deuxième des écritures. Si le cycle i de la mémoire est un cycle de lecture, l'opération de lecture va s'effectuer par le premier accès. Si le cycle i est un cycle d'écriture, on va lire par le premier accès le mot ou le mot long concerné par l'écriture pendant le cycle i, puis on va effectuer l'écriture pendant le cycle i+1 par le deuxième accès, laissant le premier accès disponible pour faire l'opération normale correspondant au cycle i+1. Cette opération sera obligatoirement une lecture, car même si l'opération normale du cycle i+1 est une écriture, nous avons vu que l'écriture s'effectuera au cycle suivant (i+2), tandis que pendant le cycle i+1 on va lire le mot concerné par l'écriture.

Habituellement dans les mémoires à deux accès, il est interdit d'effectuer une lecture et une écriture dans le même mot pendant le même cycle. Ainsi, on aura un problème, si la lecture et l'écriture effectuées pendant le cycle i+1 affectent le même mot. Néanmoins, dans ce cas, les données demandées par la lecture se trouvent en entrée du deuxième accès. On va alors utiliser ces données pour fournir les données demandées par la lecture. Etant donné que l'écriture peut se faire sur seulement une partie du mot, les données en entrée du deuxième accès risquent de ne pas comprendre tous les bits demandés par la lecture. Pour éviter ce problème, on stocke à la fin du cycle i

les bits du mot lu, et on va remplacer certains de ces bits par les bits en écriture se trouvant en entrée du deuxième accès pendant le cycle i+1. On disposera ainsi de l'ensemble des bits qui pourront être demandés par la lecture du cycle i+1.

Les techniques décrites ci-dessus pour éviter l'augmentation de la durée du cycle de la mémoire, causée par le calcul du code et de la correction des données, peuvent être aussi utilisées dans le cas de cette variante du premier mode de réalisation. Par exemple, on va utiliser des mémoires séparées pour les mots de données et pour les codes de correction d'erreur correspondants. Dans la mémoire de code, les opérations seront décalées dans le temps par rapport aux opérations dans la mémoire de mots. Néanmoins, les mémoires à deux accès permettent habituellement d'utiliser des horloges indépendantes pour les deux accès. Dans ce cas, on peut cadencer l'accès utilisé pour les écritures en utilisant une horloge décalée par rapport à l'horloge utilisée pour cadencer l'accès utilisé pour les lectures. En choisissant ce décalage de façon adéquate, on peut disposer entre une lecture et l'écriture suivante d'un temps suffisant pour calculer le nouveau code, qui pourrait dans ce cas être effectué de la première ou la deuxième façon. L'utilisation d'une mémoire à deux accès au lieu d'une mémoire à simple accès aura un certain coût. Néanmoins, dans certaines situations, on dispose de mémoires à deux accès pour réaliser des mémoires à simple accès. Ainsi, certaines familles des FPGA incluent des mémoires embarquées à deux accès, afin de couvrir les besoins des utilisateurs ayant besoin d'une mémoire à simple accès et de ceux qui ont besoin d'une mémoire à deux accès.

Ainsi, l'utilisateur ayant besoin d'une mémoire à simple accès pourra réaliser avantageusement la présente variante du premier mode de réalisation.

Deuxième mode de réalisation d'une écriture
Selon un deuxième mode de réalisation de la présente invention, on cherche à éviter de lire des bits à des positions

de bit où l'on doit ensuite écrire pour éviter les inconvénients susmentionnés du premier mode de réalisation. Pour cela, chaque fois que l'on veut faire une écriture masquée dans un mot court, ou une écriture masquée ou non-masquée dans un mot d'un mot long, on effectue simultanément l'écriture des positions en écriture et la lecture des autres positions du mot (court ou long). On pourra adapter de nombreuses mémoires existantes à la mise en oeuvre de la présente invention. Par exemple, il est relativement simple de modifier une mémoire existante pour, chaque fois qu'on adresse un mot, connecter les positions de bits dans lesquelles on veut écrire à un amplificateur d'écriture et les autres positions de bits du même mot à un amplificateur de lecture.

Selon ce deuxième mode de réalisation, on calcule le nouveau code correcteur d'erreur (et le nouveau code détecteur d'erreur le cas échéant), en utilisant la valeur des bits à écrire et la valeur des autres bits du mot, ou du mot long selon la deuxième variante de mise en oeuvre de calcul de code présentée ci-dessus. L'invention prévoit aussi de détecter et corriger une erreur dans les bits lus avant de les utiliser pour calculer le nouveau code.

Selon un aspect du deuxième mode de réalisation, le code associé au mot (court ou long) est capable de détecter et corriger une erreur dans les positions non écrites du mot lu sans connaître la valeur des positions écrites.

Ce deuxième mode de réalisation s'applique plus particulièrement dans le cas où les mots sont courts et/ou où on fait une écriture masquée, c'est-à-dire où on fait une écriture seulement dans certains bits d'un mot. Par exemple, comme l'illustre la figure 3, on veut faire une écriture dans les deux positions de bits marqués d'une croix du deuxième mot, ou dans un"mot court"constituant un élément d'un"mot long".

Selon une première variante de ce deuxième mode de réalisation, on considère les bits lus et on donne toutes les

valeurs possibles aux bits modifiés par l'opération d'écriture.

Pour chacune de ces valeurs, on détermine le syndrome du mot (court ou long) à l'aide de son code de correction d'erreur. Il est clair que, parmi toutes les valeurs possibles, il y a la valeur des bits initiaux. Alors, pour cette valeur, s'il n'y a d'erreur dans aucun des bits lus du mot, le syndrome va indiquer une erreur nulle. On saura alors que le nouveau code de correction d'erreur peut être calculé valablement à partir des bits nouvellement écrits et des bits lus. Si le minimum du nombre d'erreurs détecté est non nul, on saura qu'il y a une erreur dans les bits non écrits du mot ou mot long, et pour cette valeur minimum, on procédera à une correction d'erreur avant de procéder au calcul du nouveau code de la façon indiquée cidessus.

Selon un aspect du deuxième mode de réalisation, le code associé au mot (court ou long) est capable de détecter une erreur dans les bits lus du mot, combinée avec n'importe quelle erreur dans les bits visés par l'écriture, de distinguer le mot qui contient uniquement l'erreur dans les bits lus, des mots qui contiennent l'erreur dans les bits lus ainsi que des erreurs quelconques dans les bits visés par l'écriture, et de corriger l'erreur dans ce mot.

Si l'erreur dans les bits lus du mot peut affecter au maximum t bits, si le nombre maximum de bits du mot affectés par une écriture est q, on prévoit que le code associé au mot peut détecter toute erreur de multiplicité inférieure ou égale à q+t, et parmi tout groupe d'erreurs dont les multiplicités sont supérieures à 0 et inférieures ou égales à q+t, peut distinguer l'erreur ayant la plus petite multiplicité, et peut corriger dans un mot ou mot long toute erreur dont la multiplicité ne dépasse pas t.

Selon un aspect de la première variante du deuxième mode de réalisation, pendant une écriture sur certains bits d'un mot (court ou long), on utilise le code du mot pour vérifier tous les mots en utilisant toutes les valeurs possibles pour les

positions du mot visées par l'écriture ainsi que les valeurs lues dans les autres positions du mot ou du mot long. Si cette vérification indique un mot sans erreur, alors les bits lus ne contiennent pas d'erreur. On utilise donc les valeurs des bits lus, les valeurs des bits écrits et le code lu pour calculer le nouveau code. Si par contre cette vérification ne trouve pas de mot sans erreur, alors il y a une erreur dans les bits lus et on doit la corriger avant de calculer le nouveau code. Le mot contenant des erreurs uniquement dans les positions lues étant distingué par le code, on utilisera le code pour corriger l'erreur dans ce mot et obtenir ainsi les valeurs correctes dans les bits lus.

Dans un mode de réalisation de la première variante, on utilise des mémoires telles que à chaque cycle d'écriture, on écrit soit sur un seul bit du mot (court ou long) soit sur tous les bits du mot (cas des mémoires ayant des mots à un bit dans lesquelles on forme des mots longs comportant r mots d'un bit, r > l, ou cas des mémoires utilisant des mots à m bits, comportant soit des écritures opérant sur tous les bits du mot, soit des écritures masquables opérant sur un seul bit du mot). Les erreurs prises en compte sont des erreurs affectant un seul bit du mot ou du mot long. Selon ce mode de réalisation, le code correcteur d'erreurs associé au mot ou au mot long est un code correcteur d'erreurs simples capable de distinguer les erreurs doubles des erreurs simples (par exemple, code de Hamming augmenté par le bit de parité du mot ou du mot long et de son code). Quand on écrit sur tous les bits du mot ou du mot long, le nouveau code du mot ou du mot long est calculé de façon standard. Quand on écrit sur un seul bit, on vérifie avec le code deux mots ou mots longs, l'un est formé en associant aux bits lus la valeur 0 pour le bit à écrire, l'autre est formé en associant aux bits lus la valeur 1 pour le bit à écrire. Si l'une de ces vérifications ne détecte pas d'erreur, alors les bits lus sont corrects et peuvent être utilisés pour calculer le code. Si on détecte des erreurs sur les deux mots ainsi formés,

alors le mot pour lequel on a détecté une erreur simple contient la bonne valeur pour le bit visé par l'écriture. On utilise le code pour corriger l'erreur dans ce mot. On utilise alors les bits lus obtenus dans le mot corrigé, les valeurs à écrire dans le bit visé par l'écriture et l'ancien code, pour calculer le nouveau code.

Selon une deuxième variante du deuxième mode de réalisation de la présente invention, les écritures peuvent se faire sur tous les bits d'un mot à m bits d'un mot long, ou sur un sous-ensemble de ces bits (écriture masquée). Les erreurs prises en compte peuvent affecter un seul mot d'un mot long. On associe à chaque mot long un code appelé" code de calcul", capable de calculer les valeurs des bits d'un mot, en utilisant les valeurs des bits des autres mots du mot long, ainsi qu'un code appelé "code de correction"capable de détecter et de corriger une erreur dans un mot du mot long combinée avec l'erreur introduite dans un autre mot du mot long (le mot à écrire) quand ce mot est calculé en utilisant le code de calcul et les autres mots du mot long qui incluent alors le mot erroné.

Selon un mode de réalisation de cette deuxième variante, on prévoit que le code de calcul peut détecter ses propres erreurs. En cas de détection d'erreurs dans ce code, nous allons considérer qu'il n'y a pas d'erreur dans les mots lus du mot long (étant donné qu'on suppose qu'une erreur ne peut pas affecter deux mots du mot long ni un mot et le code). On évite ainsi d'introduire une erreur dans les bits lus en essayant de les corriger avec un code de calcul erroné.

On considère le cas où les erreurs prises en compte sont des erreurs susceptibles d'affecter un seul bit d'un mot long. Le code de calcul comporte m bits. Le bit de position i de ce code est égal à la parité des bits de position i de tous les mots du mot long. Afin de pouvoir détecter des erreurs dans ce code, on lui associe un bit qui calcule sa parité (on peut observer que la parité du code de calcul est aussi la parité du

mot long). La nature du code de correction sera spécifiée plus loin. Lors d'une écriture masquée ou non masquée d'un mot, on lit en même temps tous les bits non écrits du mot long associé au mot écrit, ainsi que le code de calcul avec sa parité et le code de correction. On vérifie le code de calcul en utilisant sa parité. Si on détecte une erreur, on considère qu'il n'y a pas d'autres erreurs dans le mot long (hypothèse d'une erreur simple), on utilise alors la valeur des bits lus et des bits écrits pour calculer le nouveau code de calcul avec sa parité et le nouveau code de correction. Si on ne détecte pas d'erreurs dans le code de calcul, on calcule les bits du mot visé par l'écriture, en utilisant le code de calcul et les mots du mot long non visés par l'écriture. On a alors un mot long complet et on peut utiliser le code de correction pour détecter les erreurs dans ce mot long et les corriger. Le mot long sera erroné s'il y a une erreur (par hypothèse simple) sur un mot lu. Comme la valeur des bits du mot visé par l'écriture est calculée en utilisant entre autres le mot lu erroné, on aura aussi une erreur sur le mot visé par l'écriture à la même position que l'erreur sur le mot lu erroné. On peut utiliser un code correcteur d'erreurs doubles en tant que code de correction. Ce code permet de détecter une erreur double et le cas échéant de la corriger. On utilisera alors les bits lus corrects et les bits écrits pour calculer les nouveaux codes. Néanmoins, un code correcteur d'erreurs doubles est beaucoup plus coûteux que le code de Hamming.

Pour réduire le coût, on utilisera le code de Hamming. Il permet de détecter une erreur double, mais est en principe incapable de la corriger. Néanmoins, on observe que les erreurs doubles considérées affectent une position d'un mot connu (le mot visé par l'écriture) et la même position d'un mot inconnu. On peut pour chaque mot visé par l'écriture calculer préalablement les syndromes du code de Hamming pour toutes les erreurs doubles ayant cette propriété. Il y a m (r-1) couples d'erreurs et syndromes correspondants pour chaque mot visé par l'écriture. On peut alors créer un tableau et stocker pour chaque syndrome

l'erreur double correspondante. Alors, lors de la correction d'une erreur double, on calcule son syndrome et on recherche dans le tableau l'erreur double correspondante à ce syndrome. On corrige alors les positions du mot indiquées par cette erreur double pour la corriger. Néanmoins, quelques-unes de ces erreurs doubles peuvent avoir le même syndrome, on augmente alors le code de Hamming en rajoutant des bits supplémentaires permettant de différencier les syndromes pour ces erreurs doubles. Souvent, un seul bit supplémentaire suffira, mais un plus grand nombre de bits peut être nécessaire dans certains cas. Une façon plus économique consiste à développer un code dédié apte à détecter et corriger les erreurs simples ainsi que les erreurs doubles susmentionnées. Un programme informatique peut être développé pour générer automatiquement ce type de code.

Optimisation de la synchronisation lecture-écriture du deuxième mode de réalisation
Pour faire une écriture selon le deuxième mode de réalisation on effectue les actions de la liste qui suit.

1) écrire les nouvelles valeurs dans les positions en écri- ture du mot (court ou long) et lire en même temps les autres positions de ce mot (ci-après"positions lues"),
2) lire le code de correction d'erreur du mot (ci-après "code"),
3) utiliser les valeurs des positions lues du mot et le code du mot, pour corriger les valeurs de ces positions,
4) en cas de détection et correction d'erreur, réécrire éven- tuellement les valeurs corrigées (cette action n'est pas nécessaire, car l'erreur pourrait être détectée et corri- gée lors de la prochaine lecture du mot erroné),
5) utiliser les valeurs (éventuellement corrigées) des posi- tions lues du mot et les valeurs écrites dans les posi- tions en écriture pour calculer le code,
6) écrire le code ainsi calculé.

On observe que pour effectuer une écriture sur une partie du mot, on réalise une opération de lecture et une opération d'écriture du code du mot. Etant donné que l'on dispose d'un seul cycle pour ces deux opérations, on va utiliser une mémoire séparée pour les codes et on va adopter l'une des trois techniques suivantes.

La mémoire des codes étant plus petite que la mémoire des données, elle va être plus rapide. On pourra dans ce cas prévoir de faire une opération de lecture suivie d'une opération d'écriture du code pendant la durée d'un seul cycle d'écriture de la mémoire des données. Ces deux opérations peuvent se faire en un seul cycle de la mémoire du code (cycle de lecture-écriture), ou en deux cycles de cette mémoire.

Si cette première approche n'est pas possible, on va utiliser pour le code une mémoire à deux accès, permettant d'effectuer dans le même cycle une opération de lecture à partir du premier accès et une opération d'écriture à partir du deuxième accès.

Une troisième solution peut s'appliquer dans le cas où le mot est composé de plusieurs champs et chaque opération d'écri- ture partielle s'effectue toujours sur l'ensemble des bits de différents champs concernés par cette écriture. On va alors ajouter un code détecteur d'erreurs à chaque champ (par exem- ple un bit de parité), et on va vérifier à l'aide de ce code les champs lus lors d'une opération d'écriture partielle. Le code correcteur d'erreurs sera stocké dans une autre mémoire dont le fonctionnement est décalé par rapport à la mémoire des données et des codes détecteurs d'erreurs. Ainsi, les champs lus seront vérifiés par les codes détecteurs d'erreurs, et le nouveau code correcteur d'erreurs sera calculé avant de commencer le cycle d'opération dans le mémoire des codes correcteurs d'erreur. Si on ne détecte pas d'erreur dans les champs lus, alors on écrit dans la mémoire de codes le code correcteur d'erreurs ainsi calculé. Par contre, dans le cas rare où on détecte une erreur dans les champs lus, on lit le

code correcteur d'erreurs, on va l'utiliser pour corriger l'erreur dans les champs lus, on recalcule le nouveau code correcteur d'erreurs, et on écrit ce code dans la mémoire des codes correcteurs d'erreurs. Ainsi, dans le cas rare de détection d'erreurs, on aura à faire deux opérations dans la mémoire des codes correcteurs d'erreurs et certains calculs.

Ces opérations et calculs pourraient occuper la mémoire des codes correcteurs d'erreurs pendant plusieurs cycles. On va alors activer un signal pour indiquer au système que cette mémoire n'est pas accessible pendant un certain nombre de cycles. Le système pourra réagir à ce signal en se mettant par exemple en cycle d'attente.

Des techniques décrites précédemment, dans le cadre du premier mode de réalisation, pourraient être aussi utilisées dans le cadre du deuxième mode de réalisation afin d'éviter d'augmenter le temps du cycle de la mémoire ou du système, à cause des différents calculs du code et de la correction des erreurs.

Ces techniques ont été présentées dans le cadre de correction d'erreurs dans des mémoires utilisées par un système électronique en tant que mémoires simple-accès, mais l'homme de métier pourra facilement les adapter pour des mémoires utilisées par un système électronique en tant que mémoires à plusieurs accès (multi-ports) en les appliquant sur chaque accès d'une telle mémoire.

Le deuxième mode de réalisation de la présente invention présente l'avantage par rapport au premier de ne pas rajouter de temps de cycle dans le cas où aucune erreur n'est détectée. Bien entendu, si une erreur est détectée, il faudra effectuer la correction d'erreur mais ceci se produit également dans le cas d'une mémoire à code de correction d'erreur classique.

L'invention est susceptible de diverses variantes et modifications qui apparaîtront à l'homme de l'art. En particulier, la présente invention présente des avantages même si k=l pour améliorer les opérations d'écriture masquée dans des mémoires à code de correction d'erreur.

Claims

REVENDICATIONS

1. Procédé de mémorisation de données permettant des détections et corrections d'erreur dans une mémoire organisée pour lire et écrire des mots d'un premier nombre (m) de bits et éventuellement pour modifier une partie seulement d'un tel mot, comprenant les étapes suivantes : associer un code de détection et de correction d'erreur à un groupe d'un deuxième nombre kil de mots ; et associer à chaque écriture une opération de vérification et, s'il y a lieu, de correction d'erreur dans le groupe de mots associé au mot dans lequel on réalise une opération d'écriture totale ou partielle.

2. Procédé selon la revendication 1, dans lequel chaque mot est un mot long de M bits comprenant un troisième nombre déterminé r1 de mots élémentaires à m bits.

3. Procédé selon la revendication 1 ou 2, dans lequel : un code de détection d'erreur est associé à chaque mot ; chaque opération d'écriture est précédée d'une lecture du mot considéré et de son code de détection d'erreur ; et en cas d'erreur, le groupe de mots et le code de correction d'erreur sont lus en vue de la correction des erreurs et de la modification du code de correction d'erreur.

4. Procédé selon la revendication 2, dans lequel chaque opération d'écriture d'une partie d'un mot long et de son code est précédée d'une lecture du mot long et de son code, et le nouveau code du mot long est calculé à partir des valeurs à écrire dans la partie en écriture du mot long et des valeurs lues des autres parties du mot long, et est écrit dans la mémoire.

5. Procédé selon la revendication 4, dans lequel les codes sont lus et écrits dans une mémoire distincte de la mémoire de données, et le cycle de la mémoire de codes est décalé dans le temps par rapport au cycle de la mémoire de mots.

6. Procédé selon la revendication 4 ou 5, dans lequel le mot long lu et le code lu sont utilisés pour détecter et corriger les erreurs éventuelles dans le mot long lu, et en cas de détection et de correction d'erreurs dans le mot long lu, le code est recalculé à partir des valeurs à écrire dans une partie du mot long et des valeurs lues corrigées des autres parties du mot long, et les valeurs lues corrigées des autres parties du mot long, ou le code recalculé, sont réécrits dans la mémoire ou la mémoire distincte des codes.

7. Procédé selon la revendication 1, dans lequel la mémoire est une mémoire à deux accès, dont le premier permet d'effectuer au moins des opérations de lecture et le deuxième permet d'effectuer au moins des opérations d'écriture, chaque opération de lecture étant effectuée par l'un des accès et chaque opération d'écriture étant remplacée par une opération de lecture effectuée par un accès et par une opération d'écriture effectuée par l'autre accès.

8. Procédé selon la revendication 2, dans lequel pendant chaque opération d'écriture dans une partie d'un mot long, on lit simultanément les autres parties du mot long, et on calcule le nouveau code en utilisant les valeurs écrites dans les parties en écriture du mot long et les valeurs lues dans les autres parties du mot long.

9. Procédé selon la revendication 8, dans lequel on procède successivement à : la lecture d'un mot, l'écriture d'une partie à remplacer de ce mot, la lecture du code du mot, l'écriture du code du nouveau mot, la vérification du mot lu, le système étant interrompu et l'écriture du mot étant reprise si la vérification du mot lu indique une erreur.

10. Procédé selon la revendication 8, dans lequel on effectue une écriture dans seulement au moins un bit d'un mot,

ou dans seulement les m bits d'un mot élémentaire d'un mot long, comprenant les étapes suivantes : lire simultanément avec l'écriture les autres bits du groupe de mots, calculer les codes de correction d'erreur pour ces autres bits et pour toutes les valeurs possibles des positions de bits dans lesquelles on écrit, et déterminer celle des valeurs possibles pour laquelle on obtient une erreur minimale et si cette erreur minimale est nulle, considérer que l'écriture a réussi et calculer un nouveau code de correction d'erreur ; si cette erreur minimale est non nulle, corriger les bits en erreur aux positions autres que celles où on a écrit et calculer un nouveau code de correction d'erreur.

11. Procédé selon la revendication 10, caractérisé en ce qu'il est appliqué à un mot constituant à lui seul le mot long.

12. Procédé selon la revendication 1, dans lequel des erreurs sont susceptibles de survenir dans un seul mot d'un groupe de mots, et dans lequel un code de détection d'erreur est associé à chaque mot, caractérisé en ce que le code de correction d'erreur est calculé sous forme d'un OU Exclusif des codes de correction d'erreur de chaque mot.

13. Procédé selon la revendication 8, dans lequel on effectue une écriture dans seulement au moins un bit d'un mot d'un mot long, et dans lequel on associe au mot long un code de calcul susceptible de reconstituer les bits du mot dans lequel on écrit à partir des valeurs des autres mots du mot long et un code de correction capable de corriger des erreurs éventuelles dans le mot long comprenant le mot reconstitué, ces erreurs éventuelles comprenant les erreurs affectant un des mots du mot long ainsi que les erreurs induites par ces erreurs dans le mot reconstitué.

14. Mémoire pour la mise en oeuvre du procédé selon l'une quelconque des revendications 8 à 11 et 13, caractérisée

en ce qu'elle comprend des moyens pour simultanément écrire dans des portions d'un mot ou dans un mot élémentaire d'un mot long et lire le reste des bits du mot long ou du groupe de mots.