Question

In OpenCL what will be the consequences and differences between the following struct declarations. And if they are illegal, why?

struct gr_array
{
    int ndims;
    __global m_integer* dim_size;
    __global m_real* data;
};
typedef struct gr_array g_real_array;

struct lr_array
{
    int ndims;
    __local m_integer* dim_size;
    __local m_real* data;
};
typedef struct lr_array l_real_array;

__ kernel temp(...){

        __local g_real_array A;
        g_real_array B;

        __local l_real_array C;
        l_real_array D;

}

My question is where will the structures be allocated (and the members)? who can access them? And is this a good practice or not?

EDIT

how about this

struct r_array
    {
       __local int ndims;
    };

typedef struct r_array real_array;

__ kernel temp(...){

        __local real_array A;
        real_array B;

}

if a work-item modifies ndims in struct B, is the change visible to other work-items in the work-group?

Answer 1

I’ve rewritten your code as valid CL, or at least CL that will compile. Here:

typedef struct gr_array {
    int ndims;
    global int* dim_size;
    global float* data;
} g_float_array;

typedef struct lr_array {
    int ndims;
    local int* dim_size;
    local float* data;
} l_float_array;

kernel void temp() {
    local g_float_array A;
    g_float_array B;

    local l_float_array C;
    l_float_array D;
}

One by one, here’s how this breaks down:

• A is in local space. It’s a struct that is composed of one int and two pointers. These pointers point to data in global space, but are themselves allocated in local space.

• B is in private space; it’s an automatic variable. It is composed of an int and two pointers that point to stuff in global memory.

• C is in local space. It contains an int and two pointers to stuff in local space.

• D, you can probably guess at this point. It’s in private space, and contains an int and two pointers that point to stuff in local space.

I cannot say if either is preferable for your problem, since you haven’t described what your are trying to accomplish.

EDIT: I realized I didn’t address the second part of your question — who can access the structure fields.

Well, you can access the fields anywhere the variable is in scope. I’m guessing that you were thinking that the fields you had marked as global in g_float_array were in global space (an local space for l_float_array). But they’re just pointing to stuff in global (or local) space.

So, you’d use them like this:

kernel void temp(
            global float* data, global int* global_size,
            local float* data_local, local int* local_size,
            int num) 
{
    local g_float_array A;
    g_float_array B;

    local l_float_array C;
    l_float_array D;

    A.ndims = B.ndims = C.ndims = D.ndims = num;

    A.data = B.data = data;
    A.dim_size = B.dim_size = global_size;

    C.data = D.data = data_local;
    C.dim_size = D.dim_size = local_size;
}

By the way — if you’re hacking CL on a Mac running Lion, you can compile .cl files using the “offline” CL compiler, which makes experimenting with this kind of stuff a bit easier. It’s located here:

/System/Library/Frameworks/OpenCL.framework/Libraries/openclc

There is some sample code here.