mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-15 04:30:12 +00:00
cc1e1707b8
Rewrite the shared implementation of BlockFrequencyInfo and
MachineBlockFrequencyInfo entirely.
The old implementation had a fundamental flaw: precision losses from
nested loops (or very wide branches) compounded past loop exits (and
convergence points).
The @nested_loops testcase at the end of
test/Analysis/BlockFrequencyAnalysis/basic.ll is motivating. This
function has three nested loops, with branch weights in the loop headers
of 1:4000 (exit:continue). The old analysis gives non-sensical results:
Printing analysis 'Block Frequency Analysis' for function 'nested_loops':
---- Block Freqs ----
entry = 1.0
for.cond1.preheader = 1.00103
for.cond4.preheader = 5.5222
for.body6 = 18095.19995
for.inc8 = 4.52264
for.inc11 = 0.00109
for.end13 = 0.0
The new analysis gives correct results:
Printing analysis 'Block Frequency Analysis' for function 'nested_loops':
block-frequency-info: nested_loops
- entry: float = 1.0, int = 8
- for.cond1.preheader: float = 4001.0, int = 32007
- for.cond4.preheader: float = 16008001.0, int = 128064007
- for.body6: float = 64048012001.0, int = 512384096007
- for.inc8: float = 16008001.0, int = 128064007
- for.inc11: float = 4001.0, int = 32007
- for.end13: float = 1.0, int = 8
Most importantly, the frequency leaving each loop matches the frequency
entering it.
The new algorithm leverages BlockMass and PositiveFloat to maintain
precision, separates "probability mass distribution" from "loop
scaling", and uses dithering to eliminate probability mass loss. I have
unit tests for these types out of tree, but it was decided in the review
to make the classes private to BlockFrequencyInfoImpl, and try to shrink
them (or remove them entirely) in follow-up commits.
The new algorithm should generally have a complexity advantage over the
old. The previous algorithm was quadratic in the worst case. The new
algorithm is still worst-case quadratic in the presence of irreducible
control flow, but it's linear without it.
The key difference between the old algorithm and the new is that control
flow within a loop is evaluated separately from control flow outside,
limiting propagation of precision problems and allowing loop scale to be
calculated independently of mass distribution. Loops are visited
bottom-up, their loop scales are calculated, and they are replaced by
pseudo-nodes. Mass is then distributed through the function, which is
now a DAG. Finally, loops are revisited top-down to multiply through
the loop scales and the masses distributed to pseudo nodes.
There are some remaining flaws.
- Irreducible control flow isn't modelled correctly. LoopInfo and
MachineLoopInfo ignore irreducible edges, so this algorithm will
fail to scale accordingly. There's a note in the class
documentation about how to get closer. See also the comments in
test/Analysis/BlockFrequencyInfo/irreducible.ll.
- Loop scale is limited to 4096 per loop (2^12) to avoid exhausting
the 64-bit integer precision used downstream.
- The "bias" calculation proposed on llvmdev is *not* incorporated
here. This will be added in a follow-up commit, once comments from
this review have been handled.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@206548 91177308-0d34-0410-b5e6-96231b3b80d8
51 lines
1.4 KiB
LLVM
51 lines
1.4 KiB
LLVM
; RUN: opt < %s -analyze -block-freq | FileCheck %s
|
|
|
|
declare void @g(i32 %x)
|
|
|
|
; CHECK-LABEL: Printing analysis {{.*}} for function 'branch_weight_0':
|
|
; CHECK-NEXT: block-frequency-info: branch_weight_0
|
|
define void @branch_weight_0(i32 %a) {
|
|
; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
|
|
entry:
|
|
br label %for.body
|
|
|
|
; Check that we get 1,4 instead of 0,3.
|
|
; CHECK-NEXT: for.body: float = 4.0,
|
|
for.body:
|
|
%i = phi i32 [ 0, %entry ], [ %inc, %for.body ]
|
|
call void @g(i32 %i)
|
|
%inc = add i32 %i, 1
|
|
%cmp = icmp ugt i32 %inc, %a
|
|
br i1 %cmp, label %for.end, label %for.body, !prof !0
|
|
|
|
; CHECK-NEXT: for.end: float = 1.0, int = [[ENTRY]]
|
|
for.end:
|
|
ret void
|
|
}
|
|
|
|
!0 = metadata !{metadata !"branch_weights", i32 0, i32 3}
|
|
|
|
; CHECK-LABEL: Printing analysis {{.*}} for function 'infinite_loop'
|
|
; CHECK-NEXT: block-frequency-info: infinite_loop
|
|
define void @infinite_loop(i1 %x) {
|
|
; CHECK-NEXT: entry: float = 1.0, int = [[ENTRY:[0-9]+]]
|
|
entry:
|
|
br i1 %x, label %for.body, label %for.end, !prof !1
|
|
|
|
; Check that the loop scale maxes out at 4096, giving 2048 here.
|
|
; CHECK-NEXT: for.body: float = 2048.0,
|
|
for.body:
|
|
%i = phi i32 [ 0, %entry ], [ %inc, %for.body ]
|
|
call void @g(i32 %i)
|
|
%inc = add i32 %i, 1
|
|
br label %for.body
|
|
|
|
; Check that the exit weight is half of entry, since half is lost in the
|
|
; infinite loop above.
|
|
; CHECK-NEXT: for.end: float = 0.5,
|
|
for.end:
|
|
ret void
|
|
}
|
|
|
|
!1 = metadata !{metadata !"branch_weights", i32 1, i32 1}
|