Avoid operator creation in transpiler #12826
Merged
Conversation
This file contains 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
jakelishman
added
Changelog: New Feature
jakelishman
requested review from
alexanderivrii,
ShellyGarion and
a team
as code owners
|
One or more of the following people are relevant to this code:
|
This removes very nearly all of the use of `DAGOpNode.op` in the default transpiler paths. The sole exception is in `InverseCancellation`, which currently would involve some quite awkward gymnastics for little near-term benefit. The pass should move fully to Rust soon, making it not worth the effort. Most of the tricks here involve using the knowledge that most operations will involve only Rust-space standard gates, and that these cannot be control-flow operations.
jakelishman
force-pushed
the
avoid-operation-creation
branch
from
d605106 to
991263a
Compare
|
One or more of the following people are relevant to this code:
|
Pull Request Test Coverage Report for Build 10184959106Details
💛 - Coveralls |
mtreinish
previously approved these changes
Jul 31, 2024
There was a problem hiding this comment.
Overall this LGTM, I'm happy to wrap up this thread of workarounds before we start migrating passes to rust (which will be doing essentially this but without the language barrier). Just one inline comment but something that's applicable to a bunch of places, basically we can use the name of a control flow op instead of an isinstance check to defer the op creation until we actually use it. Although as those are always PyInstruction it doesn't really matter from a performance perspective as we always have a cached pyobject at that point. So I'm fine merging this as-is if you don't think it's important. Feel free to just enqueue this for merge in that case.
| @@ -37,7 +37,7 @@ class MultiQEncountered(Exception): | |||
|
|
|||
| def _visit(dag, weight, wire_map): | |||
| for node in dag.op_nodes(include_directives=False): | |||
| if isinstance(node.op, ControlFlowOp): | |||
| if node.is_control_flow(): | |||
| if isinstance(node.op, ForLoopOp): | |||
There was a problem hiding this comment.
You could avoid the op usage here too if you did:
Suggested change
| if isinstance(node.op, ForLoopOp): | |
| if node.name == "for_loop": |
mtreinish
approved these changes
Jul 31, 2024
mtreinish
added
the
stable backport potential
mergify bot
pushed a commit
that referenced
this pull request
Jul 31, 2024
* Avoid operator creation in transpiler This removes very nearly all of the use of `DAGOpNode.op` in the default transpiler paths. The sole exception is in `InverseCancellation`, which currently would involve some quite awkward gymnastics for little near-term benefit. The pass should move fully to Rust soon, making it not worth the effort. Most of the tricks here involve using the knowledge that most operations will involve only Rust-space standard gates, and that these cannot be control-flow operations. * Fix `HighLevelSynthesis` fast path --------- Co-authored-by: Matthew Treinish <mtreinish@kortar.org> (cherry picked from commit 0afb06e)
github-merge-queue bot
pushed a commit
that referenced
this pull request
Jul 31, 2024
* Avoid operator creation in transpiler This removes very nearly all of the use of `DAGOpNode.op` in the default transpiler paths. The sole exception is in `InverseCancellation`, which currently would involve some quite awkward gymnastics for little near-term benefit. The pass should move fully to Rust soon, making it not worth the effort. Most of the tricks here involve using the knowledge that most operations will involve only Rust-space standard gates, and that these cannot be control-flow operations. * Fix `HighLevelSynthesis` fast path --------- Co-authored-by: Matthew Treinish <mtreinish@kortar.org> (cherry picked from commit 0afb06e) Co-authored-by: Jake Lishman <jake.lishman@ibm.com>
Procatv
pushed a commit
to Procatv/qiskit-terra-catherines
that referenced
this pull request
Aug 1, 2024
* Avoid operator creation in transpiler This removes very nearly all of the use of `DAGOpNode.op` in the default transpiler paths. The sole exception is in `InverseCancellation`, which currently would involve some quite awkward gymnastics for little near-term benefit. The pass should move fully to Rust soon, making it not worth the effort. Most of the tricks here involve using the knowledge that most operations will involve only Rust-space standard gates, and that these cannot be control-flow operations. * Fix `HighLevelSynthesis` fast path --------- Co-authored-by: Matthew Treinish <mtreinish@kortar.org>
9 tasks
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.
Summary
This removes very nearly all of the use of
DAGOpNode.opin the default transpiler paths. The sole exception is inInverseCancellation, which currently would involve some quite awkward gymnastics for little near-term benefit. The pass should move fully to Rust soon, making it not worth the effort.Most of the tricks here involve using the knowledge that most operations will involve only Rust-space standard gates, and that these cannot be control-flow operations.
Details and comments
This always includes a reno for a couple of the new methods added to
DAGOpNodeandCircuitInstruction.I measured this as being ~25% faster for some toy workloads at transpilation levels 0 and 1, probably mostly driven by the new methods letting us avoid a lot of
isinstancechecks in most cases.