Do more aggressive lambda lifting#1886
Conversation
97f8d5f to
6f67ac7
Compare
83fff63 to
418e0ed
Compare
418e0ed to
580b603
Compare
580b603 to
e76cef3
Compare
e76cef3 to
b59bd3e
Compare
b59bd3e to
25929ef
Compare
|
This seems to result in a modest speedup on average, including on |
No, I'm using a workaround. |
25929ef to
9e363d1
Compare
|
Should I guard this by an |
|
Yes, you should add a flag. |
3f94285 to
49cde7c
Compare
|
I re-ran the CI a few times to double-check whether this new pass increases the compilation time. The compilation time seems to oscillate around ±2 %, so I would say it’s in the noise. |
|
You should probably rebase and rerun the bench now that #1935 is merged to check that this PR still improves perfs |
65cf622 to
0561523
Compare
|
@OlivierNicole, there might be some improvement and the size increase seems small. Do you want to rebase the PR one more time and have the feature under a flag ? That way, we can merge instead of letting the PR rot. |
|
Yes, I intend to do this; I just haven’t found the time to squeeze it between my other tasks yet… |
0fa87ae to
77b8921
Compare
|
The test failures seem unrelated to this PR, as they also show up on master. |
|
Sorry for the delay in coming back to this. I have put the feature behind a flag. |
|
Please a small test for this, probably in compiler/tests-compiler/ |
|
Done. The CI failure seems unrelated. |
61e2268 to
e3c5496
Compare
With @vouillon we realized that the `Lambda_lifting_simple` pass that is performed by double translation makes some programs significantly faster. We measured roughly a 1.45 speedup on a large (proprietary) Bonsai benchmark. Presumably V8 is much faster with more toplevel functions and less nested closures.
e3c5496 to
a5f3560
Compare
With --enable lambda-lift-all, the driver runs Lambda_lifting_simple
before Specialize.f, which still uses the Global_flow info computed on
the pre-lifting program. The lifting pass forks the free variables of
lifted closures, so an inexact call to such a variable makes
Global_flow.function_arity index out of bounds and crashes the
compiler:
Invalid_argument("index out of bounds")
Raised at Code.Var.Tbl.get (code.ml:272)
Called from Global_flow.function_arity (global_flow.ml:819)
Called from Driver.effects_and_exact_calls (driver.ml:206)
Called from Specialize.specialize_apply ...
The test encodes the intended behavior (the program compiles and
prints len=3) and fails until the driver is fixed, e.g. by lifting
after the flow-info consumers as in the CPS branch.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Lambda_lifting_simple forks the free variables of lifted closures, so
the Global_flow info computed before lifting does not cover the
lifted program: Specialize.f would call Global_flow.function_arity on
a forked variable and crash with Invalid_argument("index out of
bounds").
Run the lifting at the end of the effects-disabled branch instead,
after Specialize.f and collects_shapes, mirroring how the CPS branch
lambda-lifts only after Effects.f. This also lets specialization see
the richer pre-lifting flow information.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
a5f3560 to
b2ac6ad
Compare
With @vouillon we realized that the
Lambda_lifting_simplepass that is performed by double translation makes some programs significantly faster. We measured roughly a 1.45 speedup on a large (proprietary) Bonsai benchmark. Presumably V8 is much faster with more toplevel functions and less nested closures.Making this a draft PR for now because:
We probably need to do some measurements before merging. (And maybe with other engines.)