CN106528054A - GPU (Graphics Processing Unit) accelerated dense vector addition computing method - Google Patents

Abstract

The invention discloses a GPU-accelerated dense vector addition calculation method. The method is suitable for accelerating the addition operation of dense vectors: A+B=C, where A and B represent the added vectors, and C represents the result vector. The algorithm is implemented in detail The steps are: the CPU generates the data required to calculate the vector addition operation on the GPU; then the CPU transfers the data to the GPU; assigns the task of vector A+B to the GPU thread; then executes the vector addition operation in the GPU kernel function. In the present invention, the main task of the CPU is to generate and transmit data, and complete the scheduling of the main program. The addition operation of related vectors is completed by the GPU kernel function, and the high parallelism hardware characteristics of the GPU are used to greatly improve the speed of the dense vector addition operation.

Description

GPU Accelerated Dense Vector Addition Calculation Method

technical field

The invention belongs to the application field of high-performance computing in power systems, and in particular relates to a GPU-accelerated dense vector addition computing method.

Background technique

GPU graphics processing unit (English: Graphics Processing Unit, abbreviation: GPU) far exceeds the CPU in the number of processing units, and is a many-core parallel processor. Traditionally, the GPU is only responsible for graphics rendering, and most of the processing is handed over to the CPU. The current GPU has become a multi-core, multi-threaded, programmable processor with powerful computing capabilities and extremely high memory bandwidth. Under the general computing model, the GPU works as a coprocessor of the CPU, and completes high-performance computing through reasonable task allocation and decomposition.

The computation of dense vectors has parallelism. Because the numerical calculations of the corresponding positions in the vector are independent of each other and have no dependencies, they can naturally be processed in parallel and are suitable for GPU acceleration.

Such operations can be accomplished through reasonable scheduling between the CPU and GPU.

Contents of the invention

Purpose of the invention: In order to overcome the deficiencies in the prior art, the present invention provides a GPU-accelerated dense vector addition calculation method, which solves the time-consuming technical defect of dense vector addition calculation.

Technical scheme: in order to achieve the above object, the technical scheme of the present invention is as follows:

A GPU-accelerated dense vector addition calculation method, which is suitable for accelerating the addition operation of dense vectors: A+B=C, where A and B represent the added vectors, and C represents the result vector. The method includes:

(1) Allocate the data storage space required for GPU calculation in the CPU, and transfer the data required for GPU calculation to the GPU;

(2) Assign the task of adding each element of vector A and B to a large number of threads in the GPU for execution;

(3) The kernel function Kernel_plus that performs vector addition in the GPU.

In step (1), prepare the data required by the GPU kernel function in the CPU, specifically as follows: vector A, B, and C are all stored as an array format, and the data includes: the number of vector elements is n, the vector DataA, DataB , the result vector DataC.

In step (2), the task of adding n elements of vectors A and B is assigned to a large number of threads in the GPU for execution, that is, one thread of the kernel function is responsible for the addition of the corresponding elements in vectors A and B, such as DataA[1 ]+DataB[1]=DataC[1].

In step (3), the kernel function Kernel_plus of completing vector addition operation is defined as Kernel_plus<N _blocks , N _threads >, and the thread block size is fixed at 128, namely: N _threads =128, and its thread block quantity N _blocks is n/128, The total number of threads is n; call the kernel function Kernel_plus<N _blocks , N _threads > to calculate the vector addition operation;

The calculation process of the kernel function Kernel_plus<N _blocks , N _threads > is:

(4.1) CUDA automatically assigns thread block index blockID and thread index threadID in the thread block for each thread;

(4.2) Assign blockID to variable tid, assign threadID to variable k, and then index the k thread in the tid number thread block by tid and t;

(4.3) variable t=tid*128+k;

(4.4) The k thread in the tid thread block is responsible for adding the t elements of vector A and vector B: C _t =A _t +B _t , where A _t , B _t and C _t are vector A respectively , the tth element in B and C.

Beneficial effect: Compared with the prior art, the CPU generates the data needed to calculate the vector addition operation on the GPU; then the CPU transmits the data to the GPU; the task of adding the matrix A ₁ +B ₁ =C ₁ is assigned to GPU thread; then execute the kernel function of vector addition in GPU. Significantly reduced computation time for dense vector addition.

Description of drawings

Accompanying drawing 1 is the schematic flow chart of the present invention.

detailed description

The present invention will be further described below in conjunction with the accompanying drawings.

As shown in Figure 1, the present invention is a GPU-accelerated dense vector addition calculation method, which is suitable for accelerating the addition operation of dense vectors: A+B=C, where A and B represent the added Vector, C represents result vector, it is characterized in that described method comprises:

(1) The data storage space required for GPU calculation is allocated in the CPU, and the data required for GPU calculation is transmitted to the GPU; the data required for calculating the vector addition operation on the GPU is generated in the CPU, and the data is transmitted to on the GPU;

(2) Assign the task of adding each element of vector A and B to a large number of threads in the GPU for execution;

(3) The kernel function Kernel_plus that performs vector addition in the GPU.

In described step (1), prepare the required data of GPU kernel function in CPU, specifically as follows: vector A, B, C are all stored as array format, and its described data comprises: vector element number is n, and vector DataA , DataB, the result vector DataC.

In the step (2), one thread of the kernel function is responsible for the addition operation of the corresponding elements in the vectors A and B, such as DataA[1]+DataB[1]=DataC[1].

In described step (3), the kernel function Kernel_plus of finishing vector addition operation is defined as Kernel_plus<N _blocks , N _threads >, and thread block size is fixed as 128, namely: N _threads =128, and its thread block quantity N _blocks is n/ 128, the total number of threads is n; call the kernel function Kernel_plus<N _blocks , N _threads > to calculate the operation of vector addition. The calculation process of the kernel function Kernel_plus<N _blocks , N _threads > is:

(4.1) CUDA automatically assigns thread block index blockID and thread index threadID in the thread block for each thread;

(4.2) Assign blockID to variable tid, assign threadID to variable k, and then index the k thread in the tid number thread block by tid and t;

(4.3) variable t=tid*128+k;

(4.4) Thread k in the thread block tid is responsible for the addition operation of the tth element of vector A and vector B: C _t =A _t +B _t, where A _t , B _t and C _t are vector A respectively , the tth element in B and C.

The above is only a preferred embodiment of the present invention, it should be pointed out that for those of ordinary skill in the art, without departing from the principle of the present invention, some improvements and modifications can also be made. It should be regarded as the protection scope of the present invention.

Claims (4)

1. The dense vector addition computing method of GPU acceleration, this method is applicable to the addition operation of accelerating dense vector: A+B=C, wherein A, B represents the vector of addition, and C represents the result vector, it is characterized in that, described Methods include: (1) Allocate the data storage space required for GPU calculation in the CPU, and transfer the data required for GPU calculation to the GPU; (2) Assign the task of adding each element of vector A and B to a large number of threads in the GPU for execution; (3) The kernel function Kernel_plus that performs vector addition in the GPU. 2. the dense vector addition calculation method of GPU acceleration according to claim 1, is characterized in that: in step (1), prepare the required data of GPU kernel function in CPU, specifically as follows: vector A, B, C All are stored in an array format, and the data includes: the number of vector elements is n, the vector DataA, DataB, and the result vector DataC. 3. the dense vector addition calculation method of GPU acceleration according to claim 1, is characterized in that: in step (2), the task of adding n elements of vector A and B is assigned to a large number of threads in the GPU for execution , that is, one thread of the kernel function is responsible for the addition operation of the corresponding elements in the vectors A and B, such as DataA[1]+DataB[1]=DataC[1]. 4. the dense vector addition calculation method of GPU acceleration according to claim 1, is characterized in that: step (3), the kernel function Kernel_plus of finishing vector addition operation is defined as Kernel_plus<N _blocks , N _threads >, thread block size It is fixed at 128, that is: N _threads =128, the number of thread blocks N _blocks is n/128, and the total number of threads is n; call the kernel function Kernel_plus<N _blocks , N _threads > to calculate the operation of vector addition; The calculation process of the kernel function Kernel_plus<N _blocks , N _threads > is: (4.1) CUDA automatically assigns thread block index blockID and thread index threadID in the thread block for each thread; (4.2) Assign blockID to variable tid, assign threadID to variable k, and then index the k thread in the tid number thread block by tid and t; (4.3) variable t=tid*128+k; (4.4) The k thread in the tid thread block is responsible for adding the t elements of vector A and vector B: C _t =A _t +B _t , where A _t , B _t and C _t are vector A respectively , the tth element in B and C.