A method and system for generating a check matrix for a correction-one-check-two-correction adjacent code

Abstract

The present application discloses a method and system for generating a check matrix for a one-correction, two-check-correction adjacent code, the method comprising: obtaining an initial check bit number based on the number of input data bits; constructing an odd-weight vector pool based on column vector weights and performing a variable initialization process; calculating a layer depth based on the odd-weight vector pool and a heuristic search; obtaining a feasible vector sequence from the odd-weight vector pool to the layer depth through a Monte Carlo random method in parallel search; constructing a target check matrix by using A* search in the feasible vector sequence; judging whether the target check matrix has been constructed; and performing even-weight vector replacement optimization on the target check matrix; the method can generate a corresponding check matrix, and combined with the Monte Carlo random method and the A* heuristic search, achieves a balanced optimization between the number of check bits and the check matrix row weights, substantially reducing hardware overhead and required bit width; and substantially reducing encoding and decoding delays and delay differences between different encoding and decoding paths.

Description

Technical Field

[0001] The present application relates to the technical field of memory reinforcement, and in particular to a method and system for generating a check matrix for a one-correction, two-check, adjacent code. Background Art

[0002] The reliability of on-chip memory is crucial to microprocessor design. Multiple cell upsets (MCUs) can cause multiple bit upsets in memory cells, often physically adjacent. Error correction codes (ECCs) are commonly used to mitigate the impact of these soft errors on memory. While many ECC codes with strong error correction capabilities exist, such as Reed-Solomon (RS) codes, Bose-Chaudhuri-Hocquenghem (BCH) codes, and Euclidean Geometry (EG) codes, which can correct multiple bit errors, suffer from higher latency, higher power consumption, and higher redundancy compared to single-error-detection-double-adjacent-error-correction (SEC-DED-DAEC). Single Error Correction-Double Error Detection-Double Adjacent Error Correction (SEC-DED-DAEC) is an ECC code that can correct single-bit errors, detect double-bit errors, and correct adjacent double-bit errors.

[0003] Research on double-bit adjacent error correction (DAEC) is gradually increasing, but the error rate issue remains unresolved. On the one hand, the number of bits of data protected by DAEC with zero error rate varies (e.g., 16, 32, 128, 512, etc.). On the other hand, different designers have different experiences and methods, and the existing implementation technologies for DAEC matrix generation are still diverse. There is still a lack of unified and concise solutions to some common problems. This leads to the following problems:

[0004] 1) Increase the workload of designers. Different designers need to learn the relevant knowledge of storage hardening and linear block codes before designing, which will increase the total workload.

[0005] 2) Different designers have different design methods. For example, the number of initial check bits and check matrix columns can be selected in different ways, which will also increase the design difficulty.

[0006] In view of this, it is a technical problem that needs to be solved urgently by those skilled in the art to provide a method and system for generating a check matrix for a one-check-two-correction adjacent code that is scalable, has no error correction rate, has low hardware overhead, and has low encoding and decoding delay. Summary of the Invention

[0007] In order to solve the above technical problems, the purpose of the present invention is to provide a method and system for generating a check matrix for a one-correction, two-check adjacent code, which realizes the balanced optimization between the number of check bits and the row weights of the check matrix, fully reduces the hardware overhead, and has the advantages of scalability, error-free correction rate, low encoding and decoding delay, and fast generation of the check matrix.

[0008] The first object of the present invention is to provide a method for generating a check matrix of a correction-one-check-two-correction adjacent code;

[0009] The technical solutions provided by the present invention are as follows:

[0010] A method for generating a check matrix for a correction-one-check-two adjacent-correction code comprises the following steps:

[0011] Get the initial check digit according to the number of input data digits;

[0012] Construct an odd-weight vector pool based on the column vector weights and perform variable initialization;

[0013] Calculating layer depth based on the odd-weight vector pool and heuristic search;

[0014] Acquire a feasible vector sequence from the odd-weight vector pool to the layer depth through a Monte Carlo random method parallel search;

[0015] Constructing a target check matrix by using A* search in the feasible vector sequence;

[0016] Determining whether the target check matrix is ​​constructed;

[0017] Perform even weight vector replacement optimization on the target check matrix.

[0018] Preferably, the process of constructing an odd-weight vector pool according to column vector weights and performing variable initialization specifically includes:

[0019] The odd-weight vector pool is constructed according to column vector weights of 3, 5, ..., r / 2, where r represents the initial check digit;

[0020] The variable initialization includes initial check matrix initialization and algorithm variable initialization.

[0021] Preferably, the calculating the layer depth according to the odd-weight vector pool and heuristic search specifically includes:

[0022] Select the starting vector;

[0023] Selecting a feasible vector from the odd-weight vector pool according to a heuristic function, and determining whether the feasible vector satisfies a constraint condition; if so, updating a check matrix; if not, pruning the odd-weight vector pool according to the constraint condition, and determining whether any feasible vector remains in the odd-weight vector pool;

[0024] The odd-weighted vector pool is pruned according to the constraint conditions, and it is determined whether there are any feasible vectors remaining in the odd-weighted vector pool. If so, a step of selecting a feasible vector from the odd-weighted vector pool according to a heuristic function and determining whether the feasible vector satisfies the constraint conditions is entered; if not, the depth reached by the vector sequence in the current time period is recorded, and the search process is backtracked to the previous node, wherein the minimum backtracking depth is used as the layer depth.

[0025] Preferably, the obtaining of a feasible vector sequence from the odd-weight vector pool to the layer depth by parallel search using a Monte Carlo random method specifically includes:

[0026] Searching for a candidate vector from the remaining feasible vectors in the odd-weight vector pool using a Monte Carlo random method, and updating a check matrix;

[0027] Pruning the odd-weight vector pool according to the constraint conditions to determine whether the layer depth has been reached;

[0028] If it has been reached, the algorithm is terminated and a feasible vector sequence that can reach the layer depth is stored;

[0029] If not, it is determined whether there are any feasible vectors in the odd-weight vector pool, and the above steps are repeated.

[0030] Preferably, constructing a target check matrix by using A* search in the feasible vector sequence specifically includes:

[0031] Continue to perform the remaining search process in the feasible vector sequence using the A* search, calculate the maximum row weight and the average row weight of the current check matrix, and obtain an evaluation value of the current sequence;

[0032] Performing bitwise AND calculation of the result vector of the last column of the current check matrix and the candidate vector on the remaining feasible vectors corresponding to the sequence in sequence, and summing the bitwise AND result vectors to take the sum as the evaluation value of the candidate vector;

[0033] Performing a weighted summation of the evaluation value of the current sequence and the evaluation value of the candidate vector to obtain a total score value of the candidate vector, and comparing the total scores of all feasible vectors in turn, and selecting the vector corresponding to the highest total score value as the next search node;

[0034] Determine whether the candidate vector meets the constraint conditions. If so, add it to the check matrix, increase the number of vector columns by one, and determine whether the number of vector columns is equal to the number of data bits. If not, prune according to the constraint conditions and repeat the total score acquisition step.

[0035] Preferably, determining whether the number of vector columns is equal to the number of data bits specifically includes:

[0036] Determine whether the number of vector columns is equal to the number of data bits:

[0037] If the number of vector columns is equal to the number of data bits, the target check matrix is ​​constructed;

[0038] If the number of vector columns is less than the number of data bits, the target check matrix has not yet been constructed, and the odd-weight vector pool is pruned according to the constraint condition and the process returns to the step of obtaining the evaluation value of the current sequence.

[0039] Preferably, performing even weight vector replacement optimization on the target check matrix specifically includes:

[0040] Construct a constraint matrix based on the constraint conditions;

[0041] Constructing a 0 / 1 programming model according to the constraint matrix;

[0042] Solve the 0 / 1 programming model using the Z3 solver to obtain a solution result;

[0043] Substitute the solution result into the target check matrix to update the target check matrix.

[0044] Preferably, constructing a constraint matrix according to the constraint conditions specifically includes:

[0045] Abstract any two vectors with different vector columns in the constraint conditions into a set of r+k first-dimensional vectors, where two positions of each first-dimensional vector are set to 1 and the rest are all 0, where k represents the number of data bits;

[0046] Abstract the vectors in which no linear correlation exists between any three vectors in the constraint condition into a set of r+k second-dimensional vectors, where each second-dimensional vector randomly selects three positions and sets them to 1, and the rest of the positions are all 0;

[0047] Abstracting the vectors whose XOR values ​​of any two adjacent columns in the constraint condition are different into a set of r+k-bit third one-dimensional vectors, wherein each of the third one-dimensional vectors first sets two adjacent bits to 1 and the remaining bits to 0, and then selects two adjacent bits that are not exactly the same and inverts them;

[0048] Abstracting a vector in which the XOR values ​​of any two adjacent columns and the XOR values ​​of any two non-adjacent columns in the constraint condition are different into a set of r+k-bit fourth one-dimensional vectors, wherein each of the fourth one-dimensional vectors first sets two adjacent bits to 1 and the remaining bits to 0, and then inverts any two non-adjacent bits;

[0049] The constraint matrix is ​​constructed according to the first one-dimensional vector, the second one-dimensional vector, the third one-dimensional vector, and the fourth one-dimensional vector.

[0050] Preferably, constructing the 0 / 1 programming model according to the constraint matrix specifically includes:

[0051] Performing a dot multiplication of the constraint matrix and the check matrix to obtain a result matrix;

[0052] Modulo 2 is taken for each element in the result matrix to update the result matrix;

[0053] Summing the column vectors in the result matrix in sequence to obtain a sum vector;

[0054] Add model constraints so that every element in the sum vector is non-zero;

[0055] A model objective function is added so that the total weight of the check matrix is ​​a target value.

[0056] The second object of the present invention is to provide a check matrix generation system for a correction-one-check-two-correction adjacent code;

[0057] The technical solutions provided by the present invention are as follows:

[0058] A check matrix generation system for a correction-one-check-two-correction adjacent code, comprising: an acquisition module, a first construction module, a calculation module, a search module, a second construction module, a judgment module, and an optimization module;

[0059] The acquisition module is used to obtain the initial check bit number according to the input data bit number;

[0060] The first construction module is used to construct an odd-weight vector pool according to the column vector weights and perform a variable initialization process;

[0061] The calculation module is used to calculate the layer depth according to the odd weight vector pool and heuristic search;

[0062] The search module is configured to obtain a feasible vector sequence from the odd-weight vector pool to the layer depth through a parallel search using a Monte Carlo random method;

[0063] The second construction module is configured to construct a target check matrix by using A* search in the feasible vector sequence;

[0064] The judging module is configured to judge whether the target check matrix has been constructed;

[0065] The optimization module is used to perform even-weight vector replacement optimization on the target check matrix.

[0066] A third object of the present invention is to provide an electronic device;

[0067] The technical solutions provided by the present invention are as follows:

[0068] An electronic device, comprising:

[0069] at least one processor; and

[0070] A memory communicatively connected to the at least one processor, the memory storing a computer program executable by the at least one processor, the computer program being executed by the at least one processor so as to enable the at least one processor to perform any one of the method steps described in a method for generating a check matrix for a correction-one-detection-two adjacent code.

[0071] A fourth object of the present invention is to provide a computer-readable storage medium;

[0072] The technical solutions provided by the present invention are as follows:

[0073] A computer-readable storage medium is used to store a computer program, wherein the computer program is used to enable a computer to execute any one of the method steps described in a method for generating a check matrix for a correction-one-detection-two adjacent-correction code.

[0074] The present invention provides a method for generating a check matrix for a correction-one-check-two-correction adjacent code, comprising: obtaining an initial check bit number based on the number of input data bits; constructing an odd-weight vector pool based on column vector weights and performing a variable initialization process; calculating a layer depth based on the odd-weight vector pool and a heuristic search; obtaining a feasible vector sequence from the odd-weight vector pool to the layer depth through a parallel search using a Monte Carlo random method; constructing a target check matrix by using an A* search in the feasible vector sequence; determining whether the target check matrix has been constructed; and performing even-weight vector replacement optimization on the target check matrix. The method can generate a corresponding check matrix by inputting the number of data bits to be protected, and combines the Monte Carlo random method and the A* heuristic search to achieve a balanced optimization between the number of check bits and the row weights of the check matrix, thereby fully reducing hardware overhead and required bit width; and simultaneously fully reducing encoding and decoding delays and delay differences between different encoding and decoding paths. The method is universal, and for different data bit numbers, the algorithm can generate a corresponding check matrix for an error-free correction-one-check-two-correction adjacent code, thereby reducing the designer's workload and completing the reinforcement of the storage body. Therefore, the present invention has the characteristics of scalability, no error correction rate, low hardware overhead, low encoding and decoding delay, and fast generation of check matrix.

[0075] The present invention also provides a check matrix generation system for a one-check-two-correction adjacent code. Since this system and the check matrix generation method for a one-check-two-correction adjacent code solve the same technical problem and belong to the same technical concept, they should have the same beneficial effects and will not be described in detail here. BRIEF DESCRIPTION OF THE DRAWINGS

[0076] In order to more clearly illustrate the embodiments of the present application or the technical solutions in the prior art, the following briefly introduces the drawings required for use in the embodiments or the description of the prior art. Obviously, the drawings described below are only some embodiments recorded in this application. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying any creative work.

[0077] Figure 1 1 is a flow chart of a method for generating a check matrix for a one-correction, two-detection, adjacent-correction code according to an embodiment of the present invention;

[0078] FIG2 (a) is a schematic diagram of a weight 3 vector pool creation process according to an embodiment of the present invention;

[0079] Figure 2 (b) is a schematic diagram of the weight 5 vector pool creation process in an embodiment of the present invention;

[0080] Figure 3 Schematic diagram of layered depth calculation in an embodiment of the present invention;

[0081] Figure 4Schematic diagram of the Monte Carlo random method in an embodiment of the present invention;

[0082] Figure 5 Schematic diagram of A* heuristic search in an embodiment of the present invention;

[0083] Figure 6 A schematic diagram of constrained matrix construction according to an embodiment of the present invention;

[0084] Figure 7 A schematic diagram of the construction of a 0 / 1 planning model in an embodiment of the present invention;

[0085] Figure 8 Schematic diagram of the structure of a check matrix generation system for a one-correction, two-check, adjacent-correction code according to an embodiment of the present invention;

[0086] Figure 9 A schematic structural diagram of an electronic device according to an embodiment of the present invention. DETAILED DESCRIPTION

[0087] In order to help those skilled in the art better understand the technical solutions in this application, the technical solutions in the embodiments of this application will be clearly and completely described below. Obviously, the embodiments described are only part of the embodiments of this application, not all of the embodiments. Based on the embodiments in this application, all other embodiments obtained by those skilled in the art without making any creative efforts shall fall within the scope of protection of this application.

[0088] It should be noted that when an element is referred to as being “fixed on” or “set on” another element, it can be directly on the other element or indirectly set on the other element; when an element is referred to as being “connected to” another element, it can be directly connected to the other element or indirectly connected to the other element.

[0089] It should be understood that the terms "length", "width", "up", "down", "front", "back", "left", "right", "vertical", "horizontal", "top", "bottom", "inside", "outside", etc., indicating the orientation or position relationship, are based on the orientation or position relationship shown in the accompanying drawings, and are only for the convenience of describing this application and simplifying the description, and do not indicate or imply that the device or element referred to must have a specific orientation, be constructed and operated in a specific orientation, and therefore cannot be understood as a limitation on this application.

[0090] Furthermore, the terms "first" and "second" are used for descriptive purposes only and should not be understood to indicate or imply relative importance or implicitly specify the number of technical features indicated. Thus, a feature specified as "first" or "second" may explicitly or implicitly include one or more of such features. Throughout the description of this application, "plurality" or "several" means two or more, unless otherwise specifically defined.

[0091] It should be noted that the structures, proportions, sizes, etc. illustrated in the drawings of this specification are only used to match the contents disclosed in the specification for people familiar with this technology to understand and read, and are not used to limit the conditions under which this application can be implemented. Therefore, they have no substantive technical significance. Any structural modification, change in proportional relationship or adjustment of size should still fall within the scope of the technical content disclosed in this application without affecting the efficacy and purpose that can be achieved by this application.

[0092] like Figure 1 As shown, an embodiment of the present invention provides a method for generating a check matrix for a correction-one-check-two-correction adjacent code, comprising the following steps:

[0093] S1. Get the initial check digit based on the number of input data digits;

[0094] In step S1, in order to be able to correct one bit error and two adjacent bit errors, it should be:

[0095] ;

[0096] Thus, we can conclude that: , so the initial check bit number can be calculated based on the input data bit number k .

[0097] S2. Construct an odd-weight vector pool based on the column vector weights and perform variable initialization;

[0098] In step S2, the odd-weighted vector pool indicates that the number of "1"s in each column vector in the vector pool is odd; the vector pool is created according to the column vector weights of 3, 5...r / 2, that is, the capacity of the vector pool is: In addition, column vectors containing two consecutive "1"s are not put into the weight 3 vector pool, that is, the vector pool with a weight of 3; wherein, variable initialization includes initialization of the check matrix and algorithm variables, and the algorithm variables are shown in Table 1.

[0099] Table 1 Algorithm variable name table

[0100]

[0101] S3. Calculating hierarchical depth based on the odd-weight vector pool and heuristic search;

[0102] In step S3, the hierarchical depth is calculated from the odd-weight vector pool by using a heuristic search. The hierarchical depth refers to the depth at which the tree search can complete the traversal of the subtree within an acceptable time after a certain path reaches the depth.

[0103] S4. Obtaining a feasible vector sequence from the odd-weight vector pool to the layer depth by a Monte Carlo random method parallel search;

[0104] In step S4, before the tree search reaches the hierarchical depth, the entire space from the odd-weight vector pool to the hierarchical depth is searched in parallel by the Monte Carlo random method to obtain a feasible vector sequence that can reach the hierarchical depth.

[0105] S5. Constructing a target check matrix by using A* search in the feasible vector sequence;

[0106] In step S5, based on the feasible vector sequence obtained in step S4, a new heuristic function is used to guide the search process to obtain a complete check matrix, namely the target check matrix, which is specifically manifested as an A* search process; wherein, the heuristic function of the A* search is specifically to obtain the evaluation of the current state as the weighted sum of the extreme difference between the maximum row weight and the average row weight, and to obtain the evaluation of the future state as the bitwise AND vector sum of the last column of the current check matrix and the candidate column, and then perform the weighted sum of the two representations.

[0107] S6. Determine whether the target check matrix is ​​constructed;

[0108] S7. Perform even-weight vector replacement optimization on the target check matrix.

[0109] In step S6 to step S7, it is determined whether the number of vector columns col_confirm_num in the target check matrix is ​​equal to the number of data bits k. If so, it means that the check matrix is ​​constructed, and then step S7 is performed to optimize the constructed check matrix by replacing the even weight vector; if not, it means that the initial check digit r is too small, and the initial check digit r is incremented by 1 and then the process returns to step S2 to continue. The goal of this method is to construct an error-free check matrix with r rows and n columns. , where k represents the number of data bits, r represents the number of initial check bits, and n represents the sum of the number of data bits and the initial check bits, i.e. the total number of bits; represents a k-row and r-column matrix, is an r-order square matrix.

[0110] Generated check matrix The main features of this code are as follows: 1) The matrix has no all-zero columns and all columns are distinct, ensuring that single-bit errors can be corrected. 2) Each column of the check matrix contains an odd number of "1s," making it possible to distinguish between single-bit and double-bit errors. 3) The XOR results of two adjacent columns of the check matrix are distinct, and the set of XOR results of two adjacent columns does not intersect with the set of XOR results of two non-adjacent columns. The former allows the code to correct adjacent two-bit errors, while the latter ensures that the code has no error correction rate. The general idea behind generating a check matrix with these characteristics is to construct a pool of r row vectors and select n column vectors from them that meet these three characteristics.

[0111] Preferably, the process of constructing an odd-weight vector pool according to column vector weights and performing variable initialization specifically includes:

[0112] Constructing the odd-weight vector pool according to column vector weights of 3, 5, ..., r / 2;

[0113] The variable initialization includes initial check matrix initialization and algorithm variable initialization.

[0114] In actual application, the creation process of the odd-weight vector pool is shown in Figure 2(a) and Figure 2(b). The odd-weight vector pool is created according to weights 3, 5...r / 2. The creation process of the weight 3 vector pool is different from that of other vector pools. Therefore, Figure 2(a) shows the creation process of the weight 3 vector pool, and Figure 2(b) shows the creation process of the weight 5 vector pool. The creation process of other vector pools is similar to that of the weight 5 vector pool. It is only necessary to increase the number of FOR loops based on the creation process of the weight 5 vector pool.

[0115] Preferably, the calculating the layer depth according to the odd-weight vector pool and heuristic search specifically includes:

[0116] Select the starting vector;

[0117] Selecting a feasible vector from the odd-weight vector pool according to a heuristic function, and determining whether the feasible vector satisfies a constraint condition; if so, updating a check matrix; if not, pruning the odd-weight vector pool according to the constraint condition, and determining whether any feasible vector remains in the odd-weight vector pool;

[0118] The odd-weighted vector pool is pruned according to the constraint conditions, and it is determined whether there are any feasible vectors remaining in the odd-weighted vector pool. If so, a step of selecting a feasible vector from the odd-weighted vector pool according to a heuristic function and determining whether the feasible vector satisfies the constraint conditions is entered; if not, the depth reached by the vector sequence in the current time period is recorded, and the search process is backtracked to the previous node, wherein the minimum backtracking depth is used as the layer depth.

[0119] In actual application, Figure 3As shown, first, the odd-weight vector pool is traversed, and each vector in it is selected as the starting vector in turn. Then, a feasible vector is selected from the remaining odd-weight vector pool according to the heuristic function in the selected starting vector, and it is judged whether the feasible vector meets the constraint conditions. If so, the check matrix is ​​updated; if not, the next step is entered, that is, the odd-weight vector pool is pruned according to the constraint conditions to determine whether there are any remaining feasible vectors in the odd-weight vector pool; then the odd-weight vector pool is pruned according to the constraint conditions to determine whether there are any remaining feasible vectors in the odd-weight vector pool. If so, the step of selecting a feasible vector from the odd-weight vector pool according to the heuristic function and determining whether the feasible vector meets the constraint conditions is entered; if not, the depth reached by the vector sequence in the current time period is recorded, and the search process is traced back to the previous node, that is, the parent node, where the minimum depth of the backtracking is used as the layer depth; the purpose of this step is to facilitate the parallel execution of the algorithm. Multiple processes can be selected to execute the algorithm with different vectors as starting vectors, thereby achieving the purpose of reducing time overhead.

[0120] Specifically, the constraints in this embodiment are four conditions within the currently constructed check matrix, namely:

[0121] 1. Any two vector columns are not the same;

[0122] 2. There are no two or more pairs of adjacent vector columns whose XOR values ​​are the same;

[0123] 3. There is no pair of adjacent vector columns whose XOR value is the same as the XOR value of any pair of non-adjacent vector columns;

[0124] 4. There is no linear correlation between any three vectors.

[0125] It should be noted that the constraints involved in this application are all the above four conditions.

[0126] Preferably, the obtaining of a feasible vector sequence from the odd-weight vector pool to the layer depth by parallel search using a Monte Carlo random method specifically includes:

[0127] Searching for a candidate vector from the remaining feasible vectors in the odd-weight vector pool using a Monte Carlo random method, and updating a check matrix;

[0128] Pruning the odd-weight vector pool according to the constraint conditions to determine whether the layer depth has been reached;

[0129] If it has been reached, the algorithm is terminated and a feasible vector sequence that can reach the layer depth is stored;

[0130] If not, it is determined whether there are any feasible vectors in the odd-weight vector pool, and the above steps are repeated.

[0131] In actual application, Figure 4 As shown, first, the remaining feasible vectors in the odd-weight vector pool are selected as the starting vector start_vec, and the Monte Carlo random method is used to find a feasible vector sequence from the starting vector to the layer depth layer_depth, and the check matrix is ​​updated. At the same time, in order to speed up the search, a parallel search method can be used; then, after pruning the odd-weight vector pool according to the constraint conditions, it is determined whether the layer depth has been reached at this time; if it has been reached, the algorithm is terminated and the feasible vector sequence that can reach the layer depth is stored; if it has not been reached, it is determined whether there are any feasible vectors in the odd-weight vector pool: if so, the Monte Carlo random method is used to search for candidate vectors from the remaining feasible vectors in the odd-weight vector pool, and the check matrix is ​​updated. If not, it is traced back to the parent node and continues to determine whether there are any feasible vectors in the odd-weight vector pool.

[0132] Preferably, constructing a target check matrix by using A* search in the feasible vector sequence specifically includes:

[0133] Continue to perform the remaining search process in the feasible vector sequence using the A* search, calculate the maximum row weight and the average row weight of the current check matrix, and obtain an evaluation value of the current sequence;

[0134] Performing bitwise AND calculation of the result vector of the last column of the current check matrix and the candidate vector on the remaining feasible vectors corresponding to the sequence in sequence, and summing the bitwise AND result vectors to take the sum as the evaluation value of the candidate vector;

[0135] Performing a weighted summation of the evaluation value of the current sequence and the evaluation value of the candidate vector to obtain a total score value of the candidate vector, and comparing the total scores of all feasible vectors in turn, and selecting the vector corresponding to the highest total score value as the next search node;

[0136] Determine whether the candidate vector meets the constraint conditions. If so, add it to the check matrix, increase the number of vector columns by one, and determine whether the number of vector columns is equal to the number of data bits. If not, prune according to the constraint conditions and repeat the total score acquisition step.

[0137] In actual application, Figure 5As shown, first, A* search is used in the feasible vector sequence to obtain the optimal vector as the candidate vector, and then the remaining feasible vectors corresponding to the sequence are sequentially calculated by bitwise ANDing the result vector of the last column of the current check matrix and the candidate vector, and the bitwise ANDing result vector is summed, and the summation result is used as the evaluation value of the candidate vector; then the evaluation value of the current sequence is weighted and summed with the evaluation value of the candidate vector to obtain the total score value of the candidate vector, and the total score values ​​of all feasible vectors are compared in turn, and the vector corresponding to the highest total score value is selected as the next search node; it is judged whether the candidate vector meets the constraint conditions, and if so, it is added to the check matrix, and the number of vector columns is increased by one, and it is judged whether the number of vector columns is equal to the number of data bits; if not, it is pruned according to the constraint conditions, and the weighted summation of the evaluation value of the current sequence and the evaluation value of the candidate vector is repeated to obtain the total score value of the candidate vector, and the total score values ​​of all feasible vectors are compared in turn, and the vector corresponding to the highest total score value is selected as the next search node;

[0138] Among them, the specific process of using A* search to obtain the optimal vector as the candidate vector in the feasible vector sequence is as follows: calculate the weights of each row of the current check matrix, and then obtain the maximum row weight max_row_weight and the average row weight average_row_weight, set the weights ω1 and ω2 of the two to satisfy ω1+ω2 = 1, and then perform weighted summation to obtain the current check matrix evaluation value f=ω1*max_row_weight + ω2*average_row_weight; predict and evaluate all optional vectors in the current odd-weight vector pool in turn, and perform bitwise AND operation on them with the last column of the current check matrix to obtain a new vector, and count the number of 1s in the new vector as the prediction value g of each candidate vector; then perform weighted summation of the current evaluation value f and the prediction value g to obtain the A* heuristic function value of each candidate vector; finally, calculate all vectors in the odd-weight vector pool according to the A* heuristic function value, and select the one with the highest function value as the next candidate vector.

[0139] Preferably, determining whether the number of vector columns is equal to the number of data bits specifically includes:

[0140] Determine whether the number of vector columns is equal to the number of data bits:

[0141] If the number of vector columns is equal to the number of data bits, the target check matrix is ​​constructed;

[0142] If the number of vector columns is less than the number of data bits, the target check matrix has not yet been constructed, and the odd-weight vector pool is pruned according to the constraint condition and the process returns to the step of obtaining the evaluation value of the current sequence.

[0143] In actual application, when the candidate vector meets the constraint conditions, it is added to the check matrix, and the number of vector columns col_confirm_num is increased by one. At the same time, it is also necessary to determine whether the number of vector columns col_confirm_num at this time is equal to the number of data bits k. If the number of vector columns col_confirm_num is equal to the number of data bits k, it means that the target check matrix is ​​constructed; if the number of vector columns col_confirm_num is less than the number of data bits k, it means that the target check matrix has not been constructed yet. After pruning the odd-weight vector pool according to the constraint conditions, return to the feasible vector sequence and use A* search to continue the remaining search process, calculate the maximum row weight and average row weight of the current check matrix, and continue to obtain the evaluation value of the current sequence.

[0144] Preferably, performing even weight vector replacement optimization on the target check matrix specifically includes:

[0145] Construct a constraint matrix based on the constraint conditions;

[0146] Constructing a 0 / 1 programming model according to the constraint matrix;

[0147] Solve the 0 / 1 programming model using the Z3 solver to obtain a solution result;

[0148] Substitute the solution result into the target check matrix to update the target check matrix.

[0149] In actual application, the constructed check matrix constructed through the above steps is abstracted according to the constraints to obtain a constraint matrix, thereby performing 0 / 1 programming modeling. The model is then solved to obtain the minimum weight of its matrix, thereby replacing odd-weight vectors with even-weight vectors of smaller weight. The Z3 solver used in this embodiment is a high-performance automatic theorem prover widely used in formal verification, software and hardware verification, program analysis, and other fields. It is based on the Satisfiability Modulo Theories (SMT) theory and can solve constraints in various theories including Boolean logic, integers, real numbers, bit vectors, and so on.

[0150] Preferably, constructing a constraint matrix according to the constraint conditions specifically includes:

[0151] Abstract any two vectors with different vector columns in the constraint conditions into a set of r+k first-dimensional vectors, where each first-dimensional vector randomly selects two positions and sets them to 1, and the rest of the positions are all 0;

[0152] Abstract the vectors in which no linear correlation exists between any three vectors in the constraint condition into a set of r+k second-dimensional vectors, where each second-dimensional vector randomly selects three positions and sets them to 1, and the rest of the positions are all 0;

[0153] Abstracting the vectors whose XOR values ​​of any two adjacent columns in the constraint condition are different into a set of r+k-bit third one-dimensional vectors, wherein each of the third one-dimensional vectors first sets two adjacent bits to 1 and the remaining bits to 0, and then selects two adjacent bits that are not exactly the same and inverts them;

[0154] Abstracting a vector in which the XOR values ​​of any two adjacent columns and the XOR values ​​of any two non-adjacent columns in the constraint condition are different into a set of r+k-bit fourth one-dimensional vectors, wherein each of the fourth one-dimensional vectors first sets two adjacent bits to 1 and the remaining bits to 0, and then inverts any two non-adjacent bits;

[0155] The constraint matrix is ​​constructed according to the first one-dimensional vector, the second one-dimensional vector, the third one-dimensional vector, and the fourth one-dimensional vector.

[0156] In actual application, Figure 6 As shown, since the target matrix is ​​r rows and r+k columns, and the constraints described previously are all constraints on column vectors, the constraint vector is an r+k one-dimensional vector, and multiple such constraint vectors are combined to form a constraint matrix.

[0157] Since there are four constraints, an r+k-bit one-dimensional all-zero vector function (init_vec) is used as the initial constraint vector:

[0158] Under the constraint that any two vector columns are different: invert any two bits in the vector function (init_vec) (i.e. set them to 1) to obtain all constraint vectors obtained by this type of condition;

[0159] Under the constraint that there is no linear correlation between any three vectors: invert any three bits in the vector function (init_vec) (i.e. set them to 1) to obtain all constraint vectors obtained by this type of condition;

[0160] Under the constraint that there are no two or more pairs of adjacent vector columns with the same XOR value: invert two adjacent bits in the vector function (init_vec) (i.e. set them to 1), and then select two other adjacent bits that are not exactly the same and invert them to obtain all the constraint vectors obtained by this type of condition;

[0161] Under the constraint that the XOR value of a pair of adjacent vector columns does not match the XOR value of any pair of non-adjacent vector columns: invert two adjacent bits in the vector function (init_vec) (i.e., set them to 1), and then select two non-adjacent bits that are not exactly the same and invert them, to obtain all constraint vectors obtained by this type of condition;

[0162] Finally, the constraint matrix is ​​formed by further merging the above four groups of constraint vectors.

[0163] Preferably, constructing the 0 / 1 programming model according to the constraint matrix specifically includes:

[0164] Performing a dot multiplication of the constraint matrix and the check matrix to obtain a result matrix;

[0165] Modulo 2 is taken for each element in the result matrix to update the result matrix;

[0166] Summing the column vectors in the result matrix in sequence to obtain a sum vector;

[0167] Add model constraints so that every element in the sum vector is non-zero;

[0168] A model objective function is added so that the total weight of the check matrix is ​​a target value.

[0169] In actual application, Figure 7 As shown, the obtained constraint matrix C is point-multiplied with the check matrix H to obtain the result matrix R=HC; then each element of the result matrix R is modulo 2, and the result matrix R is updated; the column vectors of the result matrix are summed in sequence to obtain the sum vector V_sum; the 0-1 planning model constraint condition is added so that each element in the sum vector V_sum is not 0; the 0-1 planning model objective function is added so that the total weight of the check matrix is ​​the lowest; the 0-1 planning model constraint condition in this embodiment is that each element in the sum vector V_sum is not 0, rather than adding other constraints so that each element in V_sum is not 0; the 0-1 planning model objective function is the total weight of the check matrix, and minimizing the objective function is the goal of the model solution.

[0170] like Figure 8 As shown, an embodiment of the present invention further provides a check matrix generation system for a correction-one-detection-two-correction adjacent code, comprising: an acquisition module, a first construction module, a calculation module, a search module, a second construction module, a judgment module, and an optimization module;

[0171] The acquisition module is used to obtain the initial check bit number according to the input data bit number;

[0172] The first construction module is used to construct an odd-weight vector pool according to the column vector weights and perform a variable initialization process;

[0173] The calculation module is used to calculate the layer depth according to the odd weight vector pool and heuristic search;

[0174] The search module is configured to obtain a feasible vector sequence from the odd-weight vector pool to the layer depth through a parallel search using a Monte Carlo random method;

[0175] The second construction module is configured to construct a target check matrix by using A* search in the feasible vector sequence;

[0176] The judging module is configured to judge whether the target check matrix has been constructed;

[0177] The optimization module is used to perform even-weight vector replacement optimization on the target check matrix.

[0178] In actual application, an acquisition module, a first construction module, a calculation module, a search module, a second construction module, a judgment module and an optimization module are set in a check matrix generation system of a correction-one-check-two-correction adjacent code; wherein, the first construction module is connected to the acquisition module and the calculation module respectively; the search module is connected to the calculation module and the second construction module respectively; the judgment module is connected to the second construction module and the optimization module respectively; the acquisition module obtains the initial check digit according to the input data bit number, and transmits the initial check digit to the first construction module; after the first construction module inputs the initial check digit number, it constructs an odd-weight vector pool according to the column vector weight and performs the variable initialization process, and then sends the odd-weight vector pool to the calculation module; the calculation module calculates the layer depth according to the odd-weight vector pool and heuristic search, and then sends the layer depth to the search module; the search module uses the Monte Carlo random method to search in parallel to obtain the possible values ​​from the odd-weight vector pool to the layer depth. After the row vector sequence is generated, the feasible vector sequence is sent to the second construction module; the second construction module constructs the target check matrix by using A* search in the feasible vector sequence, and sends the target check matrix to the judgment module; the judgment module judges whether the construction of the target check matrix is ​​completed, and sends the completed target check matrix to the optimization module; the optimization module performs even-weight vector replacement optimization on the target check matrix; the system can generate the corresponding check matrix, and combine the Monte Carlo random method and A* heuristic search to achieve balanced optimization between the number of check bits and the row weight of the check matrix, which fully reduces the hardware overhead and the required bit width; at the same time, it fully reduces the encoding and decoding delay and the delay difference between different encoding and decoding paths; and it has universality. For different data bit numbers, the algorithm can generate the corresponding error-free correction rate one-check-two-correction adjacent code check matrix, which can reduce the designer's workload and complete the reinforcement of the storage body.

[0179] Furthermore, the embodiment of the present application also discloses an electronic device, Figure 9 This is a structural diagram of an electronic device according to an exemplary embodiment. The content in the diagram cannot be considered as any limitation on the scope of use of the present application.

[0180] Figure 9 This is a schematic diagram of the structure of an electronic device provided in an embodiment of the present application. The electronic device 20 may specifically include: at least one processor 21, at least one memory 22, a power supply 23, a communication interface 24, an input / output interface 25, and a communication bus 26. The memory 22 is used to store a computer program, which is loaded and executed by the processor 21 to implement the relevant steps of the method for generating a check matrix for a one-correction, two-detection, adjacent-correction code disclosed in any of the aforementioned embodiments. Furthermore, the electronic device 20 in this embodiment may specifically be an electronic computer.

[0181] In this embodiment, the power supply 23 is used to provide operating voltage for each hardware device on the electronic device 20; the communication interface 24 can create a check matrix generation channel for the electronic device 20 and the external device for the correction-one-check-two-correction adjacent code. The communication protocol it follows is any communication protocol that can be applied to the technical solution of this application and is not specifically limited here; the input and output interface 25 is used to obtain external input data or output data to the outside world. Its specific interface type can be selected according to specific application needs and is not specifically limited here.

[0182] In addition, the memory 22, as a carrier for resource storage, can be a read-only memory, random access memory, disk or CD, etc. The resources stored thereon may include an operating system 221, a computer program 222 and data 223, etc. The storage method can be temporary storage or permanent storage.

[0183] The operating system 221 is used to manage and control the hardware devices and computer program 222 on the electronic device 20 to enable the processor 21 to calculate and process data 223 in the memory 22. The operating system 221 can be Windows Server, NetWare, Unix, Linux, etc. In addition to including a computer program capable of performing the method for generating a check matrix for a one-check-two-correction adjacent code performed by the electronic device 20 as disclosed in any of the aforementioned embodiments, the computer program 222 can further include computer programs capable of performing other specific tasks. In addition to including data transmitted from an external device and received by the check matrix generation device for a one-check-two-correction adjacent code, the data 223 can also include data collected by its own input / output interface 25.

[0184] The steps of the methods or algorithms described in conjunction with the embodiments disclosed herein may be implemented directly using hardware, a software module executed by a processor, or a combination of the two. The software module may be placed in random access memory (RAM), internal memory, read-only memory (ROM), electrically programmable ROM, electrically erasable programmable ROM, registers, a hard disk, a removable disk, a CD-ROM, or any other form of storage medium known in the art.

[0185] Furthermore, this application discloses a computer-readable storage medium for storing a computer program; wherein, when executed by a processor, the computer program implements the aforementioned method for generating a parity check matrix for a one-correction, two-detection, and adjacent-correction code. The specific steps of this method can be found in the corresponding contents disclosed in the aforementioned embodiments and will not be further described here.

[0186] It should be understood that the use of "method," "device," "unit," and / or "module" in this application is merely a method for distinguishing different components, elements, parts, portions, or assemblies at different levels. However, if other words can achieve the same purpose, they can be replaced by other expressions.

[0187] As used in this application and the claims, unless the context clearly indicates an exception, the terms "a," "an," "an," and / or "the" are not intended to refer to the singular and may include the plural, unless the context clearly indicates otherwise. Generally speaking, the terms "comprises" and "include" only indicate the inclusion of the steps and elements specifically identified, and these steps and elements do not constitute an exclusive list. A method or apparatus may also include other steps or elements. The phrase "comprises a..." does not preclude the presence of additional identical elements in the process, method, product, or apparatus that includes the elements.

[0188] In the following, the terms "first" and "second" are used for descriptive purposes only and should not be understood to indicate or imply relative importance or implicitly specify the quantity of the technical features indicated. Therefore, a feature specified as "first" or "second" may explicitly or implicitly include one or more of the features.

[0189] If a flow chart is used in this application, the flow chart is used to illustrate the operations performed by the system according to the embodiments of the application. It should be understood that the previous or subsequent operations are not necessarily performed in exact order. Instead, the steps can be processed in reverse order or simultaneously. At the same time, other operations can be added to these processes, or one or more operations can be removed from these processes.

[0190] The above description of the disclosed embodiments is intended to enable one skilled in the art to implement or use the present application. Various modifications to these embodiments will be readily apparent to one skilled in the art, and the general principles defined herein may be implemented in other embodiments without departing from the spirit or scope of the present application. Therefore, the present application is not limited to the embodiments shown herein, but is intended to conform to the widest scope consistent with the principles and novel features disclosed herein.

Claims

1. A method for generating a check matrix for a correction-one-check-two adjacent-correction code, characterized in that: The steps include: Get the initial check digit according to the number of input data digits; Construct an odd-weight vector pool based on the column vector weights and perform variable initialization; The layer depth is calculated based on the odd-weight vector pool and heuristic search, specifically including: Select the starting vector; Selecting a feasible vector from the odd-weight vector pool according to a heuristic function, and determining whether the feasible vector satisfies a constraint condition; if so, updating a check matrix; if not, pruning the odd-weight vector pool according to the constraint condition, and determining whether any feasible vector remains in the odd-weight vector pool; The odd-weighted vector pool is pruned according to the constraint condition, and whether the feasible vector is still remaining in the odd-weighted vector pool is determined; if so, a feasible vector is selected from the odd-weighted vector pool according to a heuristic function, and whether the feasible vector satisfies the constraint condition is determined; if not, the depth reached by the vector sequence in the current time period is recorded, and the search process is backtracked to the previous node, wherein the minimum backtracking depth is used as the layer depth; Obtaining a feasible vector sequence from the odd-weight vector pool to the layer depth through a Monte Carlo random method parallel search, specifically including: Searching for a candidate vector from the remaining feasible vectors in the odd-weight vector pool using a Monte Carlo random method, and updating a check matrix; Pruning the odd-weight vector pool according to the constraint conditions to determine whether the layer depth has been reached; If it has been reached, the algorithm is terminated and a feasible vector sequence that can reach the layer depth is stored; If not, determine whether there are any feasible vectors in the odd-weight vector pool, and repeat the above steps of obtaining a feasible vector sequence; The target check matrix is ​​constructed by using A* search in the feasible vector sequence, specifically including: Continue to perform the remaining search process in the feasible vector sequence using the A* search, calculate the maximum row weight and the average row weight of the current check matrix, and obtain an evaluation value of the current sequence; Performing bitwise AND calculation of the result vector of the last column of the current check matrix and the candidate vector on the remaining feasible vectors corresponding to the sequence in sequence, and summing the bitwise AND result vectors to take the sum as the evaluation value of the candidate vector; Performing a weighted summation of the evaluation value of the current sequence and the evaluation value of the candidate vector to obtain a total score value of the candidate vector, and comparing the total scores of all feasible vectors in turn, and selecting the vector corresponding to the highest total score value as the next search node; Determine whether the candidate vector satisfies the constraint condition. If so, add it to the check matrix, increase the number of vector columns by one, and determine whether the number of vector columns is equal to the number of data bits. If not, prune according to the constraint condition and repeat the step of obtaining the total score value. Determining whether the target check matrix is ​​constructed; Perform even weight vector replacement optimization on the target check matrix.

2. The method for generating a check matrix for a correction-one-detection-two adjacent-correction code according to claim 1, wherein: The process of constructing an odd-weight vector pool according to column vector weights and performing variable initialization specifically includes: The odd-weight vector pool is constructed according to column vector weights of 3, 5, ..., r / 2, where r represents the initial check digit; The variable initialization includes initial check matrix initialization and algorithm variable initialization.

3. The method for generating a check matrix for a correction-one-detection-two adjacent-correction code according to claim 1, wherein: The determining whether the number of vector columns is equal to the number of data bits specifically includes: Determine whether the number of vector columns is equal to the number of data bits: If the number of vector columns is equal to the number of data bits, the target check matrix is ​​constructed; If the number of vector columns is less than the number of data bits, the target check matrix has not yet been constructed, and the odd-weight vector pool is pruned according to the constraint condition and the process returns to the step of obtaining the evaluation value of the current sequence.

4. The method for generating a check matrix for a correction-one-detection-two adjacent-correction code according to claim 1, wherein: The performing even weight vector replacement optimization on the target check matrix specifically includes: Construct a constraint matrix based on the constraint conditions; Constructing a 0 / 1 programming model according to the constraint matrix; Solve the 0 / 1 programming model using the Z3 solver to obtain a solution result; Substitute the solution result into the target check matrix to update the target check matrix.

5. The method for generating a check matrix for a correction-one-detection-two adjacent-correction code according to claim 4, wherein: The construction of the constraint matrix according to the constraint conditions specifically includes: Abstract any two vectors with different vector columns in the constraint conditions into a set of r+k first-dimensional vectors, where two positions of each first-dimensional vector are set to 1 and the rest are all 0, where k represents the number of data bits; Abstract the vectors in which no linear correlation exists between any three vectors in the constraint condition into a set of r+k second-dimensional vectors, where each second-dimensional vector randomly selects three positions and sets them to 1, and the rest of the positions are all 0; Abstracting the vectors whose XOR values ​​of any two adjacent columns in the constraint condition are different into a set of r+k-bit third one-dimensional vectors, wherein each of the third one-dimensional vectors first sets two adjacent bits to 1 and the remaining bits to 0, and then selects two adjacent bits that are not exactly the same and inverts them; Abstracting a vector in which the XOR values ​​of any two adjacent columns and the XOR values ​​of any two non-adjacent columns in the constraint condition are different into a set of r+k-bit fourth one-dimensional vectors, wherein each of the fourth one-dimensional vectors first sets two adjacent bits to 1 and the remaining bits to 0, and then inverts any two non-adjacent bits; The constraint matrix is ​​constructed according to the first one-dimensional vector, the second one-dimensional vector, the third one-dimensional vector, and the fourth one-dimensional vector.

6. The method for generating a check matrix for a correction-one-detection-two adjacent-correction code according to claim 4, wherein: The constructing of the 0 / 1 programming model according to the constraint matrix specifically includes: Performing a dot multiplication of the constraint matrix and the check matrix to obtain a result matrix; Modulo 2 is taken for each element in the result matrix to update the result matrix; Summing the column vectors in the result matrix in sequence to obtain a sum vector; Add model constraints so that every element in the sum vector is non-zero; A model objective function is added so that the total weight of the check matrix is ​​a target value.

7. A check matrix generation system for a correction-one-check-two adjacent-correction code, characterized in that: include: An acquisition module, a first construction module, a calculation module, a search module, a second construction module, a judgment module, and an optimization module; The acquisition module is used to obtain the initial check bit number according to the input data bit number; The first construction module is used to construct an odd-weight vector pool according to the column vector weights and perform a variable initialization process; The computing module is specifically configured to: Select the starting vector; Selecting a feasible vector from the odd-weight vector pool according to a heuristic function, and determining whether the feasible vector satisfies a constraint condition; if so, updating a check matrix; if not, pruning the odd-weight vector pool according to the constraint condition, and determining whether any feasible vector remains in the odd-weight vector pool; The odd-weighted vector pool is pruned according to the constraint condition, and whether the feasible vector is still remaining in the odd-weighted vector pool is determined; if so, a feasible vector is selected from the odd-weighted vector pool according to a heuristic function, and whether the feasible vector satisfies the constraint condition is determined; if not, the depth reached by the vector sequence in the current time period is recorded, and the search process is backtracked to the previous node, wherein the minimum backtracking depth is used as the layer depth; The search module is specifically used to: Searching for a candidate vector from the remaining feasible vectors in the odd-weight vector pool using a Monte Carlo random method, and updating a check matrix; Pruning the odd-weight vector pool according to the constraint conditions to determine whether the layer depth has been reached; If it has been reached, the algorithm is terminated and a feasible vector sequence that can reach the layer depth is stored; If not, determine whether there are any feasible vectors in the odd-weight vector pool, and repeat the above steps of obtaining a feasible vector sequence; The second construction module is configured to construct a target check matrix by using A* search in the feasible vector sequence; specifically, to: Continue to perform the remaining search process in the feasible vector sequence using the A* search, calculate the maximum row weight and the average row weight of the current check matrix, and obtain an evaluation value of the current sequence; Performing bitwise AND calculation of the result vector of the last column of the current check matrix and the candidate vector on the remaining feasible vectors corresponding to the sequence in sequence, and summing the bitwise AND result vectors to take the sum as the evaluation value of the candidate vector; Performing a weighted summation of the evaluation value of the current sequence and the evaluation value of the candidate vector to obtain a total score value of the candidate vector, and comparing the total scores of all feasible vectors in turn, and selecting the vector corresponding to the highest total score value as the next search node; Determine whether the candidate vector satisfies the constraint condition. If so, add it to the check matrix, increase the number of vector columns by one, and determine whether the number of vector columns is equal to the number of data bits. If not, prune according to the constraint condition and repeat the step of obtaining the total score value. The judging module is configured to judge whether the target check matrix has been constructed; The optimization module is used to perform even-weight vector replacement optimization on the target check matrix.

8. An electronic device, characterized in that: include: at least one processor; as well as A memory communicatively connected to the at least one processor, the memory storing a computer program executable by the at least one processor, the computer program being executed by the at least one processor so as to enable the at least one processor to perform the method according to any one of claims 1 to 6.

9. A computer-readable storage medium, characterized in that The storage medium is used to store a computer program, and the computer program is used to enable a computer to execute the method according to any one of claims 1 to 6.

Images