The OpenCL implementation is faster in processing neighbouring pixels (with a window of 31x19)

[immortalsalomon]

Hello, everyone.

The general concept of the program is simple. For each pixel I want to find the maximum and minimum values in the neighbouring pixels using a window of 31x19 pixels. Furthermore, before considering a pixel in the window I want to check that it is valid. Let us say that a pixel is valid if its value is in a certain range.
Excluding for now the search for the maximum and minimum pixel to simplify things.

I don't understand how the implementation in Halide takes around 70ms (without min max search) while the one in OpenCL takes only 3-4ms (with min max search).

Halide Algorithm:

...

RDom rDomMinMax(-15, 31, -9, 19);

Func isPointValid;
isPointValid(x, y) = !(boundedDistanceBuffer(x, y) < 0 || boundedDistanceBuffer(x, y) > SomeMaxValue);

rDomMinMax.where(isPointValid(x + rDomMinMax.x, y + rDomMinMax.y));

Expr localDistance = boundedDistanceBuffer(x + rDomMinMax.x, y + rDomMinMax.y);

Expr minDistanceValue, maxDistanceValue;

Func minMaxDistance;
minMaxDistance(x, y) = Tuple(Float(32).min(), Float(32).max());
// There will be the min max algorithm but for now iterate over the domain only
minMaxDistance(x, y) = Tuple(localDistance, localDistance);

minDistanceValue = minMaxDistance(x, y)[0];
maxDistanceValue = minMaxDistance(x, y)[1];

...

mainFunction(x, y) = result;

Halide Scheduling:

Var x{"x"}, y{"y"}, bx {"bx"}, by {"by"}, tx {"tx"}, ty {"ty"};

// Buffer size not divisible per split factors.
mainFunction
    .compute_root()
    .gpu_tile(x, y, bx, by, tx, ty, 32, 16, TailStrategy::GuardWithIf, DeviceAPI::OpenCL)
    .store_in(MemoryType::Heap);

isPointValid
    .compute_root()
    .gpu_tile(x, y, bx, by, tx, ty, 32, 16, TailStrategy::GuardWithIf, DeviceAPI::OpenCL)
    .store_in(MemoryType::Heap);

// Make like this because used later
minMaxRange
    .compute_at(newMetaFlags0, tx)
    .store_in(MemoryType::Register);

OpenCL implementation:

for (int c = minRow; c <= maxRow; ++c)
{
	for (int p = minCol; p <= maxCol; ++p)
	{
		const int position = (c * rowSize + p) % bufferSize;
		const float localDistance = distance[position];

		if (localDistance < 0 || localDistance  > SomeMaxValue)
			continue;

		// Check if point is min or max
	}
}

I am sure that what slows down are the check for the validity of a point and the double for loop to process all neighbouring pixels. Could it be that there are parameters to optimise the implementation for OpenCL?

I found this issue related to the median filter #7302 . Do you think the answer is also feasible in this situation? If so, could you give me some tips.

Thank you in advance for your time :).