在 __global__ 和 __device__ CUDA function 中创建多个临时变量似乎会导致性能不佳

Question

我正在做一个需要实现许多小型 3x3 矩阵乘法的项目。 为了更好地组织我的代码，我编写了许多__device__函数来拆分这些小操作。 但是，当我在我的主要__global__ function cudaCalcDistance中使用那些__device__函数（ calcNED ， Geoditic2ECEF ）时，它的执行速度非常慢。 calcNED需要 500 毫秒来执行。 是因为我使用了很多导致这种性能的临时变量。 如果是这种情况，是否有避免在代码保持清晰的情况下使用许多临时变量的解决方案？

struct GPS {
    float latitude;
    float longtitude;
    float height;
};

struct Coordinate
{
    __host__ __device__ Coordinate(float x_ = 0, float y_ = 0, float z_= 0)
    {
        x = x_;
        y = y_;
        z = z_;
    }
    __host__ __device__ float norm()
    {
        return sqrtf(x * x + y * y + z * z);
    }

    float x;
    float y;
    float z;
};

__host__ __device__ Coordinate Geoditic2ECEF(GPS gps)
{
    Coordinate result;

    float a = 6378137;
    float b = 6356752;
    float f = (a - b) / a;
    float e_sq = f * (2 - f);

    float lambda = gps.latitude / 180 * M_PI;
    float phi = gps.longtitude / 180 * M_PI;

    float N = a / std::sqrt(1 - e_sq * sinf(lambda) * sinf(lambda));
    result.x = (gps.height + N) * cosf(lambda) * cosf(phi);
    result.y = (gps.height + N) * cosf(lambda) * sinf(phi);
    result.z = (gps.height + (1 - e_sq) * N) * sinf(lambda);
    return result;
}

__device__ void calcNED(float *NED, float2 imgPos,
                        float * Rb2c_cur, float *Ri2b_missile_cur,
                        float * Re2i_missile, float fov_pixel)
{
    float Ldonic[3];
    float normTmp = sqrtf(imgPos.x * imgPos.x + imgPos.y * imgPos.y + fov_pixel * fov_pixel);
    Ldonic[0] = imgPos.x /normTmp;
    Ldonic[1] = imgPos.y /normTmp;
    Ldonic[2] = fov_pixel / normTmp;

    float tmp[9];
    float tmp1[9];
    mul3x3TransposeFirst(&tmp[0], Re2i_missile, Ri2b_missile_cur);
    mul3x3(&tmp1[0], &tmp[0], Rb2c_cur);
    mul3x3ToVec3x1(&NED[0], &tmp1[0], &Ldonic[0]);
}

__global__ void cudaCalcDistance(RayInfo *distance,
                                 GPS *ship_gps,
                                 GPS3 * ship_surface_gps,
                                 float6 * ship_surface_imgPos,
                                 ObjStatus* missile_cur,
                                 float * Rb2c_cur, float *Ri2b_missile_cur,
                                 float * Re2i_missile, float fov_pixel,
                                 int num_faces, int num_partialPix, int offset,
                                 int batch_size, int width, int height)
{
    int partialPixIdx = threadIdx.x + IMUL(blockIdx.x, blockDim.x);
    int faceIdx = threadIdx.y + IMUL(blockIdx.y, blockDim.y);

    // index of result array to be calculated(float* distance)
    int resultIdx = faceIdx * batch_size * PIXEL_GRID_SIZE * PIXEL_GRID_SIZE + partialPixIdx;

    // pixel index in the output image(640 * 480)
    int pixIdx = offset * batch_size + partialPixIdx / (PIXEL_GRID_SIZE * PIXEL_GRID_SIZE);

    // row, col index of current thread in the output width * height (640 * 480) image
    int row = pixIdx / width;
    int col = pixIdx % width;

    // index of subpixel inside the subgrid for each pixel
    int partialPixIdx_X = partialPixIdx / (batch_size * PIXEL_GRID_SIZE);
    int partialPixIdx_Y = partialPixIdx % (batch_size * PIXEL_GRID_SIZE);

    if(faceIdx < num_faces && partialPixIdx < num_partialPix)
    {
        Coordinate missile_pos = Geoditic2ECEF(missile_cur->gps);
        float u = col + (float)(partialPixIdx_X - 0.5)/ PIXEL_GRID_SIZE - width / 2 - 0.5;
        float w = row + (float)(partialPixIdx_Y - 0.5)/ PIXEL_GRID_SIZE - height / 2 - 0.5;
        float2 imgPos;
        imgPos.x = u;
        imgPos.y = w;

        // TODO: The following code performs a uncoalescing memory access
        // It is not easy to avoid since it require random data access pattern
        // A possible solution is to reorganize input data
        float2 surface_imgPos[3];
        surface_imgPos[0] = ship_surface_imgPos[faceIdx].x;
        surface_imgPos[1] = ship_surface_imgPos[faceIdx].y;
        surface_imgPos[2] = ship_surface_imgPos[faceIdx].z;

        GPS surface_gps[3];
        surface_gps[0] = ship_surface_gps[faceIdx].x;
        surface_gps[1] = ship_surface_gps[faceIdx].y;
        surface_gps[2] = ship_surface_gps[faceIdx].z;

        float NED[3];
        calcNED(&NED[0], imgPos, Rb2c_cur, Ri2b_missile_cur, Re2i_missile, fov_pixel);

        if(isInsideSurface(&surface_imgPos[0], 3, imgPos))
        {
            distance[resultIdx] = calcDistanceToFace(&NED[0], &surface_imgPos[0], imgPos,
                    missile_pos, &surface_gps[0]);
        }
        else
        {
            distance[resultIdx] = calcDistanceToOcean(&NED[0], imgPos, missile_pos);
        }
    }
}

Answer 1

是因为我使用了很多导致这种性能的临时变量。

不会。如果您使用不必要的临时变量，编译器会将它们优化掉（除非它们的使用引入了副作用

标准::sqrt()

这不应该在设备端代码中工作......

__host__ __device__

主机和设备的函数编译方式不同——它们可以使用不同的库/内部函数。 所以你的问题是关于这个 function 的__device__版本。

float *NED, ... float * Rb2c_cur等。

您应该将所有仅输入缓冲区标记为const __restrict__并将 output 或输入输出标记为__restrict__ 。 不这样做会迫使编译器执行大量重新读取并避免缓存。

有关restrict的更多讨论，请参见：

• 人类可以从限制限定词中得到什么？

• Function 使用指向非 const 的指针和指向相同地址的 const arguments 的指针调用