PyTorch Bug: Corrupted Tensors On Failed Storage Resize

Ever had one of those moments where you're working with PyTorch, and things just don't add up? You expect one thing to happen, but instead, you get a cryptic error or, even worse, a nasty crash. Well, we've stumbled upon a particularly sneaky bug in PyTorch that might explain some of those head-scratching moments. It involves tensor metadata updates when storage resize operations fail, leading to what we've affectionately dubbed "corrupted 'Etjzqt' tensors." It sounds a bit dramatic, but trust us, it can cause some serious headaches in your machine learning workflows.

So, what exactly is going on here? Let's dive into the nitty-gritty. The core of the problem lies in how PyTorch handles tensor resizing, especially when the underlying storage isn't as flexible as we'd like. When you try to resize a tensor that's sharing its storage with something that *can't* be resized—like a NumPy array you've cleverly attached using set_()—PyTorch is supposed to catch this. And, to its credit, it usually does. It'll throw a `RuntimeError` with a message like: "Trying to resize storage that is not resizable." This is good! It tells you upfront that you're trying to do something impossible.

However, the bug rears its ugly head in the exception handling. PyTorch attempts to update the tensor's shape and stride metadata *before* it checks if the storage can actually accommodate this change. When the storage check fails (as it should!), it throws that `RuntimeError`. But by then, the damage is already done. The tensor's shape information has been updated to reflect the new, desired size, while its actual storage remains unchanged and, crucially, empty (0 bytes). This creates a deeply unsettling state: the tensor *thinks* it's much larger than it is, but it has no data to back it up. We're calling these "Zombie tensors" because they have the appearance of a larger tensor but lack the substance, leading to a precarious existence.

The real trouble starts when you try to interact with these "Zombie" tensors *after* the exception has been caught. Attempting to print them, access their elements, or perform any operation that requires looking at their shape and data will inevitably lead to problems. You might encounter segmentation faults, which are the operating system's way of saying, "Whoa, you're trying to access memory that doesn't belong to you!" Or, you could hit internal PyTorch `RuntimeError`s that stem from the fundamental inconsistency between the tensor's reported shape and its actual (lack of) storage. It's a recipe for instability and unpredictable behavior in your code. The very act of attempting to resize a tensor with non-resizable storage should ideally be an atomic operation – it either succeeds entirely or fails completely, leaving the tensor exactly as it was before the attempt. This bug breaks that expectation.

The Anatomy of the "Zombie Tensor" Bug

Let's really unpack why this