If it's just right, broadcasting will do the right thing
automatically.

This helps with unbacked SymInts as I can avoid testing one
equality on the inside.

Signed-off-by: Edward Z. Yang <ezyangmeta.com>

ghstack-source-id: dbc8b03
Pull Request resolved: #94521

…SymInts"


This adds support for unbacked SymInts from nonzero, and then gets this working end-to-end with advanced indexing and boolean masking. I needed to apply a variety of fixes to get this to work; these fixes are emblematic of the kind of enablement work we will need to do for unbacked SymInts as they are used more heavily.

* When we allocate a contiguous tensor, hard code relevant fields (e.g., `is_contiguous_`) true, instead of keeping the complicated guardless implementation. As Horace notes, all guardless implementations really do is push off the evaluation problem until later. We do poke contiguity reasonably often, but we also typically allocate these with torch.empty so we know statically they are contiguous.
* Allow boolean tensors into the index.Tensor meta, and redirect fake tensor to call the meta function directly (so that when it calls nonzero, it decomposes to the fake tensor nonzero)
* Don't rewrap tensors in TensorMeta; it does nothing but hits `empty_strided` which is generally not unbacked SymInt friendly
* Refactor `compute_elementwise_output_strides` to return the output permutation. I then use this to rewrite the `empty_like` reference to avoid calling `empty_strided`; instead, it allocates a contiguous tensor and permutes it.
* Refactor `_broadcast_shapes` to test for more common cases (shapes are equal) before broadcasting case, which is enough to get the broadcasting in advanced indexing going without adding an unnecessary == 1 guard.
* Make nonzero return an unbacked symint in size, and put enough assumptions on it so that the boolean masking end to end works
* Don't remove leading 1s in setitem unless the value tensor is too big for the input tensor. Submitted separately at #94521
* Don't record `memory_format` on TensorMeta if there are unbacked SymInts. Actually, we can probably do a bit better here; sometimes a tensor will have unbacked SymInt but is obviously contiguous and we ought to report that. Leaving that for future work.

Signed-off-by: Edward Z. Yang <ezyangmeta.com>

[ghstack-poisoned]

This adds support for unbacked SymInts from nonzero, and then gets this working end-to-end with advanced indexing and boolean masking. I needed to apply a variety of fixes to get this to work; these fixes are emblematic of the kind of enablement work we will need to do for unbacked SymInts as they are used more heavily.

* When we allocate a contiguous tensor, hard code relevant fields (e.g., `is_contiguous_`) true, instead of keeping the complicated guardless implementation. As Horace notes, all guardless implementations really do is push off the evaluation problem until later. We do poke contiguity reasonably often, but we also typically allocate these with torch.empty so we know statically they are contiguous.
* Allow boolean tensors into the index.Tensor meta, and redirect fake tensor to call the meta function directly (so that when it calls nonzero, it decomposes to the fake tensor nonzero)
* Don't rewrap tensors in TensorMeta; it does nothing but hits `empty_strided` which is generally not unbacked SymInt friendly
* Refactor `compute_elementwise_output_strides` to return the output permutation. I then use this to rewrite the `empty_like` reference to avoid calling `empty_strided`; instead, it allocates a contiguous tensor and permutes it.
* Refactor `_broadcast_shapes` to test for more common cases (shapes are equal) before broadcasting case, which is enough to get the broadcasting in advanced indexing going without adding an unnecessary == 1 guard.
* Make nonzero return an unbacked symint in size, and put enough assumptions on it so that the boolean masking end to end works
* Don't remove leading 1s in setitem unless the value tensor is too big for the input tensor. Submitted separately at #94521
* Don't record `memory_format` on TensorMeta if there are unbacked SymInts. Actually, we can probably do a bit better here; sometimes a tensor will have unbacked SymInt but is obviously contiguous and we ought to report that. Leaving that for future work.

Signed-off-by: Edward Z. Yang <ezyangmeta.com>

[ghstack-poisoned]

…SymInts"


This adds support for unbacked SymInts from nonzero, and then gets this working end-to-end with advanced indexing and boolean masking. I needed to apply a variety of fixes to get this to work; these fixes are emblematic of the kind of enablement work we will need to do for unbacked SymInts as they are used more heavily.

* When we allocate a contiguous tensor, hard code relevant fields (e.g., `is_contiguous_`) true, instead of keeping the complicated guardless implementation. As Horace notes, all guardless implementations really do is push off the evaluation problem until later. We do poke contiguity reasonably often, but we also typically allocate these with torch.empty so we know statically they are contiguous.
* Allow boolean tensors into the index.Tensor meta, and redirect fake tensor to call the meta function directly (so that when it calls nonzero, it decomposes to the fake tensor nonzero)
* Don't rewrap tensors in TensorMeta; it does nothing but hits `empty_strided` which is generally not unbacked SymInt friendly
* Refactor `compute_elementwise_output_strides` to return the output permutation. I then use this to rewrite the `empty_like` reference to avoid calling `empty_strided`; instead, it allocates a contiguous tensor and permutes it.
* Refactor `_broadcast_shapes` to test for more common cases (shapes are equal) before broadcasting case, which is enough to get the broadcasting in advanced indexing going without adding an unnecessary == 1 guard.
* Make nonzero return an unbacked symint in size, and put enough assumptions on it so that the boolean masking end to end works
* Don't remove leading 1s in setitem unless the value tensor is too big for the input tensor. Submitted separately at #94521
* Don't record `memory_format` on TensorMeta if there are unbacked SymInts. Actually, we can probably do a bit better here; sometimes a tensor will have unbacked SymInt but is obviously contiguous and we ought to report that. Leaving that for future work.

Signed-off-by: Edward Z. Yang <ezyangmeta.com>

[ghstack-poisoned]

This adds support for unbacked SymInts from nonzero, and then gets this working end-to-end with advanced indexing and boolean masking. I needed to apply a variety of fixes to get this to work; these fixes are emblematic of the kind of enablement work we will need to do for unbacked SymInts as they are used more heavily.

* When we allocate a contiguous tensor, hard code relevant fields (e.g., `is_contiguous_`) true, instead of keeping the complicated guardless implementation. As Horace notes, all guardless implementations really do is push off the evaluation problem until later. We do poke contiguity reasonably often, but we also typically allocate these with torch.empty so we know statically they are contiguous.
* Allow boolean tensors into the index.Tensor meta, and redirect fake tensor to call the meta function directly (so that when it calls nonzero, it decomposes to the fake tensor nonzero)
* Don't rewrap tensors in TensorMeta; it does nothing but hits `empty_strided` which is generally not unbacked SymInt friendly
* Refactor `compute_elementwise_output_strides` to return the output permutation. I then use this to rewrite the `empty_like` reference to avoid calling `empty_strided`; instead, it allocates a contiguous tensor and permutes it.
* Refactor `_broadcast_shapes` to test for more common cases (shapes are equal) before broadcasting case, which is enough to get the broadcasting in advanced indexing going without adding an unnecessary == 1 guard.
* Make nonzero return an unbacked symint in size, and put enough assumptions on it so that the boolean masking end to end works
* Don't remove leading 1s in setitem unless the value tensor is too big for the input tensor. Submitted separately at #94521
* Don't record `memory_format` on TensorMeta if there are unbacked SymInts. Actually, we can probably do a bit better here; sometimes a tensor will have unbacked SymInt but is obviously contiguous and we ought to report that. Leaving that for future work.

Signed-off-by: Edward Z. Yang <ezyangmeta.com>

[ghstack-poisoned]

…SymInts"


This adds support for unbacked SymInts from nonzero, and then gets this working end-to-end with advanced indexing and boolean masking. I needed to apply a variety of fixes to get this to work; these fixes are emblematic of the kind of enablement work we will need to do for unbacked SymInts as they are used more heavily.

* When we allocate a contiguous tensor, hard code relevant fields (e.g., `is_contiguous_`) true, instead of keeping the complicated guardless implementation. As Horace notes, all guardless implementations really do is push off the evaluation problem until later. We do poke contiguity reasonably often, but we also typically allocate these with torch.empty so we know statically they are contiguous.
* Allow boolean tensors into the index.Tensor meta, and redirect fake tensor to call the meta function directly (so that when it calls nonzero, it decomposes to the fake tensor nonzero)
* Don't rewrap tensors in TensorMeta; it does nothing but hits `empty_strided` which is generally not unbacked SymInt friendly
* Refactor `compute_elementwise_output_strides` to return the output permutation. I then use this to rewrite the `empty_like` reference to avoid calling `empty_strided`; instead, it allocates a contiguous tensor and permutes it.
* Refactor `_broadcast_shapes` to test for more common cases (shapes are equal) before broadcasting case, which is enough to get the broadcasting in advanced indexing going without adding an unnecessary == 1 guard.
* Make nonzero return an unbacked symint in size, and put enough assumptions on it so that the boolean masking end to end works
* Don't remove leading 1s in setitem unless the value tensor is too big for the input tensor. Submitted separately at #94521
* Don't record `memory_format` on TensorMeta if there are unbacked SymInts. Actually, we can probably do a bit better here; sometimes a tensor will have unbacked SymInt but is obviously contiguous and we ought to report that. Leaving that for future work.

Signed-off-by: Edward Z. Yang <ezyangmeta.com>

[ghstack-poisoned]

This adds support for unbacked SymInts from nonzero, and then gets this working end-to-end with advanced indexing and boolean masking. I needed to apply a variety of fixes to get this to work; these fixes are emblematic of the kind of enablement work we will need to do for unbacked SymInts as they are used more heavily.

* When we allocate a contiguous tensor, hard code relevant fields (e.g., `is_contiguous_`) true, instead of keeping the complicated guardless implementation. As Horace notes, all guardless implementations really do is push off the evaluation problem until later. We do poke contiguity reasonably often, but we also typically allocate these with torch.empty so we know statically they are contiguous.
* Allow boolean tensors into the index.Tensor meta, and redirect fake tensor to call the meta function directly (so that when it calls nonzero, it decomposes to the fake tensor nonzero)
* Don't rewrap tensors in TensorMeta; it does nothing but hits `empty_strided` which is generally not unbacked SymInt friendly
* Refactor `compute_elementwise_output_strides` to return the output permutation. I then use this to rewrite the `empty_like` reference to avoid calling `empty_strided`; instead, it allocates a contiguous tensor and permutes it.
* Refactor `_broadcast_shapes` to test for more common cases (shapes are equal) before broadcasting case, which is enough to get the broadcasting in advanced indexing going without adding an unnecessary == 1 guard.
* Make nonzero return an unbacked symint in size, and put enough assumptions on it so that the boolean masking end to end works
* Don't remove leading 1s in setitem unless the value tensor is too big for the input tensor. Submitted separately at #94521
* Don't record `memory_format` on TensorMeta if there are unbacked SymInts. Actually, we can probably do a bit better here; sometimes a tensor will have unbacked SymInt but is obviously contiguous and we ought to report that. Leaving that for future work.

Signed-off-by: Edward Z. Yang <ezyangmeta.com>

[ghstack-poisoned]

If it's just right, broadcasting will do the right thing
automatically.

This helps with unbacked SymInts as I can avoid testing one
equality on the inside.

Signed-off-by: Edward Z. Yang <ezyangmeta.com>

ghstack-source-id: c4aaa3e
Pull Request resolved: #94521

…SymInts"


This adds support for unbacked SymInts from nonzero, and then gets this working end-to-end with advanced indexing and boolean masking. I needed to apply a variety of fixes to get this to work; these fixes are emblematic of the kind of enablement work we will need to do for unbacked SymInts as they are used more heavily.

* When we allocate a contiguous tensor, hard code relevant fields (e.g., `is_contiguous_`) true, instead of keeping the complicated guardless implementation. As Horace notes, all guardless implementations really do is push off the evaluation problem until later. We do poke contiguity reasonably often, but we also typically allocate these with torch.empty so we know statically they are contiguous.
* Allow boolean tensors into the index.Tensor meta, and redirect fake tensor to call the meta function directly (so that when it calls nonzero, it decomposes to the fake tensor nonzero)
* Don't rewrap tensors in TensorMeta; it does nothing but hits `empty_strided` which is generally not unbacked SymInt friendly
* Refactor `compute_elementwise_output_strides` to return the output permutation. I then use this to rewrite the `empty_like` reference to avoid calling `empty_strided`; instead, it allocates a contiguous tensor and permutes it.
* Refactor `_broadcast_shapes` to test for more common cases (shapes are equal) before broadcasting case, which is enough to get the broadcasting in advanced indexing going without adding an unnecessary == 1 guard.
* Make nonzero return an unbacked symint in size, and put enough assumptions on it so that the boolean masking end to end works
* Don't remove leading 1s in setitem unless the value tensor is too big for the input tensor. Submitted separately at #94521
* Don't record `memory_format` on TensorMeta if there are unbacked SymInts. Actually, we can probably do a bit better here; sometimes a tensor will have unbacked SymInt but is obviously contiguous and we ought to report that. Leaving that for future work.

Signed-off-by: Edward Z. Yang <ezyangmeta.com>

[ghstack-poisoned]

This adds support for unbacked SymInts from nonzero, and then gets this working end-to-end with advanced indexing and boolean masking. I needed to apply a variety of fixes to get this to work; these fixes are emblematic of the kind of enablement work we will need to do for unbacked SymInts as they are used more heavily.

* When we allocate a contiguous tensor, hard code relevant fields (e.g., `is_contiguous_`) true, instead of keeping the complicated guardless implementation. As Horace notes, all guardless implementations really do is push off the evaluation problem until later. We do poke contiguity reasonably often, but we also typically allocate these with torch.empty so we know statically they are contiguous.
* Allow boolean tensors into the index.Tensor meta, and redirect fake tensor to call the meta function directly (so that when it calls nonzero, it decomposes to the fake tensor nonzero)
* Don't rewrap tensors in TensorMeta; it does nothing but hits `empty_strided` which is generally not unbacked SymInt friendly
* Refactor `compute_elementwise_output_strides` to return the output permutation. I then use this to rewrite the `empty_like` reference to avoid calling `empty_strided`; instead, it allocates a contiguous tensor and permutes it.
* Refactor `_broadcast_shapes` to test for more common cases (shapes are equal) before broadcasting case, which is enough to get the broadcasting in advanced indexing going without adding an unnecessary == 1 guard.
* Make nonzero return an unbacked symint in size, and put enough assumptions on it so that the boolean masking end to end works
* Don't remove leading 1s in setitem unless the value tensor is too big for the input tensor. Submitted separately at #94521
* Don't record `memory_format` on TensorMeta if there are unbacked SymInts. Actually, we can probably do a bit better here; sometimes a tensor will have unbacked SymInt but is obviously contiguous and we ought to report that. Leaving that for future work.

Signed-off-by: Edward Z. Yang <ezyangmeta.com>

[ghstack-poisoned]

…SymInts"


This adds support for unbacked SymInts from nonzero, and then gets this working end-to-end with advanced indexing and boolean masking. I needed to apply a variety of fixes to get this to work; these fixes are emblematic of the kind of enablement work we will need to do for unbacked SymInts as they are used more heavily.

* When we allocate a contiguous tensor, hard code relevant fields (e.g., `is_contiguous_`) true, instead of keeping the complicated guardless implementation. As Horace notes, all guardless implementations really do is push off the evaluation problem until later. We do poke contiguity reasonably often, but we also typically allocate these with torch.empty so we know statically they are contiguous.
* Allow boolean tensors into the index.Tensor meta, and redirect fake tensor to call the meta function directly (so that when it calls nonzero, it decomposes to the fake tensor nonzero)
* Don't rewrap tensors in TensorMeta; it does nothing but hits `empty_strided` which is generally not unbacked SymInt friendly
* Refactor `compute_elementwise_output_strides` to return the output permutation. I then use this to rewrite the `empty_like` reference to avoid calling `empty_strided`; instead, it allocates a contiguous tensor and permutes it.
* Refactor `_broadcast_shapes` to test for more common cases (shapes are equal) before broadcasting case, which is enough to get the broadcasting in advanced indexing going without adding an unnecessary == 1 guard.
* Make nonzero return an unbacked symint in size, and put enough assumptions on it so that the boolean masking end to end works
* Don't remove leading 1s in setitem unless the value tensor is too big for the input tensor. Submitted separately at #94521
* Don't record `memory_format` on TensorMeta if there are unbacked SymInts. Actually, we can probably do a bit better here; sometimes a tensor will have unbacked SymInt but is obviously contiguous and we ought to report that. Leaving that for future work.

Signed-off-by: Edward Z. Yang <ezyangmeta.com>

[ghstack-poisoned]

This adds support for unbacked SymInts from nonzero, and then gets this working end-to-end with advanced indexing and boolean masking. I needed to apply a variety of fixes to get this to work; these fixes are emblematic of the kind of enablement work we will need to do for unbacked SymInts as they are used more heavily.

* When we allocate a contiguous tensor, hard code relevant fields (e.g., `is_contiguous_`) true, instead of keeping the complicated guardless implementation. As Horace notes, all guardless implementations really do is push off the evaluation problem until later. We do poke contiguity reasonably often, but we also typically allocate these with torch.empty so we know statically they are contiguous.
* Allow boolean tensors into the index.Tensor meta, and redirect fake tensor to call the meta function directly (so that when it calls nonzero, it decomposes to the fake tensor nonzero)
* Don't rewrap tensors in TensorMeta; it does nothing but hits `empty_strided` which is generally not unbacked SymInt friendly
* Refactor `compute_elementwise_output_strides` to return the output permutation. I then use this to rewrite the `empty_like` reference to avoid calling `empty_strided`; instead, it allocates a contiguous tensor and permutes it.
* Refactor `_broadcast_shapes` to test for more common cases (shapes are equal) before broadcasting case, which is enough to get the broadcasting in advanced indexing going without adding an unnecessary == 1 guard.
* Make nonzero return an unbacked symint in size, and put enough assumptions on it so that the boolean masking end to end works
* Don't remove leading 1s in setitem unless the value tensor is too big for the input tensor. Submitted separately at #94521
* Don't record `memory_format` on TensorMeta if there are unbacked SymInts. Actually, we can probably do a bit better here; sometimes a tensor will have unbacked SymInt but is obviously contiguous and we ought to report that. Leaving that for future work.

Signed-off-by: Edward Z. Yang <ezyangmeta.com>

[ghstack-poisoned]

This reverts commit 03f4a63.

Reverted #94521 on behalf of https://github.com/ezyang due to fails internal tests

If it's just right, broadcasting will do the right thing
automatically.

This helps with unbacked SymInts as I can avoid testing one
equality on the inside.

Signed-off-by: Edward Z. Yang <ezyangmeta.com>

ghstack-source-id: 905f645
Pull Request resolved: #94521

If it's just right, broadcasting will do the right thing automatically.

This helps with unbacked SymInts as I can avoid testing one equality on the inside.

The previous attempt at #94521 I got the logic a bit wrong. I need to compute the difference between the data to be set, and the post-slice space for the values. But I incorrectly compared against the *pre-slice* space in the original PR. Another version of this PR which is wrong is to compare against variableIndices.size(); but remember that in advanced indexing with tensors/lists, each of the individual indices specify what coordinates to read out of each dimension; so to get the post-slice space you have to look at the dim of the advanced index itself! There is now a test for this.

Signed-off-by: Edward Z. Yang <ezyangmeta.com>

[ghstack-poisoned]

…cked"


This prevents us from guarding on leading unbacked SymInts.

The previous attempt at #94521 I got the logic a bit wrong. My idea there was to avoid slicing when the values to be set have low enough dimensionality that they definitely aren't too long. To do this, I need to compute the difference between the data to be set, and the post-slice space for the values. But I incorrectly compared against the *pre-slice* space in the original PR. Another version of this PR which is wrong is to compare against variableIndices.size(); but remember that in advanced indexing with tensors/lists, each of the individual indices specify what coordinates to read out of each dimension! A third incorrect attempt tested `variableIndices[0].dim()`, which is only correct if you don't broadcast one of the later variable indices, and if there are enough variableIndices to cover all dims. This is all quite complicated, so I went for a simpler solution of checking if the leading dim had a hint before testing if it is not equal to one.

BTW, there is no test for this one stripping behavior. There is now a test for this, based off the real code that caused the problem.

Signed-off-by: Edward Z. Yang <ezyangmeta.com>

[ghstack-poisoned]

This prevents us from guarding on leading unbacked SymInts.

The previous attempt at #94521 I got the logic a bit wrong. My idea there was to avoid slicing when the values to be set have low enough dimensionality that they definitely aren't too long. To do this, I need to compute the difference between the data to be set, and the post-slice space for the values. But I incorrectly compared against the *pre-slice* space in the original PR. Another version of this PR which is wrong is to compare against variableIndices.size(); but remember that in advanced indexing with tensors/lists, each of the individual indices specify what coordinates to read out of each dimension! A third incorrect attempt tested `variableIndices[0].dim()`, which is only correct if you don't broadcast one of the later variable indices, and if there are enough variableIndices to cover all dims. This is all quite complicated, so I went for a simpler solution of checking if the leading dim had a hint before testing if it is not equal to one.

BTW, there is no test for this one stripping behavior. There is now a test for this, based off the real code that caused the problem.

Signed-off-by: Edward Z. Yang <ezyangmeta.com>

[ghstack-poisoned]

…SymInts"


This adds support for unbacked SymInts from nonzero, and then gets this working end-to-end with advanced indexing and boolean masking. I needed to apply a variety of fixes to get this to work; these fixes are emblematic of the kind of enablement work we will need to do for unbacked SymInts as they are used more heavily.

* When we allocate a contiguous tensor, hard code relevant fields (e.g., `is_contiguous_`) true, instead of keeping the complicated guardless implementation. As Horace notes, all guardless implementations really do is push off the evaluation problem until later. We do poke contiguity reasonably often, but we also typically allocate these with torch.empty so we know statically they are contiguous.
* Allow boolean tensors into the index.Tensor meta, and redirect fake tensor to call the meta function directly (so that when it calls nonzero, it decomposes to the fake tensor nonzero)
* Don't rewrap tensors in TensorMeta; it does nothing but hits `empty_strided` which is generally not unbacked SymInt friendly
* Refactor `compute_elementwise_output_strides` to return the output permutation. I then use this to rewrite the `empty_like` reference to avoid calling `empty_strided`; instead, it allocates a contiguous tensor and permutes it.
* Refactor `_broadcast_shapes` to test for more common cases (shapes are equal) before broadcasting case, which is enough to get the broadcasting in advanced indexing going without adding an unnecessary == 1 guard.
* Make nonzero return an unbacked symint in size, and put enough assumptions on it so that the boolean masking end to end works
* Don't remove leading 1s in setitem unless the value tensor is too big for the input tensor. Submitted separately at #94521
* Don't record `memory_format` on TensorMeta if there are unbacked SymInts. Actually, we can probably do a bit better here; sometimes a tensor will have unbacked SymInt but is obviously contiguous and we ought to report that. Leaving that for future work.

Signed-off-by: Edward Z. Yang <ezyangmeta.com>

[ghstack-poisoned]

This adds support for unbacked SymInts from nonzero, and then gets this working end-to-end with advanced indexing and boolean masking. I needed to apply a variety of fixes to get this to work; these fixes are emblematic of the kind of enablement work we will need to do for unbacked SymInts as they are used more heavily.

* When we allocate a contiguous tensor, hard code relevant fields (e.g., `is_contiguous_`) true, instead of keeping the complicated guardless implementation. As Horace notes, all guardless implementations really do is push off the evaluation problem until later. We do poke contiguity reasonably often, but we also typically allocate these with torch.empty so we know statically they are contiguous.
* Allow boolean tensors into the index.Tensor meta, and redirect fake tensor to call the meta function directly (so that when it calls nonzero, it decomposes to the fake tensor nonzero)
* Don't rewrap tensors in TensorMeta; it does nothing but hits `empty_strided` which is generally not unbacked SymInt friendly
* Refactor `compute_elementwise_output_strides` to return the output permutation. I then use this to rewrite the `empty_like` reference to avoid calling `empty_strided`; instead, it allocates a contiguous tensor and permutes it.
* Refactor `_broadcast_shapes` to test for more common cases (shapes are equal) before broadcasting case, which is enough to get the broadcasting in advanced indexing going without adding an unnecessary == 1 guard.
* Make nonzero return an unbacked symint in size, and put enough assumptions on it so that the boolean masking end to end works
* Don't remove leading 1s in setitem unless the value tensor is too big for the input tensor. Submitted separately at #94521
* Don't record `memory_format` on TensorMeta if there are unbacked SymInts. Actually, we can probably do a bit better here; sometimes a tensor will have unbacked SymInt but is obviously contiguous and we ought to report that. Leaving that for future work.

Signed-off-by: Edward Z. Yang <ezyangmeta.com>

[ghstack-poisoned]

…SymInts"


This adds support for unbacked SymInts from nonzero, and then gets this working end-to-end with advanced indexing and boolean masking. I needed to apply a variety of fixes to get this to work; these fixes are emblematic of the kind of enablement work we will need to do for unbacked SymInts as they are used more heavily.

* When we allocate a contiguous tensor, hard code relevant fields (e.g., `is_contiguous_`) true, instead of keeping the complicated guardless implementation. As Horace notes, all guardless implementations really do is push off the evaluation problem until later. We do poke contiguity reasonably often, but we also typically allocate these with torch.empty so we know statically they are contiguous.
* Allow boolean tensors into the index.Tensor meta, and redirect fake tensor to call the meta function directly (so that when it calls nonzero, it decomposes to the fake tensor nonzero)
* Don't rewrap tensors in TensorMeta; it does nothing but hits `empty_strided` which is generally not unbacked SymInt friendly
* Refactor `compute_elementwise_output_strides` to return the output permutation. I then use this to rewrite the `empty_like` reference to avoid calling `empty_strided`; instead, it allocates a contiguous tensor and permutes it.
* Refactor `_broadcast_shapes` to test for more common cases (shapes are equal) before broadcasting case, which is enough to get the broadcasting in advanced indexing going without adding an unnecessary == 1 guard.
* Make nonzero return an unbacked symint in size, and put enough assumptions on it so that the boolean masking end to end works
* Don't remove leading 1s in setitem unless the value tensor is too big for the input tensor. Submitted separately at #94521
* Don't record `memory_format` on TensorMeta if there are unbacked SymInts. Actually, we can probably do a bit better here; sometimes a tensor will have unbacked SymInt but is obviously contiguous and we ought to report that. Leaving that for future work.

Signed-off-by: Edward Z. Yang <ezyangmeta.com>

cc soumith voznesenskym yanboliang penguinwu anijain2305 EikanWang jgong5 Guobing-Chen XiaobingSuper zhuhaozhe blzheng Xia-Weiwen wenzhe-nrv jiayisunx desertfire

[ghstack-poisoned]

This adds support for unbacked SymInts from nonzero, and then gets this working end-to-end with advanced indexing and boolean masking. I needed to apply a variety of fixes to get this to work; these fixes are emblematic of the kind of enablement work we will need to do for unbacked SymInts as they are used more heavily.

* When we allocate a contiguous tensor, hard code relevant fields (e.g., `is_contiguous_`) true, instead of keeping the complicated guardless implementation. As Horace notes, all guardless implementations really do is push off the evaluation problem until later. We do poke contiguity reasonably often, but we also typically allocate these with torch.empty so we know statically they are contiguous.
* Allow boolean tensors into the index.Tensor meta, and redirect fake tensor to call the meta function directly (so that when it calls nonzero, it decomposes to the fake tensor nonzero)
* Don't rewrap tensors in TensorMeta; it does nothing but hits `empty_strided` which is generally not unbacked SymInt friendly
* Refactor `compute_elementwise_output_strides` to return the output permutation. I then use this to rewrite the `empty_like` reference to avoid calling `empty_strided`; instead, it allocates a contiguous tensor and permutes it.
* Refactor `_broadcast_shapes` to test for more common cases (shapes are equal) before broadcasting case, which is enough to get the broadcasting in advanced indexing going without adding an unnecessary == 1 guard.
* Make nonzero return an unbacked symint in size, and put enough assumptions on it so that the boolean masking end to end works
* Don't remove leading 1s in setitem unless the value tensor is too big for the input tensor. Submitted separately at #94521
* Don't record `memory_format` on TensorMeta if there are unbacked SymInts. Actually, we can probably do a bit better here; sometimes a tensor will have unbacked SymInt but is obviously contiguous and we ought to report that. Leaving that for future work.

Signed-off-by: Edward Z. Yang <ezyangmeta.com>

cc soumith voznesenskym yanboliang penguinwu anijain2305 EikanWang jgong5 Guobing-Chen XiaobingSuper zhuhaozhe blzheng Xia-Weiwen wenzhe-nrv jiayisunx desertfire

[ghstack-poisoned]

This prevents us from guarding on leading unbacked SymInts.

The previous attempt at #94521 I got the logic a bit wrong. My idea there was to avoid slicing when the values to be set have low enough dimensionality that they definitely aren't too long. To do this, I need to compute the difference between the data to be set, and the post-slice space for the values. But I incorrectly compared against the *pre-slice* space in the original PR. Another version of this PR which is wrong is to compare against variableIndices.size(); but remember that in advanced indexing with tensors/lists, each of the individual indices specify what coordinates to read out of each dimension! A third incorrect attempt tested `variableIndices[0].dim()`, which is only correct if you don't broadcast one of the later variable indices, and if there are enough variableIndices to cover all dims. This is all quite complicated, so I went for a simpler solution of checking if the leading dim had a hint before testing if it is not equal to one.

BTW, there is no test for this one stripping behavior. There is now a test for this, based off the real code that caused the problem.

Signed-off-by: Edward Z. Yang <ezyangmeta.com>
Pull Request resolved: #95141
Approved by: https://github.com/ngimel

…torch#94521)""

This reverts commit f89ae0a.

)"

This reverts commit 03f4a63.

If it's just right, broadcasting will do the right thing
automatically.

This helps with unbacked SymInts as I can avoid testing one
equality on the inside.

Signed-off-by: Edward Z. Yang <ezyang@meta.com>
Pull Request resolved: pytorch#94521
Approved by: https://github.com/voznesenskym

)"

This reverts commit 03f4a63.

Reverted pytorch#94521 on behalf of https://github.com/ezyang due to fails internal tests

This prevents us from guarding on leading unbacked SymInts.

The previous attempt at pytorch#94521 I got the logic a bit wrong. My idea there was to avoid slicing when the values to be set have low enough dimensionality that they definitely aren't too long. To do this, I need to compute the difference between the data to be set, and the post-slice space for the values. But I incorrectly compared against the *pre-slice* space in the original PR. Another version of this PR which is wrong is to compare against variableIndices.size(); but remember that in advanced indexing with tensors/lists, each of the individual indices specify what coordinates to read out of each dimension! A third incorrect attempt tested `variableIndices[0].dim()`, which is only correct if you don't broadcast one of the later variable indices, and if there are enough variableIndices to cover all dims. This is all quite complicated, so I went for a simpler solution of checking if the leading dim had a hint before testing if it is not equal to one.

BTW, there is no test for this one stripping behavior. There is now a test for this, based off the real code that caused the problem.

Signed-off-by: Edward Z. Yang <ezyangmeta.com>
Pull Request resolved: pytorch#95141
Approved by: https://github.com/ngimel