Opencl: Copying from __constant to __global memory - opencl

Question

I have two kernels (both of them runs only once, so the globalWorkSize is 1 in the example):
The first kernel (kernel_Calc()) calculates some values and stores them in the __global memory. In this example it calculates (sets the transformation matrix which translates a point in 3D space) a transformation matrix and transforms the origo.
inline
float4 mul( const float4 M[ 4 ], const float4 v)
{
float4 r;
r.x = dot( v, M[ 0 ] );
r.y = dot( v, M[ 1 ] );
r.z = dot( v, M[ 2 ] );
r.w = dot( v, M[ 3 ] );
return r;
}
__kernel
void kernel_Calc( __global float4* g_TransformationMatrices, __global float3* g_Point3D )
{
__private float4 transformationMatrix[ 4 ];
transformationMatrix [ 0 ] = (float4) ( 1.0f, 0.0f, 0.0f, 0.0f );
transformationMatrix [ 1 ] = (float4) ( 0.0f, 1.0f, 0.0f, 10.0f );
transformationMatrix [ 2 ] = (float4) ( 0.0f, 0.0f, 1.0f, 0.0f );
transformationMatrix [ 3 ] = (float4) ( 0.0f, 0.0f, 0.0f, 1.0f );
g_TransformationMatrices[ 0 ] = transformationMatrix[ 0 ];
g_TransformationMatrices[ 1 ] = transformationMatrix[ 1 ];
g_TransformationMatrices[ 2 ] = transformationMatrix[ 2 ];
g_TransformationMatrices[ 3 ] = transformationMatrix[ 3 ];
float4 point4D = (float4) ( 0.0f, 0.0f, 0.0f, 1.0f );
float4 point4DTransformed = mul( transformationMatrix, point4D);
g_Point3D[ 0 ] = (float3) ( point4DTransformed.x / point4DTransformed.w ,
point4DTransformed.y / point4DTransformed.w ,
point4DTransformed.z / point4DTransformed.w );
}
On the host side I copy the calculated __global buffers into __constant buffers (CL_MEM_READ_ONLY buffers) with clEnqueueCopyBuffer() function. (I do this because I hope read from the __constant memory will be faster than read from the __global memory. The buffer copy can be done on the device side with this function without copy the __global back to the host and then copy it into the __constant.)
The second kernel (kernel_Test()) tries to load the calculated values into a __global variable (__global float4* test) which can be read on the host side. The sizeStruct is a user defined struct which contains only an integer (this is the number of the matrices and transformed points). The second and the third parameters are the buffers in the __constant memory which were filled up with clEnqueueCopyBuffer() function.
struct sizeStruct
{
int m_Size;
};
__kernel
void kernel_Test( __constant struct sizeStruct* c_SS,
__constant float4* c_TransformationMatrices,
__constant float3* c_Points3D,
__global float4 *test )
{
test[ 0 ] = c_TransformationMatrices[ 0 ];
test[ 1 ] = c_TransformationMatrices[ 1 ];
test[ 2 ] = c_TransformationMatrices[ 2 ];
test[ 3 ] = c_TransformationMatrices[ 3 ];
}
The problem is when I run the program the test variable contains this:
1.000000, 0.000000, 0.000000, 0.000000
0.000000, 0.000000, 0.000000, 0.000000
0.000000, 0.000000, 0.000000, 0.000000
0.000000, 0.000000, 0.000000, 0.000000
but it should contain:
1.000000, 0.000000, 0.000000, 0.000000
0.000000, 1.000000, 0.000000, 10.000000
0.000000, 0.000000, 1.000000, 0.000000
0.000000, 0.000000, 0.000000, 1.000000
I checked the __constant variables (by copying them to the host memory) they contain the correct data. The code is a simplified version of my program. That is the reason it may contain unnecessary operations and parameters. The example is tested and works as I described.
More interesting when I change __constant float3* c_Points3D kernel parameter to __global float3* c_Points3D kernel parameter (but still use the read_only buffer which were filled up with clEnqueueCopyBuffer() function) it works fine. It also works when I remove the __constant struct sizeStruct* c_SS parameter.
So it seems something is wrong with the address spaces of the arguments of the kernel_Test but the problem appears at __constant -> __global copy.
I’m running the program on nvidia geforce gtx 690 but I can change the device (and the platform) to intel i7-3930k (using intel sdk). Using intel-i7 cpu everything works fine without any change in the kernel code.
Q1: Why does this weird behaviour appear? Does anybody have an idea what am I doing wrong?
Q2: Is it legal to create a buffer with cl_mem_read_only and use with __global address space qualifier?

Answer 1

Q1: Why does this weird behaviour appear? Does anybody have an idea what am I doing wrong?
Nothing obvious comes to mind, can you post a complete minimum working example that compiles on Windows? I'd like to test on AMD Radeon GPUs.
Q2: Is it legal to create a buffer with cl_mem_read_only and use with __global address space qualifier?
Yes that is legal, although you will want to add const to specify that the buffer is read-only, see section 6.5.1 of the OpenCL 1.2 specification.