Cuda 使用纹理内存计算后保存值

嗨，我有一个简单的计算使用纹理记忆。但我无法保存正确的结果。 结果应该是插值。例如，角度=0.5 A[0]=1，B[0]=2，结果[0]应为1.5

我想我没有正确保存数据。我想使用纹理内存进行快速计算，并将结果保存在全局数组中。有件事我做错了。有人知道什么吗

这是我在内核中的代码

#ifndef _SIMPLETEXTURE_KERNEL_H_
#define _SIMPLETEXTURE_KERNEL_H_

texture<float, 1> tex1;
texture<float, 1> tex2;

__global__ void
transformKernel( float* g_odata, float f) 
{
    // calculate normalized texture coordinates
    unsigned int x = blockIdx.x*blockDim.x + threadIdx.x;
    int idx = threadIdx.x;

    float valA = tex1D(tex1,x);
    float valB = tex1D(tex2,x);

    // read from texture and write to global memory
    g_odata[x] = (f)*valA + (1-f)*valB;
}
#endif

\ifndef\u SIMPLETEXTURE\u KERNEL\u H_
#定义SIMPLETEXTURE_KERNEL_H_
纹理tex1；
纹理tex2；
__全局无效
transformKernel（float*g_odata，float f）
{
//计算归一化纹理坐标
无符号整数x=blockIdx.x*blockDim.x+threadIdx.x；
int idx=threadIdx.x；
浮动幅度=tex1D（tex1，x）；
float valB=tex1D（tex2，x）；
//从纹理读取并写入全局内存
g_odata[x]=（f）*valA+（1-f）*valB；
}
#恩迪夫

这是我调用的代码

#include <stdio.h>
#include <iostream>
#include "cuda.h"
#include <stdlib.h>
#include "cuda_runtime.h"
#include "device_launch_parameters.h"
#include "HelloWorld.h"

#include "linearInterpolation_kernel.cu"

using namespace std;
using std::cout;

const int blocksize = 16; 
int main()
{
    int N = 1000; 
    float *A; 
    A = (float *) malloc(N*sizeof(float));
    float *B;
    B = (float *) malloc(N*sizeof(float));
    float *result;
    result = (float *) malloc(N*sizeof(float));
    float angle = 0.5f; 

    for(int i = 0; i < N; i++){
        A[i] = (float)rand();
        B[i] = (float)rand();
    }
    cout << A[3] << endl;
    cout << B[3] << endl;

    ipLinearTexture(A,B,result,angle,N);

    float result2;

    result2 = (angle)*A[3] + (1-angle)*B[3]; 

    printf(" A %f B %f Result %f\n", A[3], B[3], result[3]);
    cout << result2 << endl;

    return 1;
}
void ipLinearTexture(float *A, float* B, float* result, float angle, int N)
{
    float cuTime;

    const cudaChannelFormatDesc channel_desc = cudaCreateChannelDesc<float>(); 
    cudaArray* cuda_A;
    cudaArray* cuda_B;
    float *dev_result;

    cudaMallocArray(&cuda_A, &channel_desc, 1, N * sizeof(float));
    cudaMallocArray(&cuda_B, &channel_desc, 1, N * sizeof(float));
    cudaMalloc(&dev_result, N * sizeof(float));

    cudaMemcpyToArray(cuda_A,0,0,A,N * sizeof(float),cudaMemcpyHostToDevice);
    cudaMemcpyToArray(cuda_B,0,0,B,N * sizeof(float),cudaMemcpyHostToDevice);

    tex1.filterMode = cudaFilterModePoint;
    tex1.addressMode[0] = cudaAddressModeWrap;

    tex2.filterMode = cudaFilterModePoint;
    tex2.addressMode[0] = cudaAddressModeWrap;


    cudaBindTextureToArray(tex1, cuda_A, channel_desc);
    cudaBindTextureToArray(tex2, cuda_B, channel_desc);

    cudaEvent_t start, stop;
    cudaEventCreate(&start);
    cudaEventRecord(start,0);

    transformKernel<<< 16, 16, 0 >>>(dev_result,angle);

    cudaEventCreate(&stop);
    cudaEventRecord(stop,0);
    cudaEventSynchronize(stop);
    cudaEventElapsedTime(&cuTime, start,stop);

    cudaMemcpy(result, dev_result, N * sizeof(float), cudaMemcpyKind::cudaMemcpyDeviceToHost);
    result[0] = (float)cuTime;

    cudaFreeArray(cuda_A);
    cudaFreeArray(cuda_B);
    cudaFree(dev_result);

}

#包括
#包括
#包括“cuda.h”
#包括
#包括“cuda_runtime.h”
#包括“设备启动参数.h”
#包括“HelloWorld.h”
#包括“linearInterpolation_kernel.cu”
使用名称空间std；
使用std：：cout；
const int blocksize=16；
int main（）
{
int N=1000；
浮动*A；
A=（浮动*）malloc（N*sizeof（浮动））；
浮动*B；
B=（浮动*）malloc（N*sizeof（浮动））；
浮动*结果；
结果=（float*）malloc（N*sizeof（float））；
浮动角度=0.5f；
对于（int i=0；icout从编程指南和文档中的示例来看，cudaMallocArray函数的声明似乎是：

cudaError_t cudaMallocArray(struct cudaArray **array, 
                const struct cudaChannelFormatDesc *desc, 
                size_t width, 
                size_t height = 0, 
                unsigned int flags = 0)

在您发布的代码中，以字节传递大小。仅尝试
N
，删除
sizeof（float）

至少上次我使用纹理进行线性插值时，当我分配
cudaArray
时，我没有以字节为单位指定大小，它可以工作。
请注意，当您调用
cudaMemcpyToArray
时，大小应以字节为单位。
您可以编辑您的问题来解释“错误结果”和“正确结果”是/应该是什么吗？我没有看到您用来验证结果是否正确的代码。我发现您覆盖结果[0]很奇怪测量时间：
result[0]=（float）cuTime；
。老实说，对于这种线性寻址模式，使用纹理不会带来性能优势，而且代码比仅使用常规设备指针更复杂。