IntenseWebs/openvino
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

FrontEnd API - change 'shared_ptr' to 'const shared_ptr&' (#9287)

Browse Source 
* FrontEnd API - change 'shared_ptr' to 'const shared_ptr&' in public arguments

* Fix clang-format
This commit is contained in:
Mikhail Nosov 2021-12-17 22:39:13 +03:00 committed by GitHub
parent 36a6774067
commit c7a3c93d3f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
29 changed files with 150 additions and 150 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/bindings/python/src/pyopenvino/frontend/frontend.cpp
View File

@ -41,7 +41,7 @@ void regclass_frontend_FrontEnd(py::module m) {
)"); )");
fem.def("convert", fem.def("convert",
static_cast<std::shared_ptr<ov::Model> (FrontEnd::*)(InputModel::Ptr) const>(&FrontEnd::convert), static_cast<std::shared_ptr<ov::Model> (FrontEnd::*)(const InputModel::Ptr&) const>(&FrontEnd::convert),
py::arg("model"), py::arg("model"),
R"( R"(
Completely convert and normalize entire function, throws if it is not possible. Completely convert and normalize entire function, throws if it is not possible.
@ -58,7 +58,7 @@ void regclass_frontend_FrontEnd(py::module m) {
)"); )");
fem.def("convert", fem.def("convert",
static_cast<void (FrontEnd::*)(std::shared_ptr<ov::Model>) const>(&FrontEnd::convert), static_cast<void (FrontEnd::*)(const std::shared_ptr<ov::Model>&) const>(&FrontEnd::convert),
py::arg("function"), py::arg("function"),
R"( R"(
Completely convert the remaining, not converted part of a function. Completely convert the remaining, not converted part of a function.

36
src/bindings/python/tests/mock/mock_py_ov_frontend/mock_py_frontend.hpp
View File

@ -257,13 +257,13 @@ public:
return false; return false;
} }
bool is_equal(Ptr another) const override { bool is_equal(const Ptr& another) const override {
m_stat.m_is_equal++; m_stat.m_is_equal++;
m_stat.m_lastArgPlace = another; m_stat.m_lastArgPlace = another;
return false; return false;
} }
bool is_equal_data(Ptr another) const override { bool is_equal_data(const Ptr& another) const override {
m_stat.m_is_equal_data++; m_stat.m_is_equal_data++;
m_stat.m_lastArgPlace = another; m_stat.m_lastArgPlace = another;
return false; return false;
@ -471,19 +471,19 @@ public:
return std::make_shared<PlaceMockPy>(); return std::make_shared<PlaceMockPy>();
} }
void set_name_for_tensor(Place::Ptr tensor, const std::string& newName) override { void set_name_for_tensor(const Place::Ptr& tensor, const std::string& newName) override {
m_stat.m_set_name_for_tensor++; m_stat.m_set_name_for_tensor++;
m_stat.m_lastArgPlace = tensor; m_stat.m_lastArgPlace = tensor;
m_stat.m_lastArgString = newName; m_stat.m_lastArgString = newName;
} }
void add_name_for_tensor(Place::Ptr tensor, const std::string& newName) override { void add_name_for_tensor(const Place::Ptr& tensor, const std::string& newName) override {
m_stat.m_add_name_for_tensor++; m_stat.m_add_name_for_tensor++;
m_stat.m_lastArgPlace = tensor; m_stat.m_lastArgPlace = tensor;
m_stat.m_lastArgString = newName; m_stat.m_lastArgString = newName;
} }
void set_name_for_operation(Place::Ptr operation, const std::string& newName) override { void set_name_for_operation(const Place::Ptr& operation, const std::string& newName) override {
m_stat.m_set_name_for_operation++; m_stat.m_set_name_for_operation++;
m_stat.m_lastArgPlace = operation; m_stat.m_lastArgPlace = operation;
m_stat.m_lastArgString = newName; m_stat.m_lastArgString = newName;
@ -499,32 +499,32 @@ public:
m_stat.m_lastArgString = name; m_stat.m_lastArgString = name;
} }
void set_name_for_dimension(Place::Ptr place, size_t shapeDimIndex, const std::string& dimName) override { void set_name_for_dimension(const Place::Ptr& place, size_t shapeDimIndex, const std::string& dimName) override {
m_stat.m_set_name_for_dimension++; m_stat.m_set_name_for_dimension++;
m_stat.m_lastArgPlace = place; m_stat.m_lastArgPlace = place;
m_stat.m_lastArgInt = static_cast<int>(shapeDimIndex); m_stat.m_lastArgInt = static_cast<int>(shapeDimIndex);
m_stat.m_lastArgString = dimName; m_stat.m_lastArgString = dimName;
} }
void cut_and_add_new_input(Place::Ptr place, const std::string& newNameOptional) override { void cut_and_add_new_input(const Place::Ptr& place, const std::string& newNameOptional) override {
m_stat.m_cut_and_add_new_input++; m_stat.m_cut_and_add_new_input++;
m_stat.m_lastArgPlace = place; m_stat.m_lastArgPlace = place;
m_stat.m_lastArgString = newNameOptional; m_stat.m_lastArgString = newNameOptional;
} }
void cut_and_add_new_output(Place::Ptr place, const std::string& newNameOptional) override { void cut_and_add_new_output(const Place::Ptr& place, const std::string& newNameOptional) override {
m_stat.m_cut_and_add_new_output++; m_stat.m_cut_and_add_new_output++;
m_stat.m_lastArgPlace = place; m_stat.m_lastArgPlace = place;
m_stat.m_lastArgString = newNameOptional; m_stat.m_lastArgString = newNameOptional;
} }
Place::Ptr add_output(Place::Ptr place) override { Place::Ptr add_output(const Place::Ptr& place) override {
m_stat.m_add_output++; m_stat.m_add_output++;
m_stat.m_lastArgPlace = place; m_stat.m_lastArgPlace = place;
return std::make_shared<PlaceMockPy>(); return std::make_shared<PlaceMockPy>();
} }
void remove_output(Place::Ptr place) override { void remove_output(const Place::Ptr& place) override {
m_stat.m_remove_output++; m_stat.m_remove_output++;
m_stat.m_lastArgPlace = place; m_stat.m_lastArgPlace = place;
} }
@ -546,19 +546,19 @@ public:
} }
// Setting tensor properties // Setting tensor properties
void set_partial_shape(Place::Ptr place, const ngraph::PartialShape& shape) override { void set_partial_shape(const Place::Ptr& place, const ngraph::PartialShape& shape) override {
m_stat.m_set_partial_shape++; m_stat.m_set_partial_shape++;
m_stat.m_lastArgPlace = place; m_stat.m_lastArgPlace = place;
m_stat.m_lastArgPartialShape = shape; m_stat.m_lastArgPartialShape = shape;
} }
ngraph::PartialShape get_partial_shape(Place::Ptr place) const override { ngraph::PartialShape get_partial_shape(const Place::Ptr& place) const override {
m_stat.m_get_partial_shape++; m_stat.m_get_partial_shape++;
m_stat.m_lastArgPlace = place; m_stat.m_lastArgPlace = place;
return {}; return {};
} }
void set_element_type(Place::Ptr place, const ngraph::element::Type& type) override { void set_element_type(const Place::Ptr& place, const ngraph::element::Type& type) override {
m_stat.m_set_element_type++; m_stat.m_set_element_type++;
m_stat.m_lastArgPlace = place; m_stat.m_lastArgPlace = place;
m_stat.m_lastArgElementType = type; m_stat.m_lastArgElementType = type;
@ -631,26 +631,26 @@ public:
return false; return false;
} }
std::shared_ptr<ov::Model> convert(InputModel::Ptr model) const override { std::shared_ptr<ov::Model> convert(const InputModel::Ptr& model) const override {
m_stat.m_convert_model++; m_stat.m_convert_model++;
return std::make_shared<ov::Model>(ov::NodeVector{}, ov::ParameterVector{}); return std::make_shared<ov::Model>(ov::NodeVector{}, ov::ParameterVector{});
} }
void convert(std::shared_ptr<ov::Model> func) const override { void convert(const std::shared_ptr<ov::Model>& func) const override {
m_stat.m_convert++; m_stat.m_convert++;
} }
std::shared_ptr<ov::Model> convert_partially(InputModel::Ptr model) const override { std::shared_ptr<ov::Model> convert_partially(const InputModel::Ptr& model) const override {
m_stat.m_convert_partially++; m_stat.m_convert_partially++;
return std::make_shared<ov::Model>(ov::NodeVector{}, ov::ParameterVector{}); return std::make_shared<ov::Model>(ov::NodeVector{}, ov::ParameterVector{});
} }
std::shared_ptr<ov::Model> decode(InputModel::Ptr model) const override { std::shared_ptr<ov::Model> decode(const InputModel::Ptr& model) const override {
m_stat.m_decode++; m_stat.m_decode++;
return std::make_shared<ov::Model>(ov::NodeVector{}, ov::ParameterVector{}); return std::make_shared<ov::Model>(ov::NodeVector{}, ov::ParameterVector{});
} }
void normalize(std::shared_ptr<ov::Model> function) const override { void normalize(const std::shared_ptr<ov::Model>& function) const override {
m_stat.m_normalize++; m_stat.m_normalize++;
} }

10
src/frontends/common/include/openvino/frontend/frontend.hpp
View File

@ -59,11 +59,11 @@ public:
/// possible /// possible
/// \param model Input model /// \param model Input model
/// \return fully converted OV Model /// \return fully converted OV Model
virtual std::shared_ptr<ov::Model> convert(InputModel::Ptr model) const; virtual std::shared_ptr<ov::Model> convert(const InputModel::Ptr& model) const;
/// \brief Completely convert the remaining, not converted part of a Model. /// \brief Completely convert the remaining, not converted part of a Model.
/// \param partiallyConverted partially converted OV Model /// \param partiallyConverted partially converted OV Model
virtual void convert(std::shared_ptr<ov::Model> partially_converted) const; virtual void convert(const std::shared_ptr<ov::Model>& partially_converted) const;
/// \brief Convert only those parts of the model that can be converted leaving others /// \brief Convert only those parts of the model that can be converted leaving others
/// as-is. Converted parts are not normalized by additional transformations; normalize /// as-is. Converted parts are not normalized by additional transformations; normalize
@ -71,18 +71,18 @@ public:
/// conversion process. /// conversion process.
/// \param model Input model /// \param model Input model
/// \return partially converted OV Model /// \return partially converted OV Model
virtual std::shared_ptr<ov::Model> convert_partially(InputModel::Ptr model) const; virtual std::shared_ptr<ov::Model> convert_partially(const InputModel::Ptr& model) const;
/// \brief Convert operations with one-to-one mapping with decoding nodes. /// \brief Convert operations with one-to-one mapping with decoding nodes.
/// Each decoding node is an OV node representing a single FW operation node with /// Each decoding node is an OV node representing a single FW operation node with
/// all attributes represented in FW-independent way. /// all attributes represented in FW-independent way.
/// \param model Input model /// \param model Input model
/// \return OV Model after decoding /// \return OV Model after decoding
virtual std::shared_ptr<ov::Model> decode(InputModel::Ptr model) const; virtual std::shared_ptr<ov::Model> decode(const InputModel::Ptr& model) const;
/// \brief Runs normalization passes on Model that was loaded with partial conversion /// \brief Runs normalization passes on Model that was loaded with partial conversion
/// \param Model partially converted OV Model /// \param Model partially converted OV Model
virtual void normalize(std::shared_ptr<ov::Model> model) const; virtual void normalize(const std::shared_ptr<ov::Model>& model) const;
/// \brief Gets name of this FrontEnd. Can be used by clients /// \brief Gets name of this FrontEnd. Can be used by clients
/// if frontend is selected automatically by FrontEndManager::load_by_model /// if frontend is selected automatically by FrontEndManager::load_by_model

26
src/frontends/common/include/openvino/frontend/input_model.hpp
View File

@ -95,17 +95,17 @@ public:
/// \brief Sets name for tensor. Overwrites existing names of this place /// \brief Sets name for tensor. Overwrites existing names of this place
/// \param tensor Tensor place /// \param tensor Tensor place
/// \param new_name New name for this tensor /// \param new_name New name for this tensor
virtual void set_name_for_tensor(Place::Ptr tensor, const std::string& new_name); virtual void set_name_for_tensor(const Place::Ptr& tensor, const std::string& new_name);
/// \brief Adds new name for tensor /// \brief Adds new name for tensor
/// \param tensor Tensor place /// \param tensor Tensor place
/// \param new_name New name to be added to this place /// \param new_name New name to be added to this place
virtual void add_name_for_tensor(Place::Ptr tensor, const std::string& new_name); virtual void add_name_for_tensor(const Place::Ptr& tensor, const std::string& new_name);
/// \brief Sets name for operation. Overwrites existing names of this place /// \brief Sets name for operation. Overwrites existing names of this place
/// \param operation Operation place /// \param operation Operation place
/// \param new_name New name for this operation /// \param new_name New name for this operation
virtual void set_name_for_operation(Place::Ptr operation, const std::string& new_name); virtual void set_name_for_operation(const Place::Ptr& operation, const std::string& new_name);
/// \brief Unassign specified name from tensor place(s) /// \brief Unassign specified name from tensor place(s)
/// \param name Name of tensor /// \param name Name of tensor
@ -119,7 +119,7 @@ public:
/// \param place Model's place /// \param place Model's place
/// \param shape_dim_index Dimension index /// \param shape_dim_index Dimension index
/// \param dim_name Name to assign on this dimension /// \param dim_name Name to assign on this dimension
virtual void set_name_for_dimension(Place::Ptr place, size_t shape_dim_index, const std::string& dim_name); virtual void set_name_for_dimension(const Place::Ptr& place, size_t shape_dim_index, const std::string& dim_name);
///// Topology Editing ///// ///// Topology Editing /////
@ -127,25 +127,25 @@ public:
/// all nodes that don't contribute to any output. /// all nodes that don't contribute to any output.
/// \param place New place to be assigned as input /// \param place New place to be assigned as input
/// \param new_name_optional Optional new name assigned to this input place /// \param new_name_optional Optional new name assigned to this input place
virtual void cut_and_add_new_input(Place::Ptr place, const std::string& new_name_optional = ""); virtual void cut_and_add_new_input(const Place::Ptr& place, const std::string& new_name_optional = "");
/// \brief Cut immediately after this place and assign this place as new output; prune /// \brief Cut immediately after this place and assign this place as new output; prune
/// all nodes that don't contribute to any output. /// all nodes that don't contribute to any output.
/// \param place New place to be assigned as output /// \param place New place to be assigned as output
/// \param new_name_optional Optional new name assigned to this output place /// \param new_name_optional Optional new name assigned to this output place
virtual void cut_and_add_new_output(Place::Ptr place, const std::string& new_name_optional = ""); virtual void cut_and_add_new_output(const Place::Ptr& place, const std::string& new_name_optional = "");
/// \brief Assign this place as new output or add necessary nodes to represent a new /// \brief Assign this place as new output or add necessary nodes to represent a new
/// output. /// output.
/// ///
/// \param place Anchor point to add an output /// \param place Anchor point to add an output
/// \return new output place, may be the same as a given place /// \return new output place, may be the same as a given place
virtual Place::Ptr add_output(Place::Ptr place); virtual Place::Ptr add_output(const Place::Ptr& place);
/// \brief Removes any sinks directly attached to this place with all inbound data flow /// \brief Removes any sinks directly attached to this place with all inbound data flow
/// if it is not required by any other output. /// if it is not required by any other output.
/// \param place Model place /// \param place Model place
virtual void remove_output(Place::Ptr place); virtual void remove_output(const Place::Ptr& place);
/// \brief Replaces all existing outputs with new ones removing all data flow that is /// \brief Replaces all existing outputs with new ones removing all data flow that is
/// not required for new outputs. /// not required for new outputs.
@ -173,30 +173,30 @@ public:
/// converted to OV. /// converted to OV.
/// \param place Model place /// \param place Model place
/// \param shape Partial shape for this place /// \param shape Partial shape for this place
virtual void set_partial_shape(Place::Ptr place, const ov::PartialShape& shape); virtual void set_partial_shape(const Place::Ptr& place, const ov::PartialShape& shape);
/// \brief Returns current partial shape used for this place /// \brief Returns current partial shape used for this place
/// \param place Model place /// \param place Model place
/// \return Partial shape for this place /// \return Partial shape for this place
virtual ov::PartialShape get_partial_shape(Place::Ptr place) const; virtual ov::PartialShape get_partial_shape(const Place::Ptr& place) const;
/// \brief Sets new element type for a place /// \brief Sets new element type for a place
/// \param place Model place /// \param place Model place
/// \param type New element type /// \param type New element type
virtual void set_element_type(Place::Ptr place, const ov::element::Type& type); virtual void set_element_type(const Place::Ptr& place, const ov::element::Type& type);
/// \brief Freezes a tensor with statically defined value or replace existing value for /// \brief Freezes a tensor with statically defined value or replace existing value for
/// already constant node or tensor /// already constant node or tensor
/// \param place Tensor place /// \param place Tensor place
/// \param value Value for tensor place representing a memory buffer /// \param value Value for tensor place representing a memory buffer
virtual void set_tensor_value(Place::Ptr place, const void* value); virtual void set_tensor_value(const Place::Ptr& place, const void* value);
/// \brief Defines partial value (lower bound and upper bound) for a tensor place /// \brief Defines partial value (lower bound and upper bound) for a tensor place
/// TODO: more details for min_value and max_value format; who defines shape? /// TODO: more details for min_value and max_value format; who defines shape?
/// \param place Tensor place /// \param place Tensor place
/// \param min_value Lower bound of partial value for tensor place /// \param min_value Lower bound of partial value for tensor place
/// \param max_value Upper bound of partial value for tensor place /// \param max_value Upper bound of partial value for tensor place
virtual void set_tensor_partial_value(Place::Ptr place, const void* min_value, const void* max_value); virtual void set_tensor_partial_value(const Place::Ptr& place, const void* min_value, const void* max_value);
}; };
} // namespace frontend } // namespace frontend

4
src/frontends/common/include/openvino/frontend/place.hpp
View File

@ -292,7 +292,7 @@ public:
/// \brief Returns true if another place is the same as this place. /// \brief Returns true if another place is the same as this place.
/// ///
/// \param another Another place object /// \param another Another place object
virtual bool is_equal(Ptr another) const; virtual bool is_equal(const Ptr& another) const;
/// \brief Returns true if another place points to the same data. /// \brief Returns true if another place points to the same data.
/// ///
@ -300,7 +300,7 @@ public:
/// -> input edge -> input port. /// -> input edge -> input port.
/// ///
/// \param another Another place object /// \param another Another place object
virtual bool is_equal_data(Ptr another) const; virtual bool is_equal_data(const Ptr& another) const;
}; };
} // namespace frontend } // namespace frontend
} // namespace ov } // namespace ov

10
src/frontends/common/src/frontend.cpp
View File

@ -27,23 +27,23 @@ bool FrontEnd::supported_impl(const std::vector<ov::Any>& variants) const {
InputModel::Ptr FrontEnd::load_impl(const std::vector<ov::Any>& params) const { InputModel::Ptr FrontEnd::load_impl(const std::vector<ov::Any>& params) const {
FRONT_END_NOT_IMPLEMENTED(load_impl); FRONT_END_NOT_IMPLEMENTED(load_impl);
} }
std::shared_ptr<Model> FrontEnd::convert(InputModel::Ptr model) const { std::shared_ptr<Model> FrontEnd::convert(const InputModel::Ptr& model) const {
FRONT_END_NOT_IMPLEMENTED(convert); FRONT_END_NOT_IMPLEMENTED(convert);
} }
void FrontEnd::convert(std::shared_ptr<Model>) const { void FrontEnd::convert(const std::shared_ptr<Model>&) const {
FRONT_END_NOT_IMPLEMENTED(convert); FRONT_END_NOT_IMPLEMENTED(convert);
} }
std::shared_ptr<Model> FrontEnd::convert_partially(InputModel::Ptr model) const { std::shared_ptr<Model> FrontEnd::convert_partially(const InputModel::Ptr& model) const {
FRONT_END_NOT_IMPLEMENTED(convert_partially); FRONT_END_NOT_IMPLEMENTED(convert_partially);
} }
std::shared_ptr<Model> FrontEnd::decode(InputModel::Ptr model) const { std::shared_ptr<Model> FrontEnd::decode(const InputModel::Ptr& model) const {
FRONT_END_NOT_IMPLEMENTED(decode); FRONT_END_NOT_IMPLEMENTED(decode);
} }
void FrontEnd::normalize(std::shared_ptr<Model> model) const { void FrontEnd::normalize(const std::shared_ptr<Model>& model) const {
FRONT_END_NOT_IMPLEMENTED(normalize); FRONT_END_NOT_IMPLEMENTED(normalize);
} }

26
src/frontends/common/src/input_model.cpp
View File

@ -40,15 +40,15 @@ Place::Ptr InputModel::get_place_by_operation_name_and_output_port(const std::st
return nullptr; return nullptr;
} }
void InputModel::set_name_for_tensor(Place::Ptr tensor, const std::string& new_name) { void InputModel::set_name_for_tensor(const Place::Ptr& tensor, const std::string& new_name) {
FRONT_END_NOT_IMPLEMENTED(set_name_for_tensor); FRONT_END_NOT_IMPLEMENTED(set_name_for_tensor);
} }
void InputModel::add_name_for_tensor(Place::Ptr tensor, const std::string& new_name) { void InputModel::add_name_for_tensor(const Place::Ptr& tensor, const std::string& new_name) {
FRONT_END_NOT_IMPLEMENTED(add_name_for_tensor); FRONT_END_NOT_IMPLEMENTED(add_name_for_tensor);
} }
void InputModel::set_name_for_operation(Place::Ptr operation, const std::string& new_name) { void InputModel::set_name_for_operation(const Place::Ptr& operation, const std::string& new_name) {
FRONT_END_NOT_IMPLEMENTED(set_name_for_operation); FRONT_END_NOT_IMPLEMENTED(set_name_for_operation);
} }
@ -60,23 +60,23 @@ void InputModel::free_name_for_operation(const std::string& name) {
FRONT_END_NOT_IMPLEMENTED(free_name_for_operation); FRONT_END_NOT_IMPLEMENTED(free_name_for_operation);
} }
void InputModel::set_name_for_dimension(Place::Ptr place, size_t shape_dim_index, const std::string& dim_name) { void InputModel::set_name_for_dimension(const Place::Ptr& place, size_t shape_dim_index, const std::string& dim_name) {
FRONT_END_NOT_IMPLEMENTED(set_name_for_dimension); FRONT_END_NOT_IMPLEMENTED(set_name_for_dimension);
} }
void InputModel::cut_and_add_new_input(Place::Ptr place, const std::string& new_name_optional) { void InputModel::cut_and_add_new_input(const Place::Ptr& place, const std::string& new_name_optional) {
FRONT_END_NOT_IMPLEMENTED(cut_and_add_new_input); FRONT_END_NOT_IMPLEMENTED(cut_and_add_new_input);
} }
void InputModel::cut_and_add_new_output(Place::Ptr place, const std::string& new_name_optional) { void InputModel::cut_and_add_new_output(const Place::Ptr& place, const std::string& new_name_optional) {
FRONT_END_NOT_IMPLEMENTED(cut_and_add_new_output); FRONT_END_NOT_IMPLEMENTED(cut_and_add_new_output);
} }
Place::Ptr InputModel::add_output(Place::Ptr place) { Place::Ptr InputModel::add_output(const Place::Ptr& place) {
FRONT_END_NOT_IMPLEMENTED(add_output); FRONT_END_NOT_IMPLEMENTED(add_output);
} }
void InputModel::remove_output(Place::Ptr place) { void InputModel::remove_output(const Place::Ptr& place) {
FRONT_END_NOT_IMPLEMENTED(remove_output); FRONT_END_NOT_IMPLEMENTED(remove_output);
} }
@ -93,22 +93,22 @@ void InputModel::extract_subgraph(const std::vector<Place::Ptr>& inputs, const s
} }
// Setting tensor properties // Setting tensor properties
void InputModel::set_partial_shape(Place::Ptr place, const PartialShape&) { void InputModel::set_partial_shape(const Place::Ptr& place, const PartialShape&) {
FRONT_END_NOT_IMPLEMENTED(set_partial_shape); FRONT_END_NOT_IMPLEMENTED(set_partial_shape);
} }
PartialShape InputModel::get_partial_shape(Place::Ptr place) const { PartialShape InputModel::get_partial_shape(const Place::Ptr& place) const {
FRONT_END_NOT_IMPLEMENTED(get_partial_shape); FRONT_END_NOT_IMPLEMENTED(get_partial_shape);
} }
void InputModel::set_element_type(Place::Ptr place, const element::Type&) { void InputModel::set_element_type(const Place::Ptr& place, const element::Type&) {
FRONT_END_NOT_IMPLEMENTED(set_element_type); FRONT_END_NOT_IMPLEMENTED(set_element_type);
} }
void InputModel::set_tensor_value(Place::Ptr place, const void* value) { void InputModel::set_tensor_value(const Place::Ptr& place, const void* value) {
FRONT_END_NOT_IMPLEMENTED(set_tensor_value); FRONT_END_NOT_IMPLEMENTED(set_tensor_value);
} }
void InputModel::set_tensor_partial_value(Place::Ptr place, const void* min_value, const void* max_value) { void InputModel::set_tensor_partial_value(const Place::Ptr& place, const void* min_value, const void* max_value) {
FRONT_END_NOT_IMPLEMENTED(set_tensor_partial_value); FRONT_END_NOT_IMPLEMENTED(set_tensor_partial_value);
} }

4
src/frontends/common/src/place.cpp
View File

@ -94,11 +94,11 @@ bool Place::is_output() const {
FRONT_END_NOT_IMPLEMENTED(is_output); FRONT_END_NOT_IMPLEMENTED(is_output);
} }
bool Place::is_equal(Ptr another) const { bool Place::is_equal(const Ptr& another) const {
FRONT_END_NOT_IMPLEMENTED(is_equal); FRONT_END_NOT_IMPLEMENTED(is_equal);
} }
bool Place::is_equal_data(Ptr another) const { bool Place::is_equal_data(const Ptr& another) const {
FRONT_END_NOT_IMPLEMENTED(is_equal_data); FRONT_END_NOT_IMPLEMENTED(is_equal_data);
} }

2
src/frontends/ir/include/openvino/frontend/ir/frontend.hpp
View File

@ -21,7 +21,7 @@ public:
/// \brief Completely convert the remaining, not converted part of a function. /// \brief Completely convert the remaining, not converted part of a function.
/// \param partiallyConverted partially converted nGraph function /// \param partiallyConverted partially converted nGraph function
/// \return fully converted nGraph function /// \return fully converted nGraph function
std::shared_ptr<Model> convert(InputModel::Ptr model) const override; std::shared_ptr<Model> convert(const InputModel::Ptr& model) const override;
/// \brief Gets name of this FrontEnd. Can be used by clients /// \brief Gets name of this FrontEnd. Can be used by clients
/// if frontend is selected automatically by FrontEndManager::load_by_model /// if frontend is selected automatically by FrontEndManager::load_by_model

2
src/frontends/ir/src/frontend.cpp
View File

@ -225,7 +225,7 @@ InputModel::Ptr FrontEnd::load_impl(const std::vector<ov::Any>& variants) const
return create_input_model(); return create_input_model();
} }
std::shared_ptr<ov::Model> FrontEnd::convert(InputModel::Ptr model) const { std::shared_ptr<ov::Model> FrontEnd::convert(const InputModel::Ptr& model) const {
auto ir_model = std::dynamic_pointer_cast<InputModel>(model); auto ir_model = std::dynamic_pointer_cast<InputModel>(model);
OPENVINO_ASSERT(ir_model != nullptr); OPENVINO_ASSERT(ir_model != nullptr);
return ir_model->convert(); return ir_model->convert();

6
src/frontends/onnx/frontend/include/openvino/frontend/onnx/frontend.hpp
View File

@ -26,9 +26,9 @@ namespace onnx {
class ONNX_FRONTEND_API FrontEnd : public ov::frontend::FrontEnd { class ONNX_FRONTEND_API FrontEnd : public ov::frontend::FrontEnd {
public: public:
std::shared_ptr<ov::Model> convert(InputModel::Ptr model) const override; std::shared_ptr<ov::Model> convert(const InputModel::Ptr& model) const override;
void convert(std::shared_ptr<ov::Model> partially_converted) const override; void convert(const std::shared_ptr<ov::Model>& partially_converted) const override;
std::shared_ptr<ov::Model> decode(InputModel::Ptr model) const override; std::shared_ptr<ov::Model> decode(const InputModel::Ptr& model) const override;
std::string get_name() const override; std::string get_name() const override;
bool supported_impl(const std::vector<ov::Any>& variants) const override; bool supported_impl(const std::vector<ov::Any>& variants) const override;
void add_extension(const std::shared_ptr<ov::Extension>& extension) override; void add_extension(const std::shared_ptr<ov::Extension>& extension) override;

6
src/frontends/onnx/frontend/src/frontend.cpp
View File

@ -61,17 +61,17 @@ InputModel::Ptr FrontEnd::load_impl(const std::vector<ov::Any>& variants) const
return nullptr; return nullptr;
} }
std::shared_ptr<ngraph::Function> FrontEnd::convert(InputModel::Ptr model) const { std::shared_ptr<ngraph::Function> FrontEnd::convert(const InputModel::Ptr& model) const {
auto model_onnx = std::dynamic_pointer_cast<InputModel>(model); auto model_onnx = std::dynamic_pointer_cast<InputModel>(model);
NGRAPH_CHECK(model_onnx != nullptr, "Invalid input model"); NGRAPH_CHECK(model_onnx != nullptr, "Invalid input model");
return model_onnx->convert(); return model_onnx->convert();
} }
void FrontEnd::convert(std::shared_ptr<ngraph::Function> partially_converted) const { void FrontEnd::convert(const std::shared_ptr<ov::Model>& partially_converted) const {
ngraph::onnx_import::detail::convert_decoded_function(partially_converted); ngraph::onnx_import::detail::convert_decoded_function(partially_converted);
} }
std::shared_ptr<ngraph::Function> FrontEnd::decode(InputModel::Ptr model) const { std::shared_ptr<ngraph::Function> FrontEnd::decode(const InputModel::Ptr& model) const {
auto model_onnx = std::dynamic_pointer_cast<InputModel>(model); auto model_onnx = std::dynamic_pointer_cast<InputModel>(model);
NGRAPH_CHECK(model_onnx != nullptr, "Invalid input model"); NGRAPH_CHECK(model_onnx != nullptr, "Invalid input model");
return model_onnx->decode(); return model_onnx->decode();

14
src/frontends/onnx/frontend/src/input_model.cpp
View File

@ -90,13 +90,13 @@ ov::frontend::Place::Ptr InputModel::get_place_by_operation_name_and_output_port
return nullptr; return nullptr;
} }
void InputModel::set_name_for_tensor(ov::frontend::Place::Ptr tensor, const std::string& new_name) { void InputModel::set_name_for_tensor(const ov::frontend::Place::Ptr& tensor, const std::string& new_name) {
const auto onnx_tensor = std::dynamic_pointer_cast<PlaceTensor>(tensor); const auto onnx_tensor = std::dynamic_pointer_cast<PlaceTensor>(tensor);
FRONT_END_GENERAL_CHECK(onnx_tensor, __FUNCTION__, " expects a pointer to place of ONNX tensor type."); FRONT_END_GENERAL_CHECK(onnx_tensor, __FUNCTION__, " expects a pointer to place of ONNX tensor type.");
onnx_tensor->set_name(new_name); onnx_tensor->set_name(new_name);
} }
void InputModel::set_name_for_operation(ov::frontend::Place::Ptr operation, const std::string& new_name) { void InputModel::set_name_for_operation(const ov::frontend::Place::Ptr& operation, const std::string& new_name) {
const auto onnx_operation = std::dynamic_pointer_cast<PlaceOp>(operation); const auto onnx_operation = std::dynamic_pointer_cast<PlaceOp>(operation);
FRONT_END_GENERAL_CHECK(onnx_operation, __FUNCTION__, " expects a pointer to place of ONNX operation type."); FRONT_END_GENERAL_CHECK(onnx_operation, __FUNCTION__, " expects a pointer to place of ONNX operation type.");
onnx_operation->set_name(new_name); onnx_operation->set_name(new_name);
@ -106,7 +106,7 @@ void InputModel::free_name_for_operation(const std::string& name) {
m_editor->clear_nodes_name(name); m_editor->clear_nodes_name(name);
} }
void InputModel::set_name_for_dimension(ov::frontend::Place::Ptr tensor, void InputModel::set_name_for_dimension(const ov::frontend::Place::Ptr& tensor,
size_t shape_dim_index, size_t shape_dim_index,
const std::string& dim_name) { const std::string& dim_name) {
const auto onnx_tensor = std::dynamic_pointer_cast<PlaceTensor>(tensor); const auto onnx_tensor = std::dynamic_pointer_cast<PlaceTensor>(tensor);
@ -114,7 +114,7 @@ void InputModel::set_name_for_dimension(ov::frontend::Place::Ptr tensor,
onnx_tensor->set_name_for_dimension(shape_dim_index, dim_name); onnx_tensor->set_name_for_dimension(shape_dim_index, dim_name);
} }
void InputModel::add_name_for_tensor(ov::frontend::Place::Ptr, const std::string&) { void InputModel::add_name_for_tensor(const ov::frontend::Place::Ptr&, const std::string&) {
FRONT_END_THROW("Method add_name_for_tensor is not applicable for ONNX model. ONNX tensor has just one name."); FRONT_END_THROW("Method add_name_for_tensor is not applicable for ONNX model. ONNX tensor has just one name.");
} }
@ -122,17 +122,17 @@ void InputModel::free_name_for_tensor(const std::string&) {
FRONT_END_THROW("Method free_name_for_tensor is not applicable for ONNX model. ONNX tensor name is an identifier."); FRONT_END_THROW("Method free_name_for_tensor is not applicable for ONNX model. ONNX tensor name is an identifier.");
} }
void InputModel::set_partial_shape(ov::frontend::Place::Ptr place, const ngraph::PartialShape& shape) { void InputModel::set_partial_shape(const ov::frontend::Place::Ptr& place, const ngraph::PartialShape& shape) {
std::map<std::string, ngraph::PartialShape> m; std::map<std::string, ngraph::PartialShape> m;
m[place->get_names()[0]] = shape; m[place->get_names()[0]] = shape;
m_editor->set_input_shapes(m); m_editor->set_input_shapes(m);
} }
ngraph::PartialShape InputModel::get_partial_shape(ov::frontend::Place::Ptr place) const { ngraph::PartialShape InputModel::get_partial_shape(const ov::frontend::Place::Ptr& place) const {
return m_editor->get_tensor_shape(place->get_names().at(0)); return m_editor->get_tensor_shape(place->get_names().at(0));
} }
void InputModel::set_element_type(ov::frontend::Place::Ptr place, const ngraph::element::Type& type) { void InputModel::set_element_type(const ov::frontend::Place::Ptr& place, const ngraph::element::Type& type) {
std::map<std::string, ngraph::element::Type_t> m; std::map<std::string, ngraph::element::Type_t> m;
m[place->get_names()[0]] = type; m[place->get_names()[0]] = type;
m_editor->set_input_types(m); m_editor->set_input_types(m);

14
src/frontends/onnx/frontend/src/input_model.hpp
View File

@ -39,21 +39,21 @@ public:
ov::frontend::Place::Ptr get_place_by_operation_name_and_output_port(const std::string& operation_name, ov::frontend::Place::Ptr get_place_by_operation_name_and_output_port(const std::string& operation_name,
int output_port_index) override; int output_port_index) override;
void set_name_for_tensor(ov::frontend::Place::Ptr tensor, const std::string& new_name) override; void set_name_for_tensor(const ov::frontend::Place::Ptr& tensor, const std::string& new_name) override;
void set_name_for_operation(ov::frontend::Place::Ptr operation, const std::string& new_name) override; void set_name_for_operation(const ov::frontend::Place::Ptr& operation, const std::string& new_name) override;
void free_name_for_operation(const std::string& name) override; void free_name_for_operation(const std::string& name) override;
void set_name_for_dimension(ov::frontend::Place::Ptr place, void set_name_for_dimension(const ov::frontend::Place::Ptr& place,
size_t shape_dim_index, size_t shape_dim_index,
const std::string& dim_name) override; const std::string& dim_name) override;
/// \brief Not applicable for ONNX model. Throws immediately /// \brief Not applicable for ONNX model. Throws immediately
void add_name_for_tensor(ov::frontend::Place::Ptr tensor, const std::string& new_name) override; void add_name_for_tensor(const ov::frontend::Place::Ptr& tensor, const std::string& new_name) override;
/// \brief Not applicable for ONNX model. Throws immediately /// \brief Not applicable for ONNX model. Throws immediately
void free_name_for_tensor(const std::string& name) override; void free_name_for_tensor(const std::string& name) override;
void set_partial_shape(ov::frontend::Place::Ptr place, const ngraph::PartialShape& shape) override; void set_partial_shape(const ov::frontend::Place::Ptr& place, const ngraph::PartialShape& shape) override;
ngraph::PartialShape get_partial_shape(ov::frontend::Place::Ptr place) const override; ngraph::PartialShape get_partial_shape(const ov::frontend::Place::Ptr& place) const override;
void set_element_type(ov::frontend::Place::Ptr place, const ngraph::element::Type& type) override; void set_element_type(const ov::frontend::Place::Ptr& place, const ngraph::element::Type& type) override;
std::shared_ptr<Model> decode(); std::shared_ptr<Model> decode();
std::shared_ptr<Model> convert(); std::shared_ptr<Model> convert();

14
src/frontends/onnx/frontend/src/place.cpp
View File

@ -29,7 +29,7 @@ bool PlaceInputEdge::is_output() const {
return false; return false;
} }
bool PlaceInputEdge::is_equal(Place::Ptr another) const { bool PlaceInputEdge::is_equal(const Place::Ptr& another) const {
if (const auto in_edge = std::dynamic_pointer_cast<PlaceInputEdge>(another)) { if (const auto in_edge = std::dynamic_pointer_cast<PlaceInputEdge>(another)) {
const auto& editor_edge = in_edge->get_input_edge(); const auto& editor_edge = in_edge->get_input_edge();
return (editor_edge.m_node_idx == m_edge.m_node_idx) && (editor_edge.m_port_idx == m_edge.m_port_idx); return (editor_edge.m_node_idx == m_edge.m_node_idx) && (editor_edge.m_port_idx == m_edge.m_port_idx);
@ -37,7 +37,7 @@ bool PlaceInputEdge::is_equal(Place::Ptr another) const {
return false; return false;
} }
bool PlaceInputEdge::is_equal_data(Place::Ptr another) const { bool PlaceInputEdge::is_equal_data(const Place::Ptr& another) const {
return get_source_tensor()->is_equal_data(another); return get_source_tensor()->is_equal_data(another);
} }
@ -78,7 +78,7 @@ bool PlaceOutputEdge::is_output() const {
return m_editor->is_output(m_edge); return m_editor->is_output(m_edge);
} }
bool PlaceOutputEdge::is_equal(Place::Ptr another) const { bool PlaceOutputEdge::is_equal(const Place::Ptr& another) const {
if (const auto out_edge = std::dynamic_pointer_cast<PlaceOutputEdge>(another)) { if (const auto out_edge = std::dynamic_pointer_cast<PlaceOutputEdge>(another)) {
const auto& editor_edge = out_edge->get_output_edge(); const auto& editor_edge = out_edge->get_output_edge();
return (editor_edge.m_node_idx == m_edge.m_node_idx) && (editor_edge.m_port_idx == m_edge.m_port_idx); return (editor_edge.m_node_idx == m_edge.m_node_idx) && (editor_edge.m_port_idx == m_edge.m_port_idx);
@ -86,7 +86,7 @@ bool PlaceOutputEdge::is_equal(Place::Ptr another) const {
return false; return false;
} }
bool PlaceOutputEdge::is_equal_data(Place::Ptr another) const { bool PlaceOutputEdge::is_equal_data(const Place::Ptr& another) const {
return get_target_tensor()->is_equal_data(another); return get_target_tensor()->is_equal_data(another);
} }
@ -147,14 +147,14 @@ bool PlaceTensor::is_output() const {
return std::find(std::begin(outputs), std::end(outputs), m_name) != std::end(outputs); return std::find(std::begin(outputs), std::end(outputs), m_name) != std::end(outputs);
} }
bool PlaceTensor::is_equal(Place::Ptr another) const { bool PlaceTensor::is_equal(const Place::Ptr& another) const {
if (const auto tensor = std::dynamic_pointer_cast<PlaceTensor>(another)) { if (const auto tensor = std::dynamic_pointer_cast<PlaceTensor>(another)) {
return m_name == tensor->get_names().at(0); return m_name == tensor->get_names().at(0);
} }
return false; return false;
} }
bool PlaceTensor::is_equal_data(Place::Ptr another) const { bool PlaceTensor::is_equal_data(const Place::Ptr& another) const {
const auto consuming_ports = get_consuming_ports(); const auto consuming_ports = get_consuming_ports();
const auto eq_to_consuming_port = [&consuming_ports](const Ptr& another) { const auto eq_to_consuming_port = [&consuming_ports](const Ptr& another) {
return std::any_of(consuming_ports.begin(), consuming_ports.end(), [&another](const Ptr& place) { return std::any_of(consuming_ports.begin(), consuming_ports.end(), [&another](const Ptr& place) {
@ -319,7 +319,7 @@ ov::frontend::Place::Ptr PlaceOp::get_producing_operation(const std::string& inp
return nullptr; return nullptr;
} }
bool PlaceOp::is_equal(Place::Ptr another) const { bool PlaceOp::is_equal(const Place::Ptr& another) const {
if (const auto place_op = std::dynamic_pointer_cast<PlaceOp>(another)) { if (const auto place_op = std::dynamic_pointer_cast<PlaceOp>(another)) {
const auto& another_node = place_op->get_editor_node(); const auto& another_node = place_op->get_editor_node();
if (m_editor->is_correct_and_unambiguous_node(m_node) || if (m_editor->is_correct_and_unambiguous_node(m_node) ||

14
src/frontends/onnx/frontend/src/place.hpp
View File

@ -24,8 +24,8 @@ public:
// external usage // external usage
bool is_input() const override; bool is_input() const override;
bool is_output() const override; bool is_output() const override;
bool is_equal(Place::Ptr another) const override; bool is_equal(const Place::Ptr& another) const override;
bool is_equal_data(Place::Ptr another) const override; bool is_equal_data(const Place::Ptr& another) const override;
Place::Ptr get_source_tensor() const override; Place::Ptr get_source_tensor() const override;
std::vector<Place::Ptr> get_consuming_operations() const override; std::vector<Place::Ptr> get_consuming_operations() const override;
Place::Ptr get_producing_operation() const override; Place::Ptr get_producing_operation() const override;
@ -47,8 +47,8 @@ public:
// external usage // external usage
bool is_input() const override; bool is_input() const override;
bool is_output() const override; bool is_output() const override;
bool is_equal(Place::Ptr another) const override; bool is_equal(const Place::Ptr& another) const override;
bool is_equal_data(Place::Ptr another) const override; bool is_equal_data(const Place::Ptr& another) const override;
Place::Ptr get_target_tensor() const override; Place::Ptr get_target_tensor() const override;
std::vector<Place::Ptr> get_consuming_ports() const override; std::vector<Place::Ptr> get_consuming_ports() const override;
Place::Ptr get_producing_operation() const override; Place::Ptr get_producing_operation() const override;
@ -71,8 +71,8 @@ public:
Place::Ptr get_producing_operation() const override; Place::Ptr get_producing_operation() const override;
bool is_input() const override; bool is_input() const override;
bool is_output() const override; bool is_output() const override;
bool is_equal(Place::Ptr another) const override; bool is_equal(const Place::Ptr& another) const override;
bool is_equal_data(Place::Ptr another) const override; bool is_equal_data(const Place::Ptr& another) const override;
std::vector<Place::Ptr> get_consuming_operations() const override; std::vector<Place::Ptr> get_consuming_operations() const override;
void set_name(const std::string& new_name); void set_name(const std::string& new_name);
@ -119,7 +119,7 @@ public:
Place::Ptr get_source_tensor(int input_port_index) const override; Place::Ptr get_source_tensor(int input_port_index) const override;
Place::Ptr get_source_tensor(const std::string& input_name) const override; Place::Ptr get_source_tensor(const std::string& input_name) const override;
bool is_equal(Place::Ptr another) const override; bool is_equal(const Place::Ptr& another) const override;
bool is_input() const override; bool is_input() const override;
bool is_output() const override; bool is_output() const override;

8
src/frontends/paddlepaddle/include/paddlepaddle_frontend/frontend.hpp
View File

@ -21,11 +21,11 @@ public:
/// \brief Completely convert the remaining, not converted part of a function. /// \brief Completely convert the remaining, not converted part of a function.
/// \param partiallyConverted partially converted OV Model /// \param partiallyConverted partially converted OV Model
/// \return fully converted OV Model /// \return fully converted OV Model
std::shared_ptr<ov::Model> convert(InputModel::Ptr model) const override; std::shared_ptr<ov::Model> convert(const InputModel::Ptr& model) const override;
/// \brief Completely convert the remaining, not converted part of a function. /// \brief Completely convert the remaining, not converted part of a function.
/// \param partiallyConverted partially converted OV Model /// \param partiallyConverted partially converted OV Model
void convert(std::shared_ptr<Model> partiallyConverted) const override; void convert(const std::shared_ptr<Model>& partiallyConverted) const override;
/// \brief Convert only those parts of the model that can be converted leaving others /// \brief Convert only those parts of the model that can be converted leaving others
/// as-is. Converted parts are not normalized by additional transformations; normalize /// as-is. Converted parts are not normalized by additional transformations; normalize
@ -33,14 +33,14 @@ public:
/// conversion process. /// conversion process.
/// \param model Input model /// \param model Input model
/// \return partially converted OV Model /// \return partially converted OV Model
std::shared_ptr<Model> convert_partially(InputModel::Ptr model) const override; std::shared_ptr<Model> convert_partially(const InputModel::Ptr& model) const override;
/// \brief Convert operations with one-to-one mapping with decoding nodes. /// \brief Convert operations with one-to-one mapping with decoding nodes.
/// Each decoding node is an OV node representing a single FW operation node with /// Each decoding node is an OV node representing a single FW operation node with
/// all attributes represented in FW-independent way. /// all attributes represented in FW-independent way.
/// \param model Input model /// \param model Input model
/// \return OV Model after decoding /// \return OV Model after decoding
std::shared_ptr<Model> decode(InputModel::Ptr model) const override; std::shared_ptr<Model> decode(const InputModel::Ptr& model) const override;
/// \brief Gets name of this FrontEnd. Can be used by clients /// \brief Gets name of this FrontEnd. Can be used by clients
/// if frontend is selected automatically by FrontEndManager::load_by_model /// if frontend is selected automatically by FrontEndManager::load_by_model

8
src/frontends/paddlepaddle/include/paddlepaddle_frontend/model.hpp
View File

@ -35,10 +35,10 @@ public:
void override_all_outputs(const std::vector<Place::Ptr>& outputs) override; void override_all_outputs(const std::vector<Place::Ptr>& outputs) override;
void override_all_inputs(const std::vector<Place::Ptr>& inputs) override; void override_all_inputs(const std::vector<Place::Ptr>& inputs) override;
void extract_subgraph(const std::vector<Place::Ptr>& inputs, const std::vector<Place::Ptr>& outputs) override; void extract_subgraph(const std::vector<Place::Ptr>& inputs, const std::vector<Place::Ptr>& outputs) override;
void set_partial_shape(Place::Ptr place, const ov::PartialShape&) override; void set_partial_shape(const Place::Ptr& place, const ov::PartialShape&) override;
ov::PartialShape get_partial_shape(Place::Ptr place) const override; ov::PartialShape get_partial_shape(const Place::Ptr& place) const override;
void set_element_type(Place::Ptr place, const ov::element::Type&) override; void set_element_type(const Place::Ptr& place, const ov::element::Type&) override;
void set_tensor_value(Place::Ptr place, const void* value) override; void set_tensor_value(const Place::Ptr& place, const void* value) override;
}; };
} // namespace frontend } // namespace frontend

8
src/frontends/paddlepaddle/include/paddlepaddle_frontend/place.hpp
View File

@ -35,7 +35,7 @@ public:
bool is_input() const override; bool is_input() const override;
bool is_output() const override; bool is_output() const override;
bool is_equal(Ptr another) const override { bool is_equal(const Ptr& another) const override {
return this == another.get(); return this == another.get();
} }
@ -67,7 +67,7 @@ public:
Place::Ptr get_source_tensor() const override; Place::Ptr get_source_tensor() const override;
Ptr get_producing_port() const override; Ptr get_producing_port() const override;
bool is_equal_data(Ptr another) const override; bool is_equal_data(const Ptr& another) const override;
private: private:
std::weak_ptr<TensorPlacePDPD> m_source_tensor; std::weak_ptr<TensorPlacePDPD> m_source_tensor;
@ -90,7 +90,7 @@ public:
Place::Ptr get_producing_operation() const override; Place::Ptr get_producing_operation() const override;
std::vector<Place::Ptr> get_consuming_ports() const override; std::vector<Place::Ptr> get_consuming_ports() const override;
Ptr get_target_tensor() const override; Ptr get_target_tensor() const override;
bool is_equal_data(Ptr another) const override; bool is_equal_data(const Ptr& another) const override;
private: private:
std::weak_ptr<OpPlacePDPD> m_op; std::weak_ptr<OpPlacePDPD> m_op;
@ -185,7 +185,7 @@ public:
std::vector<Place::Ptr> get_consuming_operations() const override; std::vector<Place::Ptr> get_consuming_operations() const override;
std::vector<Place::Ptr> get_consuming_ports() const override; std::vector<Place::Ptr> get_consuming_ports() const override;
Ptr get_producing_port() const override; Ptr get_producing_port() const override;
bool is_equal_data(Ptr another) const override; bool is_equal_data(const Ptr& another) const override;
private: private:
const paddle::framework::proto::VarDesc& m_var_desc; const paddle::framework::proto::VarDesc& m_var_desc;

8
src/frontends/paddlepaddle/src/frontend.cpp
View File

@ -276,7 +276,7 @@ InputModel::Ptr FrontEndPDPD::load_impl(const std::vector<ov::Any>& variants) co
PDPD_THROW("Model can be loaded either from 1 or 2 files/streams"); PDPD_THROW("Model can be loaded either from 1 or 2 files/streams");
} }
std::shared_ptr<ov::Model> FrontEndPDPD::convert(InputModel::Ptr model) const { std::shared_ptr<ov::Model> FrontEndPDPD::convert(const InputModel::Ptr& model) const {
auto pdpd_model = std::dynamic_pointer_cast<InputModelPDPD>(model); auto pdpd_model = std::dynamic_pointer_cast<InputModelPDPD>(model);
std::map<std::string, pdpd::CreatorFunction> CREATORS_MAP = pdpd::get_supported_ops(); std::map<std::string, pdpd::CreatorFunction> CREATORS_MAP = pdpd::get_supported_ops();
auto f = convert_each_node( auto f = convert_each_node(
@ -287,7 +287,7 @@ std::shared_ptr<ov::Model> FrontEndPDPD::convert(InputModel::Ptr model) const {
return f; return f;
} }
void FrontEndPDPD::convert(std::shared_ptr<ov::Model> partiallyConverted) const { void FrontEndPDPD::convert(const std::shared_ptr<ov::Model>& partiallyConverted) const {
for (const auto& node : partiallyConverted->get_ordered_ops()) { for (const auto& node : partiallyConverted->get_ordered_ops()) {
if (ov::is_type<PDPDFrameworkNode>(node)) { if (ov::is_type<PDPDFrameworkNode>(node)) {
pdpd::normalize_framework_node(std::dynamic_pointer_cast<PDPDFrameworkNode>(node), pdpd::normalize_framework_node(std::dynamic_pointer_cast<PDPDFrameworkNode>(node),
@ -299,7 +299,7 @@ void FrontEndPDPD::convert(std::shared_ptr<ov::Model> partiallyConverted) const
} }
} }
std::shared_ptr<ov::Model> FrontEndPDPD::convert_partially(InputModel::Ptr model) const { std::shared_ptr<ov::Model> FrontEndPDPD::convert_partially(const InputModel::Ptr& model) const {
auto pdpd_model = std::dynamic_pointer_cast<InputModelPDPD>(model); auto pdpd_model = std::dynamic_pointer_cast<InputModelPDPD>(model);
std::map<std::string, pdpd::CreatorFunction> CREATORS_MAP = pdpd::get_supported_ops(); std::map<std::string, pdpd::CreatorFunction> CREATORS_MAP = pdpd::get_supported_ops();
auto f = convert_each_node( auto f = convert_each_node(
@ -316,7 +316,7 @@ std::shared_ptr<ov::Model> FrontEndPDPD::convert_partially(InputModel::Ptr model
return f; return f;
} }
std::shared_ptr<ov::Model> FrontEndPDPD::decode(InputModel::Ptr model) const { std::shared_ptr<ov::Model> FrontEndPDPD::decode(const InputModel::Ptr& model) const {
auto pdpd_model = std::dynamic_pointer_cast<InputModelPDPD>(model); auto pdpd_model = std::dynamic_pointer_cast<InputModelPDPD>(model);
std::map<std::string, pdpd::CreatorFunction> CREATORS_MAP = pdpd::get_supported_ops(); std::map<std::string, pdpd::CreatorFunction> CREATORS_MAP = pdpd::get_supported_ops();
auto f = convert_each_node(pdpd_model, pdpd::make_framework_node); auto f = convert_each_node(pdpd_model, pdpd::make_framework_node);

8
src/frontends/paddlepaddle/src/model.cpp
View File

@ -472,19 +472,19 @@ void InputModelPDPD::extract_subgraph(const std::vector<Place::Ptr>& inputs, con
_impl->extractSubgraph(inputs, outputs); _impl->extractSubgraph(inputs, outputs);
} }
void InputModelPDPD::set_partial_shape(Place::Ptr place, const ov::PartialShape& p_shape) { void InputModelPDPD::set_partial_shape(const Place::Ptr& place, const ov::PartialShape& p_shape) {
_impl->setPartialShape(place, p_shape); _impl->setPartialShape(place, p_shape);
} }
ov::PartialShape InputModelPDPD::get_partial_shape(Place::Ptr place) const { ov::PartialShape InputModelPDPD::get_partial_shape(const Place::Ptr& place) const {
return _impl->getPartialShape(place); return _impl->getPartialShape(place);
} }
void InputModelPDPD::set_element_type(Place::Ptr place, const ov::element::Type& type) { void InputModelPDPD::set_element_type(const Place::Ptr& place, const ov::element::Type& type) {
_impl->setElementType(place, type); _impl->setElementType(place, type);
} }
void InputModelPDPD::set_tensor_value(Place::Ptr place, const void* value) { void InputModelPDPD::set_tensor_value(const Place::Ptr& place, const void* value) {
_impl->setTensorValue(place, value); _impl->setTensorValue(place, value);
} }

6
src/frontends/paddlepaddle/src/place.cpp
View File

@ -256,7 +256,7 @@ std::vector<Place::Ptr> TensorPlacePDPD::get_consuming_operations() const {
return consuming_ops; return consuming_ops;
} }
bool TensorPlacePDPD::is_equal_data(Place::Ptr another) const { bool TensorPlacePDPD::is_equal_data(const Place::Ptr& another) const {
auto consuming_ports = get_consuming_ports(); auto consuming_ports = get_consuming_ports();
bool eq_to_consuming_port = bool eq_to_consuming_port =
std::any_of(consuming_ports.begin(), consuming_ports.end(), [&another](const Ptr& place) { std::any_of(consuming_ports.begin(), consuming_ports.end(), [&another](const Ptr& place) {
@ -305,7 +305,7 @@ Place::Ptr InPortPlacePDPD::get_producing_port() const {
return get_source_tensor()->get_producing_port(); return get_source_tensor()->get_producing_port();
} }
bool InPortPlacePDPD::is_equal_data(Place::Ptr another) const { bool InPortPlacePDPD::is_equal_data(const Place::Ptr& another) const {
return get_source_tensor()->is_equal_data(another); return get_source_tensor()->is_equal_data(another);
} }
@ -338,7 +338,7 @@ std::vector<Place::Ptr> OutPortPlacePDPD::get_consuming_ports() const {
FRONT_END_THROW("Tensor has expired."); FRONT_END_THROW("Tensor has expired.");
} }
bool OutPortPlacePDPD::is_equal_data(Place::Ptr another) const { bool OutPortPlacePDPD::is_equal_data(const Place::Ptr& another) const {
return get_target_tensor()->is_equal_data(another); return get_target_tensor()->is_equal_data(another);
} }

10
src/frontends/tensorflow/include/tensorflow_frontend/frontend.hpp
View File

@ -37,11 +37,11 @@ public:
/// \brief Completely convert the model /// \brief Completely convert the model
/// \return fully converted ov Model /// \return fully converted ov Model
std::shared_ptr<Model> convert(ov::frontend::InputModel::Ptr model) const override; std::shared_ptr<Model> convert(const ov::frontend::InputModel::Ptr& model) const override;
/// \brief Completely convert the remaining, not converted part of a function. /// \brief Completely convert the remaining, not converted part of a function.
/// \param partiallyConverted partially converted ov Model /// \param partiallyConverted partially converted ov Model
void convert(std::shared_ptr<Model> partiallyConverted) const override; void convert(const std::shared_ptr<Model>& partiallyConverted) const override;
/// \brief Convert only those parts of the model that can be converted leaving others /// \brief Convert only those parts of the model that can be converted leaving others
/// as-is. Converted parts are not normalized by additional transformations; normalize /// as-is. Converted parts are not normalized by additional transformations; normalize
@ -49,18 +49,18 @@ public:
/// conversion process. /// conversion process.
/// \param model Input model /// \param model Input model
/// \return partially converted ov Model /// \return partially converted ov Model
std::shared_ptr<Model> convert_partially(ov::frontend::InputModel::Ptr model) const override; std::shared_ptr<Model> convert_partially(const ov::frontend::InputModel::Ptr& model) const override;
/// \brief Convert operations with one-to-one mapping with decoding nodes. /// \brief Convert operations with one-to-one mapping with decoding nodes.
/// Each decoding node is an ov node representing a single FW operation node with /// Each decoding node is an ov node representing a single FW operation node with
/// all attributes represented in FW-independent way. /// all attributes represented in FW-independent way.
/// \param model Input model /// \param model Input model
/// \return ov Model after decoding /// \return ov Model after decoding
std::shared_ptr<Model> decode(ov::frontend::InputModel::Ptr model) const override; std::shared_ptr<Model> decode(const ov::frontend::InputModel::Ptr& model) const override;
/// \brief Runs normalization passes on function that was loaded with partial conversion /// \brief Runs normalization passes on function that was loaded with partial conversion
/// \param Model partially converted ov Model /// \param Model partially converted ov Model
void normalize(std::shared_ptr<ov::Model> function) const override; void normalize(const std::shared_ptr<ov::Model>& function) const override;
/// \brief Gets name of this FrontEnd. Can be used by clients /// \brief Gets name of this FrontEnd. Can be used by clients
std::string get_name() const override { std::string get_name() const override {

10
src/frontends/tensorflow/src/frontend.cpp
View File

@ -306,7 +306,7 @@ ov::frontend::InputModel::Ptr FrontEndTF::load_impl(const std::vector<ov::Any>&
return nullptr; return nullptr;
} }
std::shared_ptr<ov::Model> FrontEndTF::convert(ov::frontend::InputModel::Ptr model) const { std::shared_ptr<ov::Model> FrontEndTF::convert(const ov::frontend::InputModel::Ptr& model) const {
auto model_tf = std::dynamic_pointer_cast<InputModelTF>(model); auto model_tf = std::dynamic_pointer_cast<InputModelTF>(model);
std::shared_ptr<ov::Model> f; std::shared_ptr<ov::Model> f;
translate_graph(model_tf, "here_should_be_a_graph_name", true, false, f); translate_graph(model_tf, "here_should_be_a_graph_name", true, false, f);
@ -316,7 +316,7 @@ std::shared_ptr<ov::Model> FrontEndTF::convert(ov::frontend::InputModel::Ptr mod
return f; return f;
} }
std::shared_ptr<ov::Model> FrontEndTF::convert_partially(ov::frontend::InputModel::Ptr model) const { std::shared_ptr<ov::Model> FrontEndTF::convert_partially(const ov::frontend::InputModel::Ptr& model) const {
auto model_tf = std::dynamic_pointer_cast<InputModelTF>(model); auto model_tf = std::dynamic_pointer_cast<InputModelTF>(model);
std::shared_ptr<ov::Model> f; std::shared_ptr<ov::Model> f;
translate_graph(model_tf, "here_should_be_a_graph_name", false, false, f); translate_graph(model_tf, "here_should_be_a_graph_name", false, false, f);
@ -324,14 +324,14 @@ std::shared_ptr<ov::Model> FrontEndTF::convert_partially(ov::frontend::InputMode
return f; return f;
} }
std::shared_ptr<ov::Model> FrontEndTF::decode(ov::frontend::InputModel::Ptr model) const { std::shared_ptr<ov::Model> FrontEndTF::decode(const ov::frontend::InputModel::Ptr& model) const {
auto model_tf = std::dynamic_pointer_cast<InputModelTF>(model); auto model_tf = std::dynamic_pointer_cast<InputModelTF>(model);
std::shared_ptr<ov::Model> f; std::shared_ptr<ov::Model> f;
translate_graph(model_tf, "here_should_be_a_graph_name", false, true, f); translate_graph(model_tf, "here_should_be_a_graph_name", false, true, f);
return f; return f;
} }
void FrontEndTF::convert(std::shared_ptr<ov::Model> partiallyConverted) const { void FrontEndTF::convert(const std::shared_ptr<ov::Model>& partiallyConverted) const {
for (const auto& node : partiallyConverted->get_ordered_ops()) { for (const auto& node : partiallyConverted->get_ordered_ops()) {
if (ov::is_type<TFFrameworkNode>(node)) { if (ov::is_type<TFFrameworkNode>(node)) {
translate_framework_node(std::dynamic_pointer_cast<TFFrameworkNode>(node), m_op_translators); translate_framework_node(std::dynamic_pointer_cast<TFFrameworkNode>(node), m_op_translators);
@ -344,7 +344,7 @@ void FrontEndTF::convert(std::shared_ptr<ov::Model> partiallyConverted) const {
normalize(partiallyConverted); normalize(partiallyConverted);
} }
void FrontEndTF::normalize(std::shared_ptr<ov::Model> function) const { void FrontEndTF::normalize(const std::shared_ptr<ov::Model>& function) const {
ov::pass::Manager manager; ov::pass::Manager manager;
manager.register_pass<ov::frontend::tf::pass::TransposeSinkingOVTF>(); manager.register_pass<ov::frontend::tf::pass::TransposeSinkingOVTF>();
manager.run_passes(function); manager.run_passes(function);

8
src/frontends/tensorflow/src/model.cpp
View File

@ -392,19 +392,19 @@ void InputModelTF::extract_subgraph(const std::vector<ov::frontend::Place::Ptr>&
_impl->extractSubgraph(inputs, outputs); _impl->extractSubgraph(inputs, outputs);
} }
void InputModelTF::set_partial_shape(ov::frontend::Place::Ptr place, const ov::PartialShape& p_shape) { void InputModelTF::set_partial_shape(const ov::frontend::Place::Ptr& place, const ov::PartialShape& p_shape) {
_impl->setPartialShape(place, p_shape); _impl->setPartialShape(place, p_shape);
} }
ov::PartialShape InputModelTF::get_partial_shape(ov::frontend::Place::Ptr place) const { ov::PartialShape InputModelTF::get_partial_shape(const ov::frontend::Place::Ptr& place) const {
return _impl->getPartialShape(place); return _impl->getPartialShape(place);
} }
void InputModelTF::set_element_type(ov::frontend::Place::Ptr place, const ov::element::Type& type) { void InputModelTF::set_element_type(const ov::frontend::Place::Ptr& place, const ov::element::Type& type) {
_impl->setElementType(place, type); _impl->setElementType(place, type);
} }
void InputModelTF::set_tensor_value(ov::frontend::Place::Ptr place, const void* value) { void InputModelTF::set_tensor_value(const ov::frontend::Place::Ptr& place, const void* value) {
_impl->setTensorValue(place, value); _impl->setTensorValue(place, value);
} }
} // namespace frontend } // namespace frontend

8
src/frontends/tensorflow/src/model.hpp
View File

@ -35,10 +35,10 @@ public:
void override_all_inputs(const std::vector<ov::frontend::Place::Ptr>& inputs) override; void override_all_inputs(const std::vector<ov::frontend::Place::Ptr>& inputs) override;
void extract_subgraph(const std::vector<ov::frontend::Place::Ptr>& inputs, void extract_subgraph(const std::vector<ov::frontend::Place::Ptr>& inputs,
const std::vector<ov::frontend::Place::Ptr>& outputs) override; const std::vector<ov::frontend::Place::Ptr>& outputs) override;
void set_partial_shape(ov::frontend::Place::Ptr place, const ov::PartialShape&) override; void set_partial_shape(const ov::frontend::Place::Ptr& place, const ov::PartialShape&) override;
ov::PartialShape get_partial_shape(ov::frontend::Place::Ptr place) const override; ov::PartialShape get_partial_shape(const ov::frontend::Place::Ptr& place) const override;
void set_element_type(ov::frontend::Place::Ptr place, const ov::element::Type&) override; void set_element_type(const ov::frontend::Place::Ptr& place, const ov::element::Type&) override;
void set_tensor_value(ov::frontend::Place::Ptr place, const void* value) override; void set_tensor_value(const ov::frontend::Place::Ptr& place, const void* value) override;
}; };
} // namespace frontend } // namespace frontend
} // namespace ov } // namespace ov

6
src/frontends/tensorflow/src/place.cpp
View File

@ -204,7 +204,7 @@ std::vector<ov::frontend::Place::Ptr> TensorPlaceTF::get_consuming_operations()
return consuming_ops; return consuming_ops;
} }
bool TensorPlaceTF::is_equal_data(ov::frontend::Place::Ptr another) const { bool TensorPlaceTF::is_equal_data(const ov::frontend::Place::Ptr& another) const {
auto consuming_ports = get_consuming_ports(); auto consuming_ports = get_consuming_ports();
bool eq_to_consuming_port = bool eq_to_consuming_port =
std::any_of(consuming_ports.begin(), consuming_ports.end(), [&another](const Ptr& place) { std::any_of(consuming_ports.begin(), consuming_ports.end(), [&another](const Ptr& place) {
@ -253,7 +253,7 @@ ov::frontend::Place::Ptr InPortPlaceTF::get_producing_port() const {
return get_source_tensor()->get_producing_port(); return get_source_tensor()->get_producing_port();
} }
bool InPortPlaceTF::is_equal_data(ov::frontend::Place::Ptr another) const { bool InPortPlaceTF::is_equal_data(const ov::frontend::Place::Ptr& another) const {
return get_source_tensor()->is_equal_data(another); return get_source_tensor()->is_equal_data(another);
} }
@ -286,7 +286,7 @@ std::vector<ov::frontend::Place::Ptr> OutPortPlaceTF::get_consuming_ports() cons
FRONT_END_THROW("Tensor has expired."); FRONT_END_THROW("Tensor has expired.");
} }
bool OutPortPlaceTF::is_equal_data(ov::frontend::Place::Ptr another) const { bool OutPortPlaceTF::is_equal_data(const ov::frontend::Place::Ptr& another) const {
return get_target_tensor()->is_equal_data(another); return get_target_tensor()->is_equal_data(another);
} }

8
src/frontends/tensorflow/src/place.hpp
View File

@ -25,7 +25,7 @@ public:
bool is_input() const override; bool is_input() const override;
bool is_output() const override; bool is_output() const override;
bool is_equal(Ptr another) const override { bool is_equal(const Ptr& another) const override {
return this == another.get(); return this == another.get();
} }
@ -57,7 +57,7 @@ public:
ov::frontend::Place::Ptr get_source_tensor() const override; ov::frontend::Place::Ptr get_source_tensor() const override;
Ptr get_producing_port() const override; Ptr get_producing_port() const override;
bool is_equal_data(Ptr another) const override; bool is_equal_data(const Ptr& another) const override;
private: private:
std::weak_ptr<TensorPlaceTF> m_source_tensor; std::weak_ptr<TensorPlaceTF> m_source_tensor;
@ -80,7 +80,7 @@ public:
ov::frontend::Place::Ptr get_producing_operation() const override; ov::frontend::Place::Ptr get_producing_operation() const override;
std::vector<ov::frontend::Place::Ptr> get_consuming_ports() const override; std::vector<ov::frontend::Place::Ptr> get_consuming_ports() const override;
Ptr get_target_tensor() const override; Ptr get_target_tensor() const override;
bool is_equal_data(Ptr another) const override; bool is_equal_data(const Ptr& another) const override;
private: private:
std::weak_ptr<OpPlaceTF> m_op; std::weak_ptr<OpPlaceTF> m_op;
@ -162,7 +162,7 @@ public:
std::vector<ov::frontend::Place::Ptr> get_consuming_operations() const override; std::vector<ov::frontend::Place::Ptr> get_consuming_operations() const override;
std::vector<ov::frontend::Place::Ptr> get_consuming_ports() const override; std::vector<ov::frontend::Place::Ptr> get_consuming_ports() const override;
Ptr get_producing_port() const override; Ptr get_producing_port() const override;
bool is_equal_data(Ptr another) const override; bool is_equal_data(const Ptr& another) const override;
private: private:
PartialShape m_pshape; PartialShape m_pshape;

12
tools/mo/unit_tests/mock_mo_frontend/mock_mo_ov_frontend/mock_mo_frontend.hpp
View File

@ -188,7 +188,7 @@ public:
return m_name.find("output") != std::string::npos; return m_name.find("output") != std::string::npos;
} }
bool is_equal(Ptr another) const override bool is_equal(const Ptr& another) const override
{ {
m_stat.m_is_equal++; m_stat.m_is_equal++;
m_stat.m_lastArgPlace = another; m_stat.m_lastArgPlace = another;
@ -197,7 +197,7 @@ public:
m_portIndex == mock->m_portIndex; m_portIndex == mock->m_portIndex;
} }
bool is_equal_data(Ptr another) const override bool is_equal_data(const Ptr& another) const override
{ {
if (m_is_op) if (m_is_op)
throw "Not implemented"; throw "Not implemented";
@ -358,21 +358,21 @@ public:
} }
// Setting tensor properties // Setting tensor properties
void set_partial_shape(Place::Ptr place, const ngraph::PartialShape& shape) override void set_partial_shape(const Place::Ptr& place, const ngraph::PartialShape& shape) override
{ {
m_stat.m_set_partial_shape++; m_stat.m_set_partial_shape++;
m_stat.m_lastArgPlace = place; m_stat.m_lastArgPlace = place;
m_stat.m_lastArgPartialShape = shape; m_stat.m_lastArgPartialShape = shape;
} }
ngraph::PartialShape get_partial_shape(Place::Ptr place) const override ngraph::PartialShape get_partial_shape(const Place::Ptr& place) const override
{ {
m_stat.m_get_partial_shape++; m_stat.m_get_partial_shape++;
m_stat.m_lastArgPlace = place; m_stat.m_lastArgPlace = place;
return m_returnShape; return m_returnShape;
} }
void set_element_type(Place::Ptr place, const ngraph::element::Type& type) override void set_element_type(const Place::Ptr& place, const ngraph::element::Type& type) override
{ {
m_stat.m_set_element_type++; m_stat.m_set_element_type++;
m_stat.m_lastArgPlace = place; m_stat.m_lastArgPlace = place;
@ -414,7 +414,7 @@ class MOCK_API FrontEndMockPy : public FrontEnd
public: public:
FrontEndMockPy() {} FrontEndMockPy() {}
std::shared_ptr<ov::Model> convert(InputModel::Ptr model) const override std::shared_ptr<ov::Model> convert(const InputModel::Ptr& model) const override
{ {
m_stat.m_convert_model++; m_stat.m_convert_model++;
return std::make_shared<ov::Model>(ov::NodeVector{}, ov::ParameterVector{}); return std::make_shared<ov::Model>(ov::NodeVector{}, ov::ParameterVector{});