DE102021109391B3

DE102021109391B3 - Multibytefehler-Erkennung

Info

Publication number: DE102021109391B3
Application number: DE102021109391.0A
Authority: DE
Inventors: Thomas Kern; Alexander Klockmann; Thomas Rabenalt; Michael Gössel
Original assignee: Infineon Technologies AG
Current assignee: Infineon Technologies AG
Priority date: 2021-04-14
Filing date: 2021-04-14
Publication date: 2022-08-25
Anticipated expiration: 2041-04-15
Also published as: US20220345157A1; TW202308331A

Abstract

Es wird eine Lösung zur Erkennung eines Multibytefehlers in einem Codewort eines verkürzten Fehlercodes vorgeschlagen, wobei der verkürzte Fehlercode ein τ Byte-korrigierender Fehlercode ist, Bytes des Codeworts des verkürzten Fehlercodes einen ersten Bereich bestimmen und der nicht korrigierbare Multibytefehler erkannt wird, sofern mindestens eine der folgenden Bedingungen erfüllt ist: (a) mindestens ein Fehlerpositionssignal liegt nicht in dem ersten Bereich; (b) mindestens ein Fehlerpositionssignal zeigt mindestens einen Fehler aber weniger als τ Fehler in dem ersten Bereich an und es liegt kein 1-Bytefehler bis (τ- 1)-Bytefehler vor.

Description

Ein Fehlercode ist dabei entweder ein Fehler-korrigierender Code, ein Fehler-erkennender Code oder eine Kombination aus einem Fehler-erkennenden sowie Fehler-korrigierenden Code.
Ein Beispiel für einen Fehlercode ist der Bose-Chaudhuri-Hocquenghem-Code (BCH-Code, siehe z.B. https://de.wikipedia.org/wiki/BCH-Code).
Aus EP 1 037 400 A2 und aus JP H 10 229342 A ist jeweils ein Verfahren bekannt zur Erkennung eines Multibytefehlers in einem Codewort eines verkürzten Fehlercodes, bei dem der verkürzte Fehlercode ein τ-Bytefehler-korrigierender Fehlercode ist.
Aus EP 0 413 856 A1 ist ein Verfahren bekannt zur Erkennung eines Multibytefehlers in einem Codewort eines verkürzten Fehlercodes, bei dem ein nicht-korrigierenbarer Multibytefehler erkannt wird, sofern mindestens ein Fehlerpositionssignal auf ein nicht-existierendes Byte zeigt.
Bei einem BCH-Code ist beispielsweise bekannt, zu korrigierende Bitfehlerpositionen als Nullstellen eines Lokatorpolynoms des BCH-Codes zu bestimmen. So ist beispielsweise in [4] eine spezielle Vorgehensweise für eine 2-Bitfehlerkorrektur in einem Galoisfeld GF(2^m) unter Verwendung eines BCH-Codes beschrieben. Ausgehend von einem entsprechenden Lokatorpolynom zweiten Grades wird dieses Polynom so transformiert, dass die Nullstellen des transformierten Polynoms durch einen Parameter der Wortbreite m bestimmbar sind. Dieser Parameter wird aus den Syndromkomponenten bestimmt. Die Nullstellen des transformierten Polynoms sind nach ihrer Bestimmung in die Nullstellen des ursprünglichen Lokatorpolynoms zu transformieren. Unter Verwendung eines Decoders können aus den Nullstellen des ursprünglichen Lokatorpolynoms die zu korrigierenden Bitpositionen berechnet werden.
Auch ist in [4] die Fehlerkorrektur von 3-Bitfehlern und 4-Bitfehlern unter Verwendung von BCH-Codes und die Korrektur von Bytefehlern unter Verwendung eines entsprechenden Reed-Solomon-Codes beschrieben.
Eine Aufgabe besteht darin, die bekannten Lösungen zu verbessern und insbesondere einen Ansatz zu schaffen, um effizient nicht korrigierbarer Multibytefehler zu erkennen.
Diese Aufgabe wird gemäß den Merkmalen der unabhängigen Ansprüche gelöst. Bevorzugte Ausführungsformen sind insbesondere den abhängigen Ansprüchen entnehmbar.
Zur Lösung der Aufgabe wird ein Verfahren vorgeschlagen zur Erkennung eines Multibytefehlers in einem Codewort eines verkürzten Fehlercodes,

- bei dem der verkürzte Fehlercode ein τ Byte-korrigierender Fehlercode ist,
- bei dem Bytes des Codeworts des verkürzten Fehlercodes einen ersten Bereich bestimmen,
- bei dem der nicht korrigierbare Multibytefehler erkannt wird, sofern mindestens eine der folgenden Bedingungen erfüllt ist:
1. (a) mindestens ein Fehlerpositionssignal liegt nicht in dem ersten Bereich,
2. (b) mindestens ein Fehlerpositionssignal zeigt mindestens einen Fehler aber weniger als τ Fehler in dem ersten Bereich an und es liegt kein 1-Bytefehler bis (τ - 1)-Bytefehler vor.

Hierbei sei angemerkt, dass jedes Byte eine Anzahl von b Bit(s) umfassen kann mit b ≥ 1. Der Wert für τ kann eine ganze Zahl größer als 1 sein.
Werden τ Bytefehler erkannt und liegen τ Fehlerpositionssignale in dem ersten Bereich, so kann ein τ-Bytefehler korrigiert werden.
Wird kein Fehlerpositionssignal bestimmt, liegt kein erkennbarer Fehler vor.
In dem Fall (b) kann das mindestens eine Fehlerpositionssignal teilweise oder vollständig in dem ersten Bereich oder nicht in dem ersten Bereich liegen.
Das Fehlerpositionssignal kann, sofern es nicht in dem ersten Bereich liegt, in einem definierten oder einem nicht definierten Bereich liegen. Ein nicht definierter Bereich kann dadurch bestimmt sein, dass die Bestimmung des Fehlerpositionssignal keine oder keine gültige Lösung liefert.
Es ist eine Weiterbildung, dass die Bedingung (a) ferner umfasst: das mindestens eine Fehlerpositionssignal, das nicht in dem ersten Bereich liegt, liegt in einem zweiten Bereich, der bestimmt ist durch Bytes eines nicht verkürzten Fehlercodes, die nicht auch Bytes des verkürzten Fehlercodes sind.
Es ist eine Weiterbildung, dass eine Anzahl des mindestens einen Fehlerpositionssignals mittels Zählens bestimmt wird.
Es ist eine Weiterbildung, dass mittels des Fehlerpositionssignals ein Byte eines Codeworts referenziert wird.
Es ist eine Weiterbildung, dass das mindestens eine Fehlerpositionssignal mittels mindestens eines Lokatorpolynoms des Fehlercodes bestimmt wird.
Es ist eine Weiterbildung, dass der verkürzte Fehlercode ein BCH-Code der Länge n über einem Galoisfeld GF(2^m) mit n < 2^m - 1 ist und m ≥ 3 gilt.
Der verkürzte Fehlercode ist durch Kürzen aus einem BCH-Code über GF(2^m) der Länge 2^m - 1 bestimmbar. Der verkürzte Fehlercode ist beispielsweise ein τ Bytefehler-korrigierender BCH-Code mit τ ≥ 2. Vorzugsweise ist der verkürzte Fehlercode in der Lage, mehr als τ Bytefehler zu erkennen.
Es ist eine Weiterbildung, dass der verkürzte Fehlercode ein Reed-Solomon-Code über einem Galoisfeld GF(2^m) ist.
Auch wird eine Vorrichtung vorgeschlagen zur Erkennung eines Multibytefehlers in einem Codewort eines verkürzten Fehlercodes,

- wobei der verkürzte Fehlercode ein τ Byte-korrigierender Fehlercode ist,
- wobei Bytes des Codeworts des verkürzten Fehlercodes einen ersten Bereich bestimmen,
- wobei die Vorrichtung eingerichtet ist zur Erkennung des nicht korrigierbaren Multibytefehlers, sofern mindestens eine der folgenden Bedingungen erfüllt ist:
1. (a) mindestens ein Fehlerpositionssignal liegt nicht in dem ersten Bereich,
2. (b) mindestens ein Fehlerpositionssignal zeigt mindestens einen Fehler aber weniger als τ Fehler in dem ersten Bereich an und es liegt kein 1-Bytefehler bis (τ - 1)-Bytefehler vor.

Es ist eine Weiterbildung, dass die Vorrichtung Teil eines Speichers oder eines Speichersystems ist oder separat zu dem Speicher oder dem Speichersystem ausgeführt ist.
Die Vorrichtung kann Teil des Speichers oder separat zu diesem ausgeführt sein. Insbesondere kann die Vorrichtung eine Verarbeitungseinheit umfassen, die die hier genannten Schritte durchführt. Die Verarbeitungseinheit kann mindestens eine der folgenden Komponenten umfassen: einen Prozessor, einen Mikrocontroller, einen Schaltkreis, einen ASIC, ein FPGA, eine Logikeinheit. Die Verarbeitungseinheit kann in Form mindestens einer physikalischen Einheit realisiert sein. Insbesondere kann die Verarbeitungseinheit auf mehrere physikalische Einheiten verteilt sein.
Die vorstehenden Erläuterungen betreffend die Verfahren gelten für die Vorrichtung entsprechend. Die hier beschriebenen Schritte des Verfahrens können mittels der Vorrichtung ausgeführt werden.
Die oben beschriebenen Eigenschaften, Merkmale und Vorteile dieser Erfindung sowie die Art und Weise, wie diese erreicht werden, werden nachfolgend beschrieben im Zusammenhang mit einer schematischen Beschreibung von Ausführungsbeispielen, die im Zusammenhang mit den Zeichnungen näher erläutert werden. Dabei können zur Übersichtlichkeit gleiche oder gleichwirkende Elemente mit gleichen Bezugszeichen versehen sein.

1 zeigt ein Blockdiagramm zur Veranschaulichung von Schritten zum Bestimmen von Fehlerpositionssignalen;
2 zeigt eine spezielle Ausgestaltung von 1 zur Erkennung eines nicht korrigierbaren Multibytefehlers;
3 zeigt eine alternative Ausgestaltung für die Einheit zur Bestimmung der Fehlerpositionssignale beispielhaft für einen binären BCH-Code mit b = 1 oder einen Reed-Solomon-Code mit b > 1;
4 zeigt eine H²-Matrix des nicht verkürzten Fehlercodes C²;
5 zeigt die H¹-Matrix des verkürzten Fehlercodes C¹;
6 zeigt eine Tabelle mit durch das Modularpolynom p(x) = 1+x² +x⁵ erzeugten Elemente des Galoisfeldes GF(2⁵) in Potenzdarstellung, Polynomdarstellung und Tupeldarstellung;
7 zeigt ein beispielhaftes Ablaufdiagramm zur Bestimmung, ob ein nicht korrigierbarer Multibytefehler vorliegt.

Fehler in einzelnen oder in mehreren Bits können durch Fehlercodes erkannt und/oder korrigiert werden. Dabei können Bits in sogenannte Bytes zusammengefasst bzw. gruppiert werden. Ein Byte umfasst somit eine Anzahl von b Bits, wobei b ≥ 1 gilt.
Ein Fehlercode ist ein Code, der mindestens einen Fehler erkennen und/oder korrigieren kann. Somit ist ein Fehlercode ein Fehler-erkennender und/oder Fehler-korrigierender Code. Beispielsweise kann der Fehlercode

- ein τ Bytefehler-korrigierender Code,
- ein τ Bytefehler-korrigierender und (τ + 1) Bytefehler-erkennender Code oder
- ein τ Bytefehler-korrigierender und ein mehr als τ Bytefehler-erkennender Code

Bei der Übertragung von Daten oder bei der Speicherung von Daten können Bitfehler auftreten, die erkannt und/oder korrigiert werden sollen. Beispielsweise können Nutzdaten um Prüfdaten (auch bezeichnet als Prüfbits bzw. Prüfbytes) ergänzt werden. Vorteilhaft ergibt die Kombination aus Nutzdaten und Prüfdaten im fehlerfreien Fall ein Codewort des Fehlercodes. Der Fehlercode umfasst in der Regel eine Vielzahl von Codewörtern, also von gültigen Belegungen, die aus Sicht des Fehlercodes keinen Fehler anzeigen. Der Vollständigkeit halber sei erwähnt, dass auch mehrfache Fehler ein Codewort in ein anderes Codewort überführen können. In so einem Fall liegt kein erkennbarer Fehler vor, obwohl tatsächlich ein mehrfacher Fehler auftrat. Mit anderen Worten, das Codewort ist immer eine gültige Belegung von Bits, so dass der Fehlercode keinen Fehler erkennt oder kein Fehler vorlag.
Sofern nachfolgende Erläuterungen auf Bytes abstellen, gilt, dass jedes der Bytes eine Anzahl von b ≥ 1 Bits aufweist. Entsprechend gilt für den Fall b = 1, dass jedes der Bytes nur genau ein Bit umfasst. Insofern könnten dann z.B. die Begriffe „Bytes“ oder „Bytefolge“ durch „Bits“ oder „Bitfolge“ ersetzt werden.
Im Rahmen der Fehlerkorrektur ist es eine generelle Motivation, eine vorgegebene Anzahl von Fehlern in den Bytes einer Bytefolge zu erkennen und/oder zu korrigieren. Die zu korrigierenden Bytes können dabei alle Bytes oder eine Teilmenge der Bytes sein. Es ist eine Option, dass Prüfbytes, sofern diese vorhanden sind, nicht korrigiert werden. Weiterhin ist es eine Option, Teilmengen der Bytefolge unterschiedlich zu behandeln: So könnten Fehler in einer ersten Teilmenge der Bytefolge korrigiert und in einer zweiten Teilmenge der Bytefolge nur erkannt werden.
Um ein fehlerhaftes Byte zu korrigieren, ist es erforderlich, die Position des fehlerhaften Bytes zu erkennen und einen Korrekturwert für dieses fehlerhafte Byte zu bestimmen.
Wird ein τ Bytefehler-korrigierender Fehlercode betrachtet, gilt für eine Anzahl von 1 bis τ fehlerhafte Bytes:
Die Position eines fehlerhaften Bytes wird durch ein Fehlerpositionssignal bestimmt, das einen ersten Wert annimmt, wenn das entsprechende Byte fehlerhaft ist und einen zweiten Wert annimmt, wenn das entsprechende Byte nicht fehlerhaft ist. Der erste Wert soll beispielhaft 1 und der zweite Wert soll beispielhaft 0 sein. Der Wert, um den ein fehlerhaftes Byte korrigiert werden soll, kann durch einen b-stelligen Korrekturwert bestimmt sein. Wird der Korrekturwert mit dem fehlerhaften Byte komponentenweise modulo 2 addiert, folgt daraus der korrigierte Wert.
Für b = 1 weist ein b-Bit-Byte (also ein Byte mit einer Anzahl von b Bits) nur ein einzelnes Bit auf und ein Fehler verfälscht eine Bitfolge $y = y_{0}, \dots, y_{n - 1}$
in eine fehlerhafte Bitfolge $y' = y_{0}^{'}, \dots, y_{n - 1}^{'}$
Dieser Fehler kann durch einen binären Fehlervektor $e = e_{0}, \dots, e_{n - 1}$
bestimmt sein. Somit gilt: $y' = y_{0}^{'}, \dots, y_{n - 1}^{'} = y_{0} + e_{0}, \dots, y_{n - 1} + e_{n - 1} = y + e .$
Hierbei bezeichnet „+“ die Addition modulo 2.
Ist e_i = 1 für i ∈ {0,...,n - 1}, dann ist $y_{i}^{'} = y_{i} + e_{i} = y_{i} + 1 = {\bar{y}}_{i}$
und es liegt ein Fehler an der Bitposition i vor, d.h. ein Fehlerpositionssignal an der Position i hat den Wert 1: bfp_i = 1.
Ist e_i = 0 für i ∈ {0,...,n - 1}, dann ist $y_{i}^{'} = y_{i} + e_{i} = y_{i} + 0 = y_{i}$
und es liegt kein Fehler an der Bitposition i vor, d.h. das Fehlerpositionssignal an der Position i hat den Wert 0: bfp_i = 0.
In dem Fall b = 1 sind die Komponenten des Fehlervektors e gleich den Fehlerpositionssignalen $b f p_{0}, \dots, b f p_{n - 1}$
Anstelle der Gleichung (1) gilt somit für den fehlerhaften Wert y' auch: $y' = y_{0}^{'}, \dots, y_{n - 1}^{'} = y_{0} + b f p_{0}, \dots, y_{n - 1} + b f p_{n - 1} - y + b f p,$
wobei $b f p = b f p_{0}, \dots, b f p_{n - 1}$
einen Fehlerpositionssignalvektor bezeichnet.
Umfasst das Byte mehr als ein Bit (d.h. b > 1), dann wird ein i-tes Byte mit Y_i (oder X_i) und eine Folge von Bytes mit Y bezeichnet.
Ein Fehler in dem i-ten Byte Y_i' der Bytefolge $Y' = Y_{1}^{'}, \dots, Y_{n}^{'}$
kann durch ein binäres Fehlerpositionssignal bfp_i = 1 und einen Fehlerwert E_i beschrieben werden. Dabei ist der Fehlerwert E_i ein b-Bit-Byte.
Das Fehlerpositionssignal bfp_i ist gleich 1, wenn gilt: $E_{i} \neq \underset{b}{\underset{︸}{0, \dots,0}} = \underline{0}$
Entsprechend ist das Fehlerpositionssignal bfp_i gleich 0, wenn gilt: $E_{i} = \underline{0} .$
Für einen korrigierbaren Fehler ist die Anzahl der Einsen in dem Fehlerpositionssignalvektor bfp ist gleich der Anzahl der fehlerhaften Bytes in der Bytefolge $Y' = Y_{0}^{'}, \dots, Y_{n - 1}^{'},$
Die Bytefolge kann beispielsweise mittels des Fehlercodes korrigiert werden.
Für b > 1 besteht ein Fehlervektor E = E₀,...,E_n-1 aus einer Anzahl n von b-Bit-Bytes, so dass gilt: $Y' = Y_{0}^{'}, \dots, Y_{n - 1}^{'} = Y_{0} + E_{0}, \dots, Y_{n - 1} + E_{n - 1} = Y + E$
In Gleichung (3) entspricht die Operation „+“ der komponentenweisen Addition modulo 2.
Es gilt somit:

- Ist E_i ≠ 0 für i ∈ {0,..., n - 1}, dann ist bfp_i = 1 und es liegt ein Fehler an der i-ten Byteposition vor.
- Ist E_i = 0, dann ist bfp_i = 0 und es liegt kein Fehler an der i-ten Byteposition vor.

Der hierin beschriebene Ansatz ermöglicht die Bestimmung eines nicht korrigierbaren Fehlers mit mehr als τ fehlerhaften Bytes anhand der Anzahl der Fehlerpositionssignale unter Verwendung eines lediglich τ Bytefehler-korrigierenden Fehlercodes.
Die Anzahl der Fehler, die binären Werte der Fehlerpositionssignale und, falls b > 1 ist, die b-Bit breiten Fehlerwerte werden für lineare Fehlercodes beispielsweise durch ein Fehlersyndrom des linearen Fehlercodes bestimmt.
In den hier beschriebenen Lösungen werden beispielhaft verkürzte Fehlercodes betrachtet. Ein verkürzter Fehlercode kann aus einem nicht verkürzten Fehlercode bestimmt werden, der eine größere Länge oder Codewörter mit einer größeren Länge als der verkürzte Fehlercode aufweist.
Beispielhaft können der verkürzte und der nicht verkürzte Fehlercode die gleiche Anzahl von Prüfbits aufweisen. Beispielsweise kann sowohl der verkürzte Fehlercode als auch der nicht verkürzte Fehlercode ein τ Bytefehler-korrigierender Fehlercode sein.
Der verkürzte Fehlercode kann aus dem nicht verkürzten Fehlercode hervorgehen, indem der nicht verkürzte Fehlercode um mindestens ein b-Bit-Byte verkürzt wird.
Gilt b = 1, dann entspricht jedes b-Bit-Byte genau einem Bit. Die Fehlerpositionssignale identifizieren in diesem Fall einzelne Bits, d.h. einzelne Positionen eines Codeworts des Fehlercodes, die möglicherweise fehlerhaft sind.
Wird ein τ Bytefehler-korrigierender Fehlercode verwendet, sind in dem Fall, dass τ Fehler in den zu korrigierenden b-Bit-Bytes vorhanden sind, τ Fehlerpositionssignale für die zu korrigierenden Bytes des Fehlercodes durch das resultierende Fehlersyndrom zu 1 bestimmt. Die übrigen Fehlerpositionssignale sind gleich 0.
Ein nicht korrigierbarer Multibytefehler mit mehr als τ fehlerhaften Bytes kann daran erkannt werden, dass weniger als τ Fehlerpositionssignale für die zu korrigierenden Bytes den Wert 1 annehmen und falls

- kein 1-Bytefehler, ⋮
- kein (τ - 1)-Bytefehler.

Wird eines der τ Fehlerpositionssignale, die den Wert 1 für eine Byteposition annehmen, bei der Fehlerkorrektur bestimmt, um die der nicht verkürzte Fehlercode bei der Bestimmung des verkürzten Fehlercodes gekürzt wurde, kann daran erkannt werden, dass weniger als τ Fehlerpositionssignale für die Bytes des verkürzten Fehlercodes zu 1 bestimmt sind.
Die zu korrigierenden Bytepositionen des verkürzten Fehlercodes werden als Wertebereich der Fehlerpositionssignale bezeichnet. Dann sind im Falle eines 1-Bytefehlers, 2-Bytefehlers bis τ-Bytefehlers in den Bytes des verkürzten Fehlercodes die Fehlerpositionssignale, die den Wert 1 annehmen, alle Elemente dieses Wertebereichs der Fehlerpositionssignale.
Wird hingegen ein Fehlerpositionssignal zu 1 bestimmt, das nicht ein Element des Wertebereichs der Fehlerpositionssignale ist, liegt ein nicht korrigierbarer Fehler vor.
Ist zusätzlich bestimmt, dass kein 1-Bytefehler, etc. bis (i-1)-Bytefehler der zu korrigierenden Bytes vorliegt, oder wird ein Fehlerpositionssignal mit dem Wert 1 bestimmt, das außerhalb des Wertebereichs der Fehlerpositionssignale liegt, können höchstens (τ - 1) Fehlerpositionssignale, die den Wert 1 annehmen, Elemente des Wertebereichs der Fehlerpositionssignale sein. Das Vorhandensein des Fehlersignals, das den Wert 1 annimmt und nicht Element des Wertebereichs der Fehlerpositionssignale ist, zeigt bereits an, dass ein nicht korrigierbarer Fehler vorliegt. In diesem Fall ist es nicht notwendig, die Anzahl der Fehlerpositionssignale mit dem Wert 1, die in dem Wertebereich der Fehlerpositionssignale, die den Wert 1 annehmen, zu bestimmen.
Beispiel
Beispielhaft diene als Fehlercode ein τ Byte-korrigierender Fehlercode. Dieser Fehlercode kann also maximal τ fehlerhafte Bytes korrigieren und damit können maximal τ Fehlerpositionssignale gleich 1 sein.
Dieser τ Byte-korrigierende Fehlercode ist beispielhaft ein verkürzter Fehlercode. Er ist durch Verkürzen von K Bytes $B y t e_{0,} B y t e_{1}, \dots, B y t e_{K - 1}$
aus einem ebenfalls τ Byte-korrigierenden nicht verkürzten Fehlercode hervorgegangen.
Im Fall eines Fehlers in mehr als τ Bytes des verkürzten Fehlercodes kann ein Fehlersyndrom beispielsweise so bestimmt sein, dass es gleich einem Fehlersyndrom eines Bytefehlers des nicht verkürzten Fehlercodes ist, wobei der Fehler in einem gekürzten Byte auftritt. Es ergibt sich also ein Fehlerpositionssignal auf eine Position, die in dem verkürzten Fehlercode nicht existiert: Das Fehlerpositionssignal zeigt auf ein gekürztes Byte, das nicht Teil eines Codeworts des verkürzten Fehlercodes ist. Damit können höchstens (τ - 1) Fehlerpositionssignale (mit einem Wert 1) Bytes des verkürzten Fehlercodes referenzieren. Es sind somit weniger als τ Fehlerpositionssignale für die Bytes des verkürzten Fehlercodes übrig, die noch den Wert 1 annehmen können.
Ist bekannt, dass bei der Fehlerkorrektur τ Fehlerpositionssignale beispielsweise auf der Grundlage des Fehlersyndroms bestimmt sind, die den Wert 1 annehmen, wobei ein Fehlerpositionssignal mit dem Wert 1 für ein Byte bestimmt wird, dass ein Byte des unverkürzten Fehlercodes ist und kein Byte des verkürzten Fehlercodes ist, dann liegt ein nicht korrigierbarer Fehler vor. Dies kann beispielsweise daran erkannt werden, dass die Anzahl der Fehlerpositionssignale, die den Wert 1 annehmen, für die Bytes des verkürzten Fehlercodes kleiner als τ ist. Ebenso kann das daran erkannt werden, dass ein Fehlerpositionssignal für ein Byte des unverkürzten Fehlercodes bestimmt ist, das kein Byte der verkürzten Fehlercodes ist.
Ist bestimmt, dass kein 1-Byte-Fehler bis kein (τ- 1)-Bytefehler vorliegen und ist der Fehlercode ein τ Bytefehler-korrigierender Fehlercode, kann ein nicht korrigierbarer Fehler daran erkannt werden, dass weniger als τ Fehlerpositionssignale mit dem Wert 1 für die zu korrigierenden Bytes des Fehlercodes bestimmt sind.
Unter Verwendung der Anzahl der Fehlerpositionssignale für Bytes des verkürzten Fehlercodes, die bei einer Fehlerkorrektur den Wert 1 annehmen, kann somit ein nicht korrigierbarer Fehler erkannt werden.
So ist es möglich, unter Verwendung der Anzahl der Fehlerpositionssignale, die den Wert 1 aufweisen und damit einen Fehler des ihnen entsprechenden Bytes für die Bytes eines Codewortes des verkürzten Fehlercodes anzeigen, einen nicht korrigierbaren Fehler zu erkennen, ohne dass weitere Prüfbytes erforderlich sind.
Es ist nicht notwendig, die genaue Anzahl der Fehlerpositionssignale, die den Wert 1 annehmen, für die zu korrigierenden Bytes zu bestimmen. Es kann ausreichend sein, zu bestimmen, dass ihre Anzahl kleiner als τ oder ungleich τ ist, wenn der verkürzte Fehlercode beispielsweise ein τ Bytefehler-korrigierender Fehlercode ist und die Decodierung so erfolgt, dass maximal τ Fehlerpositionssignale bestimmbar sind.
Optional können die Bytes auch Adressbits oder Adressbytes einer Leseadresse und/oder einer Schreibadresse umfassen oder aus einer solchen abgeleitet sein.
Weiterhin ist es eine Option, dass zur Bestimmung, ob ein 1-Bitfehler, etc. vorliegt, eine Parität der Bytes berücksichtigt werden kann. Beispielsweise kann ein Paritätsbit vorgesehen sein, anhand dessen eine Filterung hinsichtlich bestimmter Multibytefehler erfolgt.
Fehlercodes
Nachfolgend werden beispielhaft lineare Codes betrachtet.
Zur Veranschaulichung wird zunächst der Fall b = 1 betrachtet, d.h. ein b-Bit-Byte entspricht einem einzelnen Bit.
Eine Bitfolge von k Bits $x = x_{0}, \dots, x_{k - 1}$
wird in ein Codewort $y = y_{0}, \dots, y_{n - 1}$
codiert mit n > k > 1. Weiterhin gilt $y = x \cdot G$
wobei G eine (k,n)-Matrix ist, die als Generatormatrix des betrachteten Fehlercodes bezeichnet wird. Für b = 1 sind die Elemente der Generatormatrix binär. Diese Elemente der Generatormatrix können auch als Elemente des Galoisfeldes GF(2) bezeichnet werden.
Die Generatormatrix wird in ihrer systematischen Form mit $G_{s y s} = (P_{k, n - k}, I_{k})$
bezeichnet, wobei

- I_k die k-dimensionale Einheitsmatrix und
- P_k,n-k eine (k,n- k)-Matrix (Paritätsmatrix)

H_{s y s} = (I_{n - k}, P_{n - k, k}^{T}),

P_{n - k, k}^{T}

P_{k, n - k},

Aus einer gegebenen G-Matrix können weitere G-Matrizen durch Linearkombination ihrer Zeilen abgeleitet werden. Ebenso können aus einer gegebenen H-Matrix durch Linearkombination ihrer Zeilen weitere H-Matrizen abgeleitet werden.
Die H-Matrix gemäß Gleichung (6) ist dabei, wie jede H-Matrix eines Codes, so bestimmt, dass für ein Codewort des zugehörigen Fehlercodes gilt $H_{s y s} y = 0 | .$
Hierbei bezeichnet 0| einen Spaltenvektor mit lauter Nullelementen.
Für ein fehlerhaftes Wort $y' = y + e = y + b f p$
gilt entsprechend $H_{s y s} y' = H_{s y s} (y + e) = H_{s y s} \cdot e = H_{s y s} \cdot b f p = s_{s y s} \neq 0 | .$
wobei $s_{s y s} = H_{s y s} \cdot e = H_{s y s} \cdot b f p$
als Fehlersyndrom für die H_sys-Matrix bezeichnet werden kann.
Wird eine andere H-Matrix zum Beispiel aus H_sys durch Linearkombination ihrer Zeilen bestimmt, wird das entsprechende Fehlersyndrom mit $s = H \cdot e$
bezeichnet. Die minimale Anzahl der Prüfbits eines linearen Fehlercodes kann durch den Rang der H-Matrix des Fehlercodes bestimmt werden.
Wird die H-Matrix des Fehlercodes um linear abhängige Zeilen ergänzt, kann die Anzahl der Prüfbytes des Fehlercodes größer als der Rang der H-Matrix sein.
Das aus dem fehlerhaften Wort y' bestimmte Fehlersyndrom kann zur Fehlerkorrektur verwendet werden, wenn für die betrachtete Menge von Fehlervektoren jeder dieser Fehlervektoren zu einem unterschiedlichen Fehlersyndrom führt. Bei der Fehlerkorrektur werden die unterschiedlichen Bitpositionen bestimmt, die den Fehlersyndromen entsprechen. Jeder Fehlerposition entspricht ein Fehlerpositionssignal. Ist das Fehlerpositionssignal gleich 1, ist die referenzierte Fehlerposition fehlerhaft.
Ist b = 1, so wird über das Fehlerpositionssignal ein einzelnes Bit referenziert. Es ist also pro Fehlerpositionssignal ein Bit zu korrigieren, der Korrekturwert kann für das zu korrigierende Bit gleich 1 sein. In diesem Fall ist der Fehlerwert gleich dem Wert des Fehlerpositionssignals; es muss kein gesonderter Fehlerwert angegeben werden. Für b = 1 erfolgen Addition und Multiplikation binärer Werte jeweils modulo 2, d.h. in dem Körper Galoisfeld GF(2).
Für b ≥ 2 wird eine Bytefolge aus k b-Bit-Bytes $X = X_{0}, X_{2}, \dots, X_{k - 1}$
in ein Codewort $Y = Y_{0}, \dots, Y_{n - 1}$
codiert.
Das Fehlerpositionssignal ist in diesem Fall ein Bytefehlerpositionssignal. Beispielsweise deutet ein Bytefehlerpositionssignal mit dem Wert 1 an, dass das referenzierte Byte (umfassend b Bits) fehlerhaft ist in mindestens einem seiner b Bits. Hat das Bytefehlerpositionssignal den Wert 0, ist das referenzierte Byte nicht fehlerhaft (oder es war kein Fehler erkennbar).
Für einen τ Bytefehler-korrigierenden Code gilt, sofern höchstens τ Bytefehler vorhanden sind: Ein Bytefehler des i-ten Bytes kann durch ein binäres Fehlerpositionssignal bfp_i und einen Bytefehlerwert E_i beschrieben sein. Der Bytefehlerwert E_i umfasst dabei b Bits.
Gilt für einen Bytefehlerwert E_i ≠ 0, kann dem i-ten Byte das Fehlerpositionssignal bfp_i = 1 zugeordnet werden. Ist E_i = 0, kann dem i-ten Byte das binäre Fehlerpositionssignal bfp_i = 0 zugeordnet werden.
Das Fehlerpositionssignal beschreibt, ob

- eine bestimmte Byteposition fehlerhaft ist und korrigiert wird (werden kann) oder
- eine bestimmte Byteposition nicht fehlerhaft ist.

Dabei gibt das Fehlerpositionssignal keinen Korrekturwert für die ggf. fehlerhafte Byteposition an.
Wie ausgeführt können die Fehlerpositionssignale in dem Fehlerpositionssignalvektor bfp = bfp₀, ... ,bfp_n-1 zusammengefasst werden.
Die Anzahl der Fehlerpositionssignale, die gleich 1 sind, beschreibt, wie viele der von den Fehlerpositionssignalen referenzierten Bytes fehlerhaft sind.
7 zeigt ein beispielhaftes Ablaufdiagramm zur Bestimmung, ob ein nicht korrigierbarer Multibytefehler vorliegt. Die Reihenfolge und die gezeigten Schritte sind lediglich beispielhafte Ausführungsformen. In 7 sind die folgenden Schritte bzw. Abfragen gezeigt:

Schritt 701: Es werden Fehlerpositionssignale für Bytes eines Codeworts bestimmt. Ein Byte umfasst dabei b-Bit(s) mit b ≥ 1. Es wird zu Schritt 702 verzweigt. Alternativ könnte direkt von Schritt 701 zu Schritt 705 verzweigt werden.
Schritt 702: Hier wird bestimmt, ob die Anzahl der Fehlerpositionssignale gleich 0 ist. Ist dies der Fall, so wird kein Fehler erkannt. Liegt mindestens ein Fehlerpositionssignal vor, wird zu Schritt 703 verzweigt. In einer alternativen Ausführungsform wird zu Schritt 705 verzweigt.
Schritt 703: Es wird geprüft, ob die Anzahl der Fehlerpositionssignale für Bytes des verkürzten Fehlercodes kleiner als τ ist und ob kein 1-Bytefehler, ... bis kein (τ- 1)-Bytefehler des verkürzten Fehlercodes vorliegt. Ist dies nicht zutreffend, so liegt ein korrigierbarer Fehler vor, es wird zu Schritt 706 verzweigt. Anderenfalls, also wenn keiner dieser Fehler erkannt wurde, wird mit Schritt 704 fortgefahren. Der verkürzte Fehlercode ist ein τ Bytefehler-korrigierender Fehlercode. Der verkürzte Fehlercode ist aus einem nicht verkürzten Fehlercode bestimmbar.
Schritt 704: Es wird ein nicht korrigierbarer Multibytefehler erkannt, da kein korrigierbarer Fehler erkannt werden konnte.
Schritt 705: Es wird geprüft, ob mindestens ein Fehlerpositionssignal in einem Bereich außerhalb eines Bereichs liegt, der durch die Bytes des Codeworts des verkürzten Codes bestimmt ist. Ist dies der Fall, wird zu Schritt 704 verzweigt. Anderenfalls wird zu Schritt 703 verzweigt.
Schritt 706: Die Fehlerkorrektur der maximal τ fehlerhaften Bytes wird durchgeführt.

Die Formulierung „ein 1-Bytefehler, ... bis (τ- 1)-Bytefehler“ gibt die Fehlertypen für beliebige Werte von τ an. Für τ = 3 sind damit 1-Bytefehler und 2-Bytefehler umfasst. Für τ = 5 sind damit 1-Bytefehler, 2-Bytefehler, 3-Bytefehler und 4-Bytefehler umfasst.
Beispielhafte Bestimmung von Multibytefehlern
1 zeigt ein Blockdiagramm zur Veranschaulichung von Schritten zum Bestimmen von Fehlerpositionssignalen. Beispielsweise erfolgt die Decodierung, Fehlerkorrektur und Fehlererkennung unter Verwendung eines Fehlersyndroms. Ein Syndromgenerator stellt ein Fehlersyndrom bereit, das am Eingang einer Einheit 101 zur Bestimmung von Fehlerpositionssignalen anliegt. Die Einheit 101 liefert Fehlerpositionssignale bfp₀, ... ,bfp_n-1 für die zu korrigierenden Bytepositionen. Die Fehlerpositionssignale dienen als Eingangswerte eines Zählers 102. Der Syndromgenerator ist in 1 nicht gezeigt.
Der Zähler 102 ermittelt, ob weniger als τ oder ob genau τ Fehlerpositionssignale den ersten Wert annehmen.
Der Syndromgenerator, die Einheit 101 sowie der Zähler 102 können als Hardware und/oder Software realisiert sein.
2 zeigt eine spezielle Ausgestaltung von 1 und erlaubt die Erkennung eines nicht korrigierbaren Multibytefehlers.
In 2 ist die Einheit 101 zur Bestimmung der Fehlerpositionssignale in n Einheiten 201 bis 203 aufgeteilt, die basierend auf dem Fehlersyndrom jeweils ein einzelnes der Fehlerpositionssignale bfp₀ bis bfp_n-1 bestimmen. Das Fehlerpositionssignal gilt dann als bestimmt, wenn am Ausgang der jeweiligen Einheit 201 bis 203 der erste Wert anliegt.
Die Ausgänge der Einheiten 201 bis 203 sind mit einem Zähler 204 verbunden. Der Zähler 204 bestimmt, wie viele von den Einheiten 201 bis 203 den ersten Wert bereitstellen, d.h. der Zähler 204 zählt die von den Einheiten 201 bis 203 (in Bezug auf eine vorgegebene Zeiteinheit) bereitgestellten ersten Werte.
Ein dem Zähler 204 nachgeschalteter Vergleicher 205 bestimmt, ob die von dem Zähler bestimmte Anzahl von Fehlerpositionssignalen $A n z (b f p)$

kleiner oder gleich τ ist, wobei τ die maximale Anzahl der von dem Fehlercode korrigierbarer Fehler angibt.
Beispielsweise liefert der Vergleicher 205 an seinem Ausgang

- den Wert 1, wenn Anz(bfp) < τ ist und
- den Wert 0, wenn Anz(bfp) = τ ist.

Anhand des Fehlercodes, beispielsweise unter Verwendung der Fehlersyndrome, können Fehlersignale bestimmt werden. Die Fehlersignale

- 1-Bytefehler,
- 2-Bytefehler, ⋮
- (τ - 1) -Bytefehler

Weiterhin liegt an dem Eingang des NICHT-ODER-Gatters 206 ein Signal 0-Bytefehler an, das mit seinem Wert 1 anzeigt, dass kein Fehler aufgetreten ist und mit seinem Wert 0 anzeigt, dass ein Fehler aufgetreten ist. Hat das Signal 0-Bytefehler den Wert 1, ist auch kein Multibytefehler erkennbar.
Der Ausgang des Vergleichers ist mit einem ersten Eingang eines UND-Gatters 207 verbunden und der Ausgang des NICHT-ODER-Gatters 206 ist mit einem zweiten Eingang des UND-Gatters 207 verbunden.
Der Ausgang des UND-Gatters 207 hat nur dann den Wert 1, wenn der Vergleicher 205 bestimmt hat, dass weniger als τ Fehlerpositionssignale von dem Zähler 204 gezählt wurden und dass von dem NICHT-ODER-Gatter 206 bestimmt wurde, dass keiner der Fehler 0-Bytefehler bis (τ - 1)-Bytefehler vorlag.
Ist kein 0-Bytefehler, etc. bis kein (τ - 1)-Bytefehler aufgetreten und zeigt außerdem der Vergleicher 205 durch den ausgegebenen Wert 1 an, dass Anz(bfp) < τ gilt, dann gibt das UND-Gatter 207 den Wert 1 aus. Hierdurch wird ein nicht korrigierbarer Multibytefehler angezeigt.
3 zeigt eine alternative Ausgestaltung für die Einheit zur Bestimmung der Fehlerpositionssignale beispielhaft für einen binären BCH-Code mit b = 1 oder einen Reed-Solomon-Code mit b > 1.
Das Fehlersyndrom wird einer Einheit 301 zur Bestimmung von Lokatorpolynomen zugeführt. Die Einheit 301 stellt Lokatorpolynome bereit, die anschließend von einer Einheit 302 zur Lokatorpolynomauswertung verarbeitet werden. Die Einheit 302 erhält zusätzlich zu den Lokatorpolynomen auch Bytepositionen α⁰ bis α^n-1 und liefert im Ergebnis Fehlerpositionssignale bfp_i mit i = 1, ... , n- 1. Die Fehlerpositionssignale werden von einem nachgeschalteten Zähler 303 gezählt. Der Zähler 303 stellt an seinem Ausgang eine Anzahl Anz(bfp) von Fehlerpositionssignalen bereit.
Um basierend auf dem Fehlersyndrom Lokatorpolynome zu bestimmen, kann beispielsweise der Berlecam-Massey Algorithmus genutzt werden (vergleiche [1]).
Die Einheit zur Lokatorpolynomauswertung 302 bestimmt für die zu korrigierenden Bytepositionen α⁰ bis α^n-1, ob das Lokatorpolynom für ein αⁱ gleich 0| oder ungleich 0| ist. Ist das Lokatorpolynom für αⁱ gleich 0|, dann ist der Wert des entsprechenden Fehlerpositionssignal gleich 1, ist das Lokatorpolynom für αⁱ ungleich 0|, dann ist der Wert des entsprechenden Fehlerpositionssignales gleich 0. Zur Bestimmung der Werte des Lokatorpolynoms kann beispielsweise der Suchalgorithmus von Chien verwendet werden, der die Nullstellen des Lokatorpolynoms bestimmt (vgl. [2]).
Der Wert des Fehlerpositionssignals bfp_i

- ist 1, wenn das Lokatorpolynom für αⁱ den Wert 0| annimmt und
- ist 0, wenn das Lokatorpolynom für αⁱ einen Wert ungleich 0| annimmt.

Dabei sind α⁰ bis α^n-1 Elemente eines Galoisfeldes GF(2^m) mit m > 3 und α ist ein erzeugendes Element des Galoisfeldes Eigenschaften von Galoisfeldern sind beispielsweise in [3] beschrieben.
Nachfolgend wird ein Beispiel mit b = 1 betrachtet. Es sollen 8 Datenbits durch einen verkürzten Fehlercode C¹ verarbeitet werden. Der verkürzte Fehlercode C¹ ist ein verkürzter 3-Bitfehler-korrigierender und 4-Bitfehler-erkennender BCH-Code mit einbezogener Gesamtparität. Das verwendete Galoisfeld ist GF(2⁵). Die 8 Datenbits werden mit 16 Prüfbits geschützt. Ein Codewort des Fehlercodes C¹ weist somit 8 + 15 + 1 = 24 Bits auf.
Ein nicht verkürzter Fehlercode C² ist beispielsweise ein 3-Bitfehler-korrigierender und 4-Bitfehler-erkennender BCH-Code mit einbezogener Gesamtparität. Der Fehlercode C² hat die Länge von 2⁵ - 1 = 31 Bits.
Der verkürzte Fehlercode C¹ ergibt sich durch Kürzen von 7 Bits aus dem nicht verkürzten Fehlercode C².
Ein Codewort des nicht verkürzten Fehlercodes $y^{2} = y_{0}^{2}, y_{1}^{2}, \dots, y_{30}^{2}$
weist 31 Bits und ein Codewort des verkürzten Fehlercodes $y^{1} = y_{0}^{1}, y_{1}^{1}, \dots, y_{23}^{1}$
weist 24 Bits auf.
Das Verkürzen eines linearen Codes kann durch Streichen von Spalten der H-Matrix erreicht werden.
4 zeigt eine H²-Matrix des nicht verkürzten Fehlercodes C² und 5 zeigt die H¹-Matrix des verkürzten Fehlercodes C¹.
Die H¹-Matrix des verkürzten Fehlercodes geht durch Streichen der Spalten 30, 29, 28, 27, 26, 25, 24 aus der H²-Matrix des nicht verkürzten Fehlercodes hervor. Dadurch wird der nicht verkürzte Fehlercode um die Bits y₃₀, y₂₉, y₂₈, y₂₇, y₂₆, y₂₅, y₂₄ verkürzt.
Die H¹-Matrix des verkürzten Codes weist 24 Spalten auf, ein Codewort des verkürzten Codes hat 24 Bits. Die Länge des verkürzten Codes ist in diesem Ausführungsbeispiel gleich 24.
Dabei sind α⁰ bis αⁱ Elemente des Galoisfeldes GF(2⁵). Diese können unterschiedlich dargestellt werden (vgl. die in 6 gezeigte Tabelle). Exponenten sind für ein Galoisfeld GF(2^m) modulo 2^m -1 zu interpretieren: Für das verwendete Galoisfeld GF(2⁵) entspricht dies einer Interpretation modulo 31.
6 zeigt eine Tabelle mit durch das Modularpolynom p(x) = 1 +x²+x⁵ erzeugten Elementen des Galoisfeldes GF(2⁵) in Potenzdarstellung, Polynomdarstellung und Tupeldarstellung (auch bezeichnet als Vektordarstellung).
Für die Fehlererkennung gilt

- für einen 0-Bitfehler (wenn also kein Fehler vorliegt) $s_{1}^{3} = s_{3} = s_{5} = 0 | und s_{P} = 0,$
- für einen 1-Bitfehler $s_{1}^{3} = s_{3} \neq 0 | und s_{P} = 1,$
- für einen 2-Bitfehler $s_{1}^{3} \neq s_{3} und s_{P} = 0$
- und für einen 3-Bitfehler $s_{1}^{3} \neq s_{3} und s_{P} = 1,$

Die Fehlerkorrektur von BCH-Codes kann mittels Lokatorpolynomen erfolgen. Lokatorpolynome für BCH-Codes sind beispielsweise in [2], [4] oder [5] beschrieben.
Nachfolgend wird beispielhaft die 3-Bitfehler-Korrektur beschrieben. Ein 3-Bitfehler kann unter Verwendung eines Lokatorpolynoms dritten Grades $\begin{array}{l} L (z / 3) = \\ = z^{3} (s_{1}^{3} + s_{3}) + z^{2} (s_{1}^{4} + s_{1} s_{3}) + z (s_{1}^{3} s_{3} + s_{5}) + s_{3} (s_{1}^{3} + s_{3}) + s_{1} (s_{1}^{5} + s_{5}) \end{array}$
anhand seiner Nullstellen bestimmt werden: Die drei Nullstellen des Lokatorpolynoms gemäß Gleichung (13) zeigen die Fehlerpositionen in den Daten und stellen somit die Fehlerpositionssignale dar.
Die Korrektur eines 3-Bitfehlers kann erfolgen, indem für i mit 0 ≤ i ≤ 23 geprüft wird, ob für z = αⁱ $L (α' / 3) = 0 |$
gilt, so dass für jede zu korrigierende Bitposition $α^{3 \cdot i} (s_{1}^{3} + s_{3}) + α^{2 \cdot i} (s_{1}^{4} + s_{1} s_{3}) + α^{i} (s_{1}^{2} s_{3} + s_{5}) + s_{3} (s_{1}^{3} + s_{3}) + s_{1} (s_{1}^{5} + s_{5}) = 0 |$
geprüft wird. Anhand der Nullstellen des Lokatorpolynoms sind die zu korrigierenden Bitpositionen und damit die Werte der Fehlerpositionssignale für diese Bits zu 1 bestimmt. Für alle anderen Bitpositionen sind die Werte der Fehlerpositionssignale gleich 0.
Das Lokatorpolynom L(z/3) ist hier ein Polynom dritten Grades, das höchstens drei verschiedene Nullstellen aufweist. Im Falle eines 3-Bitfehlers innerhalb den Bitpositionen 0 bis 23 gilt:

- Ist der Wert des Lokatorpolynoms L(z/3) für z = αⁱ gleich 0|, liegt ein Fehler an der i-ten Bitposition vor und der Wert des Fehlerpositionssignals bfp_i ist 1.
- Ist der Wert des Lokatorpolynoms L(z/3) für z = α¹ ungleich 0|, liegt kein Fehler an der i-ten Bitposition vor und der Wert des Fehlerpositionssignals bfp_i ist 0.

Diese Bestimmungen können zeitgleich oder zumindest teilweise zeitgleich durchgeführt werden. In diesem Sinne kann eine parallele oder eine teilweise parallele Bearbeitung erfolgen, was vorteilhaft die benötigte Verarbeitungsdauer verkürzen kann.
Es ist eine Option, die Werte α⁰ bis α²³ für z aufeinanderfolgend oder sequentiell in das Lokatorpolynom L(z/3) einzusetzen und bestimmen, ob und für welche Werte αⁱ das Lokatorpolynom L(z/3) den Wert 0| annimmt. Für diese Nullstellen ist der Wert des entsprechenden Fehlerpositionssignals bfp_i gleich 1. Ist der Wert des Lokatorpolynoms ungleich 0|, ist der Wert des entsprechenden Fehlerpositionssignals gleich 0.
Es wird nun geprüft, ob die beiden folgenden Bedingungen erfüllt sind:

1. Ist für i mit 0 ≤ i ≤ 23 die Anzahl der Fehlerpositionssignale, die den Wert 1 annehmen, kleiner als 3?
2. Liegt weder ein 0-Bitfehler, noch ein 1-Bitfehler, noch ein 2-Bitfehler vor? (Dies kann anhand der Gleichungen (9), (10) und (11) überprüft werden.)

Sind diese beiden Bedingungen erfüllt, liegt ein nicht korrigierbarer Fehler in den Bits 0 bis 23 vor.
Es ist eine Option zu prüfen, ob für das Lokatorpolynom $L (α^{i}) = 0 |$
für ein i ≥ 24 gilt. Da das Lokatorpolynom höchstens drei verschiedene Nullstellen aufweist, kann dann das Lokatorpolynom höchstens noch zwei Nullstellen für αⁱ mit 0 ≤ i ≤ 23 aufweisen.
Wird also erkannt, dass L(α^j) = 0| für ein j ≥ 24 gilt, dann kann daran erkannt werden, dass ein nicht korrigierbarer Fehler aufgetreten ist.
Die Länge des verkürzten Fehlercodes ist in diesem Ausführungsbeispiel gleich 24. Die Bits des Fehlercodes werden als 0-tes Bit bis 23-tes Bit bezeichnet.
Anhand der Nullstellen des Lokatorpolynoms L(z/3) gemäß Gleichung (13), das ein Polynom dritten Grades ist, kann festgestellt werden, ob ein korrigierbarer 3-Bitfehler oder ein nicht korrigierbarer Multibitfehler vorliegt. Die Koeffizienten des Lokatorpolynoms sind dabei anhand der Komponenten s₁, s₃, s₅ des Fehlersyndroms des aufgetretenen Fehlers bestimmt.
Als Polynom dritten Grades weist das Lokatorpolynom L(z/3) die drei Nullstellen αⁱ¹, αⁱ² und αⁱ³ auf. Entsprechen diese drei Nullstellen Bitpositionen des verkürzten Fehlercodes, dann liegt ein korrigierbarer Dreibitfehler vor. In diesem Fall gilt $0 \leq i_{1}, i_{2}, i_{3} \leq 23.$
Für i₁, i₂ und i₃ sind die entsprechenden Fehlerpositionssignale bfp_i1, bfp_i2, bfp_i3 jeweils gleich 1 und in den Bitpositionen i₁, i₂ und i₃ wird das fehlerhafte Wort des verkürzten Fehlercodes korrigiert.
Wie vorstehend eingeführt, werden die zu korrigierenden Bytepositionen bzw. die zu korrigierenden Bitpositionen des verkürzten Fehlercodes als Wertebereich (der Fehlerpositionssignale) bezeichnet. In diesem Beispiel sind dann die drei Fehlerpositionssignale Elemente dieses Wertebereichs.
Gibt es hingegen eine Nullstelle α^j mit j ≥ 24, die also nicht in dem Wertebereich liegt, kann es nur noch höchstens zwei Fehlerpositionssignale geben, die den Wert 1 annehmen und in dem Wertebereich liegen, da ein Polynom dritten Grades nur drei Nullstellen aufweist.
Es kann somit keinen korrigierbaren 3-Bitfehler in den Bits des verkürzten Fehlercodes geben, wenn eine der Nullstellen des Lokatorpolynoms für eine Bitposition bestimmt ist, die außerhalb der Bitpositionen des verkürzten Codes liegt. Hieraus kann gefolgert werden, dass ein nicht korrigierbarer Multibitfehler in den Bits des verkürzten Fehlercodes aufgetreten ist.
Mit anderen Worten: Ein nicht korrigierbarer Multibitfehler kann bereits daran erkannt werden, dass für das Lokatorpolynom dritten Grades eine Nullstelle α^j mit j ≥ 24 bestimmbar ist, so dass das entsprechende Fehlerpositionssignal außerhalb des Wertebereiches für den verkürzten Fehlercode liegt.
Alternativ kann ein aufgetretener nicht korrigierbarer Multibitfehler auch daran erkannt werden, dass dann, wenn die Fehlerpositionen als Nullstellen eines Lokatorpolynom m-ten Grades bestimmt sind, weniger als m Fehlerpositionssignale für die Bits des verkürzten Fehlercodes bestimmt sind, für die die Fehlerpositionssignale den Wert 1 annehmen.
Die beschriebene Vorgehensweise soll nun anhand eines Beispiels veranschaulicht werden.
Beispielhaft wird angenommen, dass ein 5-Bitfehler in den Bitpositionen y₁₄, y₁₈, y₁₉, y₂₀, y₂₁ aufgetreten ist, für den die Syndromkomponenten s₁, s₃, s₅ und s_P des verkürzten Fehlercodes durch die komponentenweisen XOR-Summen (Exklusiv-Oder-Summen) der entsprechenden Spalten der H¹-Matrix gemäß 5 zu $s_{1} = α^{14} + α^{18} + α^{19} + α^{20} + α^{21} = α^{20}$
$s_{3} = α^{11} + α^{23} + α^{26} + α^{29} + α^{1} = α^{7}$
$s_{5} = α^{8} + α^{28} + α^{2} + α^{7} + α^{12} = α^{5}$
$s_{P} = 1 + 1 + 1 + 1 + 1 = 1$
bestimmt sind. Dies kann unter Verwendung der in 6 gezeigten Elemente des Galoisfeldes GF(2⁵) verifiziert werden.
Die Bedingungen für einen 3-Bitfehler zeigt Gleichung (12). Im vorliegenden Fall gelten: $s_{1}^{3} = α^{3 \cdot 20} = α^{29},$
$s_{3} = α^{6},$
$s_{1}^{3} \neq s_{3},$
$s_{P} = 1.$
Damit wären eigentlich die Bedingungen für einen vorliegenden 3-Bitfehler erfüllt. Dies trifft jedoch vorliegend nicht zu, da - wie erwähnt - in diesem Beispiel tatsächlich ein 5-Bitfehler vorliegt.
Der hier beispielhaft verwendete BCH-Fehlercode ist jedoch nur in der Lage, 3-Bitfehler zu korrigieren und 4-Bitfehler zu erkennen. Nachfolgend wird erläutert, wie trotzdem möglich ist, einen (nicht korrigierbaren) 5-Bitfehler zu erkennen.
Zunächst scheint also ein 3-Bitfehler vorzuliegen. Allerdings zeigt keines der Fehlerpositionssignale ein fehlerhaftes Bit für die korrigierenden Bits 0 bis 23 an (die Werte der Fehlerpositionssignale sind alle gleich 0).
Für i mit 0 ≤ i ≤ 23 gilt für das Lokatorpolynom gemäß Gleichung (13) $L (α^{i} / 3) \neq 0 | .$
Dies kann durch Einsetzen der Werte α⁰ bis α²³ verifiziert werden. Damit gilt für alle Fehlerpositionssignale $b f p_{0} = b f p_{1} = \dots = b f p_{23} = 0.$
Da weniger als drei Fehlerpositionssignale den Wert 1 annehmen, kann somit bestimmt werden, dass ein nicht korrigierbarer Multibitfehler in den Bits y₀ bis y₂₃ des verkürzten Fehlercodes aufgetreten ist.
Mit anderen Worten: Einerseits ergibt sich aus der Gleichung (13), dass ein 3-Bitfehler vorliegt, andererseits gibt es kein Fehlerpositionssignal, das diese Aussage bestätigt. Es liegt also ein Widerspruch zwischen diesen beiden Bedingungen vor. Daraus kann gefolgert werden, dass ein Multibitfehler vorliegt. Dieser ist nicht korrigierbar. Insbesondere ist aufgrund der vorhandenen Informationen nicht ersichtlich, welche Bits fehlerhaft sind. Auch ist nicht bekannt, um welche Art des Multibitfehlers (hier den beispielhaften 5-Bitfehler) es sich handelt und wie der Multibitfehler zu korrigieren wäre. Es ist jedoch von erheblichem Vorteil, zu erkennen, dass ein Multibitfehler vorliegt. Diese Tatsache kann zu weiteren Aktionen genutzt werden, z.B. kann eine weitere Fehlerkorrektur erforderlich, ein Speicherbereich als fehlerhaft gekennzeichnet, eine Übertragung wiederholt, ein Baustein ersetzt und/oder eine Alarmmeldung ausgegeben werden.
Für die Bits y₂₆, y₂₉ und y₃₀, die Bits des nicht gekürzten Fehlercodes, aber keine Bits des gekürzten Fehlercodes sind, ergeben sich $L (α^{26} / 2) = L (α^{29} / 2) = L (α^{30} / 2) = 0 | .$
Das Lokatorpolynom nach Gleichung (17) hat in diesem Beispiel drei Nullstellen α²⁶, α²⁹ und α³⁰. Diese entsprechen Bitpositionen des nicht verkürzten Fehlercodes, die jedoch keine Bitpositionen des verkürzten Fehlercodes sind.
Ist der Wert eines Fehlerpositionssignals für eine Bitposition des nicht verkürzten Fehlercodes zu 1 bestimmt und ist die Bitposition keine Bitposition des verkürzten Fehlercodes, dann folgt bereits hieraus, dass für die Bitpositionen des verkürzten Fehlercodes weniger als τ Fehlerpositionssignale den Wert 1 annehmen können (sofern der verkürzte Fehlercode ein τ Bitfehler-korrigierender Fehlercode ist).
Es ist eine Option, die Werte der Fehlerpositionssignale, die den Wert 1 annehmen, zu zählen. Dies kann beispielsweise mit einem Binärzähler (sequentiell oder parallel) erfolgen. Wird durch den Zähler bestimmt, dass der Zählerstand kleiner als τ ist, wenn ein τ Bitfehler-korrigierender verkürzter Fehlercode verwendet wird, kann ein nicht korrigierbarer Fehler erkannt werden, wenn bestimmt ist, dass kein 1-Bitfehler etc. bis kein τ-Bitfehler aufgetreten ist. Ist ein Lokatorpolynom τ-ten Grades bestimmt, kann bereits bestimmt werden, dass ein nicht korrigierbarer Multibitfehler aufgetreten ist, wenn weniger als τ Fehlerpositionssignale für die Bitpositionen des verkürzten Codes den Wert 1 annehmen.
Wird festgestellt, dass ein Fehlerpositionssignal gleich 1 für eine Fehlerposition bestimmt ist, die keiner Bitposition des verkürzten Fehlercodes, sondern einer Bitposition des nicht verkürzten Fehlercodes entspricht, wird ein nicht korrigierbarer Fehler erkannt.
Das Zählen der Fehlerpositionen kann dabei sowohl unter Verwendung eines sequentiellen Zählers als auch eines parallelen Zählers erfolgen, wobei ein sequentieller Zähler nach jedem Zählen auf seinen Ausgangszustand zurückzusetzen ist.
Die Werte der Fehlerpositionssignale bfp₀ bis bfp₂₃ können dabei oder zumindest teilweise parallel bestimmt werden. In [4] ist beschrieben, wie für ein Lokatorpolynom zweiten, dritten und vierten Grades die zu korrigierenden Bitpositionen bestimmt werden können. Aus den zu korrigierenden Bitpositionen sind die Fehlerpositionssignale zu 1 bestimmt.
Die Werte der Fehlerpositionssignale können auch unter Verwendung von Software durch ein Suchverfahren bestimmt werden, wobei alle den Bitpositionen des verkürzten Fehlercodes entsprechenden Elemente des Galoisfeldes in das Lokatorpolynom eingesetzt werden und ein Fehlerpositionssignal für das entsprechende Bit zu 1 bestimmt ist, wenn das Lokatorpolynom für den eingesetzten Wert den Wert 0| annimmt. Dabei ist ein Suchverfahren für das Bestimmen der Nullstellen des Lokatorpolynoms beispielsweise in [2] beschrieben.
Analog kann verfahren werden, wenn der verkürzte Fehlercode ein b-Bit Bytefehler-korrigierender Code mit b > 1 ist und der verkürzte Fehlercode aus einem nicht verkürzten Fehlercode bestimmbar ist. Beim Verkürzen eines τ Bytefehler-korrigierenden Codes mit b > 1 ist der verkürzte Fehlercode durch Verkürzen von Bytes des nicht verkürzten Fehlercodes bestimmbar.
Bei der Fehlerkorrektur kann ein Fehlerpositionssignal bestimmt sein, das den Wert 1 annimmt, wenn in dem entsprechenden Byte ein Fehler auftritt. Das Fehlerpositionssignal kann zu 1 bestimmt sein, wenn das Lokatorpolynom den Wert 0| annimmt und zu 0 bestimmt sein, wenn das Lokatorpolynom einen Wert ungleich 0| annimmt. Die Bestimmung von Fehlerpositionssignalen für einen Reed-Solomon-Code ist beispielsweise in [5] beschrieben, wobei dort die Fehlerpositionssignale als Bytefehlerpositionssignale bezeichnet sind.
Der Wert des Fehlers oder der Fehlerwert um ein fehlerhaftes Byte zu korrigieren, kann durch ein Fehlerpolynom bestimmt sein, wie das beispielsweise in [1] oder in [4] beschrieben ist.
Obwohl die Erfindung im Detail durch das mindestens eine gezeigte Ausführungsbeispiel näher illustriert und beschrieben wurde, so ist die Erfindung nicht darauf eingeschränkt und andere Variationen können vom Fachmann hieraus abgeleitet werden, ohne den Schutzumfang der Erfindung zu verlassen.
Literaturverzeichnis:

[1] Wicker, S.: Error Control Systems for Digital Communication and Storage, Prentice Hall, 1995, Seiten 214-224
[2] Wicker, S.: Error Control Systems for Digital Communication and Storage, Prentice Hall, 1995, Seiten 205-210
[3] Lin, S; Costello, D.: Error Control Coding, Prentice Hall, 1983, Seiten 29-40
[4] Okano, H.; Imai, H.: A construction method for high speed decoders using ROMs for Bose-Chadhuri-Hocquenhem and Reed Solomon Code, IEEE Trans. Comp. C36 (10), Seiten 1165-1171
[5] DE 10 2017 125 617 B4

Claims

Verfahren zur Erkennung eines Multibytefehlers in einem Codewort eines verkürzten Fehlercodes, - bei dem der verkürzte Fehlercode ein τ Byte-korrigierender Fehlercode ist, - bei dem Bytes des Codeworts des verkürzten Fehlercodes einen ersten Bereich bestimmen, - bei dem der nicht korrigierbare Multibytefehler erkannt wird, sofern mindestens eine der folgenden Bedingungen erfüllt ist: (a) mindestens ein Fehlerpositionssignal liegt nicht in dem ersten Bereich, (b) mindestens ein Fehlerpositionssignal zeigt mindestens einen Fehler aber weniger als τ Fehler in dem ersten Bereich an und es liegt kein 1-Bytefehler bis (τ - 1)-Bytefehler vor.
Verfahren nach Anspruch 1, bei dem die Bedingung (a) weiterhin umfasst: das mindestens eine Fehlerpositionssignal, das nicht in dem ersten Bereich liegt, liegt in einem zweiten Bereich, der bestimmt ist durch Bytes eines nicht verkürzten Fehlercodes, die nicht auch Bytes des verkürzten Fehlercodes sind.
Verfahren nach einem der vorhergehenden Ansprüche, bei dem eine Anzahl des mindestens einen Fehlerpositionssignals mittels Zählens bestimmt wird.
Verfahren nach einem der vorhergehenden Ansprüche, bei dem mittels des Fehlerpositionssignals ein Byte eines Codeworts referenziert wird.
Verfahren nach einem der vorhergehenden Ansprüche, bei dem das mindestens eine Fehlerpositionssignal mittels mindestens eines Lokatorpolynoms des Fehlercodes bestimmt wird.
Verfahren nach einem der vorhergehenden Ansprüche, bei dem der verkürzte Fehlercode ein BCH-Code der Länge n über einem Galoisfeld GF(2^m) mit n < 2^m - 1 ist und m ≥ 3 gilt.
Verfahren nach einem der vorhergehenden Ansprüche, bei dem der verkürzte Fehlercode ein Reed-Solomon-Code über einem Galoisfeld GF(2^m) ist.
Vorrichtung zur Erkennung eines Multibytefehlers in einem Codewort eines verkürzten Fehlercodes, - wobei der verkürzte Fehlercode ein τ Byte-korrigierender Fehlercode ist, - wobei Bytes des Codeworts des verkürzten Fehlercodes einen ersten Bereich bestimmen, - wobei die Vorrichtung eingerichtet ist zur Erkennung des nicht korrigierbaren Multibytefehlers, sofern mindestens eine der folgenden Bedingungen erfüllt ist: (a) mindestens ein Fehlerpositionssignal liegt nicht in dem ersten Bereich, (b) mindestens ein Fehlerpositionssignal zeigt mindestens einen Fehler aber weniger als τ Fehler in dem ersten Bereich an und es liegt kein 1-Bytefehler bis (τ - 1)-Bytefehler vor.
Vorrichtung nach Anspruch 8, wobei die Vorrichtung Teil eines Speichers oder eines Speichersystems ist oder separat zu dem Speicher oder dem Speichersystem ausgeführt ist.