DE3852474T2

DE3852474T2 - Nachschlagetabellen verwendende Fehlerkorrektur.

Info

Publication number: DE3852474T2
Application number: DE3852474T
Authority: DE
Inventors: Arvind Motibhai Patel
Original assignee: International Business Machines Corp
Current assignee: International Business Machines Corp
Priority date: 1987-11-10
Filing date: 1988-09-23
Publication date: 1995-07-20
Anticipated expiration: 2008-09-24
Also published as: EP0316063A2; EP0316063A3; DE3852474D1; JPH01155721A; JPH0444447B2; US4849975A; EP0316063B1

Description

Die vorliegende Erfindung betrifft ein Verfahren und eine Vorrichtung zur Korrektur von Fehlern in codierten unkorrigierten Daten unter Verwendung einer Implementierung, welche Nachschlagetabellen zum Decodieren von Syndromen von Fehlern einbezieht, wobei diese auf mindestens zwei Fehler in den Daten hinweisen.
Die folgenden Quellen offenbaren grundlegende theoretische Betrachtungen und verschiedene Verfahren und Anordnungen zur Korrektur von Fehlern in Speichereinrichtungen: w. w. Peterson, Error Correcting Codes, M.I.T. Press, 1961; R. C. Bose und D. K. Ray-Chaudhuri, "On a class of error-correcting binary group codes", Inf. Control 3, Seiten 68 bis 69, 1960; I. S. Reed und G. Solomon, "Polynomial codes over certain finite fields", J. Soc. Indust. Appl. Math 8, Seiten 300 bis 304, 1960 und R. T. Chien, "Cyclic decoding procedures for Bose-Chaudri Hocquenghem Codes", IEEE Trans. Inf. Theory, Bd. IT10, Seiten 357 bis 363, 1964.
In der ebenfalls anhängigen EP-A-0 218 413 wird eine Zweiebenen- Fehlerkorrektur-Codestruktur innerhalb eines verbesserten Multibyte Fehlerkorrektur-Subsystems offenbart. Die Daten werden auf einer Plattenspur in einer Anzahl von Subblöcken formatiert, wobei jeder Subblock innerhalb eines entsprechenden Blockes liegt. Es gibt ebenfalls zwei Sätze zu je drei Subblock-Prüfbytes C&sub1;, C&sub2; und C&sub3;. Ein Satz ist der geraden Phase zugeordnet und der andere der ungeraden Phase, wodurch verschachtelte Codeworte bereitgestellt werden. Bei dieser Anordnung erfolgt die Korrektur der ersten Ebene (von Subblock-Fehlern) unmittelbar in der Speichereinrichtung beim Durchgang dei: Daten, nachdem ein Subblock verzögert wurde, und die Daten werden zur Korrektur eines beliebigen Eehlers der zweiten Ebene (Block) an den Speicher- Manager gesendet. Diese beim Durchgang erfolgende Korrektur ist nur für Systeme geeignet, die asynchron arbeiten. Die Korrektur der zweiten (Block) Ebene wird unter Verwendung eines zusätzlichen Prüfbytes C&sub0; durchgeführt, das sich für jede Phase am Ende des Blockes befindet.
Die vorhergehend erwähnte ebenfalls anhängige Patentanmeldung offenbart die Hardware einer Plattenspeichereinrichtung, die unkorrigierte Daten in Echt zeit empfängt und drei Syndrombytes der ersten Ebene und ein Syndrombyte der zweiten Ebene (jeder Phase zugeordnet) erzeugt. Die Syndrome der ersten Ebene werden in der Speichereinrichtung decodiert, so daß ein Fehlermuster und eine Fehlerortsinformation bereitgestellt werden, die zum Speicher-Manager übertragen werden.
Die vorhergehend erwähnte Anmeldung beschreibt, wie das System funktioniert, wenn keine Fehler in irgendeinem Subblock auftreten, und wie Fehler korrigiert werden, wenn nicht mehr als ein Fehler pro Subblock auftritt und wenn mehr als ein Fehler pro Subblock auftreten. Genau gesagt, die Syndrome S&sub1;, S&sub2;, S&sub3;, die jeder Phase, die einem speziellen Subblock-Codewort zugeordnet ist, entsprechen, werden in einem lokalen Speicher abgelegt. Sie werden für die weitere Verarbeitung auf Blockebene zurückbehalten, wenn die speziellen Syndrome des Subblockes nicht komplett Null waren und wenn kein Nicht-Null-Fehlermuster durch den Decoder der ersten Ebene erzeugt worden ist. Der lokale Speicher speichert auch die Kennung eines unkorrigierten Subblockes als Subblock- Identifikator "f". Am Ende des Blockes werden ein Syndrom der zweiten Ebene, S&sub0;, das von einem Syndromgenerator der zweiten Ebene geliefert wird, sowie aus dem lokalen Speicher die Syndrome S&sub1;, S&sub2;, S&sub3;, der ersten Ebene des Subblockes f von einem Decoder der zweiten Ebene verarbeitet, um zwei Fehler in dem Subblock f zu korrigieren.
Es besteht ein Bedarf nach einer weniger teuren und dennoch wirksamen Anordnung für derartige Abläufe.
Dementsprechend stellt die vorliegende Erfindung ein Verfahren zur Korrektur von zwei Bytefehlern in codierten unkorrigierten Daten in Aufzeichnungen vorgegebener Länge, die aus einer Speichereinrichtung gelesen werden, durch Decodieren und Verarbeiten von vier Fehlersyndromen bereit, wobei das Verfahren umfaßt:
Decodieren der Syndrome durch Berechnung von Vektoren, welche von den vier Syndromen abhängig sind, in Abhängigkeit von zwei Fehlern in jeder einzelnen Aufzeichnung;
Berechnen von zwei Binärzahlen aus den Vektoren durch Nachschlagen in Tabellen;
Berechnen eines Wertes aus der Summe der Binärzahlen zum Zweck der Bestimmung des Ortes der zwei Fehler;
Bestimmung eines weiteren Wertes, der eine spezielle mathematische Abhängigkeit zu dem einen Wert hat, durch Nachschlagen in Tabellen und
Berechnen von Werten, die die Orte der Fehler dadurch identifizieren, daß ein Offset der Binärzahlen von dem weiteren Wert bestimmt wird.
Dementsprechend stellt die vorliegende Erfindung ebenfalls eine Vorrichtung zur Korrektur von zwei Bytefehlern in codierten unkorrigierten Daten in Aufzeichnungen vorgegebener Lange bereit, die aus einer Speichereinrichtung gelesen werden, indem vier Fehlersyndrome decodiert und verarbeitet werden, und zwar durch das Verfahren, das in einem der beigeiügten Ansprüche 1 bis 9 definiert ist, umfassend:
Mittel, die auf zwei Fehler in einer beliebigen Aufzeichnung reagieren, zum Decodieren der Syndrome durch Berechnung von Vektoren, welche von den vier Syndromen abhängig sind;
Mittel, die Logarithmier- und Delogarithmier-Nachschlagetabellen enthalten, zur Berechnung zweier Binärzahlen aus den Vektoren und
Mittel, die die Binärzahlen enthalten, zur Berechnung eines Wertes aus der Summe der Binärzahlen zu dem Zweck, die Orte der Fehler zu bestimmen,
Mittel zur Bestimmung eines weiteren Wertes, der eine spezielle mathematische Abhängigkeit zu dem einen Wert besitzt und
Mittel zur Berechnung von Werten, die die Orte der Fehler dadurch identifizieren, daß der Offset der Binärzahlen von dem anderen Wert berechnet wird.
Hiernach werden ein Verfahren und eine Vorrichtung zur Korrektur von bis zu zwei Bytefehlern in codierten unkorrigierten Daten in Aufzeichnungen vorgegebener Länge (wie beispielsweise ein voridentifizierter Subblock eines Blockes im Fall eines Mehrebenen- Eehlerkorrekturcode-Formates) offenbart. Die Daten werden von einer Speichereinrichtung gelesen und durch Decodieren und Verarbeiten von vier Fehlersyndromen (S&sub1;, S&sub2;, S&sub3;, S&sub0;) korrigiert, welche durch Mittel erzeugt werden, die in der vorhergehend erwähnten, ebenfalls anhängigen Patentanmeldung offenbart werden. Diese Syndrome werden in Abhängigkeit von unkorrigierten Fehlern in jeder beliebigen Aufzeichnung durch Berechnung von Vektoren P, Q und R decodiert, welche von den vier Syndromen abhängig sind. Aus diesen Vektoren werden dann durch Nachschlagen in Tabellen die Binärzahlen u und v berechnet, um darauf aufbauend für die Bestimmung der Fehlerorte die Berechnung eines Wertes d aus der Summe der Binärzahlen zu ermöglichen. Ein Wert t, der eine spezielle mathematische Abhängigkeit vom Wert d besitzt, wird dann durch Nachschlagen in Tabellen bestimmt, und die Fehlerortswerte y und z werden aus dem Offset der Binärzahlen u und v zum Wert t berechnet. Schließlich werden die Fehlermuster Ey und Ez durch Nachschlagen in Tabellen bestimmt.
Wie im besonderen dargestellt ist, werden Fehler in codierten unkorrigierten Daten in einem Plattenspeichersystem korrigiert, wobei ein Mehrebenen-Fehlerkorrekturcode verwendet wird, der als Block formatiert ist, wobei er eine Anzahl von Subblöcken enthält. Während einer Leseoperation werden für jeden Subblock Fehlersyndrome der ersten Ebene (S&sub1;, S&sub2;, S&sub3;,) und ein zusätzliches Syndrom (S&sub0;) der zweiten Ebene, das für alle Subblöcke gleichermaßen gilt, durch die Hardware der Speichereinrichtung erzeugt. Die Syndrome der ersten Ebene werden durch Nachschlagen in Tabellen decodiert, um ein Fehlermuster der ersten Ebene sowie Ortsinformationen bereitzustellen. Die Syndrome der zweiten Ebene werden durch Berechnung von Vektoren decodiert, welche von den Syndromen der ersten und der zweißen Ebene abhängig sind. Die Fehlerorte und Fehlermuster der zweiten Ebene werden durch Software oder Firmware unter Verwendung von Nachschiagetabellen bestimmt. Jede Korrektur von Fehlern wird später ausgeführt, indem Fehlerinformationen in einem asynchronen Modus abgesetzt werden.
Die vorliegende Erfindung wird zu Beispielzwecken weiter unter Bezug auf eine bevorzugte Ausführungstorm derselben, wie diese in den anhängenden Zeichnungen dargestellt ist, beschrieben werden, wobei gilt:
Fig. 1 zeigt das Datenformat einer Plattenspur, welches eine Zweiebenen-Codestruktur darstellt und
Fig. 2 ist ein Blockschaltbild der Korrekturabschnitte der ersten und der zweiten Ebene einer ECC-Vorrichtung einer Ausführungsform der vorliegenden Erfindung, das den Datenfluß verdeutlicht und die Hardware zeigt, die sich in der Speichereinrichtung befindet sowie die Software, die zum Speicher-Manager gehört.
Fig. 1 zeigt das Datenformat einer Plattenspur, welches eine Zweiebenen-Codestruktur darstellt. Wie dargestellt werden die Daten entlang einer Spur 11 aufgezeichnet, die in eine Mehrzahl von Blöcken 12 mit fester und variabler Länge formatiert ist.
Jeder Block 12 ist in Subblöcke 14 fester Länge unterteilt. Wie dargestellt, umfaßt jeder Subblock 14 zwei verschachtelte Codeworte 18, 19. Jedes Codewort 18, 19 umfaßt 48 Datenbytepositionen und drei Subblock-Prüfbytes C&sub1;, C&sub2;, C&sub3;. Jeder Block umfaßt somit Subblöcke, von denen jeder 96 (zwei Paare zu 48) Datenbytepositionen und drei Paare Subblock-Prüfbytes C&sub1;, C&sub2; und C&sub3; besitzt. Zusätzlich werden an das Ende jedes Blockes 12 innerhalb eines Feldes für Blockprüfbytes 15 vier Prüfbytes CR&sub1; bis CR&sub4; zur Datenintegritätssicherung nach der ECC-Korrektur sowie ein Paar Prüfbytes C&sub0; zur Fehlerkorrektur der zweiten Ebene angefügt. Die Art und Weise, in welcher die Fehlerkorrektur-Prüfbytes C&sub1; bis C&sub3; in jedem Subblock 12 und die Prüfbytes CR&sub1; bis CR&sub4; und C&sub0; am Ende jedes Blockes 12 bestimmt und erzeugt werden, ist nicht Bestandteil der vorliegenden Erfindung. Der Leser wird für eine detaillierte Erklärung auf die im vorhergehenden erwähnte, ebenfalls anhängige Patentanmeldung verwiesen. In der folgenden Beschreibung der vorliegenden Erfindung werden alle Prozeßschritte für eine der zwei Phasen (gerade oder ungerade) beschrieben werden. Es soll jedoch verstanden werden, daß dieselben Schritte und derselbe Prozeß für die andere Phase wiederholt werden.
Wir beziehen uns jetzt auf Fig. 2. Von einem Datenverarbeitungssystem (nicht dargestellt) werden Daten über eine Steuereinrichtung oder den Speicher-Manager 20 an die Speicherplatte 21 des Plattenspeichersystems 100 gesendet, um diese auf eine Spur zu schreiben, welche, wie in Fig. 1 dargestellt, formatiert ist. Beim Schreiben und Übertragen dieser Daten werden drei Sätze Prüfbytes C&sub1;, C&sub2; und C&sub3; für jeden Subblock durch einen ECC-Codierer 22 aufgebaut. Das Blockprüfbyte C&sub0; (und die Datenintegritäts-Prüfbytes CR&sub1; bis CR&sub4;) werden ebenfalls durch den Codierer 22 aufgebaut. Eine Subblock-Formatiereinrichtung 22A hängt die Prüfbytes C&sub1;, C&sub2; und C&sub3; an jeden entsprechenden Subblock an. Eine Block-Formatiereinrichtung 22B hängt das Blockprüfbyte C&sub0; (sowie die Datenintegritäts-Prüfbytes CR&sub1; bis CR&sub4;) an das Ende des Blockes an. Die formatierten Daten werden dann auf die Speicherplatte 21 aufgezeichnet. Die Berechnung und die Verarbeitung der Datenintegritäts-Prütbytes CR&sub1; bis CR&sub4; ist nicht Bestandteil der vorliegenden Erfindung und wird in der U.S.-Patentschrift Nr. 4 703 485 vom 27. Oktober 1987 beschrieben.
Beim Rücklesevorgang werden die gelesenen Daten durch die Codiergleichungen (1), (2), (4) und (5) der vorhergehend erwähnten, ebenfalls anhängigen Patentanmeldung geprüft, um die Syndrome der Fehler auf konventionelle Art und Weise aufzubauen. Die Subblock-Prüfbytes C&sub1;, C&sub2; und C&sub3; sind mit den Syndromen S&sub1;, S&sub2; und S&sub3; verbunden, während das Prüfbyte der Blockebene C&sub0; mit dem Syndrombyte S&sub0; verbunden ist.
Die tiefgesetzten Zahlen, die den Syndromen zugeordnet sind, z.B. S&sub1;, S&sub2; usw. beziehen sich auf die spezielle T-Matrix, die verwendet wird, um die entsprechenden Prüfzeichen zu erzeugen. Im besonderen entspricht S&sub0;, das aus C&sub0; abgeleitet wird, einem konventionellen Paritäts-Prüfbyte. Andererseits wird S&sub3; von C&sub3; abgeleitet, welches entsprechend einer Logik gebildet wird, die das Multiplizieren des Eingangsbytes mit einer Matrix T³ einschließt. Die Syndrome S&sub1; und S&sub2;, welche den Prüfbytes C&sub1; beziehungsweise C&sub2; entsprechen, werden ähnlich erzeugt und zwar unter Verwendung einer Logik, welche das Multiplizieren mit Matrizen T¹ beziehungsweise T² einschließt. Solch eine Logik zur Erzeugung der Syndrome ist wohlbekannt und nicht Bestandteil der vorliegenden Erfindung.
Beim Rücklesevorgang werden unkorrigierte Daten von der Platte 21 in einen Syndromgenerator 23 der ersten Ebene und in einen Syndromgenerator 25 der zweiten Ebene eingelesen, welche die Syndrombytes S&sub1;, S&sub2;, S&sub3; der ersten Ebene für jeden Subblock und das Syndrom S&sub0; der zweiten Ebene, welches für alle Subblöcke des Blockes gilt, erzeugen. Die Syndrombytes S&sub1;, S&sub2;, S&sub3; werden zu einem Decoder 24 der ersten Ebene in den Speicher-Manager 20 übertragen, um in Fehlermuster-Daten decodiert zu werden. Der in Software implementierte Decodiervorgang des Decoders 24 wird weiter unten in einem separaten Abschnitt mit dem Titel "Decodiervorgang der ersten Ebene" beschrieben.
Kurz gesagt, ein von Null verschiedener Wert von S&sub1;, S&sub2; oder S&sub3; zeigt einen Fehler an. Wenn ein Subblock nur ein fehlerhaftes Byte besitzt, wird dessen Platz x und das Fehlermuster Ex, wie es durch den Decoder 24 bestimmt wird, an die Software 26 zur Korrektur des entsprechenden Bytes, das aus dem Subblock-Puffer 27 geholt wird, weitergegeben. Nach der Korrektur wird dieses Byte in den Puffer 27 zurückgespeichert. Das Fehlermuster Ex wird für jeden Subblock, bei dem eine Korrektur der ersten Ebene für einen Fehler durchgeführt wird, ebenfalls in dem lokalen Speicher 28 gespeichert. Das Syndrom der zweiten Ebene S&sub0; wird an der Stelle 29 durch die Software modifiziert, um die Fehlermusterinformationen Ex, die allen korrigierten Subblöcken entspricht, einzubeziehen. Wenn der Decoder 24 einen von Null verschiedenen Wert für S&sub1;, S&sub2; oder S&sub3; empfangen hat und nicht in der Lage ist, den Subblock zu korrigieren, zeigt er das Auftreten von mehr als einem Fehler innerhalb des Subblockes dadurch an, daß er einen Subblock-Identifikator f für den lokalen Speicher 28 bereitstellt. Die nicht verarbeiteten Syndrome S&sub1;, S&sub2; und S&sub3; des Subblockes f werden durch den Decoder der zweiten Ebene für eine spätere Verarbeitung ebenfalls an den lokalen Speicher weitergeleitet. Die Decodiersoftware 30 der zweiten Ebene kombiniert das Syndrom S&sub0; mit den Syndromen S&sub1;, S&sub2;, S&sub3; aus dem lokalen Speicher 28 und konvertiert dieses kombinierte Eingangssignal durch Nachschlagen in Tabellen in die Ausgangssignale y und z, die Anzeigen für die Fehlerorte sind sowie in Ey und Ez, die die Fehlermuster wiedergeben. Diese Ausgangssignale y, z, Ey, Ez werden mit dem Identifikator f des fehlerhaften Subblockes kombiniert, um zu bewirken, daß die fehlerhaften Bytes By und Bz korrigiert werden. Die Fehlerkorrektursoftware 31 der zweiten Ebene liest die Subblöcke aus dem Puffer 27 und liefert die korrigierten Daten, indem die Korrektur der Bytes By und Bz des Subblockes f unter Verwendung der Fehlerortsinformation y, z und der Fehlermuster Ey und Ez durchgeführt wird.
Das grundlegende Zweiebenen-ECC-Korrekturschema, wie es in der vorhergehend erwähnten, ebenfalls anhängigen Patentanmeldung beschrieben wird, hat n Subblöcke innerhalb eines Blockes mit N Bytes in jedem Subblock. Die Decodierfähigkeit in der ersten Ebene gestattet die Korrektur von bis zu einem Bytefehler in jedem der Subblöcke. Die Möglichkeit, die zweite Decodierebene einzubeziehen, gestattet die Korrektur von bis zu zwei Bytefehlern in einem Subblock und einem Bytefehler in allen anderen Subblöcken eines Blockes.
Der grundlegende Fehlerfall ist ein "fehlerhaftes Byte". Ein Signalpaketfehler kann korrelierte Fehler in benachbarten Bytes hervorrufen. Es kann jedoch angenommen werden, daß durch ein ausreichendes Verschachteln diese Fehler wirksam zufällig verteilt werden. Bei geeigneter Verschachtelung ist die Wahrscheinlichkeit, daß ein Fehler auftritt, für alle Bytes gleich, wie durch das Fehlerkorrektur-Codierschema (ECC - error correction code) zu erkennen ist. Jedes Byte enthält eine vorher ausgewählte Anzahl von Bits m, und die entsprechenden Operationen für die Fehlerkorrekturcodierung werden mit einem finiten Feld GF(2m) von 2m Elementen ausgeführt. Wie dargestellt, ist m gleich 8, und das finite Feld, GF(2&sup8;), hat 256 Elemente.

Mathematischer Hintergrund - Logarithmen der Feldelemente

Man bezeichne mit G(x) ein einfaches Polynom achten Grades mit binären Koeffizienten.
G(x) = g&sub0; g&sub1;x g&sub2;x² ... g&sub7;x&sup7; x&sup8;
Die zu dem Polynom G(x) gehörende Matrix ist als die folgende nichtsinguläre Matrix definiert:
Die Matrix Ti bezeichnet die Matrix T, i-mal mit sich selbst multipliziert und alle Zahlen modulo 2 reduziert. Die Matrizen T, T², T³, ... , T²&sup5;&sup5; sind alle voneinander verschieden, und T²&sup5;&sup5; ist die Einheitsmatrix, die auch als T&sup0; geschrieben werden kann. Diese 255 Matrizen repräsentieren von Null verschiedene Elemente von GF(2&sup8;). Also repräsentiert Ti für alle i das von Null verschiedene Element ai. Das Nullelement wird durch die 8x8-Natrix repräsentiert, welche nur Nullen enthält. Die Summen- und Produktbildungen werden in GF(2&sup8;) durch Modulo-2 Matrix-Additions- und Matrix-Multiplikations-Operationen unter Verwendung der Matrixdarstellungen der Feldelemente definiert.
Die Elemente von GF(2&sup8;) können auch durch 8stellige binäre Vektoren dargestellt werden. Die quadratischen Matrizen der obigen Darstellung sind stark redundant. Tatsächlich kann jede Matrix durch genau eine ihrer Spalten (in einer speziellen Position) eindeutig identifiziert werden, welche für die unzweideutige Darstellung des entsprechenden Feldelementes sehr gut verwendet werden kann. Im besonderen wird bei den 8x8 Matrizen des oberen Satzes normalerweise die erste Spalte als 8stellige Vektordarstellung der entsprechenden Feldelemente verwendet. Dadurch wird eine Eins-zu-Eins-Beziehung zwischen dem Satz aller 8stelligen, von Null verschiedenen Vektoren und dem Satz der Ti Matrizen, die die Feldelemente ai repräsentieren, aufgebaut. Folglich entspricht jedem 8stelligen, von Null verschiedenen Vektor S ein einziger Integerwert i (0 ≤ i ≤ 254), welcher als dessen Logarithmus zur Basis a betrachtet werden kann.
Anhang A.1 ist eine Logarithmentabelle, welche alle Feldelemente auf Potenzen von a abbildet. Anhang A.2 ist eine Delogarithmiertabelle, welche die ganzzahligen Potenzen von a auf die entsprechenden Feldelemente abbildet. Diese Tabellen werden unter Verwendung der folgenden zugehörigen Matrix T als Darstellung des Grundelementes a erzeugt.
T =
Mit Hilfe dieser Tabellen kann das Produkt A&sub1; x A&sub2; (der zwei Elemente, die durch die 8stelligen Vektoren A&sub1; und A&sub2; repräsentiert werden) wie folgt berechnet werden:
A&sub1; = ai1 Verwende Logarithmiertabelle: loga A&sub1; = i&sub1;
A&sub2; = ai2 Verwende Logarithmiertabelle: loga A&sub2; = i&sub2;
A&sub1; x A&sub2; = ai1+i2 Addiere (modulo 255): i = i&sub1; + i&sub2;
ai = A Verwende Delogarithmiertabelle: loga&supmin;¹ i = A
Jede Tabelle benötigt einen Speicher von 8x256 Bits, für welchen die Wortzahl oder der Speicherplatz, der als 8-Bit-Vektor dargestellt ist, den Eingangsvektor bildet. Der auf diesem Speicherplatz gespeicherte 8-Bit-Vektor repräsentiert in den zwei Tabellen den Logarithmus beziehungsweise den inversen Logarithmus des Eingangsvektors. Es ist zu beachten, daß A = 0 (der Nullvektor) unter Verwendung der Logarithmier- und Delogarithmiertabellen nicht verarbeitet werden kann. Folglich müßte er als Sonderfall wie folgt behandelt werden: Die Multiplikation mit Null erzeugt immer eine Null und eine Division durch Null darf nicht zugelassen werden.

Decodierprozeß der ersten Ebene: Korrektur einzelner Fehler

Wie hier gezeigt wird, kann das Decodieren der Fehler der ersten Ebene unter Verwendung von softwaregestützten Verfahren durchgeführt werden, die das Nachschlagen in Tabellen einbeziehen.
Ein von Null verschiedener Wert für S&sub1;, S&sub2; oder S&sub3; zeigt das Auftreten eines Fehlers an. Nehmen wir an, der Subblock besitzt nur ein fehlerhaftes Byte (Byte x), dann besteht folgende Beziehung zwischen dem gelesenen Byte x und dem geschrieben Bx,
= Bx Ex (1)
wobei Ex das Fehlermuster im Byte x ist.
Wenn der Subblock nur ein fehlerhaftes Byte (Byte x) besitzt, bestehen folgende Beziehungen zwischen den Syndromen und Ex:
S&sub1; = Tx Ex (2)
S&sub2; = T2x Ex (3)
S&sub3; = T3x Ex (4)
Die Gleichungen (2), (3) und (4) sind als Beziehungen zwischen Feldelementen in GF(2&sup8;) anzusehen. Im besonderen repräsentiert die Matrixmultiplikation des Typs TiB das Produkt der Feldelemente ai und @, wobei ai durch die erste Spalte der Matrix Ti und @ durch den Spaltenvektor B repräsentiert werden.
Die Produktbildung in GF(2&sup8;) wurde oben mit Bezug auf die Logarithmier- und Delogarithmiertabellen (Anhänge A.1 beziehungsweise A.2) zur Basis a bereits diskutiert, wobei a ein einfaches Feldelement darstellt. Mit Hilfe dieser Tabellen kann die Fehlerposition oder der Positionswert x aus den Gleichungen (2), (3) und (4) wie folgt berechnet werden:
x = (logaS&sub2; - logaS&sub1;) modulo 255 (5)
Auch gilt:
x = (logaS&sub3; - IogaS&sub2;) modulo 255
Das Fehlermuster Ex kann aus den Gleichungen (2) und (5) wie folgt berechnet werden:
Ex = loga&supmin;¹ (logaS&sub1; - x) modulo 255 (6)
In den Gleichungen (5) und (6) sind alle Terme 8stellige Binärzahlen. In den Modulo-255-Berechnungen ist die Subtraktion einer 8stelligen Binärzahl gleich der Addition ihres Komplementes. Dazu ist es günstig, einen 8stelligen Binäraddierer mit Ende- Übertrag zu verwenden, bei welchem die nur aus Einsen bestehende 8stellige Zahl (Wert 255) die Zahl Null repräsentiert und ein positiver Überlauf (Wert 256) der Zahl Eins entspricht.
Jede Berechnung von x erfordert zwei Zugriffe auf die Logarithmiertabelle (Anhang A.1) und eine Modulo-255-Subtraktion. In gleicher Weise erfordert die Berechnung von Ex einen Zugriff auf die Delogarithmiertabelle (Anhang A.2). Das Byte Bx wird dann zu x + Ex korrigiert.
Es ist zu beachten, daß der Fehler im Prüfbyte C&sub2; liegt, wenn S&sub1; = S&sub2; und S&sub3; ≠ 0 ist. In Gleichung (5) wird x auf zwei Arten berechnet. Das Ergebnis dieser Berechnungen muß dasselbe sein, ansonsten ist mehr als ein Byte fehlerhaft. Auch wenn S&sub1; ≠ S&sub2; und S&sub1; oder S&sub2; gleich Null ist, ist mehr als ein Byte fehlerhaft. Der Subblock weist in diesem Fall Fehler auf, wird aber durch die Verarbeitungsschritte der ersten Ebene nicht korrigiert. Ein solcher Subblock wird durch die Subblocknummer f identifiziert, und die entsprechenden Syndrome S&sub1;, S&sub2;, S&sub3; werden im lokalen Speicher gespeichert und für eine spätere Verarbeitung an die zweite Ebene weitergegeben.

Decodierprozeß der zweiten Ebene: Korrektur zweier Fehler

Nehmen wir an, daß nur ein Subblock zwei fehlerhafte Bytes aufweist, die durch y und z gekennzeichnet werden und die Fehlermuster Ey beziehungsweise Ez aufweisen. Die Syndrome S&sub0;, S&sub1;, S&sub2; und S&sub3; stehen zu Ey und Ez in folgenden Beziehungen:
S&sub0; = Ey Ez (7)
S&sub1; = Ty Ey Tz Ez (8)
S&sub2; = T2y Ey T2z Ez (9)
S&sub3; = T3y Ey T3z Ez (10)
Die Verarbeitung der ersten Ebene des entsprechenden Subblockes hat die Fehler als mehrfache Fehler erkannt. Weil S&sub1;, S&sub2; und S&sub3; auf der Subblockebene verfügbar sind, korrigiert die Verarbeitung auf Subblockebene diese Fehler nicht fälschlicherweise als Ein-Symbol-Fehler Ex auf Position x.
Anhang B erklärt die Theorie, die hinter dem Decodieralgorithmus steht, welcher zum Decodieren des kombinierten Satzes aus Subblock- und Blockebenen-Syndromen bei Zwei-Symbol-Fehlern verwendet wird. Zuerst erhält man die Vektoren P, Q und R. Wie dargestellt sind dies 8stellige Konstanten, die von den Syndromen S&sub0;, S&sub1;, S&sub2; und S&sub3; wie folgt abhängen:
P = (S&sub2; x S&sub2;) (S&sub3; x S&sub1;) (11)
Q = (S&sub2; x S&sub1;) (S&sub3; x S&sub0;) (12)
R = (S&sub0; x S&sub2;) (S&sub1; x S&sub1;) (13)
Dabei kennzeichnet x die Produktbildung der Feldelemente in GE(2&sup8;), und die Feldelemente werden durch 8stellige Vektoren repräsentiert. Die Produktbildung kann unter Verwendung fest verdrahteter Logik oder durch Verwendung der Logarithmier- und Delogarithmiertabellen in GF(2&sup8;) durchgeführt werden.
Es ist zu beachten, daß P, Q und R notwendigerweise von Null verschieden sind, wenn zwei Bytes des Subblockes fehlerhaft und beide Datenbytes sind. Im Gegensatz dazu, zeigt P = 0 beziehungsweise R = 0 an, daß die zwei fehlerhaften Bytes ein fehlerhaftes Prüfbyte C&sub1; oder C&sub2; enthalten.
Nehmen wir nun an, es seien genau zwei fehlerhafte Bytes in einem der Subblöcke. Die Fehlerortswerte y und z sind zwei eindeutige Lösungen von i aus der Gleichung:
T-2iP T-iQ = R (14)
wobei P, Q und R derart von den Syndromen S&sub0;, S&sub1;, S&sub2; und S&sub3; abhängig sind, wie dies durch die Gleichungen (11) bis (13) angegeben wird.
Für jede der zwei Lösungen von i ist das Fehlermuster gegeben durch:
Ei = R/ (T2i S&sub0; S&sub2;) (15)
Der Beweis dessen erscheint in Anhang B.
Das Decodieren des kombinierten Satzes von Syndromen auf Subblock- und Blockebene kann unter Verwendung von softwaregestützten Verfahren, die das Nachschlagen in Tabellen einbeziehen, durchgeführt werden. Die Vektoren P, Q und R werden aus den Syndromen S&sub0;, S&sub1;, S&sub2; und S&sub3; unter Verwendung der Logarithmier- und Delogarithmiertabellen der Anhänge A.1 beziehungsweise A.2 berechnet. Dies erfordert in den meisten Fällen achtzehn Zugriffe auf die im Speicher stehenden Tabellen, sechs binäre Additionen (modulo 255) und drei Vektor-Additionen (modulo 2). Die Werte der Fehlerorte y und z kann man aus einem einfachen Nachschlagen in einer Tabelle erhalten. Die Tabelle und die Theorie, die sich hinter diesem Ablauf verbergen, erscheinen in Anhang C. Die Werte der Fehlerorte erhält man aus folgendem vierschrittigen Verfahren.
Schritt 1: Man erhält unter Verwendung der Logarithmier- und Delogarithmiertabelle des Anhangs A.1 beziehungsweise A.2 zwei Binärzahlen u und v, wobei gilt:
u = (logaP - logaQ) modulo 255 (16)
v = (logaR - logaQ) modulo 255 (17)
Schritt 2: Berechne als einen Schritt in Richtung Bestimmung der Orte der zwei Fehler aus der Summe der zwei Binärzahlen den Wert d wie folgt:
d = (u + v) modulo 255 (18)
Schritt 3: Man erhält den Wert t, der eine spezielle mathematische Abhängigkeit vom Wert d besitzt aus der Tabelle des Anhangs C.1.
Schritt 4: Man erhält die Werte der Fehlerorte y und z durch Berechnung des Offsets der Binärzahl vom Wert t nach folgenden Gleichungen:
y = (u - t) modulo 255 (19)
z = (t - v) modulo 255 (20)
In den Gleichungen (16) bis (20) des obigen Verfahrens sind alle Terme 8stellige Binärzahlen, die Modulo-255-Additionen oder -Subtraktionen unterliegen. Das Verfahren erfordert vier Zugriffe auf die Tabellen, vier Modulo-255-Subtraktionen und eine Modulo-255-Addition. Innerhalb dieses Verfahrens zeigt ein ungültiger d-Wert (einer mit keinem Eintrag in Anhang C.1) oder ein ungültiger Wert des Fehlerortes von y oder z (größer als m + 1) an, daß ein nicht korrigierbarer Fehler vorliegt, bei dem drei oder mehr Bytes fehlerhaft sind.
Das Fehlermuster Ey kann unter Verwendung der Logarithmier- und Delogarithmiertabellen (Anhänge A.1 beziehungsweise A.2) entsprechend Gleichung (15) berechnet werden, in welcher die Matrixmultiplikation T2yS&sub0; durch das entsprechende Feldelement ersetzt wird, was durch das Produkt von zwei Feldelementen a2y x S&sub0; gegeben ist.
Das Fehlermuster E kann in gleicher Weise unter Verwendung von Gleichung (15) oder alternativ dazu von Gleichung (9) berechnet werden, welche liefert:
Ez = S&sub0; Ey (21)
Die Fehlerkorrektur des Subblockes wird dann durch Korrektur der Bytes By und B&sub2; mit den Fehlermustern Ey und Ez durchgeführt.
Wenn auch die Ausführungsform, so wie sie dargestellt worden ist, eine Zweiebenen-Codestruktur voraussetzt, bei welcher ein Ein-Byte-Fehler in einem Codewort in der ersten Ebene korrigierbar und ein Zwei-Byte-Fehler in einem Codewort in der Blockebene korrigierbar ist, sollte verständlich sein, daß das Verfahren und die Vorrichtung zur Korrektur von zwei Bytefehlern in beliebigen Einzel- oder Mehrebenen-Codestrukturen verwendet werden kann.
Man sollte ebenfalls erkennen, daß das offenbarte Verfahren und die Vorrichtung auch dazu verwendet werden können, die Syndrome von Zwei-Byte-Fehlern in einer Aufzeichnung mit einer vorgegebenen Anzahl von Bytes, bei der jedes Byte eine vorgewählte Anzahl Bits enthält, zu decodieren.
Wenn auch das Verfahren und die Vorrichtung, so wie sie offenbart wurden, Fehler in unkorrigierten codierten Daten in einem magnetischen Plattenspeichersystem korrigieren, so sind sie doch in gleicher Weise auf Daten anwendbar, die auf einem Band oder in einer optischen Speichereinrichtung gespeichert werden und auf Daten, die zum Senden oder beim Empfang zwischengespeichert werden.
Schließlich sollte verständlich sein, daß das Decodieren der (einzelnen) Fehler der ersten Ebene an Stelle der hier beschrieben Softwareimplementierung auch durch eine Hardware erfolgen kann, wenn dies vorgezogen wird, so wie es im U.S.-Patent Nr. 4 528 838 vom 25. Juni 1985 beschrieben wird.
Es wird deshalb für den Fachmann verständlich sein, daß die vorstehenden und andere Anwendungen und/oder Implementierungen bezüglich des hierin beschriebenen Verfahrens und der Vorrichtung gemacht werden können, ohne daß man das Gebiet der Erfindung, so wie es in den anhängenden Ansprüchen definiert wird, verläßt. Anhang A.2 Delogarithmiertabelle (Basis a) in GF(2&sup8;)/ai = S Anhang A.1 Logarithmiertabelle (Basis a) in GF(2&sup8;)/loga S = i

Anhang B

Theorie des Decodierens von Zwei-Symbol-Fehlern

Dieser Anhang B liefert den Hintergrund für den Decodieralgorithmus von Zwei-Symbol-Fehlern. Er wird aus dem Chien-Suche genannten Verfahren abgeleitet, welches dem Stand der Technik entsprechend wohlbekannt ist und für die Decodierung des verallgemeinerten BCH-Codes verwendet wird, welcher in dem im Abschnitt über den Stand der Technik zitierten Artikel von Chien beschrieben wird.
Nehmen wir an, daß genau zwei fehlerhafte Bytes in einem Subblock auftreten. Mit dem folgenden Beweis wird herausgearbeitet, daß die Werte der Fehlerorte y und z zwei eindeutige Lösungen der folgenden Gleichung sind,
T-2iP T-iQ = R (B-1)
wobei P, Q und R derart von den Syndromen S&sub0;, S&sub1;, S&sub2; und S&sub3; abhängig sind, wie dies durch die Gleichungen (11) bis (13) angegeben wird. Die Fehlermuster Ei erfüllen für i = y und i = z die folgende Gleichung:
R = (T2i S&sub0; S&sub2;) Ei (B-2)
Beweis: Die Syndrome werden in den Gleichungen (7) bis (10) als Funktionen der zwei Fehler dargestellt. Diese Gleichungen werden hier wiedergegeben als:
S&sub0; = Ey Ez (B-3)
Si = Ty Ey Tz Ez (B-4)
S&sub2; = T2y Ey T2z Ez (B-5)
S&sub3; = T3y Ey T3z Ez (B-6)
Durch geeignete Kombination der Gleichungen (B-3) bis (B-6) erhält man:
Ty S&sub0; S&sub1; = (Ty Tz) Ez (B-7)
Ty S&sub1; S&sub2; = Tz (Ty Tz) Ez (B-8)
Ty S&sub2; S&sub3; = T2z (Ty Tz) Ez (B-9)
Die Matrizengleichungen (B-7), (B-8) und (B-9) sind Beziehungen zwischen Feldelementen in GF(2&sup8;), dargestellt durch Matrizen. Im besonderen stellt die Matrixmultiplikation des Typs TiB das Produkt der Feldelemente ai und @ dar, wobei ai durch die erste Spalte der Matriy Ti und @ durch den Spaltenvektor B repräsentiert werden. Im Sinne dieser Interpretation führen die Gleichungen (B7), (B-8) und (B-9) zu folgender Beziehung:
(Ty S&sub0; S&sub1;) (Ty S&sub2; S&sub3;) = (Ty S&sub1; S&sub2;)² (B-10)
wobei das Produkt der entsprechenden Elemente in GF(2&sup8;) bezeichnet. Die Gleichung (B-10) kann so umgestellt werden, daß sich folgende Matrizengleichung ergibt:
T2yR TYQ P = 0 (B-11)
In diesen Gleichungen sind P, Q und R Spaltenvektoren, die gegeben sind durch:
P = (S&sub2; S&sub2;) (S&sub3; S&sub1;) (B-12)
Q = (S&sub2; S&sub1;) (S&sub3; S&sub0;) (B-13)
R = (S&sub0; S&sub2;) (S&sub1; S&sub1;) (B-14)
Somit ist y eine Lösung für i in folgender Gleichung:
T-2iP T-iQ = R (B-15)
Dadurch daß in obigem Verfahren die Variablen y und z vertauscht werden, kann man zeigen, daß z die zweite Lösung für i entsprechend Gleichung (B-15) ist.
Die Gleichung (B-2) kann für jedes Fehlermuster durch direkte Substitution der Werte für R, S&sub0;, S&sub1; und S&sub2; verifiziert werden. Beide Seiten der Gleichung (B-2) reduzieren sich auf den Ausdruck:
(T2Y T2z) (Ey Ez) (B-16)
womit der Beweis vollständig ist.

Anhang C

Tabellenlösung für Zwei Fehlerorte

In Anhang B ist gezeigt worden, daß die Fehlerorte y und z von zwei in einem Subblock auftretenden Fehlern durch Lösung der Gleichung (B-1) nach i bestimmt werden können. Diese Gleichung ist hier wiedergegeben als:
T-2iP T-iQ = R (C-1)
Die Konstanten P, Q und R sind von den Syndromen S&sub0;, S&sub1;, S&sub2; und S&sub3; abhängig, wie dies durch die Gleichungen (B-12) bis (B-14) beschrieben wird. Wir können die Logarithmen von P, Q und R aus den Logarithmier-Delogarithmiertabellen der Anhänge A.1 und A.2 erhalten.
p = logaP (C-2)
q = logaQ (C-3)
r = logaR
Dann kann die Matrizengleichung (C-1) als Beziehung zwischen Feldelementen in GF(2&sup8;) wie folgt umgestellt werden:
a-2i ap a-i aq = ar (C-5)
Indem beide Seiten der Gleichung (C-5) mit ap-2q multipliziert werden, erhält man:
a(-2i+2p-2q) a(-i+p-q) =a(r+p-2q) (C-6)
Indem man (-i + p - q) in Gleichung (C-6) durch t substituiert, ergibt sich:
a2t at = a(r+p-2q) (C-7)
und i = (u) - t , wo u = p - q (C-8)
Die rechte Seite von Gleichung (C-7) ist ein bekanntes Feldelement ad, bei dem für den Exponenten d gilt:
d = u + v , mit u = p - q und v = r - q (C-9)
Für Gleichung (C-7) wird dann durch Nachschlagen in Tabellen eine Lösung bereitgestellt, die wie folgt ausgedrückt werden kann:
at (at a&sup0;) = ad (C-10)
Unter Verwendung dieses Ausdruckes kann jeder Wert von t (von 0 bis 254) auf einen Wert von d bezogen werden. Es ist zu beachten, daß einige d-Werte in diesen Beziehungen fehlen und daß jedem gültigen- u-Wert zwei Werte von t entsprechen. Für einen gegebenen Wert von d gilt, wenn t = t&sub1; eine Lösung von Gleichung (C-10) ist, dann wird deutlich, daß auch t = t&sub2; ebenfalls eine Lösung ist, wobei gilt:
at2 = at2 a&sup0; (C-11)
Indem t = t&sub1; in Gleichung (C-10) substituiert und dann (C-11) verwendet wird, ergibt sich:
ati at2 = ad (C-12)
Folglich gilt
d = t&sub2; + t&sub1; (C-13)
Aus den Gleichungen (C-8), (C-9) und (C-13) können folgende zwei Werte für die Fehlerorte i1 und i2 erhalten werden:
i&sub1; = u - t&sub1; (C-14)
i&sub2; = u - t&sub2; = t&sub1; - v (C-15)
Anhang C.1 bezieht jeden Wert von d auf einen der zwei Werte von t. Die d-Werte sind in aufsteigender Reihenfolge aufgelistet, damit über die Adressen eines 8x256-Bit-Speichers ein einfacher Zugriff gewährleistet ist. Der zugeordnete Wert von t ist in dem Speicher als 8-Bit-Binärzahl gespeichert. Auf Adressen, die ungültigen Werten von d entsprechen, ist der Nullvektor (ungültige Werte sind durch Striche in der Tabelle gekennzeichnet) gespeichert und wird dementsprechend interpretiert.
Im Eail von zwei Fehlern, wird über den berechneten d-Wert einer der zwei t-Werte aus Anhang C.1 gelesen. Mit diesem einen t-Wert liefern die Gleichungen (C-14) und (C-15) die beiden Werte für i als die Fehlerorte y und z. Ein ungültiger d-Wert liest einen Wert t = 0 aus Anhang C.1, welcher als ein unkorrigierbarer Fehler interpretiert wird, der drei oder mehr Bytes des Codewortes einbezieht. Anhang C.1 Tabelle t = f(d) entsprechend ad = at(at + a&sup0;)/ Beachte: Das Fehlen eines Wertes für t impliziert einen ungültigen Wert von d.

Claims

1. Verfahren zur Korrektur von zwei Bytefehlern in codierten unkorrigierten Daten in Aufzeichnungen vorgegebener Länge, die aus einer Speichereinrichtung gelesen werden, durch Decodieren und Verarbeiten von vier Fehlersyndromen (S&sub0;, S&sub1;, S&sub2;, S&sub3;), wobei das Verfahren umfaßt:

Decodieren der Syndrome durch Berechnung von Vektoren (P, Q, R), welche von den vier Syndromen abhängig sind, in Abhängigkeit von zwei Fehlern in jeder einzelnen Aufzeichnung;

Berechnen von zwei Binärzahlen (u, v) aus den Vektoren durch Nachschlagen in Tabellen;

Berechnen eines Wertes (d) aus der Summe der Binärzahlen zum Zweck der Bestimmung des Ortes der zwei Fehler;

Bestimmung eines weiteren Wertes (t), der eine spezielle mathematische Abhängigkeit zu dem einen Wert hat, durch Nachschlagen in Tabellen und

Berechnen von Werten (y, z), die die Orte der Fehler dadurch identifizieren, daß ein Offset der Binärzahlen von dem weiteren Wert bestimmt wird.

2. Verfahren nach Anspruch 1, umfassend die Berechnung der Eehlermuster durch Nachschlagen in Tabellen.

3. Verfahren nach Anspruch 2, umfassend die Verwendung von Logarithmier- und Delogarithmiertabellen zur Berechnung der Vektoren aus den vier Syndromen und zur Berechnung der Fehlermuster.

4. Verfahren nach einem der vorhergehenden Ansprüche, dadurch gekennzeichnet, daß jedes Syndrom aus b binären Bits besteht und daß die Binärzahlen u und v aus den Vektoren durch Nachschlagen in Tabellen berechnet werden, wie beispielsweise

u = (logaP - logaQ) modulo (2b - 1)

v = (logaR - logaQ) modulo (2b - 1) und

die Binärzahl d ist die folgende Binärzahl

d = (u + v) modulo (2b - 1).

5. Verfahren nach Anspruch 4, umfassend

Bestimmung eines Wertes t, der eine spezielle mathematische Abhängigkeit von dem Wert d besitzt, aus einer Nachschlagetabelle, wobei der Wert von d für jeden von (2b - 1) Werten von t dadurch vorgegeben wird, daß der Wert von d unter Verwendung eines Ausdruckes berechnet wird, welcher für jeden gültigen Wert von d zwei Werte von t bereitstellt und

im Kall von zwei Fehlern, ausgehend von dem berechneten Wert von d Lesen eines der zwei t-Werte zum Zweck der Be-Stimmung der Orte der Fehler.

6. Verfahren nach Anspruch 5, dadurch gekennzeichnet, daß der Wert t, der dem Wert d entspricht, aus einer Nachschlagetabelle von t in Abhängigkeit von d mit ad = at (at + a&sup0;) erhalten wird und

daß die Werte der Fehlerorte y und z zu

y (u - t) modulo (2b - 1) und

z = (t - v) modulo (2b - 1)

bestimmt werden.

7. Verfahren nach einem der Ansprüche 4 bis 6, dadurch gekennzeichnet, daß die Vektoren P, Q und R unter Verwendung einer Logarithmiertabelle a logaS = i und einer Delogarithmiertabelle ai = S in GF(2b) aus den vier Syndromen berechnet werden, wobei GF(2b) ein finites Feld von 2b Elementen repräsentiert.

8. Verfahren nach Anspruch 7, dadurch gekennzeichnet, daß die Fehlermuster Ey und Ez unter Verwendung der Logarithmier- und Delogarithmiertabellen wie folgt berechnet werden:

Ey = R/(T2y S&sub0; + S&sub2;) und

Ez= S&sub0; + Ey.

9. Verfahren nach Anspruch 7, dadurch gekennzeichnet, daß b gleich 8 ist und modulo (2b - 1) damit modulo 255 ist.

10. Vorrichtung zur Korrektur von zwei Bytefehlern in codierten unkorrigierten Daten in Aufzeichnungen vorgegebener Länge, die aus einer Speichereinrichtung gelesen werden, indem vier Fehlersyndrome decodiert und verarbeitet werden, und zwar durch ein Verfahren nach einem der vorhergehenden Ansprüche, umfassend:

Mittel, die auf zwei Fehler in einer beliebigen Aufzeichnung reagieren, zum Decodieren der Syndrome durch Berechnung von Vektoren, welche von den vier Syndromen abhängig sind;

Mittel, die Logarithmier- und Delogarithmier-Nachschlagetabellen enthalten, zur Berechnung zweier Binärzahlen aus den Vektoren und

Mittel, die die Binärzahlen enthalten, zur Berechnung eines ertes aus der Summe der Binärzahlen zu dem Zweck, die Orte der Fehler zu bestimmen,

Mittel zur Bestimmung eines weiteren Wertes, der eine spezielle mathematische Abhängigkeit zu dem einen Wert besitzt und

Mittel zur Berechnung von Werten, die die Orte der Fehler dadurch identifizieren, daß der Offset der Binärzahlen von dem anderen Wert berechnet wird.

11. Vorrichtung nach Anspruch 11, dadurch gekennzeichnet, daß Mittel einbezogen werden, welche die Logarithmier- und Delogarithmiertabellen zur Berechnung von Fehlermustern der zwei Fehler enthalten.

12. Vorrichtung nach Anspruch 10 oder 11, dadurch gekennzeichnet, daß Mittel einbezogen werden, welche die Logarithmier- und Delogarithmiertabellen zur Berechnung der Vektoren aus den vier Syndromen enthalten.