388 lines
15 KiB
LLVM
388 lines
15 KiB
LLVM
; RUN: opt < %s -passes=pseudo-probe,sample-profile -sample-profile-use-profi -sample-profile-file=%S/Inputs/profile-inference-rebalance-large.prof | opt -passes='print<branch-prob>' -disable-output 2>&1 | FileCheck %s
|
|
; RUN: opt < %s -passes=pseudo-probe,sample-profile -sample-profile-use-profi -sample-profile-file=%S/Inputs/profile-inference-rebalance-large.prof | opt -passes='print<block-freq>' -disable-output 2>&1 | FileCheck %s --check-prefix=CHECK2
|
|
|
|
; The test verifies that counts can rebalanced in switch statements that contain
|
|
; both 'known' and 'unknown' basic blocks.
|
|
;
|
|
; +---------+
|
|
; +----------------- | b15 [?] |
|
|
; | +---------+
|
|
; | ^
|
|
; | |
|
|
; | |
|
|
; | +---------+ +--------------+ +---------+
|
|
; | | b13 [?] | <-- | b11 [3300] | --> | b14 [?] |
|
|
; | +---------+ +--------------+ +---------+
|
|
; | | | | |
|
|
; | | | | |
|
|
; | | v | |
|
|
; | | +---------+ | |
|
|
; | | | b12 [0] | | |
|
|
; | | +---------+ | |
|
|
; | | | | |
|
|
; | | | | |
|
|
; | | v v |
|
|
; | | +--------------+ |
|
|
; | +-----------> | | <-----+
|
|
; | | b16 [3300] |
|
|
; +----------------> | |
|
|
; +--------------+
|
|
|
|
@yydebug = dso_local global i32 0, align 4
|
|
|
|
; Function Attrs: nounwind uwtable
|
|
define dso_local i32 @foo1(i32 %0, i32 %1) #0 {
|
|
b11:
|
|
call void @llvm.pseudoprobe(i64 7682762345278052905, i64 1, i32 0, i64 -1)
|
|
%cmp = icmp ne i32 %0, 0
|
|
switch i32 %1, label %b12 [
|
|
i32 1, label %b13
|
|
i32 2, label %b14
|
|
i32 3, label %b15
|
|
i32 4, label %b16
|
|
]
|
|
; CHECK: edge b11 -> b12 probability is 0x00000000 / 0x80000000 = 0.00%
|
|
; CHECK: edge b11 -> b13 probability is 0x20000000 / 0x80000000 = 25.00%
|
|
; CHECK: edge b11 -> b14 probability is 0x20000000 / 0x80000000 = 25.00%
|
|
; CHECK: edge b11 -> b15 probability is 0x20000000 / 0x80000000 = 25.00%
|
|
; CHECK: edge b11 -> b16 probability is 0x20000000 / 0x80000000 = 25.00%
|
|
; CHECK2: - b11: float = {{.*}}, int = {{.*}}, count = 3300
|
|
|
|
b12:
|
|
call void @llvm.pseudoprobe(i64 7682762345278052905, i64 2, i32 0, i64 -1)
|
|
br label %b16
|
|
; CHECK2: - b12: float = {{.*}}, int = {{.*}}, count = 0
|
|
|
|
b13:
|
|
call void @llvm.pseudoprobe(i64 7682762345278052905, i64 3, i32 0, i64 -1)
|
|
br label %b16
|
|
; CHECK2: - b13: float = {{.*}}, int = {{.*}}, count = 825
|
|
|
|
b14:
|
|
call void @llvm.pseudoprobe(i64 7682762345278052905, i64 4, i32 0, i64 -1)
|
|
br label %b16
|
|
; CHECK2: - b14: float = {{.*}}, int = {{.*}}, count = 825
|
|
|
|
b15:
|
|
call void @llvm.pseudoprobe(i64 7682762345278052905, i64 5, i32 0, i64 -1)
|
|
br label %b16
|
|
; CHECK2: - b15: float = {{.*}}, int = {{.*}}, count = 825
|
|
|
|
b16:
|
|
call void @llvm.pseudoprobe(i64 7682762345278052905, i64 6, i32 0, i64 -1)
|
|
ret i32 %1
|
|
; CHECK2: - b16: float = {{.*}}, int = {{.*}}, count = 3300
|
|
}
|
|
|
|
|
|
; The test verifies that counts can rebalanced even when control-flow ends at
|
|
; a basic block with an unknown count.
|
|
;
|
|
; +-----------+
|
|
; | b21 [128] | -+
|
|
; +-----------+ |
|
|
; | |
|
|
; v |
|
|
; +-----------+ |
|
|
; | b22 [128] | |
|
|
; +-----------+ |
|
|
; | |
|
|
; v |
|
|
; +-----------+ |
|
|
; +------------ | b23 [128] | <+
|
|
; | +-----------+
|
|
; | |
|
|
; v v
|
|
; +---------+ +-----------+
|
|
; | b26 [?] | <-- | b24 [128] |
|
|
; +---------+ +-----------+
|
|
; | |
|
|
; | v
|
|
; | +-----------+
|
|
; | | b25 [?] |
|
|
; | +-----------+
|
|
; | |
|
|
; | v
|
|
; | +-----------+
|
|
; +-----------> | b27 [?] | -+
|
|
; +-----------+ |
|
|
; | |
|
|
; v |
|
|
; +-----------+ |
|
|
; | b28 [?] | |
|
|
; +-----------+ |
|
|
; | |
|
|
; v |
|
|
; +-----------+ |
|
|
; | b29 [?] | <+
|
|
; +-----------+
|
|
|
|
define dso_local i32 @foo2(i32 %0, i32 %1) #0 {
|
|
b21:
|
|
call void @llvm.pseudoprobe(i64 2494702099028631698, i64 1, i32 0, i64 -1)
|
|
%cmp = icmp ne i32 %0, 0
|
|
br i1 %cmp, label %b22, label %b23
|
|
; CHECK: edge b21 -> b22 probability is 0x80000000 / 0x80000000 = 100.00% [HOT edge]
|
|
; CHECK: edge b21 -> b23 probability is 0x00000000 / 0x80000000 = 0.00%
|
|
; CHECK2: - b21: float = {{.*}}, int = {{.*}}, count = 128
|
|
|
|
b22:
|
|
call void @llvm.pseudoprobe(i64 2494702099028631698, i64 2, i32 0, i64 -1)
|
|
br label %b23
|
|
|
|
b23:
|
|
call void @llvm.pseudoprobe(i64 2494702099028631698, i64 3, i32 0, i64 -1)
|
|
br i1 %cmp, label %b24, label %b26
|
|
; CHECK: edge b23 -> b24 probability is 0x80000000 / 0x80000000 = 100.00% [HOT edge]
|
|
; CHECK: edge b23 -> b26 probability is 0x00000000 / 0x80000000 = 0.00%
|
|
; CHECK2: - b23: float = {{.*}}, int = {{.*}}, count = 128
|
|
|
|
b24:
|
|
call void @llvm.pseudoprobe(i64 2494702099028631698, i64 4, i32 0, i64 -1)
|
|
br i1 %cmp, label %b25, label %b26
|
|
; CHECK: edge b24 -> b25 probability is 0x40000000 / 0x80000000 = 50.00%
|
|
; CHECK: edge b24 -> b26 probability is 0x40000000 / 0x80000000 = 50.00%
|
|
|
|
b25:
|
|
call void @llvm.pseudoprobe(i64 2494702099028631698, i64 5, i32 0, i64 -1)
|
|
br label %b27
|
|
; CHECK2: - b25: float = {{.*}}, int = {{.*}}, count = 64
|
|
|
|
b26:
|
|
call void @llvm.pseudoprobe(i64 2494702099028631698, i64 6, i32 0, i64 -1)
|
|
br label %b27
|
|
; CHECK2: - b26: float = {{.*}}, int = {{.*}}, count = 64
|
|
|
|
b27:
|
|
call void @llvm.pseudoprobe(i64 2494702099028631698, i64 7, i32 0, i64 -1)
|
|
br i1 %cmp, label %b28, label %b29
|
|
; CHECK: edge b27 -> b28 probability is 0x40000000 / 0x80000000 = 50.00%
|
|
; CHECK: edge b27 -> b29 probability is 0x40000000 / 0x80000000 = 50.00%
|
|
; CHECK2: - b27: float = {{.*}}, int = {{.*}}, count = 128
|
|
|
|
b28:
|
|
call void @llvm.pseudoprobe(i64 2494702099028631698, i64 8, i32 0, i64 -1)
|
|
br label %b29
|
|
; CHECK2: - b28: float = {{.*}}, int = {{.*}}, count = 64
|
|
|
|
b29:
|
|
call void @llvm.pseudoprobe(i64 2494702099028631698, i64 9, i32 0, i64 -1)
|
|
ret i32 %1
|
|
; CHECK2: - b29: float = {{.*}}, int = {{.*}}, count = 128
|
|
}
|
|
|
|
|
|
; The test verifies a flexible mode of rebalancing in which some jumps to known
|
|
; basic blocks are ignored.
|
|
;
|
|
; +------------+
|
|
; | b31 [500] |
|
|
; +------------+
|
|
; |
|
|
; v
|
|
; +---------+ +------------+
|
|
; | b33 [?] | <-- | b32 [1500] | <-----+
|
|
; +---------+ +------------+ |
|
|
; | | |
|
|
; | v |
|
|
; | +------------+ +-----------+
|
|
; | | b34 [1200] | --> | b36 [900] |
|
|
; | +------------+ +-----------+
|
|
; | |
|
|
; | v
|
|
; | +------------+
|
|
; | | b35 [?] |
|
|
; | +------------+
|
|
; | |
|
|
; | v
|
|
; | +------------+
|
|
; +-----------> | b37 [?] | -+
|
|
; +------------+ |
|
|
; | |
|
|
; v |
|
|
; +------------+ |
|
|
; | b38 [?] | |
|
|
; +------------+ |
|
|
; | |
|
|
; v |
|
|
; +------------+ |
|
|
; | b39 [500] | <+
|
|
; +------------+
|
|
;
|
|
|
|
define dso_local i32 @foo3(i32 %0, i32 %1) #0 {
|
|
b31:
|
|
call void @llvm.pseudoprobe(i64 -7908226060800700466, i64 1, i32 0, i64 -1)
|
|
%cmp = icmp ne i32 %0, 0
|
|
br label %b32
|
|
; CHECK2: - b31: float = {{.*}}, int = {{.*}}, count = 500
|
|
|
|
b32:
|
|
call void @llvm.pseudoprobe(i64 -7908226060800700466, i64 2, i32 0, i64 -1)
|
|
br i1 %cmp, label %b33, label %b34
|
|
; CHECK: edge b32 -> b33 probability is 0x1999999a / 0x80000000 = 20.00%
|
|
; CHECK: edge b32 -> b34 probability is 0x66666666 / 0x80000000 = 80.00%
|
|
; CHECK2: - b32: float = {{.*}}, int = {{.*}}, count = 1500
|
|
|
|
b33:
|
|
call void @llvm.pseudoprobe(i64 -7908226060800700466, i64 3, i32 0, i64 -1)
|
|
br label %b37
|
|
; CHECK2: - b33: float = {{.*}}, int = {{.*}}, count = 300
|
|
|
|
b34:
|
|
call void @llvm.pseudoprobe(i64 -7908226060800700466, i64 4, i32 0, i64 -1)
|
|
br i1 %cmp, label %b35, label %b36
|
|
; CHECK: edge b34 -> b35 probability is 0x15555555 / 0x80000000 = 16.67%
|
|
; CHECK: edge b34 -> b36 probability is 0x6aaaaaab / 0x80000000 = 83.33% [HOT edge]
|
|
; CHECK2: - b34: float = {{.*}}, int = {{.*}}, count = 1200
|
|
|
|
b35:
|
|
call void @llvm.pseudoprobe(i64 -7908226060800700466, i64 5, i32 0, i64 -1)
|
|
br label %b37
|
|
; CHECK2: - b35: float = {{.*}}, int = {{.*}}, count = 200
|
|
|
|
b36:
|
|
call void @llvm.pseudoprobe(i64 -7908226060800700466, i64 6, i32 0, i64 -1)
|
|
br label %b32
|
|
; CHECK2: - b36: float = {{.*}}, int = {{.*}}, count = 1000
|
|
|
|
b37:
|
|
call void @llvm.pseudoprobe(i64 -7908226060800700466, i64 7, i32 0, i64 -1)
|
|
br i1 %cmp, label %b38, label %b39
|
|
; CHECK: edge b37 -> b38 probability is 0x40000000 / 0x80000000 = 50.00%
|
|
; CHECK: edge b37 -> b39 probability is 0x40000000 / 0x80000000 = 50.00%
|
|
; CHECK2: - b37: float = {{.*}}, int = {{.*}}, count = 500
|
|
|
|
b38:
|
|
call void @llvm.pseudoprobe(i64 -7908226060800700466, i64 8, i32 0, i64 -1)
|
|
br label %b39
|
|
; CHECK2: - b38: float = {{.*}}, int = {{.*}}, count = 250
|
|
|
|
b39:
|
|
call void @llvm.pseudoprobe(i64 -7908226060800700466, i64 9, i32 0, i64 -1)
|
|
ret i32 %1
|
|
; CHECK2: - b39: float = {{.*}}, int = {{.*}}, count = 500
|
|
}
|
|
|
|
|
|
; The test verifies that flow rebalancer can ignore 'unlikely' jumps.
|
|
;
|
|
; +-----------+
|
|
; | b41 [400] | -+
|
|
; +-----------+ |
|
|
; | |
|
|
; | |
|
|
; v |
|
|
; +-----------+ |
|
|
; | b42 [?] | |
|
|
; +-----------+ |
|
|
; | |
|
|
; | |
|
|
; v v
|
|
; +---------++---------+ +---------------------------+ +---------++---------+
|
|
; | b48 [?] || b46 [?] | <-- | | --> | b47 [?] || b49 [?] |
|
|
; +---------++---------+ | | +---------++---------+
|
|
; | ^ | | | | ^
|
|
; | | | | b43 [400] | | |
|
|
; | +-------+-------------| | | |
|
|
; | | | | | |
|
|
; | | | | ------+----------+
|
|
; | | +---------------------------+ |
|
|
; | | | | |
|
|
; | | | | |
|
|
; | | v v |
|
|
; | | +-----------+ +---------+ |
|
|
; | | | b44 [?] | | b45 [?] | |
|
|
; | | +-----------+ +---------+ |
|
|
; | | | | |
|
|
; | | | | |
|
|
; | | v v |
|
|
; | | +---------------------------+ |
|
|
; | +-----------> | | <-----+
|
|
; | | b410 [400] |
|
|
; | | |
|
|
; +----------------------> | |
|
|
; +---------------------------+
|
|
|
|
|
|
define dso_local void @foo4(i32 %0, i32 %1) #0 {
|
|
b41:
|
|
call void @llvm.pseudoprobe(i64 -6882312132165544686, i64 1, i32 0, i64 -1)
|
|
%cmp = icmp ne i32 %0, 0
|
|
br i1 %cmp, label %b42, label %b43
|
|
; CHECK: edge b41 -> b42 probability is 0x40000000 / 0x80000000 = 50.00%
|
|
; CHECK: edge b41 -> b43 probability is 0x40000000 / 0x80000000 = 50.00%
|
|
; CHECK2: - b41: float = {{.*}}, int = {{.*}}, count = 400
|
|
|
|
b42:
|
|
call void @llvm.pseudoprobe(i64 -6882312132165544686, i64 2, i32 0, i64 -1)
|
|
br label %b43
|
|
; CHECK2: - b42: float = {{.*}}, int = {{.*}}, count = 200
|
|
|
|
b43:
|
|
call void @llvm.pseudoprobe(i64 -6882312132165544686, i64 3, i32 0, i64 -1)
|
|
switch i32 %1, label %b49 [
|
|
i32 1, label %b44
|
|
i32 2, label %b45
|
|
i32 3, label %b46
|
|
i32 4, label %b47
|
|
i32 5, label %b48
|
|
]
|
|
; CHECK: edge b43 -> b49 probability is 0x00000000 / 0x80000000 = 0.00%
|
|
; CHECK: edge b43 -> b44 probability is 0x1999999a / 0x80000000 = 20.00%
|
|
; CHECK: edge b43 -> b45 probability is 0x1999999a / 0x80000000 = 20.00%
|
|
; CHECK: edge b43 -> b46 probability is 0x1999999a / 0x80000000 = 20.00%
|
|
; CHECK: edge b43 -> b47 probability is 0x1999999a / 0x80000000 = 20.00%
|
|
; CHECK: edge b43 -> b48 probability is 0x1999999a / 0x80000000 = 20.00%
|
|
; CHECK2: - b43: float = {{.*}}, int = {{.*}}, count = 400
|
|
|
|
b44:
|
|
call void @llvm.pseudoprobe(i64 -6882312132165544686, i64 4, i32 0, i64 -1)
|
|
br label %b410
|
|
; CHECK2: - b44: float = {{.*}}, int = {{.*}}, count = 80
|
|
|
|
b45:
|
|
call void @llvm.pseudoprobe(i64 -6882312132165544686, i64 5, i32 0, i64 -1)
|
|
br label %b410
|
|
; CHECK2: - b45: float = {{.*}}, int = {{.*}}, count = 80
|
|
|
|
b46:
|
|
call void @llvm.pseudoprobe(i64 -6882312132165544686, i64 6, i32 0, i64 -1)
|
|
br label %b410
|
|
; CHECK2: - b46: float = {{.*}}, int = {{.*}}, count = 80
|
|
|
|
b47:
|
|
call void @llvm.pseudoprobe(i64 -6882312132165544686, i64 7, i32 0, i64 -1)
|
|
br label %b410
|
|
; CHECK2: - b47: float = {{.*}}, int = {{.*}}, count = 80
|
|
|
|
b48:
|
|
call void @llvm.pseudoprobe(i64 -6882312132165544686, i64 8, i32 0, i64 -1)
|
|
br label %b410
|
|
; CHECK2: - b48: float = {{.*}}, int = {{.*}}, count = 80
|
|
|
|
b49:
|
|
call void @llvm.pseudoprobe(i64 -6882312132165544686, i64 9, i32 0, i64 -1)
|
|
unreachable
|
|
; CHECK2: - b49: float = {{.*}}, int = {{.*}}, count = 0
|
|
|
|
b410:
|
|
call void @llvm.pseudoprobe(i64 -6882312132165544686, i64 10, i32 0, i64 -1)
|
|
ret void
|
|
; CHECK2: - b410: float = {{.*}}, int = {{.*}}, count = 400
|
|
}
|
|
|
|
|
|
; Function Attrs: inaccessiblememonly nounwind willreturn
|
|
declare void @llvm.pseudoprobe(i64, i64, i32, i64) #4
|
|
|
|
attributes #0 = { noinline nounwind uwtable "use-sample-profile" }
|
|
attributes #4 = { inaccessiblememonly nounwind willreturn }
|
|
|
|
!llvm.pseudo_probe_desc = !{!7, !8, !9, !10}
|
|
|
|
!7 = !{i64 7682762345278052905, i64 157181141624, !"foo1", null}
|
|
!8 = !{i64 2494702099028631698, i64 208782362068, !"foo2", null}
|
|
!9 = !{i64 -7908226060800700466, i64 189901498683, !"foo3", null}
|
|
!10 = !{i64 -6882312132165544686, i64 241030178952, !"foo4", null}
|