llvm
/
torch-mlir
mirror of https://github.com/llvm/torch-mlir
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
torch-mlir/test/E2E/lower-ranked-shapes.mlir

51 lines
1.8 KiB
MLIR
Raw Normal View History

Make LowerRankedShapes clean up shape.from_extents ops. We were previously relying on a later canonicalization pass to clean them up, but it is a cleaner invariant if the pass gets rid of them itself.
2020-05-30 08:49:25 +08:00
// RUN: npcomp-opt -lower-ranked-shapes <%s -split-input-file -verify-diagnostics | FileCheck %s --dump-input=fail
Lower !shape.shape to SSA values. This uses an approach inspired by what is done in IREE. See comments on LowerRankedShapes.cpp for how it works. The basic gist is that we have an op that creates a !shape.shape from a set of SSA values representing the extents, and then iteratively replace any op producing a !shape.shape with instances of that op.
2020-05-12 12:22:40 +08:00
// CHECK-LABEL: func @broadcast_rank2_rank1
Lower to the upstream memref ABI. Specifically, we use unranked memrefs which get passed as a fixed-size set of arguments/returns. One big caveat about this is that returning results isn't going to work. See TODO in LowerTensorLoadOp. This is far from enough runtime-wise, but it starts to demarcate a plausible layering. Notice for example how this removes the runtime-dependence from LowerRankedShapes. Eventually, we want to have an `npcomp_rt` or `npcomp_hal` dialect with its own set of runtime types that will supercede this. See comments in LowerTensorLoadOp for more direction about where this is going to evolve.
2020-05-16 07:33:01 +08:00
func @broadcast_rank2_rank1(%arg0: index, %arg1: index, %arg2: index) -> (index, index) {
Lower !shape.shape to SSA values. This uses an approach inspired by what is done in IREE. See comments on LowerRankedShapes.cpp for how it works. The basic gist is that we have an op that creates a !shape.shape from a set of SSA values representing the extents, and then iteratively replace any op producing a !shape.shape with instances of that op.
2020-05-12 12:22:40 +08:00
// CHECK-NOT: shape.broadcast
// CHECK-NOT: tcp.get_extent
Make LowerRankedShapes clean up shape.from_extents ops. We were previously relying on a later canonicalization pass to clean them up, but it is a cleaner invariant if the pass gets rid of them itself.
2020-05-30 08:49:25 +08:00
// CHECK-NOT: shape.from_extents
Use upstream shape.from_extents Replace our local `tcp.shape_from_extents` op with the upstream `shape.from_extents` op.
2020-05-22 05:51:01 +08:00
%0 = shape.from_extents %arg0, %arg1
Rework reference shape lowering based on upstream shape dialect changes. * Primarily, the upstream shape dialect now uses tensor<?xindex> for non-erroring, immediate shape calculations (and will return this for shape_of of a tensor or memref). * In addition, upstream passes do not yet exist for fully lowering to standard ops, so the passes here need to be extended to handle this new convention. * This should be seen as an intermediate state, necessary to integrate a new LLVM version and needs more work and cleanup for generality. * There is a good deal of awkwardness in these conversions. The hope is that additional upstream work will yield better defined conversion paths once out of this intermediate state.
2020-08-03 13:06:12 +08:00
%1 = shape.to_extent_tensor %0 : !shape.shape -> tensor<?xindex>
%2 = shape.from_extents %arg2
%3 = shape.to_extent_tensor %2 : !shape.shape -> tensor<?xindex>
%4 = "shape.broadcast"(%1, %3) : (tensor<?xindex>, tensor<?xindex>) -> !shape.shape
%5 = shape.to_extent_tensor %4 : !shape.shape -> tensor<?xindex>
%c0 = constant 0 : index
%c1 = constant 1 : index
%e0 = shape.get_extent %5, %c0 : tensor<?xindex>, index -> index
%e1 = shape.get_extent %5, %c1 : tensor<?xindex>, index -> index
Lower !shape.shape to SSA values. This uses an approach inspired by what is done in IREE. See comments on LowerRankedShapes.cpp for how it works. The basic gist is that we have an op that creates a !shape.shape from a set of SSA values representing the extents, and then iteratively replace any op producing a !shape.shape with instances of that op.
2020-05-12 12:22:40 +08:00
return %e0, %e1 : index, index
}
Rename tcp.abort_if to tcp.shape_observe_error This more clearly captures its semantics as a structural "observer" of code that we currently mark as NoSideEffect but eventually lowers to eager error handling code. Also, update LowerRankedShapes to erase it, now that the layering here is clear. That pass reifies the eager error handling code, so the need for the dummy op to keep things alive isn't needed. With this change, we are now ready to start lowering to LLVM! This is the current print-ir-after-all from e2e-lowering-pipeline: https://reviews.llvm.org/P8221
2020-05-19 04:35:25 +08:00
Rework reference shape lowering based on upstream shape dialect changes. * Primarily, the upstream shape dialect now uses tensor<?xindex> for non-erroring, immediate shape calculations (and will return this for shape_of of a tensor or memref). * In addition, upstream passes do not yet exist for fully lowering to standard ops, so the passes here need to be extended to handle this new convention. * This should be seen as an intermediate state, necessary to integrate a new LLVM version and needs more work and cleanup for generality. * There is a good deal of awkwardness in these conversions. The hope is that additional upstream work will yield better defined conversion paths once out of this intermediate state.
2020-08-03 13:06:12 +08:00
// -----
Rework e2e flow to use new "npcomprt" This ~totally reworks the existing "runtime" stuff to be more principled and usable, such as from Python. It's still not fully production-quality, mainly in the department of memory management (e.g. it currently leaks memory; we need to figure out "who frees memrefs" + the analysis and transformation needed to do that (maybe use upstream buffer allocation pass?)). The user API is in include/npcomp/runtime/UserAPI.h, though include/npcomp/JITRuntime/JITModule.h is a friendlier wrapper. The stuff under {include,lib}/runtime is totally firewalled from the compiler and tiny (<6kB, though no attention has gone into optimizing that size). For example, we don't link in libSupport into the runtime, instead having our own bare bones replacements for basics like ArrayRef (the JITRuntime helps with bridging that gap, since it *can* depend on all common LLVM utilities). The overall features of npcomprt is that it exposes a module that with multiple function entry points. Each function has arguments and results that are tensor-valued, and npcomprt::Tensor is the runtime type that is used to interact with that (and a npcomprt::Ref<T> reference-counting wrapper is provided to wrap npcomprt::Tensor in the common case). From an implementation perspective, an npcomprt module at the LLVM/object/binary level exposes a single module descriptor struct that has pointers to other metadata (currently just a list of function metadata descriptors). All interactions with the npcomp runtime are keyed off of that module descriptor, including function lookups and dispatching. This is done to dodge platform ABI issues and also allow enough reflection to e.g. verify provided arguments. Most of the compiler-side work here was in LowerToNpcomprtABI and LowerToLLVM. Also, - Rename npcomp_rt/NpcompRt to npcomprt/Npcomprt; it was getting annoying to type the underscores/caps. - misc improvements to bash_helpers.sh
2020-07-09 08:15:40 +08:00
// CHECK-LABEL: func @erase_stray_shape_ops
func @erase_stray_shape_ops(%arg0: index) {
Make LowerRankedShapes clean up shape.from_extents ops. We were previously relying on a later canonicalization pass to clean them up, but it is a cleaner invariant if the pass gets rid of them itself.
2020-05-30 08:49:25 +08:00
// CHECK-NOT: tcp.shape_observe_error
// CHECK-NOT: shape.from_extents
Use upstream shape.from_extents Replace our local `tcp.shape_from_extents` op with the upstream `shape.from_extents` op.
2020-05-22 05:51:01 +08:00
%0 = shape.from_extents %arg0
Rename tcp.abort_if to tcp.shape_observe_error This more clearly captures its semantics as a structural "observer" of code that we currently mark as NoSideEffect but eventually lowers to eager error handling code. Also, update LowerRankedShapes to erase it, now that the layering here is clear. That pass reifies the eager error handling code, so the need for the dummy op to keep things alive isn't needed. With this change, we are now ready to start lowering to LLVM! This is the current print-ir-after-all from e2e-lowering-pipeline: https://reviews.llvm.org/P8221
2020-05-19 04:35:25 +08:00
"tcp.shape_observe_error"(%0) : (!shape.shape) -> none
return
}
Make LowerRankedShapes clean up shape.from_extents ops. We were previously relying on a later canonicalization pass to clean them up, but it is a cleaner invariant if the pass gets rid of them itself.
2020-05-30 08:49:25 +08:00
// -----
Rework e2e flow to use new "npcomprt" This ~totally reworks the existing "runtime" stuff to be more principled and usable, such as from Python. It's still not fully production-quality, mainly in the department of memory management (e.g. it currently leaks memory; we need to figure out "who frees memrefs" + the analysis and transformation needed to do that (maybe use upstream buffer allocation pass?)). The user API is in include/npcomp/runtime/UserAPI.h, though include/npcomp/JITRuntime/JITModule.h is a friendlier wrapper. The stuff under {include,lib}/runtime is totally firewalled from the compiler and tiny (<6kB, though no attention has gone into optimizing that size). For example, we don't link in libSupport into the runtime, instead having our own bare bones replacements for basics like ArrayRef (the JITRuntime helps with bridging that gap, since it *can* depend on all common LLVM utilities). The overall features of npcomprt is that it exposes a module that with multiple function entry points. Each function has arguments and results that are tensor-valued, and npcomprt::Tensor is the runtime type that is used to interact with that (and a npcomprt::Ref<T> reference-counting wrapper is provided to wrap npcomprt::Tensor in the common case). From an implementation perspective, an npcomprt module at the LLVM/object/binary level exposes a single module descriptor struct that has pointers to other metadata (currently just a list of function metadata descriptors). All interactions with the npcomp runtime are keyed off of that module descriptor, including function lookups and dispatching. This is done to dodge platform ABI issues and also allow enough reflection to e.g. verify provided arguments. Most of the compiler-side work here was in LowerToNpcomprtABI and LowerToLLVM. Also, - Rename npcomp_rt/NpcompRt to npcomprt/Npcomprt; it was getting annoying to type the underscores/caps. - misc improvements to bash_helpers.sh
2020-07-09 08:15:40 +08:00
func @cannot_erase_stray_shape_ops() -> !shape.shape {
Make LowerRankedShapes clean up shape.from_extents ops. We were previously relying on a later canonicalization pass to clean them up, but it is a cleaner invariant if the pass gets rid of them itself.
2020-05-30 08:49:25 +08:00
// expected-error @+1 {{could not be eliminated}}
%0 = shape.from_extents
return %0 : !shape.shape
}
LowerRankedShapes: support shape.const_shape op. Also, the previous code had a special case for deleting this op when it had no uses. This is subsumed by the change in this commit since now shape.const_shape is properly lowered. With this change, the included test case with multiple serially dependent ops works! This specific issue was related to the scalar argument to that function. We needed to compute a broadcast of a scalar shape (which is a shape.const_shape) with another shape.
2020-07-09 11:10:01 +08:00
// -----
Rework reference shape lowering based on upstream shape dialect changes. * Primarily, the upstream shape dialect now uses tensor<?xindex> for non-erroring, immediate shape calculations (and will return this for shape_of of a tensor or memref). * In addition, upstream passes do not yet exist for fully lowering to standard ops, so the passes here need to be extended to handle this new convention. * This should be seen as an intermediate state, necessary to integrate a new LLVM version and needs more work and cleanup for generality. * There is a good deal of awkwardness in these conversions. The hope is that additional upstream work will yield better defined conversion paths once out of this intermediate state.
2020-08-03 13:06:12 +08:00
// TODO: Remove this as it is now just testing shape and std ops.
LowerRankedShapes: support shape.const_shape op. Also, the previous code had a special case for deleting this op when it had no uses. This is subsumed by the change in this commit since now shape.const_shape is properly lowered. With this change, the included test case with multiple serially dependent ops works! This specific issue was related to the scalar argument to that function. We needed to compute a broadcast of a scalar shape (which is a shape.const_shape) with another shape.
2020-07-09 11:10:01 +08:00
// CHECK-LABEL: func @const_shape
func @const_shape() -> index {
// CHECK-NOT: shape.const_shape
Rework reference shape lowering based on upstream shape dialect changes. * Primarily, the upstream shape dialect now uses tensor<?xindex> for non-erroring, immediate shape calculations (and will return this for shape_of of a tensor or memref). * In addition, upstream passes do not yet exist for fully lowering to standard ops, so the passes here need to be extended to handle this new convention. * This should be seen as an intermediate state, necessary to integrate a new LLVM version and needs more work and cleanup for generality. * There is a good deal of awkwardness in these conversions. The hope is that additional upstream work will yield better defined conversion paths once out of this intermediate state.
2020-08-03 13:06:12 +08:00
%0 = shape.const_shape [] : tensor<?xindex>
%1 = shape.const_shape [7] : tensor<?xindex>
%2 = constant 0 : index
%3 = shape.get_extent %1, %2 : tensor<?xindex>, index -> index
LowerRankedShapes: support shape.const_shape op. Also, the previous code had a special case for deleting this op when it had no uses. This is subsumed by the change in this commit since now shape.const_shape is properly lowered. With this change, the included test case with multiple serially dependent ops works! This specific issue was related to the scalar argument to that function. We needed to compute a broadcast of a scalar shape (which is a shape.const_shape) with another shape.
2020-07-09 11:10:01 +08:00
// CHECK: %[[C7:.*]] = constant 7 : index
// CHECK: return %[[C7]]
Rework reference shape lowering based on upstream shape dialect changes. * Primarily, the upstream shape dialect now uses tensor<?xindex> for non-erroring, immediate shape calculations (and will return this for shape_of of a tensor or memref). * In addition, upstream passes do not yet exist for fully lowering to standard ops, so the passes here need to be extended to handle this new convention. * This should be seen as an intermediate state, necessary to integrate a new LLVM version and needs more work and cleanup for generality. * There is a good deal of awkwardness in these conversions. The hope is that additional upstream work will yield better defined conversion paths once out of this intermediate state.
2020-08-03 13:06:12 +08:00
return %3 : index
LowerRankedShapes: support shape.const_shape op. Also, the previous code had a special case for deleting this op when it had no uses. This is subsumed by the change in this commit since now shape.const_shape is properly lowered. With this change, the included test case with multiple serially dependent ops works! This specific issue was related to the scalar argument to that function. We needed to compute a broadcast of a scalar shape (which is a shape.const_shape) with another shape.
2020-07-09 11:10:01 +08:00
}