A GPU-based SAR back-projection imaging parallel acceleration optimization method

Abstract

The application discloses a GPU-based SAR back-projection imaging parallel acceleration optimization method, and aims at the problems of large computation amount and low data processing efficiency of a SAR back-projection imaging algorithm. All steps of imaging calculation are processed on a GPU end by using the powerful computing capacity of the GPU. Meanwhile, based on the shared memory and parallel processing capacity of the GPU, matrix transposition, point multiplication operation and coherent calculation in the SAR back-projection imaging process are analyzed and optimized, so that the back-projection imaging processing speed of the SAR can be effectively improved.

Description

TECHNICAL FIELD

[0001] The present application relates to the technical field of synthetic aperture radar, in particular to a parallel acceleration optimization method for SAR back-projection imaging based on GPU. BACKGROUND

[0002] SAR (Synthetic Aperture Radar) is a kind of high-resolution imaging radar, which has been widely used in military and civilian fields. With the improvement of SAR resolution and mapping bandwidth, higher requirements are put forward for the speed of imaging. The increase of echo data and the complexity of the algorithm bring challenges to the subsequent efficient processing of data.

[0003] The pre-processing of SAR echo data and the speed of imaging algorithm directly affect the timeliness of subsequent image processing. The back-projection imaging algorithm can adapt to SAR imaging under any model. This algorithm can obtain accurate focused images by using the point-by-point traversal method, but the point-by-point operation introduces a huge amount of calculation, which becomes a bottleneck problem restricting the efficient acquisition of SAR images. SUMMARY

[0004] In view of the huge amount of calculation of the back-projection imaging algorithm and the high parallelism of the algorithm logic, the present disclosure provides a parallel acceleration optimization scheme based on GPU to realize the efficiency of the back-projection imaging algorithm and meet the needs of precise measurement and other fields.

[0005] GPU (Graphics Processing Unit) has strong floating-point calculation capability and highly parallel architecture, and has obvious advantages in parallel computing with large calculation scale, simple logical branching and high data density, so it is suitable for processing large and complex parallel operations.

[0006] The parallel acceleration optimization method for SAR back-projection imaging based on GPU provided by the present disclosure includes the following steps:

[0007] loading the unpacked radar echo data into the GPU device end;

[0008] performing distance dimension processing on the radar echo data in the GPU device end, including pulse compression, distance windowing, and distance dimension interpolation processing;

[0009] performing azimuth dimension processing on the radar echo data processed in the distance dimension in the GPU device end, including: based on shared memory, performing radar echo matrix transposition by parallel reading, and performing parallel azimuth windowing processing by allocating thread resources;

[0010] On the GPU device side, the radar echo data processed by the distance dimension and the azimuth dimension is subjected to coherent processing, including imaging space grid division, coarse and fine granularity parallel Doppler phase calculation and Doppler phase compensation based on thread resources, and coherent superposition processing to complete imaging.

[0011] Further, the step of loading the unpacked radar echo data into the GPU device side specifically includes:

[0012] The unpacked echo data matrix Echo_cpu[M,N] is divided into S data streams, that is, the distance dimension data is stored continuously in a data stream;

[0013] S data streams are sequentially loaded into the allocated GPU memory space Echo[M,N] by using an asynchronous parallel technology, and the data corresponding to each stream is loaded and stored in the GPU in the form of continuous distance dimension data;

[0014] wherein Echo_cpu[M,N] is the storage space of the CPU end echo matrix, M is the azimuth pulse repetition time, and N is the distance sampling point number;

[0015] One data stream contains echo data of one azimuth time, and the number of streams is determined according to the optimal effect that can be achieved by the GPU multi-stream.

[0016] Further, the step of processing the radar echo data in the distance dimension on the GPU device side specifically includes:

[0017] The multiple distance dimension data in the s-th (s∈[0,S]) data stream are sequentially subjected to pulse compression;

[0018] The multiple distance pulse compression results of the s-th stream are sequentially subjected to distance dimension windowing;

[0019] The result obtained by distance dimension windowing is transformed into the frequency domain, and the distance dimension data is subjected to interpolation processing by using the zero padding method in the frequency domain;

[0020] When the current stream s has not executed to the end, that is, s≤S, all streams are blocked until the execution ends, and the streams are destroyed.

[0021] Further, the specific steps of transposing the radar echo matrix by parallel reading based on the shared memory include:

[0022] The matrix obtained by the distance dimension processing is filled into a square matrix;

[0023] The square matrix is divided into equal-sized sub-square matrices;

[0024] The fine-grained parallel level reads and writes the sub-matrix in the shared memory in parallel by rows, and reads and writes the atomic matrix from the shared memory in parallel by columns, to realize the transposition of the sub-matrix;

[0025] The coarse-grained parallel level writes the sub-matrix in the shared memory in parallel, to complete the data exchange between the sub-matrices.

[0026] The transposed matrix is removed from the padding zero, to complete the transposition operation of the matrix.

[0027] Further, the specific steps of the coherent processing include:

[0028] Thread resources are allocated at the GPU end, and the imaging space grid is divided, one grid corresponding to one pixel point;

[0029] The coarse-grained and fine-grained two-layer parallel is realized by calling the thread resources of the GPU, to calculate the two-way distance and the Doppler phase: the imaging space pixel point is mapped to the GPU thread block, one pixel corresponding to one thread block, to realize the coarse-grained parallel; the azimuth moment is mapped to the thread contained in the thread block, to realize the fine-grained parallel.

[0030] The radar echo matrix processed in the distance dimension and the azimuth dimension is mapped to the imaging space, and the Doppler phase corresponding to each azimuth moment is calculated on the same pixel grid and the Doppler phase compensation is performed, and the result is stored in the shared memory unique to the thread block corresponding to a single pixel.

[0031] The data in the shared memory is accumulated to obtain each pixel point in the imaging space, to obtain the final image matrix, and the imaging is completed.

[0032] Further, the optimization method further includes the step of copying the image matrix obtained by processing at the GPU device end to the CPU host end.

[0033] It can be seen that, aiming at the problem that the SAR backward projection imaging algorithm has a large amount of operation and low data processing efficiency, the powerful computing capacity of the GPU is utilized to process all steps of imaging calculation at the GPU end, and based on the shared memory and parallel processing capacity of the GPU, the matrix transposition, point multiplication and coherent calculation in the SAR backward projection imaging process are analyzed and optimized, which can effectively improve the processing speed of the SAR backward projection imaging.

[0034] Compared with existing technologies, the beneficial effects of this disclosure are: ① Parallel acceleration optimization of the SAR back projection imaging algorithm is achieved by using a GPU as the processing platform; ② All steps of imaging calculation are processed on the GPU, avoiding the time consumption introduced by frequent communication between the CPU and GPU, and improving data processing efficiency; ③ Asynchronous parallel technology is adopted to effectively hide the time consumption of data transmission and processing; ④ A new matrix transpose method is proposed, which uses as little video memory resources as possible and can process larger echo matrices; ⑤ Doppler phase calculation and compensation are parallelized at two levels, coarse and fine granularity, at both the azimuth and time and spatial pixel levels, which significantly improves the imaging processing speed. Attached Figure Description

[0035] Figure 1 A flowchart illustrating an exemplary embodiment of this disclosure;

[0036] Figure 2 This is a schematic diagram of the asynchronous parallel technology disclosed herein;

[0037] Figure 3 This is a schematic diagram of the matrix transpose operation disclosed herein;

[0038] Figure 4 This is a schematic diagram of the coherent calculation process disclosed in this invention;

[0039] Figure 5 This is a schematic diagram illustrating the coarse-to-fine granularity parallelism of coherent computation in this disclosure. Detailed Implementation

[0040] The present invention will now be described in detail with reference to the accompanying drawings and embodiments.

[0041] This invention provides a GPU-based parallel acceleration optimization method for SAR back projection imaging, such as... Figure 1 As shown, it includes the following steps:

[0042] Step 1: Load the unpacked synthetic aperture radar echo data into the GPU device.

[0043] The unpacked echo data matrix Echo_cpu[M,N] is divided into S data streams, meaning that data in the distance dimension is stored sequentially within each data stream. For example... Figure 2 As shown, S data streams are sequentially loaded into the allocated GPU memory space Echo[M,N] using asynchronous parallel technology. At this time, the data corresponding to each stream is loaded and stored in the GPU in a continuous form of distance dimension data. After all the echo data from the CPU is transmitted to the GPU, all steps of the imaging calculation in this invention are processed on the GPU, avoiding the time consumption caused by frequent communication between the CPU and the GPU.

[0044] Wherein, Echo_cpu[M, N] is a CPU end echo matrix, M is the number of azimuth pulse repetition time, N is the number of distance sampling points, S is the number of CUDA (operation platform) streams, one stream contains Echo[M, N] is a GPU end echo matrix storage space; the number of streams is determined according to the optimal effect that can be achieved by GPU multi-stream, in this example, the preferred number of streams S = 4.

[0045] Figure 2 As shown in the schematic diagram of asynchronous parallel technology, the CPU end echo data is divided into blocks, and the data is transmitted to the corresponding GPU end memory space by the stream, which shortens the waiting time of distance dimension processing. The parallel transmission and processing operation of multiple streams can make the GPU operation core in a busy state most of the time, effectively masking the data transmission time between CPU and GPU without data blocking.

[0046] Step 2: Distance dimension processing of radar echo data on the GPU device end.

[0047] The specific steps are as follows:

[0048] 2. a pulse compression: since the data transmitted in step 1 is stored in the GPU end in distance dimension priority, multiple distance dimension data Echo[m, :] in the s (s ∈ [0, S]) stream can be sequentially pulse compressed, this operation uses CUDACUFFT library function, and the pulse compression of distance dimension data is completed by creating CUFFT execution plan, and stored in the GPU end original distance dimension matrix Echo[m, :].

[0049] 2.b distance windowing: create a distance window Rwin[N] on the GPU end by calling threads, and the length is the number of distance dimension sampling points. The multiple distance pulse compression results of the s stream obtained in step 2.a are sequentially processed by distance dimension windowing, which realizes parallel windowing by allocating thread resources, that is:

[0050] Echo[m, Idx] = Echo[m, Idx] * Rwin[Idx],

[0051] and stored in the GPU end original distance dimension matrix Echo[m, :].

[0052] Wherein, Echo[m, Idx] is the distance dimension matrix corresponding to the m azimuth moment, and Idx is the GPU thread resource opened.

[0053] 2.c Distance dimension interpolation: all data processing of the present application is performed on GPU, and no corresponding interpolation function is available for use, so the interpolation processing of distance dimension data is realized by means of zero padding in frequency domain. Firstly, the distance windowing result of the mth azimuth time obtained in step 2.b is subjected to CUFFT transformation to frequency domain, zero padding is performed, the matrix Echo[m, N] is expanded into the matrix Echo[m, Np], wherein Np is the distance dimension point number after zero padding, then CUIFFT transformation is performed to time domain to complete distance dimension interpolation, and is stored in the original distance dimension matrix Echo[m, :] on the GPU end. Thus, the data processing stage of the s th stream of step 1 asynchronous parallel technology is completed, and the s th stream execution ends.

[0054] 2.d When the current stream s has not yet executed, that is, s≤S, the execution of all streams is blocked until it ends, and the stream is destroyed. At this time, the data processed in distance dimension is stored in the matrix Echo[M, Np] on the GPU end.

[0055] Step 3: azimuth dimension processing is performed on the data obtained in step 2 on the GPU device end.

[0056] 3.a Matrix transposition: by means of shared memory auxiliary read-write operation, combined read and combined write of global memory are realized. For example, Figure 3 The matrix transposition operation diagram. In order to better adapt to square matrix echo data and non-square matrix echo data and improve the universality of the matrix transposition method, firstly, the matrix Echo[M, Np] obtained in step 2 distance dimension processing is padded into a square matrix Echo[P, P], and then the matrix is divided into equal-sized sub-matrices, wherein P = max(M, Np), and in the present example, Np > M, P = Np.

[0057] In the fine-grained parallel layer, the sub-matrices are read and written into the shared memory by row, and the transposition of the sub-matrices is realized by reading and writing the atomic square matrix from the shared memory by column, as shown in Figure 3 (b) Sub-matrix (0, 2) and Figure 3 (c) Sub-matrix (0, 2). In the coarse-grained parallel layer, the sub-matrices are written into the corresponding sub-matrices in the original memory space after transposition, and the data exchange between the sub-matrices is completed, as shown in Figure 3 (c) Sub-matrix (0, 2) and Figure 3 (d) Sub-matrix (2, 0). After transposition, the matrix is removed from the padded zero, and the transposition operation of the matrix is completed, obtaining Echo T [M, Np], so that the data in the matrix is stored in the GPU end in the azimuth dimension first, facilitating subsequent azimuth dimension windowing and coherent calculation.

[0058] 3.b Azimuth windowing: the data matrix Echo T[M, N] is windowed in azimuth dimension and stored in the original memory space Echo T [M, N] is windowed in azimuth dimension and stored in the original memory space Echo

[0059] Azimuth window Awin[N] is created by calling threads on the GPU side, and the length is the azimuth time point number. The transposed matrix Echo T [M, Np] is windowed in azimuth dimension, which is realized by allocating thread resources, that is, Echo T [Idx, n] = Echo T [Idx, n]·Awin[Idx] is stored in the original distance dimension matrix Echo T [Idx, n]·Awin[Idx] is stored in the original distance dimension matrix Echo

[0060] wherein, Echo T [Idx, n]·Awin[Idx] is stored in the original distance dimension matrix Echo

[0061] Step 4: The data obtained by step 3 is processed on the GPU device.

[0062] As shown in Figure 4 , it is a SAR coherent calculation process flow diagram.

[0063] 4.a imaging space grid division: allocate thread resources on the GPU side to divide the imaging space grid Img[Gx, Gy], which respectively stores the x and y coordinates in the space grid, that is:

[0064] Img[bIdx.x, bIdx.y].x = x start + Idx x Delta x

[0065] Img[bIdx.x, bIdx.y].y = y start + Idx x Delta y

[0066] wherein, bIdx.x, bIdx.y is the thread block index, Idx is the thread resource, Delta x, Delta y are the azimuth grid resolution and the range grid resolution respectively, Img[Gx, Gy] is the imaging space, Gx is the azimuth grid length, Gy is the range grid length, Img(bIdx.x, bIdx.y) is the spatial coordinates of the pixel point (bIdx.x, bIdx.y).

[0067] 4.b calculation of two-way delay and Doppler phase: as shown in Figure 5As shown, the present application realizes coarse-grained parallelism by mapping imaging space pixels to GPU thread blocks, and fine-grained parallelism by mapping azimuth time to threads within the thread blocks, and realizes two-layer parallelism of coarse and fine granularity by calling thread resources of the GPU to calculate the two-way delay phase, that is

[0068] wherein AR is the one-way distance of the radar and the space pixel, bIdx.x and bIdx.y are thread block indexes, and (bIdx.x, bIdx.y) represents a thread block (bIdx.x, bIdx.y) that can uniquely identify a pixel point (bIdx.x, bIdx.y) in the pixel space Img. Idx is a thread index within the thread block, pos(Idx) is the spatial coordinate of the radar at the azimuth time Idx, and |Img(bIdx.x, bIdx.y)-pos(Idx)| is the one-way distance modulus value of the radar coordinate pos(Idx) and the imaging space pixel point (bIdx.x, bIdx.y) at the azimuth time Idx.

[0069] 4. c Doppler phase compensation: the result matrix Echo T [M, N] obtained in step 3 is mapped to the imaging space Img[Gx, Gy], the Doppler phase compensation is performed on the same pixel grid, and the result is stored in the shared memory unique to a single pixel, that is

[0070] wherein Idx is a thread within the thread block (bIdx.x, bIdx.y), and SM is the shared memory possessed by the thread block, and each thread block is allocated a shared memory for access by all threads within the thread block.

[0071] 4. d phase correlation accumulation: the data in the shared memory in step 4.c is accumulated to calculate the scattering value of each pixel point in the imaging space, obtain the final image matrix Image[Gx, Gy], and store it in the video memory space, and complete imaging. That is

[0072] wherein Image[bIdx.x, bIdx.y] is the accumulation value of the scattering value of the pixel point (bIdx.x, bIdx.y) at all azimuth times, that is, the image amplitude value.

[0073] Step 5: copy the image matrix obtained by the GPU device end processing to the CPU host end.

[0074] The built-in function cudaMemcpy() of CUDA is used to communicate between the GPU device end and the CPU host end, and the image Image[Gx, Gy] obtained in step 4 is copied back to the CPU host end.

[0075] To sum up, the above is only the preferred embodiment of the present application, and is not used to limit the protection scope of the present application. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present application shall be included in the protection scope of the present application.

Claims

1. A GPU-based SAR back-projection imaging parallel acceleration optimization method, characterized in that, The method comprises the following steps: loading unpacked radar echo data into a GPU device; performing distance dimension processing on the radar echo data on the GPU device, including pulse compression, distance windowing, and distance dimension interpolation processing; performing azimuth dimension processing on the radar echo data processed in the distance dimension on the GPU device, including radar echo matrix transposition based on shared memory through parallel reading and parallel azimuth windowing processing through allocation of thread resources; performing coherent processing on the radar echo data processed in the distance dimension and the azimuth dimension on the GPU device, including imaging space grid division, coarse and fine-grained parallel Doppler phase calculation and Doppler phase compensation based on thread resources, and coherent superposition processing to complete imaging. The step of loading the unpacked radar echo data into the GPU device specifically comprises: dividing the unpacked echo data matrix Echo_cpu[M,N] into S data streams, that is, storing the distance dimension data continuously in a data stream first; loading the S data streams into the allocated GPU memory space Echo[M,N] in sequence through asynchronous parallel technology, at this time, the data corresponding to each stream is loaded and stored in the GPU in the form of continuous distance dimension data; wherein Echo_cpu[M,N] is the storage space of the CPU end echo matrix, M is the azimuth pulse repetition time number, and N is the distance sampling point number; A data stream contains echo data of one orientation instant, the number of streams is determined according to the optimal effect that can be achieved by the GPU multi-stream. The specific steps of performing radar echo matrix transposition based on shared memory through parallel reading comprise: filling the matrix obtained through the distance dimension processing into a square matrix; dividing the square matrix into equal-sized sub-matrices; at the fine-grained parallel level, reading and writing the sub-matrices into the shared memory in parallel by row, and then reading and writing the sub-matrices from the shared memory into the original atomic square matrix in parallel by column, to realize transposition of the sub-matrices; at the coarse-grained parallel level, with the help of the shared memory, writing the sub-matrices into the corresponding sub-matrices in the original memory space after transposition in parallel, to complete data exchange between the sub-matrices; removing the filled zeros from the transposed matrix, that is, completing the matrix transposition operation.

2. The optimization method of claim 1, wherein the step of performing distance dimension processing on the radar echo data on the GPU device specifically comprises: performing pulse compression on a plurality of distance dimension data in the s th (s∈[0,S]) data stream in sequence; performing distance dimension windowing on the plurality of distance pulse compression results of the s th stream in sequence; transforming the results obtained through distance dimension windowing to the frequency domain, and performing interpolation processing on the distance dimension data in the form of zero padding in the frequency domain; when the current stream s has not executed, that is, s≤S, blocking until all streams execute, and destroying the streams.

3. The optimization method of claim 1, wherein the specific steps of coherent processing comprise: allocating thread resources on the GPU to divide the imaging space grid, and one grid corresponds to one pixel point. The GPU thread resources are called to realize two-layer parallelism of coarse and fine granularity to calculate the two-way distance and Doppler phase: the imaging space pixel points are mapped to the GPU thread blocks, one pixel corresponds to one thread block, coarse-grained parallelism is realized; the azimuth time is mapped to the threads contained in the thread block, fine-grained parallelism is realized. The radar echo matrix processed in the distance dimension and the azimuth dimension is mapped to the imaging space, the Doppler phase corresponding to each azimuth time is calculated on the same pixel grid, the Doppler phase compensation is performed, and the result is stored in the shared memory unique to the thread block corresponding to a single pixel. The data in the shared memory is accumulated to obtain each pixel point in the imaging space, and the final image matrix is obtained, and the imaging is completed.

4. The optimization method of claim 1 or 3, further comprising: The image matrix obtained by the GPU device end processing is copied to the CPU host end.

Images