为什么使用袖口导致致命错误LNK1120在MEX cuda?

9次浏览(过去30天)

显示旧的注释

Moein Mozaffarzadeh 2021年7月6日

评论道: Moein Mozaffarzadeh2021年7月9日

答:接受 Linda Koletsou Soulti

你好,

我试图写一个MEX网关(在cuda)函数，以添加GPU中的两个数组。我想过滤信号之一(MediumX在下面的代码)在我做加法在GPU。然而，当我使用“cufftPlan1d”来生成fft计划时，我在Matlab编译时得到错误。错误是:

使用mex出错

创建库test2_GPUArray。lib和对象test2_GPUArray.exp

test2_GPUArray。在函数mexFunction中引用的未解析的外部符号cufftPlan1d

test2_GPUArray。墨西哥人w64 : fatal error LNK1120: 1 unresolved externals

美可达中的错误(第168行)

[varargout{1:nargout}] = mex(mexArguments{:});

test2_GPUArray_matlabRunner错误(第3行)

mexcuda (' - v”、“test2_GPUArray。cu'， 'NVCCFLAGS=-gencode=arch=compute_50,code=sm_50 -Xptxas -dlcm=cg ');

以下是我的MEX网关代码:

                         ＃包括< cuda_runtime.h >
                        
                         ＃包括“device_launch_parameters.h”
                        
                         ＃包括< stdio . h >
                        
                         ＃包括“cuda.h”
                        
                         ＃包括< iostream >
                        
                         ＃包括< mex.h >
                        
                         ＃包括“gpu / mxGPUArray.h”
                        
                         ＃包括< cuComplex.h >
                        
                         ＃包括< cublas_v2.h >
                        
                         ＃包括<推力/ complex.h >
                        
                         ＃包括< cufft.h >
                        
                         //＃定义NRANK1 //信号为1维(NX空间点)。
                        
                         //typedef thrust::complex fcomp;
                        
                         //＃定义NX256
                        
                         //＃定义/*BATCH 10*/
                        
                         ＃定义gpuErrchk(ans) {gpuAssert((ans)，__FILE__,__LINE__);｝
                        
                         内联void gpuAssert(cudaError_t code, const char* file, int line, bool abort = true)
                        
                         ｛
                        
                         如果(code != cudassuccess)
                        
                         ｛
                        
                         流(stderr,GPUassert: %s %s %d\n， cudaGetErrorString(代码)，文件，行);
                        
                         如果(中止)退出(代码);
                        
                         ｝
                        
                         ｝
                        
                         __global__无效add(int* Device_Data_Added,int* Device_Data, int* Device_MediumX, cudaTextureObject_t tex, int N) {
                        
                         intTID = threadIdx。y * blockDim。x + threadaddx .x；
                        
                         intBlockOFFset = blockDim。x * blockDim。y * blockIdx.x；
                        
                         intRowOFFset = blockDim。x * blockDim。y * gridDim。x * blockIdx.y；
                        
                         intGID_RowBased = BlockOFFset + TID；
                        
                         如果(GID_RowBased < N) {
                        
                         Device_Data_Added[GID_RowBased] = Device_Data[GID_RowBased] + Device_MediumX[GID_RowBased];
                        
                         ///Device_Data_Added[GID_RowBased] = tex1Dfetch(tex, GID_RowBased + 1.0f) + Device_MediumX[GID_RowBased];
                        
                         ｝
                        
                         ｝
                        
                         无效mexFunction(int nlhs, mxArray* plhs[]，
                        
                         intnrhs,常量mxArray* prhs[]) {
                        
                         intN = 1024；
                        
                         intBatch = 1；
                        
                         intArrayByteSize = sizeof(int) * N；
                        
                         int *数据;
                        
                         int * Data_New;
                        
                         int * MediumX;
                        
                         int * Device_MediumX;
                        
                         //mxGPUArray const* MediumX = mxGPUCreateFromMxArray(prhs[0]);//可以是CPU或GPU,将复制到GPU，如果它还没有
                        
                         //int* Device_MediumX = static_cast((int*)mxGPUGetDataReadOnly(MediumX));//获取指针本身(假设为浮点数据)
                        
                         MediumX = (int*)mxGetPr(prhs[0]);
                        
                         / /过滤
                        
                         // fcomp* MediumX_Complex =new fcomp[N];
                        
                         //为(int I = 0;i < N;我+ +){
                        
                         //reinterpret_cast (MediumX_Complex)[2*i]= static_cast  (MediumX[i]);
                        
                         //reinterpret_cast (MediumX_Complex)[2 * i+1] = static_cast  (0);
                        
                         / /}
                        
                         cufftHandle计划；
                        
                         cufftReal * MediumXF;
                        
                         cudaMalloc((void**)&MediumXF, sizeof(cufftReal) * N * BATCH);
                        
                         cufftPlan1d(&plan, N, CUFFT_R2C, BATCH);
                        
                         //
                        
                         (cudaMalloc((void**)&Device_MediumX, sizeof(int) * N));
                        
                         (cudaMemcpy(Device_MediumX, MediumX, sizeof(int) * N, cudaMemcpyHostToDevice));
                        
                         Data = (int*)mxGetPr(prhs[1]);
                        
                         int * Device_Data;//设备指针到介质的X坐标
                        
                         gpuErrchk (cudaMalloc ((void * *) &Device_Data ArrayByteSize));
                        
                         gpuErrchk(cudaMemcpy(Device_Data, Data, ArrayByteSize, cudaMemcpyHostToDevice));
                        
                         plhs[0] = mxCreateNumericMatrix(N, 1, mxINT32_CLASS, mxREAL);
                        
                         Data_New = (int*)mxGetData(plhs[0]);
                        
                         int * Device_Data_Added;//设备指针到介质的X坐标
                        
                         gpuErrchk (cudaMalloc ((void * *) &Device_Data_Added ArrayByteSize));
                        
                         cudaResourceDescresDesc；
                        
                         memset(&resDesc, 0, sizeof(resDesc));
                        
                         resDesc。resType = cudaresourcetyplinear;
                        
                         resDesc.res.linear.devPtr = Device_Data;
                        
                         resDesc.res.linear.desc.f = cudaChannelFormatKindSigned;
                        
                         resDesc.res.linear.desc.x = 32;// bits /通道
                        
                         resDesc.res.linear.sizeInBytes = ArrayByteSize;
                        
                         cudaTextureDesctexDesc；
                        
                         memset(&texDesc, 0, sizeof(texDesc));
                        
                         texDesc。readMode = cudaReadModeElementType;
                        
                         //创建纹理对象:我们只需要做一次!
                        
                         cudaTextureObject_tTex = 0；
                        
                         cudaCreateTextureObject(&tex， &resDesc， &texDesc, NULL);
                        
                         dim3块(1024)；
                        
                         intGridX = (N / block.x+1)；
                        
                         dim3网格(GridX)/ / SystemSetup。NumberOfTransmitter
                        
                         添加< < <网格、块>> > (Device_Data_Added,Device_Data, Device_MediumX, tex, N)；
                        
                         (cudaMemcpy(Data_New, Device_Data_Added, ArrayByteSize, cudaMemcpyDeviceToHost));
                        
                         cudaFree (Device_Data);
                        
                         cudaFree (Device_Data_Added);
                        
                         cudaFree (Device_MediumX);
                        
                         cudaFree (MediumXF);
                        
                         / / mxGPUDestroyGPUArray (MediumX);
                        
                         cudaDestroyTextureObject(特克斯);
                        
                         / /删除[]MediumX_Complex;
                        
                         ｝