A sorting method for parallel reading and writing of LDPC blocks with in-order decoding

Abstract

The present invention relates to the field of communication technology, and in particular to a sorting method for parallel reading and writing of LDPC blocks with the same sequence of decoding. The method of the present invention is proposed in order to avoid read-write conflicts, adapt to various BGs, and automatically generate a read-write sequence without changing the layer order during decoding when decoding LDPC blocks with the same sequence of reading and writing. The read-write sequence of the first layer block number is arranged, and the starting position of reading and writing of each layer is calculated; the delay before reading each layer is increased so that only one layer is reading and one layer is writing at the same time, and when reading and writing the same block number, the writing time is before the reading time; when each layer has the same block number as the previous set adjacent layers, the corresponding block number is moved backward; when each layer has the same block number as the next set adjacent layers, the corresponding block number is moved forward; the present invention can automatically output the read-write sequence of parallel decoding of LDPC blocks with the same sequence of reading and writing. The present invention does not change the order of the layers during decoding, avoids read-write conflicts, and greatly reduces the delay required for decoding.

Description

Technical Field

[0001] The present invention relates to the field of communication technology, and in particular to a sorting method applicable to parallel reading and writing of various base graph LDPC (Low-Density Parity-Check, quasi-cyclic LDPC code) blocks with in-sequence decoding. Background Art

[0002] LDPC codes are block error-correcting codes with a coefficient check matrix. They are applicable to almost all channels and have become a research hotspot in the coding community in recent years. Their performance approaches the Shannon limit, and they are simple to describe and implement, making them easy to analyze and study theoretically. Decoding is simple and can be performed in parallel, making them suitable for hardware implementation.

[0003] Block-parallel decoding is a widely used LDPC decoding method. This method can only read and write one block at a time. Furthermore, it must ensure that the last write operation on a block has been completed before reading it. If the block is not fully written during reading, a delay is added, and the reader must wait for the last write to complete before starting to read. The longer the delay, the lower the decoding efficiency, which affects performance.

[0004] At the same time, in order to meet the hardware overhead problem, a block parallel decoding algorithm with consistent reading and writing order will be adopted, which makes it more difficult to reduce latency. Summary of the Invention

[0005] In order to avoid read-write conflicts when decoding LDPC blocks with the same read and write order in parallel without changing the layer order during decoding, significantly reduce the additional delay required for decoding, adapt to various different BGs, and automatically generate the read and write order, the method described in the present invention is proposed.

[0006] The technical solution adopted in the present invention is:

[0007] A method for sequencing LDPC blocks for parallel reading and writing and in-order decoding includes the following steps:

[0008] Step 1: Input the BG matrix to be sorted and get the block number required for each layer;

[0009] Step 2: Arrange the read and write order of the first layer block numbers, and calculate the starting position of reading and writing for each layer; the sorting rule is: the more times a block number is used in the set number of layers after the first layer, the higher the sorting priority of the corresponding block number;

[0010] Step 3: Increase the delay before each layer reads data, so that only one layer is reading and one layer is writing at the same time. When reading and writing the same block number, the writing time is before the reading time.

[0011] Step 4: When each layer has the same block number as the previous set adjacent layers, if a block number causes additional delay, the corresponding block number is moved back and returns to step 3 until the block number order of each layer remains unchanged;

[0012] Step 5: When each layer has the same block number as the next adjacent layer, if a certain block number causes additional delay, the corresponding block number will be moved forward;

[0013] Step 6: Increase the delay before reading each layer so that only one layer is reading and one layer is writing at the same time. When reading and writing the same block number, the writing time is before the reading time. Return to step 5 until the block number order of each layer remains unchanged.

[0014] Step 7: Output the order of reading and writing blocks for each layer, as well as the time when each layer starts.

[0015] Furthermore, the step 2 includes:

[0016] Step 2.1: Define the block number used in the first layer into four parts: ①. Used in both the second and third layers; ②. Used in the second layer, not in the third layer; ③. Not used in the second layer, used in the third layer; ④. Not used in either the second or third layer;

[0017] Step 2.2: Then the first layer is arranged in the order of ①, ②, ③, and ④ and stored in order_buffer(1); the starting position of reading is recorded as 1 and stored in read_pos_buffer(1); the starting position of writing is recorded as d+rowdegree(1) and stored in write_pos_buffer(1); where d is the required delay between read and write operations at each layer, and rowdegree(1) stores the number of blocks used in the first layer;

[0018] The second to last layer layer_num are arranged in the original order of the BG matrix and stored in the corresponding order_buffer(k); the starting position of the k-th layer is recorded as: Stored in read_pos_buffer(k); the starting position of writing in the kth layer is recorded as: read_pos_buffer(k)+d+rowdegree(k), stored in write_pos_buffer(k); where 2≤k≤layer_num; rowdegree(k) stores the number of blocks used in the kth layer; order_buffer(k) stores the order of reading and writing blocks in the kth layer, with a length of rowdegree(k); read_pos_buffer(k) stores the time when the kth layer reads the first block; write_pos_buffer(k) stores the time when the kth layer writes the first block.

[0019] Furthermore, the step 3 includes:

[0020] From the second layer to the layer_num layer, the sequence loop is repeated, where the kth layer processing process is:

[0021] Step 3.1: Detect simultaneous read and write conflicts: Calculate the position of the last read on the k-1 layer, read_pos_buffer(k-1)+rowdegree(k-1)-1, and the position of the first read on the k layer, read_pos_buffer(k), and take the difference between the two to get delay1. Calculate the position of the last write on the k-1 layer, write_pos_buffer(k-1)+rowdegree(k-1)-1, and the position of the first write on the k layer, write_pos_buffer(k), and take the difference between the two to get delay2.

[0022] Step 3.2: Shared block conflict detection: Loop through each block used by the current layer, calling the current loop block block_same; loop through up to three layers above the current layer, i.e., k-1, k-2, and k-3; if k is the second layer, loop through only k-1; if k is the third layer, loop through only k-1 and k-2; if k is greater than 3, loop through k-1, k-2, and k-3 layers; the kq processing for each layer is as follows: if both the kth layer and the kqth layer use block_same, then subtract the position where block_same is written in the kqth layer from the position where block_same is read in the kth layer, obtaining several difference values, delay3, delay4, etc.;

[0023] Step 3.3: Conflict redundancy elimination: Find the maximum value delay_max in [delay1 delay2 delay3 delay4…]. If delay_max+1 is positive, then the values ​​of read_pos_buffer(k) and write_pos_buffer(k) corresponding to the kth layer to the layer_numth layer are both increased by delay_max+1; if delay_max+1 is negative, then the values ​​of read_pos_buffer(k) and write_pos_buffer(k) corresponding to the kth layer to the layer_numth layer are both reduced by |delay_max+1|; if delay_max+1 is 0, then the values ​​of read_pos_buffer(k) and write_pos_buffer(k) corresponding to the kth layer to the layer_numth layer remain unchanged.

[0024] Furthermore, the step 4 includes:

[0025] From the second layer to the layer_num layer, the sequence loop is repeated, where the kth layer processing process is:

[0026] Step 4.1: For the current loop layer, i.e., the kth layer, use the second-to-last block to the first block to loop sequentially. The current loop block order_buffer(k)(p) is called block_current, and the next block order_buffer(k)(p+1) is called block_after.

[0027] Step 4.2: If k is the second layer, only loop k-1. If k is the third layer, only loop k-1 and k-2. If k is greater than 3, loop k-1, k-2, and k-3 layers. The processing process for each layer kq is:

[0028] Check whether the kqth layer uses block_after. If so, and the difference between the time when the kth layer reads block_after and the time when the kqth layer writes block_after is 1, return to step 4.1 to loop the next block. If the difference does not reach 1 after looping through the k-1, k-2, and k-3 layers, proceed to the next step.

[0029] Step 4.3: If k is the second layer, only loop k-1. If k is the third layer, only loop k-1 and k-2. If k is greater than 3, loop k-1, k-2, and k-3 layers. The processing process for each layer km is:

[0030] Check whether the km-th layer uses block_current. If so, and the difference between the time when the k-th layer reads block_current and the time when the km-th layer writes block_current is 1, then execute the next step. If the difference does not reach 1 after looping through the k-1, k-2, and k-3 layers, then return to step 4.1 to loop for the next block.

[0031] Step 4.4: Exchange the positions of block_current and block_after in order_buffer(k) and return to step 4.1 to loop for the next block.

[0032] Furthermore, the step 5 includes:

[0033] From the second layer to the layer_num layer, the processing process of each layer is:

[0034] Step 5.1: Loop sequentially from the second block to the last block used in the current loop layer k. The current loop block order_buffer(k)(p) is called block_current, and the previous block order_buffer(k)(p-1) is called block_before.

[0035] Step 5.2: Loop through layers k-1, k-2, and k-3. The processing for each layer kq is as follows: Check whether the kq layer uses block_current. If so, and the difference between the time when the kth layer reads block_current and the time when the kqth layer writes block_current is 1, then return to step 5.1 and loop through the next block. If the difference does not equal 1 after looping through layers k-1, k-2, and k-3, then proceed to the next step.

[0036] Step 5.3: Loop through layers k+1, k+2, and k+3. The process for each layer k+m is as follows: Check whether layer k+m uses block_before. If so, and the difference between the time layer k+m reads block_before and the time layer k writes block_before is 1, then return to step 5.1 and loop through the next block. If the difference between layers k+1, k+2, and k+3 does not equal 1, proceed to the next step.

[0037] Step 5.4: Loop through layers k+1, k+2, and k+3. The process for each layer k+n is as follows: Check whether layer k+n uses block_current. If not, or if it does but the difference between the time when layer k+n reads block_current and the time when layer k writes block_current is not 1, then return to step 5.1 and loop through the next block. Otherwise, proceed to the next step.

[0038] Step 5.5: Exchange the positions of block_current and block_before in order_buffer(k) and return to step 5.1 to loop for the next block.

[0039] The advantages of the present invention compared to the prior art are:

[0040] 1. The present invention can automatically output the LDPC block parallel decoding reading and writing sequence with the same reading and writing order.

[0041] 2. The present invention does not change the order of layers during decoding, thereby avoiding read-write conflicts and significantly reducing the delay required for decoding.

[0042] 3. The present invention is applicable to various BGs. BRIEF DESCRIPTION OF THE DRAWINGS

[0043] Figure 1 This is an overall flow chart of an embodiment of the present invention.

[0044] Figure 2 This is a flow chart of step 4 of an embodiment of the present invention.

[0045] Figure 3 This is a flow chart of step 5 of an embodiment of the present invention.

[0046] Figure 4 This is an example diagram of the change in NR BG1 delay times and the required number of iterations in an embodiment of the present invention.

[0047] Figure 5 This is an example diagram of the change in NR BG2 delay times and the required number of iterations in an embodiment of the present invention. DETAILED DESCRIPTION

[0048] The present invention will be further explained below with reference to the accompanying drawings.

[0049] like Figure 1 As shown, a method for sorting LDPC blocks for parallel reading and writing and in-order decoding includes the following steps:

[0050] Step 1: Input the BG matrix to be sorted and get the block number needed for each layer.

[0051] Step 2: Arrange the read and write order of the first layer block numbers, and calculate the starting position of reading and writing for each layer; the sorting rule is: the more times the block number is used in the set number of layers after the first layer, the higher the sorting priority of the corresponding block number; specifically, it includes:

[0052] Step 2.1: Define the block number used in the first layer into four parts: ①. Used in both the second and third layers; ②. Used in the second layer, not in the third layer; ③. Not used in the second layer, used in the third layer; ④. Not used in either the second or third layer;

[0053] Step 2.2: Then the first layer is arranged in the order of ①, ②, ③, and ④ and stored in order_buffer(1); the starting position of reading is recorded as 1 and stored in read_pos_buffer(1); the starting position of writing is recorded as d+rowdegree(1) and stored in write_pos_buffer(1); where d is the required delay between read and write operations at each layer, and rowdegree(1) stores the number of blocks used in the first layer;

[0054] The second to last layer layer_num are arranged in the original order of the BG matrix and stored in the corresponding order_buffer(k); the starting position of the k-th layer is recorded as: Stored in read_pos_buffer(k); the starting position of writing in the kth layer is recorded as: read_pos_buffer(k)+d+rowdegree(k), stored in write_pos_buffer(k); where 2≤k≤layer_num; rowdegree(k) stores the number of blocks used in the kth layer; order_buffer(k) stores the order of reading and writing blocks in the kth layer, with a length of rowdegree(k); read_pos_buffer(k) stores the time when the kth layer reads the first block; write_pos_buffer(k) stores the time when the kth layer writes the first block.

[0055] Step 3: Increase the delay before each layer reads data, so that only one layer is reading and one layer is writing at the same time. When reading and writing the same block number, the writing time is before the reading time. Specifically:

[0056] From the second layer to the layer_num layer, the sequence loop is repeated, where the kth layer processing process is:

[0057] Step 3.1: Detect simultaneous read and write conflicts: Calculate the position of the last read on the k-1 layer, read_pos_buffer(k-1)+rowdegree(k-1)-1, and the position of the first read on the k layer, read_pos_buffer(k), and take the difference between the two to get delay1. Calculate the position of the last write on the k-1 layer, write_pos_buffer(k-1)+rowdegree(k-1)-1, and the position of the first write on the k layer, write_pos_buffer(k), and take the difference between the two to get delay2.

[0058] Step 3.2: Shared block conflict detection: Loop through each block used by the current layer, calling the current loop block block_same; loop through up to three layers above the current layer, i.e., k-1, k-2, and k-3; if k is the second layer, loop through only k-1; if k is the third layer, loop through only k-1 and k-2; if k is greater than 3, loop through k-1, k-2, and k-3 layers; the kq processing for each layer is as follows: if both the kth layer and the kqth layer use block_same, then subtract the position where block_same is written in the kqth layer from the position where block_same is read in the kth layer, obtaining several difference values, delay3, delay4, etc.;

[0059] Step 3.3: Conflict redundancy elimination: Find the maximum value delay_max in [delay1 delay2 delay3 delay4…]. If delay_max+1 is positive, then the values ​​of read_pos_buffer(k) and write_pos_buffer(k) corresponding to the kth layer to the layer_numth layer are both increased by delay_max+1; if delay_max+1 is negative, then the values ​​of read_pos_buffer(k) and write_pos_buffer(k) corresponding to the kth layer to the layer_numth layer are both reduced by |delay_max+1|; if delay_max+1 is 0, then the values ​​of read_pos_buffer(k) and write_pos_buffer(k) corresponding to the kth layer to the layer_numth layer remain unchanged.

[0060] Step 4: When each layer has the same block number as the previous set adjacent layers, if a block number causes additional delay, the corresponding block number is moved back and returns to step 3 until the block number order of each layer remains unchanged;

[0061] The specific process is as follows Figure 2 As shown, the loop is performed sequentially from the second layer to the layer_num layer, where the kth layer processing process is:

[0062] Step 4.1: For the current loop layer, i.e., the kth layer, use the second-to-last block to the first block to loop sequentially. The current loop block order_buffer(k)(p) is called block_current, and the next block order_buffer(k)(p+1) is called block_after.

[0063] Step 4.2: If k is the second layer, only loop k-1. If k is the third layer, only loop k-1 and k-2. If k is greater than 3, loop k-1, k-2, and k-3 layers. The processing process for each layer kq is:

[0064] Check whether the kqth layer uses block_after. If so, and the difference between the time when the kth layer reads block_after and the time when the kqth layer writes block_after is 1, return to step 4.1 to loop the next block. If the difference does not reach 1 after looping through the k-1, k-2, and k-3 layers, proceed to the next step.

[0065] Step 4.3: If k is the second layer, only loop k-1. If k is the third layer, only loop k-1 and k-2. If k is greater than 3, loop k-1, k-2, and k-3 layers. The processing process for each layer km is:

[0066] Check whether the km-th layer uses block_current. If so, and the difference between the time when the k-th layer reads block_current and the time when the km-th layer writes block_current is 1, then execute the next step. If the difference does not reach 1 after looping through the k-1, k-2, and k-3 layers, then return to step 4.1 to loop for the next block.

[0067] Step 4.4: Exchange the positions of block_current and block_after in order_buffer(k) and return to step 4.1 to loop for the next block.

[0068] Step 5: When each layer has the same block number as the next adjacent layer, if a certain block number causes additional delay, the corresponding block number will be moved forward;

[0069] The specific process is as follows Figure 3 As shown, the process from the second layer to the layer_num layer is looped sequentially, and the processing of each layer is:

[0070] Step 5.1: Loop sequentially from the second block to the last block used in the current loop layer k. The current loop block order_buffer(k)(p) is called block_current, and the previous block order_buffer(k)(p-1) is called block_before.

[0071] Step 5.2: Loop through layers k-1, k-2, and k-3. The processing for each layer kq is as follows: Check whether the kq layer uses block_current. If so, and the difference between the time when the kth layer reads block_current and the time when the kqth layer writes block_current is 1, then return to step 5.1 and loop through the next block. If the difference does not equal 1 after looping through layers k-1, k-2, and k-3, then proceed to the next step.

[0072] Step 5.3: Loop through layers k+1, k+2, and k+3. The process for each layer k+m is as follows: Check whether layer k+m uses block_before. If so, and the difference between the time layer k+m reads block_before and the time layer k writes block_before is 1, then return to step 5.1 and loop through the next block. If the difference between layers k+1, k+2, and k+3 does not equal 1, proceed to the next step.

[0073] Step 5.4: Loop through layers k+1, k+2, and k+3. The process for each layer k+n is as follows: Check whether layer k+n uses block_current. If not, or if it does but the difference between the time when layer k+n reads block_current and the time when layer k writes block_current is not 1, then return to step 5.1 and loop through the next block. Otherwise, proceed to the next step.

[0074] Step 5.5: Exchange the positions of block_current and block_before in order_buffer(k) and return to step 5.1 to loop for the next block.

[0075] Step 6: Increase the delay before reading each layer so that only one layer is reading and one layer is writing at the same time. When reading and writing the same block number, the writing time is before the reading time. Return to step 5 until the block number order of each layer remains unchanged.

[0076] Step 7: Output the order of reading and writing blocks for each layer, as well as the time when each layer starts.

[0077] Taking NR as an example, two types of BGs are used in NR (3GPP TS 38.212 Table 5.3.2-2, Table 5.3.2-3).

[0078] After BG1 executes 22 backward shifts and 12 forward shifts (including the last one without adjustment), it needs to increase the delay by 95 to ensure no conflict; without any strategy, it needs to increase the delay by 140.

[0079] Figure 4 The change in the number of delays required after moving backward and forward: (the first value is the number of delays after initial adjustment)

[0080] After BG2 executes 11 backward shifts and 4 forward shifts (including the last one without adjustment), it needs to increase the delay by 91 to ensure no conflict; without any strategy, it needs to increase the delay by 143.

[0081] Figure 5 The change in the number of delays required after moving backward and forward: (the first value is the number of delays after the initial adjustment).

[0082] The above describes specific embodiments of the present invention. It should be understood that the present invention is not limited to the specific embodiments described above, and that those skilled in the art may make various changes or modifications within the scope of the claims without affecting the essence of the present invention. The embodiments of this application and the features in the embodiments may be combined with each other in any manner unless there is a conflict.

Claims

1. A method for sorting LDPC blocks for parallel reading and writing and in-order decoding, characterized in that: The following processes are included: Step 1: Input the BG matrix to be sorted and get the block number required for each layer; Step 2: Arrange the read and write order of the first layer block numbers, and calculate the starting position of reading and writing for each layer; the sorting rule is: the more times a block number is used in the set number of layers after the first layer, the higher the sorting priority of the corresponding block number; Step 3: Increase the delay before each layer reads data, so that only one layer is reading and one layer is writing at the same time. When reading and writing the same block number, the writing time is before the reading time. Step 4: When each layer has the same block number as the previous set adjacent layers, if a block number causes additional delay, the corresponding block number is moved back and returns to step 3 until the block number order of each layer remains unchanged; Step 5: When each layer has the same block number as the next adjacent layer, if a certain block number causes additional delay, the corresponding block number will be moved forward; Step 6: Increase the delay before each layer reads data, so that only one layer is reading and one layer is writing at the same time. When reading and writing the same block number, the writing time is before the reading time. Return to step 5 until the order of block numbers in each layer remains unchanged; Step 7: Output the order of reading and writing blocks for each layer, as well as the time when each layer starts.

2. The method for sorting LDPC blocks for parallel reading and writing and in-order decoding according to claim 1, wherein: The step 2 includes: Step 2.1: Define the block number used in the first layer into four parts: ①. Used in both the second and third layers; ②. Used in the second layer, not in the third layer; ③. Not used in the second layer, used in the third layer; ④. Not used in either the second or third layer; Step 2.2: Then the first layer is arranged in the order of ①, ②, ③, and ④ and stored in order_buffer(1); the starting position of reading is recorded as 1 and stored in read_pos_buffer(1); the starting position of writing is recorded as d+rowdegree(1) and stored in write_pos_buffer(1); where d is the required delay between read and write operations at each layer, and rowdegree(1) stores the number of blocks used in the first layer; The second to last layer layer_num are arranged in the original order of the BG matrix and stored in the corresponding order_buffer(k); the starting position of the k-th layer is recorded as: Stored in read_pos_buffer(k); the starting position of writing in the kth layer is recorded as: read_pos_buffer(k)+d+rowdegree(k), stored in write_pos_buffer(k); where 2≤k≤layer_num; rowdegree(k) stores the number of blocks used in the kth layer; order_buffer(k) stores the order of reading and writing blocks in the kth layer, with a length of rowdegree(k); read_pos_buffer(k) stores the time when the kth layer reads the first block; write_pos_buffer(k) stores the time when the kth layer writes the first block.

3. The method for sorting LDPC blocks for parallel reading and writing and in-order decoding according to claim 2, characterized in that: The step 3 includes: From the second layer to the layer_num layer, the sequence loop is repeated, where the kth layer processing process is: Step 3.1: Detect simultaneous read and write conflicts: Calculate the position of the last read on the k-1 layer, read_pos_buffer(k-1)+rowdegree(k-1)-1, and the position of the first read on the k layer, read_pos_buffer(k), and take the difference between the two to get delay1. Calculate the position of the last write on the k-1 layer, write_pos_buffer(k-1)+rowdegree(k-1)-1, and the position of the first write on the k layer, write_pos_buffer(k), and take the difference between the two to get delay2. Step 3.2: Shared block conflict detection: Loop through each block used by the current layer, calling the current loop block block_same; loop through up to three layers above the current layer, i.e., k-1, k-2, and k-3; if k is the second layer, loop through only k-1; if k is the third layer, loop through only k-1 and k-2; if k is greater than 3, loop through k-1, k-2, and k-3 layers; the kq processing for each layer is as follows: if both the kth layer and the kqth layer use block_same, then subtract the position where block_same is written in the kqth layer from the position where block_same is read in the kth layer, obtaining several difference values, delay3, delay4, etc.; Step 3.3: Conflict redundancy elimination: Find the maximum value delay_max in [delay1 delay2 delay3 delay4…]. If delay_max+1 is positive, then the values ​​of read_pos_buffer(k) and write_pos_buffer(k) corresponding to the kth layer to the layer_numth layer are both increased by delay_max+1; if delay_max+1 is negative, then the values ​​of read_pos_buffer(k) and write_pos_buffer(k) corresponding to the kth layer to the layer_numth layer are both reduced by |delay_max+1|; if delay_max+1 is 0, then the values ​​of read_pos_buffer(k) and write_pos_buffer(k) corresponding to the kth layer to the layer_numth layer remain unchanged.

4. The method for sorting LDPC blocks for parallel reading and writing and in-order decoding according to claim 3, wherein: The step 4 comprises: From the second layer to the layer_num layer, the sequence loop is repeated, where the kth layer processing process is: Step 4.1: For the current loop layer, i.e., the kth layer, use the second-to-last block to the first block to loop sequentially. The current loop block order_buffer(k)(p) is called block_current, and the next block order_buffer(k)(p+1) is called block_after. Step 4.2: If k is the second layer, only loop k-1. If k is the third layer, only loop k-1 and k-2. If k is greater than 3, loop k-1, k-2, and k-3 layers. The processing process for each layer kq is: Check whether the kqth layer uses block_after. If so, and the difference between the time when the kth layer reads block_after and the time when the kqth layer writes block_after is 1, return to step 4.1 to loop the next block. If the difference does not reach 1 after looping through the k-1, k-2, and k-3 layers, proceed to the next step. Step 4.3: If k is the second layer, only loop k-1. If k is the third layer, only loop k-1 and k-2. If k is greater than 3, loop k-1, k-2, and k-3 layers. The processing process for each layer km is: Check whether the km-th layer uses block_current. If so, and the difference between the time when the k-th layer reads block_current and the time when the km-th layer writes block_current is 1, then execute the next step. If the difference does not reach 1 after looping through the k-1, k-2, and k-3 layers, then return to step 4.1 to loop for the next block. Step 4.4: Exchange the positions of block_current and block_after in order_buffer(k) and return to step 4.1 to loop for the next block.

5. The method for sorting LDPC blocks for parallel reading and writing and in-order decoding according to claim 4, characterized in that: The step 5 comprises: From the second layer to the layer_num layer, the processing process of each layer is: Step 5.1: Loop sequentially from the second block to the last block used in the current loop layer k. The current loop block order_buffer(k)(p) is called block_current, and the previous block order_buffer(k)(p-1) is called block_before. Step 5.2: Loop through layers k-1, k-2, and k-3. The processing for each layer kq is as follows: Check whether the kq layer uses block_current. If so, and the difference between the time when the kth layer reads block_current and the time when the kqth layer writes block_current is 1, then return to step 5.1 and loop through the next block. If the difference does not equal 1 after looping through layers k-1, k-2, and k-3, then proceed to the next step. Step 5.3: Loop through layers k+1, k+2, and k+3. The process for each layer k+m is as follows: Check whether layer k+m uses block_before. If so, and the difference between the time layer k+m reads block_before and the time layer k writes block_before is 1, then return to step 5.1 and loop through the next block. If the difference between layers k+1, k+2, and k+3 does not equal 1, proceed to the next step. Step 5.4: Loop through layers k+1, k+2, and k+3. The process for each layer k+n is as follows: Check whether layer k+n uses block_current. If not, or if it does but the difference between the time when layer k+n reads block_current and the time when layer k writes block_current is not 1, then return to step 5.1 and loop through the next block. Otherwise, proceed to the next step. Step 5.5: Exchange the positions of block_current and block_before in order_buffer(k) and return to step 5.1 to loop for the next block.

Images