Runtime branching feature

[popizdeh]

I seem to be stuck between a rock and a hard place. I have a generator that depends on quite a few parameters which leads to combinatorial explosion, thousands of combinations which results in hundreds of megabytes of code. Adding one more bool parameter means doubling the size of generated code, this is not going to work.

One way I can think of working around this would be to split my generator into separate stages, so instead of having GeneratorParam<bool> featureA and another GeneratorParam<bool> featureB in one generator I'd have separate generators so my calling code would know to pass the output of featureA generator as input to featureB generator when both features are enabled and so on. The problem with this approach is that entire stage needs to be evaluated before its output can be passed as input for the next stage. So featureA would write a full image buffer before featureB could start its work. Images I work with are quite large so reading and writing that much memory for each stage is simply not going to work.

The other alternative would be to use select and do everything at runtime. But because select evaluates all arguments it would be executing very costly code for featureA even when this feature is off. Not to mention that code for featureA might depend on various input parameters which are only valid when that feature is on, executing the "on" path when the feature is off could cause division by zero, indexing out of bounds or other problems.

I'd really like to have a runtime branch in the generated code. It would be branching on a constant so branch taken is going to be the same across all pixels! I'm imagining a RuntimeParam similar to GeneratorParam but doing the check at runtime, and having code generated for both if and else branches in the generator. I'm not sure how well this would work in practice but I'd expect the branch predictor to work out that same branch is always taken...

Would something like this be theoretically possible, does it break some underlying constraint Halide has?

[abadams]

Check out Func::specialize. You can pass it a boolean Expr and it will inject a branch around the evaluation of that specific Func.

[popizdeh]

Exactly what I was looking for, thanks Andrew!

It'd be nice if enums were supported for Input parameters:

enum Direction
{
    Left,
    Right
};

Input<Direction> direction;

Expr value = select(direction == Direction::Left, input(x - 1)
                                                  input(x + 1))

Func f;
f(x) = value;

f.specialize(direction == Direction::Left);
f.specialize(direction == Direction::Right);

It looks like the caller has to pass integers as inputs and relationship between values of the backing enum and value of the parameter is not enforced by the type system...