Class 具有多维指针的CUDA类_Class_Cuda

Class 具有多维指针的CUDA类

class cuda

Class 具有多维指针的CUDA类,class,cuda,Class,Cuda,我已经为这个类的实现奋斗了很长一段时间，希望有人能帮助我 class Material_Properties_Class_device { public: int max_variables; Logical * table_prop; Table_Class ** prop_table; }; 指针的实现如下所示 Material_Properties_Class **d_material_prop = new Material_Properties_Class* [4]; Logica

我已经为这个类的实现奋斗了很长一段时间，希望有人能帮助我

class Material_Properties_Class_device 
{

public:
int max_variables;
Logical * table_prop;
Table_Class ** prop_table;
};

指针的实现如下所示

Material_Properties_Class **d_material_prop = new Material_Properties_Class* [4];
Logical *table_prop;

for (int k = 1; k <= 3; k++ )
{ 
cutilSafeCall(cudaMalloc((void**)&(d_material_prop[k]),sizeof(Material_Properties_Class)));  
cutilSafeCall(cudaMemcpy(d_material_prop[k], material_prop[k], sizeof(Material_Properties_Class ), cudaMemcpyHostToDevice)); 
}

for( int i = 1; i <= 3; i++ )
{   
cutilSafeCall(cudaMalloc((void**)&(table_prop), sizeof(Logical)));
cudaMemcpy(&(d_material_prop[i]->table_prop), &(table_prop), sizeof(Logical*),cudaMemcpyHostToDevice);
cudaMemcpy(table_prop, material_prop[i]->table_prop, sizeof(Logical),cudaMemcpyHostToDevice);
}

cutilSafeCall(cudaMalloc((void ***)&material_prop_device, (4) * sizeof(Material_Properties_Class *)));  
cutilSafeCall(cudaMemcpy(material_prop_device, d_material_prop, (4) * sizeof(Material_Properties_Class *), cudaMemcpyHostToDevice));

并在第二个for循环中插入另一个循环

for (int k = 1; k <= 3; k++ )
        { 
            cutilSafeCall(cudaMalloc((void**)&(prop_table[k]), sizeof(Table_Class))); 
            cutilSafeCall(cudaMemcpy( prop_table[k], material_prop[i]->prop_table[k], sizeof( Table_Class *), cudaMemcpyHostToDevice)); 
        }

for（int k=1；k prop_table[k]，sizeof（table_Class*），cudaMemcpyHostToDevice））；
}

帮助将是非常宝贵的

这个问题经常出现。多维指针尤其具有挑战性

如果可能，建议您将多维指针用法（

**

）扁平化为一维指针用法（

），正如您所看到的，即使这样也有些麻烦

进一步描述了一维情况（

）。虽然你似乎已经明白了

如果您真的想处理二维（

***

）案例，请查看

三维案例（

***

）的示例实现如下。（“疯狂！”）

以这种方式处理二维和三维是相当困难的。因此，建议将其展平。

有些神奇。也许会有帮助

struct fading_coefficient
{
    double* frequency_array;
    double* temperature_array;
    int frequency_size;
    int temperature_size;
    double** fading_coefficients;
};

struct fading_coefficient* cuda_fading_coefficient;
    double* frequency_array = NULL;
    double* temperature_array = NULL;
    double** fading_coefficients = NULL;
    double** fading_coefficients1 = (double **)malloc(fading_coefficient->frequency_size * sizeof(double *));   

    cudaMalloc((void**)&frequency_array,fading_coefficient->frequency_size *sizeof(double));
    cudaMemcpy( frequency_array, fading_coefficient->frequency_array, fading_coefficient->frequency_size *sizeof(double), cudaMemcpyHostToDevice );
    free(fading_coefficient->frequency_array);

    cudaMalloc((void**)&temperature_array,fading_coefficient->temperature_size *sizeof(double));
    cudaMemcpy( temperature_array, fading_coefficient->temperature_array, fading_coefficient->temperature_size *sizeof(double), cudaMemcpyHostToDevice );
    free(fading_coefficient->temperature_array);

    cudaMalloc((void***)&fading_coefficients,fading_coefficient->temperature_size *sizeof(double*));

    for (int i = 0; i < fading_coefficient->temperature_size; i++)
    {
        cudaMalloc((void**)&(fading_coefficients1[i]),fading_coefficient->frequency_size *sizeof(double));
        cudaMemcpy( fading_coefficients1[i], fading_coefficient->fading_coefficients[i], fading_coefficient->frequency_size *sizeof(double), cudaMemcpyHostToDevice );
        free(fading_coefficient->fading_coefficients[i]);
    }
    cudaMemcpy(fading_coefficients, fading_coefficients1, fading_coefficient->temperature_size *sizeof(double*), cudaMemcpyHostToDevice );

    fading_coefficient->frequency_array = frequency_array;
    fading_coefficient->temperature_array = temperature_array;
    fading_coefficient->fading_coefficients = fading_coefficients;

    cudaMalloc((void**)&cuda_fading_coefficient,sizeof(struct fading_coefficient));
    cudaMemcpy( cuda_fading_coefficient, fading_coefficient, sizeof(struct fading_coefficient), cudaMemcpyHostToDevice );

结构衰减系数 { 双频阵列；双*温度_阵列； int-frequency_-size；内部温度和尺寸；双**衰落系数； }; 结构衰落系数*cuda衰落系数；双*频率_数组=空；双*温度_数组=NULL；双**衰落系数=零；双**衰落系数1=（双**）malloc（衰落系数->频率大小*大小（双*）； cudamaloc（（void**）和频率阵列，衰落系数->频率大小*大小（双）； cudaMemcpy（频率数组，衰落系数->频率数组，衰落系数->频率大小*大小（双精度），cudaMemcpyHostToDevice）；自由（衰减系数->频率阵列）； cudamaloc（（void**）和温度数组，衰减系数->温度大小*大小（双）； cudaMemcpy（温度数组，衰减系数->温度数组，衰减系数->温度大小*大小（双精度），cudaMemcpyHostToDevice）；自由（衰减系数->温度阵列）； Cudamaloc（（空隙***）和衰减系数，衰减系数->温度大小*尺寸（双*）；对于（int i=0；i<衰减系数->温度大小；i++） { cudamaloc（（void**）和（衰落系数1[i]），衰落系数->频率大小*大小（double））； cudaMemcpy（衰落系数1[i]，衰落系数->衰落系数[i]，衰落系数->频率大小*大小（双精度），cudaMemcpyHostToDevice）；自由（衰减系数->衰减系数[i]）； } cudaMemcpy（衰减系数，衰减系数1，衰减系数->温度大小*大小（双*），cudaMemcpyHostToDevice）；衰落系数->频率阵列=频率阵列；衰减系数->温度阵列=温度阵列；衰落系数->衰落系数=衰落系数； cudamaloc（（void**）和cuda_衰减系数，sizeof（结构衰减系数）； cudaMemcpy（cuda_衰落系数、衰落系数、sizeof（结构衰落系数）、cudaMemcpyHostToDevice）；

为此干杯，我知道这是一种痛苦，但我不能把它抹平，因为我必须将我的代码集成到一个现有的串行代码中，该代码使用了大量这些结构用于各种访问目的。如果我弄明白了，我会为我的简单类发布结果。谢谢这看起来很完美，会给它一个好的结果。我用一个包含一些数据的对象实现了你的示例，但是我没有让它工作，衰减系数没有包含任何数据；我还是不明白。例如，为什么您要再次释放数据，并从底部的3行中再次将其复制回来？？？？提前感谢免费RAM记忆（衰减系数->衰减系数[i]）；在衰落系数->衰落系数=衰落系数；我正在使用淡入淡出系数->淡入淡出系数指针指向视频内存。干杯，我让它工作了，我现在必须更改它以支持结构对象数组。再次感谢您让我花费了很多时间和精力，现在我将T_T的示例扩展到包含**数组的多维结构数组。

struct fading_coefficient
{
    double* frequency_array;
    double* temperature_array;
    int frequency_size;
    int temperature_size;
    double** fading_coefficients;
};

struct fading_coefficient* cuda_fading_coefficient;
    double* frequency_array = NULL;
    double* temperature_array = NULL;
    double** fading_coefficients = NULL;
    double** fading_coefficients1 = (double **)malloc(fading_coefficient->frequency_size * sizeof(double *));   

    cudaMalloc((void**)&frequency_array,fading_coefficient->frequency_size *sizeof(double));
    cudaMemcpy( frequency_array, fading_coefficient->frequency_array, fading_coefficient->frequency_size *sizeof(double), cudaMemcpyHostToDevice );
    free(fading_coefficient->frequency_array);

    cudaMalloc((void**)&temperature_array,fading_coefficient->temperature_size *sizeof(double));
    cudaMemcpy( temperature_array, fading_coefficient->temperature_array, fading_coefficient->temperature_size *sizeof(double), cudaMemcpyHostToDevice );
    free(fading_coefficient->temperature_array);

    cudaMalloc((void***)&fading_coefficients,fading_coefficient->temperature_size *sizeof(double*));

    for (int i = 0; i < fading_coefficient->temperature_size; i++)
    {
        cudaMalloc((void**)&(fading_coefficients1[i]),fading_coefficient->frequency_size *sizeof(double));
        cudaMemcpy( fading_coefficients1[i], fading_coefficient->fading_coefficients[i], fading_coefficient->frequency_size *sizeof(double), cudaMemcpyHostToDevice );
        free(fading_coefficient->fading_coefficients[i]);
    }
    cudaMemcpy(fading_coefficients, fading_coefficients1, fading_coefficient->temperature_size *sizeof(double*), cudaMemcpyHostToDevice );

    fading_coefficient->frequency_array = frequency_array;
    fading_coefficient->temperature_array = temperature_array;
    fading_coefficient->fading_coefficients = fading_coefficients;

    cudaMalloc((void**)&cuda_fading_coefficient,sizeof(struct fading_coefficient));
    cudaMemcpy( cuda_fading_coefficient, fading_coefficient, sizeof(struct fading_coefficient), cudaMemcpyHostToDevice );