C++ CUDA强调如何使用矢量将对象传输到设备

我正在学习Cuda推力，我想将对象从主机向量传输到设备阵列，以便在内核中使用它

代码如下：

#include <stdio.h>
#include <thrust/host_vector.h>
#include <thrust/device_vector.h>
#include <thrust/copy.h>
#include <cstdlib>

#ifndef SIMULATION_H_
#define SIMULATION_H_

class Simulation {
    public:
    int num_layers;
    float dz;
    float dr;
    int ndz;
    int ndr;
    int events_left;

    __host__ __device__ Simulation();
    __host__ __device__ Simulation(int events_left, int num_layers, float dz, float dr, int ndz, int ndr);
    __device__ int getNumLayers();
    __device__ float getDZ();
    __device__ float getDR();
    __device__ int getNDZ();
    __device__ int getNDR();
    __device__ int getEventsLeft();

    __device__ void setNumLayers(int num_layers);
    __device__ void setDZ(float dz);
    __device__ void setDR(float dr);
    __device__ void setNDZ(int ndz);
    __device__ void setNDR(int ndr);
    __device__ void setEventsLeft(int events_left);    
};

#endif /* SIMULATION_H_ */

__host__ __device__ Simulation::Simulation(){}
__host__ __device__ Simulation::Simulation(int events_left, int num_layers, float dz, float dr, int ndz, int ndr) {
    this->events_left = events_left;
    this->num_layers = num_layers;
    this->dz = dz;
    this->dr = dr;
    this->ndz = ndz;
    this->ndr = ndr;
}
__device__ int Simulation::getNumLayers() { return this->num_layers;}
__device__ float Simulation::getDZ() { return this->dz;}
__device__ float Simulation::getDR() { return this->dr;}
__device__ int Simulation::getNDZ() { return this->ndz;}
__device__ int Simulation::getNDR() { return this->ndr;}
__device__ int Simulation::getEventsLeft() { return this->events_left;}

__device__ void Simulation::setNumLayers(int num_layers) {this->num_layers = num_layers;}
__device__ void Simulation::setDZ(float dz) {this->dz = dz;}
__device__ void Simulation::setDR(float dr) {this->dr = dr;}
__device__ void Simulation::setNDZ(int ndz) {this->ndz = ndz;}
__device__ void Simulation::setNDR(int ndr) {this->ndr = ndr;}
__device__ void Simulation::setEventsLeft(int events_left) {this->events_left = events_left;}

__global__ void Foo(Simulation* sim){
    int i = threadIdx.x + blockIdx.x * blockDim.x;

    printf("TH <%d>, num_layers <%d>\n", i, sim[0].num_layers);
    printf("TH <%d>, dz         <%f>\n", i, sim[0].dz);
    printf("TH <%d>, dr         <%f>\n", i, sim[0].dr);
    printf("TH <%d>, ndr        <%d>\n", i, sim[0].ndr);
    printf("TH <%d>, ndz        <%d>\n", i, sim[0].ndz);
}

int main(void) {

    // Number of simulations
    int num_simulations = 1;

    // Simulations host vector
    thrust::host_vector<Simulation> hv_simulations(num_simulations);

    // Parameters for simulation one
    float dz = 0.01;
    float dr = 0.01;
    int ndz = 40;
    int ndr = 50;
    int events_left = 1000;
    int num_layers = 3;

    // Create a simulation
    Simulation sim1(events_left, num_layers, dz, dr, ndz, ndr);

    // Add simulation one to simulations vector
    hv_simulations.push_back(sim1);

    // Transfer simulations to device
    thrust::device_vector<Simulation> dv_simulations = hv_simulations;

    // Get raw pointer to device simulations
    Simulation* d_simulations = thrust::raw_pointer_cast(dv_simulations.data());

    // Call Foo kernel
    Foo<<<1, 2>>>(d_simulations);

    return 0;
}

#包括
#包括
#包括
#包括
#包括
#ifndef模拟_
#定义模拟_
课堂模拟{
公众：
int num_层；
浮动dz；
浮动dr；
int ndz；
国际发改委；
int events_左；
__主机设备模拟（）；
__主机设备模拟（int-events\u left，int-num\u layers，float dz，float dr，int-ndz，int-ndr）；
__设备_uuint getNumLayers（）；
__设备_uuu浮动getDZ（）；
__设备\uuuuuu浮点getDR（）；
__设备_u; int getNDZ（）；
__设备_uuint getNDR（）；
__device_uu int getEventsLeft（）；
__设备无效设置层（整数层）；
__装置uuuu无效设置dz（浮动dz）；
__设备无效setDR（浮动dr）；
__设备无效设置ndz（int ndz）；
__设备无效设置ndr（int ndr）；
__设备\uuuuuvoid setEventsLeft（int-events\u左）；
};
#endif/*模拟*/
__主机设备模拟：：模拟（）{}
__主机设备模拟：：模拟（int-events\u left，int-num\u layers，float-dz，float-dr，int-ndz，int-ndr）{
此->事件左=事件左；
此->num\u layers=num\u layers；
这->dz=dz；
这->dr=dr；
这->ndz=ndz；
本->ndr=ndr；
}
__device_uuu_uuint Simulation:：getNumLayers（）{return this->num_ulayers；}
__device_uuu浮点模拟：：getDZ（）{返回此->dz；}
__设备\浮点模拟：：getDR（）{返回此->dr；}
__设备模拟：：getNDZ（）{返回此->ndz；}
__设备模拟：：getNDR（）{返回此->ndr；}
__设备模拟：：getEventsLeft（）{返回此->事件左；}
__设备\uuuuvoid模拟：：setNumLayers（int num\u layers）{this->num\u layers=num\u layers；}
__设备模拟：：setDZ（float dz）{this->dz=dz；}
__设备\无效模拟：：setDR（浮点dr）{this->dr=dr；}
__设备模拟：：setNDZ（intndz）{this->ndz=ndz；}
__设备模拟：：setNDR（int-ndr）{this->ndr=ndr；}
__设备\uuuuvoid模拟：：setEventsLeft（int events\u left）{this->events\u left=events\u left；}
__全局无效Foo（模拟*sim）{
int i=threadIdx.x+blockIdx.x*blockDim.x；
printf（“TH，num\u layers\n”，i，sim[0].num\u layers）；
printf（“TH，dz\n”，i，sim[0].dz）；
printf（“TH，dr\n”，i，sim[0].dr）；
printf（“TH，ndr\n”，i，sim[0].ndr）；
printf（“TH，ndz\n”，i，sim[0].ndz）；
}
内部主（空）{
//模拟次数
int num_=1；
//模拟宿主向量
推力：主机矢量hv\U模拟（num\U模拟）；
//模拟一的参数
浮子dz=0.01；
浮动dr=0.01；
int ndz=40；
int ndr=50；
int events_left=1000；
int num_layers=3；
//创建一个模拟
模拟sim1（事件左、层数、dz、dr、ndz、ndr）；
//将仿真一添加到仿真向量
高压模拟。推回（sim1）；
//将模拟传输到设备
推力：：设备矢量dv\U仿真=高压仿真；
//获取设备模拟的原始指针
模拟*d_模拟=推力：：原始指针（dv_模拟.data（））；
//调用Foo内核
Foo（d_模拟）；
返回0；
}

我希望获得作为参数传递的值，而控制台抛出以下命令：

TH <0>, num_layers <1428486120>
TH <1>, num_layers <1428486120>
TH <0>, dz         <0.000000>
TH <1>, dz         <0.000000>
TH <0>, dr         <0.000000>
TH <1>, dr         <0.000000>
TH <0>, ndr        <0>
TH <1>, ndr        <0>
TH <0>, ndz        <0>
TH <1>, ndz        <0>

TH，num\u层
TH，num_层
TH，dz
TH，dz
TH，dr
TH，dr
国家发改委
国家发改委
TH，ndz
TH，ndz

---

为什么?？谢谢。

我想你有一个基本的

向量操作错误，与CUDA或推力无关

这将创建一个长度
num\u模拟的向量
：

thrust::host_vector<Simulation> hv_simulations(num_simulations);

您可以通过创建空向量来解决此问题：

thrust::host_vector<Simulation> hv_simulations;

哦，那真是一个基本的错误！谢谢你，罗伯特。
thrust::host_vector<Simulation> hv_simulations;

hv_simulations[0] = sim1;