Class ov::frontend::Place#

class Place#

An interface for identifying a place in a graph and iterate over it; can refer to an operation node, tensor, port etc.

Place can refer to Tensor, Input Edge, Input Port, Operation, Output Port, Output Edge

           [Tensor A]
               |
               | [Input Edge]
               |
               V
      -------------------
      [  [Input Port 0] ]
      [                 ]
      [   Operation A   ]
      [                 ]
      [ [Output Port 0] ]
      -------------------
               |
               | [Output Edge]
               |
               V
           [Tensor B]
               |
               | [Input Edge]
               |
               V
      -------------------
      [  [Input Port 0] ]
      [                 ]
      [   Operation B   ]
      [                 ]
      [ [Output Port 0] ]
      -------------------
               |
               | [Output Edge]
               |
               V
           [Tensor C]

Note

Each front end implementation provides specialization of this interface to represent a place in a model graph. Various methods in the front end classes accept and retrieve instances of Place to point to particular node part which should be modified or satisfies some criteria. For example, this class is used to report model inputs and outputs, for searching operations and tensors by name, for setting shape etc.

Public Functions

virtual std::vector<std::string> get_names() const#

All associated names (synonyms) that identify this place in the graph in a framework specific way.

Returns:: A vector of strings each representing a name that identifies this place in the graph. Can be empty if there are no names associated with this place or name cannot be attached.

virtual std::vector<Ptr> get_consuming_operations() const#

Returns references to all operation nodes that consume data from this place.

Note

It can be called for any kind of graph place searching for the first consuming operations. It is optional if place has only one output port

Returns:: A vector with all operation node references that consumes data from this place

virtual std::vector<Ptr> get_consuming_operations(int output_port_index) const#

Returns references to all operation nodes that consume data from this place for specified output port.

Note

It can be called for any kind of graph place searching for the first consuming operations.

Parameters:: output_port_index – If place is an operational node it specifies which output port should be considered.
Returns:: A vector with all operation node references that consumes data from this place

virtual std::vector<Ptr> get_consuming_operations(const std::string &outputName) const#

Returns references to all operation nodes that consume data from this place for specified output port.

Note

It can be called for any kind of graph place searching for the first consuming operations.

Parameters:: outputName – If a given place is itself an operation node, this specifies name of output port group
Returns:: A vector with all operation node references that consumes data from this place

virtual std::vector<Ptr> get_consuming_operations(const std::string &outputName, int outputPortIndex) const#

Returns references to all operation nodes that consume data from this place for specified output port.

Note

It can be called for any kind of graph place searching for the first consuming operations.

Parameters:

outputName – If a given place is itself an operation node, this specifies name of output port group, each group can have multiple ports
outputPortIndex – If place is an operational node it specifies which output port should be considered.

Returns:

A vector with all operation node references that consumes data from this place

virtual Ptr get_target_tensor() const#

Returns a tensor place that gets data from this place; applicable for operations, output ports and output edges which have only one output port.

Returns:: A tensor place which hold the resulting value for this place

virtual Ptr get_target_tensor(const std::string &outputName) const#

Returns a tensor place that gets data from this place; applicable for operations.

Parameters:: outputName – Name of output port group
Returns:: A tensor place which hold the resulting value for this place

virtual Ptr get_target_tensor(const std::string &outputName, int outputPortIndex) const#

Returns a tensor place that gets data from this place; applicable for operations.

Parameters:

outputName – Name of output port group, each group can have multiple ports
outputPortIndex – Output port index if the current place is an operation node and has multiple output ports

Returns:

A tensor place which hold the resulting value for this place

virtual Ptr get_target_tensor(int output_port_index) const#

Returns a tensor place that gets data from this place; applicable for operations.

Parameters:: output_port_index – Output port index if the current place is an operation node and has multiple output ports
Returns:: A tensor place which hold the resulting value for this place

virtual Ptr get_source_tensor() const#

Returns a tensor place that supplies data for this place; applicable for operations, input ports and input edges which have only one input port.

Returns:: A tensor place which supplies data for this place

virtual Ptr get_source_tensor(int input_port_index) const#

Returns a tensor place that supplies data for this place; applicable for operations.

Parameters:: input_port_index – Input port index for operational nodes.
Returns:: A tensor place which supplies data for this place

virtual Ptr get_source_tensor(const std::string &inputName) const#

Returns a tensor place that supplies data for this place; applicable for operations.

Parameters:: inputName – Name of input port group
Returns:: A tensor place which supplies data for this place

virtual Ptr get_source_tensor(const std::string &inputName, int inputPortIndex) const#

Returns a tensor place that supplies data for this place; applicable for operations.

Parameters:

inputName – If a given place is itself an operation node, this specifies name of output port group, each group can have multiple ports
inputPortIndex – Input port index for operational nodes.

Returns:

A tensor place which supplies data for this place

virtual Ptr get_producing_operation() const#

Get an operation node place that immediately produces data for this place; applicable if place has only one input port.

Returns:: An operation place that produces data for this place

virtual Ptr get_producing_operation(int input_port_index) const#

Get an operation node place that immediately produces data for this place.

Parameters:: input_port_index – If a given place is itself an operation node, this specifies a port index
Returns:: An operation place that produces data for this place

virtual Ptr get_producing_operation(const std::string &inputName) const#

Get an operation node place that immediately produces data for this place.

Parameters:: inputName – If a given place is itself an operation node, this specifies name of output port group
Returns:: An operation place that produces data for this place

virtual Ptr get_producing_operation(const std::string &inputName, int inputPortIndex) const#

Get an operation node place that immediately produces data for this place.

Parameters:

inputName – If a given place is itself an operation node, this specifies name of output port group, each group can have multiple ports
inputPortIndex – If a given place is itself an operation node, this specifies a port index

Returns:

An operation place that produces data for this place

virtual Ptr get_producing_port() const#: Returns a port that produces data for this place.

virtual Ptr get_input_port() const#

For operation node returns reference to an input port; applicable if operation node has only one input port.

Returns:: Input port place or nullptr if not exists

virtual Ptr get_input_port(int input_port_index) const#

For operation node returns reference to an input port with specified index.

Parameters:: input_port_index – Input port index
Returns:: Appropriate input port place or nullptr if not exists

virtual Ptr get_input_port(const std::string &input_name) const#

For operation node returns reference to an input port with specified name; applicable if port group has only one input port.

Parameters:: input_name – Name of port group
Returns:: Appropriate input port place or nullptr if not exists

virtual Ptr get_input_port(const std::string &input_name, int input_port_index) const#

For operation node returns reference to an input port with specified name and index.

Parameters:

input_name – Name of port group, each group can have multiple ports
input_port_index – Input port index in a group

Returns:

Appropriate input port place or nullptr if not exists

virtual Ptr get_output_port() const#

For operation node returns reference to an output port; applicable for operations with only one output port.

Returns:: Appropriate output port place or nullptr if not exists

virtual Ptr get_output_port(int output_port_index) const#

For operation node returns reference to an output port with specified index.

Parameters:: output_port_index – Output port index
Returns:: Appropriate output port place or nullptr if not exists

virtual Ptr get_output_port(const std::string &output_name) const#

For operation node returns reference to an output port with specified name; applicable if port group has only one output port.

Parameters:: output_name – Name of output port group
Returns:: Appropriate output port place or nullptr if not exists

virtual Ptr get_output_port(const std::string &output_name, int output_port_index) const#

For operation node returns reference to an output port with specified name and index.

Parameters:

output_name – Name of output port group, each group can have multiple ports
output_port_index – Output port index

Returns:

Appropriate output port place or nullptr if not exists

virtual std::vector<Place::Ptr> get_consuming_ports() const#: Returns all input ports that consume data flows through this place.

virtual bool is_input() const#: Returns true if this place is input for a model.

virtual bool is_output() const#: Returns true if this place is output for a model.

virtual bool is_equal(const Ptr &another) const#

Returns true if another place is the same as this place.

Parameters:: another – Another place object

virtual bool is_equal_data(const Ptr &another) const#

Returns true if another place points to the same data.

Note

The same data means all places on path: output port -> output edge -> tensor -> input edge -> input port.

Parameters:: another – Another place object