Fast combined Chase and GMD decoding of generalized Reed-Solomon codes

Abstract

A method for soft decoding of a generalized Reed-Solomon (RS) error correction code includes: receiving a codeword through a digital electronic communication channel; verifying an HD error and an erasure decoding has failed; a Groebner base in charge of a fixed erasure set is found out; constructing a Chase decoding tree and a GMD decoding tree on the Chase coordinate set and the GMD coordinate set; traversing the decoding tree using the polynomial of the Groebner base as a base representing an updated coefficient polynomial on the Chase and GMD decoding tree; updating the polynomial on the decode tree using a root step of flipping the edge and a derivative step or a root step of erasing the edge; calculating an error position by performing polynomial evaluation on candidate polynomials from the decoding tree, and calculating an error value by using a Forne equation; and correcting the received codeword according to the calculated error position and the calculated error value.

Description

Technical Field

[0001] Embodiments of the present disclosure relate to a new and efficient method for soft decoding of Reed - Solomon (RS) codes. Background Art

[0002] Reed - Solomon codes are a set of error - correcting codes widely used in various applications. RS codes are widely used in communication and storage systems. In some applications, RS codes are used as part of a generalized concatenated code (GCC) scheme. In such a scheme, RS codes are decoded for both errors and erasures, where the errors of the RS code correspond to undetected errors in the row code, and the erasures of the RS code correspond to detected errors in the row code. Compared with the probability of decoding errors of ordinary error - erasure decoding, some list - decoding algorithms can reduce the probability of decoding errors. Regarding algebraic soft decoding, significant gains in decoding performance can be achieved by using soft information (i.e., probability information about the received symbols): instead of simply using a single a posteriori maximum - probability finite - field element at each coordinate as the decoder input, the decoder can benefit from knowing the a posteriori probability of each finite - field element (or its approximation) at each coordinate. Summary of the Invention

[0003] According to an embodiment of the present disclosure, a method for soft decoding of a generalized Reed - Solomon (RS) error - correcting code is provided. The method includes: receiving a codeword y through a digital electronic communication channel, where for at least one error vector y = x + e, where F q is a finite field of q elements, where q is a prime power, and for the transmitted codeword x ∈ C, where C is a generalized Reed - Solomon code having length n <= q - 1 and configured to be shortened, and minimum Hamming distance d >= 2; performing hard - decision (HD) error and erasure decoding on the codeword using a fixed erasure set; verifying that the HD error and erasure decoding has failed; finding the Groebner basis of the solution module responsible for the fixed erasure set; using channel reliability information to determine a Chase coordinate set and a generalized minimum - distance (GMD) coordinate set; constructing Chase and GMD decoding trees on the Chase coordinate set and the GMD coordinate set; first traversing the depth of the decoding tree using the polynomials of the Groebner basis as a basis for representing the updated coefficient polynomials on the Chase and GMD decoding trees; updating the polynomials on the decoding tree using a root and derivative step that flips an edge or a root step that erases an edge; calculating the error locations by performing polynomial evaluations on candidate polynomials from the decoding tree, and calculating the error values; and correcting the received codeword according to the calculated error locations and the calculated error values, and saving the corrected received codeword to the decoder output list.

[0004] According to another embodiment of the present disclosure, performing hard decision (HD) error and erasure decoding using a fixed erasure set includes: calculating an estimated error locator polynomial (ELP) v(X) excluding erasures by performing an error and erasure Berlekamp-Massey algorithm, where X is an indeterminate variable; verifying that v(X) has deg(v(X)) roots inverses at coordinates that are not fixed erasures where and A′1 is a fixed erasure set, and where L is the estimated order, is the number of fixed erasures, and is the correction order of the excluded erasures; defining σ1 := v; calculating the error and fixed erasure ELP where is the erasure locator polynomial, and the error and fixed erasure error evaluation polynomial (EEP) where is the syndrome polynomial associated with y and the fixed erasure set; finding the error values of the error positions outside A′1 by using the Forney formula with the roots of σ1; and finding the error values of the error positions in A′1 by using the Forney formula with the inverses of the elements of A′1; using the found error values to correct all errors in the decoded codeword; and outputting the corrected decoded codeword.

[0005] According to another embodiment of the present disclosure, verifying that HD error and erasure decoding has failed includes: verifying that v(X) does not have deg(v(X)) roots inverses at the inverses of the un-erased coordinates, or verifying

[0006] According to another embodiment of the present disclosure, constructing a decoding tree includes: allocating memory for r max +1 Groebner bases, one memory for each depth, where r max is the maximum design depth, and storing the Groebner basis {(1,0), (0,1)} of the module of the coefficient polynomial for the case of only fixed erasures in the memory at depth 0, where the decoding tree includes a root that is the all-zero vector in , and at depth r, for all r ∈ {1,..., r max}, vertices that are vectors of length η and weight r in and edges that are pairs (β′, β), where η is the number of Chase flip coordinates plus the number of variable GMD erasure coordinates, and where for each vertex at depth r that has non-zero entries at coordinates i1,..., i r a single vertex β′ = (β′1,..., β′ η ​) is selected at depth r - 1 which is equal to β on all coordinates except for an additional flipped or erased coordinate i l , l ∈ {1,..., r}, and for this additional flipped or erased coordinate i l ,

[0007] According to another embodiment of the present disclosure, traversing the decoding tree depth first includes: updating the Groebner basis read from the memory at the previous depth when moving on an edge corresponding to an additional variable erasure or an additional Chase flip, wherein the updated Groebner basis is stored in the memory.

[0008] According to another embodiment of the present disclosure, updating the Groebner basis read from the memory at the previous depth includes: using Koetter iteration to delete the additional coordinate when moving on an edge corresponding to an additional variable erasure or using a pair of Koetter iterations when moving on an edge corresponding to a Chase flip on the additional coordinate.

[0009] According to another embodiment of the present disclosure, the method includes: verifying that the stop condition holds during the update of the Groebner basis; outputting that the stop condition is a false positive, and when its inverse is not on the fixed erasure or variable erasure the number of roots of , return to the depth - first search of the tree, where is the set of estimated errors and variable erasures ELP, and is the number of variable erasures.

[0010] According to another embodiment of the present disclosure, the method includes: verifying that the stop condition holds during the update of the Groebner basis; outputting that the stop condition is a false positive, and when at least one of the error values found on the coordinates having locators in the un - erased coordinates is equal to 0, return to the depth - first search on the tree, where A′1 is the set of fixed erasures and A′2 is the current hypothesis of variable erasures.

[0011] According to another embodiment of the present disclosure, calculating the error locations by polynomial evaluation of candidate polynomials from the decoding tree and calculating the error values by using the Forney formula includes: verifying that a valid pair of EEP and ELP has been found by checking that the number of roots of the ELP is equal to its degree minus the number of variable erasures and the inverses of all roots are outside the set of fixed erasures, finding the error values on the un - erased coordinates using the Forney algorithm with the EEP and ELP, and checking that the estimated error values on the un - erased coordinates are not zero; calculating the estimated errors and erased ELP wherein is a set of estimation errors and variable erasures ELP, and is the fixed erasure ELP, and the error values are found only on the coordinates with locators in by using the Forney formula, wherein A′1 is the fixed erasure set, and A′2 is the current hypothesis of variable erasures, and the error values of all erasure coordinates are calculated by using the Forney formula, wherein is the number of variable erasures.

[0012] According to another embodiment of the present disclosure, finding all roots of on the inverse of the elements in includes: evaluating and storing the h of all coordinates 01 (β), h 11 (β), h′ 01 (β) and h′ 11 (β) values, where h 01 and h 11 are the second polynomials of the Groebner basis of the error and fixed erasure key equation solving module; calculating a new estimated error set of where f 10 and f 11 are separate polynomials of the current Groebner basis from the coefficient polynomial solving module; and calculating the derivative of the ELP σ′(β) by evaluating the derivatives f′ 10 (β), f′ 11 (β), and using 4 additional multiplications to calculate σ′(β), and using the calculated values and the stored values and the following formula to find the estimated value σ′(X):

[0013] According to another embodiment of the present disclosure, a digital electronic circuit is provided that tangibly embodies a program of instructions executed by the digital electronic circuit to perform method steps for soft decoding of a generalized Reed-Solomon (RS) error correction code. BRIEF DESCRIPTION OF THE DRAWINGS

[0014] Figure 1 is a flowchart of a decoding process using a new combined fast Chase / GMD algorithm according to an embodiment.

[0015] Figure 2 is a block diagram of a system for performing a decoding process using a new combined fast Chase / GMD algorithm according to an embodiment of the present disclosure.

[0016] Figure 3Shows an example of a variant of a decoding tree according to an embodiment of the present disclosure. Detailed implementation

[0017] Embodiments of the present disclosure relate to a new method for fast combined Chase and GMD decoding of generalized RS (GRS) codes (including RS codes as a special case). The present invention builds on and extends the previous fast Chase decoding algorithm, which did not consider combining fast GMD with fast Chase decoding.

[0018] The main soft decoding algorithms for block codes are the generalized minimum distance (GMD) decoding and the Chase decoding algorithm. GMD decoding involves repeated application of error and erasure decoding while successively erasing an even number of the least reliable coordinates.

[0019] In Chase decoding, there is a pre-determined list of test error patterns located on the η least reliable coordinates for some small η, where generally, and d is the minimum Hamming distance of the code. For example, the list can include all possible non-zero vectors, all vectors with a sufficiently low weight, a predefined number of random vectors, etc. The decoder runs successively on the error patterns from this list. Each such error pattern is subtracted from the received codeword, and the result is fed to a hard decision (HD) decoder. If the HD decoder succeeds, then its output is saved to the decoder's output list.

[0020] However, it should be noted that although Chase decoding has an exponential nature, for medium-length high-rate codes, it is known to have a better complexity / performance trade-off than algebraic soft decoding. For this reason, Chase decoding of RS codes remains of great interest.

[0021] When the finite field size q increases, the complexity of O(q ) for the Chase decoding scan of all test error patterns from η becomes infeasible, where for a prime power q, F q is the finite field of q elements underlying the RS code. For this reason, for each coordinate, only the 2 most likely noise symbols are scanned. It should be noted that by defining the HD symbol as the most likely symbol, one of these 2 most likely noise symbols is always 0. It should also be noted that this is equivalent to scanning the 2 most likely values of the codeword coordinates.

[0022] The exponential complexity of Chase decoding is much higher than the linear complexity of GMD. However, the decoding performance of Chase decoding is usually much better than that of GMD decoding. It is possible to combine Chase decoding and GMD decoding: for some unreliable coordinates, the decoder runs on the test error patterns (Chase), while for other unreliable coordinates, only erasure attempts are made (GMD).

[0023] Possible criteria have emerged for selecting the coordinates for GMD and the coordinates for Chase in the combined Chase and GMD decoding.

[0024] For example, η can be obtained chase The set I of η coordinates for which Chase trials are performed is defined by taking the coordinates i ∈ {0,..., n - 1} chase chase For which

[0025]

[0026] Taking η chase The lowest value, where (r0,..., r n-1 ) is the channel output, and s i (j) is the j-th most likely symbol of the i-th received coordinate, where i ∈ {0,..., n - 1} and j ∈ {1,..., q}, and M is the number of the most likely symbols considered in the Chase coordinates. Usually, M = 2. Additionally, the set I of η coordinates for which GMD decoding is performed can also be defined by taking those coordinates i outside the above-mentioned η chase coordinates GMD GMD For which

[0027]

[0028] Taking η GMD The lowest value.

[0029] To gain an intuitive understanding of such criteria, it is recalled that in the possible simplified Chase decoding, only 2 of the q possible symbols, the most likely ones, are scanned. If the posterior probabilities of the remaining q - 2 symbols are much smaller (in general) than the posterior probabilities of the 2 most likely symbols, then this method is reasonable.

[0030] For example, if in a certain coordinate, all q - 1 symbols except the HD symbol (which is the most likely symbol) have similar posterior probabilities, then there is no clear choice for the second most likely symbol in that coordinate. If such a coordinate is considered unreliable, then it is better to attempt to erase that coordinate rather than search for all q - 1 potential replacements.

[0031] ​​In the fast Chase decoding algorithm, the decoder shares computations between HD decodings of different test error patterns. For example, if two test error patterns differ in a single coordinate, it seems reasonable that it is not necessary to go through all the steps of the HD decoding twice. Similarly, in the fast GMD algorithm, whenever an additional erasure is added, the decoder uses the previous decoded output as a starting point instead of starting an entirely new error and erasure decoding.

[0032] Embodiments of the present disclosure support two types of erasures: (1) static erasures, which are present in all Chase and GMD trials, such as in the case of decoding a GCC code, the static erasures correspond to errors detected in the row code; and (2) dynamic erasures, which are added to the GMD decoding. The reason for supporting two types of erasures is to maximize the efficiency of the algorithm according to the embodiments. Generally, static erasures are "taken out" from the updated polynomial to avoid updating high-degree polynomials, especially when the number of static erasures is high, and then taken into account at the end of the combined Chase / GMD process.

[0033] Embodiments of the present disclosure utilize an update rule: given the error locator polynomial (ELP) updated so far for GMD erasures and Chase-modified coordinates, embodiments of the present disclosure provide a low-complexity method to update the ELP for the next GMD erasure / Chase-modified coordinate. Then, the fast combined Chase and GMD decoding arranges the scanned errors / erasures on a tree described below and uses the update rule at the edges of the tree.

[0034] GRS Codes and Key Equations

[0035] Let q be a prime power, and let F q be the finite field of q elements. Consider a primitive generalized Reed-Solomon (GRS) code C of length n := q - 1 and minimum Hamming distance d ≥ 2. For example, let be a vector of non-zero elements (where ). For a vector let f(X) := f0 + f1X + … + f n-1 X n-1 ∈ F q [X]. Now, is defined as the set of all vectors such that for all vectors, has roots 1, λ,..., λ q for some fixed primitive element λ ∈ F d-2 , where (-⊙-) represents coefficient-wise multiplication of polynomials. Note that when When C is a Reed - Solomon (RS) code. Also note that there is no loss of generality in considering primitive GRS codes, since more general cases can be obtained by shortening primitive GRS codes. In the remainder of this article, will be called the GRS scaling vector.

[0036] Recall the key equations. Assume that a codeword x ∈ C is transmitted, and for at least one error vector the received codeword is y = x + e. For j ∈ {0,..., d - 2}, let the syndrome polynomial associated with y be S (y) (X) := S0 + S1X + … + S d-2 X d-2 . By the definition of GRS codes, the same syndrome polynomial is associated with e.

[0037] The complete error locator set of e is the subset such that for all i ∈ {0,..., n - 1},

[0038]

[0039] where supp(e) := {i ∈ {0,..., n - 1}|e i ≠ 0}. Thus, for E as the complete error locator set, it must contain all the field elements that point to the error positions and may also contain additional elements. For example, is always a complete error locator set, but it is not a useful locator, as will be made clear below.

[0040] Let ε be the total number of errors, i.e., the number of non - zero coordinates in e. Let be the complete error locator set, where ε′ ≥ ε, and let the corresponding (possibly zero) error values be β1,..., β ε′ ∈ F q . Define the error locator polynomial (ELP) associated with E by setting σ E (X) ∈ F q [X], and define the error evaluator polynomial (EEP) associated with E by setting ω E (X) ∈ F q [X], where for the unique i′ ∈ {0,..., n - 1} with α i = λ i′ , Then the ELP, EEP, and syndrome polynomial satisfy the following key equations:

[0041] ω E ≡S (y) σ E mod(X d-1 )

[0042] Another useful equation is the Forney-style one, which relates error locations to error values and reads

[0043]

[0044] for all j ∈ {1,..., ε′}.

[0045] Error and erasure decoding

[0046] Before proceeding, it will be useful to review some facts about "ordinary" error and erasure decoding of GRS codes.

[0047] Suppose the e0 coordinates of the received vector y are erased. Let be any vector that agrees with y on the non-erased coordinates. For example, is obtained from y by filling in arbitrary values on the erased coordinates For example, these arbitrary values can all be zero, and write The error and erasure decoder finds the positions and values of the non-zero entries of, thus recovering x.

[0048] Let be the set of non-erased coordinates, so that |J| = n - e0. Let E1 be the set of locators of all errors on J. For example, let E1 := {α j | j ∈ J and }, and write e1 := |E1| for the number of errors on the non-erased part. Also let be the set of erased coordinates, and consider E := E1 ∪ E0 to be the complete set of error locators of. Define and such that σ E = σ0σ1. The key equation now reads Sσ0σ1 ≡ ω E mod(X d-1 ), where defines We also have

[0049] For g(X) ∈ F q [X] and r ∈ N, let For the solution module of the "general" key equation: M g，r := {(u, v) ∈ F q [X] × F q[X] | u ≡ gv mod(X r )}。

[0050] For pairs (u, v) ∈ F q [X] 2 , the order Ord(u, v) is defined by Ord(u, v) := max{deg(u) + 1, deg(v)}. Further, for an integer w (possibly zero or negative), the (1, w)-weighted degree is defined as wdeg 1,w (u, v) := max{deg(u), deg(v) + w}. Note that when w = -1, the order is the same as the weighted degree up to an additive constant: Ord(u, v) = wdeg 1，-1 (u, v) + 1. The basis for almost all error and erasure decoding algorithms is the following well-known proposition, whose proof is omitted.

[0051] Proposition 1:

[0052] 1. gcd(w E , σ1) = 1.

[0053] 2. Assume 2e1 + e0 ≤ d - 1 and S ≠ 0. Then

[0054] a. (ω E , σ1) has the minimum (1, e0 - 1)-weighted degree in . Further, if some non-zero has then there exists some constant such that (u, v) = c · (ω E , σ1).

[0055] b. Define N := {(u, v) ∈ M S，d-1 | σ0 divides v}. Then, (ω E , σ E ) has the minimum (1, -1)-weighted degree in N \ {(0, 0)}. Further, if some non-zero (u, v) ∈ N has wdeg 1，-1 (u, v) = wdeg 1，-1 (ω E , σ E ), then there exists some such that (u, v) = c · (ω E , σ E ).

[0056] Proposition 1 shows that decoding can be performed by solving a minimization problem. For example, the Euclidean algorithm can be used to solve the minimization in part 2(a) of the proposition, and the modified Berlekamp-Massey (BM) algorithm can be used to solve the minimization in part 2(b).

[0057] Koetter iteration

[0058] This part uses the general form of Koetter iteration, and K is an arbitrary field. Specifically, for the field K and the monomial ordering on K[X] l of monomials For some l ∈ N * , with respect to the leading monomial LM<(·) of the written polynomial vector. When the ordering is clear from the context, just write LM(·).

[0059] For the K[X]-submodule For a positive integer l of rank l + 1, let G = {g0,..., g l} be the Groebner basis of M with respect to l+1 some monomial ordering on K[X] Assume without loss of generality that the leading monomial of g j contains the j-th unit vector, counting from 0.

[0060] Let D: K[X] l+1 → K be a non-zero linear function for which M + := M ∩ ker(D) is a K[X]-module. The Koetter iteration transforms the (l + 1)-element Groebner basis G of M into an (l + 1)-element Groebner basis + of M while preserving the property of containing the j-th unit vector. Its existence is in the following pseudocode.

[0061] Koetter iteration:

[0062] Input: Groebner basis G = {g0,..., g l} of M, where LM(g j ) contains the j-th unit vector for all j

[0063] Output: Groebner basis + of M where contains the j-th unit vector for all j

[0064] Algorithm:

[0065] ● For j = 0, ..., l, compute Δ j := D(g j )

[0066] ● Set J := {j ∈ {0, ..., l} | Δ j ≠ 0}

[0067] ● For j ∈ {0, ..., l} \ J

[0068] ○ Set

[0069] ● Let j * ∈ J such that

[0070] ● For j ∈ J

[0071] ○ If j ≠ j * , then set

[0072] ○ Otherwise, set

[0073] Decoding tree

[0074] Possible embodiments of the decoding tree are described below. In an embodiment, there are ηchase coordinates for Chase flipping and η GMD coordinates for variable GMD erasure attempts (above the fixed erasures). Let be the set of coordinates that scan the Chase test vectors, and let be the set of coordinates that attempt GMD erasures. The sets I chase and I GMD are determined according to channel reliability information (such as the and defined above).

[0075] Write η := η chase + η GMD , and each Chase test vector / GMD erasure pattern of the embodiment is determined by a binary vector of length η. The first η chase coordinates determine the Chase test error vector on I chase , where the 0 entry in coordinate i ∈ {1, ..., η chase} corresponds to 0 on γ i , while the 1 entry in coordinate i corresponds to the second most likely error value in coordinate γ i . Note that by defining the HD received vector, the most likely error value is 0.

[0076] Similarly, the following η GMD coordinates define the GMD erasure pattern, where a zero in coordinate i ∈ {η chase + 1,..., η chase + η GMD} corresponds to a non-erased coordinate γ i and a one in coordinate i corresponds to an erased coordinate γ i .

[0077] For some predefined r max , binary vectors of length η and Hamming weight up to r max are arranged on the vertices of a directed tree T that will now be defined. The root is the all-zero vector in, and for all r ∈ {1,..., r max}, the vertices at depth r are the vectors of weight r in. To define the edges of T, for each r ≥ 1 and each vertex r at depth r that has non-zero entries at coordinates i1,..., i choose a single vertex β′ = (β′1,..., β′ η ) at depth r - 1 that is equal to β in all coordinates except for one i l (l ∈ {1,..., r}), for which note that, given β, there are r different ways to choose β′, and one such choice can be fixed. Now, the edges of T are exactly all the pairs (β′, β).

[0078] The edge (β′, β) defined above corresponds to exactly one additional flipped or erased coordinate that is adjacent (i.e., ). Thus, alternatively, the edge (β′, β) can be labeled by . Similarly, a path from the root to a vertex at depth r ≥ 1 can be identified with a vector having a different and thus the vertex itself can be identified.

[0079] Note that scanning the tree T corresponds to scanning all combinations of test error vectors and erasure patterns over I := I chase ∪ I GMD for which the total number of non-zero test error values plus the total number of variable erasures is at most r max .

[0080] Keep in mind that the above is just one possible choice of decoding tree. For example, in the tree above, when r = η, the final scan I GMDAll possible erasure patterns on. In an alternative embodiment, far fewer erasure patterns are scanned. In this alternative embodiment, I GMD The coordinates on are sorted in ascending order of channel reliability, and for I chase For each test error pattern on, the decoder first deletes the two least reliable coordinates on I GMD , and then deletes the next two coordinates, and so on.

[0081] Minimization task

[0082] Let \(r, e_0\in\{0,\ldots,n\}\), where \(n\) is the code length, and let be distinct, and let (not necessarily distinct). These pairs \((\alpha j , \beta j ) are pairs of locators and values of error patterns assumed during fast Chase / GMD decoding, while \(\alpha'\ j represents a hypothesized set of erasure locators. Let \(A':=\{\alpha'\ j \}\) be the set of erasure locators, and let be the erasure ELP.

[0083] Remark 1: Note that, for convenience, this part uses a notation slightly different from that of the previous part. For example, the erasure locators are labeled by \(A'\) instead of \(E_0\), etc.

[0084] In fact, the erasure set \(A'\) can be further partitioned into a "large" fixed erasure subset that exists throughout the fast Chase / GMD decoding algorithm and a "small" variable erasure set that is the current erasure hypothesis. Thus, let be the number of fixed erasures, let be the number of variable erasures, let be the fixed erasure set, and let be the current hypothesis of variable erasures. In addition, set and such that

[0085] Next, define some useful \(F q [X]\)-modules. By filling arbitrary values on the erasure coordinates, let be obtained from the received vector \(y\), which includes erasures on the fixed erasure set \(A'_1\). Let

[0086]

[0087] where for the unique \(i'\in\{0,\ldots,n - 1\}\) with \(\alpha i =\lambda i′ , Similarly, assume

[0088]

[0089] For a quick Chase decoding without any erasures, refer to the following module.

[0090]

[0091] Remark 2. Note that

[0092] 1. and are both defined as the set of all pairs of polynomials that satisfy a congruence of a specific key equation type plus specific conditions that depend on the errors and erasures assumed so far. As will be explained below, each additional condition can be taken into account by using an update rule based on Koetter iteration.

[0093] 2. Note that and incorporate erasures in two different ways. Obviously,[[]] is more suitable for variable erasure patterns, since it does not include a syndrome that depends on the variable part of the erasure pattern, and the Forney - type conditions that appear in its definition do not require the evaluation of the changing erasure ELP. In fact,[[]] appears mainly as an auxiliary tool for stating and proving Theorem 3 below, while is the module that is actually used to define the update rule for the fast combined Chase / GMD decoding.

[0094] 3. Observing the conditions that appear in the definition of it is clear that, apart from the following differences, it has a form very similar to that of M r :

[0095] a. It includes additional constraints of the form Each such constraint has the same form as the first part of the constraint used for Chase flipping.

[0096] b. Each a j , j ∈ {1,..., r} is replaced by and S (y) is replaced by Once it is determined that the HD decoding fails and the fast combined Chase / GMD should be initiated, can be calculated and thus chase can also be calculated for all η coordinates for the planned Chase flips, and a′ j .

[0097] Assume is the set of all error locators outside of A′, and let E := A ∪ A′, so that E is the complete error locator set. Let σ E (X) := Π α∈E (1 - αX), σ1(X) := Π α∈A (1 - αX). In this part, it will sometimes be more convenient to index vectors by the elements of (rather than by the integers in {0, 1,..., n - 1}). Thus, for α ∈ E, let β(α) be the corresponding error value (possibly zero), and let a(α) be the corresponding value of the GRS scaling vector (i.e., if α = λ i , then ). In this notation, we have ω E = ∑ α∈E β(α)a(α)Π α′∈E\{α} (1 - α′X), and the Forney formula reads

[0098]

[0099] In what follows, we will switch between indexing by integers and indexing by field elements (choosing the simplest notation in each context), and it should be clear from the context which notation is being used.

[0100] The probability of using Koetter iteration to perform combined fast Chase / GMD decoding follows almost directly from the following theorem. In this theorem, for a subset and a vector we write z| U for the punctured vector obtained by restricting z to U. Additionally, we write for the

[0101] complement of U in

[0102] 1. For all r, M r ,, is an F q [X]-module.

[0103] 2. The mapping is a monomorphism of F q [X]-modules, the image of which is exactly and thus induces an isomorphism which should be called θ.

[0104] 3. If α1,..., α r are the error locators and β1,..., βr If it corresponds to an error value, then:

[0105] c. And for the (1, e0 - 1) weighted lexicographic order with Y > X, it is considered that

[0106] d. And for the weighted lexicographic order with Y > X

[0107]

[0108] The proof is omitted here.

[0109] Using low - degree polynomials

[0110] does not directly use the polynomials in, but can use polynomials of much lower degree. From this point on, write < w for the (1, w) weighted lexicographic order with Y > X. Let {h0 = (h 00 , h 01 ), h1 = (h 10 , h 11 )} be the Groebner basis of with respect to the monomial order such that the leading - term monomial of h0 is on the left, i.e., in the first coordinate, while the leading - term monomial of h1 is on the right, i.e., in the second coordinate. Since {h0, h1} is also a free - module basis, each element can be written as the unique pair (f0(X), f1(X)) of (u, v) = f0(X)h0 + f1(X)h1, and the mapping is an isomorphism of F q [X] - modules.

[0111] Note that for all is a sub - module, and let

[0112]

[0113] be the μ - image of. Call the module of the coefficient polynomials of . By writing the typical element as f0(X)h0 + f1(X)h1 and substituting in the constraints of the definition of , the following properties of N r can be obtained with constraints suitable for applying the Koetter iteration. For the following proposition, recall part 3(b) of Remark 2, for all j ∈ {1,..., r},

[0114] Proposition 4. Consider to be the set of all pairs \((f_0,f_1)\in F\) q [X] 2 such that:

[0115] ●

[0116] 1. and

[0117] 2. where

[0118]

[0119]

[0120] ●

[0121] To translate the minimality assertion of Theorem 3 into the language of coefficient polynomials, the following proposition can be used in the presence of erasures.

[0122] Proposition 5. Let Then, for all consider

[0123]

[0124] The proof is omitted.

[0125] Theorems 3 and 5 show that one should search for the vector of minimal leading monomials in \(\langle w\rangle\), and for this, it suffices to have a Groebner basis with respect to \(\langle w\rangle\). Then one can take the unique vector of minimal leading monomials in this binary Groebner basis. Alternatively, one can search for the Groebner basis of \(\langle w\rangle\), but this is usually less efficient. in \(\langle w\rangle\), and for this, with respect to \(\langle w\rangle\), for it suffices to have a Groebner basis. Then one can take the unique vector of minimal leading monomials in this binary Groebner basis. Alternatively, with respect to search for the Groebner basis of \(\langle w\rangle\), but this is usually less efficient.

[0126] The definition of \(\langle w\rangle\) shows how one can transform the Groebner basis of \(\langle w\rangle\) into the Groebner basis of \(\langle w\rangle\) by two applications of the Koetter iteration, or how one can transform the Groebner basis of \(\langle w\rangle\) into the Groebner basis of \(\langle w\rangle\) by a single iteration of the Koetter iteration. the Groebner basis of \(\langle w\rangle\) into the Groebner basis of \(\langle w\rangle\), or how one can transform the Groebner basis of \(\langle w\rangle\) into the Groebner basis of \(\langle w\rangle\) into the Groebner basis of \(\langle w\rangle\).

[0127] The exact update rules corresponding to one or two Koetter iterations will be described in detail below. Note that, according to the embodiments, such update rules are the key to fast Chase / GMD: for additional flips or erasures, instead of starting from scratch, all the accumulated computations so far are used as a starting point, and only low-complexity update rules are applied.

[0128] Finally, note that, by definition, {(1, 0), (0, 1)} can be made the <w-Groebner basis of this module. This Groebner basis will be used at the root of the decoding tree.

[0129] Algorithm

[0130] Initialization

[0131] After a finite-distance HD decoding failure, the initialization of the fast combined Chase / GMD algorithm according to the embodiments is performed. To initialize the algorithm, it is necessary to find the Groebner basis of, where relative to the only constant is

[0132] An algorithm for finding the Groebner basis is as follows:

[0133] Input:

[0134]

[0135]

[0136] v := d - 1

[0137] Output:

[0138] the Groebner basis of

[0139] Initialization:

[0140] (a0, b0) := (1, 0); (a1, b1) := (0, 1); α0 := -1; j := 1; k := 0

[0141] Iteration:

[0142] If r ≥ 0, then

[0143] i := 0; d := 1 + r

[0144] Otherwise

[0145] i := 1; d := --r

[0146] Perform when k < η

[0147] α j := b j X in (X)·g(X) k coefficient of

[0148] k := k + 1

[0149] If α i ≠ 0, then

[0150]

[0151] (a i (X), b i (X)) := (Xa i (X), Xb i (X))

[0152] j := 1 - i

[0153] d := d - 1

[0154] If d = 0, then

[0155] i := 1 - i; d := 1

[0156] Otherwise

[0157] (a 1-i (X), b 1-i (X)) := (Xa 1-i (X), Xb 1-i (X))

[0158] j := i; d := d + 1

[0159] At the end of the algorithm, the leading monomials of (a0(X), b0(X)) and (a1(X), b1(X)) with respect to are not in the same coordinates. To continue with combined Chase / GMD decoding, take the first Groebner basis element to be (a i (X), b i (X)) (i = 0, 1) whose leading monomial is on the left, and take the second Groebner basis element to be (a 1-i (X), b 1-i (X)).

[0160] Alternatively, the two polynomial updates during the error and erasure BM algorithm can be used to obtain the Groebner basis as follows. An efficient version of the BM algorithm for errors and erasures is as follows. The output is two pairs of polynomials.

[0161] Algorithm A: Efficient Error and Erasure BM Algorithm

[0162] Input:

[0163] ●S (y) (X)

[0164] ●

[0165] ●

[0166] Output:

[0167] ● If v(X), otherwise v(X) = σ1(X): = Π α∈A (1 - αX), where v(X) is the estimated ELP excluding erasures;

[0168] ● v - (X), which is required to find the Groebner basis of;

[0169] ● δ, which is associated with finding the Groebner basis of;

[0170] Initialization:

[0171] ● Calculate

[0172] ● v(X): = 1

[0173] ● v-(X): = 1

[0174] ● δ: = 1

[0175] ● b: = 1

[0176] ●

[0177] Iteration:

[0178] ● For to d - 2

[0179] ○ Set

[0180] ○ If Δ = 0, then

[0181] ■ Update δ ← δ + 1

[0182] ○ If Δ ≠ 0 and then

[0183] ■ Update v(X) ← v(X) - Δ·b- 1 X δ v-(X)

[0184] ■ Update δ ← δ + 1

[0185] ○ If Δ ≠ 0 and then

[0186] ■ Set TMP := v(X)

[0187] ■ Update v(X) ← v(X) - Δ·b -1 X δ v - (X)

[0188] ■ Update

[0189] ■ Set v - (X) := TMP

[0190] ■ Set b := Δ

[0191] ■ Set δ := 1

[0192] To obtain the Groebner basis from the output of the algorithm, in the case of ordinary error and erasure decoding failure, it is possible to proceed as follows:

[0193] 1. Calculate

[0194] ●

[0195] ●

[0196] 2. If and contain different unit vectors (i.e., are located at different coordinates), then

[0197] ● Let h0 be the vector from {b0, b1} having the leading monomial in the first coordinate, and let h1 be the vector from {b0, b1} having the leading monomial in the second coordinate

[0198] ● Output {h0, h1} as the Groebner basis

[0199] 3. If and contain the same unit vector (i.e., they are on the same side), then:

[0200] ● If then for the unique and l ∈ N * , update b1 ← b1 - cX l b0

[0201] ● If Then, for the unique one that ensures the cancellation of leading monomials For \(l\in N\), update \(b_0\leftarrow b_0 - cX\) l \(b_1\)

[0202] ● Calculate and output \(\{h_0, h_1\}\) according to Step 2.

[0203] Note that by defining the monomial order \(\lt_w\) (for any \(w\)), the comparison in Step 3 is equivalent to \(\text{deg}(b_{j}(X))\lt\text{deg}(b_{j'}(X))\), where \(j\) is the common coordinate of the leading monomials. Similarly,[[]] 0j \(\text{deg}(b_{j}(X))\lt\text{deg}(b_{j'}(X))\), 1j where \(j\) is the common coordinate of the leading monomials. Similarly,[[]] is equivalent to \(\text{deg}(b_{j}(X))\geq\text{deg}(b_{j'}(X))\). 0j \(\text{deg}(b_{j}(X))\geq\text{deg}(b_{j'}(X))\). 1j

[0204] Note that any algorithm for finding the Groebner basis of the module defined by the above constraints can also be used for fixing erased HD errors and erasure decoding. In typical applications, to reduce complexity, the Groebner basis for initialization is obtained from the same algorithm used for initial error and erasure HD decoding.

[0205] Update rule for additional flips

[0206] This rule corresponds to the case of moving from to .

[0207] Algorithm B: Edge update rule for moving from to .

[0208] In the following, there are two types of iterations. In the "root" - type iteration, the algorithm stipulates that some of the updated polynomials have additional roots. In the "derivative" iteration, the algorithm stipulates that the updated polynomials satisfy the Forney - type, which involves the derivatives of some polynomials.

[0209] Input:

[0210] ● (This only depends on the initialization at the root of the decoding tree)

[0211] ● The Groebner basis \(G = \{f_0=(f_{j_1}, f_{j_2}), f_1=(f_{j_3}, f_{j_4})\}\), where \(\text{LM}(f_{j_1})\) 00 , \(f_{j_2}\) 01 )), \(f_1=(f_{j_3}, f_{j_4})\) 10 , \(f_{j_4}\) 11 )}, where \(\text{LM}(f_{j_1})\) w (f_{j_1}\) j ​The j-th unit vector with j ∈ {0, 1}

[0212] ● The next hypothesized error location α r and the corresponding hypothesized error value β r

[0213] Output:

[0214] ● The Groebner basis of where LM w (f j ) contains the j-th unit vector with j ∈ {0, 1}

[0215] Algorithm:

[0216] ● For type = root, der

[0217] ○ If type = der, then

[0218] ■ For j = 0, 1, set / / init: the output of root iter

[0219] ○ For j = 0, 1, compute

[0220]

[0221] (where b, b, c, c are defined in Proposition 4 0r , b 1r , c 0r , c 1r )

[0222] ○ Set J := {j ∈ {0, 1} | Δ j ≠ 0}

[0223] ○ For j ∈ {0, 1} \ J, set

[0224] ○ Let j * ∈ J such that

[0225] ○ For j ∈ J

[0226] ■ If j ≠ j * , then set

[0227] ■ Otherwise, set

[0228] Update rules for additional variable erasures

[0229] Such rules are related to moving from to The corresponding case is an additional variable erasure. It is very similar to Algorithm B but is simpler than Algorithm B in the following sense: instead of the two iterations in Algorithm B ("root", "der"), only a single iteration is configured.

[0230] Algorithm C: For moving from to Edge update rule.

[0231] Input:

[0232] ● (This depends only on the initialization at the root of the decoding tree)

[0233] ● The Groebner basis G = {f0 = (f 00 , f 01 ), f1 = (f 10 , f 11 )}, where LM w (f j ) contains the j-th unit vector for j ∈ {0, 1}

[0234] ● The next hypothesized erasure position α′ and the corresponding hypothesized error value β r

[0235] Output:

[0236] ● The Groebner basis where LM w (f j ) contains the j-th unit vector for j ∈ {0, 1}

[0237] Algorithm:

[0238] ● For j = 0, 1, compute Δ j := h 01 (α′ -1 )f j0 (α′ -1 ) + h 11 (α′ -1 )f j1 (α′ -1 )

[0239] ● Set J := {j ∈ {0, 1} | Δ j ≠ 0}

[0240] ● For j ∈ {0, 1} \ J, set

[0241] ● Let j * ∈ J such that

[0242] ● For j ∈ J

[0243] ○ If j ∈ j * , then set

[0244] ○ Otherwise, set

[0245] Stop condition

[0246] Write for the ELP estimated so far Note that the polynomial may not be explicitly computed. To definitely determine whether the flips and erasures so far have produced the correct ELP, at least until the undetected errors that are inherently possible for GRS codes, i.e., for some non - zero c, Check in whether the number of roots of is equal to in and this typically includes an exhaustive substitution of all elements of

[0247] To avoid such exhaustive substitutions after each update at the edges of the decoding tree, a stop condition is introduced, i.e., a condition on the Groener basis so far with the following properties: (1) It never misses the case for some c, ; and (2) It may sometimes pass (with low probability) when for all non - zero c, .

[0248] Case 2 is called a false positive. The only cost of a false positive is an unnecessary exhaustive substitution of the polynomial, i.e., an increase in complexity. Since false positives are rare (details below), the resulting increase in complexity is usually negligible.

[0249] To make the stop condition effective, an additional error is needed in the unreliable coordinates above the minimum configured by part 3 of Theorem 3. This slightly reduces the correction ability of the combined fast Chase / GMD algorithm.

[0250] Let The idea of the stop condition is that when the condition of part 3 of Theorem 3 holds, then, if the edge of the decoding tree corresponds to the correct flip hypothesis, i.e., α r is indeed the error locator with the corresponding error value β r , then Δ1 = 0 must be true in both iterations of Algorithm B. Similarly, if the edge of the decoding tree corresponds to an erasure of a coordinate containing an error, then Δ1 = 0 is true in a single iteration of Algorithm C.

[0251] Therefore, the first criterion for stopping and performing exhaustive substitution is that the above difference is zero. The second condition is to filter out the cases that are also relevant to the method according to the embodiment, where variable erasure is allowed on top of variable flipping. This criterion will be described below without going into more details.

[0252] The stop condition is described as follows:

[0253] 1. On the edge corresponding to adding a flip, i.e., when moving from to , for both the root iteration and the derivative iteration of algorithm B, check whether Δ1 = 0. Alternatively, on the edge corresponding to adding an erasure, i.e., when moving from to , for a single iteration of algorithm C, check whether Δ1 = 0.

[0254] 2. If the check in part 1 passes, then check (which corresponds to the parent node or respectively for the cases in part 1) and its formal derivative α1,..., α in the first case (algorithm B) r-1 or α1,..., α r (algorithm C) have no common roots.

[0255] Efficient evaluation

[0256] Whenever the stop criterion holds, is evaluated. In some cases, can also be evaluated. It is considered that

[0257]

[0258] Note that after computing the Groebner basis of as part of the initial error and erasure decoding, h 01 (X) and h 11 (X) are known, and can be efficiently evaluated as follows:

[0259] 1. After computing h0 and h1 in the initialization step, for all evaluate and store the values of h 01 (β), h 11 (β), h′ 01 (β) and h′ 11 (β).

[0260] 2. Whenever a new When only the low-degree polynomial f 10 (X), f 11 (X) is evaluated, and two additional multiplications are used to calculate as Similarly, whenever σ′ is evaluated, f′ 10 (β), f′ 11 (β) are additionally evaluated, and four additional multiplications are used to calculate σ′(β), and then the estimated value σ′(X) is obtained using the calculated value, the stored value, and the following formula:

[0261]

[0262] Example of the overall decoding algorithm on the tree

[0263] This section presents a possible high-level example of the entire decoding process using the new combined fast Chase / GMD algorithm. It should be borne in mind that different examples can also be used. For example, instead of using the BM algorithm for error and erasure decoding in the first stage, the Groebner basis outlined above can be found using this algorithm or other algorithms can be used. of

[0264] Figure 1 is a flowchart of the decoding process using the new combined fast Chase / GMD algorithm according to an example. Now referring to the accompanying drawings, the decoding process starts in step 10 by receiving the codeword y via a digital electronic communication channel. For at least one error vector the codeword y = x + e, where F qis a finite field of q elements, where q is a prime power, and for the transmitted codeword, x ∈ C, where C is a possibly shortened generalized Reed - Solomon code having length n <= q - 1 and minimum Hamming distance d >= 2. In step 11, hard - decision (HD) error and erasure decoding is performed on the codeword using a fixed erasure set, and in step 12, it is determined whether the HD error and erasure decoding has failed. When the HD error and erasure decoding fails, the decoding process further includes: in step 13, finding the Groebner basis of the solving module responsible for the fixed erasure set, and in step 14, using channel reliability information to determine the Chase coordinate set and the generalized minimum distance (GMD) coordinate set. In step 15, Chase and GMD decoding trees are constructed on the Chase coordinate set and the GMD coordinate set, and in step 16, the polynomials of the Groebner basis are used as the basis for representing the updated coefficient polynomials on the Chase and GMD decoding trees to first depth - traverse the decoding tree. In step 17, the polynomials on the decoding tree are updated using the root and derivative steps that flip edges or the root step that erases edges, and in step 18, the error locations are calculated by performing polynomial evaluation on the candidate polynomials from the decoding tree, and the error values are calculated. Performing polynomial evaluation on the candidate polynomials includes: verifying that a valid pair of EEP and ELP has been found by checking that the number of roots of the ELP is equal to its degree minus the number of variable erasures and that the inverses of all roots are outside the erasure set, and calculating the error values includes: using the EEP and ELP to find the error values on the non - erased coordinates using the Forney algorithm and checking that the estimated error values on the non - erased coordinates are not zero. In step 20, the received codeword is corrected according to the calculated error locations and the calculated error values, and the corrected received codeword is saved to the decoder output list.

[0265] An example of the decoding process using the new combined fast Chase / GMD algorithm according to an embodiment is as follows.

[0266] 1. For example, by taking the following steps, perform error and erasure decoding with fixed erasures:

[0267] a. Perform algorithm A

[0268] b. Check whether v(X) has deg(v(X)) roots on the non - erased coordinates (i.e., on ), and where L is the estimated order, and is the correction order not responsible for erasures.

[0269] c. If the condition in step b holds, then continue with the following steps:

[0270] i. Define σ1 := v

[0271] ii. Calculate and

[0272] iii. The inverse of the roots of the error locations outside A′1 from the σ1 point. Use the Forney formula to find the error values of all these error locations and the error values of the erasure coordinates in A′1.

[0273] iv. Using the locations and values from the previous steps, correct all errors.

[0274] v. Output the decoded codeword and announce success.

[0275] 2. If the condition in step 1b fails, then start fast combined Chase / GMD decoding:

[0276] a. Find the Groebner basis {h0, h1} from as described in the initial step above.

[0277] b. Construct the decoding tree T. Assign memory for r max +1 Groebner bases, one for each depth. Store the Groebner basis {(1, 0), (0, 1)} of in the memory at depth 0.

[0278] c. First traverse the tree depth

[0279] i. When moving on the edge corresponding to moving from to such as the edge corresponding to an additional variable erasure or an additional Chase flip, use algorithm C to update the Groebner basis read from the memory at the previous depth. Store the resulting Groebner basis in the memory at the current depth, thus overwriting the previously stored value (if any).

[0280] ii. When moving on the edge corresponding to moving from r - 1 to r, use algorithm B to update the Groebner basis read from the memory at the previous depth. Store the resulting Groebner basis in the memory at the current depth, thus overwriting the previously stored value (if any).

[0281] iii. If, during the update, the stop condition holds, then:

[0282] 1. Write {f0 = (f 00 , f 01 ), f1 = (f 10 , f 11 )} of the original Groebner basis on the parent node, check whether it holds for some c ≠ 0, where and is as follows:

[0283] a. Using the fast evaluation method defined above, find all roots of on the inverse of the elements in. Verify that the number of these roots is exactly If not, then declare the stop condition as a false positive, and return to the depth - first search on the tree.

[0284] b. By using the Forney - style for calculate and find the error values only on the unerased coordinates (i.e., the coordinates with locators in ). If at least one of the error values results in 0, then declare the stop condition as a false positive, and return to the depth - first search on the tree.

[0285] 2. Use the Forney - style to calculate all error values for the erased coordinates (these values can be zero or non - zero).

[0286] 3. Correct the received codeword according to the calculated error positions and error values, and save it to the output list of the decoder. Return to the tree search to find potential additional decoded codewords in the output list of the decoder. Note that in some embodiments, the maximum list size can be bounded by some integer parameter L ≥ 1. In such embodiments, once the list reaches the size of L, the search stops.

[0287] Figure 3 shows an example of a variant of the decoding tree. Here, I Chase has 3 coordinates, and the left - hand triple for each vertex in the figure represents "not flip / flip" (0 / 1 respectively) for each coordinate in I Chase . Additionally, I GMD has 2 coordinates, and the right - hand pair for each vertex in the figure represents "not erase / erase" (0 / 1 respectively) for each coordinate in I GMD . The thin black edges correspond to Chase flips, while the thick gray edges correspond to GMD erasures. In this example, since there are only 2 GMD coordinates, constructing the decoding tree simplifies to first constructing a "tree with only black edges" where there are only Chase flips without any erasures, and then for each vertex, adding two consecutive GMD erasure edges, ending at vertices with the same flip value on I Chase but erasing the two GMD coordinates.

[0288] Final note: Some additional embodiments

[0289] In an embodiment, it is not mandatory to limit Chase decoding to 2 error hypotheses per coordinate. In general, any number of hypotheses between 2 and q can be selected per coordinate, and this represents a trade-off between complexity and the probability of decoding success.

[0290] In addition, in an embodiment, for variable erasure (GMD) and Chase decoding, it is not mandatory to use two disjoint sets. For example, one can have coordinates that attempt to try both various error values and erasures. For example, in most of the above, two error values, such as 0 and β, were considered for a coordinate in Chase decoding, where β is the second most likely error for the coordinate. However, it is also possible to add an "erased" value for that coordinate, i.e., the probabilities are now {0, β, erased}. If the value changes from 0, β at some edge of the decoding tree, then algorithm B is used for the update, and if the value changes from 0 to erased, then algorithm C is used for the update.

[0291] System implementation

[0292] It should be understood that embodiments of the present disclosure can be implemented using various forms of hardware, software, firmware, special processes, or combinations thereof. In one embodiment, the present disclosure can be implemented using hardware such as an application specific integrated circuit (ASIC) or a field programmable gate array (FPGA). In another embodiment, the present disclosure can be implemented using software such as an application program (e.g., instructions) tangibly embodied (e.g., stored) on a computer readable program storage device (e.g., a computer readable storage medium). The application program can be uploaded to and executed by a machine (e.g., a processor, a controller, etc.) including any suitable architecture.

[0293] Figure 2 is a block diagram of a host storage system 20 according to an embodiment, the host storage system 20 including an error correction circuit that performs fast combined Chase and GMD decoding of a generalized Reed - Solomon code.

[0294] The host storage system 20 includes a host 100 and a storage device 200. Additionally, the storage device 200 includes a storage controller 210 and an NVM 220. According to an embodiment, the host 100 includes a host controller 110 and a host memory 120. The host memory 120 can be used as a buffer memory that temporarily stores data to be sent to or received from the storage device 200.

[0295] The storage device 200 includes a storage medium that stores data in response to requests from the host 100. For example, the storage device 200 includes at least one of an SSD, an embedded memory, and / or a removable external memory. When the storage device 200 is an SSD, the storage device 200 complies with the NVMe standard. When the storage device 200 is an embedded memory or an external memory, the storage device 200 complies with the UFS standard or the eMMC standard. Each of the host 100 and the storage device 200 generates and transmits a packet according to the adopted standard protocol.

[0296] When the NVM 220 of the storage device 200 includes a flash memory, the flash memory may include a 2D NAND memory array or a 3D (or vertical) NAND (VNAND) memory array. For example, the storage device 200 may include various other types of NVM. For example, the storage device 200 includes at least one of a magnetic RAM (MRAM), a spin transfer torque MRAM, a conductive bridge RAM (CBRAM), a ferroelectric RAM (FRAM), a PRAM, an RRAM, or various other types of memories.

[0297] According to an embodiment, the host controller 110 and the host memory 120 are implemented as separate semiconductor chips. Alternatively, in some embodiments, the host controller 110 and the host memory 120 are integrated in the same semiconductor chip. For example, the host controller 110 is one of a plurality of modules included in an application processor (AP). The AP may be implemented as a system on a chip (SoC). Additionally, the host memory 120 may be an embedded memory included in the AP or an NVM or a memory module located outside the AP.

[0298] The host controller 110 manages operations of storing data (such as write data) in the buffer of the host memory 120 in the NVM 220 or storing data (such as read data) in the buffer from the NVM 220.

[0299] The storage controller 210 includes a host interface 211, a memory interface 212, and a CPU 213. Additionally, the storage controller 210 further includes a flash translation layer (FTL) 214, a packet manager 215, a buffer memory 216, an error correction code (ECC) engine 217, and an advanced encryption standard (AES) engine 218. The storage controller 210 also includes a working memory for loading the FTL 214. The CPU 213 executes the FTL 214 to control data write and read operations on the NVM 220.

[0300] The host interface 211 sends packets to the host 100 and receives packets from the host 100. Packets sent from the host 100 to the host interface 211 include commands or data to be written to the NVM 220. Packets sent from the host interface 211 to the host 100 include responses to commands or data read from the NVM 220. The memory interface 212 sends data to be written to the NVM 220 to the NVM 220 or receives data read from the NVM 220. The memory interface 212 complies with standard protocols such as Toggle or Open NAND Flash Interface (ONFI).

[0301] The FTL 214 performs various functions such as address mapping operations, wear leveling operations, and garbage collection operations. The address mapping operation converts the logical address received from the host 100 into a physical address for actually storing data in the NVM 220. The wear leveling operation prevents excessive degradation of a specific block by allowing uniform use of the blocks of the NVM 220. For example, the wear leveling operation can be implemented using firmware techniques that balance the erase counts of physical blocks. The garbage collection operation ensures the available capacity in the NVM 220 by erasing an existing block after copying the valid data of the existing block to a new block.

[0302] The packet manager 215 generates packets according to a protocol that agrees with the interface of the host 100 or parses various types of information from the packets received from the host 100. In addition, the buffer memory 216 temporarily stores data to be written to the NVM 220 or data to be read from the NVM 220. Although the buffer memory 216 can be included in the storage controller 210, the buffer memory 216 can be located outside the storage controller 210.

[0303] The ECC engine 217 performs error detection and correction operations on the read data read from the NVM 220. More specifically, the ECC engine 217 generates parity bits for the write data to be written to the NVM 220, and the generated parity bits are stored in the NVM 220 together with the write data. During the reading of data from the NVM 220, the ECC engine 217 corrects the errors in the read data by using the parity bits read from the NVM 220 together with the read data, and outputs the error-corrected read data. According to the embodiments described above, the ECC engine 217 uses fast combined chase and GMD decoding of the generalized Reed-Solomon code to perform error correction, and can be implemented as an application-specific integrated circuit.

[0304] The AES engine 218 performs at least one of an encryption operation and a decryption operation on the data input to the storage controller 210 by using a symmetric key algorithm.

[0305] It should also be understood that since some of the component systems and method steps depicted in the drawings can be implemented using software, the actual connections between system components (or process steps) can vary depending on the programming of the present invention. Given the teachings of the present invention provided herein, those of ordinary skill in the relevant art will be able to envision these implementations or configurations of the present invention, as well as similar implementations or configurations.

[0306] Although the present invention has been described in detail with reference to exemplary embodiments, those skilled in the art will understand that various modifications and substitutions can be made to the present invention without departing from the spirit and scope of the present invention as set forth in the appended claims.

Claims

1. A method for soft decoding of a generalized Reed-Solomon (RS) error correction code, comprising: A codeword y is received via a digital electronic communication channel, where for at least one error vector y=x+e,where F q is a finite field of q elements, where q is a prime power, and for the transmitted codeword, x∈C, where C is a generalized Reed-Solomon code with length n<=q-1 configured to be shortened and a minimum Hamming distance d≥2; performing hard decision (HD) error and erasure decoding on the codeword using a fixed erasure set; Verifying that the HD error and erasure decoding has failed; Find the Groebner basis of the solution module responsible for fixing the erasure set; Using channel reliability information to determine the Chase coordinate set and the generalized minimum distance (GMD) coordinate set; Constructing Chase and GMD decoding trees on the Chase coordinate set and the GMD coordinate set; First, traverse the decoding tree depth using the polynomial of the Groebner basis as a basis for representing the updated coefficient polynomial on the Chase and GMD decoding trees; updating a polynomial on the decoding tree using a root step and a derivative step that flips an edge or a root step that erases an edge; calculating error locations by performing polynomial evaluation on candidate polynomials from the decoding tree, and calculating error values; as well as The received codeword is corrected according to the calculated error position and the calculated error value, and the corrected received codeword is saved to a decoder output list.

2. The method of claim 1 , wherein performing hard decision (HD) error and erasure decoding using a fixed erasure set comprises: Compute the estimated error position polynomial (ELP) v(X) excluding erasures by performing the error and erasure Berlekamp-Massey algorithm, where X is an uncertain variable; Verify that v(X) is not a fixed erased coordinate The inverse of deg(v(X)) with roots on And A′1 is a fixed erasure set, and Where L is the estimation order, is the number of fixed erases, and is the correction order to exclude erasure; Define σ1: = v; Calculation errors and fixed erasures in is the erasure locator polynomial, as well as the computational error and fixed erasure error evaluation polynomial (EEP) in is the adjoint polynomial associated with y and the fixed erasure set; Using the roots of σ1, by using the Forney formula, find the error value of the error position outside A′1; and using the inverse of the elements of A′1, by using the Forney formula, find the error value of the error position in A′1; using the found error value to correct all errors in the decoded codeword; as well as Output the corrected decoded codeword.

3. The method of claim 2, wherein verifying that the HD error and erasure decoding has failed comprises: Verify that v(X) does not have a root deg(v(X)) in the inverse of the unerased coordinates, or verify that 4. The method according to claim 1, wherein constructing a decoding tree comprises: For r max +1Groebner basis assigned memory, one memory per depth, where r max is the maximum design depth, and the coefficient polynomial for the case of only fixed erasures The Groebner basis {(1,0),(0,1)} of the module is stored in a memory of depth 0, where the decoding tree is included in where is the root of the all-zero vector, at depth r for all r∈{1,…,r max As The vertices of the vector of length η and weight r in and the edges as pairs (β′,β), where η is the number of Chase flip coordinates plus the number of variable GMD erase coordinates, where for each vertex at depth r at coordinates i1,…,i r Every vertex with a non-zero entry at Single vertex β′=(β′1,…,β′ η ) is selected at depth r-1, the single vertex β′ in addition to one additional flip or erase coordinate i in the edge l , all coordinates other than l∈{1,…,r} are equal to β, and for the one additional flip or erase coordinate, 5. The method of claim 1, wherein first traversing the decoding tree depth comprises: The Groebner basis read from the memory of the previous depth is updated when moving on an edge corresponding to an additional variable erase or an additional Chase flip, wherein the updated Groebner basis is stored in the memory.

6. The method of claim 5, wherein updating the Groebner basis read from the memory at the previous depth comprises: A Koetter iteration that deletes the additional coordinate is used when moving on an edge corresponding to an additional variable erase, or a pair of Koetter iterations is used when moving on an edge corresponding to a Chase flip on the additional coordinate.

7. The method according to claim 1, further comprising: Verifying that a stopping condition holds during the updating of the Groebner basis; output that the stop condition is a false positive, and When its inverse is not on fixed erase or variable erase The number of roots is not , returning to a depth-first search of the tree, where is the set of estimated errors and variable erasure ELPs, and is the number of mutable erasures.

8. The method according to claim 1, further comprising: Verifying that a stopping condition holds during the updating of the Groebner basis; output that the stop condition is a false positive, and When the unerased coordinates When at least one of the error values ​​found at the coordinates with the locator in is equal to 0, return to the depth-first search on the tree, wherein A'1 is the fixed erasure set, and A'2 is the current assumption of the variable erasure.

9. The method of claim 1 , wherein calculating the error location by polynomial evaluation of candidate polynomials from the decoding tree, and calculating the error value by using the Forney formula comprises: Verify that a valid pair of EEP and ELP has been found by checking that the number of ELP roots is equal to its degree minus the number of variable erasures and that the inverses of all roots are outside the fixed erasure set, find the error value on the unerased coordinates using the Forney algorithm using the EEP and ELP, and check that the estimated error value on the unerased coordinates is not zero; Computational estimation errors and erasures in is the set of estimated errors and variable erasure ELPs, and is a fixed erase ELP, and by using the Forney formula only The error value was found at the coordinates with the locator in , where A′1 is the fixed erasure set, and A′2 is the current assumption of variable erasure, and By using the Forney formula, all Erase coordinate error values, where is the number of mutable erasures.

10. The method according to claim 9, wherein finding The inverse of the elements in All roots include: For all coordinates Evaluate and store h 01 (β), h 11 (β), h′ 01 (β) and h′ 11 (β) value, where h 01 and h 11 is a quadratic polynomial in the Groebner basis of the solver module for the error and fixed erasure key equations; For the new estimated error set calculate where f 10 and f 11 is a single polynomial of the current Groebner basis from the coefficient polynomial solver; and By evaluating the derivative f′ 10 (β),f′ 11 (β) to calculate the derivative of ELPσ′(β), and use 4 additional multiplications to calculate σ′(β), and use the calculated value and the stored value and the following formula to find the estimated value σ′(X):

11. A computer-readable storage medium having instructions stored thereon, which, when executed by a processor, cause the processor to perform method steps for soft decoding of a generalized Reed-Solomon (RS) error correction code, the method steps comprising: A codeword y is received via a digital electronic communication channel, where for at least one error vector y=x+e,where F q is a finite field of q elements, where q is a prime power, and for the transmitted codeword, x∈C, where C is a generalized Reed-Solomon code with length n<=q-1 configured to be shortened and a minimum Hamming distance d≥2; performing hard decision (HD) error and erasure decoding on the codeword using a fixed erasure set; Verifying that the HD error and erasure decoding has failed; Find the Groebner basis of the solution module responsible for fixing the erasure set; Using channel reliability information to determine the Chase coordinate set and the generalized minimum distance (GMD) coordinate set; Constructing Chase and GMD decoding trees on the Chase coordinate set and the GMD coordinate set; First, traverse the decoding tree depth using the polynomial of the Groebner basis as a basis for representing the updated coefficient polynomial on the Chase and GMD decoding trees; updating a polynomial on the decoding tree using a root step and a derivative step that flips an edge or a root step that erases an edge; calculating error locations by performing polynomial evaluation on candidate polynomials from the decoding tree, and calculating error values; as well as The received codeword is corrected according to the calculated error position and the calculated error value, and the corrected received codeword is saved to a decoder output list.

12. The computer readable storage medium of claim 11, wherein performing hard decision (HD) error and erasure decoding using a fixed erasure set comprises: Compute the estimated error position polynomial (ELP) v(X) excluding erasures by performing the error and erasure Berlekamp-Massey algorithm, where X is an uncertain variable; Verify that v(X) is not a fixed erased coordinate The inverse of deg(v(X)) with roots on And A′1 is a fixed erasure set, and Where L is the estimation order, is the number of fixed erases, and is the correction order to exclude erasure; Define σ1: = v; Calculation errors and fixed erasures in is the erasure locator polynomial, as well as the computational error and fixed erasure error evaluation polynomial (EEP) in is the adjoint polynomial associated with y and the fixed erasure set; Using the roots of σ1, by using the Forney formula, find the error value of the error position outside A′1; and using the inverse of the elements of A′1, by using the Forney formula, find the error value of the error position in A′1; using the found error value to correct all errors in the decoded codeword; as well as Output the corrected decoded codeword.

13. The computer-readable storage medium of claim 12, wherein verifying that the HD error and erasure decoding has failed comprises: Verify that v(X) does not have a root deg(v(X)) in the inverse of the unerased coordinates, or verify that 14. The computer-readable storage medium of claim 11, wherein constructing a decoding tree comprises: For r max +1Groebner basis assigned memory, one memory per depth, where r max is the maximum design depth, and the coefficient polynomial for the case of only fixed erasures The Groebner basis {(1,0),(0,1)} of the module is stored in a memory of depth 0, where the decoding tree is included in where is the root of the all-zero vector, at depth r for all r∈{1,…,r max As The vertices of the vector of length η and weight r in and the edges as pairs (β′,β), where η is the number of Chase flip coordinates plus the number of variable GMD erase coordinates, where for each vertex at depth r at coordinates i1,…,i r Every vertex with a non-zero entry at Single vertex β′=(β′1,…,β′ η ) is selected at depth r-1, the single vertex β′ in addition to one additional flip or erase coordinate i in the edge l , all coordinates other than l∈{1,…,r} are equal to β, and for the one additional flip or erase coordinate, 15. The computer-readable storage medium of claim 11, wherein first traversing the decoding tree depth comprises: The Groebner basis read from the memory of the previous depth is updated when moving on an edge corresponding to an additional variable erase or an additional Chase flip, wherein the updated Groebner basis is stored in the memory.

16. The computer-readable storage medium of claim 15, wherein updating a Groebner basis read from a memory at a previous depth comprises: A Koetter iteration that deletes the additional coordinate is used when moving on an edge corresponding to an additional variable erase, or a pair of Koetter iterations is used when moving on an edge corresponding to a Chase flip on the additional coordinate.

17. The computer-readable storage medium of claim 11, wherein the method steps further comprise: Verifying that a stopping condition holds during the updating of the Groebner basis; output that the stop condition is a false positive, and When its inverse is not on fixed erase or variable erase The number of roots is not , returning to a depth-first search of the tree, where is the set of estimated errors and variable erasure ELPs, and is the number of mutable erasures.

18. The computer-readable storage medium of claim 11, wherein the method steps further comprise: Verifying that a stopping condition holds during the updating of the Groebner basis; output that the stop condition is a false positive, and When the unerased coordinates When at least one of the error values ​​found at the coordinates with the locator in is equal to 0, return to the depth-first search on the tree, wherein A'1 is the fixed erasure set, and A'2 is the current assumption of the variable erasure.

19. The computer-readable storage medium of claim 11, wherein calculating an error location by performing polynomial evaluation on a candidate polynomial from the decoding tree, and calculating an error value by using a Forney formula comprises: Verify that a valid pair of EEP and ELP has been found by checking that the number of ELP roots is equal to its degree minus the number of variable erasures and that the inverses of all roots are outside the fixed erasure set, find the error value on the unerased coordinates using the Forney algorithm using the EEP and ELP, and check that the estimated error value on the unerased coordinates is not zero; Computational estimation errors and erasures in is the set of estimated errors and variable erasure ELPs, and is a fixed erase ELP, and by using the Forney formula only The error value was found at the coordinates with the locator in , where A′1 is the fixed erasure set, and A′2 is the current assumption of variable erasure, and By using the Forney formula, all Erase coordinate error values, where is the number of mutable erasures.

20. The computer-readable storage medium of claim 19, wherein the The inverse of the elements in All roots include: For all coordinates Evaluate and store h 01 (β), h 11 (β), h′ 01 (β) and h′ 11 (β) value, where h 01 and h 11 is a quadratic polynomial in the Groebner basis of the solver module for the error and fixed erasure key equations; For the new estimated error set calculate where f 10 and f 11 is a single polynomial of the current Groebner basis from the coefficient polynomial solver; as well as The derivative of ELPσ′(β) is calculated by evaluating the derivatives f1′0(β), f1′1(β), and σ′(β) is calculated using 4 additional multiplications. The estimated value σ′(X) is found using the calculated and stored values ​​and the following formula:

Images