Question

这段代码适用于Cuda 4.2

extern "C" texture<int,1,cudaReadModeElementType> __tex0;
extern "C" __global__ void kernel(){
  float4 f = tex1Dfetch(*(texture<float4,1,cudaReadModeElementType>*)&__tex0,ii_z)
}

由于Cuda已经改变了语法，我无法从纹理中获取不同类型的纹理，任何想法？

PS 即可。我在参考文献中发现了Cuda 纹理对象，但这是改变所有出现的很多工作。是否有一个更好的解决方案，代码更改？

感谢

如果有人想要原始代码，请点击here。

Answer 1

这似乎是最小的责任案例：

texture<int,1,cudaReadModeElementType> __tex0;

__global__ void kernel0(float4 *out)
{
    int t__a = blockIdx.x*blockDim.x+threadIdx.x;
    int ii = (t__a*3);
    float4 rr = tex1Dfetch(*(texture<float4,1,cudaReadModeElementType>*)&__tex0,ii);
    out[t__a] = rr;
}

CUDA 7.5将无法编译此内核并出现错误：

texture_repo.cu（7）：错误：无法获取纹理/表面的地址 "__tex0"函数中的变量__device__/__global__

我相信这是正确的。纹理引用是不透明的占位符类型，它不具有POD类型的任何常见属性，我会非常怀疑编写代码，例如您提供链接的示例。

但是，CUDA 4.2确实会编译并发出有效的PTX：

.entry _Z7kernel0P6float4(
        .param .u64 _Z7kernel0P6float4_param_0
)
{
        .reg .f32       %f<25>;
        .reg .s32       %r<8>;
        .reg .s64       %rl<5>;


        ld.param.u64    %rl1, [_Z7kernel0P6float4_param_0];
        cvta.to.global.u64      %rl2, %rl1;
        .loc 2 5 1
        mov.u32         %r2, %ntid.x;
        mov.u32         %r3, %ctaid.x;
        mov.u32         %r4, %tid.x;
        mad.lo.s32      %r5, %r2, %r3, %r4;
        .loc 2 6 1
        mul.lo.s32      %r1, %r5, 3;
        mov.u32         %r6, 0;
        // inline asm
        tex.1d.v4.f32.s32 {%f1, %f2, %f3, %f4}, [__tex0, {%r1}];
        // inline asm
        .loc 2 8 1
        mul.wide.s32    %rl3, %r5, 16;
        add.s64         %rl4, %rl2, %rl3;
        st.global.v4.f32        [%rl4], {%f1, %f2, %f3, %f4};
        .loc 2 9 2
        ret;
}

除了抑制编译器错误之外，转换显然没有任何效果，并且在PTX级别读取有效，因为纹理引用读取始终返回四宽矢量类型，即使额外的矢量元素为空并被忽略。我认为这在CUDA 4.2中编译为编译器错误，在这种情况下看起来CUDA 7.5是正确的。

那就是说，一个非常黑客的解决办法就是这样做：

texture<int,1,cudaReadModeElementType> __tex0;

__device__ float4 tex_load0(int idx)
{
    float4 temp;
    asm("tex.1d.v4.f32.s32 {%0, %1, %2, %3}, [__tex0, {%4}];" :
        "=f"(temp.x), "=f"(temp.y), "=f"(temp.z), "=f"(temp.w) : "r"(idx));
    return temp;
}

__global__ void kernel1(float4 *out)
{
    int t__a = blockIdx.x*blockDim.x+threadIdx.x;
    int ii = (t__a*3);
    float4 rr = tex_load0(ii); 
    out[t__a] = rr;
}

[免责声明：已编译但未经测试。不建议。使用风险自负]。

即。将CUDA 4.2编译器内联发出的相同PTX插入到设备函数中，并使用对设备函数的调用替换纹理提取。使用CUDA 7.5工具链，可以发出：

//
// Generated by NVIDIA NVVM Compiler
//
// Compiler Build ID: CL-19856038
// Cuda compilation tools, release 7.5, V7.5.17
// Based on LLVM 3.4svn
//

.version 4.3
.target sm_30
.address_size 64

    // .globl   _Z9tex_load0i
.global .texref __tex0;

.visible .func  (.param .align 16 .b8 func_retval0[16]) _Z9tex_load0i(
    .param .b32 _Z9tex_load0i_param_0
)
{
    .reg .f32   %f<5>;
    .reg .b32   %r<2>;


    ld.param.u32    %r1, [_Z9tex_load0i_param_0];
    // inline asm
    tex.1d.v4.f32.s32 {%f1, %f2, %f3, %f4}, [__tex0, {%r1}];
    // inline asm
    st.param.f32    [func_retval0+0], %f1;
    st.param.f32    [func_retval0+4], %f2;
    st.param.f32    [func_retval0+8], %f3;
    st.param.f32    [func_retval0+12], %f4;
    ret;
}

    // .globl   _Z7kernel1P6float4
.visible .entry _Z7kernel1P6float4(
    .param .u64 _Z7kernel1P6float4_param_0
)
{
    .reg .f32   %f<5>;
    .reg .b32   %r<6>;
    .reg .b64   %rd<5>;


    ld.param.u64    %rd1, [_Z7kernel1P6float4_param_0];
    cvta.to.global.u64  %rd2, %rd1;
    mov.u32     %r2, %ctaid.x;
    mov.u32     %r3, %ntid.x;
    mov.u32     %r4, %tid.x;
    mad.lo.s32  %r5, %r3, %r2, %r4;
    mul.lo.s32  %r1, %r5, 3;
    mul.wide.s32    %rd3, %r5, 16;
    add.s64     %rd4, %rd2, %rd3;
    // inline asm
    tex.1d.v4.f32.s32 {%f1, %f2, %f3, %f4}, [__tex0, {%r1}];
    // inline asm
    st.global.v4.f32    [%rd4], {%f1, %f2, %f3, %f4};
    ret;
}

与发出的CUDA 4.2工具链相同的PTX。这是有效的，因为编译器无法对内联PTX应用几乎相同级别的类型安全检查。但是要仔细思考你是否真的想要这样做，因为它（在我看来）是未定义的行为。

另请注意，由于在PTX中处理纹理引用的方式，您不能将它们作为显式参数传递，因此您需要在代码中为每个纹理定义一个读取函数。

如何将不同种类的纹理绑定到CUDA中的纹理引用？

1 个答案: