2nd round

Author: fs-eire

include/onnxruntime/ep/adapter/op_kernel.h

@@ -77,12 +77,12 @@ struct OpKernelContext {
     if (index < 0 || static_cast<size_t>(index) >= input_tensors_.size()) {
       return nullptr;
     }
-    if (input_tensors_[index] != nullptr) {
-      return static_cast<const T*>(input_tensors_[index].get());
+    if (input_tensors_[index].DataRaw() != nullptr) {
+      return &input_tensors_[index];
     }
 
-    if (index < constant_input_tensors_.size() && constant_input_tensors_[index] != nullptr) {
-      return static_cast<const T*>(constant_input_tensors_[index].get());
+    if (index < constant_input_tensors_.size() && constant_input_tensors_[index].DataRaw() != nullptr) {
+      return &constant_input_tensors_[index];
     }
 
     auto input = context_.GetInput(index);
@@ -91,14 +91,14 @@ struct OpKernelContext {
     }
 
     input_tensors_[index] = CreateTensorFromApiValue(input);
-    return static_cast<const T*>(input_tensors_[index].get());
+    return &input_tensors_[index];
   }
   Tensor* Output(int index, const TensorShape& shape) {
     if (index < 0 || static_cast<size_t>(index) >= output_tensors_.size()) {
       return nullptr;
     }
-    if (output_tensors_[index] != nullptr) {
-      return output_tensors_[index].get();
+    if (output_tensors_[index].DataRaw() != nullptr) {
+      return &output_tensors_[index];
     }
 
     auto output = context_.GetOutput(index, shape.GetDims().data(), shape.GetDims().size());
@@ -107,7 +107,7 @@ struct OpKernelContext {
     }
 
     output_tensors_[index] = CreateTensorFromApiValue(output);
-    return output_tensors_[index].get();
+    return &output_tensors_[index];
   }
   Tensor* Output(int index, const std::vector<int64_t>& shape) {
     return Output(index, TensorShape{shape});
@@ -132,9 +132,9 @@ struct OpKernelContext {
   ORT_DISALLOW_COPY_ASSIGNMENT_AND_MOVE(OpKernelContext);
   Ort::KernelContext context_;
   const OpKernel& op_kernel_;
-  const std::vector<std::unique_ptr<Tensor>>& constant_input_tensors_;
-  mutable std::vector<std::unique_ptr<Tensor>> input_tensors_;
-  std::vector<std::unique_ptr<Tensor>> output_tensors_;
+  const std::vector<Tensor>& constant_input_tensors_;
+  mutable std::vector<Tensor> input_tensors_;
+  std::vector<Tensor> output_tensors_;
 };
 
 /// <summary>
@@ -181,10 +181,10 @@ struct KernelImpl : OrtKernelImpl {
                                                    _In_opt_ OrtSharedPrePackedWeightCache* /* prepacked_weight_cache */,
                                                    _Out_ bool* is_packed) noexcept {
     auto* kernel_impl = static_cast<KernelImpl*>(this_ptr)->impl_.get();
-    const auto tensor = CreateTensorFromApiValue(Ort::ConstValue{weight});
+    const auto tensor = CreateTensorFromApiValue(weight);
     Status status;
     ORT_TRY {
-      status = kernel_impl->PrePack(*tensor.get(), input_index, AllocatorPtr{}, *is_packed, nullptr);
+      status = kernel_impl->PrePack(tensor, input_index, AllocatorPtr{}, *is_packed, nullptr);
     }
     ORT_CATCH(const std::exception& ex) {
       ORT_HANDLE_EXCEPTION([&]() {

include/onnxruntime/ep/adapter/op_kernel_info.h

@@ -52,7 +52,7 @@ struct OpKernelInfo {
       }
     }
     const OrtKernelInfo* kernel_info_;
-    std::vector<std::unique_ptr<Tensor>> constant_input_tensors;
+    std::vector<Tensor> constant_input_tensors;
     ORT_DISALLOW_COPY_ASSIGNMENT_AND_MOVE(KernelInfoCache);
   };
 
@@ -81,17 +81,17 @@ struct OpKernelInfo {
     return info_.GetInputCount();
   }
 
-  const std::vector<std::unique_ptr<Tensor>>& GetConstantInputTensors() const noexcept {
+  const std::vector<Tensor>& GetConstantInputTensors() const noexcept {
     return cache_->constant_input_tensors;
   }
 
   bool TryGetConstantInput(int input_index, const Tensor** constant_input_value) const {
     if (input_index < 0 || static_cast<size_t>(input_index) >= cache_->constant_input_tensors.size()) {
       return false;
     }
-    const Tensor* tensor = cache_->constant_input_tensors[input_index].get();
-    if (tensor != nullptr) {
-      *constant_input_value = tensor;
+    const Tensor& tensor = cache_->constant_input_tensors[input_index];
+    if (tensor.DataRaw() != nullptr) {
+      *constant_input_value = &tensor;
       return true;
     }
     return false;

include/onnxruntime/ep/adapter/tensor_helper.h

@@ -19,7 +19,7 @@ namespace adapter {
 /// <summary>
 /// Create an unowned onnxruntime::Tensor from a tensor OrtValue from C API.
 /// </summary>
-inline std::unique_ptr<onnxruntime::Tensor> CreateTensorFromApiValue(const OrtValue* ort_value) {
+inline onnxruntime::Tensor CreateTensorFromApiValue(const OrtValue* ort_value) {
   Ort::ConstValue value{ort_value};
   EP_ENFORCE(value.IsTensor(), "Only tensor OrtValue is supported.");
 
@@ -41,10 +41,10 @@ inline std::unique_ptr<onnxruntime::Tensor> CreateTensorFromApiValue(const OrtVa
                                    },
                                    memory_info.GetMemoryType()};
 
-  return std::make_unique<Tensor>(data_type,
-                                  TensorShape{shape.shape, shape.shape_len},
-                                  const_cast<void*>(value.GetTensorRawData()),
-                                  tensor_memory_info);
+  return Tensor(data_type,
+                TensorShape{shape.shape, shape.shape_len},
+                const_cast<void*>(value.GetTensorRawData()),
+                tensor_memory_info);
 }
 
 }  // namespace adapter