Tests for fallback boxed dispatch (including TLS mode) by ezyang · Pull Request #26719 · pytorch/pytorch

ezyang · 2019-09-24T15:17:55Z

Stack from ghstack:

Tests for fallback boxed dispatch (including TLS mode) #26719 Tests for fallback boxed dispatch (including TLS mode)

This PR adds a pair of tests for fallback boxed dispatch, exercising two different ways you might use it: (1) to implement a "wrapper" tensor type (e.g., LazyTensor, NestedTensor), and (2) to implement a toggleable "mode" (e.g., Profiling, Tracing). Both implement the most trivial possible implementations of their type: they "wrap" a real tensor simply forward along to the real implementation. This PR also adds the necessary feature support for toggleable mode, which is in the original generic dispatch abstraction design, but was not previously implemented. I had not originally intended to add this, but it turns out writing a new "mode" is a lot simpler than writing a "wrapper" type, so I ended up writing the mode version first.

General structure of the PR:

Add two new testing tensor type ids, TESTING_ONLY_GenericWrapperTensorId and TESTING_ONLY_GenericModeTensorId, which our tests use. They might find other use in other tests if necessary.
Add support for toggling the availability of TESTING_ONLY_GenericModeTensorId. Introduces a new thread local variable accessible by tls_local_tensor_type_set() which is considered as part of dispatch.
The mode fallback is very simple: it increments a counter and then passes on the call to the underlying kernel by invoking the JIT.
The wrapper fallback is more complex: it parses the arguments, unwrapping any wrapped tensor arguments, then invokes the JIT, and then rewraps the outputs.

The examples here are somewhat simplistic; there are a number of engineering improvements that could be applied. We could save these for later (landing this patch to get immediate testing), or incorporate them into this patch:

getOperator is horrible. Bram Wasti and I discussed a plan for how to make this easier, by simply refactoring the JIT interface.
GenericWrapperTensorImpl doesn't populate all of its fields accurately. Most notably, size is not setup correctly.
generic_wrapper_fallback should handle tensor lists in arguments and returns properly.

One pitfall: fallback dispatch only works with non-c10 code. That's why I test using batch_norm.

Signed-off-by: Edward Z. Yang ezyang@fb.com

Differential Revision: D17549624

Signed-off-by: Edward Z. Yang <ezyang@fb.com> [ghstack-poisoned]

Signed-off-by: Edward Z. Yang <ezyang@fb.com> ghstack-source-id: 6d0ec71 Pull Request resolved: #26719

Signed-off-by: Edward Z. Yang <ezyang@fb.com> Differential Revision: [D17549624](https://our.internmc.facebook.com/intern/diff/D17549624) [ghstack-poisoned]

Signed-off-by: Edward Z. Yang <ezyang@fb.com> ghstack-source-id: c52f6f9 Pull Request resolved: #26719

Signed-off-by: Edward Z. Yang <ezyang@fb.com> Differential Revision: [D17549624](https://our.internmc.facebook.com/intern/diff/D17549624) [ghstack-poisoned]

Signed-off-by: Edward Z. Yang <ezyang@fb.com> ghstack-source-id: 92d0ced Pull Request resolved: #26719

Signed-off-by: Edward Z. Yang <ezyang@fb.com> Differential Revision: [D17549624](https://our.internmc.facebook.com/intern/diff/D17549624) [ghstack-poisoned]

Signed-off-by: Edward Z. Yang <ezyang@fb.com> ghstack-source-id: 3da260e Pull Request resolved: #26719

…dispatch." Signed-off-by: Edward Z. Yang <ezyang@fb.com> Differential Revision: [D17549624](https://our.internmc.facebook.com/intern/diff/D17549624) [ghstack-poisoned]

Signed-off-by: Edward Z. Yang <ezyang@fb.com> ghstack-source-id: d792770 Pull Request resolved: #26719

This PR adds a pair of tests for fallback boxed dispatch, exercising two different ways you might use it: (1) to implement a "wrapper" tensor type (e.g., LazyTensor, NestedTensor), and (2) to implement a toggleable "mode" (e.g., Profiling, Tracing). Both implement the most trivial possible implementations of their type: they "wrap" a real tensor simply forward along to the real implementation. This PR also adds the necessary feature support for toggleable mode, which is in the original generic dispatch abstraction design, but was not previously implemented. I had not originally intended to add this, but it turns out writing a new "mode" is a lot simpler than writing a "wrapper" type, so I ended up writing the mode version first. General structure of the PR: * Add two new testing tensor type ids, `TESTING_ONLY_GenericWrapperTensorId` and `TESTING_ONLY_GenericModeTensorId`, which our tests use. They might find other use in other tests if necessary. * Add support for toggling the availability of `TESTING_ONLY_GenericModeTensorId`. Introduces a new thread local variable accessible by `tls_included_tensor_type_set()` which is considered as part of dispatch. (It is a little goofy that we now have to do two TLS accesses; I'm not too sure if there's a way to avoid this.) * There is a screed about how modes (Profiling/Tracing) are different from hybrid wrapper-modes (Variable) * The mode fallback is very simple: it increments a counter and then passes on the call to the underlying kernel by invoking the JIT. * The wrapper fallback is more complex: it parses the arguments, unwrapping any wrapped tensor arguments, then invokes the JIT, and then rewraps the outputs. The examples here are somewhat simplistic; there are a number of engineering improvements that could be applied. We could save these for later (landing this patch to get immediate testing), or incorporate them into this patch: * `getOperator` is horrible. Bram Wasti and I discussed a plan for how to make this easier, by simply refactoring the JIT interface. * `GenericWrapperTensorImpl` doesn't populate all of its fields accurately. Most notably, size is not setup correctly. * `generic_wrapper_fallback` should handle tensor lists in arguments and returns properly. One pitfall: fallback dispatch only works with non-c10 code. That's why I test using `batch_norm`. Signed-off-by: Edward Z. Yang <ezyang@fb.com> Differential Revision: [D17549624](https://our.internmc.facebook.com/intern/diff/D17549624) [ghstack-poisoned]

Signed-off-by: Edward Z. Yang <ezyang@fb.com> ghstack-source-id: 512eb4b Pull Request resolved: #26719

zdevito

Generally looks good. I have a few medium level comments about the API and use of thread locals.

zdevito · 2019-10-01T00:16:30Z

c10/core/impl/LocalTensorTypeSet.cpp


 #endif

+void set_enabled_via_excluded(TensorTypeId tid, bool enabled) {


The names of these functions are confusing to me. The caller still needs to understand that thefinal set will be (tensor_properties | included) - excluded but then there is also a second translation between how this function affects included/excluded. Wouldn't it make more sense to just have it follow the set operations directely, excluded.add, excluded.remove, included.add, included.remove.

zdevito · 2019-10-01T00:18:58Z

c10/core/impl/LocalTensorTypeSet.h

 C10_API void tls_variable_set_enabled(bool enabled);
-C10_API TensorTypeSet tls_excluded_tensor_type_set();
+
+C10_API bool TESTING_ONLY_tls_generic_mode_is_enabled();


Is it the best idea to have separate functions here for every key? I am concerned that over time non-simple operations on the tensor set can end up here, but I'd prefer the opposite: that the only thing you can do to a key is to enable it in a thread or in tensors properties.

Solves my giant comment problem too.

zdevito · 2019-10-01T00:22:43Z

c10/core/impl/LocalTensorTypeSet.cpp


 // NB: Zero initialized!
 thread_local uint64_t raw_excluded;
+thread_local uint64_t raw_included;


These are used adjacent to each other in dispatch, so it would be more efficient if they were in a single thread_local struct. Otherwise there is a sequence of like 4 loads to get to each one. I would imagine this struct would grow into the generic thread-local dispatch state that the chain of responsibility would need to call super as well.

…ng TLS mode)" This PR adds a pair of tests for fallback boxed dispatch, exercising two different ways you might use it: (1) to implement a "wrapper" tensor type (e.g., LazyTensor, NestedTensor), and (2) to implement a toggleable "mode" (e.g., Profiling, Tracing). Both implement the most trivial possible implementations of their type: they "wrap" a real tensor simply forward along to the real implementation. This PR also adds the necessary feature support for toggleable mode, which is in the original generic dispatch abstraction design, but was not previously implemented. I had not originally intended to add this, but it turns out writing a new "mode" is a lot simpler than writing a "wrapper" type, so I ended up writing the mode version first. General structure of the PR: * Add two new testing tensor type ids, `TESTING_ONLY_GenericWrapperTensorId` and `TESTING_ONLY_GenericModeTensorId`, which our tests use. They might find other use in other tests if necessary. * Add support for toggling the availability of `TESTING_ONLY_GenericModeTensorId`. Introduces a new thread local variable accessible by `tls_included_tensor_type_set()` which is considered as part of dispatch. (It is a little goofy that we now have to do two TLS accesses; I'm not too sure if there's a way to avoid this.) * There is a screed about how modes (Profiling/Tracing) are different from hybrid wrapper-modes (Variable) * The mode fallback is very simple: it increments a counter and then passes on the call to the underlying kernel by invoking the JIT. * The wrapper fallback is more complex: it parses the arguments, unwrapping any wrapped tensor arguments, then invokes the JIT, and then rewraps the outputs. The examples here are somewhat simplistic; there are a number of engineering improvements that could be applied. We could save these for later (landing this patch to get immediate testing), or incorporate them into this patch: * `getOperator` is horrible. Bram Wasti and I discussed a plan for how to make this easier, by simply refactoring the JIT interface. * `GenericWrapperTensorImpl` doesn't populate all of its fields accurately. Most notably, size is not setup correctly. * `generic_wrapper_fallback` should handle tensor lists in arguments and returns properly. One pitfall: fallback dispatch only works with non-c10 code. That's why I test using `batch_norm`. Signed-off-by: Edward Z. Yang <ezyang@fb.com> Differential Revision: [D17549624](https://our.internmc.facebook.com/intern/diff/D17549624) [ghstack-poisoned]

Signed-off-by: Edward Z. Yang <ezyang@fb.com> ghstack-source-id: 1b16e64 Pull Request resolved: #26719

…ch (including TLS mode)" This PR adds a pair of tests for fallback boxed dispatch, exercising two different ways you might use it: (1) to implement a "wrapper" tensor type (e.g., LazyTensor, NestedTensor), and (2) to implement a toggleable "mode" (e.g., Profiling, Tracing). Both implement the most trivial possible implementations of their type: they "wrap" a real tensor simply forward along to the real implementation. This PR also adds the necessary feature support for toggleable mode, which is in the original generic dispatch abstraction design, but was not previously implemented. I had not originally intended to add this, but it turns out writing a new "mode" is a lot simpler than writing a "wrapper" type, so I ended up writing the mode version first. General structure of the PR: * Add two new testing tensor type ids, `TESTING_ONLY_GenericWrapperTensorId` and `TESTING_ONLY_GenericModeTensorId`, which our tests use. They might find other use in other tests if necessary. * Add support for toggling the availability of `TESTING_ONLY_GenericModeTensorId`. Introduces a new thread local variable accessible by `tls_local_tensor_type_set()` which is considered as part of dispatch. * The mode fallback is very simple: it increments a counter and then passes on the call to the underlying kernel by invoking the JIT. * The wrapper fallback is more complex: it parses the arguments, unwrapping any wrapped tensor arguments, then invokes the JIT, and then rewraps the outputs. The examples here are somewhat simplistic; there are a number of engineering improvements that could be applied. We could save these for later (landing this patch to get immediate testing), or incorporate them into this patch: * `getOperator` is horrible. Bram Wasti and I discussed a plan for how to make this easier, by simply refactoring the JIT interface. * `GenericWrapperTensorImpl` doesn't populate all of its fields accurately. Most notably, size is not setup correctly. * `generic_wrapper_fallback` should handle tensor lists in arguments and returns properly. One pitfall: fallback dispatch only works with non-c10 code. That's why I test using `batch_norm`. Signed-off-by: Edward Z. Yang <ezyang@fb.com> Differential Revision: [D17549624](https://our.internmc.facebook.com/intern/diff/D17549624) [ghstack-poisoned]

This PR adds a pair of tests for fallback boxed dispatch, exercising two different ways you might use it: (1) to implement a "wrapper" tensor type (e.g., LazyTensor, NestedTensor), and (2) to implement a toggleable "mode" (e.g., Profiling, Tracing). Both implement the most trivial possible implementations of their type: they "wrap" a real tensor simply forward along to the real implementation. This PR also adds the necessary feature support for toggleable mode, which is in the original generic dispatch abstraction design, but was not previously implemented. I had not originally intended to add this, but it turns out writing a new "mode" is a lot simpler than writing a "wrapper" type, so I ended up writing the mode version first. General structure of the PR: * Add two new testing tensor type ids, `TESTING_ONLY_GenericWrapperTensorId` and `TESTING_ONLY_GenericModeTensorId`, which our tests use. They might find other use in other tests if necessary. * Add support for toggling the availability of `TESTING_ONLY_GenericModeTensorId`. Introduces a new thread local variable accessible by `tls_local_tensor_type_set()` which is considered as part of dispatch. * The mode fallback is very simple: it increments a counter and then passes on the call to the underlying kernel by invoking the JIT. * The wrapper fallback is more complex: it parses the arguments, unwrapping any wrapped tensor arguments, then invokes the JIT, and then rewraps the outputs. The examples here are somewhat simplistic; there are a number of engineering improvements that could be applied. We could save these for later (landing this patch to get immediate testing), or incorporate them into this patch: * `getOperator` is horrible. Bram Wasti and I discussed a plan for how to make this easier, by simply refactoring the JIT interface. * `GenericWrapperTensorImpl` doesn't populate all of its fields accurately. Most notably, size is not setup correctly. * `generic_wrapper_fallback` should handle tensor lists in arguments and returns properly. One pitfall: fallback dispatch only works with non-c10 code. That's why I test using `batch_norm`. Signed-off-by: Edward Z. Yang <ezyang@fb.com> Differential Revision: [D17549624](https://our.internmc.facebook.com/intern/diff/D17549624) [ghstack-poisoned]

Signed-off-by: Edward Z. Yang <ezyang@fb.com> ghstack-source-id: e8b7d08 Pull Request resolved: #26719

This PR introduces a dirt simple registration API to allow custom Tensors. The API exposed aims to avoid code complexity and compilation times. It makes an explicit trade-off supporting developer productivity over compute efficiency. Couple of reasons to have this: - Tests are easier to write (see #26719) - It addresses the limit for the 64 possible TensorTypeId's we can have with TensorTypeSet - Drastically reduces mental overhead for folks working in research wanting to add a Tensor - Allows entirely decoupled static registration for tensors defined in separate repos (planned usage in pytorch/sparse) [ghstack-poisoned]

This PR adds a pair of tests for fallback boxed dispatch, exercising two different ways you might use it: (1) to implement a "wrapper" tensor type (e.g., LazyTensor, NestedTensor), and (2) to implement a toggleable "mode" (e.g., Profiling, Tracing). Both implement the most trivial possible implementations of their type: they "wrap" a real tensor simply forward along to the real implementation. This PR also adds the necessary feature support for toggleable mode, which is in the original generic dispatch abstraction design, but was not previously implemented. I had not originally intended to add this, but it turns out writing a new "mode" is a lot simpler than writing a "wrapper" type, so I ended up writing the mode version first. General structure of the PR: * Add two new testing tensor type ids, `TESTING_ONLY_GenericWrapperTensorId` and `TESTING_ONLY_GenericModeTensorId`, which our tests use. They might find other use in other tests if necessary. * Add support for toggling the availability of `TESTING_ONLY_GenericModeTensorId`. Introduces a new thread local variable accessible by `tls_local_tensor_type_set()` which is considered as part of dispatch. * The mode fallback is very simple: it increments a counter and then passes on the call to the underlying kernel by invoking the JIT. * The wrapper fallback is more complex: it parses the arguments, unwrapping any wrapped tensor arguments, then invokes the JIT, and then rewraps the outputs. The examples here are somewhat simplistic; there are a number of engineering improvements that could be applied. We could save these for later (landing this patch to get immediate testing), or incorporate them into this patch: * `getOperator` is horrible. Bram Wasti and I discussed a plan for how to make this easier, by simply refactoring the JIT interface. * `GenericWrapperTensorImpl` doesn't populate all of its fields accurately. Most notably, size is not setup correctly. * `generic_wrapper_fallback` should handle tensor lists in arguments and returns properly. One pitfall: fallback dispatch only works with non-c10 code. That's why I test using `batch_norm`. Signed-off-by: Edward Z. Yang <ezyang@fb.com> Differential Revision: [D17549624](https://our.internmc.facebook.com/intern/diff/D17549624) [ghstack-poisoned]

Signed-off-by: Edward Z. Yang <ezyang@fb.com> ghstack-source-id: 9e3ebf7 Pull Request resolved: #26719

facebook-github-bot · 2019-10-09T20:38:36Z

@ezyang merged this pull request in d70f8dd.

Summary: Pull Request resolved: pytorch/pytorch#26719 This PR adds a pair of tests for fallback boxed dispatch, exercising two different ways you might use it: (1) to implement a "wrapper" tensor type (e.g., LazyTensor, NestedTensor), and (2) to implement a toggleable "mode" (e.g., Profiling, Tracing). Both implement the most trivial possible implementations of their type: they "wrap" a real tensor simply forward along to the real implementation. This PR also adds the necessary feature support for toggleable mode, which is in the original generic dispatch abstraction design, but was not previously implemented. I had not originally intended to add this, but it turns out writing a new "mode" is a lot simpler than writing a "wrapper" type, so I ended up writing the mode version first. General structure of the PR: * Add two new testing tensor type ids, `TESTING_ONLY_GenericWrapperTensorId` and `TESTING_ONLY_GenericModeTensorId`, which our tests use. They might find other use in other tests if necessary. * Add support for toggling the availability of `TESTING_ONLY_GenericModeTensorId`. Introduces a new thread local variable accessible by `tls_local_tensor_type_set()` which is considered as part of dispatch. * The mode fallback is very simple: it increments a counter and then passes on the call to the underlying kernel by invoking the JIT. * The wrapper fallback is more complex: it parses the arguments, unwrapping any wrapped tensor arguments, then invokes the JIT, and then rewraps the outputs. The examples here are somewhat simplistic; there are a number of engineering improvements that could be applied. We could save these for later (landing this patch to get immediate testing), or incorporate them into this patch: * `getOperator` is horrible. Bram Wasti and I discussed a plan for how to make this easier, by simply refactoring the JIT interface. * `GenericWrapperTensorImpl` doesn't populate all of its fields accurately. Most notably, size is not setup correctly. * `generic_wrapper_fallback` should handle tensor lists in arguments and returns properly. One pitfall: fallback dispatch only works with non-c10 code. That's why I test using `batch_norm`. Signed-off-by: Edward Z. Yang <ezyang@fb.com> Differential Revision: D17549624 Test Plan: Imported from OSS Pulled By: ezyang fbshipit-source-id: 57dbdd8d6812a66082aa6db2934c8edcda340ea6

Summary: Pull Request resolved: pytorch#26719 This PR adds a pair of tests for fallback boxed dispatch, exercising two different ways you might use it: (1) to implement a "wrapper" tensor type (e.g., LazyTensor, NestedTensor), and (2) to implement a toggleable "mode" (e.g., Profiling, Tracing). Both implement the most trivial possible implementations of their type: they "wrap" a real tensor simply forward along to the real implementation. This PR also adds the necessary feature support for toggleable mode, which is in the original generic dispatch abstraction design, but was not previously implemented. I had not originally intended to add this, but it turns out writing a new "mode" is a lot simpler than writing a "wrapper" type, so I ended up writing the mode version first. General structure of the PR: * Add two new testing tensor type ids, `TESTING_ONLY_GenericWrapperTensorId` and `TESTING_ONLY_GenericModeTensorId`, which our tests use. They might find other use in other tests if necessary. * Add support for toggling the availability of `TESTING_ONLY_GenericModeTensorId`. Introduces a new thread local variable accessible by `tls_local_tensor_type_set()` which is considered as part of dispatch. * The mode fallback is very simple: it increments a counter and then passes on the call to the underlying kernel by invoking the JIT. * The wrapper fallback is more complex: it parses the arguments, unwrapping any wrapped tensor arguments, then invokes the JIT, and then rewraps the outputs. The examples here are somewhat simplistic; there are a number of engineering improvements that could be applied. We could save these for later (landing this patch to get immediate testing), or incorporate them into this patch: * `getOperator` is horrible. Bram Wasti and I discussed a plan for how to make this easier, by simply refactoring the JIT interface. * `GenericWrapperTensorImpl` doesn't populate all of its fields accurately. Most notably, size is not setup correctly. * `generic_wrapper_fallback` should handle tensor lists in arguments and returns properly. One pitfall: fallback dispatch only works with non-c10 code. That's why I test using `batch_norm`. Signed-off-by: Edward Z. Yang <ezyang@fb.com> Differential Revision: D17549624 Test Plan: Imported from OSS Pulled By: ezyang fbshipit-source-id: 57dbdd8d6812a66082aa6db2934c8edcda340ea6

Tests for fallback boxed dispatch.

9af4afa

Signed-off-by: Edward Z. Yang <ezyang@fb.com> [ghstack-poisoned]

pytorchbot added the module: internals Related to internal abstractions in c10 and ATen label Sep 24, 2019

ezyang added a commit that referenced this pull request Sep 24, 2019

Tests for fallback boxed dispatch.

8c94c5d

Signed-off-by: Edward Z. Yang <ezyang@fb.com> ghstack-source-id: 6d0ec71 Pull Request resolved: #26719

Update on "Tests for fallback boxed dispatch."

6ecf4d4

Signed-off-by: Edward Z. Yang <ezyang@fb.com> Differential Revision: [D17549624](https://our.internmc.facebook.com/intern/diff/D17549624) [ghstack-poisoned]

ezyang mentioned this pull request Sep 25, 2019

Add some missing constructors to IValue. #26806

Closed

ezyang added a commit that referenced this pull request Sep 25, 2019

Tests for fallback boxed dispatch.

4c7048f

Signed-off-by: Edward Z. Yang <ezyang@fb.com> ghstack-source-id: c52f6f9 Pull Request resolved: #26719

ezyang mentioned this pull request Sep 25, 2019

Make resize_as_ generic, so XLA works. #26809

Closed

Update on "Tests for fallback boxed dispatch."

65c00ef

Signed-off-by: Edward Z. Yang <ezyang@fb.com> Differential Revision: [D17549624](https://our.internmc.facebook.com/intern/diff/D17549624) [ghstack-poisoned]

Update on "Tests for fallback boxed dispatch."

25ba71d

Signed-off-by: Edward Z. Yang <ezyang@fb.com> Differential Revision: [D17549624](https://our.internmc.facebook.com/intern/diff/D17549624) [ghstack-poisoned]

Update on "Tests for fallback boxed dispatch."

6a35e96

Signed-off-by: Edward Z. Yang <ezyang@fb.com> Differential Revision: [D17549624](https://our.internmc.facebook.com/intern/diff/D17549624) [ghstack-poisoned]

Update on "Tests for fallback boxed dispatch."

73f46e6

Signed-off-by: Edward Z. Yang <ezyang@fb.com> Differential Revision: [D17549624](https://our.internmc.facebook.com/intern/diff/D17549624) [ghstack-poisoned]

ezyang mentioned this pull request Sep 26, 2019

Change calling convention of ATenDispatch from getOp to callUnboxed. #26857

Closed

ezyang added a commit that referenced this pull request Sep 26, 2019

Tests for fallback boxed dispatch.

74ce14b

Signed-off-by: Edward Z. Yang <ezyang@fb.com> ghstack-source-id: 92d0ced Pull Request resolved: #26719

Update on "Tests for fallback boxed dispatch."

c0124c1

Signed-off-by: Edward Z. Yang <ezyang@fb.com> Differential Revision: [D17549624](https://our.internmc.facebook.com/intern/diff/D17549624) [ghstack-poisoned]

Update on "Tests for fallback boxed dispatch."

5ed34b5

Signed-off-by: Edward Z. Yang <ezyang@fb.com> Differential Revision: [D17549624](https://our.internmc.facebook.com/intern/diff/D17549624) [ghstack-poisoned]

namedtensor macrofix on "Tests for fallback boxed dispatch."

b9839aa

Signed-off-by: Edward Z. Yang <ezyang@fb.com> Differential Revision: [D17549624](https://our.internmc.facebook.com/intern/diff/D17549624) [ghstack-poisoned]

ezyang added a commit that referenced this pull request Sep 26, 2019

Tests for fallback boxed dispatch.

e241bd2

Signed-off-by: Edward Z. Yang <ezyang@fb.com> ghstack-source-id: 3da260e Pull Request resolved: #26719

Include the correct named tensor header on "Tests for fallback boxed …

132f51a

…dispatch." Signed-off-by: Edward Z. Yang <ezyang@fb.com> Differential Revision: [D17549624](https://our.internmc.facebook.com/intern/diff/D17549624) [ghstack-poisoned]

ezyang added a commit that referenced this pull request Sep 27, 2019

Tests for fallback boxed dispatch.

b4324db

Signed-off-by: Edward Z. Yang <ezyang@fb.com> ghstack-source-id: d792770 Pull Request resolved: #26719

ezyang changed the title ~~Tests for fallback boxed dispatch.~~ Tests for fallback boxed dispatch (including TLS mode) Sep 27, 2019

ezyang requested review from bwasti, li-roy, smessmer and zdevito September 27, 2019 22:34

ezyang added a commit that referenced this pull request Sep 30, 2019

Tests for fallback boxed dispatch.

bbebf26

Signed-off-by: Edward Z. Yang <ezyang@fb.com> ghstack-source-id: 512eb4b Pull Request resolved: #26719

zdevito approved these changes Oct 1, 2019

View reviewed changes

bwasti mentioned this pull request Oct 1, 2019

Use FunctionSchema instead of char* for dispatch #27178

Closed

bwasti approved these changes Oct 1, 2019

View reviewed changes

bwasti mentioned this pull request Oct 2, 2019

Custom Tensor Registration #27201

Closed

ezyang added a commit that referenced this pull request Oct 2, 2019

Tests for fallback boxed dispatch.

2dd7f32

Signed-off-by: Edward Z. Yang <ezyang@fb.com> ghstack-source-id: 1b16e64 Pull Request resolved: #26719

ezyang added a commit that referenced this pull request Oct 3, 2019

Tests for fallback boxed dispatch.

a6348e0

Signed-off-by: Edward Z. Yang <ezyang@fb.com> ghstack-source-id: e8b7d08 Pull Request resolved: #26719

li-roy approved these changes Oct 3, 2019

View reviewed changes

ezyang added a commit that referenced this pull request Oct 8, 2019

Tests for fallback boxed dispatch.

129269b

Signed-off-by: Edward Z. Yang <ezyang@fb.com> ghstack-source-id: 9e3ebf7 Pull Request resolved: #26719

facebook-github-bot closed this in d70f8dd Oct 9, 2019

facebook-github-bot added the merged label Oct 9, 2019

facebook-github-bot deleted the gh/ezyang/375/head branch October 28, 2019 22:11

mruberry added the Merged label Oct 28, 2020

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Tests for fallback boxed dispatch (including TLS mode)#26719

Tests for fallback boxed dispatch (including TLS mode)#26719
ezyang wants to merge 17 commits intogh/ezyang/375/basefrom
gh/ezyang/375/head

ezyang commented Sep 24, 2019 •

edited

Loading

Uh oh!

zdevito left a comment

Uh oh!

zdevito Oct 1, 2019

Uh oh!

zdevito Oct 1, 2019

Uh oh!

ezyang Oct 1, 2019

Uh oh!

zdevito Oct 1, 2019

Uh oh!

facebook-github-bot commented Oct 9, 2019

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

7 participants


		#endif

		void set_enabled_via_excluded(TensorTypeId tid, bool enabled) {

Conversation

ezyang commented Sep 24, 2019 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

zdevito left a comment

Choose a reason for hiding this comment

Uh oh!

zdevito Oct 1, 2019

Choose a reason for hiding this comment

Uh oh!

zdevito Oct 1, 2019

Choose a reason for hiding this comment

Uh oh!

ezyang Oct 1, 2019

Choose a reason for hiding this comment

Uh oh!

zdevito Oct 1, 2019

Choose a reason for hiding this comment

Uh oh!

facebook-github-bot commented Oct 9, 2019

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

7 participants

ezyang commented Sep 24, 2019 •

edited

Loading