Fast node polarization code decoding method for parity check

Abstract

The invention discloses a fast node polarization code decoding method for parity check, and belongs to the field of wireless communication signal processing. According to the method, hardware implementation complexity and decoding delay are comprehensively considered, an existing decoding method is improved on the basis of an SCL decoding algorithm assisted by mixed parity check and CRC, parity check bits are inserted into a sequence, the parity check bits are used for conducting parity check processing on the sequence in a segmented mode, and when a parity check node is decoded during decoding, the sequence is decoded to the CRC node. A path passing the parity check and having the most reliable path metric is reserved among the plurality of paths. Compared with the traditional Polar code decoding algorithm, the method provided by the invention has the advantages that the decoding delay is reduced by utilizing the fast nodes, and meanwhile, the decoding path is segmented by adopting a parity check mode and the segments are pruned, so that the calculation complexity of the decoding algorithm is reduced.

Description

Technical Field

[0001] This invention relates to the field of wireless communication signal processing, and more specifically to wireless communication polar code decoding technology. Background Technology

[0002] In May 2017, the 3GPP (3rd Generation Partnership Project) officially released Release 15 (R15), the first technical standard for fifth-generation mobile communication systems. Under this standard, Polar codes and low-density parity-check codes (LDPC) were jointly identified as the core channel coding technologies for 5G New Radio (NR). According to the standard specifications, the downlink shared channel (PDSCH) and uplink shared channel (PUSCH) use quasi-cyclic LDPC codes (QC-LDPC), while the control information channel (DCI, UCI) and broadcast channel (PBCH) primarily utilize Polar coding schemes. It is worth noting that the Polar code theory proposed by information theorist Arikan has been rigorously proven that when the code length approaches infinity, its channel capacity can reach the theoretical maximum value of the Shannon limit.

[0003] In short code length scenarios, Polar coding exhibits superior performance characteristics compared to LDPC coding. Especially in low coding rate scenarios, the computational complexity of Polar coding is significantly lower than that of LDPC coding. This technical advantage makes it valuable in special applications such as satellite communication and long-distance ocean communication. Since satellite spread spectrum communication systems generally employ short code designs, using Polar coding schemes can significantly improve the system's transmission reliability. Furthermore, in the baseband processing unit of modern communication systems, the channel decoding module typically occupies a large amount of hardware logic resources; therefore, its algorithm optimization remains a key breakthrough for improving the overall system performance.

[0004] In the research of decoding algorithms, Arikan's earliest proposed Serial Cancellation (SC) decoding method performed poorly under short code conditions. To address this limitation, subsequent research focused on improvements in three dimensions: decoding reliability, computational complexity, and processing latency. Among these, the List-based Successive Cancellation (SCL) algorithm proposed by Tal and Vardy effectively mitigated the error propagation problem in the traditional SC algorithm by retaining multiple candidate paths in parallel. A further improvement, the CA-SCL algorithm, innovatively introduced a Cyclic Redundancy Check (CRC) mechanism to improve the accuracy of the final decoding result through check filtering. Notably, other studies, by defining four special types of nodes and their fast processing methods, significantly reduced processing latency while maintaining decoding performance, providing a new technical path for the implementation of real-time communication systems. The continuous evolution of these algorithms not only promoted the development of channel coding theory but also laid an important foundation for the practical deployment of 5G and future communication systems.

[0005] Decoding methods for Polar codes still face many challenges, specifically:

[0006] (1) The initial SC decoding algorithm had simple rules, but the decoding effect was not ideal under finite code length, and the serial decoding mechanism caused a large decoding delay.

[0007] (2) Decoding algorithms represented by SCL improve decoding performance by increasing the decoding search path, but retaining multiple decoding paths will multiply the decoding complexity.

[0008] (3) Decoding algorithms represented by fast nodes accelerate decoding and reduce decoding latency by defining special nodes and performing simplified decoding processing on special nodes, but do not consider the optimization of the decoding path. Summary of the Invention

[0009] This invention proposes a fast nodal polar code decoding method with parity checking to reduce the decoding delay and computational complexity of Polar codes.

[0010] The technical solution adopted in this invention is as follows:

[0011] A fast nodal polar code decoding method with parity checking, comprising the following steps:

[0012] Step 1: Initialize the intermediate decoding variables based on the input decoding code block (i.e., the soft information to be decoded) and decoding parameters;

[0013] The decoding parameters include: the special node index I in the decoding block. tsn Parity check node index I pc Among them, I fsn ={{idx1,len1},{idx2,len2},...,{idx k ,len k},...,{idx M ,len M}}, where M is the number of special nodes in the decoded code block, and idx k Let len ​​be the node type of the k-th special node in the code block. k Let I be the node length of the k-th node; pc =[p1,p2,...,p k ,...,p T ], where T is the number of parity check nodes inserted in the decoded block, p k Let K be the position of the kth parity check node in the code block, K be the length of the effective information bits in the decoded block, and L be the maximum number of decoded lists to be retained during decoding.

[0014] The intermediate variables for decoding include: a list of decoding paths Λ={L1}, a decoding position index i, and a path metric vector PM, where the length of the path metric vector PM is L, and L1 represents the initial decoding path;

[0015] Step 2: Update the intermediate layer soft information LLR according to the input Polar code decoding structure until the layer containing the special node is decoded;

[0016] Step 3, based on special node index I fsn len k Determine the length of special nodes to be processed: based on len k Obtain the layer number of the layer containing the special node. According to the Polar code decoding structure, perform the decision operation of serial cancellation decoding until... The layers, and during the computation and processing, perform different special node processing based on the special node type;

[0017] Among them, special node processing includes: channel layer decoding result calculation, decoding path splitting, and decoding path metric PM value update in path metric vector PM;

[0018] Step 4, based on parity check node index I pc Determine whether the decoding has reached the parity check location. If the decoding has reached the parity check node location, perform parity check on the parity check segments corresponding to all decoding paths.

[0019] Furthermore, when inserting parity bits, the parity bits are arranged at the end of the segment so that the inserted parity bits have the characteristics of being dense at the beginning and sparse at the end.

[0020] Step 5: Delete the paths that fail the parity check and update the current decoding path list Λ;

[0021] Step 6: If the decoding of the code block is not completed, return to step 2; if all bits of the code block are decoded, perform cyclic redundancy check (CRC check) on all decoding paths, and then select the path with the smallest PM from the paths that pass the CRC check and output it; if none of them pass the CRC check, select the path with the smallest PM as the decoding result output.

[0022] Furthermore, in step 2, the Polar code decoding structure is generated by combining multiple unit decoding factors. Each unit decoding factor includes two decision operations: the f operation and the g operation. The specific operation expressions are as follows:

[0023] f(L1,L2)=sgn(L1)sgn(L2)min(|L1|,|L2|)

[0024] g(L1,L2,B3)=(1-2B3)·L1+L2

[0025] Where sgn(·) represents taking the sign bit, L1 and L2 represent the soft information input to the unit decoding factor, and B3 is the hard decision result of the f operation, the expression of which is:

[0026] Furthermore, in step 3, the decision operation processing of serial cancellation decoding according to the Polar code decoding structure refers to performing f and g operations according to the Polar code decoding structure to update the soft information of the corresponding layer.

[0027] Furthermore, in step 4, the special node types include four categories:

[0028] The first special node: all leaf nodes are Rate-0 nodes, where Rate-0 indicates a node with a frozen bit position in the channel layer;

[0029] The second special node: all leaf nodes are Rate-1 nodes, where Rate-1 represents the node where the channel layer information bit is located;

[0030] The third special node: Among the leaf nodes, only the node with the smallest number is the Rate-0 node, and the rest are all Rate-1 nodes;

[0031] The fourth special node: Among the leaf nodes, only the node with the largest number is the Rate-1 node, and the rest are all Rate-0 nodes.

[0032] Furthermore, the special node processing for various special nodes is as follows:

[0033] First special node:

[0034] The node directly feeds back a vector of all zeros, without path splitting; it only updates the PM value of the original decoding path, updating the PM of the first special node that does not meet the hard decision condition to:

[0035]

[0036] Among them, PM l PM' l These represent the PM before and after the update of the l-th path, respectively. This represents the LLR information of the special node currently being processed in the l-th path of the current decoding path list Λ;

[0037] Second special node:

[0038] Calculate the hard bit information B directly based on the corresponding LLR information. v :

[0039]

[0040] Where i = 1, 2, ..., len k , The sign of the i-th bit of the LLR information of the current node;

[0041] Based on hard bit information B v Calculate the corresponding decoding result:

[0042]

[0043] in, This represents the decoding result, z represents the starting sequence number of the current processing node, and G represents the decoding result. len For a length of len k The Polar code encoding matrix;

[0044] And the decoding path metric PM for the second special node that does not meet the hard decision condition is updated as follows:

[0045]

[0046] in, B represents the hard bit information of the l-th path. v The sign of the j-th bit;

[0047] Third special node:

[0048] Parity checking is performed on the LLR hard decision result of the point to obtain the final hard bit value:

[0049]

[0050] in, Let represent the intermediate hard bit value of the i-th bit, and parity represent the parity value of the LLR hard decision result of the input node. This represents the final hard bit value of the i-th bit;

[0051] Based on the final hard bit information B v The decoding result of the third special node is obtained:

[0052] The update formula for the PM of the fourth special node is:

[0053]

[0054] Where j is the current bit index being processed, and i represents the index of the least reliable node in the node list.

[0055] Fourth special node:

[0056] Calculate the hard bit information B of the fourth special node. v :

[0057]

[0058] in, The sign of the i-th bit of the LLR information of the current node;

[0059] The PM update formula for the fourth special node is:

[0060]

[0061] Furthermore, in step 4, the expression for parity checking is:

[0062]

[0063] Where parity_check represents the parity check result, r s-1 and r s These represent the start and end positions of the parity check segment of the current code block, respectively. u represents the hard decision result of the current node's LLR input, and the subscript r... s-1 and r s These are the start and end positions of the parity check segment of the current code block, respectively.

[0064] The technical solution provided by this invention brings at least the following beneficial effects:

[0065] Considering both hardware implementation complexity and decoding latency, this invention improves upon existing decoding methods by employing a hybrid parity check and CRC-assisted SCL decoding algorithm. Parity bits are inserted into the sequence, and these bits are used to segment the sequence for parity checking. During decoding, when a parity check node is encountered, the path that passes parity check and has the most reliable path metric is retained among multiple paths. Compared to traditional Polar code decoding algorithms, this invention utilizes fast nodes to reduce decoding latency and employs parity checking to segment the decoding path and prune at the segmentation points, thereby reducing the computational complexity of the decoding algorithm. Attached Figure Description

[0066] To more clearly illustrate the technical solutions in the embodiments of the present invention, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the accompanying drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0067] Figure 1 This is a flowchart illustrating a fast node polar code decoding method for parity checking proposed in an embodiment of the present invention.

[0068] Figure 2 This is a flowchart illustrating the steps of a fast node polar code decoding method for parity checking in an embodiment of the present invention.

[0069] Figure 3 This is a diagram of the Polar code decoding structure according to an embodiment of the present invention;

[0070] Figure 4 This is a diagram showing the sub-channel polarization weight distribution in an embodiment of the present invention when the Polar code N=512 and K=256.

[0071] Figure 5 This is a comparison chart of the decoding performance of the present invention when N=256 and K=128 in Polar code.

[0072] Figure 6 This is a comparison chart of the decoding performance of the present invention when N=512 and K=256 in Polar code.

[0073] Figure 7 The number of entries at fast nodes is compared for different algorithms, where (a) N = 256, K = 128; (b) N = 512, K = 256.

[0074] Figure 8 This is a comparison chart of the bit error rates of different code types in an embodiment of the present invention. Detailed Implementation

[0075] 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 described in detail and completely below with reference to the accompanying drawings. Obviously, the described embodiments are only a part of the embodiments of this application, and not all of them. Generally, the components of the embodiments of the present invention described and shown in the accompanying drawings can be arranged and designed using different configurations. Therefore, the following detailed description of the embodiments of the present invention provided in the accompanying drawings is not intended to limit the scope of the claimed application, but merely represents selected embodiments of the present invention.

[0076] See Figure 1 and Figure 2 The specific implementation steps of the parity-checking fast node polar code decoding method (S-PC-CASCL) provided in this embodiment of the invention include:

[0077] (1) First, the internal variables are initialized. The input to the decoding algorithm is the soft-demodulated LLR (log-likelihood ratio), denoted as y. N N is the length of the decoded code block. That is, y N The input is soft information, with a data length of N. Special node index number I. fsn I fsnAn index used for a specific node in a code block can be represented as I. fsn ={{idx1,len1},{idx2,len2},...,{idx k ,len k},...,{idx M ,len M}}, where M is the number of special nodes in the decoded code block, idx k Let len ​​be the node type of the k-th special node in the code block. k Let I be the node length of the k-th node. Parity node index I pc , can be represented as I pc =[p1,p2,...,p k ,...,p T ], where T is the number of parity check nodes inserted in the code block, p k Let be the position of the k-th parity check node in the code block. The length of the effective information bits in the code block is K, and the maximum number of decoder lists retained during decoding is L. Initialize the intermediate decoding variables according to the input parameters: the decoding path indicator set Λ={L1}, the decoding position index i, and the path metric (PM) value vector PM. The path metric is used to measure the reliability of the decoding path, and the maximum number of paths retained is L; therefore, the length of the path metric vector PM is L.

[0078] (2) After initialization, the intermediate LLR will be updated according to the Polar code decoding structure until the layer containing the special node is decoded. For example... Figure 3 The following is the decoding structure of Polar codes:

[0079] Let λ = λ max The layer is called the channel layer (λ represents the channel layer index), and the corresponding value is the channel layer LLR, for a code block of length N. The bits to be decoded are distributed at λ=0, and the intermediate layer λ i ,i=1,...,λ max -1. In the serial decoding process, the first bit to obtain the decoding result is at the λ=0 layer. The LLR of the channel layer is based on the soft information input to the decoder. The LLRs of other layers are obtained using the following recursive method. For ease of description, the decoding structure consists of multiple unit decoding factors ( Figure 3 The unit factor is generated by combining elements within a single red dashed box (representing a unit decoding factor). The two operations involved in calculating the LLR are defined as the f operation and the g operation, respectively. Figure 3 (As shown in red in the middle), the result of the f operation is in the upper left corner of the unit factor (denoted as L3), and the result of the g operation is in the lower right corner of the unit factor (denoted as L4):

[0080] L3=f(L1,L2)=sgn(L1)sgn(L2)min(|L1|,|L2|)

[0081] L4=g(L1,L2,B3)=(1-2B3)·L1+L2

[0082] In the above formula, sgn(·) represents taking the sign bit, and L1 and L2 represent the LLR input to the unit factor (e.g., ...). Figure 3 In the equations y1 and y5), B3 represents the hard decision result of L3:

[0083]

[0084] (3) Based on special node index I fsn len k Determine the length of the special node to be processed, based on len. k The layer containing the special node is determined by the size of the special node. The size of the special node is denoted as len. k The layer number of the special node The decision operation of serial cancellation decoding is performed according to the decoding structure (i.e., based on the two decision functions of the configured SC algorithm: f function and g function, f operation and g operation are performed) until... The layer proceeds to different nodes for processing based on node type. It is also determined by a specific node index (I). fsn idx k The special node type is determined. There are four special node types: Rate-0, Rate-1, SPC, and REP. The classification criteria for special nodes are shown in Table 1, and the classification is related to the position of information bits in the code block. Special node processing mainly includes channel layer decoding result calculation, decoding path splitting, and decoding path metric PM value update.

[0085] Table 1 Characteristics of Special Nodes

[0086]

[0087] For the Rate-0 node, all leaf nodes in the subtree demarcated from the Rate-0 node are frozen bits. When decoding to the Rate-0 node, the node directly feeds back a vector of all zeros. Without path splitting, only the original decoding path PM is updated. For paths that do not meet the hard decision condition, the PM is updated as follows:

[0088]

[0089] in, This represents the LLR input of the special node currently being processed in the l-th path of the existing list, with a node length of len. k .

[0090] The decoded bits corresponding to Rate-1 nodes are all information bits. When decoding to a Rate-1 node, the hard bit information B is directly calculated based on the corresponding LLR information. v :

[0091]

[0092] Where i = 1, 2, ..., len k After calculating all the hard bit information using the above formula, the decoding result of the information bits corresponding to the Rate-1 section can be directly calculated using the following formula, where G len For a length of len k Polar code encoding matrix:

[0093]

[0094] in, The current decoding result is represented by u, where u represents the hard decision result of the input current node's LLR, and u[minL v The symbol ] indicates the hard decision result for the corresponding symbol position within the brackets.

[0095] The length is len k The Rate-1 node will be... For secondary path splitting, the PM update formula for paths that do not meet the hard decision condition is as follows:

[0096]

[0097] The SPC node needs to perform parity checking on the input LLR hard decision result of the special node to obtain the final hard bit value:

[0098]

[0099] After obtaining the hard bit value of the node, the decoding result for the corresponding information bit is calculated using the same formula as that for the Rate-1 node. The SPC node splits upon receiving the hard bit return value of the information bit. Next, the PM update formula for the SPC node is as follows, where j is the bit number currently being processed:

[0100]

[0101] The REP node has only the last bit as an information bit. Summing the LLRs of all input nodes yields the hard-bit decision result B. v :

[0102]

[0103] The PM update formula for REP nodes is:

[0104]

[0105] (4) Based on parity check node index I pc Determine if the decoding has reached the parity check location. If it has, perform parity checking on all parity check segments corresponding to the decoding path.

[0106]

[0107] Where r s-1 and r s These are the start and end positions of the parity check segment of the current code block, respectively.

[0108] The position of the parity check node is related to the polarization subchannel weights during Polar coding. When the code length is 512 bits and the effective information bits are 256, the polarization subchannel weight distribution using the β-expansion-based channel polarization weight metric method is as follows: Figure 4 As shown, the inductive sub-channel polarization weights exhibit the following characteristics:

[0109] (a) The information bits are distributed in segments, and the segments at the beginning (with smaller index numbers) are shorter.

[0110] (b) The later the position of the channel (the larger the index number), the larger the overall polarization weight, and the higher the reliability of the channel.

[0111] When inserting parity bits, the parity bits are placed at the end of the segment, a position with high channel reliability. Based on the distribution characteristics of the sub-channel polarization weights, the inserted parity bits exhibit a dense pattern at the beginning and a sparse pattern at the end. Table 2 shows the segmentation situation with 8 parity nodes inserted at a code length of 256 and 512 under a code rate of 0.5.

[0112] Table 2 Segmentation for Different Code Lengths

[0113]

[0114] (5) Delete the paths that fail the parity check and update the current decoding path list Λ.

[0115] (6) When all bits of the code block are decoded, CRC check is performed on all decoding paths. The path with the smallest PM is selected from the paths that pass the CRC check and output. If none of them pass the CRC check, the path with the smallest PM is selected as the decoding result output.

[0116] (7) If the decoding of the code block is not completed, return to step (2).

[0117] Regarding the method (S-PC-CASCL) proposed in the embodiments of the present invention, Figure 5 The processing performance of the proposed method in this embodiment of the invention is demonstrated when the code rate is 0.5 and the code length is 256. For comparison, the SC, CASCL, and S-CASCL algorithms were simulated simultaneously at the same code rate and code length (for details, please refer to "Huang Zhe. Research and Implementation of Key Technologies for Anti-Interception Satellite Communication Systems [D]"). After comparison, the classic SC algorithm has the worst decoding performance. CASCL, due to the addition of a decoding list to broaden the decoding path search space and the use of CRC check to filter the final path, has a significant improvement in decoding performance compared to the classic SC algorithm. Although the S-CASCL algorithm uses approximate processing for special nodes during the decoding process, its decoding performance is comparable to that of the CASCL algorithm. The S-PC-CASCL proposed in this embodiment of the invention has decoding performance comparable to that of the S-CASCL algorithm and is also superior to that of the SC algorithm.

[0118] Figure 6 At a code rate of 0.5 and a code length of 512, the performance of the S-PC-CASCL algorithm is compared to that of the simplified Fast Node-based CRC-aided Successive CancellationList (S-SCASCL) algorithm, which retains only the most reliable path at each segmentation. Due to the increase in code length, the decoding performance of the three algorithms in the figure is relatively... Figure 4 The corresponding algorithm has been improved. Similarly, at a code length of 512, S-PC-CASCL performs comparably to the S-CASCL algorithm in terms of decoding performance.

[0119] Figure 7 In the diagram, (a) and (b) represent the number of lists processed before fast nodes in the decoding process of the three algorithms at different code lengths and signal-to-noise ratios under a code rate of 0.5. The computational complexity of list-based decoding algorithms is positively correlated with the number of lists; the number of lists reflects the computational complexity of the algorithm. S-SCASCL has the lowest number of lists, and S-PC-CASCL has a lower number of lists than S-CASCL. As the signal-to-noise ratio increases, the number of lists in S-PC-CASCL gradually increases because as the channel environment improves, more lists pass parity checks at the segmentation points. At a code length of 256 and a code rate of 0.5, the number of lists generated by S-SCASCL decoding is about 42% lower than that of S-CASCL, but due to... Figure 5As shown in the bit error rate curve, the decoding performance of this algorithm degrades rapidly. In contrast, S-PC-CASCL reduces the number of decoding paths by 16% compared to S-CASCL at a signal-to-noise ratio (SNR) of -2dB, and by 5% at an SNR of 4.5dB. At a 512-code length and a 0.5 code rate, S-PC-CASCL produces approximately 53% of the number of decoding paths as S-CASCL. At an SNR of -2dB, S-PC-CASCL reduces the number of decoding paths by 13%, and by 4% at an SNR of 4.5dB. At lower SNRs, S-PC-CASCL can prune more unnecessary decoding paths and insert more densely for check nodes, resulting in a more significant pruning effect. Furthermore, the S-PC-CASCL algorithm also employs special node processing, thus inheriting the low decoding latency advantage of S-CASCL.

[0120] Because the S-PC-CASCL of this invention is based on special node processing, the algorithm complexity is related to the distribution of special nodes. Further statistical analysis of the number of the four types of special nodes allows for a comparison of algorithm complexity. For Rate-1 and SPC nodes, the main components include min(N) v L-1) times path sorting and N v The process involves comparing long paths, then sorting the current path PM. Rate-0 nodes do not split paths, only perform one path update. REP nodes perform only one path split, one path PM update, and one path sort. When there is no bottleneck in actual hardware parallelism, the processing latency quantization for special nodes is as follows:

[0121] T Rate-0 =1,

[0122] T REP =2,

[0123] T Rate-1 =min(L-1,N) v ),

[0124] T SPC =min(L-1,N) v )+1

[0125] Further analysis reveals the advantages of the proposed method in reducing computational complexity and decoding latency. Table 3 shows the number of nodes and decoding latency of various types in the S-PC-CASCL algorithm decoding process when the signal-to-noise ratio is high (4.5dB), the code types are (30, 128), (60, 128), and (30, 64). Different special nodes have different splitting times, and the computational complexity mainly focuses on Rate-1 and SPC nodes. For a size of N... v The node, Rate-1, will split into N. v Next, the SPC node splits into N.v -1 splits, REP nodes split only once, and Rate-0 nodes do not split paths. The computational complexity and decoding delay statistics of S-CASCL under the same special node partitioning are shown in Table 4.

[0126] Table 3. Number of Nodes, Corresponding List Count, and Bit Error Rate / Delay Statistics (S-PC-CASCL)

[0127]

[0128] Table 4. Number of Nodes, Corresponding List Count, and Error Rate / Delay Statistics (S-CASCL)

[0129]

[0130] The bit error rate curve of the corresponding code type of the S-PC-CASCL algorithm in this embodiment of the invention is as follows: Figure 8 As shown, all three code types still have good error correction performance, with low code rate and long code length code types having better error correction performance.

[0131] Traditional methods have focused on simplifying and accelerating the decoding process to reduce decoding latency, while others aim to reduce the decoding search list by segmenting the process to shorten the search path. The method proposed in this invention further improves upon the fast node decoding algorithm by segmenting and inserting parity check nodes to reduce the decoding search space and computational complexity. This algorithm combines the advantages of reduced decoding latency and shorter decoding search paths.

[0132] The method proposed in this invention uses parity check nodes to segment code blocks. The parity check logic is simple and is implemented by XORing binary fields. The hardware implementation is friendly and does not increase the difficulty of hardware implementation of the decoding algorithm.

[0133] Because poor decoding paths are removed in advance at the segmentation points, the number of decoding lists at special nodes is reduced, thus lowering the computational complexity of the proposed method while maintaining good decoding performance. The pruning effect is particularly pronounced when the signal-to-noise ratio is poor, avoiding unnecessary waste of computational resources.

[0134] Finally, it should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention, and not to limit them; although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some of the technical features; and these modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the spirit and scope of the technical solutions of the embodiments of the present invention.

[0135] The above descriptions are merely some embodiments of the present invention. Those skilled in the art can make various modifications and improvements without departing from the inventive concept of the present invention, and these all fall within the scope of protection of the present invention.

Claims

1. A fast node polar code decoding method with parity checking, characterized in that, Includes the following steps: Step 1: Initialize the intermediate decoding variables based on the input decoding block and decoding parameters; The decoding parameters include: the special node index I in the decoding block. fsn Parity check node index I pc ; I fsn ={{idx1,len1},{idx2,len2},...,{idx k ,len k },...,{idx M ,len M }}, where M is the number of special nodes in the decoded code block, and idx k Let len ​​be the node type of the k-th special node in the code block. k Let be the length of the k-th node; I pc =[p1,p2,...,p k ,...,p T ], where T is the number of parity check nodes inserted in the decoded block, p k Let K be the position of the kth parity check node in the code block, K be the length of the effective information bits in the decoded block, and L be the maximum number of decoded lists to be retained during decoding. The intermediate variables for decoding include: a list of decoding paths Λ={L1}, a decoding position index i, and a path metric vector PM, where L1 represents the initial decoding path and the path metric vector PM has a length of L; Step 2: Update the intermediate layer soft information LLR according to the input Polar code decoding structure until the layer containing the special node is decoded; Step 3, based on special node index I fsn len k Determine the length of special nodes to be processed: based on len k Obtain the layer number of the layer containing the special node. According to the Polar code decoding structure, perform the decision operation of serial cancellation decoding until... Layers, and in the process of computation and processing, different special node processing is performed according to the special node type; Among them, special node processing includes: channel layer decoding result calculation, decoding path splitting, and decoding path metric PM value update in path metric vector PM; Step 4, based on parity check node index I pc Determine whether the decoding has reached the parity check location. If the decoding has reached the parity check node location, perform parity check on the parity check segments corresponding to all decoding paths. Furthermore, when inserting parity bits, the parity bits are arranged at the end of the segment so that the inserted parity bits have the characteristics of being dense at the beginning and sparse at the end. Step 5: Delete the paths that fail the parity check and update the current decoding path list Λ; Step 6: If the decoding of the code block is not completed, return to step 2; if all bits of the code block are decoded, perform cyclic redundancy check on all decoding paths, and then select the path with the smallest PM from the paths that pass the CRC check for output; if none of them pass the CRC check, select the path with the smallest PM as the decoding result output.

2. The method as described in claim 1, characterized in that, In step 2, the Polar code decoding structure is generated by combining multiple unit decoding factors. Each unit decoding factor includes two decision operations: the f operation and the g operation. The specific operation expressions are as follows: f(L1,L2)=sgn(L1)sgn(L2)min(|L1|,|L2|) g(L1,L2,B3)=(1-2B3)·L1+L2 Where sgn(·) represents taking the sign bit, L1 and L2 represent the soft information input to the unit decoding factor, and B3 is the hard decision result of the f operation, the expression of which is:

3. The method as described in claim 2, characterized in that, In step 3, the decision operation of serial cancellation decoding based on the Polar code decoding structure refers to performing f and g operations to update the LLR of the corresponding layer based on the Polar code decoding structure.

4. The method as described in claim 1, characterized in that, In step 4, the special node types include four categories: The first special node: all leaf nodes are Rate-0 nodes, where Rate-0 indicates a node with a frozen bit position in the channel layer; The second special node: all leaf nodes are Rate-1 nodes, where Rate-1 represents the node where the channel layer information bit is located; The third special node: Among the leaf nodes, only the node with the smallest number is the Rate-0 node, and the rest are all Rate-1 nodes; The fourth special node: Among the leaf nodes, only the node with the largest number is the Rate-1 node, and the rest are all Rate-0 nodes.

5. The method as described in claim 4, characterized in that, The special node processing for the first special node includes: The node directly feeds back a vector of all zeros, without path splitting; it only updates the PM value of the original decoding path, updating the PM of the first special node that does not meet the hard decision condition to: And l∈Λ Among them, PM l PM' l These represent the PM before and after the update of the l-th path, respectively. This represents the LLR information of the special node currently being processed in the l-th path of the current decoding path list Λ.

6. The method as described in claim 4, characterized in that, The special node processing for the second special node includes: Calculate the hard bit information B based on the corresponding LLR information. v : Where i = 1, 2, ..., len k , The sign of the i-th bit of the LLR information of the current node; Based on hard bit information B v Calculate the corresponding decoding result: Where z represents the starting sequence number of the current processing node, G len For a length of len k The Polar code encoding matrix; And the decoding path metric PM for the second special node that does not meet the hard decision condition is updated as follows: Among them, PM l PM' l These represent the PM before and after the update of the l-th path, respectively. This represents the LLR information of the special node currently being processed in the l-th path of the current decoding path list Λ; B represents the hard bit information of the l-th path. v The symbol of the j-th bit.

7. The method as described in claim 4, characterized in that, The special node processing for the third special node includes: Parity checking is performed on the LLR hard decision result of the point to obtain the final hard bit value: in, Let represent the intermediate hard bit value of the i-th bit, and parity represent the parity value of the LLR hard decision result of the input node. This represents the final hard bit value of the i-th bit; Based on the final hard bit information B v The decoding result of the third special node is obtained: The update formula for the PM of the fourth special node is: Among them, PM l PM' l These represent the PM before and after the update of the l-th path, respectively. This represents the LLR information of the special node currently being processed in the l-th path of the current decoding path list Λ; j is the bit index currently being processed, and i is the sequence number of the least reliable node among the nodes.

8. The method as described in claim 4, characterized in that, The special node processing for the fourth special node includes: Calculate the hard bit information B of the fourth special node. v : in, The sign of the i-th bit of the LLR information of the current node; The PM update formula for the fourth special node is: Among them, PM l PM' l These represent the PM before and after the update of the l-th path, respectively. This represents the LLR information of the special node currently being processed in the l-th path of the current decoding path list Λ.

9. The method as described in claim 1, characterized in that, In step 4, the expression for parity checking is: Where parity_check represents the parity check result, u represents the hard decision result of the input node's LLR, and the subscript r s-1 and r s These are the start and end positions of the parity check segment of the current code block, respectively.

Images