b21cef37e4
This PR sorts the declarations fed into ElimDeadBranches in increasing
size. This can improve performance when we are dealing with a lot of
iterations.
The motivation for this change is as follows. Currently the algorithm
for doing one step of abstract interpretation is:
```
for decl in scc do
interpDecl
if summaryChanged decl then
return true
return false
```
whenever we return true we run another step. Now suppose we are in a
situation where we have an SCC with one big decl in the front and then
`n` small ones afterwards. For each time that the small ones change
their summary, we will re-run analysis of the big one in the front.
Currently the ordering is basically at "random" based on how other
compilers inject things into the SCC. This change ensures the behavior
is consistent and at least somewhat intelligent. By putting the small
declarations first, whenever we trigger a rerun of the loop we bias
analyzing the small declarations first, thus decreasing run time.
Note that this change does not have much effect on the current pipeline
because: We usually construct the SCCs in a way such that small ones
happen to be in front anyways. However, with upcomping changes on
specialization this is about to change.
28 lines
889 B
Text
28 lines
889 B
Text
[Compiler.result] size: 1
|
||
def g (α : ◾) (n : Nat) (a : lcAny) (b : lcAny) (f : lcAny → lcAny) : lcAny :=
|
||
let _x.1 := g._redArg n a f;
|
||
return _x.1
|
||
[Compiler.result] size: 9
|
||
def g._redArg (n : Nat) (a : lcAny) (f : lcAny → lcAny) : lcAny :=
|
||
let zero := 0;
|
||
let isZero := Nat.decEq n zero;
|
||
cases isZero : lcAny
|
||
| Bool.true =>
|
||
return a
|
||
| Bool.false =>
|
||
let one := 1;
|
||
let n.1 := Nat.sub n one;
|
||
let _x.2 := g._redArg n.1 a f;
|
||
let _x.3 := f _x.2;
|
||
return _x.3
|
||
[Compiler.result] size: 1
|
||
def h._closed_0 : Nat → Nat :=
|
||
let _x.1 := double;
|
||
return _x.1
|
||
[Compiler.result] size: 4
|
||
def h (n : Nat) (a : Nat) : Nat :=
|
||
let _x.1 := h._closed_0;
|
||
let _x.2 := g._redArg n a _x.1;
|
||
let _x.3 := g._redArg a n _x.1;
|
||
let _x.4 := Nat.add _x.2 _x.3;
|
||
return _x.4
|