DE102017109588B4 - Eingebetteter Paritätsmatrixgenerator - Google Patents

Abstract

Schaltung, umfassend:einen eingebetteten Paritätsmatrixgenerator, ausgelegt zum dynamischen Erzeugen einer Paritätsmatrix abhängig von der Datenbreite eines Datenworts aus einer Mehrzahl von Datenworten unterschiedlicher Datenbreite;einen Codierer, ausgelegt zum Hinzufügen eines Redundanzworts zu dem Datenwort auf der Basis der dynamisch erzeugten Paritätsmatrix;eine mit dem Codierer gekoppelte Teilschaltung, ausgelegt zum Empfangen des Datenworts und des Redundanzworts von dem Codierer; undeinen mit der Teilschaltung gekoppelten Decodierer, ausgelegt zum Empfangen des Datenworts und des Redundanzworts von der Teilschaltung und zum Detektieren etwaiger Fehler in dem Datenwort auf der Basis der Paritätsmatrix.

Description

• Speicher und Register mit sicherheitskritischem Inhalt werden unter Verwendung von Fehlerdetektion und -korrektur geschützt. Paritätsmatrizen, die lineare Beziehungen beschreiben, die ein Codewort erfüllen muss, wurden nur für einzelne Speicher und Register abgeleitet. Immer wenn ein Speicher, der eine neue Datenbreite aufweist, benötigt wird, wird daher eine neue Paritätsmatrix abgeleitet und zum Chipentwurf hinzugefügt, der eine Ansammlung von vorentwickelten Paritätsmatrizen für jede Speichergröße umfasst.
• Ein alternativer Ansatz ist eine vorentwickelte Paritätsmatrix mit Teilmatrizen entsprechend der Datenbreite. Dieser Ansatz ist insofern einfach, als es nur eine vorentwickelte Paritätsmatrix gibt, aber im tatsächlichen Einsatz sind die Teilmatrizen außer für wenige feste Wortlängen nicht optimal ausgeglichen. Außerdem sind die Teilmatrizen im Allgemeinen nicht zu symmetrischer Codeerzeugung fähig. US 2009/0063930 A1 beschreibt einen LDPC Encoder, der im Rahmen einer Datenübertragung eingesetzt wird.
• Die unabhängigen Ansprüche definieren die Erfindung in verschiedenen Aspekten. Die abhängigen Ansprüche geben Ausführungsformen gemäß der Erfindung in verschiedenen Aspekten an.
• Es werden nun die Zeichnungen kurz beschrieben.
• 1A zeigt ein Schaltbild einer Schaltung gemäß einem Aspekt der Offenbarung.
• 1B zeigt ein Schaltbild einer Schaltung gemäß einem anderen Aspekt der Offenbarung.
• 2 zeigt ein Schaltbild einer Schaltung gemäß einem anderen Aspekt der Offenbarung.
• 3 zeigt ein Schaltbild einer Schaltung gemäß einem anderen Aspekt der Offenbarung.
• Als Nächstes werden beispielhafte Ausführungsformen gemäß der Erfindung ausführlich unter Bezugnahme auf die Zeichnungen beschrieben.
• Die vorliegende Offenbarung betrifft einen Paritätsmatrixgenerator für eine beliebige Codewortbreite. Der Paritätsmatrixgenerator ist schnell genug, um direkt in den Codierer und Decodierer oder auf einer höheren Ebene der Hierarchie eingebettet zu werden.
• 1A zeigt ein Schaltbild einer Schaltung 100A gemäß einem Aspekt der Offenbarung. 1B zeigt ein Schaltbild einer Schaltung 100B gemäß einem anderen Aspekt der Offenbarung. Diese Schaltungen 100 (100A und 100B) sind ähnlich, mit Ausnahme der Orte des eingebetteten Paritätsmatrixgenerators 140, wie nachfolgend beschrieben wird.
• Die Schaltung 100 umfasst einen eingebetteten Paritätsmatrixgenerator 140 (umfassend 140a und 140b wie in 1A gezeigt oder 140c wie in 1B gezeigt), einen Codierer 110, eine Teilschaltung 120 und einen Decodierer 130. Die Schaltung 100 kann sich in einem Mikrocontroller oder einem beliebigen Computersystem mit geschützten Teilschaltungen befinden. Der Codierer 110 und der Decodierer 130 können sich im selben oder als Alternative in verschiedenen Bereichen eines Chips befinden. Als Übersicht ist der sicherheitskritische Speicher 120 in eine Hülle mit dem Codierer 110 und dem Decodierer 120 eingebettet, wobei beide mit derselben Paritätsmatrix konfiguriert sind. Für die Zwecke der vorliegenden Besprechung wird Timing vernachlässigt.
• Der eingebettete Paritätsmatrixgenerator 140 ist ausgelegt zum Erzeugen einer Paritätsmatrix für ein Datenwort d_i einer beliebigen Datenbreite (dw). Der eingebettete Paritätsmatrixgenerator 140 beseitigt eine Anforderung, dass es für jede Teilschaltung 120 eine vordefinierte Paritätsmatrix gibt, sowie es bei vorherigen Schutzmethoden erforderlich war. Der Paritätsmatrixgenerator 140 kann zweimal jeweils im Codierer 110 und im Decodierer 130 eingebettet sein, wie in 1A gezeigt. Als Alternative kann der Paritätsmatrixgenerator 140 eingebettet sein oder nur einmal in einer Hüllenarchitektur, wobei die resultierende Paritätsmatrix in den Codierer 110 und den Decodierer 130 eingespeist wird. Eine Paritätsmatrix ist im Allgemeinen so definiert, dass ihre Anzahl von Zeilen der Datenwortbreite entspricht und ihre Anzahl von Spalten der Redundanzwortbreite entspricht. Der eingebettete Paritätsmatrixgenerator 140 ist ausgelegt zum dynamischen Erzeugen einer Paritätsmatrix gemäß nachfolgend weiter beschriebenen Kriterien.
• Der Codierer 110 ist ausgelegt zum Codieren eines Datenworts (d i) zu einem Codewort unter Verwendung einer durch den Paritätsmatrixgenerator 140 erzeugten Paritätsmatrix. Das Codewort umfasst das codierte Datenwort (d_i') und ein Redundanzwort (r_i). Das Datenwort (d_i) kann Programmdaten, Benutzerdaten, Konfigurationsdaten oder eine beliebige andere geeignete Art von Daten sein. Das Redundanzwort (r i) kann zum Beispiel ein Fehlerkorrekturcode- bzw. ECC-Wort sein. Die Paritätsmatrix (P) wird als Funktion des Datenworts (d) erzeugt, das heißt, P=gp(dw), wobei dw Datenbreite und gp eine Erzeugungsfunktion ist.
• Die Teilschaltung 120 ist ausgelegt zum Speichern des Datenworts (d_i') und des Redundanzworts (r_i), obwohl die Offenbarung in dieser Hinsicht nicht beschränkt ist. Der Codierer 110 und der Decodierer 130 können ausgelegt sein zum Codieren und Decodieren eines Datenworts (d_i), das von einem Punkt zu einem anderen ohne die dazwischentretende Teilschaltung 120 übertragen wird, oder mit der Teilschaltung 120 als Bus. Die Teilschaltung 120 kann eine beliebige Art von geeigneter Teilschaltung sein, wie etwa ein Speicher, ein Register, ein Bus, eine Schnittstelle usw. Das „N“ in der Figur repräsentiert eine Tiefe der Teilschaltung 120. Die Tiefe N ist N serielle Synchronisationsstufen, wobei jede Stufe dw+rw Signale zur nächsten Stufe und schließlich zum Ausgang der Teilschaltung 120 leitet (d.h. N*(dw+rw)).
• Der Decodierer 130 ist ausgelegt zum Decodieren des Codeworts zu dem Datenwort (d'_o) und dem Redundanzwort (r_o) unter Verwendung der erzeugten Paritätsmatrix, die im Codierer 110 und im Decodierer 130 dieselbe ist. Der Decodierer 130 ist dann ausgelegt zum Detektieren etwaiger Fehler in dem Datenwort (d'_o) auf der Basis der Paritätsmatrix und gegebenenfalls zum Korrigieren etwaiger detektierter Fehler. Der Decodierer 130 kann mit der Paritätsmatrix Einzelbitfehler korrigieren und Doppelbitfehler detektieren. Dreifachbitfehler im Datenwort können ohne Fehlerkorrektur detektiert werden.
• Mit dem eingebetteten Paritätsmatrixgenerator 140 muss keine vordefinierte Menge von Paritätsmatrizen bereitgestellt werden. Dies ist besonders vorteilhaft, wenn eine Anzahl von zu schützenden Datenbit in verschiedenen Produktableitungen unterschiedlich ist oder wenn unterschiedliche Frequenzanforderungen Modifikationen der XOR-Baumtiefen des Codierungsschemas durchsetzen.
• 2 zeigt ein Schaltbild einer Schaltung 200 gemäß einem anderen Aspekt der Offenbarung.
• Die Schaltung 200 ist insofern der 100 von 1A und 1B ähnlich, als der Codierer 210 dem Codierer 110 entspricht, die Teilschaltung 220 der Teilschaltung 120 entspricht, der Decodierer 230 dem Decodierer 130 entspricht und der eingebettete Paritätsmatrixgenerator 240 dem eingebetteten Paritätsmatrixgenerator 140 entspricht.
• Die Schaltung 200 umfasst zusätzlich Inverter 250a, 250b und Multiplexer 260a, 260b, ausgelegt zum Invertieren des Codeworts (Datenwort + Redundanzwort). Diese zusätzlichen Inverterstrukturen dienen zur Selbst-Stuck-at-Prüfung unter Verwendung eines symmetrischen Redundanzcodes. Wenn ein Fehlerkorrekturcode (ECC) mit Einzelfehlerkorrektur und Doppelfehlerdetektion (SECDED) verwendet wird, kann diese Stuck-at-Prüfung bis zu drei Stuck-at-Fehler in beliebiger Kombination detektieren. Während der Stuck-at-Prüfung ist normaler Speicherzugriff gesperrt, aber nach dem Prüfen sind die ursprünglichen Daten verfügbar. Man erreicht dies, indem zuerst ursprüngliche Daten aus der Teilschaltung 220 gelesen werden, Daten nach der Inversion in den Speicher 120 geschrieben werden, die Daten wieder gelesen, invertiert und geschrieben werden, so dass die Daten letztendlich zweimal invertiert wurden. Die Invertierung wird durch ein Steuersignal eingeschaltet, das mit den Multiplexern 260a, 260b gekoppelt ist, die entweder alle Daten und Redundanzcodewerte, die in die Teilschaltung 220 geschrieben oder aus ihr gelesen werden, negieren oder die ursprünglichen Daten schreiben. Wenn der Redundanzcode symmetrisch ist, müssen der Decodierer 230 und der Codierer 210 die aktuelle Polarität des Codeworts nicht kennen. Wenn der Redundanzcode asymmetrisch ist, müssen die Codebit entsprechend Matrixspalten mit geraden Summen zusätzlich in dem Codierer 210 vor dem Schreiben und in dem Decodierer 230 nach dem Lesen invertiert werden. Somit ist es, wenn möglich, vorzuziehen, symmetrische Codes zu verwenden.
• Diese Schaltung 200 wird weiter in der US-Patentanmeldung Nr. 14/166,360 , eingereicht am 28. Januar 2014 und publiziert als US 2015-0212877 A1 , beschrieben.
• 3 zeigt ein Schaltbild einer Schaltung 300 gemäß einem anderen Aspekt der Offenbarung.
• Die Schaltung 300 ist insofern der Schaltung 200 von 2 ähnlich, als der Codierer 310 dem Codierer 210 entspricht, die Teilschaltung 320 der Teilschaltung 220 entspricht, der Decodierer 330 dem Decodierer 230 entspricht, die Inverter 350 den Invertern 250 entsprechen, die Multiplexer 360 den Multiplexern 260 entsprechen und der eingebettete Paritätsmatrixgenerator 340 dem eingebetteten Paritätsmatrixgenerator 240 entspricht.
• Die Schaltung 300 umfasst zusätzlich ein Inversionssteuersignal zur Hinzufügung eines Modifizierbit, was durch die Verbindung dieses Signals mit dem Codierer 310 und dem Decodierer 330 angegeben ist. Diese Modifikation ist für einen Fall nützlich, bei dem nicht alle Spaltensummen der Paritätsmatrix ungerade sind, das heißt die Paritätsmatrix nicht symmetrisch ist. Genauer gesagt werden die geraden Spalten der Matrix durch ein Modifizierbit justiert. Das Modifizierbit macht diese geraden Spalten künstlich ungerade, was zu einem selben Verhalten führt, als wäre die Paritätsmatrix symmetrisch.
• Diese Schaltung 300 wird weiter in der US-Patentanmeldung Nr. 14/447,806 , eingereicht am 31. Juli 2014 und publiziert als US 2015-0039952 A1 , beschrieben.
• Der hier offenbarte Paritätsmatrixgenerator ist dafür ausgelegt, schnell eine optimale Paritätsmatrix für einen Bereich von Konfigurationsparametern zu erzeugen. Der Paritätsmatrixgenerator ist ausgelegt zum Bereitstellen von gleichförmigen generischen Codierer- und Decodiererkomponenten, die automatisch für eine beliebige erforderliche Datenwortbreite gemäß einer Speicher- oder Registergröße erzeugt werden. Neben Datenbreiten ist der Paritätsmatrixgenerator für symmetrische SECDED- und DED-Redundanzcodes, modifizierbare asymmetrische SECDED/DED-Codes konfigurierbar, weist einen vollständig ausgeglichenen oder minimierten XOR-Gatterzählwert, eine minimierte oder benutzerdefiniert begrenzte XOR-Baumtiefe und vergrößerte Mehrfachbitfehlerdetektion durch inkrementierte Codebreite auf.
• Bei einer symmetrischen Matrix sind alle Spaltensummen ungerade, was eine Vorausbedingung für nicht destruktives Inversionsprüfen ohne Modifizierbit ist. Eine asymmetrische Matrix weist mindestens eine gerade Spaltensumme auf.
• Der Paritätsmatrix-Erzeugungsalgorithmus basiert auf beliebigen der folgenden Kriterien:
• a) Ausgleichen von Einsen (1en) in Paritätsmatrixspalten:
• Paritätsmatrix-Spaltensummen werden auf eine beliebige erforderliche und durchführbare Weise ausgeglichen. Wenn zum Beispiel ein Ziel darin besteht, eine Paritätsmatrix für symmetrische Codeerzeugung zu erhalten, und zwei Spalten einer anfänglichen Paritätsmatrix gerade Summen aufweisen, werden alternative Permutationen von 1en in Matrixzeilen berechnet, so dass eine Summe einer Spalte inkrementiert und eine Summe einer anderen Spalte dekrementiert wird. Um eine Maximaltiefe von XOR-Bäumen zur Codeerzeugung, die mit einer Anzahl von 1en in jeder Spalte der Paritätsmatrix zusammenhängt, zu minimieren, werden die 1en so verteilt, dass eine Spaltensummendifferenz minimal ist. Dieser Ausgleich bezieht sich auf die vollständige Matrix, die aus mehreren Teilmatrizen mit einzelnen voneinander abhängigen Spaltensummen, die nicht unbedingt optimal ausgeglichen sind, zusammengesetzt sein kann.
• b) Paritätsmatrix für symmetrische Codeerzeugung:
• Eine Paritätsmatrix erzeugt symmetrischen Code, der zur nicht destruktiven Stuck-at-Prüfung von Speichern verwendet wird, wie in der US-Patentanmeldung Nr. 14/166,360 beschrieben, wenn alle ihre Spaltensummen ungerade sind. Zusammen mit den Hammingdistanzen (hd), die zur Erzielung erforderlicher Fehlerdetektionsfähigkeiten notwendig sind (hd >= 2 * BEc, wobei BEc eine Anzahl von sicher korrigierbaren Bitfehlern ist, und hd >=BEd -1, wobei BEd eine Anzahl von sicher detektierbaren Bitfehlern ist), einer gegebenen Datenwortbreite und gegebenenfalls einer gegebenen Codewortbreite wird der Raum möglicher Lösungen für eine geeignete Paritätsprüfmatrix aufgespannt. Um Flächen- und Stromverbrauch und kombinatorische Ausbreitungsverzögerungen für Schaltkreise des Codierers 110/210/310 und Decodierers 130/230/330 zu verringern, ist die Paritätsmatrix außerdem so konstruiert, dass eine Gesamtzahl von XOR-Gattern, die mit der Anzahl von 1en in der Matrix zusammenhängt, und eine Größe der XOR-Bäume, die mit der Anzahl von 1en in den Spalten der Matrix zusammenhängt, minimiert werden. Zusätzlich ist es wünschenswert, aber nicht obligatorisch, Prozentsätze detektierbarer Mehrbitfehler, für die keine 100%ige Detektion erforderlich ist, zu maximieren.
• c) Komponenten der generischen Registertransferebene (RTL):
• Eine Implementierung der Matrixerzeugungsalgorithmen in Verifikationsumgebungen ist in jeder Umgebung und jeder Programmiersprache möglich, einschließlich Hardwarebeschreibungssprachen wie VHDL oder Verifikationssprachen wie Systeme oder SystemVerilog. Die Erzeugung kann in Form von konfigurierbaren RTL-Komponenten für Komponenten von Codierer 110/210/310 und Decodierer 130/230/330 bereitgestellt werden, die automatisch während der Entwicklungsarbeit gemäß direkter Spezifikation oder indirekter Ableitung generischer Parametererzeugungen erzeugt werden. Eine Komponente solcher generischer Komponenten ist eine Funktion zum Erzeugen geeignet erzeugter Paritätsmatrizen, wobei alle konfigurierten Eigenschaften direkt in den generischen RTL-Entwurf eingebettet werden. Auf einem Verifikationsprüfstand macht es der Paritätsmatrixgenerator überflüssig, Bibliotheken von Matrizen für alle benötigten Instanzen zu unterhalten, indem aktuell benötigte Matrizen auf dynamische Weise, das heißt im Fluge, erzeugt werden. Der Paritätsmatrixgenerator ist schnell genug, so dass Entwicklungsarbeit verglichen mit festen im Voraus erzeugten Matrizen nicht merklich verlangsamt wird. Die erhaltenen vernachlässigbaren Erzeugungszeiten von nur einigen wenigen Sekunden für große Codewortbreiten, selbst weit über jede praktische Notwendigkeit hinaus.
• d) Paritätsmatrixkonfiguration
• Die dynamische Erzeugung von Paritätsmatrizen basiert auf einer Sequenz von iterativen Transformationen von Zwischenlösungen, die noch nicht alle Anforderungen erfüllen. Bereitstellung und Manipulation dieser Zwischenlösungen als explizite Matrizen sind zu ineffizient. Stattdessen gibt es eine Matrixkonfiguration, die nicht eine einzige Matrix eindeutig spezifiziert, sondern eine Menge von Matrizen, die sich alle spezifische Eigenschaften teilen. Eine Matrixkonfiguration ist definiert als eine Liste von 3-Tupeln C:= {{dw₀ k₀ bv₀} ... {dw_i k_i bv_i} ...}, wobei jedes Tupel Ci := {dw_i k_i bv_i} eine Zeilenpartition einer Paritätsprüfmatrix spezifiziert, mit
  d_Wi: Anzahl der Zeilen von Partition i
  k_i: Anzahl der 1en in jeder Zeile von Partition i (Zeilen-Hamminggewichte)
  bv_i: Ausgleichsvektor für die Spaltensummen der C_i entsprechenden Teilmatrix
• Der Ausgleichsvektor spezifiziert die relativen Differenzen von Spaltensummen C1s der Teilmatrix, wobei ein kleineres Ausgleichsvektorelement einer größeren Summe der Elemente der entsprechenden Spalte entspricht. Die 1en in jeder Matrix werden somit dergestalt ausgeglichen, dass die Spalte j mit dem niedrigsten bv_ij-Wert die höchste Spaltensumme aufweist. Eine Teilkonfiguration ist nicht verschieden, wenn eine Konstante zu allen Elementen des Ausgleichsvektors addiert wird.
• Gegebenenfalls kann ein Spaltensummenvektor zu der Spezifikation einer Teilkonfiguration addiert werden (in der vorliegenden Arbeit lediglich zu Veranschaulichungszwecken) : {dw_ik_ibv_i} : sv_j
• Wenn Spaltensummenvektor und Ausgleichsvektor addiert werden, sind alle Elemente des Ergebnisvektors gleich.
• Die Spezifikation der Spaltensummen fügt keinerlei zusätzliche Nebenbedingung hinzu, kann aber eindeutig aus dem Ausgleichsvektor abgeleitet werden: ∃_c∀_ic = sv_ij + bv_ij, wobei c der Mindestwert des Ausgleichsvektors ist. Im Fall c=0 nennt man den Ausgleichsvektor normiert. Die Summe der Spaltensummen ist immer gegeben als ${\text{dw}}_{\text{i}}{\text{* k}}_{\text{i}}={{\displaystyle {\sum }_{\text{i}}\text{SV}}}_{\text{ij}}.$

  
• Die Verkettung einer beliebigen Auswahl von Teilmatrizen entsprechend einer Liste von Teilkonfigurationen stellt eine Matrix dar, die die Gesamtkonfiguration erfüllt.
• Zum Beispiel kann die (Teil-)Konfiguration {3 3 {0 0 0 0 1 1}}: {2 2 2 1 1 1} durch eine Matrix mit den Zeilen {{1 1 1 0 0 0} {1 0 0 1 1 0} {0 1 1 0 0 1}} oder als Alternative mit {{1 1 1 0 0 0} {1 1 0 1 0 0} {0 0 1 0 1 1}} oder anderen implementiert werden. Wenn alle Elemente des Ausgleichsvektors um eine Konstante inkrementiert werden, unterscheidet sich die die Konfiguration erfüllende Menge von Matrizen nicht, z.B. {3 3 {1 1 1 1 2 2}}: {2 2 2 1 1 1}. Diese Inkrementierung kann wie später beschrieben für Un-Ausgleich verwendet werden. Alle Matrixlösungen einer Teilkonfiguration haben gemeinsam, dass jede Zeile 3 1en aufweist und ihre Spaltensummen gleich {2 2 2 2 1} sind. Die Teilkonfiguration {3 5 {0 0 0 1 1 1}}: {3 3 3 2 2 2} hat die Lösung { {1 1 1 0 1 1} {1 1 1 1 0 1} {1 1 1 1 1 0}}. Die kombinierte Konfiguration {{3 3 {0 0 0 0 1 1}}: {2 2 2 1 1 1}} {3 5 {0 0 0 1 1 1}}: {3 3 3 2 2 2}}} hat somit die Lösungen {{1 1 1 0 0 0) {1 0 0 1 1 0} {0 1 1 0 0 1} {1 1 1 0 1 1} {1 1 1 1 0 1} {1 1 1 1 1 0}}, {{1 1 1 0 0 0} {1 1 0 1 0 0} {0 0 1 0 1 1} {1 1 1 0 1 1} {1 1 1 1 0 1} {1 1 1 1 1 0}} oder andere.
• Eine beliebige dieser kombinierten Lösungen hat einen Spaltensummenvektor {5 5 5 3 3 3} und einen entsprechenden globalen Ausgleichsvektor {0 0 0 2 2 2}. Aus diesem kleinen Beispiel ist offensichtlich, dass das Manipulieren von Matrixkonfigurationen weit effizienter als die Verwendung der Matrizen ist. Zum Beispiel ist die Konfiguration für eine Menge von Paritätsmatrizen für die Datenbreite 267 immer noch sehr praktisch: {{120 3 {0 0 0 0 0 0 0 0 0 0} } {147 5 {0 0 0 0 0 1 1 1 1 1}}}. Das Massieren von expliziten Matrizen mit 10 * 267 Elementen wäre dagegen viel weniger effizient.
• Der Ausgleichsvektor ist nicht beliebig auswählbar: Für Teilkonfigurationen mit ungültigem Ausgleichsvektor existieren keine Lösungen, z.B. für {3 3 {0 0 0 0 1 1}} oder {3 3 {0 2 0 0 0 0}} oder {3 3 {0 0 1 2 3 3}}. Im Gegensatz dazu erhält man für {3 3 {0 0 3 2 2 2}} eine Lösung: {{1 1 0 1 0 0} {1 1 0 0 1 0} {1 1 0 0 0 1}}. Die Summe der Spaltensummenvektorelemente {3 2 1 1 1 1} muss dw_i * k_i = 3*3 = 9 sein.
• Die Codebreite spiegelt sich in der Länge der Ausgleichsvektoren wider: rw = Länge(bvi) für beliebiges i, was direkt der Anzahl von Spalten der Paritätsprüfmatrix entspricht. Für jede Teilkonfiguration wird die Anzahl von Teilmatrixzeilen durch die Ungleichung ${\text{dw}}_{\text{i}}<=\left(\begin{array}{c}\text{rw}\\ {\text{k}}_{\text{i}}\end{array}\right)$

  

  begrenzt.
• Zum Beispiel konfiguriert {dw_max(5), 3 {0 0 0 0 0}} eine vollständige Teilmatrix mit ${\text{dw}}_{\text{MAX}}\left(5\right)=\left(\begin{array}{c}5\\ 3\end{array}\right)=10$

  

  verschiedenen Zeilen mit durchweg einzigartigen Permutationen von 3-1-Positionen.
• e) Paritätsmatrixkonfiguration mit Nebenbedingungen
• Eine Paritätsmatrixkonfiguration mit Nebenbedingungen umfasst ein zusätzliches Nebenbedingungsmuster in jeder Teilkonfiguration und wird als Liste von 4-Tupeln mit {dwi pat_i ki bv_i} spezifiziert. Das Nebenbedingungsmuster spezifiziert, dass alle Zeilen der Teilkonfiguration das Muster erfüllen. Der Ausgleichsvektor bezieht sich hier nur auf die Positionen ohne Nebenbedingungen, und hat somit Länge (bv_i) = rw - rwl_i, mit rwl_i := Anzahl (Spalten mit Nebenbedingungen), da es offensichtlich Unsinn wäre, die festen Positionen mit Nebenbedingungen einzuschließen, für die kein Ausgleich möglich ist. Wenn das Nebenbedingungsmuster rwl_i Zeilenpositionen einschränkt, ist die Anzahl von Teilmatrixzeilen dwi <= (rw-rwl_ik_i) .
• Zum Beispiel wird die Konfiguration {3, {* * * 0 *}, 3, {1 0 1 1}} durch die Matrix {{1 1 1 0 0} {1 1 0 0 1} {0 1 1 0 1}} erfüllt, und die maximale Konfiguration würde als {4, {* * * 0 *}, 3, {0 0 0 0}} gegeben, mit einer zusätzlichen Matrixzeile {1 0 1 0 1} .
• Eine Konfiguration ohne Nebenbedingungen gemäß c) kann als Konfiguration mit Nebenbedingungen mit dem Nicht-Nebenbedingungs-Muster {*} betrachtet werden.
• Die Gültigkeit einer Teilkonfiguration mit Nebenbedingungen folgt direkt aus der Gültigkeit der Konfiguration ohne Nebenbedingungen, die den Tupelelementen ohne Nebenbedingungsmuster entspricht.
• Wenn die Nebenbedingung durch ein Muster mit Platzhaltern für Positionen ohne Nebenbedingungen spezifiziert wird, ist die Gültigkeit der Teilkonfiguration automatisch gegeben, wenn die Teilkonfiguration ohne Nebenbedingungen gültig ist.
• Nebenbedingungen könnten als Alternative als logische Funktionen von Zeilenbit spezifiziert werden, z.B. „if Bit 1 = 1 then Bit 3 = 0“. In diesem Fall könnte die Teilkonfiguration in mehrere Teilkonfigurationen mit Musternebenbedingungen mit den Mustern: {* * * 1 0},{* * * 0 *} oder alternativ {* * * 1 0},{* * * 0 0},{* * * 0 1} aufgeteilt werden.
• Der Kürze halber können äußerste rechte kohärente Platzhalterpositionen weggelassen werden, d.h. {* 0 * * *} ~> {* 0}, {1 * *} ~> {1}. Wenn Teilkonfigurationen mit Nebenbedingungen mit Nebenbedingungsmustern verschiedener Länge zu Konfigurationen mit Nebenbedingungen kombiniert werden, werden diejenigen mit Nebenbedingungen kleinerer Länge an ihren Platzhalterpositionen aufgeteilt, bis alle Muster dieselbe Länge aufweisen, z.B. {1 *} ~> {1 0} {1 1}, wobei die resultierenden Datenbreiten dw_i0 und dw_i1 und Ausgleichsvektoren bv_i0 und bv_i1 auf nachfolgend beschriebene angemessene Weise berechnet werden.
• f) Ausgleich und Un-Ausgleich
• Eine Teilkonfiguration mit einem Ausgleichsvektor mit einer Differenz von höchstens 1 zwischen minimalem und maximalem Element ist eine ausgeglichene Teilkonfiguration. Alle Permutationen des Ausgleichsvektors führen auch zu ausgeglichenen Teilkonfigurationen. Eine ausgeglichene Teilkonfiguration kann äquivalent spezifiziert werden, indem man den Ausgleichsvektor in dem Tupel mit der Codebreite: {dw_i pat_i k_i rw} ersetzt.
• Ein Ausgleichsvektor mit minimalem Element 0 ist ein normierter Ausgleichsvektor.
• Ein Ausgleichsvektor mit einer Differenz >1 zwischen minimalem und maximalem Element ist ein Un-Ausgleichsvektor. Wenn diese Differenz 2 ist, ist der Un-Ausgleichsgrad 1, im Allgemeinen n-1 für Differenz n. Zusätzlich bezeichnet ein Un-Ausgleichsindex die Anzahl von zum Un-Ausgleich ausgeführten Inkrement-/Dekrementschritten. Er kann berechnet werden durch Sortieren von normiertem Ausgleichs- und Un-Ausgleichsvektor und Berechnen eines Vektors mit absoluten elementweisen Differenzen. Un-Ausgleich (bv, n, m) wird für eine Transformation von ausgeglichener Vorgabekonfiguration geschrieben, wenn die maximale Differenz zwischen höchstem und niedrigstem Element des Ausgleichsvektors (oder entsprechenden Spaltensummen) n ist und m Un-Ausgleichsschritte ausgeführt wurden. Un-Ausgleich (bv, n,m, c) wird geschrieben, wenn eine Konstante c zu allen Elementen des normierten Ausgleichsvektors addiert wird, die Differenz zwischen seinen kleinsten und größten Elementen n+1 ist und die Summe aller positiven Elemente des Differenzvektors zwischen Ausgleichsvektor und unausgeglichenem Vektor m ist.
• Es folgen einige wenige Beispiele: $$\text{Un}-\text{Ausgleich}\left(\left\{1\text{1 1 1 1 0 0}\right\}\mathrm{,0,0,0}\right)=\left\{1\text{1 1 1 1 0 0}\right\}$$

  

  $$\text{Un}-\text{Ausgleich}\left(\left\{1\text{1 1 1 1 0 0}\right\}\mathrm{,0,0,1}\right)=\left\{\text{2 2 2 2 2 1 1}\right\}$$

  

  $$\text{Un}-\text{Ausgleich}\left(\left\{1\text{1 1 1 1 0 0}\right\}\mathrm{,0,0,2}\right)=\left\{3\text{3 3 3 3 2 2}\right\}$$

  

  $$\text{Un}-\text{Ausgleich}\left(\left\{1\text{1 1 1 1 0 0}\right\}\mathrm{,1,1,0}\right)=\left\{\text{2 1 1 1 0 0 0}\right\}$$

  

  $$\text{Un}-\text{Ausgleich}\left(\left\{1\text{1 1 1 1 0 0}\right\}\mathrm{,1,2,0}\right)=\left\{2\text{2 1 0 0 0 0}\right\}$$

  

  $$\text{Un}-\text{Ausgleich}\left(\left\{1\text{1 1 1 1 0 0}\right\}\mathrm{,1,1,1}\right)=\left\{2\text{2 2 2 2 2 2 0}\right\}$$

  

  $$\text{Un}-\text{Ausgleich}\left(\left\{1\text{1 1 1 1 0 0}\right\}\mathrm{,2,1,1}\right)=\left\{3\text{2 2 2 2 1 0}\right\}$$

  

  $$\text{Un}-\text{Ausgleich}\left(\left\{1\text{1 1 1 1 0 0}\right\}\mathrm{,2,2,1}\right)=\left\{3\text{3 2 2 1 1 0}\right\}$$

  
• Eine ausgeglichene Konfiguration hat eine Lösung für ausreichende Codebreite, während unausgeglichene Konfigurationen möglicherweise keine Lösung haben. Wenn eine unausgeglichene Konfiguration keine Lösung hat, hat eine noch mehr unausgeglichene Konfiguration auch keine. Diese Beziehung legt nahe, dass Un-Ausgleichen iterativ zu vergrößern, wenn es notwendig ist, wobei von einer gültigen ausgeglichenen Konfiguration ausgegangen wird.
• g) Mehrfach-Ausgleich
• Um einen globalen Ausgleichsvektor für eine gesamte Konfiguration zu erfüllen, werden die Ausgleichsvektoren der Teilkonfigurationen dergestalt bestimmt, dass ihre Verbund-Spaltensummen dem globalen Ausgleichsvektor entsprechen. Dieser Un-Ausgleichswert jedes einzelnen Ausgleichsvektors ist niemals höher als der Un-Ausgleichswert des globalen Ausgleichsvektors. Oft lässt sich globaler Un-Ausgleich ohne Un-Ausgleichen erzielen. Durch Mehrfach-Ausgleich ist man in der Lage, Ausgleichsvektoren für Teilkonfigurationen einer Konfiguration zu erzeugen, um einen gegebenen globalen Ausgleichsvektor der vollständigen Konfiguration zu erfüllen. Zum Beispiel wird für eine Liste {{dw₀ k₀} {dw_i k₁} } := {{2 2} {5 3}} und einen globalen Ausgleichsvektor bvg:= {0 0 3 0 3} die Konfiguration {{2 2 {0 1 2 1 2}}: 2 1 0 1 0 {5 3 {0 0 2 1 2}}:4 4 2 3 2} erhalten.
• Im Folgenden werden Mengen von Funktionen zusammengefasst, die insgesamt das System eingebetteter Matrixerzeugungsfunktionen bilden, das in die generischen Codierer- und Decodiererkomponenten eingefügt wird.
• h) Eine Menge von Matrixgeneratoren zum
• - Transformieren einer Teilkonfiguration {dwi k_i bv_i} ohne Nebenbedingungen in eine Paritätsprüfmatrix mit dw_i Zeilen, alle mit Hamminggewicht k_i, und wobei der Vektor ihrer Spaltensummen, addiert zu ihrem Ausgleichsvektor bv_i, zu einem Vektor mit identischen Elementen führt.
• - Transformieren einer Teilkonfiguration {dw_i pat_i k_i bv_i} mit Nebenbedingungen in eine Paritätsprüfmatrix, wobei die Spalten mit Nebenbedingungen abhängig von dem Nebenbedingungsmuster nur 0en oder nur 1en enthalten. Tatsächlich ruft diese Funktion zuerst die vorherige Funktion für die Spalten ohne Nebenbedingungen auf und fügt dann gemäß dem Nebenbedingungsmuster 0- und 1-Spalten hinzu.
• - Transformieren einer Konfiguration mit Teilkonfigurationen in eine Paritätsprüfmatrix durch einfaches Verketten der durch die Anwendung der ersten Funktion auf die Teilkonfigurationen erhaltenen Teilmatrizen.
• - Transformieren einer Konfiguration mit Nebenbedingungen mit Teilkonfigurationen mit Nebenbedingungen in eine Paritätsprüfmatrix durch einfaches Verketten der durch Anwendung der zweiten Funktion auf die Teilkonfigurationen mit Nebenbedingungen erhaltenen Teilmatrizen.
• i) Eine Menge von Konfigurationsgeneratoren zum
• - Berechnen der Vorgabekonfiguration für eine gegebene Nutzinformationsdatenbreite, Matrixzeilen-Hammingdistanz und eine optionale Codebreite >= dem erforderlichen Minimum. Zum Beispiel erfordert eine (Hsiao-) Paritätsmatrix für SECDED eine Zeilen-Hammingdistanz >= 2 mit mindestens 3 1en pro Zeile.
• - Berechnen einer Konfiguration mit Teilkonfigurationen für ungerade k>=3
• - Berechnen einer Konfiguration mit Teilkonfigurationen für ungerade und gerade k>=3
• - Berechnen einer invertierbaren Konfiguration mit Teilkonfigurationen mit ungeradem k>=3 durch Transformieren einer anfänglichen nicht invertierbaren Konfiguration in eine invertierbare, was nicht immer ohne Vergrößern der Codebreite möglich ist.
• - Berechnen einer invertierbaren Konfiguration mit Teilkonfigurationen für ungerade und gerade k>=3, was in vielen Fällen Vermeidung einer inkrementierten Codebreite erlaubt.
• j) Eine Menge von Konfigurations-Transformationsfunktionen zum
• - Vergrößern von dwi von Teilkonfiguration i um δ_+dwi und Verringern von dw_j von Teilkonfiguration j um δ_-dwi, so dass ${\displaystyle \sum _{\text{i}}{\mathrm{\delta }}_{+\text{dwi}}={\displaystyle \sum _{\text{j}}{\mathrm{\delta }}_{-\text{dwj}}}}$
  
  ist. Solche Transformationen ändern den globalen Ausgleichsvektor der vollständigen Konfiguration, was beabsichtigt ist, wenn z.B. die Anzahl gerader Spaltensummen nicht auf die erforderliche Weise durch Ausgleich oder Un-Ausgleich einzelner Teilkonfigurationen modifiziert werden kann, ohne ihre Datenbreiten anzufassen.
• - Berechnen von Transformationsspezifikationen { δ_+dwi0, ..., δ_+dwim , δ_-dwj0, ... δ_-dwjn } mit ${\displaystyle \sum _{\text{i}}{\mathrm{\delta }}_{+\text{dwi}}={\displaystyle \sum _{\text{j}}{\mathrm{\delta }}_{-\text{dwj}}}},$
  
  dergestalt, dass der globale Ausgleichsvektor ${\text{bv}}_{\text{g}}:=\left\{{\text{bv}}_{\text{g}}^{\text{rw}-\text{1}},{\text{bv}}_{\text{g}}^{\text{rw}-\text{2}},\dots {\text{bv}}_{\text{g}}^0\right\}$
  
  auf eine spezifische erforderliche Weise in ${\text{bv}}_{\text{g}}:=\left\{{\text{bv}}_{\text{g}}^{\text{'rw}-\text{1}},{\text{bv}}_{\text{g}}^{\text{'rw}-\text{2}},\dots {\text{bv}}_{\text{g}}^{\text{'}0}\right\}$
  
  modifiziert wird. Zum Beispiel vergrößert Modifizieren einer Konfiguration {{dw_i , k_i, bv_i, {0}}, {dw_j , k_j , bv_j, {1}} in {{dw_i-1, k_i , bv_i, {0} }, {dw_j + 1, k_j, bv_j,{1}} die äußerste linke Spaltensumme um 1 und verringert dementsprechend die äußerste linke Komponente des resultierenden globalen Ausgleichsvektors um 1 auf ${\text{bv'}}_{\text{g}}:=\left\{{\text{bv}}_{\text{g}}^{\text{rw}-\text{1}}-\mathrm{1,}{\text{bv}}_{\text{g}}^{\text{'rw}-\text{2}},\dots {\text{bv}}_{\text{g}}^{\text{'}0}\right\},$
  
  wobei die rechteren Komponenten des neuen globalen Ausgleichsteilvektors neu berechnet werden müssen.
• k) Eine Menge von Hilfsfunktionen zum
• - Berechnen des Vektors von (links-rechtspartitionierten) Spaltensummen in Bezug auf eine Matrixkonfiguration (mit Nebenbedingungen)
• - Berechnen des Vektors von (links-rechtspartitionierten) Spaltensummen in Bezug auf eine Liste von Matrixkonfigurationen
• - Transformieren von Spaltensummenvektoren in Ausgleichsvektoren.
• - Berechnen des globalen Ausgleichsvektors einer Konfiguration aus seinen Teilkonfigurationen.
• - Berechnen des Vektors von Gerade-Ungerade-Indikatoren hinsichtlich Spaltensummenvektoren und der Anzahl von (partitionierten) geraden Spaltensummen
• - Berechnen der Maximalzahl von (Nutzinformations-)Datenbit für eine gegebene Codebreite und Zeilen-Hammingdistanz oder die minimale Codebreite für eine gegebene Datenbreite
• - Prüfen einer Konfiguration auf die Nichtexistenz einer Lösung gemäß den folgenden Lemmata:
  • 1. Eine Lösung für die ausgeglichene Vorgabekonfiguration (mit ausreichender Codebreite) existiert immer.
  • 2. Für eine Konfiguration, die nicht durch iteratives Verringern einer ausgewählten Position des Ausgleichsvektors und Vergrößern einer anderen Position um dieselbe Differenz in eine ausgeglichene Konfiguration transformiert werden kann, existiert keine Lösung. Wenn zum Beispiel der Ausgleichsvektor {0 0 0 0 1} eine Konfiguration betrifft, kann für {0 2 0 2 2} keine Lösung existieren, existiert aber definitiv nicht für {1 0 0 0 1}.
  • 3. Für Un-Ausgleich (n, m, c) und wenn n+m > dw ist oder wenn die Differenz zwischen maximaler Datenbreite entsprechend der Codebreite und gegebener Datenbreite kleiner als n ist: n+m > dwmax(rw) - dw, existiert keine Lösung. Zum Beispiel kann die Konfiguration {3, 3, {0 0 0 0 1}} nicht in {3, 3, {0 4 0 2 0}} transformiert werden.
  • 4. Wenn eine Lösung für eine Konfiguration existiert, hat jede Konfiguration mit beliebig permutiertem Ausgleichsvektor eine Lösung.
  • 5. Es existiert keine lösbare invertierbare Konfiguration mit nur ungeraden Zeilen-Hamminggewichten, wenn die Anzahl gerader Spaltensummen ungerade ist. Dies ist ein starkes und einfaches Kriterium zum Entscheiden, ob der Generator für Ungerade-Gerade-Matrixzeilengewichte aufgerufen wird.
  • 6. Wenn keine Un-Ausgleich(nO,mO,cO)-Lösung existiert, hat Un-Ausgleich(n1,m1,c1) auch keine Lösung, wenn n1+m1>n0+m0 ist.
• Diese Lemmata geben schnelle Prüfungen auf die Existenz von Lösungen von Teilkonfigurationen. Eine andere, potentiell kostspieligere Prüfung leitet die Existenz einer Lösung einer Konfiguration rekursiv aus der Existenz von Lösungen für die zwei Teilkonfigurationen ab, die sich aus Aufteilen der Konfiguration {dw_i, k_i, bv_i, {*} } in 2 Teile mit Nebenbedingungen mit Nebenbedingungsmustern {dw_i0 {0} k_i0 bv_i0} und {dw_i1 {1} k_i1 bv_i1} ergeben. Für diesen Zweck wurde eine Mehrfach-Ausgleichsfunktion zum Aufteilen einer Konfiguration in gültige Teilkonfigurationen bereitgestellt. Bei Verwendung von Prüfen der Gültigkeit einer Konfiguration wird die rekursive Untersuchung der Gültigkeit einer Konfiguration gestoppt, wenn alle ihre Teilkonfigurationen Ausgleichsvektoren nur mit 0-1 aufweisen, die gemäß Lemma 1 gültig sind.
• Die Anordnung von Prüfungen gemäß ihrer Komplexität ist für eine effiziente Konstruktionsprozedur für eine Konfiguration mit mindestens einer Lösung mit den erforderlichen Eigenschaften entscheidend.
• 1) Eine Menge von Konfigurationstransformationsfunktionen zum
• - Vergrößern von dwi von Teilkonfigurationen i um δ_+dwi und Verringern von d_wj von Teilkonfigurationen j um δ_-dwj, dergestalt, dass ${\displaystyle \sum _{\text{i}}{\mathrm{\delta }}_{+\text{dwi}}={\displaystyle \sum _{\text{j}}{\mathrm{\delta }}_{-\text{dwj}}}}$
  
  ist. Solche Transformationen ändern den globalen Ausgleichsvektor der vollständigen Konfiguration, was beabsichtigt ist, wenn z.B. die Anzahl gerader Spaltensummen nicht auf die erforderliche Weise durch Ausgleich oder Un-Ausgleich nur von einzelnen Teilkonfigurationen ohne Ausgleich ihrer Datenbreiten modifiziert werden kann.
• - Berechnen von Transformationsspezifikationen { δ_+dwi0 , ..., δ_+dwin , δ_-dwj0 , ... δ-_dwjn} mit ${\displaystyle \sum _{\text{i}}{\mathrm{\delta }}_{+\text{dwi}}={\displaystyle \sum _{\text{j}}{\mathrm{\delta }}_{-\text{dwj}}}}$
  
  dergestalt, dass der globale Ausgleichsvektor ${\text{bv}}_{\text{g}}:=\left\{{\text{bv}}_{\text{g}}^{\text{rw}-\text{1}},{\text{bv}}_{\text{g}}^{\text{rw}-\text{2}},\dots {\text{bv}}_{\text{g}}^0\right\}$
  
  auf spezifische erforderliche Weise in ${\text{bv'}}_{\text{g}}:=\left\{{\text{bv}}_{\text{g}}^{\text{'rw}-\text{1}},{\text{bv}}_{\text{g}}^{\text{'rw}-\text{2}},\dots {\text{bv}}_{\text{g}}^{\text{'}0}\right\}$
  
  modifiziert wird. Zum Beispiel vergrößert Transformation einer Konfiguration {{dw_i , k_i , bv_i, {0}}, {dw_j , k_j bv_j,{1}} in {{dw_i-1, k_i bv'_i,{0}, {dW_j + 1, k_j bv'_j, {1}} die äußerste linke Spaltensumme um 1, wodurch sie möglicherweise ungerade wird, und verringert dementsprechend die äußerste linke Komponente des resultierenden globalen Ausgleichsvektors um 1 auf ${\text{bv'}}_{\text{g}}:=\left\{{\text{bv}}_{\text{g}}^{\text{'rw}-\text{1}},{\text{bv}}_{\text{g}}^{\text{'rw}-\text{2}},\dots {\text{bv}}_{\text{g}}^{\text{'}0}\right\},$
  
  wobei die rechteren Komponenten des neuen globalen Ausgleichs-Teilvektors neu berechnet werden müssen.
• m) Eine Menge von Konfigurationsgeneratoren zum
• - Berechnen der Vorgabekonfiguration für eine gegebene Nutzinformations-Datenbreite, Matrixzeilen-Hammingdistanz und eine optionale Codebreite >= dem erforderlichen Minimum. Zum Beispiel erfordert eine (Hsiao-) Paritätsmatrix für SECDED eine Zeilen-Hammingdistanz >=2, mit einem Minimum von 3 1en pro Zeile.
• - Berechnen einer Konfiguration mit Teilkonfigurationen für ungerades k>=3
• - Berechnen einer Konfiguration mit Teilkonfigurationen für ungerade und gerade k>=3
• - Berechnen einer invertierbaren Konfiguration mit Teilkonfigurationen für ungerades k>=3 durch Transformieren einer anfänglichen nicht invertierbaren Konfiguration in eine invertierbare, was nicht immer ohne Vergrößern der Codebreite möglich ist.
• - Berechnen einer invertierbaren Konfiguration mit Teilkonfigurationen für ungerade und gerade k>=3, was in einigen Fällen Vermeidung einer inkrementierten Codebreite erlaubt.
• n) Vollständige Entscheidungsprozedur für Gültigkeit der Konfiguration
• Eine Teilkonfiguration wird gültig genannt, wenn mindestens eine zufriedenstellende Teilmatrix existiert, und eine aus mehreren Teilkonfigurationen zusammengesetzte Konfiguration ist gültig, wenn alle ihre Teilkonfigurationen gültig sind.
• Dementsprechend wird die Gültigkeit einer Konfiguration rekursiv aus der Gültigkeit der Teilkonfigurationen für die äußerste linke 1- und äußerste linke 0-Zeile abgeleitet: V{dw_i k_i bv_i} := V{dw1_i {1} k1_i bvl_i} /\ V{dw0_i {0} k0_i bv0_i pat0_i}, wobei:
• dw1_i := Cls({dw_i, k_i, bv_i}, rw-1), d.h. die Summe der äußersten linken Spalte (Index rw-1);
• dw0_i := dwi - dwl_i ; k1_i := k_i -1; k0_i:- k_i pat1_i := {1}, pat0_i, := {0} ist.
• Die Ausgleichsvektoren bv1_i und bv0_i werden durch die Mehrfach-Ausgleichsprozedur cfgdbvs erzeugt, die gültige Teilkonfigurationen aus gegebenen Listen von {dw_i, k_i}-Paaren und einem globalen Ausgleichsvektor berechnet, der in diesem Spezialfall dem ursprünglichen Ausgleichsvektor ohne sein äußerstes linkes Element entspricht, so dass man Folgendes erhält: cfgdbvs {{dw1_i k1_i} {dw0_i k0_i} } bv₁(rw-2..0) = {{dw1_i k1_i bv1_i} {dw0_i k0_i bv0_i} }
• Die Gültigkeit der Konfiguration {3, 3, {0 0 0 0 1}} folgt aus der Gültigkeit der 1-Teilkonfiguration, die zwei Zeilen mit {2,2,{0 0 0 0}} aufweist, und einer 0-Teilkonfiguration, die 1 Zeile {1 3 {0 0 0 1}} aufweist.
• Die Vorteile der vorliegenden Offenbarung sind zahlreich. Die zusammengefassten Prozeduren erzeugen Paritätsprüfmatrizen mit optionaler Invertierungsfähigkeit für beliebige Datenwort- und Codebreiten.
• Gemäß verschiedenen Optimierungskriterien, wie etwa XOR-Gatterzählwert, XOR-Baumtiefe, Codebreite, Mehrfachbitdetektion, werden beweisbar optimale Lösungen erzeugt. Dies ist garantiert, indem man von einer Minimallösung ausgeht, die anfänglich nicht alle Anforderungen erfüllt, und die Matrixkonfiguration mit lediglich der Mindestanzahl von zum Erhalten einer alle Nebenbedingungen erfüllenden Lösung benötigten Schritten allmählich transformiert.
• Das Konzept der Matrixkonfigurationen und priorisierten Validitätsprüfungen erlaubt das Ausführen von sehr kurzen und schnellen Transformationen mit Rückverfolgung, bevor die letztendliche explizite Matrixlösung erzeugt wird.
• Nach Auswahl von Parametern (nur wenn die Vorgabeeinstellungen nicht verwendet werden) ist keine menschliche Interaktion erforderlich, die gesamte Erzeugung geschieht automatisch für eine beliebige Menge von Parametern, die direkt aus Speicher- oder Registergrößen ableitbar ist.
• Statt einer Menge von vielen verschiedenen Ansätzen für verschiedene Anforderungen werden gleichförmige umfassende generische Funktionen und Codierer- und Decodiererkomponenten bereitgestellt.
• Die rekursiven Erzeugungsalgorithmen werden kurz gehalten, indem Zwischenaufgaben auf bereits durch Grundfunktionen abgedeckte Teilaufgaben reduziert werden. Zum Beispiel wird die Funktion des Prüfens der Gültigkeit von Teilkonfigurationen ohne Nebenbedingungen rekursiv angewandt, wenn eine Teilkonfiguration in eine Teil-Teilkonfiguration mit vorderer durchweg-len-Spalte und eine Teilkonfiguration mit vorderer durchweg-0en-Spalte aufgeteilt wird.
• Für diesen Zweck wurde eine allgemeinere Funktion konzipiert, die (Un-)Ausgleichsvektoren einer beliebigen Anzahl von Teilkonfigurationen berechnet, um einen globalen Ausgleichsvektor zu erfüllen.
• Modulentwicklern, die lediglich verschiedene generische Parameter für die enthaltenen vordefinierten RTL-Komponenten auswählen müssen, um die erzeugten Fehlerbehandlungsschaltkreise gemäß verschiedenen Kriterien zu optimieren, die auf der Basis von Flächen- und statischen Timinganalysen auf Modulebene zu beurteilen sind, sind verschiedene Optionen direkt zugänglich. Wenn ein Modul mit hoher Frequenz laufen gelassen wird, kann der Modulentwickler zum Beispiel die maximale XOR-Tiefe auf eine Grenze konfigurieren, die sicherstellt, dass kombinatorische Pfade die maximale Verzögerung, die in einem Taktzyklus immer noch verarbeitbar ist, nicht überschreiten. Wenn Fläche ein Problem ist, ist die Matrix mit der kleinsten Gesamtzahl von Einsen die beste Option. Sicherheitsanalysen können sehr gut zu neuen Anforderungen führen, denen durch entsprechende Umkonfigurationen nachgekommen werden kann, die keine zusätzliche Bemühung außer nur der Auswahl verschiedener Parametermengen erfordern.
• Es folgt eine ausführlichere Betrachtung der Erzeugung von Paritätsmatrizen für SECDED-Schutz. Eine Paritätsmatrix wird erst erzeugt, nachdem eine Konfiguration mit allen gewünschten Eigenschaften bestimmt wurde. Die folgenden Konstruktionsschritte werden ausgeführt, um eine invertierbare Matrix für eine Datenbreite von 128 und eine ECC-Breite von 9 zu erzeugen.
• Schritt a)
• Die Konstruktion einer Konfiguration beginnt mit einer schnellen Prüfung, um zu bestimmen, ob eine anfängliche Vorgabe-(Hsiao-)Konfiguration mit ungeraden Zeilengewichten ausgehend von 3 überhaupt eine invertierbare Lösung aufweisen kann: es gibt keine Lösung, falls $$\left(\left({\displaystyle \sum _{\text{i}}^{2*\text{i}+\text{3}\le \text{rw}}{\text{dw}}_{\text{i}}}{\text{*k}}_{\text{i}}\right)\text{/rw}\right)\text{/\%2}=\text{1}$$

  

  und $$\left(\left({\displaystyle \sum _{\text{i}}^{2*\text{i}+\text{3}\le \text{rw}}{\text{dw}}_{\text{i}}{\text{*k}}_{\text{i}}}\right)\text{/rw}\right)\text{\%2rw})\text{\%}2=\text{1}$$

  

  oder $$\left(\left({\displaystyle \sum _{\text{i}}^{2*\text{i}+\text{3}\le \text{rw}}{\text{dw}}_{\text{i}}{\text{*k}}_{\text{i}}}\right)\text{/rw}\right)\text{\%2}=0$$

  

  und $$rw-\left({\displaystyle \sum _{\text{i}}^{2*\text{i}+\text{3}\le \text{rw}}{\text{dw}}_{\text{i}}}{\text{*k}}_{\text{i}}\right)\text{\%rw})\text{\%2rw})\text{\%}2=\text{1}$$

  

  mit k_i := 2*i+3, wobei k_i ≤ rw; $${\text{dw}}_{\text{i}}:=\text{max}\left(\mathrm{0,}\text{min}\left(\begin{array}{c}\text{rw}\\ {\text{k}}_{\text{i}}\end{array}\right),\text{dw}-{\displaystyle \sum _{\text{j}=\text{0}}^{\text{j}<\text{i}}{\text{dw}}_{\text{j}}}\right),$$

  

  
  und wobei x%n hier die Modulo-n-Funktion, x/n ganzzahlige Division durch n bedeutet.
• Zum Beispiel gibt es keine Lösung für 128 Datenbit mit einer ECC-Breite von 9: $$\begin{array}{l}\text{Cfg0\_128\_9:}=\left\{\left\{\left(\begin{array}{c}9\\ 3\end{array}\right),\mathrm{3,}9\right\}\left\{128-\left(\begin{array}{c}9\\ 3\end{array}\right),\mathrm{5,}9\right\}\right\}=\\ \left\{\{843\left\{0\text{0 0 0 0 0 0 0 0}\right\}:\{28\text{28 28 28 28 28 28}\right\}\\ 2828\}\\ \{445\left\{0\text{0 0 0 1 1 1 1 1}\right\}:\{25\text{25 25 25 24 24 24 24}\\ 24\}\},\text{mit den folgenden Spaltensummen:}\\ \left\{\text{53 53 53 53 52 52 52 52 52}\right\}.\end{array}$$

  
• Da 5 von diesen gerade sind, kann diese nichtinvertierbare nicht in eine invertierbare Lösung transformiert werden, weil für jede 3-Zeile, die durch eine 5-Zeile ersetzt wird, 2 Einsen hinzugefügt werden, so dass die Anzahl gerader Spaltensummen immer noch ungerade ist. Die anfängliche Lösung kann höchstens in eine Lösung mit 8 ungeraden, aber nicht mit 9 ungeraden Spaltensummen, transformiert werden, z.B. mit der Konfiguration
  {{84 3 {0 0 0 0 0 0 0 0 0 } : {28 28 28 28 28 28 28 28 28}
  {44 5 {0 0 0 0 0 0 1 2 2}:{25 25 25 25 25 25 24 23 23}}, die die folgenden Spaltensummen produziert: {53 53 53 53 53 53 52 51 51}.
• Im Gegensatz dazu weist für eine Datenwortlänge 9 von 127 die Vorgabekonfiguration $\text{Cfg0\_127\_9:}=\left\{\left\{\left(\begin{array}{c}9\\ 3\end{array}\right),\mathrm{3,}9\right\}\left\{127-\left(\begin{array}{c}9\\ 3\end{array}\right),\mathrm{5,}9\right\}\right\}=\{\left\{\mathrm{84,3,}\left\{\begin{array}{ccccccccc}0& 0& 0& 0& 0& 0& 0& 0& 0\end{array}\right\}\left\{\mathrm{43,}\text{5}\text{,}\left\{\begin{array}{ccccccccc}0& 0& 0& 0& 0& 0& 0& 0& 1\end{array}\right\}\right\}\right\}$

  

  eine gerade Anzahl gerader Spaltensummen auf: {52 52 52 52 52 52 52 52 51} und kann somit durch Un-Ausgleich der zweiten Teilkonfiguration mit dem Un-Ausgleichsvektor {0 0 0 0 2 2 2 2 2} invertierbar gemacht werden, was zu Cfg1_127_9:= {{84,3, {0 0 0 0 0 0 0 0 0} {43, 5, {0 0 0 0 2 2 2 2 2}}} mit den Spaltensummen {53 53 53 53 51 51 51 51 51} führt. Durch Un-Ausgleich wird im Allgemeinen die Gesamtzahl von 1en in der Matrix nicht modifiziert. Als Alternative könnte auch eine invertierbare Konfiguration erhalten worden sein, indem 5 3-Zeilen mit 5 5-Zeilen ersetzt werden, um daher die Gesamtzahl von Einsen um 5*2 = 10 zu vergrößern: Cfg2_127_9:= {{79 3 {0 0 0 1 1 1 1 1 1} {48 5 {0 0 0 0 0 0 1 1 1}}}, was den Spaltensummen {54 54 54 53 53 53 52 52 52} entspricht. Obwohl diese Konfiguration noch nicht invertierbar ist, ist hier kein Un-Ausgleich erforderlich, sondern gegenseitiger Neu-Ausgleich ausreichend:
• Cfg2_127_9:= {{79 3 {0 0 0 1 1 1 1 1 1}:{27 27 27 26 26 26 26 26 26} {48 5 {1 1 1 0 0 0 0 0 0} : {26 26 26 27 27 27 27 27 27}}, um gleiche Spaltensummen von jeweils 53 zu erzielen.
• Die Auswertung der Konfiguration Cfgo_128_9 zeigt, dass für Daten mit 128 geschützt durch ECC-Bit keine symmetrische Lösung mit ungeraden Zeilengewichten existiert.
• Schritt b)
• Aus diesem Grund gibt es einen anderen Algorithmus, der Zeilen mit geraden Gewichten hinzufügt. Um die Hammingdistanzen der Matrixzeilen auf dem Minimum zu halten, das für dieselbe Fehlerkorrektur- und -detektionsfähigkeit wie bei Lösungen mit ungeraden Gewichten erforderlich ist, werden jedoch zusätzliche Nebenbedingungen auferlegt. Ohne die Universalität des Ansatzes zu beeinflussen, aber zum leichteren Verständnis, werden Nebenbedingungen an den drei äußersten linken Matrixspalten exemplifiziert.
• Zeilen mit einer ungeraden Anzahl von Zeilengewichten >=3 erhalten Nebenbedingungen mit den Kombinationen {0 0 0}, {0 0 1}, {0 1 0}, {1 0 0} in ihren äußersten linken Positionen. Zeilen mit einer geraden Anzahl von Zeilengewichten >= 4 weisen an ihren äußersten linken Positionen {1 1 1} auf. Diese Konstruktion garantiert, dass alle Zeilen mit Hamminggewicht k eine Hammingdistanz von mindestens 2 von allen Zeilen mit Hamminggewicht k-1 und von allen Zeilen mit Gewicht k+1 aufweisen, was für 2-Bit-Fehlerdetektion/1-Bit-Fehlerkorrektur ausreichend ist. Eine Hammingdistanz >1 zwischen Zeilen mit k und k+2 Einsen ist auch für gerades k garantiert, da die drei äußersten rechten Zeilenpositionen k-3 und k-1 Einsen aufweisen. Für ungerades k hätten im ungünstigsten Fall k-Zeilen k Einsen an den äußersten rechten ew-3-Positionen und k+2-1 = k+1 Einsen an den äußersten rechten ew-3-Positionen. Obwohl rechte Teilzeilen nur eine Hammingdistanz 1 aufweisen würden, wird dies durch den Umstand kompensiert, dass dieses Szenario nur entsteht, wenn k-Zeilen das Nebenbedingungsmuster {0 0 0} aufweisen und k+2-Zeilen die Nebenbedingungsmuster {0 0 1} , {0 1 0} oder {1 0 0}. In diesem Fall vergrößern die linken Teilzeilen somit die Hammingdistanz auf das erforderliche Minimum von 2.
• Schritt c) Der Algorithmus zur Erzeugung gerader Lösungen führt die folgenden Schritte auf:
• Schritt c1) Eine anfängliche Minimallösung wird mit Nebenbedingungs-Gewichtspartitionen mit ungeradem und geradem k erzeugt:
  • Ausgehend von 2k+1=3 werden die ungeraden Teilkonfigurationen mit Nebenbedingungen
  $$\{{\text{dw}}_{2\text{k}+\text{1}\text{,}\left\{001\right\}}\left\{0\text{0 1}\right\}2\text{k}+{\text{1 bv}}_{2\text{k}+\text{1}\text{,}\left\{001\right\}}\},$$
  
  $$\{{\text{dw}}_{2\text{k}+\text{1}\text{,}\left\{0\text{1 0}\right\}}\left\{0\text{1 0}\right\}2\text{k}+{\text{1 bv}}_{2\text{k}+\text{1}\text{,}\left\{0\text{1 0}\right\}}\},$$
  
  $$\{{\text{dw}}_{2\text{k}+\text{1}\text{,}\left\{\text{1}0\text{0}\right\}}\left\{\text{1 0 0}\right\}2\text{k}+{\text{1 bv}}_{2\text{k}+\text{1}\text{,}\left\{\text{1}0\text{0}\right\}}\},$$
  
  $$\{{\text{dw}}_{2\text{k}+\text{1}\text{,}\left\{00\text{0}\right\}}\left\{0\text{0 0}\right\}2\text{k}+{\text{1 bv}}_{2\text{k}+\text{1}\text{,}\left\{00\text{0}\right\}}\},$$
  
erzeugt, mit ${\text{dw}}_{2\text{k}+\text{1}\left\{00\text{0}\right\}}<=\left(\begin{array}{c}\text{ew}-\text{3}\\ 2\text{k}+\text{1}\end{array}\right),{\text{dw}}_{2\text{k}+\text{1}\left\{001\right\}}<=\left(\begin{array}{c}\text{ew}-\text{3}\\ 2\text{k}\end{array}\right)$

und dW_{2k+1{0 1 0}} bzw. dw_{2k+1{1 0 0}.}
• Ausgehend von 2k+2-4 werden die Teilkonfigurationen mit Nebenbedingungen $$\begin{array}{l}\left\{{\text{dw}}_{2\text{k}+\mathrm{2,}\left\{\text{1 1 1}\right\}}\left\{1\text{1 1}\right\}\text{2k}+{\text{2 bv}}_{2\text{k}+\text{2}\text{,}\left\{\text{1 1}1\right\}}\right\}{\text{mit dw}}_{2\text{k}+\text{2}\left\{1\text{1 1}\right\}}\hfill \\ <=\left(\begin{array}{c}\text{ew}-\text{3}\\ 2\text{k}-\text{1}\end{array}\right)\hfill \end{array}$$

  

  erzeugt, bis die Summe aller dw_k gleich der erforderlichen Gesamtdatenbreite dw ist.
• Diese Konstruktion ergibt eine Konfiguration für eine Matrix mit minimaler Gesamtzahl von Einsen, die normalerweise noch nicht symmetrisch ist.
• Schritt c2) Die anfängliche Konfiguration wird, falls notwendig, dergestalt transformiert, dass sie mindestens eine gerade Anzahl von geraden Spaltensummen, im besten Fall bereits 0, aufweist. Obwohl eine solche Transformation mit einer reinen Ungerade-k-Konfiguration unmöglich ist, wird der erforderliche Effekt hier durch Inkrementieren einiger dw_ki und Dekrementieren einiger dw_kj erzielt, wobei ki ungerade und kj gerade ist, oder umgekehrt. Zusätzlich werden die Austauschpaare dergestalt ausgewählt, dass die Summen aller Spalten mit Nebenbedingungen, in der vorliegenden Situation die drei äußersten linken Einsen, alle ungerade sind. Eine spezifische Subroutine wählt mögliche zu inkrementierende Teilkonfigurationen und andere zu dekrementierende aus, so dass die Summe von Inkrementen genau gleich den Summen von Dekrementen ist, um die insgesamte erforderliche Summe dw aller Datenbreiten aller Teilkonfigurationen zu bewahren.
• Schritt c3) Die sich aus 2. ergebende linkssymmetrische Konfiguration wird nun durch (Un)-Ausgleich ungesättigter Teilkonfigurationen gegeneinander in eine voll symmetrische Konfiguration transformiert. Hierzu wird die bereits für die rein ungeraden Teilkonfigurationen verwendete Prozedur wiederverwendet.
• Wenn keine solche totalsymmetrische Lösung existiert, werden entsprechende Paare von dwk und dwk+n*2 mit demselben Nebenbedingungsmuster in-/dekrementiert. Hierdurch wird erreicht, dass die Symmetrie der Spalten mit Nebenbedingungen bewahrt wird. Die resultierende Konfiguration ist dann voll symmetrisch.
• Schritt c4) Um die maximalen Spaltensummen zu minimieren, wird eine optionale zusätzliche Transformation durchgeführt. Sie verringert die Spaltensummen des rechten Teils durch Vergrößern der Spaltensummen des linken Teils dergestalt, dass die Gesamtsymmetrie bewahrt wird. Dieser Effekt wird erreicht, indem man eine gerade Anzahl von {0 0 0}-, {0 0 1}-, {0 1 0}- oder {1 0 0}-Zeilen mit derselben Anzahl von {1 1 1}-Zeilen mit nächsthöherem Zeilengewicht ersetzt. Durch jeden Austausch 2*{0 0 0},2k+1 -> 2*{1 1 1},2k+2 wird die Summe aller linken Spalten insgesamt um 6 inkrementiert und die Summe aller rechten Spalten insgesamt um 4 dekrementiert.
• Durch jeden Austausch 2*{0 0 1 } , 2 k+1 -> 2*{1 1 1},2k+2 wird die Summe aller linken Spalten insgesamt um 4 inkrementiert und die Summe aller rechten Spalten insgesamt um 2 dekrementiert.
• Indem nur gleiche ungerade gewichtete Zeilen 2*{0 0 0},2k+1 -> 2*{0 0 1},2k+1, 2*{0 1 0},2k+1 oder 2*{1 0 0},2k+1 ausgetauscht werden, wird die Summe aller linken Spalten insgesamt um 2 inkrementiert und die Summe aller rechten Spalten insgesamt um 2 dekrementiert.
• Schritt d) Die folgende Tabelle zeigt die maximalen Datenwortbreiten, die durch minimale ECC-Breiten (ew) schützbar sind. Tabelle 1: Datenbreitenbereiche für gerade/ungerade symmetrische Lösungen

  ew	dwmax	dwevmax	dwev0	dwev1
  5	11	5	-	-
  6	26	14	-	-
  -7	57	33	28	28
  8	120	72	59	67
  9	247	151	122	146
  10	502	310	249	305
  11	1013	629	504	624
  12	2036	1268	1015	1263
  13	4083	2547	2038	2542
  14	8178	5106	4085	5101
  15	16369	10225	8180	10220
  16	32752	20464	16371	20459
  17	65519	40943	32754	40938
  18	131054	81902	65521	81897
  19	262125	163821	131056	163814
  20	524268	327660	262127	327655

• Für Datenbreiten dw im Bereich dwmax(ew-1) <= dw <= dwevmax(ew) reicht theoretisch eine ecc-Breite ew selbst für eine gerade invertierbare Lösung aus, wenn keine ungerade invertierbare Lösung existiert.
• Aufgrund anderer Nebenbedingungen für Un-Ausgleich kann jedoch in einigen Fällen keine gerade invertierbare Lösung existieren. Umgekehrt existiert für Datenbreiten im Bereich dwevmax(ew) < dw <= dwmax(ew) keine gerade invertierbare Lösung mit ECC mit ew, wenn keine invertierbare ungerade Lösung existiert. In diesem Fall muss ew um 1 inkrementiert werden, was immer eine invertierbare Lösung ermöglicht.
• In der Spalte dwev0, wird das tatsächliche Minimum-dw gegeben, für das eine gerade Lösung verwendet wird, wenn keine ungerade (Hamming-Gewichte) Lösung existiert. In der Spalte dwev1 ist das tatsächliche Maximum-dw gezeigt, d.h. für alle größeren dw, für die keine ungerade Lösung existiert, muss ew unausweichlich um 1 inkrementiert werden.

Claims (20)

1. Schaltung, umfassend: einen eingebetteten Paritätsmatrixgenerator, ausgelegt zum dynamischen Erzeugen einer Paritätsmatrix abhängig von der Datenbreite eines Datenworts aus einer Mehrzahl von Datenworten unterschiedlicher Datenbreite; einen Codierer, ausgelegt zum Hinzufügen eines Redundanzworts zu dem Datenwort auf der Basis der dynamisch erzeugten Paritätsmatrix; eine mit dem Codierer gekoppelte Teilschaltung, ausgelegt zum Empfangen des Datenworts und des Redundanzworts von dem Codierer; und einen mit der Teilschaltung gekoppelten Decodierer, ausgelegt zum Empfangen des Datenworts und des Redundanzworts von der Teilschaltung und zum Detektieren etwaiger Fehler in dem Datenwort auf der Basis der Paritätsmatrix.
2. Schaltung nach Anspruch 1, wobei die Teilschaltung aus einer Gruppe von Teilschaltungen bestehend aus einem Speicher, einem Register, einem Bus und einer Schnittstelle, ausgewählt ist.
3. Schaltung nach Anspruch 1 oder 2, wobei der Paritätsmatrixgenerator sowohl in dem Codierer als auch dem Decodierer eingebettet ist.
4. Schaltung nach einem der Ansprüche 1 bis 3, wobei der Decodierer ferner ausgelegt ist zum Korrigieren des Datenworts auf der Basis der Paritätsmatrix.
5. Schaltung nach einem der Ansprüche 1 bis 4, wobei der Paritätsmatrixgenerator ferner ausgelegt ist zum Erzeugen der Paritätsmatrix, um es dem Decodierer zu ermöglichen, etwaige Einzelbitfehler in dem Datenwort zu korrigieren, etwaige Doppelbitfehler in dem in dem Datenwort zu detektieren und bis zu drei Bitfehler zu detektieren, aber nicht zu korrigieren.
6. Schaltung nach einem der Ansprüche 1 bis 5, wobei der Paritätsmatrixgenerator ferner ausgelegt ist zum Erzeugen der Paritätsmatrix mit einer minimalen Anzahl von Modifizierbit, wodurch die Breite des Datenworts plus Redundanzwort gleich einer Paritätsmatrix sein kann, die ausgeglichen und asymmetrisch ist.
7. Schaltung nach einem der Ansprüche 1 bis 6, wobei der Paritätsmatrixgenerator ferner ausgelegt ist zum Erzeugen der Paritätsmatrix, so dass sie Spaltensummen umfasst, die gemäß einem Ausgleichsvektor ausgeglichen sind.
8. Schaltung nach einem der Ansprüche 1 bis 7, wobei der Paritätsmatrixgenerator ferner ausgelegt ist zum Durchführen einer schnellen Prüfung auf Durchführbarkeit einer Ausgleichs- oder Un-Ausgleichsspezifikation für Spaltensummen der Paritätsmatrix.
9. Schaltung nach einem der Ansprüche 1 bis 8, wobei der Paritätsmatrixgenerator ferner ausgelegt ist zum Erzeugen der Paritätsmatrix, so dass sie Spaltensummen umfasst, die gemäß einem Ausgleichsvektor und Un-Ausgleich von Spaltensummen auf Differenzen von mehr als eins ausgeglichen sind.
10. Schaltung nach einem der Ansprüche 1 bis 9, wobei der Paritätsmatrixgenerator ferner ausgelegt ist zum automatischen Berechnen einer minimalen erforderlichen Breite des Redundanzworts.
11. Schaltung nach einem der Ansprüche 1 bis 10, wobei der Paritätsmatrixgenerator ferner ausgelegt ist zum Erzeugen der Paritätsmatrix, so dass sie symmetrisch ist.
12. Schaltung nach Anspruch 11, wobei der Paritätsmatrixgenerator ferner ausgelegt ist zum Erzeugen der Paritätsmatrix, so dass sie symmetrisch mit Teilmatrizen mit Nebenbedingungen mit ungeraden und geraden Zeilen-Hamminggewichten ist und eine selbe Codewortbreite wie die Paritätsmatrix, wenn sie in asymmetrischer Form ist, aufweist.
13. Schaltung nach Anspruch 11 oder 12, wobei der Paritätsmatrixgenerator ferner ausgelegt ist zum Erzeugen der Paritätsmatrix, so dass sie symmetrisch ist, durch Hinzufügen einer minimalen Anzahl von Einsen zu einer asymmetrischen Paritätsmatrix, während die Datenbreite bewahrt wird.
14. Schaltung nach Anspruch 13, wobei der Paritätsmatrixgenerator ferner ausgelegt ist zum Ausgleichen der Paritätsmatrix durch Hinzufügen von Einsen zu der Paritätsmatrix, bis die Paritätsmatrix eine XOR-Baumtiefe aufweist, die kleiner als eine vorbestimmte Grenze ist.
15. Schaltung nach Anspruch 14, wobei der Paritätsmatrixgenerator ferner ausgelegt ist zum Vergrößern einer Breite des Redundanzworts nur um so viel, dass XOR-Baumtiefen unter einem vorbestimmten Wert liegen.
16. Schaltung nach einem der Ansprüche 1 bis 15, wobei der Paritätsmatrixgenerator ferner ausgelegt ist zum Erzeugen der Paritätsmatrix mit einer vordefinierten Menge von Zeilen-Hamminggewichten.
17. Verfahren, umfassend: dynamisches Erzeugen einer Paritätsmatrix für ein Datenwort abhängig von der Datenbreite des Datenworts einer Mehrzahl von Datenworten unterschiedlicher Datenbreite durch einen eingebetteten Paritätsmatrixgenerator; Hinzufügen eines Redundanzworts zu dem Datenwort durch einen Codierer auf der Basis der dynamisch erzeugten Paritätsmatrix; Empfangen des Datenworts und des Redundanzworts von dem Codierer durch eine mit dem Codierer gekoppelte Teilschaltung; und Empfangen des Datenworts und des Redundanzworts von der Teilschaltung durch einen mit der Teilschaltung gekoppelten Decodierer; und Detektieren etwaiger Fehler in dem Datenwort durch den Decodierer auf der Basis der dynamisch erzeugten Paritätsmatrix.
18. Verfahren nach Anspruch 17, ferner umfassend: Erzeugen von zwei Teilmatrizen mit Vordere-Eins-Zeilen und Vordere-Null-Zeilen durch den Paritätsmatrixgenerator; und rekursives Ausgleichen der Paritätsmatrix zu einer ausgeglichenen Paritätsmatrix durch den Paritätsmatrixgenerator.
19. Verfahren nach Anspruch 17, wobei der Schritt des dynamischen Erzeugens der Paritätsmatrix Folgendes umfasst: Rekursives Erzeugen von Teilkonfigurationen mit Nebenbedingungen mit individuellen Teildatenbreiten, Zeilen-Hamminggewichten, Ausgleichsvektoren und Nebenbedingungsmustern.
20. Verfahren nach Anspruch 17, wobei der Schritt des dynamischen Erzeugens der Paritätsmatrix Folgendes umfasst: Neupartitionieren von Teilmatrizen mit verschiedenen Zeilen-Hamminggewichten und/oder Nebenbedingungsmustern; und Mehrfachausgleichen der Teilmatrizen, wobei eine anfängliche asymmetrische Paritätsmatrix in eine symmetrische Paritätsmatrix transformiert wird.

Images