Halide 19.0.0
Halide compiler and libraries
Loading...
Searching...
No Matches
Halide::Generator< T > Class Template Reference

#include <Generator.h>

Inheritance diagram for Halide::Generator< T >:
Halide::Internal::GeneratorBase Halide::NamesInterface Halide::Internal::AbstractGenerator

Public Member Functions

template<typename... Args>
void apply (const Args &...args)
 
template<typename T2 >
std::unique_ptr< T2 > create () const
 
template<typename T2 , typename... Args>
std::unique_ptr< T2 > apply (const Args &...args) const
 
 Generator (const Generator &)=delete
 
Generatoroperator= (const Generator &)=delete
 
 Generator (Generator &&that)=delete
 
Generatoroperator= (Generator &&that)=delete
 
- Public Member Functions inherited from Halide::Internal::GeneratorBase
 ~GeneratorBase () override
 
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 for the current target.
 
template<typename data_t >
int natural_vector_size () const
 Given a data type, return an estimate of the "natural" vector size for that data type when compiling for the current target.
 
template<typename... Args>
void set_inputs (const Args &...args)
 set_inputs is a variadic wrapper around set_inputs_vector, which makes usage much simpler in many cases, as it constructs the relevant entries for the vector for you, which is often a bit unintuitive at present.
 
Realization realize (std::vector< int32_t > sizes)
 
template<typename... Args, typename std::enable_if< NoRealizations< Args... >::value >::type * = nullptr>
Realization realize (Args &&...args)
 
void realize (Realization r)
 
Pipeline get_pipeline ()
 
template<typename T , typename std::enable_if< std::is_same< T, Halide::Func >::value >::type * = nullptr>
GeneratorInput< T > * add_input (const std::string &name, const Type &t, int dimensions)
 
template<typename T , typename std::enable_if<!std::is_arithmetic< T >::value &&!std::is_same< T, Halide::Func >::value >::type * = nullptr>
GeneratorInput< T > * add_input (const std::string &name, const Type &t, int dimensions)
 
template<typename T , typename std::enable_if<!std::is_arithmetic< T >::value &&!std::is_same< T, Halide::Func >::value >::type * = nullptr>
GeneratorInput< T > * add_input (const std::string &name, int dimensions)
 
template<typename T , typename std::enable_if<!std::is_arithmetic< T >::value &&!std::is_same< T, Halide::Func >::value >::type * = nullptr>
GeneratorInput< T > * add_input (const std::string &name)
 
template<typename T , typename std::enable_if< std::is_arithmetic< T >::value >::type * = nullptr>
GeneratorInput< T > * add_input (const std::string &name)
 
template<typename T , typename std::enable_if< std::is_same< T, Expr >::value >::type * = nullptr>
GeneratorInput< T > * add_input (const std::string &name, const Type &type)
 
template<typename T , typename std::enable_if< std::is_same< T, Halide::Func >::value >::type * = nullptr>
GeneratorOutput< T > * add_output (const std::string &name, const Type &t, int dimensions)
 
template<typename T , typename std::enable_if<!std::is_arithmetic< T >::value &&!std::is_same< T, Halide::Func >::value >::type * = nullptr>
GeneratorOutput< T > * add_output (const std::string &name, const Type &t, int dimensions)
 
template<typename T , typename std::enable_if<!std::is_arithmetic< T >::value &&!std::is_same< T, Halide::Func >::value >::type * = nullptr>
GeneratorOutput< T > * add_output (const std::string &name, int dimensions)
 
template<typename T , typename std::enable_if<!std::is_arithmetic< T >::value &&!std::is_same< T, Halide::Func >::value >::type * = nullptr>
GeneratorOutput< T > * add_output (const std::string &name)
 
void add_requirement (const Expr &condition, const std::vector< Expr > &error_args)
 
template<typename... Args, typename = typename std::enable_if<Internal::all_are_printable_args<Args...>::value>::type>
HALIDE_NO_USER_CODE_INLINE void add_requirement (const Expr &condition, Args &&...error_args)
 
void trace_pipeline ()
 
std::string name () override
 Return the name of this Generator.
 
GeneratorContext context () const override
 Return the Target and autoscheduler info that this Generator was created with.
 
std::vector< ArgInfoarginfos () override
 Return a list of all the ArgInfos for this generator.
 
bool allow_out_of_order_inputs_and_outputs () const override
 By default, a Generator must declare all Inputs before all Outputs.
 
void set_generatorparam_value (const std::string &name, const std::string &value) override
 Set the value for a specific GeneratorParam for an AbstractGenerator instance.
 
void set_generatorparam_value (const std::string &name, const LoopLevel &loop_level) override
 
std::vector< Parameterinput_parameter (const std::string &name) override
 Given the name of an input, return the Parameter(s) for that input.
 
std::vector< Funcoutput_func (const std::string &name) override
 Given the name of an output, return the Func(s) for that output.
 
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 in place 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_cpp_stub (const std::string &stub_file_path) override
 Emit a Generator Stub (.stub.h) file to the given path.
 
bool emit_hlpipe (const std::string &hlpipe_file_path) override
 Emit a Serialized Halide Pipeline (.hlpipe) file to the given path.
 
 GeneratorBase (const GeneratorBase &)=delete
 
GeneratorBaseoperator= (const GeneratorBase &)=delete
 
 GeneratorBase (GeneratorBase &&that)=delete
 
GeneratorBaseoperator= (GeneratorBase &&that)=delete
 
- Public Member Functions inherited from Halide::Internal::AbstractGenerator
virtual ~AbstractGenerator ()=default
 
Module build_module (const std::string &function_name="")
 Call generate() and produce a Module for the result.
 
Module build_gradient_module (const std::string &function_name)
 Build a module that is suitable for using for gradient descent calculation in TensorFlow or PyTorch.
 
Callable compile_to_callable (const JITHandlers *jit_handlers=nullptr, const std::map< std::string, JITExtern > *jit_externs=nullptr)
 JIT the AbstractGenerator into a Callable (using the currently-set Target) and return it.
 
void set_generatorparam_values (const GeneratorParamsMap &m)
 

Static Public Member Functions

static std::unique_ptr< T > create (const Halide::GeneratorContext &context)
 
static std::unique_ptr< T > create (const Halide::GeneratorContext &context, const std::string &registered_name, const std::string &stub_name)
 

Protected Member Functions

 Generator ()
 
Pipeline build_pipeline () override
 Build and return the Pipeline for this AbstractGenerator.
 
void call_configure () override
 
void call_generate () override
 
void call_schedule () override
 
- Protected Member Functions inherited from Halide::Internal::GeneratorBase
 GeneratorBase (size_t size)
 
void set_generator_names (const std::string &registered_name, const std::string &stub_name)
 
virtual void init_from_context (const Halide::GeneratorContext &context)
 
void pre_build ()
 
void post_build ()
 
void pre_configure ()
 
void post_configure ()
 
void pre_generate ()
 
void post_generate ()
 
void pre_schedule ()
 
void post_schedule ()
 
void check_exact_phase (Phase expected_phase) const
 
void check_min_phase (Phase expected_phase) const
 
void advance_phase (Phase new_phase)
 
void ensure_configure_has_been_called ()
 
Target get_target () const
 
bool using_autoscheduler () const
 

Additional Inherited Members

- Protected Types inherited from Halide::Internal::GeneratorBase
enum  Phase {
  Created , ConfigureCalled , InputsSet , GenerateCalled ,
  ScheduleCalled
}
 
template<typename T >
using Input = GeneratorInput<T>
 
template<typename T >
using Output = GeneratorOutput<T>
 
- Protected Types inherited from Halide::NamesInterface
using Expr = Halide::Expr
 
using EvictionKey = Halide::EvictionKey
 
using ExternFuncArgument = Halide::ExternFuncArgument
 
using Func = Halide::Func
 
using GeneratorContext = Halide::GeneratorContext
 
using ImageParam = Halide::ImageParam
 
using LoopLevel = Halide::LoopLevel
 
using MemoryType = Halide::MemoryType
 
using NameMangling = Halide::NameMangling
 
using Partition = Halide::Partition
 
using Pipeline = Halide::Pipeline
 
using PrefetchBoundStrategy = Halide::PrefetchBoundStrategy
 
using RDom = Halide::RDom
 
using RVar = Halide::RVar
 
using TailStrategy = Halide::TailStrategy
 
using Target = Halide::Target
 
using Tuple = Halide::Tuple
 
using Type = Halide::Type
 
using Var = Halide::Var
 
template<typename T >
using GeneratorParam = Halide::GeneratorParam<T>
 
template<typename T = void, int D = -1>
using Buffer = Halide::Buffer<T, D>
 
template<typename T >
using Param = Halide::Param<T>
 
- Static Protected Member Functions inherited from Halide::NamesInterface
template<typename T >
static Expr cast (Expr e)
 
static Expr cast (Halide::Type t, Expr e)
 
static Type Bool (int lanes=1)
 
static Type Float (int bits, int lanes=1)
 
static Type Int (int bits, int lanes=1)
 
static Type UInt (int bits, int lanes=1)
 
- Protected Attributes inherited from Halide::Internal::GeneratorBase
enum Halide::Internal::GeneratorBase::Phase Created
 
GeneratorParam< Targettarget {"target", Target()}
 
GeneratorParam_AutoSchedulerParams autoscheduler_
 

Detailed Description

template<class T>
class Halide::Generator< T >
Examples
tutorial/lesson_15_generators.cpp.

Definition at line 3740 of file Generator.h.

Constructor & Destructor Documentation

◆ Generator() [1/3]

template<class T >
Halide::Generator< T >::Generator ( )
inlineprotected

Definition at line 3742 of file Generator.h.

References Halide::Internal.

◆ Generator() [2/3]

template<class T >
Halide::Generator< T >::Generator ( const Generator< T > & )
delete

◆ Generator() [3/3]

template<class T >
Halide::Generator< T >::Generator ( Generator< T > && that)
delete

Member Function Documentation

◆ create() [1/3]

template<class T >
static std::unique_ptr< T > Halide::Generator< T >::create ( const Halide::GeneratorContext & context)
inlinestatic

Definition at line 3747 of file Generator.h.

◆ create() [2/3]

template<class T >
static std::unique_ptr< T > Halide::Generator< T >::create ( const Halide::GeneratorContext & context,
const std::string & registered_name,
const std::string & stub_name )
inlinestatic

Definition at line 3756 of file Generator.h.

◆ apply() [1/2]

template<class T >
template<typename... Args>
void Halide::Generator< T >::apply ( const Args &... args)
inline

Definition at line 3765 of file Generator.h.

◆ create() [3/3]

template<class T >
template<typename T2 >
std::unique_ptr< T2 > Halide::Generator< T >::create ( ) const
inline

Definition at line 3773 of file Generator.h.

◆ apply() [2/2]

template<class T >
template<typename T2 , typename... Args>
std::unique_ptr< T2 > Halide::Generator< T >::apply ( const Args &... args) const
inline

Definition at line 3778 of file Generator.h.

◆ build_pipeline()

template<class T >
Pipeline Halide::Generator< T >::build_pipeline ( )
inlineoverrideprotectedvirtual

Build and return the Pipeline for this AbstractGenerator.

This method should be called only once per instance.

CALL-AFTER: set_generatorparam_value, bind_input CALL-BEFORE: input_parameter, output_func, external_code_map

Implements Halide::Internal::AbstractGenerator.

Definition at line 3852 of file Generator.h.

◆ call_configure()

template<class T >
void Halide::Generator< T >::call_configure ( )
inlineoverrideprotectedvirtual

Implements Halide::Internal::GeneratorBase.

Definition at line 3857 of file Generator.h.

◆ call_generate()

template<class T >
void Halide::Generator< T >::call_generate ( )
inlineoverrideprotectedvirtual

Implements Halide::Internal::GeneratorBase.

Definition at line 3861 of file Generator.h.

◆ call_schedule()

template<class T >
void Halide::Generator< T >::call_schedule ( )
inlineoverrideprotectedvirtual

Implements Halide::Internal::GeneratorBase.

Definition at line 3865 of file Generator.h.

◆ operator=() [1/2]

template<class T >
Generator & Halide::Generator< T >::operator= ( const Generator< T > & )
delete

◆ operator=() [2/2]

template<class T >
Generator & Halide::Generator< T >::operator= ( Generator< T > && that)
delete

The documentation for this class was generated from the following file: