OpenCL support

Also, don't forget there is a difference between local int a and local
int* a, one is just a pointer to some pre-allocated memory and the
other actually requires memory to be allocated.

Correct.

Any implementation should ignore local pointers variables and only deal
with local scalar, vector and array variables.

Sorry, I'm not sure what do you mean by this.

int f()
{
    int * __local p; // __local pointer to __private memory
    __local int * p; // __private pointer to __local memory
}

Both examples seem reasonable to me.

[Villmow, Micah] A kernel with locally defined variables cannot call
another kernel with local variables. This is illegal in OpenCL because
when a kernel calls another kernel, that kernel is treated as a normal
function. A normal function is not allowed to have local variables
declared inside the body. Basically this restricts locally defined
variables in a kernel body to the top level kernel function only.

This sounds reasonable, but, to be precise, the specification says: "The
behavior of calling kernel functions with variables declared inside the
function with the __local or local qualifier from other kernel functions is
implementation-defined." In principle, an implementation can statically
compute the call graph of the kernel function being compiled and conflate
local memory allocation requirements from different kernel functions in the
graph...

Regards,
Anton.

From: Anton Lokhmotov [mailto:Anton.Lokhmotov@arm.com]
Sent: Thursday, December 09, 2010 2:14 AM
To: cfe-dev@cs.uiuc.edu
Cc: Villmow, Micah
Subject: Re: [cfe-dev] [LLVMdev] OpenCL support

> Also, don't forget there is a difference between local int a and
local
> int* a, one is just a pointer to some pre-allocated memory and the
> other actually requires memory to be allocated.
Correct.

> Any implementation should ignore local pointers variables and only
deal
> with local scalar, vector and array variables.
Sorry, I'm not sure what do you mean by this.

int f()
{
    int * __local p; // __local pointer to __private memory
    __local int * p; // __private pointer to __local memory
}

Both examples seem reasonable to me.

[Villmow, Micah] Yeah, but since neither one actually requires any memory allocation, there does not need to be any special processing. It is only when memory allocation for the local address space inside of a kernel occurs that needs to be handled differently.

> [Villmow, Micah] A kernel with locally defined variables cannot call
> another kernel with local variables. This is illegal in OpenCL
because
> when a kernel calls another kernel, that kernel is treated as a
normal
> function. A normal function is not allowed to have local variables
> declared inside the body. Basically this restricts locally defined
> variables in a kernel body to the top level kernel function only.
This sounds reasonable, but, to be precise, the specification says:
"The
behavior of calling kernel functions with variables declared inside the
function with the __local or local qualifier from other kernel
functions is
implementation-defined." In principle, an implementation can
statically
compute the call graph of the kernel function being compiled and
conflate
local memory allocation requirements from different kernel functions in
the
graph...

[Villmow, Micah] Ok I see your point. We make it illegal because of these two lines in the spec.
"It is just a regular function call if a __kernel function is called by another kernel
function. "
and
"This qualifier can be used with arguments to functions (including __kernel functions) declared as pointers, or
with variables declared inside a __kernel function."

Since having a kernel call another kernel turns the second kernel into a regular function call, we interpret it as being illegal to allocate local memory in a non-top level kernel. But your view is also valid.