maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/mlir/test/mlir-cpu-runner/async.mlir

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

92 lines
3.5 KiB
MLIR
Raw Normal View History

[mlir] Async: add automatic reference counting at async.runtime operations level Depends On D95311 Previous automatic-ref-counting pass worked with high level async operations (e.g. async.execute), however async values reference counting is a runtime implementation detail. New pass mostly relies on the save liveness analysis to place drop_ref operations, and does better verification of CFG with different liveIn sets in block successors. This is almost NFC change. No new reference counting ideas, just a cleanup of the previous version. Reviewed By: mehdi_amini Differential Revision: https://reviews.llvm.org/D95390
2021-04-13 01:48:02 +08:00
// RUN: mlir-opt %s -async-to-async-runtime \
// RUN: -async-runtime-ref-counting \
// RUN: -async-runtime-ref-counting-opt \
[mlir] Async: re-enable tests after fixing fkakines Test flakiness was fixed by: https://github.com/llvm/llvm-project/commit/9edcedf7f222ce7c893d1e3bf19b3a7a1f0f2218 Runs these tests to verify that all parts of the lowering work correctly. Reviewed By: mehdi_amini Differential Revision: https://reviews.llvm.org/D93384
2020-12-16 18:17:53 +08:00
// RUN: -convert-async-to-llvm \
// RUN: -convert-linalg-to-loops \
[mlir] Turn Linalg to LLVM into a partial conversion Historically, Linalg To LLVM conversion subsumed numerous other conversions, including (affine) loop lowerings to CFG and conversions from the Standard and Vector dialects to the LLVM dialect. This was due to the insufficient support for partial conversions in the infrastructure that essentially required conversions that involve type change (in this case, !linalg.range to !llvm.struct) to be performed in a single conversion sweep. This is no longer the case so remove the subsumed conversions and run them as separate passes when necessary. Depends On D95317 Reviewed By: nicolasvasilache Differential Revision: https://reviews.llvm.org/D96008
2021-02-04 18:53:10 +08:00
// RUN: -convert-scf-to-std \
[mlir] Async: re-enable tests after fixing fkakines Test flakiness was fixed by: https://github.com/llvm/llvm-project/commit/9edcedf7f222ce7c893d1e3bf19b3a7a1f0f2218 Runs these tests to verify that all parts of the lowering work correctly. Reviewed By: mehdi_amini Differential Revision: https://reviews.llvm.org/D93384
2020-12-16 18:17:53 +08:00
// RUN: -convert-linalg-to-llvm \
[mlir] factor memref-to-llvm lowering out of std-to-llvm After the MemRef has been split out of the Standard dialect, the conversion to the LLVM dialect remained as a huge monolithic pass. This is undesirable for the same complexity management reasons as having a huge Standard dialect itself, and is even more confusing given the existence of a separate dialect. Extract the conversion of the MemRef dialect operations to LLVM into a separate library and a separate conversion pass. Reviewed By: herhut, silvas Differential Revision: https://reviews.llvm.org/D105625
2021-07-09 00:35:18 +08:00
// RUN: -convert-memref-to-llvm \
[MLIR] Replace std ops with arith dialect ops Precursor: https://reviews.llvm.org/D110200 Removed redundant ops from the standard dialect that were moved to the `arith` or `math` dialects. Renamed all instances of operations in the codebase and in tests. Reviewed By: rriddle, jpienaar Differential Revision: https://reviews.llvm.org/D110797
2021-10-13 07:14:57 +08:00
// RUN: -convert-arith-to-llvm \
[mlir] Async: re-enable tests after fixing fkakines Test flakiness was fixed by: https://github.com/llvm/llvm-project/commit/9edcedf7f222ce7c893d1e3bf19b3a7a1f0f2218 Runs these tests to verify that all parts of the lowering work correctly. Reviewed By: mehdi_amini Differential Revision: https://reviews.llvm.org/D93384
2020-12-16 18:17:53 +08:00
// RUN: -convert-std-to-llvm \
[mlir] Factor type reconciliation out of Standard-to-LLVM conversion Conversion to the LLVM dialect is being refactored to be more progressive and is now performed as a series of independent passes converting different dialects. These passes may produce `unrealized_conversion_cast` operations that represent pending conversions between built-in and LLVM dialect types. Historically, a more monolithic Standard-to-LLVM conversion pass did not need these casts as all operations were converted in one shot. Previous refactorings have led to the requirement of running the Standard-to-LLVM conversion pass to clean up `unrealized_conversion_cast`s even though the IR had no standard operations in it. The pass must have been also run the last among all to-LLVM passes, in contradiction with the partial conversion logic. Additionally, the way it was set up could produce invalid operations by removing casts between LLVM and built-in types even when the consumer did not accept the uncasted type, or could lead to cryptic conversion errors (recursive application of the rewrite pattern on `unrealized_conversion_cast` as a means to indicate failure to eliminate casts). In fact, the need to eliminate A->B->A `unrealized_conversion_cast`s is not specific to to-LLVM conversions and can be factored out into a separate type reconciliation pass, which is achieved in this commit. While the cast operation itself has a folder pattern, it is insufficient in most conversion passes as the folder only applies to the second cast. Without complex legality setup in the conversion target, the conversion infra will either consider the cast operations valid and not fold them (a separate canonicalization would be necessary to trigger the folding), or consider the first cast invalid upon generation and stop with error. The pattern provided by the reconciliation pass applies to the first cast operation instead. Furthermore, having a separate pass makes it clear when `unrealized_conversion_cast`s could not have been eliminated since it is the only reason why this pass can fail. Reviewed By: nicolasvasilache Differential Revision: https://reviews.llvm.org/D109507
2021-09-09 22:06:10 +08:00
// RUN: -reconcile-unrealized-casts \
[mlir] Async: re-enable tests after fixing fkakines Test flakiness was fixed by: https://github.com/llvm/llvm-project/commit/9edcedf7f222ce7c893d1e3bf19b3a7a1f0f2218 Runs these tests to verify that all parts of the lowering work correctly. Reviewed By: mehdi_amini Differential Revision: https://reviews.llvm.org/D93384
2020-12-16 18:17:53 +08:00
// RUN: | mlir-cpu-runner \
// RUN: -e main -entry-point-result=void -O0 \
// RUN: -shared-libs=%linalg_test_lib_dir/libmlir_c_runner_utils%shlibext \
// RUN: -shared-libs=%linalg_test_lib_dir/libmlir_runner_utils%shlibext \
// RUN: -shared-libs=%linalg_test_lib_dir/libmlir_async_runtime%shlibext \
// RUN: | FileCheck %s
Revert "Revert "[mlir] Convert from Async dialect to LLVM coroutines"" This reverts commit 4986d5eaff359081a867def1c6a2e1147dbb2ad6 with proper patches to CMakeLists.txt: - Add MLIRAsync as a dependency to MLIRAsyncToLLVM - Add Coroutines as a dependency to MLIRExecutionEngine
2020-10-23 03:20:42 +08:00
func @main() {
[MLIR] Replace std ops with arith dialect ops Precursor: https://reviews.llvm.org/D110200 Removed redundant ops from the standard dialect that were moved to the `arith` or `math` dialects. Renamed all instances of operations in the codebase and in tests. Reviewed By: rriddle, jpienaar Differential Revision: https://reviews.llvm.org/D110797
2021-10-13 07:14:57 +08:00
%i0 = arith.constant 0 : index
%i1 = arith.constant 1 : index
%i2 = arith.constant 2 : index
%i3 = arith.constant 3 : index
Revert "Revert "[mlir] Convert from Async dialect to LLVM coroutines"" This reverts commit 4986d5eaff359081a867def1c6a2e1147dbb2ad6 with proper patches to CMakeLists.txt: - Add MLIRAsync as a dependency to MLIRAsyncToLLVM - Add Coroutines as a dependency to MLIRExecutionEngine
2020-10-23 03:20:42 +08:00
[MLIR] Replace std ops with arith dialect ops Precursor: https://reviews.llvm.org/D110200 Removed redundant ops from the standard dialect that were moved to the `arith` or `math` dialects. Renamed all instances of operations in the codebase and in tests. Reviewed By: rriddle, jpienaar Differential Revision: https://reviews.llvm.org/D110797
2021-10-13 07:14:57 +08:00
%c0 = arith.constant 0.0 : f32
%c1 = arith.constant 1.0 : f32
%c2 = arith.constant 2.0 : f32
%c3 = arith.constant 3.0 : f32
%c4 = arith.constant 4.0 : f32
Revert "Revert "[mlir] Convert from Async dialect to LLVM coroutines"" This reverts commit 4986d5eaff359081a867def1c6a2e1147dbb2ad6 with proper patches to CMakeLists.txt: - Add MLIRAsync as a dependency to MLIRAsyncToLLVM - Add Coroutines as a dependency to MLIRExecutionEngine
2020-10-23 03:20:42 +08:00
[MLIR] Create memref dialect and move dialect-specific ops from std. Create the memref dialect and move dialect-specific ops from std dialect to this dialect. Moved ops: AllocOp -> MemRef_AllocOp AllocaOp -> MemRef_AllocaOp AssumeAlignmentOp -> MemRef_AssumeAlignmentOp DeallocOp -> MemRef_DeallocOp DimOp -> MemRef_DimOp MemRefCastOp -> MemRef_CastOp MemRefReinterpretCastOp -> MemRef_ReinterpretCastOp GetGlobalMemRefOp -> MemRef_GetGlobalOp GlobalMemRefOp -> MemRef_GlobalOp LoadOp -> MemRef_LoadOp PrefetchOp -> MemRef_PrefetchOp ReshapeOp -> MemRef_ReshapeOp StoreOp -> MemRef_StoreOp SubViewOp -> MemRef_SubViewOp TransposeOp -> MemRef_TransposeOp TensorLoadOp -> MemRef_TensorLoadOp TensorStoreOp -> MemRef_TensorStoreOp TensorToMemRefOp -> MemRef_BufferCastOp ViewOp -> MemRef_ViewOp The roadmap to split the memref dialect from std is discussed here: https://llvm.discourse.group/t/rfc-split-the-memref-dialect-from-std/2667 Differential Revision: https://reviews.llvm.org/D98041
2021-02-10 20:53:11 +08:00
%A = memref.alloc() : memref<4xf32>
[mlir][linalg] Change the pretty printed FillOp operand order. The patch changes the pretty printed FillOp operand order from output, value to value, output. The change is a follow up to https://reviews.llvm.org/D104121 that passes the fill value using a scalar input instead of the former capture semantics. Differential Revision: https://reviews.llvm.org/D104356
2021-06-23 14:28:58 +08:00
linalg.fill(%c0, %A) : f32, memref<4xf32>
Revert "Revert "[mlir] Convert from Async dialect to LLVM coroutines"" This reverts commit 4986d5eaff359081a867def1c6a2e1147dbb2ad6 with proper patches to CMakeLists.txt: - Add MLIRAsync as a dependency to MLIRAsyncToLLVM - Add Coroutines as a dependency to MLIRExecutionEngine
2020-10-23 03:20:42 +08:00
// CHECK: [0, 0, 0, 0]
[MLIR] Create memref dialect and move dialect-specific ops from std. Create the memref dialect and move dialect-specific ops from std dialect to this dialect. Moved ops: AllocOp -> MemRef_AllocOp AllocaOp -> MemRef_AllocaOp AssumeAlignmentOp -> MemRef_AssumeAlignmentOp DeallocOp -> MemRef_DeallocOp DimOp -> MemRef_DimOp MemRefCastOp -> MemRef_CastOp MemRefReinterpretCastOp -> MemRef_ReinterpretCastOp GetGlobalMemRefOp -> MemRef_GetGlobalOp GlobalMemRefOp -> MemRef_GlobalOp LoadOp -> MemRef_LoadOp PrefetchOp -> MemRef_PrefetchOp ReshapeOp -> MemRef_ReshapeOp StoreOp -> MemRef_StoreOp SubViewOp -> MemRef_SubViewOp TransposeOp -> MemRef_TransposeOp TensorLoadOp -> MemRef_TensorLoadOp TensorStoreOp -> MemRef_TensorStoreOp TensorToMemRefOp -> MemRef_BufferCastOp ViewOp -> MemRef_ViewOp The roadmap to split the memref dialect from std is discussed here: https://llvm.discourse.group/t/rfc-split-the-memref-dialect-from-std/2667 Differential Revision: https://reviews.llvm.org/D98041
2021-02-10 20:53:11 +08:00
%U = memref.cast %A : memref<4xf32> to memref<*xf32>
Revert "Revert "[mlir] Convert from Async dialect to LLVM coroutines"" This reverts commit 4986d5eaff359081a867def1c6a2e1147dbb2ad6 with proper patches to CMakeLists.txt: - Add MLIRAsync as a dependency to MLIRAsyncToLLVM - Add Coroutines as a dependency to MLIRExecutionEngine
2020-10-23 03:20:42 +08:00
call @print_memref_f32(%U): (memref<*xf32>) -> ()
// CHECK: Current thread id: [[MAIN:.*]]
// CHECK: [1, 0, 0, 0]
[MLIR] Create memref dialect and move dialect-specific ops from std. Create the memref dialect and move dialect-specific ops from std dialect to this dialect. Moved ops: AllocOp -> MemRef_AllocOp AllocaOp -> MemRef_AllocaOp AssumeAlignmentOp -> MemRef_AssumeAlignmentOp DeallocOp -> MemRef_DeallocOp DimOp -> MemRef_DimOp MemRefCastOp -> MemRef_CastOp MemRefReinterpretCastOp -> MemRef_ReinterpretCastOp GetGlobalMemRefOp -> MemRef_GetGlobalOp GlobalMemRefOp -> MemRef_GlobalOp LoadOp -> MemRef_LoadOp PrefetchOp -> MemRef_PrefetchOp ReshapeOp -> MemRef_ReshapeOp StoreOp -> MemRef_StoreOp SubViewOp -> MemRef_SubViewOp TransposeOp -> MemRef_TransposeOp TensorLoadOp -> MemRef_TensorLoadOp TensorStoreOp -> MemRef_TensorStoreOp TensorToMemRefOp -> MemRef_BufferCastOp ViewOp -> MemRef_ViewOp The roadmap to split the memref dialect from std is discussed here: https://llvm.discourse.group/t/rfc-split-the-memref-dialect-from-std/2667 Differential Revision: https://reviews.llvm.org/D98041
2021-02-10 20:53:11 +08:00
memref.store %c1, %A[%i0]: memref<4xf32>
Revert "Revert "[mlir] Convert from Async dialect to LLVM coroutines"" This reverts commit 4986d5eaff359081a867def1c6a2e1147dbb2ad6 with proper patches to CMakeLists.txt: - Add MLIRAsync as a dependency to MLIRAsyncToLLVM - Add Coroutines as a dependency to MLIRExecutionEngine
2020-10-23 03:20:42 +08:00
call @mlirAsyncRuntimePrintCurrentThreadId(): () -> ()
call @print_memref_f32(%U): (memref<*xf32>) -> ()
%outer = async.execute {
// CHECK: Current thread id: [[THREAD0:.*]]
// CHECK: [1, 2, 0, 0]
[MLIR] Create memref dialect and move dialect-specific ops from std. Create the memref dialect and move dialect-specific ops from std dialect to this dialect. Moved ops: AllocOp -> MemRef_AllocOp AllocaOp -> MemRef_AllocaOp AssumeAlignmentOp -> MemRef_AssumeAlignmentOp DeallocOp -> MemRef_DeallocOp DimOp -> MemRef_DimOp MemRefCastOp -> MemRef_CastOp MemRefReinterpretCastOp -> MemRef_ReinterpretCastOp GetGlobalMemRefOp -> MemRef_GetGlobalOp GlobalMemRefOp -> MemRef_GlobalOp LoadOp -> MemRef_LoadOp PrefetchOp -> MemRef_PrefetchOp ReshapeOp -> MemRef_ReshapeOp StoreOp -> MemRef_StoreOp SubViewOp -> MemRef_SubViewOp TransposeOp -> MemRef_TransposeOp TensorLoadOp -> MemRef_TensorLoadOp TensorStoreOp -> MemRef_TensorStoreOp TensorToMemRefOp -> MemRef_BufferCastOp ViewOp -> MemRef_ViewOp The roadmap to split the memref dialect from std is discussed here: https://llvm.discourse.group/t/rfc-split-the-memref-dialect-from-std/2667 Differential Revision: https://reviews.llvm.org/D98041
2021-02-10 20:53:11 +08:00
memref.store %c2, %A[%i1]: memref<4xf32>
Revert "Revert "[mlir] Convert from Async dialect to LLVM coroutines"" This reverts commit 4986d5eaff359081a867def1c6a2e1147dbb2ad6 with proper patches to CMakeLists.txt: - Add MLIRAsync as a dependency to MLIRAsyncToLLVM - Add Coroutines as a dependency to MLIRExecutionEngine
2020-10-23 03:20:42 +08:00
call @mlirAsyncRuntimePrintCurrentThreadId(): () -> ()
call @print_memref_f32(%U): (memref<*xf32>) -> ()
[mlir] Implement lowering to LLVM of async.execute ops with token dependencies Add support for lowering `async.execute` operations with token dependencies Example: ``` %dep = ... : !async.token %token = async.execute[%dep] { ... } ``` Token dependencies lowered to `async.await` operations inside the outline coroutine body. Reviewed By: herhut, mehdi_amini, ftynse Differential Revision: https://reviews.llvm.org/D89958
2020-10-30 20:19:42 +08:00
// No op async region to create a token for testing async dependency.
%noop = async.execute {
Revert "Revert "[mlir] Convert from Async dialect to LLVM coroutines"" This reverts commit 4986d5eaff359081a867def1c6a2e1147dbb2ad6 with proper patches to CMakeLists.txt: - Add MLIRAsync as a dependency to MLIRAsyncToLLVM - Add Coroutines as a dependency to MLIRExecutionEngine
2020-10-23 03:20:42 +08:00
// CHECK: Current thread id: [[THREAD1:.*]]
[mlir] Implement lowering to LLVM of async.execute ops with token dependencies Add support for lowering `async.execute` operations with token dependencies Example: ``` %dep = ... : !async.token %token = async.execute[%dep] { ... } ``` Token dependencies lowered to `async.await` operations inside the outline coroutine body. Reviewed By: herhut, mehdi_amini, ftynse Differential Revision: https://reviews.llvm.org/D89958
2020-10-30 20:19:42 +08:00
call @mlirAsyncRuntimePrintCurrentThreadId(): () -> ()
async.yield
}
%inner = async.execute [%noop] {
// CHECK: Current thread id: [[THREAD2:.*]]
Revert "Revert "[mlir] Convert from Async dialect to LLVM coroutines"" This reverts commit 4986d5eaff359081a867def1c6a2e1147dbb2ad6 with proper patches to CMakeLists.txt: - Add MLIRAsync as a dependency to MLIRAsyncToLLVM - Add Coroutines as a dependency to MLIRExecutionEngine
2020-10-23 03:20:42 +08:00
// CHECK: [1, 2, 3, 0]
[MLIR] Create memref dialect and move dialect-specific ops from std. Create the memref dialect and move dialect-specific ops from std dialect to this dialect. Moved ops: AllocOp -> MemRef_AllocOp AllocaOp -> MemRef_AllocaOp AssumeAlignmentOp -> MemRef_AssumeAlignmentOp DeallocOp -> MemRef_DeallocOp DimOp -> MemRef_DimOp MemRefCastOp -> MemRef_CastOp MemRefReinterpretCastOp -> MemRef_ReinterpretCastOp GetGlobalMemRefOp -> MemRef_GetGlobalOp GlobalMemRefOp -> MemRef_GlobalOp LoadOp -> MemRef_LoadOp PrefetchOp -> MemRef_PrefetchOp ReshapeOp -> MemRef_ReshapeOp StoreOp -> MemRef_StoreOp SubViewOp -> MemRef_SubViewOp TransposeOp -> MemRef_TransposeOp TensorLoadOp -> MemRef_TensorLoadOp TensorStoreOp -> MemRef_TensorStoreOp TensorToMemRefOp -> MemRef_BufferCastOp ViewOp -> MemRef_ViewOp The roadmap to split the memref dialect from std is discussed here: https://llvm.discourse.group/t/rfc-split-the-memref-dialect-from-std/2667 Differential Revision: https://reviews.llvm.org/D98041
2021-02-10 20:53:11 +08:00
memref.store %c3, %A[%i2]: memref<4xf32>
Revert "Revert "[mlir] Convert from Async dialect to LLVM coroutines"" This reverts commit 4986d5eaff359081a867def1c6a2e1147dbb2ad6 with proper patches to CMakeLists.txt: - Add MLIRAsync as a dependency to MLIRAsyncToLLVM - Add Coroutines as a dependency to MLIRExecutionEngine
2020-10-23 03:20:42 +08:00
call @mlirAsyncRuntimePrintCurrentThreadId(): () -> ()
call @print_memref_f32(%U): (memref<*xf32>) -> ()
async.yield
}
async.await %inner : !async.token
[mlir] Implement lowering to LLVM of async.execute ops with token dependencies Add support for lowering `async.execute` operations with token dependencies Example: ``` %dep = ... : !async.token %token = async.execute[%dep] { ... } ``` Token dependencies lowered to `async.await` operations inside the outline coroutine body. Reviewed By: herhut, mehdi_amini, ftynse Differential Revision: https://reviews.llvm.org/D89958
2020-10-30 20:19:42 +08:00
// CHECK: Current thread id: [[THREAD3:.*]]
Revert "Revert "[mlir] Convert from Async dialect to LLVM coroutines"" This reverts commit 4986d5eaff359081a867def1c6a2e1147dbb2ad6 with proper patches to CMakeLists.txt: - Add MLIRAsync as a dependency to MLIRAsyncToLLVM - Add Coroutines as a dependency to MLIRExecutionEngine
2020-10-23 03:20:42 +08:00
// CHECK: [1, 2, 3, 4]
[MLIR] Create memref dialect and move dialect-specific ops from std. Create the memref dialect and move dialect-specific ops from std dialect to this dialect. Moved ops: AllocOp -> MemRef_AllocOp AllocaOp -> MemRef_AllocaOp AssumeAlignmentOp -> MemRef_AssumeAlignmentOp DeallocOp -> MemRef_DeallocOp DimOp -> MemRef_DimOp MemRefCastOp -> MemRef_CastOp MemRefReinterpretCastOp -> MemRef_ReinterpretCastOp GetGlobalMemRefOp -> MemRef_GetGlobalOp GlobalMemRefOp -> MemRef_GlobalOp LoadOp -> MemRef_LoadOp PrefetchOp -> MemRef_PrefetchOp ReshapeOp -> MemRef_ReshapeOp StoreOp -> MemRef_StoreOp SubViewOp -> MemRef_SubViewOp TransposeOp -> MemRef_TransposeOp TensorLoadOp -> MemRef_TensorLoadOp TensorStoreOp -> MemRef_TensorStoreOp TensorToMemRefOp -> MemRef_BufferCastOp ViewOp -> MemRef_ViewOp The roadmap to split the memref dialect from std is discussed here: https://llvm.discourse.group/t/rfc-split-the-memref-dialect-from-std/2667 Differential Revision: https://reviews.llvm.org/D98041
2021-02-10 20:53:11 +08:00
memref.store %c4, %A[%i3]: memref<4xf32>
Revert "Revert "[mlir] Convert from Async dialect to LLVM coroutines"" This reverts commit 4986d5eaff359081a867def1c6a2e1147dbb2ad6 with proper patches to CMakeLists.txt: - Add MLIRAsync as a dependency to MLIRAsyncToLLVM - Add Coroutines as a dependency to MLIRExecutionEngine
2020-10-23 03:20:42 +08:00
call @mlirAsyncRuntimePrintCurrentThreadId(): () -> ()
call @print_memref_f32(%U): (memref<*xf32>) -> ()
async.yield
}
async.await %outer : !async.token
// CHECK: Current thread id: [[MAIN]]
// CHECK: [1, 2, 3, 4]
call @mlirAsyncRuntimePrintCurrentThreadId(): () -> ()
call @print_memref_f32(%U): (memref<*xf32>) -> ()
[MLIR] Create memref dialect and move dialect-specific ops from std. Create the memref dialect and move dialect-specific ops from std dialect to this dialect. Moved ops: AllocOp -> MemRef_AllocOp AllocaOp -> MemRef_AllocaOp AssumeAlignmentOp -> MemRef_AssumeAlignmentOp DeallocOp -> MemRef_DeallocOp DimOp -> MemRef_DimOp MemRefCastOp -> MemRef_CastOp MemRefReinterpretCastOp -> MemRef_ReinterpretCastOp GetGlobalMemRefOp -> MemRef_GetGlobalOp GlobalMemRefOp -> MemRef_GlobalOp LoadOp -> MemRef_LoadOp PrefetchOp -> MemRef_PrefetchOp ReshapeOp -> MemRef_ReshapeOp StoreOp -> MemRef_StoreOp SubViewOp -> MemRef_SubViewOp TransposeOp -> MemRef_TransposeOp TensorLoadOp -> MemRef_TensorLoadOp TensorStoreOp -> MemRef_TensorStoreOp TensorToMemRefOp -> MemRef_BufferCastOp ViewOp -> MemRef_ViewOp The roadmap to split the memref dialect from std is discussed here: https://llvm.discourse.group/t/rfc-split-the-memref-dialect-from-std/2667 Differential Revision: https://reviews.llvm.org/D98041
2021-02-10 20:53:11 +08:00
memref.dealloc %A : memref<4xf32>
Revert "Revert "[mlir] Convert from Async dialect to LLVM coroutines"" This reverts commit 4986d5eaff359081a867def1c6a2e1147dbb2ad6 with proper patches to CMakeLists.txt: - Add MLIRAsync as a dependency to MLIRAsyncToLLVM - Add Coroutines as a dependency to MLIRExecutionEngine
2020-10-23 03:20:42 +08:00
return
}
[MLIR] Extend Symbol verification to reject public symbol declarations. - Extend the Symbol interface with `isDeclaration` to identify operations that declare a symbol as opposed to define it. - Extend verification to disallow public declarations as per the discussion in https://llvm.discourse.group/t/rfc-symbol-definition-declaration-x-visibility-checks/2140 - Adopt the new interface for `FuncOp` and fix test and code to not have/create public function declarations. Differential Revision: https://reviews.llvm.org/D91456
2020-11-14 05:04:53 +08:00
func private @mlirAsyncRuntimePrintCurrentThreadId() -> ()
Revert "Revert "[mlir] Convert from Async dialect to LLVM coroutines"" This reverts commit 4986d5eaff359081a867def1c6a2e1147dbb2ad6 with proper patches to CMakeLists.txt: - Add MLIRAsync as a dependency to MLIRAsyncToLLVM - Add Coroutines as a dependency to MLIRExecutionEngine
2020-10-23 03:20:42 +08:00
[MLIR] Extend Symbol verification to reject public symbol declarations. - Extend the Symbol interface with `isDeclaration` to identify operations that declare a symbol as opposed to define it. - Extend verification to disallow public declarations as per the discussion in https://llvm.discourse.group/t/rfc-symbol-definition-declaration-x-visibility-checks/2140 - Adopt the new interface for `FuncOp` and fix test and code to not have/create public function declarations. Differential Revision: https://reviews.llvm.org/D91456
2020-11-14 05:04:53 +08:00
func private @print_memref_f32(memref<*xf32>) attributes { llvm.emit_c_interface }