[TIR] tir.transform.StorageFlatten refactor #9091

Lunderberg · 2021-09-23T13:40:18Z

This started after noticing that StorageFlatten incorrectly handled BufferLoad/BufferStore nodes that pointed to a buffer defined in an attr::buffer_bind_scope annotation. Rather than adding more logic into the existing StorageFlattener mutator, I split up the existing behavior into multiple independent mutators.

This PR includes a series of commits, each of which refactors one of the behaviors out of the StorageFlattener class and into a separate class. While all of the transforms are called sequentially in the tir.transform.StorageFlatten to maintain the same overall behavior, each transform results in a valid TIR tree.

BufferShapeLegalize, which rewrites Buffer nodes to have sizes that match the BufferRealize node in which they are defined.
BufferStrideLegalize, which rewrites the strides of Buffer nodes that are annotated with attr::dim_align.
ThreadScopePropagate, which defines the allocation scope of Buffer nodes based on the thread iter in which they are declared, if no allocation scope was already defined.
BufferBindUnwrapper, which rewrites access into Buffer objects that are defined by attr::buffer_bind_scope. Refactoring this behavior into a separate mutator was my original goal, in order to resolve the issue of BufferLoad/BufferStore nodes that point to bound buffers, but doing so required the previous three behaviors to also be refactored into separate mutators.
StorageFlattener, which contains all remaining behavior from the original StorageFlattener, and outputs the final Allocate/Store/Load nodes.

This refactor will also help in the future, when introducing layout transformations.

Lunderberg · 2021-09-23T13:40:26Z

@csullivan

tmoreau89 · 2021-09-23T20:44:58Z

CC @kparzysz-quic

junrushao · 2021-09-23T20:46:59Z

CC: @vinx13

csullivan

This looks great @Lunderberg, thank you! I'm part way through review and will continue more this afternoon. Very nice to see the functionality of storage flatten broken out into their logical units, and also dependence on AttrStmts removed early.

csullivan · 2021-09-24T16:47:25Z

src/tir/transforms/storage_flatten.cc

+      ICHECK_EQ(op->buffer->shape.size(), op->bounds.size())
+          << "External buffer realize has mismatched dimension";


Consider making this a CHECK as external buffers can be provided by the user and failing this check could indicate a use error.

Makes sense, and changed.

csullivan · 2021-09-24T17:13:22Z

src/tir/transforms/storage_flatten.cc

+  }
+
+ private:
+  Stmt HandleBufferBindScope(const AttrStmtNode* op) {


Add a comment describing that the buffer bind scope buffer attributes are updated according to the legalized buffer. Similarly add comments in the other passes which have BufferBindScope handler methods.

Makes sense, and comments have been added.

csullivan · 2021-09-24T17:25:40Z

src/tir/transforms/storage_flatten.cc

+
+    // Keeping this to have matched behavior to previous version.
+    // There are many parts of the codebase that assume that a strided
+    // array cannot be compact.


nit: An example of one such case that makes this assumption could be useful for context.

Makes sense, and added.

csullivan

Finishing up the review,

csullivan · 2021-09-27T17:17:47Z

src/tir/transforms/storage_flatten.cc

+  //   but this binded region is a subregion of
+  //   a matrix(tensor), which means it requires strides.
+  //
+  // We do support a few relaxed case, such as bindingx


Typo,

Suggested change

// We do support a few relaxed case, such as bindingx

// We do support a few relaxed case, such as binding a

Typo fixed.

csullivan · 2021-09-27T17:39:31Z

src/tir/transforms/storage_flatten.cc

+    PrimExpr ElemOffset() const {
+      ICHECK(remap);
+
+      Buffer copy = remap->target;
+      {
+        Array<PrimExpr> shape;
+        for (auto r : bounds) {
+          shape.push_back(r->extent);
+        }
+        copy.CopyOnWrite()->shape = std::move(shape);
+      }
+
+      Buffer target_slice = copy.MakeSlice(remap->begins, remap->extents);
+      if (buffer->strides.size() == 0) {
+        ICHECK_EQ(target_slice->strides.size(), 0U)
+            << "Trying to bind compact buffer to strided one strides=" << target_slice->strides;
+      } else {
+        target_slice = target_slice.MakeStrideView();
+      }
+
+      return copy->ElemOffset(remap->begins);
+    }
+  };


Not seeing struct BufferEntry::ElemOffset used anywhere. Consider removing or refactoring to use the method?

And removed. It was part of an earlier (and broken) implementation.

csullivan · 2021-09-27T17:42:17Z

src/tir/transforms/storage_flatten.cc

+// The specific tensor data layout is not determined before
+// StorageFlatten pass. We use buffer_bind_scope
+// to specify before hand we want to bind a subregion
+// of tensor to a symbolic buffer, which get used in extern.
+//
+// Example:
+//
+// realize A in range [i*4, extent=10) {
+//   bind Ab to A in [i*4+1, extent=4) {
+//     call_func(Ab.ptr, Ab.shape[0])
+//   }
+// }
+//
+// After StorageFlatten
+//
+// alloc A[10]
+//   call(A + 1,  4)
+//
+// Buffer is a protocol to declare specific
+// data layout and shape we expect.
+// So this function need to check:
+// - If the bind range is within the realize range
+// - If we can match the requirement of buffer
+// - Remap variables such as Ab.ptr to the actual value.
+//
+// Here are a few possible failure cases:
+// - Buffer is declared to have constant shape,
+//   but we try to bind it to a different one.
+// - Buffer is declared to be compact(no strides)
+//   but this binded region is a subregion of
+//   a matrix(tensor), which means it requires strides.
+//
+// We do support a few relaxed case, such as bindingx
+// region with shape [1, 1, n, m] to buffer with shape [n, m]


These docs are duplicated from those on the BufferBindUnwrapper. Consider removing or updating.

Thank you, and updated to have shorter documentation in BufferBindUnwrapper, while StorageFlatten maintains the full documentation.

csullivan · 2021-09-27T17:45:17Z

src/tir/transforms/storage_flatten.cc

+
+    fptr->body = ThreadScopePropagate(fptr->buffer_map)(std::move(fptr->body));
+
+    fptr->body = BufferBindUnwrapper(fptr->buffer_map, &bound_analyzer)(std::move(fptr->body));


In reading through the refactor, it occurs to me that the passes prior to BufferBindUnwrapper could be simpler if the buffer_bind_scope was unwrapped earlier, e.g. prior to ThreadScopePropagate or perhaps first of all. Then each pass would not need to special case the handling done in the variants of HandleBufferBindScope.

Is there something that makes it difficult to apply BufferBindUnwrapper earlier?

I agree that I'd want to unwrap the binds earlier, if I could, to prevent the amount of rewriting needed to pass the updated buffers along. The main issue I ran into was for IR definitions that directly reference buf.elem_offset (example). In order to determine the offset of the bufffer view relative to the data pointer of the parent buffer, the shape and strides of the parent buffer need to be determined first.

I have two ideas for making the implementation be cleaner and more readable. One is to change how data are packed in an AttrStmtNode for buffer_bind_scope, to use the MatchBufferRegion class. The other is to extend StmtExprMutator to act on BufferNode, so that the buffer replacements only need to be done in a single location for each pass through. As it is, rewriting the BufferStoreNode, BufferLoadNode, AttrStmtNode, and CallNode must be done each time the buffer gets modified, even if it's just to use the modified Buffer object.

Parametrized it to get more detailed information while debugging failures in apache#9091, but isn't semantically part of that PR.

csullivan · 2021-09-28T16:18:24Z

src/tir/transforms/storage_flatten.cc

+      // behavior from ArgBinder::BindBuffer.
+      size_t diff = entry.realized_begins.size() - op->indices.size();
+      for (size_t i = 0; i < diff; i++) {
+        new_indices.push_back(0);


Assuming this is for matching cases like [1, 1, n, m], do we need to check that the leading axes are indeed extent=1?

Let me ask a more general question, is it possible to expand or squeeze all shapes and then do exact matching as before? Noticing a fair amount of special casing in this commit for handling the extra unit dimensions.

For the specific case, there is a check as part of the call to ArgBinder::BindBuffer. I'll add a comment to indicate that.

For the general question, that was the intent in BufferShapeLegalize, so that afterwards the buffers all have a single well-defined shape. It looks like I had missed one case where BufferBindUnwrapper changed the number of dimensions when binding to an external buffer, but I've added another commit to this PR to pull that behavior into BufferShapeLegalize instead.

Parametrized it to get more detailed information while debugging failures in #9091, but isn't semantically part of that PR.

Allowed a compact DLTensor to bind to a Buffer object that defines strides, if the strides defined correspond to a compact layout.

Previously, StorageFlattener would determine the shape of a physical buffer based on the extents of the BufferRealizeNode. Pulled these out into a separate BufferShapeLegalize pass. After this pass, all buffers have a shape that matches the buffer realization extents.

Previously, StorageFlattener would handle any attr::dim_align annotations. Now, this is pulled out into a separate BufferStrideLegalize pass.

Previously, StorageFlattener would use the scope in IterVar to assign a scope to allocated buffers, where not otherwise defined. This has been pulled out into a separate ThreadScopePropagate pass.

Previously, StorageFlattener would look for `attr::buffer_bind_scope` to determine if a Buffer object is a view into another buffer, and would apply that mapping while making the Allocate/Store/Load nodes. Now, the mapping of buffer binds is pulled out into a separate BufferStrideUnwrapper pass. This also resolves an issue in which BufferLoad/BufferStore nodes that refer to a Buffer defined through `attr::buffer_bind_scope` would generate Load/Store nodes that point to the linked buffer, rather than the actual buffer.

Even after BufferShapeLegalize, rank-zero tensors may have an empty shape.

Original refactoring requiring that a bufferview have no explicit striding, and instead take the striding from the buffer that it is viewing. Modified to allow bufferview to specify striding, so long as it is consistent with the viewed buffer's striding. This reproduces the behavior of StorageFlatten before the refactoring.

AttrStmtNodes that contain rewritten Buffers need to be rewritten as well.

The earlier stage of the refactor left a buffer's storage scope undefined if it's scope was not determined by the IterVar of a loop containing its allocation. Now, these are explicitly set to StorageScope::kGlobal, to match the previous behavior of StorageFlatten.

data.

needs special handling.

assumed to have no strides defined.

Maintains earlier behavior of StorageFlatten, which allows buffer views to be mapped to higher dimension buffers, if the view extent is 1 in each extra dimension.

…d_scope.

Previously, BufferBindUnwrapper passed fuzzy_match=true to ArgBinder::BindBuffer, which could change the number of dimensions. Now, all buffer dimensions should be updated prior to BufferBindUnwrapper, and it is an error to have mismatched dimensions in BufferBindUnwrapper.

Lunderberg · 2021-09-29T15:38:23Z

Latest round of changes, added another pass to remove assert statements that can be statically validated. These are placed by ArgBinder::Bind if it can't verify a constraint at the time when it binds a variable. If later variable substitutions allow the constraint to be statically verified, they can still remain in the final generated code. These didn't appear prior to the refactor, because StorageFlatten made a single substitution, whereas the refactor does so in multiple passes.

ArgBinder::BindBuffer inserts these assert statements if they are not verifiable at the time of substitution. Previously, with one giant substitution, the assertions were verifiable at that time. After the refactor, with substitutions done in multiple stages for shape/stride/buffer_bind_scope, we need to clean up any assertions that are verifiable after all substitutions have occurred.

- Removed StorageFlattener::BufferEntry::RelIndex, behavior already handled by BufferShapeLegalize. - Improved comments and error messages. - Extracted duplicate behavior in BufferLoad/BufferStore handling in BufferShapeLegalize.

A true Assert statement can be removed, but a false Assert statement requires CFA to give as a compile-time error. Since we only need the removal of true assert statements, skipping the CFA this time.

csullivan

LGTM! Thanks @Lunderberg!

tmoreau89

Thank you @Lunderberg LGTM

tmoreau89 · 2021-10-01T00:12:59Z

Thanks @csullivan and @Lunderberg the PR has been merged.

Parametrized it to get more detailed information while debugging failures in apache#9091, but isn't semantically part of that PR.

@csullivan

* [TE] Improved flexibility of ArgBinder::BindDLTensor Allowed a compact DLTensor to bind to a Buffer object that defines strides, if the strides defined correspond to a compact layout. * [TIR] Exposed ElemOffset as a member function of BufferNode. * [TE] Pulled shape determination out of StorageFlattener Previously, StorageFlattener would determine the shape of a physical buffer based on the extents of the BufferRealizeNode. Pulled these out into a separate BufferShapeLegalize pass. After this pass, all buffers have a shape that matches the buffer realization extents. * [TE] Refactor stride calculation out of StorageFlattener Previously, StorageFlattener would handle any attr::dim_align annotations. Now, this is pulled out into a separate BufferStrideLegalize pass. * [TE] Refactor thread scope propagation out of StorageFlattener. Previously, StorageFlattener would use the scope in IterVar to assign a scope to allocated buffers, where not otherwise defined. This has been pulled out into a separate ThreadScopePropagate pass. * [TE] Refactor buffer bind mapping out of StorageFlattener. Previously, StorageFlattener would look for `attr::buffer_bind_scope` to determine if a Buffer object is a view into another buffer, and would apply that mapping while making the Allocate/Store/Load nodes. Now, the mapping of buffer binds is pulled out into a separate BufferStrideUnwrapper pass. This also resolves an issue in which BufferLoad/BufferStore nodes that refer to a Buffer defined through `attr::buffer_bind_scope` would generate Load/Store nodes that point to the linked buffer, rather than the actual buffer. * [TIR] Removed checks on buffer->shape.size() Even after BufferShapeLegalize, rank-zero tensors may have an empty shape. * [TIR] Relaxed check on a bufferview's striding. Original refactoring requiring that a bufferview have no explicit striding, and instead take the striding from the buffer that it is viewing. Modified to allow bufferview to specify striding, so long as it is consistent with the viewed buffer's striding. This reproduces the behavior of StorageFlatten before the refactoring. * [TIR] Fixed StorageFlatten test for shape_legalize. AttrStmtNodes that contain rewritten Buffers need to be rewritten as well. * [TIR] Assigned storage scope The earlier stage of the refactor left a buffer's storage scope undefined if it's scope was not determined by the IterVar of a loop containing its allocation. Now, these are explicitly set to StorageScope::kGlobal, to match the previous behavior of StorageFlatten. * Updated ICHECK_EQ to CHECK_EQ for a test that depends on user-provided data. * Added comments in storage_flatten.cc, indicating why buffer_bind_scope needs special handling. * Updated comment with a few examples of where compact buffers are assumed to have no strides defined. * Updated following @csullivan's comments. * Added fuzzy mapping to the BufferShapeLegalize. Maintains earlier behavior of StorageFlatten, which allows buffer views to be mapped to higher dimension buffers, if the view extent is 1 in each extra dimension. * Updated BufferShapeLegalize, asserts need to be inside the buffer_bind_scope. * Pulled all shape-dependent behavior into BufferShapeLegalize. Previously, BufferBindUnwrapper passed fuzzy_match=true to ArgBinder::BindBuffer, which could change the number of dimensions. Now, all buffer dimensions should be updated prior to BufferBindUnwrapper, and it is an error to have mismatched dimensions in BufferBindUnwrapper. * Added another pass to remove verifiable assert statements. ArgBinder::BindBuffer inserts these assert statements if they are not verifiable at the time of substitution. Previously, with one giant substitution, the assertions were verifiable at that time. After the refactor, with substitutions done in multiple stages for shape/stride/buffer_bind_scope, we need to clean up any assertions that are verifiable after all substitutions have occurred. * Minor cleanup - Removed StorageFlattener::BufferEntry::RelIndex, behavior already handled by BufferShapeLegalize. - Improved comments and error messages. - Extracted duplicate behavior in BufferLoad/BufferStore handling in BufferShapeLegalize. * Updated to handle BufferRealizeNode with no defined bounds. * Updated to be less aggressive when checking AssertStmt A true Assert statement can be removed, but a false Assert statement requires CFA to give as a compile-time error. Since we only need the removal of true assert statements, skipping the CFA this time.

Parametrized it to get more detailed information while debugging failures in apache#9091, but isn't semantically part of that PR.

@csullivan

* [TE] Improved flexibility of ArgBinder::BindDLTensor Allowed a compact DLTensor to bind to a Buffer object that defines strides, if the strides defined correspond to a compact layout. * [TIR] Exposed ElemOffset as a member function of BufferNode. * [TE] Pulled shape determination out of StorageFlattener Previously, StorageFlattener would determine the shape of a physical buffer based on the extents of the BufferRealizeNode. Pulled these out into a separate BufferShapeLegalize pass. After this pass, all buffers have a shape that matches the buffer realization extents. * [TE] Refactor stride calculation out of StorageFlattener Previously, StorageFlattener would handle any attr::dim_align annotations. Now, this is pulled out into a separate BufferStrideLegalize pass. * [TE] Refactor thread scope propagation out of StorageFlattener. Previously, StorageFlattener would use the scope in IterVar to assign a scope to allocated buffers, where not otherwise defined. This has been pulled out into a separate ThreadScopePropagate pass. * [TE] Refactor buffer bind mapping out of StorageFlattener. Previously, StorageFlattener would look for `attr::buffer_bind_scope` to determine if a Buffer object is a view into another buffer, and would apply that mapping while making the Allocate/Store/Load nodes. Now, the mapping of buffer binds is pulled out into a separate BufferStrideUnwrapper pass. This also resolves an issue in which BufferLoad/BufferStore nodes that refer to a Buffer defined through `attr::buffer_bind_scope` would generate Load/Store nodes that point to the linked buffer, rather than the actual buffer. * [TIR] Removed checks on buffer->shape.size() Even after BufferShapeLegalize, rank-zero tensors may have an empty shape. * [TIR] Relaxed check on a bufferview's striding. Original refactoring requiring that a bufferview have no explicit striding, and instead take the striding from the buffer that it is viewing. Modified to allow bufferview to specify striding, so long as it is consistent with the viewed buffer's striding. This reproduces the behavior of StorageFlatten before the refactoring. * [TIR] Fixed StorageFlatten test for shape_legalize. AttrStmtNodes that contain rewritten Buffers need to be rewritten as well. * [TIR] Assigned storage scope The earlier stage of the refactor left a buffer's storage scope undefined if it's scope was not determined by the IterVar of a loop containing its allocation. Now, these are explicitly set to StorageScope::kGlobal, to match the previous behavior of StorageFlatten. * Updated ICHECK_EQ to CHECK_EQ for a test that depends on user-provided data. * Added comments in storage_flatten.cc, indicating why buffer_bind_scope needs special handling. * Updated comment with a few examples of where compact buffers are assumed to have no strides defined. * Updated following @csullivan's comments. * Added fuzzy mapping to the BufferShapeLegalize. Maintains earlier behavior of StorageFlatten, which allows buffer views to be mapped to higher dimension buffers, if the view extent is 1 in each extra dimension. * Updated BufferShapeLegalize, asserts need to be inside the buffer_bind_scope. * Pulled all shape-dependent behavior into BufferShapeLegalize. Previously, BufferBindUnwrapper passed fuzzy_match=true to ArgBinder::BindBuffer, which could change the number of dimensions. Now, all buffer dimensions should be updated prior to BufferBindUnwrapper, and it is an error to have mismatched dimensions in BufferBindUnwrapper. * Added another pass to remove verifiable assert statements. ArgBinder::BindBuffer inserts these assert statements if they are not verifiable at the time of substitution. Previously, with one giant substitution, the assertions were verifiable at that time. After the refactor, with substitutions done in multiple stages for shape/stride/buffer_bind_scope, we need to clean up any assertions that are verifiable after all substitutions have occurred. * Minor cleanup - Removed StorageFlattener::BufferEntry::RelIndex, behavior already handled by BufferShapeLegalize. - Improved comments and error messages. - Extracted duplicate behavior in BufferLoad/BufferStore handling in BufferShapeLegalize. * Updated to handle BufferRealizeNode with no defined bounds. * Updated to be less aggressive when checking AssertStmt A true Assert statement can be removed, but a false Assert statement requires CFA to give as a compile-time error. Since we only need the removal of true assert statements, skipping the CFA this time.

Lunderberg requested review from Hzfengsy, junrushao, kparzysz-quic, masahi, tqchen, vinx13 and ZihengJiang as code owners September 23, 2021 13:40

csullivan reviewed Sep 24, 2021

View reviewed changes

Lunderberg force-pushed the storage_flatten_refactor branch from d797be3 to a92100d Compare September 27, 2021 13:06

csullivan reviewed Sep 27, 2021

View reviewed changes

Lunderberg added a commit to Lunderberg/tvm that referenced this pull request Sep 28, 2021

[UnitTest] Parametrized test_conv2d_int8_intrinsics

0b05451

Parametrized it to get more detailed information while debugging failures in apache#9091, but isn't semantically part of that PR.

Lunderberg mentioned this pull request Sep 28, 2021

[UnitTest] Parametrized test_conv2d_int8_intrinsics #9143

Merged

csullivan reviewed Sep 28, 2021

View reviewed changes

masahi pushed a commit that referenced this pull request Sep 29, 2021

[UnitTest] Parametrized test_conv2d_int8_intrinsics (#9143)

0467539

Parametrized it to get more detailed information while debugging failures in #9091, but isn't semantically part of that PR.

Lunderberg added 13 commits September 29, 2021 10:34

[TE] Improved flexibility of ArgBinder::BindDLTensor

e2afbbc

Allowed a compact DLTensor to bind to a Buffer object that defines strides, if the strides defined correspond to a compact layout.

[TIR] Exposed ElemOffset as a member function of BufferNode.

806eb13

[TE] Refactor stride calculation out of StorageFlattener

6599278

Previously, StorageFlattener would handle any attr::dim_align annotations. Now, this is pulled out into a separate BufferStrideLegalize pass.

[TE] Refactor thread scope propagation out of StorageFlattener.

0716e01

Previously, StorageFlattener would use the scope in IterVar to assign a scope to allocated buffers, where not otherwise defined. This has been pulled out into a separate ThreadScopePropagate pass.

[TIR] Removed checks on buffer->shape.size()

1c729e6

Even after BufferShapeLegalize, rank-zero tensors may have an empty shape.

[TIR] Fixed StorageFlatten test for shape_legalize.

f361263

AttrStmtNodes that contain rewritten Buffers need to be rewritten as well.

Updated ICHECK_EQ to CHECK_EQ for a test that depends on user-provided

31c4269

data.

Added comments in storage_flatten.cc, indicating why buffer_bind_scope

7d3f1ae

needs special handling.

Updated comment with a few examples of where compact buffers are

506c391

assumed to have no strides defined.

Lunderberg added 4 commits September 29, 2021 10:34

Updated following @csullivan's comments.

054cd72

Added fuzzy mapping to the BufferShapeLegalize.

acf1c3a

Maintains earlier behavior of StorageFlatten, which allows buffer views to be mapped to higher dimension buffers, if the view extent is 1 in each extra dimension.

Updated BufferShapeLegalize, asserts need to be inside the buffer_bin…

0b06e98

…d_scope.

Lunderberg force-pushed the storage_flatten_refactor branch from 1e981de to 41b8eff Compare September 29, 2021 15:35

Lunderberg added 2 commits September 29, 2021 10:39

Minor cleanup

3d3ec42

- Removed StorageFlattener::BufferEntry::RelIndex, behavior already handled by BufferShapeLegalize. - Improved comments and error messages. - Extracted duplicate behavior in BufferLoad/BufferStore handling in BufferShapeLegalize.

Lunderberg force-pushed the storage_flatten_refactor branch from 41b8eff to 3d3ec42 Compare September 29, 2021 15:39

Lunderberg added 2 commits September 29, 2021 14:34

Updated to handle BufferRealizeNode with no defined bounds.

ddfc56f

Updated to be less aggressive when checking AssertStmt

ee2dc22

A true Assert statement can be removed, but a false Assert statement requires CFA to give as a compile-time error. Since we only need the removal of true assert statements, skipping the CFA this time.

csullivan approved these changes Sep 30, 2021

View reviewed changes

tmoreau89 approved these changes Oct 1, 2021

View reviewed changes

tmoreau89 merged commit 659f3b7 into apache:main Oct 1, 2021

Lunderberg deleted the storage_flatten_refactor branch October 1, 2021 01:00

ylc pushed a commit to ylc/tvm that referenced this pull request Jan 7, 2022

[UnitTest] Parametrized test_conv2d_int8_intrinsics (apache#9143)

164fa50

Parametrized it to get more detailed information while debugging failures in apache#9091, but isn't semantically part of that PR.

ylc pushed a commit to ylc/tvm that referenced this pull request Jan 13, 2022

[UnitTest] Parametrized test_conv2d_int8_intrinsics (apache#9143)

5b59563

Parametrized it to get more detailed information while debugging failures in apache#9091, but isn't semantically part of that PR.

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

[TIR] tir.transform.StorageFlatten refactor #9091

[TIR] tir.transform.StorageFlatten refactor #9091

Lunderberg commented Sep 23, 2021

Lunderberg commented Sep 23, 2021

tmoreau89 commented Sep 23, 2021

junrushao commented Sep 23, 2021

csullivan left a comment

csullivan Sep 24, 2021

Lunderberg Sep 24, 2021

csullivan Sep 24, 2021

Lunderberg Sep 24, 2021

csullivan Sep 24, 2021

Lunderberg Sep 24, 2021

csullivan left a comment

csullivan Sep 27, 2021

Lunderberg Sep 27, 2021

csullivan Sep 27, 2021

Lunderberg Sep 27, 2021

csullivan Sep 27, 2021

Lunderberg Sep 27, 2021

csullivan Sep 27, 2021

Lunderberg Sep 27, 2021

csullivan Sep 28, 2021

csullivan Sep 28, 2021

Lunderberg Sep 28, 2021

Lunderberg commented Sep 29, 2021

csullivan left a comment

tmoreau89 left a comment

tmoreau89 commented Oct 1, 2021

		ICHECK_EQ(op->buffer->shape.size(), op->bounds.size())
		<< "External buffer realize has mismatched dimension";

	// We do support a few relaxed case, such as bindingx
	// We do support a few relaxed case, such as binding a


		fptr->body = ThreadScopePropagate(fptr->buffer_map)(std::move(fptr->body));

		fptr->body = BufferBindUnwrapper(fptr->buffer_map, &bound_analyzer)(std::move(fptr->body));

[TIR] tir.transform.StorageFlatten refactor #9091

[TIR] tir.transform.StorageFlatten refactor #9091

Conversation

Lunderberg commented Sep 23, 2021

Lunderberg commented Sep 23, 2021

tmoreau89 commented Sep 23, 2021

junrushao commented Sep 23, 2021

csullivan left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

csullivan left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Lunderberg commented Sep 29, 2021

csullivan left a comment

Choose a reason for hiding this comment

tmoreau89 left a comment

Choose a reason for hiding this comment

tmoreau89 commented Oct 1, 2021