[CUDA Plugin] Refactoring Einsum (microsoft#27606)

## Description

Refactor the CUDA Einsum kernel to unify the CUDA Einsum implementation
into a single code path that works for both the standard CUDA EP build
and the plugin EP build.

### Motivation

Without refactoring, Einsum CUDA kernel need two parallel class
hierarchies and pervasive `#ifdef BUILD_CUDA_EP_AS_PLUGIN` guards —
almost every code block (kernel registration,
`Compute`/`ComputeInternal`, `DeviceCompute`, preprocessor/processor
instantiation for each data type) was duplicated. This made the code
hard to read, hard to maintain, and error-prone due to divergence risk
between the two paths.

Additionally, `EinsumComputePreprocessor` and
`EinsumTypedComputeProcessor<T>` crossed the shared-library boundary via
~15 virtual methods in `ProviderHostCPU` (factory, Run,
SetDeviceHelpers, custom deleters for each of float/double/MLFloat16),
adding fragile coupling.

### Key Changes

#### 1. Unified CUDA Einsum class (`einsum.h` / `einsum.cc`)
- **Before**: Two `Einsum` class definitions — one inheriting
`CudaKernel` (plugin path) and one inheriting `onnxruntime::Einsum`
(non-plugin path), with a vtable stub `DeviceCompute` that
`assert(false)`s.
- **After**: Single `class Einsum final : public CudaKernel` with
`ComputeInternal`. No conditional compilation in CUDA Einsum files (zero
`BUILD_CUDA_EP_AS_PLUGIN` guards remain).
- CUDA `einsum.cc`: 208 → 101 lines (−51%). CUDA `einsum.h`: 69 → 37
lines (−46%).

#### 2. Decoupled `EinsumCudaAssets` from `CUDAExecutionProvider*`
- **Before**: `EinsumCudaAssets` held a raw `const
CUDAExecutionProvider*` pointer.
- **After**: Stores only the specific values needed (`cudaDeviceProp*`,
`cublasHandle_t`, `bool use_tf32_`), extracted by the caller using
`CudaKernel` accessors (`GetDeviceProp()`, `GetCublasHandle()`,
`cuda_ep_->UseTF32()`). This is better dependency inversion — the shared
Einsum utilities no longer couple to the concrete EP class.

#### 3. Added `GetComputeStream` helper to `CudaKernel`
- New inline helper `CudaKernel::GetComputeStream(OpKernelContext*)` for
kernels that need the underlying ORT `Stream*` object (not just the raw
`cudaStream_t`).

#### 4. Inlined Einsum utility logic into headers
- Moved implementation from `.cc` to `.h` for
`EinsumComputePreprocessor` and `EinsumTypedComputeProcessor<T>`
(guarded by `#ifndef SHARED_PROVIDER` / `#else`), so the plugin build
can compile the logic directly instead of going through the provider
bridge.
- `einsum_compute_preprocessor.cc`: 479 → 8 lines.
`einsum_typed_compute_processor.cc`: 459 → 19 lines.
- Corresponding `.h` files grew to absorb the inlined implementations.

#### 5. Simplified provider bridge surface for Einsum
- **Removed** ~15 virtual methods from `ProviderHostCPU`:
`EinsumComputePreprocessor__operator_delete`,
`EinsumComputePreprocessor__Create`, `EinsumComputePreprocessor__Run`,
`EinsumComputePreprocessor__SetDeviceHelpers`,
`EinsumTypedComputeProcessor__operator_delete` (×3 types),
`EinsumTypedComputeProcessor_*__Create` (×3),
`EinsumTypedComputeProcessor__SetDeviceHelpers` (×3),
`EinsumTypedComputeProcessor__Run` (×3).
- **Replaced** with 3 simpler `EinsumTypedComputeProcessor_*_Compute`
pass-through methods (one per data type: float, double, MLFloat16).
- Removed `EinsumComputePreprocessor` and
`EinsumTypedComputeProcessor<T>` forward declarations from
`provider_api.h`.

#### 6. Added `CreateTensor` device helper
- New `DeviceHelpers::CreateTensor` callback allows the caller to
control tensor allocation. Passed through `Transpose`, `MatMul`, and
`ReduceSum` wrappers, completing the device-abstraction pattern
(previously `std::make_unique<Tensor>` was hardcoded).
- Also inlined the `EinsumOp::Transpose`, `EinsumOp::MatMul`, and
`EinsumOp::ReduceSum` wrapper functions into the header (from
`einsum_auxiliary_ops.cc`).

### Files Changed (16 files, +1370 / −1333)

| File | Change |
|---|---|
| `cpu/cpu_provider_shared.h` | Replace ~15 bridge virtuals with 3
`Compute` methods; add `EinsumOp::DeviceHelpers` type aliases |
| `cpu/cpu_provider_shared.cc` | Update implementations matching the new
`ProviderHostCPU` interface |
| `cpu/math/einsum.cc` | Minor adjustment to CPU Einsum |
| `cpu/math/einsum_utils/einsum_auxiliary_ops.cc` | Move
`Transpose`/`MatMul`/`ReduceSum` wrappers to header (inline) |
| `cpu/math/einsum_utils/einsum_auxiliary_ops.h` | Inline wrapper
functions; add `CreateTensor` helper signature |
| `cpu/math/einsum_utils/einsum_compute_preprocessor.cc` | Shrink to
stub (logic moved to header) |
| `cpu/math/einsum_utils/einsum_compute_preprocessor.h` | Inline full
implementation; add `#ifndef SHARED_PROVIDER` / `#else` dual definition
|
| `cpu/math/einsum_utils/einsum_typed_compute_processor.cc` | Shrink to
stub (logic moved to header) |
| `cpu/math/einsum_utils/einsum_typed_compute_processor.h` | Inline full
implementation with `SHARED_PROVIDER` dual definition; add
`FinalizeOutput` and `PairwiseOperandProcess` |
| `cuda/cuda_kernel.h` | Add `GetComputeStream(OpKernelContext*)` helper
|
| `cuda/math/einsum.cc` | Unified single-path implementation (remove all
`#ifdef` guards) |
| `cuda/math/einsum.h` | Single `Einsum : CudaKernel` class (remove dual
hierarchy) |
| `cuda/math/einsum_utils/einsum_auxiliary_ops.cc` | Update to use new
`EinsumCudaAssets` fields |
| `cuda/math/einsum_utils/einsum_auxiliary_ops.h` | Decouple
`EinsumCudaAssets` from EP pointer; add `CreateTensor` |
| `shared_library/provider_api.h` | Remove Einsum forward declarations
and header include |
| `shared_library/provider_bridge_provider.cc` | Replace factory-based
bridge with direct `Run()` → `Compute` forwarding |

### Motivation and Context
This is a preparatory refactoring for the CUDA plugin EP work. By making
CUDA Einsum self-contained (not inheriting from the CPU
`onnxruntime::Einsum` base class), it can be compiled as part of a
plugin shared library without depending on the CPU EP's class vtable
layout across the ABI boundary.

Author: tianleiwu

onnxruntime/core/providers/cpu/cpu_provider_shared.cc

@@ -12,6 +12,8 @@
 #include "core/providers/cpu/controlflow/scan.h"
 #include "core/providers/cpu/math/cumsum.h"
 #include "core/providers/cpu/math/einsum.h"
+#include "core/providers/cpu/math/einsum_utils/einsum_typed_compute_processor.h"
+#include "core/providers/cpu/math/einsum_utils/einsum_compute_preprocessor.h"
 #include "core/providers/cpu/object_detection/non_max_suppression.h"
 #include "core/providers/cpu/object_detection/roialign.h"
 #include "core/providers/cpu/tensor/concatbase.h"
@@ -169,35 +171,63 @@ struct ProviderHostCPUImpl : ProviderHostCPU {
 
   Status Einsum__Compute(const Einsum* p, OpKernelContext* context) override { return p->Einsum::Compute(context); }
 
-  // EinsumComputePreprocessor (wrapped)
-  void EinsumComputePreprocessor__operator_delete(EinsumComputePreprocessor* p) override { delete p; }
-  std::unique_ptr<EinsumComputePreprocessor> EinsumComputePreprocessor__Create(EinsumEquationPreprocessor& equation_preprocessor,
-                                                                               const std::vector<const Tensor*>& inputs,
-                                                                               AllocatorPtr allocator,
-                                                                               void* einsum_cuda_assets) override { return std::make_unique<EinsumComputePreprocessor>(equation_preprocessor, inputs, allocator, einsum_cuda_assets); }
-
-  Status EinsumComputePreprocessor__Run(EinsumComputePreprocessor* p) override { return p->Run(); }
-  void EinsumComputePreprocessor__SetDeviceHelpers(EinsumComputePreprocessor* p, const EinsumOp::DeviceHelpers::Diagonal& diagonal_func, const EinsumOp::DeviceHelpers::Transpose& transpose_func) override { return p->SetDeviceHelpers(diagonal_func, transpose_func); }
-
-  // EinsumTypedComputeProcessor (wrapped)
-  void EinsumTypedComputeProcessor__operator_delete(EinsumTypedComputeProcessor<float>* p) override { delete p; }
-  void EinsumTypedComputeProcessor__operator_delete(EinsumTypedComputeProcessor<double>* p) override { delete p; }
-  void EinsumTypedComputeProcessor__operator_delete(EinsumTypedComputeProcessor<MLFloat16>* p) override { delete p; }
-  std::unique_ptr<EinsumTypedComputeProcessor<float>> EinsumTypedComputeProcessor_float__Create(OpKernelContext* context, AllocatorPtr allocator, concurrency::ThreadPool* tp, const void* mlas_backend_config, EinsumComputePreprocessor& einsum_compute_preprocessor, void* einsum_cuda_assets) override { return std::make_unique<EinsumTypedComputeProcessor<float>>(context, allocator, tp, mlas_backend_config, einsum_compute_preprocessor, einsum_cuda_assets); }
-  std::unique_ptr<EinsumTypedComputeProcessor<double>> EinsumTypedComputeProcessor_double__Create(OpKernelContext* context, AllocatorPtr allocator, concurrency::ThreadPool* tp, const void* mlas_backend_config, EinsumComputePreprocessor& einsum_compute_preprocessor, void* einsum_cuda_assets) override { return std::make_unique<EinsumTypedComputeProcessor<double>>(context, allocator, tp, mlas_backend_config, einsum_compute_preprocessor, einsum_cuda_assets); }
-  std::unique_ptr<EinsumTypedComputeProcessor<MLFloat16>> EinsumTypedComputeProcessor_MLFloat16__Create(OpKernelContext* context, AllocatorPtr allocator, concurrency::ThreadPool* tp, const void* mlas_backend_config, EinsumComputePreprocessor& einsum_compute_preprocessor, void* einsum_cuda_assets) override { return std::make_unique<EinsumTypedComputeProcessor<MLFloat16>>(context, allocator, tp, mlas_backend_config, einsum_compute_preprocessor, einsum_cuda_assets); }
-  void EinsumTypedComputeProcessor__SetDeviceHelpers(EinsumTypedComputeProcessor<float>* p, const EinsumOp::DeviceHelpers::Transpose& device_transpose_func, const EinsumOp::DeviceHelpers::MatMul<float>& device_matmul_func, const EinsumOp::DeviceHelpers::ReduceSum<float>& device_reduce_sum_func, const EinsumOp::DeviceHelpers::DataCopy& device_data_copy_func, const EinsumOp::DeviceHelpers::ZeroBuffer& device_zero_buffer_func) override { return p->SetDeviceHelpers(device_transpose_func, device_matmul_func, device_reduce_sum_func, device_data_copy_func, device_zero_buffer_func); }
-  void EinsumTypedComputeProcessor__SetDeviceHelpers(EinsumTypedComputeProcessor<double>* p, const EinsumOp::DeviceHelpers::Transpose& device_transpose_func, const EinsumOp::DeviceHelpers::MatMul<double>& device_matmul_func, const EinsumOp::DeviceHelpers::ReduceSum<double>& device_reduce_sum_func, const EinsumOp::DeviceHelpers::DataCopy& device_data_copy_func, const EinsumOp::DeviceHelpers::ZeroBuffer& device_zero_buffer_func) override { return p->SetDeviceHelpers(device_transpose_func, device_matmul_func, device_reduce_sum_func, device_data_copy_func, device_zero_buffer_func); }
-  void EinsumTypedComputeProcessor__SetDeviceHelpers(EinsumTypedComputeProcessor<MLFloat16>* p, const EinsumOp::DeviceHelpers::Transpose& device_transpose_func, const EinsumOp::DeviceHelpers::MatMul<MLFloat16>& device_matmul_func, const EinsumOp::DeviceHelpers::ReduceSum<MLFloat16>& device_reduce_sum_func, const EinsumOp::DeviceHelpers::DataCopy& device_data_copy_func, const EinsumOp::DeviceHelpers::ZeroBuffer& device_zero_buffer_func) override { return p->SetDeviceHelpers(device_transpose_func, device_matmul_func, device_reduce_sum_func, device_data_copy_func, device_zero_buffer_func); }
-  Status EinsumTypedComputeProcessor__Run(EinsumTypedComputeProcessor<float>* p) override { return p->Run(); }
-  Status EinsumTypedComputeProcessor__Run(EinsumTypedComputeProcessor<double>* p) override { return p->Run(); }
-  Status EinsumTypedComputeProcessor__Run(EinsumTypedComputeProcessor<MLFloat16>* p) override { return p->Run(); }
   void UpsampleBase__AdjustOutputSizeAsPolicy(const UpsampleBase* p, TensorShapeVector& output_dims,
                                               gsl::span<const int64_t> input_dims,
                                               InlinedVector<float>& scales) const override {
     p->AdjustOutputSizeAsPolicy(output_dims, input_dims, scales);
   }
 
+  Status EinsumTypedComputeProcessor_float_Compute(
+      OpKernelContext* context, AllocatorPtr allocator, concurrency::ThreadPool* tp,
+      const void* mlas_backend_config, EinsumComputePreprocessor& einsum_compute_preprocessor, void* einsum_cuda_assets,
+      const EinsumOp::DeviceHelpers::Transpose& device_transpose_func,
+      const EinsumOp::DeviceHelpers::MatMul<float>& device_matmul_func,
+      const EinsumOp::DeviceHelpers::ReduceSum<float>& device_reduce_sum_func,
+      const EinsumOp::DeviceHelpers::DataCopy& device_data_copy_func,
+      const EinsumOp::DeviceHelpers::ZeroBuffer& device_zero_buffer_func,
+      const EinsumOp::DeviceHelpers::CreateTensor& device_create_tensor_func) override {
+    EinsumTypedComputeProcessor<float> einsum_compute_processor(
+        context, allocator, tp, mlas_backend_config, einsum_compute_preprocessor, einsum_cuda_assets);
+    einsum_compute_processor.SetDeviceHelpers(
+        device_transpose_func, device_matmul_func, device_reduce_sum_func,
+        device_data_copy_func, device_zero_buffer_func, device_create_tensor_func);
+    return einsum_compute_processor.Run();
+  }
+
+  Status EinsumTypedComputeProcessor_double_Compute(
+      OpKernelContext* context, AllocatorPtr allocator, concurrency::ThreadPool* tp,
+      const void* mlas_backend_config, EinsumComputePreprocessor& einsum_compute_preprocessor, void* einsum_cuda_assets,
+      const EinsumOp::DeviceHelpers::Transpose& device_transpose_func,
+      const EinsumOp::DeviceHelpers::MatMul<double>& device_matmul_func,
+      const EinsumOp::DeviceHelpers::ReduceSum<double>& device_reduce_sum_func,
+      const EinsumOp::DeviceHelpers::DataCopy& device_data_copy_func,
+      const EinsumOp::DeviceHelpers::ZeroBuffer& device_zero_buffer_func,
+      const EinsumOp::DeviceHelpers::CreateTensor& device_create_tensor_func) override {
+    EinsumTypedComputeProcessor<double> einsum_compute_processor(
+        context, allocator, tp, mlas_backend_config, einsum_compute_preprocessor, einsum_cuda_assets);
+    einsum_compute_processor.SetDeviceHelpers(
+        device_transpose_func, device_matmul_func, device_reduce_sum_func,
+        device_data_copy_func, device_zero_buffer_func, device_create_tensor_func);
+    return einsum_compute_processor.Run();
+  }
+
+  Status EinsumTypedComputeProcessor_MLFloat16_Compute(
+      OpKernelContext* context, AllocatorPtr allocator, concurrency::ThreadPool* tp,
+      const void* mlas_backend_config, EinsumComputePreprocessor& einsum_compute_preprocessor, void* einsum_cuda_assets,
+      const EinsumOp::DeviceHelpers::Transpose& device_transpose_func,
+      const EinsumOp::DeviceHelpers::MatMul<MLFloat16>& device_matmul_func,
+      const EinsumOp::DeviceHelpers::ReduceSum<MLFloat16>& device_reduce_sum_func,
+      const EinsumOp::DeviceHelpers::DataCopy& device_data_copy_func,
+      const EinsumOp::DeviceHelpers::ZeroBuffer& device_zero_buffer_func,
+      const EinsumOp::DeviceHelpers::CreateTensor& device_create_tensor_func) override {
+    EinsumTypedComputeProcessor<MLFloat16> einsum_compute_processor(
+        context, allocator, tp, mlas_backend_config, einsum_compute_preprocessor, einsum_cuda_assets);
+    einsum_compute_processor.SetDeviceHelpers(
+        device_transpose_func, device_matmul_func, device_reduce_sum_func,
+        device_data_copy_func, device_zero_buffer_func, device_create_tensor_func);
+    return einsum_compute_processor.Run();
+  }
+
 #ifndef DISABLE_CONTRIB_OPS
   Status embed_layer_norm__CheckInputs(const OpKernelContext* context, bool quantizedVersion) override {
     return contrib::embed_layer_norm::CheckInputs(context, quantizedVersion);