derek.holloway
7502bf64a4
CodeQL / Analyze (actions) (push) Canceled after 0s
CodeQL / Analyze (python) (push) Canceled after 0s
pre-commit / pre-commit (push) Canceled after 0s
Multi-Arch CI / setup (push) Canceled after 0s
Publish build_manylinux_x86_64 images / publish_build_manylinux_x86_64 (push) Canceled after 0s
Setup (Multi-Arch) / setup (push) Canceled after 0s
Multi-Arch CI / Linux::${{ fromJSON(needs.setup.outputs.linux_build_config || '{}').build_variant_label || 'skip' }} (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish no_rocm_image_ubi10 image / publish_no_rocm_image_ubi10 (push) Canceled after 0s
Multi-Arch CI / Windows::${{ fromJSON(needs.setup.outputs.windows_build_config || '{}').build_variant_label || 'skip' }} (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Multi-Arch CI / Manifest Diff (push) Canceled after 0s
TheRock Manifest Diff Report / Generate Manifest Diff Report (push) Canceled after 0s
Multi-Arch CI / CI Summary (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04 (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04_ocl_rt images / publish_no_rocm_image_ubuntu24_04_ocl_rt (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_rocgdb (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04_rocgdb images / publish_no_rocm_image_ubuntu24_04_rocgdb (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_ocl_rt (push) Canceled after 0s
Publish TheRock Docker image / build-and-push-image (push) Canceled after 0s
Unit Tests / Unit Tests :: ubuntu-24.04 (push) Canceled after 0s
Unit Tests / Unit Tests :: windows-2022 (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_media (push) Canceled after 0s
Unit Tests / Unit Tests Summary (push) Canceled after 0s
Publish no_rocm_image_ubuntu24_04 images / publish_no_rocm_image_ubuntu24_04_openmpi (push) Canceled after 0s
403 lines
13 KiB
MLIR
403 lines
13 KiB
MLIR
// RUN: mlir-opt -split-input-file -test-liveness-analysis %s 2>&1 | FileCheck %s
|
|
|
|
// Positive test: Type (1.a) "is an operand of an op with memory effects"
|
|
// zero is live because it is stored in memory.
|
|
// CHECK-LABEL: test_tag: zero:
|
|
// CHECK-NEXT: result #0: live
|
|
func.func @test_1_type_1.a(%arg0: memref<i32>) {
|
|
%c0_i32 = arith.constant {tag = "zero"} 0 : i32
|
|
memref.store %c0_i32, %arg0[] : memref<i32>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
// Positive test: Type (1.b) "is a non-forwarded branch operand and a block
|
|
// where its op could take the control has an op with memory effects"
|
|
// %arg2 is live because it can make the control go into a block with a memory
|
|
// effecting op.
|
|
// CHECK-LABEL: test_tag: br:
|
|
// CHECK-NEXT: operand #0: live
|
|
// CHECK-NEXT: operand #1: live
|
|
// CHECK-NEXT: operand #2: live
|
|
func.func @test_2_RegionBranchOpInterface_type_1.b(%arg0: memref<i32>, %arg1: memref<i32>, %arg2: i1) {
|
|
%c0_i32 = arith.constant 0 : i32
|
|
cf.cond_br %arg2, ^bb1(%c0_i32 : i32), ^bb2(%c0_i32 : i32) {tag = "br"}
|
|
^bb1(%0 : i32):
|
|
memref.store %0, %arg0[] : memref<i32>
|
|
cf.br ^bb3
|
|
^bb2(%1 : i32):
|
|
memref.store %1, %arg1[] : memref<i32>
|
|
cf.br ^bb3
|
|
^bb3:
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
// Positive test: Type (1.b) "is a non-forwarded branch operand and a block
|
|
// where its op could take the control has an op with memory effects"
|
|
// %arg0 is live because it can make the control go into a block with a memory
|
|
// effecting op.
|
|
// CHECK-LABEL: test_tag: flag:
|
|
// CHECK-NEXT: operand #0: live
|
|
func.func @test_3_BranchOpInterface_type_1.b(%arg0: i32, %arg1: memref<i32>, %arg2: memref<i32>) {
|
|
%c0_i32 = arith.constant 0 : i32
|
|
cf.switch %arg0 : i32, [
|
|
default: ^bb1,
|
|
42: ^bb2
|
|
] {tag = "flag"}
|
|
^bb1:
|
|
memref.store %c0_i32, %arg1[] : memref<i32>
|
|
cf.br ^bb3
|
|
^bb2:
|
|
memref.store %c0_i32, %arg2[] : memref<i32>
|
|
cf.br ^bb3
|
|
^bb3:
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
// Positive test: Type(1.c) "is a non-forwarded branch operand and its branch
|
|
// op could result in different result"
|
|
// CHECK-LABEL: test_tag: cond_br:
|
|
// CHECK-NEXT: operand #0: live
|
|
// CHECK-NEXT: operand #1: live
|
|
// CHECK-NEXT: operand #2: live
|
|
func.func @test_branch_result_in_different_result_1.c(%arg0 : tensor<f32>, %arg1 : tensor<f32>, %arg2 : i1) -> tensor<f32> {
|
|
cf.cond_br %arg2, ^bb1(%arg0 : tensor<f32>), ^bb2(%arg1 : tensor<f32>) {tag = "cond_br"}
|
|
^bb1(%0 : tensor<f32>):
|
|
cf.br ^bb3(%0 : tensor<f32>)
|
|
^bb2(%1 : tensor<f32>):
|
|
cf.br ^bb3(%1 : tensor<f32>)
|
|
^bb3(%2 : tensor<f32>):
|
|
return %2 : tensor<f32>
|
|
}
|
|
|
|
// -----
|
|
|
|
// Positive test: Type(1.c) "is a non-forwarded branch operand and its branch
|
|
// op could result in different result"
|
|
// CHECK-LABEL: test_tag: region_branch:
|
|
// CHECK-NEXT: operand #0: live
|
|
func.func @test_region_branch_result_in_different_result_1.c(%arg0 : tensor<f32>, %arg1 : tensor<f32>, %arg2 : i1) -> tensor<f32> {
|
|
%0 = scf.if %arg2 -> tensor<f32> {
|
|
scf.yield %arg0 : tensor<f32>
|
|
} else {
|
|
scf.yield %arg1 : tensor<f32>
|
|
} {tag="region_branch"}
|
|
return %0 : tensor<f32>
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func private @private(%arg0 : i32, %arg1 : i32) {
|
|
func.return
|
|
}
|
|
|
|
// Positive test: Type (1.d) "is a non-forwarded call operand"
|
|
// CHECK-LABEL: test_tag: call
|
|
// CHECK-LABEL: operand #0: not live
|
|
// CHECK-LABEL: operand #1: not live
|
|
// CHECK-LABEL: operand #2: live
|
|
func.func @test_4_type_1.d(%arg0: i32, %arg1: i32, %device: i32, %m0: memref<i32>) {
|
|
test.call_on_device @private(%arg0, %arg1), %device {tag = "call"} : (i32, i32, i32) -> ()
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
// Positive test: Type (2) "is returned by a public function"
|
|
// zero is live because it is returned by a public function.
|
|
// CHECK-LABEL: test_tag: zero:
|
|
// CHECK-NEXT: result #0: live
|
|
func.func @test_5_type_2() -> (f32){
|
|
%0 = arith.constant {tag = "zero"} 0.0 : f32
|
|
return %0 : f32
|
|
}
|
|
|
|
// -----
|
|
|
|
// Positive test: Type (3) "is used to compute a value of type (1) or (2)"
|
|
// %arg1 is live because the scf.while has a live result and %arg1 is a
|
|
// non-forwarded branch operand.
|
|
// %arg2 is live because it is forwarded to the live result of the scf.while
|
|
// op.
|
|
// %arg5 is live because it is forwarded to %arg8 which is live.
|
|
// %arg8 is live because it is forwarded to %arg4 which is live as it writes
|
|
// to memory.
|
|
// Negative test:
|
|
// %arg3 is not live even though %arg1, %arg2, and %arg5 are live because it
|
|
// is neither a non-forwarded branch operand nor a forwarded operand that
|
|
// forwards to a live value. It actually is a forwarded operand that forwards
|
|
// to non-live values %0#1 and %arg7.
|
|
// CHECK-LABEL: test_tag: condition:
|
|
// CHECK-NEXT: operand #0: live
|
|
// CHECK-NEXT: operand #1: live
|
|
// CHECK-NEXT: operand #2: not live
|
|
// CHECK-NEXT: operand #3: live
|
|
// CHECK-LABEL: test_tag: add:
|
|
// CHECK-NEXT: operand #0: live
|
|
func.func @test_6_RegionBranchTerminatorOpInterface_type_3(%arg0: memref<i32>, %arg1: i1) -> (i32) {
|
|
%c0_i32 = arith.constant 0 : i32
|
|
%c1_i32 = arith.constant 1 : i32
|
|
%c2_i32 = arith.constant 2 : i32
|
|
%0:3 = scf.while (%arg2 = %c0_i32, %arg3 = %c1_i32, %arg4 = %c2_i32, %arg5 = %c2_i32) : (i32, i32, i32, i32) -> (i32, i32, i32) {
|
|
memref.store %arg4, %arg0[] : memref<i32>
|
|
scf.condition(%arg1) {tag = "condition"} %arg2, %arg3, %arg5 : i32, i32, i32
|
|
} do {
|
|
^bb0(%arg6: i32, %arg7: i32, %arg8: i32):
|
|
%1 = arith.addi %arg8, %arg8 {tag = "add"} : i32
|
|
%c3_i32 = arith.constant 3 : i32
|
|
scf.yield %arg6, %arg7, %arg8, %c3_i32 : i32, i32, i32, i32
|
|
}
|
|
return %0#0 : i32
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func private @private0(%0 : i32) -> i32 {
|
|
%1 = arith.addi %0, %0 {tag = "in_private0"} : i32
|
|
func.return %1 : i32
|
|
}
|
|
|
|
// Positive test: Type (3) "is used to compute a value of type (1) or (2)"
|
|
// zero, ten, and one are live because they are used to decide the number of
|
|
// times the `for` loop executes, which in turn decides the value stored in
|
|
// memory.
|
|
// in_private0 and x are also live because they decide the value stored in
|
|
// memory.
|
|
// Negative test:
|
|
// y is not live even though the non-forwarded branch operand and x are live.
|
|
// CHECK-LABEL: test_tag: in_private0:
|
|
// CHECK-NEXT: operand #0: live
|
|
// CHECK-NEXT: operand #1: live
|
|
// CHECK-NEXT: result #0: live
|
|
// CHECK-LABEL: test_tag: zero:
|
|
// CHECK-NEXT: result #0: live
|
|
// CHECK-LABEL: test_tag: ten:
|
|
// CHECK-NEXT: result #0: live
|
|
// CHECK-LABEL: test_tag: one:
|
|
// CHECK-NEXT: result #0: live
|
|
// CHECK-LABEL: test_tag: x:
|
|
// CHECK-NEXT: result #0: live
|
|
// CHECK-LABEL: test_tag: y:
|
|
// CHECK-NEXT: result #0: not live
|
|
// CHECK-LABEL: test_tag: for:
|
|
// CHECK-NEXT: operand #0: live
|
|
// CHECK-NEXT: operand #1: live
|
|
// CHECK-NEXT: operand #2: live
|
|
// CHECK-NEXT: operand #3: live
|
|
// CHECK-NEXT: operand #4: not live
|
|
// CHECK-NEXT: result #0: live
|
|
// CHECK-NEXT: result #1: not live
|
|
// CHECK-NEXT: region: #0:
|
|
// CHECK-NEXT: block: #0:
|
|
// CHECK-NEXT: argument: #0: live
|
|
// CHECK-NEXT: argument: #1: not live
|
|
// CHECK-NEXT: argument: #2: not live
|
|
func.func @test_7_type_3(%arg0: memref<i32>) {
|
|
%c0 = arith.constant {tag = "zero"} 0 : index
|
|
%c10 = arith.constant {tag = "ten"} 10 : index
|
|
%c1 = arith.constant {tag = "one"} 1 : index
|
|
%x = arith.constant {tag = "x"} 0 : i32
|
|
%y = arith.constant {tag = "y"} 1 : i32
|
|
%0:2 = scf.for %arg1 = %c0 to %c10 step %c1 iter_args(%arg2 = %x, %arg3 = %y) -> (i32, i32) {
|
|
%1 = arith.addi %x, %x : i32
|
|
%2 = func.call @private0(%1) : (i32) -> i32
|
|
scf.yield %2, %arg3 : i32, i32
|
|
} {tag = "for"}
|
|
memref.store %0#0, %arg0[] : memref<i32>
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
func.func private @private1(%0 : i32) -> i32 {
|
|
%1 = func.call @private2(%0) : (i32) -> i32
|
|
%2 = arith.muli %0, %1 {tag = "in_private1"} : i32
|
|
func.return %2 : i32
|
|
}
|
|
|
|
func.func private @private2(%0 : i32) -> i32 {
|
|
%cond = arith.index_cast %0 {tag = "in_private2"} : i32 to index
|
|
%1 = scf.index_switch %cond -> i32
|
|
case 1 {
|
|
%ten = arith.constant 10 : i32
|
|
scf.yield %ten : i32
|
|
}
|
|
case 2 {
|
|
%twenty = arith.constant 20 : i32
|
|
scf.yield %twenty : i32
|
|
}
|
|
default {
|
|
%thirty = arith.constant 30 : i32
|
|
scf.yield %thirty : i32
|
|
}
|
|
func.return %1 : i32
|
|
}
|
|
|
|
// Positive test: Type (3) "is used to compute a value of type (1) or (2)"
|
|
// in_private1, in_private2, and final are live because they are used to compute
|
|
// the value returned by this public function.
|
|
// CHECK-LABEL: test_tag: in_private1:
|
|
// CHECK-NEXT: operand #0: live
|
|
// CHECK-NEXT: operand #1: live
|
|
// CHECK-NEXT: result #0: live
|
|
// CHECK-LABEL: test_tag: in_private2:
|
|
// CHECK-NEXT: operand #0: live
|
|
// CHECK-NEXT: result #0: live
|
|
// CHECK-LABEL: test_tag: final:
|
|
// CHECK-NEXT: operand #0: live
|
|
// CHECK-NEXT: operand #1: live
|
|
// CHECK-NEXT: result #0: live
|
|
func.func @test_8_type_3(%arg: i32) -> (i32) {
|
|
%0 = func.call @private1(%arg) : (i32) -> i32
|
|
%final = arith.muli %0, %arg {tag = "final"} : i32
|
|
return %final : i32
|
|
}
|
|
|
|
// -----
|
|
|
|
// Negative test: None of the types (1), (2), or (3)
|
|
// zero is not live because it has no effect outside the program: it doesn't
|
|
// affect the memory or the program output.
|
|
// CHECK-LABEL: test_tag: zero:
|
|
// CHECK-NEXT: result #0: not live
|
|
// CHECK-LABEL: test_tag: one:
|
|
// CHECK-NEXT: result #0: live
|
|
func.func @test_9_negative() -> (f32){
|
|
%0 = arith.constant {tag = "zero"} 0.0 : f32
|
|
%1 = arith.constant {tag = "one"} 1.0 : f32
|
|
return %1 : f32
|
|
}
|
|
|
|
// -----
|
|
|
|
// Negative test: None of the types (1), (2), or (3)
|
|
// %1 is not live because it has no effect outside the program: it doesn't
|
|
// affect the memory or the program output. Even though it is returned by the
|
|
// function `@private_1`, it is never used by the caller.
|
|
// Note that this test clearly shows how this liveness analysis utility differs
|
|
// from the existing liveness utility present at
|
|
// llvm-project/mlir/include/mlir/Analysis/Liveness.h. The latter marks %1 as
|
|
// live as it exists the block of function `@private_1`, simply because it is
|
|
// computed inside and returned by the block, irrespective of whether or not it
|
|
// is used by the caller.
|
|
// CHECK-LABEL: test_tag: one:
|
|
// CHECK: result #0: not live
|
|
func.func private @private_1() -> (i32, i32) {
|
|
%0 = arith.constant 0 : i32
|
|
%1 = arith.addi %0, %0 {tag = "one"} : i32
|
|
return %0, %1 : i32, i32
|
|
}
|
|
func.func @test_10_negative() -> (i32) {
|
|
%0:2 = func.call @private_1() : () -> (i32, i32)
|
|
return %0#0 : i32
|
|
}
|
|
|
|
// -----
|
|
|
|
// Test that we correctly set a liveness value for operations in dead block.
|
|
// These won't be visited by the dataflow framework so the analysis need to
|
|
// explicitly manage them.
|
|
// CHECK-LABEL: test_tag: dead_block_cmpi:
|
|
// CHECK-NEXT: operand #0: not live
|
|
// CHECK-NEXT: operand #1: not live
|
|
// CHECK-NEXT: result #0: not live
|
|
func.func @dead_block() {
|
|
%false = arith.constant false
|
|
%zero = arith.constant 0 : i64
|
|
cf.cond_br %false, ^bb1, ^bb4
|
|
^bb1:
|
|
%3 = arith.cmpi eq, %zero, %zero {tag = "dead_block_cmpi"} : i64
|
|
cf.br ^bb1
|
|
^bb4:
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
// CHECK-LABEL: test_tag: for:
|
|
// CHECK-NEXT: region: #0:
|
|
// CHECK-NEXT: block: #0:
|
|
// CHECK-NEXT: argument: #0: live
|
|
func.func @affine_loop_no_use_iv_has_side_effect_op() {
|
|
%c1 = arith.constant 1 : index
|
|
%alloc = memref.alloc() : memref<10xindex>
|
|
affine.for %arg0 = 0 to 79 {
|
|
memref.store %c1, %alloc[%c1] : memref<10xindex>
|
|
} {tag = "for"}
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
// CHECK-LABEL: test_tag: for:
|
|
// CHECK-NEXT: region: #0:
|
|
// CHECK-NEXT: block: #0:
|
|
// CHECK-NEXT: argument: #0: not live
|
|
func.func @affine_loop_no_use_iv() {
|
|
affine.for %arg0 = 0 to 79 {
|
|
} {tag = "for"}
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
// CHECK-LABEL: test_tag: forall:
|
|
// CHECK-NEXT: operand #0: live
|
|
// CHECK-NEXT: region: #0:
|
|
// CHECK-NEXT: block: #0:
|
|
// CHECK-NEXT: argument: #0: live
|
|
|
|
func.func @forall_no_use_iv_has_side_effect_op(%idx1: index, %idx2: index) {
|
|
scf.parallel (%i) = (%idx1) to (%idx2) step (%idx2) {
|
|
%r = memref.alloca() : memref<10xf32>
|
|
%cst = arith.constant 0.0 : f32
|
|
scf.forall (%e2) in (%idx2) {
|
|
memref.store %cst, %r[%idx2] : memref<10xf32>
|
|
} {tag = "forall"}
|
|
}
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
// CHECK-LABEL: test_tag: for:
|
|
// CHECK-NEXT: operand #0: not live
|
|
// CHECK-NEXT: operand #1: not live
|
|
// CHECK-NEXT: operand #2: not live
|
|
// CHECK-NEXT: operand #3: not live
|
|
|
|
func.func @test_for_loop_read_only(%arg0: memref<10xindex>) {
|
|
%c0 = arith.constant 0 : index
|
|
%c10 = arith.constant 10 : index
|
|
%c1 = arith.constant 1 : index
|
|
%0 = scf.for %iv = %c0 to %c10 step %c1 iter_args(%idx = %c0) -> (index) {
|
|
%loaded = memref.load %arg0[%idx] : memref<10xindex>
|
|
scf.yield %loaded : index
|
|
} {tag = "for"}
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
// CHECK-LABEL: test_tag: func:
|
|
// CHECK-NEXT: region: #0:
|
|
// CHECK-NEXT: block: #0:
|
|
// CHECK-NEXT: argument: #0: live
|
|
// CHECK-NEXT: argument: #1: not live
|
|
// CHECK-NEXT: block: #1:
|
|
// CHECK-NEXT: argument: #0: not live
|
|
// CHECK-NEXT: block: #2:
|
|
// CHECK-NEXT: argument: #0: live
|
|
func.func @unstructured_cf(%val: f32, %c: i1) -> f32 attributes {tag = "func"} {
|
|
cf.br ^bb1(%val : f32)
|
|
^bb0(%arg0: f32):
|
|
return %arg0: f32
|
|
^bb1(%arg1: f32):
|
|
return %arg1: f32
|
|
}
|