Field of the invention

The invention relates to the field of error correction codes (ECC) for optical storage systems. It may also be applied to magnetic recording storage devices, Redundant Array of Independent Disk (RAID) systems, and transmission systems.

Background of the Invention

WO 99/67913 purports to disclose a forward error correction decoder which receives a received word comprising a plurality of characters. The decoder also receives a reliability value for each character. The decoder calculates a syndrome for each member of the set of possible received words by transforming each member with the parity check matrix. Members of the set having the same syndrome are grouped together into cosets. A weight based on the reliability value is then assigned to each member in each coset. The weight is defined to be the number of low-reliability, non-zero characters in each member of the set of possible received words. For each coset, the member that has the lowest weight is selected as a coset leader. A syndrome is computed for the soft codeword by transforming it with the parity check matrix. The coset leader with the same syndrome as the received word is subtracted from the received word resulting in a codeword estimate. This can be seen to have the drawback that using reliability values, as well as calculating syndromes for sets of potential codewords constitutes a considerable processing burden.

An improved error correction decoder is desirable.

Summary of the invention

An approach of efficiently encodable quasi-cyclic error correcting codes will be named "zArray Codes" in the following. zArray codes are based on the known "array codes" as published in R. J. G. Smith, "Easily Decodable Efficient Self-Orthogonal Block Codes", Electronics Letters, VoI 13 No. 7, ppl73-174, 1977. zArray codes constitute, in a systematic way, ECC codes of type Low Density Parity Check or LDPC, which are, on one hand, efficiently encodable even at large codeword length, and, on the other hand, have a good performance when decoded using message passing algorithms.

Advantages of zArray codes over Array codes are:

^■ By being column regular, zArray codes enable for a better message passing decoding performance than the column- iregular Array codes.

^■ zArray codes maintain an encoding time that grows linearly with codeword length.

^■ zArray codes allow parity bit generation, i.e. encoding, to be split into an adjustable number of independent sequential tasks, enabling parallelization of the encoding process .

A parity check matrix of a zArray codes is defined and generated by the following steps: A first intermediate matrix Hl is generated so as to comprise two rows of square, identically sized, binary sub-matrices, where the first row comprises p identity matrices I of size p»p, and the second row comprises p increasing powers σ" of a cyclic shift matrix σ of size p*p, wherein u=0, ...,p-l. From the first intermediate matrix Hl, a second intermediate matrix H2 is generated by removing m equidistant columns from each of the sub-matrices of the first intermediate matrix Hl at column indices (r+i • (2r+l) +q) modulo p, wherein i,m,p,q are integers, wherein i=0, ...,m-l, wherein m,p,q,r are predefined such that p=m+2mr, and wherein column indices within the sub-matrices start with 0. From the second intermediate matrix H2, a third intermediate matrix H3 is generated by deleting those matrix rows from the first row of sub-matrices of the second intermediate matrix H2 which, due to the removing step, contain only zeros. As a consequence of this deleting, the first row of the third intermediate matrix H3 comprises p small identity matrices Is of size (p-m) • (p-m) . From the third intermediate matrix H3, the parity check matrix H of the zArray code is generated by inserting or appending m-1 binary column vectors of height 2p-m having weight 2, wherein the column vectors have "1" elements in the middle rows of those row ranges of the sub-matrices [σV] that have row weight 2. The latter mentioned binary column vectors have together been named the "z" matrix, hence the name of zArray codes. zArray Codes are designed for efficient encodability and good message passing decoding performance. However, message passing decoding is justified only when errors are reflected by low bit reliabilites for the received codeword. This might not be the case for burst errors, or for erasures representing burst errors at known positions, or for shot noise events.

In the following, we denote as a "symbol" of a zArray codeword the tuple of those p-m bits that correspond to those columns of the parity check matrix H that contain the columns of one of the cyclic shift submatrices σ" after column removal. Further, we denote as "symbol x" or "the x-th symbol" that one of the tuples, which corresponds to the columns of σ ^{x l} . Note that in this nomenclature, because of their number, those m-1 bits of a codeword that correspond to the z matrix part of the parity check matrix H, are in general not considered a symbol.

In case of a single or double symbol erasure corrupting multiple bits of one or two symbols, message passing decoding will likely fail to find the correct codeword. Algebraic decoding is applied successfully instead, since zArray codes retain most of the structure inherited from Smith's code. This will likely allow correction of single and double symbol erasure (s) . A similar double erasure correcting code has already been invented by M. Blaum with his class of Array Codes in "A CODING TECHNIQUE FOR RECOVERY AGAINST DOUBLE DISK FAILURE IN DISK ARRAYS" in 1992. See US Pat. No. 5,271,012 or EP 0 519 669, respectively. These codes have minimum distance 3 and can therefore correct any double symbol erasures, which Blaum calls phased erasures. The problem with these codes is that erasure decoding cannot be parallelized due to their cyclic dependencies. One approach not having this restriction is Blaum' s "EVENODD: AN EFFICIENT SCHEME FOR TOLERATING DOUBLE DISK FAILURES IN RAID ARCHITECTURES", published in IEEE Trans Com-44, pp. 192-202, see also US Pat. No. 5,579,475. The latter approaches can be seen to have the disadvantage that EVENODD codes have at least some weight 1 columns in their parity check matrix, which is known to weaken the performance of message passing LDPC decoding.

Blaum also presented, in US 5,351,246, a generalization of the double erasure correcting codes to multiple erasure correcting codes.

The present invention solves the problem of correcting one or two symbol erasures occurring within a codeword of a subclass of zArray Codes through algebraic decoding.

The invention has realized that a processing step from the zArray encoding approach, can actually be used - with minor modifications - to algebraically de_code and correct codewords where up to two "symbols" are known to be defect. This form of decoding can actually be applied on any kind of LDPC encoded bits. But specifically, if the mentioned zArray codes have been used for ECC encoding, and the codeword bits are partitioned into symbols as described above, the zArray code properties enable that the processing is parallelizable into a number of parallel, independent sequences of bit operations, hence allowing high throughput.

The mentioned encoding processing step for zArray codes is based on the known requirement that v-H ^T = 0, i.e. that the codeword v to be generated, when GF2-multiplied with the transpose of the parity check matrix H, must result in a zero vector. The codeword v to be determined is split into 3 parts, one of which is the given information word u. This is based on the notion that zArray codes are systematic codes, hence a zArray coded code word v consists of the information word u and some appended parity bits. The 2 parts of the code word v that are not equal to the information word u, are then derived in a recursive, but parallelizable way.

More specifically, zArray encoding an information word u into a code word v consisting of a first parity part vparl, a second parity part vpar2, and the information word u, comprises the steps of: obtaining a first interim vector w by GF2-multiplying the information word u with an information matrix Hinf; determining the second parity part vpar2 such that its GF2- product with a second parity matrix Hpar2 equals the first interim vector w except at the (p-m + ( (i ^• (2r+l) +q) mod p) ) -th vector elements; determining a second interim vector w2 as the GF2-addition of the GF2-product of the second parity part vpar2 with the second parity matrix Hpar2 and the first interim vector w; and determining the first parity part vparl such that its GF2-product with a first parity matrix Hparl equals the second interim vector w2 ; wherein the information matrix Hinf comprises those (p-2) ^• (p-m) columns of the parity check matrix H that are associated to the information word u, the first parity matrix Hparl comprises the m-1 inserted or appended binary column vectors, and the second parity matrix Hpar2 comprises the remaining columns of the parity check matrix H. zArray Codes were derived from a class of Smith' s array codes having minimum distance 3. zArray codes have a design parameter m. When m is chosen as m>l , the minimum distance of zArray codewords is d _min =2, but the distance between most codewords is d≥3. This means that most combinations of two symbol erasures will be correctable, but not all of them.

The invention also addresses

• how to set the zArray Code parameter "r" in order to minimize the probability of two uncorrectable erasures. The resulting restriction defines a new subclass of zArray Codes;

• how to identify events where a double symbol erasure is uncorrectable due to insufficient code distance; and • how to detect decoding errors due to erroneous erasure information .

The latter can not be achieved with the teaching of US Pat. No. 5,271, 012.

From an implementation point of view the invention also teaches how to parallelize the decoding of two symbol erasures by exploiting the zArray Code structure.

Drawings Exemplary embodiments of the invention are illustrated in the drawings and are explained in more detail in the following description .

In the figures: Fig. 1 shows the parity check matrix Hmz of a quasi-cyclic

LDPC Code with m=3 and r=l, p=9. Ones are represented by black squares. White and grey squares represent Zeros. Bar a) symbolically illustrates an uncorrectable erasure of symbols 6 & 9; bar b) symbolically illustrates an uncorrectable erasure of symbols 6 & 8.

Fig. 2 shows part of the parity check matrix Hmz of a quasi- cyclic LDPC Code with m=3 and r=l . Ones are represented by black squares. White and grey squares represent Zeros. Arrows denote the decoding schedule being done in 2m tasks. The diamonds on the left indicate rows involving vparl . The bar on top illustrates the position of the erasures. Fig. 3 shows part of the parity check matrix Hmz of a quasi- cyclic LDPC Code with m=3 and r=l . Ones are represented by black squares. White and grey squares represent Zeros. Arrows denote the decoding schedule being done in 2m tasks. The diamonds on the left indicate rows involving vparl . The bar on top illustrates the position of the erasures.

Fig. 4 shows a block diagram for a 2m parallel implementation of the double erasure decoder.

Detailed description of the invention

Handling double symbol erasure does not essentially differ from the idea of the first encoding stage of zArray codes for finding v _par2 . Nearly any other two symbols might be reconstructed (encoded) if v _par2 is known. For some combinations, no reconstruction schedule can be found due to d _min =2. The uncorrectable double erasure probability can be minimized though adjusting the design parameter r to certain values. This introduces a new subclass of zArray Codes through sacrificing design freedom.

Within this subclass, decoding (if at all possible) can be parallelized into 2m tasks, equivalent to the v _par2 encoding process. Alternatively only m task might be setup with decoding depth doubled. Any single symbol erasure is correctable because of d _min =2. Erroneous bit positions within the symbol can be easily determined through the upper (p-m) syndrome checks of H _mz . It is also shown how the double erasure correction process can be used to correct single symbol erasures as well.

A symbol of a zArray codeword with index x is defined to be a tuple comprising the p-m bits corresponding to the submatrices I" or σ ^{(x l)} ' respectively. Note that in this nomenclature, v _parl is not a symbol.

zArray codes can in many cases correct up to two symbol erasures by applying a strategy similar to the encoding process of v _par2 . Erasures denote errors where the symbol position is known but the precise error pattern is not.

A 2m or m task parallel schedule might be applied if two symbols of a codeword have been erased.

In some cases no decoding schedule might be found. Constraining the design parameter r will minimize the occurrence probability of these cases. It will be shown how to identify these events for this subclass of zArray Codes.

The case of one erasure decoding is trivial, but it will be shown how the double erasure decoding process can also be used to correct every single erasure and detect decoding errors in case of erroneous erasure information.

Defining a subclass of zArray Codes by setting design parameter r to maximize the correctable double erasure probability The correctable double erasure probability can be brought to a maximum for a given m if r satisfies the following constraint:

(1 + 2*r) is prime (I)

This choice defines a subclass of zArray codes. It was found through extensive computer search that zArray Codes with parameters r not satisfying (I) have a much lower double erasure correction probability.

Notice that for m>l neither p=m+2mr nor p-m are prime. This distinguishes zArray Code and its subclass from the traditional Array Codes by Smith and Blaum.

In the following, we will restrict ourselves to this subclass and assume that (I) holds. Then the number of uncorrectable double erasures is

With the number of possible double erasure combinations

the correctable erasure probability reads

P _cm =\-tln.

Identifying uncorrectable double symbol erasure

Fig. 1 shows the parity check matrix Hmz of a quasi-cyclic LDPC Code with m=3 and r=l, p=9. Ones are represented by black squares. White and grey squares represent Zeros. Bar a) on top of the matrix illustrates an uncorrectable erasure of symbol 6 and symbol 9; bar b) illustrates an uncorrectable erasure of symbol 6 and symbol 8.

In this, symbol indexing iSym is defined to start with iSym=l for the leftmost p-m bit tuple of v _par2 , proceeds to iSym=2 for the rightmost p-m bit tuple of v _par2 , then proceeds to iSym=3 for the leftmost p-m bit tuple of the information word u, and ends at iSym=p for the rightmost p-m bit tuple of the information word u.

A double symbol erasure is defined as a 2 element vector iSymEra denoting the indices of the erased symbols. It is additionally assumed here that iSymEra (1) < iSymEra (2) .

For a correctable double symbol erasure with r satisfying (I) the following condition must hold.

mod( (iSymEra (2) - iSymEra (1) ), 2r+l) > 0 (II)

That is, iSymEra (2) - iSymEra (1) is not a multiple of (2r+l) .

This condition is not satisfied whenever the submatrices σ ⁽ ' ^SynErα ₍ ⁱ⁾ - ⁱ⁾ , _and ^ ₁ ^Sy _n ^ErU(I) - ^I) , _have row-weight 0 within the same rows.

See Fig. 1 for two examples :

a) Within a codeword of a zArray Code with parameters m=3 and r=l symbols 6 & 9 have been erased. With iSymEra =[6,

9] condition (II) does not hold.

mod(9 - 6, 2*1+1) = 0

This double symbol erasure is uncorrectable. b) With iSymEra =[6, 8] condition (II) holds.

mod (8 - 6, 3) = 2

This double symbol erasure is correctable.

Parallel erasure decoding utilizing vparl

A double symbol erasure is given by iSymEra denoting the symbols being erased within the received word r. The task of erasure decoding then amounts to choosing the bits of symbols iSymEra (1) and iSymEra (2) in such a way that the parity check equation r'H^ _z = 0 is fulfilled, r' is then said to be the decoding result from r and is expected to equal the original codeword v in case of successful decoding.

With a given iSymEra denoting the known positions of the two erroneous symbols, the parity check matrix H _mz can be split into 5 parts:

H [H left H syml center sym2 H right

with

I"

^ left -

Z I' σ (ιSymEm(l)-2) t

I"

H syml _(ιSymEm(l)-l) i

I" i"

H ιSymErα(\) \ (ιSymEm(2)-2) t I"

H sym2 _(ιSymEra(2)-Y) t and

H right ιSymEra(2) » . P-U

Note that, depending on the error symbol positions contained in iSymEra(l) and iSymEra(2), at most two of Hleft, Hcenter and Hright may vanish by virtue of comprising 0 columns.

Using the 5 parts as defined above, enables defining the matrices

H lcr ¹¹ Mt ⁿ center ⁿ right and

H _sym - |H _syml H sym2

With other words, Hlcr is the juxtaposition of those parts of the parity check matrix Hmz that are associated to the non- erroneous symbols, and Hsym is the juxtaposition of those parts of the parity check matrix Hmz that are associated to the erroneous symbols.

Correspondingly, we extract from a received word r aword r _lcr by removing the erroneous 2* (p-m) bits of the two symbols at the positions denoted by iSymEra (1) and iSymEra (2) . The naming "lcr" was chosen to symbolize the fact that removing two arbitrarily placed erased symbols from a codeword leaves a _left part, a center part, and a r_ight part. However, it must be noted, that depending on the position of the erasures, up to two of these parts can vanish because of having width 0.

With these definitions, decoding can be done in 5 steps: Step 1: Check if iSymEra satisfies condition (II) . Break (i.e. exit) if (II) is violated. Step 2: GF2-Multiply r _icr and H _icr to obtain an interim vector w = r _lCT H^.

Step 3 : Find r _sym recurs ively by solving

r sym H ^τ sym ^: W ( i n :

in 2m independent parallel tasks. Each row of H _sym having weight 1 serves as a starting point for the different recursions resulting in 2r bits of r _sym each. One might also use only m tasks if either rows from H _syml or H _sym2 are used to start the recursions. This will increase the recursion depth to Ar.

Step 4: Divide r _sym into r _sym = [r _sym i r _sym2 ] . Multiplex the bits of the two symbols r _sym i and r _sym2 into r _icr according to the erasure positions memorized in iSymEra, yielding the corrected codeword r' . Step 5: Perform post decoding syndrome check. Decoding is considered successful if r'H^ _z = 0 holds. Otherwise a decoding error was detected. The syndrome check might be restricted to those rows of H _mz not involved in Step 3. All the others are satisfied through Step 3.

Notice that the capability of detecting a decoding error in case of erroneous erasure information will increase with a rising number of v _par i bits, i.e. greater m, since more rows of H _mz will not be taken into account in Step 3 thereby increasing the probability of finding a decoding error in Step 5.

For m=l there is no chance of detecting a decoding error.

Fig. 2 shows part of the parity check matrix Hmz of a quasi- cyclic LDPC Code with m=3 and r=l . Ones are represented by black squares. White and grey squares represent Zeros. Arrows denote the decoding schedule being done in 2m tasks. The diamonds on the left indicate rows involving vparl . The bar on top illustrates the position of the erasures. Fig. 2 illustrates an example where the above Step 3 is executed in 2m tasks.

Fig. 3 shows part of the parity check matrix Hmz of a quasi- cyclic LDPC Code with m=3 and r=l . Ones are represented by black squares. White and grey squares represent Zeros. Arrows denote the decoding schedule being done in 2m tasks. The diamonds on the left indicate rows involving vparl . The bar on top illustrates the position of the erasures. Fig. 3 illustrates an example where the above Step 3 is executed in m tasks.

A hardware realization for the Steps 1 to 4 of the algorithm described above can be directly deduced from the block diagram shown in Fig. 4. The first interim vector w 403 is generated by the block Hi _cr 401 which performs the GF2 matrix vector multiplication with r _icr 402. After interleaving w in block π _w 404, a demultiplexer 405 feeds a number of 2m (or m) XORs 406, 407. The r _sym then results from interleaving 408, 409 and concatenation 410. Finally, v is found through multiplexing 411 r _sym i and r _sym2 into r _icr . Fig. 4 shows a block diagram for a 2m parallel implementation of the double erasure decoder.

Single erasure decoding

Method A Any single erasure indicated through a scalar iSymEraSng is correctable. The bit error pattern can easily be extracted from the (p-m) bit of the syndrome s = rH^ _z corresponding to the upper (p-m) rows of H _mz . Also check if the p bits of s corresponding to the lower p bits of H _mz indicate the same error pattern to identify false erasure information and thereby detect decoding errors .

Method B Single erasure decoding might also be accomplished through the 5 Steps described above by generating iSymEra from iSymEraSng by adding the right (or the left) neighboring symbol index .

iSymEra = [iSymEraSng (iSymEraSng+1) ] , if iSymEraSng <

P

iSymEra = [1 iSymEraSng] , if iSymEraSng = p

with other words: In method B, in addition to the single symbol that really is known to be erroneous, one of its directly contiguous neighbor symbols is also and artificially indicated as erroneous - knowing that in reality it isn't. Having two different symbol indexes in iSymEra, then the double symbol erasure decoding as described above is used. This procedure is allowable, because two contiguous symbol erasures are always correctable!

In an additional Step 6, it may be checked thatthe symbol that had been artificially declared as erroneous, namely symbol (iSymEraSng+1) or symbol 1 has been correctly restored, to detect decoding errors.

The invention has realized that a processing step from the zArray e_ncoding approach can actually be used - with minor modifications - to algebraically decode and correct codewords where up to two "symbols" are known to be defect. The properties of the zArray codes are such that the processing step can be parallelized into a number of parallel, independent sequences of bit operations, hence allowing high throughput. However, some of the double erasure constellations are uncorrectable. But the invention has also recognized that the zArray Code parameter "r" strongly influences how many of all existing erasure constellations turn out to be uncorrectable. A rule for choosing "r" is given; the resulting subset of all possible zArray codes has a good double erasure correction probability. As by-products, the invention also describes a criterion by which the uncorrectable cases can be detected, and methods to reliably decode all cases of single erasure.

The invented methods extend the applicability of the zArray codes into those contexts where multiple erasures occur. Other than prior art double erasure decoders, the invented method is parallelizable and is based on codes suited for message passing decoding.

With other words, for correcting a multibit, LDPC coded codeword where up to two multibit symbols within the codeword are known to be erroneous, a method is proposed, where the position of the erroneous multibit symbols is checked for correctability, where the non-erroneous subset of the codeword is GF2-multiplied with a corresponding subset of the parity check matrix of the LDPC code resulting in an interim vector, and where the erroneous parts of the codeword are reconstructed such that they, when GF2-multiplied to their associated parts of the parity check matrix, yield the same interim vector.