From b11c1063461ee15bb8e2e584620c51393bbf9b29 Mon Sep 17 00:00:00 2001 From: Ryan Hill <38674843+RyanUnderhill@users.noreply.github.com> Date: Wed, 16 Sep 2020 17:00:15 -0700 Subject: [PATCH] Remove almost all of the reinterpret_casts from the provider shared API (#5190) --- .../core/framework/provider_bridge_ort.cc | 437 +++++++++--------- .../shared_library/provider_interfaces.h | 32 +- 2 files changed, 232 insertions(+), 237 deletions(-) diff --git a/onnxruntime/core/framework/provider_bridge_ort.cc b/onnxruntime/core/framework/provider_bridge_ort.cc index 425d24b658..cec18fc3f4 100644 --- a/onnxruntime/core/framework/provider_bridge_ort.cc +++ b/onnxruntime/core/framework/provider_bridge_ort.cc @@ -24,6 +24,43 @@ #include "core/providers/cuda/cuda_common.h" #endif +namespace onnxruntime { +// These Provider types are really just internal types, so we #define PROVIDER_BRIDGE_ORT so that only these definitions are seen by provider_interfaces.h +// Users of provider_interfaces.h (through provider_api.h) will see the wrappers that call through the provider shared interface which is implemented by this file +using Provider_AttributeProto = ONNX_NAMESPACE::AttributeProto; +using Provider_GraphProto = ONNX_NAMESPACE::GraphProto; +using Provider_ModelProto = ONNX_NAMESPACE::ModelProto; +using Provider_NodeProto = ONNX_NAMESPACE::NodeProto; +using Provider_TensorProto = ONNX_NAMESPACE::TensorProto; +using Provider_TensorProtos = google::protobuf::RepeatedPtrField; +using Provider_TensorShapeProto_Dimension = ONNX_NAMESPACE::TensorShapeProto_Dimension; +using Provider_TensorShapeProto_Dimensions = google::protobuf::RepeatedPtrField; +using Provider_TensorShapeProto = ONNX_NAMESPACE::TensorShapeProto; +using Provider_TypeProto_Tensor = ONNX_NAMESPACE::TypeProto_Tensor; +using Provider_TypeProto = ONNX_NAMESPACE::TypeProto; +using Provider_ValueInfoProto = ONNX_NAMESPACE::ValueInfoProto; +using Provider_ValueInfoProtos = google::protobuf::RepeatedPtrField; + +using Provider_ComputeCapability = ComputeCapability; +using Provider_DataTransferManager = DataTransferManager; +using Provider_IDataTransfer = IDataTransfer; +using Provider_IndexedSubGraph = IndexedSubGraph; +using Provider_IndexedSubGraph_MetaDef = IndexedSubGraph::MetaDef; +using Provider_KernelDef = KernelDef; +using Provider_KernelDefBuilder = KernelDefBuilder; +using Provider_KernelRegistry = KernelRegistry; +using Provider_Function = Function; +using Provider_Graph = Graph; +using Provider_GraphViewer = GraphViewer; +using Provider_Model = Model; +using Provider_Node = Node; +using Provider_NodeArg = NodeArg; +using Provider_NodeAttributes = NodeAttributes; +using Provider_OpKernelContext = OpKernelContext; +using Provider_OpKernelInfo = OpKernelInfo; +using Provider_Tensor = Tensor; +} // namespace onnxruntime + #define PROVIDER_BRIDGE_ORT #include "core/providers/shared_library/provider_interfaces.h" #include "onnx/common/stl_backports.h" @@ -90,7 +127,7 @@ struct Provider_TensorShapeProto_Dimension_Iterator_Impl : Provider_TensorShapeP bool operator!=(const Provider_TensorShapeProto_Dimension_Iterator& p) const override { return v_ != static_cast(&p)->v_; } void operator++() override { v_.operator++(); } - const Provider_TensorShapeProto_Dimension& operator*() override { return *reinterpret_cast(&v_.operator*()); } + const Provider_TensorShapeProto_Dimension& operator*() override { return *v_; } google::protobuf::internal::RepeatedPtrIterator v_; }; @@ -102,7 +139,7 @@ struct Provider_NodeAttributes_Iterator_Impl : Provider_NodeAttributes_Iterator void operator++() override { v_.operator++(); } const std::string& first() const override { return v_->first; } - const Provider_AttributeProto& second() override { return *reinterpret_cast(static_cast(&v_->second)); } + const Provider_AttributeProto& second() override { return v_->second; } NodeAttributes::const_iterator v_; }; @@ -113,9 +150,7 @@ struct Provider_Node__NodeIterator_Impl : Provider_Node__NodeIterator { bool operator!=(const Provider_Node__NodeIterator& p) const override { return v_ != static_cast(&p)->v_; } void operator++() override { v_.operator++(); } - const Provider_Node& operator*() override { - return *reinterpret_cast(&*v_); - } + const Provider_Node& operator*() override { return *v_; } Node::NodeConstIterator v_; }; @@ -126,29 +161,19 @@ struct Provider_Node__EdgeIterator_Impl : Provider_Node__EdgeIterator { bool operator!=(const Provider_Node__EdgeIterator& p) const override { return v_ != static_cast(&p)->v_; } void operator++() override { v_.operator++(); } - const Provider_Node& GetNode() const override { return *reinterpret_cast(&v_->GetNode()); } - - int GetSrcArgIndex() const override { - return v_->GetSrcArgIndex(); - } - - int GetDstArgIndex() const override { - return v_->GetDstArgIndex(); - } + const Provider_Node& GetNode() const override { return v_->GetNode(); } + int GetSrcArgIndex() const override { return v_->GetSrcArgIndex(); } + int GetDstArgIndex() const override { return v_->GetDstArgIndex(); } Node::EdgeConstIterator v_; }; -struct Provider_OpKernel_Impl : Provider_OpKernel { - OpKernelInfo op_kernel_info_; -}; - struct OpKernel_Translator : OpKernel { OpKernel_Translator(const OpKernelInfo& info, Provider_OpKernel* p) : OpKernel{info}, p_{p} { } Status Compute(OpKernelContext* context) const override { - return p_->Compute(reinterpret_cast(context), *reinterpret_cast(static_cast(this))); + return p_->Compute(context, *reinterpret_cast(static_cast(this))); } std::unique_ptr p_; @@ -162,30 +187,21 @@ struct Provider_IExecutionProvider_Router_Impl : Provider_IExecutionProvider_Rou virtual ~Provider_IExecutionProvider_Router_Impl() {} - std::shared_ptr Provider_GetKernelRegistry() const override { - auto result = GetKernelRegistry(); - return *reinterpret_cast*>(&result); - } - - std::shared_ptr GetKernelRegistry() const override { - auto result = outer_->Provider_GetKernelRegistry(); - return *reinterpret_cast*>(&result); - } + std::shared_ptr Provider_GetKernelRegistry() const override { return GetKernelRegistry(); } + std::shared_ptr GetKernelRegistry() const override { return outer_->Provider_GetKernelRegistry(); } std::vector> Provider_GetCapability(const onnxruntime::Provider_GraphViewer& graph, const std::vector& kernel_registries) const override { - auto capabilities_internal = IExecutionProvider::GetCapability(*reinterpret_cast(&graph), *reinterpret_cast*>(&kernel_registries)); - return std::move(*reinterpret_cast>*>(&capabilities_internal)); + return IExecutionProvider::GetCapability(graph, kernel_registries); } std::vector> GetCapability(const onnxruntime::GraphViewer& graph, const std::vector& kernel_registries) const override { - auto provider_result = outer_->Provider_GetCapability(*reinterpret_cast(&graph), *reinterpret_cast*>(&kernel_registries)); - return std::move(*reinterpret_cast>*>(&provider_result)); + return outer_->Provider_GetCapability(graph, kernel_registries); } common::Status Compile(const std::vector& fused_nodes, std::vector& node_compute_funcs) override { - return outer_->Provider_Compile(*reinterpret_cast*>(&fused_nodes), node_compute_funcs); + return outer_->Provider_Compile(fused_nodes, node_compute_funcs); } Provider_AllocatorPtr Provider_GetAllocator(int id, OrtMemType mem_type) const override { @@ -199,13 +215,8 @@ struct Provider_IExecutionProvider_Router_Impl : Provider_IExecutionProvider_Rou return static_cast(allocator.get())->p_; } - std::unique_ptr Provider_GetDataTransfer() const override { - return std::unique_ptr(reinterpret_cast(IExecutionProvider::GetDataTransfer().release())); - } - - std::unique_ptr GetDataTransfer() const override { - return std::unique_ptr(reinterpret_cast(outer_->Provider_GetDataTransfer().release())); - } + std::unique_ptr Provider_GetDataTransfer() const override { return IExecutionProvider::GetDataTransfer(); } + std::unique_ptr GetDataTransfer() const override { return outer_->Provider_GetDataTransfer(); } void Provider_InsertAllocator(Provider_AllocatorPtr allocator) override { IExecutionProvider::InsertAllocator(static_cast(allocator.get())->p_); @@ -263,9 +274,7 @@ struct ProviderHostImpl : ProviderHost { return onnxruntime::make_unique(onnxruntime::make_unique(device_id, name)); } - std::unique_ptr CreateGPUDataTransfer() override { - return std::unique_ptr(reinterpret_cast(new GPUDataTransfer())); - } + std::unique_ptr CreateGPUDataTransfer() override { return onnxruntime::make_unique(); } void cuda__Impl_Cast(const int64_t* input_data, int32_t* output_data, size_t count) override { return cuda::Impl_Cast(input_data, output_data, count); @@ -307,306 +316,280 @@ struct ProviderHostImpl : ProviderHost { } // Provider_TypeProto_Tensor - int32_t Provider_TypeProto_Tensor__elem_type(const Provider_TypeProto_Tensor* p) override { return reinterpret_cast(p)->elem_type(); } + int32_t Provider_TypeProto_Tensor__elem_type(const Provider_TypeProto_Tensor* p) override { return p->elem_type(); } // Provider_TypeProto - const Provider_TypeProto_Tensor& Provider_TypeProto__tensor_type(const Provider_TypeProto* p) override { return *reinterpret_cast(&reinterpret_cast(p)->tensor_type()); } + const Provider_TypeProto_Tensor& Provider_TypeProto__tensor_type(const Provider_TypeProto* p) override { return p->tensor_type(); } // Provider_AttributeProto - std::unique_ptr Provider_AttributeProto__construct() override { return std::unique_ptr(reinterpret_cast(new ONNX_NAMESPACE::AttributeProto())); } - void Provider_AttributeProto__operator_delete(Provider_AttributeProto* p) override { delete reinterpret_cast(p); } - void Provider_AttributeProto__operator_assign(Provider_AttributeProto* p, const Provider_AttributeProto& v) override { *reinterpret_cast(p) = *reinterpret_cast(&v); } + std::unique_ptr Provider_AttributeProto__construct() override { return onnxruntime::make_unique(); } + void Provider_AttributeProto__operator_delete(Provider_AttributeProto* p) override { delete p; } + void Provider_AttributeProto__operator_assign(Provider_AttributeProto* p, const Provider_AttributeProto& v) override { *p = v; } - ONNX_NAMESPACE::AttributeProto_AttributeType Provider_AttributeProto__type(const Provider_AttributeProto* p) override { return reinterpret_cast(p)->type(); } - int Provider_AttributeProto__ints_size(const Provider_AttributeProto* p) override { return reinterpret_cast(p)->ints_size(); } - int64_t Provider_AttributeProto__ints(const Provider_AttributeProto* p, int i) override { return reinterpret_cast(p)->ints(i); } - int64_t Provider_AttributeProto__i(const Provider_AttributeProto* p) override { return reinterpret_cast(p)->i(); } - float Provider_AttributeProto__f(const Provider_AttributeProto* p) override { return reinterpret_cast(p)->f(); } - void Provider_AttributeProto__set_s(Provider_AttributeProto* p, const ::std::string& value) override { return reinterpret_cast(p)->set_s(value); } - const ::std::string& Provider_AttributeProto__s(const Provider_AttributeProto* p) override { return reinterpret_cast(p)->s(); } - void Provider_AttributeProto__set_name(Provider_AttributeProto* p, const ::std::string& value) override { return reinterpret_cast(p)->set_name(value); } - void Provider_AttributeProto__set_type(Provider_AttributeProto* p, ONNX_NAMESPACE::AttributeProto_AttributeType value) override { return reinterpret_cast(p)->set_type(value); } - Provider_TensorProto* Provider_AttributeProto__add_tensors(Provider_AttributeProto* p) override { return reinterpret_cast(reinterpret_cast(p)->add_tensors()); } + ONNX_NAMESPACE::AttributeProto_AttributeType Provider_AttributeProto__type(const Provider_AttributeProto* p) override { return p->type(); } + int Provider_AttributeProto__ints_size(const Provider_AttributeProto* p) override { return p->ints_size(); } + int64_t Provider_AttributeProto__ints(const Provider_AttributeProto* p, int i) override { return p->ints(i); } + int64_t Provider_AttributeProto__i(const Provider_AttributeProto* p) override { return p->i(); } + float Provider_AttributeProto__f(const Provider_AttributeProto* p) override { return p->f(); } + void Provider_AttributeProto__set_s(Provider_AttributeProto* p, const ::std::string& value) override { return p->set_s(value); } + const ::std::string& Provider_AttributeProto__s(const Provider_AttributeProto* p) override { return p->s(); } + void Provider_AttributeProto__set_name(Provider_AttributeProto* p, const ::std::string& value) override { return p->set_name(value); } + void Provider_AttributeProto__set_type(Provider_AttributeProto* p, ONNX_NAMESPACE::AttributeProto_AttributeType value) override { return p->set_type(value); } + Provider_TensorProto* Provider_AttributeProto__add_tensors(Provider_AttributeProto* p) override { return p->add_tensors(); } // Provider_GraphProto - void Provider_GraphProto__operator_delete(Provider_GraphProto* p) override { delete reinterpret_cast(p); } + void Provider_GraphProto__operator_delete(Provider_GraphProto* p) override { delete p; } - Provider_ValueInfoProtos* Provider_GraphProto__mutable_input(Provider_GraphProto* p) override { return reinterpret_cast(reinterpret_cast(p)->mutable_input()); } + Provider_ValueInfoProtos* Provider_GraphProto__mutable_input(Provider_GraphProto* p) override { return p->mutable_input(); } - const Provider_ValueInfoProtos& Provider_GraphProto__output(const Provider_GraphProto* p) override { return *reinterpret_cast(&reinterpret_cast(p)->output()); } - Provider_ValueInfoProtos* Provider_GraphProto__mutable_output(Provider_GraphProto* p) override { return reinterpret_cast(reinterpret_cast(p)->mutable_output()); } + const Provider_ValueInfoProtos& Provider_GraphProto__output(const Provider_GraphProto* p) override { return p->output(); } + Provider_ValueInfoProtos* Provider_GraphProto__mutable_output(Provider_GraphProto* p) override { return p->mutable_output(); } - Provider_ValueInfoProtos* Provider_GraphProto__mutable_value_info(Provider_GraphProto* p) override { return reinterpret_cast(reinterpret_cast(p)->mutable_value_info()); } - Provider_TensorProtos* Provider_GraphProto__mutable_initializer(Provider_GraphProto* p) override { return reinterpret_cast(reinterpret_cast(p)->mutable_initializer()); } - Provider_NodeProto* Provider_GraphProto__add_node(Provider_GraphProto* p) override { return reinterpret_cast(reinterpret_cast(p)->add_node()); } + Provider_ValueInfoProtos* Provider_GraphProto__mutable_value_info(Provider_GraphProto* p) override { return p->mutable_value_info(); } + Provider_TensorProtos* Provider_GraphProto__mutable_initializer(Provider_GraphProto* p) override { return p->mutable_initializer(); } + Provider_NodeProto* Provider_GraphProto__add_node(Provider_GraphProto* p) override { return p->add_node(); } - void Provider_GraphProto__operator_assign(Provider_GraphProto* p, const Provider_GraphProto& v) override { *reinterpret_cast(p) = *reinterpret_cast(&v); } + void Provider_GraphProto__operator_assign(Provider_GraphProto* p, const Provider_GraphProto& v) override { *p = v; } // Provider_ModelProto - void Provider_ModelProto__operator_delete(Provider_ModelProto* p) override { delete reinterpret_cast(p); } + void Provider_ModelProto__operator_delete(Provider_ModelProto* p) override { delete p; } - bool Provider_ModelProto__SerializeToString(const Provider_ModelProto* p, std::string& string) override { return reinterpret_cast(p)->SerializeToString(&string); } - bool Provider_ModelProto__SerializeToOstream(const Provider_ModelProto* p, std::ostream& output) override { return reinterpret_cast(p)->SerializeToOstream(&output); } + bool Provider_ModelProto__SerializeToString(const Provider_ModelProto* p, std::string& string) override { return p->SerializeToString(&string); } + bool Provider_ModelProto__SerializeToOstream(const Provider_ModelProto* p, std::ostream& output) override { return p->SerializeToOstream(&output); } - const ONNX_NAMESPACE::Provider_GraphProto& Provider_ModelProto__graph(const Provider_ModelProto* p) override { return *reinterpret_cast(&reinterpret_cast(p)->graph()); } - ONNX_NAMESPACE::Provider_GraphProto* Provider_ModelProto__mutable_graph(Provider_ModelProto* p) override { return reinterpret_cast(reinterpret_cast(p)->mutable_graph()); } + const Provider_GraphProto& Provider_ModelProto__graph(const Provider_ModelProto* p) override { return p->graph(); } + Provider_GraphProto* Provider_ModelProto__mutable_graph(Provider_ModelProto* p) override { return p->mutable_graph(); } - void Provider_ModelProto__set_ir_version(Provider_ModelProto* p, int64_t value) override { reinterpret_cast(p)->set_ir_version(value); } + void Provider_ModelProto__set_ir_version(Provider_ModelProto* p, int64_t value) override { p->set_ir_version(value); } // Provider_TensorProto - void Provider_TensorProto__operator_delete(Provider_TensorProto* p) override { delete reinterpret_cast(p); } - void Provider_TensorProto__operator_assign(Provider_TensorProto* p, const Provider_TensorProto& v) override { *reinterpret_cast(p) = *reinterpret_cast(&v); } + void Provider_TensorProto__operator_delete(Provider_TensorProto* p) override { delete p; } + void Provider_TensorProto__operator_assign(Provider_TensorProto* p, const Provider_TensorProto& v) override { *p = v; } // Provider_TensorProtos - Provider_TensorProto* Provider_TensorProtos__Add(Provider_TensorProtos* p) override { return reinterpret_cast(reinterpret_cast*>(p)->Add()); } + Provider_TensorProto* Provider_TensorProtos__Add(Provider_TensorProtos* p) override { return p->Add(); } // Provider_TensorShapeProto_Dimension const std::string& Provider_TensorShapeProto_Dimension__dim_param(const Provider_TensorShapeProto_Dimension* p) override { - return reinterpret_cast(p)->dim_param(); + return p->dim_param(); } // Provider_TensorShapeProto_Dimensions std::unique_ptr Provider_TensorShapeProto_Dimensions__begin(const Provider_TensorShapeProto_Dimensions* p) override { - return onnxruntime::make_unique(reinterpret_cast*>(p)->begin()); + return onnxruntime::make_unique(p->begin()); } std::unique_ptr Provider_TensorShapeProto_Dimensions__end(const Provider_TensorShapeProto_Dimensions* p) override { - return onnxruntime::make_unique(reinterpret_cast*>(p)->end()); + return onnxruntime::make_unique(p->end()); } // Provider_TensorShapeProto - int Provider_TensorShapeProto__dim_size(const Provider_TensorShapeProto* p) override { return reinterpret_cast(p)->dim_size(); } - const Provider_TensorShapeProto_Dimensions& Provider_TensorShapeProto__dim(const Provider_TensorShapeProto* p) override { return *reinterpret_cast(&reinterpret_cast(p)->dim()); } + int Provider_TensorShapeProto__dim_size(const Provider_TensorShapeProto* p) override { return p->dim_size(); } + const Provider_TensorShapeProto_Dimensions& Provider_TensorShapeProto__dim(const Provider_TensorShapeProto* p) override { return p->dim(); } // Provider_ValueInfoProto - const Provider_TypeProto& Provider_ValueInfoProto__type(const Provider_ValueInfoProto* p) override { return *reinterpret_cast(&reinterpret_cast(p)->type()); } - virtual void Provider_ValueInfoProto__operator_assign(Provider_ValueInfoProto* p, const Provider_ValueInfoProto& v) override { *reinterpret_cast(p) = *reinterpret_cast(&v); } + const Provider_TypeProto& Provider_ValueInfoProto__type(const Provider_ValueInfoProto* p) override { return p->type(); } + virtual void Provider_ValueInfoProto__operator_assign(Provider_ValueInfoProto* p, const Provider_ValueInfoProto& v) override { *p = v; } // Provider_ValueInfoProtos - Provider_ValueInfoProto* Provider_ValueInfoProtos__Add(Provider_ValueInfoProtos* p) override { return reinterpret_cast(reinterpret_cast*>(p)->Add()); } + Provider_ValueInfoProto* Provider_ValueInfoProtos__Add(Provider_ValueInfoProtos* p) override { return p->Add(); } - const Provider_ValueInfoProto& Provider_ValueInfoProtos__operator_array(const Provider_ValueInfoProtos* p, int index) override { return *reinterpret_cast(&(*reinterpret_cast*>(p))[index]); } + const Provider_ValueInfoProto& Provider_ValueInfoProtos__operator_array(const Provider_ValueInfoProtos* p, int index) override { return (*p)[index]; } // Provider_ComputeCapability - std::unique_ptr Provider_ComputeCapability__construct(std::unique_ptr t_sub_graph) override { return std::unique_ptr(reinterpret_cast(new ComputeCapability(std::unique_ptr(reinterpret_cast(t_sub_graph.release()))))); } - void Provider_ComputeCapability__operator_delete(Provider_ComputeCapability* p) override { delete reinterpret_cast(p); } - std::unique_ptr& Provider_ComputeCapability__SubGraph(Provider_ComputeCapability* p) override { return *reinterpret_cast*>(&reinterpret_cast(p)->sub_graph); } + std::unique_ptr Provider_ComputeCapability__construct(std::unique_ptr t_sub_graph) override { return onnxruntime::make_unique(std::move(t_sub_graph)); } + void Provider_ComputeCapability__operator_delete(Provider_ComputeCapability* p) override { delete p; } + std::unique_ptr& Provider_ComputeCapability__SubGraph(Provider_ComputeCapability* p) override { return p->sub_graph; } // Provider_DataTransferManager - Status Provider_DataTransferManager__CopyTensor(const Provider_DataTransferManager* p, const Provider_Tensor& src, Provider_Tensor& dst, int exec_queue_id) override { return reinterpret_cast(p)->CopyTensor(*reinterpret_cast(&src), *reinterpret_cast(&dst), exec_queue_id); } + Status Provider_DataTransferManager__CopyTensor(const Provider_DataTransferManager* p, const Provider_Tensor& src, Provider_Tensor& dst, int exec_queue_id) override { return p->CopyTensor(src, dst, exec_queue_id); } // Provider_IDataTransfer - void Provider_IDataTransfer__operator_delete(Provider_IDataTransfer* p) override { delete reinterpret_cast(p); } + void Provider_IDataTransfer__operator_delete(Provider_IDataTransfer* p) override { delete p; } // Provider_IndexedSubGraph_MetaDef - std::unique_ptr Provider_IndexedSubGraph_MetaDef__construct() override { return std::unique_ptr(reinterpret_cast(new IndexedSubGraph::MetaDef())); } - void Provider_IndexedSubGraph_MetaDef__operator_delete(Provider_IndexedSubGraph_MetaDef* p) override { delete reinterpret_cast(p); } + std::unique_ptr Provider_IndexedSubGraph_MetaDef__construct() override { return onnxruntime::make_unique(); } + void Provider_IndexedSubGraph_MetaDef__operator_delete(Provider_IndexedSubGraph_MetaDef* p) override { delete p; } - std::string& Provider_IndexedSubGraph_MetaDef__name(Provider_IndexedSubGraph_MetaDef* p) override { return reinterpret_cast(p)->name; } - std::string& Provider_IndexedSubGraph_MetaDef__domain(Provider_IndexedSubGraph_MetaDef* p) override { return reinterpret_cast(p)->domain; } - int& Provider_IndexedSubGraph_MetaDef__since_version(Provider_IndexedSubGraph_MetaDef* p) override { return reinterpret_cast(p)->since_version; } - ONNX_NAMESPACE::OperatorStatus& Provider_IndexedSubGraph_MetaDef__status(Provider_IndexedSubGraph_MetaDef* p) override { return reinterpret_cast(p)->status; } - std::vector& Provider_IndexedSubGraph_MetaDef__inputs(Provider_IndexedSubGraph_MetaDef* p) override { return reinterpret_cast(p)->inputs; } - std::vector& Provider_IndexedSubGraph_MetaDef__outputs(Provider_IndexedSubGraph_MetaDef* p) override { return reinterpret_cast(p)->outputs; } - Provider_NodeAttributes& Provider_IndexedSubGraph_MetaDef__attributes(Provider_IndexedSubGraph_MetaDef* p) override { return *reinterpret_cast(&reinterpret_cast(p)->attributes); } - std::string& Provider_IndexedSubGraph_MetaDef__doc_string(Provider_IndexedSubGraph_MetaDef* p) override { return reinterpret_cast(p)->doc_string; } + std::string& Provider_IndexedSubGraph_MetaDef__name(Provider_IndexedSubGraph_MetaDef* p) override { return p->name; } + std::string& Provider_IndexedSubGraph_MetaDef__domain(Provider_IndexedSubGraph_MetaDef* p) override { return p->domain; } + int& Provider_IndexedSubGraph_MetaDef__since_version(Provider_IndexedSubGraph_MetaDef* p) override { return p->since_version; } + ONNX_NAMESPACE::OperatorStatus& Provider_IndexedSubGraph_MetaDef__status(Provider_IndexedSubGraph_MetaDef* p) override { return p->status; } + std::vector& Provider_IndexedSubGraph_MetaDef__inputs(Provider_IndexedSubGraph_MetaDef* p) override { return p->inputs; } + std::vector& Provider_IndexedSubGraph_MetaDef__outputs(Provider_IndexedSubGraph_MetaDef* p) override { return p->outputs; } + Provider_NodeAttributes& Provider_IndexedSubGraph_MetaDef__attributes(Provider_IndexedSubGraph_MetaDef* p) override { return p->attributes; } + std::string& Provider_IndexedSubGraph_MetaDef__doc_string(Provider_IndexedSubGraph_MetaDef* p) override { return p->doc_string; } // Provider_IndexedSubGraph - std::unique_ptr Provider_IndexedSubGraph__construct() override { return std::unique_ptr(reinterpret_cast(new IndexedSubGraph())); } - void Provider_IndexedSubGraph__operator_delete(Provider_IndexedSubGraph* p) override { delete reinterpret_cast(p); } + std::unique_ptr Provider_IndexedSubGraph__construct() override { return onnxruntime::make_unique(); } + void Provider_IndexedSubGraph__operator_delete(Provider_IndexedSubGraph* p) override { delete p; } - std::vector& Provider_IndexedSubGraph__Nodes(Provider_IndexedSubGraph* p) override { return reinterpret_cast(p)->nodes; } + std::vector& Provider_IndexedSubGraph__Nodes(Provider_IndexedSubGraph* p) override { return p->nodes; } - void Provider_IndexedSubGraph__SetMetaDef(Provider_IndexedSubGraph* p, std::unique_ptr&& meta_def_) override { return reinterpret_cast(p)->SetMetaDef(std::move(*reinterpret_cast*>(&meta_def_))); } - const Provider_IndexedSubGraph_MetaDef* Provider_IndexedSubGraph__GetMetaDef(const Provider_IndexedSubGraph* p) override { return reinterpret_cast(reinterpret_cast(p)->GetMetaDef()); } + void Provider_IndexedSubGraph__SetMetaDef(Provider_IndexedSubGraph* p, std::unique_ptr&& meta_def_) override { return p->SetMetaDef(std::move(meta_def_)); } + const Provider_IndexedSubGraph_MetaDef* Provider_IndexedSubGraph__GetMetaDef(const Provider_IndexedSubGraph* p) override { return p->GetMetaDef(); } // Provider_KernelDef - void Provider_KernelDef__operator_delete(Provider_KernelDef* p) override { delete reinterpret_cast(p); } + void Provider_KernelDef__operator_delete(Provider_KernelDef* p) override { delete p; } // Provider_KernelDefBuilder - std::unique_ptr Provider_KernelDefBuilder__construct() override { return std::unique_ptr(reinterpret_cast(new KernelDefBuilder())); } - void Provider_KernelDefBuilder__operator_delete(Provider_KernelDefBuilder* p) override { delete reinterpret_cast(p); } + std::unique_ptr Provider_KernelDefBuilder__construct() override { return onnxruntime::make_unique(); } + void Provider_KernelDefBuilder__operator_delete(Provider_KernelDefBuilder* p) override { delete p; } - void Provider_KernelDefBuilder__SetName(Provider_KernelDefBuilder* p, const char* op_name) override { reinterpret_cast(p)->SetName(op_name); } - void Provider_KernelDefBuilder__SetDomain(Provider_KernelDefBuilder* p, const char* domain) override { reinterpret_cast(p)->SetDomain(domain); } - void Provider_KernelDefBuilder__SinceVersion(Provider_KernelDefBuilder* p, int since_version) override { reinterpret_cast(p)->SinceVersion(since_version); } - void Provider_KernelDefBuilder__Provider(Provider_KernelDefBuilder* p, const char* provider_type) override { reinterpret_cast(p)->Provider(provider_type); } - void Provider_KernelDefBuilder__TypeConstraint(Provider_KernelDefBuilder* p, const char* arg_name, MLDataType supported_type) override { reinterpret_cast(p)->TypeConstraint(arg_name, supported_type); } - void Provider_KernelDefBuilder__TypeConstraint(Provider_KernelDefBuilder* p, const char* arg_name, const std::vector& supported_types) override { reinterpret_cast(p)->TypeConstraint(arg_name, supported_types); } - void Provider_KernelDefBuilder__InputMemoryType(Provider_KernelDefBuilder* p, OrtMemType type, int input_index) override { reinterpret_cast(p)->InputMemoryType(type, input_index); } - void Provider_KernelDefBuilder__OutputMemoryType(Provider_KernelDefBuilder* p, OrtMemType type, int input_index) override { reinterpret_cast(p)->OutputMemoryType(type, input_index); } - void Provider_KernelDefBuilder__ExecQueueId(Provider_KernelDefBuilder* p, int queue_id) override { reinterpret_cast(p)->ExecQueueId(queue_id); } + void Provider_KernelDefBuilder__SetName(Provider_KernelDefBuilder* p, const char* op_name) override { p->SetName(op_name); } + void Provider_KernelDefBuilder__SetDomain(Provider_KernelDefBuilder* p, const char* domain) override { p->SetDomain(domain); } + void Provider_KernelDefBuilder__SinceVersion(Provider_KernelDefBuilder* p, int since_version) override { p->SinceVersion(since_version); } + void Provider_KernelDefBuilder__Provider(Provider_KernelDefBuilder* p, const char* provider_type) override { p->Provider(provider_type); } + void Provider_KernelDefBuilder__TypeConstraint(Provider_KernelDefBuilder* p, const char* arg_name, MLDataType supported_type) override { p->TypeConstraint(arg_name, supported_type); } + void Provider_KernelDefBuilder__TypeConstraint(Provider_KernelDefBuilder* p, const char* arg_name, const std::vector& supported_types) override { p->TypeConstraint(arg_name, supported_types); } + void Provider_KernelDefBuilder__InputMemoryType(Provider_KernelDefBuilder* p, OrtMemType type, int input_index) override { p->InputMemoryType(type, input_index); } + void Provider_KernelDefBuilder__OutputMemoryType(Provider_KernelDefBuilder* p, OrtMemType type, int input_index) override { p->OutputMemoryType(type, input_index); } + void Provider_KernelDefBuilder__ExecQueueId(Provider_KernelDefBuilder* p, int queue_id) override { p->ExecQueueId(queue_id); } - std::unique_ptr Provider_KernelDefBuilder__Build(Provider_KernelDefBuilder* p) override { - return std::unique_ptr(reinterpret_cast(reinterpret_cast(p)->Build().release())); - } + std::unique_ptr Provider_KernelDefBuilder__Build(Provider_KernelDefBuilder* p) override { return p->Build(); } // Provider_KernelRegistry - std::shared_ptr Provider_KernelRegistry__construct() override { - auto result = std::make_shared(); - return *reinterpret_cast*>(&result); - } - void Provider_KernelRegistry__operator_delete(Provider_KernelRegistry* p) override { delete reinterpret_cast(p); } + std::shared_ptr Provider_KernelRegistry__construct() override { return std::make_shared(); } + void Provider_KernelRegistry__operator_delete(Provider_KernelRegistry* p) override { delete p; } Status Provider_KernelRegistry__Register(Provider_KernelRegistry* p, Provider_KernelCreateInfo&& create_info) override { - KernelCreateInfo info_real(std::move(*reinterpret_cast*>(&create_info.kernel_def)), + KernelCreateInfo info_real(std::move(create_info.kernel_def), [kernel_create_func = create_info.kernel_create_func](const OpKernelInfo& info) -> OpKernel* { - return new OpKernel_Translator(info, kernel_create_func(*reinterpret_cast(&info))); + return new OpKernel_Translator(info, kernel_create_func(info)); }); - return reinterpret_cast(p)->Register(std::move(info_real)); + return p->Register(std::move(info_real)); } // Provider_Function - const Provider_Graph& Provider_Function__Body(const Provider_Function* p) override { return *reinterpret_cast(&reinterpret_cast(p)->Body()); } + const Provider_Graph& Provider_Function__Body(const Provider_Function* p) override { return p->Body(); } // Provider_Node - const std::string& Provider_Node__Name(const Provider_Node* p) noexcept override { return reinterpret_cast(p)->Name(); } - const std::string& Provider_Node__Description(const Provider_Node* p) noexcept override { return reinterpret_cast(p)->Description(); } - const std::string& Provider_Node__Domain(const Provider_Node* p) noexcept override { return reinterpret_cast(p)->Domain(); } - const std::string& Provider_Node__OpType(const Provider_Node* p) noexcept override { return reinterpret_cast(p)->OpType(); } + const std::string& Provider_Node__Name(const Provider_Node* p) noexcept override { return p->Name(); } + const std::string& Provider_Node__Description(const Provider_Node* p) noexcept override { return p->Description(); } + const std::string& Provider_Node__Domain(const Provider_Node* p) noexcept override { return p->Domain(); } + const std::string& Provider_Node__OpType(const Provider_Node* p) noexcept override { return p->OpType(); } - const Provider_Function* Provider_Node__GetFunctionBody(const Provider_Node* p) noexcept override { return reinterpret_cast(reinterpret_cast(p)->GetFunctionBody()); } + const Provider_Function* Provider_Node__GetFunctionBody(const Provider_Node* p) noexcept override { return p->GetFunctionBody(); } - ConstPointerContainer> Provider_Node__ImplicitInputDefs(const Provider_Node* p) noexcept override { - auto result = reinterpret_cast(p)->ImplicitInputDefs(); - return *reinterpret_cast>*>(&result); - } + ConstPointerContainer> Provider_Node__ImplicitInputDefs(const Provider_Node* p) noexcept override { return p->ImplicitInputDefs(); } + ConstPointerContainer> Provider_Node__InputDefs(const Provider_Node* p) noexcept override { return p->InputDefs(); } + ConstPointerContainer> Provider_Node__OutputDefs(const Provider_Node* p) noexcept override { return p->OutputDefs(); } - ConstPointerContainer> Provider_Node__InputDefs(const Provider_Node* p) noexcept override { - auto result = reinterpret_cast(p)->InputDefs(); - return *reinterpret_cast>*>(&result); - } - ConstPointerContainer> Provider_Node__OutputDefs(const Provider_Node* p) noexcept override { - auto result = reinterpret_cast(p)->OutputDefs(); - return *reinterpret_cast>*>(&result); - } + NodeIndex Provider_Node__Index(const Provider_Node* p) noexcept override { return p->Index(); } - NodeIndex Provider_Node__Index(const Provider_Node* p) noexcept override { return reinterpret_cast(p)->Index(); } + void Provider_Node__ToProto(const Provider_Node* p, Provider_NodeProto& proto, bool update_subgraphs = false) override { p->ToProto(proto, update_subgraphs); } - void Provider_Node__ToProto(const Provider_Node* p, Provider_NodeProto& proto, bool update_subgraphs = false) override { reinterpret_cast(p)->ToProto(*reinterpret_cast(&proto), update_subgraphs); } + const Provider_NodeAttributes& Provider_Node__GetAttributes(const Provider_Node* p) noexcept override { return p->GetAttributes(); } + size_t Provider_Node__GetInputEdgesCount(const Provider_Node* p) noexcept override { return p->GetInputEdgesCount(); } + size_t Provider_Node__GetOutputEdgesCount(const Provider_Node* p) noexcept override { return p->GetOutputEdgesCount(); } - const Provider_NodeAttributes& Provider_Node__GetAttributes(const Provider_Node* p) noexcept override { return *reinterpret_cast(&reinterpret_cast(p)->GetAttributes()); } - size_t Provider_Node__GetInputEdgesCount(const Provider_Node* p) noexcept override { return reinterpret_cast(p)->GetInputEdgesCount(); } - size_t Provider_Node__GetOutputEdgesCount(const Provider_Node* p) noexcept override { return reinterpret_cast(p)->GetOutputEdgesCount(); } + std::unique_ptr Provider_Node__InputNodesBegin(const Provider_Node* p) noexcept override { return onnxruntime::make_unique(p->InputNodesBegin()); } + std::unique_ptr Provider_Node__InputNodesEnd(const Provider_Node* p) noexcept override { return onnxruntime::make_unique(p->InputNodesEnd()); } - std::unique_ptr Provider_Node__InputNodesBegin(const Provider_Node* p) noexcept override { return onnxruntime::make_unique(reinterpret_cast(p)->InputNodesBegin()); } - std::unique_ptr Provider_Node__InputNodesEnd(const Provider_Node* p) noexcept override { return onnxruntime::make_unique(reinterpret_cast(p)->InputNodesEnd()); } - - std::unique_ptr Provider_Node__OutputEdgesBegin(const Provider_Node* p) noexcept override { return onnxruntime::make_unique(reinterpret_cast(p)->OutputEdgesBegin()); } - std::unique_ptr Provider_Node__OutputEdgesEnd(const Provider_Node* p) noexcept override { return onnxruntime::make_unique(reinterpret_cast(p)->OutputEdgesEnd()); } + std::unique_ptr Provider_Node__OutputEdgesBegin(const Provider_Node* p) noexcept override { return onnxruntime::make_unique(p->OutputEdgesBegin()); } + std::unique_ptr Provider_Node__OutputEdgesEnd(const Provider_Node* p) noexcept override { return onnxruntime::make_unique(p->OutputEdgesEnd()); } // Provider_NodeArg - const std::string& Provider_NodeArg__Name(const Provider_NodeArg* p) noexcept override { return reinterpret_cast(p)->Name(); } - const ONNX_NAMESPACE::Provider_TensorShapeProto* Provider_NodeArg__Shape(const Provider_NodeArg* p) override { return reinterpret_cast(reinterpret_cast(p)->Shape()); } - ONNX_NAMESPACE::DataType Provider_NodeArg__Type(const Provider_NodeArg* p) noexcept override { return reinterpret_cast(p)->Type(); } - const Provider_NodeArgInfo& Provider_NodeArg__ToProto(const Provider_NodeArg* p) noexcept override { return *reinterpret_cast(&reinterpret_cast(p)->ToProto()); } - bool Provider_NodeArg__Exists(const Provider_NodeArg* p) const noexcept override { return reinterpret_cast(p)->Exists(); } - const ONNX_NAMESPACE::Provider_TypeProto* Provider_NodeArg__TypeAsProto(const Provider_NodeArg* p) noexcept override { return reinterpret_cast(reinterpret_cast(p)->TypeAsProto()); } + const std::string& Provider_NodeArg__Name(const Provider_NodeArg* p) noexcept override { return p->Name(); } + const Provider_TensorShapeProto* Provider_NodeArg__Shape(const Provider_NodeArg* p) override { return p->Shape(); } + ONNX_NAMESPACE::DataType Provider_NodeArg__Type(const Provider_NodeArg* p) noexcept override { return p->Type(); } + const Provider_NodeArgInfo& Provider_NodeArg__ToProto(const Provider_NodeArg* p) noexcept override { return p->ToProto(); } + bool Provider_NodeArg__Exists(const Provider_NodeArg* p) const noexcept override { return p->Exists(); } + const Provider_TypeProto* Provider_NodeArg__TypeAsProto(const Provider_NodeArg* p) noexcept override { return p->TypeAsProto(); } // Provider_NodeAttributes - std::unique_ptr Provider_NodeAttributes__construct() override { return std::unique_ptr(reinterpret_cast(new NodeAttributes())); } - void Provider_NodeAttributes__operator_delete(Provider_NodeAttributes* p) noexcept override { delete reinterpret_cast(p); } - size_t Provider_NodeAttributes__size(const Provider_NodeAttributes* p) override { return reinterpret_cast(p)->size(); } - void Provider_NodeAttributes__clear(Provider_NodeAttributes* p) noexcept override { return reinterpret_cast(p)->clear(); } - Provider_AttributeProto& Provider_NodeAttributes__operator_array(Provider_NodeAttributes* p, const std::string& string) override { return *reinterpret_cast(&(*reinterpret_cast(p))[string]); } - void Provider_NodeAttributes__operator_assign(Provider_NodeAttributes* p, const Provider_NodeAttributes& v) override { *reinterpret_cast(p) = *reinterpret_cast(&v); } + std::unique_ptr Provider_NodeAttributes__construct() override { return onnxruntime::make_unique(); } + void Provider_NodeAttributes__operator_delete(Provider_NodeAttributes* p) noexcept override { delete p; } + size_t Provider_NodeAttributes__size(const Provider_NodeAttributes* p) override { return p->size(); } + void Provider_NodeAttributes__clear(Provider_NodeAttributes* p) noexcept override { return p->clear(); } + Provider_AttributeProto& Provider_NodeAttributes__operator_array(Provider_NodeAttributes* p, const std::string& string) override { return (*p)[string]; } + void Provider_NodeAttributes__operator_assign(Provider_NodeAttributes* p, const Provider_NodeAttributes& v) override { *p = v; } std::unique_ptr Provider_NodeAttributes__begin(const Provider_NodeAttributes* p) override { - return onnxruntime::make_unique(reinterpret_cast(p)->begin()); + return onnxruntime::make_unique(p->begin()); } std::unique_ptr Provider_NodeAttributes__end(const Provider_NodeAttributes* p) override { - return onnxruntime::make_unique(reinterpret_cast(p)->end()); + return onnxruntime::make_unique(p->end()); } std::unique_ptr Provider_NodeAttributes__find(const Provider_NodeAttributes* p, const std::string& key) override { - return onnxruntime::make_unique(reinterpret_cast(p)->find(key)); - } - void Provider_NodeAttributes__insert(Provider_NodeAttributes* p, const Provider_NodeAttributes& v) override { - auto& nodes = *reinterpret_cast(&v); - return reinterpret_cast(p)->insert(nodes.begin(), nodes.end()); + return onnxruntime::make_unique(p->find(key)); } + void Provider_NodeAttributes__insert(Provider_NodeAttributes* p, const Provider_NodeAttributes& v) override { return p->insert(v.begin(), v.end()); } // Provider_Model - void Provider_Model__operator_delete(Provider_Model* p) override { delete reinterpret_cast(p); } - Provider_Graph& Provider_Model__MainGraph(Provider_Model* p) override { return *reinterpret_cast(&reinterpret_cast(p)->MainGraph()); } - std::unique_ptr Provider_Model__ToProto(Provider_Model* p) override { return std::unique_ptr(reinterpret_cast(new ONNX_NAMESPACE::ModelProto(reinterpret_cast(p)->ToProto()))); } + void Provider_Model__operator_delete(Provider_Model* p) override { delete p; } + Provider_Graph& Provider_Model__MainGraph(Provider_Model* p) override { return p->MainGraph(); } + std::unique_ptr Provider_Model__ToProto(Provider_Model* p) override { return onnxruntime::make_unique(p->ToProto()); } // Provider_Graph - std::unique_ptr Provider_Graph__CreateGraphViewer(const Provider_Graph* p) override { - return std::unique_ptr(reinterpret_cast(new GraphViewer(*reinterpret_cast(p)))); - } + std::unique_ptr Provider_Graph__CreateGraphViewer(const Provider_Graph* p) override { return onnxruntime::make_unique(*p); } + std::unique_ptr Provider_Graph__ToGraphProto(const Provider_Graph* p) override { return onnxruntime::make_unique(p->ToGraphProto()); } - std::unique_ptr Provider_Graph__ToGraphProto(const Provider_Graph* p) override { - return std::unique_ptr(reinterpret_cast(new ONNX_NAMESPACE::GraphProto(reinterpret_cast(p)->ToGraphProto()))); - } + Provider_NodeArg& Provider_Graph__GetOrCreateNodeArg(Provider_Graph* p, const std::string& name, const Provider_TypeProto* p_arg_type) override { return p->GetOrCreateNodeArg(name, p_arg_type); } - Provider_NodeArg& Provider_Graph__GetOrCreateNodeArg(Provider_Graph* p, const std::string& name, const Provider_TypeProto* p_arg_type) override { - return *reinterpret_cast(&reinterpret_cast(p)->GetOrCreateNodeArg(name, reinterpret_cast(p_arg_type))); - } - - Status Provider_Graph__Resolve(Provider_Graph* p) override { return reinterpret_cast(p)->Resolve(); } - void Provider_Graph__AddInitializedTensor(Provider_Graph* p, const Provider_TensorProto& tensor) override { reinterpret_cast(p)->AddInitializedTensor(*reinterpret_cast(&tensor)); } + Status Provider_Graph__Resolve(Provider_Graph* p) override { return p->Resolve(); } + void Provider_Graph__AddInitializedTensor(Provider_Graph* p, const Provider_TensorProto& tensor) override { p->AddInitializedTensor(tensor); } Provider_Node& Provider_Graph__AddNode(Provider_Graph* p, const std::string& name, const std::string& op_type, const std::string& description, const std::vector& input_args, const std::vector& output_args, const Provider_NodeAttributes* attributes, const std::string& domain) override { - return *reinterpret_cast(&reinterpret_cast(p)->AddNode(name, op_type, description, *reinterpret_cast*>(&input_args), *reinterpret_cast*>(&output_args), reinterpret_cast(attributes), domain)); + return p->AddNode(name, op_type, description, input_args, output_args, attributes, domain); } - const std::vector& Provider_Graph__GetOutputs(const Provider_Graph* p) noexcept override { return *reinterpret_cast*>(&reinterpret_cast(p)->GetOutputs()); } - void Provider_Graph__SetOutputs(Provider_Graph* p, const std::vector& outputs) override { reinterpret_cast(p)->SetOutputs(*reinterpret_cast*>(&outputs)); } + const std::vector& Provider_Graph__GetOutputs(const Provider_Graph* p) noexcept override { return p->GetOutputs(); } + void Provider_Graph__SetOutputs(Provider_Graph* p, const std::vector& outputs) override { p->SetOutputs(outputs); } - const std::vector& Provider_Graph__GetInputs(const Provider_Graph* p) noexcept override { return *reinterpret_cast*>(&reinterpret_cast(p)->GetInputs()); } - bool Provider_Graph__GetInitializedTensor(const Provider_Graph* p, const std::string& tensor_name, const Provider_TensorProto*& value) override { return reinterpret_cast(p)->GetInitializedTensor(tensor_name, reinterpret_cast(value)); } + const std::vector& Provider_Graph__GetInputs(const Provider_Graph* p) noexcept override { return p->GetInputs(); } + bool Provider_Graph__GetInitializedTensor(const Provider_Graph* p, const std::string& tensor_name, const Provider_TensorProto*& value) override { return p->GetInitializedTensor(tensor_name, value); } // Provider_GraphViewer - void Provider_GraphViewer__operator_delete(Provider_GraphViewer* p) override { delete reinterpret_cast(p); } - std::unique_ptr Provider_GraphViewer__CreateModel(const Provider_GraphViewer* p, const logging::Logger& logger) override { - auto& graph_viewer = *reinterpret_cast(p); - return std::unique_ptr(reinterpret_cast(new Model(graph_viewer.Name(), true, ModelMetaData(), PathString(), - IOnnxRuntimeOpSchemaRegistryList(), graph_viewer.DomainToVersionMap(), - std::vector(), logger))); + void Provider_GraphViewer__operator_delete(Provider_GraphViewer* p) override { delete p; } + std::unique_ptr Provider_GraphViewer__CreateModel(const Provider_GraphViewer* graph_viewer, const logging::Logger& logger) override { + return onnxruntime::make_unique(graph_viewer->Name(), true, ModelMetaData(), PathString(), + IOnnxRuntimeOpSchemaRegistryList(), graph_viewer->DomainToVersionMap(), + std::vector(), logger); } - const std::string& Provider_GraphViewer__Name(const Provider_GraphViewer* p) noexcept override { return reinterpret_cast(p)->Name(); } + const std::string& Provider_GraphViewer__Name(const Provider_GraphViewer* p) noexcept override { return p->Name(); } - const Provider_Node* Provider_GraphViewer__GetNode(const Provider_GraphViewer* p, NodeIndex node_index) override { return reinterpret_cast(reinterpret_cast(p)->GetNode(node_index)); } - const Provider_NodeArg* Provider_GraphViewer__GetNodeArg(const Provider_GraphViewer* p, const std::string& name) override { return reinterpret_cast(reinterpret_cast(p)->GetNodeArg(name)); } + const Provider_Node* Provider_GraphViewer__GetNode(const Provider_GraphViewer* p, NodeIndex node_index) override { return p->GetNode(node_index); } + const Provider_NodeArg* Provider_GraphViewer__GetNodeArg(const Provider_GraphViewer* p, const std::string& name) override { return p->GetNodeArg(name); } - bool Provider_GraphViewer__IsSubgraph(const Provider_GraphViewer* p) override { return reinterpret_cast(p)->IsSubgraph(); } - int Provider_GraphViewer__NumberOfNodes(const Provider_GraphViewer* p) noexcept override { return reinterpret_cast(p)->NumberOfNodes(); } - int Provider_GraphViewer__MaxNodeIndex(const Provider_GraphViewer* p) noexcept override { return reinterpret_cast(p)->MaxNodeIndex(); } + bool Provider_GraphViewer__IsSubgraph(const Provider_GraphViewer* p) override { return p->IsSubgraph(); } + int Provider_GraphViewer__NumberOfNodes(const Provider_GraphViewer* p) noexcept override { return p->NumberOfNodes(); } + int Provider_GraphViewer__MaxNodeIndex(const Provider_GraphViewer* p) noexcept override { return p->MaxNodeIndex(); } - const std::vector& Provider_GraphViewer__GetInputs(const Provider_GraphViewer* p) noexcept override { return *reinterpret_cast*>(&reinterpret_cast(p)->GetInputs()); } - const std::vector& Provider_GraphViewer__GetOutputs(const Provider_GraphViewer* p) noexcept override { return *reinterpret_cast*>(&reinterpret_cast(p)->GetOutputs()); } - const std::vector& Provider_GraphViewer__GetValueInfo(const Provider_GraphViewer* p) noexcept override { return *reinterpret_cast*>(&reinterpret_cast(p)->GetValueInfo()); } + const std::vector& Provider_GraphViewer__GetInputs(const Provider_GraphViewer* p) noexcept override { return p->GetInputs(); } + const std::vector& Provider_GraphViewer__GetOutputs(const Provider_GraphViewer* p) noexcept override { return p->GetOutputs(); } + const std::vector& Provider_GraphViewer__GetValueInfo(const Provider_GraphViewer* p) noexcept override { return p->GetValueInfo(); } - const Provider_InitializedTensorSet& Provider_GraphViewer__GetAllInitializedTensors(const Provider_GraphViewer* p) override { return *reinterpret_cast(&reinterpret_cast(p)->GetAllInitializedTensors()); } - bool Provider_GraphViewer__GetInitializedTensor(const Provider_GraphViewer* p, const std::string& tensor_name, const Provider_TensorProto*& value) override { return reinterpret_cast(p)->GetInitializedTensor(tensor_name, reinterpret_cast(value)); } + const Provider_InitializedTensorSet& Provider_GraphViewer__GetAllInitializedTensors(const Provider_GraphViewer* p) override { return p->GetAllInitializedTensors(); } + bool Provider_GraphViewer__GetInitializedTensor(const Provider_GraphViewer* p, const std::string& tensor_name, const Provider_TensorProto*& value) override { return p->GetInitializedTensor(tensor_name, value); } - const std::unordered_map& Provider_GraphViewer__DomainToVersionMap(const Provider_GraphViewer* p) override { return reinterpret_cast(p)->DomainToVersionMap(); } + const std::unordered_map& Provider_GraphViewer__DomainToVersionMap(const Provider_GraphViewer* p) override { return p->DomainToVersionMap(); } - const std::vector& Provider_GraphViewer__GetNodesInTopologicalOrder(const Provider_GraphViewer* p) override { return reinterpret_cast(p)->GetNodesInTopologicalOrder(); } + const std::vector& Provider_GraphViewer__GetNodesInTopologicalOrder(const Provider_GraphViewer* p) override { return p->GetNodesInTopologicalOrder(); } // Provider_OpKernel_Base - const Provider_OpKernelInfo& Provider_OpKernel_Base__GetInfo(const Provider_OpKernel_Base* p) override { return *reinterpret_cast(&reinterpret_cast(p)->Info()); } + const Provider_OpKernelInfo& Provider_OpKernel_Base__GetInfo(const Provider_OpKernel_Base* p) override { return reinterpret_cast(p)->Info(); } // Provider_OpKernelContext - const Provider_Tensor* Provider_OpKernelContext__Input_Tensor(const Provider_OpKernelContext* p, int index) override { return reinterpret_cast(reinterpret_cast(p)->Input(index)); } - Provider_Tensor* Provider_OpKernelContext__Output(Provider_OpKernelContext* p, int index, const TensorShape& shape) override { return reinterpret_cast(reinterpret_cast(p)->Output(index, shape)); } + const Provider_Tensor* Provider_OpKernelContext__Input_Tensor(const Provider_OpKernelContext* p, int index) override { return p->Input(index); } + Provider_Tensor* Provider_OpKernelContext__Output(Provider_OpKernelContext* p, int index, const TensorShape& shape) override { return p->Output(index, shape); } // Provider_OpKernelInfo - Status Provider_OpKernelInfo__GetAttr_int64(const Provider_OpKernelInfo* p, const std::string& name, int64_t* value) override { return reinterpret_cast(p)->GetAttr(name, value); } - Status Provider_OpKernelInfo__GetAttr_float(const Provider_OpKernelInfo* p, const std::string& name, float* value) override { return reinterpret_cast(p)->GetAttr(name, value); } + Status Provider_OpKernelInfo__GetAttr_int64(const Provider_OpKernelInfo* p, const std::string& name, int64_t* value) override { return p->GetAttr(name, value); } + Status Provider_OpKernelInfo__GetAttr_float(const Provider_OpKernelInfo* p, const std::string& name, float* value) override { return p->GetAttr(name, value); } - const Provider_DataTransferManager& Provider_OpKernelInfo__GetDataTransferManager(const Provider_OpKernelInfo* p) noexcept override { return *reinterpret_cast(&reinterpret_cast(p)->GetDataTransferManager()); } - int Provider_OpKernelInfo__GetKernelDef_ExecQueueId(const Provider_OpKernelInfo* p) noexcept override { return reinterpret_cast(p)->GetKernelDef().ExecQueueId(); } + const Provider_DataTransferManager& Provider_OpKernelInfo__GetDataTransferManager(const Provider_OpKernelInfo* p) noexcept override { return p->GetDataTransferManager(); } + int Provider_OpKernelInfo__GetKernelDef_ExecQueueId(const Provider_OpKernelInfo* p) noexcept override { return p->GetKernelDef().ExecQueueId(); } // Provider_Tensor - float* Provider_Tensor__MutableData_float(Provider_Tensor* p) override { return reinterpret_cast(p)->MutableData(); } - const float* Provider_Tensor__Data_float(const Provider_Tensor* p) override { return reinterpret_cast(p)->Data(); } + float* Provider_Tensor__MutableData_float(Provider_Tensor* p) override { return p->MutableData(); } + const float* Provider_Tensor__Data_float(const Provider_Tensor* p) override { return p->Data(); } - void* Provider_Tensor__MutableDataRaw(Provider_Tensor* p) noexcept override { return reinterpret_cast(p)->MutableDataRaw(); } - const void* Provider_Tensor__DataRaw(const Provider_Tensor* p) const noexcept override { return reinterpret_cast(p)->DataRaw(); } + void* Provider_Tensor__MutableDataRaw(Provider_Tensor* p) noexcept override { return p->MutableDataRaw(); } + const void* Provider_Tensor__DataRaw(const Provider_Tensor* p) const noexcept override { return p->DataRaw(); } - const TensorShape& Provider_Tensor__Shape(const Provider_Tensor* p) override { return reinterpret_cast(p)->Shape(); } - size_t Provider_Tensor__SizeInBytes(const Provider_Tensor* p) override { return reinterpret_cast(p)->SizeInBytes(); } - const OrtMemoryInfo& Provider_Tensor__Location(const Provider_Tensor* p) override { return reinterpret_cast(p)->Location(); } + const TensorShape& Provider_Tensor__Shape(const Provider_Tensor* p) override { return p->Shape(); } + size_t Provider_Tensor__SizeInBytes(const Provider_Tensor* p) override { return p->SizeInBytes(); } + const OrtMemoryInfo& Provider_Tensor__Location(const Provider_Tensor* p) override { return p->Location(); } } provider_host_; diff --git a/onnxruntime/core/providers/shared_library/provider_interfaces.h b/onnxruntime/core/providers/shared_library/provider_interfaces.h index 62009f2cb9..b5c0627c81 100644 --- a/onnxruntime/core/providers/shared_library/provider_interfaces.h +++ b/onnxruntime/core/providers/shared_library/provider_interfaces.h @@ -25,7 +25,8 @@ using DataType = const std::string*; namespace onnxruntime { -// onnx Protobuf types +// onnx Protobuf types (all of these are actually just Provider_ -> ONNX_NAMESPACE::) +#ifndef PROVIDER_BRIDGE_ORT struct Provider_AttributeProto; struct Provider_GraphProto; struct Provider_ModelProto; @@ -39,16 +40,15 @@ struct Provider_TypeProto_Tensor; struct Provider_TypeProto; struct Provider_ValueInfoProto; struct Provider_ValueInfoProtos; +#endif -// OnnxRuntime Types -struct ProviderHost; +// OnnxRuntime Types (all of these are actually just Provider_ -> ) +#ifndef PROVIDER_BRIDGE_ORT struct Provider_ComputeCapability; struct Provider_DataTransferManager; struct Provider_IDataTransfer; -struct Provider_IExecutionProvider; struct Provider_IndexedSubGraph; struct Provider_IndexedSubGraph_MetaDef; -struct Provider_KernelCreateInfo; struct Provider_KernelDef; struct Provider_KernelDefBuilder; struct Provider_KernelRegistry; @@ -59,10 +59,15 @@ struct Provider_Model; struct Provider_Node; struct Provider_NodeArg; struct Provider_NodeAttributes; -struct Provider_OpKernel_Base; struct Provider_OpKernelContext; struct Provider_OpKernelInfo; struct Provider_Tensor; +#endif + +struct Provider_IExecutionProvider; +struct Provider_KernelCreateInfo; +struct Provider_OpKernel_Base; +struct ProviderHost; class TensorShape; template @@ -177,7 +182,7 @@ using Provider_NodeArgInfo = Provider_ValueInfoProto; // We can't just reinterpret_cast this one, since it's an unordered_map of object BY VALUE (can't do anything by value on the real types) //using Provider_NodeAttributes = std::unordered_map; -using Provider_InitializedTensorSet = std::unordered_map; +using Provider_InitializedTensorSet = std::unordered_map; struct Provider_Node__NodeIterator { virtual ~Provider_Node__NodeIterator() {} @@ -466,7 +471,7 @@ struct ProviderHost { virtual ONNX_NAMESPACE::DataType Provider_NodeArg__Type(const Provider_NodeArg* p) noexcept = 0; virtual const Provider_NodeArgInfo& Provider_NodeArg__ToProto(const Provider_NodeArg* p) noexcept = 0; virtual bool Provider_NodeArg__Exists(const Provider_NodeArg* p) const noexcept = 0; - virtual const ONNX_NAMESPACE::Provider_TypeProto* Provider_NodeArg__TypeAsProto(const Provider_NodeArg* p) noexcept = 0; + virtual const Provider_TypeProto* Provider_NodeArg__TypeAsProto(const Provider_NodeArg* p) noexcept = 0; // Provider_NodeAttributes virtual std::unique_ptr Provider_NodeAttributes__construct() = 0; @@ -554,6 +559,8 @@ struct ProviderHost { extern ProviderHost* g_host; +#ifndef PROVIDER_BRIDGE_ORT + struct Provider_TypeProto_Tensor { int32_t elem_type() const { return g_host->Provider_TypeProto_Tensor__elem_type(this); } @@ -609,8 +616,8 @@ struct Provider_ModelProto { bool SerializeToString(std::string& string) const { return g_host->Provider_ModelProto__SerializeToString(this, string); } bool SerializeToOstream(std::ostream& output) const { return g_host->Provider_ModelProto__SerializeToOstream(this, output); } - const ONNX_NAMESPACE::Provider_GraphProto& graph() const { return g_host->Provider_ModelProto__graph(this); } - ONNX_NAMESPACE::Provider_GraphProto* mutable_graph() { return g_host->Provider_ModelProto__mutable_graph(this); } + const Provider_GraphProto& graph() const { return g_host->Provider_ModelProto__graph(this); } + Provider_GraphProto* mutable_graph() { return g_host->Provider_ModelProto__mutable_graph(this); } void set_ir_version(int64_t value) { return g_host->Provider_ModelProto__set_ir_version(this, value); } @@ -741,6 +748,7 @@ struct Provider_KernelDef { Provider_KernelDef(const Provider_KernelDef*) = delete; void operator=(const Provider_KernelDef&) = delete; }; +#endif using Provider_KernelCreateFn = std::function; using Provider_KernelCreatePtrFn = std::add_pointer::type; @@ -761,6 +769,7 @@ struct Provider_KernelCreateInfo { using Provider_BuildKernelCreateInfoFn = Provider_KernelCreateInfo (*)(); +#ifndef PROVIDER_BRIDGE_ORT struct Provider_KernelDefBuilder { static std::unique_ptr Create() { return g_host->Provider_KernelDefBuilder__construct(); } static void operator delete(void* p) { g_host->Provider_KernelDefBuilder__operator_delete(reinterpret_cast(p)); } @@ -972,6 +981,7 @@ struct Provider_GraphViewer { Provider_GraphViewer(const Provider_GraphViewer&) = delete; void operator=(const Provider_GraphViewer&) = delete; }; +#endif struct Provider_OpKernel_Base { const Provider_OpKernelInfo& GetInfo() const { return g_host->Provider_OpKernel_Base__GetInfo(this); } @@ -979,6 +989,7 @@ struct Provider_OpKernel_Base { PROVIDER_DISALLOW_ALL(Provider_OpKernel_Base) }; +#ifndef PROVIDER_BRIDGE_ORT struct Provider_OpKernelContext { const Provider_Tensor* Input_Tensor(int index) const { return g_host->Provider_OpKernelContext__Input_Tensor(this, index); } @@ -1043,5 +1054,6 @@ inline float* Provider_Tensor::MutableData() { return MutableData_float() template <> inline const float* Provider_Tensor::Data() const { return Data_float(); } +#endif } // namespace onnxruntime