Implement/migrate Arena allocators to cuda plugin ep.

cmake/onnxruntime_providers_cuda_plugin.cmake

@@ -111,6 +111,10 @@ onnxruntime_add_shared_library_module(onnxruntime_providers_cuda_plugin
     ${CUDA_PLUGIN_EP_CC_SRCS}
     ${CUDA_PLUGIN_EP_CU_SRCS}
 )
+
+# Mirror directory structure in the Visual Studio solution tree.
+source_group(TREE ${ONNXRUNTIME_ROOT}/core FILES ${CUDA_EP_CC_SRCS} ${CUDA_EP_CU_SRCS})
+source_group(TREE ${ONNXRUNTIME_ROOT} FILES ${CUDA_CONTRIB_OPS_CC_SRCS} ${CUDA_CONTRIB_OPS_CU_SRCS})
 # Keep the plugin CUDA target aligned with the repo-wide C++20 baseline.
 # Forcing CUDA C++17 here breaks newer protobuf/absl headers used by the plugin
 # build, as absl::compare expects standard ordering support in this configuration.

cmake/onnxruntime_unittests.cmake

@@ -509,6 +509,13 @@ if (onnxruntime_USE_CUDA AND NOT onnxruntime_MINIMAL_BUILD AND NOT onnxruntime_R
     )
   list(APPEND onnxruntime_test_providers_src ${onnxruntime_test_providers_cuda_src})
 
+  if (onnxruntime_BUILD_CUDA_EP_AS_PLUGIN)
+    file(GLOB onnxruntime_test_providers_cuda_plugin_src CONFIGURE_DEPENDS
+      "${TEST_SRC_DIR}/providers/cuda/plugin/*.cc"
+    )
+    list(APPEND onnxruntime_test_providers_src ${onnxruntime_test_providers_cuda_plugin_src})
+  endif()
+
   if (onnxruntime_USE_CUDA_NHWC_OPS AND CUDNN_MAJOR_VERSION GREATER 8)
     file(GLOB onnxruntime_test_providers_cuda_nhwc_src CONFIGURE_DEPENDS
       "${TEST_SRC_DIR}/providers/cuda/nhwc/*.cc"

onnxruntime/core/providers/cuda/plugin/cuda_allocator_plugin.h

@@ -10,6 +10,11 @@
 
 #include "cuda_plugin_utils.h"
 
+#include <algorithm>
+#include <sstream>
+#include <string>
+#include <type_traits>
+
 namespace onnxruntime {
 namespace cuda_plugin {
 
@@ -35,6 +40,51 @@ class CudaAllocatorBase : public OrtAllocator {
   const OrtMemoryInfo* memory_info_;
 };
 
+static_assert(std::is_standard_layout_v<CudaAllocatorBase>,
+              "CudaAllocatorBase must be standard-layout so that OrtAllocator* and "
+              "CudaAllocatorBase* share the same address.");
+
+/// Allocator statistics tracked by arena allocators.
+struct AllocatorStats {
+  int64_t num_allocs = 0;
+  int64_t num_reserves = 0;
+  int64_t num_arena_extensions = 0;
+  int64_t num_arena_shrinkages = 0;
+  int64_t bytes_in_use = 0;
+  int64_t total_allocated_bytes = 0;
+  int64_t max_bytes_in_use = 0;
+  int64_t max_alloc_size = 0;
+  int64_t bytes_limit = 0;
+
+  void ToKeyValuePairs(const OrtApi& api, OrtKeyValuePairs* kvps) const {
+    if (num_allocs > 0 || bytes_limit != 0) {
+      api.AddKeyValuePair(kvps, "Limit", std::to_string(bytes_limit).c_str());
+      api.AddKeyValuePair(kvps, "InUse", std::to_string(bytes_in_use).c_str());
+      api.AddKeyValuePair(kvps, "TotalAllocated", std::to_string(total_allocated_bytes).c_str());
+      api.AddKeyValuePair(kvps, "MaxInUse", std::to_string(max_bytes_in_use).c_str());
+      api.AddKeyValuePair(kvps, "NumAllocs", std::to_string(num_allocs).c_str());
+      api.AddKeyValuePair(kvps, "NumReserves", std::to_string(num_reserves).c_str());
+      api.AddKeyValuePair(kvps, "NumArenaExtensions", std::to_string(num_arena_extensions).c_str());
+      api.AddKeyValuePair(kvps, "NumArenaShrinkages", std::to_string(num_arena_shrinkages).c_str());
+      api.AddKeyValuePair(kvps, "MaxAllocSize", std::to_string(max_alloc_size).c_str());
+    }
+  }
+
+  std::string DebugString() const {
+    std::ostringstream ss;
+    ss << "Limit:                    " << bytes_limit << "\n"
+       << "InUse:                    " << bytes_in_use << "\n"
+       << "TotalAllocated:           " << total_allocated_bytes << "\n"
+       << "MaxInUse:                 " << max_bytes_in_use << "\n"
+       << "NumAllocs:                " << num_allocs << "\n"
+       << "NumReserves:              " << num_reserves << "\n"
+       << "NumArenaExtensions:       " << num_arena_extensions << "\n"
+       << "NumArenaShrinkages:       " << num_arena_shrinkages << "\n"
+       << "MaxAllocSize:             " << max_alloc_size << "\n";
+    return ss.str();
+  }
+};
+
 /// CUDA device memory allocator using cudaMalloc/cudaFree.
 /// Lifetime is managed by the EP factory (ReleaseAllocatorImpl), not by a Release callback.
 class CudaDeviceAllocator final : public CudaAllocatorBase {