saymrwulf/onnxruntime
1
0
Fork 0
mirror of https://github.com/saymrwulf/onnxruntime.git synced 2026-07-30 20:18:08 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Rename all of the ONNX_NAMESPACE types for shared providers to be back in the ONNX_NAMESPACE with their original names. (#7034)

Browse source
This commit is contained in:
Ryan Hill 2021-03-16 21:18:50 -07:00 committed by GitHub
parent 73d085ccdd
commit a0fdabd23f
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
16 changed files with 469 additions and 472 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

225
onnxruntime/core/framework/provider_bridge_ort.cc
View file

@ -25,24 +25,15 @@
#include "core/providers/cuda/cuda_common.h"
#endif
namespace onnxruntime {
// These Provider types are really just internal types, since we don't include provider_api.h 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_int64s = google::protobuf::RepeatedField<int64_t>;
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<ONNX_NAMESPACE::TensorProto>;
using Provider_TensorShapeProto_Dimension = ONNX_NAMESPACE::TensorShapeProto_Dimension;
using Provider_TensorShapeProto_Dimensions = google::protobuf::RepeatedPtrField<ONNX_NAMESPACE::TensorShapeProto_Dimension>;
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<ONNX_NAMESPACE::ValueInfoProto>;
namespace ONNX_NAMESPACE {
// We use these names in the provider API because we don't have the protobuf definitions of the RepeatedField* types
using int64s = google::protobuf::RepeatedField<int64_t>;
using TensorProtos = google::protobuf::RepeatedPtrField<TensorProto>;
using TensorShapeProto_Dimensions = google::protobuf::RepeatedPtrField<TensorShapeProto_Dimension>;
using ValueInfoProtos = google::protobuf::RepeatedPtrField<ValueInfoProto>;
} // namespace ONNX_NAMESPACE
namespace onnxruntime {
using IndexedSubGraph_MetaDef = IndexedSubGraph::MetaDef;
} // namespace onnxruntime
@ -75,13 +66,13 @@ namespace onnxruntime {
ProviderHost* g_host{};
struct Provider_TensorShapeProto_Dimension_Iterator_Impl : Provider_TensorShapeProto_Dimension_Iterator {
Provider_TensorShapeProto_Dimension_Iterator_Impl(google::protobuf::internal::RepeatedPtrIterator<const onnx::TensorShapeProto_Dimension>&& v) : v_{std::move(v)} {}
struct TensorShapeProto_Dimension_Iterator_Impl : TensorShapeProto_Dimension_Iterator {
TensorShapeProto_Dimension_Iterator_Impl(google::protobuf::internal::RepeatedPtrIterator<const onnx::TensorShapeProto_Dimension>&& v) : v_{std::move(v)} {}
bool operator!=(const Provider_TensorShapeProto_Dimension_Iterator& p) const override { return v_ != static_cast<const Provider_TensorShapeProto_Dimension_Iterator_Impl*>(&p)->v_; }
bool operator!=(const TensorShapeProto_Dimension_Iterator& p) const override { return v_ != static_cast<const TensorShapeProto_Dimension_Iterator_Impl*>(&p)->v_; }
void operator++() override { v_.operator++(); }
const Provider_TensorShapeProto_Dimension& operator*() override { return *v_; }
const ONNX_NAMESPACE::TensorShapeProto_Dimension& operator*() override { return *v_; }
google::protobuf::internal::RepeatedPtrIterator<const onnx::TensorShapeProto_Dimension> v_;
};
@ -93,7 +84,7 @@ struct NodeAttributes_Iterator_Impl : NodeAttributes_Iterator {
void operator++() override { v_.operator++(); }
const std::string& first() const override { return v_->first; }
const Provider_AttributeProto& second() override { return v_->second; }
const ONNX_NAMESPACE::AttributeProto& second() override { return v_->second; }
NodeAttributes::const_iterator v_;
};
@ -244,114 +235,114 @@ struct ProviderHostImpl : ProviderHost {
std::ostream& logging__Capture__Stream(logging::Capture* p) noexcept override { return p->Stream(); }
// Utils::DataTypeUtils
const std::string* Utils__DataTypeUtils__ToType(const Provider_TypeProto& type_proto) override { return ONNX_NAMESPACE::Utils::DataTypeUtils::ToType(type_proto); }
const std::string* Utils__DataTypeUtils__ToType(const ONNX_NAMESPACE::TypeProto& type_proto) override { return ONNX_NAMESPACE::Utils::DataTypeUtils::ToType(type_proto); }
// Provider_int64s
int Provider_int64s__size(const Provider_int64s* p) override { return p->size(); }
const int64_t& Provider_int64s__Get(const Provider_int64s* p, int index) override { return p->Get(index); }
// int64s
int int64s__size(const ONNX_NAMESPACE::int64s* p) override { return p->size(); }
const int64_t& int64s__Get(const ONNX_NAMESPACE::int64s* p, int index) override { return p->Get(index); }
// Provider_TypeProto_Tensor
const Provider_TensorShapeProto& Provider_TypeProto_Tensor__shape(const Provider_TypeProto_Tensor* p) override { return p->shape(); }
Provider_TensorShapeProto* Provider_TypeProto_Tensor__mutable_shape(Provider_TypeProto_Tensor* p) override { return p->mutable_shape(); }
int32_t Provider_TypeProto_Tensor__elem_type(const Provider_TypeProto_Tensor* p) override { return p->elem_type(); }
// TypeProto_Tensor
const ONNX_NAMESPACE::TensorShapeProto& TypeProto_Tensor__shape(const ONNX_NAMESPACE::TypeProto_Tensor* p) override { return p->shape(); }
ONNX_NAMESPACE::TensorShapeProto* TypeProto_Tensor__mutable_shape(ONNX_NAMESPACE::TypeProto_Tensor* p) override { return p->mutable_shape(); }
int32_t TypeProto_Tensor__elem_type(const ONNX_NAMESPACE::TypeProto_Tensor* p) override { return p->elem_type(); }
// Provider_TypeProto
const Provider_TypeProto_Tensor& Provider_TypeProto__tensor_type(const Provider_TypeProto* p) override { return p->tensor_type(); }
Provider_TypeProto_Tensor* Provider_TypeProto__mutable_tensor_type(Provider_TypeProto* p) override { return p->mutable_tensor_type(); }
// TypeProto
const ONNX_NAMESPACE::TypeProto_Tensor& TypeProto__tensor_type(const ONNX_NAMESPACE::TypeProto* p) override { return p->tensor_type(); }
ONNX_NAMESPACE::TypeProto_Tensor* TypeProto__mutable_tensor_type(ONNX_NAMESPACE::TypeProto* p) override { return p->mutable_tensor_type(); }
// Provider_AttributeProto
std::unique_ptr<Provider_AttributeProto> Provider_AttributeProto__construct() override { return onnxruntime::make_unique<ONNX_NAMESPACE::AttributeProto>(); }
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; }
// AttributeProto
std::unique_ptr<ONNX_NAMESPACE::AttributeProto> AttributeProto__construct() override { return onnxruntime::make_unique<ONNX_NAMESPACE::AttributeProto>(); }
void AttributeProto__operator_delete(ONNX_NAMESPACE::AttributeProto* p) override { delete p; }
void AttributeProto__operator_assign(ONNX_NAMESPACE::AttributeProto* p, const ONNX_NAMESPACE::AttributeProto& v) override { *p = v; }
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(); }
int Provider_AttributeProto__floats_size(const Provider_AttributeProto* p) override { return p->floats_size(); }
int64_t Provider_AttributeProto__ints(const Provider_AttributeProto* p, int i) override { return p->ints(i); }
float Provider_AttributeProto__floats(const Provider_AttributeProto* p, int i) override { return p->floats(i); }
const Provider_int64s& Provider_AttributeProto__ints(const Provider_AttributeProto* p) override { return p->ints(); }
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(); }
ONNX_NAMESPACE::AttributeProto_AttributeType AttributeProto__type(const ONNX_NAMESPACE::AttributeProto* p) override { return p->type(); }
int AttributeProto__ints_size(const ONNX_NAMESPACE::AttributeProto* p) override { return p->ints_size(); }
int AttributeProto__floats_size(const ONNX_NAMESPACE::AttributeProto* p) override { return p->floats_size(); }
int64_t AttributeProto__ints(const ONNX_NAMESPACE::AttributeProto* p, int i) override { return p->ints(i); }
float AttributeProto__floats(const ONNX_NAMESPACE::AttributeProto* p, int i) override { return p->floats(i); }
const ONNX_NAMESPACE::int64s& AttributeProto__ints(const ONNX_NAMESPACE::AttributeProto* p) override { return p->ints(); }
int64_t AttributeProto__i(const ONNX_NAMESPACE::AttributeProto* p) override { return p->i(); }
float AttributeProto__f(const ONNX_NAMESPACE::AttributeProto* p) override { return p->f(); }
void AttributeProto__set_s(ONNX_NAMESPACE::AttributeProto* p, const ::std::string& value) override { return p->set_s(value); }
const ::std::string& AttributeProto__s(const ONNX_NAMESPACE::AttributeProto* p) override { return p->s(); }
void AttributeProto__set_name(ONNX_NAMESPACE::AttributeProto* p, const ::std::string& value) override { return p->set_name(value); }
void AttributeProto__set_type(ONNX_NAMESPACE::AttributeProto* p, ONNX_NAMESPACE::AttributeProto_AttributeType value) override { return p->set_type(value); }
ONNX_NAMESPACE::TensorProto* AttributeProto__add_tensors(ONNX_NAMESPACE::AttributeProto* p) override { return p->add_tensors(); }
// Provider_GraphProto
void Provider_GraphProto__operator_delete(Provider_GraphProto* p) override { delete p; }
// GraphProto
void GraphProto__operator_delete(ONNX_NAMESPACE::GraphProto* p) override { delete p; }
const Provider_ValueInfoProto& Provider_GraphProto__input(const Provider_GraphProto* p, int index) override { return p->input(index); }
Provider_ValueInfoProto* Provider_GraphProto__mutable_input(Provider_GraphProto* p, int index) override { return p->mutable_input(index); }
Provider_ValueInfoProtos* Provider_GraphProto__mutable_input(Provider_GraphProto* p) override { return p->mutable_input(); }
int Provider_GraphProto__input_size(const Provider_GraphProto* p) override { return p->input_size(); }
const ONNX_NAMESPACE::ValueInfoProto& GraphProto__input(const ONNX_NAMESPACE::GraphProto* p, int index) override { return p->input(index); }
ONNX_NAMESPACE::ValueInfoProto* GraphProto__mutable_input(ONNX_NAMESPACE::GraphProto* p, int index) override { return p->mutable_input(index); }
ONNX_NAMESPACE::ValueInfoProtos* GraphProto__mutable_input(ONNX_NAMESPACE::GraphProto* p) override { return p->mutable_input(); }
int GraphProto__input_size(const ONNX_NAMESPACE::GraphProto* p) override { return p->input_size(); }
const Provider_ValueInfoProtos& Provider_GraphProto__output(const Provider_GraphProto* p) override { return p->output(); }
const Provider_ValueInfoProto& Provider_GraphProto__output(const Provider_GraphProto* p, int index) override { return p->output(index); }
Provider_ValueInfoProtos* Provider_GraphProto__mutable_output(Provider_GraphProto* p) override { return p->mutable_output(); }
const ONNX_NAMESPACE::ValueInfoProtos& GraphProto__output(const ONNX_NAMESPACE::GraphProto* p) override { return p->output(); }
const ONNX_NAMESPACE::ValueInfoProto& GraphProto__output(const ONNX_NAMESPACE::GraphProto* p, int index) override { return p->output(index); }
ONNX_NAMESPACE::ValueInfoProtos* GraphProto__mutable_output(ONNX_NAMESPACE::GraphProto* p) override { return p->mutable_output(); }
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(); }
ONNX_NAMESPACE::ValueInfoProtos* GraphProto__mutable_value_info(ONNX_NAMESPACE::GraphProto* p) override { return p->mutable_value_info(); }
ONNX_NAMESPACE::TensorProtos* GraphProto__mutable_initializer(ONNX_NAMESPACE::GraphProto* p) override { return p->mutable_initializer(); }
ONNX_NAMESPACE::NodeProto* GraphProto__add_node(ONNX_NAMESPACE::GraphProto* p) override { return p->add_node(); }
void Provider_GraphProto__operator_assign(Provider_GraphProto* p, const Provider_GraphProto& v) override { *p = v; }
void GraphProto__operator_assign(ONNX_NAMESPACE::GraphProto* p, const ONNX_NAMESPACE::GraphProto& v) override { *p = v; }
// Provider_ModelProto
std::unique_ptr<Provider_ModelProto> Provider_ModelProto__construct() override { return onnxruntime::make_unique<ONNX_NAMESPACE::ModelProto>(); }
void Provider_ModelProto__operator_delete(Provider_ModelProto* p) override { delete p; }
// ModelProto
std::unique_ptr<ONNX_NAMESPACE::ModelProto> ModelProto__construct() override { return onnxruntime::make_unique<ONNX_NAMESPACE::ModelProto>(); }
void ModelProto__operator_delete(ONNX_NAMESPACE::ModelProto* p) override { delete p; }
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); }
bool Provider_ModelProto__ParseFromString(Provider_ModelProto* p, const std::string& data) override { return p->ParseFromString(data); }
std::string Provider_ModelProto__SerializeAsString(const Provider_ModelProto* p) override { return p->SerializeAsString(); }
bool ModelProto__SerializeToString(const ONNX_NAMESPACE::ModelProto* p, std::string& string) override { return p->SerializeToString(&string); }
bool ModelProto__SerializeToOstream(const ONNX_NAMESPACE::ModelProto* p, std::ostream& output) override { return p->SerializeToOstream(&output); }
bool ModelProto__ParseFromString(ONNX_NAMESPACE::ModelProto* p, const std::string& data) override { return p->ParseFromString(data); }
std::string ModelProto__SerializeAsString(const ONNX_NAMESPACE::ModelProto* p) override { return p->SerializeAsString(); }
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(); }
const ONNX_NAMESPACE::GraphProto& ModelProto__graph(const ONNX_NAMESPACE::ModelProto* p) override { return p->graph(); }
ONNX_NAMESPACE::GraphProto* ModelProto__mutable_graph(ONNX_NAMESPACE::ModelProto* p) override { return p->mutable_graph(); }
void Provider_ModelProto__set_ir_version(Provider_ModelProto* p, int64_t value) override { p->set_ir_version(value); }
void ModelProto__set_ir_version(ONNX_NAMESPACE::ModelProto* p, int64_t value) override { p->set_ir_version(value); }
// Provider_TensorProto
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; }
bool Provider_TensorProto__has_data_location(const Provider_TensorProto* p) override { return p->has_data_location(); }
int Provider_TensorProto__data_location(const Provider_TensorProto* p) override { return p->data_location(); }
// TensorProto
void TensorProto__operator_delete(ONNX_NAMESPACE::TensorProto* p) override { delete p; }
void TensorProto__operator_assign(ONNX_NAMESPACE::TensorProto* p, const ONNX_NAMESPACE::TensorProto& v) override { *p = v; }
bool TensorProto__has_data_location(const ONNX_NAMESPACE::TensorProto* p) override { return p->has_data_location(); }
int TensorProto__data_location(const ONNX_NAMESPACE::TensorProto* p) override { return p->data_location(); }
// Provider_TensorProtos
Provider_TensorProto* Provider_TensorProtos__Add(Provider_TensorProtos* p) override { return p->Add(); }
// TensorProtos
ONNX_NAMESPACE::TensorProto* TensorProtos__Add(ONNX_NAMESPACE::TensorProtos* p) override { return p->Add(); }
// Provider_TensorShapeProto_Dimension
int Provider_TensorShapeProto_Dimension__value_case(const Provider_TensorShapeProto_Dimension* p) override { return p->value_case(); }
const std::string& Provider_TensorShapeProto_Dimension__dim_param(const Provider_TensorShapeProto_Dimension* p) override { return p->dim_param(); }
int64_t Provider_TensorShapeProto_Dimension__dim_value(const Provider_TensorShapeProto_Dimension* p) override { return p->dim_value(); }
void Provider_TensorShapeProto_Dimension__clear_dim_value(Provider_TensorShapeProto_Dimension* p) override { return p->clear_dim_value(); }
void Provider_TensorShapeProto_Dimension__set_dim_value(Provider_TensorShapeProto_Dimension* p, int64_t value) override { return p->set_dim_value(value); }
// TensorShapeProto_Dimension
int TensorShapeProto_Dimension__value_case(const ONNX_NAMESPACE::TensorShapeProto_Dimension* p) override { return p->value_case(); }
const std::string& TensorShapeProto_Dimension__dim_param(const ONNX_NAMESPACE::TensorShapeProto_Dimension* p) override { return p->dim_param(); }
int64_t TensorShapeProto_Dimension__dim_value(const ONNX_NAMESPACE::TensorShapeProto_Dimension* p) override { return p->dim_value(); }
void TensorShapeProto_Dimension__clear_dim_value(ONNX_NAMESPACE::TensorShapeProto_Dimension* p) override { return p->clear_dim_value(); }
void TensorShapeProto_Dimension__set_dim_value(ONNX_NAMESPACE::TensorShapeProto_Dimension* p, int64_t value) override { return p->set_dim_value(value); }
// Provider_TensorShapeProto_Dimensions
std::unique_ptr<Provider_TensorShapeProto_Dimension_Iterator> Provider_TensorShapeProto_Dimensions__begin(const Provider_TensorShapeProto_Dimensions* p) override {
return onnxruntime::make_unique<Provider_TensorShapeProto_Dimension_Iterator_Impl>(p->begin());
// TensorShapeProto_Dimensions
std::unique_ptr<TensorShapeProto_Dimension_Iterator> TensorShapeProto_Dimensions__begin(const ONNX_NAMESPACE::TensorShapeProto_Dimensions* p) override {
return onnxruntime::make_unique<TensorShapeProto_Dimension_Iterator_Impl>(p->begin());
}
std::unique_ptr<Provider_TensorShapeProto_Dimension_Iterator> Provider_TensorShapeProto_Dimensions__end(const Provider_TensorShapeProto_Dimensions* p) override {
return onnxruntime::make_unique<Provider_TensorShapeProto_Dimension_Iterator_Impl>(p->end());
std::unique_ptr<TensorShapeProto_Dimension_Iterator> TensorShapeProto_Dimensions__end(const ONNX_NAMESPACE::TensorShapeProto_Dimensions* p) override {
return onnxruntime::make_unique<TensorShapeProto_Dimension_Iterator_Impl>(p->end());
}
// Provider_TensorShapeProto
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(); }
const Provider_TensorShapeProto_Dimension& Provider_TensorShapeProto__dim(const Provider_TensorShapeProto* p, int index) override { return p->dim(index); }
Provider_TensorShapeProto_Dimension* Provider_TensorShapeProto__mutable_dim(Provider_TensorShapeProto* p, int index) override { return p->mutable_dim(index); }
void Provider_TensorShapeProto__clear_dim(Provider_TensorShapeProto* p) override { return p->clear_dim(); }
Provider_TensorShapeProto_Dimension* Provider_TensorShapeProto__add_dim(Provider_TensorShapeProto* p) override { return p->add_dim(); }
// TensorShapeProto
int TensorShapeProto__dim_size(const ONNX_NAMESPACE::TensorShapeProto* p) override { return p->dim_size(); }
const ONNX_NAMESPACE::TensorShapeProto_Dimensions& TensorShapeProto__dim(const ONNX_NAMESPACE::TensorShapeProto* p) override { return p->dim(); }
const ONNX_NAMESPACE::TensorShapeProto_Dimension& TensorShapeProto__dim(const ONNX_NAMESPACE::TensorShapeProto* p, int index) override { return p->dim(index); }
ONNX_NAMESPACE::TensorShapeProto_Dimension* TensorShapeProto__mutable_dim(ONNX_NAMESPACE::TensorShapeProto* p, int index) override { return p->mutable_dim(index); }
void TensorShapeProto__clear_dim(ONNX_NAMESPACE::TensorShapeProto* p) override { return p->clear_dim(); }
ONNX_NAMESPACE::TensorShapeProto_Dimension* TensorShapeProto__add_dim(ONNX_NAMESPACE::TensorShapeProto* p) override { return p->add_dim(); }
// Provider_ValueInfoProto
const Provider_TypeProto& Provider_ValueInfoProto__type(const Provider_ValueInfoProto* p) override { return p->type(); }
Provider_TypeProto* Provider_ValueInfoProto__mutable_type(Provider_ValueInfoProto* p) override { return p->mutable_type(); }
virtual void Provider_ValueInfoProto__operator_assign(Provider_ValueInfoProto* p, const Provider_ValueInfoProto& v) override { *p = v; }
// ValueInfoProto
const ONNX_NAMESPACE::TypeProto& ValueInfoProto__type(const ONNX_NAMESPACE::ValueInfoProto* p) override { return p->type(); }
ONNX_NAMESPACE::TypeProto* ValueInfoProto__mutable_type(ONNX_NAMESPACE::ValueInfoProto* p) override { return p->mutable_type(); }
virtual void ValueInfoProto__operator_assign(ONNX_NAMESPACE::ValueInfoProto* p, const ONNX_NAMESPACE::ValueInfoProto& v) override { *p = v; }
// Provider_ValueInfoProtos
Provider_ValueInfoProto* Provider_ValueInfoProtos__Add(Provider_ValueInfoProtos* p) override { return p->Add(); }
// ValueInfoProtos
ONNX_NAMESPACE::ValueInfoProto* ValueInfoProtos__Add(ONNX_NAMESPACE::ValueInfoProtos* p) override { return p->Add(); }
const Provider_ValueInfoProto& Provider_ValueInfoProtos__operator_array(const Provider_ValueInfoProtos* p, int index) override { return (*p)[index]; }
const ONNX_NAMESPACE::ValueInfoProto& ValueInfoProtos__operator_array(const ONNX_NAMESPACE::ValueInfoProtos* p, int index) override { return (*p)[index]; }
// ComputeCapability
std::unique_ptr<ComputeCapability> ComputeCapability__construct(std::unique_ptr<IndexedSubGraph> t_sub_graph) override { return onnxruntime::make_unique<ComputeCapability>(std::move(t_sub_graph)); }
@ -428,7 +419,7 @@ struct ProviderHostImpl : ProviderHost {
NodeIndex Node__Index(const Node* p) noexcept override { return p->Index(); }
void Node__ToProto(const Node* p, Provider_NodeProto& proto, bool update_subgraphs = false) override { p->ToProto(proto, update_subgraphs); }
void Node__ToProto(const Node* p, ONNX_NAMESPACE::NodeProto& proto, bool update_subgraphs = false) override { p->ToProto(proto, update_subgraphs); }
const NodeAttributes& Node__GetAttributes(const Node* p) noexcept override { return p->GetAttributes(); }
size_t Node__GetInputEdgesCount(const Node* p) noexcept override { return p->GetInputEdgesCount(); }
@ -447,11 +438,11 @@ struct ProviderHostImpl : ProviderHost {
// NodeArg
const std::string& NodeArg__Name(const NodeArg* p) noexcept override { return p->Name(); }
const Provider_TensorShapeProto* NodeArg__Shape(const NodeArg* p) override { return p->Shape(); }
const ONNX_NAMESPACE::TensorShapeProto* NodeArg__Shape(const NodeArg* p) override { return p->Shape(); }
ONNX_NAMESPACE::DataType NodeArg__Type(const NodeArg* p) noexcept override { return p->Type(); }
const Provider_NodeArgInfo& NodeArg__ToProto(const NodeArg* p) noexcept override { return p->ToProto(); }
const NodeArgInfo& NodeArg__ToProto(const NodeArg* p) noexcept override { return p->ToProto(); }
bool NodeArg__Exists(const NodeArg* p) const noexcept override { return p->Exists(); }
const Provider_TypeProto* NodeArg__TypeAsProto(const NodeArg* p) noexcept override { return p->TypeAsProto(); }
const ONNX_NAMESPACE::TypeProto* NodeArg__TypeAsProto(const NodeArg* p) noexcept override { return p->TypeAsProto(); }
// NodeAttributes
std::unique_ptr<NodeAttributes> NodeAttributes__construct() override { return onnxruntime::make_unique<NodeAttributes>(); }
@ -459,8 +450,8 @@ struct ProviderHostImpl : ProviderHost {
size_t NodeAttributes__size(const NodeAttributes* p) override { return p->size(); }
void NodeAttributes__clear(NodeAttributes* p) noexcept override { return p->clear(); }
size_t NodeAttributes__count(const NodeAttributes* p, const std::string& keyval) override { return p->count(keyval); }
Provider_AttributeProto& NodeAttributes__operator_array(NodeAttributes* p, const std::string& string) override { return (*p)[string]; }
const Provider_AttributeProto& NodeAttributes__at(const NodeAttributes* p, const std::string& string) override { return p->at(string); }
ONNX_NAMESPACE::AttributeProto& NodeAttributes__operator_array(NodeAttributes* p, const std::string& string) override { return (*p)[string]; }
const ONNX_NAMESPACE::AttributeProto& NodeAttributes__at(const NodeAttributes* p, const std::string& string) override { return p->at(string); }
void NodeAttributes__operator_assign(NodeAttributes* p, const NodeAttributes& v) override { *p = v; }
std::unique_ptr<NodeAttributes_Iterator> NodeAttributes__begin(const NodeAttributes* p) override {
@ -477,16 +468,16 @@ struct ProviderHostImpl : ProviderHost {
// Model
void Model__operator_delete(Model* p) override { delete p; }
Graph& Model__MainGraph(Model* p) override { return p->MainGraph(); }
std::unique_ptr<Provider_ModelProto> Model__ToProto(Model* p) override { return onnxruntime::make_unique<ONNX_NAMESPACE::ModelProto>(p->ToProto()); }
std::unique_ptr<ONNX_NAMESPACE::ModelProto> Model__ToProto(Model* p) override { return onnxruntime::make_unique<ONNX_NAMESPACE::ModelProto>(p->ToProto()); }
// Graph
std::unique_ptr<GraphViewer> Graph__CreateGraphViewer(const Graph* p) override { return onnxruntime::make_unique<GraphViewer>(*p); }
std::unique_ptr<Provider_GraphProto> Graph__ToGraphProto(const Graph* p) override { return onnxruntime::make_unique<ONNX_NAMESPACE::GraphProto>(p->ToGraphProto()); }
std::unique_ptr<ONNX_NAMESPACE::GraphProto> Graph__ToGraphProto(const Graph* p) override { return onnxruntime::make_unique<ONNX_NAMESPACE::GraphProto>(p->ToGraphProto()); }
NodeArg& Graph__GetOrCreateNodeArg(Graph* p, const std::string& name, const Provider_TypeProto* p_arg_type) override { return p->GetOrCreateNodeArg(name, p_arg_type); }
NodeArg& Graph__GetOrCreateNodeArg(Graph* p, const std::string& name, const ONNX_NAMESPACE::TypeProto* p_arg_type) override { return p->GetOrCreateNodeArg(name, p_arg_type); }
Status Graph__Resolve(Graph* p) override { return p->Resolve(); }
void Graph__AddInitializedTensor(Graph* p, const Provider_TensorProto& tensor) override { p->AddInitializedTensor(tensor); }
void Graph__AddInitializedTensor(Graph* p, const ONNX_NAMESPACE::TensorProto& tensor) override { p->AddInitializedTensor(tensor); }
Node& Graph__AddNode(Graph* p, const std::string& name, const std::string& op_type, const std::string& description, const std::vector<NodeArg*>& input_args, const std::vector<NodeArg*>& output_args, const NodeAttributes* attributes, const std::string& domain) override {
return p->AddNode(name, op_type, description, input_args, output_args, attributes, domain);
}
@ -495,7 +486,7 @@ struct ProviderHostImpl : ProviderHost {
void Graph__SetOutputs(Graph* p, const std::vector<const NodeArg*>& outputs) override { p->SetOutputs(outputs); }
const std::vector<const NodeArg*>& Graph__GetInputs(const Graph* p) noexcept override { return p->GetInputs(); }
bool Graph__GetInitializedTensor(const Graph* p, const std::string& tensor_name, const Provider_TensorProto*& value) override { return p->GetInitializedTensor(tensor_name, value); }
bool Graph__GetInitializedTensor(const Graph* p, const std::string& tensor_name, const ONNX_NAMESPACE::TensorProto*& value) override { return p->GetInitializedTensor(tensor_name, value); }
// GraphViewer
void GraphViewer__operator_delete(GraphViewer* p) override { delete p; }
@ -521,7 +512,7 @@ struct ProviderHostImpl : ProviderHost {
const std::vector<const NodeArg*>& GraphViewer__GetValueInfo(const GraphViewer* p) noexcept override { return p->GetValueInfo(); }
const Provider_InitializedTensorSet& GraphViewer__GetAllInitializedTensors(const GraphViewer* p) override { return p->GetAllInitializedTensors(); }
bool GraphViewer__GetInitializedTensor(const GraphViewer* p, const std::string& tensor_name, const Provider_TensorProto*& value) override { return p->GetInitializedTensor(tensor_name, value); }
bool GraphViewer__GetInitializedTensor(const GraphViewer* p, const std::string& tensor_name, const ONNX_NAMESPACE::TensorProto*& value) override { return p->GetInitializedTensor(tensor_name, value); }
const std::unordered_map<std::string, int>& GraphViewer__DomainToVersionMap(const GraphViewer* p) override { return p->DomainToVersionMap(); }

4
onnxruntime/core/providers/dnnl/dnnl_execution_provider.cc
View file

@ -398,7 +398,7 @@ void DNNLExecutionProvider::CreateMetaDef(const GraphViewer& graph_viewer,
std::unordered_set<std::string> input_initializers;
// Create ng_required_initializers attribute of NGraphCustomOp
auto initializers = ONNX_NAMESPACE::Provider_AttributeProto::Create();
auto initializers = ONNX_NAMESPACE::AttributeProto::Create();
initializers->set_name("initializers");
initializers->set_type(ONNX_NAMESPACE::AttributeProto_AttributeType::AttributeProto_AttributeType_TENSORS);
@ -438,7 +438,7 @@ void DNNLExecutionProvider::CreateMetaDef(const GraphViewer& graph_viewer,
}
}
auto ap = ONNX_NAMESPACE::Provider_AttributeProto::Create();
auto ap = ONNX_NAMESPACE::AttributeProto::Create();
ap->set_s(subgraph_id);
ap->set_type(ONNX_NAMESPACE::AttributeProto_AttributeType::AttributeProto_AttributeType_STRING);
meta_def->attributes()["subgraph_id"] = *ap;

8
onnxruntime/core/providers/dnnl/subgraph/dnnl_kernel.h
View file

@ -51,7 +51,7 @@ class DnnlKernel {
ORT_UNUSED_PARAMETER(attributes_prefix);
}
Status GetIntsAttr(const Provider_AttributeProto& proto, std::vector<int64_t>& values) {
Status GetIntsAttr(const ONNX_NAMESPACE::AttributeProto& proto, std::vector<int64_t>& values) {
ORT_RETURN_IF_NOT(proto.type() == ::ONNX_NAMESPACE::AttributeProto_AttributeType::AttributeProto_AttributeType_INTS,
"proto.type() != AttributeProto_AttributeType_INTS");
values.reserve(proto.ints_size());
@ -61,20 +61,20 @@ class DnnlKernel {
return Status::OK();
}
Status GetIntAttr(const Provider_AttributeProto& proto, int64_t& value) {
Status GetIntAttr(const ONNX_NAMESPACE::AttributeProto& proto, int64_t& value) {
ORT_RETURN_IF_NOT(proto.type() == ::ONNX_NAMESPACE::AttributeProto_AttributeType::AttributeProto_AttributeType_INT,
"proto.type() != AttributeProto_AttributeType_INT");
value = proto.i();
return Status::OK();
}
Status GetFloatAttr(const Provider_AttributeProto& proto, float& value) {
Status GetFloatAttr(const ONNX_NAMESPACE::AttributeProto& proto, float& value) {
ORT_RETURN_IF_NOT(proto.type() == ::ONNX_NAMESPACE::AttributeProto_AttributeType::AttributeProto_AttributeType_FLOAT,
"proto.type() != AttributeProto_AttributeType_FLOAT");
value = proto.f();
return Status::OK();
}
Status GetStringAttr(const Provider_AttributeProto& proto, std::string& value) {
Status GetStringAttr(const ONNX_NAMESPACE::AttributeProto& proto, std::string& value) {
ORT_RETURN_IF_NOT(proto.type() == ::ONNX_NAMESPACE::AttributeProto_AttributeType::AttributeProto_AttributeType_STRING,
"proto.type() != AttributeProto_AttributeType_STRING");
value = proto.s();

18
onnxruntime/core/providers/openvino/backend_manager.cc
View file

@ -92,7 +92,7 @@ BackendManager::BackendManager(const Node* fused_node, const logging::Logger& lo
}
}
bool BackendManager::ModelHasBatchedInputs(const ONNX_NAMESPACE::Provider_ModelProto& model_proto) const {
bool BackendManager::ModelHasBatchedInputs(const ONNX_NAMESPACE::ModelProto& model_proto) const {
bool has_batched_inputs = true;
for (int i = 0; i < (int)subgraph_context_.input_indexes.size(); i++) {
@ -144,7 +144,7 @@ bool BackendManager::ModelHasSymbolicInputDims(const onnxruntime::Node* fused_no
return has_sym_dims;
}
std::unique_ptr<ONNX_NAMESPACE::Provider_ModelProto>
std::unique_ptr<ONNX_NAMESPACE::ModelProto>
BackendManager::GetModelProtoFromFusedNode(const onnxruntime::Node* fused_node,
const logging::Logger& logger) const {
const auto* node_function = fused_node->GetFunctionBody();
@ -199,10 +199,10 @@ std::string MakeMapKeyString(std::vector<std::vector<int64_t>>& shapes,
return key;
}
std::shared_ptr<ONNX_NAMESPACE::Provider_ModelProto>
BackendManager::ReWriteInputShapeInfo(const ONNX_NAMESPACE::Provider_ModelProto& model_proto,
std::shared_ptr<ONNX_NAMESPACE::ModelProto>
BackendManager::ReWriteInputShapeInfo(const ONNX_NAMESPACE::ModelProto& model_proto,
std::vector<std::vector<int64_t>> input_shapes) {
auto model_copy = std::shared_ptr<Provider_ModelProto>(Provider_ModelProto::Create());
auto model_copy = std::shared_ptr<ONNX_NAMESPACE::ModelProto>(ONNX_NAMESPACE::ModelProto::Create());
std::string proto_str;
model_proto.SerializeToString(proto_str);
model_copy->ParseFromString(proto_str);
@ -219,16 +219,16 @@ BackendManager::ReWriteInputShapeInfo(const ONNX_NAMESPACE::Provider_ModelProto&
return model_copy;
}
std::shared_ptr<ONNX_NAMESPACE::Provider_ModelProto>
BackendManager::ReWriteBatchDimWithOne(const ONNX_NAMESPACE::Provider_ModelProto& model_proto) {
auto model_copy = std::shared_ptr<Provider_ModelProto>(Provider_ModelProto::Create());
std::shared_ptr<ONNX_NAMESPACE::ModelProto>
BackendManager::ReWriteBatchDimWithOne(const ONNX_NAMESPACE::ModelProto& model_proto) {
auto model_copy = std::shared_ptr<ONNX_NAMESPACE::ModelProto>(ONNX_NAMESPACE::ModelProto::Create());
std::string proto_str;
model_proto.SerializeToString(proto_str);
model_copy->ParseFromString(proto_str);
auto graph_proto = model_copy->mutable_graph();
for (int i = 0; i < graph_proto->input_size(); i++) {
ONNX_NAMESPACE::Provider_TensorShapeProto* g_in_shape = graph_proto->mutable_input((int)i)->mutable_type()->mutable_tensor_type()->mutable_shape();
ONNX_NAMESPACE::TensorShapeProto* g_in_shape = graph_proto->mutable_input((int)i)->mutable_type()->mutable_tensor_type()->mutable_shape();
g_in_shape->mutable_dim(0)->clear_dim_value();
g_in_shape->mutable_dim(0)->set_dim_value(1);
}

14
onnxruntime/core/providers/openvino/backend_manager.h
View file

@ -21,19 +21,19 @@ class BackendManager {
static void ReleaseGlobalContext();
private:
std::unique_ptr<ONNX_NAMESPACE::Provider_ModelProto> GetModelProtoFromFusedNode(
std::unique_ptr<ONNX_NAMESPACE::ModelProto> GetModelProtoFromFusedNode(
const onnxruntime::Node* fused_node, const logging::Logger& logger) const;
bool ModelHasSymbolicInputDims(const onnxruntime::Node* fused_node) const;
bool ModelHasBatchedInputs(const ONNX_NAMESPACE::Provider_ModelProto& model_proto) const;
bool ModelHasBatchedInputs(const ONNX_NAMESPACE::ModelProto& model_proto) const;
std::shared_ptr<ONNX_NAMESPACE::Provider_ModelProto>
ReWriteBatchDimWithOne(const ONNX_NAMESPACE::Provider_ModelProto& model_proto);
std::shared_ptr<ONNX_NAMESPACE::ModelProto>
ReWriteBatchDimWithOne(const ONNX_NAMESPACE::ModelProto& model_proto);
std::shared_ptr<ONNX_NAMESPACE::Provider_ModelProto>
ReWriteInputShapeInfo(const ONNX_NAMESPACE::Provider_ModelProto& model_proto,
std::shared_ptr<ONNX_NAMESPACE::ModelProto>
ReWriteInputShapeInfo(const ONNX_NAMESPACE::ModelProto& model_proto,
std::vector<std::vector<int64_t>> input_shapes);
std::unique_ptr<ONNX_NAMESPACE::Provider_ModelProto> model_proto_;
std::unique_ptr<ONNX_NAMESPACE::ModelProto> model_proto_;
std::shared_ptr<IBackend> concrete_backend_;
std::map<std::string, std::shared_ptr<IBackend>> backend_map_;
SubGraphContext subgraph_context_;

8
onnxruntime/core/providers/openvino/backend_utils.cc
View file

@ -33,7 +33,7 @@ bool IsDebugEnabled() {
return (std::getenv("ORT_OPENVINO_ENABLE_DEBUG") != nullptr);
#endif
}
void DumpOnnxModelProto(const Provider_ModelProto& model_proto, std::string file_name) {
void DumpOnnxModelProto(const ONNX_NAMESPACE::ModelProto& model_proto, std::string file_name) {
std::fstream outfile(file_name, std::ios::out | std::ios::trunc | std::ios::binary);
model_proto.SerializeToOstream(outfile);
}
@ -46,7 +46,7 @@ struct static_cast_int64 {
};
std::shared_ptr<InferenceEngine::CNNNetwork>
CreateCNNNetwork(const Provider_ModelProto& model_proto, const GlobalContext& global_context, const SubGraphContext& subgraph_context, std::map<std::string, std::shared_ptr<ngraph::Node>>& const_outputs_map) {
CreateCNNNetwork(const ONNX_NAMESPACE::ModelProto& model_proto, const GlobalContext& global_context, const SubGraphContext& subgraph_context, std::map<std::string, std::shared_ptr<ngraph::Node>>& const_outputs_map) {
#if defined OPENVINO_2020_3
ORT_UNUSED_PARAMETER(const_outputs_map);
#endif
@ -105,7 +105,7 @@ CreateCNNNetwork(const Provider_ModelProto& model_proto, const GlobalContext& gl
}
}
InferenceEngine::Precision ConvertPrecisionONNXToOpenVINO(const Provider_TypeProto& onnx_type, std::string device) {
InferenceEngine::Precision ConvertPrecisionONNXToOpenVINO(const ONNX_NAMESPACE::TypeProto& onnx_type, std::string device) {
ONNX_NAMESPACE::DataType type_string = ONNX_NAMESPACE::Utils::DataTypeUtils::ToType(onnx_type);
if (*type_string == "float" || *type_string == "tensor(float)") {
return InferenceEngine::Precision::FP32;
@ -134,7 +134,7 @@ InferenceEngine::Precision ConvertPrecisionONNXToOpenVINO(const Provider_TypePro
}
}
void SetIODefs(const Provider_ModelProto& model_proto,
void SetIODefs(const ONNX_NAMESPACE::ModelProto& model_proto,
std::shared_ptr<InferenceEngine::CNNNetwork> network,
std::unordered_map<std::string, int> output_names,
std::map<std::string, std::shared_ptr<ngraph::Node>>& const_outputs_map,

6
onnxruntime/core/providers/openvino/backend_utils.h
View file

@ -19,14 +19,14 @@ const std::string log_tag = "[OpenVINO-EP] ";
bool IsDebugEnabled();
#endif
void SetIODefs(const ONNX_NAMESPACE::Provider_ModelProto& model_proto,
void SetIODefs(const ONNX_NAMESPACE::ModelProto& model_proto,
std::shared_ptr<InferenceEngine::CNNNetwork> network,
std::unordered_map<std::string, int> output_names,
std::map<std::string, std::shared_ptr<ngraph::Node>>& const_outputs_map,
std::string device);
std::shared_ptr<InferenceEngine::CNNNetwork>
CreateCNNNetwork(const ONNX_NAMESPACE::Provider_ModelProto& model_proto, const GlobalContext& global_context, const SubGraphContext& subgraph_context, std::map<std::string, std::shared_ptr<ngraph::Node>>& const_outputs_map);
CreateCNNNetwork(const ONNX_NAMESPACE::ModelProto& model_proto, const GlobalContext& global_context, const SubGraphContext& subgraph_context, std::map<std::string, std::shared_ptr<ngraph::Node>>& const_outputs_map);
int GetFirstAvailableDevice(GlobalContext& global_context);
@ -44,7 +44,7 @@ GetOutputTensor(Ort::CustomOpApi& ort, OrtKernelContext* context,
#endif
InferenceEngine::Precision
ConvertPrecisionONNXToOpenVINO(const ONNX_NAMESPACE::Provider_TypeProto& onnx_type, std::string device);
ConvertPrecisionONNXToOpenVINO(const ONNX_NAMESPACE::TypeProto& onnx_type, std::string device);
OrtValue*
GetOutputTensor(Ort::CustomOpApi& ort, OrtKernelContext* context, size_t batch_size,

2
onnxruntime/core/providers/openvino/backends/backend_factory.cc
View file

@ -12,7 +12,7 @@ namespace onnxruntime {
namespace openvino_ep {
std::shared_ptr<IBackend>
BackendFactory::MakeBackend(const Provider_ModelProto& model_proto,
BackendFactory::MakeBackend(const ONNX_NAMESPACE::ModelProto& model_proto,
GlobalContext& global_context,
const SubGraphContext& subgraph_context) {
std::string type = global_context.device_type;

40
onnxruntime/core/providers/openvino/backends/basic_backend.cc
View file

@ -22,7 +22,7 @@ namespace openvino_ep {
using namespace backend_utils;
BasicBackend::BasicBackend(const Provider_ModelProto& model_proto,
BasicBackend::BasicBackend(const ONNX_NAMESPACE::ModelProto& model_proto,
GlobalContext& global_context,
const SubGraphContext& subgraph_context)
: global_context_(global_context), subgraph_context_(subgraph_context) {
@ -173,7 +173,7 @@ void BasicBackend::Infer(Ort::CustomOpApi& ort, OrtKernelContext* context) {
LOGS_DEFAULT(INFO) << log_tag << "In Infer";
if (subgraph_context_.is_constant) {
#if defined(OPENVINO_2020_4) || defined(OPENVINO_2021_1) || defined(OPENVINO_2021_2)
#if defined(OPENVINO_2020_4) || defined(OPENVINO_2021_1) || defined(OPENVINO_2021_2)
for (auto item : const_outputs_map_) {
auto out_name = item.first;
auto node = item.second;
@ -184,25 +184,25 @@ void BasicBackend::Infer(Ort::CustomOpApi& ort, OrtKernelContext* context) {
// Get Output tensors
LOGS_DEFAULT(INFO) << log_tag << "Inference successful";
} else {
//Requesting for an idle infer_request from a pool of infer_requests_
std::shared_ptr<InferenceEngine::InferRequest> infer_request = inferRequestsQueue_->getIdleRequest();
if (!infer_request) {
LOGS_DEFAULT(INFO) << "No idle Infer Requests found from the infer_requests_ pool!";
THROW_IE_EXCEPTION << "No idle Infer Requests!";
}
StartAsyncInference(ort, context, infer_request);
CompleteAsyncInference(ort, context, infer_request);
// Get Output tensors
LOGS_DEFAULT(INFO) << log_tag << "Inference successful";
//Once the inference is completed, the infer_request becomes free and is placed back into pool of infer_requests_
inferRequestsQueue_->putIdleRequest(infer_request);
//Requesting for an idle infer_request from a pool of infer_requests_
std::shared_ptr<InferenceEngine::InferRequest> infer_request = inferRequestsQueue_->getIdleRequest();
if (!infer_request) {
LOGS_DEFAULT(INFO) << "No idle Infer Requests found from the infer_requests_ pool!";
THROW_IE_EXCEPTION << "No idle Infer Requests!";
}
StartAsyncInference(ort, context, infer_request);
CompleteAsyncInference(ort, context, infer_request);
// Get Output tensors
LOGS_DEFAULT(INFO) << log_tag << "Inference successful";
//Once the inference is completed, the infer_request becomes free and is placed back into pool of infer_requests_
inferRequestsQueue_->putIdleRequest(infer_request);
#ifndef NDEBUG
if (openvino_ep::backend_utils::IsDebugEnabled()) {
inferRequestsQueue_->printstatus(); //Printing the elements of infer_requests_ vector pool only in debug mode
std::string& hw_target = (global_context_.device_id != "") ? global_context_.device_id : global_context_.device_type;
printPerformanceCounts(infer_request, std::cout, hw_target);
}
if (openvino_ep::backend_utils::IsDebugEnabled()) {
inferRequestsQueue_->printstatus(); //Printing the elements of infer_requests_ vector pool only in debug mode
std::string& hw_target = (global_context_.device_id != "") ? global_context_.device_id : global_context_.device_type;
printPerformanceCounts(infer_request, std::cout, hw_target);
}
#endif
}
}

2
onnxruntime/core/providers/openvino/backends/basic_backend.h
View file

@ -22,7 +22,7 @@ namespace openvino_ep {
class InferRequestsQueue;
class BasicBackend : public IBackend {
public:
BasicBackend(const Provider_ModelProto& model_proto,
BasicBackend(const ONNX_NAMESPACE::ModelProto& model_proto,
GlobalContext& global_context,
const SubGraphContext& subgraph_context);

2
onnxruntime/core/providers/openvino/backends/vadm_backend.cc
View file

@ -25,7 +25,7 @@ namespace openvino_ep {
using namespace backend_utils;
VADMBackend::VADMBackend(const Provider_ModelProto& model_proto,
VADMBackend::VADMBackend(const ONNX_NAMESPACE::ModelProto& model_proto,
GlobalContext& global_context,
const SubGraphContext& subgraph_context)
: global_context_(global_context), subgraph_context_(subgraph_context) {

2
onnxruntime/core/providers/openvino/backends/vadm_backend.h
View file

@ -14,7 +14,7 @@ namespace openvino_ep {
class VADMBackend : public IBackend {
public:
VADMBackend(const Provider_ModelProto& model_proto,
VADMBackend(const ONNX_NAMESPACE::ModelProto& model_proto,
GlobalContext& global_context,
const SubGraphContext& subgraph_context);

2
onnxruntime/core/providers/openvino/ibackend.h
View file

@ -20,7 +20,7 @@ class IBackend {
class BackendFactory {
public:
static std::shared_ptr<IBackend>
MakeBackend(const Provider_ModelProto& model_proto,
MakeBackend(const ONNX_NAMESPACE::ModelProto& model_proto,
GlobalContext& global_context,
const SubGraphContext& subgraph_context);
};

130
onnxruntime/core/providers/shared_library/provider_api.h
View file

@ -25,71 +25,6 @@
#include "core/providers/providers.h"
#include "core/common/path_string.h"
namespace onnxruntime {
namespace logging {
enum class DataType {
SYSTEM = 0, ///< System data.
USER = 1 ///< Contains potentially sensitive user data.
};
} // namespace logging
enum class AutoPadType {
NOTSET = 0,
VALID = 1,
SAME_UPPER = 2,
SAME_LOWER = 3,
};
// onnx Protobuf types (all of these are actually just Provider_<type> -> ONNX_NAMESPACE::<type>)
struct Provider_int64s; // RepeatedPtrField
struct Provider_AttributeProto;
struct Provider_GraphProto;
struct Provider_ModelProto;
struct Provider_NodeProto;
struct Provider_TensorProto;
struct Provider_TensorProtos;
struct Provider_TensorShapeProto_Dimension;
struct Provider_TensorShapeProto_Dimensions; // RepeatedPtrField
struct Provider_TensorShapeProto;
struct Provider_TypeProto_Tensor;
struct Provider_TypeProto;
struct Provider_ValueInfoProto;
struct Provider_ValueInfoProtos; // RepeatedPtrField
// OnnxRuntime Types (these are the internal types)
struct CPUIDInfo;
namespace logging {
struct Logger;
struct Capture;
} // namespace logging
struct ComputeCapability;
struct DataTransferManager;
struct IDataTransfer;
struct IndexedSubGraph;
struct IndexedSubGraph_MetaDef;
struct KernelCreateInfo;
struct KernelDef;
struct KernelDefBuilder;
struct KernelRegistry;
struct Function;
struct Graph;
struct GraphViewer;
struct Model;
struct Path;
struct Node;
struct NodeArg;
struct NodeAttributes;
struct OpKernelContext;
struct OpKernelInfo;
struct PrimitiveDataTypeBase;
struct Tensor;
class DataTypeImpl;
using MLDataType = const DataTypeImpl*;
} // namespace onnxruntime
namespace ONNX_NAMESPACE {
// These are exact duplicates of the real protobuf types, defined here since we can't include the protobuf headers
@ -150,8 +85,73 @@ enum OperatorStatus : int {
STABLE = 1
};
// onnx Protobuf types (All of these are direct mappings to the onnx types except for the Repeated*Field ones which map to a Repeated*Field type)
struct int64s; // RepeatedField
struct AttributeProto;
struct GraphProto;
struct ModelProto;
struct NodeProto;
struct TensorProto;
struct TensorProtos; // RepeatedPtrField
struct TensorShapeProto_Dimension;
struct TensorShapeProto_Dimensions; // RepeatedPtrField
struct TensorShapeProto;
struct TypeProto_Tensor;
struct TypeProto;
struct ValueInfoProto;
struct ValueInfoProtos; // RepeatedPtrField
} // namespace ONNX_NAMESPACE
namespace onnxruntime {
namespace logging {
enum class DataType {
SYSTEM = 0, ///< System data.
USER = 1 ///< Contains potentially sensitive user data.
};
} // namespace logging
enum class AutoPadType {
NOTSET = 0,
VALID = 1,
SAME_UPPER = 2,
SAME_LOWER = 3,
};
// OnnxRuntime Types (these are the internal types)
struct CPUIDInfo;
namespace logging {
struct Logger;
struct Capture;
} // namespace logging
struct ComputeCapability;
struct DataTransferManager;
struct IDataTransfer;
struct IndexedSubGraph;
struct IndexedSubGraph_MetaDef;
struct KernelCreateInfo;
struct KernelDef;
struct KernelDefBuilder;
struct KernelRegistry;
struct Function;
struct Graph;
struct GraphViewer;
struct Model;
struct Path;
struct Node;
struct NodeArg;
struct NodeAttributes;
struct OpKernelContext;
struct OpKernelInfo;
struct PrimitiveDataTypeBase;
struct Tensor;
class DataTypeImpl;
using MLDataType = const DataTypeImpl*;
using NodeArgInfo = ONNX_NAMESPACE::ValueInfoProto;
} // namespace onnxruntime
#include "core/framework/execution_provider.h"
#include "provider_interfaces.h"
#include "core/framework/op_kernel.h"

466
onnxruntime/core/providers/shared_library/provider_interfaces.h
View file

@ -52,24 +52,23 @@ struct NodeAttributes_Iterator {
virtual void operator++() = 0;
virtual const std::string& first() const = 0;
virtual const Provider_AttributeProto& second() = 0;
virtual const ONNX_NAMESPACE::AttributeProto& second() = 0;
};
struct Provider_TensorShapeProto_Dimension_Iterator {
virtual ~Provider_TensorShapeProto_Dimension_Iterator() {}
struct TensorShapeProto_Dimension_Iterator {
virtual ~TensorShapeProto_Dimension_Iterator() {}
virtual bool operator!=(const Provider_TensorShapeProto_Dimension_Iterator& p) const = 0;
virtual bool operator!=(const TensorShapeProto_Dimension_Iterator& p) const = 0;
virtual void operator++() = 0;
virtual const Provider_TensorShapeProto_Dimension& operator*() = 0;
virtual const ONNX_NAMESPACE::TensorShapeProto_Dimension& operator*() = 0;
};
using NodeIndex = size_t;
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 NodeAttributes = std::unordered_map<std::string, ONNX_NAMESPACE::Provider_AttributeProto_Copyable>;
// using NodeAttributes = std::unordered_map<std::string, ONNX_NAMESPACE::AttributeProto_Copyable>;
using Provider_InitializedTensorSet = std::unordered_map<std::string, const Provider_TensorProto*>;
using Provider_InitializedTensorSet = std::unordered_map<std::string, const ONNX_NAMESPACE::TensorProto*>;
struct Node__NodeIterator {
virtual ~Node__NodeIterator() {}
@ -191,108 +190,108 @@ struct ProviderHost {
virtual std::ostream& logging__Capture__Stream(logging::Capture* p) noexcept = 0;
// Utils::DataTypeUtils
virtual const std::string* Utils__DataTypeUtils__ToType(const Provider_TypeProto& type_proto) = 0;
virtual const std::string* Utils__DataTypeUtils__ToType(const ONNX_NAMESPACE::TypeProto& type_proto) = 0;
// Provider_int64s
virtual int Provider_int64s__size(const Provider_int64s* p) = 0;
virtual const int64_t& Provider_int64s__Get(const Provider_int64s* p, int index) = 0;
// int64s
virtual int int64s__size(const ONNX_NAMESPACE::int64s* p) = 0;
virtual const int64_t& int64s__Get(const ONNX_NAMESPACE::int64s* p, int index) = 0;
// Provider_TypeProto_Tensor
virtual const Provider_TensorShapeProto& Provider_TypeProto_Tensor__shape(const Provider_TypeProto_Tensor* p) = 0;
virtual Provider_TensorShapeProto* Provider_TypeProto_Tensor__mutable_shape(Provider_TypeProto_Tensor* p) = 0;
virtual int32_t Provider_TypeProto_Tensor__elem_type(const Provider_TypeProto_Tensor* p) = 0;
// TypeProto_Tensor
virtual const ONNX_NAMESPACE::TensorShapeProto& TypeProto_Tensor__shape(const ONNX_NAMESPACE::TypeProto_Tensor* p) = 0;
virtual ONNX_NAMESPACE::TensorShapeProto* TypeProto_Tensor__mutable_shape(ONNX_NAMESPACE::TypeProto_Tensor* p) = 0;
virtual int32_t TypeProto_Tensor__elem_type(const ONNX_NAMESPACE::TypeProto_Tensor* p) = 0;
// Provider_TypeProto
virtual const Provider_TypeProto_Tensor& Provider_TypeProto__tensor_type(const Provider_TypeProto* p) = 0;
virtual Provider_TypeProto_Tensor* Provider_TypeProto__mutable_tensor_type(Provider_TypeProto* p) = 0;
// TypeProto
virtual const ONNX_NAMESPACE::TypeProto_Tensor& TypeProto__tensor_type(const ONNX_NAMESPACE::TypeProto* p) = 0;
virtual ONNX_NAMESPACE::TypeProto_Tensor* TypeProto__mutable_tensor_type(ONNX_NAMESPACE::TypeProto* p) = 0;
// Provider_AttributeProto
virtual std::unique_ptr<Provider_AttributeProto> Provider_AttributeProto__construct() = 0;
virtual void Provider_AttributeProto__operator_delete(Provider_AttributeProto* p) = 0;
virtual void Provider_AttributeProto__operator_assign(Provider_AttributeProto* p, const Provider_AttributeProto& v) = 0;
// AttributeProto
virtual std::unique_ptr<ONNX_NAMESPACE::AttributeProto> AttributeProto__construct() = 0;
virtual void AttributeProto__operator_delete(ONNX_NAMESPACE::AttributeProto* p) = 0;
virtual void AttributeProto__operator_assign(ONNX_NAMESPACE::AttributeProto* p, const ONNX_NAMESPACE::AttributeProto& v) = 0;
virtual ONNX_NAMESPACE::AttributeProto_AttributeType Provider_AttributeProto__type(const Provider_AttributeProto* p) = 0;
virtual int Provider_AttributeProto__ints_size(const Provider_AttributeProto* p) = 0;
virtual int Provider_AttributeProto__floats_size(const Provider_AttributeProto* p) = 0;
virtual int64_t Provider_AttributeProto__ints(const Provider_AttributeProto* p, int i) = 0;
virtual float Provider_AttributeProto__floats(const Provider_AttributeProto* p, int i) = 0;
virtual const Provider_int64s& Provider_AttributeProto__ints(const Provider_AttributeProto* p) = 0;
virtual int64_t Provider_AttributeProto__i(const Provider_AttributeProto* p) = 0;
virtual float Provider_AttributeProto__f(const Provider_AttributeProto* p) = 0;
virtual void Provider_AttributeProto__set_s(Provider_AttributeProto* p, const ::std::string& value) = 0;
virtual const ::std::string& Provider_AttributeProto__s(const Provider_AttributeProto* p) = 0;
virtual void Provider_AttributeProto__set_name(Provider_AttributeProto* p, const ::std::string& value) = 0;
virtual void Provider_AttributeProto__set_type(Provider_AttributeProto* p, ONNX_NAMESPACE::AttributeProto_AttributeType value) = 0;
virtual Provider_TensorProto* Provider_AttributeProto__add_tensors(Provider_AttributeProto* p) = 0;
virtual ONNX_NAMESPACE::AttributeProto_AttributeType AttributeProto__type(const ONNX_NAMESPACE::AttributeProto* p) = 0;
virtual int AttributeProto__ints_size(const ONNX_NAMESPACE::AttributeProto* p) = 0;
virtual int AttributeProto__floats_size(const ONNX_NAMESPACE::AttributeProto* p) = 0;
virtual int64_t AttributeProto__ints(const ONNX_NAMESPACE::AttributeProto* p, int i) = 0;
virtual float AttributeProto__floats(const ONNX_NAMESPACE::AttributeProto* p, int i) = 0;
virtual const ONNX_NAMESPACE::int64s& AttributeProto__ints(const ONNX_NAMESPACE::AttributeProto* p) = 0;
virtual int64_t AttributeProto__i(const ONNX_NAMESPACE::AttributeProto* p) = 0;
virtual float AttributeProto__f(const ONNX_NAMESPACE::AttributeProto* p) = 0;
virtual void AttributeProto__set_s(ONNX_NAMESPACE::AttributeProto* p, const ::std::string& value) = 0;
virtual const ::std::string& AttributeProto__s(const ONNX_NAMESPACE::AttributeProto* p) = 0;
virtual void AttributeProto__set_name(ONNX_NAMESPACE::AttributeProto* p, const ::std::string& value) = 0;
virtual void AttributeProto__set_type(ONNX_NAMESPACE::AttributeProto* p, ONNX_NAMESPACE::AttributeProto_AttributeType value) = 0;
virtual ONNX_NAMESPACE::TensorProto* AttributeProto__add_tensors(ONNX_NAMESPACE::AttributeProto* p) = 0;
// Provider_GraphProto
virtual void Provider_GraphProto__operator_delete(Provider_GraphProto* p) = 0;
virtual void Provider_GraphProto__operator_assign(Provider_GraphProto* p, const Provider_GraphProto& v) = 0;
// GraphProto
virtual void GraphProto__operator_delete(ONNX_NAMESPACE::GraphProto* p) = 0;
virtual void GraphProto__operator_assign(ONNX_NAMESPACE::GraphProto* p, const ONNX_NAMESPACE::GraphProto& v) = 0;
virtual const Provider_ValueInfoProto& Provider_GraphProto__input(const Provider_GraphProto* p, int index) = 0;
virtual Provider_ValueInfoProtos* Provider_GraphProto__mutable_input(Provider_GraphProto* p) = 0;
virtual Provider_ValueInfoProto* Provider_GraphProto__mutable_input(Provider_GraphProto* p, int index) = 0;
virtual int Provider_GraphProto__input_size(const Provider_GraphProto* p) = 0;
virtual const ONNX_NAMESPACE::ValueInfoProto& GraphProto__input(const ONNX_NAMESPACE::GraphProto* p, int index) = 0;
virtual ONNX_NAMESPACE::ValueInfoProtos* GraphProto__mutable_input(ONNX_NAMESPACE::GraphProto* p) = 0;
virtual ONNX_NAMESPACE::ValueInfoProto* GraphProto__mutable_input(ONNX_NAMESPACE::GraphProto* p, int index) = 0;
virtual int GraphProto__input_size(const ONNX_NAMESPACE::GraphProto* p) = 0;
virtual const Provider_ValueInfoProtos& Provider_GraphProto__output(const Provider_GraphProto* p) = 0;
virtual const Provider_ValueInfoProto& Provider_GraphProto__output(const Provider_GraphProto* p, int index) = 0;
virtual Provider_ValueInfoProtos* Provider_GraphProto__mutable_output(Provider_GraphProto* p) = 0;
virtual const ONNX_NAMESPACE::ValueInfoProtos& GraphProto__output(const ONNX_NAMESPACE::GraphProto* p) = 0;
virtual const ONNX_NAMESPACE::ValueInfoProto& GraphProto__output(const ONNX_NAMESPACE::GraphProto* p, int index) = 0;
virtual ONNX_NAMESPACE::ValueInfoProtos* GraphProto__mutable_output(ONNX_NAMESPACE::GraphProto* p) = 0;
virtual Provider_ValueInfoProtos* Provider_GraphProto__mutable_value_info(Provider_GraphProto* p) = 0;
virtual Provider_TensorProtos* Provider_GraphProto__mutable_initializer(Provider_GraphProto* p) = 0;
virtual Provider_NodeProto* Provider_GraphProto__add_node(Provider_GraphProto* p) = 0;
virtual ONNX_NAMESPACE::ValueInfoProtos* GraphProto__mutable_value_info(ONNX_NAMESPACE::GraphProto* p) = 0;
virtual ONNX_NAMESPACE::TensorProtos* GraphProto__mutable_initializer(ONNX_NAMESPACE::GraphProto* p) = 0;
virtual ONNX_NAMESPACE::NodeProto* GraphProto__add_node(ONNX_NAMESPACE::GraphProto* p) = 0;
// Provider_ModelProto
virtual std::unique_ptr<Provider_ModelProto> Provider_ModelProto__construct() = 0;
virtual void Provider_ModelProto__operator_delete(Provider_ModelProto* p) = 0;
// ModelProto
virtual std::unique_ptr<ONNX_NAMESPACE::ModelProto> ModelProto__construct() = 0;
virtual void ModelProto__operator_delete(ONNX_NAMESPACE::ModelProto* p) = 0;
virtual bool Provider_ModelProto__SerializeToString(const Provider_ModelProto* p, std::string& string) = 0;
virtual bool Provider_ModelProto__SerializeToOstream(const Provider_ModelProto* p, std::ostream& output) = 0;
virtual bool Provider_ModelProto__ParseFromString(Provider_ModelProto* p, const std::string& data) = 0;
virtual std::string Provider_ModelProto__SerializeAsString(const Provider_ModelProto* p) = 0;
virtual bool ModelProto__SerializeToString(const ONNX_NAMESPACE::ModelProto* p, std::string& string) = 0;
virtual bool ModelProto__SerializeToOstream(const ONNX_NAMESPACE::ModelProto* p, std::ostream& output) = 0;
virtual bool ModelProto__ParseFromString(ONNX_NAMESPACE::ModelProto* p, const std::string& data) = 0;
virtual std::string ModelProto__SerializeAsString(const ONNX_NAMESPACE::ModelProto* p) = 0;
virtual const Provider_GraphProto& Provider_ModelProto__graph(const Provider_ModelProto* p) = 0;
virtual Provider_GraphProto* Provider_ModelProto__mutable_graph(Provider_ModelProto* p) = 0;
virtual const ONNX_NAMESPACE::GraphProto& ModelProto__graph(const ONNX_NAMESPACE::ModelProto* p) = 0;
virtual ONNX_NAMESPACE::GraphProto* ModelProto__mutable_graph(ONNX_NAMESPACE::ModelProto* p) = 0;
virtual void Provider_ModelProto__set_ir_version(Provider_ModelProto* p, int64_t value) = 0;
virtual void ModelProto__set_ir_version(ONNX_NAMESPACE::ModelProto* p, int64_t value) = 0;
// Provider_TensorProto
virtual void Provider_TensorProto__operator_delete(Provider_TensorProto* p) = 0;
virtual void Provider_TensorProto__operator_assign(Provider_TensorProto* p, const Provider_TensorProto& v) = 0;
virtual bool Provider_TensorProto__has_data_location(const Provider_TensorProto* p) = 0;
virtual int Provider_TensorProto__data_location(const Provider_TensorProto* p) = 0;
// TensorProto
virtual void TensorProto__operator_delete(ONNX_NAMESPACE::TensorProto* p) = 0;
virtual void TensorProto__operator_assign(ONNX_NAMESPACE::TensorProto* p, const ONNX_NAMESPACE::TensorProto& v) = 0;
virtual bool TensorProto__has_data_location(const ONNX_NAMESPACE::TensorProto* p) = 0;
virtual int TensorProto__data_location(const ONNX_NAMESPACE::TensorProto* p) = 0;
// Provider_TensorProtos
virtual Provider_TensorProto* Provider_TensorProtos__Add(Provider_TensorProtos* p) = 0;
// TensorProtos
virtual ONNX_NAMESPACE::TensorProto* TensorProtos__Add(ONNX_NAMESPACE::TensorProtos* p) = 0;
// Provider_TensorShapeProto_Dimension
virtual int Provider_TensorShapeProto_Dimension__value_case(const Provider_TensorShapeProto_Dimension* p) = 0;
virtual const std::string& Provider_TensorShapeProto_Dimension__dim_param(const Provider_TensorShapeProto_Dimension* p) = 0;
virtual int64_t Provider_TensorShapeProto_Dimension__dim_value(const Provider_TensorShapeProto_Dimension* p) = 0;
virtual void Provider_TensorShapeProto_Dimension__set_dim_value(Provider_TensorShapeProto_Dimension* p, int64_t value) = 0;
virtual void Provider_TensorShapeProto_Dimension__clear_dim_value(Provider_TensorShapeProto_Dimension* p) = 0;
// TensorShapeProto_Dimension
virtual int TensorShapeProto_Dimension__value_case(const ONNX_NAMESPACE::TensorShapeProto_Dimension* p) = 0;
virtual const std::string& TensorShapeProto_Dimension__dim_param(const ONNX_NAMESPACE::TensorShapeProto_Dimension* p) = 0;
virtual int64_t TensorShapeProto_Dimension__dim_value(const ONNX_NAMESPACE::TensorShapeProto_Dimension* p) = 0;
virtual void TensorShapeProto_Dimension__set_dim_value(ONNX_NAMESPACE::TensorShapeProto_Dimension* p, int64_t value) = 0;
virtual void TensorShapeProto_Dimension__clear_dim_value(ONNX_NAMESPACE::TensorShapeProto_Dimension* p) = 0;
// Provider_TensorShapeProto_Dimensions
virtual std::unique_ptr<Provider_TensorShapeProto_Dimension_Iterator> Provider_TensorShapeProto_Dimensions__begin(const Provider_TensorShapeProto_Dimensions* p) = 0;
virtual std::unique_ptr<Provider_TensorShapeProto_Dimension_Iterator> Provider_TensorShapeProto_Dimensions__end(const Provider_TensorShapeProto_Dimensions* p) = 0;
// TensorShapeProto_Dimensions
virtual std::unique_ptr<TensorShapeProto_Dimension_Iterator> TensorShapeProto_Dimensions__begin(const ONNX_NAMESPACE::TensorShapeProto_Dimensions* p) = 0;
virtual std::unique_ptr<TensorShapeProto_Dimension_Iterator> TensorShapeProto_Dimensions__end(const ONNX_NAMESPACE::TensorShapeProto_Dimensions* p) = 0;
// Provider_TensorShapeProto
virtual int Provider_TensorShapeProto__dim_size(const Provider_TensorShapeProto* p) = 0;
virtual const Provider_TensorShapeProto_Dimensions& Provider_TensorShapeProto__dim(const Provider_TensorShapeProto* p) = 0;
virtual const Provider_TensorShapeProto_Dimension& Provider_TensorShapeProto__dim(const Provider_TensorShapeProto* p, int index) = 0;
virtual Provider_TensorShapeProto_Dimension* Provider_TensorShapeProto__mutable_dim(Provider_TensorShapeProto* p, int index) = 0;
virtual void Provider_TensorShapeProto__clear_dim(Provider_TensorShapeProto* p) = 0;
virtual Provider_TensorShapeProto_Dimension* Provider_TensorShapeProto__add_dim(Provider_TensorShapeProto* p) = 0;
// TensorShapeProto
virtual int TensorShapeProto__dim_size(const ONNX_NAMESPACE::TensorShapeProto* p) = 0;
virtual const ONNX_NAMESPACE::TensorShapeProto_Dimensions& TensorShapeProto__dim(const ONNX_NAMESPACE::TensorShapeProto* p) = 0;
virtual const ONNX_NAMESPACE::TensorShapeProto_Dimension& TensorShapeProto__dim(const ONNX_NAMESPACE::TensorShapeProto* p, int index) = 0;
virtual ONNX_NAMESPACE::TensorShapeProto_Dimension* TensorShapeProto__mutable_dim(ONNX_NAMESPACE::TensorShapeProto* p, int index) = 0;
virtual void TensorShapeProto__clear_dim(ONNX_NAMESPACE::TensorShapeProto* p) = 0;
virtual ONNX_NAMESPACE::TensorShapeProto_Dimension* TensorShapeProto__add_dim(ONNX_NAMESPACE::TensorShapeProto* p) = 0;
// Provider_ValueInfoProto
virtual void Provider_ValueInfoProto__operator_assign(Provider_ValueInfoProto* p, const Provider_ValueInfoProto& v) = 0;
virtual const Provider_TypeProto& Provider_ValueInfoProto__type(const Provider_ValueInfoProto* p) = 0;
virtual Provider_TypeProto* Provider_ValueInfoProto__mutable_type(Provider_ValueInfoProto* p) = 0;
// ValueInfoProto
virtual void ValueInfoProto__operator_assign(ONNX_NAMESPACE::ValueInfoProto* p, const ONNX_NAMESPACE::ValueInfoProto& v) = 0;
virtual const ONNX_NAMESPACE::TypeProto& ValueInfoProto__type(const ONNX_NAMESPACE::ValueInfoProto* p) = 0;
virtual ONNX_NAMESPACE::TypeProto* ValueInfoProto__mutable_type(ONNX_NAMESPACE::ValueInfoProto* p) = 0;
// Provider_ValueInfoProtos
virtual Provider_ValueInfoProto* Provider_ValueInfoProtos__Add(Provider_ValueInfoProtos* p) = 0;
// ValueInfoProtos
virtual ONNX_NAMESPACE::ValueInfoProto* ValueInfoProtos__Add(ONNX_NAMESPACE::ValueInfoProtos* p) = 0;
virtual const Provider_ValueInfoProto& Provider_ValueInfoProtos__operator_array(const Provider_ValueInfoProtos* p, int index) = 0;
virtual const ONNX_NAMESPACE::ValueInfoProto& ValueInfoProtos__operator_array(const ONNX_NAMESPACE::ValueInfoProtos* p, int index) = 0;
// ComputeCapability
virtual std::unique_ptr<ComputeCapability> ComputeCapability__construct(std::unique_ptr<IndexedSubGraph> t_sub_graph) = 0;
@ -369,7 +368,7 @@ struct ProviderHost {
virtual ConstPointerContainer<std::vector<NodeArg*>> Node__OutputDefs(const Node* p) noexcept = 0;
virtual NodeIndex Node__Index(const Node* p) noexcept = 0;
virtual void Node__ToProto(const Node* p, Provider_NodeProto& proto, bool update_subgraphs = false) = 0;
virtual void Node__ToProto(const Node* p, ONNX_NAMESPACE::NodeProto& proto, bool update_subgraphs = false) = 0;
virtual const NodeAttributes& Node__GetAttributes(const Node* p) noexcept = 0;
virtual size_t Node__GetInputEdgesCount(const Node* p) noexcept = 0;
@ -388,11 +387,11 @@ struct ProviderHost {
// NodeArg
virtual const std::string& NodeArg__Name(const NodeArg* p) noexcept = 0;
virtual const Provider_TensorShapeProto* NodeArg__Shape(const NodeArg* p) = 0;
virtual const ONNX_NAMESPACE::TensorShapeProto* NodeArg__Shape(const NodeArg* p) = 0;
virtual ONNX_NAMESPACE::DataType NodeArg__Type(const NodeArg* p) noexcept = 0;
virtual const Provider_NodeArgInfo& NodeArg__ToProto(const NodeArg* p) noexcept = 0;
virtual const ONNX_NAMESPACE::NodeArgInfo& NodeArg__ToProto(const NodeArg* p) noexcept = 0;
virtual bool NodeArg__Exists(const NodeArg* p) const noexcept = 0;
virtual const Provider_TypeProto* NodeArg__TypeAsProto(const NodeArg* p) noexcept = 0;
virtual const ONNX_NAMESPACE::TypeProto* NodeArg__TypeAsProto(const NodeArg* p) noexcept = 0;
// NodeAttributes
virtual std::unique_ptr<NodeAttributes> NodeAttributes__construct() = 0;
@ -402,8 +401,8 @@ struct ProviderHost {
virtual size_t NodeAttributes__size(const NodeAttributes* p) = 0;
virtual void NodeAttributes__clear(NodeAttributes* p) noexcept = 0;
virtual size_t NodeAttributes__count(const NodeAttributes* p, const std::string& keyval) = 0;
virtual Provider_AttributeProto& NodeAttributes__operator_array(NodeAttributes* p, const std::string& string) = 0;
virtual const Provider_AttributeProto& NodeAttributes__at(const NodeAttributes* p, const std::string& string) = 0;
virtual ONNX_NAMESPACE::AttributeProto& NodeAttributes__operator_array(NodeAttributes* p, const std::string& string) = 0;
virtual const ONNX_NAMESPACE::AttributeProto& NodeAttributes__at(const NodeAttributes* p, const std::string& string) = 0;
virtual std::unique_ptr<NodeAttributes_Iterator> NodeAttributes__begin(const NodeAttributes* p) = 0;
virtual std::unique_ptr<NodeAttributes_Iterator> NodeAttributes__end(const NodeAttributes* p) = 0;
@ -413,23 +412,23 @@ struct ProviderHost {
// Model
virtual void Model__operator_delete(Model* p) = 0;
virtual Graph& Model__MainGraph(Model* p) = 0;
virtual std::unique_ptr<Provider_ModelProto> Model__ToProto(Model* p) = 0;
virtual std::unique_ptr<ONNX_NAMESPACE::ModelProto> Model__ToProto(Model* p) = 0;
// Graph
virtual std::unique_ptr<GraphViewer> Graph__CreateGraphViewer(const Graph* p) = 0;
virtual std::unique_ptr<Provider_GraphProto> Graph__ToGraphProto(const Graph* p) = 0;
virtual std::unique_ptr<ONNX_NAMESPACE::GraphProto> Graph__ToGraphProto(const Graph* p) = 0;
virtual NodeArg& Graph__GetOrCreateNodeArg(Graph* p, const std::string& name, const Provider_TypeProto* p_arg_type) = 0;
virtual NodeArg& Graph__GetOrCreateNodeArg(Graph* p, const std::string& name, const ONNX_NAMESPACE::TypeProto* p_arg_type) = 0;
virtual Status Graph__Resolve(Graph* p) = 0;
virtual void Graph__AddInitializedTensor(Graph* p, const Provider_TensorProto& tensor) = 0;
virtual void Graph__AddInitializedTensor(Graph* p, const ONNX_NAMESPACE::TensorProto& tensor) = 0;
virtual Node& Graph__AddNode(Graph* p, const std::string& name, const std::string& op_type, const std::string& description, const std::vector<NodeArg*>& input_args, const std::vector<NodeArg*>& output_args, const NodeAttributes* attributes, const std::string& domain) = 0;
virtual const std::vector<const NodeArg*>& Graph__GetOutputs(const Graph* p) noexcept = 0;
virtual void Graph__SetOutputs(Graph* p, const std::vector<const NodeArg*>& outputs) = 0;
virtual const std::vector<const NodeArg*>& Graph__GetInputs(const Graph* p) noexcept = 0;
virtual bool Graph__GetInitializedTensor(const Graph* p, const std::string& tensor_name, const Provider_TensorProto*& value) = 0;
virtual bool Graph__GetInitializedTensor(const Graph* p, const std::string& tensor_name, const ONNX_NAMESPACE::TensorProto*& value) = 0;
// GraphViewer
virtual void GraphViewer__operator_delete(GraphViewer* p) = 0;
@ -451,7 +450,7 @@ struct ProviderHost {
virtual const std::vector<const NodeArg*>& GraphViewer__GetValueInfo(const GraphViewer* p) noexcept = 0;
virtual const Provider_InitializedTensorSet& GraphViewer__GetAllInitializedTensors(const GraphViewer* p) = 0;
virtual bool GraphViewer__GetInitializedTensor(const GraphViewer* p, const std::string& tensor_name, const Provider_TensorProto*& value) = 0;
virtual bool GraphViewer__GetInitializedTensor(const GraphViewer* p, const std::string& tensor_name, const ONNX_NAMESPACE::TensorProto*& value) = 0;
virtual const std::unordered_map<std::string, int>& GraphViewer__DomainToVersionMap(const GraphViewer* p) = 0;
virtual const std::vector<NodeIndex>& GraphViewer__GetNodesInTopologicalOrder(const GraphViewer* p) = 0;
@ -532,167 +531,174 @@ struct Capture {
namespace Utils {
struct DataTypeUtils {
static const std::string* ToType(const Provider_TypeProto& type_proto) { return g_host->Utils__DataTypeUtils__ToType(type_proto); }
static const std::string* ToType(const ONNX_NAMESPACE::TypeProto& type_proto) { return g_host->Utils__DataTypeUtils__ToType(type_proto); }
PROVIDER_DISALLOW_ALL(DataTypeUtils)
};
} // namespace Utils
}
struct Provider_int64s {
int size() const { return g_host->Provider_int64s__size(this); }
const int64_t& Get(int index) const { return g_host->Provider_int64s__Get(this, index); }
namespace ONNX_NAMESPACE {
PROVIDER_DISALLOW_ALL(Provider_int64s)
struct int64s {
int size() const { return g_host->int64s__size(this); }
const int64_t& Get(int index) const { return g_host->int64s__Get(this, index); }
PROVIDER_DISALLOW_ALL(int64s)
};
struct Provider_TypeProto_Tensor {
const Provider_TensorShapeProto& shape() const { return g_host->Provider_TypeProto_Tensor__shape(this); }
Provider_TensorShapeProto* mutable_shape() { return g_host->Provider_TypeProto_Tensor__mutable_shape(this); }
int32_t elem_type() const { return g_host->Provider_TypeProto_Tensor__elem_type(this); }
struct AttributeProto {
static std::unique_ptr<AttributeProto> Create() { return g_host->AttributeProto__construct(); }
void operator=(const AttributeProto& v) { g_host->AttributeProto__operator_assign(this, v); }
static void operator delete(void* p) { g_host->AttributeProto__operator_delete(reinterpret_cast<AttributeProto*>(p)); }
PROVIDER_DISALLOW_ALL(Provider_TypeProto_Tensor)
AttributeProto_AttributeType type() const { return g_host->AttributeProto__type(this); }
int ints_size() const { return g_host->AttributeProto__ints_size(this); }
int floats_size() const { return g_host->AttributeProto__floats_size(this); }
int64_t ints(int i) const { return g_host->AttributeProto__ints(this, i); }
float floats(int i) const { return g_host->AttributeProto__floats(this, i); }
const int64s& ints() const { return g_host->AttributeProto__ints(this); }
int64_t i() const { return g_host->AttributeProto__i(this); }
float f() const { return g_host->AttributeProto__f(this); }
void set_s(const ::std::string& value) { return g_host->AttributeProto__set_s(this, value); }
const ::std::string& s() const { return g_host->AttributeProto__s(this); }
void set_name(const ::std::string& value) { return g_host->AttributeProto__set_name(this, value); }
void set_type(AttributeProto_AttributeType value) { return g_host->AttributeProto__set_type(this, value); }
TensorProto* add_tensors() { return g_host->AttributeProto__add_tensors(this); }
AttributeProto() = delete;
AttributeProto(const AttributeProto&) = delete;
};
struct Provider_TypeProto {
const Provider_TypeProto_Tensor& tensor_type() const { return g_host->Provider_TypeProto__tensor_type(this); }
Provider_TypeProto_Tensor* mutable_tensor_type() { return g_host->Provider_TypeProto__mutable_tensor_type(this); }
struct GraphProto {
static void operator delete(void* p) { g_host->GraphProto__operator_delete(reinterpret_cast<GraphProto*>(p)); }
void operator=(const GraphProto& v) { return g_host->GraphProto__operator_assign(this, v); }
PROVIDER_DISALLOW_ALL(Provider_TypeProto)
const ValueInfoProto& input(int index) const { return g_host->GraphProto__input(this, index); }
ValueInfoProtos* mutable_input() { return g_host->GraphProto__mutable_input(this); }
ValueInfoProto* mutable_input(int index) { return g_host->GraphProto__mutable_input(this, index); }
int input_size() const { return g_host->GraphProto__input_size(this); }
const ValueInfoProtos& output() const { return g_host->GraphProto__output(this); }
const ValueInfoProto& output(int index) const { return g_host->GraphProto__output(this, index); }
ValueInfoProtos* mutable_output() { return g_host->GraphProto__mutable_output(this); }
ValueInfoProtos* mutable_value_info() { return g_host->GraphProto__mutable_value_info(this); }
TensorProtos* mutable_initializer() { return g_host->GraphProto__mutable_initializer(this); }
NodeProto* add_node() { return g_host->GraphProto__add_node(this); }
GraphProto() = delete;
GraphProto(const GraphProto&) = delete;
};
struct Provider_AttributeProto {
static std::unique_ptr<Provider_AttributeProto> Create() { return g_host->Provider_AttributeProto__construct(); }
void operator=(const Provider_AttributeProto& v) { g_host->Provider_AttributeProto__operator_assign(this, v); }
static void operator delete(void* p) { g_host->Provider_AttributeProto__operator_delete(reinterpret_cast<Provider_AttributeProto*>(p)); }
struct ModelProto {
static std::unique_ptr<ModelProto> Create() { return g_host->ModelProto__construct(); }
static void operator delete(void* p) { g_host->ModelProto__operator_delete(reinterpret_cast<ModelProto*>(p)); }
ONNX_NAMESPACE::AttributeProto_AttributeType type() const { return g_host->Provider_AttributeProto__type(this); }
int ints_size() const { return g_host->Provider_AttributeProto__ints_size(this); }
int floats_size() const { return g_host->Provider_AttributeProto__floats_size(this); }
int64_t ints(int i) const { return g_host->Provider_AttributeProto__ints(this, i); }
float floats(int i) const { return g_host->Provider_AttributeProto__floats(this, i); }
const Provider_int64s& ints() const { return g_host->Provider_AttributeProto__ints(this); }
int64_t i() const { return g_host->Provider_AttributeProto__i(this); }
float f() const { return g_host->Provider_AttributeProto__f(this); }
void set_s(const ::std::string& value) { return g_host->Provider_AttributeProto__set_s(this, value); }
const ::std::string& s() const { return g_host->Provider_AttributeProto__s(this); }
void set_name(const ::std::string& value) { return g_host->Provider_AttributeProto__set_name(this, value); }
void set_type(ONNX_NAMESPACE::AttributeProto_AttributeType value) { return g_host->Provider_AttributeProto__set_type(this, value); }
Provider_TensorProto* add_tensors() { return g_host->Provider_AttributeProto__add_tensors(this); }
bool SerializeToString(std::string& string) const { return g_host->ModelProto__SerializeToString(this, string); }
bool SerializeToOstream(std::ostream& output) const { return g_host->ModelProto__SerializeToOstream(this, output); }
bool ParseFromString(const std::string& data) { return g_host->ModelProto__ParseFromString(this, data); }
std::string SerializeAsString() const { return g_host->ModelProto__SerializeAsString(this); }
Provider_AttributeProto() = delete;
Provider_AttributeProto(const Provider_AttributeProto&) = delete;
const GraphProto& graph() const { return g_host->ModelProto__graph(this); }
GraphProto* mutable_graph() { return g_host->ModelProto__mutable_graph(this); }
void set_ir_version(int64_t value) { return g_host->ModelProto__set_ir_version(this, value); }
ModelProto() = delete;
ModelProto(const ModelProto&) = delete;
void operator=(const ModelProto&) = delete;
};
struct Provider_GraphProto {
static void operator delete(void* p) { g_host->Provider_GraphProto__operator_delete(reinterpret_cast<Provider_GraphProto*>(p)); }
void operator=(const Provider_GraphProto& v) { return g_host->Provider_GraphProto__operator_assign(this, v); }
struct TensorProto {
static void operator delete(void* p) { g_host->TensorProto__operator_delete(reinterpret_cast<TensorProto*>(p)); }
void operator=(const TensorProto& v) { g_host->TensorProto__operator_assign(this, v); }
const Provider_ValueInfoProto& input(int index) const { return g_host->Provider_GraphProto__input(this, index); }
Provider_ValueInfoProtos* mutable_input() { return g_host->Provider_GraphProto__mutable_input(this); }
Provider_ValueInfoProto* mutable_input(int index) { return g_host->Provider_GraphProto__mutable_input(this, index); }
int input_size() const { return g_host->Provider_GraphProto__input_size(this); }
bool has_data_location() const { return g_host->TensorProto__has_data_location(this); }
TensorProto_DataLocation data_location() const { return TensorProto_DataLocation(g_host->TensorProto__data_location(this)); }
const Provider_ValueInfoProtos& output() const { return g_host->Provider_GraphProto__output(this); }
const Provider_ValueInfoProto& output(int index) const { return g_host->Provider_GraphProto__output(this, index); }
Provider_ValueInfoProtos* mutable_output() { return g_host->Provider_GraphProto__mutable_output(this); }
Provider_ValueInfoProtos* mutable_value_info() { return g_host->Provider_GraphProto__mutable_value_info(this); }
Provider_TensorProtos* mutable_initializer() { return g_host->Provider_GraphProto__mutable_initializer(this); }
Provider_NodeProto* add_node() { return g_host->Provider_GraphProto__add_node(this); }
Provider_GraphProto() = delete;
Provider_GraphProto(const Provider_GraphProto&) = delete;
TensorProto() = delete;
TensorProto(const TensorProto&) = delete;
};
struct Provider_ModelProto {
static std::unique_ptr<Provider_ModelProto> Create() { return g_host->Provider_ModelProto__construct(); }
static void operator delete(void* p) { g_host->Provider_ModelProto__operator_delete(reinterpret_cast<Provider_ModelProto*>(p)); }
struct TensorProtos {
TensorProto* Add() { return g_host->TensorProtos__Add(this); }
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); }
bool ParseFromString(const std::string& data) { return g_host->Provider_ModelProto__ParseFromString(this, data); }
std::string SerializeAsString() const { return g_host->Provider_ModelProto__SerializeAsString(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); }
Provider_ModelProto() = delete;
Provider_ModelProto(const Provider_ModelProto&) = delete;
void operator=(const Provider_ModelProto&) = delete;
PROVIDER_DISALLOW_ALL(TensorProtos)
};
struct Provider_TensorProto {
static void operator delete(void* p) { g_host->Provider_TensorProto__operator_delete(reinterpret_cast<Provider_TensorProto*>(p)); }
void operator=(const Provider_TensorProto& v) { g_host->Provider_TensorProto__operator_assign(this, v); }
bool has_data_location() const { return g_host->Provider_TensorProto__has_data_location(this); }
ONNX_NAMESPACE::TensorProto_DataLocation data_location() const { return ONNX_NAMESPACE::TensorProto_DataLocation(g_host->Provider_TensorProto__data_location(this)); }
Provider_TensorProto() = delete;
Provider_TensorProto(const Provider_TensorProto&) = delete;
};
struct Provider_TensorProtos {
Provider_TensorProto* Add() { return g_host->Provider_TensorProtos__Add(this); }
PROVIDER_DISALLOW_ALL(Provider_TensorProtos)
};
struct Provider_TensorShapeProto_Dimension {
struct TensorShapeProto_Dimension {
enum ValueCase {
kDimValue = 1,
kDimParam = 2,
VALUE_NOT_SET = 0,
};
ValueCase value_case() const { return ValueCase(g_host->Provider_TensorShapeProto_Dimension__value_case(this)); }
const std::string& dim_param() const { return g_host->Provider_TensorShapeProto_Dimension__dim_param(this); }
int64_t dim_value() const { return g_host->Provider_TensorShapeProto_Dimension__dim_value(this); }
void set_dim_value(int64_t value) { return g_host->Provider_TensorShapeProto_Dimension__set_dim_value(this, value); }
void clear_dim_value() { return g_host->Provider_TensorShapeProto_Dimension__clear_dim_value(this); }
ValueCase value_case() const { return ValueCase(g_host->TensorShapeProto_Dimension__value_case(this)); }
const std::string& dim_param() const { return g_host->TensorShapeProto_Dimension__dim_param(this); }
int64_t dim_value() const { return g_host->TensorShapeProto_Dimension__dim_value(this); }
void set_dim_value(int64_t value) { return g_host->TensorShapeProto_Dimension__set_dim_value(this, value); }
void clear_dim_value() { return g_host->TensorShapeProto_Dimension__clear_dim_value(this); }
PROVIDER_DISALLOW_ALL(Provider_TensorShapeProto_Dimension)
PROVIDER_DISALLOW_ALL(TensorShapeProto_Dimension)
};
struct Provider_TensorShapeProto_Dimensions {
IteratorHolder<Provider_TensorShapeProto_Dimension_Iterator, const Provider_TensorShapeProto_Dimension> begin() const { return g_host->Provider_TensorShapeProto_Dimensions__begin(this); }
IteratorHolder<Provider_TensorShapeProto_Dimension_Iterator, const Provider_TensorShapeProto_Dimension> end() const { return g_host->Provider_TensorShapeProto_Dimensions__end(this); }
struct TensorShapeProto_Dimensions {
IteratorHolder<TensorShapeProto_Dimension_Iterator, const TensorShapeProto_Dimension> begin() const { return g_host->TensorShapeProto_Dimensions__begin(this); }
IteratorHolder<TensorShapeProto_Dimension_Iterator, const TensorShapeProto_Dimension> end() const { return g_host->TensorShapeProto_Dimensions__end(this); }
PROVIDER_DISALLOW_ALL(Provider_TensorShapeProto_Dimensions)
PROVIDER_DISALLOW_ALL(TensorShapeProto_Dimensions)
};
struct Provider_TensorShapeProto {
int dim_size() const { return g_host->Provider_TensorShapeProto__dim_size(this); }
const Provider_TensorShapeProto_Dimensions& dim() const { return g_host->Provider_TensorShapeProto__dim(this); }
const Provider_TensorShapeProto_Dimension& dim(int index) const { return g_host->Provider_TensorShapeProto__dim(this, index); }
Provider_TensorShapeProto_Dimension* mutable_dim(int index) { return g_host->Provider_TensorShapeProto__mutable_dim(this, index); }
void clear_dim() { return g_host->Provider_TensorShapeProto__clear_dim(this); }
Provider_TensorShapeProto_Dimension* add_dim() { return g_host->Provider_TensorShapeProto__add_dim(this); }
struct TensorShapeProto {
int dim_size() const { return g_host->TensorShapeProto__dim_size(this); }
const TensorShapeProto_Dimensions& dim() const { return g_host->TensorShapeProto__dim(this); }
const TensorShapeProto_Dimension& dim(int index) const { return g_host->TensorShapeProto__dim(this, index); }
TensorShapeProto_Dimension* mutable_dim(int index) { return g_host->TensorShapeProto__mutable_dim(this, index); }
void clear_dim() { return g_host->TensorShapeProto__clear_dim(this); }
TensorShapeProto_Dimension* add_dim() { return g_host->TensorShapeProto__add_dim(this); }
PROVIDER_DISALLOW_ALL(Provider_TensorShapeProto)
PROVIDER_DISALLOW_ALL(TensorShapeProto)
};
struct Provider_ValueInfoProto {
const Provider_TypeProto& type() const { return g_host->Provider_ValueInfoProto__type(this); }
Provider_TypeProto* mutable_type() { return g_host->Provider_ValueInfoProto__mutable_type(this); }
struct TypeProto_Tensor {
const TensorShapeProto& shape() const { return g_host->TypeProto_Tensor__shape(this); }
TensorShapeProto* mutable_shape() { return g_host->TypeProto_Tensor__mutable_shape(this); }
int32_t elem_type() const { return g_host->TypeProto_Tensor__elem_type(this); }
void operator=(const Provider_ValueInfoProto& v) { g_host->Provider_ValueInfoProto__operator_assign(this, v); }
PROVIDER_DISALLOW_ALL(TypeProto_Tensor)
};
Provider_ValueInfoProto() = delete;
Provider_ValueInfoProto(const Provider_ValueInfoProto&) = delete;
struct TypeProto {
const TypeProto_Tensor& tensor_type() const { return g_host->TypeProto__tensor_type(this); }
TypeProto_Tensor* mutable_tensor_type() { return g_host->TypeProto__mutable_tensor_type(this); }
PROVIDER_DISALLOW_ALL(TypeProto)
};
struct ValueInfoProto {
const TypeProto& type() const { return g_host->ValueInfoProto__type(this); }
TypeProto* mutable_type() { return g_host->ValueInfoProto__mutable_type(this); }
void operator=(const ValueInfoProto& v) { g_host->ValueInfoProto__operator_assign(this, v); }
ValueInfoProto() = delete;
ValueInfoProto(const ValueInfoProto&) = delete;
static void operator delete(void*) = delete;
};
struct Provider_ValueInfoProtos {
Provider_ValueInfoProto* Add() { return g_host->Provider_ValueInfoProtos__Add(this); }
const Provider_ValueInfoProto& operator[](int index) const { return g_host->Provider_ValueInfoProtos__operator_array(this, index); }
struct ValueInfoProtos {
ValueInfoProto* Add() { return g_host->ValueInfoProtos__Add(this); }
const ValueInfoProto& operator[](int index) const { return g_host->ValueInfoProtos__operator_array(this, index); }
PROVIDER_DISALLOW_ALL(Provider_ValueInfoProtos)
PROVIDER_DISALLOW_ALL(ValueInfoProtos)
};
} // namespace ONNX_NAMESPACE
namespace onnxruntime {
struct ComputeCapability {
static std::unique_ptr<ComputeCapability> Create(std::unique_ptr<IndexedSubGraph> t_sub_graph) { return g_host->ComputeCapability__construct(std::move(t_sub_graph)); }
static void operator delete(void* p) { g_host->ComputeCapability__operator_delete(reinterpret_cast<ComputeCapability*>(p)); }
@ -876,7 +882,7 @@ struct Node {
ConstPointerContainer<std::vector<NodeArg*>> OutputDefs() const noexcept { return g_host->Node__OutputDefs(this); }
NodeIndex Index() const noexcept { return g_host->Node__Index(this); }
void ToProto(Provider_NodeProto& proto, bool update_subgraphs = false) const { return g_host->Node__ToProto(this, proto, update_subgraphs); }
void ToProto(ONNX_NAMESPACE::NodeProto& proto, bool update_subgraphs = false) const { return g_host->Node__ToProto(this, proto, update_subgraphs); }
const NodeAttributes& GetAttributes() const noexcept { return g_host->Node__GetAttributes(this); }
size_t GetInputEdgesCount() const noexcept { return g_host->Node__GetInputEdgesCount(this); }
@ -924,11 +930,11 @@ struct Node {
struct NodeArg {
const std::string& Name() const noexcept { return g_host->NodeArg__Name(this); }
const Provider_TensorShapeProto* Shape() const { return g_host->NodeArg__Shape(this); }
const ONNX_NAMESPACE::TensorShapeProto* Shape() const { return g_host->NodeArg__Shape(this); }
ONNX_NAMESPACE::DataType Type() const noexcept { return g_host->NodeArg__Type(this); }
const Provider_NodeArgInfo& ToProto() const noexcept { return g_host->NodeArg__ToProto(this); }
const NodeArgInfo& ToProto() const noexcept { return g_host->NodeArg__ToProto(this); }
bool Exists() const noexcept { return g_host->NodeArg__Exists(this); }
const Provider_TypeProto* TypeAsProto() const noexcept { return g_host->NodeArg__TypeAsProto(this); }
const ONNX_NAMESPACE::TypeProto* TypeAsProto() const noexcept { return g_host->NodeArg__TypeAsProto(this); }
PROVIDER_DISALLOW_ALL(NodeArg)
};
@ -941,12 +947,12 @@ struct NodeAttributes {
size_t size() const { return g_host->NodeAttributes__size(this); }
void clear() noexcept { g_host->NodeAttributes__clear(this); }
size_t count(const std::string& keyval) const { return g_host->NodeAttributes__count(this, keyval); }
Provider_AttributeProto& operator[](const std::string& string) { return g_host->NodeAttributes__operator_array(this, string); }
const Provider_AttributeProto& at(const std::string& string) const { return g_host->NodeAttributes__at(this, string); }
ONNX_NAMESPACE::AttributeProto& operator[](const std::string& string) { return g_host->NodeAttributes__operator_array(this, string); }
const ONNX_NAMESPACE::AttributeProto& at(const std::string& string) const { return g_host->NodeAttributes__at(this, string); }
IteratorHolder<NodeAttributes_Iterator, std::pair<std::string&, Provider_AttributeProto&>> begin() const { return g_host->NodeAttributes__begin(this); }
IteratorHolder<NodeAttributes_Iterator, std::pair<std::string&, Provider_AttributeProto&>> end() const { return g_host->NodeAttributes__end(this); }
IteratorHolder<NodeAttributes_Iterator, std::pair<std::string&, Provider_AttributeProto&>> find(const std::string& key) const { return g_host->NodeAttributes__find(this, key); }
IteratorHolder<NodeAttributes_Iterator, std::pair<std::string&, ONNX_NAMESPACE::AttributeProto&>> begin() const { return g_host->NodeAttributes__begin(this); }
IteratorHolder<NodeAttributes_Iterator, std::pair<std::string&, ONNX_NAMESPACE::AttributeProto&>> end() const { return g_host->NodeAttributes__end(this); }
IteratorHolder<NodeAttributes_Iterator, std::pair<std::string&, ONNX_NAMESPACE::AttributeProto&>> find(const std::string& key) const { return g_host->NodeAttributes__find(this, key); }
void insert(const NodeAttributes& v) { return g_host->NodeAttributes__insert(this, v); }
NodeAttributes() = delete;
@ -958,7 +964,7 @@ struct Model {
Graph& MainGraph() { return g_host->Model__MainGraph(this); }
std::unique_ptr<Provider_ModelProto> ToProto() { return g_host->Model__ToProto(this); }
std::unique_ptr<ONNX_NAMESPACE::ModelProto> ToProto() { return g_host->Model__ToProto(this); }
Model() = delete;
Model(const Model&) = delete;
@ -967,12 +973,12 @@ struct Model {
struct Graph {
std::unique_ptr<GraphViewer> CreateGraphViewer() const { return g_host->Graph__CreateGraphViewer(this); }
std::unique_ptr<Provider_GraphProto> ToGraphProto() const { return g_host->Graph__ToGraphProto(this); }
std::unique_ptr<ONNX_NAMESPACE::GraphProto> ToGraphProto() const { return g_host->Graph__ToGraphProto(this); }
NodeArg& GetOrCreateNodeArg(const std::string& name, const ONNX_NAMESPACE::Provider_TypeProto* p_arg_type) { return g_host->Graph__GetOrCreateNodeArg(this, name, p_arg_type); }
NodeArg& GetOrCreateNodeArg(const std::string& name, const ONNX_NAMESPACE::TypeProto* p_arg_type) { return g_host->Graph__GetOrCreateNodeArg(this, name, p_arg_type); }
Status Resolve() { return g_host->Graph__Resolve(this); }
void AddInitializedTensor(const ONNX_NAMESPACE::Provider_TensorProto& tensor) { return g_host->Graph__AddInitializedTensor(this, tensor); }
void AddInitializedTensor(const ONNX_NAMESPACE::TensorProto& tensor) { return g_host->Graph__AddInitializedTensor(this, tensor); }
Node& AddNode(const std::string& name, const std::string& op_type, const std::string& description, const std::vector<NodeArg*>& input_args, const std::vector<NodeArg*>& output_args, const NodeAttributes* attributes, const std::string& domain) { return g_host->Graph__AddNode(this, name, op_type, description, input_args, output_args, attributes, domain); }
const std::vector<const NodeArg*>& GetOutputs() const noexcept { return g_host->Graph__GetOutputs(this); }
@ -980,7 +986,7 @@ struct Graph {
const std::vector<const NodeArg*>& GetInputs() const noexcept { return g_host->Graph__GetInputs(this); }
bool GetInitializedTensor(const std::string& tensor_name, const Provider_TensorProto*& value) const { return g_host->Graph__GetInitializedTensor(this, tensor_name, value); }
bool GetInitializedTensor(const std::string& tensor_name, const ONNX_NAMESPACE::TensorProto*& value) const { return g_host->Graph__GetInitializedTensor(this, tensor_name, value); }
PROVIDER_DISALLOW_ALL(Graph)
};
@ -1007,7 +1013,7 @@ struct GraphViewer {
const std::vector<const NodeArg*>& GetValueInfo() const noexcept { return g_host->GraphViewer__GetValueInfo(this); }
const Provider_InitializedTensorSet& GetAllInitializedTensors() const noexcept { return g_host->GraphViewer__GetAllInitializedTensors(this); }
bool GetInitializedTensor(const std::string& tensor_name, const Provider_TensorProto*& value) const { return g_host->GraphViewer__GetInitializedTensor(this, tensor_name, value); }
bool GetInitializedTensor(const std::string& tensor_name, const ONNX_NAMESPACE::TensorProto*& value) const { return g_host->GraphViewer__GetInitializedTensor(this, tensor_name, value); }
const std::unordered_map<std::string, int>& DomainToVersionMap() const noexcept { return g_host->GraphViewer__DomainToVersionMap(this); }
@ -1099,8 +1105,8 @@ inline const float* Tensor::Data<float>() const { return Data_float(); }
namespace utils {
inline bool HasDimValue(const Provider_TensorShapeProto_Dimension& dim) {
return dim.value_case() == Provider_TensorShapeProto_Dimension::kDimValue;
inline bool HasDimValue(const ONNX_NAMESPACE::TensorShapeProto_Dimension& dim) {
return dim.value_case() == ONNX_NAMESPACE::TensorShapeProto_Dimension::kDimValue;
}
} // namespace utils

12
onnxruntime/core/providers/tensorrt/tensorrt_execution_provider.cc
View file

@ -551,7 +551,7 @@ Status TensorrtExecutionProvider::SetComputeStream(void* stream) {
}
// Convert GraphViewer graph to GraphProto
void ToGraphProtoInternal(const GraphViewer& graph, Provider_GraphProto& graph_proto) {
void ToGraphProtoInternal(const GraphViewer& graph, ONNX_NAMESPACE::GraphProto& graph_proto) {
for (const auto* input_arg : graph.GetInputs()) {
*(graph_proto.mutable_input()->Add()) = input_arg->ToProto();
}
@ -572,7 +572,7 @@ void ToGraphProtoInternal(const GraphViewer& graph, Provider_GraphProto& graph_p
// Nodes must be sorted in Topological Order in the GraphProto per ONNX spec.
for (auto& node_idx : graph.GetNodesInTopologicalOrder()) {
const gsl::not_null<Provider_NodeProto*> node_proto{graph_proto.add_node()};
const gsl::not_null<ONNX_NAMESPACE::NodeProto*> node_proto{graph_proto.add_node()};
const gsl::not_null<const Node*> p_node{graph.GetNode(node_idx)};
p_node->ToProto(*node_proto);
}
@ -744,9 +744,9 @@ SubGraphCollection_t TensorrtExecutionProvider::GetSupportedList(SubGraphCollect
for (auto input : node->InputDefs()) {
auto& n_input = graph_build.GetOrCreateNodeArg(input->Name(), input->TypeAsProto());
inputs.push_back(&n_input);
const Provider_TensorProto* initializer = nullptr;
const ONNX_NAMESPACE::TensorProto* initializer = nullptr;
if (graph.GetInitializedTensor(input->Name(), initializer)) {
const Provider_TensorProto* subgraph_initializer = nullptr;
const ONNX_NAMESPACE::TensorProto* subgraph_initializer = nullptr;
if (!graph_build.GetInitializedTensor(input->Name(), subgraph_initializer)) {
graph_build.AddInitializedTensor(*(initializer));
}
@ -754,9 +754,9 @@ SubGraphCollection_t TensorrtExecutionProvider::GetSupportedList(SubGraphCollect
}
for (auto input : node->ImplicitInputDefs()) {
const Provider_TensorProto* initializer = nullptr;
const ONNX_NAMESPACE::TensorProto* initializer = nullptr;
if (graph.GetInitializedTensor(input->Name(), initializer)) {
const Provider_TensorProto* subgraph_initializer = nullptr;
const ONNX_NAMESPACE::TensorProto* subgraph_initializer = nullptr;
if (!graph_build.GetInitializedTensor(input->Name(), subgraph_initializer)) {
graph_build.AddInitializedTensor(*(initializer));
}