Cuda 具有读写功能的纹理存储器

我正在开发一个CUDA应用程序，其中内核必须多次进入全局内存。该内存由所有CTA随机访问（无位置，因此无法使用共享内存）。我需要优化它。我听说纹理内存可以缓解这个问题，但是内核可以读写纹理内存吗？一维纹理记忆？2D纹理记忆？还有CUDA阵列呢？

CUDA纹理是只读的。纹理读取被缓存。因此，性能增益是概率性的

CUDA Toolkit 3.1及更高版本还具有可写纹理，称为曲面，但它们仅适用于计算能力>=2.0的设备。曲面就像纹理一样，但优点是它们也可以由内核编写

---

曲面只能绑定到使用flag

cudaArraySurfaceLoadStore创建的
cudaArray
我建议将您的内存声明为倾斜线性内存，并使用纹理绑定。我还没有尝试新的无黏结纹理。有人试过吗

所提到的纹理mem是通过缓存只读的。将其视为只读内存。
因此，重要的是要注意，在内核本身中，您不会写入绑定到纹理的内存，因为它可能不会更新到纹理缓存。
我遇到了这个问题，经过一点搜索，我发现问题和答案很有用。
纹理记忆基本上是全局记忆。纹理内存是指可以与全局内存读取关联的特殊缓存机制。因此，内核可以操作绑定到纹理的全局内存。但正如图中所示，没有任何指令，例如
tex1D（ref，x）=12.0
这是对sgarizvi答案的后续说明

如今，计算能力
>=2.0
的卡比
2012
的卡更为常见，也就是说，在提出这个问题时

下面是一个关于如何使用CUDA表面存储器写入纹理的简单示例

#include <stdio.h>

#include "TimingGPU.cuh"
#include "Utilities.cuh"

surface<void, cudaSurfaceType1D> surfD;

/*******************/
/* KERNEL FUNCTION */
/*******************/
__global__ void SurfaceMemoryWrite(const int N) {

    int tid = blockIdx.x * blockDim.x + threadIdx.x;

    surf1Dwrite((float)tid, surfD, tid * sizeof(float), cudaBoundaryModeTrap);
}

/********/
/* MAIN */
/********/
int main() {

    const int N = 10;

    cudaChannelFormatDesc channelDesc = cudaCreateChannelDesc<float>();
    //Alternatively
    //cudaChannelFormatDesc channelDesc = cudaCreateChannelDesc(32, 0, 0, 0, cudaChannelFormatKindFloat);

    cudaArray *d_arr;   gpuErrchk(cudaMallocArray(&d_arr, &channelDesc, N, 1, cudaArraySurfaceLoadStore));
    gpuErrchk(cudaBindSurfaceToArray(surfD, d_arr));

    SurfaceMemoryWrite<<<1, N>>>(N);

    float *h_arr = new float[N];
    gpuErrchk(cudaMemcpyFromArray(h_arr, d_arr, 0, 0, N * sizeof(float), cudaMemcpyDeviceToHost));

    for (int i=0; i<N; i++) printf("h_arr[%i] = %f\n", i, h_arr[i]);

    return 0;
}

#包括
#包括“TimingGPU.cuh”
#包括“Utilities.cuh”
表面冲浪；
/*******************/
/*核函数*/
/*******************/
__全局_uuu无效表面内存写入（常量int N）{
int tid=blockIdx.x*blockDim.x+threadIdx.x；
SURF1DRITE（（浮动）tid、surfD、tid*sizeof（浮动）、cudaBoundaryModeTrap）；
}
/********/
/*主要*/
/********/
int main（）{
常数int N=10；
cudaChannelFormatDesc channelDesc=cudaCreateChannelDesc（）；
//或者
//cudaChannelFormatDesc channelDesc=cudaCreateChannelDesc（32,0,0，cudaChannelFormatKindFloat）；
cudaArray*d_arr；gpuErrchk（cudaMallocArray（&d_arr，&channelDesc，N，1，cudaArraySurfaceLoadStore））；
gpuErrchk（cudaBindSurfaceToArray（surfD，d_arr））；
表面摩擦学（N）；
浮动*h_arr=新浮动[N]；
gpuErrchk（cudaMemcpyFromArray（h_arr，d_arr，0，0，N*sizeof（float），cudaMemcpyDeviceToHost））；
对于（inti=0；i，这是对Farzad回答的后续

Farzad的观点在CUDA C编程指南中得到了强调：

纹理和曲面内存被缓存（请参见设备内存访问）
在同一个内核调用中，缓存与
关于全局内存写入和表面内存写入，所以
纹理提取或曲面读取到已写入的地址
在同一内核调用中通过全局写入或表面写入返回
未定义的数据。换句话说，线程可以安全地读取某些纹理
或仅当此内存位置已被
由以前的内核调用或内存副本更新，但如果有
以前已由同一线程或来自的另一个线程更新
相同的内核调用

这意味着可以修改纹理绑定到的全局内存位置，但这不能发生在操作纹理抓取的同一内核中。另一方面，由于内核启动时会清除纹理缓存，因此可以跨内核执行上述意义上的“写入纹理”，请参阅

下面，我提供了一个例子，其中纹理绑定到的全局内存位置被修改

median_filter_periodic_boundary<<<iDivUp(N, BLOCKSIZE), BLOCKSIZE>>>(d_out, N);
...
square<<<iDivUp(N, BLOCKSIZE), BLOCKSIZE>>>(d_vec, pitch, N);
...
median_filter_periodic_boundary<<<iDivUp(N, BLOCKSIZE), BLOCKSIZE>>>(d_out, N);

请注意以下事项：

我没有将纹理绑定到
cudaArray
，因为
cudaArray
s不能从内核内部修改
我没有将纹理绑定到
cudamaloc
ed数组，因为绑定到
cudamaloc
ed数组的纹理只能由
tex1Dfetch
获取，而
tex1Dfetch
没有
cudaAddressModeWrap
寻址模式保证信号周期性扩展到其边界之外
我正在将纹理绑定到一个
cudamallocitch
ed数组，因为这样就可以通过
tex1D
获取纹理，这允许
cudaAddressModeWrap
寻址模式
我使用的是标准化坐标，因为只有这些坐标才能启用
cudaAddressModeWrap
寻址模式
我需要点
#2
、
#3
和
#4
，因为我从我正在编写的代码中提取了这个示例。
请阅读CUDA编程指南第3节中关于表面内存的文档。如果您的内存访问在没有局部性的大内存块上确实是随机的，那么任何类型的缓存都不会提供给您一个显著的改进。您需要找到一种方法来改进内存访问模式，或者适应当前的低性能。我可以对表面内存执行原子操作吗？@username\u 4567否：纹理和表面内存被缓存（请参阅设备内存访问）在同一内核调用中，缓存在全局内存写入和表面内存写入方面不保持一致，因此任何纹理提取或表面读取到一个地址，该地址已通过内核中的全局写入或表面写入写入
#include <stdio.h>

#include "TimingGPU.cuh"
#include "Utilities.cuh"

texture<float, 1, cudaReadModeElementType> signal_texture;

#define BLOCKSIZE 32

/*************************************************/
/* KERNEL FUNCTION FOR MEDIAN FILTER CALCULATION */
/*************************************************/
__global__ void median_filter_periodic_boundary(float * __restrict__ d_out, const unsigned int N){

    int tid = threadIdx.x + blockIdx.x * blockDim.x;

    if (tid < N) {

        float signal_center = tex1D(signal_texture, (float)(tid + 0.5 - 0) / (float)N);
        float signal_before = tex1D(signal_texture, (float)(tid + 0.5 - 1) / (float)N);
        float signal_after  = tex1D(signal_texture, (float)(tid + 0.5 + 1) / (float)N);

        d_out[tid] = (signal_center + signal_before + signal_after) / 3.f;

    }
}

/*************************************************/
/* KERNEL FUNCTION FOR MEDIAN FILTER CALCULATION */
/*************************************************/
__global__ void square(float * __restrict__ d_vec, const size_t pitch, const unsigned int N){

    unsigned int tid = threadIdx.x + blockIdx.x * blockDim.x;

    if (tid < N) d_vec[tid] = 2.f * tid;

}

/********/
/* MAIN */
/********/
int main() {

    const int N = 10;                                                                                

    // --- Input/output host array declaration and initialization
    float *h_vec = (float *)malloc(N * sizeof(float));
    for (int i = 0; i < N; i++) h_vec[i] = (float)i;

    // --- Input/output host and device array vectors
    size_t pitch;
    float *d_vec;   gpuErrchk(cudaMallocPitch(&d_vec, &pitch, N * sizeof(float), 1));
    printf("pitch = %i\n", pitch);
    float *d_out;   gpuErrchk(cudaMalloc(&d_out, N * sizeof(float)));
    gpuErrchk(cudaMemcpy(d_vec, h_vec, N * sizeof(float), cudaMemcpyHostToDevice));

    // --- CUDA texture memory binding and properties definition
    cudaChannelFormatDesc channelDesc = cudaCreateChannelDesc<float>();
    //Alternatively
    //cudaChannelFormatDesc channelDesc = cudaCreateChannelDesc(32, 0, 0, 0, cudaChannelFormatKindFloat);
    size_t texture_offset = 0;
    gpuErrchk(cudaBindTexture2D(&texture_offset, signal_texture, d_vec, channelDesc, N, 1, pitch)); 
    signal_texture.normalized = true; 
    signal_texture.addressMode[0] = cudaAddressModeWrap;

    // --- Median filter kernel execution
    median_filter_periodic_boundary<<<iDivUp(N, BLOCKSIZE), BLOCKSIZE>>>(d_out, N);
    gpuErrchk(cudaPeekAtLastError());
    gpuErrchk(cudaDeviceSynchronize());

    gpuErrchk(cudaMemcpy(h_vec, d_out, N * sizeof(float), cudaMemcpyDeviceToHost));
    printf("\n\nFirst filtering\n");
    for (int i=0; i<N; i++) printf("h_vec[%i] = %f\n", i, h_vec[i]);

    // --- Square kernel execution
    square<<<iDivUp(N, BLOCKSIZE), BLOCKSIZE>>>(d_vec, pitch, N);
    gpuErrchk(cudaPeekAtLastError());
    gpuErrchk(cudaDeviceSynchronize());

    gpuErrchk(cudaMemcpy(h_vec, d_vec, N * sizeof(float), cudaMemcpyDeviceToHost));
    printf("\n\nSquaring\n");
    for (int i=0; i<N; i++) printf("h_vec[%i] = %f\n", i, h_vec[i]);

    // --- Median filter kernel execution
    median_filter_periodic_boundary<<<iDivUp(N, BLOCKSIZE), BLOCKSIZE>>>(d_out, N);
    gpuErrchk(cudaPeekAtLastError());
    gpuErrchk(cudaDeviceSynchronize());

    printf("\n\nSecond filtering\n");
    gpuErrchk(cudaMemcpy(h_vec, d_out, N * sizeof(float), cudaMemcpyDeviceToHost));
    for (int i=0; i<N; i++) printf("h_vec[%i] = %f\n", i, h_vec[i]);

    printf("Test finished\n");

    return 0;
}