Illegal memory accessed while using double pointer in CUDA - pointers

Question

In the code given below, d_slot is a double pointer initialized to NULL in the main.
It's value is changed in the kernel 'test'.
The code which i'm going to implement requires the value of d_slot to be carried and not be reverted back to NULL as it happens after 'test' is completed.
(This is perhaps because the double pointer is passed by value and not by reference)
#include <stdio.h>
#include <cuda_runtime.h>
#include <cuda_profiler_api.h>
#include <helper_cuda.h>
#include <unistd.h>
#include <stdlib.h>
struct radix_tree_root {
unsigned int height;
struct radix_tree_node *rnode;
};
struct radix_tree_node {
unsigned int count;
void *slots[64];
};
__global__ void test1(struct radix_tree_node **d_slot,struct radix_tree_root *d_root)
{
(d_slot) = &d_root->rnode;
printf("From test1: d_slot = %p\t*d_slot = %p\n",d_slot,*d_slot);
}
__global__ void test2(struct radix_tree_node **d_slot)
{
printf("From test2: d_slot = %p\n",d_slot);
}
__global__ void test3(struct radix_tree_node ***d_slot,struct radix_tree_root *d_root)
{
(*d_slot) = &d_root->rnode;
}
int
main(void)
{
struct radix_tree_root *root,*d_root;
struct radix_tree_node **d_slot=NULL;
cudaError_t err = cudaSuccess;
root = (struct radix_tree_root *) malloc(sizeof(struct radix_tree_root));
root->height = 0;
root->rnode =NULL;
//allocate memory to d_root in the GPU//
err = cudaMalloc((void **)&d_root, sizeof(struct radix_tree_root));
if (err != cudaSuccess)
{
fprintf(stderr, "Failed to allocate device d_root (error code %s)!\n", cudaGetErrorString(err));
exit(EXIT_FAILURE);
}
//copy root to d_root
err = cudaMemcpy(d_root, root, (sizeof(struct radix_tree_root)), cudaMemcpyHostToDevice);
if (err != cudaSuccess)
{
fprintf(stderr, "Failed to copy root from host to device (error code %s)!\n", cudaGetErrorString(err));
exit(EXIT_FAILURE);
}
printf("\nFrom the main: d_root = %p\n",d_root);
test1<<<1,1>>>(d_slot,d_root);
err = cudaGetLastError();//brief Returns the last error from a runtime call
cudaDeviceSynchronize();
test2<<<1,1>>>(d_slot);
err = cudaGetLastError();//brief Returns the last error from a runtime call
cudaDeviceSynchronize();
//test3<<<1,1>>>(&d_slot,d_root);
err = cudaGetLastError();//brief Returns the last error from a runtime call
cudaDeviceSynchronize();
//test2<<<1,1>>>(d_slot);
err = cudaGetLastError();//brief Returns the last error from a runtime call
cudaDeviceSynchronize();
err = cudaFree(d_root);
if (err != cudaSuccess)
{
fprintf(stderr, "Failed to free device d_root (error code %s)!\n", cudaGetErrorString(err));
exit(EXIT_FAILURE);
}
free(root);
printf("successful execution of entire program\n");
return 0;
}
The output of this code is:
From the main: d_root = 0x900ca0000
From test1: d_slot = 0x900ca0008 *d_slot = (nil)
From test2: d_slot = (nil)
successful execution of entire program
This was all fine. But when i uncommented the 'test3' and the 'test2' kernels given in the above code,
I expected the value of d_slot to be carried forward...
However, there was an error encountered...
The output of the code with 'test3' and 'test2' uncommented is:
From the main: d_root = 0x900ca0000
From test1: d_slot = 0x900ca0008 *d_slot = (nil)
From test2: d_slot = (nil)
Failed to free device d_root (error code an illegal memory access was encountered)!
So my question is,
"How do I successfully assign value to d_slot (a double pointer)
in the kernel without losing it's value after the the completion of kernel-execution?"

Answer 1

There needs to be some location in graphics memory that test1 can write to and test2 and test3 can read from. You could use cudaMalloc a second time to allocate space for a struct radix_tree_node * like so:
cudaMalloc((void **)&d_slot, sizeof(struct radix_tree_root *));
Then test1 can write a pointer value to *d_slot and test2 and test3 can read the value that test1 wrote from *d_slot.