[ET-VK] Move GPUMemoryLayout and StorageType to utils/

```
find . -type f -exec sed -i 's/vkapi::kBuffer/utils::kBuffer/g' {} +
find . -type f -exec sed -i 's/vkapi::kTexture/utils::kTexture/g' {} +
find . -type f -exec sed -i 's/vkapi::kWidthPacked/utils::kWidthPacked/g' {} +
find . -type f -exec sed -i 's/vkapi::kHeightPacked/utils::kHeightPacked/g' {} +
find . -type f -exec sed -i 's/vkapi::kChannelsPacked/utils::kChannelsPacked/g' {} +
find . -type f -exec sed -i 's/vkapi::to_packed_dim_nchw_offset/utils::to_packed_dim_nchw_offset/g' {} +
find . -type f -exec sed -i 's/vkapi::GPUMemoryLayout/utils::GPUMemoryLayout/g' {} +
find . -type f -exec sed -i 's/vkapi::StorageType/utils::StorageType/g' {} +
```

Differential Revision: [D59527913](https://our.internmc.facebook.com/intern/diff/D59527913/)

[ghstack-poisoned]

Author: jorgep31415

backends/vulkan/runtime/VulkanBackend.cpp

@@ -76,30 +76,30 @@ vkapi::ScalarType get_scalar_type(const vkgraph::VkDataType& vk_datatype) {
   }
 }
 
-vkapi::StorageType get_storage_type(
+utils::StorageType get_storage_type(
     const vkgraph::VkStorageType& vk_storage_type) {
   switch (vk_storage_type) {
     case vkgraph::VkStorageType::BUFFER:
-      return vkapi::kBuffer;
+      return utils::kBuffer;
     case vkgraph::VkStorageType::TEXTURE_3D:
-      return vkapi::kTexture3D;
+      return utils::kTexture3D;
     case vkgraph::VkStorageType::TEXTURE_2D:
-      return vkapi::kTexture2D;
+      return utils::kTexture2D;
     default:
       break;
   }
   VK_THROW("Invalid storage type encountered!");
 }
 
-vkapi::GPUMemoryLayout get_memory_layout(
+utils::GPUMemoryLayout get_memory_layout(
     const vkgraph::VkMemoryLayout& vk_memory_layout) {
   switch (vk_memory_layout) {
     case vkgraph::VkMemoryLayout::TENSOR_WIDTH_PACKED:
-      return vkapi::kWidthPacked;
+      return utils::kWidthPacked;
     case vkgraph::VkMemoryLayout::TENSOR_HEIGHT_PACKED:
-      return vkapi::kHeightPacked;
+      return utils::kHeightPacked;
     case vkgraph::VkMemoryLayout::TENSOR_CHANNELS_PACKED:
-      return vkapi::kChannelsPacked;
+      return utils::kChannelsPacked;
     default:
       break;
   }
@@ -115,16 +115,16 @@ GraphConfig get_graph_config(ArrayRef<CompileSpec>& compile_specs) {
     if (strcmp(spec.key, "storage_type_override") == 0) {
       ET_CHECK_MSG(value_size == sizeof(int32_t), "Unexpected value size!");
       int value_as_int = static_cast<int>(getUInt32LE(value_data));
-      vkapi::StorageType storage_type =
-          static_cast<vkapi::StorageType>(value_as_int);
+      utils::StorageType storage_type =
+          static_cast<utils::StorageType>(value_as_int);
 
       config.set_storage_type_override(storage_type);
     }
     if (strcmp(spec.key, "memory_layout_override") == 0) {
       ET_CHECK_MSG(value_size == sizeof(uint32_t), "Unexpected value size!");
       uint32_t value_as_int = getUInt32LE(value_data);
-      vkapi::GPUMemoryLayout memory_layout =
-          static_cast<vkapi::GPUMemoryLayout>(value_as_int);
+      utils::GPUMemoryLayout memory_layout =
+          static_cast<utils::GPUMemoryLayout>(value_as_int);
 
       config.set_memory_layout_override(memory_layout);
     }
@@ -172,15 +172,15 @@ class GraphBuilder {
 
   void add_tensor_to_graph(const uint32_t fb_id, VkTensorPtr tensor_fb) {
     const vkapi::ScalarType& dtype = get_scalar_type(tensor_fb->datatype());
-    vkapi::StorageType storage_type =
+    utils::StorageType storage_type =
         tensor_fb->storage_type() == vkgraph::VkStorageType::DEFAULT_STORAGE
         ? compute_graph_->suggested_storage_type()
         : get_storage_type(tensor_fb->storage_type());
 
     UIntVector dims_fb = tensor_fb->dims();
     const std::vector<int64_t> dims_vector(dims_fb->cbegin(), dims_fb->cend());
 
-    vkapi::GPUMemoryLayout memory_layout =
+    utils::GPUMemoryLayout memory_layout =
         tensor_fb->memory_layout() == vkgraph::VkMemoryLayout::DEFAULT_LAYOUT
         ? compute_graph_->suggested_memory_layout(dims_vector)
         : get_memory_layout(tensor_fb->memory_layout());

backends/vulkan/runtime/api/Tensor.cpp

@@ -15,10 +15,10 @@ namespace api {
 
 std::vector<int64_t> calculate_strides(
     const std::vector<int64_t>& sizes,
-    const vkapi::GPUMemoryLayout memory_layout,
+    const utils::GPUMemoryLayout memory_layout,
     const bool texel_strides) {
   const int64_t dim_offset =
-      vkapi::to_packed_dim_nchw_offset<int64_t>(memory_layout);
+      utils::to_packed_dim_nchw_offset<int64_t>(memory_layout);
   const int64_t last_dim = sizes.size() - dim_offset;
   VK_CHECK_COND(last_dim >= 0);
 
@@ -45,7 +45,7 @@ std::vector<int64_t> calculate_strides(
 
 std::vector<int64_t> calculate_padded_sizes(
     const std::vector<int64_t>& sizes,
-    const vkapi::GPUMemoryLayout memory_layout) {
+    const utils::GPUMemoryLayout memory_layout) {
   int64_t ndim = sizes.size();
   if (ndim == 0) {
     ndim = 1;
@@ -60,7 +60,7 @@ std::vector<int64_t> calculate_padded_sizes(
 
   // Pad the packed dim to the next multiple of 4.
   const int64_t dim_offset =
-      vkapi::to_packed_dim_nchw_offset<int64_t>(memory_layout);
+      utils::to_packed_dim_nchw_offset<int64_t>(memory_layout);
   const int64_t padded_dim_size = utils::val_at(-dim_offset, sizes);
   padded_sizes.at(ndim_up4 - dim_offset) = utils::align_up_4(padded_dim_size);
 
@@ -69,7 +69,7 @@ std::vector<int64_t> calculate_padded_sizes(
 
 utils::uvec3 calculate_image_extents(
     const std::vector<int64_t>& padded_sizes,
-    const vkapi::GPUMemoryLayout memory_layout) {
+    const utils::GPUMemoryLayout memory_layout) {
   VK_CHECK_COND(padded_sizes.size() == 4);
 
   uint32_t N = utils::safe_downcast<uint32_t>(padded_sizes.at(0));
@@ -78,15 +78,15 @@ utils::uvec3 calculate_image_extents(
   uint32_t W = utils::safe_downcast<uint32_t>(padded_sizes.at(3));
 
   switch (memory_layout) {
-    case vkapi::kWidthPacked:
+    case utils::kWidthPacked:
       VK_CHECK_COND(W % 4 == 0);
       W /= 4;
       break;
-    case vkapi::kHeightPacked:
+    case utils::kHeightPacked:
       VK_CHECK_COND(H % 4 == 0);
       H /= 4;
       break;
-    case vkapi::kChannelsPacked:
+    case utils::kChannelsPacked:
       VK_CHECK_COND(C % 4 == 0);
       C /= 4;
       break;
@@ -103,8 +103,8 @@ vTensor::vTensor(
     Context* const context,
     const std::vector<int64_t>& sizes,
     const vkapi::ScalarType dtype,
-    const vkapi::StorageType storage_type,
-    const vkapi::GPUMemoryLayout memory_layout,
+    const utils::StorageType storage_type,
+    const utils::GPUMemoryLayout memory_layout,
     const bool allocate_memory)
     : dtype_(dtype),
       memory_layout_(memory_layout),
@@ -125,7 +125,7 @@ vTensor::vTensor(
           padded_sizes_,
           dtype_,
           allocate_memory) {
-  if (storage_type != vkapi::kBuffer) {
+  if (storage_type != utils::kBuffer) {
     texture_limits_.limits = utils::ivec3{
         utils::safe_downcast<int32_t>(storage_.image_extents_.data[0]),
         utils::safe_downcast<int32_t>(storage_.image_extents_.data[1]),
@@ -204,33 +204,33 @@ const vkapi::BufferBindInfo vTensor::ntexels_ubo() {
 
 VmaAllocationCreateInfo vTensor::get_allocation_create_info() const {
   switch (storage_type()) {
-    case vkapi::kBuffer:
+    case utils::kBuffer:
       return storage_.buffer_.allocation_create_info();
-    case vkapi::kTexture2D:
-    case vkapi::kTexture3D:
+    case utils::kTexture2D:
+    case utils::kTexture3D:
       return storage_.image_.allocation_create_info();
   }
   return {};
 }
 
 VkMemoryRequirements vTensor::get_memory_requirements() const {
   switch (storage_type()) {
-    case vkapi::kBuffer:
+    case utils::kBuffer:
       return storage_.buffer_.get_memory_requirements();
-    case vkapi::kTexture2D:
-    case vkapi::kTexture3D:
+    case utils::kTexture2D:
+    case utils::kTexture3D:
       return storage_.image_.get_memory_requirements();
   }
   return {};
 }
 
 void vTensor::bind_allocation(const vkapi::Allocation& allocation) {
   switch (storage_type()) {
-    case vkapi::kBuffer:
+    case utils::kBuffer:
       storage_.buffer_.bind_allocation(allocation);
       break;
-    case vkapi::kTexture2D:
-    case vkapi::kTexture3D:
+    case utils::kTexture2D:
+    case utils::kTexture3D:
       storage_.image_.bind_allocation(allocation);
       break;
   }
@@ -275,7 +275,7 @@ void vTensor::reallocate(const std::vector<int64_t>& new_sizes) {
 }
 
 void vTensor::virtual_resize(const std::vector<int64_t>& new_sizes) {
-  if (storage_type() != vkapi::kBuffer) {
+  if (storage_type() != utils::kBuffer) {
     // For texture storage check that the current texture is large enough for
     // the new sizes of the tensor.
     utils::uvec3 virtual_extents =
@@ -302,7 +302,7 @@ void vTensor::virtual_resize(const std::vector<int64_t>& new_sizes) {
 vkapi::VulkanImage allocate_image(
     Context* const context_ptr,
     utils::uvec3& image_extents,
-    const vkapi::StorageType storage_type,
+    const utils::StorageType storage_type,
     const VkFormat image_format,
     const bool allocate_memory) {
   vkapi::Adapter* adapter_ptr = context_ptr->adapter_ptr();
@@ -318,11 +318,11 @@ vkapi::VulkanImage allocate_image(
   VkImageViewType image_view_type;
 
   switch (storage_type) {
-    case vkapi::kTexture3D:
+    case utils::kTexture3D:
       image_type = VK_IMAGE_TYPE_3D;
       image_view_type = VK_IMAGE_VIEW_TYPE_3D;
       break;
-    case vkapi::kTexture2D:
+    case utils::kTexture2D:
       image_type = VK_IMAGE_TYPE_2D;
       image_view_type = VK_IMAGE_VIEW_TYPE_2D;
       break;
@@ -347,13 +347,13 @@ vkapi::VulkanImage allocate_image(
 vkapi::VulkanBuffer allocate_buffer(
     Context* const context_ptr,
     const int64_t numel,
-    const vkapi::StorageType storage_type,
+    const utils::StorageType storage_type,
     const vkapi::ScalarType dtype,
     const bool allocate_memory) {
   vkapi::Adapter* adapter_ptr = context_ptr->adapter_ptr();
 
   switch (storage_type) {
-    case vkapi::kBuffer:
+    case utils::kBuffer:
       break;
     default:
       // Return an empty VulkanBuffer if Buffer storage is not used
@@ -366,8 +366,8 @@ vkapi::VulkanBuffer allocate_buffer(
 
 vTensorStorage::vTensorStorage(
     Context* const context,
-    const vkapi::StorageType storage_type,
-    const vkapi::GPUMemoryLayout gpu_memory_layout,
+    const utils::StorageType storage_type,
+    const utils::GPUMemoryLayout gpu_memory_layout,
     const std::vector<int64_t>& padded_sizes,
     const vkapi::ScalarType dtype,
     const bool allocate_memory)
@@ -458,7 +458,7 @@ void vTensorStorage::transition(
 
 void vTensorStorage::discard_and_reallocate(
     const std::vector<int64_t>& padded_sizes,
-    const vkapi::GPUMemoryLayout gpu_memory_layout,
+    const utils::GPUMemoryLayout gpu_memory_layout,
     const vkapi::ScalarType dtype) {
   const bool image_owns_memory = image_.owns_memory();
   const bool buffer_owns_memory = buffer_.owns_memory();

backends/vulkan/runtime/api/Tensor.h

@@ -13,7 +13,7 @@
 #include <executorch/backends/vulkan/runtime/api/Context.h>
 #include <executorch/backends/vulkan/runtime/api/ParamsBuffer.h>
 
-#include <executorch/backends/vulkan/runtime/vk_api/Types.h>
+#include <executorch/backends/vulkan/runtime/utils/StorageUtils.h>
 
 namespace vkcompute {
 namespace api {
@@ -31,7 +31,7 @@ namespace api {
  */
 std::vector<int64_t> calculate_strides(
     const std::vector<int64_t>& sizes,
-    const vkapi::GPUMemoryLayout memory_layout,
+    const utils::GPUMemoryLayout memory_layout,
     const bool texel_strides = true);
 
 /*
@@ -46,20 +46,20 @@ std::vector<int64_t> calculate_strides(
  *   1. The dimensionality of the tensor will be padded to a multiple of 4.
  *   2. The size of the packed dimension will be padded to a multiple of 4.
  *
- * The "packed dimension" is determined based on the vkapi::GPUMemoryLayout
+ * The "packed dimension" is determined based on the utils::GPUMemoryLayout
  * argument.
  */
 std::vector<int64_t> calculate_padded_sizes(
     const std::vector<int64_t>& sizes,
-    const vkapi::GPUMemoryLayout memory_layout);
+    const utils::GPUMemoryLayout memory_layout);
 
 /*
  * Given the padded sizes of a tensor and the GPU memory layout, calculate the
  * 3D image extents required to store the tensor data as an image texture.
  */
 utils::uvec3 calculate_image_extents(
     const std::vector<int64_t>& padded_sizes,
-    const vkapi::GPUMemoryLayout memory_layout);
+    const utils::GPUMemoryLayout memory_layout);
 
 struct LastAccess {
   vkapi::PipelineStageFlags stage;
@@ -82,8 +82,8 @@ class vTensorStorage final {
 
   vTensorStorage(
       Context* context,
-      const vkapi::StorageType storage_type,
-      const vkapi::GPUMemoryLayout gpu_memory_layout,
+      const utils::StorageType storage_type,
+      const utils::GPUMemoryLayout gpu_memory_layout,
       const std::vector<int64_t>& sizes,
       const vkapi::ScalarType dtype,
       const bool allocate_memory = true);
@@ -102,7 +102,7 @@ class vTensorStorage final {
   // Context
   Context* context_{};
 
-  vkapi::StorageType storage_type_;
+  utils::StorageType storage_type_;
 
   // Resource sizings
   utils::uvec3 image_extents_{};
@@ -135,7 +135,7 @@ class vTensorStorage final {
 
   void discard_and_reallocate(
       const std::vector<int64_t>& padded_sizes,
-      const vkapi::GPUMemoryLayout gpu_memory_layout,
+      const utils::GPUMemoryLayout gpu_memory_layout,
       const vkapi::ScalarType dtype);
 };
 
@@ -152,8 +152,8 @@ class vTensor final {
       Context* context,
       const std::vector<int64_t>& sizes,
       const vkapi::ScalarType dtype,
-      const vkapi::StorageType storage_type = vkapi::kTexture3D,
-      const vkapi::GPUMemoryLayout memory_layout = vkapi::kChannelsPacked,
+      const utils::StorageType storage_type = utils::kTexture3D,
+      const utils::GPUMemoryLayout memory_layout = utils::kChannelsPacked,
       const bool allocate_memory = true);
 
   vTensor(const vTensor& other) = delete;
@@ -164,7 +164,7 @@ class vTensor final {
 
  private:
   vkapi::ScalarType dtype_;
-  vkapi::GPUMemoryLayout memory_layout_;
+  utils::GPUMemoryLayout memory_layout_;
 
   // sizes of the tensor in NCHW dimension order
   std::vector<int64_t> sizes_;
@@ -226,12 +226,12 @@ class vTensor final {
     Metadata
   */
 
-  inline vkapi::StorageType storage_type() const {
+  inline utils::StorageType storage_type() const {
     return storage_.storage_type_;
   }
 
   inline bool has_buffer_storage() const {
-    return storage_.storage_type_ == vkapi::kBuffer;
+    return storage_.storage_type_ == utils::kBuffer;
   }
 
   inline const utils::uvec3& image_extents() const {
@@ -245,7 +245,7 @@ class vTensor final {
     return dtype_;
   }
 
-  inline vkapi::GPUMemoryLayout gpu_memory_layout() const {
+  inline utils::GPUMemoryLayout gpu_memory_layout() const {
     return memory_layout_;
   }