Autoscheduler: "Unbounded producer->consumer relationship" error should be more helpful

[steven-johnson]

When using apps/autoscheduler on existing code, it's easy to encounter a failure like:

Condition failed: in.is_bounded()
Unbounded producer->consumer relationship: foo -> bar

Could this error be improved to suggest ways to improve the underlying code to allow the autoscheduler to run on it?

[steven-johnson]

This seems to be particularly easy to run into for pipelines that use fixed-point int32 math, or int32 lerps, since int32 is treated as 'unbounded'.

(Attempts to work around this by wrapping expressions in unsafe_promise_clamped(e, (int32_t)-2147483648, (int32_t)2147483647) generally end with signed_integer_overflow failures in the autoscheduler.)

[steven-johnson]

(assigning to @abadams for triage)

[abadams]

Do you have a minimal example of the sort of thing that causes a problem? E.g. is this data-dependent access into something that has a boundary condition (like an image warp)?

[steven-johnson]

Yes, that's the sort of case I've seen it on so far. I can put together simple examples at some point.

[steven-johnson]

Unfortunately, I dropped the ball on producing the example(s) here, and don't still have the repro case in a usable state. In general the issue should still be improved (so I'm leaving it open for now) but probably no useful action items here until another good repro case comes along.)

[tufei]

I encountered the same issue and using unsafe_promise_clamped() solves my issue.

Please take a look at:

tufei/Halide-elements@ba6f192

, if you are still waiting on a simple example.

Regards,

[catid]

Also seeing this issue from an image warp function:

Unhandled exception: Internal Error at /build/source/src/autoschedulers/adams2019/FunctionDAG.cpp:920 triggered by user code at : Condition failed: in.is_bounded(): Unbounded producer->consumer relationship: repeat_edge -> output

[soufianekhiat]

Here a simple example which produce the same issue, which is simple "Face Normal of triangular Mesh" computation:

//////////////////////////////////////////////////////////////////////////
Buffer<Scalar> oVerticesBuffer(&aVertices[0], { (int)aVertices.size() }, "VerticesBuffer");
Buffer<int> oIndicesBuffer(&aIndices[0], { (int)aIndices.size() }, "IndicesBuffer");

std::vector<Scalar> aTrianglesNormals(aIndices.size());
Buffer<Scalar> oTrianglesNormalsBuffer(&aTrianglesNormals[0], { (int)aTrianglesNormals.size() }, "TrianglesNormalsBuffer");

auto NormalizeHalide =
	[](Expr& nx, Expr& ny, Expr& nz, Expr xx, Expr yy, Expr zz)
	{
		Expr fNorm = sqrt(xx*xx + yy*yy + zz*zz);

		nx = xx/fNorm;
		ny = yy/fNorm;
		nz = zz/fNorm;
	};

Func vertices{ "Vertices" };
Func indices{ "Indices" };

{
	Var initXVert{ "initXVert" };
	Var initXInd{ "initXInd" };
	vertices(initXVert) = oVerticesBuffer(initXVert);
	indices(initXInd) = oIndicesBuffer(initXInd);
}

Var x{ "x" };
Var y{ "y" };
Var z{ "z" };

Func computeNormals{ "ComputeNormals" };

Expr a = indices(3*x + 0);
Expr b = indices(3*x + 1);
Expr c = indices(3*x + 2);

Expr x0 = vertices(3*a + 0);
Expr y0 = vertices(3*a + 1);
Expr z0 = vertices(3*a + 2);

Expr x1 = vertices(3*b + 0);
Expr y1 = vertices(3*b + 1);
Expr z1 = vertices(3*b + 2);

Expr x2 = vertices(3*c + 0);
Expr y2 = vertices(3*c + 1);
Expr z2 = vertices(3*c + 2);

Expr vD01x = x1 - x0;
Expr vD01y = y1 - y0;
Expr vD01z = z1 - z0;

Expr vD02x = x2 - x0;
Expr vD02y = y2 - y0;
Expr vD02z = z2 - z0;

Expr v01x;
Expr v01y;
Expr v01z;
NormalizeHalide(v01x, v01y, v01z, vD01x, vD01y, vD01z);

Expr v02x;
Expr v02y;
Expr v02z;
NormalizeHalide(v02x, v02y, v02z, vD02x, vD02y, vD02z);

Expr vCrossX = v01y*v02z - v01z*v02y;
Expr vCrossY = v01z*v02x - v01x*v02z;
Expr vCrossZ = v01x*v02y - v01y*v02x;

Expr vCrossXNormalized;
Expr vCrossYNormalized;
Expr vCrossZNormalized;
NormalizeHalide(vCrossXNormalized, vCrossYNormalized, vCrossZNormalized, vCrossX, vCrossY, vCrossZ);

Func faceNormal{ "FaceNormal" };
faceNormal(x) = select(x % 3 == 0, vCrossXNormalized, select(x % 3 == 1, vCrossYNormalized, vCrossZNormalized ));

vertices.set_estimates({ {0, (int)aVertices.size()} });
indices.set_estimates({ {0, (int)aIndices.size()} });
faceNormal.set_estimates({ {0, (int)aIndices.size()} });

Pipeline pipe(faceNormal);
AutoSchedulerResults auto_schedule_results = pipe.auto_schedule("Adams2019", target);

Condition failed: in.is_bounded()
Unbounded producer->consumer relationship: Vertices-> FaceNormal

[oelgendy]

@soufianekhiat I think that issue is that: the indices need to be clamped to their min and max value

for example, if you take x and y indices from a 2d frame buffer and the max index is 99,

Var x,y,i;
x=clamp(Indices(i,0), 0, 99);
y=clamp(Indices(i,1), 0, 99);

[soufianekhiat]

@oelgendy
I see, apparently this is what's the historgram sample do.

Thanks