Multi-target range and velocity resolution ambiguity removal method based on GPU two-level parallel implementation

Abstract

The application discloses a multi-target distance and speed deblurring GPU two-stage parallel implementation method, relates to the technical field of radar deblurring, and comprises the following steps: acquiring a plurality of PRFs, randomly selecting a PRF each time, and generating a plurality of PRF groups; a plurality of plots correspond to each PRF, one plot is selected from the plurality of plots corresponding to each PRF in the PRF group each time to form a plot combination, a plurality of plot combinations corresponding to the PRF group are generated, and identifiers of plots in each plot combination are acquired; a group of thread blocks is allocated to each plot combination, and a plurality of threads are allocated to each plot; coarse-grained parallel processing is adopted for the plurality of plot combinations to obtain minimum variances corresponding to the plot combinations; and fine-grained parallel processing is adopted for any plot combination to obtain a minimum variance corresponding to the plot combination. The application can enhance the real-time performance of a deblurring algorithm.

Description

Technical Field

[0001] This invention belongs to the field of radar deblurring technology, specifically involving a GPU-based two-level parallel implementation method for deblurring the range and velocity of multiple targets. Background Technology

[0002] Pulse radar repeatedly transmits pulse waveforms at a certain period and obtains target-related information by receiving target echoes. Due to the limitation of the pulse repetition period, radar has certain ranging and velocity measurement ranges. When the target's distance or velocity exceeds these ranges, the target information measured by the radar becomes blurred and cannot reflect the true target information. Range obstruction occurs when the target's distance or velocity exceeds the maximum measurement range, and when the target echo falls within the time range of the transmitted signal. Velocity obstruction occurs when the target velocity is near blind velocity. Both range and velocity obstruction can cause the loss of target information.

[0003] In existing technologies, to address the problems of target information ambiguity and occlusion, a method combining repetition frequency variation and the N / M criterion is typically used. This involves transmitting waveforms with M different pulse repetition frequencies; during reception, if the target is detected within N or more pulse repetition times (PRTs), the target is considered to exist. The essence of deambiguation under multi-variable repetition frequencies is solving a system of congruence equations. Commonly used deambiguation algorithms include the Sun Tzu theorem method, the residual lookup table method, the sliding window clustering method, and the one-dimensional set algorithm. The Sun Tzu Theorem method uses the Chinese Remainder Theorem to derive congruence equations, offering good real-time performance. However, this method requires all repetition frequencies to be coprime, and the presence of measurement errors can lead to significant computational errors, making it unsuitable for engineering applications. The residual difference lookup table method quickly matches target distance and velocity through table lookup. It offers good real-time performance when the distance and velocity measurement range is small, but as the detection range increases, the residual difference table occupies a large space and the lookup time is significant. The sliding window clustering method sets a sliding window of a certain width that slides within the maximum detection range, and defuzzification is achieved by detecting whether the number of targets within the window meets the requirements. This method is fast, but its detection performance is affected by the window width and step size. The one-dimensional set algorithm essentially uses an exhaustive method to solve a system of congruence equations, listing all possible targets. Using distance or velocity information to find the distance corresponding to the true target, this method has lower requirements for radar repetition rate parameters, less impact from measurement errors, higher accuracy, and stronger robustness compared to the previous methods. It is a method with better deambiguity performance. However, this method involves data sorting during the calculation process, resulting in a large amount of computation and time-consuming variance calculation. Especially in the case of multiple targets and multiple frequencies, the number of point combination combinations grows exponentially. For example, according to the 4 / 7 rule, when there are 5 targets, 21,875 point combination combinations can be generated. When the maximum detection range is large, resulting in a large maximum ambiguity, the amount of data in a single point combination is also large. The computational load of the entire deambiguity process grows exponentially, and it is difficult to meet the real-time requirements using traditional serial calculation methods.

[0004] Therefore, there is an urgent need to provide a parallel acceleration method for multi-target distance and velocity defuzzification to improve the shortcomings of existing methods. Summary of the Invention

[0005] To address the aforementioned problems in the existing technology, this invention provides a GPU-based two-level parallel implementation method for multi-target distance and velocity deblurring.

[0006] This invention provides a GPU-based two-level parallel implementation method for multi-target distance and velocity deblurring, comprising:

[0007] Get Each frequency is randomly selected each time. One repetition frequency is generated to form multiple repetition frequency groups; each repetition frequency corresponds to multiple points; each time, one point is selected from each of the multiple points corresponding to each repetition frequency in the repetition frequency group to form a point combination, generating multiple point combinations corresponding to the repetition frequency group, and obtaining the identifier of the point in each point combination.

[0008] A set of thread blocks is allocated to each point combination, and multiple threads are allocated to each point. For multiple point combinations, coarse-grained parallel processing is used to obtain the minimum variance corresponding to each point combination. For any point combination, fine-grained parallel processing is used to obtain the minimum variance corresponding to the point combination.

[0009] For any combination of dots, fine-grained parallel processing is used to obtain the minimum variance corresponding to the combination of dots, including:

[0010] For each point in the point combination, distance or velocity data corresponding to each point is generated based on the point information and the repetition frequency information of the point. The distance or velocity data corresponding to the point combination is obtained, and a data sequence is generated. The data sequence is sorted, and the variance of the sorted data sequence is calculated to obtain a variance sequence. The variance sequence is processed using a loop iterative method to obtain the minimum variance corresponding to the point combination. If the minimum variance corresponding to the point combination is less than a threshold, the point combination is successfully defuzzified; otherwise, the point combination is deleted.

[0011] The beneficial effects of this invention are:

[0012] This invention provides a two-level parallel implementation method for multi-target distance and velocity defuzzification on a GPU. By employing a two-level parallel strategy of parallel processing of data between multiple point combinations and within a single point combination, large-scale data computation is distributed to GPU parallel computing to improve real-time performance. Specifically, during data sorting, the merge insertion sort method is implemented using the locally ordered characteristics of the data, enabling fast parallel sorting on the GPU. When the number of targets is large, the speedup of the GPU parallel implementation can reach thousands of times, significantly enhancing the real-time performance of the defuzzification algorithm.

[0013] The present invention will be further described in detail below with reference to the accompanying drawings and embodiments. Attached Figure Description

[0014] Figure 1 This is a flowchart of a GPU two-level parallel implementation method for multi-target distance and velocity deblurring provided in an embodiment of the present invention;

[0015] Figure 2 This is a schematic diagram of a GPU-based two-level parallel implementation method for multi-target distance and velocity deblurring provided in an embodiment of the present invention;

[0016] Figure 3This is a schematic diagram of the generation of distance or velocity data corresponding to each dot provided in an embodiment of the present invention;

[0017] Figure 4 This is a flowchart of a merging and consolidation method provided in an embodiment of the present invention;

[0018] Figure 5 This is a schematic diagram of a multi-threaded parallel data sorting method provided in an embodiment of the present invention;

[0019] Figure 6 This is a schematic diagram of locally ordered data under the same combination of traces provided in an embodiment of the present invention;

[0020] Figure 7 This is a schematic diagram of a multi-threaded parallel calculation of variance provided in an embodiment of the present invention;

[0021] Figure 8 This is a schematic diagram of a multi-threaded parallel computation for calculating the minimum variance provided in an embodiment of the present invention;

[0022] Figure 9 This is a schematic diagram of a multi-threaded parallel approach to comparing thresholds provided in an embodiment of the present invention;

[0023] Figure 10a This is a schematic diagram of the first repetition frequency RD provided in an embodiment of the present invention;

[0024] Figure 10b This is a schematic diagram of the second repetition frequency RD provided in an embodiment of the present invention;

[0025] Figure 10c This is a schematic diagram of the RD of the third repetition frequency provided in an embodiment of the present invention;

[0026] Figure 10d This is a schematic diagram of the RD of the fourth repetition frequency provided in an embodiment of the present invention;

[0027] Figure 11 This is a curve showing the change in GPU-side deblurring speedup ratio with the number of dots under the 2 / 4 criterion provided in this embodiment of the invention;

[0028] Figure 12 This is a graph showing the speedup ratio of merge insertion sort relative to bitone sort under the 2 / 4 criterion as a function of the number of dots, provided in an embodiment of the present invention.

[0029] Figure 13a This is a schematic diagram of the RD of the first repetition frequency provided in an embodiment of the present invention;

[0030] Figure 13b This is a schematic diagram of the second repetition frequency RD provided in an embodiment of the present invention;

[0031] Figure 13c This is a schematic diagram of the RD of the third frequency provided in an embodiment of the present invention;

[0032] Figure 13d This is a schematic diagram of the fourth frequency RD provided in an embodiment of the present invention;

[0033] Figure 13e This is a schematic diagram of the RD of the fifth frequency provided in an embodiment of the present invention;

[0034] Figure 13f This is a schematic diagram of the RD of the sixth frequency provided in an embodiment of the present invention;

[0035] Figure 13g This is a schematic diagram of the RD of the seventh frequency provided in an embodiment of the present invention;

[0036] Figure 14 This is a curve showing the change in GPU-side deblurring speedup ratio with the number of dots under the 4 / 7 criterion provided in this embodiment of the invention;

[0037] Figure 15 This is a graph showing the speedup ratio of merge insertion sort relative to bitone sort under the 4 / 7 criterion provided in this embodiment of the invention as a function of the number of dots. Detailed Implementation

[0038] The present invention will be further described in detail below with reference to specific embodiments, but the implementation of the present invention is not limited thereto.

[0039] To address target range and velocity occlusion issues in existing technologies, the N / M criterion combined with multi-frequency deblurring is typically used. When measuring a target using a repetition frequency, if there are If a target is detected at a certain location by one or more repetition frequencies, then the target is considered to exist. Due to the different PRTs and the small proportion of the area where the target is occluded in the total area, the target will only be occluded in a few repetition frequencies. The N / M criterion takes advantage of this characteristic to ensure that the deblurring can still be successful even if the target is lost in some repetition frequencies, thus improving the robustness of the deblurring effect.

[0040] The above content describes a deblurring method for single targets. When multiple targets are detected at the same time, it is impossible to distinguish the target to which a point belongs based on apparent distance or apparent velocity. In this case, it is necessary to combine targets with different repetition frequencies and determine whether each combination can successfully deblur. When deblurring is successful, the point combination is considered to belong to the same target.

[0041] The one-dimensional set algorithm is an exhaustive method. The principle behind resolving distance ambiguity and velocity ambiguity using this method is the same. Since the target distance cannot be predicted in advance, one apparent distance may correspond to multiple true target distances, i.e.:

[0042] ;

[0043] in, Indicates the first Apparent distance at a repetition frequency Indicates the first The ambiguity multiple at a repetition frequency, Indicates the first The maximum unambiguous distance at each repetition frequency This indicates the radar's maximum detection range, encompassing all possible range values. Arranged from smallest to largest. Based on the above, it can be seen that under each repetition frequency... Superimposed Multiples of this value will eventually result in the same value at the actual target distance; therefore, the sorted data will inevitably show... ( (Number of repetition frequencies) adjacent true distance values. Due to target measurement errors and the fact that multiple PRTs do not measure the target strictly at the same time, the true distances of the points at different repetition frequencies have slight deviations. The results obtained after arranging are... The true values ​​of the targets are not strictly equal. The distances between the targets after sorting are based on their proximity. Grouping each group into sets, we calculate the variance to obtain a variance sequence, and then find the minimum variance. The mean value corresponding to the number of values ​​is used to obtain the true distance to the target.

[0044] The above content describes the one-dimensional set algorithm flow for a single objective. For multi-objective scenarios, the one-dimensional set algorithm using the N / M criterion for distance ambiguity resolution includes, under the N / M criterion, starting from... Randomly select from each repetition frequency One repetition frequency, obtain For each repetition frequency group, obtain all points corresponding to each repetition frequency. Each repetition frequency group corresponds to... ( arrive They represent The algorithm iterates through each pair of points (number of points in each frequency repetition frequency) and executes the one-dimensional set algorithm to obtain the minimum mean square error. Only when the minimum mean square error is less than the mean square error threshold is it considered that the points in the pair originate from the same target, and the target is considered to exist at that location, i.e., the deblurring is successful. The mean value at the minimum mean square error is the true distance to the target.

[0045] The above are commonly used deblurring methods in existing technologies. However, when using one-dimensional set algorithms to deblur multiple targets, the number of point combinations is large, and the computational workload of sorting and calculating variance within the same point combination is significant, resulting in a massive computational burden that makes real-time performance difficult. This invention proposes a two-level parallel GPU implementation method for multi-target distance and velocity deblurring. This method parallelizes the one-dimensional set algorithm on the Graphics Processing Unit (GPU) and designs a two-level parallel strategy for parallel processing of data between multiple point combinations and within a single point combination. Large-scale data computation is distributed to GPU parallel computing to improve real-time performance. Specifically, during data sorting, a merge insertion sort method is implemented using the locally ordered characteristics of the data, enabling fast parallel sorting on the GPU. When the number of targets is large, the speedup of the GPU parallel implementation can reach thousands of times, significantly enhancing the real-time performance of the deblurring algorithm.

[0046] Next, we will introduce the GPU parallel implementation method for deblurring, specifically:

[0047] S1. Based on the waveform parameters obtained from the front-end parameter parsing module, the CPU acquires the N / M criterion parameters and the staggered repetition frequency parameters. Randomly selected from each repetition frequency The process involves performing the operation multiple times to create several different frequency repetition groups, and initializing parameters such as the maximum ambiguity for each frequency repetition in each group.

[0048] S2. Copy the parameters corresponding to each repetition frequency group generated by the CPU and the trace information corresponding to each repetition frequency obtained from the front-end signal processing module from the CPU to the GPU.

[0049] S3. On the GPU side, the point information corresponding to each repetition frequency is used to generate multiple point combinations corresponding to each repetition frequency group, and each point combination is processed.

[0050] S4. Determine the computational complexity of the distance and velocity dimensions based on the maximum ambiguity of the distance and velocity dimensions. Select the dimension with the smaller computational complexity and use the one-dimensional set algorithm to de-ambiguously de-blur the point combinations corresponding to all repetition groups in the corresponding dimension to obtain the successfully de-ambiguously de-blurred point combinations.

[0051] S5. Use the one-dimensional set algorithm to perform another-dimensional defuzzification on the successfully defuzzified point combination to obtain a jointly defuzzified point combination.

[0052] S6. Copy the successfully deblurred point combination based on distance and velocity from the GPU to the CPU.

[0053] S7. Under the N / M criterion, the same target can be successfully deblurred in multiple repetition frequency groups. That is, multiple points are generated for the same target. On the CPU side, the multiple points belonging to the same target are fused to obtain the final point of the target.

[0054] Please see Figure 1 , Figure 1 This is a flowchart of a GPU two-level parallel implementation method for multi-target distance and velocity deblurring provided in an embodiment of the present invention. The GPU two-level parallel implementation method for multi-target distance and velocity deblurring provided by the present invention includes:

[0055] S101, Obtain Each frequency is randomly selected each time. One repetition frequency, generating multiple repetition frequency groups. Each repetition frequency corresponds to multiple points. Each time, one point is selected from each of the multiple points corresponding to each repetition frequency in the repetition frequency group to form a point combination, generating multiple point combinations corresponding to the repetition frequency group, and obtaining the identifier of the point in each point combination.

[0056] Specifically, in this embodiment, each repetition frequency corresponds to multiple points. One point is selected from the multiple points corresponding to each repetition frequency to form a point combination. This process is repeated multiple times to generate multiple point combinations corresponding to the repetition frequency group. For example, the repetition frequency group includes 3 repetition frequencies, each of which corresponds to 2 points. Each time, one point is selected from the points corresponding to the 3 repetition frequencies to form a point combination including 3 points. Each point in the point combination corresponds to a different repetition frequency.

[0057] During the generation of point combination, allocation is performed on the GPU. There are 1 thread, and each thread processes a combination of dots.

[0058] In this embodiment, obtaining the identifier of the dots in each dot combination includes:

[0059] In a single thread, based on the identifier of the thread assigned to the point combination, the repetition frequency group to which each point in the point combination belongs is inferred, the number of points corresponding to each repetition frequency in the repetition frequency group is obtained, and the identifier of the point corresponding to each repetition frequency is calculated.

[0060] Based on the identifier of the point corresponding to each repetition frequency, obtain the identifier of the point in the point combination.

[0061] It should be noted that, under the N / M criterion, multiple repetition frequency groups are generated, and multiple point combinations are generated for each point combination. For each point combination, an identifier for the point within the corresponding repetition frequency is generated, which facilitates the acquisition of the distance or velocity data corresponding to the point during the subsequent defuzzification process.

[0062] S102. Allocate a set of thread blocks to each point combination, and allocate multiple threads to each point combination; for multiple point combinations, use coarse-grained parallel processing to obtain the minimum variance corresponding to each point combination; for any point combination, use fine-grained parallel processing to obtain the minimum variance corresponding to the point combination.

[0063] For any combination of dots, fine-grained parallel processing is used to obtain the minimum variance corresponding to the combination of dots, including:

[0064] For each point in the point combination, distance or velocity data corresponding to each point is generated based on the point information and the repetition frequency information of the point. The distance or velocity data corresponding to the point combination is obtained, and a data sequence is generated. The data sequence is sorted, and the variance of the sorted data sequence is calculated to obtain a variance sequence. The variance sequence is processed using a loop iterative method to obtain the minimum variance corresponding to the point combination. If the minimum variance corresponding to the point combination is less than a threshold, the point combination is successfully defuzzified; otherwise, it is considered that it is not generated by the same target, and the point combination is deleted.

[0065] Specifically, in this embodiment, parallel computing is divided into fine-grained parallelism and coarse-grained parallelism. Fine-grained parallelism usually refers to instruction-level or thread-level parallelism. For example, vector or matrix data within an algorithm can be mapped to multiple CUDA cores of the GPU for parallel computing. CUDA is a programming model proposed by NVIDIA for general-purpose computing on GPUs. Coarse-grained parallelism usually refers to task-level parallelism. Tasks can be different tasks or the same task that processes different data. Multiple tasks are parallelized to improve the efficiency of processing large amounts of data.

[0066] Based on the above, in multi-target deblurring, the multiple points corresponding to the repetition frequencies in the repetition frequency group will combine into a large number of point combinations. Processing each point combination requires sorting a large number of possible distance or velocity values. For example... Figure 2 As shown, Figure 2 This is a schematic diagram of a GPU-based two-level parallel implementation method for multi-target distance and velocity deblurring provided in this embodiment of the invention. First, multiple point combinations are generated in parallel on the GPU, and the identifier of each point in the combination is recorded. Then, the processing of the distance or velocity data corresponding to each point combination is regarded as a subtask, and different thread blocks are allocated to implement the processing of multiple subtasks to achieve coarse-grained parallelism. In a single subtask, multiple threads are allocated to implement parallel data operations to achieve fine-grained parallelism. After processing, the minimum variance of multiple point combinations is compared in parallel to see if it is less than a set threshold, and the point combinations that meet the conditions are retained.

[0067] In this embodiment, as Figure 3 As shown, Figure 3This is a schematic diagram of the generation of distance or velocity data corresponding to each point provided in the embodiment of the present invention. For each combination of points, it is necessary to generate all possible distance or velocity data corresponding to each point based on the point information and the repetition frequency information corresponding to the point. The generation of each data is independent and multiple threads are used to generate them in parallel.

[0068] For each point in the point combination, based on the point information and the repetition frequency information corresponding to the point, generate distance or velocity data corresponding to each point, obtain the distance or velocity data corresponding to the point combination, and generate a data sequence, including:

[0069] For dot combination Each point is assigned. A group of thread blocks, that is, a group of thread blocks including Each thread block allocates a specific thread for any given point. One thread; among which, This indicates the length of the distance or velocity data corresponding to the dot;

[0070] Obtain the maximum distance or maximum Doppler velocity corresponding to the repetition frequency for each point;

[0071] Obtain the trace information corresponding to each trace;

[0072] The ambiguity of the dot is calculated based on the identifier of the thread assigned to it.

[0073] Based on the ambiguity of the dot, the maximum distance or maximum Doppler velocity of the repetition frequency corresponding to the dot, and the dot information corresponding to the dot, calculate the distance or velocity data of the dot under the corresponding ambiguity.

[0074] Based on the distance or velocity data corresponding to all the dots in the dot combination, obtain a set of distance or velocity data corresponding to the dot combination.

[0075] Calculate the identifier of the position of the distance or velocity data corresponding to the point in the set of distance or velocity data corresponding to the point combination, and place the distance or velocity data corresponding to the point in the corresponding position to form a data sequence.

[0076] In this embodiment, different threads are assigned to different dots in the dot combination, including:

[0077] Obtain the maximum blur of the dot pattern;

[0078] In the thread block corresponding to the dot, the corresponding thread is allocated according to the maximum ambiguity of the dot. After processing by each thread, distance or velocity data is obtained, and each dot corresponds to a set of distance or velocity data.

[0079] In this embodiment, as Figure 4 and Figure 5As shown, Figure 4 This is a flowchart of a merging and consolidation method provided in an embodiment of the present invention. Figure 5 This is a schematic diagram of a multi-threaded parallel data sorting method provided in an embodiment of the present invention, which sorts a data sequence, including:

[0080] A thread is assigned to any two ordered sequences in the data sequence, and they are merged using insertion sort to obtain multiple ordered sequences after the first merge; among them, the distance or speed data corresponding to each point is regarded as an ordered sequence in the data sequence.

[0081] Assign a thread to any two ordered sequences from the multiple ordered sequences after the first merge, and merge them using insertion sort to obtain the multiple ordered sequences after the second merge.

[0082] This process is repeated until an ordered sequence is formed after multiple mergings, resulting in a sorted data sequence.

[0083] In this embodiment, please continue to refer to Figure 5 Assign a thread to any two ordered sequences in the data sequence and merge them using insertion sort, including:

[0084] Based on the lengths of any two ordered sequences in the data sequence, the allocated set of threads is divided into two groups of sub-threads, which process the first ordered sequence and the second ordered sequence respectively; where,

[0085] For the first ordered sequence, calculate the identifier of the insertion position of the multiple sets of distance or velocity data corresponding to the first ordered sequence in the second ordered sequence; wherein, if the identifier of the insertion position is the same as the identifier of the distance or velocity data corresponding to the second ordered sequence, then insert the distance or velocity data corresponding to the first ordered sequence after the distance or velocity data corresponding to the second ordered sequence.

[0086] Get the identifier of the current position of the multiple sets of distance or velocity data corresponding to the first ordered sequence;

[0087] Add the identifier of the insertion position to the identifier of the current position to obtain the identifier of the position of multiple sets of distance or velocity data corresponding to the first ordered sequence in the merged ordered sequence, so as to merge the first ordered sequence with the second ordered sequence.

[0088] For the second ordered sequence, calculate the identifier 2 of the insertion position of the multiple sets of distance or velocity data corresponding to the second ordered sequence in the first ordered sequence; wherein, if the identifier 2 of the insertion position is the same as the identifier of the distance or velocity data corresponding to the first ordered sequence, then insert the distance or velocity data corresponding to the second ordered sequence before the distance or velocity data corresponding to the first ordered sequence.

[0089] The identifier two for the current position of the multiple sets of distance or velocity data corresponding to the second ordered sequence;

[0090] Add the second identifier of the insertion position to the second identifier of the current position to obtain the identifiers of the positions of multiple sets of distance or velocity data corresponding to the second ordered sequence in the merged ordered sequence, so as to merge the first ordered sequence with the second ordered sequence.

[0091] It should be noted that in one-dimensional set algorithms, where data sorting time complexity is high, serial sorting cannot meet real-time requirements when sorting large-scale data. Based on the aforementioned one-dimensional set computing principle, for a single point, all possible distance or velocity data generated from it are ordered. However, the distance or velocity data generated from multiple points are unordered. During data generation, all possible data for the same point are grouped together to form an ascending sequence, and the possible data of all points within a point combination form multiple ascending sequences.

[0092] A good way to sort this type of data is merge sort. Unlike regular merge sort, which recursively merges sub-segments up to the length of 1, merges data upwards from the current ordered sequence. This is much faster, typically with a time complexity of O(n log n). ,in, Total data length This represents the number of ordered data segments. When the data length is large, this operation is still relatively time-consuming on the CPU.

[0093] To improve the real-time performance of sorting operations, this invention proposes a method combining merge sort and insertion sort. While still employing a pairwise merging approach, the specific merging process utilizes methods such as... Figure 6 In this way, Figure 6 This is a schematic diagram of an insertion sort provided in an embodiment of the present invention. There are currently two ordered data segments, and a certain data in ordered data segment 1... The identifier is Use binary search in ordered data segment 2 to find The insertion point yields the result identifier as That is, in ordered data segments 1 and 2, compared The number of small data points are respectively and The identifier for this data in the merged and sorted sequence is and The sum. For a single data point, the time complexity of this operation is O(n). , The length of ordered data segment 2 is given. If implemented on the CPU, the time complexity of this operation is higher than that of the traditional method described in the previous paragraph. However, when using this method, there is no dependency between the data, which facilitates parallel implementation on the GPU.

[0094] In this embodiment, please refer to Figure 7 , Figure 7 This is a schematic diagram of a multi-threaded parallel calculation of variance provided in an embodiment of the present invention. The calculation of the variance of the sorted data sequence yields a variance sequence, including:

[0095] To length of Allocation of sorted data sequences One thread, each time selecting adjacent... Given an ordered sequence, calculate the variance to obtain a variance sequence; where the points included in the point combination correspond to... Each frequency.

[0096] In this embodiment, please refer to Figure 8 , Figure 8 This is a schematic diagram of a multi-threaded parallel computation for calculating the minimum variance provided in an embodiment of the present invention. It uses a loop iterative method to process the variance sequence and obtain the minimum variance corresponding to the combination of points, including:

[0097] The length is The variance sequence is divided into a first subsequence and a second subsequence; wherein the length of the first subsequence is... The length of the second subsequence is , Less than And it is the largest number that is a power of 2;

[0098] Assign to the first subsequence and the second subsequence One thread compares the size of the data in the first subsequence and the second subsequence, puts the smaller data into the first subsequence to update the data in the first subsequence and the second subsequence, and the minimum variance is located in the updated first subsequence;

[0099] The length is The updated first subsequence is divided into a first half sequence and a second half sequence;

[0100] Assignment of the first half and the second half of the sequence One thread compares the size of the data in the first half of the sequence and the second half of the sequence, puts the smaller data into the first half of the sequence to update the data in the first half of the sequence and the second half of the sequence, and the minimum variance is located in the updated first half of the sequence.

[0101] The updated first half of the sequence is further divided into two sequences. This process is repeated until the length of the data in the updated first half of the sequence is 1, thus obtaining the minimum variance corresponding to the combination of dots.

[0102] In this embodiment, the thresholds include a distance threshold and a speed threshold.

[0103] In this embodiment, please refer to Figure 9 , Figure 9 This is a schematic diagram of a multi-threaded parallel comparison threshold provided in an embodiment of the present invention, which also includes: updating the number of successfully deblurred point combinations using atomic operation functions.

[0104] Since multiple threads execute this operation in parallel, saving the results can easily lead to multiple threads simultaneously writing to the same memory location. Therefore, the `atomicAdd` function in CUDA is used to implement safe memory writing for multiple threads. A variable is defined to store the number of successfully deblurred point combinations. Whenever a combination of points that meets the conditions is found, this function is used to... Add 1 to ensure that each successfully deblurred point combination is written to a different location in memory.

[0105] In summary, this invention provides a two-level parallel implementation method for multi-target distance and velocity defuzzification on a GPU. Through a two-level parallel strategy—comparing data processing between multiple point combinations and within a single point combination—it improves program efficiency. The merge insertion sort method is implemented using the locally ordered nature of the data, facilitating parallel implementation on the GPU. While accurately reconstructing the true distance and velocity of the targets, it improves the system's real-time performance. When the number of repetition frequencies and the number of points are large, the speedup of the defuzzification algorithm can reach the order of thousands. The time efficiency of the merge insertion sort algorithm based on locally ordered sequences is 3 to 5 times that of the traditional parallel sorting algorithm, bitonic sort, significantly improving the overall defuzzification efficiency of the system.

[0106] In an optional embodiment of the present invention, the complexity of the GPU two-level parallel implementation method for multi-target distance and velocity deblurring provided in the above embodiment is verified through simulation experiments, specifically as follows:

[0107] I. Analysis Content

[0108] Let the target quantity be The total number of repetitions is The number of repetitions in each repetition group is The total number of dot combinations is The number of all possible distance or velocity data generated by each combination of dots is (The average of multiple repetition groups), theoretically, the number of point combinations that ultimately achieve successful deblurring is: .

[0109] Please refer to Tables 1 and 2. Table 1 compares the time complexity of various defuzzification operations implemented on the CPU and GPU. Table 2 compares the time complexity of merge insertion sort and the traditional parallel sorting algorithm bitonic sort implemented on the GPU.

[0110] Table 1. Time complexity of each operation on the CPU and GPU sides

[0111]

[0112] Table 2. Comparison of GPU-based time complexity of bitonic sort and merge insertion sort

[0113]

[0114] Analyzing the time complexity comparison results of the above implementations of each module on the CPU and GPU, although using the GPU adds two data copying operations, the amount of data copied is relatively small. However, as the number of data points increases or the number of repetitions in each repetition group increases... As the CPU's runtime increases, the runtime on the CPU side grows exponentially, but the runtime on the GPU side grows less due to the advantage of parallelism.

[0115] Comparing the two parallel sorting algorithms, traditional bitonic sort recursively moves down to the subsequence length of 1 before merging upwards, while merge insertion sort directly merges upwards based on locally ordered data, giving it a natural advantage in time efficiency.

[0116] II. Simulation Results

[0117] Under the hardware conditions of CPU (AMD EPYC 7502) and GPU (NVIDIA GeForce RTX 3090), the following two experiments were conducted to verify the effectiveness and acceleration effect of the parallel deblurring algorithm.

[0118] Experiment 1, results under the 2 / 4 criterion.

[0119] 1. Parameter settings

[0120] Set the repetition frequency parameters, waveform parameters, and target parameters as shown in Table 3, and generate the simulated echo in MATLAB.

[0121] Table 3 Parameter Table under the 2 / 4 Criterion

[0122]

[0123] 2. Verification of the accuracy of defuzzification

[0124] After signal processing algorithms such as front-end pulse compression and coherent accumulation, the RD diagrams at four repetition frequencies are obtained, as follows: Figures 10a-10d As shown, Figure 10a This is a schematic diagram of the first repetition rate RD provided in an embodiment of the present invention. Figure 10b This is a schematic diagram of the second repetition rate RD provided in an embodiment of the present invention. Figure 10c This is a schematic diagram of the RD of the third repetition frequency provided in an embodiment of the present invention. Figure 10d This is a schematic diagram of the fourth repetition frequency RD provided in the embodiment of the present invention. Constant false alarm detection is performed on the RD graph, and the point result log is printed out on the terminal.

[0125] Combining the RD map and the point tracking results, the target was blurred in all repetition frequencies. Furthermore, due to distance or velocity occlusion, point tracking was lost in repetition frequencies 2, 3, and 4. Only in repetition frequency 1 were the five targets detected. A deblurring algorithm was used to process the point tracking in the four repetition frequencies. By comparing the target parameters with the deblurring results, and ignoring minor errors in measurement accuracy and precision, the deblurring algorithm accurately reconstructed the true point tracking information of the target.

[0126] 3. GPU acceleration effect

[0127] 500 Monte Carlo experiments were performed on both the CPU and GPU sides, and the runtime of each module was recorded. The average runtime was calculated, and the specific execution time and speedup ratio were summarized, as shown in Table 4. The execution time and speedup ratio of the traditional bitonetic sorting method and the merge insertion sort method under GPU parallelism were recorded, as shown in Table 5. The number of repetition frequencies was set from 1 to 10, and a curve was plotted showing the change in the GPU deblurring speedup ratio with the number of dots, as shown in Table 5. Figure 11 As shown, Figure 11 This is a graph showing the GPU-side deblurring speedup as a function of the number of dots under the 2 / 4 criterion provided in this embodiment of the invention; a graph showing the merge insertion sort speedup as a function of the number of dots is also shown. Figure 12 As shown, Figure 12 This is a graph showing the speedup ratio of merge insertion sort relative to bitone sort under the 2 / 4 criterion provided in this embodiment of the invention as a function of the number of dots.

[0128] Table 4. Summary of Execution Time and Speedup Ratio of Each Module on the CPU and GPU Sides under the 2 / 4 Criterion

[0129]

[0130] Table 5. Execution Time and Speedup of Merge Insertion Sort and Traditional Bitonic Sort under the 2 / 4 Criterion

[0131]

[0132] Under the 2 / 4 rule, the number of repetitions is small, and the computational load is low. However, parallel acceleration requires the allocation of GPU resources and thread resources, which incurs some time consumption. Some modules take longer to implement on the GPU than on the CPU. When the number of points is small, the execution efficiency of the GPU is not as good as that of the CPU. However, as the number of points increases, the GPU can still achieve several times the speedup. The merge insertion sort algorithm implemented on the GPU has a speedup of nearly 4 times compared to the traditional bitoneic sort.

[0133] Experiment 2: Results under the 4 / 7 criterion.

[0134] 1. Parameter settings

[0135] Set the repetition frequency parameters, waveform parameters, and target parameters as shown in Table 6, and generate the simulated echo in MATLAB.

[0136] Table 6 Parameter Table under Criterion 4 / 7

[0137]

[0138] 2. Verification of the accuracy of defuzzification

[0139] After signal processing algorithms such as front-end pulse compression and coherent accumulation, the RD diagrams at 7 repetition frequencies are obtained, as follows: Figures 13a-13g As shown, Figure 13a This is a schematic diagram of the RD of the first repetition frequency provided in an embodiment of the present invention. Figure 13b This is a schematic diagram of the second repetition frequency RD provided in an embodiment of the present invention. Figure 13c This is a schematic diagram of the RD of the third frequency provided in an embodiment of the present invention. Figure 13d This is a schematic diagram of the fourth frequency RD provided in an embodiment of the present invention. Figure 13e This is a schematic diagram of the RD of the fifth frequency provided in an embodiment of the present invention. Figure 13f This is a schematic diagram of the sixth frequency RD provided in an embodiment of the present invention. Figure 13g This is a schematic diagram of the seventh frequency RD provided in the embodiment of the present invention. Constant false alarm detection is performed on the RD graph, and the point result log is printed out on the terminal.

[0140] Combining the RD map and the point trace results, the target was blurred in all repetition frequencies. Furthermore, due to distance or velocity occlusion, only repetition frequency 3 detected the set 10 targets; the other 6 repetition frequencies showed point trace loss. Using a deblurring algorithm to process the point traces in the 7 repetition frequencies, and comparing the set target parameters with the deblurring results, ignoring minor errors caused by measurement accuracy and measurement error, the deblurring algorithm accurately restored the true point trace information of the target.

[0141] 3. GPU acceleration effect

[0142] 500 Monte Carlo experiments were performed on both the CPU and GPU sides, and the runtime of each module was recorded. The average runtime was calculated, and the specific execution time and speedup ratio were summarized, as shown in Table 7. The execution time and speedup ratio of the traditional bitonetic sorting method and the merge insertion sort method under GPU parallelism were recorded, as shown in Table 8. The number of repetition frequencies was set from 1 to 10, and a curve was plotted showing the change in the GPU deblurring speedup ratio with the number of dots, as shown in Table 8. Figure 14 As shown, Figure 14 This is a graph showing the GPU-side deblurring speedup as a function of the number of dots under the 4 / 7 criterion provided in this embodiment of the invention; a graph showing the merge insertion sort speedup as a function of the number of dots is also shown. Figure 15 As shown, Figure 15 This is a graph showing the speedup ratio of merge insertion sort relative to bitone sort under the 4 / 7 criterion provided in this embodiment of the invention as a function of the number of dots.

[0143] Table 7. Summary of Execution Time and Speedup Ratio of Each Module on the CPU and GPU Sides under the 4 / 7 Criterion

[0144]

[0145] Table 8. Execution Time and Speedup of Merge Insertion Sort and Traditional Bitonic Sort under the 2 / 4 Criterion

[0146]

[0147] Under the 4 / 7 rule, the number of repetition frequencies and the number of point combinations are relatively large, resulting in a significant acceleration effect on the GPU. When the number of points is small, the speedup is on the order of ten. As the number of points increases, the parallel advantage of the GPU becomes prominent, and the speedup can reach the order of hundreds or even thousands. The merge insertion sort algorithm implemented on the GPU has a speedup of 3 to 5 times compared to the traditional bitonic sort.

[0148] In summary, the parallel implementation of distance and velocity deblurring on the GPU significantly improves program execution efficiency, especially in cases involving multiple frequencies and multiple targets. The GPU can accelerate the algorithm to the order of thousands, making it suitable for engineering applications.

[0149] For data sorting, although the traditional parallel bitone sorting algorithm is implemented in parallel, it still consumes the most time in the entire defuzzification process due to the time complexity of the sorting algorithm itself. The merge insertion algorithm, which utilizes the local ordered characteristics of data, has a natural advantage in time complexity, reducing the data sorting time to 3 to 5 times that of the traditional method, and significantly improving the real-time performance of the entire system.

[0150] It should be noted that, in this document, relational terms such as "first" and "second" are used merely to distinguish one entity or operation from another, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Furthermore, the terms "comprising," "including," or any other variations are intended to cover non-exclusive inclusion, such that an article or apparatus comprising a list of elements includes not only those elements but also other elements not expressly listed. Without further limitations, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the article or apparatus that includes said element. Terms such as "connected" or "linked" are not limited to physical or mechanical connections but can include electrical connections, whether direct or indirect. The orientations or positional relationships indicated by terms such as "upper," "lower," "left," and "right" are based on the orientations or positional relationships shown in the accompanying drawings and are used only for the convenience of describing the invention and for simplifying the description, and do not indicate or imply that the device or element referred to must have a specific orientation, be constructed and operated in a specific orientation, and therefore should not be construed as limiting the invention.

[0151] In the description of this specification, the references to terms such as "one embodiment," "some embodiments," "example," "specific example," or "some examples," etc., indicate that a specific feature or characteristic described in connection with that embodiment or example is included in at least one embodiment or example of the present invention. In this specification, the illustrative expressions of the above terms do not necessarily refer to the same embodiment or example. Moreover, the specific features or characteristics described may be combined in any suitable manner in one or more embodiments or examples. Furthermore, those skilled in the art can combine and integrate the different embodiments or examples described in this specification.

[0152] The above description, in conjunction with specific preferred embodiments, provides a further detailed explanation of the present invention. It should not be construed that the specific implementation of the present invention is limited to these descriptions. For those skilled in the art, various simple deductions or substitutions can be made without departing from the concept of the present invention, and all such modifications and substitutions should be considered within the scope of protection of the present invention.

Claims

1. A GPU-based two-level parallel implementation method for multi-target distance and velocity deblurring, characterized in that, include: Get Each frequency is randomly selected each time. Multiple repetition frequencies are generated, and multiple repetition frequency groups are generated. Each repetition frequency corresponds to multiple points. Each time, one point is selected from the multiple points corresponding to each repetition frequency in the repetition frequency group. The GPU side forms a point combination and generates multiple point combinations corresponding to the repetition frequency group. The identifier of the point in each point combination is obtained. A set of thread blocks is allocated to each of the said dot combinations, and multiple threads are allocated to each dot. The processing of distance or velocity data corresponding to each point combination is regarded as a subtask. Different thread blocks are allocated to implement the processing of multiple subtasks to achieve coarse-grained parallelism. In a single subtask, multiple threads are allocated to implement parallel data operations to achieve fine-grained parallelism. After processing, the minimum variance corresponding to the point combination is obtained. For any of the aforementioned point combinations, fine-grained parallel processing is employed to obtain the minimum variance corresponding to the point combination, including: For each point in the point combination, distance or velocity data corresponding to each point is generated based on the point information and the repetition frequency information corresponding to the point. The distance or velocity data corresponding to the point combination is obtained, and a data sequence is generated. The data sequence is sorted, and the variance of the sorted data sequence is calculated to obtain a variance sequence. The variance sequence is processed using an iterative method to obtain the minimum variance corresponding to the point combination. If the minimum variance corresponding to the point combination is less than a threshold, the point combination is successfully defuzzified; otherwise, the point combination is deleted. Sorting the data sequence includes: A thread is assigned to any two ordered sequences in the data sequence, and they are merged using insertion sort to obtain multiple ordered sequences after the first merge; wherein, the distance or speed data corresponding to each point is considered as an ordered sequence in the data sequence. A thread is assigned to any two ordered sequences from the multiple ordered sequences after the first merging, and the merging is performed using insertion sort to obtain the multiple ordered sequences after the second merging. This process is repeated until an ordered sequence is formed after multiple mergings, resulting in a sorted data sequence.

2. The GPU-based two-level parallel implementation method for multi-target distance and velocity deblurring according to claim 1, characterized in that, Obtain the identifier of the dots in each of the dot combinations, including: Infer the frequency group to which each of the dots in the dot combination belongs, obtain the number of dots corresponding to each frequency in the frequency group, and calculate the identifier of the dot corresponding to each frequency. Based on the identifiers of the dots corresponding to each repetition frequency, obtain the identifiers of the dots in the dot combination.

3. The GPU-based two-stage parallel implementation method for multi-target distance and velocity deblurring according to claim 1, characterized in that, For each point in the point combination, based on the point information and the repetition frequency information corresponding to the point, distance or velocity data corresponding to each point is generated; the distance or velocity data corresponding to the point combination is obtained; and a data sequence is generated, including: For the combination of dots Each point is assigned. Each thread block allocates a specific thread for any given point. 1 thread; among which, This indicates the length of the distance or velocity data corresponding to the point; Obtain the maximum distance or maximum Doppler velocity corresponding to the repetition frequency for each point; Obtain the trace information corresponding to each trace; The ambiguity of the dot is calculated based on the identifier of the thread assigned to the dot. Based on the ambiguity of the dot pattern, the maximum distance or maximum Doppler velocity of the repetition frequency corresponding to the dot pattern, and the dot pattern information corresponding to the dot pattern, calculate the distance or velocity data of the dot pattern under the corresponding ambiguity. Based on the distance or speed data corresponding to all the dots in the dot combination, obtain a set of distance or speed data corresponding to the dot combination; Calculate the identifier of the position of the distance or velocity data corresponding to the mark in the set of distance or velocity data corresponding to the mark combination, and place the distance or velocity data corresponding to the mark in the corresponding position to form the data sequence.

4. The GPU-based two-stage parallel implementation method for multi-target distance and velocity deblurring according to claim 1, characterized in that, Assign a thread to any two ordered sequences in the data sequence and merge them using insertion sort, including: Based on the lengths of any two ordered sequences in the data sequence, the allocated set of threads is divided into two groups of sub-threads, which process the first ordered sequence and the second ordered sequence respectively; wherein, For the first ordered sequence, calculate the identifier of the insertion position of the multiple sets of distance or velocity data corresponding to the first ordered sequence in the second ordered sequence; wherein, if the identifier of the insertion position is the same as the identifier of the distance or velocity data corresponding to the second ordered sequence, then insert the distance or velocity data corresponding to the first ordered sequence after the distance or velocity data corresponding to the second ordered sequence. Get the identifier of the current position of the multiple sets of distance or velocity data corresponding to the first ordered sequence; Add the identifier of the insertion position to the identifier of the current position to obtain the identifier of the position of the multiple sets of distance or velocity data corresponding to the first ordered sequence in the merged ordered sequence, so as to merge the first ordered sequence with the second ordered sequence; For the second ordered sequence, calculate the identifier 2 of the insertion position of the multiple sets of distance or velocity data corresponding to the second ordered sequence in the first ordered sequence; wherein, if the identifier 2 of the insertion position is the same as the identifier of the distance or velocity data corresponding to the first ordered sequence, then insert the distance or velocity data corresponding to the second ordered sequence before the distance or velocity data corresponding to the first ordered sequence. The identifier two for the current position of the multiple sets of distance or velocity data corresponding to the second ordered sequence; The identifier of the insertion position is added to the identifier of the current position to obtain the identifier of the position of the multiple sets of distance or velocity data corresponding to the second ordered sequence in the merged ordered sequence, so as to merge the first ordered sequence and the second ordered sequence.

5. The GPU-based two-stage parallel implementation method for multi-target distance and velocity deblurring according to claim 1, characterized in that, Calculate the variance of the sorted data sequence to obtain the variance sequence, including: To length of The sorted data sequence allocation One thread, each time selecting adjacent... Given an ordered sequence, calculate the variance to obtain a variance sequence; wherein, the points included in the point combination correspond to... Each frequency.

6. The GPU-based two-level parallel implementation method for multi-target distance and velocity deblurring according to claim 1, characterized in that, The variance sequence is processed using a cyclic iterative method to obtain the minimum variance corresponding to the combination of points, including: The length is The variance sequence is divided into a first subsequence and a second subsequence; wherein the length of the first subsequence is The length of the second subsequence is , Less than And it is the largest number that is a power of 2; Assign to the first subsequence and the second subsequence One thread compares the size of the data in the first subsequence and the second subsequence, puts the smaller data into the first subsequence to update the data in the first subsequence and the second subsequence, and the minimum variance is located in the updated first subsequence; The length is The updated first subsequence is divided into a first half sequence and a second half sequence. Assignment to the first half of the sequence and the second half of the sequence One thread compares the size of the data in the first half sequence and the second half sequence, puts the smaller data into the first half sequence to update the data in the first half sequence and the second half sequence, and the minimum variance is located in the updated first half sequence; The updated first half sequence is further divided into two sequences, and this process is repeated until the data length in the updated first half sequence is 1, thus obtaining the minimum variance corresponding to the combination of dots.

7. The GPU-based two-level parallel implementation method for multi-target distance and velocity deblurring according to claim 1, characterized in that, The thresholds include a distance threshold and a speed threshold.

8. The GPU two-level parallel implementation method for multi-target distance and velocity deblurring according to claim 1, characterized in that, Also includes: The number of successfully defuzzified point combinations is updated using atomic operation functions.

Images