Update on "Update torch::stable::Tensor() default constructor"

Allows things like ```cpp Tensor cu_seqlens_q; if (...) { cu_seqlens_q = ... } ... ``` Also adds `torch::stable::Tensor.defined()` [ghstack-poisoned]
pytorch · mikaylagawarecki · Jul 30, 2025 · Aug 4, 2025 · Aug 8, 2025 · Aug 11, 2025
commit daef220b3d1c17bf3b37213f2318d01137a12b51
diff --git a/test/cpp_extensions/libtorch_agnostic_extension/libtorch_agnostic/ops.py b/test/cpp_extensions/libtorch_agnostic_extension/libtorch_agnostic/ops.py
@@ -166,13 +166,13 @@ def fill_infinity(t) -> Tensor:
     return torch.ops.libtorch_agnostic.fill_infinity.default(t)
 
 
-def test_default_constructor(undefined) -> bool:
+def test_default_constructor(defined) -> bool:
     """
     Tests the default constructor for torch::stable::Tensor.
 
     Args:
-        undefined: bool - if True, tests defined tensor; if False, tests undefined tensor
+        defined: bool - if True, tests defined tensor; if False, tests undefined tensor
 
     Returns: bool - result of calling .defined() on the tensor
     """
-    return torch.ops.libtorch_agnostic.test_default_constructor.default(undefined)
+    return torch.ops.libtorch_agnostic.test_default_constructor.default(defined)
diff --git a/test/cpp_extensions/libtorch_agnostic_extension/test/test_libtorch_agnostic.py b/test/cpp_extensions/libtorch_agnostic_extension/test/test_libtorch_agnostic.py
@@ -222,11 +222,52 @@ def test_fill_infinity(self, device):
         def test_default_constructor(self):
             import libtorch_agnostic
 
-            is_defined_defined = libtorch_agnostic.ops.test_default_constructor(True)
-            self.assertTrue(is_defined_defined)
+            defined_tensor_is_defined = libtorch_agnostic.ops.test_default_constructor(
+                True
+            )
+            self.assertTrue(defined_tensor_is_defined)
+
+            undefined_tensor_is_defined = (
+                libtorch_agnostic.ops.test_default_constructor(False)
+            )
+            self.assertFalse(undefined_tensor_is_defined)
+
+        @onlyCPU
+        def test_default_constructor_memory_cleanup(self):
+            import subprocess
+            import sys
+
+            import libtorch_agnostic
+
+            def run_in_subprocess():
+                import gc
+                import os
+
+                import psutil
+
+                process = psutil.Process(os.getpid())
+                gc.collect()
+
+                initial_memory = process.memory_info().rss
+
+                for _ in range(100):
+                    libtorch_agnostic.ops.test_default_constructor(False)
+
+                final_memory = process.memory_info().rss
+                memory_increase = final_memory - initial_memory
+
+                return memory_increase
+
+            # Run the memory test in a subprocess
+            result = subprocess.run(
+                [sys.executable, "-c", f"print({run_in_subprocess()})"],
+                capture_output=True,
+                text=True,
+            )
 
-            is_undefined_defined = libtorch_agnostic.ops.test_default_constructor(False)
-            self.assertFalse(is_undefined_defined)
+            # Check the result from the subprocess
+            memory_increase = int(result.stdout.strip())
+            self.assertEqual(memory_increase, 0)
 
     instantiate_device_type_tests(TestLibtorchAgnostic, globals(), except_for=None)
 

diff --git a/torch/csrc/stable/tensor.h b/torch/csrc/stable/tensor.h
@@ -29,11 +29,13 @@ class Tensor {
   std::shared_ptr<AtenTensorOpaque> ath_;
 
  public:
+  // Construct a stable::Tensor with an uninitialized AtenTensorHandle (ATH)
+  // Steals ownership from the ATH
   Tensor() {
     AtenTensorHandle ret;
-    AOTI_TORCH_ERROR_CODE_CHECK(aoti_torch_new_uninitialized_tensor(&ret));
+    TORCH_ERROR_CODE_CHECK(aoti_torch_new_uninitialized_tensor(&ret));
     ath_ = std::shared_ptr<AtenTensorOpaque>(ret, [](AtenTensorHandle ath) {
-      AOTI_TORCH_ERROR_CODE_CHECK(aoti_torch_delete_tensor_object(ath));
+      TORCH_ERROR_CODE_CHECK(aoti_torch_delete_tensor_object(ath));
     });
   }
 
@@ -123,7 +125,7 @@ class Tensor {
 
   bool defined() const {
 AOTITorchError aoti_torch_new_uninitialized_tensor(AtenTensorHandle* ret) { 
   AOTI_TORCH_CONVERT_EXCEPTION_TO_ERROR_CODE({ 
     at::Tensor* out_tensor = new at::Tensor(); 
     *ret = tensor_pointer_to_tensor_handle(out_tensor); 
   }); 
 } 
 Tensor() = default; 
 TensorBase() = default; 
 AOTITorchError aoti_torch_new_uninitialized_tensor(AtenTensorHandle* ret) { 
   AOTI_TORCH_CONVERT_EXCEPTION_TO_ERROR_CODE({ 
     at::Tensor* out_tensor = new at::Tensor(); 
     *ret = tensor_pointer_to_tensor_handle(out_tensor); 
   }); 
 } 
 Tensor() = default; 
 TensorBase() = default; 
     bool defined;
-    AOTI_TORCH_ERROR_CODE_CHECK(aoti_torch_is_defined(ath_.get(), &defined));
+    TORCH_ERROR_CODE_CHECK(aoti_torch_is_defined(ath_.get(), &defined));
     return defined;
   }