From e307e0986eedade4733dbd5057bb5c14110a4296 Mon Sep 17 00:00:00 2001 From: Andrew Adams Date: Tue, 11 Nov 2025 13:28:09 -0800 Subject: [PATCH 01/42] Top-down type inference support --- src/Func.cpp | 7 ++++++ src/Function.cpp | 3 +++ src/IROperator.cpp | 45 +++++++++++++++++++++++++++++++++++++ src/IROperator.h | 4 ++++ src/IRPrinter.cpp | 2 ++ src/Type.h | 14 +++++++++++- src/runtime/HalideRuntime.h | 11 ++++----- 7 files changed, 80 insertions(+), 6 deletions(-) diff --git a/src/Func.cpp b/src/Func.cpp index f4e4298fae07..74bcf3dfbfbf 100644 --- a/src/Func.cpp +++ b/src/Func.cpp @@ -3388,8 +3388,15 @@ Stage FuncRef::operator/=(const FuncRef &e) { } FuncRef::operator Expr() const { + /* user_assert(func.has_pure_definition() || func.has_extern_definition()) << "Can't call Func \"" << func.name() << "\" because it has not yet been defined.\n"; + */ + + if (!(func.has_pure_definition() || func.has_extern_definition())) { + return Call::make(Type{}, func.name(), args, Call::Halide, + FunctionPtr(), 0, Buffer<>(), Parameter()); + } user_assert(func.outputs() == 1) << "Can't convert a reference Func \"" << func.name() diff --git a/src/Function.cpp b/src/Function.cpp index d9484e5aca0d..50384dc265ac 100644 --- a/src/Function.cpp +++ b/src/Function.cpp @@ -220,6 +220,7 @@ struct CheckVars : public IRGraphVisitor { void visit(const Call *op) override { IRGraphVisitor::visit(op); + /* if (op->name == name && op->call_type == Call::Halide) { for (size_t i = 0; i < op->args.size(); i++) { const Variable *var = op->args[i].as(); @@ -232,6 +233,7 @@ struct CheckVars : public IRGraphVisitor { } } } + */ } void visit(const Variable *var) override { @@ -568,6 +570,7 @@ void Function::define(const vector &args, vector values) { // Freeze all called functions FreezeFunctions freezer(name()); + // TODO: Check for calls to undefined Funcs for (const auto &value : values) { value.accept(&freezer); } diff --git a/src/IROperator.cpp b/src/IROperator.cpp index c109f1d2ccff..e202ab025516 100644 --- a/src/IROperator.cpp +++ b/src/IROperator.cpp @@ -689,6 +689,16 @@ void match_types(Expr &a, Expr &b) { return; } + if (a.type().is_unknown() && !b.type().is_unknown()) { + b = cast(Type{}, b); + return; + } + + if (b.type().is_unknown() && !a.type().is_unknown()) { + a = cast(Type{}, a); + return; + } + user_assert(!a.type().is_handle() && !b.type().is_handle()) << "Can't do arithmetic on opaque pointer types: " << a << ", " << b << "\n"; @@ -1507,12 +1517,47 @@ Expr saturating_cast(Type t, Expr e) { return Call::make(t, Call::saturating_cast, {std::move(e)}, Call::PureIntrinsic); } +Expr declare_type(Type t, const Expr &e) { + // TODO: This may be called on unsanitized exprs. May need CSE. + internal_assert(e.type().is_unknown()); + if (const Call *op = e.as()) { + internal_assert(op->call_type == Call::Halide); + return Call::make(t, op->name, op->args, op->call_type, + op->func, op->value_index, op->image, op->param); + } else if (const Add *op = e.as()) { + return Add::make(declare_type(t, op->a), declare_type(t, op->b)); + } else if (const Sub *op = e.as()) { + return Sub::make(declare_type(t, op->a), declare_type(t, op->b)); + } else if (const Mul *op = e.as()) { + return Mul::make(declare_type(t, op->a), declare_type(t, op->b)); + } else if (const Div *op = e.as
()) { + return Div::make(declare_type(t, op->a), declare_type(t, op->b)); + } else if (const Min *op = e.as()) { + return Min::make(declare_type(t, op->a), declare_type(t, op->b)); + } else if (const Max *op = e.as()) { + return Max::make(declare_type(t, op->a), declare_type(t, op->b)); + } else if (const Cast *op = e.as()) { + // Must be a cast to unknown + return Cast::make(t, op->value); + } else { + user_error << "Can't do top-down type inference on " << e; + } +} + Expr select(Expr condition, Expr true_value, Expr false_value) { if (as_const_int(condition)) { // Why are you doing this? We'll preserve the select node until constant folding for you. condition = cast(Bool(true_value.type().lanes()), std::move(condition)); } + if (true_value.type().is_unknown() && !false_value.type().is_unknown()) { + true_value = declare_type(false_value.type(), true_value); + } + + if (false_value.type().is_unknown() && !true_value.type().is_unknown()) { + false_value = declare_type(true_value.type(), false_value); + } + // Coerce int literals to the type of the other argument if (as_const_int(true_value)) { true_value = cast(false_value.type(), std::move(true_value)); diff --git a/src/IROperator.h b/src/IROperator.h index 797f12870f5d..301177e38a2e 100644 --- a/src/IROperator.h +++ b/src/IROperator.h @@ -389,6 +389,10 @@ inline Expr cast(Expr a) { /** Cast an expression to a new type. */ Expr cast(Type t, Expr a); +/** Declare an Expr with unknown type has a given type. Useful when defining + * Funcs inductively. */ +Expr declare_type(Type t, const Expr &e); + /** Return the sum of two expressions, doing any necessary type * coercion using \ref Internal::match_types */ Expr operator+(Expr a, Expr b); diff --git a/src/IRPrinter.cpp b/src/IRPrinter.cpp index 331e5de658b2..c8731f8474f4 100644 --- a/src/IRPrinter.cpp +++ b/src/IRPrinter.cpp @@ -46,6 +46,8 @@ ostream &operator<<(ostream &out, const Type &type) { case Type::BFloat: out << "bfloat"; break; + case Type::Unknown: + out << "unknown"; } if (!type.is_handle()) { out << type.bits(); diff --git a/src/Type.h b/src/Type.h index 8a023429e5e6..03880cedc3dd 100644 --- a/src/Type.h +++ b/src/Type.h @@ -291,6 +291,7 @@ struct Type { static constexpr halide_type_code_t Float = halide_type_float; static constexpr halide_type_code_t BFloat = halide_type_bfloat; static constexpr halide_type_code_t Handle = halide_type_handle; + static constexpr halide_type_code_t Unknown = halide_type_unknown; // @} /** The number of bytes required to store a single scalar value of this type. Ignores vector lanes. */ @@ -300,7 +301,7 @@ struct Type { // Default ctor initializes everything to predictable-but-unlikely values Type() - : type(Handle, 0, 0) { + : type(Unknown, 0, 1) { } /** Construct a runtime representation of a Halide type from: @@ -452,6 +453,12 @@ struct Type { return code() == Handle; } + /** Is this type a floating point type (float or double). */ + HALIDE_ALWAYS_INLINE + bool is_unknown() const { + return code() == Unknown; + } + // Returns true iff type is a signed integral type where overflow is defined. HALIDE_ALWAYS_INLINE bool can_overflow_int() const { @@ -565,6 +572,11 @@ inline Type Handle(int lanes = 1, const halide_handle_cplusplus_type *handle_typ return Type(Type::Handle, 64, lanes, handle_type); } +/** Construct an unknown type */ +inline Type Unknown() { + return Type{}; +} + /** Construct the halide equivalent of a C type */ template inline Type type_of() { diff --git a/src/runtime/HalideRuntime.h b/src/runtime/HalideRuntime.h index acf5e340df5b..aec33e7b3f09 100644 --- a/src/runtime/HalideRuntime.h +++ b/src/runtime/HalideRuntime.h @@ -487,11 +487,12 @@ typedef enum halide_type_code_t : uint8_t #endif { - halide_type_int = 0, ///< signed integers - halide_type_uint = 1, ///< unsigned integers - halide_type_float = 2, ///< IEEE floating point numbers - halide_type_handle = 3, ///< opaque pointer type (void *) - halide_type_bfloat = 4, ///< floating point numbers in the bfloat format + halide_type_int = 0, ///< signed integers + halide_type_uint = 1, ///< unsigned integers + halide_type_float = 2, ///< IEEE floating point numbers + halide_type_handle = 3, ///< opaque pointer type (void *) + halide_type_bfloat = 4, ///< floating point numbers in the bfloat format + halide_type_unknown = 5, ///< an expression of unknown type, to be determined later } halide_type_code_t; // Note that while __attribute__ can go before or after the declaration, From 8463f42e7b29d17dd2cfe29306e9ebf3f0611b29 Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Thu, 20 Nov 2025 19:57:17 -0500 Subject: [PATCH 02/42] Inductive functions rebase --- src/Bounds.cpp | 2 +- src/BoundsInference.cpp | 16 ++ src/CMakeLists.txt | 2 + src/Func.cpp | 3 + src/Function.cpp | 89 ++++++++- src/Function.h | 6 + src/IRPrinter.cpp | 3 + src/Inductive.cpp | 126 +++++++++++++ src/Inductive.h | 24 +++ src/Schedule.h | 9 + src/ScheduleFunctions.cpp | 7 +- test/correctness/CMakeLists.txt | 1 + test/correctness/inductive.cpp | 243 +++++++++++++++++++++++++ test/error/CMakeLists.txt | 7 + test/error/inductive_loop.cpp | 18 ++ test/error/inductive_loop_2.cpp | 18 ++ test/error/inductive_loop_3.cpp | 18 ++ test/error/inductive_nested_select.cpp | 19 ++ test/error/inductive_no_select.cpp | 19 ++ test/error/inductive_reorder.cpp | 21 +++ test/error/inductive_var_swap.cpp | 19 ++ test/error/inductive_vectorize.cpp | 20 ++ 22 files changed, 685 insertions(+), 5 deletions(-) create mode 100644 src/Inductive.cpp create mode 100644 src/Inductive.h create mode 100644 test/correctness/inductive.cpp create mode 100644 test/error/inductive_loop.cpp create mode 100644 test/error/inductive_loop_2.cpp create mode 100644 test/error/inductive_loop_3.cpp create mode 100644 test/error/inductive_nested_select.cpp create mode 100644 test/error/inductive_no_select.cpp create mode 100644 test/error/inductive_reorder.cpp create mode 100644 test/error/inductive_var_swap.cpp create mode 100644 test/error/inductive_vectorize.cpp diff --git a/src/Bounds.cpp b/src/Bounds.cpp index 9087516b54b8..ba9ba69975a9 100644 --- a/src/Bounds.cpp +++ b/src/Bounds.cpp @@ -3286,7 +3286,7 @@ FuncValueBounds compute_function_value_bounds(const vector &order, Interval result; - if (f.is_pure()) { + if (f.is_pure() && !f.is_inductive()) { // Make a scope that says the args could be anything. Scope arg_scope; diff --git a/src/BoundsInference.cpp b/src/BoundsInference.cpp index 8befb2c0454e..ac5af651c70a 100644 --- a/src/BoundsInference.cpp +++ b/src/BoundsInference.cpp @@ -7,6 +7,7 @@ #include "IREquality.h" #include "IRMutator.h" #include "IROperator.h" +#include "Inductive.h" #include "Inline.h" #include "Qualify.h" #include "Scope.h" @@ -1002,6 +1003,21 @@ class BoundsInference : public IRMutator { } } + // For any inductively defined functions, make sure their + // bounds include the base case. + for (Stage &s : stages) { + if (!s.func.is_pure() || !s.func.is_inductive()) { + continue; + } + debug(4) << "Expanding bounds for inductively defined function " << s.func.name() << "\n"; + for (const auto &b1 : s.bounds) { + const Box &b = b1.second; + for (const auto &cval : s.exprs) { + s.bounds[b1.first] = expand_to_include_base_case(s.func.args(), cval.value, s.func.name(), b); + } + } + } + // The region required of the each output is expanded to include the size of the output buffer. for (const Function &output : outputs) { Box output_box; diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 1e2229eca2c7..ec9897dd434c 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -132,6 +132,7 @@ target_sources( HexagonOffload.h HexagonOptimize.h ImageParam.h + Inductive.h InferArguments.h InjectHostDevBufferCopies.h Inline.h @@ -313,6 +314,7 @@ target_sources( HexagonOffload.cpp HexagonOptimize.cpp ImageParam.cpp + Inductive.cpp InferArguments.cpp InjectHostDevBufferCopies.cpp Inline.cpp diff --git a/src/Func.cpp b/src/Func.cpp index 74bcf3dfbfbf..0510bcfce400 100644 --- a/src/Func.cpp +++ b/src/Func.cpp @@ -1352,6 +1352,9 @@ Stage &Stage::fuse(const VarOrRVar &inner, const VarOrRVar &outer, const VarOrRV } else if (dims[i].dim_type == DimType::PureRVar || outer_type == DimType::PureRVar) { dims[i].dim_type = DimType::PureRVar; + } else if (dims[i].dim_type == DimType::InductiveVar || + outer_type == DimType::InductiveVar) { + dims[i].dim_type = DimType::InductiveVar; } else { dims[i].dim_type = DimType::PureVar; } diff --git a/src/Function.cpp b/src/Function.cpp index 50384dc265ac..a26939c543f9 100644 --- a/src/Function.cpp +++ b/src/Function.cpp @@ -634,7 +634,11 @@ void Function::define(const vector &args, vector values) { contents->init_def = Definition(init_def_args, values, rdom, true); for (const auto &arg : args) { - Dim d = {arg, ForType::Serial, DeviceAPI::None, DimType::PureVar}; + DimType dtype = DimType::PureVar; + if (is_inductive(arg)) { + dtype = DimType::InductiveVar; + } + Dim d = {arg, ForType::Serial, DeviceAPI::None, dtype}; contents->init_def.schedule().dims().push_back(d); StorageDim sd = {arg}; contents->func_schedule.storage_dims().push_back(sd); @@ -1067,8 +1071,89 @@ bool Function::has_pure_definition() const { return contents->init_def.defined(); } +bool Function::is_inductive() const { + class RecursiveHelper : public IRVisitor { + using IRVisitor::visit; + const string &func; + void visit(const Call *op) override { + if (op->name == func) { + recursive = true; + } + IRVisitor::visit(op); + } + + public: + bool recursive = false; + RecursiveHelper(const string &func) + : func(func) { + } + }; + + if (!has_pure_definition()) { + return false; + } + + RecursiveHelper r(name()); + for (const Expr &e : definition().values()) { + e.accept(&r); + } + + return r.recursive; +} + +bool Function::is_inductive(const string &var) const { + class RecursiveHelper : public IRVisitor { + using IRVisitor::visit; + const string &func; + const string &var; + const int &pos; + void visit(const Call *op) override { + if (op->name == func) { + recursive = true; + if (const auto &v = op->args[pos].as()) { + if (v->name != var) { + inductive_in_var = true; + } + } else { + inductive_in_var = true; + } + } + IRVisitor::visit(op); + } + + public: + bool recursive = false; + bool inductive_in_var = false; + RecursiveHelper(const string &func, const string &var, const int &pos) + : func(func), var(var), pos(pos) { + } + }; + + if (!has_pure_definition()) { + return false; + } + + int pos = -1; + for (int i = 0; i < definition().args().size(); i++) { + if (const auto &v = definition().args()[i].as()) { + if (v->name == var) { + pos = i; + } + } + } + if (pos == -1) { + return false; + } + RecursiveHelper r(name(), var, pos); + for (const Expr &e : definition().values()) { + e.accept(&r); + } + + return r.inductive_in_var; +} + bool Function::can_be_inlined() const { - return is_pure() && definition().specializations().empty(); + return is_pure() && definition().specializations().empty() && !is_inductive(); } bool Function::has_update_definition() const { diff --git a/src/Function.h b/src/Function.h index 55800f3457e5..16c8bb221825 100644 --- a/src/Function.h +++ b/src/Function.h @@ -187,6 +187,12 @@ class Function { !has_extern_definition()); } + /** Does this function have an inductive pure definition? */ + bool is_inductive() const; + + /** Is this function inductive in the given variable? */ + bool is_inductive(const std::string &var) const; + /** Is it legal to inline this function? */ bool can_be_inlined() const; diff --git a/src/IRPrinter.cpp b/src/IRPrinter.cpp index c8731f8474f4..824a24424027 100644 --- a/src/IRPrinter.cpp +++ b/src/IRPrinter.cpp @@ -498,6 +498,9 @@ std::ostream &operator<<(std::ostream &out, const DimType &t) { case DimType::PureRVar: out << "PureRVar"; break; + case DimType::InductiveVar: + out << "InductiveVar"; + break; case DimType::ImpureRVar: out << "ImpureRVar"; break; diff --git a/src/Inductive.cpp b/src/Inductive.cpp new file mode 100644 index 000000000000..15e413fd0e48 --- /dev/null +++ b/src/Inductive.cpp @@ -0,0 +1,126 @@ +#include "Inductive.h" + +#include "Bounds.h" +#include "ConciseCasts.h" +#include "Error.h" +#include "Function.h" +#include "IR.h" +#include "IREquality.h" +#include "IRVisitor.h" +#include "Simplify.h" +#include "Substitute.h" + +namespace Halide { +namespace Internal { + +using std::string; +using std::vector; + +class BaseCaseSolver : public IRVisitor { + using IRVisitor::visit; + const vector &vars; + const string &func; + + const vector &start_box; + + vector condition_intervals; + + Scope bounds; + + int nested_select = 0; + + void visit(const Call *op) override { + if (op->is_intrinsic(Call::if_then_else)) { + nested_select += 1; + vector old_intervals = condition_intervals; + for (int i = 0; i < vars.size(); i++) { + condition_intervals[i] = Interval::make_intersection(old_intervals[i], solve_for_outer_interval(simplify(op->args[0]), vars[i])); + bounds.push(vars[i], condition_intervals[i]); + } + + op->args[1].accept(this); + for (int i = 0; i < vars.size(); i++) { + condition_intervals[i] = Interval::make_intersection(old_intervals[i], solve_for_outer_interval(simplify(!op->args[0]), vars[i])); + bounds.pop(vars[i]); + bounds.push(vars[i], condition_intervals[i]); + } + op->args[2].accept(this); + condition_intervals = old_intervals; + for (int i = 0; i < vars.size(); i++) { + bounds.pop(vars[i]); + } + nested_select -= 1; + } else if (op->name == func) { + user_assert(nested_select > 0) << "Function " << func << " contains an inductive function reference outside of a select operation.\n"; + user_assert(nested_select == 1) << "Function " << func << " contains an inductive function reference inside a nested select operation.\n"; + bool found_inductive = false; + for (int position = 0; position < vars.size(); position++) { + const Expr inductive_expr = op->args[position]; + const Expr new_v = Variable::make(inductive_expr.type(), vars[position]); + const Expr gets_lower = simplify(new_v - inductive_expr > 0, true, bounds); + const Interval i_lower = solve_for_inner_interval(gets_lower, vars[position]); + + Interval new_interval; + if (equal(new_v, inductive_expr)) { + new_interval = start_box[position]; + } else if (i_lower.is_everything()) { + found_inductive = true; + new_interval = Interval(Interval::neg_inf(), start_box[position].max); + } else { + new_interval = Interval::everything(); + } + new_interval = Interval::make_intersection(new_interval, condition_intervals[position]); + Scope i_scope; + i_scope.push(vars[position], new_interval); + result_intervals[position] = Interval::make_union(result_intervals[position], Interval::make_union(new_interval, bounds_of_expr_in_scope(inductive_expr, i_scope))); + } + user_assert(found_inductive) << "Unable to prove in inductive function " << func << " that the inductive step is monotonically decreasing.\n"; + + IRVisitor::visit(op); + + } else { + IRVisitor::visit(op); + } + } + +public: + vector result_intervals; + + BaseCaseSolver(const vector &v, const string &func, const vector &con) + : vars(v), func(func), start_box(con) { + condition_intervals = vector(start_box.size()); + result_intervals = vector(start_box.size(), Interval::nothing()); + } +}; + +// anonymous namespace + +const Box expand_to_include_base_case(const vector &vars, const Expr &RHS, const string &func, const Box &box_required) { + Expr substed = substitute_in_all_lets(RHS); + Box box2 = box_required; + BaseCaseSolver b(vars, func, box_required.bounds); + substed.accept(&b); + for (uint i = 0; i < vars.size(); i++) { + user_assert(b.result_intervals[i].is_bounded()) << "Unable to prove that the inductive function " << func << " uses a bounded interval"; + Interval new_interval(min(b.result_intervals[i].min, box_required[i].min), box_required[i].max); + box2[i] = new_interval; + } + + return box2; +} + +const Box expand_to_include_base_case(const Function &fn, const Box &box_required, const int &pos) { + return expand_to_include_base_case(fn.args(), fn.values()[pos], fn.name(), box_required); +} + +const Box expand_to_include_base_case(const Function &fn, const Box &box_required) { + Box b = expand_to_include_base_case(fn.args(), fn.values()[0], fn.name(), box_required); + for (int pos = 1; pos < fn.values().size(); pos++) { + Box b2 = expand_to_include_base_case(fn.args(), fn.values()[pos], fn.name(), box_required); + merge_boxes(b, b2); + } + return b; +} + +} // namespace Internal +} // namespace Halide diff --git a/src/Inductive.h b/src/Inductive.h new file mode 100644 index 000000000000..12ee0143abfc --- /dev/null +++ b/src/Inductive.h @@ -0,0 +1,24 @@ +#ifndef INDUCTIVE_H +#define INDUCTIVE_H + +#include "Bounds.h" +#include "Expr.h" +#include "Interval.h" +#include "Scope.h" +#include "Solve.h" + +namespace Halide { +namespace Internal { + +/** Given an initial box for an inductively defined function, + returns an expanded box that includes the function's non-inductive base case. */ +const Box expand_to_include_base_case(const std::vector &vars, const Expr &RHS, const std::string &func, const Box &box_required); + +const Box expand_to_include_base_case(const Function &fn, const Box &box_required, const int &pos=0); + +const Box expand_to_include_base_case(const Function &fn, const Box &box_required); + +} // namespace Internal +} // namespace Halide + +#endif diff --git a/src/Schedule.h b/src/Schedule.h index a72c52bbd59f..1906e7231ee1 100644 --- a/src/Schedule.h +++ b/src/Schedule.h @@ -363,6 +363,11 @@ enum class DimType { * definitions you can even redundantly re-evaluate points. */ PureVar = 0, + /** The dim originated from a Var in an inductively defined pure + * definition. InductiveVars cannot be reordered, parallelized, + * or vectorized. */ + InductiveVar, + /** The dim originated from an RVar. You can evaluate a Func at * distinct values of this RVar in any order (including in * parallel) over exactly the interval specified in the @@ -473,6 +478,10 @@ struct Dim { return (dim_type == DimType::PureRVar) || (dim_type == DimType::ImpureRVar); } + bool is_inductive() const { + return dim_type == DimType::InductiveVar; + } + /** Could multiple iterations of this loop happen at the same * time, with reads and writes interleaved in arbitrary ways * according to the memory model of the underlying compiler and diff --git a/src/ScheduleFunctions.cpp b/src/ScheduleFunctions.cpp index a0b4a4c18876..5067c96ebdcd 100644 --- a/src/ScheduleFunctions.cpp +++ b/src/ScheduleFunctions.cpp @@ -1335,7 +1335,7 @@ class InjectFunctionRealization : public IRMutator { // none of the functions in a fused group can be inlined, so this will only // happen when we're lowering a single func. if (provide_name != funcs[0].name() && - !funcs[0].is_pure() && + (!funcs[0].is_pure() || funcs[0].is_inductive()) && funcs[0].schedule().compute_level().is_inlined() && function_is_used_in_stmt(funcs[0], provide_op)) { @@ -2300,7 +2300,7 @@ bool validate_schedule(Function f, const Stmt &s, const Target &target, bool is_ // will get lowered into compute_at innermost and thus can be treated // similarly as a non-inlined Func. if (store_at.is_inlined() && compute_at.is_inlined() && hoist_storage_at.is_inlined()) { - if (f.is_pure()) { + if (f.is_pure() && !f.is_inductive()) { validate_schedule_inlined_function(f); } return true; @@ -2567,6 +2567,9 @@ Stmt schedule_functions(const vector &outputs, const map &env, const Target &target, bool &any_memoized) { + for (const Function &o : outputs) { + user_assert(!o.is_inductive()) << "Function" << o.name() << " is an inductively defined output buffer, which is unsupported.\n"; + } string root_var = LoopLevel::root().lock().to_string(); Stmt s = For::make(root_var, 0, 0, ForType::Serial, Partition::Never, DeviceAPI::Host, Evaluate::make(0)); diff --git a/test/correctness/CMakeLists.txt b/test/correctness/CMakeLists.txt index 66e57183ad63..4690a75723ef 100644 --- a/test/correctness/CMakeLists.txt +++ b/test/correctness/CMakeLists.txt @@ -185,6 +185,7 @@ tests( implicit_pure_def_with_rvar_args.cpp in_place.cpp indexing_access_undef.cpp + inductive.cpp infer_arguments.cpp inline_reduction.cpp inlined_generator.cpp diff --git a/test/correctness/inductive.cpp b/test/correctness/inductive.cpp new file mode 100644 index 000000000000..f95761e812ae --- /dev/null +++ b/test/correctness/inductive.cpp @@ -0,0 +1,243 @@ +#include "Halide.h" +#include "check_call_graphs.h" +#include "test_sharding.h" + +#include +#include + +namespace { + +using std::map; +using std::string; + +using namespace Halide; +using namespace Halide::Internal; + +int simple_inductive_test() { + Func g("g"), h("h"); + Var x("x"), y("y"); + + // g(x, y) = x + y; + // g(r.x, r.y) = g(r.x, r.y); + g(x, y) = select(x <= 0, 0, g(max(0, x - 1), y) + x + y); + + h(x, y) = g(x + 5, y) / 4; + + g.compute_at(h, x).store_at(h, y); + + Buffer im = h.realize({600, 5}); + auto func = [](int x, int y) { + return (y * (x + 5) + (x + 5) * (x + 6) / 2) / 4; + }; + if (check_image(im, func)) { + return 1; + } + return 0; +} + +int reorder_test() { + Func g("g"), h("h"); + Var x("x"), y("y"); + + Var xi("xi"), xii("xii"), xo("xo"); + + // g(x, y) = x + y; + // g(r.x, r.y) = g(r.x, r.y); + g(x, y) = select(x <= 0, 0, g(max(0, x - 1), y) + x + y); + + h(x, y) = g(x + 5, y) / 4; + h.split(x, xo, xi, 24).reorder(xi, y, xo); + + g.compute_at(h, xo).store_root(); + + g.split(x, xi, xii, 5).reorder(xii, y, xi).vectorize(y, 8); + + Buffer im = h.realize({80, 80}); + auto func = [](int x, int y) { + return (y * (x + 5) + (x + 5) * (x + 6) / 2) / 4; + }; + if (check_image(im, func)) { + return 1; + } + return 0; +} + +int summed_area_table() { + Func f("f"), g("g"), h("h"); + Var x("x"), y("y"); + f(x, y) = x + y; + g(x, y) = f(x, y) + select(x <= 0, 0, g(x - 1, y)) + select(y <= 0, 0, g(x, y - 1)) - select(x <= 0 || y <= 0, 0, g(x - 1, y - 1)); + h(x, y) = g(x, y) / 8; + g.compute_at(h, x).store_root(); + + Buffer im = h.realize({80, 80}); + auto func = [](int x, int y) { + return (x * (x + 1) / 2 * (y + 1) + y * (y + 1) / 2 * (x + 1)) / 8; + }; + if (check_image(im, func)) { + return 1; + } + return 0; +} + +int large_baseline() { + Func g("g"), h("h"); + Var x("x"), y("y"); + + // g(x, y) = x + y; + // g(r.x, r.y) = g(r.x, r.y); + g(x, y) = select(x <= 8, (y * x + x * (x + 1) / 2) - 1, g(x - 1, y) + x + y); + + h(x, y) = g(x + 5, y) / 4; + + g.compute_at(h, x).store_at(h, y); + + Buffer im = h.realize({80, 80}); + auto func = [](int x, int y) { + return (y * (x + 5) + (x + 5) * (x + 6) / 2 - 1) / 4; + }; + if (check_image(im, func)) { + return 1; + } + return 0; +} + +int fibonacci() { + Func g("g"), h("h"); + Var x("x"), y("y"); + + // g(x, y) = x + y; + // g(r.x, r.y) = g(r.x, r.y); + g(x, y) = select(x <= 1, 1, g(x - 1, y) + g(x - 2, y)); + h(x, y) = g(x, y); + + h.bound(x, 0, 80); + Buffer im = h.realize({80, 80}); + auto func = [](int x, int y) { + int a = 1; + int b = 1; + for (int i = 2; i <= x; i++) { + int c = a + b; + b = a; + a = c; + } + return a; + }; + if (check_image(im, func)) { + return 1; + } + return 0; +} + +int sum_2d_test() { + Func f("f"), g("g"), h("h"); + Var x("x"), y("y"); + f(x, y) = select(x <= 0, 0, x + f(x - 1, y)); + g(x, y) = select(y <= 0, f(x, 0), f(x, y) + g(x, y - 1)); + h(x, y) = g(x, y); + h.bound(x, 0, 80).bound(y, 0, 80).vectorize(x, 8); + g.compute_at(h, x).store_root().vectorize(x, 8); + f.compute_at(h, x).store_root(); + Buffer im = h.realize({80, 80}); + auto func = [](int x, int y) { + int ans = 0; + for (int a = 0; a <= x; a++) { + for (int b = 0; b <= y; b++) { + ans += a; + } + } + return ans; + }; + if (check_image(im, func)) { + return 1; + } + return 0; +} + +int sum_1d_test() { + Func f("f"), g("g"), h("h"); + Var x("x"), y("y"); + f(x, y) = x + y; + f(x, y) += x; // select(x<=0, 0, x+f(x-1,y)); + g(x, y) = select(y <= 0, f(x, 0), f(x, y) + g(x, y - 1)); + h(x, y) = g(x, y); + h.bound(x, 0, 80).bound(y, 0, 80); + // stress-testing bounds inference for dependent non-inlined funcs + f.compute_at(h, x); + Buffer im = h.realize({80, 80}); + auto func = [](int x, int y) { + int ans = 0; + for (int a = 0; a <= y; a++) { + ans += 2 * x + a; + } + return ans; + }; + if (check_image(im, func)) { + return 1; + } + return 0; +} + +int multi_baseline_test() { + Func f("f"), g("g"), h("h"); + Var x("x"), y("y"); + f(x, y) = x + y; + f(x, y) += x; // select(x<=0, 0, x+f(x-1,y)); + g(x, y) = select(y <= 0, f(x, 0), f(x, y) + g(x, y - 1)) + select(y <= 3, f(x, 0), f(x, y) + g(x, y - 1)); + h(x, y) = g(x, y); + h.bound(x, 0, 80).bound(y, 0, 20); + f.compute_at(h, x); + Buffer im = h.realize({80, 20}); + auto func = [](int x, int y) { + std::vector ans; + + for (int a = 0; a <= y; a++) { + int b = 2 * x + a; + if (a <= 0) { + ans.emplace_back(4 * x); + } else if (a <= 3) { + ans.emplace_back(2 * x + (2 * x + a) + ans[a - 1]); + } else { + ans.emplace_back(2 * x + a + ans[a - 1] + (2 * x + a) + ans[a - 1]); + } + } + return ans[y]; + }; + if (check_image(im, func)) { + return 1; + } + return 0; +} + +} // namespace + +int main(int argc, char **argv) { + struct Task { + std::string desc; + std::function fn; + }; + + std::vector tasks = { + {"simple inductive test", simple_inductive_test}, + {"reordering test", reorder_test}, + {"summed area table test", summed_area_table}, + {"large baseline test", large_baseline}, + {"fibonacci test", fibonacci}, + {"2d sum test", sum_2d_test}, + {"1d sum test", sum_1d_test}, + {"multi-baseline tset", multi_baseline_test}}; + + using Sharder = Halide::Internal::Test::Sharder; + Sharder sharder; + for (size_t t = 0; t < tasks.size(); t++) { + if (!sharder.should_run(t)) continue; + const auto &task = tasks.at(t); + std::cout << task.desc << "\n"; + if (task.fn() != 0) { + return 1; + } + } + + printf("Success!\n"); + return 0; +} diff --git a/test/error/CMakeLists.txt b/test/error/CMakeLists.txt index 79c5bff5063e..d20fae300bf1 100644 --- a/test/error/CMakeLists.txt +++ b/test/error/CMakeLists.txt @@ -74,6 +74,13 @@ tests( implicit_args.cpp impossible_constraints.cpp incomplete_target.cpp + inductive_loop.cpp + inductive_loop_2.cpp + inductive_loop_3.cpp + inductive_nested_select.cpp + inductive_no_select.cpp + inductive_reorder.cpp + inductive_var_swap.cpp init_def_should_be_all_vars.cpp input_buffer_func_name_collision.cpp input_generator_buffer_func_name_collision.cpp diff --git a/test/error/inductive_loop.cpp b/test/error/inductive_loop.cpp new file mode 100644 index 000000000000..cb894256a355 --- /dev/null +++ b/test/error/inductive_loop.cpp @@ -0,0 +1,18 @@ +#include "Halide.h" +#include + +using namespace Halide; + +int main(int argc, char **argv) { + Func f("f"), g("g"); + + Var x("x"); + + f(x) = select(x < 1, 0, f(x)); + g(x) = f(x) * 2; + + g.realize({10}); + + printf("Success!\n"); + return 0; +} diff --git a/test/error/inductive_loop_2.cpp b/test/error/inductive_loop_2.cpp new file mode 100644 index 000000000000..f6086e239eef --- /dev/null +++ b/test/error/inductive_loop_2.cpp @@ -0,0 +1,18 @@ +#include "Halide.h" +#include + +using namespace Halide; + +int main(int argc, char **argv) { + Func f("f"), g("g"); + + Var x("x"); + + f(x) = select(x < 2, 0, f(x - 1) + f(x) + f(x - 2)); + g(x) = f(x) * 2; + + g.realize({10}); + + printf("Success!\n"); + return 0; +} diff --git a/test/error/inductive_loop_3.cpp b/test/error/inductive_loop_3.cpp new file mode 100644 index 000000000000..c281480d5fa7 --- /dev/null +++ b/test/error/inductive_loop_3.cpp @@ -0,0 +1,18 @@ +#include "Halide.h" +#include + +using namespace Halide; + +int main(int argc, char **argv) { + Func f("f"), g("g"); + + Var x("x"); + + f(x) = select(x < 2, 0, f(x - 1) + f(min(2, x)) + f(x - 2)); + g(x) = f(x) * 2; + + g.realize({10}); + + printf("Success!\n"); + return 0; +} diff --git a/test/error/inductive_nested_select.cpp b/test/error/inductive_nested_select.cpp new file mode 100644 index 000000000000..c9abf663008f --- /dev/null +++ b/test/error/inductive_nested_select.cpp @@ -0,0 +1,19 @@ +#include "Halide.h" +#include + +using namespace Halide; + +int main(int argc, char **argv) { + Func f("f"), g("g"); + + Var x("x"); + + // Nested select operations are currently unsupported. + f(x) = select(x < 1, 0, select(x < 3, 1, f(x - 1))); + g(x) = f(x) * 2; + + g.realize({10}); + + printf("Success!\n"); + return 0; +} diff --git a/test/error/inductive_no_select.cpp b/test/error/inductive_no_select.cpp new file mode 100644 index 000000000000..d8d395be9e03 --- /dev/null +++ b/test/error/inductive_no_select.cpp @@ -0,0 +1,19 @@ +#include "Halide.h" +#include + +using namespace Halide; + +int main(int argc, char **argv) { + Func f("f"), g("g"); + + Var x("x"); + + f(x) = x + f(x - 1); + + g(x) = f(x) * 2; + + g.realize({10}); + + printf("Success!\n"); + return 0; +} diff --git a/test/error/inductive_reorder.cpp b/test/error/inductive_reorder.cpp new file mode 100644 index 000000000000..01dbe642645b --- /dev/null +++ b/test/error/inductive_reorder.cpp @@ -0,0 +1,21 @@ +#include "Halide.h" +#include + +using namespace Halide; + +int main(int argc, char **argv) { + Func f("f"), g("g"); + + Var x("x"), xi("xi"), xo("xo"); + + f(x) = select(x < 1, 0, x + f(x - 1)); + f.split(x, xo, xi, 8); + f.reorder(xo, xi); + + g(x) = f(x) * 2; + + g.realize({10}); + + printf("Success!\n"); + return 0; +} diff --git a/test/error/inductive_var_swap.cpp b/test/error/inductive_var_swap.cpp new file mode 100644 index 000000000000..4a8453eb0901 --- /dev/null +++ b/test/error/inductive_var_swap.cpp @@ -0,0 +1,19 @@ +#include "Halide.h" +#include + +using namespace Halide; + +int main(int argc, char **argv) { + Func f("f"), g("g"); + + Var x("x"), y("y"); + + f(x, y) = select(x < 1, 0, x + f(y - 1, x - 1)); + + g(x, y) = f(x, y) * 2; + + g.realize({10, 10}); + + printf("Success!\n"); + return 0; +} diff --git a/test/error/inductive_vectorize.cpp b/test/error/inductive_vectorize.cpp new file mode 100644 index 000000000000..bc6dd1e4bc95 --- /dev/null +++ b/test/error/inductive_vectorize.cpp @@ -0,0 +1,20 @@ +#include "Halide.h" +#include + +using namespace Halide; + +int main(int argc, char **argv) { + Func f("f"), g("g"); + + Var x("x"); + + f(x) = select(x < 1, 0, x + f(x - 1)); + f.vectorize(x, 8); + + g(x) = f(x) * 2; + + g.realize({10}); + + printf("Success!\n"); + return 0; +} From 795d58047a1e34ba8fa0c1b5d35266154ab68200 Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Fri, 21 Nov 2025 00:02:44 -0500 Subject: [PATCH 03/42] fixes --- src/Func.cpp | 4 ++-- test/error/inductive_no_select.cpp | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/Func.cpp b/src/Func.cpp index 0510bcfce400..eba435d509cf 100644 --- a/src/Func.cpp +++ b/src/Func.cpp @@ -492,7 +492,7 @@ void Stage::set_dim_type(const VarOrRVar &var, ForType t) { // If it's an rvar and the for type is parallel, we need to // validate that this doesn't introduce a race condition, // unless it is flagged explicitly or is a associative atomic operation. - if (!dim.is_pure() && var.is_rvar && is_parallel(t)) { + if (!dim.is_pure() && (var.is_rvar || dim.is_inductive()) && is_parallel(t)) { if (!definition.schedule().allow_race_conditions() && definition.schedule().atomic()) { if (!definition.schedule().override_atomic_associativity_test()) { @@ -3398,7 +3398,7 @@ FuncRef::operator Expr() const { if (!(func.has_pure_definition() || func.has_extern_definition())) { return Call::make(Type{}, func.name(), args, Call::Halide, - FunctionPtr(), 0, Buffer<>(), Parameter()); + func.get_contents(), 0, Buffer<>(), Parameter()); } user_assert(func.outputs() == 1) diff --git a/test/error/inductive_no_select.cpp b/test/error/inductive_no_select.cpp index d8d395be9e03..5fdc3f430232 100644 --- a/test/error/inductive_no_select.cpp +++ b/test/error/inductive_no_select.cpp @@ -8,7 +8,7 @@ int main(int argc, char **argv) { Var x("x"); - f(x) = x + f(x - 1); + f(x) = cast(x + f(x - 1)); g(x) = f(x) * 2; From 99a1f089af04135a457bdb8e9dde5ef03eaf2ee0 Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Sat, 22 Nov 2025 01:44:51 -0500 Subject: [PATCH 04/42] rebase additional fixes --- src/Function.cpp | 2 +- src/Inductive.cpp | 10 +++++----- src/Type.h | 2 +- test/correctness/inductive.cpp | 1 - 4 files changed, 7 insertions(+), 8 deletions(-) diff --git a/src/Function.cpp b/src/Function.cpp index a26939c543f9..f8a8da49eac3 100644 --- a/src/Function.cpp +++ b/src/Function.cpp @@ -1134,7 +1134,7 @@ bool Function::is_inductive(const string &var) const { } int pos = -1; - for (int i = 0; i < definition().args().size(); i++) { + for (size_t i = 0; i < definition().args().size(); i++) { if (const auto &v = definition().args()[i].as()) { if (v->name == var) { pos = i; diff --git a/src/Inductive.cpp b/src/Inductive.cpp index 15e413fd0e48..56ac4f9aa1ae 100644 --- a/src/Inductive.cpp +++ b/src/Inductive.cpp @@ -33,20 +33,20 @@ class BaseCaseSolver : public IRVisitor { if (op->is_intrinsic(Call::if_then_else)) { nested_select += 1; vector old_intervals = condition_intervals; - for (int i = 0; i < vars.size(); i++) { + for (size_t i = 0; i < vars.size(); i++) { condition_intervals[i] = Interval::make_intersection(old_intervals[i], solve_for_outer_interval(simplify(op->args[0]), vars[i])); bounds.push(vars[i], condition_intervals[i]); } op->args[1].accept(this); - for (int i = 0; i < vars.size(); i++) { + for (size_t i = 0; i < vars.size(); i++) { condition_intervals[i] = Interval::make_intersection(old_intervals[i], solve_for_outer_interval(simplify(!op->args[0]), vars[i])); bounds.pop(vars[i]); bounds.push(vars[i], condition_intervals[i]); } op->args[2].accept(this); condition_intervals = old_intervals; - for (int i = 0; i < vars.size(); i++) { + for (size_t i = 0; i < vars.size(); i++) { bounds.pop(vars[i]); } nested_select -= 1; @@ -54,7 +54,7 @@ class BaseCaseSolver : public IRVisitor { user_assert(nested_select > 0) << "Function " << func << " contains an inductive function reference outside of a select operation.\n"; user_assert(nested_select == 1) << "Function " << func << " contains an inductive function reference inside a nested select operation.\n"; bool found_inductive = false; - for (int position = 0; position < vars.size(); position++) { + for (size_t position = 0; position < vars.size(); position++) { const Expr inductive_expr = op->args[position]; const Expr new_v = Variable::make(inductive_expr.type(), vars[position]); const Expr gets_lower = simplify(new_v - inductive_expr > 0, true, bounds); @@ -100,7 +100,7 @@ const Box expand_to_include_base_case(const vector &vars, const Expr &RH Box box2 = box_required; BaseCaseSolver b(vars, func, box_required.bounds); substed.accept(&b); - for (uint i = 0; i < vars.size(); i++) { + for (size_t i = 0; i < vars.size(); i++) { user_assert(b.result_intervals[i].is_bounded()) << "Unable to prove that the inductive function " << func << " uses a bounded interval"; Interval new_interval(min(b.result_intervals[i].min, box_required[i].min), box_required[i].max); box2[i] = new_interval; diff --git a/src/Type.h b/src/Type.h index 03880cedc3dd..19251940e29e 100644 --- a/src/Type.h +++ b/src/Type.h @@ -301,7 +301,7 @@ struct Type { // Default ctor initializes everything to predictable-but-unlikely values Type() - : type(Unknown, 0, 1) { + : type(Unknown, 0, 0) { } /** Construct a runtime representation of a Halide type from: diff --git a/test/correctness/inductive.cpp b/test/correctness/inductive.cpp index f95761e812ae..29b4719dbe8b 100644 --- a/test/correctness/inductive.cpp +++ b/test/correctness/inductive.cpp @@ -192,7 +192,6 @@ int multi_baseline_test() { std::vector ans; for (int a = 0; a <= y; a++) { - int b = 2 * x + a; if (a <= 0) { ans.emplace_back(4 * x); } else if (a <= 3) { From 5124b2e5bbf28d777ac713992ebc6a1423121b69 Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Sat, 22 Nov 2025 01:49:58 -0500 Subject: [PATCH 05/42] size_t fix --- src/Inductive.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Inductive.cpp b/src/Inductive.cpp index 56ac4f9aa1ae..332d38f341e6 100644 --- a/src/Inductive.cpp +++ b/src/Inductive.cpp @@ -115,7 +115,7 @@ const Box expand_to_include_base_case(const Function &fn, const Box &box_require const Box expand_to_include_base_case(const Function &fn, const Box &box_required) { Box b = expand_to_include_base_case(fn.args(), fn.values()[0], fn.name(), box_required); - for (int pos = 1; pos < fn.values().size(); pos++) { + for (size_t pos = 1; pos < fn.values().size(); pos++) { Box b2 = expand_to_include_base_case(fn.args(), fn.values()[pos], fn.name(), box_required); merge_boxes(b, b2); } From 8b2e23993b27564989233b0e512c6c2db5fb1e16 Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Sat, 22 Nov 2025 20:01:07 -0500 Subject: [PATCH 06/42] get default types back to normal; add new test --- python_bindings/test/correctness/basics.py | 9 -------- src/Func.cpp | 6 +++++- src/IROperator.cpp | 4 ++-- src/Type.h | 4 ++-- test/correctness/inductive.cpp | 25 +++++++++++++++++++++- test/correctness/tracing.cpp | 4 ++++ 6 files changed, 37 insertions(+), 15 deletions(-) diff --git a/python_bindings/test/correctness/basics.py b/python_bindings/test/correctness/basics.py index 15bc76087e77..886a8e786eba 100644 --- a/python_bindings/test/correctness/basics.py +++ b/python_bindings/test/correctness/basics.py @@ -500,15 +500,6 @@ def test_unevaluated_funcref(): f[x] += 1 assert f.realize([1])[0] == 1 - with assert_throws( - hl.HalideError, - r"Error: Can't call Func \"f(\$\d+)?\" because it has not yet been defined\.", - ): - # This is invalid because we only allow unevaluated func refs on the LHS of a - # binary operator. - f = hl.Func("f") - f[x] = 1 + f[x] - with assert_throws( hl.HalideError, r"Cannot use an unevaluated reference to 'f(\$\d+)?' to define an update at a different location\.", diff --git a/src/Func.cpp b/src/Func.cpp index eba435d509cf..192bdfe00c08 100644 --- a/src/Func.cpp +++ b/src/Func.cpp @@ -3397,7 +3397,11 @@ FuncRef::operator Expr() const { */ if (!(func.has_pure_definition() || func.has_extern_definition())) { - return Call::make(Type{}, func.name(), args, Call::Halide, + Type t = Type(Type::Unknown, 0, 1); + if (!func.required_types().empty()) { + t = func.required_types()[0]; + } + return Call::make(t, func.name(), args, Call::Halide, func.get_contents(), 0, Buffer<>(), Parameter()); } diff --git a/src/IROperator.cpp b/src/IROperator.cpp index e202ab025516..6d33e6db687c 100644 --- a/src/IROperator.cpp +++ b/src/IROperator.cpp @@ -690,12 +690,12 @@ void match_types(Expr &a, Expr &b) { } if (a.type().is_unknown() && !b.type().is_unknown()) { - b = cast(Type{}, b); + b = cast(a.type(), b); return; } if (b.type().is_unknown() && !a.type().is_unknown()) { - a = cast(Type{}, a); + a = cast(b.type(), a); return; } diff --git a/src/Type.h b/src/Type.h index 19251940e29e..4937ea528d2f 100644 --- a/src/Type.h +++ b/src/Type.h @@ -301,7 +301,7 @@ struct Type { // Default ctor initializes everything to predictable-but-unlikely values Type() - : type(Unknown, 0, 0) { + : type(Handle, 0, 0) { } /** Construct a runtime representation of a Halide type from: @@ -574,7 +574,7 @@ inline Type Handle(int lanes = 1, const halide_handle_cplusplus_type *handle_typ /** Construct an unknown type */ inline Type Unknown() { - return Type{}; + return Type(Type::Unknown, 0, 1); } /** Construct the halide equivalent of a C type */ diff --git a/test/correctness/inductive.cpp b/test/correctness/inductive.cpp index 29b4719dbe8b..e10646bc91cb 100644 --- a/test/correctness/inductive.cpp +++ b/test/correctness/inductive.cpp @@ -208,6 +208,27 @@ int multi_baseline_test() { return 0; } +int type_declare_test() { + Func g = Func(Int(32), AnyDims, "g"); + Func h("h"); + Var x("x"), y("y"); + + g(x, y) = select(x <= 0, 0, 1 + g(max(0, x - 1), y) + x + 2); + + h(x, y) = g(x + 5, y) / 4; + + g.compute_at(h, x).store_at(h, y); + + Buffer im = h.realize({600, 5}); + auto func = [](int x, int y) { + return (3 * (x + 5) + (x + 5) * (x + 6) / 2) / 4; + }; + if (check_image(im, func)) { + return 1; + } + return 0; +} + } // namespace int main(int argc, char **argv) { @@ -224,7 +245,9 @@ int main(int argc, char **argv) { {"fibonacci test", fibonacci}, {"2d sum test", sum_2d_test}, {"1d sum test", sum_1d_test}, - {"multi-baseline tset", multi_baseline_test}}; + {"multi-baseline test", multi_baseline_test}, + {"type declaration test", type_declare_test}, + }; using Sharder = Halide::Internal::Test::Sharder; Sharder sharder; diff --git a/test/correctness/tracing.cpp b/test/correctness/tracing.cpp index 02d5d94d70e6..2c548fd03562 100644 --- a/test/correctness/tracing.cpp +++ b/test/correctness/tracing.cpp @@ -217,7 +217,11 @@ int main(int argc, char **argv) { f.realize({10}, get_jit_target_from_environment().with_feature(Target::TracePipeline)); // The golden trace, recorded when this test was written +<<<<<<< HEAD static event correct_pipeline_trace[] = { +======= + event correct_pipeline_trace[] = { +>>>>>>> 2197d3da2 (get default types back to normal; add new test) {102, 0, 8, 3, 0, 0, 0, 0, {0, 0, 0, 0}, {0.000000f, 0.000000f, 0.000000f, 0.000000f}, ""}, {102, 1, 9, 3, 0, 0, 0, 0, {0, 0, 0, 0}, {0.000000f, 0.000000f, 0.000000f, 0.000000f}, ""}, }; From 2ca58c15a05a707b5ecc2975c4e3e50a86605d93 Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Sat, 22 Nov 2025 20:12:53 -0500 Subject: [PATCH 07/42] clang-format --- src/Inductive.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/Inductive.h b/src/Inductive.h index 12ee0143abfc..09ba5c491430 100644 --- a/src/Inductive.h +++ b/src/Inductive.h @@ -10,15 +10,15 @@ namespace Halide { namespace Internal { -/** Given an initial box for an inductively defined function, +/** Given an initial box for an inductively defined function, returns an expanded box that includes the function's non-inductive base case. */ const Box expand_to_include_base_case(const std::vector &vars, const Expr &RHS, const std::string &func, const Box &box_required); -const Box expand_to_include_base_case(const Function &fn, const Box &box_required, const int &pos=0); +const Box expand_to_include_base_case(const Function &fn, const Box &box_required, const int &pos = 0); const Box expand_to_include_base_case(const Function &fn, const Box &box_required); -} // namespace Internal -} // namespace Halide +} // namespace Internal +} // namespace Halide #endif From 2bdd6ff1e08d7e1d2b38f45802d5c42d94bed157 Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Sun, 23 Nov 2025 01:01:26 -0500 Subject: [PATCH 08/42] add test and documentation --- src/Function.cpp | 5 ++++- src/Inductive.h | 31 +++++++++++++++++++++++++++++-- test/error/CMakeLists.txt | 2 ++ test/error/inductive_update.cpp | 20 ++++++++++++++++++++ 4 files changed, 55 insertions(+), 3 deletions(-) create mode 100644 test/error/inductive_update.cpp diff --git a/src/Function.cpp b/src/Function.cpp index f8a8da49eac3..b206d5620140 100644 --- a/src/Function.cpp +++ b/src/Function.cpp @@ -694,7 +694,10 @@ void Function::define_update(const vector &_args, vector values, con user_assert(!frozen()) << "Func " << name() << " cannot be given a new update definition, " << "because it has already been realized or used in the definition of another Func.\n"; - + user_assert(!is_inductive()) + << "In update definition " << update_idx << " of Func \"" << name() << "\":\n" + << "Inductive functions cannot have update definitions.\n"; + for (auto &value : values) { user_assert(value.defined()) << "In update definition " << update_idx << " of Func \"" << name() << "\":\n" diff --git a/src/Inductive.h b/src/Inductive.h index 09ba5c491430..707a7fc8a2ac 100644 --- a/src/Inductive.h +++ b/src/Inductive.h @@ -1,6 +1,35 @@ #ifndef INDUCTIVE_H #define INDUCTIVE_H +/** \file + * + * Utilities for processing inductively defined functions. + * + * A simple example of an inductively defined function is + * f(x) = select(x <= 0, input(0), input(x) + f(x - 1)); + * The purpose of inductive functions is to allow execution patterns that are + * impossible with reduction domains. For example, in the following code: + * + * f(x) = select(x <= 0, input(0), input(x) + f(x - 1)); + * g(x) = f(x) / 4; + * f.compute_at(g, x).store_root(); + * + * The resulting program computes a single value of f(x) at each value of g(x), + * thanks to Halide's sliding window optimization. As a result of storage folding, + * only the two most recent values of f(x) are stored at any given time. This is + * impossible if f(x) is defined using a reduction domain, since every value of f(x) + * must be computed and stored before g(x) is computed. + * + * If Halide is unable to perform the sliding window optimization, computing the + * inductive function is generally inefficient. + * + * In inductive functions, any recursive references must be inside a select statement, + * and cannot be inside nested select statements. The inductive arguments in the + * recursive reference must be monotonically decreasing. Currently, only single-valued + * functions are supported. Inductive functions cannot be inlined, and cannot have + * update definitions. + */ + #include "Bounds.h" #include "Expr.h" #include "Interval.h" @@ -13,9 +42,7 @@ namespace Internal { /** Given an initial box for an inductively defined function, returns an expanded box that includes the function's non-inductive base case. */ const Box expand_to_include_base_case(const std::vector &vars, const Expr &RHS, const std::string &func, const Box &box_required); - const Box expand_to_include_base_case(const Function &fn, const Box &box_required, const int &pos = 0); - const Box expand_to_include_base_case(const Function &fn, const Box &box_required); } // namespace Internal diff --git a/test/error/CMakeLists.txt b/test/error/CMakeLists.txt index d20fae300bf1..2e1c748ad571 100644 --- a/test/error/CMakeLists.txt +++ b/test/error/CMakeLists.txt @@ -80,7 +80,9 @@ tests( inductive_nested_select.cpp inductive_no_select.cpp inductive_reorder.cpp + inductive_update.cpp inductive_var_swap.cpp + inductive_vectorize.cpp init_def_should_be_all_vars.cpp input_buffer_func_name_collision.cpp input_generator_buffer_func_name_collision.cpp diff --git a/test/error/inductive_update.cpp b/test/error/inductive_update.cpp new file mode 100644 index 000000000000..acb16183f552 --- /dev/null +++ b/test/error/inductive_update.cpp @@ -0,0 +1,20 @@ +#include "Halide.h" +#include + +using namespace Halide; + +int main(int argc, char **argv) { + Func f("f"), g("g"); + + Var x("x"); + + f(x) = select(x < 1, 0, x + f(x - 1)); + f(x) += 1; + + g(x) = f(x) * 2; + + g.realize({10}); + + printf("Success!\n"); + return 0; +} \ No newline at end of file From 657b90bb88216a48bc07e80d3ef221c2e167c603 Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Sun, 23 Nov 2025 19:30:14 -0500 Subject: [PATCH 09/42] add user error and additional support for function declarations --- src/Func.cpp | 4 ++++ src/Func.h | 4 ++++ src/IROperator.cpp | 5 +++++ src/Inductive.h | 8 ++++++++ test/correctness/inductive.cpp | 2 +- 5 files changed, 22 insertions(+), 1 deletion(-) diff --git a/src/Func.cpp b/src/Func.cpp index 192bdfe00c08..bd7d311a7684 100644 --- a/src/Func.cpp +++ b/src/Func.cpp @@ -67,6 +67,10 @@ Func::Func(const string &name) : func(unique_name(name)) { } +Func::Func(const Type &required_type, const string &name) + : func({required_type}, AnyDims, unique_name(name)) { +} + Func::Func(const Type &required_type, int required_dims, const string &name) : func({required_type}, required_dims, unique_name(name)) { } diff --git a/src/Func.h b/src/Func.h index 0bfb591871c7..cc023936a907 100644 --- a/src/Func.h +++ b/src/Func.h @@ -756,6 +756,10 @@ class Func { /** Declare a new undefined function with the given name */ explicit Func(const std::string &name); + /** Declare a new undefined function with the given name. + * The function will be constrained to represent Exprs of required_type. */ + explicit Func(const Type &required_type, const std::string &name); + /** Declare a new undefined function with the given name. * The function will be constrained to represent Exprs of required_type. * If required_dims is not AnyDims, the function will be constrained to exactly diff --git a/src/IROperator.cpp b/src/IROperator.cpp index 6d33e6db687c..9f75e95284f4 100644 --- a/src/IROperator.cpp +++ b/src/IROperator.cpp @@ -370,6 +370,11 @@ Expr make_const_helper(Type t, T val) { return UIntImm::make(t, (uint64_t)val); } else if (t.is_float()) { return FloatImm::make(t, (double)val); + } else if(t.is_unknown()){ + user_error << "Can't make a constant of unknown type.\n" + << "This is likely caused by a failure of type inference inside an inductive function definition.\n" + << "If you are trying to create an inductive function, you must define its type explicitly.\n"; + return Expr(); } else { internal_error << "Can't make a constant of type " << t << "\n"; return Expr(); diff --git a/src/Inductive.h b/src/Inductive.h index 707a7fc8a2ac..33598de38b60 100644 --- a/src/Inductive.h +++ b/src/Inductive.h @@ -28,6 +28,14 @@ * recursive reference must be monotonically decreasing. Currently, only single-valued * functions are supported. Inductive functions cannot be inlined, and cannot have * update definitions. + * + * In some cases, the inductive function's type cannot be inferred and must be declared + * explicitly. This occurs when constants appear in operations with a recursive reference. + * For example, in the following code, Halide cannot infer the type of f: + * f(x) = select(x <= 0, 0, f(x - 1) + 1); + * + * To fix this, declare f with an explicit type: + * Func f = Func(Int(32), "f"); */ #include "Bounds.h" diff --git a/test/correctness/inductive.cpp b/test/correctness/inductive.cpp index e10646bc91cb..23c3ab568544 100644 --- a/test/correctness/inductive.cpp +++ b/test/correctness/inductive.cpp @@ -209,7 +209,7 @@ int multi_baseline_test() { } int type_declare_test() { - Func g = Func(Int(32), AnyDims, "g"); + Func g = Func(Int(32), "g"); Func h("h"); Var x("x"), y("y"); From ddd2bb765718ff29e4e98f7b408605531407dc09 Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Sun, 23 Nov 2025 19:31:50 -0500 Subject: [PATCH 10/42] clang-format --- src/Func.cpp | 2 +- src/Function.cpp | 2 +- src/IROperator.cpp | 2 +- src/Inductive.h | 26 +++++++++++++------------- 4 files changed, 16 insertions(+), 16 deletions(-) diff --git a/src/Func.cpp b/src/Func.cpp index bd7d311a7684..56c3bc9eea53 100644 --- a/src/Func.cpp +++ b/src/Func.cpp @@ -67,7 +67,7 @@ Func::Func(const string &name) : func(unique_name(name)) { } -Func::Func(const Type &required_type, const string &name) +Func::Func(const Type &required_type, const string &name) : func({required_type}, AnyDims, unique_name(name)) { } diff --git a/src/Function.cpp b/src/Function.cpp index b206d5620140..b4d9d79a25bb 100644 --- a/src/Function.cpp +++ b/src/Function.cpp @@ -697,7 +697,7 @@ void Function::define_update(const vector &_args, vector values, con user_assert(!is_inductive()) << "In update definition " << update_idx << " of Func \"" << name() << "\":\n" << "Inductive functions cannot have update definitions.\n"; - + for (auto &value : values) { user_assert(value.defined()) << "In update definition " << update_idx << " of Func \"" << name() << "\":\n" diff --git a/src/IROperator.cpp b/src/IROperator.cpp index 9f75e95284f4..380fec073b04 100644 --- a/src/IROperator.cpp +++ b/src/IROperator.cpp @@ -370,7 +370,7 @@ Expr make_const_helper(Type t, T val) { return UIntImm::make(t, (uint64_t)val); } else if (t.is_float()) { return FloatImm::make(t, (double)val); - } else if(t.is_unknown()){ + } else if (t.is_unknown()) { user_error << "Can't make a constant of unknown type.\n" << "This is likely caused by a failure of type inference inside an inductive function definition.\n" << "If you are trying to create an inductive function, you must define its type explicitly.\n"; diff --git a/src/Inductive.h b/src/Inductive.h index 33598de38b60..f0053c08b257 100644 --- a/src/Inductive.h +++ b/src/Inductive.h @@ -4,33 +4,33 @@ /** \file * * Utilities for processing inductively defined functions. - * - * A simple example of an inductively defined function is + * + * A simple example of an inductively defined function is * f(x) = select(x <= 0, input(0), input(x) + f(x - 1)); - * The purpose of inductive functions is to allow execution patterns that are + * The purpose of inductive functions is to allow execution patterns that are * impossible with reduction domains. For example, in the following code: * * f(x) = select(x <= 0, input(0), input(x) + f(x - 1)); * g(x) = f(x) / 4; * f.compute_at(g, x).store_root(); * - * The resulting program computes a single value of f(x) at each value of g(x), - * thanks to Halide's sliding window optimization. As a result of storage folding, - * only the two most recent values of f(x) are stored at any given time. This is - * impossible if f(x) is defined using a reduction domain, since every value of f(x) + * The resulting program computes a single value of f(x) at each value of g(x), + * thanks to Halide's sliding window optimization. As a result of storage folding, + * only the two most recent values of f(x) are stored at any given time. This is + * impossible if f(x) is defined using a reduction domain, since every value of f(x) * must be computed and stored before g(x) is computed. * - * If Halide is unable to perform the sliding window optimization, computing the + * If Halide is unable to perform the sliding window optimization, computing the * inductive function is generally inefficient. * - * In inductive functions, any recursive references must be inside a select statement, - * and cannot be inside nested select statements. The inductive arguments in the - * recursive reference must be monotonically decreasing. Currently, only single-valued - * functions are supported. Inductive functions cannot be inlined, and cannot have + * In inductive functions, any recursive references must be inside a select statement, + * and cannot be inside nested select statements. The inductive arguments in the + * recursive reference must be monotonically decreasing. Currently, only single-valued + * functions are supported. Inductive functions cannot be inlined, and cannot have * update definitions. * * In some cases, the inductive function's type cannot be inferred and must be declared - * explicitly. This occurs when constants appear in operations with a recursive reference. + * explicitly. This occurs when constants appear in operations with a recursive reference. * For example, in the following code, Halide cannot infer the type of f: * f(x) = select(x <= 0, 0, f(x - 1) + 1); * From 18aadb8e6a99951611183aee104a55320269c063 Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Thu, 4 Dec 2025 16:06:25 -0500 Subject: [PATCH 11/42] clang-tidy and additional safety check. All tests pass --- src/Function.cpp | 48 ++++++++++++++++++++++++++++++++--------------- src/Inductive.cpp | 10 +++++----- src/Inductive.h | 6 +++--- 3 files changed, 41 insertions(+), 23 deletions(-) diff --git a/src/Function.cpp b/src/Function.cpp index b4d9d79a25bb..9efabb2df50d 100644 --- a/src/Function.cpp +++ b/src/Function.cpp @@ -205,9 +205,10 @@ struct CheckVars : public IRGraphVisitor { Scope<> defined_internally; const std::string name; bool unbound_reduction_vars_ok = false; + bool pure; - CheckVars(const std::string &n) - : name(n) { + CheckVars(const std::string &n, bool pure) + : name(n), pure(pure) { } using IRVisitor::visit; @@ -220,20 +221,37 @@ struct CheckVars : public IRGraphVisitor { void visit(const Call *op) override { IRGraphVisitor::visit(op); - /* - if (op->name == name && op->call_type == Call::Halide) { - for (size_t i = 0; i < op->args.size(); i++) { - const Variable *var = op->args[i].as(); - if (!pure_args[i].empty()) { - user_assert(var && var->name == pure_args[i]) - << "In definition of Func \"" << name << "\":\n" - << "All of a function's recursive references to itself" - << " must contain the same pure variables in the same" - << " places as on the left-hand-side.\n"; + bool proper_func = (name == op->name || op->call_type != Call::Halide); + if (op->call_type == Call::Halide && + op->func.defined() && + op->name != name) { + Function func = Function(op->func); + proper_func = (name == op->name || func.has_pure_definition() || func.has_extern_definition()); + } + if (pure) { + user_assert(proper_func) + << "In pure definition of Func \"" << name << "\":\n" + << "Can't call Func \"" << op->name + << "\" because it has not yet been defined," + << " and it is not a recursive call.\n"; + } else { + user_assert(proper_func) + << "In update definition of Func \"" << name << "\":\n" + << "Can't call Func \"" << op->name + << "\" because it has not yet been defined.\n"; + if (op->name == name && op->call_type == Call::Halide) { + for (size_t i = 0; i < op->args.size(); i++) { + const Variable *var = op->args[i].as(); + if (!pure_args[i].empty()) { + user_assert(var && var->name == pure_args[i]) + << "In update definition of Func \"" << name << "\":\n" + << "All of a function's recursive references to itself" + << " in update definitions must contain the same pure" + << " variables in the same places as on the left-hand-side.\n"; + } } } } - */ } void visit(const Variable *var) override { @@ -562,7 +580,7 @@ void Function::define(const vector &args, vector values) { // Make sure all the vars in the value are either args or are // attached to some parameter - CheckVars check(name()); + CheckVars check(name(), true); check.pure_args = args; for (const auto &value : values) { value.accept(&check); @@ -767,7 +785,7 @@ void Function::define_update(const vector &_args, vector values, con // pure args, in the reduction domain, or a parameter. Also checks // that recursive references to the function contain all the pure // vars in the LHS in the correct places. - CheckVars check(name()); + CheckVars check(name(), false); check.pure_args = pure_args; for (const auto &arg : args) { arg.accept(&check); diff --git a/src/Inductive.cpp b/src/Inductive.cpp index 332d38f341e6..b45482fdbc50 100644 --- a/src/Inductive.cpp +++ b/src/Inductive.cpp @@ -46,8 +46,8 @@ class BaseCaseSolver : public IRVisitor { } op->args[2].accept(this); condition_intervals = old_intervals; - for (size_t i = 0; i < vars.size(); i++) { - bounds.pop(vars[i]); + for (const auto &var : vars) { + bounds.pop(var); } nested_select -= 1; } else if (op->name == func) { @@ -95,7 +95,7 @@ class BaseCaseSolver : public IRVisitor { // anonymous namespace -const Box expand_to_include_base_case(const vector &vars, const Expr &RHS, const string &func, const Box &box_required) { +Box expand_to_include_base_case(const vector &vars, const Expr &RHS, const string &func, const Box &box_required) { Expr substed = substitute_in_all_lets(RHS); Box box2 = box_required; BaseCaseSolver b(vars, func, box_required.bounds); @@ -109,11 +109,11 @@ const Box expand_to_include_base_case(const vector &vars, const Expr &RH return box2; } -const Box expand_to_include_base_case(const Function &fn, const Box &box_required, const int &pos) { +Box expand_to_include_base_case(const Function &fn, const Box &box_required, const int &pos) { return expand_to_include_base_case(fn.args(), fn.values()[pos], fn.name(), box_required); } -const Box expand_to_include_base_case(const Function &fn, const Box &box_required) { +Box expand_to_include_base_case(const Function &fn, const Box &box_required) { Box b = expand_to_include_base_case(fn.args(), fn.values()[0], fn.name(), box_required); for (size_t pos = 1; pos < fn.values().size(); pos++) { Box b2 = expand_to_include_base_case(fn.args(), fn.values()[pos], fn.name(), box_required); diff --git a/src/Inductive.h b/src/Inductive.h index f0053c08b257..90bd27e86b7e 100644 --- a/src/Inductive.h +++ b/src/Inductive.h @@ -49,9 +49,9 @@ namespace Internal { /** Given an initial box for an inductively defined function, returns an expanded box that includes the function's non-inductive base case. */ -const Box expand_to_include_base_case(const std::vector &vars, const Expr &RHS, const std::string &func, const Box &box_required); -const Box expand_to_include_base_case(const Function &fn, const Box &box_required, const int &pos = 0); -const Box expand_to_include_base_case(const Function &fn, const Box &box_required); +Box expand_to_include_base_case(const std::vector &vars, const Expr &RHS, const std::string &func, const Box &box_required); +Box expand_to_include_base_case(const Function &fn, const Box &box_required, const int &pos = 0); +Box expand_to_include_base_case(const Function &fn, const Box &box_required); } // namespace Internal } // namespace Halide From 747715869a1a10959eddcbae566762e78959cad6 Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Thu, 4 Dec 2025 20:02:34 -0500 Subject: [PATCH 12/42] patched makefile --- Makefile | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Makefile b/Makefile index 8bcfc65de765..aa9ab9c36ebb 100644 --- a/Makefile +++ b/Makefile @@ -521,6 +521,7 @@ SOURCE_FILES = \ HexagonOffload.cpp \ HexagonOptimize.cpp \ ImageParam.cpp \ + Inductive.cpp \ InferArguments.cpp \ InjectHostDevBufferCopies.cpp \ Inline.cpp \ @@ -724,6 +725,7 @@ HEADER_FILES = \ HexagonOffload.h \ HexagonOptimize.h \ ImageParam.h \ + Inductive.h \ InferArguments.h \ InjectHostDevBufferCopies.h \ Inline.h \ From e6c7738c714416afdf8787f2a47f9d70e478f7e7 Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Fri, 5 Dec 2025 17:05:21 -0500 Subject: [PATCH 13/42] Serialization fix --- src/Serialization.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/Serialization.cpp b/src/Serialization.cpp index 33de404edffe..475711312543 100644 --- a/src/Serialization.cpp +++ b/src/Serialization.cpp @@ -352,6 +352,8 @@ Serialize::DimType Serializer::serialize_dim_type(const DimType &dim_type) { return Serialize::DimType::PureRVar; case DimType::ImpureRVar: return Serialize::DimType::ImpureRVar; + case DimType::InductiveVar: + return Serialize::DimType::InductiveVar; default: user_error << "Unsupported dim type\n"; return Serialize::DimType::PureVar; From a77274dd0c1ab3dbf16d9edb0fea18bc13dc7a60 Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Fri, 5 Dec 2025 17:31:36 -0500 Subject: [PATCH 14/42] more dimtype fixes --- src/Deserialization.cpp | 2 ++ src/halide_ir.fbs | 1 + 2 files changed, 3 insertions(+) diff --git a/src/Deserialization.cpp b/src/Deserialization.cpp index 8a27cc8c1386..d4b650121834 100644 --- a/src/Deserialization.cpp +++ b/src/Deserialization.cpp @@ -382,6 +382,8 @@ DimType Deserializer::deserialize_dim_type(Serialize::DimType dim_type) { return DimType::PureRVar; case Serialize::DimType::ImpureRVar: return DimType::ImpureRVar; + case Serialize::DimType::InductiveVar: + return DimType::InductiveVar; default: user_error << "unknown dim type " << (int)dim_type << "\n"; return DimType::PureVar; diff --git a/src/halide_ir.fbs b/src/halide_ir.fbs index 7f3492684743..480dab36a8d4 100644 --- a/src/halide_ir.fbs +++ b/src/halide_ir.fbs @@ -562,6 +562,7 @@ table Split { enum DimType: ubyte { PureVar, + InductiveVar, PureRVar, ImpureRVar, } From 7fbd8f30bcb3fd30100dc76c0a3e07f48d772c1f Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Thu, 11 Dec 2025 04:13:06 -0500 Subject: [PATCH 15/42] fix memory leaks --- src/Function.cpp | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/src/Function.cpp b/src/Function.cpp index 9efabb2df50d..70790d6b329e 100644 --- a/src/Function.cpp +++ b/src/Function.cpp @@ -647,6 +647,22 @@ void Function::define(const vector &args, vector values) { for (size_t i = 0; i < args.size(); i++) { init_def_args[i] = Var(args[i]); } + + // If the function is inductive, + // the value and args might refer back to the + // function itself, introducing circular references and hence + // memory leaks. We need to break these cycles. + WeakenFunctionPtrs weakener(contents.get()); + for (auto &arg : init_def_args) { + arg = weakener.mutate(arg); + } + for (auto &value : values) { + value = weakener.mutate(value); + } + if (check.reduction_domain.defined()) { + check.reduction_domain.set_predicate( + weakener.mutate(check.reduction_domain.predicate())); + } ReductionDomain rdom; contents->init_def = Definition(init_def_args, values, rdom, true); From 5701a78a99458b698cf5bdec91381c386b5d53ff Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Fri, 12 Dec 2025 21:22:48 -0500 Subject: [PATCH 16/42] remove commented-out code --- test/correctness/inductive.cpp | 9 --------- 1 file changed, 9 deletions(-) diff --git a/test/correctness/inductive.cpp b/test/correctness/inductive.cpp index 23c3ab568544..67ab9c2fce7f 100644 --- a/test/correctness/inductive.cpp +++ b/test/correctness/inductive.cpp @@ -17,8 +17,6 @@ int simple_inductive_test() { Func g("g"), h("h"); Var x("x"), y("y"); - // g(x, y) = x + y; - // g(r.x, r.y) = g(r.x, r.y); g(x, y) = select(x <= 0, 0, g(max(0, x - 1), y) + x + y); h(x, y) = g(x + 5, y) / 4; @@ -41,8 +39,6 @@ int reorder_test() { Var xi("xi"), xii("xii"), xo("xo"); - // g(x, y) = x + y; - // g(r.x, r.y) = g(r.x, r.y); g(x, y) = select(x <= 0, 0, g(max(0, x - 1), y) + x + y); h(x, y) = g(x + 5, y) / 4; @@ -84,10 +80,7 @@ int large_baseline() { Func g("g"), h("h"); Var x("x"), y("y"); - // g(x, y) = x + y; - // g(r.x, r.y) = g(r.x, r.y); g(x, y) = select(x <= 8, (y * x + x * (x + 1) / 2) - 1, g(x - 1, y) + x + y); - h(x, y) = g(x + 5, y) / 4; g.compute_at(h, x).store_at(h, y); @@ -106,8 +99,6 @@ int fibonacci() { Func g("g"), h("h"); Var x("x"), y("y"); - // g(x, y) = x + y; - // g(r.x, r.y) = g(r.x, r.y); g(x, y) = select(x <= 1, 1, g(x - 1, y) + g(x - 2, y)); h(x, y) = g(x, y); From a3bcb7ab609916a8d2cfcdd1bd29d7da4719ebe2 Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Fri, 12 Dec 2025 21:23:40 -0500 Subject: [PATCH 17/42] clang-format --- src/Function.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Function.cpp b/src/Function.cpp index 70790d6b329e..a0bd38326ff7 100644 --- a/src/Function.cpp +++ b/src/Function.cpp @@ -647,7 +647,7 @@ void Function::define(const vector &args, vector values) { for (size_t i = 0; i < args.size(); i++) { init_def_args[i] = Var(args[i]); } - + // If the function is inductive, // the value and args might refer back to the // function itself, introducing circular references and hence From 1ba55ffe1662e74de9a92832c9ab97620876da99 Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Mon, 12 Jan 2026 01:32:50 -0500 Subject: [PATCH 18/42] Fix explicit storage folding check for inductive functions --- src/StorageFolding.cpp | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/StorageFolding.cpp b/src/StorageFolding.cpp index 4b4fa8152d4a..fcd2c2b2293b 100644 --- a/src/StorageFolding.cpp +++ b/src/StorageFolding.cpp @@ -172,7 +172,10 @@ class InjectFoldingCheck : public IRMutator { body = mutate(op->body); } else { // Update valid range based on bounds written to. - Box b = box_provided(body, func.name()); + Box provided = box_provided(body, func.name()); + Box required = box_required(body, func.name()); + required.used = Expr(); + Box b = box_union(provided, required); Expr old_leading_edge = Load::make(Int(32), head + "_next", 0, Buffer<>(), Parameter(), const_true(), ModulusRemainder()); From 6f91c5a75474ecbf3023901930f1dc686ca0e2b5 Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Mon, 12 Jan 2026 04:18:51 -0500 Subject: [PATCH 19/42] Fix function call --- src/Inductive.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Inductive.cpp b/src/Inductive.cpp index b45482fdbc50..64f8ee719545 100644 --- a/src/Inductive.cpp +++ b/src/Inductive.cpp @@ -57,7 +57,7 @@ class BaseCaseSolver : public IRVisitor { for (size_t position = 0; position < vars.size(); position++) { const Expr inductive_expr = op->args[position]; const Expr new_v = Variable::make(inductive_expr.type(), vars[position]); - const Expr gets_lower = simplify(new_v - inductive_expr > 0, true, bounds); + const Expr gets_lower = simplify(new_v - inductive_expr > 0, bounds); const Interval i_lower = solve_for_inner_interval(gets_lower, vars[position]); Interval new_interval; From 6b0859f1fb34bb902ab89cf1c3ae92403ca1984a Mon Sep 17 00:00:00 2001 From: "halide-ci[bot]" <266445882+halide-ci[bot]@users.noreply.github.com> Date: Thu, 28 May 2026 16:26:20 +0000 Subject: [PATCH 20/42] Apply pre-commit auto-fixes --- test/error/inductive_update.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/error/inductive_update.cpp b/test/error/inductive_update.cpp index acb16183f552..cc4312dc0353 100644 --- a/test/error/inductive_update.cpp +++ b/test/error/inductive_update.cpp @@ -17,4 +17,4 @@ int main(int argc, char **argv) { printf("Success!\n"); return 0; -} \ No newline at end of file +} From af31a214c8ccc4f08b45d1ca520767d748ded4ce Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Thu, 28 May 2026 14:48:15 -0400 Subject: [PATCH 21/42] rebase fixes --- src/Function.cpp | 6 +++--- test/correctness/tracing.cpp | 4 ---- 2 files changed, 3 insertions(+), 7 deletions(-) diff --git a/src/Function.cpp b/src/Function.cpp index a0bd38326ff7..1372da71c784 100644 --- a/src/Function.cpp +++ b/src/Function.cpp @@ -654,14 +654,14 @@ void Function::define(const vector &args, vector values) { // memory leaks. We need to break these cycles. WeakenFunctionPtrs weakener(contents.get()); for (auto &arg : init_def_args) { - arg = weakener.mutate(arg); + arg = weakener(arg); } for (auto &value : values) { - value = weakener.mutate(value); + value = weakener(value); } if (check.reduction_domain.defined()) { check.reduction_domain.set_predicate( - weakener.mutate(check.reduction_domain.predicate())); + weakener(check.reduction_domain.predicate())); } ReductionDomain rdom; diff --git a/test/correctness/tracing.cpp b/test/correctness/tracing.cpp index 2c548fd03562..02d5d94d70e6 100644 --- a/test/correctness/tracing.cpp +++ b/test/correctness/tracing.cpp @@ -217,11 +217,7 @@ int main(int argc, char **argv) { f.realize({10}, get_jit_target_from_environment().with_feature(Target::TracePipeline)); // The golden trace, recorded when this test was written -<<<<<<< HEAD static event correct_pipeline_trace[] = { -======= - event correct_pipeline_trace[] = { ->>>>>>> 2197d3da2 (get default types back to normal; add new test) {102, 0, 8, 3, 0, 0, 0, 0, {0, 0, 0, 0}, {0.000000f, 0.000000f, 0.000000f, 0.000000f}, ""}, {102, 1, 9, 3, 0, 0, 0, 0, {0, 0, 0, 0}, {0.000000f, 0.000000f, 0.000000f, 0.000000f}, ""}, }; From b6867b1b4a5512d09149ae3335226a488929f0dd Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Thu, 28 May 2026 15:17:46 -0400 Subject: [PATCH 22/42] codespell --- test/correctness/inductive.cpp | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/test/correctness/inductive.cpp b/test/correctness/inductive.cpp index 67ab9c2fce7f..3532e3e155d0 100644 --- a/test/correctness/inductive.cpp +++ b/test/correctness/inductive.cpp @@ -131,13 +131,13 @@ int sum_2d_test() { f.compute_at(h, x).store_root(); Buffer im = h.realize({80, 80}); auto func = [](int x, int y) { - int ans = 0; + int result = 0; for (int a = 0; a <= x; a++) { for (int b = 0; b <= y; b++) { - ans += a; + result += a; } } - return ans; + return result; }; if (check_image(im, func)) { return 1; @@ -157,11 +157,11 @@ int sum_1d_test() { f.compute_at(h, x); Buffer im = h.realize({80, 80}); auto func = [](int x, int y) { - int ans = 0; + int result = 0; for (int a = 0; a <= y; a++) { - ans += 2 * x + a; + result += 2 * x + a; } - return ans; + return result; }; if (check_image(im, func)) { return 1; @@ -180,18 +180,18 @@ int multi_baseline_test() { f.compute_at(h, x); Buffer im = h.realize({80, 20}); auto func = [](int x, int y) { - std::vector ans; + std::vector result; for (int a = 0; a <= y; a++) { if (a <= 0) { - ans.emplace_back(4 * x); + result.emplace_back(4 * x); } else if (a <= 3) { - ans.emplace_back(2 * x + (2 * x + a) + ans[a - 1]); + result.emplace_back(2 * x + (2 * x + a) + result[a - 1]); } else { - ans.emplace_back(2 * x + a + ans[a - 1] + (2 * x + a) + ans[a - 1]); + result.emplace_back(2 * x + a + result[a - 1] + (2 * x + a) + result[a - 1]); } } - return ans[y]; + return result[y]; }; if (check_image(im, func)) { return 1; From 0573a07471d71f36bd41c0ef2d16151229b9c1fc Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Fri, 29 May 2026 13:40:39 -0400 Subject: [PATCH 23/42] additional bugfixes and tests --- src/Function.cpp | 80 ++++++------------- src/Inductive.cpp | 37 +++++---- src/Inductive.h | 2 - test/error/CMakeLists.txt | 5 +- test/error/inductive_2d_arbitrary.cpp | 18 +++++ test/error/inductive_cond_nested.cpp | 18 +++++ test/error/inductive_cond_self_reference.cpp | 18 +++++ ...nductive_loop.cpp => inductive_loop_1.cpp} | 0 8 files changed, 102 insertions(+), 76 deletions(-) create mode 100644 test/error/inductive_2d_arbitrary.cpp create mode 100644 test/error/inductive_cond_nested.cpp create mode 100644 test/error/inductive_cond_self_reference.cpp rename test/error/{inductive_loop.cpp => inductive_loop_1.cpp} (100%) diff --git a/src/Function.cpp b/src/Function.cpp index 1372da71c784..a18eb7b88fd0 100644 --- a/src/Function.cpp +++ b/src/Function.cpp @@ -659,10 +659,6 @@ void Function::define(const vector &args, vector values) { for (auto &value : values) { value = weakener(value); } - if (check.reduction_domain.defined()) { - check.reduction_domain.set_predicate( - weakener(check.reduction_domain.predicate())); - } ReductionDomain rdom; contents->init_def = Definition(init_def_args, values, rdom, true); @@ -1109,63 +1105,24 @@ bool Function::has_pure_definition() const { } bool Function::is_inductive() const { - class RecursiveHelper : public IRVisitor { - using IRVisitor::visit; - const string &func; - void visit(const Call *op) override { - if (op->name == func) { - recursive = true; - } - IRVisitor::visit(op); - } - - public: - bool recursive = false; - RecursiveHelper(const string &func) - : func(func) { - } - }; - if (!has_pure_definition()) { return false; } - RecursiveHelper r(name()); + bool recursive = false; for (const Expr &e : definition().values()) { - e.accept(&r); + visit_with(e, [&](auto *self, const Call *op) { + if (op->name == name()) { + recursive = true; + } + self->visit_base(op); + }); } - return r.recursive; + return recursive; } bool Function::is_inductive(const string &var) const { - class RecursiveHelper : public IRVisitor { - using IRVisitor::visit; - const string &func; - const string &var; - const int &pos; - void visit(const Call *op) override { - if (op->name == func) { - recursive = true; - if (const auto &v = op->args[pos].as()) { - if (v->name != var) { - inductive_in_var = true; - } - } else { - inductive_in_var = true; - } - } - IRVisitor::visit(op); - } - - public: - bool recursive = false; - bool inductive_in_var = false; - RecursiveHelper(const string &func, const string &var, const int &pos) - : func(func), var(var), pos(pos) { - } - }; - if (!has_pure_definition()) { return false; } @@ -1178,15 +1135,30 @@ bool Function::is_inductive(const string &var) const { } } } + if (pos == -1) { return false; } - RecursiveHelper r(name(), var, pos); + + bool recursive = false; + bool inductive_in_var = false; for (const Expr &e : definition().values()) { - e.accept(&r); + visit_with(e, [&](auto *self, const Call *op) { + if (op->name == name()) { + recursive = true; + if (const auto &v = op->args[pos].as()) { + if (v->name != var) { + inductive_in_var = true; + } + } else { + inductive_in_var = true; + } + } + self->visit_base(op); + }); } - return r.inductive_in_var; + return inductive_in_var; } bool Function::can_be_inlined() const { diff --git a/src/Inductive.cpp b/src/Inductive.cpp index 64f8ee719545..8b68fdac4ac2 100644 --- a/src/Inductive.cpp +++ b/src/Inductive.cpp @@ -16,6 +16,8 @@ namespace Internal { using std::string; using std::vector; +namespace { + class BaseCaseSolver : public IRVisitor { using IRVisitor::visit; const vector &vars; @@ -31,16 +33,24 @@ class BaseCaseSolver : public IRVisitor { void visit(const Call *op) override { if (op->is_intrinsic(Call::if_then_else)) { + if (nested_select == 0) { + visit_with(op->args[0], [&](auto *self, const Call *inner_op) { + user_assert(inner_op->name != func) << "Function " << func << " contains an inductive function reference outside of a select operation value.\n"; + self->visit_base(inner_op); + }); + } + nested_select += 1; vector old_intervals = condition_intervals; for (size_t i = 0; i < vars.size(); i++) { - condition_intervals[i] = Interval::make_intersection(old_intervals[i], solve_for_outer_interval(simplify(op->args[0]), vars[i])); + Interval inter = Interval::make_intersection(old_intervals[i], solve_for_outer_interval(simplify(op->args[0]), vars[i])); + condition_intervals[i] = Interval(inter.min, Interval::pos_inf()); bounds.push(vars[i], condition_intervals[i]); } - op->args[1].accept(this); for (size_t i = 0; i < vars.size(); i++) { - condition_intervals[i] = Interval::make_intersection(old_intervals[i], solve_for_outer_interval(simplify(!op->args[0]), vars[i])); + Interval inter = Interval::make_intersection(old_intervals[i], solve_for_outer_interval(simplify(!op->args[0]), vars[i])); + condition_intervals[i] = Interval(inter.min, Interval::pos_inf()); bounds.pop(vars[i]); bounds.push(vars[i], condition_intervals[i]); } @@ -51,7 +61,7 @@ class BaseCaseSolver : public IRVisitor { } nested_select -= 1; } else if (op->name == func) { - user_assert(nested_select > 0) << "Function " << func << " contains an inductive function reference outside of a select operation.\n"; + user_assert(nested_select > 0) << "Function " << func << " contains an inductive function reference outside of a select operation value.\n"; user_assert(nested_select == 1) << "Function " << func << " contains an inductive function reference inside a nested select operation.\n"; bool found_inductive = false; for (size_t position = 0; position < vars.size(); position++) { @@ -67,7 +77,9 @@ class BaseCaseSolver : public IRVisitor { found_inductive = true; new_interval = Interval(Interval::neg_inf(), start_box[position].max); } else { - new_interval = Interval::everything(); + std::ostringstream err; + err << "Inductive variable " << vars[position] << " in inductive function " << func << " is not provably monotonically decreasing outside of the base case."; + user_error << err.str() << "\n"; } new_interval = Interval::make_intersection(new_interval, condition_intervals[position]); Scope i_scope; @@ -93,7 +105,7 @@ class BaseCaseSolver : public IRVisitor { } }; -// anonymous namespace +} // anonymous namespace Box expand_to_include_base_case(const vector &vars, const Expr &RHS, const string &func, const Box &box_required) { Expr substed = substitute_in_all_lets(RHS); @@ -109,18 +121,5 @@ Box expand_to_include_base_case(const vector &vars, const Expr &RHS, con return box2; } -Box expand_to_include_base_case(const Function &fn, const Box &box_required, const int &pos) { - return expand_to_include_base_case(fn.args(), fn.values()[pos], fn.name(), box_required); -} - -Box expand_to_include_base_case(const Function &fn, const Box &box_required) { - Box b = expand_to_include_base_case(fn.args(), fn.values()[0], fn.name(), box_required); - for (size_t pos = 1; pos < fn.values().size(); pos++) { - Box b2 = expand_to_include_base_case(fn.args(), fn.values()[pos], fn.name(), box_required); - merge_boxes(b, b2); - } - return b; -} - } // namespace Internal } // namespace Halide diff --git a/src/Inductive.h b/src/Inductive.h index 90bd27e86b7e..e2f78232c8ef 100644 --- a/src/Inductive.h +++ b/src/Inductive.h @@ -50,8 +50,6 @@ namespace Internal { /** Given an initial box for an inductively defined function, returns an expanded box that includes the function's non-inductive base case. */ Box expand_to_include_base_case(const std::vector &vars, const Expr &RHS, const std::string &func, const Box &box_required); -Box expand_to_include_base_case(const Function &fn, const Box &box_required, const int &pos = 0); -Box expand_to_include_base_case(const Function &fn, const Box &box_required); } // namespace Internal } // namespace Halide diff --git a/test/error/CMakeLists.txt b/test/error/CMakeLists.txt index 2e1c748ad571..315aaaf54591 100644 --- a/test/error/CMakeLists.txt +++ b/test/error/CMakeLists.txt @@ -74,7 +74,10 @@ tests( implicit_args.cpp impossible_constraints.cpp incomplete_target.cpp - inductive_loop.cpp + inductive_2d_arbitrary.cpp + inductive_cond_nested.cpp + inductive_cond_self_reference.cpp + inductive_loop_1.cpp inductive_loop_2.cpp inductive_loop_3.cpp inductive_nested_select.cpp diff --git a/test/error/inductive_2d_arbitrary.cpp b/test/error/inductive_2d_arbitrary.cpp new file mode 100644 index 000000000000..41ca9976fc14 --- /dev/null +++ b/test/error/inductive_2d_arbitrary.cpp @@ -0,0 +1,18 @@ +#include "Halide.h" +#include + +using namespace Halide; + +int main(int argc, char **argv) { + Func f("f"), g("g"); + + Var x("x"), y("y"); + + f(x, y) = select(x < 2 || y < 2 || y > 6, 0, f(x - 1, y + 1)) + select(x < 2 || x > 6 || y < 2, 0, f(x + 1, y - 1)); + g(x, y) = f(x, y) * 2; + + g.realize({10, 10}); + + printf("Success!\n"); + return 0; +} diff --git a/test/error/inductive_cond_nested.cpp b/test/error/inductive_cond_nested.cpp new file mode 100644 index 000000000000..b16ecf982df9 --- /dev/null +++ b/test/error/inductive_cond_nested.cpp @@ -0,0 +1,18 @@ +#include "Halide.h" +#include + +using namespace Halide; + +int main(int argc, char **argv) { + Func f("f"), g("g"); + + Var x("x"); + + f(x) = select(x < max(2, abs(select(x < 0, f(x - 1), 5))), 0, f(x - 1) + x); + g(x) = f(x) * 2; + + g.realize({10}); + + printf("Success!\n"); + return 0; +} diff --git a/test/error/inductive_cond_self_reference.cpp b/test/error/inductive_cond_self_reference.cpp new file mode 100644 index 000000000000..1999f7acb3b4 --- /dev/null +++ b/test/error/inductive_cond_self_reference.cpp @@ -0,0 +1,18 @@ +#include "Halide.h" +#include + +using namespace Halide; + +int main(int argc, char **argv) { + Func f("f"), g("g"); + + Var x("x"); + + f(x) = select(x < f(x - 1), 0, f(x - 1) + x); + g(x) = f(x) * 2; + + g.realize({10}); + + printf("Success!\n"); + return 0; +} diff --git a/test/error/inductive_loop.cpp b/test/error/inductive_loop_1.cpp similarity index 100% rename from test/error/inductive_loop.cpp rename to test/error/inductive_loop_1.cpp From 8cea75d273930e9756d69eadba889e1bd164dee4 Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Sat, 13 Jun 2026 05:04:35 -0400 Subject: [PATCH 24/42] Starting to add new benchmark --- apps/CMakeLists.txt | 1 + apps/stereobm/CMakeLists.txt | 0 apps/stereobm/Makefile | 0 apps/stereobm/stereobm.cpp | 42 ++++++++ apps/stereobm/stereobm_generator.cpp | 145 +++++++++++++++++++++++++++ 5 files changed, 188 insertions(+) create mode 100644 apps/stereobm/CMakeLists.txt create mode 100644 apps/stereobm/Makefile create mode 100644 apps/stereobm/stereobm.cpp create mode 100644 apps/stereobm/stereobm_generator.cpp diff --git a/apps/CMakeLists.txt b/apps/CMakeLists.txt index ab7d71214e34..188647f3f9c8 100644 --- a/apps/CMakeLists.txt +++ b/apps/CMakeLists.txt @@ -67,6 +67,7 @@ add_app(resize) # add_app(resnet_50) # TODO(#5374): missing CMake build # add_app(simd_op_check) # TODO(#5374): missing CMake build add_app(stencil_chain) +add_app(stereobm) add_app(unsharp) add_app(wavelet) # keep-sorted end diff --git a/apps/stereobm/CMakeLists.txt b/apps/stereobm/CMakeLists.txt new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/apps/stereobm/Makefile b/apps/stereobm/Makefile new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/apps/stereobm/stereobm.cpp b/apps/stereobm/stereobm.cpp new file mode 100644 index 000000000000..ffda5b55f0ff --- /dev/null +++ b/apps/stereobm/stereobm.cpp @@ -0,0 +1,42 @@ +#include +#include +#include + +#include "HalideBuffer.h" +#include "HalideRuntime.h" + +#include "stereobm.h" +#include "stereobm_auto_schedule.h" + +#include "halide_benchmark.h" +#include "halide_image_io.h" + +using namespace Halide::Tools; + +int main(int argc, char **argv) { + if (argc != 4) { + printf("Usage: %s left right out\n", argv[0]); + return 1; + } + + Halide::Runtime::Buffer left = load_and_convert_image(argv[1]); + Halide::Runtime::Buffer right = load_and_convert_image(argv[2]); + Halide::Runtime::Buffer output(left.width(), left.height()); + + double best_manual = benchmark([&]() { + stereobm(left, right, output); + output.device_sync(); + }); + printf("Manually-tuned time: %gms\n", best_manual * 1e3); + + double best_auto = benchmark([&]() { + stereobm_auto_scheudle(left, right, output); + output.device_sync(); + }); + printf("Auto-scheduled time: %gms\n", best_auto * 1e3); + + convert_and_save_image(output, argv[2]); + + printf("Success!\n"); + return 0; +} diff --git a/apps/stereobm/stereobm_generator.cpp b/apps/stereobm/stereobm_generator.cpp new file mode 100644 index 000000000000..82c89da08dee --- /dev/null +++ b/apps/stereobm/stereobm_generator.cpp @@ -0,0 +1,145 @@ +#include "Halide.h" + +using namespace Halide; +using namespace Halide::BoundaryConditions; + +Var x, y, c; + +Func stereobm_func(Func input0, Func input1, int winsize, int depth, int tilesize, int ftzero, int threshold, int mindisp, int uniqueness_ratio, int filtercap, Target target) { + const Type int8 = Int(8); + const Type uint16 = UInt(16); + const Type int32 = Int(32); + const int native_lanes = target.natural_vector_size(); + + Var x("x"); + Var y("y"); + Var c("c"); + Var d("d"); + Var di("di"); + Var xi("xi"), yi("yi"), xo("xo"), yo("yo"); + + Func proc0("proc0"), proc1("proc1"); + proc0(y, x, c) = BoundaryConditions::constant_exterior(input0, 0)(y, x, c); + proc1(y, x, c) = BoundaryConditions::constant_exterior(input1, 0)(y, x, c); + + Func b0("b0"), b1("b1"); + // convert to grayscale + b0(y, x) = cast(cast((cast(proc0(y, x, 0)) * 1868 + cast(proc0(y, x, 1)) * 9617 + cast(proc0(y, x, 2)) * 4899 + 8192) >> 14)); + b1(y, x) = cast(cast((cast(proc1(y, x, 0)) * 1868 + cast(proc1(y, x, 1)) * 9617 + cast(proc1(y, x, 2)) * 4899 + 8192) >> 14)); + + // prefiltering with sobel filter + Func xsobel0("xsobel0"), xsobel1("xsobel1"); + Expr e0 = b0(y + 1, x - 1) - b0(y - 1, x - 1) + 2 * b0(y + 1, x) - 2 * b0(y - 1, x) + b0(y + 1, x + 1) - b0(y - 1, x + 1); + Expr e1 = b1(y + 1, x - 1) - b1(y - 1, x - 1) + 2 * b1(y + 1, x) - 2 * b1(y - 1, x) + b1(y + 1, x + 1) - b1(y - 1, x + 1); + xsobel0(y, x) = cast(clamp(e0, -filtercap, filtercap) + filtercap); + xsobel1(y, x) = cast(clamp(e1, -filtercap, filtercap) + filtercap); + + Func diff("diff"); + diff(di, yi, x, yo) = Halide::cast(cast(abs((xsobel0(yi + yo * tilesize, x)) - (xsobel1(yi + yo * tilesize + di - depth + 1, x))))); + + Func vsum(uint16, std::string("vsum")); + Func zero_blur(uint16, "zero_blur"); + RDom rx0(0, winsize); + zero_blur(di, yi, yo) = sum(cast(diff(di, yi, rx0, yo))); + vsum(di, yi, x, yo) = select(x <= 0, zero_blur(di, yi, yo), likely(vsum(di, yi, max(x - 1, 0), yo) + diff(di, yi, x + winsize - 1, yo) - diff(di, yi, max(x - 1, 0), yo))); /// should be x-1 + Func blur_y(uint16, 1, "blur_y"); + RDom ry(0, tilesize, "ry"); + RDom ry1(1, depth - 1, "ry1"); + Func f1("f1"); + f1(di, x, yo) = sum(vsum(di, rx0, x, yo)); + blur_y(di, yi, x, yo) = select(yi <= 0, f1(di, x, yo), likely(blur_y(di, max(yi - 1, 0), x, yo) + vsum(di, yi + winsize - 1, x, yo) - vsum(di, max(yi - 1, 0), x, yo))); + + Func text("text"), zerotext("zerotext"), textsum("textsum"), textf1("textf1"), textblury("textblury"); + text(yi, x, yo) = cast(abs(cast(b0(yi + yo * tilesize, x)) - cast(ftzero))); + zerotext(yi, yo) = sum(cast(text(yi, rx0, yo))); + textsum(yi, x, yo) = select(x <= 0, zerotext(yi, yo), textsum(yi, x - 1, yo) + text(yi, x + winsize - 1, yo) - text(yi, x - 1, yo)); + textf1(x, yo) = sum(textsum(rx0, x, yo)); + textblury(yi, x, yo) = undef(); + textblury(ry, x, yo) = select(ry == 0, textf1(x, yo), textblury(max(ry - 1, 0), x, yo) + textsum(ry + winsize - 1, x, yo) - textsum(max(ry - 1, 0), x, yo)); + + Func preout("preout"); + RDom rd(0, depth, "rd"); + preout(yi, x, yo) = cast(65535); + preout(yi, x, yo) = min(blur_y(rd, yi, x, yo), preout(yi, x, yo)); + + Func prearg("prearg"); + prearg(di, yi, x, yo) = select(preout(yi, x, yo) == blur_y(di, yi, x, yo), cast(di), cast(65535)); + Func argmin1("argmin"); + argmin1(yi, x, yo) = cast(65535); + argmin1(yi, x, yo) = min(argmin1(yi, x, yo), prearg(rd, yi, x, yo)); + + Func second_best("second_best"); + second_best(di, yi, x, yo) = select(abs(di - cast(argmin1(yi, x, yo))) <= 1, cast(65535), blur_y(di, yi, x, yo)); + Func argmin2("argmin2"); + argmin2(yi, x, yo) = cast(65535); + argmin2(yi, x, yo) = min(argmin2(yi, x, yo), second_best(rd, yi, x, yo)); + + Func p_clamped("p_clamped"); + p_clamped(yi, x, yo) = unsafe_promise_clamped(argmin1(yi, x, yo), 1, depth - 2); + + Func subpout(int32, "subpout"); + Expr p = cast(blur_y(cast(int32, p_clamped(yi, x, yo)) + 1, yi, x, yo)); + Expr n = cast(blur_y(cast(int32, p_clamped(yi, x, yo)) - 1, yi, x, yo)); + Expr d1 = p + n - 2 * preout(yi, x, yo) + abs(p - n); + Expr subpout_expr = cast((cast(depth - p_clamped(yi, x, yo) - 1 + mindisp) * 256 + (select(d1 == 0, 0, (p - n) * 256 / d1) + 15)) >> 4); + subpout(yi, x, yo) = select(argmin1(yi, x, yo) > 0 && argmin1(yi, x, yo) < depth - 1, subpout_expr, cast(depth - argmin1(yi, x, yo) - 1 + mindisp) * 16); + + Func splitoutput("splitoutput"), output("output"); + splitoutput(yi, x, yo) = select((textblury(yi, x, yo) < threshold || cast(argmin2(yi, x, yo)) <= cast(preout(yi, x, yo)) + (cast(preout(yi, x, yo)) * cast(uniqueness_ratio)) / 100), 0, subpout(yi, x, yo)); + output(y, x) = splitoutput(y % tilesize, x, y / tilesize); + + b0.compute_root().vectorize(y, native_lanes * 4); + b1.compute_root().vectorize(y, native_lanes * 4); + xsobel0.compute_root().vectorize(y, native_lanes * 4); + xsobel1.compute_root().vectorize(y, native_lanes * 4); + + preout.compute_at(splitoutput, yi).update().atomic(false).vectorize(rd, depth); + argmin1.compute_at(splitoutput, yi).update().atomic(false).vectorize(rd, depth); + argmin2.compute_at(splitoutput, yi).update().atomic(false).vectorize(rd, depth); + + splitoutput.compute_root().reorder_storage(yi, yo, x).parallel(yo); + + blur_y.bound(di, 0, depth); + vsum.bound(di, 0, depth); + + blur_y.compute_at(splitoutput, x).store_at(splitoutput, x).vectorize(di, depth).fold_storage(yi, 2); + vsum.compute_at(splitoutput, x).store_at(splitoutput, yo).vectorize(di, depth).fold_storage(x, 2); + + f1.compute_at(splitoutput, x).vectorize(di, depth); + zero_blur.compute_at(splitoutput, yo).vectorize(di, depth); + + zerotext.compute_at(splitoutput, yo); + textf1.compute_at(splitoutput, x); + textsum.compute_at(splitoutput, x).store_at(splitoutput, yo).fold_storage(x, 2); + textblury.compute_at(splitoutput, x); + // subpout.compute_at(splitoutput, x); + + output.vectorize(y, native_lanes); + + return output; +} + +class StereoBM : public Generator { +public: + // Inputs: two images of the same scene as seen by a left and right eye + Input> left_color{"left_color"}; + Input> right_color{"right_color"}; + + GeneratorParam winsize{"winsize", 15}; // Size of box surrounding each to sum diffs over + GeneratorParam depth{"depth", 64}; // range of disparities to test + GeneratorParam tilesize{"tilesize", 64}; + GeneratorParam ftzero{"ftzero", 0}; + GeneratorParam threshold{"threshold", 10}; + GeneratorParam mindisp{"mindisp", 0}; + GeneratorParam uniqueness_ratio{"uniqueness_ratio", 15}; + GeneratorParam filtercap{"filtercap", 31}; + + Output> output{"output"}; + + void generate() { + Func stereo = stereobm_func(left_color, right_color, winsize, depth, tilesize, ftzero, threshold, mindisp, uniqueness_ratio, filtercap, get_target()); + output = stereo; + } +}; + +HALIDE_REGISTER_GENERATOR(StereoBM, stereobm) From c75c9f72164c9e21b5d4e2cc2147daa79ee349a3 Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Thu, 18 Jun 2026 11:22:11 -0400 Subject: [PATCH 25/42] add two apps: StereoBM and IIR cascade. Made modifications to SlidingWindow.cpp and Monotonic.cpp to ensure IIR cascade works. Co-authored by: Claude Opus 4.7 --- Makefile | 1 + apps/CMakeLists.txt | 1 + apps/iir_cascade/CMakeLists.txt | 48 ++++ apps/iir_cascade/Makefile | 31 ++ apps/iir_cascade/iir_cascade_generator.cpp | 95 +++++++ apps/iir_cascade/test.cpp | 63 +++++ apps/images/README.md | 5 + apps/images/aloeL.png | Bin 0 -> 180925 bytes apps/images/aloeR.png | Bin 0 -> 181237 bytes apps/stereobm/CMakeLists.txt | 99 +++++++ apps/stereobm/Makefile | 62 ++++ apps/stereobm/process.cpp | 155 ++++++++++ apps/stereobm/stereobm.cpp | 42 --- apps/stereobm/stereobm_generator.cpp | 311 ++++++++++++--------- apps/vcpkg.json | 1 + src/Monotonic.cpp | 2 +- 16 files changed, 742 insertions(+), 174 deletions(-) create mode 100644 apps/iir_cascade/CMakeLists.txt create mode 100644 apps/iir_cascade/Makefile create mode 100644 apps/iir_cascade/iir_cascade_generator.cpp create mode 100644 apps/iir_cascade/test.cpp create mode 100644 apps/images/README.md create mode 100644 apps/images/aloeL.png create mode 100644 apps/images/aloeR.png create mode 100644 apps/stereobm/process.cpp delete mode 100644 apps/stereobm/stereobm.cpp diff --git a/Makefile b/Makefile index aa9ab9c36ebb..df1fa82c2393 100644 --- a/Makefile +++ b/Makefile @@ -2212,6 +2212,7 @@ TEST_APPS=\ resize \ resnet_50 \ stencil_chain \ + stereobm \ wavelet TEST_APPS_DEPS=$(TEST_APPS:%=%_test_app) diff --git a/apps/CMakeLists.txt b/apps/CMakeLists.txt index 188647f3f9c8..13d81b6ec8b9 100644 --- a/apps/CMakeLists.txt +++ b/apps/CMakeLists.txt @@ -54,6 +54,7 @@ add_app(hexagon_benchmarks) # add_app(hexagon_dma) # TODO(#5374): missing CMake build add_app(hist) add_app(iir_blur) +add_app(iir_cascade) add_app(interpolate) add_app(lens_blur) add_app(linear_algebra) diff --git a/apps/iir_cascade/CMakeLists.txt b/apps/iir_cascade/CMakeLists.txt new file mode 100644 index 000000000000..54084635323b --- /dev/null +++ b/apps/iir_cascade/CMakeLists.txt @@ -0,0 +1,48 @@ +cmake_minimum_required(VERSION 3.28) +project(iir_cascade) + +enable_testing() + +# Set up language settings +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED YES) +set(CMAKE_CXX_EXTENSIONS NO) + +# Find Halide +find_package(Halide REQUIRED) + +# Generator +add_halide_generator( + iir_cascade.generator + SOURCES iir_cascade_generator.cpp + LINK_LIBRARIES Halide::Tools +) + +# Filters +add_halide_library( + iir_cascade + FROM iir_cascade.generator + ${IIR_CASCADE_FEATURES} + PARAMS inductive=true +) +add_halide_library( + iir_cascade_noninductive + FROM iir_cascade.generator + GENERATOR iir_cascade + ${IIR_CASCADE_FEATURES} + PARAMS inductive=false +) + +# Main executable +add_executable(iir_cascade_test test.cpp) +target_link_libraries(iir_cascade_test PRIVATE Halide::Tools iir_cascade iir_cascade_noninductive) + +# Test that the app actually works! +add_test(NAME iir_cascade_test COMMAND iir_cascade_test) +set_tests_properties( + iir_cascade_test + PROPERTIES + LABELS iir_cascade + PASS_REGULAR_EXPRESSION "Success!" + SKIP_REGULAR_EXPRESSION "\\[SKIP\\]" +) diff --git a/apps/iir_cascade/Makefile b/apps/iir_cascade/Makefile new file mode 100644 index 000000000000..fe9a8939f087 --- /dev/null +++ b/apps/iir_cascade/Makefile @@ -0,0 +1,31 @@ +include ../support/Makefile.inc + +.PHONY: build clean test + +build: $(BIN)/$(HL_TARGET)/test + +$(GENERATOR_BIN)/iir_cascade.generator: iir_cascade_generator.cpp $(GENERATOR_DEPS) + @mkdir -p $(@D) + $(CXX) $(CXXFLAGS) $(filter %.cpp,$^) -o $@ $(LIBHALIDE_LDFLAGS) + +$(BIN)/%/iir_cascade.a: $(GENERATOR_BIN)/iir_cascade.generator + @mkdir -p $(@D) + $^ -g iir_cascade -f iir_cascade -e $(GENERATOR_OUTPUTS) -o $(@D) target=$*-no_runtime inductive=true + +$(BIN)/%/iir_cascade_noninductive.a: $(GENERATOR_BIN)/iir_cascade.generator + @mkdir -p $(@D) + $^ -g iir_cascade -f iir_cascade_noninductive -e $(GENERATOR_OUTPUTS) -o $(@D) target=$*-no_runtime inductive=false + +$(BIN)/%/runtime.a: $(GENERATOR_BIN)/iir_cascade.generator + @mkdir -p $(@D) + $^ -r runtime -o $(@D) target=$* + +$(BIN)/%/test: test.cpp $(BIN)/%/iir_cascade.a $(BIN)/%/iir_cascade_noninductive.a $(BIN)/%/runtime.a + @mkdir -p $(@D) + $(CXX-$*) $(CXXFLAGS-$*) -Wall -O2 -I$(BIN)/$* $^ -o $@ $(LDFLAGS-$*) + +clean: + rm -rf $(BIN) + +test: $(BIN)/$(HL_TARGET)/test + $< diff --git a/apps/iir_cascade/iir_cascade_generator.cpp b/apps/iir_cascade/iir_cascade_generator.cpp new file mode 100644 index 000000000000..d615f257c8a0 --- /dev/null +++ b/apps/iir_cascade/iir_cascade_generator.cpp @@ -0,0 +1,95 @@ +// Creates a cascade of 1D forward-only IIR filters with tanh nonlinearity. +// Contains a version that uses inductive functions, and a version that does not. + +#include "Halide.h" + +using namespace Halide; +using namespace Halide::BoundaryConditions; + +class IIRCascade : public Generator { +public: + Input> input{"input"}; + GeneratorParam N{"N", 4}; // number of filter iterations + GeneratorParam weight{"weight", 0.3f}; // IIR coefficient + GeneratorParam gain{"gain", 3.f}; // gain applied to filter output before nonlinearity + GeneratorParam inductive{"inductive", true}; + Output> output{"output"}; + + void generate() { + Var t("t"), s("s"); + Func in_f("in"); + in_f(t, s) = BoundaryConditions::repeat_edge(input)(t, s); + std::vector filt(N); + RDom rt(1, input.width() - 1, "rt"); + + for (int k = 0; k < N; k++) { + filt[k] = Func(Float(32), "filt" + std::to_string(k)); + Func src; + if (k == 0) { + src = in_f; + } else { + src = filt[k - 1]; + } + if (inductive) { + filt[k](t, s) = select(t <= 0, + weight * src(t, s), + likely((1.f - weight) * filt[k](t - 1, s) + weight * tanh(gain * src(t, s)))); + } else { + filt[k](t, s) = undef(); + filt[k](0, s) = weight * src(0, s); + filt[k](rt, s) = (1.f - weight) * filt[k](rt - 1, s) + weight * tanh(gain * src(rt, s)); + } + } + + output(t, s) = undef(); + RDom ro(0, input.width(), "ro"); + output(ro, s) = tanh(gain * filt[N - 1](ro, s)); + + int VEC; + if (inductive) { + VEC = 32; + } else { + VEC = 4; + } + + Var so("so"), si("si"); + if (get_target().has_feature(Target::CUDA)) { + // Similarly to iir_blur, we can't get parallelism from the recursive dimension. + // The inductive version uses less i/o because it does not have to write the + // entire intermediate filter outputs to global memory. + const int WARP = 32; + output.update().split(s, so, si, WARP).gpu_blocks(so).gpu_lanes(si).reorder(ro, si, so); + for (int k = 0; k < N; k++) { + if (inductive) { + filt[k].fold_storage(t, 2); + filt[k].store_at(output, si).compute_at(output, ro); + } else { + filt[k].compute_at(output, si).reorder_storage(s, t).store_in(MemoryType::Heap); + filt[k].update(1).unroll(rt, 8); + } + } + } else { + // The inductive version is generally not faster on CPU unless the non-linearity is changed to a + // less expensive function and the input is large enough to saturate the last-level cache. + output.split(s, so, si, VEC).vectorize(si); + output.update() + .split(s, so, si, VEC) + .reorder(si, ro, so) + .vectorize(si); + + for (int k = 0; k < N; k++) { + if (inductive) { + filt[k].reorder_storage(s, t).fold_storage(t, 2); + filt[k].store_at(output, so).compute_at(output, ro).vectorize(s, VEC); + } else { + filt[k].compute_at(output, so).reorder_storage(s, t).vectorize(s, VEC).update().vectorize(s, VEC); + filt[k].update(1).vectorize(s, VEC); + } + } + + output.dim(0).set_bounds(0, input.width()); + } + } +}; + +HALIDE_REGISTER_GENERATOR(IIRCascade, iir_cascade) diff --git a/apps/iir_cascade/test.cpp b/apps/iir_cascade/test.cpp new file mode 100644 index 000000000000..75dd92a63844 --- /dev/null +++ b/apps/iir_cascade/test.cpp @@ -0,0 +1,63 @@ +#include +#include +#include +#include +#include + +#include "HalideBuffer.h" +#include "HalideRuntime.h" + +#include "iir_cascade.h" +#include "iir_cascade_noninductive.h" + +#include "halide_benchmark.h" + +using namespace Halide::Tools; + +int main(int argc, char **argv) { + + const int T = 1024; // number of time steps + const int S = 1024; // number of strips + + Halide::Runtime::Buffer input(T, S); + Halide::Runtime::Buffer out_inductive(T, S); + Halide::Runtime::Buffer out_noninductive(T, S); + + // Set an element to something non-zero, to make sure the generators actually write to the output buffers. + out_inductive(5, 5) = 1.f; + out_noninductive(5, 5) = 2.f; + + input.for_each_element([&](int x, int y) { + input(x, y) = 0.5f * x + 10.0f * sinf(0.01f * x + 0.02f * y); // some arbitrary input signal + }); + + double t_inductive = benchmark([&]() { + iir_cascade(input, out_inductive); + out_inductive.device_sync(); + }); + printf("inductive time: %gms\n", t_inductive * 1e3); + + double t_noninductive = benchmark([&]() { + iir_cascade_noninductive(input, out_noninductive); + out_noninductive.device_sync(); + }); + printf("non-inductive time: %gms\n", t_noninductive * 1e3); + + // out_inductive.copy_to_host(); + // out_noninductive.copy_to_host(); + + float max_err = 0.f; + for (int y = 0; y < S; y++) { + for (int x = 0; x < T; x++) { + max_err = std::max(max_err, std::abs(out_inductive(x, y) - out_noninductive(x, y))); + } + } + printf("max abs difference: %g\n", max_err); + if (max_err > 1e-4f) { + printf("Inductive and non-inductive outputs differ!\n"); + return 1; + } + + printf("Success!\n"); + return 0; +} diff --git a/apps/images/README.md b/apps/images/README.md new file mode 100644 index 000000000000..c3e600673f50 --- /dev/null +++ b/apps/images/README.md @@ -0,0 +1,5 @@ +# Attribution + +aloeL.png and aloeR.png are derived from: D. Scharstein and C. Pal. Learning +conditional random fields for stereo. In IEEE Computer Society Conference on +Computer Vision and Pattern Recognition (CVPR 2007), Minneapolis, MN, June 2007. diff --git a/apps/images/aloeL.png b/apps/images/aloeL.png new file mode 100644 index 0000000000000000000000000000000000000000..e8e037c704bf6cf13972a7e44e81a3c881a4dd11 GIT binary patch literal 180925 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
    L5~J9R^#(4VX$VzB@E_MzZvZn?Xz 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 YlILsP3w*QJ(Xhhx1vPCxylpZxF-|6t|b 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%0Ags``>*@QVS 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 z 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

    mrjR+`yRh_v=Llzq=}B9sB(iy|qa$S58hubXy} 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/dev/null) + OPENCV_LIBS := $(shell pkg-config --libs opencv4 2>/dev/null) +endif + +# We set parameters here to feed into both OpenCV and our generator, so that they are consistent. +STEREOBM_WINSIZE ?= 9 +STEREOBM_DEPTH ?= 16 +STEREOBM_FILTERCAP ?= 31 +STEREOBM_THRESHOLD ?= 10 +STEREOBM_UNIQUENESS ?= 0 +STEREOBM_MINDISP ?= 0 +STEREOBM_TILESIZE ?= 64 + +STEREOBM_GEN_PARAMS := winsize=$(STEREOBM_WINSIZE) depth=$(STEREOBM_DEPTH) tilesize=$(STEREOBM_TILESIZE) threshold=$(STEREOBM_THRESHOLD) mindisp=$(STEREOBM_MINDISP) uniqueness_ratio=$(STEREOBM_UNIQUENESS) filtercap=$(STEREOBM_FILTERCAP) + +STEREOBM_DEFINES := -DWINSIZE=$(STEREOBM_WINSIZE) -DDEPTH=$(STEREOBM_DEPTH) -DPREFILTER_CAP=$(STEREOBM_FILTERCAP) -DTEXTURE_THRESHOLD=$(STEREOBM_THRESHOLD) -DUNIQUENESS_RATIO=$(STEREOBM_UNIQUENESS) -DMIN_DISP=$(STEREOBM_MINDISP) + +# Always build and test the no-OpenCV variant; add OpenCV if available +BUILD_TARGETS := $(BIN)/$(HL_TARGET)/process +TEST_OUTPUTS := $(BIN)/$(HL_TARGET)/out.png +ifeq ($(STEREOBM_BUILD_OPENCV),1) + BUILD_TARGETS += $(BIN)/$(HL_TARGET)/process_opencv + TEST_OUTPUTS += $(BIN)/$(HL_TARGET)/out2.png +endif + +.PHONY: build clean test + +build: $(BUILD_TARGETS) + +$(GENERATOR_BIN)/stereobm.generator: stereobm_generator.cpp $(GENERATOR_DEPS) + @mkdir -p $(@D) + $(CXX) $(CXXFLAGS) $(filter %.cpp,$^) -o $@ $(LIBHALIDE_LDFLAGS) + +$(BIN)/%/stereobm.a: $(GENERATOR_BIN)/stereobm.generator + @mkdir -p $(@D) + $^ -g stereobm -e $(GENERATOR_OUTPUTS) -o $(@D) -f stereobm target=$* $(STEREOBM_GEN_PARAMS) + +$(BIN)/%/process_opencv: process.cpp $(BIN)/%/stereobm.a + @mkdir -p $(@D) + $(CXX) $(CXXFLAGS) -DSTEREOBM_BUILD_OPENCV=1 $(STEREOBM_DEFINES) $(OPENCV_CXXFLAGS) -I$(BIN)/$* -Wall -O3 $^ -o $@ $(LDFLAGS) $(IMAGE_IO_FLAGS) $(CUDA_LDFLAGS) $(OPENCL_LDFLAGS) $(OPENCV_LIBS) + +$(BIN)/%/process: process.cpp $(BIN)/%/stereobm.a + @mkdir -p $(@D) + $(CXX) $(CXXFLAGS) -DSTEREOBM_BUILD_OPENCV=0 $(STEREOBM_DEFINES) -I$(BIN)/$* -Wall -O3 $^ -o $@ $(LDFLAGS) $(IMAGE_IO_FLAGS) $(CUDA_LDFLAGS) $(OPENCL_LDFLAGS) + +$(BIN)/%/out.png: $(BIN)/%/process_opencv + @mkdir -p $(@D) + $< $(IMAGES)/aloeL.png $(IMAGES)/aloeR.png $@ + +$(BIN)/%/out2.png: $(BIN)/%/process + @mkdir -p $(@D) + $< $(IMAGES)/aloeL.png $(IMAGES)/aloeR.png $@ + +clean: + rm -rf $(BIN) + +test: $(TEST_OUTPUTS) diff --git a/apps/stereobm/process.cpp b/apps/stereobm/process.cpp new file mode 100644 index 000000000000..c65b6197a88b --- /dev/null +++ b/apps/stereobm/process.cpp @@ -0,0 +1,155 @@ +#include +#include +#include +#include +#include + +#include "HalideBuffer.h" +#include "HalideRuntime.h" + +#include "stereobm.h" + +#include "halide_benchmark.h" +#include "halide_image_io.h" + +#if STEREOBM_BUILD_OPENCV +#include +#include +#include +#endif + +using namespace Halide::Tools; + +#if STEREOBM_BUILD_OPENCV +#ifndef WINSIZE +static constexpr int WINSIZE = 9; +#endif +#ifndef DEPTH +static constexpr int DEPTH = 16; +#endif +#ifndef PREFILTER_CAP +static constexpr int PREFILTER_CAP = 31; +#endif +#ifndef TEXTURE_THRESHOLD +static constexpr int TEXTURE_THRESHOLD = 10; +#endif +#ifndef UNIQUENESS_RATIO +static constexpr int UNIQUENESS_RATIO = 0; +#endif +#ifndef MIN_DISP +static constexpr int MIN_DISP = 0; +#endif +#endif + +int main(int argc, char **argv) { + if (argc != 4) { + printf("Usage: %s left right out\n", argv[0]); + return 1; + } + + Halide::Runtime::Buffer left, right; + +#if STEREOBM_BUILD_OPENCV + // Load a pair of 3-channel images and convert to grayscale with OpenCV + cv::Mat left_color = cv::imread(argv[1], cv::IMREAD_COLOR); + cv::Mat right_color = cv::imread(argv[2], cv::IMREAD_COLOR); + if (left_color.empty() || right_color.empty()) { + fprintf(stderr, "OpenCV could not read %s / %s\n", argv[1], argv[2]); + return 1; + } + cv::Mat cv_left, cv_right; + cv::cvtColor(left_color, cv_left, cv::COLOR_BGR2GRAY); + cv::cvtColor(right_color, cv_right, cv::COLOR_BGR2GRAY); + + auto gray_to_buffer = [](const cv::Mat &g) { + Halide::Runtime::Buffer buf(g.cols, g.rows); + buf.for_each_element([&](int i, int j) { + buf(i, j) = g.at(j, i); + }); + return buf; + }; + left = gray_to_buffer(cv_left); + right = gray_to_buffer(cv_right); +#else + // Without OpenCV, load with Halide's image IO and manually convert to grayscale + auto load_gray = [](const char *path) { + Halide::Runtime::Buffer color = load_and_convert_image(path); + Halide::Runtime::Buffer gray(color.width(), color.height()); + gray.for_each_element([&](int i, int j) { + uint32_t r = color(i, j, 0), g = color(i, j, 1), b = color(i, j, 2); + gray(i, j) = (uint8_t)((r * 4899 + g * 9617 + b * 1868 + 8192) >> 14); + }); + return gray; + }; + left = load_gray(argv[1]); + right = load_gray(argv[2]); +#endif + + Halide::Runtime::Buffer output(left.width(), left.height()); + + double best = benchmark([&]() { + stereobm(left, right, output); + output.device_sync(); + }); + printf("Halide time: %gms\n", best * 1e3); + +#if STEREOBM_BUILD_OPENCV + cv::Ptr bm = cv::StereoBM::create(DEPTH, WINSIZE); + bm->setPreFilterType(cv::StereoBM::PREFILTER_XSOBEL); + bm->setPreFilterCap(PREFILTER_CAP); + bm->setMinDisparity(MIN_DISP); + bm->setTextureThreshold(TEXTURE_THRESHOLD); + bm->setUniquenessRatio(UNIQUENESS_RATIO); + + cv::Mat cv_disp; + double cv_best = benchmark([&]() { + bm->compute(cv_left, cv_right, cv_disp); + }); + printf("OpenCV time: %gms\n", cv_best * 1e3); + + const int32_t invalid = (MIN_DISP - 1) * 16; + long long compared = 0; + long long sum_abs = 0; + int max_abs = 0; + if (output.width() != cv_disp.cols || output.height() != cv_disp.rows) { + fprintf(stderr, "Output size %d x %d doesn't match OpenCV's output size %d x %d\n", + output.width(), output.height(), cv_disp.cols, cv_disp.rows); + return 1; + } + output.for_each_element([&](int i, int j) { + int32_t h = output(i, j); + int32_t o = cv_disp.at(j, i); + if (h == invalid || o == invalid) return; + int diff = std::abs(h - o); + compared++; + sum_abs += diff; + max_abs = std::max(max_abs, diff); + }); + + if (compared > 0) { + printf("compared %lld pixels\n", compared); + printf("mean abs diff: %g px\n", + (sum_abs / (double)compared) / 16.0); + printf("max abs diff: %g px\n", max_abs / 16.0); + } else { + printf("no overlapping valid pixels to compare\n"); + } +#endif + + // normalize output to range [0, 255] + int32_t dmin = INT32_MAX, dmax = INT32_MIN; + output.for_each_value([&](int32_t v) { + dmin = std::min(dmin, v); + dmax = std::max(dmax, v); + }); + double scale = (dmax > dmin) ? 255.0 / (dmax - dmin) : 0.0; + Halide::Runtime::Buffer vis(output.width(), output.height()); + vis.for_each_element([&](int i, int j) { + int n = (output(i, j) - dmin) * scale + 0.5; + vis(i, j) = std::max(0, std::min(255, n)); + }); + convert_and_save_image(vis, argv[3]); + + printf("Success!\n"); + return 0; +} diff --git a/apps/stereobm/stereobm.cpp b/apps/stereobm/stereobm.cpp deleted file mode 100644 index ffda5b55f0ff..000000000000 --- a/apps/stereobm/stereobm.cpp +++ /dev/null @@ -1,42 +0,0 @@ -#include -#include -#include - -#include "HalideBuffer.h" -#include "HalideRuntime.h" - -#include "stereobm.h" -#include "stereobm_auto_schedule.h" - -#include "halide_benchmark.h" -#include "halide_image_io.h" - -using namespace Halide::Tools; - -int main(int argc, char **argv) { - if (argc != 4) { - printf("Usage: %s left right out\n", argv[0]); - return 1; - } - - Halide::Runtime::Buffer left = load_and_convert_image(argv[1]); - Halide::Runtime::Buffer right = load_and_convert_image(argv[2]); - Halide::Runtime::Buffer output(left.width(), left.height()); - - double best_manual = benchmark([&]() { - stereobm(left, right, output); - output.device_sync(); - }); - printf("Manually-tuned time: %gms\n", best_manual * 1e3); - - double best_auto = benchmark([&]() { - stereobm_auto_scheudle(left, right, output); - output.device_sync(); - }); - printf("Auto-scheduled time: %gms\n", best_auto * 1e3); - - convert_and_save_image(output, argv[2]); - - printf("Success!\n"); - return 0; -} diff --git a/apps/stereobm/stereobm_generator.cpp b/apps/stereobm/stereobm_generator.cpp index 82c89da08dee..0f49284505f2 100644 --- a/apps/stereobm/stereobm_generator.cpp +++ b/apps/stereobm/stereobm_generator.cpp @@ -1,144 +1,193 @@ +// M*////////////////////////////////////////////////////////////////////////////////////// +// +// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. +// +// By downloading, copying, installing or using the software you agree to this license. +// If you do not agree to this license, do not download, install, +// copy or use the software. +// +// +// License Agreement +// For Open Source Computer Vision Library +// +// Copyright (C) 2000, Intel Corporation, all rights reserved. +// Copyright (C) 2013, OpenCV Foundation, all rights reserved. +// Third party copyrights are property of their respective owners. +// +// Redistribution and use in source and binary forms, with or without modification, +// are permitted provided that the following conditions are met: +// +// * Redistribution's of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// * Redistribution's in binary form must reproduce the above copyright notice, +// this list of conditions and the following disclaimer in the documentation +// and/or other materials provided with the distribution. +// +// * The name of the copyright holders may not be used to endorse or promote products +// derived from this software without specific prior written permission. +// +// This software is provided by the copyright holders and contributors "as is" and +// any express or implied warranties, including, but not limited to, the implied +// warranties of merchantability and fitness for a particular purpose are disclaimed. +// In no event shall the Intel Corporation or contributors be liable for any direct, +// indirect, incidental, special, exemplary, or consequential damages +// (including, but not limited to, procurement of substitute goods or services; +// loss of use, data, or profits; or business interruption) however caused +// and on any theory of liability, whether in contract, strict liability, +// or tort (including negligence or otherwise) arising in any way out of +// the use of this software, even if advised of the possibility of such damage. +// +// M*/ + +// Halide adaptation of https://github.com/opencv/opencv/blob/4.x/modules/calib3d/src/stereobm.cpp + #include "Halide.h" using namespace Halide; using namespace Halide::BoundaryConditions; -Var x, y, c; - -Func stereobm_func(Func input0, Func input1, int winsize, int depth, int tilesize, int ftzero, int threshold, int mindisp, int uniqueness_ratio, int filtercap, Target target) { - const Type int8 = Int(8); - const Type uint16 = UInt(16); - const Type int32 = Int(32); - const int native_lanes = target.natural_vector_size(); - - Var x("x"); - Var y("y"); - Var c("c"); - Var d("d"); - Var di("di"); - Var xi("xi"), yi("yi"), xo("xo"), yo("yo"); - - Func proc0("proc0"), proc1("proc1"); - proc0(y, x, c) = BoundaryConditions::constant_exterior(input0, 0)(y, x, c); - proc1(y, x, c) = BoundaryConditions::constant_exterior(input1, 0)(y, x, c); - - Func b0("b0"), b1("b1"); - // convert to grayscale - b0(y, x) = cast(cast((cast(proc0(y, x, 0)) * 1868 + cast(proc0(y, x, 1)) * 9617 + cast(proc0(y, x, 2)) * 4899 + 8192) >> 14)); - b1(y, x) = cast(cast((cast(proc1(y, x, 0)) * 1868 + cast(proc1(y, x, 1)) * 9617 + cast(proc1(y, x, 2)) * 4899 + 8192) >> 14)); - - // prefiltering with sobel filter - Func xsobel0("xsobel0"), xsobel1("xsobel1"); - Expr e0 = b0(y + 1, x - 1) - b0(y - 1, x - 1) + 2 * b0(y + 1, x) - 2 * b0(y - 1, x) + b0(y + 1, x + 1) - b0(y - 1, x + 1); - Expr e1 = b1(y + 1, x - 1) - b1(y - 1, x - 1) + 2 * b1(y + 1, x) - 2 * b1(y - 1, x) + b1(y + 1, x + 1) - b1(y - 1, x + 1); - xsobel0(y, x) = cast(clamp(e0, -filtercap, filtercap) + filtercap); - xsobel1(y, x) = cast(clamp(e1, -filtercap, filtercap) + filtercap); - - Func diff("diff"); - diff(di, yi, x, yo) = Halide::cast(cast(abs((xsobel0(yi + yo * tilesize, x)) - (xsobel1(yi + yo * tilesize + di - depth + 1, x))))); - - Func vsum(uint16, std::string("vsum")); - Func zero_blur(uint16, "zero_blur"); - RDom rx0(0, winsize); - zero_blur(di, yi, yo) = sum(cast(diff(di, yi, rx0, yo))); - vsum(di, yi, x, yo) = select(x <= 0, zero_blur(di, yi, yo), likely(vsum(di, yi, max(x - 1, 0), yo) + diff(di, yi, x + winsize - 1, yo) - diff(di, yi, max(x - 1, 0), yo))); /// should be x-1 - Func blur_y(uint16, 1, "blur_y"); - RDom ry(0, tilesize, "ry"); - RDom ry1(1, depth - 1, "ry1"); - Func f1("f1"); - f1(di, x, yo) = sum(vsum(di, rx0, x, yo)); - blur_y(di, yi, x, yo) = select(yi <= 0, f1(di, x, yo), likely(blur_y(di, max(yi - 1, 0), x, yo) + vsum(di, yi + winsize - 1, x, yo) - vsum(di, max(yi - 1, 0), x, yo))); - - Func text("text"), zerotext("zerotext"), textsum("textsum"), textf1("textf1"), textblury("textblury"); - text(yi, x, yo) = cast(abs(cast(b0(yi + yo * tilesize, x)) - cast(ftzero))); - zerotext(yi, yo) = sum(cast(text(yi, rx0, yo))); - textsum(yi, x, yo) = select(x <= 0, zerotext(yi, yo), textsum(yi, x - 1, yo) + text(yi, x + winsize - 1, yo) - text(yi, x - 1, yo)); - textf1(x, yo) = sum(textsum(rx0, x, yo)); - textblury(yi, x, yo) = undef(); - textblury(ry, x, yo) = select(ry == 0, textf1(x, yo), textblury(max(ry - 1, 0), x, yo) + textsum(ry + winsize - 1, x, yo) - textsum(max(ry - 1, 0), x, yo)); - - Func preout("preout"); - RDom rd(0, depth, "rd"); - preout(yi, x, yo) = cast(65535); - preout(yi, x, yo) = min(blur_y(rd, yi, x, yo), preout(yi, x, yo)); - - Func prearg("prearg"); - prearg(di, yi, x, yo) = select(preout(yi, x, yo) == blur_y(di, yi, x, yo), cast(di), cast(65535)); - Func argmin1("argmin"); - argmin1(yi, x, yo) = cast(65535); - argmin1(yi, x, yo) = min(argmin1(yi, x, yo), prearg(rd, yi, x, yo)); - - Func second_best("second_best"); - second_best(di, yi, x, yo) = select(abs(di - cast(argmin1(yi, x, yo))) <= 1, cast(65535), blur_y(di, yi, x, yo)); - Func argmin2("argmin2"); - argmin2(yi, x, yo) = cast(65535); - argmin2(yi, x, yo) = min(argmin2(yi, x, yo), second_best(rd, yi, x, yo)); - - Func p_clamped("p_clamped"); - p_clamped(yi, x, yo) = unsafe_promise_clamped(argmin1(yi, x, yo), 1, depth - 2); - - Func subpout(int32, "subpout"); - Expr p = cast(blur_y(cast(int32, p_clamped(yi, x, yo)) + 1, yi, x, yo)); - Expr n = cast(blur_y(cast(int32, p_clamped(yi, x, yo)) - 1, yi, x, yo)); - Expr d1 = p + n - 2 * preout(yi, x, yo) + abs(p - n); - Expr subpout_expr = cast((cast(depth - p_clamped(yi, x, yo) - 1 + mindisp) * 256 + (select(d1 == 0, 0, (p - n) * 256 / d1) + 15)) >> 4); - subpout(yi, x, yo) = select(argmin1(yi, x, yo) > 0 && argmin1(yi, x, yo) < depth - 1, subpout_expr, cast(depth - argmin1(yi, x, yo) - 1 + mindisp) * 16); - - Func splitoutput("splitoutput"), output("output"); - splitoutput(yi, x, yo) = select((textblury(yi, x, yo) < threshold || cast(argmin2(yi, x, yo)) <= cast(preout(yi, x, yo)) + (cast(preout(yi, x, yo)) * cast(uniqueness_ratio)) / 100), 0, subpout(yi, x, yo)); - output(y, x) = splitoutput(y % tilesize, x, y / tilesize); - - b0.compute_root().vectorize(y, native_lanes * 4); - b1.compute_root().vectorize(y, native_lanes * 4); - xsobel0.compute_root().vectorize(y, native_lanes * 4); - xsobel1.compute_root().vectorize(y, native_lanes * 4); - - preout.compute_at(splitoutput, yi).update().atomic(false).vectorize(rd, depth); - argmin1.compute_at(splitoutput, yi).update().atomic(false).vectorize(rd, depth); - argmin2.compute_at(splitoutput, yi).update().atomic(false).vectorize(rd, depth); - - splitoutput.compute_root().reorder_storage(yi, yo, x).parallel(yo); - - blur_y.bound(di, 0, depth); - vsum.bound(di, 0, depth); - - blur_y.compute_at(splitoutput, x).store_at(splitoutput, x).vectorize(di, depth).fold_storage(yi, 2); - vsum.compute_at(splitoutput, x).store_at(splitoutput, yo).vectorize(di, depth).fold_storage(x, 2); - - f1.compute_at(splitoutput, x).vectorize(di, depth); - zero_blur.compute_at(splitoutput, yo).vectorize(di, depth); - - zerotext.compute_at(splitoutput, yo); - textf1.compute_at(splitoutput, x); - textsum.compute_at(splitoutput, x).store_at(splitoutput, yo).fold_storage(x, 2); - textblury.compute_at(splitoutput, x); - // subpout.compute_at(splitoutput, x); - - output.vectorize(y, native_lanes); - - return output; -} - class StereoBM : public Generator { public: - // Inputs: two images of the same scene as seen by a left and right eye - Input> left_color{"left_color"}; - Input> right_color{"right_color"}; - - GeneratorParam winsize{"winsize", 15}; // Size of box surrounding each to sum diffs over - GeneratorParam depth{"depth", 64}; // range of disparities to test - GeneratorParam tilesize{"tilesize", 64}; - GeneratorParam ftzero{"ftzero", 0}; - GeneratorParam threshold{"threshold", 10}; - GeneratorParam mindisp{"mindisp", 0}; - GeneratorParam uniqueness_ratio{"uniqueness_ratio", 15}; - GeneratorParam filtercap{"filtercap", 31}; - + // Inputs: two grayscale images of the same scene as seen by a left and right camera + Input> left_gray{"left_gray"}; + Input> right_gray{"right_gray"}; + + GeneratorParam winsize{"winsize", 9}; // size of block surrounding each pixel to compare; must be odd + GeneratorParam depth{"depth", 16}; // maximum number of disparities to consider + GeneratorParam tilesize{"tilesize", 64}; // strip size + GeneratorParam threshold{"threshold", 10}; // reject pixels if sum of prefiltered pixels in block is less than this + GeneratorParam mindisp{"mindisp", 0}; // minimum disparity to consider. + GeneratorParam uniqueness_ratio{"uniqueness_ratio", 0}; // reject if the second-best match is too close to the best match, as a percentage of the best match score. + GeneratorParam filtercap{"filtercap", 31}; // clamp the prefiltering output to the range [0, filtercap*2]. Output> output{"output"}; void generate() { - Func stereo = stereobm_func(left_color, right_color, winsize, depth, tilesize, ftzero, threshold, mindisp, uniqueness_ratio, filtercap, get_target()); - output = stereo; + const Type uint16 = UInt(16); + const Type int32 = Int(32); + const int native_lanes = get_target().natural_vector_size(); + + Var y("y"); + Var x("x"); + Var c("c"); + Var di("di"); + Var xi("xi"), xo("xo"); + + Expr W = left_gray.dim(0).extent(); + Expr H = left_gray.dim(1).extent(); + + Func proc0("proc0"), proc1("proc1"); + // shift the input to ensure the indices of blur_y correspond to the center pixel in the window. + proc0(x, y) = cast(BoundaryConditions::mirror_interior(left_gray)(x - winsize / 2, y - winsize / 2)); + proc1(x, y) = cast(BoundaryConditions::mirror_interior(right_gray)(x - winsize / 2, y - winsize / 2)); + + Func b0("b0"), b1("b1"); + + // prefiltering with sobel filter + Func xsobel0("xsobel0"), xsobel1("xsobel1"); + Expr e0 = proc0(x + 1, y - 1) - proc0(x - 1, y - 1) + 2 * proc0(x + 1, y) - 2 * proc0(x - 1, y) + proc0(x + 1, y + 1) - proc0(x - 1, y + 1); + Expr e1 = proc1(x + 1, y - 1) - proc1(x - 1, y - 1) + 2 * proc1(x + 1, y) - 2 * proc1(x - 1, y) + proc1(x + 1, y + 1) - proc1(x - 1, y + 1); + Expr ix = x - winsize / 2, iy = y - winsize / 2; // image-space coordinates + Expr border = ix == 0 || ix == W - 1 || ((H % 2 == 1) && iy == H - 1); + xsobel0(x, y) = select(border, cast(filtercap), cast(clamp(e0, -1 * filtercap, filtercap) + filtercap)); + xsobel1(x, y) = select(border, cast(filtercap), cast(clamp(e1, -1 * filtercap, filtercap) + filtercap)); + + Func diff("diff"); + // for each disparity di, sample right image (depth-1-di)+mindisp pixels left of the left image's pixel + // image is divided into strips indexed by xo that are processed in parallel + diff(di, xi, y, xo) = Halide::cast(cast(abs((xsobel0(xi + xo * tilesize, y)) - (xsobel1(xi + xo * tilesize + di - depth + 1 - mindisp, y))))); + + // compute the sum of absolute differences (SAD) for each pixel and disparity + Func vsum(uint16, std::string("vsum")); + Func zero_blur(uint16, "zero_blur"); + RDom rwin(0, winsize, "rwin"); + zero_blur(di, xi, xo) = sum(cast(diff(di, xi, rwin, xo))); + vsum(di, xi, y, xo) = select(y <= 0, zero_blur(di, xi, xo), likely(vsum(di, xi, max(y - 1, 0), xo) + diff(di, xi, y + winsize - 1, xo) - diff(di, xi, max(y - 1, 0), xo))); + Func blur_y(uint16, "blur_y"); + RDom rx(0, tilesize, "rx"); + Func f1("f1"); + f1(di, y, xo) = sum(vsum(di, rwin, y, xo)); + blur_y(di, xi, y, xo) = select(xi <= 0, f1(di, y, xo), likely(blur_y(di, max(xi - 1, 0), y, xo) + vsum(di, xi + winsize - 1, y, xo) - vsum(di, max(xi - 1, 0), y, xo))); + + // compute the texture value for each pixel, which is the sum of pixels in the surrounding block + Func text("text"), zerotext("zerotext"), textsum("textsum"), textf1("textf1"), textblury("textblury"); + text(xi, y, xo) = cast(abs(cast(xsobel0(xi + xo * tilesize, y)) - cast(filtercap))); + zerotext(xi, xo) = sum(cast(text(xi, rwin, xo))); + textsum(xi, y, xo) = select(y <= 0, zerotext(xi, xo), textsum(xi, y - 1, xo) + text(xi, y + winsize - 1, xo) - text(xi, y - 1, xo)); + textf1(y, xo) = sum(textsum(rwin, y, xo)); + textblury(xi, y, xo) = undef(); + textblury(rx, y, xo) = select(rx == 0, textf1(y, xo), textblury(max(rx - 1, 0), y, xo) + textsum(rx + winsize - 1, y, xo) - textsum(max(rx - 1, 0), y, xo)); + + // compute the best and second-best disparity for each pixel + Func preout("preout"); + RDom rd(0, depth, "rd"); + preout(xi, y, xo) = cast(65535); + preout(xi, y, xo) = min(blur_y(rd, xi, y, xo), preout(xi, y, xo)); + Func prearg("prearg"); + prearg(di, xi, y, xo) = select(preout(xi, y, xo) == blur_y(di, xi, y, xo), cast(di), cast(65535)); + Func argmin1("argmin1"); + argmin1(xi, y, xo) = cast(65535); + argmin1(xi, y, xo) = min(argmin1(xi, y, xo), prearg(rd, xi, y, xo)); + Func second_best("second_best"); + second_best(di, xi, y, xo) = select(abs(di - cast(argmin1(xi, y, xo))) <= 1, cast(65535), blur_y(di, xi, y, xo)); + Func argmin2("argmin2"); + argmin2(xi, y, xo) = cast(65535); + argmin2(xi, y, xo) = min(argmin2(xi, y, xo), second_best(rd, xi, y, xo)); + Func p_clamped("p_clamped"); + p_clamped(xi, y, xo) = clamp(argmin1(xi, y, xo), 1, depth - 2); // indexes into blur_y + + // subpixel refinement + Func subpout(int32, "subpout"); + Expr p = cast(blur_y(cast(int32, p_clamped(xi, y, xo)) + 1, xi, y, xo)); + Expr n = cast(blur_y(cast(int32, p_clamped(xi, y, xo)) - 1, xi, y, xo)); + Expr d1 = p + n - 2 * preout(xi, y, xo) + abs(p - n); + Expr q = (abs(p - n) * 256) / d1; + Expr quot = select(p >= n, q, -q); + Expr subpout_expr = cast((cast(depth - p_clamped(xi, y, xo) - 1 + mindisp) * 256 + (select(d1 == 0, 0, quot) + 15)) >> 4); + subpout(xi, y, xo) = select(argmin1(xi, y, xo) > 0 && argmin1(xi, y, xo) < depth - 1, subpout_expr, cast(depth - argmin1(xi, y, xo) - 1 + mindisp) * 16); + + // edge case handling + Expr filtered = cast((mindisp - 1) * 16); + Expr reject = textblury(xi, y, xo) < threshold; // reject if block texture is too uniform + if (int(uniqueness_ratio) > 0) { // reject if second-best disparity is too close to best disparity + reject = reject || (cast(argmin2(xi, y, xo)) <= cast(preout(xi, y, xo)) + (cast(preout(xi, y, xo)) * cast(uniqueness_ratio)) / 100); + } + Func splitoutput("splitoutput"); + splitoutput(xi, y, xo) = select(reject, filtered, subpout(xi, y, xo)); + + // disparities are only valid where the SAD window and the full disparity search both fit inside the image. + Expr sw2 = winsize / 2; + Expr in_valid_roi = x >= (Expr(mindisp) + Expr(depth) - 1) + sw2 && x < W - mindisp - sw2 && + y >= sw2 && y < H - sw2; + output(x, y) = select(in_valid_roi, splitoutput(x % tilesize, y, x / tilesize), filtered); + + proc0.compute_root().vectorize(x, native_lanes * 4); + proc1.compute_root().vectorize(x, native_lanes * 4); + xsobel0.compute_root().vectorize(x, native_lanes * 4); + xsobel1.compute_root().vectorize(x, native_lanes * 4); + + preout.compute_at(splitoutput, xi).update().atomic(false).vectorize(rd, depth); + argmin1.compute_at(splitoutput, xi).update().atomic(false).vectorize(rd, depth); + argmin2.compute_at(splitoutput, xi).update().atomic(false).vectorize(rd, depth); + + subpout.compute_at(splitoutput, xi).vectorize(xi, native_lanes); + splitoutput.compute_root().reorder_storage(xi, xo, y).parallel(xo).vectorize(xi, native_lanes); + + blur_y.bound(di, 0, depth); + vsum.bound(di, 0, depth); + + blur_y.compute_at(splitoutput, y).store_at(splitoutput, y).vectorize(di, depth).fold_storage(xi, 2); + vsum.compute_at(splitoutput, y).store_at(splitoutput, xo).vectorize(di, depth).fold_storage(y, 2); + + f1.compute_at(splitoutput, y).vectorize(di, depth); + zero_blur.compute_at(splitoutput, xo).vectorize(di, depth); + + zerotext.compute_at(splitoutput, xo); + textf1.compute_at(splitoutput, y); + textsum.compute_at(splitoutput, y).store_at(splitoutput, xo).fold_storage(y, 2); + textblury.compute_at(splitoutput, y); + + output.vectorize(x, native_lanes); } }; diff --git a/apps/vcpkg.json b/apps/vcpkg.json index 1c3c5805f7ca..1c22114d1063 100644 --- a/apps/vcpkg.json +++ b/apps/vcpkg.json @@ -21,6 +21,7 @@ "name": "opencl", "platform": "(windows & x64 & !uwp & !xbox) | (linux & x64) | (linux & arm64)" }, + "opencv4", "protobuf", "pybind11", "tensorflow-lite" diff --git a/src/Monotonic.cpp b/src/Monotonic.cpp index 82934a31de5e..68298975e6ba 100644 --- a/src/Monotonic.cpp +++ b/src/Monotonic.cpp @@ -509,7 +509,7 @@ ConstantInterval derivative_bounds(const Expr &e, const std::string &var, const return ConstantInterval::everything(); } DerivativeBounds m(var, scope); - remove_likelies(remove_promises(e)).accept(&m); + simplify(remove_likelies(remove_promises(e))).accept(&m); return m.result; } From 821b77107bf032a99c998e3dd7927101f6fb63d3 Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Tue, 23 Jun 2026 23:44:26 -0400 Subject: [PATCH 26/42] more robust inductive functions --- src/BoundsInference.cpp | 1 + src/Inductive.cpp | 67 ++++++++++++++------- test/error/CMakeLists.txt | 1 + test/error/inductive_cond_nested_select.cpp | 18 ++++++ 4 files changed, 66 insertions(+), 21 deletions(-) create mode 100644 test/error/inductive_cond_nested_select.cpp diff --git a/src/BoundsInference.cpp b/src/BoundsInference.cpp index ac5af651c70a..17ed5116c275 100644 --- a/src/BoundsInference.cpp +++ b/src/BoundsInference.cpp @@ -387,6 +387,7 @@ class BoundsInference : public IRMutator { // don't care what sites are loaded, just what sites need // to have the correct value in them. So remap all selects // to if_then_elses to get tighter bounds. + // The implementation of expand_to_base_case relies on this conversion. class SelectToIfThenElse : public IRMutator { using IRMutator::visit; Expr visit(const Select *op) override { diff --git a/src/Inductive.cpp b/src/Inductive.cpp index 8b68fdac4ac2..5e97f24240bd 100644 --- a/src/Inductive.cpp +++ b/src/Inductive.cpp @@ -31,33 +31,58 @@ class BaseCaseSolver : public IRVisitor { int nested_select = 0; + void visit(const Select *op) override { + std::cout << "what"; + } + void visit(const Call *op) override { if (op->is_intrinsic(Call::if_then_else)) { - if (nested_select == 0) { - visit_with(op->args[0], [&](auto *self, const Call *inner_op) { - user_assert(inner_op->name != func) << "Function " << func << " contains an inductive function reference outside of a select operation value.\n"; - self->visit_base(inner_op); - }); - } + // Theoretically there is no need to check op->args[0]. + // Select nodes are only converted to if_then_else when the condition is pure, + // which means the condition cannot have any recursive calls. + // std::cout<<"cond is" << op->args[0]; + op->args[0].accept(this); + + bool left_recurse = false, right_recurse = false; + visit_with(op->args[1], [&](auto *self, const Call *inner_op) { + if (inner_op->name == func) { + left_recurse = true; + } + self->visit_base(inner_op); + }); + visit_with(op->args[2], [&](auto *self, const Call *inner_op) { + if (inner_op->name == func) { + right_recurse = true; + } + self->visit_base(inner_op); + }); + // Again, this check is theoretically unnecessary + user_assert(!(left_recurse && right_recurse)) << "Select node in inductive function " << func << " does not have a base case"; nested_select += 1; vector old_intervals = condition_intervals; - for (size_t i = 0; i < vars.size(); i++) { - Interval inter = Interval::make_intersection(old_intervals[i], solve_for_outer_interval(simplify(op->args[0]), vars[i])); - condition_intervals[i] = Interval(inter.min, Interval::pos_inf()); - bounds.push(vars[i], condition_intervals[i]); - } - op->args[1].accept(this); - for (size_t i = 0; i < vars.size(); i++) { - Interval inter = Interval::make_intersection(old_intervals[i], solve_for_outer_interval(simplify(!op->args[0]), vars[i])); - condition_intervals[i] = Interval(inter.min, Interval::pos_inf()); - bounds.pop(vars[i]); - bounds.push(vars[i], condition_intervals[i]); + if (left_recurse) { + for (size_t i = 0; i < vars.size(); i++) { + Interval inter = Interval::make_intersection(old_intervals[i], solve_for_outer_interval(simplify(op->args[0]), vars[i])); + condition_intervals[i] = Interval(inter.min, Interval::pos_inf()); + bounds.push(vars[i], condition_intervals[i]); + } + op->args[1].accept(this); + for (const auto &var : vars) { + bounds.pop(var); + } } - op->args[2].accept(this); - condition_intervals = old_intervals; - for (const auto &var : vars) { - bounds.pop(var); + if (right_recurse) { + for (size_t i = 0; i < vars.size(); i++) { + Interval inter = Interval::make_intersection(old_intervals[i], solve_for_outer_interval(simplify(!op->args[0]), vars[i])); + condition_intervals[i] = Interval(inter.min, Interval::pos_inf()); + bounds.push(vars[i], condition_intervals[i]); + } + op->args[2].accept(this); + condition_intervals = old_intervals; + for (const auto &var : vars) { + bounds.pop(var); + } } nested_select -= 1; } else if (op->name == func) { diff --git a/test/error/CMakeLists.txt b/test/error/CMakeLists.txt index 315aaaf54591..1ddf2a8776bd 100644 --- a/test/error/CMakeLists.txt +++ b/test/error/CMakeLists.txt @@ -76,6 +76,7 @@ tests( incomplete_target.cpp inductive_2d_arbitrary.cpp inductive_cond_nested.cpp + inductive_cond_nested_select.cpp inductive_cond_self_reference.cpp inductive_loop_1.cpp inductive_loop_2.cpp diff --git a/test/error/inductive_cond_nested_select.cpp b/test/error/inductive_cond_nested_select.cpp new file mode 100644 index 000000000000..088d861de925 --- /dev/null +++ b/test/error/inductive_cond_nested_select.cpp @@ -0,0 +1,18 @@ +#include "Halide.h" +#include + +using namespace Halide; + +int main(int argc, char **argv) { + Func f(Int(32), "f"), g("g"); + + Var x("x"); + + f(x) = select(x < 0, 0, f(x - 1) + select(x < f(x + 1), 0, 1)); + g(x) = f(x) * 2; + + g.realize({10}); + + printf("Success!\n"); + return 0; +} From 0781a7d0d66fd2a1ade4bbb478c9c23ecf28678e Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Wed, 24 Jun 2026 00:24:05 -0400 Subject: [PATCH 27/42] remove test --- src/Inductive.cpp | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/Inductive.cpp b/src/Inductive.cpp index 5e97f24240bd..b098336945a1 100644 --- a/src/Inductive.cpp +++ b/src/Inductive.cpp @@ -31,10 +31,6 @@ class BaseCaseSolver : public IRVisitor { int nested_select = 0; - void visit(const Select *op) override { - std::cout << "what"; - } - void visit(const Call *op) override { if (op->is_intrinsic(Call::if_then_else)) { // Theoretically there is no need to check op->args[0]. From 16648c39c92439c34cdb47d44eb50ea7d18ba46d Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Wed, 24 Jun 2026 00:26:27 -0400 Subject: [PATCH 28/42] fix another bug --- src/Inductive.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Inductive.cpp b/src/Inductive.cpp index b098336945a1..8293a1b75e9e 100644 --- a/src/Inductive.cpp +++ b/src/Inductive.cpp @@ -75,11 +75,11 @@ class BaseCaseSolver : public IRVisitor { bounds.push(vars[i], condition_intervals[i]); } op->args[2].accept(this); - condition_intervals = old_intervals; for (const auto &var : vars) { bounds.pop(var); } } + condition_intervals = old_intervals; nested_select -= 1; } else if (op->name == func) { user_assert(nested_select > 0) << "Function " << func << " contains an inductive function reference outside of a select operation value.\n"; From a0021bf14ad5d1793bf4518165380047ca772fc3 Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Wed, 24 Jun 2026 16:00:04 -0400 Subject: [PATCH 29/42] Fix issues for tuples and add test; fix opencv dependency (latter part was co-authored by Claude Opus 4.7 --- apps/stereobm/Makefile | 11 ++++--- src/BoundsInference.cpp | 4 +-- src/Func.cpp | 16 ++++++---- src/Func.h | 5 +++ src/Function.cpp | 4 ++- src/IR.cpp | 12 +++++--- src/Inductive.cpp | 8 +++-- test/correctness/inductive.cpp | 42 ++++++++++++++++++++++++++ test/error/CMakeLists.txt | 1 + test/error/inductive_tuple_to_expr.cpp | 18 +++++++++++ 10 files changed, 101 insertions(+), 20 deletions(-) create mode 100644 test/error/inductive_tuple_to_expr.cpp diff --git a/apps/stereobm/Makefile b/apps/stereobm/Makefile index 0a103f1d49c4..5674b4fec3fa 100644 --- a/apps/stereobm/Makefile +++ b/apps/stereobm/Makefile @@ -1,10 +1,13 @@ include ../support/Makefile.inc # process.cpp compares against OpenCV's StereoBM. -STEREOBM_BUILD_OPENCV ?= 1 -ifeq ($(STEREOBM_BUILD_OPENCV),1) - OPENCV_CXXFLAGS := $(shell pkg-config --cflags opencv4 2>/dev/null) - OPENCV_LIBS := $(shell pkg-config --libs opencv4 2>/dev/null) +# Auto-disable if opencv4 is not available via pkg-config. +OPENCV_CXXFLAGS := $(shell pkg-config --cflags opencv4 2>/dev/null) +OPENCV_LIBS := $(shell pkg-config --libs opencv4 2>/dev/null) +ifeq ($(OPENCV_CXXFLAGS),) + STEREOBM_BUILD_OPENCV ?= 0 +else + STEREOBM_BUILD_OPENCV ?= 1 endif # We set parameters here to feed into both OpenCV and our generator, so that they are consistent. diff --git a/src/BoundsInference.cpp b/src/BoundsInference.cpp index 17ed5116c275..07e0af20b04a 100644 --- a/src/BoundsInference.cpp +++ b/src/BoundsInference.cpp @@ -1012,9 +1012,9 @@ class BoundsInference : public IRMutator { } debug(4) << "Expanding bounds for inductively defined function " << s.func.name() << "\n"; for (const auto &b1 : s.bounds) { - const Box &b = b1.second; + // const Box &b = b1.second; for (const auto &cval : s.exprs) { - s.bounds[b1.first] = expand_to_include_base_case(s.func.args(), cval.value, s.func.name(), b); + s.bounds[b1.first] = expand_to_include_base_case(s.func.args(), cval.value, s.func.name(), s.bounds[b1.first]); } } } diff --git a/src/Func.cpp b/src/Func.cpp index 56c3bc9eea53..6674853855b9 100644 --- a/src/Func.cpp +++ b/src/Func.cpp @@ -75,6 +75,10 @@ Func::Func(const Type &required_type, int required_dims, const string &name) : func({required_type}, required_dims, unique_name(name)) { } +Func::Func(const std::vector &required_types, const string &name) + : func(required_types, AnyDims, unique_name(name)) { +} + Func::Func(const std::vector &required_types, int required_dims, const string &name) : func(required_types, required_dims, unique_name(name)) { } @@ -3400,6 +3404,10 @@ FuncRef::operator Expr() const { << "Can't call Func \"" << func.name() << "\" because it has not yet been defined.\n"; */ + user_assert(func.required_types().empty() || func.outputs() == 1) + << "Can't convert a reference Func \"" << func.name() + << "\" to an Expr, because " << func.name() << " returns a Tuple.\n"; + if (!(func.has_pure_definition() || func.has_extern_definition())) { Type t = Type(Type::Unknown, 0, 1); if (!func.required_types().empty()) { @@ -3409,16 +3417,12 @@ FuncRef::operator Expr() const { func.get_contents(), 0, Buffer<>(), Parameter()); } - user_assert(func.outputs() == 1) - << "Can't convert a reference Func \"" << func.name() - << "\" to an Expr, because " << func.name() << " returns a Tuple.\n"; - return Call::make(func, args); } FuncTupleElementRef FuncRef::operator[](int i) const { - user_assert(func.has_pure_definition() || func.has_extern_definition()) - << "Can't call Func \"" << func.name() << "\" because it has not yet been defined.\n"; + /*user_assert(func.has_pure_definition() || func.has_extern_definition()) + << "Can't call Func \"" << func.name() << "\" because it has not yet been defined.\n"; */ user_assert(func.outputs() != 1) << "Can't index into a reference to Func \"" << func.name() diff --git a/src/Func.h b/src/Func.h index cc023936a907..687c2fead2c5 100644 --- a/src/Func.h +++ b/src/Func.h @@ -766,6 +766,11 @@ class Func { * that many dimensions. */ explicit Func(const Type &required_type, int required_dims, const std::string &name); + /** Declare a new undefined function with the given name. + * If required_types is not empty, the function will be constrained to represent + * Tuples of the same arity and types. (If required_types is empty, there is no constraint.) */ + explicit Func(const std::vector &required_types, const std::string &name); + /** Declare a new undefined function with the given name. * If required_types is not empty, the function will be constrained to represent * Tuples of the same arity and types. (If required_types is empty, there is no constraint.) diff --git a/src/Function.cpp b/src/Function.cpp index a18eb7b88fd0..dd9528920443 100644 --- a/src/Function.cpp +++ b/src/Function.cpp @@ -1033,7 +1033,9 @@ int Function::dimensions() const { } int Function::outputs() const { - return (int)output_types().size(); + return (has_pure_definition() || has_extern_definition()) ? + (int)output_types().size() : + (int)required_types().size(); } const std::vector &Function::output_types() const { diff --git a/src/IR.cpp b/src/IR.cpp index ae0e38a36251..06922580c142 100644 --- a/src/IR.cpp +++ b/src/IR.cpp @@ -599,10 +599,14 @@ Expr Call::make(const Function &func, const std::vector &args, int idx) { internal_assert(idx >= 0 && idx < func.outputs()) << "Value index out of range in call to halide function\n"; - internal_assert(func.has_pure_definition() || func.has_extern_definition()) - << "Call to undefined halide function\n"; - return make(func.output_types()[(size_t)idx], func.name(), args, Halide, - func.get_contents(), idx, Buffer<>(), Parameter()); + /*internal_assert(func.has_pure_definition() || func.has_extern_definition()) + << "Call to undefined halide function\n"; */ + if (func.has_pure_definition() || func.has_extern_definition()) + return make(func.output_types()[(size_t)idx], func.name(), args, Halide, + func.get_contents(), idx, Buffer<>(), Parameter()); + else + return make(func.required_types()[(size_t)idx], func.name(), args, Halide, + func.get_contents(), idx, Buffer<>(), Parameter()); } namespace { diff --git a/src/Inductive.cpp b/src/Inductive.cpp index 8293a1b75e9e..f6a181c34ce5 100644 --- a/src/Inductive.cpp +++ b/src/Inductive.cpp @@ -134,9 +134,11 @@ Box expand_to_include_base_case(const vector &vars, const Expr &RHS, con BaseCaseSolver b(vars, func, box_required.bounds); substed.accept(&b); for (size_t i = 0; i < vars.size(); i++) { - user_assert(b.result_intervals[i].is_bounded()) << "Unable to prove that the inductive function " << func << " uses a bounded interval"; - Interval new_interval(min(b.result_intervals[i].min, box_required[i].min), box_required[i].max); - box2[i] = new_interval; + user_assert(b.result_intervals[i].is_bounded() || b.result_intervals[i].is_empty()) << "Unable to prove that the inductive function " << func << " uses a bounded interval"; + if (!b.result_intervals[i].is_empty()) { + Interval new_interval(min(b.result_intervals[i].min, box_required[i].min), box_required[i].max); + box2[i] = new_interval; + } } return box2; diff --git a/test/correctness/inductive.cpp b/test/correctness/inductive.cpp index 3532e3e155d0..96e7183394c2 100644 --- a/test/correctness/inductive.cpp +++ b/test/correctness/inductive.cpp @@ -220,6 +220,46 @@ int type_declare_test() { return 0; } +int tuple_test() { + Func g = Func(std::vector{Int(32), Int(32)}, "g"); + Func h("h"); + Var x("x"), y("y"); + + g(x, y) = Tuple(select(x <= 0, 0, g(max(0, x - 1), y)[0] + x + y), x - y); + h(x, y) = g(10, y)[0] / 4 + g(10, y)[1] + x; + + g.compute_root(); + + Buffer im = h.realize({10, 10}); + auto func = [](int x, int y) { + return (y * (5 + 5) + (5 + 5) * (5 + 6) / 2) / 4 + 10 - y + x; + }; + if (check_image(im, func)) { + return 1; + } + return 0; +} + +int tuple_test_2() { + Func g = Func(std::vector{Int(32), Int(32)}, "g"); + Func h("h"); + Var x("x"), y("y"); + + g(x, y) = Tuple(select(x <= 0, 0, g(max(0, x - 1), y)[0] + x + y), select(y <= 0, 0, g(x, max(0, y - 1))[1] + x + y)); + h(x, y) = g(x, y)[0] + g(x, y)[1]; + + g.compute_root(); + + Buffer im = h.realize({10, 10}); + auto func = [](int x, int y) { + return y * x + x * (x + 1) / 2 + x * y + y * (y + 1) / 2; + }; + if (check_image(im, func)) { + return 1; + } + return 0; +} + } // namespace int main(int argc, char **argv) { @@ -238,6 +278,8 @@ int main(int argc, char **argv) { {"1d sum test", sum_1d_test}, {"multi-baseline test", multi_baseline_test}, {"type declaration test", type_declare_test}, + {"tuple test", tuple_test}, + {"tuple test 2", tuple_test_2}, }; using Sharder = Halide::Internal::Test::Sharder; diff --git a/test/error/CMakeLists.txt b/test/error/CMakeLists.txt index 1ddf2a8776bd..dbf6585dbbbd 100644 --- a/test/error/CMakeLists.txt +++ b/test/error/CMakeLists.txt @@ -84,6 +84,7 @@ tests( inductive_nested_select.cpp inductive_no_select.cpp inductive_reorder.cpp + inductive_tuple_to_expr.cpp inductive_update.cpp inductive_var_swap.cpp inductive_vectorize.cpp diff --git a/test/error/inductive_tuple_to_expr.cpp b/test/error/inductive_tuple_to_expr.cpp new file mode 100644 index 000000000000..369595f7a6da --- /dev/null +++ b/test/error/inductive_tuple_to_expr.cpp @@ -0,0 +1,18 @@ +#include "Halide.h" + +using namespace Halide; + +int main(int argc, char **argv) { + Func g = Func(std::vector{Int(32), Int(32)}, "g"); + Func h("h"); + Var x("x"), y("y"); + + g(x, y) = Tuple(select(x <= 0, 0, g(max(0, x - 1), y) + x + y), select(y <= 0, 0, g(x, max(0, y - 1)) + x + y)); + + h(x, y) = g(x, y)[0] / 2; + + h.realize({10, 10}); + + printf("Success!\n"); + return 0; +} From 592983bd3f630f6d719f761fe5137e34a028f57e Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Wed, 24 Jun 2026 16:28:21 -0400 Subject: [PATCH 30/42] fix makefile for sterebm again, co-authored with Claude Opus 4.7 --- apps/stereobm/Makefile | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/apps/stereobm/Makefile b/apps/stereobm/Makefile index 5674b4fec3fa..d5547c44a52e 100644 --- a/apps/stereobm/Makefile +++ b/apps/stereobm/Makefile @@ -1,14 +1,11 @@ include ../support/Makefile.inc # process.cpp compares against OpenCV's StereoBM. -# Auto-disable if opencv4 is not available via pkg-config. +# Auto-disable if opencv4 calib3d header is not available. OPENCV_CXXFLAGS := $(shell pkg-config --cflags opencv4 2>/dev/null) OPENCV_LIBS := $(shell pkg-config --libs opencv4 2>/dev/null) -ifeq ($(OPENCV_CXXFLAGS),) - STEREOBM_BUILD_OPENCV ?= 0 -else - STEREOBM_BUILD_OPENCV ?= 1 -endif +HAVE_OPENCV_CALIB3D := $(shell echo '\#include ' | $(CXX) $(OPENCV_CXXFLAGS) -x c++ - -fsyntax-only 2>/dev/null && echo yes) +STEREOBM_BUILD_OPENCV ?= $(if $(HAVE_OPENCV_CALIB3D),1,0) # We set parameters here to feed into both OpenCV and our generator, so that they are consistent. STEREOBM_WINSIZE ?= 9 From e19a6bce8591b84dfd51eb984302e0c9a0345d67 Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Wed, 24 Jun 2026 17:17:38 -0400 Subject: [PATCH 31/42] add opencv dependency and fix makefile for sterebm again, co-authored with Claude Opus 4.7 --- .github/workflows/testing-make.yml | 1 + apps/stereobm/Makefile | 12 +++++++----- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/.github/workflows/testing-make.yml b/.github/workflows/testing-make.yml index d65c8607b5ab..231711ced5cd 100644 --- a/.github/workflows/testing-make.yml +++ b/.github/workflows/testing-make.yml @@ -72,6 +72,7 @@ jobs: pkg-config \ libpng-dev \ libjpeg-turbo8-dev \ + libopencv-dev \ "llvm-${LLVM_VERSION}-dev" \ "clang-${LLVM_VERSION}" \ "lld-${LLVM_VERSION}" \ diff --git a/apps/stereobm/Makefile b/apps/stereobm/Makefile index d5547c44a52e..2e7bb09c8706 100644 --- a/apps/stereobm/Makefile +++ b/apps/stereobm/Makefile @@ -1,11 +1,13 @@ include ../support/Makefile.inc # process.cpp compares against OpenCV's StereoBM. -# Auto-disable if opencv4 calib3d header is not available. -OPENCV_CXXFLAGS := $(shell pkg-config --cflags opencv4 2>/dev/null) -OPENCV_LIBS := $(shell pkg-config --libs opencv4 2>/dev/null) -HAVE_OPENCV_CALIB3D := $(shell echo '\#include ' | $(CXX) $(OPENCV_CXXFLAGS) -x c++ - -fsyntax-only 2>/dev/null && echo yes) -STEREOBM_BUILD_OPENCV ?= $(if $(HAVE_OPENCV_CALIB3D),1,0) +# Auto-disable if opencv4 is not available via pkg-config. +HAVE_OPENCV4 := $(shell pkg-config --exists opencv4 2>/dev/null && echo yes) +STEREOBM_BUILD_OPENCV ?= $(if $(HAVE_OPENCV4),1,0) +ifeq ($(STEREOBM_BUILD_OPENCV),1) + OPENCV_CXXFLAGS := $(shell pkg-config --cflags opencv4 2>/dev/null) + OPENCV_LIBS := $(shell pkg-config --libs opencv4 2>/dev/null) +endif # We set parameters here to feed into both OpenCV and our generator, so that they are consistent. STEREOBM_WINSIZE ?= 9 From b2cd1e3e09ca367b6d6294d64007ee4c13b68c1f Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Wed, 24 Jun 2026 22:22:20 -0400 Subject: [PATCH 32/42] fix makefile for stereobm again, co-authored with Claude Opus 4.7 --- apps/stereobm/Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/apps/stereobm/Makefile b/apps/stereobm/Makefile index 2e7bb09c8706..f62039579923 100644 --- a/apps/stereobm/Makefile +++ b/apps/stereobm/Makefile @@ -44,7 +44,7 @@ $(BIN)/%/stereobm.a: $(GENERATOR_BIN)/stereobm.generator $(BIN)/%/process_opencv: process.cpp $(BIN)/%/stereobm.a @mkdir -p $(@D) - $(CXX) $(CXXFLAGS) -DSTEREOBM_BUILD_OPENCV=1 $(STEREOBM_DEFINES) $(OPENCV_CXXFLAGS) -I$(BIN)/$* -Wall -O3 $^ -o $@ $(LDFLAGS) $(IMAGE_IO_FLAGS) $(CUDA_LDFLAGS) $(OPENCL_LDFLAGS) $(OPENCV_LIBS) + $(CXX) $(CXXFLAGS) -Wno-cast-qual -DSTEREOBM_BUILD_OPENCV=1 $(STEREOBM_DEFINES) $(OPENCV_CXXFLAGS) -I$(BIN)/$* -Wall -O3 $^ -o $@ $(LDFLAGS) $(IMAGE_IO_FLAGS) $(CUDA_LDFLAGS) $(OPENCL_LDFLAGS) $(OPENCV_LIBS) $(BIN)/%/process: process.cpp $(BIN)/%/stereobm.a @mkdir -p $(@D) From 824ff468cfcc4d450e8ee8c42230b5c65a79326c Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Wed, 24 Jun 2026 22:25:42 -0400 Subject: [PATCH 33/42] fix macos stereobm dependency, co-authored with Claude Opus 4.7 --- .github/workflows/testing-make.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/testing-make.yml b/.github/workflows/testing-make.yml index 231711ced5cd..09129b68ff99 100644 --- a/.github/workflows/testing-make.yml +++ b/.github/workflows/testing-make.yml @@ -79,7 +79,7 @@ jobs: "liblld-${LLVM_VERSION}-dev" echo "LLVM_CONFIG=llvm-config-${LLVM_VERSION}" | tee -a "$GITHUB_ENV" elif [ "$RUNNER_OS" = "macOS" ]; then - brew install libjpeg-turbo libpng pkgconf protobuf "llvm@${LLVM_VERSION}" "lld@${LLVM_VERSION}" + brew install libjpeg-turbo libpng pkgconf protobuf opencv "llvm@${LLVM_VERSION}" "lld@${LLVM_VERSION}" echo "LLVM_CONFIG=$(brew --prefix "llvm@${LLVM_VERSION}")/bin/llvm-config" | tee -a "$GITHUB_ENV" fi From 4b31d31e1d550a4da699bd53679b74926348b7ba Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Thu, 25 Jun 2026 01:59:06 -0400 Subject: [PATCH 34/42] clang tidy --- src/IR.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/IR.cpp b/src/IR.cpp index 06922580c142..86d322ce766f 100644 --- a/src/IR.cpp +++ b/src/IR.cpp @@ -601,12 +601,13 @@ Expr Call::make(const Function &func, const std::vector &args, int idx) { << "Value index out of range in call to halide function\n"; /*internal_assert(func.has_pure_definition() || func.has_extern_definition()) << "Call to undefined halide function\n"; */ - if (func.has_pure_definition() || func.has_extern_definition()) + if (func.has_pure_definition() || func.has_extern_definition()) { return make(func.output_types()[(size_t)idx], func.name(), args, Halide, func.get_contents(), idx, Buffer<>(), Parameter()); - else + } else { return make(func.required_types()[(size_t)idx], func.name(), args, Halide, func.get_contents(), idx, Buffer<>(), Parameter()); + } } namespace { From ea2794d45513205d5ea8ac6e08c0748d60e2e6d5 Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Sun, 5 Jul 2026 22:33:19 -0400 Subject: [PATCH 35/42] Performance improvements to stereobm app.Co-authored-by: Claude Sonnet 4.6 --- apps/stereobm/process.cpp | 8 ++++---- apps/stereobm/stereobm_generator.cpp | 30 ++++++++++++++++++---------- 2 files changed, 23 insertions(+), 15 deletions(-) diff --git a/apps/stereobm/process.cpp b/apps/stereobm/process.cpp index c65b6197a88b..e43d94e16dc4 100644 --- a/apps/stereobm/process.cpp +++ b/apps/stereobm/process.cpp @@ -85,7 +85,7 @@ int main(int argc, char **argv) { right = load_gray(argv[2]); #endif - Halide::Runtime::Buffer output(left.width(), left.height()); + Halide::Runtime::Buffer output(left.width(), left.height()); double best = benchmark([&]() { stereobm(left, right, output); @@ -138,9 +138,9 @@ int main(int argc, char **argv) { // normalize output to range [0, 255] int32_t dmin = INT32_MAX, dmax = INT32_MIN; - output.for_each_value([&](int32_t v) { - dmin = std::min(dmin, v); - dmax = std::max(dmax, v); + output.for_each_value([&](int16_t v) { + dmin = std::min(dmin, (int32_t)v); + dmax = std::max(dmax, (int32_t)v); }); double scale = (dmax > dmin) ? 255.0 / (dmax - dmin) : 0.0; Halide::Runtime::Buffer vis(output.width(), output.height()); diff --git a/apps/stereobm/stereobm_generator.cpp b/apps/stereobm/stereobm_generator.cpp index 0f49284505f2..c9140bf45161 100644 --- a/apps/stereobm/stereobm_generator.cpp +++ b/apps/stereobm/stereobm_generator.cpp @@ -60,10 +60,11 @@ class StereoBM : public Generator { GeneratorParam mindisp{"mindisp", 0}; // minimum disparity to consider. GeneratorParam uniqueness_ratio{"uniqueness_ratio", 0}; // reject if the second-best match is too close to the best match, as a percentage of the best match score. GeneratorParam filtercap{"filtercap", 31}; // clamp the prefiltering output to the range [0, filtercap*2]. - Output> output{"output"}; + Output> output{"output"}; void generate() { const Type uint16 = UInt(16); + const Type int16 = Int(16); const Type int32 = Int(32); const int native_lanes = get_target().natural_vector_size(); @@ -110,13 +111,18 @@ class StereoBM : public Generator { blur_y(di, xi, y, xo) = select(xi <= 0, f1(di, y, xo), likely(blur_y(di, max(xi - 1, 0), y, xo) + vsum(di, xi + winsize - 1, y, xo) - vsum(di, max(xi - 1, 0), y, xo))); // compute the texture value for each pixel, which is the sum of pixels in the surrounding block - Func text("text"), zerotext("zerotext"), textsum("textsum"), textf1("textf1"), textblury("textblury"); + Func text("text"), zerotext("zerotext"), textsum("textsum"), textf1("textf1"); + Func textblury(uint16, "textblury"); // explicit type required for inductive self-reference text(xi, y, xo) = cast(abs(cast(xsobel0(xi + xo * tilesize, y)) - cast(filtercap))); zerotext(xi, xo) = sum(cast(text(xi, rwin, xo))); textsum(xi, y, xo) = select(y <= 0, zerotext(xi, xo), textsum(xi, y - 1, xo) + text(xi, y + winsize - 1, xo) - text(xi, y - 1, xo)); + // textblury(xi) is the width-winsize sliding window of textsum in x, + // written as an O(1)/pixel inductive running sum (mirrors blur_y's xi + // scan) so it can be fused into blur_y's xi loop via compute_with: the + // SAD update vectorizes over di while this stays a scalar 1-add/pixel + // texture update in the same loop -- exactly OpenCV's structure. textf1(y, xo) = sum(textsum(rwin, y, xo)); - textblury(xi, y, xo) = undef(); - textblury(rx, y, xo) = select(rx == 0, textf1(y, xo), textblury(max(rx - 1, 0), y, xo) + textsum(rx + winsize - 1, y, xo) - textsum(max(rx - 1, 0), y, xo)); + textblury(xi, y, xo) = select(xi <= 0, textf1(y, xo), likely(textblury(max(xi - 1, 0), y, xo) + textsum(xi + winsize - 1, y, xo) - textsum(max(xi - 1, 0), y, xo))); // compute the best and second-best disparity for each pixel Func preout("preout"); @@ -137,17 +143,17 @@ class StereoBM : public Generator { p_clamped(xi, y, xo) = clamp(argmin1(xi, y, xo), 1, depth - 2); // indexes into blur_y // subpixel refinement - Func subpout(int32, "subpout"); + Func subpout(int16, "subpout"); Expr p = cast(blur_y(cast(int32, p_clamped(xi, y, xo)) + 1, xi, y, xo)); Expr n = cast(blur_y(cast(int32, p_clamped(xi, y, xo)) - 1, xi, y, xo)); Expr d1 = p + n - 2 * preout(xi, y, xo) + abs(p - n); Expr q = (abs(p - n) * 256) / d1; Expr quot = select(p >= n, q, -q); - Expr subpout_expr = cast((cast(depth - p_clamped(xi, y, xo) - 1 + mindisp) * 256 + (select(d1 == 0, 0, quot) + 15)) >> 4); - subpout(xi, y, xo) = select(argmin1(xi, y, xo) > 0 && argmin1(xi, y, xo) < depth - 1, subpout_expr, cast(depth - argmin1(xi, y, xo) - 1 + mindisp) * 16); + Expr subpout_expr = cast((cast(depth - p_clamped(xi, y, xo) - 1 + mindisp) * 256 + (select(d1 == 0, 0, quot) + 15)) >> 4); + subpout(xi, y, xo) = select(argmin1(xi, y, xo) > 0 && argmin1(xi, y, xo) < depth - 1, subpout_expr, cast((depth - argmin1(xi, y, xo) - 1 + mindisp) * 16)); // edge case handling - Expr filtered = cast((mindisp - 1) * 16); + Expr filtered = cast((mindisp - 1) * 16); Expr reject = textblury(xi, y, xo) < threshold; // reject if block texture is too uniform if (int(uniqueness_ratio) > 0) { // reject if second-best disparity is too close to best disparity reject = reject || (cast(argmin2(xi, y, xo)) <= cast(preout(xi, y, xo)) + (cast(preout(xi, y, xo)) * cast(uniqueness_ratio)) / 100); @@ -182,10 +188,12 @@ class StereoBM : public Generator { f1.compute_at(splitoutput, y).vectorize(di, depth); zero_blur.compute_at(splitoutput, xo).vectorize(di, depth); - zerotext.compute_at(splitoutput, xo); + zerotext.compute_at(splitoutput, xo).vectorize(xi, native_lanes); + textsum.compute_at(splitoutput, y).store_at(splitoutput, xo).vectorize(xi, native_lanes).fold_storage(y, 2); textf1.compute_at(splitoutput, y); - textsum.compute_at(splitoutput, y).store_at(splitoutput, xo).fold_storage(y, 2); - textblury.compute_at(splitoutput, y); + // scalar O(1) running sum fused into blur_y's xi-scan loop (OpenCV-style) + textblury.compute_at(splitoutput, y).store_at(splitoutput, y).fold_storage(xi, 2); + textblury.compute_with(blur_y, xi); output.vectorize(x, native_lanes); } From 75a65fe4bb6558f9f05933b949262f140152f210 Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Sun, 5 Jul 2026 23:00:32 -0400 Subject: [PATCH 36/42] remove comments --- apps/stereobm/stereobm_generator.cpp | 5 ----- 1 file changed, 5 deletions(-) diff --git a/apps/stereobm/stereobm_generator.cpp b/apps/stereobm/stereobm_generator.cpp index c9140bf45161..be2838ce5211 100644 --- a/apps/stereobm/stereobm_generator.cpp +++ b/apps/stereobm/stereobm_generator.cpp @@ -116,11 +116,6 @@ class StereoBM : public Generator { text(xi, y, xo) = cast(abs(cast(xsobel0(xi + xo * tilesize, y)) - cast(filtercap))); zerotext(xi, xo) = sum(cast(text(xi, rwin, xo))); textsum(xi, y, xo) = select(y <= 0, zerotext(xi, xo), textsum(xi, y - 1, xo) + text(xi, y + winsize - 1, xo) - text(xi, y - 1, xo)); - // textblury(xi) is the width-winsize sliding window of textsum in x, - // written as an O(1)/pixel inductive running sum (mirrors blur_y's xi - // scan) so it can be fused into blur_y's xi loop via compute_with: the - // SAD update vectorizes over di while this stays a scalar 1-add/pixel - // texture update in the same loop -- exactly OpenCV's structure. textf1(y, xo) = sum(textsum(rwin, y, xo)); textblury(xi, y, xo) = select(xi <= 0, textf1(y, xo), likely(textblury(max(xi - 1, 0), y, xo) + textsum(xi + winsize - 1, y, xo) - textsum(max(xi - 1, 0), y, xo))); From 39bd68fe2918e2615464678c8406475c633f03ef Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Wed, 8 Jul 2026 12:00:38 -0400 Subject: [PATCH 37/42] Fix ambiguous expr casts --- apps/stereobm/stereobm_generator.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/apps/stereobm/stereobm_generator.cpp b/apps/stereobm/stereobm_generator.cpp index be2838ce5211..866752924550 100644 --- a/apps/stereobm/stereobm_generator.cpp +++ b/apps/stereobm/stereobm_generator.cpp @@ -158,7 +158,7 @@ class StereoBM : public Generator { // disparities are only valid where the SAD window and the full disparity search both fit inside the image. Expr sw2 = winsize / 2; - Expr in_valid_roi = x >= (Expr(mindisp) + Expr(depth) - 1) + sw2 && x < W - mindisp - sw2 && + Expr in_valid_roi = x >= (static_cast(mindisp) + static_cast(depth) - 1) + sw2 && x < W - mindisp - sw2 && y >= sw2 && y < H - sw2; output(x, y) = select(in_valid_roi, splitoutput(x % tilesize, y, x / tilesize), filtered); From 1af908acdca4bb43416e0b78f463a9efe9c8a5c1 Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Wed, 8 Jul 2026 12:02:51 -0400 Subject: [PATCH 38/42] Another static_cast --- apps/stereobm/stereobm_generator.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/apps/stereobm/stereobm_generator.cpp b/apps/stereobm/stereobm_generator.cpp index 866752924550..81845d23a705 100644 --- a/apps/stereobm/stereobm_generator.cpp +++ b/apps/stereobm/stereobm_generator.cpp @@ -158,7 +158,7 @@ class StereoBM : public Generator { // disparities are only valid where the SAD window and the full disparity search both fit inside the image. Expr sw2 = winsize / 2; - Expr in_valid_roi = x >= (static_cast(mindisp) + static_cast(depth) - 1) + sw2 && x < W - mindisp - sw2 && + Expr in_valid_roi = x >= (static_cast(mindisp) + static_cast(depth) - 1) + sw2 && x < W - static_cast(mindisp) - sw2 && y >= sw2 && y < H - sw2; output(x, y) = select(in_valid_roi, splitoutput(x % tilesize, y, x / tilesize), filtered); From 8ff1b77d62776dab7c53cec8177ba88bd6277108 Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Mon, 13 Jul 2026 16:17:32 -0400 Subject: [PATCH 39/42] Draft for storage folding optimization that allows clobbering, plus tweaks to stereobm Co-Authored-By: Claude Opus 4.8 --- apps/stereobm/stereobm_generator.cpp | 27 ++- src/Func.cpp | 4 + src/StorageFolding.cpp | 210 ++++++++++++++++++++- test/correctness/CMakeLists.txt | 1 + test/correctness/inductive.cpp | 11 +- test/correctness/inductive_folding.cpp | 152 +++++++++++++++ test/error/CMakeLists.txt | 5 + test/error/inductive_diagonal_fold.cpp | 19 ++ test/error/inductive_external_lag_fold.cpp | 18 ++ test/error/inductive_redundant_z_fold.cpp | 21 +++ test/error/inductive_small_fold.cpp | 19 ++ test/error/inductive_tuple_fold.cpp | 21 +++ 12 files changed, 489 insertions(+), 19 deletions(-) create mode 100644 test/correctness/inductive_folding.cpp create mode 100644 test/error/inductive_diagonal_fold.cpp create mode 100644 test/error/inductive_external_lag_fold.cpp create mode 100644 test/error/inductive_redundant_z_fold.cpp create mode 100644 test/error/inductive_small_fold.cpp create mode 100644 test/error/inductive_tuple_fold.cpp diff --git a/apps/stereobm/stereobm_generator.cpp b/apps/stereobm/stereobm_generator.cpp index 81845d23a705..cc4ca3cf69e7 100644 --- a/apps/stereobm/stereobm_generator.cpp +++ b/apps/stereobm/stereobm_generator.cpp @@ -103,21 +103,22 @@ class StereoBM : public Generator { Func zero_blur(uint16, "zero_blur"); RDom rwin(0, winsize, "rwin"); zero_blur(di, xi, xo) = sum(cast(diff(di, xi, rwin, xo))); - vsum(di, xi, y, xo) = select(y <= 0, zero_blur(di, xi, xo), likely(vsum(di, xi, max(y - 1, 0), xo) + diff(di, xi, y + winsize - 1, xo) - diff(di, xi, max(y - 1, 0), xo))); + vsum(di, xi, y, xo) = select(y <= 0, zero_blur(di, xi, xo), likely(vsum(di, xi, y - 1, xo) + diff(di, xi, y + winsize - 1, xo) - diff(di, xi, y - 1, xo))); Func blur_y(uint16, "blur_y"); RDom rx(0, tilesize, "rx"); Func f1("f1"); f1(di, y, xo) = sum(vsum(di, rwin, y, xo)); - blur_y(di, xi, y, xo) = select(xi <= 0, f1(di, y, xo), likely(blur_y(di, max(xi - 1, 0), y, xo) + vsum(di, xi + winsize - 1, y, xo) - vsum(di, max(xi - 1, 0), y, xo))); + blur_y(di, xi, y, xo) = select(xi <= 0, f1(di, y, xo), likely(blur_y(di, xi - 1, y, xo) + vsum(di, xi + winsize - 1, y, xo) - vsum(di, xi - 1, y, xo))); // compute the texture value for each pixel, which is the sum of pixels in the surrounding block - Func text("text"), zerotext("zerotext"), textsum("textsum"), textf1("textf1"); + Func text("text"), zerotext("zerotext"), textf1("textf1"); + Func textsum(uint16, "textsum"); // explicit type required for inductive self-reference Func textblury(uint16, "textblury"); // explicit type required for inductive self-reference text(xi, y, xo) = cast(abs(cast(xsobel0(xi + xo * tilesize, y)) - cast(filtercap))); zerotext(xi, xo) = sum(cast(text(xi, rwin, xo))); - textsum(xi, y, xo) = select(y <= 0, zerotext(xi, xo), textsum(xi, y - 1, xo) + text(xi, y + winsize - 1, xo) - text(xi, y - 1, xo)); + textsum(xi, y, xo) = select(y <= 0, zerotext(xi, xo), likely(textsum(xi, y - 1, xo) + text(xi, y + winsize - 1, xo) - text(xi, y - 1, xo))); textf1(y, xo) = sum(textsum(rwin, y, xo)); - textblury(xi, y, xo) = select(xi <= 0, textf1(y, xo), likely(textblury(max(xi - 1, 0), y, xo) + textsum(xi + winsize - 1, y, xo) - textsum(max(xi - 1, 0), y, xo))); + textblury(xi, y, xo) = select(xi <= 0, textf1(y, xo), likely(textblury(xi - 1, y, xo) + textsum(xi + winsize - 1, y, xo) - textsum(xi - 1, y, xo))); // compute the best and second-best disparity for each pixel Func preout("preout"); @@ -177,19 +178,25 @@ class StereoBM : public Generator { blur_y.bound(di, 0, depth); vsum.bound(di, 0, depth); - blur_y.compute_at(splitoutput, y).store_at(splitoutput, y).vectorize(di, depth).fold_storage(xi, 2); - vsum.compute_at(splitoutput, y).store_at(splitoutput, xo).vectorize(di, depth).fold_storage(y, 2); + blur_y.compute_at(splitoutput, y).store_at(splitoutput, y).vectorize(di, depth).fold_storage(xi, 1); + vsum.compute_at(splitoutput, y).store_at(splitoutput, xo).vectorize(di, depth).fold_storage(y, 1); f1.compute_at(splitoutput, y).vectorize(di, depth); zero_blur.compute_at(splitoutput, xo).vectorize(di, depth); zerotext.compute_at(splitoutput, xo).vectorize(xi, native_lanes); - textsum.compute_at(splitoutput, y).store_at(splitoutput, xo).vectorize(xi, native_lanes).fold_storage(y, 2); + textsum.compute_at(splitoutput, y).store_at(splitoutput, xo).vectorize(xi).fold_storage(y, 1); textf1.compute_at(splitoutput, y); - // scalar O(1) running sum fused into blur_y's xi-scan loop (OpenCV-style) - textblury.compute_at(splitoutput, y).store_at(splitoutput, y).fold_storage(xi, 2); + textblury.compute_at(splitoutput, y).store_at(splitoutput, y).fold_storage(xi, 1); textblury.compute_with(blur_y, xi); + // Constrain the output origin to 0 so the base-case boundary terms + // (min(output.min.1, 0), select(output.min.1 <= y, ...)) fold to + // constants, letting the inductive fold analysis simplify the y + // footprint of textsum/vsum to a clean single-element step. + output.dim(0).set_min(0); + output.dim(1).set_min(0); + output.vectorize(x, native_lanes); } }; diff --git a/src/Func.cpp b/src/Func.cpp index 6674853855b9..be3ad7c52c3e 100644 --- a/src/Func.cpp +++ b/src/Func.cpp @@ -3428,6 +3428,10 @@ FuncTupleElementRef FuncRef::operator[](int i) const { << "Can't index into a reference to Func \"" << func.name() << "\", because it does not return a Tuple.\n"; + user_assert(!func.required_types().empty() || !func.output_types().empty()) + << "Can't index into a reference to Func \"" << func.name() + << "\", because it does not have an explicitly defined type.\n"; + user_assert(i >= 0 && i < func.outputs()) << "Tuple index out of range in reference to Func \"" << func.name() << "\".\n"; diff --git a/src/StorageFolding.cpp b/src/StorageFolding.cpp index fcd2c2b2293b..60096c41a0b7 100644 --- a/src/StorageFolding.cpp +++ b/src/StorageFolding.cpp @@ -4,10 +4,12 @@ #include "CSE.h" #include "Debug.h" #include "ExprUsesVar.h" +#include "IREquality.h" #include "IRMutator.h" #include "IROperator.h" #include "IRPrinter.h" #include "Monotonic.h" +#include "Scope.h" #include "Simplify.h" #include "Substitute.h" #include "Util.h" @@ -50,6 +52,121 @@ int count_producers(const Stmt &in, const std::string &name) { return counter.count; } +Stmt scrub_self_reads(const Stmt &s, const string &func) { + return mutate_with(s, [&](auto *self, const Provide *op) { + debug(3) << "Scrubbing self reads in Provide: " << Stmt(op) << " func name: " << func << "\n"; + if (op->name == func) { + vector values; + for (const Expr &v : op->values) { + values.push_back(mutate_with(v, [&](auto *self, const Call *op) { + if (op->name == func && op->call_type == Call::Halide) { + return make_zero(op->type); + } + return Call::make(op->type, op->name, self->mutate(op->args), op->call_type, + op->func, op->value_index, op->image, op->param); + })); + } + return Provide::make(op->name, values, op->args, op->predicate); + } + return Provide::make(op->name, self->mutate(op->values), self->mutate(op->args), self->mutate(op->predicate)); + }); +} + +// True if every self-call of func (inside func's own Provide) matches the +// store index in all dimensions except dim, and strictly differs from it in dim. +bool inductive_only_in_dim(const Stmt &body, const string &func, int dim) { + bool single_dim = true; + vector store_args; + bool in_own_provide = false; + visit_with( + body, + [&](auto *self, const Provide *op) { + if (op->name == func) { + store_args = op->args; + in_own_provide = true; + self->visit_base(op); + in_own_provide = false; + } else { + self->visit_base(op); + } + }, + [&](auto *self, const Call *op) { + if (in_own_provide && op->name == func && op->call_type == Call::Halide) { + if ((int)op->args.size() != (int)store_args.size()) { + single_dim = false; + } else { + for (int d = 0; d < (int)op->args.size(); d++) { + bool ok = (d == dim) ? can_prove(op->args[d] != store_args[d]) : can_prove(op->args[d] == store_args[d]); + if (!ok) { + single_dim = false; + } + } + } + } + self->visit_base(op); + }); + return single_dim; +} + +// Verify there is exactly one store to func in the loop body, and that within +// a single iteration of the fold loop that store never writes the same location +// twice. +bool one_store_per_iteration(Stmt body, const string &func) { + struct Store { + vector args; + vector> loops; // enclosing inner loops + }; + vector> loops; + vector stores; + visit_with( + body, + [&](auto *self, const For *op) { + loops.emplace_back(op->name, Interval(op->min, op->max)); + op->body.accept(self); + loops.pop_back(); + }, + [&](auto *self, const Provide *op) { + if (op->name == func) { + Store s; + s.args = op->args; + s.loops = loops; + stores.push_back(std::move(s)); + } + self->visit_base(op); + }); + + if (stores.size() != 1) { + return false; + } + + const Store &s = stores[0]; + if (s.loops.empty()) { + return true; + } + + // Rename the inner loop vars to a different iteration and falsify a collision. + Scope bounds; + Expr distinct = const_false(); + vector other = s.args; + for (const auto &lp : s.loops) { + string other_name = lp.first + "$_"; + Expr v = Variable::make(Int(32), lp.first); + Expr ov = Variable::make(Int(32), other_name); + for (Expr &e : other) { + e = graph_substitute(lp.first, ov, e); + } + distinct = distinct || (v != ov); + bounds.push(lp.first, lp.second); + bounds.push(other_name, lp.second); + } + Expr hazard = distinct; + for (size_t d = 0; d < s.args.size(); d++) { + hazard = hazard && (s.args[d] == other[d]); + } + hazard = simplify(common_subexpression_elimination(hazard), bounds); + return is_const_zero(hazard); +} + // Fold the storage of a function in a particular dimension by a particular factor class FoldStorageOfFunction : public IRMutator { string func; @@ -160,6 +277,7 @@ class InjectFoldingCheck : public IRMutator { int dim; bool in_produce; const StorageDim &storage_dim; + bool allow_inplace; using IRMutator::visit; Stmt visit(const ProducerConsumer *op) override { @@ -174,8 +292,21 @@ class InjectFoldingCheck : public IRMutator { // Update valid range based on bounds written to. Box provided = box_provided(body, func.name()); Box required = box_required(body, func.name()); + Stmt body_no_self = scrub_self_reads(body, func.name()); + Box external_required = box_required(body_no_self, func.name()); + Box external = box_union(provided, external_required); required.used = Expr(); - Box b = box_union(provided, required); + external.used = Expr(); + // In-place recurrence: the write aliases the just-read lagged + // slot, so the required footprint can be one element tighter. + if (allow_inplace && dim < (int)required.size() && required[dim].is_bounded()) { + if (storage_dim.fold_forward) { + required[dim].min += 1; + } else { + required[dim].max -= 1; + } + } + Box b = box_union(required, external); Expr old_leading_edge = Load::make(Int(32), head + "_next", 0, Buffer<>(), Parameter(), const_true(), ModulusRemainder()); @@ -389,10 +520,11 @@ class InjectFoldingCheck : public IRMutator { InjectFoldingCheck(Function func, string head, string tail, string loop_var, Expr sema_var, - int dim, const StorageDim &storage_dim) + int dim, const StorageDim &storage_dim, + bool allow_inplace) : func(std::move(func)), head(std::move(head)), tail(std::move(tail)), loop_var(std::move(loop_var)), sema_var(std::move(sema_var)), - dim(dim), storage_dim(storage_dim) { + dim(dim), storage_dim(storage_dim), allow_inplace(allow_inplace) { } }; @@ -538,6 +670,13 @@ class AttemptStorageFoldingOfFunction : public IRMutator { required.used = Expr(); Box box = box_union(provided, required); + // Footprint of func ignoring any recurrence self-read. + // Used to determine whether we can safely alias the write with the self-read slot. + Stmt body_no_self = scrub_self_reads(body, func.name()); + Box external_required = box_required(body_no_self, func.name()); + external_required.used = Expr(); + Box box_external = box_union(provided, external_required); + Expr loop_var = Variable::make(Int(32), op->name); string dynamic_footprint; @@ -600,6 +739,68 @@ class AttemptStorageFoldingOfFunction : public IRMutator { Expr extent = Max::make(extent_initial, extent_steady); extent = simplify(common_subexpression_elimination(extent), bounds); + // Structural safety for aliasing the write with a self-read slot. + // Let the storage folding extent be k + 1. To alias the write, + // we need to ensure that, for each x, all reads and writes of f(x) + // occur after all reads and writes of f(x-k) in the same loop iteration. + // unit_advance checks that the footprint bounds only shift by 1 each iteration. + // The iteration where both f(x) and f(x-k) are accessed must be the + // first iteration where f(x) is within the + // storage-folded footprint, so f(x) must be written to before it is safely read. + // Thus, we only have to check for writes to f(x) instead of both reads and writes. + // can_prove(extent_no_self <= extent - 1, bounds) checks + // that computing the footprint without self-reads makes + // the min value strictly larger than x-k, which ensures that f(x-k) is + // not written to in the same iteration as f(x), and all reads of f(x-k) + // are self-reads used to compute values of f. It is thus sufficient to + // check that f(x-k) is only used to compute a single value of f(x), and + // no additional values of f are computed. We allow f to have additional + // dimensions other than x, so long as their arguments can be treated as pure variables + // (i.e. the store indices are identical to the recursive self-call indices). + // + // single_write checks that f(x) is the only value that is stored. + // inductive_only_in_dim(op->body, func.name(), dim) checks that the + // recurrence only recurses in the fold dimension, so all other arguments + // of f can be treated as pure variables. + // one_store_per_iteration(op->body, func.name()) + // checks that f(x) is written exactly once per iteration. + // We also check that f is not tuple-valued and has no external definition. + // Storing a tuple value lowers down to multiple store operations, which could + // all use depend on same element of f(x-k). + + bool single_inductive_store = + inductive_only_in_dim(op->body, func.name(), dim) && + one_store_per_iteration(op->body, func.name()); + + bool can_inplace = false; + if (single_inductive_store && dim < (int)box_external.size() && box_external[dim].is_bounded() && func.outputs() == 1 && !func.has_extern_definition()) { + Expr min_e = simplify(common_subexpression_elimination(box_external[dim].min)); + Expr max_e = simplify(common_subexpression_elimination(box_external[dim].max)); + Expr min_e_steady = simplify(substitute(steady_state, const_true(), min_e), steady_bounds); + Expr max_e_steady = simplify(substitute(steady_state, const_true(), max_e), steady_bounds); + Expr min_e_initial = simplify(substitute(steady_state, const_false(), min_e), bounds); + Expr max_e_initial = simplify(substitute(steady_state, const_false(), max_e), bounds); + Expr extent_e_initial = simplify(substitute(loop_var, op->min, max_e_initial - min_e_initial + 1), bounds); + Expr extent_e_steady = simplify(max_e_steady - min_e_steady + 1, steady_bounds); + Expr extent_no_self = simplify(common_subexpression_elimination(Max::make(extent_e_initial, extent_e_steady)), bounds); + + Expr max_step = simplify(substitute(op->name, loop_var + 1, max) - max, bounds); + Expr min_step = simplify(substitute(op->name, loop_var + 1, min) - min, bounds); + bool unit_advance = + (can_prove(max_step == 1, bounds)) || + (can_prove(min_step == -1, bounds)); + bool single_write = + dim < (int)provided.size() && provided[dim].is_bounded() && + can_prove(provided[dim].max <= provided[dim].min, bounds) && + can_prove(provided[dim].max >= max_e, bounds); + + bool extent_shrinks = can_prove(extent_no_self <= extent - 1, bounds); + can_inplace = unit_advance && single_write && extent_shrinks; + } + if (can_inplace) { + extent = simplify(extent - 1); + } + // Find the StorageDim corresponding to dim. const std::vector &storage_dims = func.schedule().storage_dims(); auto storage_dim_i = std::find_if(storage_dims.begin(), storage_dims.end(), @@ -694,7 +895,8 @@ class AttemptStorageFoldingOfFunction : public IRMutator { op->name, sema_var, dim, - storage_dim)(body); + storage_dim, + can_inplace)(body); if (storage_dim.fold_forward) { can_fold_forwards = true; diff --git a/test/correctness/CMakeLists.txt b/test/correctness/CMakeLists.txt index 4690a75723ef..1adba43f8b94 100644 --- a/test/correctness/CMakeLists.txt +++ b/test/correctness/CMakeLists.txt @@ -186,6 +186,7 @@ tests( in_place.cpp indexing_access_undef.cpp inductive.cpp + inductive_folding.cpp infer_arguments.cpp inline_reduction.cpp inlined_generator.cpp diff --git a/test/correctness/inductive.cpp b/test/correctness/inductive.cpp index 96e7183394c2..a5f0362f2e9e 100644 --- a/test/correctness/inductive.cpp +++ b/test/correctness/inductive.cpp @@ -14,15 +14,17 @@ using namespace Halide; using namespace Halide::Internal; int simple_inductive_test() { - Func g("g"), h("h"); + Func g(Int(32), "g"), h("h"); Var x("x"), y("y"); - g(x, y) = select(x <= 0, 0, g(max(0, x - 1), y) + x + y); + g(x, y) = select(x <= 0, 0, likely(g(max(0, x - 1), y) + x + y)); h(x, y) = g(x + 5, y) / 4; g.compute_at(h, x).store_at(h, y); + h.bound(x, 0, 600).bound(y, 0, 5); + Buffer im = h.realize({600, 5}); auto func = [](int x, int y) { return (y * (x + 5) + (x + 5) * (x + 6) / 2) / 4; @@ -149,11 +151,10 @@ int sum_1d_test() { Func f("f"), g("g"), h("h"); Var x("x"), y("y"); f(x, y) = x + y; - f(x, y) += x; // select(x<=0, 0, x+f(x-1,y)); + f(x, y) += x; g(x, y) = select(y <= 0, f(x, 0), f(x, y) + g(x, y - 1)); h(x, y) = g(x, y); h.bound(x, 0, 80).bound(y, 0, 80); - // stress-testing bounds inference for dependent non-inlined funcs f.compute_at(h, x); Buffer im = h.realize({80, 80}); auto func = [](int x, int y) { @@ -173,7 +174,7 @@ int multi_baseline_test() { Func f("f"), g("g"), h("h"); Var x("x"), y("y"); f(x, y) = x + y; - f(x, y) += x; // select(x<=0, 0, x+f(x-1,y)); + f(x, y) += x; g(x, y) = select(y <= 0, f(x, 0), f(x, y) + g(x, y - 1)) + select(y <= 3, f(x, 0), f(x, y) + g(x, y - 1)); h(x, y) = g(x, y); h.bound(x, 0, 80).bound(y, 0, 20); diff --git a/test/correctness/inductive_folding.cpp b/test/correctness/inductive_folding.cpp new file mode 100644 index 000000000000..b63ca15fe778 --- /dev/null +++ b/test/correctness/inductive_folding.cpp @@ -0,0 +1,152 @@ +#include "Halide.h" +#include "check_call_graphs.h" +#include "test_sharding.h" + +#include +#include +#include + +namespace { + +using namespace Halide; + +int fib_fold2() { + Func f(Int(32), "f"), g("g"); + Var x("x"), y("y"); + f(x, y) = select(x <= 1, x + y, likely(f(x - 1, y) + f(x - 2, y))); + g(x, y) = f(x, y); + f.compute_at(g, x).store_root().fold_storage(x, 2); + g.bound(x, 0, 30).bound(y, 0, 8); + + Buffer im = g.realize({30, 8}); + return check_image(im, [](int x, int y) { + if (x <= 1) return x + y; + int a = y, b = 1 + y; + for (int i = 2; i <= x; i++) { + int c = b + a; + a = b; + b = c; + } + return b; + }); +} + +int multi_inner_injective_fold1() { + Func f(Int(32), "f"), g("g"); + Var x("x"), y("y"), z("z"); + f(x, y, z) = select(x <= 0, y + z, likely(f(x - 1, y, z) + 1)); + g(x, y, z) = f(x, y, z); + g.reorder(z, y, x); + f.compute_at(g, x).store_root().fold_storage(x, 1); + g.bound(x, 0, 16).bound(y, 0, 4).bound(z, 0, 4); + + Buffer im = g.realize({16, 4, 4}); + return check_image(im, [](int x, int y, int z) { return x + y + z; }); +} + +int consumer_strided_nonfold_fold1() { + Func f(Int(32), "f"), g("g"); + Var x("x"), y("y"); + f(x, y) = select(x <= 0, y, likely(f(x - 1, y) + 1)); // f(x,y) = x + y + g(x, y) = f(x, 2 * y); + f.compute_at(g, x).store_root().fold_storage(x, 1); + g.bound(x, 0, 64).bound(y, 0, 8); + + Buffer im = g.realize({64, 8}); + return check_image(im, [](int x, int y) { return x + 2 * y; }); +} + +// --- Cases that must be REFUSED (folding tighter than safe). Each asks for a +// fold factor below the true minimum; with the guards working, Halide rejects it +// (fold-factor-too-small) rather than silently corrupting. We expect a throw. + +// lag-3 needs 3 slots; folding to 2 is unsafe. +int lag3_fold2_refused() { + try { + Func f(Int(32), "f"), g("g"); + Var x("x"), y("y"); + f(x, y) = select(x <= 2, x + y, likely(f(x - 3, y) + 1)); + g(x, y) = f(x, y); + f.compute_at(g, x).store_root().fold_storage(x, 2); + g.bound(x, 0, 64).bound(y, 0, 8); + Buffer im = g.realize({64, 8}); + } catch (const Halide::Error &) { + return 0; + } + printf(" lag-3 was folded to 2 but should have been refused\n"); + return 1; +} + +// Self-call broadcasts the non-fold dim to a fixed index: f(x,y) reads +// f(x-1, 0). Folding x to 1 is unsafe -- f(x,0) overwrites the buffer[0][0] slot +// that f(x, y>0) still needs to read as f(x-1, 0). Must be refused. +int self_broadcast_nonfold_refused() { + try { + Func f(Int(32), "f"), g("g"); + Var x("x"), y("y"); + f(x, y) = select(x <= 0, y, likely(f(x - 1, 0) + 1)); + g(x, y) = f(x, y); + f.compute_at(g, x).store_root().fold_storage(x, 1); + g.bound(x, 0, 64).bound(y, 0, 8); + Buffer im = g.realize({64, 8}); + } catch (const Halide::Error &) { + return 0; + } + printf(" self-broadcast in non-fold dim was folded to 1 but should have been refused\n"); + return 1; +} + +// Redundant stores in a non-inductive dimension: f is 1-D in x, but is produced +// inside an inner y loop (g reuses f(x) for every y), so f(x) is written once per +// y -- the same slot, redundantly. Folding x to 1 is unsafe: the second y would +// read the freshly-written f(x) as if it were f(x-1). The store is not injective +// over the inner y loop, so store_is_single_and_disjoint must refuse it (this is +// exactly the ParallelRVar-style duplicate-store falsification). +int redundant_nonfold_store_refused() { + try { + Func f(Int(32), "f"), g("g"); + Var x("x"), y("y"); + f(x) = select(x <= 0, 0, likely(f(x - 1) + 1)); // 1-D, f(x) = x + g(x, y) = f(x); // reused across y + g.reorder(y, x); // x outer, y inner + f.compute_at(g, y).store_root().fold_storage(x, 1); // re-produced per y + g.bound(x, 0, 64).bound(y, 0, 8); + Buffer im = g.realize({64, 8}); + } catch (const Halide::Error &) { + return 0; + } + printf(" redundant non-fold store folded to 1 but should have been refused\n"); + return 1; +} + +} // namespace + +int main(int argc, char **argv) { + struct Task { + std::string desc; + std::function fn; + }; + + std::vector tasks = { + {"multi-lag (x-1, x-2), fold_storage 2", fib_fold2}, + {"multi-inner-dim recurrence, fold_storage 1", multi_inner_injective_fold1}, + {"strided non-fold consumer access, fold_storage 1", consumer_strided_nonfold_fold1}, + {"lag-3 folded to 2 is refused", lag3_fold2_refused}, + {"self-broadcast in non-fold dim folded to 1 is refused", self_broadcast_nonfold_refused}, + {"redundant non-fold store folded to 1 is refused", redundant_nonfold_store_refused}, + }; + + using Sharder = Halide::Internal::Test::Sharder; + Sharder sharder; + for (size_t t = 0; t < tasks.size(); t++) { + if (!sharder.should_run(t)) continue; + const auto &task = tasks.at(t); + std::cout << task.desc << "\n"; + if (task.fn() != 0) { + return 1; + } + } + + printf("Success!\n"); + return 0; +} diff --git a/test/error/CMakeLists.txt b/test/error/CMakeLists.txt index dbf6585dbbbd..9c9b7a197eef 100644 --- a/test/error/CMakeLists.txt +++ b/test/error/CMakeLists.txt @@ -78,12 +78,17 @@ tests( inductive_cond_nested.cpp inductive_cond_nested_select.cpp inductive_cond_self_reference.cpp + inductive_diagonal_fold.cpp + inductive_external_lag_fold.cpp inductive_loop_1.cpp inductive_loop_2.cpp inductive_loop_3.cpp inductive_nested_select.cpp inductive_no_select.cpp + inductive_redundant_z_fold.cpp inductive_reorder.cpp + inductive_small_fold.cpp + inductive_tuple_fold.cpp inductive_tuple_to_expr.cpp inductive_update.cpp inductive_var_swap.cpp diff --git a/test/error/inductive_diagonal_fold.cpp b/test/error/inductive_diagonal_fold.cpp new file mode 100644 index 000000000000..eb83c020ae80 --- /dev/null +++ b/test/error/inductive_diagonal_fold.cpp @@ -0,0 +1,19 @@ +#include "Halide.h" +#include + +using namespace Halide; + +// Illegal to fold a dimension of a 2-d recurrence to a fold factor of 1, +// since it would create a read-after-write hazard. +int main(int argc, char **argv) { + Func f(Int(32), "f"), g("g"); + Var x("x"), y("y"); + f(x, y) = select(x <= 0 || y <= 0, x + y, likely(f(x - 1, y - 1) + 1)); + g(x, y) = f(x, y); + f.compute_at(g, x).store_root().fold_storage(y, 1); + g.bound(x, 0, 64).bound(y, 0, 8); + Buffer im = g.realize({64, 8}); + + printf("Success!\n"); + return 0; +} diff --git a/test/error/inductive_external_lag_fold.cpp b/test/error/inductive_external_lag_fold.cpp new file mode 100644 index 000000000000..04c1335e035d --- /dev/null +++ b/test/error/inductive_external_lag_fold.cpp @@ -0,0 +1,18 @@ +#include "Halide.h" +#include + +using namespace Halide; + +// Both f(x) and f(x-1) must be live to compute g, so a fold factor of 1 is unsafe. +int main(int argc, char **argv) { + Func f(Int(32), "f"), g("g"); + Var x("x"), y("y"); + f(x, y) = select(x <= 0, y, likely(f(x - 1, y) + 1)); + g(x, y) = f(x, y) + f(max(x - 1, 0), y); + f.compute_at(g, x).store_root().fold_storage(x, 1); + g.bound(x, 0, 64).bound(y, 0, 8); + Buffer im = g.realize({64, 8}); + + printf("Success!\n"); + return 0; +} diff --git a/test/error/inductive_redundant_z_fold.cpp b/test/error/inductive_redundant_z_fold.cpp new file mode 100644 index 000000000000..5b779e77e958 --- /dev/null +++ b/test/error/inductive_redundant_z_fold.cpp @@ -0,0 +1,21 @@ +#include "Halide.h" +#include + +using namespace Halide; + +// Redundantly recomputes f(x, y) for every z, so f(x - 1, y) +// cannot safely be overwritten when computing f(x, y). +// A fold factor of 1 for x is unsafe. +int main(int argc, char **argv) { + Func f(Int(32), "f"), h("h"); + Var x("x"), y("y"), z("z"); + f(x, y) = select(x <= 0, y, likely(f(x - 1, y) + 1)); + h(x, y, z) = f(x, y); + h.reorder(z, y, x); // x outer, then y, z inner + f.compute_at(h, z).store_root().fold_storage(x, 1); + h.bound(x, 0, 64).bound(y, 0, 8).bound(z, 0, 4); + Buffer im = h.realize({64, 8, 4}); + + printf("Success!\n"); + return 0; +} diff --git a/test/error/inductive_small_fold.cpp b/test/error/inductive_small_fold.cpp new file mode 100644 index 000000000000..e5573de2cb47 --- /dev/null +++ b/test/error/inductive_small_fold.cpp @@ -0,0 +1,19 @@ +#include "Halide.h" +#include + +using namespace Halide; + +int main(int argc, char **argv) { + Func f("f"), g("g"); + + Var x("x"); + + f(x) = select(x <= 0, 0, f(x - 1) + f(x - 2) + x); + g(x) = f(x) * 2; + + f.compute_at(g, x).store_root().fold_storage(x, 1); + g.realize({10}); + + printf("Success!\n"); + return 0; +} diff --git a/test/error/inductive_tuple_fold.cpp b/test/error/inductive_tuple_fold.cpp new file mode 100644 index 000000000000..512e0e1d0d60 --- /dev/null +++ b/test/error/inductive_tuple_fold.cpp @@ -0,0 +1,21 @@ +#include "Halide.h" +#include + +using namespace Halide; + +int main(int argc, char **argv) { + Func f(std::vector{Int(32), Int(32)}, "f"), g("g"); + + Var x("x"); + + // We can't fold the storage to size 1 because Halide could overwrite the first Tuple element before reading it + // to compute the second Tuple element. + f(x) = select(x <= 0, Tuple(0, 0), Tuple(f(x - 1)[0] + 1, f(x - 1)[1] + f(x - 1)[0])); + g(x) = f(x)[1] * 2; + + f.compute_at(g, x).store_root().fold_storage(x, 1); + g.realize({10}); + + printf("Success!\n"); + return 0; +} From 50a9c6c07c2965e329a9a378ef3b5a059b25f612 Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Mon, 13 Jul 2026 17:03:23 -0400 Subject: [PATCH 40/42] remove refused tests --- test/correctness/inductive_folding.cpp | 66 -------------------------- 1 file changed, 66 deletions(-) diff --git a/test/correctness/inductive_folding.cpp b/test/correctness/inductive_folding.cpp index b63ca15fe778..4f0de0dde7dd 100644 --- a/test/correctness/inductive_folding.cpp +++ b/test/correctness/inductive_folding.cpp @@ -56,69 +56,6 @@ int consumer_strided_nonfold_fold1() { return check_image(im, [](int x, int y) { return x + 2 * y; }); } -// --- Cases that must be REFUSED (folding tighter than safe). Each asks for a -// fold factor below the true minimum; with the guards working, Halide rejects it -// (fold-factor-too-small) rather than silently corrupting. We expect a throw. - -// lag-3 needs 3 slots; folding to 2 is unsafe. -int lag3_fold2_refused() { - try { - Func f(Int(32), "f"), g("g"); - Var x("x"), y("y"); - f(x, y) = select(x <= 2, x + y, likely(f(x - 3, y) + 1)); - g(x, y) = f(x, y); - f.compute_at(g, x).store_root().fold_storage(x, 2); - g.bound(x, 0, 64).bound(y, 0, 8); - Buffer im = g.realize({64, 8}); - } catch (const Halide::Error &) { - return 0; - } - printf(" lag-3 was folded to 2 but should have been refused\n"); - return 1; -} - -// Self-call broadcasts the non-fold dim to a fixed index: f(x,y) reads -// f(x-1, 0). Folding x to 1 is unsafe -- f(x,0) overwrites the buffer[0][0] slot -// that f(x, y>0) still needs to read as f(x-1, 0). Must be refused. -int self_broadcast_nonfold_refused() { - try { - Func f(Int(32), "f"), g("g"); - Var x("x"), y("y"); - f(x, y) = select(x <= 0, y, likely(f(x - 1, 0) + 1)); - g(x, y) = f(x, y); - f.compute_at(g, x).store_root().fold_storage(x, 1); - g.bound(x, 0, 64).bound(y, 0, 8); - Buffer im = g.realize({64, 8}); - } catch (const Halide::Error &) { - return 0; - } - printf(" self-broadcast in non-fold dim was folded to 1 but should have been refused\n"); - return 1; -} - -// Redundant stores in a non-inductive dimension: f is 1-D in x, but is produced -// inside an inner y loop (g reuses f(x) for every y), so f(x) is written once per -// y -- the same slot, redundantly. Folding x to 1 is unsafe: the second y would -// read the freshly-written f(x) as if it were f(x-1). The store is not injective -// over the inner y loop, so store_is_single_and_disjoint must refuse it (this is -// exactly the ParallelRVar-style duplicate-store falsification). -int redundant_nonfold_store_refused() { - try { - Func f(Int(32), "f"), g("g"); - Var x("x"), y("y"); - f(x) = select(x <= 0, 0, likely(f(x - 1) + 1)); // 1-D, f(x) = x - g(x, y) = f(x); // reused across y - g.reorder(y, x); // x outer, y inner - f.compute_at(g, y).store_root().fold_storage(x, 1); // re-produced per y - g.bound(x, 0, 64).bound(y, 0, 8); - Buffer im = g.realize({64, 8}); - } catch (const Halide::Error &) { - return 0; - } - printf(" redundant non-fold store folded to 1 but should have been refused\n"); - return 1; -} - } // namespace int main(int argc, char **argv) { @@ -131,9 +68,6 @@ int main(int argc, char **argv) { {"multi-lag (x-1, x-2), fold_storage 2", fib_fold2}, {"multi-inner-dim recurrence, fold_storage 1", multi_inner_injective_fold1}, {"strided non-fold consumer access, fold_storage 1", consumer_strided_nonfold_fold1}, - {"lag-3 folded to 2 is refused", lag3_fold2_refused}, - {"self-broadcast in non-fold dim folded to 1 is refused", self_broadcast_nonfold_refused}, - {"redundant non-fold store folded to 1 is refused", redundant_nonfold_store_refused}, }; using Sharder = Halide::Internal::Test::Sharder; From a8ca0f26e092009e9c0515d0da96c3cccaefcb01 Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Thu, 16 Jul 2026 13:04:37 -0400 Subject: [PATCH 41/42] clang-tidy fixes --- src/StorageFolding.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/StorageFolding.cpp b/src/StorageFolding.cpp index 60096c41a0b7..e9f86a9ca1cb 100644 --- a/src/StorageFolding.cpp +++ b/src/StorageFolding.cpp @@ -56,7 +56,7 @@ Stmt scrub_self_reads(const Stmt &s, const string &func) { return mutate_with(s, [&](auto *self, const Provide *op) { debug(3) << "Scrubbing self reads in Provide: " << Stmt(op) << " func name: " << func << "\n"; if (op->name == func) { - vector values; + vector values(op->values.size()); for (const Expr &v : op->values) { values.push_back(mutate_with(v, [&](auto *self, const Call *op) { if (op->name == func && op->call_type == Call::Halide) { @@ -111,7 +111,7 @@ bool inductive_only_in_dim(const Stmt &body, const string &func, int dim) { // Verify there is exactly one store to func in the loop body, and that within // a single iteration of the fold loop that store never writes the same location // twice. -bool one_store_per_iteration(Stmt body, const string &func) { +bool one_store_per_iteration(const Stmt &body, const string &func) { struct Store { vector args; vector> loops; // enclosing inner loops From d82805edac16f84649bc7a299172969201773b78 Mon Sep 17 00:00:00 2001 From: Steven Raphael Date: Thu, 16 Jul 2026 13:24:42 -0400 Subject: [PATCH 42/42] bugfix --- src/StorageFolding.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/StorageFolding.cpp b/src/StorageFolding.cpp index e9f86a9ca1cb..3efec47e3a4c 100644 --- a/src/StorageFolding.cpp +++ b/src/StorageFolding.cpp @@ -56,7 +56,8 @@ Stmt scrub_self_reads(const Stmt &s, const string &func) { return mutate_with(s, [&](auto *self, const Provide *op) { debug(3) << "Scrubbing self reads in Provide: " << Stmt(op) << " func name: " << func << "\n"; if (op->name == func) { - vector values(op->values.size()); + vector values; + values.reserve(op->values.size()); for (const Expr &v : op->values) { values.push_back(mutate_with(v, [&](auto *self, const Call *op) { if (op->name == func && op->call_type == Call::Halide) {