VariableKernel calls into scattered C++ api #44158
Closed
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
Previously, the C++ API only supported calling ops with a gathered TensorOptions object. So even if the VariableKernel took scattered arguments, it had to re-gather them to call into the C++ API. But a diff stacked below this one introduced a scattered API for the C++ frontend. This reaps the benefits and makes sure that if the Variable kernel gets scattered arguments (i.e. it's a c10-full op), then it passes those on without regathering Differential Revision: [D23512538](https://our.internmc.facebook.com/intern/diff/D23512538/) [ghstack-poisoned]
This was referenced Sep 3, 2020
Closed
smessmer
added a commit
that referenced
this pull request
Sep 3, 2020
Previously, the C++ API only supported calling ops with a gathered TensorOptions object. So even if the VariableKernel took scattered arguments, it had to re-gather them to call into the C++ API. But a diff stacked below this one introduced a scattered API for the C++ frontend. This reaps the benefits and makes sure that if the Variable kernel gets scattered arguments (i.e. it's a c10-full op), then it passes those on without regathering Differential Revision: [D23512538](https://our.internmc.facebook.com/intern/diff/D23512538/) ghstack-source-id: 111389736 Pull Request resolved: #44158
💊 CI failures summary and remediationsAs of commit 2cee265 (more details on the Dr. CI page): Commit 2cee265 was recently pushed. Waiting for builds... This comment was automatically generated by Dr. CI (expand for details).Follow this link to opt-out of these comments for your Pull Requests.Please report bugs/suggestions on the GitHub issue tracker or post in the (internal) Dr. CI Users group. This comment has been revised 88 times. |
ezyang
reviewed
Sep 5, 2020
Previously, the C++ API only supported calling ops with a gathered TensorOptions object. So even if the VariableKernel took scattered arguments, it had to re-gather them to call into the C++ API. But a diff stacked below this one introduced a scattered API for the C++ frontend. This reaps the benefits and makes sure that if the Variable kernel gets scattered arguments (i.e. it's a c10-full op), then it passes those on without regathering Differential Revision: [D23512538](https://our.internmc.facebook.com/intern/diff/D23512538/) [ghstack-poisoned]
smessmer
added a commit
that referenced
this pull request
Sep 17, 2020
Pull Request resolved: #44158 Previously, the C++ API only supported calling ops with a gathered TensorOptions object. So even if the VariableKernel took scattered arguments, it had to re-gather them to call into the C++ API. But a diff stacked below this one introduced a scattered API for the C++ frontend. This reaps the benefits and makes sure that if the Variable kernel gets scattered arguments (i.e. it's a c10-full op), then it passes those on without regathering ghstack-source-id: 112287026 Differential Revision: [D23512538](https://our.internmc.facebook.com/intern/diff/D23512538/)
Previously, the C++ API only supported calling ops with a gathered TensorOptions object. So even if the VariableKernel took scattered arguments, it had to re-gather them to call into the C++ API. But a diff stacked below this one introduced a scattered API for the C++ frontend. This reaps the benefits and makes sure that if the Variable kernel gets scattered arguments (i.e. it's a c10-full op), then it passes those on without regathering Differential Revision: [D23512538](https://our.internmc.facebook.com/intern/diff/D23512538/) [ghstack-poisoned]
smessmer
added a commit
that referenced
this pull request
Sep 22, 2020
Pull Request resolved: #44158 Previously, the C++ API only supported calling ops with a gathered TensorOptions object. So even if the VariableKernel took scattered arguments, it had to re-gather them to call into the C++ API. But a diff stacked below this one introduced a scattered API for the C++ frontend. This reaps the benefits and makes sure that if the Variable kernel gets scattered arguments (i.e. it's a c10-full op), then it passes those on without regathering ghstack-source-id: 112590388 Differential Revision: [D23512538](https://our.internmc.facebook.com/intern/diff/D23512538/)
Previously, the C++ API only supported calling ops with a gathered TensorOptions object. So even if the VariableKernel took scattered arguments, it had to re-gather them to call into the C++ API. But a diff stacked below this one introduced a scattered API for the C++ frontend. This reaps the benefits and makes sure that if the Variable kernel gets scattered arguments (i.e. it's a c10-full op), then it passes those on without regathering Differential Revision: [D23512538](https://our.internmc.facebook.com/intern/diff/D23512538/) [ghstack-poisoned]
smessmer
added a commit
that referenced
this pull request
Sep 22, 2020
Pull Request resolved: #44158 Previously, the C++ API only supported calling ops with a gathered TensorOptions object. So even if the VariableKernel took scattered arguments, it had to re-gather them to call into the C++ API. But a diff stacked below this one introduced a scattered API for the C++ frontend. This reaps the benefits and makes sure that if the Variable kernel gets scattered arguments (i.e. it's a c10-full op), then it passes those on without regathering ghstack-source-id: 112608372 Differential Revision: [D23512538](https://our.internmc.facebook.com/intern/diff/D23512538/)
Previously, the C++ API only supported calling ops with a gathered TensorOptions object. So even if the VariableKernel took scattered arguments, it had to re-gather them to call into the C++ API. But a diff stacked below this one introduced a scattered API for the C++ frontend. This reaps the benefits and makes sure that if the Variable kernel gets scattered arguments (i.e. it's a c10-full op), then it passes those on without regathering Differential Revision: [D23512538](https://our.internmc.facebook.com/intern/diff/D23512538/) [ghstack-poisoned]
Previously, the C++ API only supported calling ops with a gathered TensorOptions object. So even if the VariableKernel took scattered arguments, it had to re-gather them to call into the C++ API. But a diff stacked below this one introduced a scattered API for the C++ frontend. This reaps the benefits and makes sure that if the Variable kernel gets scattered arguments (i.e. it's a c10-full op), then it passes those on without regathering Differential Revision: [D23512538](https://our.internmc.facebook.com/intern/diff/D23512538/) [ghstack-poisoned]
smessmer
added a commit
that referenced
this pull request
Sep 24, 2020
Pull Request resolved: #44158 Previously, the C++ API only supported calling ops with a gathered TensorOptions object. So even if the VariableKernel took scattered arguments, it had to re-gather them to call into the C++ API. But a diff stacked below this one introduced a scattered API for the C++ frontend. This reaps the benefits and makes sure that if the Variable kernel gets scattered arguments (i.e. it's a c10-full op), then it passes those on without regathering ghstack-source-id: 112810178 Differential Revision: [D23512538](https://our.internmc.facebook.com/intern/diff/D23512538/)
Previously, the C++ API only supported calling ops with a gathered TensorOptions object. So even if the VariableKernel took scattered arguments, it had to re-gather them to call into the C++ API. But a diff stacked below this one introduced a scattered API for the C++ frontend. This reaps the benefits and makes sure that if the Variable kernel gets scattered arguments (i.e. it's a c10-full op), then it passes those on without regathering Differential Revision: [D23512538](https://our.internmc.facebook.com/intern/diff/D23512538/) [ghstack-poisoned]
smessmer
added a commit
that referenced
this pull request
Sep 24, 2020
Pull Request resolved: #44158 Previously, the C++ API only supported calling ops with a gathered TensorOptions object. So even if the VariableKernel took scattered arguments, it had to re-gather them to call into the C++ API. But a diff stacked below this one introduced a scattered API for the C++ frontend. This reaps the benefits and makes sure that if the Variable kernel gets scattered arguments (i.e. it's a c10-full op), then it passes those on without regathering ghstack-source-id: 112825787 Differential Revision: [D23512538](https://our.internmc.facebook.com/intern/diff/D23512538/)
ezyang
reviewed
Sep 25, 2020
ezyang
approved these changes
Sep 25, 2020
Previously, the C++ API only supported calling ops with a gathered TensorOptions object. So even if the VariableKernel took scattered arguments, it had to re-gather them to call into the C++ API. But a diff stacked below this one introduced a scattered API for the C++ frontend. This reaps the benefits and makes sure that if the Variable kernel gets scattered arguments (i.e. it's a c10-full op), then it passes those on without regathering Differential Revision: [D23512538](https://our.internmc.facebook.com/intern/diff/D23512538/) [ghstack-poisoned]
Previously, the C++ API only supported calling ops with a gathered TensorOptions object. So even if the VariableKernel took scattered arguments, it had to re-gather them to call into the C++ API. But a diff stacked below this one introduced a scattered API for the C++ frontend. This reaps the benefits and makes sure that if the Variable kernel gets scattered arguments (i.e. it's a c10-full op), then it passes those on without regathering Differential Revision: [D23512538](https://our.internmc.facebook.com/intern/diff/D23512538/) [ghstack-poisoned]
@ezyang I added a link to the codegen diff in the description |
Previously, the C++ API only supported calling ops with a gathered TensorOptions object. So even if the VariableKernel took scattered arguments, it had to re-gather them to call into the C++ API. But a diff stacked below this one introduced a scattered API for the C++ frontend. This reaps the benefits and makes sure that if the Variable kernel gets scattered arguments (i.e. it's a c10-full op), then it passes those on without regathering codegen diff: P143616493 Differential Revision: [D23512538](https://our.internmc.facebook.com/intern/diff/D23512538/) [ghstack-poisoned]
smessmer
added a commit
that referenced
this pull request
Sep 25, 2020
Pull Request resolved: #44158 Previously, the C++ API only supported calling ops with a gathered TensorOptions object. So even if the VariableKernel took scattered arguments, it had to re-gather them to call into the C++ API. But a diff stacked below this one introduced a scattered API for the C++ frontend. This reaps the benefits and makes sure that if the Variable kernel gets scattered arguments (i.e. it's a c10-full op), then it passes those on without regathering ghstack-source-id: 112920037 Differential Revision: [D23512538](https://our.internmc.facebook.com/intern/diff/D23512538/)
Previously, the C++ API only supported calling ops with a gathered TensorOptions object. So even if the VariableKernel took scattered arguments, it had to re-gather them to call into the C++ API. But a diff stacked below this one introduced a scattered API for the C++ frontend. This reaps the benefits and makes sure that if the Variable kernel gets scattered arguments (i.e. it's a c10-full op), then it passes those on without regathering codegen diff: P143616493 Differential Revision: [D23512538](https://our.internmc.facebook.com/intern/diff/D23512538/) [ghstack-poisoned]
smessmer
added a commit
that referenced
this pull request
Sep 29, 2020
Pull Request resolved: #44158 Previously, the C++ API only supported calling ops with a gathered TensorOptions object. So even if the VariableKernel took scattered arguments, it had to re-gather them to call into the C++ API. But a diff stacked below this one introduced a scattered API for the C++ frontend. This reaps the benefits and makes sure that if the Variable kernel gets scattered arguments (i.e. it's a c10-full op), then it passes those on without regathering ghstack-source-id: 113120133 Differential Revision: [D23512538](https://our.internmc.facebook.com/intern/diff/D23512538/)
Previously, the C++ API only supported calling ops with a gathered TensorOptions object. So even if the VariableKernel took scattered arguments, it had to re-gather them to call into the C++ API. But a diff stacked below this one introduced a scattered API for the C++ frontend. This reaps the benefits and makes sure that if the Variable kernel gets scattered arguments (i.e. it's a c10-full op), then it passes those on without regathering codegen diff: P143616493 Differential Revision: [D23512538](https://our.internmc.facebook.com/intern/diff/D23512538/) [ghstack-poisoned]
Previously, the C++ API only supported calling ops with a gathered TensorOptions object. So even if the VariableKernel took scattered arguments, it had to re-gather them to call into the C++ API. But a diff stacked below this one introduced a scattered API for the C++ frontend. This reaps the benefits and makes sure that if the Variable kernel gets scattered arguments (i.e. it's a c10-full op), then it passes those on without regathering codegen diff: P143616493 Differential Revision: [D23512538](https://our.internmc.facebook.com/intern/diff/D23512538/) [ghstack-poisoned]
smessmer
added a commit
that referenced
this pull request
Sep 30, 2020
Pull Request resolved: #44158 Previously, the C++ API only supported calling ops with a gathered TensorOptions object. So even if the VariableKernel took scattered arguments, it had to re-gather them to call into the C++ API. But a diff stacked below this one introduced a scattered API for the C++ frontend. This reaps the benefits and makes sure that if the Variable kernel gets scattered arguments (i.e. it's a c10-full op), then it passes those on without regathering ghstack-source-id: 113235799 Differential Revision: [D23512538](https://our.internmc.facebook.com/intern/diff/D23512538/)
Previously, the C++ API only supported calling ops with a gathered TensorOptions object. So even if the VariableKernel took scattered arguments, it had to re-gather them to call into the C++ API. But a diff stacked below this one introduced a scattered API for the C++ frontend. This reaps the benefits and makes sure that if the Variable kernel gets scattered arguments (i.e. it's a c10-full op), then it passes those on without regathering codegen diff: P143616493 Differential Revision: [D23512538](https://our.internmc.facebook.com/intern/diff/D23512538/) [ghstack-poisoned]
smessmer
added a commit
that referenced
this pull request
Oct 1, 2020
Pull Request resolved: #44158 Previously, the C++ API only supported calling ops with a gathered TensorOptions object. So even if the VariableKernel took scattered arguments, it had to re-gather them to call into the C++ API. But a diff stacked below this one introduced a scattered API for the C++ frontend. This reaps the benefits and makes sure that if the Variable kernel gets scattered arguments (i.e. it's a c10-full op), then it passes those on without regathering ghstack-source-id: 113341222 Differential Revision: [D23512538](https://our.internmc.facebook.com/intern/diff/D23512538/)
Previously, the C++ API only supported calling ops with a gathered TensorOptions object. So even if the VariableKernel took scattered arguments, it had to re-gather them to call into the C++ API. But a diff stacked below this one introduced a scattered API for the C++ frontend. This reaps the benefits and makes sure that if the Variable kernel gets scattered arguments (i.e. it's a c10-full op), then it passes those on without regathering codegen diff: P143616493 Differential Revision: [D23512538](https://our.internmc.facebook.com/intern/diff/D23512538/) [ghstack-poisoned]
smessmer
added a commit
that referenced
this pull request
Oct 1, 2020
Pull Request resolved: #44158 Previously, the C++ API only supported calling ops with a gathered TensorOptions object. So even if the VariableKernel took scattered arguments, it had to re-gather them to call into the C++ API. But a diff stacked below this one introduced a scattered API for the C++ frontend. This reaps the benefits and makes sure that if the Variable kernel gets scattered arguments (i.e. it's a c10-full op), then it passes those on without regathering ghstack-source-id: 113355690 Differential Revision: [D23512538](https://our.internmc.facebook.com/intern/diff/D23512538/)
|
This pull request has been merged in 82cc86b. |
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.
Stack from ghstack:
Previously, the C++ API only supported calling ops with a gathered TensorOptions object. So even if the VariableKernel took scattered arguments,
it had to re-gather them to call into the C++ API. But a diff stacked below this one introduced a scattered API for the C++ frontend.
This reaps the benefits and makes sure that if the Variable kernel gets scattered arguments (i.e. it's a c10-full op), then it passes those on without regathering
codegen diff: P143616493
Differential Revision: D23512538