OpenCL find max in array - opencl

Question

I am trying to find max value in a 1-D array by reduction operators. I had refered the method in: OpenCL™ Optimization Case Study: Simple Reductions
Following is my code:
__kernel void Normallize(__global float* input, __global float* output,__global float* cmax, int rows, int cols){
int g_idx = get_global_id(0);
for(int i=0 ; i< get_global_size(0) ; i++) cmax[i] = 0;
barrier(CLK_GLOBAL_MEM_FENCE);
for(int offset = get_global_size(0)/2 ; offset >0 ; offset--){
if(g_idx < offset){
float pre = input[g_idx];
float next = input[g_idx + offset];
cmax[g_idx] = (pre > next) ? pre:next;
}
barrier(CLK_GLOBAL_MEM_FENCE);
}
output[g_idx] = cmax[0];
}
After do some research, I still can't figure out the problem in my code.

Answer 1

Did you mean this(%60 VALU utilization for an amd gpu)?:
__kernel void maxping(__global __read_only float * a, __global __write_only float *b){
int threadId=get_global_id(0);
int localThreadId=get_local_id(0);
int localSize=get_local_size(0);
__local float fastMem[256];
fastMem[localThreadId]=a[threadId];
barrier(CLK_GLOBAL_MEM_FENCE|CLK_LOCAL_MEM_FENCE);
for(int i=localSize/2;i>=1;i/=2)
{
if(localThreadId<i)
{
if(fastMem[localThreadId]<fastMem[localThreadId+i])
fastMem[localThreadId]=fastMem[localThreadId+i];
}
barrier(CLK_LOCAL_MEM_FENCE);
}
if(localThreadId==0)
b[threadId]=fastMem[localThreadId];
}
where each group(of 256 threads) reduce in local memory and setting each first-in-group value to max of its group. This example has 4096 elements from 0 to 4095.
For upper kernel, VALU usage is something like:
x: idle thread
o: thread in process, m: thread in memory operation
** : m m m m m m m m m m m m m m m m
i=0 : o o o o o o o o x x x x x x x x
i=1 : o o o o x x x x x x x x x x x x
i=2 : o o x x x x x x x x x x x x x x
i=3 : o x x x x x x x x x x x x x x x
** : m m m m m m m m m m m m m m m m
but i counts more steps and each row spans 250 units.
__kernel void maxpong(__global __write_only float * a, __global __read_only float *b){
int threadId=get_global_id(0);
int localSize=get_local_size(0);
int maxGroups=4096/localSize;
if(threadId==0)
{
float maxv=FLT_MIN;
for(int i=0;i<maxGroups;i++)
{
if(maxv<b[i*localSize])
maxv=b[i*localSize];
}
a[0]=maxv;
}
}
where only first thread(best in cpu) does a simple max(0,1,2,...,M) and sets first element of a to max(a).
First kernel does 255/256 of total computing. But it leaves half of cores of each compute unit untouched. So, you can sort another thing in that other half of cores. That could be another array to be max()'ed or same array's min()'ed or even same max of same array but with working on half of it while other cores working on other half.
%73 VALU utilization for max(a) with a different initial kernel:
__kernel void maxping(__global __read_only float * a, __global __write_only float *b){
int threadId=get_global_id(0);
int localThreadId=get_local_id(0);
int localSize=get_local_size(0);
__local float fastMem[256];
__local float fastMem2[256];
fastMem[localThreadId]=a[threadId];
fastMem2[localThreadId]=a[threadId+2048];
barrier(CLK_GLOBAL_MEM_FENCE|CLK_LOCAL_MEM_FENCE);
for(int i=localSize/2;i>=1;i/=2)
{
if(localThreadId<i)
{
// sorting first part
if(fastMem[localThreadId]<fastMem[localThreadId+i])
fastMem[localThreadId]=fastMem[localThreadId+i];
}
else if(localThreadId>localSize-i)
{
// sorting second part
if(fastMem2[localThreadId]<fastMem2[localThreadId-i])
fastMem2[localThreadId]=fastMem2[localThreadId-i];
}
else
{
// idle thread. Free compute slot.
// can squeeze some geometry computing
// or up-sweep scan of another reduction type
}
barrier(CLK_LOCAL_MEM_FENCE);
}
if(localThreadId==0)
b[threadId]=(fastMem[localThreadId]>fastMem2[255]?fastMem[localThreadId]:fastMem2[255]);
}
this uses 2048 threads for 4096 element array. Sets 0th, 256th, 512nd, .. elements to their respective group maximums, then you easily check which one is bigger on the host side.
There is still unused cores.
For upper kernel, VALU usage is something like:
x: idle thread
o: thread in process, m: thread doing memory operation
** : m m m m m m m m m m m m m m m m
i=0 : o o o o o o o o o o o o o o o o
i=1 : o o o o x x x x x x x x o o o o
i=2 : o o x x x x x x x x x x x x o o
i=3 : o x x x x x x x x x x x x x x o
** : m m m m m m m m m m m m m m m m
but i steps for log2(256) times so there are more "i" steps and amd hardware has 64 cores which fully serve even when there are 64 threads in a step. When we sum all thread usage for this loop, it doesn't give %73 but when other "warps"(40 of these) stream to same compute unit, more holes are filled hence more vector arithmetic logic units become more oftenly used. Even the local memory assignment part is important because all cores' memory operation units are kept busy(global to local, local to global) while other warps keep comparison units busy.
Edit: If you need not a multiple of 256 of global size, then you can add a global id check after local memory operation so it doesnt do undefined behaviour. Maybe you can pad array with extra FLT_MIN values instead.