Update definition of Buffer takes precedence over any prior usage

[Carpetfizz]

Consider this example where each pixel needs to undergo two tests. The final value of the pixel must be determined by the minimum value of the two tests.

Var x, y;
Func f;
int32_t width = 100;
int32_t height = 100;
Buffer<uint8_t> output(width, height);
Buffer<double> minBuffer(width, height);
minBuffer.fill(1e10);
f(x, y) = cast<uint8_t>(0);
std::vector<double> zs = {0, 1};
for (const double& z : zs)
{
    Expr zTest = Expr(z) < minBuffer(x, y);
    f(x, y) = select(zTest, cast<uint8_t>(Expr(z) * Expr(255)), f(x, y));
    minBuffer(x, y) = select(zTest, Expr(z), minBuffer(x, y));
}
f.realize(output);

In this case, the final value of the pixel must be 0 black image since the minimum z = 0. However, I'm getting back a white image, suggesting that the update definition to minBuffer is being evaluated before the zTest has taken place.

NOT A CONTRIBUTION

[abadams]

Buffers can't be used like Funcs. minBuffer(x, y) returns a temporary Expr, and assigning to it doesn't affect the buffer. I'm surprised that the compiler didn't give the error that assignments must have an lvalue on the LHS, but I guess C++ is weird. Here's some equivalent code to what you did:

struct Foo {
    int x;
};

Foo f() {
    return {3};
}

int main(int argc, char **argv) {
    f() = Foo{17};

    // Prints 3, not 17
    printf("%d\n", f().x);
    return 0;
}

I'll try to change things so that your code will trigger a compiler error.

[Carpetfizz]

Thank you @abadams! Is there any way to actually get this behavior to work in Halide? I tried turning minBuffer into Func and got the following error :

Error: Func minBuffer cannot be given a new update definition, because it has already been realized or used in the definition of another Func.

Unfortunately I don't have a self contained example of this but I'd be happy to create one if just the error is insufficient.

[abadams]

Halide Funcs have to form an acyclic graph. You can't have Func A that depends on Func B that depends on Func A. Try to accomplish your algorithm using a single Func.