[mypyc] Inline increfs and decrefs in commonly executed blocks #11540
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
These operations are performance-critical, but inlining everywhere can slow down compilation a lot, so we only inline them outside error handlers (and other rarely executed code paths). This still can slow compilation by 10-15%, but I think that we just need to live with it, since the performance gains are impressive. We can perhaps claw back some of the loss by optimizing away redundant increfs/decrefs. Also parallel compilation would make this much less significant. This can speed up the richards benchmark by 65% (!). With this change: ``` running richards ........... interpreted: 0.181880s (avg of 6 iterations; stdev 0.91%) compiled: 0.005314s (avg of 6 iterations; stdev 1.2%) compiled is 34.229x faster ``` Using master: ``` running richards ........... interpreted: 0.182124s (avg of 6 iterations; stdev 2.1%) compiled: 0.008794s (avg of 6 iterations; stdev 1.9%) compiled is 20.710x faster ``` Also, this makes the int_list microbenchmark up to 80% faster. Compiled mypy was also around 3% faster.
|
Partially related to #11547. |
msullivan
approved these changes
Nov 14, 2021
tushar-deepsource
pushed a commit
to DeepSourceCorp/mypy
that referenced
this pull request
Jan 20, 2022
…n#11540) These operations are performance-critical, but inlining everywhere can slow down compilation a lot, so we only inline them outside error handlers (and other rarely executed code paths). This still can slow compilation by 10-15%, but I think that we just need to live with it, since the performance gains are impressive. We can perhaps claw back some of the loss by optimizing away redundant increfs/decrefs. Also parallel compilation would make this much less significant. This can speed up the richards benchmark by 65% (!). With this change: ``` running richards ........... interpreted: 0.181880s (avg of 6 iterations; stdev 0.91%) compiled: 0.005314s (avg of 6 iterations; stdev 1.2%) compiled is 34.229x faster ``` Using master: ``` running richards ........... interpreted: 0.182124s (avg of 6 iterations; stdev 2.1%) compiled: 0.008794s (avg of 6 iterations; stdev 1.9%) compiled is 20.710x faster ``` Also, this makes the int_list microbenchmark up to 80% faster. Compiled mypy was also around 3% faster.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
These operations are performance-critical, but inlining everywhere
can slow down compilation a lot, so we only inline them outside error
handlers (and other rarely executed code paths).
This still can slow compilation by 10-15%, but I think that we just need
to live with it, since the performance gains are impressive. We can perhaps
claw back some of the loss by optimizing away redundant increfs/decrefs.
Also parallel compilation would make this much less significant.
This can speed up the richards benchmark by 65% (!).
With this change:
Using master:
Also, this makes the int_list microbenchmark up to 80% faster.
Compiled mypy was also around 3% faster.