自定义类型的Cuda纹理提取

我想使用自定义结构（ushort8）从纹理内存中读取，我想从每次抓取中读取128位。编译代码时，会出现以下错误：

/usr/local/cuda-9.0/bin/nvcc -ccbin g++ -I /home/nvidia/NVIDIA_CUDA-9.0_Samples/common/inc/  -m64    --default-stream per-thread -Xptxas -v --resource-usage --maxrregcount=32 -gencode arch=compute_62,code=sm_62 -gencode arch=compute_62,code=compute_62 -o teste.o -c teste.cu #-DNO_COMPUTE_LOCAL
teste.cu(20): error: no instance of overloaded function "tex2DLayered" matches the argument list
            argument types are: (texture<ushort8, 242, cudaReadModeElementType>, const unsigned int, const unsigned int, const unsigned int)

/usr/local/cuda-9.0/bin/nvcc-ccbin g++-I/home/nvidia/nvidia_-cuda-9.0_Samples/common/inc/-m64——每个线程的默认流——Xptxas-v——资源使用率——maxregcount=32——gencode-arch=compute_62，code=sm_-arch=compute_62，code=compute_62-o teste.o-c teste.cu#-DNO#本地
cu（20）：错误：没有重载函数“tex2DLayered”的实例与参数列表匹配
参数类型有：（纹理、常量无符号整数、常量无符号整数、常量无符号整数）

我正在使用CUDA9.0

我已经有了一个使用gpu全局内存的版本，我想用纹理内存复制相同的版本

我已经试过ushort4，效果很好。 这是密码

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>


typedef struct __align__(16) {
    unsigned short s0, s1, s2, s3, s4, s5, s6, s7;
}ushort8;


texture<ushort8, cudaTextureType2DLayered> d_samples;

__global__ void teste(){
    __shared__ ushort8 samples[4];

    samples[threadIdx.x]=tex2DLayered(d_samples,threadIdx.x,threadIdx.y,threadIdx.z);
    printf("thread=%d, value=%hu\n",threadIdx.x, samples[threadIdx.x].s0 );
    printf("thread=%d, value=%hu\n",threadIdx.x, samples[threadIdx.x].s1);
    printf("thread=%d, value=%hu\n",threadIdx.x, samples[threadIdx.x].s2 );
    printf("thread=%d, value=%hu\n",threadIdx.x, samples[threadIdx.x].s3 );
    printf("thread=%d, value=%hu\n",threadIdx.x, samples[threadIdx.x].s4 );
    printf("thread=%d, value=%hu\n",threadIdx.x, samples[threadIdx.x].s5 );
    printf("thread=%d, value=%hu\n",threadIdx.x, samples[threadIdx.x].s6 );
    printf("thread=%d, value=%hu\n",threadIdx.x, samples[threadIdx.x].s7 );

}


int main(int argc, char *argv[]){
    dim3 threadsPerBlock(4,1,1);
    dim3 numBlocks(1,1,1);
    cudaError_t err=cudaSuccess;
    cudaChannelFormatDesc channelDesc_samples = cudaCreateChannelDesc(32, 32, 32, 32, cudaChannelFormatKindUnsigned);
    cudaArray *samples_3darray;

    ushort8 samples[4];

    samples[0].s0=0;
    samples[0].s1=1;
    samples[0].s2=2;
    samples[0].s3=3;
    samples[0].s4=4;
    samples[0].s5=5;
    samples[0].s6=6;
    samples[0].s7=7;

    samples[1].s0=8;
    samples[1].s1=9;
    samples[1].s2=10;
    samples[1].s3=11;
    samples[1].s4=12;
    samples[1].s5=13;
    samples[1].s6=14;
    samples[1].s7=15;

    samples[2].s0=16;
    samples[2].s1=17;
    samples[2].s2=18;
    samples[2].s3=19;
    samples[2].s4=20;
    samples[2].s5=21;
    samples[2].s6=22;
    samples[2].s7=23;

    samples[3].s0=24;
    samples[3].s1=25;
    samples[3].s2=26;
    samples[3].s3=27;
    samples[3].s4=28;
    samples[3].s5=29;
    samples[3].s6=30;
    samples[3].s7=31;


    err=cudaMalloc3DArray(&samples_3darray, &channelDesc_samples, make_cudaExtent(4, 1, 1), cudaArrayLayered);
    if(err!=cudaSuccess){
        fprintf(stderr, "Failed to allocate the texture memory for the samples(error code %d)!\n", cudaGetLastError());
        exit(EXIT_FAILURE);
    }
    cudaMemcpy3DParms myparms_samples = {0};
    myparms_samples.srcPos = make_cudaPos(0,0,0);
    myparms_samples.dstPos = make_cudaPos(0,0,0);
    myparms_samples.srcPtr = make_cudaPitchedPtr(samples, 4 * sizeof(ushort8),4, 1);
    myparms_samples.dstArray = samples_3darray;
    myparms_samples.extent = make_cudaExtent(4, 1,1);
    myparms_samples.kind = cudaMemcpyHostToDevice;

    d_samples.addressMode[0] = cudaAddressModeBorder;
    d_samples.addressMode[1] = cudaAddressModeBorder;
    d_samples.addressMode[2] = cudaAddressModeBorder;
    d_samples.filterMode = cudaFilterModePoint;
    d_samples.normalized = false;  // access with normalized texture coordinates
    err=cudaMemcpy3D(&myparms_samples);
    if(err!=cudaSuccess){
        fprintf(stderr, "Failed to copy the image samples from host to device (error code %d)!\n", cudaGetLastError());
        exit(EXIT_FAILURE);
    }

    err=cudaBindTextureToArray(d_samples, samples_3darray, channelDesc_samples);
    if(err!=cudaSuccess){
        fprintf(stderr, "Failed to bind the texture memory (error code %d)!\n", cudaGetLastError());
        exit(EXIT_FAILURE);
    }

    teste<<<numBlocks, threadsPerBlock>>>();
    if(err!=cudaSuccess){
        fprintf(stderr, "Failed to launch the kernel for the calculation of the local sum (error code %d)!\n", cudaGetLastError());
        exit(EXIT_FAILURE);
    }

    err=cudaUnbindTexture(d_samples);
    if(err!=cudaSuccess){
        fprintf(stderr, "Failed to unbind the image(error code %d)!\n", cudaGetLastError());
        exit(EXIT_FAILURE);
    }
    err=cudaFreeArray(samples_3darray);
    if(err!=cudaSuccess){
        fprintf(stderr, "Failed to free the samples(error code %d)!\n", cudaGetLastError());
        exit(EXIT_FAILURE);
    }

    return 0;

}

#包括
#包括
#包括
#包括
类型定义结构对齐（16）{
无符号短s0、s1、s2、s3、s4、s5、s6、s7；
}ushort8；
纹理d_样本；
__全局无效测试（）{
__共享8个样本[4]；
样本[threadIdx.x]=tex2DLayered（d_样本，threadIdx.x，threadIdx.y，threadIdx.z）；
printf（“thread=%d，value=%hu\n”，threadIdx.x，samples[threadIdx.x].s0）；
printf（“thread=%d，value=%hu\n”，threadIdx.x，samples[threadIdx.x].s1）；
printf（“thread=%d，value=%hu\n”，threadIdx.x，samples[threadIdx.x].s2）；
printf（“thread=%d，value=%hu\n”，threadIdx.x，samples[threadIdx.x].s3）；
printf（“thread=%d，value=%hu\n”，threadIdx.x，samples[threadIdx.x].s4）；
printf（“thread=%d，value=%hu\n”，threadIdx.x，samples[threadIdx.x].s5）；
printf（“thread=%d，value=%hu\n”，threadIdx.x，samples[threadIdx.x].s6）；
printf（“thread=%d，value=%hu\n”，threadIdx.x，samples[threadIdx.x].s7）；
}
int main（int argc，char*argv[]）{
dim3螺纹锁固胶（4,1,1）；
dim3（1,1,1）；
cudaError\u t err=cudaSuccess；
cudaChannelFormatDesc channelDesc_samples=cudaCreateChannelDesc（32,32,32,32，cudaChannelFormatKindUnsigned）；
cudaArray*样本3du数组；
ushort8个样本[4]；
样本[0]，s0=0；
样本[0].s1=1；
样本[0].s2=2；
样本[0]，s3=3；
样本[0]，s4=4；
样品[0]，s5=5；
样本[0]，s6=6；
样本[0]，s7=7；
样品[1]，s0=8；
样本[1]，s1=9；
样本[1]，s2=10；
样本[1]，s3=11；
样品[1]，s4=12；
样品[1]，s5=13；
样本[1]，s6=14；
样品[1]，s7=15；
样品[2]，s0=16；
样本[2]，s1=17；
样本[2]，s2=18；
样本[2]，s3=19；
样品[2]，s4=20；
样品[2]，s5=21；
样本[2]，s6=22；
样品[2]，s7=23；
样品[3]，s0=24；
样本[3]，s1=25；
样本[3]，s2=26；
样本[3]，s3=27；
样本[3]，s4=28；
样品[3]，s5=29；
样品[3].s6=30；
样本[3]，s7=31；
err=cudaMalloc3DArray（&samples\u 3darray，&channelDesc\u samples，make\u cudaExtent（4,1,1），cudaArrayLayered）；
if（err！=cudaSuccess）{
fprintf（stderr，“未能为样本分配纹理内存（错误代码%d）！\n”，cudaGetLastError（））；
退出（退出失败）；
}
cudaMemcpy3DParms myparms_samples={0}；
myparms_samples.srcPos=make_cudaPos（0,0,0）；
myparms_samples.dstPos=make_cudaPos（0,0,0）；
myparms_samples.srcPtr=make_cudaPitchedPtr（样本，4*sizeof（ushort8），4,1）；
myparms_samples.dstArray=samples_3darray；
myparms_samples.extent=make_cudaExtent（4,1,1）；
myparms_samples.kind=cudamemcpyhostodice；
d_samples.addressMode[0]=cudaAddressModeBorder；
d_samples.addressMode[1]=cudaAddressModeBorder；
d_samples.addressMode[2]=cudaAddressModeBorder；
d_samples.filterMode=cudaFilterModePoint；
d_samples.normalized=false；//使用规范化纹理坐标访问
err=cudaMemcpy3D（&myparms_样本）；
if（err！=cudaSuccess）{
fprintf（stderr，“无法将图像样本从主机复制到设备（错误代码%d）！\n”，cudaGetLastError（））；
退出（退出失败）；
}
err=cudaBindTextureToArray（d_样本、样本\u 3darray、通道描述样本）；
if（err！=cudaSuccess）{
fprintf（stderr，“绑定纹理内存失败（错误代码%d）！\n”，cudaGetLastError（））；
退出（退出失败）；
}
teste（）；
if（err！=cudaSuccess）{
fprintf（stderr，“无法启动内核以计算本地和（错误代码%d）！\n”，cudaGetLastError（））；
退出（退出失败）；
}
err=cudaUnbindTexture（d_样本）；
if（err！=cudaSuccess）{
fprintf（stderr，“无法解除映像绑定（错误代码%d）！\n”，cudaGetLastError（））；
退出（退出失败）；
}
err=cudaFreeArray（样本数组）；
if（err！=cudaSuccess）{
fprintf（stderr，“未能释放样本（错误代码%d）！\n”，cudaGetLastError（））；
退出（退出失败）；
}
返回0；
}

---

有人能帮我吗？谢谢大家!

我想我找到了解决办法。我使用了一个重新解释的演员阵容，它正在发挥作用

texture<uint4, cudaTextureType2DLayered> d_samples;

__global__ void teste(){
    __shared__ ushort8 samples[4];

    reinterpret_cast<uint4*>(samples)[threadIdx.x]=tex2DLayered(d_samples,threadIdx.x,threadIdx.y,threadIdx.z);
    printf("thread=%d, value=%hu\n",threadIdx.x, samples[threadIdx.x].s0 );
    printf("thread=%d, value=%hu\n",threadIdx.x, samples[threadIdx.x].s1);
    printf("thread=%d, value=%hu\n",threadIdx.x, samples[threadIdx.x].s2 );
    printf("thread=%d, value=%hu\n",threadIdx.x, samples[threadIdx.x].s3 );
    printf("thread=%d, value=%hu\n",threadIdx.x, samples[threadIdx.x].s4 );
    printf("thread=%d, value=%hu\n",threadIdx.x, samples[threadIdx.x].s5 );
    printf("thread=%d, value=%hu\n",threadIdx.x, samples[threadIdx.x].s6 );
    printf("thread=%d, value=%hu\n",threadIdx.x, samples[threadIdx.x].s7 );

}

纹理d_样本；
__全局无效测试（）{
__共享8个样本[4]；
重新解释（示例）[threadIdx.x]=tex2DLayered（d_示例，threadIdx.x，threadIdx.y，threadIdx.z）；
printf（“thread=%d，value=%hu\n”，threadIdx.x，samples[threadIdx.x].s0）；
printf（“thread=%d，value=%hu\n”，threadIdx.x，samples[threadIdx.x].s1）；
printf（“thread=%d，value=%hu\n”，threadIdx.x，samples[threadIdx.x].s2）；
printf（“thread=%d，value=%hu\n”，threadIdx.x，samples[threadIdx.x].s3）；
printf（“thread=%d，value=%hu\n”，threadIdx.x，samples[threadIdx.x].s4）；
printf（“thread=%d，value=%hu\n”，threadIdx.x，samples[threadIdx.x].s5）；
printf（“thread=%d，value=%hu\n”，threadIdx.x，samples[threadIdx.x].s6）；
printf（“thread=%d，value=%hu\n”，threadIdx.x，samples[threadIdx.x].s7）；
}

我认为纹理不支持8元组。一般来说，基本类型以及2元组和4元组是受支持的。您可以在CUDA编程指南中的纹理部分找到这种效果的说明