OpenCL kernel only affecting portion of entire work-space - c++

Question

I have been working on a 2D implementation of SPH as found here: http://www.cs.cornell.edu/~bindel/class/cs5220-f11/code/sph.pdf
I got it working CPU side, but found that without the ability to crank up the number of iterations, the quality of the simulation is not the best.
Hence I decided to port it to OpenCL 1.2 using the C++ bindings. My kernel is compiling, and the data is being written into and read from the buffers perfectly well.
However, due to my unfamiliarity with the GPU architechture and how index-spaces and work-groups are laid out, and the scarcity of resources that address this particular topic, I've been clawing in the dark somewhat when it comes to making sure that my kernel code is doing what I think it is doing.
The problem that I am encountering is that only one work-group of particles seem to be updated the way they should.
My guess is that I am updating acceleration wrong, but I am not certain how to accomplish it given that I need to compare every work-item to every other work item, and when I try to perform the operation through the naive method the simulation ends up exploding.
I am trying to iterate through the work-groups(blocks) and then through the individual work-items in each block, but the effect seems to be that only 1 block is ever updated.
Suggestions? Ideas? Resources?
Would welcome any input at this stage.
Thanks!
Code for the kernel is attached below.
void Density_Calculation(
float ConstantDensitySumTerm,
float ConstantDensityKernelTerm,
float eps,
float H2,
global float4* position,
global float* density,
local float4* pblock
)
{
// Id of this work-item in global index space
int gid = get_global_id(0);
// Id of this work-item within it's work group
int tid = get_local_id(0);
int globalSize = get_global_size(0);
int localSize = get_local_size(0);
int numTiles = globalSize/localSize;
// Zero out the density term of this work-item
density[gid] = 0;
density[gid] += ConstantDensitySumTerm;
float4 thisPosition = position[gid];
float densityTerm = 0.0;
// Outer loop iterates over all the work-group blocks
for(int i = 0; i < numTiles; ++i)
{
// Cache the particle position within the work-group
pblock[tid] = position[(i * localSize) + tid];
// synchronize to make sure data is available for processing
barrier(CLK_LOCAL_MEM_FENCE);
// Inner loop iterates over the work-items in each work-group, after all positions have been cached
for(int j = 0; j < localSize; ++j)
{
float4 otherPosition = pblock[j];
float4 deltaPosition = thisPosition - otherPosition;
float r2 = (deltaPosition.x * deltaPosition.x) + (deltaPosition.y * deltaPosition.y) + (deltaPosition.z * deltaPosition.z);
float z = (H2 - r2) + eps;
if(z > 0)
{
float rho_ij = ConstantDensityKernelTerm * z * z * z;
densityTerm += rho_ij;
}
}
// Synchronize so that next tile can be loaded
barrier(CLK_LOCAL_MEM_FENCE);
}
density[gid] += densityTerm;
}
void Acceleration_Calculation(
float eps,
float ConstantDensitySumTerm, float ConstantDensityKernelTerm,
float H2, float ReferenceDensity, float InteractionRadius,
float C0, float CP, float CV,
global float4* position,
global float4* velocity_full,
global float4* acceleration,
global float* density,
local float4* pblock
)
{
Density_Calculation(ConstantDensitySumTerm, ConstantDensityKernelTerm, eps, H2, position, density, pblock);
// Id of this work-item in global index space
int gid = get_global_id(0);
// Id of this work-item within it's work group
int tid = get_local_id(0);
int globalSize = get_global_size(0);
int localSize = get_local_size(0);
int numTiles = globalSize/localSize;
// Set acceleration parameters
//acceleration[gid].x = 0.0;
acceleration[gid].y = -0.01;
float4 thisPosition = position[gid];
float4 thisVelocity = velocity_full[gid];
float rhoi = density[gid];
float accelerationTermX = 0.0;
float accelerationTermY = 0.0;
for(int i = 0; i < numTiles; ++i)
{
for(int j = 0; j < localSize; ++j)
{
float4 otherPosition = position[j];
float4 deltaPosition = thisPosition - otherPosition;
float r2 = (deltaPosition.x * deltaPosition.x) + (deltaPosition.y * deltaPosition.y) + (deltaPosition.z * deltaPosition.z);
if(r2 < (H2 + eps))
{
float rhoj = density[j];
float q = sqrt(r2) / InteractionRadius;
float u = 1 - q;
float w0 = C0 * (u / rhoi / rhoj);
float wP = w0 * CP * (rhoi + rhoj - (2 * ReferenceDensity)) * (u / q);
float wV = w0 * CV;
float4 deltaVelocity = thisVelocity - velocity_full[j];
accelerationTermX += (wP * deltaPosition.x) + (wV * deltaVelocity.x);
accelerationTermY += (wP * deltaPosition.y) + (wV * deltaVelocity.y);
}
}
}
acceleration[gid].x += accelerationTermX;
acceleration[gid].y += accelerationTermY;
}
void LeapfrogIntegrator(
const float4 dt,
global float4* position,
global float4* velocity_full,
global float4* velocity_half,
global float4* acceleration
)
{
// Id of this work-item in global index space
int gid = get_global_id(0);
velocity_half[gid] = velocity_full[gid] + (acceleration[gid] * (dt/2));
velocity_full[gid] += acceleration[gid] * dt;
position[gid] += velocity_full[gid] * dt;
}
void kernel SPH_kernel(
float dt, float eps,
float ConstantDensitySumTerm, float ConstantDensityKernelTerm,
float H2, float ReferenceDensity, float InteractionRadius,
float C0, float CP, float CV,
global float4* position,
global float4* velocity_half,
global float4* velocity_full,
global float4* acceleration,
global float* density,
local float4* pblock
)
{
const float4 dt4 = (float4)(dt,dt,dt,0.0f);
Acceleration_Calculation(eps, ConstantDensitySumTerm, ConstantDensityKernelTerm, H2, ReferenceDensity, InteractionRadius, C0, CP, CV,
position, velocity_full, acceleration, density, pblock);
LeapfrogIntegrator(dt4, position, velocity_full, velocity_half, acceleration);
}