1#ifndef HALIDE_GENERATOR_H_
2#define HALIDE_GENERATOR_H_
270#include <type_traits>
281#if !(__cplusplus >= 201703L || _MSVC_LANG >= 201703L)
282#error "Halide requires C++17 or later; please upgrade your compiler."
287class GeneratorContext;
304 user_error <<
"Enumeration value not found.\n";
310 auto it = enum_map.find(
s);
311 user_assert(
it != enum_map.end()) <<
"Enumeration value not found: " <<
s <<
"\n";
380template<
bool B,
typename T>
386template<
typename First,
typename...
Rest>
387struct select_type : std::conditional<First::value, typename First::type, typename select_type<Rest...>::type> {};
389template<
typename First>
391 using type =
typename std::conditional<First::value, typename First::type, void>::type;
401 inline const std::string &
name()
const {
413#define HALIDE_GENERATOR_PARAM_TYPED_SETTER(TYPE) \
414 virtual void set(const TYPE &new_value) = 0;
432#undef HALIDE_GENERATOR_PARAM_TYPED_SETTER
473 const std::string name_;
490template<
typename FROM,
typename TO>
494 return static_cast<TO2>(from);
518 return this->
value();
525#define HALIDE_GENERATOR_PARAM_TYPED_SETTER(TYPE) \
526 void set(const TYPE &new_value) override { \
527 typed_setter_impl<TYPE>(new_value, #TYPE); \
546#undef HALIDE_GENERATOR_PARAM_TYPED_SETTER
565 template<
typename FROM,
typename std::enable_if<
566 !std::is_convertible<FROM, T>::value>
::type * =
nullptr>
572 template<
typename FROM,
typename std::enable_if<
573 std::is_same<FROM, T>::value>
::type * =
nullptr>
580 template<
typename FROM,
typename std::enable_if<
581 !std::is_same<FROM, T>::value &&
582 std::is_convertible<FROM, T>::value &&
583 std::is_convertible<T, FROM>::value>
::type * =
nullptr>
595 template<
typename FROM,
typename std::enable_if<
596 !std::is_same<FROM, T>::value &&
597 std::is_convertible<FROM, T>::value &&
598 !std::is_convertible<T, FROM>::value>
::type * =
nullptr>
622 return this->
value().to_string();
626 std::ostringstream
oss;
627 oss << v <<
".to_string()";
648 bool try_set(
const std::string &key,
const std::string &
value);
682 }
else if (new_value_string ==
"inlined") {
702 return "LoopLevel::inlined()";
704 return "LoopLevel::root()";
713 return std::string();
730 const T &min = std::numeric_limits<T>::lowest(),
731 const T &max = std::numeric_limits<T>::max())
748 if (
sizeof(T) ==
sizeof(
char) && !std::is_same<T, bool>::value) {
760 std::ostringstream
oss;
762 if (std::is_same<T, float>::value) {
765 if (
oss.str().find(
'.') == std::string::npos) {
774 std::ostringstream
oss;
775 oss <<
"std::to_string(" << v <<
")";
780 std::ostringstream
oss;
781 if (std::is_same<T, float>::value) {
783 }
else if (std::is_same<T, double>::value) {
785 }
else if (std::is_integral<T>::value) {
786 if (std::is_unsigned<T>::value) {
789 oss <<
"int" << (
sizeof(T) * 8) <<
"_t";
821 return this->
value() ?
"true" :
"false";
825 std::ostringstream
oss;
826 oss <<
"std::string((" << v <<
") ? \"true\" : \"false\")";
857 return "Enum_" + this->
name() +
"_map().at(" + v +
")";
861 return "Enum_" + this->
name();
869 std::ostringstream
oss;
870 oss <<
"enum class Enum_" << this->
name() <<
" {\n";
879 oss <<
"inline HALIDE_NO_USER_CODE_INLINE const std::map<Enum_" << this->
name() <<
", std::string>& Enum_" << this->
name() <<
"_map() {\n";
880 oss <<
" static const std::map<Enum_" << this->
name() <<
", std::string> m = {\n";
885 oss <<
" return m;\n";
891 const std::map<std::string, T> enum_map;
902 return "Halide::Internal::halide_type_to_enum_string(" + v +
")";
925 this->
set(new_value_string);
929 return "\"" + this->
value() +
"\"";
937 return "std::string";
994 :
Internal::GeneratorParamImplBase<T>(name, value) {
997 GeneratorParam(
const std::string &name,
const T &value,
const T &min,
const T &max)
1001 GeneratorParam(
const std::string &name,
const T &value,
const std::map<std::string, T> &enum_map)
1002 :
Internal::GeneratorParamImplBase<T>(name, value, enum_map) {
1006 :
Internal::GeneratorParamImplBase<T>(name, value) {
1013template<
typename Other,
typename T>
1017template<
typename Other,
typename T>
1026template<
typename Other,
typename T>
1030template<
typename Other,
typename T>
1039template<
typename Other,
typename T>
1043template<
typename Other,
typename T>
1052template<
typename Other,
typename T>
1056template<
typename Other,
typename T>
1065template<
typename Other,
typename T>
1069template<
typename Other,
typename T>
1078template<
typename Other,
typename T>
1082template<
typename Other,
typename T>
1091template<
typename Other,
typename T>
1095template<
typename Other,
typename T>
1104template<
typename Other,
typename T>
1108template<
typename Other,
typename T>
1117template<
typename Other,
typename T>
1121template<
typename Other,
typename T>
1130template<
typename Other,
typename T>
1134template<
typename Other,
typename T>
1143template<
typename Other,
typename T>
1147template<
typename Other,
typename T>
1156template<
typename Other,
typename T>
1160template<
typename Other,
typename T>
1166 return (T)a && (T)b;
1173template<
typename Other,
typename T>
1177template<
typename Other,
typename T>
1183 return (T)a || (T)b;
1192namespace GeneratorMinMax {
1197template<
typename Other,
typename T>
1199 return min(a, (T)b);
1201template<
typename Other,
typename T>
1203 return min((T)a, b);
1206template<
typename Other,
typename T>
1208 return max(a, (T)b);
1210template<
typename Other,
typename T>
1212 return max((T)a, b);
1221template<
typename Other,
typename T>
1225template<
typename Other,
typename T>
1234template<
typename Other,
typename T>
1238template<
typename Other,
typename T>
1252template<
typename T2>
1253class GeneratorInput_Buffer;
1267 template<
typename T2>
1269 template<
typename T2,
int D2>
1283 template<
typename T2,
int D2>
1299 template<
typename T2,
int D2>
1301 : parameter_(parameter_from_buffer(b)) {
1304 template<
typename T2>
1306 return {t.parameter_};
1309 template<
typename T2>
1311 std::vector<Parameter> r;
1312 r.reserve(v.size());
1313 for (
const auto &
s : v) {
1314 r.push_back(
s.parameter_);
1320class AbstractGenerator;
1335 template<
typename...
Args>
1340 template<
typename Dst>
1358template<
typename T =
void>
1360 template<
typename T2>
1370 const std::shared_ptr<AbstractGenerator> &
gen) {
1371 std::vector<StubOutputBuffer<T>> result;
1372 for (
const Func &
f : v) {
1392 template<
typename T2>
1473 const std::string &
name,
1475 const std::vector<Type> &types,
1508 template<
typename ElemType>
1518 template<
typename T>
1530inline const std::vector<Expr> &GIOBase::get_values<Expr>()
const {
1535inline const std::vector<Func> &GIOBase::get_values<Func>()
const {
1542 const std::string &
name,
1544 const std::vector<Type> &t,
1581template<
typename T,
typename ValueType>
1584 using TBase =
typename std::remove_all_extents<T>::type;
1587 return std::is_array<T>::value;
1590 template<
typename T2 = T,
typename std::enable_if<
1592 !std::is_array<T2>::value>::type * =
nullptr>
1597 template<
typename T2 = T,
typename std::enable_if<
1599 std::is_array<T2>::value && std::rank<T2>::value == 1 && (std::extent<T2, 0>::value > 0)>::type * =
nullptr>
1604 template<
typename T2 = T,
typename std::enable_if<
1606 std::is_array<T2>::value && std::rank<T2>::value == 1 && std::extent<T2, 0>::value == 0>::type * =
nullptr>
1625 const ValueType &
at(
size_t i)
const {
1631 typename std::vector<ValueType>::const_iterator
begin()
const {
1637 typename std::vector<ValueType>::const_iterator
end()
const {
1651#define HALIDE_FORWARD_METHOD(Class, Method) \
1652 template<typename... Args> \
1653 inline auto Method(Args &&...args)->typename std::remove_reference<decltype(std::declval<Class>().Method(std::forward<Args>(args)...))>::type { \
1654 return this->template as<Class>().Method(std::forward<Args>(args)...); \
1657#define HALIDE_FORWARD_METHOD_CONST(Class, Method) \
1658 template<typename... Args> \
1659 inline auto Method(Args &&...args) const-> \
1660 typename std::remove_reference<decltype(std::declval<Class>().Method(std::forward<Args>(args)...))>::type { \
1661 this->check_gio_access(); \
1662 return this->template as<Class>().Method(std::forward<Args>(args)...); \
1673 friend class ::Halide::Func;
1674 friend class ::Halide::Stage;
1677 if (TBase::has_static_halide_type) {
1678 return "Halide::Internal::StubInputBuffer<" +
1682 return "Halide::Internal::StubInputBuffer<>";
1686 template<
typename T2>
1694 TBase::has_static_halide_type ? std::vector<
Type>{TBase::static_halide_type()} : std::vector<Type>{},
1695 TBase::has_static_dimensions ? TBase::static_dimensions() : -1) {
1700 static_assert(!TBase::has_static_halide_type,
"You can only specify a Type argument for Input<Buffer<T>> if T is void or omitted.");
1701 static_assert(!TBase::has_static_dimensions,
"You can only specify a dimension argument for Input<Buffer<T, D>> if D is -1 or omitted.");
1706 static_assert(!TBase::has_static_halide_type,
"You can only specify a Type argument for Input<Buffer<T>> if T is void or omitted.");
1711 TBase::has_static_halide_type ? std::vector<
Type>{TBase::static_halide_type()} : std::vector<Type>{},
1713 static_assert(!TBase::has_static_dimensions,
"You can only specify a dimension argument for Input<Buffer<T, D>> if D is -1 or omitted.");
1716 template<
typename...
Args>
1719 return Func(*
this)(std::forward<Args>(args)...);
1724 return Func(*
this)(std::move(args));
1727 template<
typename T2>
1729 user_assert(!this->
is_array()) <<
"Cannot assign an array type to a non-array type for Input " << this->
name();
1735 return this->
funcs().at(0);
1757 return Func(*this).in();
1762 return Func(*this).in(other);
1767 return Func(*this).in(others);
1772 user_assert(!this->
is_array()) <<
"Cannot convert an Input<Buffer<>[]> to an ImageParam; use an explicit subscript operator: " << this->
name();
1795 typename std::vector<ImageParam>::const_iterator
begin()
const {
1796 user_error <<
"Input<Buffer<>>::begin() is not supported.";
1801 typename std::vector<ImageParam>::const_iterator
end()
const {
1802 user_error <<
"Input<Buffer<>>::end() is not supported.";
1839 template<
typename T2>
1883 template<
typename...
Args>
1886 return this->
funcs().at(0)(std::forward<Args>(args)...);
1891 return this->
funcs().at(0)(args);
1896 return this->
funcs().at(0);
1928 return Func(*this).
in(others);
1956 static_assert(std::is_same<typename std::remove_all_extents<T>::type,
Expr>::value,
"GeneratorInput_DynamicScalar is only legal to use with T=Expr for now");
1966 user_assert(!std::is_array<T>::value) <<
"Input<Expr[]> is not allowed";
1973 return this->
exprs().at(0);
2027 user_assert(value == 0) <<
"Zero is the only legal default value for Inputs which are pointer types.\n";
2041 const std::string &
name)
2046 const std::string &
name,
2055 return this->
exprs().at(0);
2068 user_assert(value ==
nullptr) <<
"nullptr is the only valid estimate for Input<PointerType>";
2079 if (std::is_same<T2, bool>::value) {
2091 if (std::is_same<T2, bool>::value) {
2115 if (!std::is_same<TBase, bool>::value) {
2118 p.set_min_value(
min_);
2121 p.set_max_value(
max_);
2138 const std::string &
name)
2143 const std::string &
name,
2156 const std::string &
name,
2169template<
typename T2,
typename =
void>
2172template<
typename T2>
2213 : Super(name, def) {
2217 : Super(array_size, name, def) {
2222 : Super(name, def,
min,
max) {
2227 : Super(array_size, name, def,
min,
max) {
2231 : Super(name, t, d) {
2244 : Super(array_size, name, t, d) {
2248 : Super(array_size, name, t) {
2254 : Super(array_size, name, d) {
2258 : Super(array_size, name) {
2268 static_assert(std::is_same<T2, Func>::value,
"Only Func allowed here");
2272 user_assert(
funcs_.size() == 1) <<
"Use [] to access individual Funcs in Output<Func[]>";
2337#undef HALIDE_OUTPUT_FORWARD
2338#undef HALIDE_OUTPUT_FORWARD_CONST
2342 const std::string &
name,
2344 const std::vector<Type> &t,
2349 const std::vector<Type> &t,
2375 using TBase =
typename std::remove_all_extents<T>::type;
2379 return std::is_array<T>::value;
2382 template<
typename T2 = T,
typename std::enable_if<
2384 !std::is_array<T2>::value>::type * =
nullptr>
2389 template<
typename T2 = T,
typename std::enable_if<
2391 std::is_array<T2>::value && std::rank<T2>::value == 1 && (std::extent<T2, 0>::value > 0)>::type * =
nullptr>
2396 template<
typename T2 = T,
typename std::enable_if<
2398 std::is_array<T2>::value && std::rank<T2>::value == 1 && std::extent<T2, 0>::value == 0>::type * =
nullptr>
2404 template<
typename...
Args,
typename T2 = T,
typename std::enable_if<!std::is_array<T2>::value>::type * =
nullptr>
2447 typename std::vector<ValueType>::const_iterator
begin()
const {
2453 typename std::vector<ValueType>::const_iterator
end()
const {
2458 template<
typename T2 = T,
typename std::enable_if<
2460 std::is_array<T2>::value && std::rank<T2>::value == 1 && std::extent<T2, 0>::value == 0>::type * =
nullptr>
2480 <<
"Cannot assign Func \"" << f.
name()
2481 <<
"\" to Output \"" << this->
name() <<
"\"\n"
2482 <<
"Output " << this->
name()
2483 <<
" is declared to have " <<
my_types.size() <<
" tuple elements"
2484 <<
" but Func " << f.
name()
2485 <<
" has " << f.
types().size() <<
" tuple elements.\n";
2488 <<
"Cannot assign Func \"" << f.
name()
2489 <<
"\" to Output \"" << this->
name() <<
"\"\n"
2490 << (
my_types.size() > 1 ?
"In tuple element " + std::to_string(
i) +
", " :
"")
2491 <<
"Output " << this->
name()
2493 <<
" but Func " << f.
name()
2494 <<
" has type " << f.
types().at(
i) <<
"\n";
2499 <<
"Cannot assign Func \"" << f.
name()
2500 <<
"\" to Output \"" << this->
name() <<
"\"\n"
2501 <<
"Output " << this->
name()
2502 <<
" has declared dimensionality " << this->
dims()
2503 <<
" but Func " << f.
name()
2504 <<
" has dimensionality " << f.
dimensions() <<
"\n";
2517 TBase::has_static_halide_type ? std::vector<
Type>{TBase::static_halide_type()} : std::vector<Type>{},
2518 TBase::has_static_dimensions ? TBase::static_dimensions() : -1) {
2525 static_assert(!TBase::has_static_halide_type,
"You can only specify a Type argument for Output<Buffer<T, D>> if T is void or omitted.");
2526 static_assert(!TBase::has_static_dimensions,
"You can only specify a dimension argument for Output<Buffer<T, D>> if D is -1 or omitted.");
2532 static_assert(!TBase::has_static_halide_type,
"You can only specify a Type argument for Output<Buffer<T, D>> if T is void or omitted.");
2537 TBase::has_static_halide_type ? std::vector<
Type>{TBase::static_halide_type()} : std::vector<Type>{},
2540 static_assert(!TBase::has_static_dimensions,
"You can only specify a dimension argument for Output<Buffer<T, D>> if D is -1 or omitted.");
2545 TBase::has_static_halide_type ? std::vector<
Type>{TBase::static_halide_type()} : std::vector<Type>{},
2546 TBase::has_static_dimensions ? TBase::static_dimensions() : -1) {
2553 static_assert(!TBase::has_static_halide_type,
"You can only specify a Type argument for Output<Buffer<T, D>> if T is void or omitted.");
2554 static_assert(!TBase::has_static_dimensions,
"You can only specify a dimension argument for Output<Buffer<T, D>> if D is -1 or omitted.");
2560 static_assert(!TBase::has_static_halide_type,
"You can only specify a Type argument for Output<Buffer<T, D>> if T is void or omitted.");
2565 TBase::has_static_halide_type ? std::vector<
Type>{TBase::static_halide_type()} : std::vector<Type>{},
2568 static_assert(!TBase::has_static_dimensions,
"You can only specify a dimension argument for Output<Buffer<T, D>> if D is -1 or omitted.");
2572 if (TBase::has_static_halide_type) {
2573 return "Halide::Internal::StubOutputBuffer<" +
2577 return "Halide::Internal::StubOutputBuffer<>";
2593 template<
typename T2,
int D2>
2599 <<
"Cannot assign to the Output \"" << this->
name()
2600 <<
"\": the expression is not convertible to the same Buffer type and/or dimensions.\n";
2604 <<
"Output " << this->
name() <<
" should have type=" << this->
gio_type() <<
" but saw type=" <<
Type(buffer.
type()) <<
"\n";
2608 <<
"Output " << this->
name() <<
" should have dim=" << this->
dims() <<
" but saw dim=" << buffer.dimensions() <<
"\n";
2613 this->
funcs_.at(0)(_) = buffer(_);
2621 template<
typename T2>
2633 assign_from_func(f);
2639 user_assert(!this->
is_array()) <<
"Cannot convert an Output<Buffer<>[]> to an ImageParam; use an explicit subscript operator: " << this->
name();
2641 return this->
funcs_.at(0).output_buffer();
2647 user_assert(!this->
is_array()) <<
"Cannot call set_estimates() on an array Output; use an explicit subscript operator: " << this->
name();
2649 this->
funcs_.at(0).set_estimates(estimates);
2691 return this->funcs_.at(
i);
2721 this->check_gio_access();
2722 this->check_value_writable();
2726 get_assignable_func_ref(0) = f;
2733 this->check_gio_access();
2734 this->check_value_writable();
2735 return get_assignable_func_ref(
i);
2741 this->check_gio_access();
2742 return Super::operator[](
i);
2746 this->check_gio_access();
2748 for (
Func &f : this->funcs_) {
2749 f.set_estimate(var,
min, extent);
2755 this->check_gio_access();
2757 for (
Func &f : this->funcs_) {
2758 f.set_estimates(estimates);
2811 : Super(array_size, name) {
2819 : Super(name, {t}) {
2827 : Super(name, {t}, d) {
2831 : Super(name, t, d) {
2835 : Super(array_size, name, d) {
2839 : Super(array_size, name, {t}) {
2842 explicit GeneratorOutput(
size_t array_size,
const std::string &name,
const std::vector<Type> &t)
2843 : Super(array_size, name, t) {
2847 : Super(array_size, name, {t}, d) {
2850 explicit GeneratorOutput(
size_t array_size,
const std::string &name,
const std::vector<Type> &t,
int d)
2851 : Super(array_size, name, t, d) {
2857 template<
typename T2,
int D2>
2859 Super::operator=(buffer);
2863 template<
typename T2>
2870 Super::operator=(f);
2879 std::istringstream
iss(value);
2900 if (!error_msg.empty()) {
2908 return std::string();
2913 return std::string();
2918 return std::string();
2928 static std::unique_ptr<Internal::GeneratorParamBase> make(
2930 const std::string &generator_name,
2931 const std::string &
gpname,
2935 std::string error_msg = defined ?
"Cannot set the GeneratorParam " +
gpname +
" for " + generator_name +
" because the value is explicitly specified in the C++ source." :
"";
2936 return std::unique_ptr<GeneratorParam_Synthetic<T>>(
2963 const std::string error_msg;
3021 return autoscheduler_params_;
3029 template<
typename T>
3031 return T::create(*
this);
3033 template<
typename T,
typename...
Args>
3034 inline std::unique_ptr<T>
apply(
const Args &...args)
const {
3069 template<
typename T>
3076 template<
typename T>
3078 template<
typename T = void,
int D = -1>
3080 template<
typename T>
3098template<
typename...
Args>
3104template<
typename T,
typename...
Args>
3115 std::set<std::string> names;
3118 std::vector<Internal::GeneratorParamBase *> filter_generator_params;
3121 std::vector<Internal::GeneratorInputBase *> filter_inputs;
3124 std::vector<Internal::GeneratorOutputBase *> filter_outputs;
3129 std::vector<std::unique_ptr<Internal::GeneratorParamBase>> owned_synthetic_params;
3132 std::vector<std::unique_ptr<Internal::GIOBase>> owned_extras;
3140 return filter_generator_params;
3142 const std::vector<Internal::GeneratorInputBase *> &
inputs()
const {
3143 return filter_inputs;
3145 const std::vector<Internal::GeneratorOutputBase *> &
outputs()
const {
3146 return filter_outputs;
3162 template<
typename data_t>
3177 template<
typename...
Args>
3182 <<
"Expected exactly " <<
pi.inputs().size()
3183 <<
" inputs but got " <<
sizeof...(args) <<
"\n";
3184 set_inputs_vector(build_inputs(std::forward_as_tuple<const Args &...>(args...), std::make_index_sequence<
sizeof...(Args)>{}));
3188 this->check_scheduled(
"realize");
3196 this->check_scheduled(
"realize");
3201 this->check_scheduled(
"realize");
3212 template<
typename T,
3213 typename std::enable_if<std::is_same<T, Halide::Func>::value>::type * =
nullptr>
3217 p->generator =
this;
3218 param_info_ptr->owned_extras.push_back(std::unique_ptr<Internal::GIOBase>(
p));
3219 param_info_ptr->filter_inputs.push_back(
p);
3224 template<
typename T,
3225 typename std::enable_if<!std::is_arithmetic<T>::value && !std::is_same<T, Halide::Func>::value>::type * =
nullptr>
3227 static_assert(!T::has_static_halide_type,
"You can only call this version of add_input() for a Buffer<T, D> where T is void or omitted .");
3228 static_assert(!T::has_static_dimensions,
"You can only call this version of add_input() for a Buffer<T, D> where D is -1 or omitted.");
3231 p->generator =
this;
3232 param_info_ptr->owned_extras.push_back(std::unique_ptr<Internal::GIOBase>(
p));
3233 param_info_ptr->filter_inputs.push_back(
p);
3238 template<
typename T,
3239 typename std::enable_if<!std::is_arithmetic<T>::value && !std::is_same<T, Halide::Func>::value>::type * =
nullptr>
3241 static_assert(T::has_static_halide_type,
"You can only call this version of add_input() for a Buffer<T, D> where T is not void.");
3242 static_assert(!T::has_static_dimensions,
"You can only call this version of add_input() for a Buffer<T, D> where D is -1 or omitted.");
3245 p->generator =
this;
3246 param_info_ptr->owned_extras.push_back(std::unique_ptr<Internal::GIOBase>(
p));
3247 param_info_ptr->filter_inputs.push_back(
p);
3252 template<
typename T,
3253 typename std::enable_if<!std::is_arithmetic<T>::value && !std::is_same<T, Halide::Func>::value>::type * =
nullptr>
3255 static_assert(T::has_static_halide_type,
"You can only call this version of add_input() for a Buffer<T, D> where T is not void.");
3256 static_assert(T::has_static_dimensions,
"You can only call this version of add_input() for a Buffer<T, D> where D is not -1.");
3259 p->generator =
this;
3260 param_info_ptr->owned_extras.push_back(std::unique_ptr<Internal::GIOBase>(
p));
3261 param_info_ptr->filter_inputs.push_back(
p);
3265 template<
typename T,
3266 typename std::enable_if<std::is_arithmetic<T>::value>::type * =
nullptr>
3270 p->generator =
this;
3271 param_info_ptr->owned_extras.push_back(std::unique_ptr<Internal::GIOBase>(
p));
3272 param_info_ptr->filter_inputs.push_back(
p);
3276 template<
typename T,
3277 typename std::enable_if<std::is_same<T, Expr>::value>::type * =
nullptr>
3281 p->generator =
this;
3283 param_info_ptr->owned_extras.push_back(std::unique_ptr<Internal::GIOBase>(
p));
3284 param_info_ptr->filter_inputs.push_back(
p);
3289 template<
typename T,
3290 typename std::enable_if<std::is_same<T, Halide::Func>::value>::type * =
nullptr>
3294 p->generator =
this;
3295 param_info_ptr->owned_extras.push_back(std::unique_ptr<Internal::GIOBase>(
p));
3296 param_info_ptr->filter_outputs.push_back(
p);
3301 template<
typename T,
3302 typename std::enable_if<!std::is_arithmetic<T>::value && !std::is_same<T, Halide::Func>::value>::type * =
nullptr>
3304 static_assert(!T::has_static_halide_type,
"You can only call this version of add_output() for a Buffer<T, D> where T is void or omitted .");
3305 static_assert(!T::has_static_dimensions,
"You can only call this version of add_output() for a Buffer<T, D> where D is -1 or omitted.");
3308 p->generator =
this;
3309 param_info_ptr->owned_extras.push_back(std::unique_ptr<Internal::GIOBase>(
p));
3310 param_info_ptr->filter_outputs.push_back(
p);
3315 template<
typename T,
3316 typename std::enable_if<!std::is_arithmetic<T>::value && !std::is_same<T, Halide::Func>::value>::type * =
nullptr>
3318 static_assert(T::has_static_halide_type,
"You can only call this version of add_output() for a Buffer<T, D> where T is not void.");
3319 static_assert(!T::has_static_dimensions,
"You can only call this version of add_output() for a Buffer<T, D> where D is -1 or omitted.");
3322 p->generator =
this;
3323 param_info_ptr->owned_extras.push_back(std::unique_ptr<Internal::GIOBase>(
p));
3324 param_info_ptr->filter_outputs.push_back(
p);
3329 template<
typename T,
3330 typename std::enable_if<!std::is_arithmetic<T>::value && !std::is_same<T, Halide::Func>::value>::type * =
nullptr>
3332 static_assert(T::has_static_halide_type,
"You can only call this version of add_output() for a Buffer<T, D> where T is not void.");
3333 static_assert(T::has_static_dimensions,
"You can only call this version of add_output() for a Buffer<T, D> where D is not -1.");
3336 p->generator =
this;
3337 param_info_ptr->owned_extras.push_back(std::unique_ptr<Internal::GIOBase>(
p));
3338 param_info_ptr->filter_outputs.push_back(
p);
3344 template<
typename...
Args,
3430 template<
typename T>
3433 template<
typename T>
3477 friend void ::Halide::Internal::generator_test();
3489 std::unique_ptr<GeneratorParamInfo> param_info_ptr;
3491 std::string generator_registered_name, generator_stub_name;
3494 struct Requirement {
3496 std::vector<Expr> error_args;
3498 std::vector<Requirement> requirements;
3503 template<
typename T>
3504 T *find_by_name(
const std::string &
name,
const std::vector<T *> &v) {
3506 if (t->name() ==
name) {
3513 Internal::GeneratorInputBase *find_input_by_name(
const std::string &
name);
3514 Internal::GeneratorOutputBase *find_output_by_name(
const std::string &
name);
3516 void check_scheduled(
const char *
m)
const;
3518 void build_params(
bool force =
false);
3523 void get_host_target();
3524 void get_jit_target_from_environment();
3525 void get_target_from_environment();
3527 void set_inputs_vector(
const std::vector<std::vector<StubInput>> &inputs);
3529 static void check_input_is_singular(Internal::GeneratorInputBase *in);
3530 static void check_input_is_array(Internal::GeneratorInputBase *in);
3537 template<
typename T,
int Dims>
3539 auto *in = param_info().
inputs().at(
i);
3540 check_input_is_singular(in);
3541 const auto k = in->kind();
3549 f(Halide::_) = arg(Halide::_);
3562 template<
typename T,
int Dims>
3563 std::vector<StubInput> build_input(
size_t i,
const GeneratorInput<
Buffer<T, Dims>> &arg) {
3564 auto *in = param_info().
inputs().at(
i);
3565 check_input_is_singular(in);
3566 const auto k = in->kind();
3582 std::vector<StubInput> build_input(
size_t i,
const Func &arg) {
3583 auto *in = param_info().
inputs().at(
i);
3585 check_input_is_singular(in);
3592 std::vector<StubInput> build_input(
size_t i,
const std::vector<Func> &arg) {
3593 auto *in = param_info().
inputs().at(
i);
3595 check_input_is_array(in);
3597 std::vector<StubInput>
siv;
3598 siv.reserve(arg.size());
3599 for (
const auto &f : arg) {
3600 siv.emplace_back(f);
3606 std::vector<StubInput> build_input(
size_t i,
const Expr &arg) {
3607 auto *in = param_info().
inputs().at(
i);
3609 check_input_is_singular(in);
3615 std::vector<StubInput> build_input(
size_t i,
const std::vector<Expr> &arg) {
3616 auto *in = param_info().
inputs().at(
i);
3618 check_input_is_array(in);
3619 std::vector<StubInput>
siv;
3620 siv.reserve(arg.size());
3621 for (
const auto &value : arg) {
3622 siv.emplace_back(value);
3629 template<
typename T,
3630 typename std::enable_if<std::is_arithmetic<T>::value>::type * =
nullptr>
3631 std::vector<StubInput> build_input(
size_t i,
const T &arg) {
3632 auto *in = param_info().
inputs().at(
i);
3634 check_input_is_singular(in);
3642 template<
typename T,
3643 typename std::enable_if<std::is_arithmetic<T>::value>::type * =
nullptr>
3644 std::vector<StubInput> build_input(
size_t i,
const std::vector<T> &arg) {
3645 auto *in = param_info().
inputs().at(
i);
3647 check_input_is_array(in);
3648 std::vector<StubInput>
siv;
3649 siv.reserve(arg.size());
3650 for (
const auto &value : arg) {
3654 siv.emplace_back(e);
3660 std::vector<std::vector<StubInput>> build_inputs(
const std::tuple<const Args &...> &t, std::index_sequence<Indices...>) {
3661 return {build_input(
Indices, std::get<Indices>(t))...};
3666 template<
typename T>
3667 static void get_arguments(std::vector<AbstractGenerator::ArgInfo> &args,
ArgInfoDirection dir,
const T &t) {
3669 args.push_back({e->name(),
3672 e->gio_types_defined() ? e->gio_types() : std::vector<
Type>{},
3673 e->dims_defined() ? e->dims() : 0});
3717 using GeneratorFactoryMap = std::map<const std::string, GeneratorFactory>;
3719 GeneratorFactoryMap factories;
3740 Internal::Introspection::get_introspection_helper<T>()) {
3747 auto g = std::make_unique<T>();
3748 g->init_from_context(
context);
3761 template<
typename...
Args>
3769 template<
typename T2>
3774 template<
typename T2,
typename...
Args>
3775 inline std::unique_ptr<T2>
apply(
const Args &...args)
const {
3789 template<
typename T2,
typename =
void>
3790 struct has_configure_method : std::false_type {};
3792 template<
typename T2>
3795 template<
typename T2,
typename =
void>
3796 struct has_generate_method : std::false_type {};
3798 template<
typename T2>
3801 template<
typename T2,
typename =
void>
3802 struct has_schedule_method : std::false_type {};
3804 template<
typename T2>
3814 t->call_generate_impl();
3815 t->call_schedule_impl();
3819 void call_configure_impl() {
3821 if constexpr (has_configure_method<T>::value) {
3823 static_assert(std::is_void<
decltype(t->configure())>::value,
"configure() must return void");
3829 void call_generate_impl() {
3831 static_assert(has_generate_method<T>::value,
"Expected a generate() method here.");
3833 static_assert(std::is_void<
decltype(t->generate())>::value,
"generate() must return void");
3838 void call_schedule_impl() {
3840 if constexpr (has_schedule_method<T>::value) {
3842 static_assert(std::is_void<
decltype(t->schedule())>::value,
"schedule() must return void");
3851 return this->build_pipeline_impl();
3855 this->call_configure_impl();
3859 this->call_generate_impl();
3863 this->call_schedule_impl();
3867 friend void ::Halide::Internal::generator_test();
3868 friend void ::Halide::Internal::generator_test();
3869 friend class ::Halide::GeneratorContext;
3972 const std::string &name,
3975 const std::string &name,
3985struct halide_global_ns;
3988#define _HALIDE_REGISTER_GENERATOR_IMPL(GEN_CLASS_NAME, GEN_REGISTRY_NAME, FULLY_QUALIFIED_STUB_NAME) \
3989 namespace halide_register_generator { \
3990 struct halide_global_ns; \
3991 namespace GEN_REGISTRY_NAME##_ns { \
3992 std::unique_ptr<Halide::Internal::AbstractGenerator> factory(const Halide::GeneratorContext &context); \
3993 std::unique_ptr<Halide::Internal::AbstractGenerator> factory(const Halide::GeneratorContext &context) { \
3994 using GenType = std::remove_pointer<decltype(new GEN_CLASS_NAME)>::type; \
3995 return GenType::create(context, #GEN_REGISTRY_NAME, #FULLY_QUALIFIED_STUB_NAME); \
3999 auto reg_##GEN_REGISTRY_NAME = Halide::Internal::RegisterGenerator(#GEN_REGISTRY_NAME, GEN_REGISTRY_NAME##_ns::factory); \
4002 static_assert(std::is_same<::halide_register_generator::halide_global_ns, halide_register_generator::halide_global_ns>::value, \
4003 "HALIDE_REGISTER_GENERATOR must be used at global scope");
4005#define _HALIDE_REGISTER_GENERATOR2(GEN_CLASS_NAME, GEN_REGISTRY_NAME) \
4006 _HALIDE_REGISTER_GENERATOR_IMPL(GEN_CLASS_NAME, GEN_REGISTRY_NAME, GEN_REGISTRY_NAME)
4008#define _HALIDE_REGISTER_GENERATOR3(GEN_CLASS_NAME, GEN_REGISTRY_NAME, FULLY_QUALIFIED_STUB_NAME) \
4009 _HALIDE_REGISTER_GENERATOR_IMPL(GEN_CLASS_NAME, GEN_REGISTRY_NAME, FULLY_QUALIFIED_STUB_NAME)
4014#define __HALIDE_REGISTER_ARGCOUNT_IMPL(_1, _2, _3, COUNT, ...) \
4017#define _HALIDE_REGISTER_ARGCOUNT_IMPL(ARGS) \
4018 __HALIDE_REGISTER_ARGCOUNT_IMPL ARGS
4020#define _HALIDE_REGISTER_ARGCOUNT(...) \
4021 _HALIDE_REGISTER_ARGCOUNT_IMPL((__VA_ARGS__, 3, 2, 1, 0))
4023#define ___HALIDE_REGISTER_CHOOSER(COUNT) \
4024 _HALIDE_REGISTER_GENERATOR##COUNT
4026#define __HALIDE_REGISTER_CHOOSER(COUNT) \
4027 ___HALIDE_REGISTER_CHOOSER(COUNT)
4029#define _HALIDE_REGISTER_CHOOSER(COUNT) \
4030 __HALIDE_REGISTER_CHOOSER(COUNT)
4032#define _HALIDE_REGISTER_GENERATOR_PASTE(A, B) \
4035#define HALIDE_REGISTER_GENERATOR(...) \
4036 _HALIDE_REGISTER_GENERATOR_PASTE(_HALIDE_REGISTER_CHOOSER(_HALIDE_REGISTER_ARGCOUNT(__VA_ARGS__)), (__VA_ARGS__))
4052#define HALIDE_REGISTER_GENERATOR_ALIAS(GEN_REGISTRY_NAME, ORIGINAL_REGISTRY_NAME, ...) \
4053 namespace halide_register_generator { \
4054 struct halide_global_ns; \
4055 namespace ORIGINAL_REGISTRY_NAME##_ns { \
4056 std::unique_ptr<Halide::Internal::AbstractGenerator> factory(const Halide::GeneratorContext &context); \
4058 namespace GEN_REGISTRY_NAME##_ns { \
4059 std::unique_ptr<Halide::Internal::AbstractGenerator> factory(const Halide::GeneratorContext &context) { \
4060 auto g = ORIGINAL_REGISTRY_NAME##_ns::factory(context); \
4061 const Halide::GeneratorParamsMap m = __VA_ARGS__; \
4062 g->set_generatorparam_values(m); \
4067 auto reg_##GEN_REGISTRY_NAME = Halide::Internal::RegisterGenerator(#GEN_REGISTRY_NAME, GEN_REGISTRY_NAME##_ns::factory); \
4070 static_assert(std::is_same<::halide_register_generator::halide_global_ns, halide_register_generator::halide_global_ns>::value, \
4071 "HALIDE_REGISTER_GENERATOR_ALIAS must be used at global scope");
4076#define HALIDE_GENERATOR_PYSTUB(GEN_REGISTRY_NAME, MODULE_NAME) \
4077 static_assert(PY_MAJOR_VERSION >= 3, "Python bindings for Halide require Python 3+"); \
4078 extern "C" PyObject *_halide_pystub_impl(const char *module_name, const Halide::Internal::GeneratorFactory &factory); \
4079 namespace halide_register_generator::GEN_REGISTRY_NAME##_ns { \
4080 extern std::unique_ptr<Halide::Internal::AbstractGenerator> factory(const Halide::GeneratorContext &context); \
4082 extern "C" HALIDE_EXPORT_SYMBOL PyObject *PyInit_##MODULE_NAME() { \
4083 const auto factory = halide_register_generator::GEN_REGISTRY_NAME##_ns::factory; \
4084 return _halide_pystub_impl(#MODULE_NAME, factory); \
#define internal_assert(c)
Defines Func - the front-end handle on a halide function, and related classes.
#define HALIDE_GENERATOR_PARAM_TYPED_SETTER(TYPE)
#define HALIDE_FORWARD_METHOD(Class, Method)
#define HALIDE_FORWARD_METHOD_CONST(Class, Method)
#define HALIDE_ALWAYS_INLINE
Classes for declaring image parameters to halide pipelines.
Defines methods for introspecting in C++.
Provides a single global registry of Generators, GeneratorParams, and Params indexed by this pointer.
Defines the structure that describes a Halide target.
#define HALIDE_NO_USER_CODE_INLINE
bool defined() const
Check if this Buffer refers to an existing Buffer.
Helper class for identifying purpose of an Expr passed to memoize.
bool defined() const
Does this function have at least a pure definition.
int dimensions() const
The dimensionality (number of arguments) of this function.
const std::vector< Type > & types() const
Realization realize(std::vector< int32_t > sizes={}, const Target &target=Target())
Evaluate this function over some rectangular domain and return the resulting buffer or buffers.
const std::string & name() const
The name of this function, either given during construction, or automatically generated.
Func in(const Func &f)
Creates and returns a new identity Func that wraps this Func.
A fragment of front-end syntax of the form f(x, y, z), where x, y, z are Vars or Exprs.
GeneratorContext is a class that is used when using Generators (or Stubs) directly; it is used to all...
GeneratorContext with_target(const Target &t) const
GeneratorContext(const Target &t)
std::unique_ptr< T > apply(const Args &...args) const
std::unique_ptr< T > create() const
GeneratorContext & operator=(GeneratorContext &&)=default
GeneratorContext & operator=(const GeneratorContext &)=default
const Target & target() const
GeneratorContext(const Target &t, const AutoschedulerParams &autoscheduler_params)
GeneratorContext()=default
GeneratorContext(const GeneratorContext &)=default
const AutoschedulerParams & autoscheduler_params() const
GeneratorContext(GeneratorContext &&)=default
void call_generate() override
Generator(Generator &&that)=delete
static std::unique_ptr< T > create(const Halide::GeneratorContext &context, const std::string ®istered_name, const std::string &stub_name)
void call_schedule() override
std::unique_ptr< T2 > apply(const Args &...args) const
static std::unique_ptr< T > create(const Halide::GeneratorContext &context)
Generator & operator=(Generator &&that)=delete
Generator & operator=(const Generator &)=delete
void apply(const Args &...args)
void call_configure() override
std::unique_ptr< T2 > create() const
Pipeline build_pipeline() override
Build and return the Pipeline for this AbstractGenerator.
Generator(const Generator &)=delete
typename Super::TBase TBase
GeneratorOutput(const std::string &name)
GeneratorOutput(const std::string &name, const std::vector< Type > &t, int d)
GeneratorOutput< T > & operator=(const Internal::StubOutputBuffer< T2 > &stub_output_buffer)
GeneratorOutput(const char *name)
GeneratorOutput(const std::string &name, const std::vector< Type > &t)
GeneratorOutput(size_t array_size, const std::string &name, int d)
GeneratorOutput(size_t array_size, const std::string &name, const Type &t, int d)
GeneratorOutput(const std::string &name, const Type &t, int d)
GeneratorOutput< T > & operator=(Buffer< T2, D2 > &buffer)
GeneratorOutput(size_t array_size, const std::string &name, const std::vector< Type > &t, int d)
GeneratorOutput(const std::string &name, int d)
GeneratorOutput(size_t array_size, const std::string &name)
GeneratorOutput(const std::string &name, const Type &t)
GeneratorOutput(size_t array_size, const std::string &name, const std::vector< Type > &t)
GeneratorOutput(size_t array_size, const std::string &name, const Type &t)
GeneratorOutput< T > & operator=(const Func &f)
GeneratorParam is a templated class that can be used to modify the behavior of the Generator at code-...
GeneratorParam(const std::string &name, const std::string &value)
GeneratorParam(const std::string &name, const T &value, const T &min, const T &max)
GeneratorParam(const std::string &name, const T &value)
GeneratorParam(const std::string &name, const T &value, const std::map< std::string, T > &enum_map)
An Image parameter to a halide pipeline.
AbstractGenerator is an ABC that defines the API a Generator must provide to work with the existing G...
A reference-counted handle to Halide's internal representation of a function.
GIOBase is the base class for all GeneratorInput<> and GeneratorOutput<> instantiations; it is not pa...
const std::string & name() const
GIOBase & operator=(const GIOBase &)=delete
size_t array_size() const
virtual const char * input_or_output() const =0
GIOBase(size_t array_size, const std::string &name, ArgInfoKind kind, const std::vector< Type > &types, int dims)
void check_matching_dims(int d) const
bool array_size_defined() const
const std::vector< Type > & gio_types() const
bool dims_defined() const
GIOBase & operator=(GIOBase &&)=delete
const std::vector< Func > & funcs() const
std::vector< Type > types_
void check_matching_types(const std::vector< Type > &t) const
std::string array_name(size_t i) const
virtual void check_value_writable() const =0
GIOBase(const GIOBase &)=delete
void check_matching_array_size(size_t size) const
friend class GeneratorStub
GIOBase(GIOBase &&)=delete
void check_gio_access() const
void set_dimensions(int dims)
void set_array_size(int size)
std::vector< Func > funcs_
virtual bool is_array() const
virtual void verify_internals()
virtual ~GIOBase()=default
std::vector< Expr > exprs_
void set_type(const Type &type)
bool gio_types_defined() const
GeneratorBase * generator
const std::vector< Expr > & exprs() const
const std::vector< ElemType > & get_values() const
GeneratorContext context() const override
Return the Target and autoscheduler info that this Generator was created with.
void ensure_configure_has_been_called()
std::string name() override
Return the name of this Generator.
friend class StubOutputBufferBase
virtual void call_schedule()=0
bool allow_out_of_order_inputs_and_outputs() const override
By default, a Generator must declare all Inputs before all Outputs.
GeneratorParam< Target > target
GeneratorBase(size_t size, const void *introspection_helper)
void bind_input(const std::string &name, const std::vector< Parameter > &v) override
Rebind a specified Input to refer to the given piece of IR, replacing the default ImageParam / Param ...
GeneratorInput< T > * add_input(const std::string &name)
std::vector< Func > output_func(const std::string &name) override
Given the name of an output, return the Func(s) for that output.
std::vector< Parameter > input_parameter(const std::string &name) override
Given the name of an input, return the Parameter(s) for that input.
void bind_input(const std::string &name, const std::vector< Func > &v) override
void bind_input(const std::string &name, const std::vector< Expr > &v) override
bool emit_hlpipe(const std::string &hlpipe_file_path) override
Emit a Serialized Halide Pipeline (.hlpipe) file to the given path.
Realization realize(Args &&...args)
GeneratorBase(const GeneratorBase &)=delete
virtual void call_generate()=0
GeneratorOutput< T > * add_output(const std::string &name)
int natural_vector_size() const
Given a data type, return an estimate of the "natural" vector size for that data type when compiling ...
friend class GeneratorInputBase
Target get_target() const
~GeneratorBase() override
virtual void init_from_context(const Halide::GeneratorContext &context)
void check_exact_phase(Phase expected_phase) const
void set_generatorparam_value(const std::string &name, const LoopLevel &loop_level) override
void check_min_phase(Phase expected_phase) const
void realize(Realization r)
enum Halide::Internal::GeneratorBase::Phase Created
void set_generator_names(const std::string ®istered_name, const std::string &stub_name)
Realization realize(std::vector< int32_t > sizes)
GeneratorInput< T > * add_input(const std::string &name, int dimensions)
std::vector< ArgInfo > arginfos() override
Return a list of all the ArgInfos for this generator.
virtual void call_configure()=0
GeneratorInput< T > * add_input(const std::string &name, const Type &type)
void set_generatorparam_value(const std::string &name, const std::string &value) override
Set the value for a specific GeneratorParam for an AbstractGenerator instance.
GeneratorBase(GeneratorBase &&that)=delete
GeneratorOutput< T > * add_output(const std::string &name, int dimensions)
bool using_autoscheduler() const
friend class GeneratorParamBase
bool emit_cpp_stub(const std::string &stub_file_path) override
Emit a Generator Stub (.stub.h) file to the given path.
friend class GeneratorParamInfo
GeneratorBase & operator=(const GeneratorBase &)=delete
GeneratorBase & operator=(GeneratorBase &&that)=delete
void set_inputs(const Args &...args)
set_inputs is a variadic wrapper around set_inputs_vector, which makes usage much simpler in many cas...
GeneratorParam_AutoSchedulerParams autoscheduler_
HALIDE_NO_USER_CODE_INLINE void add_requirement(const Expr &condition, Args &&...error_args)
GeneratorInput< T > * add_input(const std::string &name, const Type &t, int dimensions)
void add_requirement(const Expr &condition, const std::vector< Expr > &error_args)
int natural_vector_size(Halide::Type t) const
Given a data type, return an estimate of the "natural" vector size for that data type when compiling ...
void advance_phase(Phase new_phase)
GeneratorOutput< T > * add_output(const std::string &name, const Type &t, int dimensions)
friend class GeneratorOutputBase
GeneratorFactoryProvider provides a way to customize the Generators that are visible to generate_filt...
virtual AbstractGeneratorPtr create(const std::string &name, const Halide::GeneratorContext &context) const =0
Create an instance of the Generator that is registered under the given name.
GeneratorFactoryProvider(const GeneratorFactoryProvider &)=delete
GeneratorFactoryProvider()=default
GeneratorFactoryProvider & operator=(GeneratorFactoryProvider &&)=delete
GeneratorFactoryProvider(GeneratorFactoryProvider &&)=delete
GeneratorFactoryProvider & operator=(const GeneratorFactoryProvider &)=delete
virtual std::vector< std::string > enumerate() const =0
Return a list of all registered Generators that are available for use with the create() method.
virtual ~GeneratorFactoryProvider()=default
GeneratorOutput_Arithmetic(const std::string &name)
GeneratorOutput_Arithmetic(size_t array_size, const std::string &name)
typename Super::TBase TBase
GeneratorOutput_Buffer(const std::string &name, int d)
GeneratorOutput_Buffer(size_t array_size, const std::string &name)
typename Super::TBase TBase
GeneratorOutput_Buffer(size_t array_size, const std::string &name, const std::vector< Type > &t, int d)
GeneratorOutput_Buffer< T > & operator=(const StubOutputBuffer< T2 > &stub_output_buffer)
GeneratorOutput_Buffer(const std::string &name)
HALIDE_NO_USER_CODE_INLINE std::string get_c_type() const override
GeneratorOutput_Buffer< T > & set_estimates(const Region &estimates)
HALIDE_NO_USER_CODE_INLINE T2 as() const
GeneratorOutput_Buffer(const std::string &name, const std::vector< Type > &t)
GeneratorOutput_Buffer(size_t array_size, const std::string &name, int d)
GeneratorOutput_Buffer< T > & operator=(const Func &f)
HALIDE_NO_USER_CODE_INLINE GeneratorOutput_Buffer< T > & operator=(Buffer< T2, D2 > &buffer)
const Func & operator[](size_t i) const
GeneratorOutput_Buffer(size_t array_size, const std::string &name, const std::vector< Type > &t)
GeneratorOutput_Buffer(const std::string &name, const std::vector< Type > &t, int d)
Func operator[](size_t i)
const Func & operator[](size_t i) const
GeneratorOutput_Func(const std::string &name)
typename Super::TBase TBase
GeneratorOutput_Func< T > & operator=(const Func &f)
GeneratorOutput_Func(const std::string &name, const std::vector< Type > &t, int d)
GeneratorOutput_Func(size_t array_size, const std::string &name, const std::vector< Type > &t, int d)
GeneratorOutput_Func(const std::string &name, int d)
GeneratorOutput_Func< T > & set_estimate(const Var &var, const Expr &min, const Expr &extent)
Func & operator[](size_t i)
GeneratorOutput_Func(const std::string &name, const std::vector< Type > &t)
GeneratorOutput_Func< T > & set_estimates(const Region &estimates)
const char * input_or_output() const override
~GeneratorOutputBase() override
GeneratorOutputBase(const std::string &name, ArgInfoKind kind, const std::vector< Type > &t, int d)
virtual std::string get_c_type() const
HALIDE_NO_USER_CODE_INLINE T2 as() const
void check_value_writable() const override
GeneratorOutputBase(size_t array_size, const std::string &name, ArgInfoKind kind, const std::vector< Type > &t, int d)
Forward schedule-related methods to the underlying Func.
std::vector< ValueType >::const_iterator end() const
const ValueType & operator[](size_t i) const
GeneratorOutputImpl(const std::string &name, ArgInfoKind kind, const std::vector< Type > &t, int d)
const ValueType & at(size_t i) const
std::vector< ValueType >::const_iterator begin() const
bool is_array() const override
FuncRef operator()(std::vector< ExprOrVar > args) const
typename std::remove_all_extents< T >::type TBase
FuncRef operator()(Args &&...args) const
void set_from_string(const std::string &new_value_string) override
std::string get_c_type() const override
GeneratorParam_Arithmetic(const std::string &name, const T &value, const T &min=std::numeric_limits< T >::lowest(), const T &max=std::numeric_limits< T >::max())
std::string get_default_value() const override
std::string call_to_string(const std::string &v) const override
void set_impl(const T &new_value) override
GeneratorParam_AutoSchedulerParams()
std::string get_c_type() const override
void set_from_string(const std::string &new_value_string) override
std::string get_default_value() const override
std::string call_to_string(const std::string &v) const override
void set_from_string(const std::string &new_value_string) override
std::string get_default_value() const override
std::string call_to_string(const std::string &v) const override
GeneratorParam_Bool(const std::string &name, const T &value)
std::string get_c_type() const override
std::string call_to_string(const std::string &v) const override
std::string get_default_value() const override
GeneratorParam_Enum(const std::string &name, const T &value, const std::map< std::string, T > &enum_map)
void set_from_string(const std::string &new_value_string) override
std::string get_c_type() const override
std::string get_type_decls() const override
GeneratorParam_LoopLevel(const std::string &name, const LoopLevel &value)
std::string get_c_type() const override
std::string call_to_string(const std::string &v) const override
bool is_looplevel_param() const override
void set(const LoopLevel &value) override
void set_from_string(const std::string &new_value_string) override
std::string get_default_value() const override
GeneratorParam_String(const std::string &name, const std::string &value)
std::string get_c_type() const override
void set_from_string(const std::string &new_value_string) override
std::string get_default_value() const override
std::string call_to_string(const std::string &v) const override
bool is_synthetic_param() const override
std::string call_to_string(const std::string &v) const override
void set_from_string(const std::string &new_value_string) override
std::string get_default_value() const override
std::string get_c_type() const override
void set_from_string(const std::string &new_value_string) override
GeneratorParam_Target(const std::string &name, const T &value)
std::string get_c_type() const override
std::string get_default_value() const override
std::string call_to_string(const std::string &v) const override
std::string get_type_decls() const override
std::string get_c_type() const override
std::string call_to_string(const std::string &v) const override
std::string get_default_value() const override
GeneratorParam_Type(const std::string &name, const T &value)
void check_value_readable() const
virtual bool is_synthetic_param() const
GeneratorParamBase(GeneratorParamBase &&)=delete
virtual std::string call_to_string(const std::string &v) const =0
void fail_wrong_type(const char *type)
virtual ~GeneratorParamBase()
virtual std::string get_type_decls() const
GeneratorParamBase(const std::string &name)
virtual std::string get_default_value() const =0
void set(const std::string &new_value)
GeneratorParamBase(const GeneratorParamBase &)=delete
virtual std::string get_c_type() const =0
virtual bool is_looplevel_param() const
virtual void set_from_string(const std::string &value_string)=0
void check_value_writable() const
GeneratorParamBase & operator=(GeneratorParamBase &&)=delete
const std::string & name() const
GeneratorParamBase & operator=(const GeneratorParamBase &)=delete
void set(const char *new_value)
void set(const std::string &new_value)
GeneratorParamImpl(const std::string &name, const T &value)
virtual void set_impl(const T &new_value)
const std::vector< Internal::GeneratorInputBase * > & inputs() const
const std::vector< Internal::GeneratorParamBase * > & generator_params() const
GeneratorParamInfo(GeneratorBase *generator, size_t size)
const std::vector< Internal::GeneratorOutputBase * > & outputs() const
GeneratorRegistry(const GeneratorRegistry &)=delete
static AbstractGeneratorPtr create(const std::string &name, const Halide::GeneratorContext &context)
GeneratorRegistry & operator=(GeneratorRegistry &&that)=delete
GeneratorRegistry(GeneratorRegistry &&that)=delete
GeneratorRegistry & operator=(const GeneratorRegistry &)=delete
static void register_factory(const std::string &name, GeneratorFactory generator_factory)
static std::vector< std::string > enumerate()
static void unregister_factory(const std::string &name)
RegisterGenerator(const char *registered_name, GeneratorFactory generator_factory)
Target get_target() const
std::shared_ptr< AbstractGenerator > generator
Realization realize(Args &&...args)
StubOutputBufferBase(const Func &f, const std::shared_ptr< AbstractGenerator > &generator)
Realization realize(std::vector< int32_t > sizes)
StubOutputBuffer is the placeholder that a Stub uses when it requires a Buffer for an output (rather ...
StubOutputBuffer()=default
static std::vector< StubOutputBuffer< T > > to_output_buffers(const std::vector< Func > &v, const std::shared_ptr< AbstractGenerator > &gen)
A reference to a site in a Halide statement at the top of the body of a particular for loop.
static LoopLevel root()
Construct a special LoopLevel value which represents the location outside of all for loops.
static LoopLevel inlined()
Construct a special LoopLevel value that implies that a function should be inlined away.
void set(const LoopLevel &other)
Mutate our contents to match the contents of 'other'.
static Type Bool(int lanes=1)
static Expr cast(Halide::Type t, Expr e)
static Type UInt(int bits, int lanes=1)
static Type Int(int bits, int lanes=1)
static Type Float(int bits, int lanes=1)
Halide::Pipeline Pipeline
A handle on the output buffer of a pipeline.
A scalar parameter to a halide pipeline.
A reference-counted handle to a parameter to a halide pipeline.
void set_default_value(const Expr &e)
Get and set the default values for scalar parameters.
void set_estimate(Expr e)
A class representing a Halide pipeline.
void trace_pipeline()
Generate begin_pipeline and end_pipeline tracing calls for this pipeline.
Realization realize(std::vector< int32_t > sizes={}, const Target &target=Target())
See Func::realize.
A multi-dimensional domain over which to iterate.
A reduction variable represents a single dimension of a reduction domain (RDom).
A Realization is a vector of references to existing Buffer objects.
A single definition of a Func.
Create a small array of Exprs for defining and calling functions with multiple outputs.
A Halide variable, to be used when defining functions.
auto max_forward(const Other &a, const GeneratorParam< T > &b) -> decltype(max(a,(T) b))
auto min_forward(const Other &a, const GeneratorParam< T > &b) -> decltype(min(a,(T) b))
std::function< AbstractGeneratorPtr(const GeneratorContext &context)> GeneratorFactory
int generate_filter_main(int argc, char **argv)
generate_filter_main() is a convenient wrapper for GeneratorRegistry::create() + compile_to_files(); ...
std::string halide_type_to_enum_string(const Type &t)
std::vector< Expr > parameter_constraints(const Parameter &p)
Expr make_const(Type t, int64_t val)
Construct an immediate of the given type from any numeric C++ type.
std::string halide_type_to_c_source(const Type &t)
HALIDE_NO_USER_CODE_INLINE std::string enum_to_string(const std::map< std::string, T > &enum_map, const T &t)
std::vector< Type > parse_halide_type_list(const std::string &types)
std::string halide_type_to_c_type(const Type &t)
std::string print_loop_nest(const std::vector< Function > &output_funcs)
Emit some simple pseudocode that shows the structure of the loop nest specified by this pipeline's sc...
typename select_type< cond< has_static_halide_type_method< TBase >::value, GeneratorOutput_Buffer< T > >, cond< std::is_same< TBase, Func >::value, GeneratorOutput_Func< T > >, cond< std::is_arithmetic< TBase >::value, GeneratorOutput_Arithmetic< T > > >::type GeneratorOutputImplBase
typename select_type< cond< has_static_halide_type_method< TBase >::value, GeneratorInput_Buffer< T > >, cond< std::is_same< TBase, Func >::value, GeneratorInput_Func< T > >, cond< std::is_arithmetic< TBase >::value, GeneratorInput_Arithmetic< T > >, cond< std::is_scalar< TBase >::value, GeneratorInput_Scalar< T > >, cond< std::is_same< TBase, Expr >::value, GeneratorInput_DynamicScalar< T > > >::type GeneratorInputImplBase
typename select_type< cond< std::is_same< T, Target >::value, GeneratorParam_Target< T > >, cond< std::is_same< T, LoopLevel >::value, GeneratorParam_LoopLevel >, cond< std::is_same< T, std::string >::value, GeneratorParam_String< T > >, cond< std::is_same< T, Type >::value, GeneratorParam_Type< T > >, cond< std::is_same< T, bool >::value, GeneratorParam_Bool< T > >, cond< std::is_arithmetic< T >::value, GeneratorParam_Arithmetic< T > >, cond< std::is_enum< T >::value, GeneratorParam_Enum< T > > >::type GeneratorParamImplBase
std::unique_ptr< AbstractGenerator > AbstractGeneratorPtr
void execute_generator(const ExecuteGeneratorArgs &args)
Execute a Generator for AOT compilation – this provides the implementation of the command-line Genera...
HALIDE_NO_USER_CODE_INLINE void collect_print_args(std::vector< Expr > &args)
const GeneratorFactoryProvider & get_registered_generators()
Return a GeneratorFactoryProvider that knows about all the currently-registered C++ Generators.
T parse_scalar(const std::string &value)
const std::map< std::string, Halide::Type > & get_halide_type_enum_map()
T enum_from_string(const std::map< std::string, T > &enum_map, const std::string &s)
This file defines the class FunctionDAG, which is our representation of a Halide pipeline,...
auto operator>=(const Other &a, const GeneratorParam< T > &b) -> decltype(a >=(T) b)
Greater than or equal comparison between GeneratorParam<T> and any type that supports operator>= with...
Type UInt(int bits, int lanes=1)
Constructing an unsigned integer type.
Expr reinterpret(Type t, Expr e)
Reinterpret the bits of one value as another type.
Type Float(int bits, int lanes=1)
Construct a floating-point type.
auto operator==(const Other &a, const GeneratorParam< T > &b) -> decltype(a==(T) b)
Equality comparison between GeneratorParam<T> and any type that supports operator== with T.
@ Internal
Not visible externally, similar to 'static' linkage in C.
auto operator<(const Other &a, const GeneratorParam< T > &b) -> decltype(a<(T) b)
Less than comparison between GeneratorParam<T> and any type that supports operator< with T.
std::map< std::string, std::string > GeneratorParamsMap
auto operator*(const Other &a, const GeneratorParam< T > &b) -> decltype(a *(T) b)
Multiplication between GeneratorParam<T> and any type that supports operator* with T.
auto operator||(const Other &a, const GeneratorParam< T > &b) -> decltype(a||(T) b)
Logical or between between GeneratorParam<T> and any type that supports operator|| with T.
PrefetchBoundStrategy
Different ways to handle accesses outside the original extents in a prefetch.
auto operator-(const Other &a, const GeneratorParam< T > &b) -> decltype(a -(T) b)
Subtraction between GeneratorParam<T> and any type that supports operator- with T.
Expr cast(Expr a)
Cast an expression to the halide type corresponding to the C++ type T.
auto operator!(const GeneratorParam< T > &a) -> decltype(!(T) a)
Not operator for GeneratorParam.
TailStrategy
Different ways to handle a tail case in a split when the factor does not provably divide the extent.
std::function< std::unique_ptr< Internal::CompilerLogger >(const std::string &fn_name, const Target &target)> CompilerLoggerFactory
Type Int(int bits, int lanes=1)
Constructing a signed integer type.
auto operator+(const Other &a, const GeneratorParam< T > &b) -> decltype(a+(T) b)
Addition between GeneratorParam<T> and any type that supports operator+ with T.
Callable create_callable_from_generator(const GeneratorContext &context, const std::string &name, const GeneratorParamsMap &generator_params={})
Create a Generator from the currently-registered Generators, use it to create a Callable.
Expr min(const FuncRef &a, const FuncRef &b)
Explicit overloads of min and max for FuncRef.
auto operator&&(const Other &a, const GeneratorParam< T > &b) -> decltype(a &&(T) b)
Logical and between between GeneratorParam<T> and any type that supports operator&& with T.
auto operator%(const Other &a, const GeneratorParam< T > &b) -> decltype(a %(T) b)
Modulo between GeneratorParam<T> and any type that supports operator% with T.
NameMangling
An enum to specify calling convention for extern stages.
auto operator<=(const Other &a, const GeneratorParam< T > &b) -> decltype(a<=(T) b)
Less than or equal comparison between GeneratorParam<T> and any type that supports operator<= with T.
auto operator>(const Other &a, const GeneratorParam< T > &b) -> decltype(a >(T) b)
Greater than comparison between GeneratorParam<T> and any type that supports operator> with T.
auto operator!=(const Other &a, const GeneratorParam< T > &b) -> decltype(a !=(T) b)
Inequality comparison between between GeneratorParam<T> and any type that supports operator!...
Type Bool(int lanes=1)
Construct a boolean type.
std::vector< Range > Region
A multi-dimensional box.
auto operator/(const Other &a, const GeneratorParam< T > &b) -> decltype(a/(T) b)
Division between GeneratorParam<T> and any type that supports operator/ with T.
Expr max(const FuncRef &a, const FuncRef &b)
MemoryType
An enum describing different address spaces to be used with Func::store_in.
Partition
Different ways to handle loops with a potentially optimizable boundary conditions.
unsigned __INT64_TYPE__ uint64_t
signed __INT64_TYPE__ int64_t
signed __INT32_TYPE__ int32_t
unsigned __INT8_TYPE__ uint8_t
unsigned __INT16_TYPE__ uint16_t
unsigned __INT32_TYPE__ uint32_t
signed __INT16_TYPE__ int16_t
signed __INT8_TYPE__ int8_t
Special the Autoscheduler to be used (if any), along with arbitrary additional arguments specific to ...
A fragment of Halide syntax.
HALIDE_ALWAYS_INLINE Type type() const
Get the type of this expression node.
HALIDE_ALWAYS_INLINE const Internal::BaseExprNode * get() const
Override get() to return a BaseExprNode * instead of an IRNode *.
An argument to an extern-defined Func.
static TO2 value(const FROM &from)
The Dim struct represents one loop in the schedule's representation of a loop nest.
ExecuteGeneratorArgs is the set of arguments to execute_generator().
CompilerLoggerFactory compiler_logger_factory
std::string function_name
enum Halide::Internal::ExecuteGeneratorArgs::BuildMode build_mode
std::string file_base_name
CreateGeneratorFn create_generator
std::string generator_name
std::set< OutputFileType > output_types
std::vector< std::string > suffixes
std::vector< Target > targets
GeneratorParamsMap generator_params
std::function< AbstractGeneratorPtr(const std::string &name, const GeneratorContext &context)> CreateGeneratorFn
HALIDE_ALWAYS_INLINE bool defined() const
static constexpr bool value
typename std::conditional< First::value, typename First::type, void >::type type
A struct representing a target machine and os to generate code for.
int natural_vector_size(const Halide::Type &t) const
Given a data type, return an estimate of the "natural" vector size for that data type when compiling ...
Types in the halide type system.