A low-complexity polar decoding method

Abstract

The application provides a low-complexity polar decoding method, which adopts a data structure of a "variable-length vector" set to store an LLR matrix and a bit matrix, and then calculates the LLR based on the LLR matrix and the bit matrix, so as to avoid the problems of excessive nesting and repeated calculation caused by nested calling of an LLR calculation module, and cooperate with optimization of a path selection processing strategy, so that the decoding complexity can be obviously reduced without reducing the decoding performance.

Description

Technical Field

[0001] This invention relates to the field of wireless communication technology, and more specifically, to a low-complexity polar decoding method. Background Technology

[0002] In the physical layer of current 5G NR systems, control information (MIB, DCI, and UCI) mainly uses polar codes. Polar codes can be regarded as a type of linear block code, but their design philosophy differs from that of traditional linear block codes. Traditional linear block codes (such as LDPC coding) are mostly systematic codes, which map the original bit information one by one to systematic bits and then distribute them "evenly" to the parity bits as "copies" for transmission to resist sudden random bit flipping errors. Polar codes, on the other hand, do not distinguish between systematic bits and parity bits, and directly distribute the original bit information "non-uniformly" to the encoded output sequence as "copies" for transmission.

[0003] The theoretical basis of Polar codes is the polarization theory of channels. This theory proves that, based on appropriate coding methods, a communication channel can be virtually divided into multiple sub-channels. These sub-channels can be divided into two categories: one category has a channel capacity approaching 1, which is a reliable channel, and the other category has a channel capacity approaching 0, which is an unreliable channel. Therefore, the original bit information can be directly mapped to reliable sub-channels for transmission.

[0004] Therefore, the key to polar codes lies in the design of the coding matrix and the selection of reliable channels.

[0005] The polar code encoding matrix can be denoted as G. N It is an N×N dimension matrix, where N is the length of the polar encoded output sequence, which is obtained by the Cranello product of n matrices G2, as shown in the following formula:

[0006]

[0007]

[0008] There are two mechanisms for selecting reliable channels: Density Evolution (DE) and Polar Weight (PW). The former calculates the transmission error probability of each sub-channel based on polar code decoding algorithms (mostly SCL decoding algorithms), thereby obtaining the reliability of each sub-channel. Its advantage is high accuracy, but its disadvantage is computational complexity and the need for real-time calculation. The latter evaluates sub-channel reliability by directly tracking the polarization process experienced by the sub-channel. Its advantage is simple calculation and no need for real-time calculation (it can be stored in a table for use), but its disadvantage is slightly lower accuracy. Ultimately, the PW mechanism was chosen for the 5G NR pilot test.

[0009] In the current 5G NR physical layer, such as Figure 1 As shown, most of them use the SCL decoding algorithm as the core of the decoding process, which is as follows:

[0010] Step 1: SCL decoding process: Based on the SCL decoder, L possible decoding results U can be obtained;

[0011] Step 2: Initialize the loop counter, k = 1;

[0012] Step 3: Perform a loop check: if k > L, report decoding failure and end decoding; otherwise, continue to Step 4;

[0013] Step 4: Extract the original information: based on the k-th decoding result u k The original information c' is extracted as shown in the following formula:

[0014]

[0015]

[0016] Step 5: DCRC Deinterleaving: If i IL If the result is 1, then DCRC deinterleaving is performed; otherwise, the result is directly mapped and denoted as c, as shown in the following formula:

[0017] c” Π(j) =c' j

[0018]

[0019] Where, m j Represents a sequence The j-th one is not less than The element index;

[0020] Step 6: CRC check: Perform a CRC check on the deinterleaving result c. If the check passes, end the decoding and output the decoding result c; otherwise, continue to Step 7.

[0021] Step 7: Loop count accumulation: k = k + 1, and jump to Step 3;

[0022] The SCL decoder process is as follows:

[0023] Step 1: Initialize SCL decoding results and status information: U = 0, p = 0, Y = 0, y t =0;

[0024] Step 2: Initialize the LLR loop counter: i = 1;

[0025] Step 3: If i > N, then end the decoding and output the decoding result U; otherwise, continue to Step 4.

[0026] Step 4: Initialize the temporary decoding result: p tmp =0, u tmp =0;

[0027] Step 5: Initialize the path loop counter: k = 1;

[0028] Step 6: Perform a path loop check: if k > L, then jump to Step 10; otherwise, continue to Step 7.

[0029] Step 7: Obtain the decoding result: Call the LLR calculation module (FUNC) llr_calc ) Calculate LLR, with input parameters being (log2(N), LLR) in ,u tmp Then, a hard decision is made to obtain the corresponding decoding result δ of the i-th bit, as shown in the following formula:

[0030]

[0031] Step 8: Update the SCL temporary decoding result and status information: First, perform a right circular shift operation to update Y, and then update p according to the three types of the i-th bit (frozen bit, information bit, and PC check bit). tmp and u tmp As shown in the following formula:

[0032] y t =Y 1,k ,Y 1,k =Y 2,,k ,Y 2,k =Y 3,k ,Y 3,k =Y 4,k ,Y 4,k =Y 5,k ,Y 5,k =y t

[0033] condition1:

[0034]

[0035] condition2:fori∈qIandi∈qPC

[0036]

[0037] condition3:

[0038]

[0039] Step 9: Perform path loop accumulation: k = k + 1, and jump to Step 6;

[0040] Step 10: Path Selection: Select p tmp The smallest L elements in the set are sorted in ascending order, and the corresponding element indices are recorded as a vector called `order`. `p` is then updated based on this set of elements, as shown in the following equation:

[0041]

[0042] Step 11: Path Copying: Based on K and u tmp Update U and Y as shown in the following equation:

[0043]

[0044] Step 12: Perform LLR loop accumulation: i = i + 1, and jump to Step 3.

[0045] The LLR calculation module is denoted as FUNC llr_calc Its input and output parameters are denoted as:

[0046] The input parameters are: (n', LLR) tmp ,u tmp ,i);

[0047] The output parameter is llr;

[0048] The LLR calculation module is based on a nested implementation, and the processing is as follows: x(start:duration:end) represents the set of elements selected from the vector x within the index range [start,end] with duration as the interval.

[0049] Step 1: Determine parameters a and b: If 2 n' >2, then nested call to FUNC llr_calc Otherwise, based on LLR tmp The direct calculation is shown in the following formula:

[0050] condition1:for2 n '≤2

[0051]

[0052] condition2:for2 n'>2

[0053]

[0054] Step 2: Calculate the updated LLR: There are two cases based on whether i is parity or even, as shown in the following formula:

[0055]

[0056] During the above processing:

[0057] llr in It is an N*1 vector, the input of the polar decoder, and its physical meaning is the log-likelihood ratio;

[0058] U is an N*L matrix, where each column corresponds to a decoding path and the corresponding decoding result. There are a total of L decoding paths, where L physically represents the maximum number of decoding paths (or the maximum number of decoding search paths).

[0059] p is an L*1 vector representing the path metric of the decoding path corresponding to each column in U. The larger the value, the lower the reliability of the corresponding decoding result.

[0060] p tmp It is a 2L*1 vector, which is the path metric of the temporary decoding path calculated based on p. Each decoding path can derive two decoding paths, so its dimension is 2L.

[0061] u tmp This is a 2L*1 vector, representing the decoding result of the current bit of the temporary decoding path calculated based on p, and is related to p. tmp One-to-one correspondence;

[0062] LLR calculation module (i.e., FUNC) llr_calc This can be used to calculate a new increment of the path metric for temporary decoding paths, which is implemented based on a nested mechanism;

[0063] Y is a 5*L vector used to perform parity checking on the decoding results of L paths;

[0064] It is a DCRC interleaved sequence with a length of [length missing].

[0065] K is the length of the polar-coded output sequence, which physically represents the length of the original information bit sequence.

[0066] N is the length of the polar decoding input sequence. N>K and its value must be a power of 2, i.e., n = log2(N) is an integer, which can be calculated with reference to the TS38.212 protocol.

[0067] qI represents the set of reliable subchannel indices selected for transmitting the original information bits and check bits, containing (K+n) PC The number of elements can be calculated by referring to the table in protocol TS38.212;

[0068] qPC represents the set of reliable subchannel indices used for transmitting parity bits, which is a subset of qI and contains n. PC Each element can be calculated by referring to the table in protocol TS38.212;

[0069] For the sake of consistency and ease of understanding, x will be used in this article. i Let X represent the i-th element of vector x. i,j This represents the element in the i-th row and j-th column of matrix X, with all indices starting from 1 by default.

[0070] As can be seen, the computational complexity of this decoding process is mainly concentrated in "obtaining the decoding result" (Step 7) and "path copying" (Step 11). For the former, it requires frequent nested calls to the LLR calculation module (FUNC). llr_calc To calculate LLR, the maximum nesting level can reach n = log2(N), and it also involves the calculation of the natural logarithm (see FUNC). llr_calc The calculation process in Step 2 (in the middle) is actually related to the nested call to FUNC for different values ​​of i input on the same decoding path. llr_calc The majority of the computation process may be the same: the common intermediate quantities can be categorized as LLR matrices and bit matrices, the former used to record a and b used in each nested computation, and the latter used to record u that may be used in each nested computation. s value.

[0071] For the latter, updating requires copying the U matrix, which needs to be done N times. Since the U matrix is ​​an N*L dimension matrix, the copying workload is enormous. In fact, for frozen bits and check bits, such copying can be avoided. Summary of the Invention

[0072] The present invention aims to provide a low-complexity polar decoding method to solve the problem of high complexity in the polar decoding process of the SCL algorithm.

[0073] This invention provides a low-complexity polar decoding method, including the following improvements:

[0074] (1) Using two sets of variable-length vectors (llr) base ,LLR path The design uses LLR to store LLR matrix information. base The path is independent, and there are a total of n+1 columns. The j-th column contains 2.j-1 One element; LLR path Related to the path, there are a total of n columns, and the j-th column contains N-2... j-1 This design, with its single element, minimizes the storage space occupied by the LLR matrix and reduces the amount of copying work required for the LLR matrix during path selection.

[0075] (2) LLR update module (FUNC) llr_update The LLR update module utilizes the inherent characteristics of the LLR matrix to perform appropriate updates to the LLR matrix based on the input bit index i, thereby supporting the calculation of each LLR and avoiding the problems of excessive nesting and redundant calculations in traditional processing.

[0076] (3) Using the variable-length vector set B path The design for storing bit matrix information, B path Related to the path, there are a total of n columns, and the j-th column contains N-2... j-1 This design, with its single element, minimizes the storage space occupied by the bit matrix and reduces the workload of copying the bit matrix during path selection.

[0077] (4)u s Update module (FUNC) b_update The design of this u s The update module utilizes the inherent characteristics of the bit matrix to perform appropriate updates to the bit matrix based on the input bit index i, thereby supporting the calculation of each LLR and avoiding the problems of excessive nesting and redundant calculations in traditional processing.

[0078] (5) Path selection module (FUNC) path _ sel The design of this module fully utilizes the characteristics of path metric calculation in the SCL algorithm: for frozen bits and PC check bits, a single path calculation result will derive two paths, one path's path metric will increase or remain unchanged, and the other path's path metric will become the maximum value; for information bits, a single path calculation result will derive two paths, one path's path metric will increase, and the other path's path metric will remain unchanged. Based on this characteristic, this module is based on the set SET old and SET new The design minimizes the number of copy operations for the LLR matrix, bit matrix, and path decoding results.

[0079] (6) Use sign(a)*sign(b)*min(|a|,|b|) to approximate the calculation of ln((1+e a+b ) / (e a +e bThis approximation can solve the problem of excessive computational complexity of the natural logarithm, and ln((1+e a+b ) / (e a +e b The problem of requiring high accuracy in calculating the natural logarithm when it approaches 0.

[0080] In summary, due to the adoption of the above technical solution, the beneficial effects of the present invention are:

[0081] This invention uses a data structure of "variable-length vector" sets to store the LLR matrix and bit matrix, and then calculates the LLR based on them. This avoids the problems of excessive nesting and repeated calculations caused by nested calls to the LLR calculation module. Combined with the optimization of the path selection processing strategy, the decoding complexity can be significantly reduced without reducing the decoding performance. Attached Figure Description

[0082] To more clearly illustrate the technical solutions of the embodiments of the present invention, the accompanying drawings in the embodiments will be briefly described below. It should be understood that the following drawings only show some embodiments of the present invention and should not be regarded as a limitation on the scope. For those skilled in the art, other related drawings can be obtained based on these drawings without creative effort.

[0083] Figure 1 This is a flowchart of a polar decoding algorithm based on the SCL algorithm suitable for the 5G NR standard.

[0084] Figure 2 This is a flowchart of a low-complexity polar decoding method in an embodiment of the present invention.

[0085] Figure 3 This is a flowchart of the LLR update module processing procedure in an embodiment of the present invention.

[0086] Figure 4 This is a flowchart of the path selection module processing procedure in an embodiment of the present invention.

[0087] Figure 5 u in the embodiments of the present invention s A flowchart of the update module processing procedure. Detailed Implementation

[0088] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. The components of the embodiments of the present invention described and shown in the accompanying drawings can generally be arranged and designed in various different configurations.

[0089] Therefore, the following detailed description of the embodiments of the invention provided in the accompanying drawings is not intended to limit the scope of the claimed invention, but merely to illustrate selected embodiments of the invention. All other embodiments obtained by those skilled in the art based on the embodiments of the invention without inventive effort are within the scope of protection of the invention.

[0090] Example

[0091] For ease of description, let's note:

[0092] llr in It is an N*1 vector, the input of the polar decoder, and its physical meaning is the log-likelihood ratio;

[0093] U is an N*L matrix, where each column corresponds to a decoding path and the corresponding decoding result. There are a total of L decoding paths, where L physically represents the maximum number of decoding paths (or the maximum number of decoding search paths).

[0094] p is an L*1 vector representing the path metric of the decoding path corresponding to each column in U. The larger the value, the lower the reliability of the corresponding decoding result.

[0095] N p This represents the number of valid paths, initialized to 1, and cannot exceed L.

[0096] llr base It is a (2N-1)*1 vector, which can be based on a vector idx of length n. llr_base Divide the starting address into n sub-vectors of different lengths, with lengths of 2 in each sub-vector. 0 ,2 1 ,2 2 , ...,2 n , n = log2(N);

[0097] LLR path The matrix is ​​(nN-(2(N-1)-1))*L, and each column can be based on a vector idx of length n. llr_path Divide the starting address into n sub-vectors of different lengths, with lengths of N-2 respectively. 0 N-2 1 ,...,N-2 n , n = log2(N);

[0098] B path The matrix is ​​(nN-(2(N-1)-1))*L, and each column can be based on a vector idx of length n. b_path Divide the starting address into n sub-vectors of different lengths, with lengths of N-2 respectively. 0 N-2 1,...,N-2 n , n = log2(N);

[0099] order path Let U be an L*1 vector, representing the ascending sort index of the path metric corresponding to each column of the decoding path in U;

[0100] p tmp It is a 2L*1 vector, which is the path metric of the temporary decoding path calculated based on p. Each decoding path can derive two decoding paths, so its dimension is 2L.

[0101] u tmp This is a 2L*1 vector, representing the decoding result of the current bit of the temporary decoding path calculated based on p, and is related to p. tmp One-to-one correspondence;

[0102] LLR calculation module (i.e., FUNC) llr_calc This can be used to calculate a new increment of the path metric for temporary decoding paths, which is implemented based on a nested mechanism;

[0103] Y is a 5*L vector used to perform parity checking on the decoding results of L paths;

[0104] It is a DCRC interleaved sequence with a length of [length missing].

[0105] K is the length of the polar-coded output sequence, which physically represents the length of the original information bit sequence.

[0106] N is the length of the polar decoding input sequence. N>K and its value must be a power of 2. It can be calculated with reference to the TS38.212 protocol.

[0107] qI represents the set of reliable subchannel indices selected for transmitting the original information bits and check bits, containing (K+n) PC The number of elements can be calculated by referring to the table in protocol TS38.212;

[0108] qPC represents the set of reliable subchannel indices used for transmitting parity bits, which is a subset of qI and contains n. PC Each element can be calculated by referring to the table in protocol TS38.212.

[0109] For the sake of consistency and ease of understanding, x will be used in this article. i Let X represent the i-th element of vector x. i,j x represents the element in the j-th column of the i-th row of matrix X. x(start:duration:end) represents the set of elements selected from vector x within the index range [start,end] with duration as the interval, and all indices start from 1 by default.

[0110] This embodiment proposes a low-complexity polar decoding method that uses a variable-length vector set data structure to store the LLR matrix and bit matrix, and then calculates the LLR based on them, thus avoiding nested calls to FUNC. llr_calc This addresses the issues of excessive nesting and redundant calculations, and addresses the problem of designing a column-sorted index array for U to minimize frequent copying of the U matrix, effectively reducing decoding complexity. The main improvements are as follows:

[0111] (1) Using two sets of variable-length vector sets (llr) base ,LLR path The design uses LLR to store LLR matrix information. base The path is independent, and there are a total of n+1 columns. The j-th column contains 2. j-1 One element; LLR path Related to the path, there are a total of n columns, and the j-th column contains N-2... j-1 This design, with its single element, minimizes the storage space occupied by the LLR matrix and reduces the amount of copying work required for the LLR matrix during path selection.

[0112] (2) LLR update module (FUNC) llr_update The LLR update module utilizes the inherent characteristics of the LLR matrix to perform appropriate updates to the LLR matrix based on the input bit index i, thereby supporting the calculation of each LLR and avoiding the problems of excessive nesting and redundant calculations in traditional processing.

[0113] (3) Using the variable-length vector set B path The design for storing bit matrix information, B path Related to the path, there are a total of n columns, and the j-th column contains N-2... j-1 This design, with its single element, minimizes the storage space occupied by the bit matrix and reduces the workload of copying the bit matrix during path selection.

[0114] (4)u s Update module (FUNC) b_update The design of this u s The update module utilizes the inherent characteristics of the bit matrix to perform appropriate updates to the bit matrix based on the input bit index i, thereby supporting the calculation of each LLR and avoiding the problems of excessive nesting and redundant calculations in traditional processing.

[0115] (5) Path selection module (FUNC) path_selThe design of this module fully utilizes the characteristics of path metric calculation in the SCL algorithm: for frozen bits and PC check bits, a single path calculation result will derive two paths, one path's path metric will increase or remain unchanged, and the other path's path metric will become the maximum value; for information bits, a single path calculation result will derive two paths, one path's path metric will increase, and the other path's path metric will remain unchanged. Based on this characteristic, this module is based on the set SET old and SET new The design minimizes the number of copy operations for the LLR matrix, bit matrix, and path decoding results.

[0116] (6) Use sign(a)*sign(b)*min(|a|,|b|) to approximate the calculation of ln((1+e a+b ) / (e a +e b This approximation can solve the problem of excessive computational complexity of the natural logarithm, and ln((1+e a+b ) / (e a +e b The problem of requiring high accuracy in calculating the natural logarithm when it approaches 0.

[0117] Therefore, as Figure 2 The diagram illustrates the low-complexity polar decoding method provided in this embodiment, where Steps 1, 3, and 4 represent the main differences from traditional polar decoding. Specifically, it includes the following steps:

[0118] Step 1: SCL decoding process: Based on the optimized SCL decoder, obtain L possible decoding results U and the decoding path sorting result order;

[0119] Step 2: Initialize the loop counter, k = 1;

[0120] Step 3: Perform a loop check: if k > N p If the decoding fails, the decoding process will end; otherwise, proceed to Step 4.

[0121] Step 4: Extract the original information: based on the k-th decoding result u k The original information c' is extracted as shown in the following formula:

[0122]

[0123]

[0124] Step 5: DCRC Deinterleaving: If i ILIf the result is 1, then DCRC deinterleaving is performed; otherwise, the deinterleaving result is directly mapped and denoted as c, as shown in the following formula:

[0125] c” Π(j) =c' j

[0126]

[0127] Step 6: CRC check: Perform a CRC check on the deinterleaving result c. If the check passes, end the decoding and output the decoding result c; otherwise, continue to Step 7.

[0128] Step 7: Loop count accumulation: k = k + 1, and jump to Step 3.

[0129] Furthermore, in Step 1, the SCL decoder processing procedure is optimized as follows:

[0130] Step 1-1: Initialize SCL decoding results and status information: Initialize U = 0, i = 1, N p =1, LLR path =0, B path =0, initialize p and idx path idx base llr base order path As shown in the following formula:

[0131]

[0132]

[0133]

[0134]

[0135]

[0136] Step 1-2: Initialize the LLR loop counter: i = 1;

[0137] Step 1-3: If i > N, then end the decoding and output the decoding result U; otherwise, continue to Step 1-4.

[0138] Step 1-4: Initialize the temporary decoding result: p tmp =0, u tmp =0;

[0139] Step 1-5: Initialize the path loop counter: k = 1;

[0140] Step 1-6: Perform path loop checks: If k > N p If so, proceed to Step 1-10; otherwise, continue to Step 1-7.

[0141] Step 1-7: Obtain the decoding result: Call the LLR update module to update the LLR. base and LLR path To perform an update, the input parameter is (llr) base ,LLR path B path idx base idx path Then, calculate llr and the hard-decision decoding result δ, as shown in the following formula:

[0142]

[0143]

[0144] Steps 1-8: Update the SCL temporary decoding result and status information: First, perform a right circular shift operation to update Y, then update p according to the three types of the i-th bit: frozen bit, information bit, and PC check bit. tmp and u tmp As shown in the following formula:

[0145] y t =Y 1,k ,Y 1,k =Y 2,,k ,Y 2,k =Y 3,k ,Y 3,k =Y 4,k ,Y 4,k =Y 5,k ,Y 5,k =y t

[0146] condition1:

[0147]

[0148] condition2:for i∈qI and i∈qPC

[0149]

[0150] condition3:

[0151]

[0152] Step 1-9: Perform path loop accumulation: k = k + 1, and jump to Step 1-6;

[0153] Step 1-10: Path Selection and Copying: If i∈qPC or i∈qI, then proceed directly to Step 1-11; otherwise, call the path selection module to select a valid path and process path-related information, including U, p, and LLR. path B path Y, order path and N p Update and discard the LLR path. path and B path To reset, the input parameters are (U, LLR) path B path idx path ,Y,order path N p ,p tmp ,u tmp ,L,i,n);

[0154] Step 1-11: Bit matrix update: Call u s Update module for B path To perform an update, the input parameter is (llr) base B path idx base ,i,n);

[0155] Step 1-12: Perform LLR loop accumulation: i = i + 1, and jump to Step 1-3.

[0156] Furthermore, such as Figure 3 As shown, in Steps 1-7, the LLR update module is denoted as FUNC. llr_update , can be used for llr base and LLR path The update is performed, and its input and output parameters are denoted as:

[0157] The input parameter is: (llr base ,LLR path B path idx base idx path ,i,n,k);

[0158] The output parameter is: (llr base ,LLR path );

[0159] The LLR update module's processing procedure is as follows:

[0160] Step 1-7-1: Initialize variable i last_next and i start_next As shown in the following formula:

[0161]

[0162] Step 1-7-2: Initialize the layer loop counter: j = n;

[0163] Step 1-7-3: Perform a loop check: if j < 1, then end the processing of this module and output the updated llr. base and LLR path Otherwise, continue with Step 1-7-4;

[0164] Step 1-7-4: Determine if an update is triggered: If any of the following conditions are met, continue to Step 1-7-5; otherwise, proceed to Step 1-7-8.

[0165] i = i start_curr

[0166]

[0167] Step 1-7-5: Calculate the a required to update the LLR matrix tmp and b tmp As shown in the following formula:

[0168]

[0169]

[0170] Step 1-7-6: Update LLR base and LLR path As shown in the following formula:

[0171]

[0172]

[0173]

[0174] Step 1-7-7: Update variable i last_next and i start_next As shown in the following formula:

[0175]

[0176] Step 1-7-8: Perform a layered loop decrease: j = j-1, and jump to Step 1-7-2.

[0177] Furthermore, such as Figure 4 As shown, in Step 1-10, the path selection module is denoted as FUNC. path _ sel It can select a valid path and apply the selected path to N. p order path Update p, Y, and U, and adjust LLR based on discarded paths. path and B path The input and output parameters for resetting are denoted as follows:

[0178] The input parameters are: (U,LLR) path B path idx path ,Y,order path N p ,p tmp ,u tmp ,L,i,n);

[0179] The output parameters are: (U, p, LLR) path B path ,Y,order path N p );

[0180] The path selection module processes the path as follows:

[0181] Step 1-10-1: Reorder temporary path metrics: for p tmp Reorder the indices in ascending order, and denote the reordered set of indices as the vector `order`. tmp ;

[0182] Step 1-10-2: Calculate the path update set: including the set of newly added path indexes (SET) new Discard Path Index Path Set SET old Add a new path sorting index set SET new _ plus As shown in the following formula:

[0183]

[0184]

[0185]

[0186] in, Represents the empty set;

[0187] Step 1-10-3: Initialize the path loop count k = 1;

[0188] Step 1-10-4: Perform path loop judgment: if k > |SET new If |, then jump to Step 1-10-12, |SET new | represents the set SET new The number of elements contained; otherwise, continue to Step 1-10-5;

[0189] Step 1-10-5: Update path order and path metric: If N p =L, then update the path order. tmp And the path metric p, as shown in the following formula; otherwise, proceed directly to Step 1-10-6;

[0190]

[0191] Step 1-10-6: Initialize the layer loop counter j = 1;

[0192] Step 1-10-7: Perform a layered loop check: if j > n, then jump to Step 1-10-10; otherwise, continue executing Step 1-10-8;

[0193] Step 1-10-8: Path Copying: Reset LLR path and B path As shown in the following formula:

[0194]

[0195]

[0196]

[0197] Step 1-10-9: Increment the layer loop count: j = j + 1, and jump to Step 1-10-7;

[0198] Step 1-10-10: Reset Y and U as shown in the following formula:

[0199]

[0200]

[0201]

[0202]

[0203] Step 1-10-11: Path loop count accumulation: k = k + 1, and jump to Step 1-10-4;

[0204] Step 1-10-12: Update path information: First update N p In updating p and order path As shown in the following formula:

[0205] Step 1: N p =min(2N) p ,L)

[0206] Step 2:

[0207]

[0208]

[0209] Furthermore, such as Figure 5 As shown, in Step 1-11, u s The update module is denoted as FUNC b_update The bit matrix B can be processed. path The update is performed, and its input and output parameters are denoted as:

[0210] The input parameter is: (llr base B path idx base ,i,n);

[0211] The output parameter is: B path ;

[0212] u s The update module processing procedure is as follows:

[0213] Step 1-11-1: Initialize the path loop counter: k = 1;

[0214] Step 1-11-2: Perform path loop judgment: if k>N p If the condition is met, this module will process the request; otherwise, continue executing Step 1-11-3.

[0215] Step 1-11-3: Initialize the layer loop counter: j = 1;

[0216] Step 1-11-4: Perform a layered loop check: if j>n, then jump to Step 1-11-7; otherwise, continue executing Step 1-11-5.

[0217] Step 1-11-5: Update the bit matrix, i.e., update B. path The update will be performed according to the following two scenarios, as shown in the following formula:

[0218] condition1: j = 1 and i ≤ N-1

[0219]

[0220] condition2: i = i last andi≤N-2 j-1

[0221]

[0222]

[0223]

[0224] Step 1-11-6: Perform layer loop counting accumulation: j = j + 1, and jump to Step 1-11-4;

[0225] Step 1-11-7: Perform path loop counting accumulation: k = k + 1, and jump to Step 1-11-2.

[0226] As can be seen from the above, the present invention uses a data structure of "variable length vector" set to store the LLR matrix and bit matrix, and then calculates the LLR based on them, so as to avoid the problem of excessive nesting and repeated calculation caused by nested calls to the LLR calculation module. With the optimization of the path selection processing strategy, the decoding complexity can be significantly reduced without reducing the decoding performance.

[0227] The above description is merely a preferred embodiment of the present invention and is not intended to limit the invention. Various modifications and variations can be made to the present invention by those skilled in the art. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the scope of protection of the present invention.

Claims

1. A low-complexity polar decoding method, characterized in that, Includes the following steps: Step 1: SCL Decoding Processing: Obtaining possible SCL decoders based on optimization L The decoding result U and the decoding path sorting result order are used; the process of optimizing the SCL decoder is as follows: Step 1-1: Initialize SCL decoding results and status information: Initialize U=0, i =1, N p =1, LLR path =0, B path =0, initialize p and idx llr_path idx llr_base llr base order path As shown in the following formula: Step 1-2: Initialize the LLR loop counter: i =1; Steps 1-3: If i > N If the decoding is successful, the decoding process ends and the decoding result U is output; otherwise, continue executing Step 1-4. Step 1-4: Initialize the temporary decoding result: p tmp =0, u tmp =0; Step 1-5: Initialize the path loop count: k =1; Step 1-6: Perform path loop checks: If k > N p If the condition is met, proceed to Step 1-10; otherwise, continue to Step 1-7. Step 1-7: Obtain the decoding result: Call the LLR update module to update the LLR. base and LLR path To perform an update, the input parameter is (llr) base LLR path B path idx llr_base idx llr_path , i , n , k Then calculate llr Hard judgment decoding results δ As shown in the following formula: Steps 1-8: Update SCL temporary decoding results and status information: First, perform a right circular shift operation to update Y, then proceed according to the steps... i The three types of bits—frozen bits, information bits, and PC check bits—are updated separately. tmp and u tmp As shown in the following formula: Steps 1-9: Perform path iteration and accumulation: k = k +1, and jump to Step 1-6; Step 1- 10: Path Selection and Copying: If i ∈qPC or i If ∈qI, then proceed directly to Step 1-11; Otherwise, the path selection module is invoked to select a valid path and to process path-related information, including U, p, and LLR. path B path Y, order path and N p Update and discard the LLR path. path and B path To reset, the input parameters are (U, LLR) path B path idx llr _path ,Y,order path , N p ,p tmp , u tmp , L , i , n ); Step 1-11: Bit matrix update: call u s Update module for B path To perform an update, the input parameter is (llr) base B path idx llr_base , i , n ); Step 1-12: Perform LLR loop accumulation: i = i +1, and jump to Step 1-3; in: llr in for N A vector, which is the input to the polar decoder; U is N L A matrix, in which each column corresponds to a decoding path and the corresponding decoding result, totaling [number missing]. L Barcode decoding path; p is L A vector representing the path metric of the decoding path corresponding to each column in U; llr base For (2) N -1) A vector, which is based on a vector idx of length n. llr_base Allocate space for the starting address n Subvectors of different lengths, with lengths of 2 in each order. 0 ,2 1 ,2 2 , ...,2 n , n =log2( N ); LLR path for( nN -(2( N -1)-1)) L A matrix, each column based on a length of n vector idx llr_path Allocate space for the starting address n Subvectors of different lengths, with lengths in the following order: N -2 0 , N -2 1 ,..., N -2 n , n =log2( N ); B path for( nN -(2( N -1)-1)) L A matrix, each column based on a length of n vector idx b_path Allocate space for the starting address n Subvectors of different lengths, with lengths in the following order: N -2 0 , N -2 1 ,..., N -2 n , n =log2( N ); order path for L A vector representing the ascending sorted index of the path metric corresponding to each column of the decoding path in U; p tmp 2 L A 1-dimensional vector is a path metric for temporary decoding paths computed based on p. Each decoding path can derive two decoding paths, hence its dimension is 2. L ; u tmp 2 L A vector, representing the decoding result of the current bit of the temporary decoding path calculated based on p, and related to p. tmp One-to-one correspondence; Y is 5 L Vectors are used to represent... L Parity checks are performed on the decoding results of each path; K The length of the polar-encoded output sequence; N The length of the input sequence for polar decoding. N > K ; N p This represents the number of valid paths, initialized to 1, and cannot exceed [a certain number]. L ; qI represents the set of reliable subchannel indices selected for transmitting the original information bits and check bits, containing ( K+n PC ) elements; qPC represents the set of reliable subchannel indices used for transmitting parity bits, and is a subset of qI, containing... n PC Each element.

2. The low-complexity polar decoding method according to claim 1, characterized in that, The method further includes the following steps: Step 2: Initialize the loop counter. k =1; Step 3: Perform a loop check: if k > N p If the error occurs, the decoding will fail and the decoding process will end. Otherwise, proceed to Step 4; Step 4: Extracting raw information: based on the first step k The decoding result u k The original information c' is extracted as shown in the following formula: Step 5: DCRC Deinterleaving: If i IL If the value is 1, then DCRC deinterleaving is performed; otherwise, the deinterleaving result is directly mapped and denoted as c, as shown in the following formula: Step 6: CRC check: Perform CRC check on the deinterleaving result c. If the check passes, end the decoding and output the decoding result c. Otherwise, proceed to Step 7; Step 7: Loop counting and accumulation: k = k +1, and jump to Step 3; in: m j Indicates DCRC interleaved sequence The Middle j Not less than The element index; Indicates DCRC interleaved sequence The length.

3. The low-complexity polar decoding method according to claim 2, characterized in that, In Steps 1-7, the LLR update module processes the data as follows: Step 1-7-1: Initialize variables i last_next and i start_next As shown in the following formula: Step 1-7-2: Initialize the layer loop counter: j = n ; Step 1-7-3: Perform a loop check: If j If the value is less than 1, the module's processing ends, and the updated LLR is output. base and LLR path Otherwise, continue with Step 1-7-4; Step 1-7-4: Determine if an update is triggered: If any of the following conditions are met, continue to Step 1-7-5; otherwise, proceed to Step 1-7-8. Step 1-7-5: Calculate the a required to update the LLR matrix tmp and b tmp As shown in the following formula: Step 1-7-6: Update LLR base and LLR path As shown in the following formula: Step 1-7-7: Update variables i last_next and i start_next As shown in the following formula: Step 1-7-8: Perform layer-by-layer decrease: j = j -1, and jump to Step 1-7-2.

4. The low-complexity polar decoding method according to claim 3, characterized in that, In Steps 1-10, the path selection module processes the following steps: Step 1-10-1: Reorder temporary path metrics: for p tmp Reorder the indices in ascending order, and denote the reordered set of indices as the vector `order`. tmp ; Step 1-10-2: Calculate the path update set: including the set of newly added path indexes (SET) new Discard Path Index Path Set SET old Add a new path sorting index set SET new_plus ; Step 1-10-3: Initialize the path loop count k =1; Step 1-10-4: Perform path loop judgment: if k >|SET new If |, then jump to Step 1-10-12, |SET new | represents the set SET new The number of elements contained; Otherwise, continue with Step 1-10-5; Step 1-10-5: Update path order and path metric: If N p = L Then update the path order. tmp And the path metric p, as shown in the following formula; otherwise, proceed directly to Step 1-10-6; Step 1-10-6: Initialize the layer loop count j =1; Step 1-10-7: Perform layered loop checks: If j > n If so, proceed to Step 1-10-10; Otherwise, continue with Step 1-10-8; Step 1-10-8: Path Copying: Reset LLR path and B path As shown in the following formula: Step 1-10-9: Increment the layer loop count: j = j +1, and jump to Step 1-10-7; Step 1-10-10: Reset Y and U as shown in the following formula: Step 1-10-11: Accumulate the path loop count: k = k +1, and jump to Step 1-10-4; Step 1-10-12: Update path information: Update first N p In updating p and order path As shown in the following formula: 。 5. The low-complexity polar decoding method according to claim 4, characterized in that, In Step 1-10-2: The formula for calculating the path update set is as follows: in, This represents the empty set.

6. The low-complexity polar decoding method according to claim 5, characterized in that, In Step 1-11, u s The update module processing procedure is as follows: Step 1-11-1: Initialize the path loop counter: k =1; Step 1-11-2: Perform path loop judgment: if k > N p If the condition is met, the processing of this module ends; otherwise, continue to Step 1-11-3. Step 1-11-3: Initialize the layer loop counter: j =1; Step 1-11-4: Perform layered loop checks: If j > n If the condition is met, proceed to Step 1-11-7; otherwise, continue to Step 1-11-5. Step 1-11-5: Update the bit matrix, i.e., update B. path The update will be performed according to the following two scenarios, as shown in the following formula: Step 1-11-6: Perform layer loop counting accumulation: j = j +1, and jump to Step 1-11-4; Step 1-11-7: Perform path loop counting and accumulation: k = k +1, and jump to Step 1-11-2.

Images