replace c10 intarrayref with et

Author: Gasoonjia

backends/cuda/runtime/aoti_delegate_handle.h

@@ -17,7 +17,6 @@ namespace backends {
 namespace cuda {
 
 using executorch::runtime::Error;
-using executorch::runtime::etensor::Tensor;
 
 extern "C" {
 

backends/cuda/runtime/shims/aoti_runtime/model_container.h renamed to backends/cuda/runtime/shims/aoti_runtime/_model_container.h

@@ -199,8 +199,8 @@ AOTI_TORCH_EXPORT AOTITorchError aoti_torch_create_tensor_from_blob(
     const int64_t *strides_ptr, int64_t storage_offset, int32_t dtype,
     int32_t device_type, int32_t device_index,
     AtenTensorHandle *ret_new_tensor) {
-  executorch::backends::cuda::c10::IntArrayRef sizes(sizes_ptr, ndim);
-  executorch::backends::cuda::c10::IntArrayRef strides(strides_ptr, ndim);
+  executorch::aten::IntArrayRef sizes(sizes_ptr, ndim);
+  executorch::aten::IntArrayRef strides(strides_ptr, ndim);
   *ret_new_tensor =
       new executorch::backends::cuda::slim::SlimTensor(executorch::backends::cuda::slim::from_blob(
           data, sizes, strides, static_cast<executorch::backends::cuda::c10::ScalarType>(dtype),
@@ -216,8 +216,8 @@ AOTI_TORCH_EXPORT AOTITorchError aoti_torch_create_tensor_from_blob_v2(
     int32_t device_type, int32_t device_index, AtenTensorHandle *ret_new_tensor,
     int32_t layout, const uint8_t *opaque_metadata,
     int64_t opaque_metadata_size) {
-  executorch::backends::cuda::c10::IntArrayRef sizes(sizes_ptr, ndim);
-  executorch::backends::cuda::c10::IntArrayRef strides(strides_ptr, ndim);
+  executorch::aten::IntArrayRef sizes(sizes_ptr, ndim);
+  executorch::aten::IntArrayRef strides(strides_ptr, ndim);
   *ret_new_tensor =
       new executorch::backends::cuda::slim::SlimTensor(executorch::backends::cuda::slim::from_blob(
           data, sizes, strides, static_cast<executorch::backends::cuda::c10::ScalarType>(dtype),
@@ -231,8 +231,8 @@ AOTI_TORCH_EXPORT AOTITorchError aoti_torch_empty_strided(
     int64_t ndim, const int64_t *sizes_ptr, const int64_t *strides_ptr,
     int32_t dtype, int32_t device_type, int32_t device_index,
     AtenTensorHandle *ret_new_tensor) {
-  executorch::backends::cuda::c10::IntArrayRef sizes(sizes_ptr, ndim);
-  executorch::backends::cuda::c10::IntArrayRef strides(strides_ptr, ndim);
+  executorch::aten::IntArrayRef sizes(sizes_ptr, ndim);
+  executorch::aten::IntArrayRef strides(strides_ptr, ndim);
   auto empty_strided = executorch::backends::cuda::slim::empty_strided(
           sizes, strides, static_cast<executorch::backends::cuda::c10::ScalarType>(dtype),
           {static_cast<executorch::backends::cuda::c10::DeviceType>(device_type),
@@ -246,8 +246,8 @@ AOTI_TORCH_EXPORT AOTITorchError aoti_torch__reinterpret_tensor(
     AtenTensorHandle self, int64_t ndim, const int64_t *sizes_ptr,
     const int64_t *strides_ptr, int64_t offset_increment,
     AtenTensorHandle *ret_new_tensor) {
-  executorch::backends::cuda::c10::IntArrayRef sizes(sizes_ptr, ndim);
-  executorch::backends::cuda::c10::IntArrayRef strides(strides_ptr, ndim);
+  executorch::aten::IntArrayRef sizes(sizes_ptr, ndim);
+  executorch::aten::IntArrayRef strides(strides_ptr, ndim);
   *ret_new_tensor = new executorch::backends::cuda::slim::SlimTensor(
       self->storage(), sizes, strides, self->dtype(),
       self->storage_offset() + offset_increment);
@@ -257,8 +257,8 @@ AOTI_TORCH_EXPORT AOTITorchError aoti_torch__reinterpret_tensor(
 AOTI_TORCH_EXPORT AOTITorchError
 aoti_torch_as_strided(AtenTensorHandle self, const int64_t *sizes_ptr,
                       const int64_t *strides_ptr, AtenTensorHandle *ret) {
-  executorch::backends::cuda::c10::IntArrayRef sizes(sizes_ptr, self->dim());
-  executorch::backends::cuda::c10::IntArrayRef strides(strides_ptr, self->dim());
+  executorch::aten::IntArrayRef sizes(sizes_ptr, self->dim());
+  executorch::aten::IntArrayRef strides(strides_ptr, self->dim());
   *ret = new executorch::backends::cuda::slim::SlimTensor(
       self->storage(), sizes, strides, self->dtype(), self->storage_offset());
   return AOTI_TORCH_SUCCESS;

backends/cuda/runtime/shims/aoti_torch/tensor_converter.h renamed to backends/cuda/runtime/shims/aoti_torch/_tensor_converter.h

@@ -10,21 +10,21 @@
 namespace executorch::backends::cuda::slim {
 // The returned SlimTensor owns the underlying storage
 inline SlimTensor
-empty_strided(executorch::backends::cuda::c10::IntArrayRef sizes,
-              executorch::backends::cuda::c10::IntArrayRef strides,
+empty_strided(executorch::aten::IntArrayRef sizes,
+              executorch::aten::IntArrayRef strides,
               executorch::backends::cuda::c10::ScalarType dtype,
               const executorch::backends::cuda::c10::Device &device = CPU_DEVICE) {
   Storage storage = new_storage(sizes, strides, dtype, device);
   return SlimTensor(std::move(storage), sizes, strides, dtype, 0);
 }
 
-inline SlimTensor empty(executorch::backends::cuda::c10::IntArrayRef sizes,
-                        executorch::backends::cuda::c10::ScalarType dtype,
-                        const executorch::backends::cuda::c10::Device &device = CPU_DEVICE) {
+inline SlimTensor empty(executorch::aten::IntArrayRef sizes,
+                       executorch::backends::cuda::c10::ScalarType dtype,
+                       const executorch::backends::cuda::c10::Device& device) {
   std::vector<int64_t> contig_strides =
-      executorch::backends::cuda::slim::compute_contiguous_strides(sizes);
-  Storage storage = new_storage(sizes, contig_strides, dtype, device);
-  return SlimTensor(std::move(storage), sizes, contig_strides, dtype, 0);
+      executorch::backends::cuda::slim::compute_contiguous_strides(et_to_c10(sizes));
+  Storage storage = new_storage(sizes, vec_to_et(contig_strides), dtype, device);
+  return SlimTensor(std::move(storage), sizes, vec_to_et(contig_strides), dtype, 0);
 }
 
 inline SlimTensor empty_like(const SlimTensor &other) {

backends/cuda/runtime/shims/aoti_torch/c/shim.h

@@ -3,7 +3,7 @@
 #include <executorch/backends/cuda/runtime/slim/core/Empty.h>
 
 namespace executorch::backends::cuda::slim {
-inline SlimTensor zeros(executorch::backends::cuda::c10::IntArrayRef sizes,
+inline SlimTensor zeros(executorch::aten::IntArrayRef sizes,
                         executorch::backends::cuda::c10::ScalarType dtype,
                         const executorch::backends::cuda::c10::Device &device = CPU_DEVICE) {
   SlimTensor tensor = empty(sizes, dtype, device);
@@ -15,7 +15,7 @@ inline SlimTensor zeros_like(const SlimTensor &other) {
   return zeros(other.sizes(), other.dtype(), other.device());
 }
 
-inline SlimTensor ones(executorch::backends::cuda::c10::IntArrayRef sizes,
+inline SlimTensor ones(executorch::aten::IntArrayRef sizes,
                        executorch::backends::cuda::c10::ScalarType dtype,
                        const executorch::backends::cuda::c10::Device &device = CPU_DEVICE) {
   SlimTensor tensor = empty(sizes, dtype, device);

backends/cuda/runtime/slim/core/Empty.h

@@ -5,8 +5,8 @@
 namespace executorch::backends::cuda::slim {
 
 // The returned SlimTensor does not own the underlying storage
-inline SlimTensor from_blob(void *data, executorch::backends::cuda::c10::IntArrayRef sizes,
-                            executorch::backends::cuda::c10::IntArrayRef strides,
+inline SlimTensor from_blob(void *data, executorch::aten::IntArrayRef sizes,
+                            executorch::aten::IntArrayRef strides,
                             executorch::backends::cuda::c10::ScalarType dtype,
                             const executorch::backends::cuda::c10::Device &device = CPU_DEVICE,
                             int64_t storage_offset = 0) {
@@ -19,13 +19,13 @@ inline SlimTensor from_blob(void *data, executorch::backends::cuda::c10::IntArra
   return SlimTensor(std::move(storage), sizes, strides, dtype, storage_offset);
 }
 
-inline SlimTensor from_blob(void *data, executorch::backends::cuda::c10::IntArrayRef sizes,
+inline SlimTensor from_blob(void *data, executorch::aten::IntArrayRef sizes,
                             executorch::backends::cuda::c10::ScalarType dtype,
-                            const executorch::backends::cuda::c10::Device &device = CPU_DEVICE,
-                            int64_t storage_offset = 0) {
+                            const executorch::backends::cuda::c10::Device& device,
+                            int64_t storage_offset) {
   std::vector<int64_t> contig_strides =
-      executorch::backends::cuda::slim::compute_contiguous_strides(sizes);
-  return from_blob(data, sizes, contig_strides, dtype, device, storage_offset);
+      executorch::backends::cuda::slim::compute_contiguous_strides(et_to_c10(sizes));
+  return from_blob(data, sizes, vec_to_et(contig_strides), dtype, device, storage_offset);
 }
 
 } // namespace executorch::backends::cuda::slim

backends/cuda/runtime/slim/core/Factory.h

@@ -5,11 +5,11 @@
 namespace executorch::backends::cuda::slim {
 
 inline SlimTensor constant_pad_nd(const SlimTensor &self,
-                                  executorch::backends::cuda::c10::IntArrayRef pad,
+                                  executorch::aten::IntArrayRef pad,
                                   const executorch::backends::cuda::c10::Scalar &value) {
   STANDALONE_CHECK(pad.size() % 2 == 0, "Length of pad must be even");
 
-  executorch::backends::cuda::c10::IntArrayRef input_sizes = self.sizes();
+  executorch::aten::IntArrayRef input_sizes = self.sizes();
   int64_t l_inp = self.dim();
   int64_t l_pad = static_cast<int64_t>(pad.size()) / 2;
   int64_t l_diff = l_inp - l_pad;
@@ -81,7 +81,7 @@ inline SlimTensor constant_pad_nd(const SlimTensor &self,
   return output;
 }
 
-inline SlimTensor pad(const SlimTensor &self, executorch::backends::cuda::c10::IntArrayRef pad,
+inline SlimTensor pad(const SlimTensor &self, executorch::aten::IntArrayRef pad,
                       std::string_view mode, std::optional<double> value) {
   if (mode == "constant") {
     return constant_pad_nd(self, pad, value.value_or(0.0));

backends/cuda/runtime/slim/core/FromBlob.h

@@ -17,6 +17,7 @@
 #include <executorch/backends/cuda/runtime/c10/util/safe_numerics.h>
 #include <executorch/backends/cuda/runtime/slim/core/Storage.h>
 #include <executorch/backends/cuda/runtime/slim/util/SizeUtil.h>
+#include <executorch/backends/cuda/runtime/slim/util/ArrayRefUtil.h>
 #include <executorch/runtime/core/exec_aten/exec_aten.h>
 
 namespace executorch::backends::cuda::slim {
@@ -55,8 +56,8 @@ class SlimTensor {
  public:
   SlimTensor(
       Storage&& storage,
-      executorch::backends::cuda::c10::IntArrayRef sizes,
-      executorch::backends::cuda::c10::IntArrayRef strides,
+      executorch::aten::IntArrayRef sizes,
+      executorch::aten::IntArrayRef strides,
       executorch::backends::cuda::c10::ScalarType dtype,
       int64_t storage_offset = 0)
       : storage_(std::move(storage)),
@@ -99,14 +100,11 @@ class SlimTensor {
 
     // Create a non-owning storage that wraps the ETensor's data
     // ETensor is guaranteed to be on CPU
-    Storage storage(new MaybeOwningStorage(
-        CPU_DEVICE,
-        data_ptr,
-        etensor->nbytes()
-        ));
+    Storage storage(
+        new MaybeOwningStorage(CPU_DEVICE, data_ptr, etensor->nbytes()));
 
     // Initialize the SlimTensor with the wrapped storage
-    *this = SlimTensor(std::move(storage), sizes, strides, slim_dtype, 0);
+    *this = SlimTensor(std::move(storage), vec_to_et(sizes), vec_to_et(strides), slim_dtype, 0);
   }
 
   SlimTensor(const SlimTensor&) = default;
@@ -134,8 +132,8 @@ class SlimTensor {
     return executorch::backends::cuda::c10::elementSize(dtype_);
   }
 
-  executorch::backends::cuda::c10::IntArrayRef sizes() const {
-    return sizes_and_strides_.sizes_arrayref();
+  executorch::aten::IntArrayRef sizes() const {
+    return c10_to_et(sizes_and_strides_.sizes_arrayref());
   }
 
   int64_t size(int64_t dim) const {
@@ -144,8 +142,8 @@ class SlimTensor {
     return sizes_and_strides_.size_at(static_cast<size_t>(wrapped_dim));
   }
 
-  executorch::backends::cuda::c10::IntArrayRef strides() const {
-    return sizes_and_strides_.strides_arrayref();
+  executorch::aten::IntArrayRef strides() const {
+    return c10_to_et(sizes_and_strides_.strides_arrayref());
   }
 
   int64_t stride(int64_t dim) const {
@@ -213,8 +211,8 @@ class SlimTensor {
   }
 
   void set_sizes_and_strides(
-      executorch::backends::cuda::c10::IntArrayRef sizes,
-      executorch::backends::cuda::c10::IntArrayRef strides,
+      executorch::aten::IntArrayRef sizes,
+      executorch::aten::IntArrayRef strides,
       std::optional<int64_t> storage_offset = std::nullopt) {
     const int64_t new_dim = static_cast<int64_t>(sizes.size());
     STANDALONE_CHECK(
@@ -225,8 +223,8 @@ class SlimTensor {
         strides.size(),
         ")");
 
-    std::vector<int64_t> new_sizes = sizes.vec();
-    std::vector<int64_t> new_strides = strides.vec();
+    std::vector<int64_t> new_sizes = to_vec(sizes);
+    std::vector<int64_t> new_strides = to_vec(strides);
 
     // stride calculation logic
     bool overflowed = false;
@@ -259,8 +257,7 @@ class SlimTensor {
     refresh_contiguous();
   }
 
-  void set_sizes_contiguous(
-      executorch::backends::cuda::c10::IntArrayRef new_size) {
+  void set_sizes_contiguous(executorch::aten::IntArrayRef new_size) {
     sizes_and_strides_.set_sizes(new_size);
     refresh_numel();
     empty_tensor_restride(
@@ -271,7 +268,7 @@ class SlimTensor {
       executorch::backends::cuda::c10::MemoryFormat memory_format);
 
   SlimTensor resize_(
-      executorch::backends::cuda::c10::IntArrayRef sizes,
+      executorch::aten::IntArrayRef sizes,
       std::optional<c10::MemoryFormat> optional_memory_format);
 
   // Conversion operations
@@ -283,8 +280,8 @@ class SlimTensor {
     Storage new_storage(new MaybeOwningStorage(storage_->clone(device)));
     return SlimTensor(
         std::move(new_storage),
-        sizes_and_strides_.sizes_arrayref(),
-        sizes_and_strides_.strides_arrayref(),
+        c10_to_et(sizes_and_strides_.sizes_arrayref()),
+        c10_to_et(sizes_and_strides_.strides_arrayref()),
         dtype_,
         storage_offset_);
   }
@@ -525,34 +522,32 @@ class SlimTensor {
         executorch::backends::cuda::slim::compute_contiguous_strides(
             this->sizes());
     return _clone_impl(
-        this->sizes(), contig_strides, this->dtype(), this->device());
+        this->sizes(), vec_to_et(contig_strides), this->dtype(), this->device());
   }
 
   // View operations
   SlimTensor as_strided(
-      executorch::backends::cuda::c10::IntArrayRef sizes,
-      executorch::backends::cuda::c10::IntArrayRef strides,
+      executorch::aten::IntArrayRef sizes,
+      executorch::aten::IntArrayRef strides,
       int64_t storage_offset) const;
   SlimTensor as_strided_(
-      executorch::backends::cuda::c10::IntArrayRef sizes,
-      executorch::backends::cuda::c10::IntArrayRef strides,
+      executorch::aten::IntArrayRef sizes,
+      executorch::aten::IntArrayRef strides,
       int64_t storage_offset);
 
-  SlimTensor permute(executorch::backends::cuda::c10::IntArrayRef dims) const;
+  SlimTensor permute(executorch::aten::IntArrayRef dims) const;
 
   // Transpose operations
   SlimTensor transpose() const;
   SlimTensor transpose(int64_t dim0, int64_t dim1) const;
   SlimTensor t() const;
 
-  SlimTensor reshape(
-      executorch::backends::cuda::c10::IntArrayRef proposed_shape) const;
+  SlimTensor reshape(executorch::aten::IntArrayRef proposed_shape) const;
 
   SlimTensor narrow(int64_t dim, int64_t start, int64_t length) const;
 
   // Generic element access returning SlimTensor
-  SlimTensor operator[](
-      executorch::backends::cuda::c10::IntArrayRef indices) const {
+  SlimTensor operator[](executorch::aten::IntArrayRef indices) const {
     STANDALONE_CHECK(
         indices.size() <= this->dim(),
         "Number of indices (",
@@ -597,21 +592,21 @@ class SlimTensor {
       int64_t new_storage_offset = this->storage_offset_ + offset_adjustment;
       return SlimTensor(
           Storage(this->storage_),
-          new_sizes,
-          new_strides,
+          vec_to_et(new_sizes),
+          vec_to_et(new_strides),
           this->dtype_,
           new_storage_offset);
     }
   }
 
   // Convenience overload for single index
   SlimTensor operator[](int64_t index) const {
-    return (*this)[executorch::backends::cuda::c10::IntArrayRef{index}];
+    return (*this)[executorch::aten::IntArrayRef{index}];
   }
 
   // Convenience overloads for common multi-dimensional cases
   SlimTensor operator[](std::initializer_list<int64_t> indices) const {
-    return (*this)[executorch::backends::cuda::c10::IntArrayRef(indices)];
+    return (*this)[initlist_to_et(indices)];
   }
 
   // Extract scalar value from 0-dimensional tensor
@@ -667,8 +662,8 @@ class SlimTensor {
 
  private:
   SlimTensor _clone_impl(
-      executorch::backends::cuda::c10::IntArrayRef sizes,
-      executorch::backends::cuda::c10::IntArrayRef strides,
+      executorch::aten::IntArrayRef sizes,
+      executorch::aten::IntArrayRef strides,
       executorch::backends::cuda::c10::ScalarType dtype,
       const executorch::backends::cuda::c10::Device& device) const {
     Storage storage = new_storage(sizes, strides, dtype, device);
@@ -679,7 +674,7 @@ class SlimTensor {
   }
 
   void refresh_numel() {
-    numel_ = compute_numel(sizes_and_strides_.sizes_arrayref());
+    numel_ = compute_numel(c10_to_et(sizes_and_strides_.sizes_arrayref()));
   }
 
   bool compute_is_contiguous() const {