Seems to me that, all projects based on Bret Victor’s talk only implement a few features, and that’s not enough yet.

Anyway, congratulations on the effort.

You need to run the test 1000 times. Like:
time1 = time()
for i in range(1000):
c_result = (a + b) * (a + b) * (a / 2.0)
time2 = time()
print(“Execution time with numpy: “, time2 – time1, “s”)

You will see OpenCL performs better than NumPy (but NumPy is still pretty good, IMHO). On my machine:

(‘Execution time of test without OpenCL: ‘, 9.549367904663086, ‘s’)
(‘Execution time with numpy: ‘, 0.01725006103515625, ‘s’)
===============================================================
(‘Platform name:’, ‘Intel(R) OpenCL’)
(‘Platform profile:’, ‘FULL_PROFILE’)
(‘Platform vendor:’, ‘Intel(R) Corporation’)
(‘Platform version:’, ‘OpenCL 1.1 LINUX’)
—————————————————————
(‘Device name:’, ‘ Intel(R) Core(TM) i7-2630QM CPU @ 2.00GHz’)
(‘Device type:’, ‘CPU’)
(‘Device memory: ‘, 5864, ‘MB’)
(‘Device max clock speed:’, 2000, ‘MHz’)
(‘Device compute units:’, 8)
Execution time of test: 0.000382 s
Results OK
===============================================================
(‘Platform name:’, ‘NVIDIA CUDA’)
(‘Platform profile:’, ‘FULL_PROFILE’)
(‘Platform vendor:’, ‘NVIDIA Corporation’)
(‘Platform version:’, ‘OpenCL 1.1 CUDA 4.2.1′)
—————————————————————
(‘Device name:’, ‘GeForce GT 540M’)
(‘Device type:’, ‘GPU’)
(‘Device memory: ‘, 2047, ‘MB’)
(‘Device max clock speed:’, 1344, ‘MHz’)
(‘Device compute units:’, 2)
Execution time of test: 0.000624512 s
Results OK

Here are the most relevant points from the host code:

typedef struct{
cl_uchar cDist;
cl_uchar cClass
float y[N_POINTS_DEPTH];
float x[N_POINTS_RANGE];
float c1D[N_POINTS_DEPTH];
}myStruct_t;


The test kernel takes only 2 arguments, the struct as for input, and another struct of the same type to hold some test data computed from the input. Here’s the host-side memory allocation:

//instantiate a struct for input:
myStruct_t a;
a.y[0] = 1.4;
a.y[1] = 2.5;

//allocate memory for output:
cl_mem out = clCreateBuffer(context, CL_MEM_READ_WRITE, sizeof(myStruct_t), NULL, &errNum);
if(errNum != CL_SUCCESS){
fatal(clError(errNum));
}else{
DEBUG(2, "Successfully allocated memory for output.\n");
}


Then, set the kernel args:

errNum = clSetKernelArg(kernel, 0, sizeof(myStruct_t), &a);
errNum |= clSetKernelArg(kernel, 1, sizeof(cl_mem), &out);
if (errNum != CL_SUCCESS){
fprintf(stderr, "Error setting kernel arguments.\n");
fatal(clError(errNum));
exit(EXIT_FAILURE);
}else{
DEBUG(2, "Successfully defined kernel arguments.\n");
}


The kernel:

__kernel void testStructs( private myStruct_t soundIn,
global myStruct_t *result){
local myStruct_t ssp;

*result = ssp;
}


So from my tests i figured out that apparently you cannot actually use the ‘constant’ qualifier when passing in a struct, it has to be ‘private’. This is ok for me, since ‘constant’ is a special type of ‘global’ and reading it comes at a performance penalty anyway. To me it makes sense to have a settings struct in the fastest available memory.
I tested this on an Nvidia GPU with OpenCL 1.1 and on a Intel Ivy Bridge CPU also with a OpenCL 1.1 implementation.

i am on Kubuntu 11.10 (same as Ubuntu), using the most recent nvidia driver.