CUDA数据初始化

就有关CUDA的教程而言，大多数数据都是通过内核调用发送到设备的。我不知道我是否还能表演 初始化数据——进程——清除cuda中的某种操作。这是我的代码，我试过了，但似乎不起作用

#include <cuda.h>
#include <stdio.h>
#include <cuda_runtime.h>

#define CUDA_CHECK_VALUE(value, a) {                            \
    cudaError_t _m_cudaStatus = value;                          \
    if(_m_cudaStatus != cudaSuccess) {                          \
        printf("Error &s at line %d in file %s\n",              \
                cudaGetErrorString(_m_cudaStatus),              \
                __LINE__, __FILE__);                            \
        exit(1);                                                \
    } else {printf("Done! - %d\n", a);} }

__constant__
float* data;

__host__ __device__
void initMemory(int size){
    CUDA_CHECK_VALUE(cudaMalloc(&data, sizeof(float) * size), 0);
    float *ha = new float[size];
    for(int i =0; i < size; i++){
        ha[i] = i * 1.0f;
    }
    CUDA_CHECK_VALUE(cudaMemcpyToSymbol(data, ha, sizeof(float) * size, 0, cudaMemcpyHostToDevice), 1);
    CUDA_CHECK_VALUE(cudaDeviceSynchronize(), 2);
}

__host__ __device__
void freeMemory(){
    CUDA_CHECK_VALUE(cudaDeviceSynchronize(), 3);
    cudaFree(data);
}

__global__
void print(int size){
    printf("size = %d\n", size);
    for(int i = 0; i < size; i++){
        printf("data[%d] = %f\n", i, data[i]);
    }
}

int main(){
    int size = 1024;

    initMemory(size);
    printf("1\n");
    print<<<1, 1>>>(size);
    printf("2\n");
    cudaDeviceSynchronize();
    freeMemory();
    printf("3\n");
}

#包括
#包括
#包括
#定义CUDA检查值（值，a）{\
cudaError\u t\u m\u cudaStatus=值\
如果（_m_cudaStatus！=cudaSuccess）{\
printf（“文件%s中第%d行出现错误（&s）\n”\
cudaGetErrorString（_m_cudaStatus）\
__行（文件）\
出口（1）\
}else{printf（“完成！-%d\n”，a）；}
__不变的__
浮动*数据；
__主机设备__
无效初始化内存（整数大小）{
CUDA检查值（cudaMalloc（&data，sizeof（浮点）*大小），0）；
浮动*ha=新浮动[大小]；
对于（int i=0；i

---

在这段代码中，我试图将主机初始化的一些数据保留一次，并为多次调用准备内核进程，最后通过cleanup方法释放cuda内存。但我不太确定这是否是使用CUDA的正确方法，以及如何相应地修改我的代码。

在不过分强调这一点的情况下，可以公平地说，您在问题中显示的两个版本的代码中几乎都有错误。因此，与解释两次尝试中出现的所有错误相比，显示工作版本的外观更简单：

#include <cuda.h>
#include <stdio.h>
#include <cuda_runtime.h>

#define CUDA_CHECK_VALUE(value, a) {                            \
    cudaError_t _m_cudaStatus = value;                          \
    if(_m_cudaStatus != cudaSuccess) {                          \
        printf("Error %s at line %d in file %s\n",              \
                cudaGetErrorString(_m_cudaStatus),              \
                __LINE__, __FILE__);                            \
        exit(1);                                                \
    } else {printf("Done! - %d\n", a);} }

__device__ float* data;

void initMemory(int size){
    float* da;
    CUDA_CHECK_VALUE(cudaMalloc(&da, sizeof(float) * size), 0);
    float *ha = new float[size];
    for(int i =0; i < size; i++){
        ha[i] = i * 1.0f;
    }
    CUDA_CHECK_VALUE(cudaMemcpy(da, ha, sizeof(float) * size, cudaMemcpyHostToDevice), 1);
    CUDA_CHECK_VALUE(cudaMemcpyToSymbol(data, &da, sizeof(da), 0, cudaMemcpyHostToDevice), 2);
    CUDA_CHECK_VALUE(cudaDeviceSynchronize(), 3);
    delete[] ha;
}

void freeMemory(){
    CUDA_CHECK_VALUE(cudaDeviceSynchronize(), 4);
    float* da;
    CUDA_CHECK_VALUE(cudaMemcpyFromSymbol(&da, data, sizeof(da), 0, cudaMemcpyDeviceToHost), 5);
    CUDA_CHECK_VALUE(cudaFree(da), 6);
}

__global__
void print(int size){
    for(int i = 0; i < size; i++){
        printf("data[%d] = %f\n", i, data[i]);
    }
}

int main(){
    int size = 1024;

    initMemory(size);
    printf("1\n");
    print<<<1, 1>>>(size);
    cudaDeviceSynchronize();
    printf("2\n");
    freeMemory();
    printf("3\n");
}

#包括
#包括
#包括
#定义CUDA检查值（值，a）{\
cudaError\u t\u m\u cudaStatus=值\
如果（_m_cudaStatus！=cudaSuccess）{\
printf（“文件%s中第%d行出现错误%s\n”\
cudaGetErrorString（_m_cudaStatus）\
__行（文件）\
出口（1）\
}else{printf（“完成！-%d\n”，a）；}
__设备浮点数*数据；
无效初始化内存（整数大小）{
浮动*da；
CUDA检查值（cudaMalloc（&da，sizeof（浮动）*大小），0）；
浮动*ha=新浮动[大小]；
对于（int i=0；i

有几点：

必须认识到，

initMemory

和

freemory

都在代码中的主机上运行。用

\uuuu设备\uuuu

装饰代码不会自动使代码在设备上运行。它只将代码的一个版本编译为可以在内核中调用的设备函数。然而，您实际上并没有这样做，所以所有代码都在主机上运行，因为您在主机上调用了它

\uuuuuuuuuuuuuuuuuuuuuuu共享

和

\uuuuuuuuuuuuuuuuuuuu常量

内存无法从主机动态分配，正如您在我们看到的代码的两次迭代中尝试的那样

initMemory

和

freemory

的第二个实现需要使用一些额外的CUDA主机API函数，以便使事情正常工作，这一点从上面的代码中可以明显看出

---

在不过分强调这一点的情况下，可以公平地说，您在问题中显示的两个版本的代码中几乎所有内容都错了。因此，与解释两次尝试中出现的所有错误相比，显示工作版本的外观更简单：

#include <cuda.h>
#include <stdio.h>
#include <cuda_runtime.h>

#define CUDA_CHECK_VALUE(value, a) {                            \
    cudaError_t _m_cudaStatus = value;                          \
    if(_m_cudaStatus != cudaSuccess) {                          \
        printf("Error %s at line %d in file %s\n",              \
                cudaGetErrorString(_m_cudaStatus),              \
                __LINE__, __FILE__);                            \
        exit(1);                                                \
    } else {printf("Done! - %d\n", a);} }

__device__ float* data;

void initMemory(int size){
    float* da;
    CUDA_CHECK_VALUE(cudaMalloc(&da, sizeof(float) * size), 0);
    float *ha = new float[size];
    for(int i =0; i < size; i++){
        ha[i] = i * 1.0f;
    }
    CUDA_CHECK_VALUE(cudaMemcpy(da, ha, sizeof(float) * size, cudaMemcpyHostToDevice), 1);
    CUDA_CHECK_VALUE(cudaMemcpyToSymbol(data, &da, sizeof(da), 0, cudaMemcpyHostToDevice), 2);
    CUDA_CHECK_VALUE(cudaDeviceSynchronize(), 3);
    delete[] ha;
}

void freeMemory(){
    CUDA_CHECK_VALUE(cudaDeviceSynchronize(), 4);
    float* da;
    CUDA_CHECK_VALUE(cudaMemcpyFromSymbol(&da, data, sizeof(da), 0, cudaMemcpyDeviceToHost), 5);
    CUDA_CHECK_VALUE(cudaFree(da), 6);
}

__global__
void print(int size){
    for(int i = 0; i < size; i++){
        printf("data[%d] = %f\n", i, data[i]);
    }
}

int main(){
    int size = 1024;

    initMemory(size);
    printf("1\n");
    print<<<1, 1>>>(size);
    cudaDeviceSynchronize();
    printf("2\n");
    freeMemory();
    printf("3\n");
}

#包括
#包括
#包括
#定义CUDA检查值（值，a）{\
cudaError\u t\u m\u cudaStatus=值\
如果（_m_cudaStatus！=cudaSuccess）{\
printf（“文件%s中第%d行出现错误%s\n”\
cudaGetErrorString（_m_cudaStatus）\
__行（文件）\
出口（1）\
}else{printf（“完成！-%d\n”，a）；}
__设备浮点数*数据；
无效初始化内存（整数大小）{
浮动*da；
CUDA检查值（cudaMalloc（&da，sizeof（浮动）*大小），0）；
浮动*ha=新浮动[大小]；
对于（int i=0；i