WO2019227456A1 - Evenodd code constructing method - Google Patents

Abstract

The present invention is applicable to the field of improvements of codec algorithm technology, and provides an EVENODD code constructing method. An EVENODD code is a binary array code used for correcting a fault condition of two disks in RAID-6, and has asymptotically optimized coding and decoding complexities. However, the updating complexity of the EVENODD code is sub-optimal. Proposed is a new binary MDS array code construction, i.e. an EVENODD+ code, so that the encoding, decoding and updating complexities of the EVENODD+ code are lower than those of the EVENODD code. Furthermore, the updating complexity of the EVENODD+ code can reach asymptotic optimization.

Description

Method for constructing EVENODD code Technical field

The invention belongs to the technical improvement field of encoding and decoding algorithms, and particularly relates to a method for constructing an EVENODD code.

Background technique

Array codes have been widely used in storage systems, such as using redundant arrays of inexpensive disks (RAID) ^[1] to improve data reliability. Among them, the RAID-6 array code uses two independent disks to store parity codes, and can tolerate any two disk failures.

Assume a binary array code of size r × n, where each entry in the array stores one bit of data. Among the n columns of the array code, the first k columns are called information columns, corresponding to k information bits, and the remaining n-k columns are called check columns, corresponding to n-k check bits. The array code is actually the maximum distance separable code (MDS). That is, the original information bits can be decoded by taking any k columns; that is, it can accommodate any n-k columns to fail. (Note that the MDS attribute here is measured by column weights, not Hamming weights) where the number of rows r depends on the structure of the array code. In addition to MDS attributes, some other important performance indicators, such as encoding complexity (i.e., the number of XORs required to construct the check bit), decoding complexity (i.e., the number of XORs required to recover invalid information bits from the surviving encoded bits) And update complexity (ie, the average number of check bit updates affected by a single change in information bits). Among them, update complexity affects the performance of lowercase updates, and is a key indicator of storage applications (such as databases) with intensive update workloads. Therefore, it is of great significance to design an array code with as low update complexity as possible.

There are many methods for constructing binary MDS array codes in the previous literature. EVENODD code [2] and RDP code [3] are representative of array codes that can correct the failure of two disks. Other binary MDS array codes are X-code [4], Liberation code [5], H-code [6], C-code [7], HV code [8], and Short code [9]. The EVENODD code is designed in [10] to have a good algebraic structure that can expand more check columns. Therefore, in this study, we focused on extending the EVENODD code to improve its performance.

Summary of the Invention

The purpose of the present invention is to provide a method for constructing an EVENODD code, which aims to solve the technical problems of complicated encoding and decoding and high update complexity.

The present invention is implemented in this way. A method for constructing an EVENODD code includes the following steps:

S1. In the EVENODD + code of (m-1) × (k + 2), the i-th information bit of the j-th information column is b _{i, j} , where i = 0,1, ..., m-2, j = 0,1, ..., k-1. Let b _{m-1, j} = 0, where j = 0,1, ..., k-1, the k-th column or the first check column is calculated by the following formula:

Take 0≤i≤m-2, the k + 1th column, that is, the second check column is calculated as

The matrix of the above equation is expressed as EVENODD + (m, k); m≥k; m represents the number of stored bits in each column minus one; k represents the number of information columns; j represents the number of columns; i represents the number of rows.

A further technical solution of the present invention is: the EVENODD + (m, k) has two check columns, and j = 0,1, ..., k -1, the first j column is called the information column, and the information bits are stored. Let j = k, k + 1, and the last j column is called the check column, and the check bits are stored.

A further technical solution of the present invention is: characterized in that the EVENODD + (m, k) is an MDS array code when m is an odd integer and all factors except m are mutually prime with k.

A further technical solution of the present invention is that the encoding, decoding, and updating complexity of the EVENODD + (m, k) code are respectively

The beneficial effects of the present invention are: the new EVENODD + code structure effectively reduces the update complexity and the difficulty of encoding and decoding; the expansion structure that can accommodate more check columns and the design of an effective repair algorithm for column failure situations.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a flowchart of a method for constructing an EVENODD code according to an embodiment of the present invention.

Detailed ways

As shown in FIG. 1, the method for constructing an EVENODD code provided by the present invention includes the following steps:

S1. In the EVENODD + code of (m-1) × (k + 2), the i-th information bit of the j-th information column is b _{i, j} , where i = 0,1, ..., m-2, j = 0,1, ..., k-1. Let b _{m-1, j} = 0, where j = 0,1, ..., k-1, the k-th column or the first check column is calculated by the following formula:

Taking 0≤i≤m-2, the k + 1th column, that is, the second check column, is calculated by the following formula:

The matrix of the above equation is expressed as EVENODD + (m, k); m≥k; m represents the number of stored bits in each column minus one; k represents the number of information columns; j represents the number of columns; i represents the number of rows.

The EVENODD code stores a original information bit and a check bit by constructing a (p-1) × (k + 2) matrix, where p is prime and p≥k. The first k columns of the array code are information columns, and the last two columns are check columns 1. Let i = 0,1, ..., p-2, j = 0,1, ..., k + 1, b _{i, j be} represented as the i-th bit of the j-th information column in the matrix. The check bit b _i, k in column _k is calculated by the following formula:

The check bit b _i, k + 1 in column _{k + 1} is calculated by the following formula:

When j = 0,1, ..., k-1, b _{p-1, j} = 0, meanwhile

Note: The above subscripts are in units of modulo p. The calculated complexity of the EVENODD code is (p-1) (2k-1) -1, which is the optimal case [2]. However, the update complexity of the EVENODD code is

This is a suboptimal situation. (Note: The optimal update complexity of a binary MDS array code with 2 check bits is

).

Now, we have designed the EVENODD + code, which is an extended structure of the EVENODD code. The EVENODD + code belongs to the MDS code and has the same error tolerance of 2 as the EVENODD code. In special cases, it can be reduced to EVENODD code. Experiments show that EVENODD + codes have lower encoding, decoding, and update complexity than EVENODD codes, and the update complexity of EVENODD + codes is gradually optimized. The design principle of the EVENODD + code is as follows. In the original EVENODD code, b _{p-1, k + 1} is added to each check bit in the k + 1th column, so that the update complexity is sub-optimized. Therefore, the main idea of the EVENODD + code is to retain the MDS attribute, but avoid adding a special bit to each check bit in the k + 1th column. This helps the EVENODD + code to reduce update complexity.

Note that the definition of the EVENODD code here refers to the simplified version of the original EVENODD code in [2]. We obtain this code by deleting p-k information columns from the original (p-1) × (p + 2) EVENODD code. . The original EVENODD code can be regarded as a special case of the simplified EVENODD code when k = p.

Form I: EVENODD + (9,3) (Note: b _8,4 = b _7,1 + b _6,2 )

b 0,0	b 0,1	b 0, 2	b 0,0 + b 0,1 + b 0,2	b 0,0 + b 7,2 + b 8,4
b 1,0	b 1,1	b 1, 2	b 1,0 + b 1,1 + b 1,2	b 1,0 + b 0,1 + b 8,4
b 2,0	b 2,1	b 2, 2	b 2,0 + b 2,1 + b 2,2	b 2,0 + b 1,1 + b 0,2
b 3,0	b 3,1	b 3, 2	b 3,0 + b 3,1 + b 3,2	b 3,0 + b 2,1 + b 1,2
b 4,0	b 4,1	b 4, 2	b 4,0 + b 4,1 + b 4,2	b 4,0 + b 3,1 + b 2,2
b 5,0	b 5,1	b 5, 2	b 5,0 + b 5,1 + b 5,2	b 5,0 + b 4,1 + b 3,2
b 6,0	b 6,1	b 6, 2	b 6,0 + b 6,1 + b 6,2	b 6,0 + b 5,1 + b 4,2
b 7,0	b 7,1	b 7, 2	b 7,0 + b 7,1 + b 7,2	b 7,0 + b 6,1 + b 5,2

New structure of EVENODD +

We now propose the EVENODD + code (with two check columns). Given an odd integer m≥k, next we define an array code of size (m-1) × (k + 2). Let j = 0,1, ..., k-1, the first j columns are called information columns, and store the information bits, namely b _{0, j} , b _{1, j} , ..., b _{m-2, j} . Let j = k, k + 1, and the next j columns are called check columns, which store check bits, that is, b _{0, j} , b _{1, j} , ..., b _{m-2, j} .

Note: Unless otherwise specified, the modulo m is taken as the unit throughout the paper.

An information array b _{i, j of} size (m-1) × k is given, where i = 0,1, ..., m-2 and j = 0,1, ..., k-1. We assume b _{m-1, j} = 0, and let j = 0,1, ..., k-1. Column k is calculated by the following formula:

Take 0≤i≤m-2 (1)

Column k + 1 is calculated by the following formula:

Note:

We denote the matrix defined in the above equation as EVENODD + (m, k). There are two main differences between the EVENODD + (m, k) code and the original EVENODD code. First, the number of bits in each column in the EVENODD + (m, k) code is more flexible, that is, m is an odd integer that satisfies Theorem 1 (see Section 3), and p is a prime number in EVENODD. Second, the check bits on the k + 1th column in the two codes are different. In EVENODD + (m, k), we only add b _{m-1, k + 1} to the first on the k + 1th column

Above parity bits, and in the EVENODD code, b _{p-1, k + 1} will be added to all parity bits on column k + 1. The above two differences enable the EVENODD + (m, k) code to achieve progressively optimal update complexity and lower encoding and decoding complexity than the EVENODD code. When m = p = k, EVENODD + (m, k) code can be simplified to EVENODD code. Table I shows an example of the EVENODD + (9,3) code, where b _8,4 is added to the first two check bits in the fourth column.

MDS attributes

The MDS attribute of EVENODD + (m, k) code in Theorem 1 will be proved, and a decoding method that can correct the failure of any two columns is also given.

Theorem 1. The EVENODD + (m, k) code is an MDS array code if and only if m is an odd integer (all divisors except 1 are greater than k-1).

Proof: "When". We notice that when m is an odd integer (all divisors except 1 are greater than k-1), the EVENODD + (m, k) code is an MDS array code. In other words, k (m-1) information bits can be reconstructed after any two columns fail. Reconstruction can be divided into 3 cases: (i) decoding from all information columns (ii) decoding from any k-1 information columns and a check column (iii) from any k-2 information columns and two Decode in parity column.

First discussing (i), we can directly obtain k (m-1) information bits from k information columns. The second discussion (ii), first we assume that the f and k + 1 columns are invalid, where 0≤f≤k-1. We can recover the information bits of column f by the following formula (1):

b _{i, k} + (b _{i, 0} + b _{i, 1} + ... + b _{i, f-1} + b _{i, f + 1} + ... + b _{i, k-1} ) = b _{i, f} takes i = 0 , 1, ..., m-2. Then, we assume that the f-th and k-th columns fail, where 0≤f≤k-1.

, B _{if, f} can be recovered by the following formula:

The first equation above is from formula (2). If f = 0, the other information bits b _{i, 0} can be repaired by the following formula:

The first equation above is from formula (2), taking

In addition, if f≥1, we can set

Then b _{mf-1, f} can be recovered by the following formula:

The first equation above comes from formula (2), and the last equation comes from b _{m-1, f} = 0. Now that b _{mf-1, f} has been calculated, we can fix b _{if, f} as follows:

take

So we can restore the f-th column in the second way.

Finally, discuss (iii). Without loss of generality, we assume that the two failed information columns are f and g, where 0≤f≤g≤k-1. When we want to decode the fth and gth columns, we first obtain b _{m-1, k + 1 by} adding all the check bits in the kth and k + 1th columns. Methods as below:

m-1, k + 1 (5)

In the above equation, (3) comes from (1) and (2); (4) comes from b _{m-1, j} = 0, taking j = 0,1, ..., k-1; (5) comes from { -j, 1-j,…, m-1-j} = {0,1,…, m-1} mod m, when

We let b _{i, k + 1} -b _{m-1, k + 1} and let b ′ _{i, k + 1} = b _{i, k + 1} , and take

Finally, we can get through formula (2):

Take i = 0,1, ..., m-1. Next, we take i = 0,1, ..., m-1, and subtract (k-2) (m-1) of the surviving k-2 information columns from b ′ _{i, k + 1} and b _{i, k} ) Information bits, and then get the following 2m bits:

b _{i, f} + b _{i, g} and b _{g-f + i, f} + b _{i, g} take i = 0,1, ..., m-1 (6)

Before reviewing, b _{m-1, f} = b _{m-1, g} = 0, we can deduce:

Then we calculate b _{2 (gf) + m-1, f} and b _{2 (gf) + m-1, g} as follows:

When i = 0,1, ..., m-1, the information bits b _{i (gf) + m-1, f} and b _{i (gf) + m-1, g} can be iteratively decoded in the following cases:

{m-1 + i (g-f) mod m | 1≤i≤m-1} = {0,…, m-2} (7)

Among them, 1≤g-f≤k-1 and all divisors of m except k are greater than k-1, then we can get gcd (g-f, m) = 1. First we prove that when i ≠ j, (m-1 + i (g-f)) mod m ≠ (m-1 + j (g-f)) mod m. If (m-1 + i (gf)) mod m = (m-1 + j (gf)) mod m when 1≤i≤j≤m-1, then there is an integer l such that (m-1) + j (gf) = lm + m-1 + i (gf)

The above equation can be reduced to:

(j-i) (g-f) = lm

Since gcd (g-f, m) = 1, we get (j-i) | m. However, this is impossible because 1≤i≤j≤m-2. Similarly, we can prove that for 1≤i≤m-1,

m-1 + i (g-f) mod m ≠ m-1

Therefore, equation (7) holds. Therefore, when m is odd (all divisors of m are greater than k-1 except 1), we can decode all information bits for the fth and gth columns.

"If and only if." If the EVENODD + (m, k) code is an MDS code, then we can recover all the information bits from any k columns. Consider that we want to recover the f- and g-th information columns from the other k-2 information columns and 2 check columns. Through the same procedure of (iii) above, if equation (7) holds, we restore all the information bits of the f and g columns of information columns. Since formula (7) holds only when gcd (g-f, m) = 1, all divisors of m except k are greater than k-1. This completes the proof.

We show the reconstruction method of (iii) through the example of m = 9 and k = 3 in Table I. Suppose the f and g information columns are invalid, where 1≤f≤g≤2. We can sum all check bits in columns 3 and 4 to calculate b _8,4 :

After subtracting b _8,4 from b _0,4 and b _1,4 , we can get 18 of the following bits: b _{i, 3} = b _{i, 0} + b _{i, 1} + b _{i, 2} and b ′ _{i, 4} = b _{i, 0} + b _{(i-1) mod 9,1} + b _{(i-2) mod 9,2} , where i = 0,1, ..., 8. Then subtract b _{i, l} from b _{i, 3} and b ′ _{i, 4} , where i = 0,1, ..., 8. When l = {0,1,2} \ {g, f}, 18 following bits are obtained:

b _{i, f} + b _{i, g} and b _{(g-f + i) mod 9, f} + b _{i, g} i = 0,1, ..., 8.

When b _{8, f} = b _{8, g} = 0, we can get b _{(g-f + i) mod 9, f} = b _{(g-f + i) mod 9, f} + b _{8, g} , and b _{(g-f + i) mod 9, g} = b _{(g-f + i) mod 9, f} + (b _{(g-f + i) mod 9, f} + b _{(g-f + i) mod 9, g} ) Other information bits can be recovered iteratively.

We notice the third case proved in Theorem 1. The calculation process of b _{m-1, k + 1} by summing all 2 (m-1) check bits by formula (3) is the key point. According to formula (3), if there is an even number of check bits in the k + 1th column (including b _{m-1, k + 1} ), we can always calculate b _{m-1, k + 1} . This is why we added b _{m-1, k + 1} before the k + 1th column

One of the reasons for the check bit. But in order to ensure that any k-1 information column and k + 1 column can recover all the information bits, the number of check bits in the k + 1 column (including b _{m-1, k + 1} ) should not be less than

Each.

Complexity analysis

The following theorem gives the complexity of encoding, decoding and updating of EVENODD + (m, k) code. Note: We only consider the decoding complexity when 2 data blocks fail.

Theorem 2. The encoding, decoding, and updating complexity of the EVENODD + (m, k) code are

Proof: First, consider the coding complexity. According to formula (1), calculation of the k-th column requires (k-1) (m-1) XOR operations. According to formula (2), calculation of the k + 1th column requires (k-1) (m-1) + k-2 XOR operations. Therefore, the coding complexity is 2km-2m-k.

Then consider the decoding complexity of two data block failures. The decoding process has been given in the proof of Theorem 1. First, we need 2m-3 XOR operations to calculate b _{m-1, k + 1} through formula (5). Then calculate the need by formula (6)

XOR operation. Finally, we need 2m-3 XOR operations to recover the invalid 2 (m-1) information bits. Therefore, the decoding complexity is

Finally, consider update complexity. If an information bit changes, we need to update a parity bit in the kth column and the

Parity bits. Therefore, the update complexity is

The normalized coding complexity is defined as the ratio of the coding complexity to the number of information bits, and the normalized decoding complexity is defined as the ratio of the decoding complexity to the number of information bits. By Theorem 2, we can get the normalized encoding complexity of EVENODD + (m, k) codes as

The normalized encoding complexity of the EVENODD code is

Therefore, when m = p> k, the normalized encoding complexity of the EVENODD + (m, k) code is slightly less than the EVENODD code.

According to Theorem 2, the normalized decoding complexity of the EVENODD + (m, k) code is

The EVENODD code is

Therefore, when m = p> k, the normalized decoding complexity of the EVENODD + (m, k) code is slightly less than the EVENODD code.

According to Theorem 2, the update complexity of the EVENODD + (m, k) code is

If m ＞＞ k, then the update complexity is close to the optimal value

Therefore, when m is much larger than k, the update complexity is gradually optimized. The update complexity of the EVENODD code is

When m = p> k, the update complexity of the EVENODD code is strictly greater than the EVENODD + (m, k) code. Table II gives the update complexity of the EVENODD code and the EVENODD + (m, k) code and the example in [11] (k = 7, m = p (value range: 7-53)). We find that when m> 7, the update complexity of EVENODD + (m, k) codes is lower than that of EVENODD codes, and this advantage becomes more obvious as m increases. Since m = 49 is not a prime number, we have not given the EVENODD code in Table II and the results given in [11].

Table II: EVENODD code, EVENODD + (m, k7) code and the update complexity of the examples in [11]

m	EVENODD	EVENODD + (m, k)	[11] Examples
7	2.7143	2.7143	2.1429
11	2.7714	2.4286	2.0857
13	2.7857	2.3571	2.0714
17	2.8035	2.2689	2.0536
19	2.8095	2.2381	2.0476
twenty three	2.8182	2.1948	2.0390
29	2.8265	2.1531	2.0306
31	2.8229	2.1429	2.0286
37	2.8333	2.1190	2.0238
41	2.8357	2.1071	2.0214
43	2.8367	2.1020	2.0204
47	2.8385	2.0932	2.0186
49	n / a	2.0893	n / a
53	2.8407	2.0824	2.0165

Although the example in [11] has the best update complexity, it does not give a method of how to decode the information bits when two coded columns fail. At the same time, the example in [11] has more check columns. The generalization is not necessarily the MDS code.

We propose the EVENODD + (m, k) code, which is a new structure of the EVENODD code, which has progressively optimal update complexity, and the encoding and decoding complexity is also slightly lower than the EVENODD code. In the direction of reducing complexity, our main The idea is to add b _{m-1, k + 1} to the front only in the second check column

In the traditional EVENODD code, b _{p-1, k + 1 is} added to all the check bits of the second check column. So far, we will also study the capacity to accommodate more check columns. The design of extended construction and effective repair algorithm for column failure.

The above description is only the preferred embodiments of the present invention and is not intended to limit the present invention. Any modification, equivalent replacement, and improvement made within the spirit and principle of the present invention shall be included in the protection of the present invention. Within range.

Claims (4)

1. A method for constructing an EVENODD + code, wherein the method for constructing the EVENODD + code includes the following steps:

   S1. In the EVENODD + code of (m-1) × (k + 2), the i-th information bit of the j-th information column is b _{i, j} , where i = 0,1, ..., m-2, j = 0,1, ..., k-1. Let b _{m; 1, j} = 0, where j = 0,1, ..., k-1, and the k-th column or the first check column is calculated as:

   

   Taking 0≤i≤m-2, the k + 1th column, that is, the second check column, is calculated by the following formula:

   

   The matrix of the above equation is expressed as EVENODD + (m, k); m≥k; m represents the number of stored bits in each column minus one; k represents the number of information columns; j represents the number of columns; i represents the number of rows.
2. The method for constructing an EVENODD + code according to claim 1, characterized in that the EVENODD + (m, k) has two check columns, and is commanded in an array code of (m-1) × (k + 2) j = 0,1, ..., k-1, the first j columns are called information columns, and the information bits are stored. Let j = k, k + 1, and the last j columns are called check columns, and the check bits are stored.
3. The method for constructing an EVENODD + code according to claim 2, wherein the EVENODD + (m, k) is an MDS array code when m is an odd integer and all factors except m are mutually prime with k. .
4. The method for constructing an EVENODD + code according to claim 3, wherein the complexity of encoding, decoding and updating of the EVENODD + (m, k) code is 2km-2m-k,

   

Images