CODEWITHSUNDEEP
c++opencl
Fresto
Fresto

Reputation: 465

Dynamic array in an array of structures in OpenCL

I have a struct :

struct A
{
double a;
int c;
double *array;
}
main()
{
A *str = new A[50];
for(int i=0;i<50;i++)
{
str[i].array = new double[5];
str[i].array[0] = 50;
}
.....
Buffer BufA = Buffer(...,..., 50 * sizeof(A),str);
.....
}

In kernel

struct A
{
double a;
int c;
double *array;
}

__kernel void vector(__global A *str)
{
int id = get_global_id(0);
printf("Element - %f",str[id].array[0]);
}

But in the kernel does not see the value in the array. Probably, because in the buffer I allocated memory for an array of structures without the memory of a dynamic array. How can I implement this?

Upvotes: 0

Views: 394

Answers (2)

Max Langhof
Max Langhof

Reputation: 23681

On top of the address virtualization mentioned by YSC, you should also keep in mind that the memory that your graphics card (or other OCL device) is operating on may be distinct (as in, different pieces of hardware) from the memory your CPU is operating on.

The OpenCL buffers are responsible for transporting their contents between these memories. So for example an array of ints that you create and write to on the CPU would have to be copied to GPU memory (and have space allocated there, and possibly be copied back after the kernel is done), which these buffers do for you. But if you store pointers to other CPU memory in your buffer, then that other memory will not be transferred automatically. Further, the pointer relation would most likely break, as there is no guarantee that your other data is at the same location in GPU memory as in CPU memory.

The solution, naturally, is to put all the data you want transferred into buffers, including the sub-arrays. One way to do this without using excessive amounts of buffers would be to pack the sub-arrays together into one and storing indices into it instead of pointers to memory.

Upvotes: 1

YSC
YSC

Reputation: 40060

On modern system, a process doesn't see the actual addresses of objects, but rather the virtual addresses of such objects.

This means, two processes cannot pass each others pointers and expect them to mean the same thing. You need to rethink your application with that in mind.

Upvotes: 3

Related Questions