在设备上访问动态分配的 arrays（不将它们作为 kernel 参数传递）

Question

How can an array of structs that has been dynamically allocated on the host be used by a kernel, without passing the array of structs as a kernel argument? This seems like a common procedure with a good amount of documentation online, yet it doesn't work on the following program.

Note: Please note that the following questions have been studied before posting this question:

1) copying host memory to cuda __device__ variable 2) Global variable in CUDA 3) Is there any way to dynamically allocate constant memory? CUDA

So far, unsuccessful attempts have been made to:

1. Dynamically allocate array of structs with cudaMalloc() , then
2. Use cudaMemcpyToSymbol() with the pointer returned from cudaMalloc() to copy to a __device__ variable which can be used by the kernel.

Code attempt:

NBody.cu (error checking using cudaStatus has mostly been omitted for better readability, and function to read data from file into dynamic array removed):

#include "cuda_runtime.h"
#include "device_launch_parameters.h"

#include <stdio.h>
#include <stdlib.h>

#define BLOCK 256

struct nbody {
    float x, y, vx, vy, m;
};
typedef struct nbody nbody;

// Global declarations
nbody* particle;

// Device variables
__device__ unsigned int d_N;  // Kernel can successfully access this
__device__ nbody d_particle;  // Update: part of problem was here with (*)

// Aim of kernel: to print contents of array of structs without using kernel argument
__global__ void step_cuda_v1() {
    int i = threadIdx.x + blockDim.x * blockIdx.x;

    if (i < d_N) {
        printf("%.f\n", d_particle.x);
    }
}

int main() {
    unsigned int N = 10;
    unsigned int I = 1;

    cudaMallocHost((void**)&particle, N * sizeof(nbody)); // Host allocation

    cudaError_t cudaStatus;
    for (int i = 0; i < N; i++) particle[i].x = i;

    nbody* particle_buf; // device buffer
    cudaSetDevice(0);

    cudaMalloc((void**)&particle_buf, N * sizeof(nbody)); // Allocate device mem
    cudaMemcpy(particle_buf, particle, N * sizeof(nbody), cudaMemcpyHostToDevice); // Copy data into device mem
    cudaMemcpyToSymbol(d_particle, &particle_buf, sizeof(nbody*)); // Copy pointer to data into __device__ var
    cudaMemcpyToSymbol(d_N, &N, sizeof(unsigned int)); // This works fine

    int NThreadBlock = (N + BLOCK - 1) / BLOCK;
    for (int iteration = 0; iteration <= I; iteration++) {

        step_cuda_v1 << <NThreadBlock, BLOCK >> > ();
        //step_cuda_v1 << <1, 5 >> > (particle_buf);
        cudaDeviceSynchronize();
        cudaStatus = cudaGetLastError();
        if (cudaStatus != cudaSuccess)
        {
            fprintf(stderr, "ERROR: %s\n", cudaGetErrorString(cudaStatus));
            exit(-1);
        }
    }
    return 0;
}

OUTPUT:

"ERROR: kernel launch failed."

Summary:

• How can I print the contents of the array of structs from the kernel, without passing it as a kernel argument?
• Coding in C using VS2019 with CUDA 10.2

Answer 1

With the help of @Robert Crovella and @talonmies, here is the solution that outputs a sequence that cycles from 0 to 9 repeatedly.

#include "cuda_runtime.h"
#include "device_launch_parameters.h"

#include <stdio.h>
#include <stdlib.h>

#define BLOCK 256

//#include "Nbody.h"
struct nbody {
    float x, y, vx, vy, m;
};
typedef struct nbody nbody;

// Global declarations
nbody* particle;

// Device variables
__device__ unsigned int d_N;  // Kernel can successfully access this
__device__ nbody* d_particle;
//__device__ nbody d_particle;  // Update: part of problem was here with (*)

// Aim of kernel: to print contents of array of structs without using kernel argument
__global__ void step_cuda_v1() {
    int i = threadIdx.x + blockDim.x * blockIdx.x;

    if (i < d_N) {
        printf("%.f\n", d_particle[i].x);
    }
}

int main() {
    unsigned int N = 10;
    unsigned int I = 1;

    cudaMallocHost((void**)&particle, N * sizeof(nbody)); // Host allocation

    cudaError_t cudaStatus;
    for (int i = 0; i < N; i++) particle[i].x = i;

    nbody* particle_buf; // device buffer
    cudaSetDevice(0);

    cudaMalloc((void**)&particle_buf, N * sizeof(nbody)); // Allocate device mem
    cudaMemcpy(particle_buf, particle, N * sizeof(nbody), cudaMemcpyHostToDevice); // Copy data into device mem
    cudaMemcpyToSymbol(d_particle, &particle_buf, sizeof(nbody*)); // Copy pointer to data into __device__ var
    cudaMemcpyToSymbol(d_N, &N, sizeof(unsigned int)); // This works fine

    int NThreadBlock = (N + BLOCK - 1) / BLOCK;
    for (int iteration = 0; iteration <= I; iteration++) {

        step_cuda_v1 << <NThreadBlock, BLOCK >> > ();
        //step_cuda_v1 << <1, 5 >> > (particle_buf);
        cudaDeviceSynchronize();
        cudaStatus = cudaGetLastError();
        if (cudaStatus != cudaSuccess)
        {
            fprintf(stderr, "ERROR: %s\n", cudaGetErrorString(cudaStatus));
            exit(-1);
        }
    }
    return 0;
}