+

WO2003038620A2 - Procede de memorisation de donnees avec correction d'erreur - Google Patents

Procede de memorisation de donnees avec correction d'erreur Download PDF

Info

Publication number
WO2003038620A2
WO2003038620A2 PCT/FR2002/003758 FR0203758W WO03038620A2 WO 2003038620 A2 WO2003038620 A2 WO 2003038620A2 FR 0203758 W FR0203758 W FR 0203758W WO 03038620 A2 WO03038620 A2 WO 03038620A2
Authority
WO
WIPO (PCT)
Prior art keywords
word
code
read
bits
error
Prior art date
Application number
PCT/FR2002/003758
Other languages
English (en)
Other versions
WO2003038620A3 (fr
Inventor
Michaël NICOLAIDIS
Original Assignee
Iroc Technologies
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Priority claimed from FR0114231A external-priority patent/FR2831970A1/fr
Application filed by Iroc Technologies filed Critical Iroc Technologies
Priority to EP02793205A priority Critical patent/EP1573541A2/fr
Priority to US10/494,080 priority patent/US7124348B2/en
Publication of WO2003038620A2 publication Critical patent/WO2003038620A2/fr
Publication of WO2003038620A3 publication Critical patent/WO2003038620A3/fr

Links

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00—Error detection; Error correction; Monitoring
    • G06F11/07—Responding to the occurrence of a fault, e.g. fault tolerance
    • G06F11/08—Error detection or correction by redundancy in data representation, e.g. by using checking codes
    • G06F11/10—Adding special bits or symbols to the coded information, e.g. parity check, casting out 9's or 11's
    • G06F11/1008—Adding special bits or symbols to the coded information, e.g. parity check, casting out 9's or 11's in individual solid state devices
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F21/00—Security arrangements for protecting computers, components thereof, programs or data against unauthorised activity
    • G06F21/70—Protecting specific internal or peripheral components, in which the protection of a component leads to protection of the entire computer
    • G06F21/71—Protecting specific internal or peripheral components, in which the protection of a component leads to protection of the entire computer to assure secure computing or processing of information
    • G06F21/75—Protecting specific internal or peripheral components, in which the protection of a component leads to protection of the entire computer to assure secure computing or processing of information by inhibiting the analysis of circuitry or operation
    • G06F21/755—Protecting specific internal or peripheral components, in which the protection of a component leads to protection of the entire computer to assure secure computing or processing of information by inhibiting the analysis of circuitry or operation with measures against power attack

Definitions

  • the present invention relates to the organization of a memory associated with error correction means.
  • each memory point ensures the storage of data bits by acting on an increasingly small number of charge carriers. Consequently, each memory point is more and more likely to be affected by an error, that is to say by an inversion of the memorized data (passage from 0 to 1 or from 1 to 0), in particular as a result of particle irradiation.
  • error correction codes have been developed, each memory word being associated with an error correction code. When reading the content of a word and the associated error correction code, and calculating a syndrome between the stored word and the error correction code, this syndrome makes it possible to determine whether the word is affected of an error or not, to determine the location of the error and to correct this error.
  • error correction codes examples include the Hamming code and the Reed-Solomon code. It will be noted that a distinction is made between simple error detection codes, for example the association with a word of a parity bit, which allow to detect the existence of an error, error correction codes which make it possible to determine the location of the error and therefore to correct it.
  • error correction codes An obvious disadvantage of using error correction codes is the amount of bits they require. For example, for words longer than four bits, a Hamming code requires n + 1 bits to allow the correction of an error, and only of an error, in a word of 2 n bits. This means that for an eight (2 3 ) bit word, four bits of code will be required, and even five bits if a parity code is added to the error correction code. For a 64 (2 5 ) bit word, five or six bits of error correction code will be required. It is clear that the relative area occupied by the part of the memory allocated to the error correction code depends on the length of the stored words and decreases when this length increases.
  • the present invention provides a data storage method allowing error detections and corrections in a memory organized to read and write words of a first number (m) of bits and possibly to modify only part of such a word, comprising the following steps: associating an error detection and correction code with a group of a second number ( ⁇ l) of words; and at each partial writing in the group of words: - calculate a new code of the modified group of words, - carry out a verification operation and, if an error appears, carry out an error correction of the modified word and / or of the new code .
  • the present invention also relates to a memory for the implementation of the method.
  • the present invention also provides a method of memorizing data allowing detections and error corrections in a memory whose words are divided into several fields, the writing operations being able to be carried out on all of the bits of one or several fields, comprising the following steps: associate an error correction code, said field code, with each field of a word, and when writing in one or more fields of a word, activate a writing in the corresponding field code or codes, the values to be written in each field code being calculated from the values of the bits to be written in the corresponding field.
  • FIGS. 1 to 3 illustrate structures of memory blocks according to the present invention.
  • the present invention provides for associating with a group of k words, that is to say a set of km bits, a unique EC error correction code.
  • a unique EC error correction code is used for a set of km bits and no longer k error correction codes each of which corresponds to a set of m bits.
  • this greatly reduces the size occupied in memory for error correction.
  • an error detection code ED is added to each word of m bits, for example, in the case where there cannot be more than one error per word, a single bit of parity.
  • an error detection code for example a parity code, ED
  • word may be interpreted as designating a short word or a long word.
  • word For example, if in a system we are supposed to use a memory whose word is 4 bits, we must provide 3 additional bits per word to implement the Hamming code. To reduce this cost, it is advantageous to introduce long words and to maximize their size to minimize the cost of the code, but one does not want to use long words of very large size to avoid a very high consumption during a reading.
  • One can choose for example long words of 64 bits (r 16).
  • groups of an even larger size for example groups of 4 long words). In this case, we will associate a parity bit per long word, and a Hamming code (9 bits) per group of words.
  • the number of bits of a word in a memory is generally determined according to functional constraints and operating speed of the system in which the memory is inserted. For the implementation of the present invention, we will modify the memory to increase the size of the word that we will be able to read during a reading cycle. Long words are thus obtained composed of r words of m bits which can be read in a single cycle.
  • a memory normally provided for words of m bits cannot make readings on r words of m bits, which is necessary if one wants to use long words. It is therefore necessary to modify the memory which normally results in an extension of the system design time. Nevertheless, we find more and more, in known memory generators, memories with maskable operations. We can then choose such a memory using words of rm bits, so that we can do the reading on the long word, as well as maskable writing operations which will make it possible to write on the m bits of a short word or on a subset of these bits in the case where the original memory makes it possible to make maskable operations on a subset of the m bits of the word.
  • a first way of calculating the new error correction code consists in taking into account the comparison between each bit of the initial word or of the corrected word and each bit of the newly written word as well as the old value of the code. This can be done in a conventional way by exclusive OR gate networks (XOR). It will be noted that this method is suitable for rewriting a complete word in place of the preexisting word or for rewriting only a few bits of a word (masked writing).
  • the group contains a single short or long word
  • the write operation is performed on a subset of bits of the word (maskable operation) or of the long word (maskable or non-maskable operation)
  • the calculation of the new code is done in a second way, directly from the values of the written bits and the values of the bits not affected by writing (unwritten). In this case, the unwritten bits of the word read must be corrected, if necessary. The correction will be made using the word read and its code. This correction is carried out in order to calculate the new code using correct values in the unwritten bits of the word read.
  • the operation to modify the error correction code in this second way requires that a reading (of a word or of an unwritten part of a word) be carried out before each writing.
  • certain memories for example cache memories
  • the techniques presented do not introduce a reduction in system performance.
  • reading several words before writing is interesting because we can store these words in a buffer and, if we have just read one of these words, we can read very quickly by reading the word in the buffer.
  • the imperatives of reducing the cost of the code combine with the imperatives of increasing the speed.
  • the cycle comprising a reading followed by a writing exists in a standard manner for reasons specific to the operation of the memory.
  • the operation of the memory is modified in order to be able to read and write sequentially a word or a part of it in the same memory access cycle. This is possible, because, the word being selected at the start of the cycle, the read amplifiers are first activated in order to be able to read the word, and then the write amplifiers are activated for all the bits of the word or of a part thereof. of these, to perform a non-maskable or maskable writing.
  • This modification eliminates the read cycle which must precede a write cycle, but the cycle time will be extended.
  • the present invention also aims to optimize the speed of reading / writing.
  • the actions in the following list are carried out.
  • the word is read, modified and written (actions 1, 4 and 6).
  • the modification consists in substituting, for a part of the word read, data already ready, there is no delay induced by the modification.
  • the word read must be checked by its code and corrected if an error is detected.
  • These operations require time to be completed and may introduce an additional delay between the operation reading and writing. This is particularly true if reading and writing are performed in the same cycle, since the data is written immediately after reading.
  • there may be a certain time available between the instant of reading the data and the instant of writing for example the data may be available before the end of the reading cycle).
  • this time can be very short, or even zero.
  • the data to be written must be placed at the inputs of the memory for a certain period of time, before the start of the writing cycle (set-up time).
  • the modified word (or the values of the modified bits) will be written before the end of the verification and correction of the data read.
  • This verification will be carried out in parallel with the writing and in the event of error detection, the corrected read data is rewritten.
  • the values of the bits in writing positions are replaced in the corrected word by the new values to be written in these positions.
  • an additional cycle d 'writing is only added when an error is detected.
  • the first way of calculating the new code uses the code read to calculate the code to be written, and introduces a delay between the moment when the code is read and the moment when the new code is ready for writing.
  • the second way of calculating the new code calculates the code to be written from the bits to be written in the word and the bits read in the unwritten positions of the word. You can then read the word and start calculating the new code before reading the old word code.
  • Separate memories are used for the data words and for the corresponding error correction codes.
  • the operations will be shifted in time with respect to the operations in the word memory. In this way, there is time to calculate the new code beforehand and to write the new code, without introducing any delay between reading the old code and writing the new one. In this way, the duration of the code memory cycle will not be affected.
  • this offset between the cycles of the two memories can delay the correction of errors in the word and in its code, because the code is read with a delay compared to the reading of the corresponding word. Note however that the delay in reading the code will not be entirely added to the time required to correct the word.
  • the calculations required for the correction of the word read can begin before reading the code, because the first part of these calculations uses only the word read.
  • the correction usually begins with the calculation of the code of the word read in order to then compare it with the code of this word stored in the code memory.
  • the correction of the word can introduce a delay in reading.
  • the readings introduced before a writing to allow the calculation of the new code can be used as the readings introduced before a writing to allow the calculation of the new code
  • the readings carried out in a normal reading cycle can be avoided by using the technique described above to avoid the delay in writing the word.
  • this technique we will calculate the code before correcting a possible error in the word read, and we will write it in the memory of the code without waiting for the word to be corrected.
  • We correct the word read in parallel, and only in the rare situation where we have detected and corrected an error we recalculate the code using correct data and rewrite it in the code memory. In this case, a signal is activated which indicates to the system that the memory is not accessible.
  • a memory using dual-port the first port to take readings and the second of writes. If the cycle i of the memory is a read cycle, the read operation will be performed by the first access. If cycle i is a writing cycle, we will read by the first access the word or the long word concerned by writing during cycle i, then we will perform 1 writing during cycle i + 1 by the second access, leaving the first access available to do the normal operation corresponding to the cycle i + 1. This operation must be read, because even if the normal operation of the cycle i + 1 is a writing, we have seen that the writing will be carried out at the following cycle (i + 2), while during the cycle i + 1 we will read the word concerned by the writing.
  • Second embodiment of a writing According to a second embodiment of the present invention, it is sought to avoid reading bits at bit positions where one must then write to avoid the abovementioned drawbacks of the first embodiment. For this, each time we want to make a masked writing in a short word, or a masked or non-masked writing in a word of a long word, we simultaneously write the writing positions and read the other word positions (short or long).
  • Many existing memories can be adapted to the implementation of the present invention. For example, it is relatively simple to modify an existing memory so that, each time you address a word, connect the bit positions in which you want to write to a write amplifier and the other bit positions of the same word. to a sense amplifier.
  • the new error correcting code (and the new error detecting code if applicable) is calculated, using the value of the bits to be written and the value of the other bits of the word, or of the word long according to the second variant of code calculation implementation presented above.
  • the invention also provides for detecting and correcting an error in the bits read before using them to calculate the new code.
  • the code associated with the word is capable of detecting and correcting an error in the unwritten positions of the word read without knowing the value of the written positions.
  • This second embodiment applies more particularly in the case where the words are short and / or where a masked writing is made, that is to say where a writing is made only in certain bits of a word. For example, as illustrated in FIG. 3, we want to write in the two bit positions marked with a cross of the second word, or in a "short word" constituting an element of a "long word”.
  • the bits read are considered and all the possible values are given to the bits modified by the write operation.
  • the word syndrome (short or long) is determined using its error correction code. It is clear that, among all the possible values, there is the value of the initial bits. Then, for this value, if there is no error in any of the bits read from the word, the syndrome will indicate a zero error. It will then be known that the new error correction code can be validly calculated from the newly written bits and the read bits. If the minimum of the number of errors detected is not zero, we will know that there is an error in the unwritten bits of the word or long word, and for this minimum value, we will correct an error before proceed with the calculation of the new code as indicated above.
  • the code associated with the word is capable of detecting an error in the bits read from the word, combined with any error in the bits targeted by the writing, of distinguishing the word which contains only the error in the bits read, words which contain the error in the bits read as well as any errors in the bits intended for writing, and to correct the error in this word.
  • the code associated with the word can detect any error of multiplicity less than or equal to q + t, and among any group of errors whose multiplicities are greater than 0 and less than or equal to q + t, can distinguish the error with the smallest multiplicity, and can correct in a word or long word any error whose the multiplicity does not exceed t.
  • the word code is used to check all the words using all the possible values for the positions of the word targeted by the writing as well as the values read in the other positions of the word or long word. If this check indicates a word without error, then the bits read contain no error. The values of the bits read, the values of the bits written and the code read are therefore used to calculate the new code. If on the other hand this verification does not find a word without error, then there is an error in the bits read and it must be corrected before calculating the new code.
  • memories are used such that at each writing cycle, one writes either on a single bit of the word (short or long) or on all the bits of the word (case of memories having one-bit words in which long words are formed comprising r one-bit words, r> l, or in the case of memories using m-bit words, comprising either writes operating on all the bits of the word, or maskable writes operating on a single bit of the word).
  • the errors taken into account are errors affecting a single bit of the word or of the long word.
  • the error correction code associated with the word or the long word is a simple error correction code capable of distinguishing double errors from simple errors (for example, Hamming code increased by the parity bit of the word or long word and its code).
  • the new code of the word or long word is calculated in a standard way.
  • we check with the code two words or long words one is formed by associating the bits read with the value 0 for the bit to write, the other is formed by associating the bits read with the value 1 for the bit to write. If one of these checks does not detect an error, then the bits read are correct and can be used to calculate the code.
  • the word for which a simple error has been detected contains the correct value for the bit targeted by the writing.
  • the bits read obtained in the corrected word, the values to be written in the bit targeted by the writing and the old code are then used to calculate the new code.
  • the writes can be done on all the bits of a word with m bits of a long word, or on a subset of these bits (masked writing) .
  • the errors taken into account can affect a single word of a long word.
  • a code called "calculation code” capable of calculating the values of the bits of a word, using the values of the bits of the other words of the long word, as well as a code called "correction code” capable detect and correct an error in a word of the long word combined with the error introduced into another word of the long word (the word to be written) when this word is calculated using the calculation code and the other words of the long word which then include the wrong word.
  • the calculation code can detect its own errors. If errors are detected in this code, we will consider that there is no error in the words read from the long word (since it is assumed that an error cannot affect two words of the long word nor a word and code). This avoids introducing an error in the bits read by trying to correct them with an incorrect calculation code.
  • the calculation code has m bits.
  • the position bit i of this code is equal to the parity of the position bits i of all the words of the long word.
  • a bit is associated with it which calculates its parity (it can be observed that the parity of the calculation code is also the parity of the long word).
  • the nature of the correction code will be specified later.
  • a double error correction code can be used as the correction code. This code makes it possible to detect a double error and if necessary to correct it. We will then use the correct read bits and the written bits to calculate the new codes.
  • a double error correction code is much more expensive than the Hamming code. To reduce the cost, we will use the Hamming code. It detects a double error, but is in principle unable to correct it. Nevertheless, it is observed that the double errors considered affect a position of a known word (the word targeted by the writing) and the same position of an unknown word.
  • each word targeted by the writing it is possible for each word targeted by the writing to calculate beforehand the syndromes of the Hamming code for all double errors having this property. There are am (rl) pairs of errors and corresponding syndromes for each word targeted by the writing. We can then create an array and store for each syndrome the corresponding double error. Then, when correcting a double error, we calculate its syndrome and we look in the table for the double error corresponding to this syndrome. The positions of the word indicated by this double error are then corrected to correct it. Nevertheless, some of these double errors can have the same syndrome, the Hamming code is then increased by adding additional bits making it possible to differentiate the syndromes for these double errors. Often a single additional bit will suffice, but more bits may be required in some cases. A more economical way is to develop a dedicated code capable of detecting and correcting single errors as well as double errors above. A computer program can be developed to automatically generate this type of code.
  • read positions 1) write the new values in the writing positions of the word (short or long) and read at the same time the other positions of this word (hereinafter "read positions"), 2) read the error correction code of the word (hereinafter "code"),
  • the code memory Since the code memory is smaller than the data memory, it will be faster. In this case, provision may be made to perform a read operation followed by a code write operation for the duration of a single write cycle of the data memory. These two operations can be done in a single cycle of the code memory (read-write cycle), or in two cycles of this memory. If this first approach is not possible, we will use a two-access memory for the code, making it possible to carry out in the same cycle a read operation from the first access and a write operation from the second access .
  • a third solution can be applied in the case where the word is composed of several fields and each partial writing operation is always carried out on all of the bits of different fields concerned by this writing.
  • the error correction code will be stored in another memory, the operation of which is offset from the memory of the data and error detection codes.
  • the fields read will be verified by the error detecting codes, and the new error correcting code will be calculated before starting the operation cycle in the memory of the error correcting codes. If no error is detected in the fields read, then the error correction code thus calculated is written into the code memory.
  • the second embodiment of the present invention has the advantage over the first of not adding cycle time in the event that no error is detected. Of course, if an error is detected, it will be necessary to carry out the error correction but this also occurs in the case of a memory with conventional error correction code.
  • each word is partitioned into several fields, the writings being able to be made on all the bits of one or more fields of the word and a field code is associated with each field.
  • Field codes can be stored in the same memory as the data fields or in a separate memory.
  • the memory or memories are organized so that, each time one or more data fields are selected for writing, the corresponding field code or codes are selected. Thus, with each writing, the values of the bits of the data to be used are used. write in the selected fields to calculate the values of the corresponding field codes.
  • the invention is susceptible to various variants and modifications which will appear to those skilled in the art.

Landscapes

  • Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • Physics & Mathematics (AREA)
  • General Engineering & Computer Science (AREA)
  • General Physics & Mathematics (AREA)
  • Computer Hardware Design (AREA)
  • Quality & Reliability (AREA)
  • Mathematical Physics (AREA)
  • Computer Security & Cryptography (AREA)
  • Software Systems (AREA)
  • Techniques For Improving Reliability Of Storages (AREA)
  • Detection And Correction Of Errors (AREA)

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>/=) de mots ; et à chaque écriture partielle dans le groupe de mots calculer un nouveau code du groupe de mots modifié, effectuer une opération de vérification et, si une erreur apparaît, effectuer une correction d'erreur du mot modifié et/ou du nouveau code.

Description

PROCEDE DE MEMORISATION DE DONNEES 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 1 ' emplacement de 1 ' 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 1 '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 ( ≥l) de mots ; et à chaque écriture partielle dans le groupe de mots : - calculer un nouveau code du groupe de mots modifié, - effectuer une opération de vérification et, si une erreur apparaît, effectuer une correction d'erreur du mot modifié et/ou du nouveau code.
La présente invention vise aussi une mémoire pour la mise en oeuvre du procédé. La présente invention prévoit aussi un procédé de mémorisation de données permettant des détections et corrections d'erreur dans une mémoire dont les mots sont divisés en plusieurs champs, les opérations d'écriture pouvant s'effectuer sur l'ensemble des bits d'un ou plusieurs champs, comprenant les étapes suivantes : associer un code de correction d'erreur, dit code de champ, à chaque champ d'un mot, et lors d'une écriture dans un ou plusieurs champs d'un mot, activer une écriture dans le ou les codes de champs corres- pondants, les valeurs à écrire dans chaque code de champ étant calculées à partir des valeurs des bits à écrire dans le champ correspondant .
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 ci- dessus, 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 1 ' 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 sous- ensemble 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 1 ' 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 1 '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 1 '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 sous- ensemble 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 1 ' instant de lecture des données et 1 ' 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 êcri- ture, 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émen- taire, 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 1 'é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éma- tique, 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 comman- dables 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 intro- duites 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 tech¬ nique exposée dans la demande de brevet français N° 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 correc¬ tion 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éalisa¬ tion, 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 1 ' é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ù 1 '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 re- lativement 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 1 '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 ci- dessus .
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 1 'erreur dans les bits lus ainsi que des erreurs quelconques dans les bits visés par l'écriture, et de corriger 1 'erreur dans ce mot .
Si 1 ' 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 1 '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 1 'écriture à la même position que 1 '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 1 ' écriture calculer préalablement les syndromes du code de Hamming pour toutes les erreurs doubles ayant cette propriété. Il y a m(r-l) couples d'erreurs et syndromes correspondants pour chaque mot visé par 1 ' é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 écriture 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 corrigée lors de la prochaine lecture du mot erroné) ,
5) utiliser les valeurs (éventuellement corrigées) des positions 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'écriture 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 exemple 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.
Troisième mode de réalisation d'une écriture Dans le cas de mémoires à opérations masquables, c'est-à-dire de mémoires dans lesquelles on peut écrire dans des bits quelconques d'un mot, les deux premiers modes de réalisation résolvent le problème du calcul d'un nouveau code de correction d'erreur après une écriture au coût d'une complexifi- cation des opérations. Selon un troisième mode de réalisation de la présente invention, chaque mot est partitionné en plusieurs champs, les écritures pouvant se faire sur tous les bits d'un ou plusieurs champs du mot et on associe à chaque champ un code de champ. Les codes de champs peuvent être mémorisés dans la même mémoire que les champs de données ou dans une mémoire séparée.
La ou les mémoires sont organisées pour que, chaque fois que 1 ' on sélectionne en écriture un ou plusieurs champs de données, on sélectionne le ou les codes de champs correspondants. Ainsi, à chaque écriture, on utilise les valeurs des bits des données à écrire dans les champs sélectionnés pour calculer les valeurs des codes de champs correspondants.
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 (k≥l) de mots ; et à chaque écriture partielle dans le groupe de mots : - calculer un nouveau code du groupe de mots modifié, - effectuer une opération de vérification et, si une erreur apparaît, effectuer une correction d'erreur du mot modifié et/ou du nouveau code.
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é r≥l 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 dans un mot est précédée d'une lecture de ce mot 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 et de son code est précédée d'une lecture du mot et de son code, et le nouveau code du mot est calculé à partir des valeurs à écrire dans la partie en écriture du mot et des valeurs lues des autres parties du mot, 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, comprenant les étapes suivantes : écrire le nouveau code et au moins la partie modifiée du mot sans attendre une détection ou correction d'erreur dans les autres parties du mot, utiliser le mot lu et le code lu pour détecter et corriger les erreurs éventuelles dans le mot lu, et, en cas de détection et de correction d'erreurs dans le mot lu :
- recalculer le code à partir des valeurs à écrire dans une partie du mot et des valeurs lues corrigées des autres parties du mot, et
- réécrire le code recalculé et éventuellement les valeurs lues corrigées des autres parties du mot.
7. Procédé selon la revendication 1, dans lequel le système de mémorisation effectue une opération d'écriture ou une opération de lecture de données à chaque cycle et est réalisé par 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, on lit simultanément les autres parties du mot, et on calcule le nouveau code en utilisant les valeurs écrites dans les parties en écriture du mot et les valeurs lues dans les autres parties du mot.
9. Procédé selon la revendication 8, dans lequel on procède successivement à : l'écriture d'une partie à remplacer d'un mot, la lecture des autres bits du 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 1 'é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, comprenant les étapes suivantes : lire simultanément avec 1 'écriture les autres bits du mot, 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 3, caractérisé en ce qu'il comprend les étapes suivantes : lire, en même temps que le mot dans lequel on écrit, le code du groupe de mots, et calculer le nouveau code du groupe de mots en modifiant le code lu selon les valeurs des bits écrits dans le mot et les valeurs de ces bits lues avant écriture.
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, et dans lequel on associe au mot un code de calcul susceptible de reconstituer les bits du mot dans lequel on écrit à partir des valeurs des autres bits du mot et un code de correction capable de corriger des erreurs éventuelles dans le mot reconstitué, ces erreurs éventuelles comprenant les erreurs affectant lesdits autres bits ainsi que les erreurs induites par ces erreurs dans les bits reconstitués du mot.
14. Procédé de mémorisation de données permettant des détections et corrections d'erreur dans une mémoire dont les mots sont divisés en plusieurs champs, les opérations d'écriture pouvant s'effectuer sur l'ensemble des bits d'un ou plusieurs champs, comprenant les étapes suivantes : associer un code de correction d'erreur, dit code de champ, à chaque champ d'un mot, et lors d'une écriture dans un ou plusieurs champs d'un mot, activer une écriture dans le ou les codes de champs correspondants, les valeurs à écrire dans chaque code de champ étant calculées à partir des valeurs des bits à écrire dans le champ correspondant .
PCT/FR2002/003758 2001-11-02 2002-10-31 Procede de memorisation de donnees avec correction d'erreur WO2003038620A2 (fr)

Priority Applications (2)

Application Number Priority Date Filing Date Title
EP02793205A EP1573541A2 (fr) 2001-11-02 2002-10-31 Procede de memorisation de donnees avec correction d'erreur
US10/494,080 US7124348B2 (en) 2001-11-02 2002-10-31 Data storage method with error correction

Applications Claiming Priority (4)

Application Number Priority Date Filing Date Title
FR01/14231 2001-11-02
FR0114231A FR2831970A1 (fr) 2001-11-02 2001-11-02 Procede de memorisation de donnees avec correction d'erreur
FR02/08626 2002-07-09
FR0208626A FR2831971A1 (fr) 2001-11-02 2002-07-09 Procede de memorisation de donnees avec correction d'erreur

Publications (2)

Publication Number Publication Date
WO2003038620A2 true WO2003038620A2 (fr) 2003-05-08
WO2003038620A3 WO2003038620A3 (fr) 2006-08-10

Family

ID=26213242

Family Applications (1)

Application Number Title Priority Date Filing Date
PCT/FR2002/003758 WO2003038620A2 (fr) 2001-11-02 2002-10-31 Procede de memorisation de donnees avec correction d'erreur

Country Status (4)

Country Link
US (1) US7124348B2 (fr)
EP (1) EP1573541A2 (fr)
FR (1) FR2831971A1 (fr)
WO (1) WO2003038620A2 (fr)

Families Citing this family (17)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
JP2006190425A (ja) * 2005-01-07 2006-07-20 Nec Electronics Corp 半導体記憶装置
DE602006020010D1 (de) * 2005-12-19 2011-03-24 St Microelectronics Sa Schutz der Ausführung eines DES-Algorithmus
US8196011B2 (en) * 2006-02-15 2012-06-05 Hitachi Ulsi Systems Co., Ltd. Error detection and correction circuit and semiconductor memory
US7724593B2 (en) * 2006-07-07 2010-05-25 Rao G R Mohan Memories with front end precharge
US8291379B2 (en) * 2006-12-13 2012-10-16 International Business Machines Corporation Runtime analysis of a computer program to identify improper memory accesses that cause further problems
US20080168331A1 (en) * 2007-01-05 2008-07-10 Thomas Vogelsang Memory including error correction code circuit
US8271648B2 (en) * 2007-04-03 2012-09-18 Cinedigm Digital Cinema Corp. Method and apparatus for media duplication
CN101473383B (zh) * 2007-04-26 2014-03-12 艾格瑞系统有限公司 具有错误校正能力和高效率的部分字写操作的存储器设备
US7995409B2 (en) * 2007-10-16 2011-08-09 S. Aqua Semiconductor, Llc Memory with independent access and precharge
US8095853B2 (en) * 2007-10-19 2012-01-10 S. Aqua Semiconductor Llc Digital memory with fine grain write operation
US9164834B2 (en) * 2013-05-06 2015-10-20 Samsung Electronics Co., Ltd. Semiconductor memory devices, memory systems including the same and method of writing data in the same
US9569308B1 (en) 2013-07-15 2017-02-14 Rambus Inc. Reduced-overhead error detection and correction
US9985655B2 (en) * 2015-09-01 2018-05-29 International Business Machines Corporation Generating ECC values for byte-write capable registers
US9766975B2 (en) 2015-09-01 2017-09-19 International Business Machines Corporation Partial ECC handling for a byte-write capable register
US10176038B2 (en) 2015-09-01 2019-01-08 International Business Machines Corporation Partial ECC mechanism for a byte-write capable register
US10198315B2 (en) * 2016-02-29 2019-02-05 Sandisk Technologies Llc Non-volatile memory with corruption recovery
US20170286216A1 (en) * 2016-04-01 2017-10-05 Intel Corporation Energy efficient read/write support for a protected memory

Citations (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US3573728A (en) * 1969-01-09 1971-04-06 Ibm Memory with error correction for partial store operation
US3814921A (en) * 1972-11-15 1974-06-04 Honeywell Inf Systems Apparatus and method for a memory partial-write of error correcting encoded data
EP0491073A1 (fr) * 1990-12-18 1992-06-24 Siemens Nixdorf Informationssysteme Aktiengesellschaft Méthode et procédé de protection de données dans des unités de mémoire
WO2001014971A1 (fr) * 1999-08-04 2001-03-01 Sun Microsystems, Inc. Systeme et procede de detection d'erreurs type double bit et de correction de telles erreurs imputables a des defaillances de composants

Family Cites Families (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US4277844A (en) * 1979-07-26 1981-07-07 Storage Technology Corporation Method of detecting and correcting errors in digital data storage systems
US5357529A (en) * 1992-04-24 1994-10-18 Digital Equipment Corporation Error detecting and correcting apparatus and method with transparent test mode
US5841795A (en) * 1996-02-12 1998-11-24 Compaq Computer Corporation Error correction codes

Patent Citations (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US3573728A (en) * 1969-01-09 1971-04-06 Ibm Memory with error correction for partial store operation
US3814921A (en) * 1972-11-15 1974-06-04 Honeywell Inf Systems Apparatus and method for a memory partial-write of error correcting encoded data
EP0491073A1 (fr) * 1990-12-18 1992-06-24 Siemens Nixdorf Informationssysteme Aktiengesellschaft Méthode et procédé de protection de données dans des unités de mémoire
WO2001014971A1 (fr) * 1999-08-04 2001-03-01 Sun Microsystems, Inc. Systeme et procede de detection d'erreurs type double bit et de correction de telles erreurs imputables a des defaillances de composants

Also Published As

Publication number Publication date
US7124348B2 (en) 2006-10-17
FR2831971A3 (fr) 2003-05-09
WO2003038620A3 (fr) 2006-08-10
EP1573541A2 (fr) 2005-09-14
FR2831971A1 (fr) 2003-05-09
US20050028061A1 (en) 2005-02-03

Similar Documents

Publication Publication Date Title
WO2003038620A2 (fr) Procede de memorisation de donnees avec correction d'erreur
FR2481487A1 (fr) Systeme de traitement de l'information utilisant des techniques de regeneration et de detection et correction d'erreurs
FR2903219A1 (fr) Procede de rafraichissement d'un memoire vive dynamique et dispositif de memoire vive dynamique correspondant,en particulier incorpore dans un telephone mobile cellulaire
FR2858101A1 (fr) Systeme de memoire flash
FR2946787A1 (fr) Procede de detection d'une attaque par injection de faute d'un dispositif de memoire, et dispositif de memoire correspondant
EP3182292B1 (fr) Procédé de prédiction d'une donnée a précharger dans une mémoire cache
FR2810152A1 (fr) Memoire eeprom securisee comprenant un circuit de correction d'erreur
FR2911414A1 (fr) Dispositif et procede pour lire un mot de donnees et dispositif et procede pour memoriser un bloc de donnees
FR3055992A1 (fr) Gestion d'index dans une memoire flash
EP0875830B1 (fr) Circuit testable à faible nombre de broches
EP3712795B1 (fr) Procédé d'exécution, par un microprocesseur, d'un code binaire comportant une fonction appelante et une fonction appelee
WO2015086845A1 (fr) Systeme d'ecriture de donnees dans une mémoire
EP0606796B1 (fr) Procédé de programmation en champ uniforme d'une mémoire électriquement programmable et mémoire mettant en oeuvre le procédé
EP4195050A1 (fr) Procede et dispositif de correction d'erreurs dans les memoires resistives
FR2831970A1 (fr) Procede de memorisation de donnees avec correction d'erreur
EP1376608A1 (fr) Procédé d'écriture dans une mémoire non volatile et système pour la mise en oeuvre d'un tel procédé
EP1544724B1 (fr) Nouvelle architecture de mémoire FIFO et procédé de gestion d'une telle mémoire
FR2851843A1 (fr) Memoire flash comprenant un algorithme de verification d'effacement integre dans un algorithme de programmation
EP4089557B1 (fr) Procédé d'exécution d'un code binaire par un microprocesseur
EP1300953A1 (fr) Code de détection et/ou de correction d'erreurs à haute efficacité
WO2003032160A2 (fr) Architecture de circuits protegee contre des perturbations
FR3104285A1 (fr) Contrôle d’intégrité d’une mémoire
WO2010128068A1 (fr) Procede de protection de circuits electroniques, dispositif et systeme mettant en œuvre le procede
FR2867325A1 (fr) Dispositif de protection contre l'injection d'erreur dans un bloc logique asynchrone d'un module logique elementaire
EP1571754B1 (fr) Dispositif de protection contre l'injection d'erreur dans une bascule synchrone d'un module logique élémentaire

Legal Events

Date Code Title Description
AK Designated states

Kind code of ref document: A2

Designated state(s): JP US

AL Designated countries for regional patents

Kind code of ref document: A2

Designated state(s): AT BE BG CH CY CZ DE DK EE ES FI FR GB GR IE IT LU MC NL PT SE SK TR

121 Ep: the epo has been informed by wipo that ep was designated in this application
WWE Wipo information: entry into national phase

Ref document number: 2002793205

Country of ref document: EP

WWE Wipo information: entry into national phase

Ref document number: 10494080

Country of ref document: US

WWP Wipo information: published in national office

Ref document number: 2002793205

Country of ref document: EP

NENP Non-entry into the national phase

Ref country code: JP

WWW Wipo information: withdrawn in national office

Country of ref document: JP

点击 这是indexloc提供的php浏览器服务，不要输入任何密码和下载