Merge TensorImplPtr into TensorPtr.

Summary:
Looks like the users can totally share the same Tensor backed by the same TensorImpl.
That way sharing a Tensor happens naturally, and whoever wants to build a truly separate Tensor would just unsafeGetTensorImpl() and go ahead. Cloning also seems straightforward - just copy the data\metadata from an existing TensorPtr into a new one, like we do now.

Reviewed By: swolchok

Differential Revision: D63557912

fbshipit-source-id: 98939ab410ab4c13ccad1c1d64189ed51fce3621

Author: shoumikhin

docs/source/extension-tensor.md

@@ -31,9 +31,9 @@ You must ensure `sizes`, `dim_order`, `strides`, and `data` stay valid. This mak
 
 ## Introducing TensorPtr
 
-To alleviate these issues, ExecuTorch provides `TensorPtr` and `TensorImplPtr` via the new [Tensor Extension](https://github.com/pytorch/executorch/tree/main/extension/tensor) that manage the lifecycle of tensors and their implementations. These are essentially smart pointers (`std::unique_ptr<Tensor>` and `std::shared_ptr<TensorImpl>`, respectively) that handle the memory management of both the tensor's data and its dynamic metadata.
+To alleviate these issues, ExecuTorch provides `TensorPtr`, a smart pointer that manages the lifecycle of both the tensor's data and its dynamic metadata.
 
-Now, users no longer need to worry about metadata lifetimes separately. Data ownership is determined based on whether it is passed by pointer or moved into the `TensorPtr` as an `std::vector`. Everything is bundled in one place and managed automatically, enabling you to focus on actual computations.
+With `TensorPtr`, users no longer need to worry about metadata lifetimes separately. Data ownership is determined based on whether it is passed by pointer or moved into the `TensorPtr` as an `std::vector`. Everything is bundled in one place and managed automatically, enabling you to focus on actual computations.
 
 Here’s how you can use it:
 
@@ -50,16 +50,13 @@ auto tensor = make_tensor_ptr(
 module.forward(tensor);
 ```
 
-The data is now owned by the tensor instance because it's provided as a vector. To create a non-owning `TensorPtr` just pass the data by pointer. The `type` is deduced automatically based on the data vector (`float`). `strides` and `dim_order` are computed automatically to the default values based on the `sizes` if not specified explicitly as additional arguments.
+The data is now owned by the tensor instance because it's provided as a vector. To create a non-owning `TensorPtr`, just pass the data by pointer. The `type` is deduced automatically based on the data vector (`float`). `strides` and `dim_order` are computed automatically to default values based on the `sizes` if not specified explicitly as additional arguments.
 
 `EValue` in `Module::forward()` accepts `TensorPtr` directly, ensuring seamless integration. `EValue` can now be constructed implicitly with a smart pointer to any type that it can hold. This allows `TensorPtr` to be dereferenced implicitly when passed to `forward()`, and `EValue` will hold the `Tensor` that the `TensorPtr` points to.
 
 ## API Overview
 
-The new API revolves around two main smart pointers:
-
-- `TensorPtr`: `std::unique_ptr` managing a `Tensor` object. Since each `Tensor` instance is unique, `TensorPtr` ensures exclusive ownership.
-- `TensorImplPtr`: `std::shared_ptr` managing a `TensorImpl` object. Multiple `Tensor` instances can share the same `TensorImpl`, so `TensorImplPtr` ensures shared ownership.
+`TensorPtr` is literally an alias for `std::shared_ptr<Tensor>`, so you can work with it easily without duplicating the data and metadata. Each `Tensor` instance may either own its data or reference external data.
 
 ### Creating Tensors
 
@@ -75,15 +72,15 @@ You can create a scalar tensor, i.e. a tensor with zero dimensions or with one o
 auto tensor = make_tensor_ptr(3.14);
 ```
 
-The resulting tensor will contain a single value 3.14 of type double, which is deduced automatically.
+The resulting tensor will contain a single value `3.14` of type double, which is deduced automatically.
 
 *Providing A Single Data Value with a Type*
 
 ```cpp
 auto tensor = make_tensor_ptr(42, ScalarType::Float);
 ```
 
-Now the integer 42 will be cast to float and the tensor will contain a single value 42 of type float.
+Now the integer `42` will be cast to float and the tensor will contain a single value `42` of type float.
 
 #### Owning Data from a Vector
 
@@ -139,7 +136,7 @@ auto tensor = make_tensor_ptr(
     ScalarType::Float);  // float scalar type
 ```
 
-The `TensorPtr` does not own the data, you must ensure the `data` remains valid.
+The `TensorPtr` does not own the data, so you must ensure the `data` remains valid.
 
 *Providing Raw Data with Custom Deleter*
 
@@ -151,36 +148,25 @@ auto tensor = make_tensor_ptr(
     {2, 3},                               // sizes
     data,                                 // data pointer
     ScalarType::Double,                   // double scalar type
-    TensorShapeDynamism::DYNAMIC_BOUND,   // some default dynamism
+    TensorShapeDynamism::DYNAMIC_BOUND,   // default dynamism
     [](void* ptr) { delete[] static_cast<double*>(ptr); });
 ```
 
-The `TensorPtr` will call the custom deleter when it is destroyed, i.e. when the smart pointer is reset and no more references to the underlying `TensorImplPtr` exist.
+The `TensorPtr` will call the custom deleter when it is destroyed, i.e., when the smart pointer is reset and no more references to the underlying `Tensor` exist.
 
 #### Sharing Existing Tensor
 
-You can create a `TensorPtr` by wrapping an existing `TensorImplPtr`, and the latter can be created with the same collection of APIs as `TensorPtr`. Any changes made to `TensorImplPtr` or any `TensorPtr` sharing the same `TensorImplPtr` are reflected across all.
-
-*Sharing Existing TensorImplPtr*
-
-```cpp
-auto tensor_impl = make_tensor_impl_ptr(
-    {2, 3},
-    {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f});
-auto tensor = make_tensor_ptr(tensor_impl);
-auto tensor_copy = make_tensor_ptr(tensor_impl);
-```
-
-Both `tensor` and `tensor_copy` share the underlying `TensorImplPtr`, reflecting changes to data but not to metadata.
-
-Also, you can create a new `TensorPtr` that shares the same `TensorImplPtr` as an existing `TensorPtr`.
+Since `TensorPtr` is a `std::shared_ptr<Tensor>`, you can easily create a `TensorPtr` that shares an existing `Tensor`. Any changes made to the shared data are reflected across all instances sharing the same data.
 
 *Sharing Existing TensorPtr*
 
 ```cpp
-auto tensor_copy = make_tensor_ptr(tensor);
+auto tensor = make_tensor_ptr({2, 3}, {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f});
+auto tensor_copy = tensor;
 ```
 
+Now `tensor` and `tensor_copy` point to the same data and metadata.
+
 #### Viewing Existing Tensor
 
 You can create a `TensorPtr` from an existing `Tensor`, copying its properties and referencing the same data.
@@ -203,11 +189,11 @@ Tensor original_tensor = /* some existing tensor */;
 auto tensor = clone_tensor_ptr(original_tensor);
 ```
 
-The newly created `TensorPtr` has its own copy of the data, so can modify and manage it independently.
+The newly created `TensorPtr` has its own copy of the data, so it can modify and manage it independently.
 Likewise, you can create a clone of an existing `TensorPtr`.
 
 ```cpp
-auto original_tensor = make_tensor_ptr();
+auto original_tensor = make_tensor_ptr(/* ... */);
 auto tensor = clone_tensor_ptr(original_tensor);
 ```
 
@@ -219,9 +205,9 @@ The `TensorShapeDynamism` enum specifies the mutability of a tensor's shape:
 
 - `STATIC`: The tensor's shape cannot be changed.
 - `DYNAMIC_BOUND`: The tensor's shape can be changed but cannot contain more elements than it originally had at creation based on the initial sizes.
-- `DYNAMIC`: The tensor's shape can be changed arbitrarily. Note that, currently, `DYNAMIC` is an alias for `DYNAMIC_BOUND`.
+- `DYNAMIC`: The tensor's shape can be changed arbitrarily. Currently, `DYNAMIC` is an alias for `DYNAMIC_BOUND`.
 
-When resizing a tensor, you must respect its dynamism setting. Resizing is only allowed for tensors with `DYNAMIC` or `DYNAMIC_BOUND` shapes, and you cannot resize `DYNAMIC_BOUND` tensor to contain more elements than it had initially.
+When resizing a tensor, you must respect its dynamism setting. Resizing is only allowed for tensors with `DYNAMIC` or `DYNAMIC_BOUND` shapes, and you cannot resize `DYNAMIC_BOUND` tensors to contain more elements than they had initially.
 
 ```cpp
 auto tensor = make_tensor_ptr(
@@ -378,7 +364,7 @@ This also applies when using functions like `set_input()` or `set_output()` that
 
 ## Interoperability with ATen
 
-If your code is compiled with the preprocessor flag `USE_ATEN_LIB` enabled, all the `TensorPtr` APIs will use `at::` APIs under the hood. E.g. `TensorPtr` becomes a `std::unique_ptr<at::Tensor>` and `TensorImplPtr` becomes `c10::intrusive_ptr<at::TensorImpl>`. This allows for seamless integration with [PyTorch ATen](https://pytorch.org/cppdocs) library.
+If your code is compiled with the preprocessor flag `USE_ATEN_LIB` enabled, all the `TensorPtr` APIs will use `at::` APIs under the hood. E.g. `TensorPtr` becomes a `std::shared_ptr<at::Tensor>`. This allows for seamless integration with [PyTorch ATen](https://pytorch.org/cppdocs) library.
 
 ### API Equivalence Table
 
@@ -413,14 +399,13 @@ Here's a table matching `TensorPtr` creation functions with their corresponding
 
 ## Best Practices
 
-- *Manage Lifetimes Carefully*: Even though `TensorPtr` and `TensorImplPtr` handle memory management, you still need to ensure that any non-owned data (e.g., when using `from_blob()`) remains valid while the tensor is in use.
-- *Use Convenience Functions*: Utilize the provided helper functions for common tensor creation patterns to write cleaner and more readable code.
+- *Manage Lifetimes Carefully*: Even though `TensorPtr` handles memory management, ensure that any non-owned data (e.g., when using `from_blob()`) remains valid while the tensor is in use.
+- *Use Convenience Functions*: Utilize helper functions for common tensor creation patterns to write cleaner and more readable code.
 - *Be Aware of Data Ownership*: Know whether your tensor owns its data or references external data to avoid unintended side effects or memory leaks.
-- *Ensure TensorPtr Outlives EValue*: When passing tensors to modules that expect `EValue`, make sure the `TensorPtr` remains valid as long as the `EValue` is in use.
-- *Understand Scalar Types*: Be mindful of the scalar types when creating tensors, especially when casting between types.
+- *Ensure `TensorPtr` Outlives `EValue`*: When passing tensors to modules that expect `EValue`, ensure that the `TensorPtr` remains valid as long as the `EValue` is in use.
 
 ## Conclusion
 
-The `TensorPtr` and `TensorImplPtr` in ExecuTorch simplify tensor memory management by bundling the data and dynamic metadata into smart pointers. This design eliminates the need for users to manage multiple pieces of data and ensures safer and more maintainable code.
+The `TensorPtr` in ExecuTorch simplifies tensor memory management by bundling the data and dynamic metadata into a smart pointer. This design eliminates the need for users to manage multiple pieces of data and ensures safer and more maintainable code.
 
 By providing interfaces similar to PyTorch's ATen library, ExecuTorch simplifies the adoption of the new API, allowing developers to transition without a steep learning curve.

extension/tensor/targets.bzl

@@ -13,13 +13,11 @@ def define_common_targets():
         runtime.cxx_library(
             name = "tensor" + aten_suffix,
             srcs = [
-                "tensor_impl_ptr.cpp",
                 "tensor_ptr.cpp",
                 "tensor_ptr_maker.cpp",
             ],
             exported_headers = [
                 "tensor.h",
-                "tensor_impl_ptr.h",
                 "tensor_ptr.h",
                 "tensor_ptr_maker.h",
             ],

extension/tensor/tensor.h

@@ -9,6 +9,5 @@
 #pragma once
 
 // Umbrella header for the Tensor extension.
-#include <executorch/extension/tensor/tensor_impl_ptr.h>
 #include <executorch/extension/tensor/tensor_ptr.h>
 #include <executorch/extension/tensor/tensor_ptr_maker.h>