24 #ifndef TVM_TIR_STMT_H_
25 #define TVM_TIR_STMT_H_
27 #include <tvm/ffi/reflection/registry.h>
31 #include <type_traits>
63 class Stmt :
public ObjectRef {
82 refl::ObjectDef<LetStmtNode>()
125 refl::ObjectDef<AttrStmtNode>()
164 refl::ObjectDef<AssertStmtNode>()
207 refl::ObjectDef<BufferStoreNode>()
223 ffi::Optional<PrimExpr> predicate = std::nullopt,
254 refl::ObjectDef<BufferRealizeNode>()
306 refl::ObjectDef<AllocateNode>()
339 ffi::Map<ffi::String, ffi::Any> annotations = ffi::Map<ffi::String, ffi::Any>(),
355 ffi::Optional<runtime::Tensor>
data;
377 refl::ObjectDef<AllocateConstNode>()
414 Var buffer_var,
DataType dtype, ffi::Array<PrimExpr> extents, ObjectRef data_or_idx,
415 Stmt body, ffi::Map<ffi::String, ffi::Any> annotations = ffi::Map<ffi::String, ffi::Any>(),
431 refl::ObjectDef<DeclBufferNode>()
512 size_t size()
const {
return operator->()->size(); }
537 template <
typename... Args>
539 ffi::Array<Stmt> seq;
541 ffi::details::for_each(
Flattener(&seq), std::forward<Args>(seq_args)...);
545 }
else if (seq.size() == 1) {
552 if constexpr (
sizeof...(seq_args) == 1) {
554 SeqStmt original = opt.value();
555 bool all_same = [&]() {
556 if (original->seq.
size() != seq.size()) {
559 for (
size_t i = 0; i < seq.size(); i++) {
560 if (!original->seq[i].same_as(seq[i])) {
577 explicit Flattener(ffi::Array<Stmt>* seq) : seq_(seq) {}
579 template <
typename T>
581 if constexpr (std::is_same_v<T, SeqStmt>) {
584 if constexpr (!std::is_base_of_v<T, SeqStmt>) {
587 if constexpr (std::is_base_of_v<Stmt, T>) {
588 if (
const SeqStmtNode* ptr = t.template as<SeqStmtNode>()) {
589 return ffi::GetRef<SeqStmt>(ptr);
597 template <
typename T>
599 if constexpr (std::is_base_of_v<ObjectRef, T>) {
601 if (!stmt_or_seq.defined()) {
606 if constexpr (std::is_same_v<T, SeqStmt>) {
608 (*this)(0, stmt_or_seq->seq);
612 if constexpr (std::is_base_of_v<T, SeqStmt>) {
615 if (
auto* op = stmt_or_seq.template as<SeqStmtNode>()) {
621 if constexpr (std::is_base_of_v<T, Evaluate>) {
626 if (
auto* op = stmt_or_seq.template as<EvaluateNode>()) {
627 if (
auto* as_int = op->value.template as<IntImmNode>(); as_int && as_int->value == 0) {
633 if constexpr (std::is_base_of_v<Stmt, T>) {
635 seq_->push_back(stmt_or_seq);
638 for (
auto v : stmt_or_seq) {
645 ffi::Array<Stmt>* seq_;
666 refl::ObjectDef<IfThenElseNode>()
681 ffi::Optional<Stmt> else_case = std::nullopt,
Span span =
Span());
754 refl::ObjectDef<ForNode>()
773 ffi::Optional<IterVar> thread_binding = std::nullopt,
774 ffi::Map<ffi::String, ffi::Any> annotations = ffi::Map<ffi::String, ffi::Any>(),
800 refl::ObjectDef<WhileNode>()
831 refl::ObjectDef<BufferRegionNode>()
887 refl::ObjectDef<MatchBufferRegionNode>()
958 refl::ObjectDef<BlockNode>()
979 ffi::Array<IterVar> iter_vars, ffi::Array<BufferRegion> reads,
980 ffi::Array<BufferRegion> writes, ffi::String name_hint,
Stmt body,
981 ffi::Optional<Stmt> init = std::nullopt,
982 ffi::Array<Buffer> alloc_buffers = ffi::Array<Buffer>(),
983 ffi::Array<MatchBufferRegion> match_buffers = ffi::Array<MatchBufferRegion>(),
984 ffi::Map<ffi::String, ffi::Any> annotations = ffi::Map<ffi::String, ffi::Any>(),
1008 refl::ObjectDef<BlockRealizeNode>()
1231 "meta_schedule.thread_extent_low_inclusive";
1235 "meta_schedule.thread_extent_high_inclusive";
1239 "meta_schedule.random_compute_producer";
1322 return attr_key.compare(0, 7,
"pragma_") == 0;
1345 return "vectorized";
1349 return "thread_binding";
1351 LOG(FATAL) <<
"Unknown ForKind" << t;
Base class for other IR constructs that can be converted to PrimExpr. This is useful for the FFI to c...
Definition: expr.h:154
Managed reference to PrimExprConvertibleNode.
Definition: expr.h:165
Reference to PrimExprNode.
Definition: expr.h:124
Definition: source_map.h:111
Runtime primitive data type.
Definition: data_type.h:47
Allocate a buffer that can be used in body.
Definition: stmt.h:349
static int64_t ConstantAllocationSize(const ffi::Array< PrimExpr > &extents)
If the buffer size is constant, return the size. Otherwise return 0.
TVM_FFI_DECLARE_OBJECT_INFO_FINAL("tir.AllocateConst", AllocateConstNode, StmtNode)
Stmt body
The body to be executed.
Definition: stmt.h:366
DataType dtype
The type of the buffer.
Definition: stmt.h:362
Var buffer_var
The buffer variable.
Definition: stmt.h:352
ffi::Array< PrimExpr > extents
The extents of the buffer.
Definition: stmt.h:364
ffi::Map< ffi::String, ffi::Any > annotations
Additional annotations about the allocation.
Definition: stmt.h:373
ffi::Optional< Integer > irmod_storage_idx
If the PrimFunc containing the Stmt is added to IRModule, this is an optional index to indicate the i...
Definition: stmt.h:360
ffi::Optional< runtime::Tensor > data
The optional data associated to the constant.
Definition: stmt.h:355
int64_t ConstantAllocationSize() const
If the buffer size is constant, return the size. Otherwise return 0.
Definition: stmt.h:392
static void RegisterReflection()
Definition: stmt.h:375
Managed reference to AllocateConstNode.
Definition: stmt.h:407
AllocateConst(Var buffer_var, DataType dtype, ffi::Array< PrimExpr > extents, ObjectRef data_or_idx, Stmt body, ffi::Map< ffi::String, ffi::Any > annotations=ffi::Map< ffi::String, ffi::Any >(), Span span=Span())
TVM_DEFINE_OBJECT_REF_COW_METHOD(AllocateConstNode)
TVM_FFI_DEFINE_OBJECT_REF_METHODS_NULLABLE(AllocateConst, Stmt, AllocateConstNode)
Allocate a buffer that can be used in body.
Definition: stmt.h:284
TVM_FFI_DECLARE_OBJECT_INFO_FINAL("tir.Allocate", AllocateNode, StmtNode)
ffi::Map< ffi::String, ffi::Any > annotations
Additional annotations about the allocation.
Definition: stmt.h:302
PrimExpr condition
Only allocate buffer when condition is satisfied.
Definition: stmt.h:293
Stmt body
The body to be executed.
Definition: stmt.h:295
static int64_t ConstantAllocationSize(const ffi::Array< PrimExpr > &extents)
If the buffer size is constant, return the size. Otherwise return 0.
int64_t ConstantAllocationSize() const
If the buffer size is constant, return the size. Otherwise return 0.
Definition: stmt.h:320
static void RegisterReflection()
Definition: stmt.h:304
DataType dtype
The type of the buffer.
Definition: stmt.h:289
Var buffer_var
The buffer variable.
Definition: stmt.h:287
ffi::Array< PrimExpr > extents
The extents of the buffer.
Definition: stmt.h:291
Managed reference to AllocateNode.
Definition: stmt.h:335
TVM_DEFINE_OBJECT_REF_COW_METHOD(AllocateNode)
TVM_FFI_DEFINE_OBJECT_REF_METHODS_NULLABLE(Allocate, Stmt, AllocateNode)
Allocate(Var buffer_var, DataType dtype, ffi::Array< PrimExpr > extents, PrimExpr condition, Stmt body, ffi::Map< ffi::String, ffi::Any > annotations=ffi::Map< ffi::String, ffi::Any >(), Span span=Span())
Assert condition, if an error occurs, return the error message.
Definition: stmt.h:150
PrimExpr condition
Condition to be checked.
Definition: stmt.h:153
PrimExpr message
Error message when assertion failed.
Definition: stmt.h:155
TVM_FFI_DECLARE_OBJECT_INFO_FINAL("tir.AssertStmt", AssertStmtNode, StmtNode)
static void RegisterReflection()
Definition: stmt.h:162
Stmt body
Body which this assertion holds true. Will be executed after the assertion.
Definition: stmt.h:160
Managed reference to AssertStmtNode.
Definition: stmt.h:176
TVM_FFI_DEFINE_OBJECT_REF_METHODS_NULLABLE(AssertStmt, Stmt, AssertStmtNode)
AssertStmt(PrimExpr condition, PrimExpr message, Stmt body, Span span=Span())
TVM_DEFINE_OBJECT_REF_COW_METHOD(AssertStmtNode)
Define certain auxiliary attribute for the body to be a symbolic value. This provide auxiliary inform...
Definition: stmt.h:112
ffi::Any node
this is attribute about certain node
Definition: stmt.h:115
PrimExpr value
The attribute value, value is well defined at current scope.
Definition: stmt.h:119
Stmt body
The body statement to be executed.
Definition: stmt.h:121
static void RegisterReflection()
Definition: stmt.h:123
ffi::String attr_key
the type key of the attribute
Definition: stmt.h:117
TVM_FFI_DECLARE_OBJECT_INFO_FINAL("tir.AttrStmt", AttrStmtNode, StmtNode)
Managed reference to AttrStmtNode.
Definition: stmt.h:138
TVM_FFI_DEFINE_OBJECT_REF_METHODS_NULLABLE(AttrStmt, Stmt, AttrStmtNode)
AttrStmt(ffi::Any node, ffi::String attr_key, PrimExpr value, Stmt body, Span span=Span())
TVM_DEFINE_OBJECT_REF_COW_METHOD(AttrStmtNode)
A block is a basic schedule unit in TIR.
Definition: stmt.h:929
ffi::String name_hint
The name_hint of the block.
Definition: stmt.h:938
ffi::Array< MatchBufferRegion > match_buffers
The match buffer regions.
Definition: stmt.h:942
ffi::Array< BufferRegion > writes
The write buffer regions of the block.
Definition: stmt.h:936
ffi::Optional< Stmt > init
The init statement is executed during the first iteration of reduction loops in a reduction block....
Definition: stmt.h:952
ffi::Map< ffi::String, ffi::Any > annotations
The annotation of the block.
Definition: stmt.h:944
ffi::Array< IterVar > iter_vars
The variables of the block.
Definition: stmt.h:932
static void RegisterReflection()
Definition: stmt.h:956
ffi::Array< Buffer > alloc_buffers
The buffer allocated in the block.
Definition: stmt.h:940
Stmt body
The body of the block.
Definition: stmt.h:954
ffi::Array< BufferRegion > reads
The read buffer regions of the block.
Definition: stmt.h:934
TVM_FFI_DECLARE_OBJECT_INFO_FINAL("tir.Block", BlockNode, StmtNode)
A block realization node represents execution of the block at the binding values.
Definition: stmt.h:994
TVM_FFI_DECLARE_OBJECT_INFO_FINAL("tir.BlockRealize", BlockRealizeNode, StmtNode)
ffi::Array< PrimExpr > iter_values
The corresponding values of the iter vars.
Definition: stmt.h:997
PrimExpr predicate
The predicate of the block realization, the block will only be executed when the predicate is true.
Definition: stmt.h:1002
static void RegisterReflection()
Definition: stmt.h:1006
Block block
The block to be realized.
Definition: stmt.h:1004
Managed reference to BlockRealizeNode.
Definition: stmt.h:1020
TVM_DEFINE_OBJECT_REF_COW_METHOD(BlockRealizeNode)
BlockRealize(ffi::Array< PrimExpr > iter_values, PrimExpr predicate, Block block, Span span=Span())
TVM_FFI_DEFINE_OBJECT_REF_METHODS_NULLABLE(BlockRealize, Stmt, BlockRealizeNode)
Managed reference to BlockNode.
Definition: stmt.h:976
TVM_DEFINE_OBJECT_REF_COW_METHOD(BlockNode)
Block(ffi::Array< IterVar > iter_vars, ffi::Array< BufferRegion > reads, ffi::Array< BufferRegion > writes, ffi::String name_hint, Stmt body, ffi::Optional< Stmt > init=std::nullopt, ffi::Array< Buffer > alloc_buffers=ffi::Array< Buffer >(), ffi::Array< MatchBufferRegion > match_buffers=ffi::Array< MatchBufferRegion >(), ffi::Map< ffi::String, ffi::Any > annotations=ffi::Map< ffi::String, ffi::Any >(), Span span=Span())
TVM_FFI_DEFINE_OBJECT_REF_METHODS_NULLABLE(Block, Stmt, BlockNode)
Annotate the region where the buffer need to be read and write in the body. We only need to allocate ...
Definition: stmt.h:241
TVM_FFI_DECLARE_OBJECT_INFO_FINAL("tir.BufferRealize", BufferRealizeNode, StmtNode)
BufferRealizeNode()=default
static void RegisterReflection()
Definition: stmt.h:252
Buffer buffer
The buffer variable.
Definition: stmt.h:244
PrimExpr condition
Only realize if condition holds.
Definition: stmt.h:248
Stmt body
The body of realization.
Definition: stmt.h:250
ffi::Array< Range > bounds
Bounds to be realized.
Definition: stmt.h:246
BufferRealizeNode(Buffer buffer, ffi::Array< Range > bounds, PrimExpr condition, Stmt body, Span span=Span())
Definition: stmt.h:262
Managed reference to BufferRealizeNode.
Definition: stmt.h:272
BufferRealize(Buffer buffer, ffi::Array< Range > bounds, PrimExpr condition, Stmt body, Span span=Span())
TVM_FFI_DEFINE_OBJECT_REF_METHODS_NOTNULLABLE(BufferRealize, Stmt, BufferRealizeNode)
TVM_DEFINE_OBJECT_REF_COW_METHOD(BufferRealizeNode)
Representing the region of multi-dimensional buffer access.
Definition: stmt.h:822
TVM_FFI_DECLARE_OBJECT_INFO_FINAL("tir.BufferRegion", BufferRegionNode, PrimExprConvertibleNode)
PrimExpr ToPrimExpr() const final
static void RegisterReflection()
Definition: stmt.h:829
Buffer buffer
The buffer of the buffer region.
Definition: stmt.h:825
static constexpr TVMFFISEqHashKind _type_s_eq_hash_kind
Definition: stmt.h:838
ffi::Array< Range > region
The region array of the buffer region.
Definition: stmt.h:827
Managed reference to BufferRegionNode.
Definition: stmt.h:846
static BufferRegion FullRegion(Buffer buffer)
Create a BufferRegion which is full region of the given buffer.
static BufferRegion FromPoint(Buffer buffer, ffi::Array< PrimExpr > indices)
Create a BufferRegion which is a single point of the given buffer.
TVM_FFI_DEFINE_OBJECT_REF_METHODS_NULLABLE(BufferRegion, PrimExprConvertible, BufferRegionNode)
TVM_DEFINE_OBJECT_REF_COW_METHOD(BufferRegionNode)
BufferRegion(Buffer buffer, ffi::Array< Range > region)
Store value to the high dimension buffer.
Definition: stmt.h:194
Buffer buffer
The buffer variable.
Definition: stmt.h:197
ffi::Array< PrimExpr > indices
The indices location to be stored.
Definition: stmt.h:201
PrimExpr value
The value to be stored.
Definition: stmt.h:199
TVM_FFI_DECLARE_OBJECT_INFO_FINAL("tir.BufferStore", BufferStoreNode, StmtNode)
static void RegisterReflection()
Definition: stmt.h:205
ffi::Optional< PrimExpr > predicate
The predicate mask for storing values.
Definition: stmt.h:203
Managed reference to BufferStoreNode.
Definition: stmt.h:220
TVM_FFI_DEFINE_OBJECT_REF_METHODS_NULLABLE(BufferStore, Stmt, BufferStoreNode)
BufferStore(Buffer buffer, PrimExpr value, ffi::Array< PrimExpr > indices, ffi::Optional< PrimExpr > predicate=std::nullopt, Span span=Span())
TVM_DEFINE_OBJECT_REF_COW_METHOD(BufferStoreNode)
Buffer is a symbolic n-darray structure. It is a composition of primitive symbolic types,...
Definition: buffer.h:156
Declare a buffer that can be used in the body.
Definition: stmt.h:422
static void RegisterReflection()
Definition: stmt.h:429
Buffer buffer
The buffer being declared.
Definition: stmt.h:425
Stmt body
The body to be executed.
Definition: stmt.h:427
TVM_FFI_DECLARE_OBJECT_INFO_FINAL("tir.DeclBuffer", DeclBufferNode, StmtNode)
Managed reference to DeclBufferNode.
Definition: stmt.h:439
DeclBuffer(Buffer buffer, Stmt body, Span span=Span())
TVM_DEFINE_OBJECT_REF_COW_METHOD(DeclBufferNode)
TVM_FFI_DEFINE_OBJECT_REF_METHODS_NULLABLE(DeclBuffer, Stmt, DeclBufferNode)
Evaluates an expression. This is mostly used for putting a Call node into Stmt.
Definition: stmt.h:475
static void RegisterReflection()
Definition: stmt.h:480
PrimExpr value
The expression to be evaluated.
Definition: stmt.h:478
TVM_FFI_DECLARE_OBJECT_INFO_FINAL("tir.Evaluate", EvaluateNode, StmtNode)
Managed reference to EvaluateNode.
Definition: stmt.h:491
TVM_DEFINE_OBJECT_REF_COW_METHOD(EvaluateNode)
Evaluate(int value, Span span=Span())
Definition: stmt.h:495
Evaluate(PrimExpr value, Span span=Span())
TVM_FFI_DEFINE_OBJECT_REF_METHODS_NULLABLE(Evaluate, Stmt, EvaluateNode)
A for loop, with possible type annotations.
Definition: stmt.h:725
PrimExpr min
The minimum value of iteration.
Definition: stmt.h:730
ForKind kind
The kind of the for loop.
Definition: stmt.h:734
TVM_FFI_DECLARE_OBJECT_INFO_FINAL("tir.For", ForNode, StmtNode)
static void RegisterReflection()
Definition: stmt.h:752
Var loop_var
The loop variable.
Definition: stmt.h:728
ffi::Optional< IterVar > thread_binding
Only valid when kind == ForKind::kThreadBinding The context thread that this loop variable bounds to.
Definition: stmt.h:741
ffi::Map< ffi::String, ffi::Any > annotations
Additional annotations about the loop.
Definition: stmt.h:750
PrimExpr extent
The extent of the iteration.
Definition: stmt.h:732
Stmt body
The body of the for loop.
Definition: stmt.h:736
Managed reference to ForNode.
Definition: stmt.h:770
TVM_DEFINE_OBJECT_REF_COW_METHOD(ForNode)
For(Var loop_var, PrimExpr min, PrimExpr extent, ForKind kind, Stmt body, ffi::Optional< IterVar > thread_binding=std::nullopt, ffi::Map< ffi::String, ffi::Any > annotations=ffi::Map< ffi::String, ffi::Any >(), Span span=Span())
TVM_FFI_DEFINE_OBJECT_REF_METHODS_NULLABLE(For, Stmt, ForNode)
IfThenElse statement.
Definition: stmt.h:655
PrimExpr condition
The condition.
Definition: stmt.h:658
TVM_FFI_DECLARE_OBJECT_INFO_FINAL("tir.IfThenElse", IfThenElseNode, StmtNode)
ffi::Optional< Stmt > else_case
The branch to be executed when condition is false, can be null.
Definition: stmt.h:662
static void RegisterReflection()
Definition: stmt.h:664
Stmt then_case
The branch to be executed when condition is true.
Definition: stmt.h:660
Managed reference to IfThenElseNode.
Definition: stmt.h:678
TVM_DEFINE_OBJECT_REF_COW_METHOD(IfThenElseNode)
TVM_FFI_DEFINE_OBJECT_REF_METHODS_NULLABLE(IfThenElse, Stmt, IfThenElseNode)
IfThenElse(PrimExpr condition, Stmt then_case, ffi::Optional< Stmt > else_case=std::nullopt, Span span=Span())
Let binding, bind var to value, then run body.
Definition: stmt.h:71
PrimExpr value
The value to be bound.
Definition: stmt.h:76
Stmt body
The body block.
Definition: stmt.h:78
static void RegisterReflection()
Definition: stmt.h:80
TVM_FFI_DECLARE_OBJECT_INFO_FINAL("tir.LetStmt", LetStmtNode, StmtNode)
Var var
The variable.
Definition: stmt.h:74
Managed reference to LetStmtNode.
Definition: stmt.h:94
TVM_DEFINE_OBJECT_REF_COW_METHOD(LetStmtNode)
LetStmt(Var var, PrimExpr value, Stmt body, Span span=Span())
TVM_FFI_DEFINE_OBJECT_REF_METHODS_NULLABLE(LetStmt, Stmt, LetStmtNode)
Match introduces a constraint that the source buffer region can be remapped to the data layout specif...
Definition: stmt.h:878
TVM_FFI_DECLARE_OBJECT_INFO_FINAL("tir.MatchBufferRegion", MatchBufferRegionNode, Object)
Buffer buffer
The target buffer.
Definition: stmt.h:881
static void RegisterReflection()
Definition: stmt.h:885
BufferRegion source
The source buffer region.
Definition: stmt.h:883
Managed reference to MatchBufferRegionNode.
Definition: stmt.h:900
MatchBufferRegion(Buffer buffer, BufferRegion source)
TVM_FFI_DEFINE_OBJECT_REF_METHODS_NULLABLE(MatchBufferRegion, ObjectRef, MatchBufferRegionNode)
TVM_DEFINE_OBJECT_REF_COW_METHOD(MatchBufferRegionNode)
The container of seq statement. Represent a sequence of statements.
Definition: stmt.h:450
size_t size() const
Definition: stmt.h:456
ffi::Array< Stmt > seq
internal sequence content.
Definition: stmt.h:453
TVM_FFI_DECLARE_OBJECT_INFO_FINAL("tir.SeqStmt", SeqStmtNode, StmtNode)
static void RegisterReflection()
Definition: stmt.h:462
Stmt operator[](size_t index) const
Get the index-th element in the sequence.
Definition: stmt.h:460
Helper class to flatten sequence of arguments into Array.
Definition: stmt.h:575
Flattener(ffi::Array< Stmt > *seq)
Definition: stmt.h:577
static ffi::Optional< SeqStmt > AsSeqStmt(const T &t)
Definition: stmt.h:580
void operator()(size_t i, const T &stmt_or_seq) const
Definition: stmt.h:598
Sequence statement.
Definition: stmt.h:502
TVM_FFI_DEFINE_OBJECT_REF_METHODS_NULLABLE(SeqStmt, Stmt, SeqStmtNode)
size_t size() const
Definition: stmt.h:512
TVM_DEFINE_OBJECT_REF_COW_METHOD(SeqStmtNode)
SeqStmt(ffi::Array< Stmt > seq, Span span=Span())
Construct SeqStmt.
Stmt operator[](size_t index) const
Get the index-th element in the sequence.
Definition: stmt.h:516
static Stmt Flatten(Args &&... seq_args)
Construct a sequence statement by flattening all the arrays and sequences in the arguments recursivel...
Definition: stmt.h:538
Base node of all statements.
Definition: stmt.h:38
TVM_OBJECT_ENABLE_SCRIPT_PRINTER()
TVM_FFI_DECLARE_OBJECT_INFO("tir.Stmt", StmtNode, Object)
static constexpr const uint32_t _type_child_slots
Definition: stmt.h:58
static constexpr TVMFFISEqHashKind _type_s_eq_hash_kind
Definition: stmt.h:56
StmtNode(Span span)
Definition: stmt.h:47
static void RegisterReflection()
Definition: stmt.h:49
Span span
Span that points to the original source code. Reserved debug information.
Definition: stmt.h:44
Container of all statements.
Definition: stmt.h:63
TVM_FFI_DEFINE_OBJECT_REF_METHODS_NULLABLE(Stmt, ObjectRef, StmtNode)
a named variable in TIR
Definition: var.h:77
A While loop.
Definition: stmt.h:791
Stmt body
The body of the while loop.
Definition: stmt.h:796
TVM_FFI_DECLARE_OBJECT_INFO_FINAL("tir.While", WhileNode, StmtNode)
static void RegisterReflection()
Definition: stmt.h:798
PrimExpr condition
The termination condition.
Definition: stmt.h:794
Managed reference to WhileNode.
Definition: stmt.h:811
While(PrimExpr condition, Stmt body, Span span=Span())
TVM_DEFINE_OBJECT_REF_COW_METHOD(WhileNode)
TVM_FFI_DEFINE_OBJECT_REF_METHODS_NULLABLE(While, Stmt, WhileNode)
Definition: repr_printer.h:91
void Evaluate(PrimExpr value)
Evaluate the input expression.
Var var(std::string name_hint, DataType t=DataType::Int(32))
Construct a new Var expression.
constexpr const char * compute_scope
Mark the scope as when computation start to happen This can hint some code generator to create a new ...
Definition: stmt.h:1055
constexpr const char * buffer_bind_scope
Bind the buffer specification to the region of the op When this scope occurs, the stmt....
Definition: stmt.h:1127
constexpr const char * software_pipeline_order
Mark the order of a statement in the software pipeline.
Definition: stmt.h:1206
constexpr const char * meta_schedule_unroll_explicit
Mark auto-unroll setting on the block.
Definition: stmt.h:1248
constexpr const char * hand_threaded
Mark that the kernel is hand threaded and doesn't need syncs inserted.
Definition: stmt.h:1186
constexpr const char * buffer_dim_align
Mark alignment of buffer dimension stmt.node is Tensor stmt.value is tvm_tuple(dim,...
Definition: stmt.h:1115
constexpr const char * channel_read_advance
Advance step of channel after end of scope.
Definition: stmt.h:1132
constexpr const char * volatile_scope
Mark the scope as volatile access for certain handle.
Definition: stmt.h:1044
constexpr const char * meta_schedule_auto_tensorize
Mark that a block should be further rewritten using tensorization.
Definition: stmt.h:1254
constexpr const char * pipeline_stage_scope
pipeline stage scope, implies always execution
Definition: stmt.h:1138
constexpr const char * manifest_shared_memory_local_stage
Mark the local stage for the shared memory access should be added.
Definition: stmt.h:1218
constexpr const char * pragma_import_c
Import C source or file into the final code gen module.
Definition: stmt.h:1075
constexpr const char * pragma_unroll_explicit
Pragma: unroll explicit.
Definition: stmt.h:1071
constexpr const char * meta_schedule_tiling_structure
Mark the tiling structure of blocks that are applied by rule Multi-Level-Tiling.
Definition: stmt.h:1221
constexpr const char * software_pipeline_stage
Mark the stage of a statement in the software pipeline.
Definition: stmt.h:1203
constexpr const char * meta_schedule_random_compute_producer
Mark the block whose producer needs to be applied by rule Random-Compute-Location.
Definition: stmt.h:1238
constexpr const char * warp_execution
Mark that a block is executed by a warp. This implies the extend of threadIdx.x is warp size.
Definition: stmt.h:1298
constexpr const char * device_scope
Mark that it is in the device scope.
Definition: stmt.h:1145
bool IsPragmaKey(const std::string &attr_key)
Check if attr_key is a pragma key extension.
Definition: stmt.h:1321
constexpr const char * thread_extent
Mark launching extent of thread, used by device API.
Definition: stmt.h:1033
constexpr const char * script_parsing_detect_access
Mark whether the script-completer need to fill in missing access region during script parsing.
Definition: stmt.h:1195
constexpr const char * meta_schedule_tensor_core_enabled
Mark that tensor core is enabled in the PrimExpr.
Definition: stmt.h:1269
constexpr const char * virtual_thread
Mark launching of a virtual thread.
Definition: stmt.h:1035
constexpr const char * extern_scope
Mark the scope as generated by extern primitive. such scope can contain arbitrary ir program and we n...
Definition: stmt.h:1050
constexpr const char * meta_schedule_cache_type
Mark a block as generated by cache_read or cache_write block. 0 means cache_read; 1 means cache_write...
Definition: stmt.h:1277
constexpr const char * reduce_scope
Mark of reduce scope.
Definition: stmt.h:1067
constexpr const char * meta_schedule_unroll_implicit
Mark auto-unroll setting on the block.
Definition: stmt.h:1251
constexpr const char * channel_write_scope
channel write scope
Definition: stmt.h:1134
constexpr const char * auto_copy
Mark auto copy for memhammer.
Definition: stmt.h:1286
constexpr const char * rolling_buffer_scope
Mark realization for rolling buffer optimization.
Definition: stmt.h:1104
constexpr const char * async_commit_queue_scope
Annotations for invoking and synchronizing asynchronous operations.
Definition: stmt.h:1169
constexpr const char * device_id
The allocation device for global malloc in host.
Definition: stmt.h:1061
constexpr const char * meta_schedule_thread_extent_low_inclusive
The allowed range of thread extent in thread bindings.
Definition: stmt.h:1230
constexpr const char * meta_schedule_layout_rewrite_preproc
Mark that a block is a preprocessor block for layout rewrite.
Definition: stmt.h:1257
constexpr const char * vector_bytes
Mark vectorization length constraint on block.
Definition: stmt.h:1292
constexpr const char * device_type
The device type.
Definition: stmt.h:1063
constexpr const char * explicit_write_region
Mark that a block has an explicitly specified write region. This is used to override the default writ...
Definition: stmt.h:1311
constexpr const int meta_schedule_cache_type_read
Definition: stmt.h:1280
constexpr const char * software_pipeline_async_stages
List stages in the software pipeline that should run asynchronously.
Definition: stmt.h:1212
constexpr const char * meta_schedule_auto_tensorize_init
Mark that the init statement of a block should be further rewritten using tensorization.
Definition: stmt.h:1261
constexpr const char * meta_schedule_cooperative_fetch
Mark that the loop should be further skip and bound to environment threads to enable cooperative fetc...
Definition: stmt.h:1227
constexpr const char * scan_update_scope
Mark of scan update scope.
Definition: stmt.h:1106
constexpr const char * pragma_auto_unroll_max_step
Pragma: auto-unroll, max_step.
Definition: stmt.h:1069
constexpr const char * loop_scope
Mark of loop scope.
Definition: stmt.h:1065
constexpr const char * double_buffer_scope
Marks production of double buffer data.
Definition: stmt.h:1098
constexpr const char * fragment_shape
Mark that the shape of TensorCore fragment.
Definition: stmt.h:1176
constexpr const char * pragma_tensor_core
Try to modify the AST to support Tensor Core.
Definition: stmt.h:1079
constexpr const char * fragment_layout
Mark that the layout of TensorCore fragment.
Definition: stmt.h:1181
constexpr const char * layout_free_buffers
Mark the buffers which is const access and can be transformed layout.
Definition: stmt.h:1215
constexpr const char * async_wait_queue_scope
Definition: stmt.h:1170
constexpr const char * explicit_read_region
Mark that a block has an explicitly specified read region. This is used to override the default read ...
Definition: stmt.h:1306
constexpr const int meta_schedule_cache_type_write
Definition: stmt.h:1283
constexpr const char * coproc_scope
Mark region is processed by a co-processor.
Definition: stmt.h:1037
constexpr const char * buffer_bound
Mark stores/loads with theirs bounds.
Definition: stmt.h:1117
constexpr const char * async_wait_inflight_count
Definition: stmt.h:1171
constexpr const char * layout_transforms
Marks the layout transforms to be used for a tensor.
Definition: stmt.h:1086
constexpr const char * axis_separators
Marks the physical axis separators.
Definition: stmt.h:1094
constexpr const char * realize_scope
Mark storage scope of realization.
Definition: stmt.h:1059
constexpr const char * irregular_loop_mark
,ark a ForNode represent an irregular loop of non-structural control flow edges.
Definition: stmt.h:1314
constexpr const char * channel_read_scope
channel read scope
Definition: stmt.h:1130
constexpr const char * meta_schedule_thread_extent_high_inclusive
The allowed range of thread extent in thread bindings.
Definition: stmt.h:1234
constexpr const char * channel_write_advance
Advance step of channel after end of scope.
Definition: stmt.h:1136
constexpr const char * coproc_uop_scope
Mark region creates coprocessor micro ops, can be reused if corresponding variable is independent.
Definition: stmt.h:1042
constexpr const char * meta_schedule_inline_rule
Mark that a block is disallowed in auto inline.
Definition: stmt.h:1301
constexpr const char * pragma_loop_partition_hint
Mark that the loop should be partitioned.
Definition: stmt.h:1200
constexpr const char * pipeline_exec_scope
pipeline execution scope, implies the scope can be pipelined.
Definition: stmt.h:1140
constexpr const char * pragma_import_llvm
Import llvm source or file into the final code gen module.
Definition: stmt.h:1077
constexpr const char * pragma_scope_prefix
Mark region is guarded by the pragma extension.
Definition: stmt.h:1073
constexpr const char * scan_init_scope
Mark of scan init scope.
Definition: stmt.h:1108
constexpr const char * require_block_var_bound_predicate
Mark that the block need to add predicate for block var bounds during lowering.
Definition: stmt.h:1266
constexpr const char * storage_alignment
Mark storage alignment requirement of buffers.
Definition: stmt.h:1057
constexpr const char * local_stage
Mark local stage constraint on data copy.
Definition: stmt.h:1289
constexpr const char * meta_schedule_vectorize
Mark auto-vectorize setting on the block.
Definition: stmt.h:1245
constexpr const char * double_buffer_write
Marks region used by double buffer write.
Definition: stmt.h:1102
constexpr const char * async_scope
Mark that the attached statement runs asynchronously.
Definition: stmt.h:1150
constexpr const char * meta_schedule_parallel
Mark auto-parallel setting on the block.
Definition: stmt.h:1242
const char * ForKind2String(ForKind t)
Definition: stmt.h:1338
std::ostream & operator<<(std::ostream &os, CallEffectKind side_effect)
Definition: op_attr_types.h:123
ForKind
The kind of the loop.
Definition: stmt.h:694
@ kThreadBinding
The loop variable is bound to a thread in an environment. In the final stage of lowering,...
@ kParallel
Parallel execution on CPU.
@ kSerial
default semantics – serial execution.
PrimExpr TypeAnnotation(DataType dtype, Span span=Span())
Create a type annotation expression.
@ kVectorized
The loop is vectorized.
Definition: var.h:237
@ kUnrolled
The execution is unrolled.
Definition: var.h:233
Performance counters for profiling via the PAPI library.
Definition: analyzer.h:37
PrimExpr min(PrimExpr a, PrimExpr b, Span span=Span())
take minimum of two values