fast rasterization on with opencl - opengl

Question

i am writing a rasterizer for real-time 3d rendering with opencl.
my current architecture:
vertex shader: 1 thread per vertex
rasterizer: 1 thread per face that loops over all pixels covered by the face
fragment shader: 1 thread per pixel
this works well when the faces occupy a small screen space but when i have one covering a large portion of the screen, the frame rate tanks on account of the fact that the rasterization thread must synchronously loop over all pixels the face covers.
I think this could be solved by a tiled approach. The screen would be divided into subsections (tiles), and one thread would be launched per tile. Only the faces whose bounding box overlap the tile would be processed.
I have some questions about this method though:
Should I find the tile's overlapping faces the CPU or GPU?
What data structure should be used to store the face lists? They will have variable length, however I believe OpenCL buffers are fixed length.
Sample of host code of current implementation:
// set up vertex shader args
queue.enqueueNDRangeKernel(vertexShader, cl::NullRange, numVerts, cl::NullRange);
// set up rasterizer args
queue.enqueueNDRangeKernel(rasterizer, cl::NullRange, numFaces, cl::NullRange);
// set up fragment shader args
queue.enqueueNDRangeKernel(fragmentShader, cl::NullRange, numPixels, cl::NullRange);
// read frame buffer to draw to screen
queue.enqueueReadBuffer(buffer_screen, CL_TRUE, 0, width * height * 3 * sizeof(unsigned char), screen);
Sample of rasterizer kernel:
float2 bboxmin = (float2)(INFINITY,INFINITY);
float2 bboxmax = (float2)(-INFINITY,-INFINITY);
float2 clampCoords = (float2)(width-1, height-1);
// get bounding box
for (int i=0; i<3; i++) {
for (int j=0; j<2; j++) {
bboxmin[j] = max(0.f, min(bboxmin[j], vs[i][j]));
bboxmax[j] = min(clampCoords[j], max(bboxmax[j], vs[i][j]));
}
}
// loop over all pixels in bounding box
// this is the part that needs to be improved
int2 pix;
for (pix.x=bboxmin.x; pix.x<=bboxmax.x; pix.x++) {
for (pix.y=bboxmin.y; pix.y<=bboxmax.y; pix.y++) {
float3 bc_screen = barycentric(vs[0].xy, vs[1].xy, vs[2].xy, (float2)(pix.x,pix.y), offset);
float3 bc_clip = (float3)(bc_screen.x/vsVP[0][3], bc_screen.y/vsVP[1][3], bc_screen.z/vsVP[2][3]);
bc_clip = bc_clip/(bc_clip.x+bc_clip.y+bc_clip.z);
float frag_depth = dot(homoZs, bc_clip);
int pixInd = pix.x+pix.y*width;
if (bc_screen.x<0 || bc_screen.y<0 || bc_screen.z<0 || zbuffer[pixInd]>frag_depth) continue;
zbuffer[pixInd] = frag_depth;
}
}

Answer 1

A workaround is to cancel rasterization if a face gets too large and just return. This will lead to some visual artifacts, but at least the frame rate won't suffer.