return false;
}
- auto data_node = broadcast->get_argument(0);
- auto shape_node = std::dynamic_pointer_cast<ngraph::opset1::Constant>(broadcast->get_argument(1));
- auto axes_node = std::dynamic_pointer_cast<ngraph::opset1::Constant>(broadcast->get_argument(2));
+ auto data_node = broadcast->input_value(0).get_node_shared_ptr();
+ auto shape_node = std::dynamic_pointer_cast<ngraph::opset1::Constant>(broadcast->input_value(1).get_node_shared_ptr());
+ auto axes_node = std::dynamic_pointer_cast<ngraph::opset1::Constant>(broadcast->input_value(2).get_node_shared_ptr());
if (!data_node || !shape_node || !axes_node) return false;
auto output_shape = shape_node->get_vector<int64_t>();
auto on_value = std::stof(on_value_node->convert_value_to_string(0));
auto off_value = std::stof(off_value_node->convert_value_to_string(0));
- auto one_hot_ie = std::make_shared<ngraph::op::OneHotIE>(one_hot->get_argument(0),
+ auto one_hot_ie = std::make_shared<ngraph::op::OneHotIE>(one_hot->input_value(0),
one_hot->get_axis(), depth_value, on_value, off_value, output_type);
one_hot_ie->set_friendly_name(one_hot->get_friendly_name());
bool ngraph::pass::ConvertOneHotToOneHotIE::run_on_function(std::shared_ptr<ngraph::Function> f) {
is_f16 = ngraph::op::util::has_f16_constants(f);
return GraphRewrite::run_on_function(f);
-}
\ No newline at end of file
+}
return false;
}
- auto data_node = slice->get_argument(0);
- auto begin_node = std::dynamic_pointer_cast<ngraph::opset1::Constant>(slice->get_argument(1));
- auto end_node = std::dynamic_pointer_cast<ngraph::opset1::Constant>(slice->get_argument(2));
- auto stride_node = std::dynamic_pointer_cast<ngraph::opset1::Constant>(slice->get_argument(3));
+ auto data_output = slice->input_value(0);
+ auto begin_node = std::dynamic_pointer_cast<ngraph::opset1::Constant>(slice->input_value(1).get_node_shared_ptr());
+ auto end_node = std::dynamic_pointer_cast<ngraph::opset1::Constant>(slice->input_value(2).get_node_shared_ptr());
+ auto stride_node = std::dynamic_pointer_cast<ngraph::opset1::Constant>(slice->input_value(3).get_node_shared_ptr());
auto partial_input_shape = slice->get_input_partial_shape(0);
if (!new_axis_mask.empty()) {
auto new_shape = std::make_shared<ngraph::opset1::Constant>(element::i64,
ngraph::Shape{reshape_pattern.size()}, reshape_pattern);
- data_node = std::make_shared<ngraph::opset1::Reshape>(data_node, new_shape, true);
+ auto data_node = std::make_shared<ngraph::opset1::Reshape>(data_output, new_shape, true);
data_node->set_friendly_name(slice->get_friendly_name() + "/Reshape_before");
new_ops.push_back(data_node);
+ data_output = data_node->output(0);
}
- auto data_node_shape = data_node->get_output_shape(0);
+ auto data_node_shape = data_output.get_shape();
// MKLDNN: "Crop supports only 2d, 4d and 5d blobs."
if (data_node_shape.size() != 2 && data_node_shape.size() != 4 && data_node_shape.size() != 5) {
return false;
}
// Crop
- data_node = std::make_shared<ngraph::op::CropIE> (data_node, axes, dim, offset);
+ std::shared_ptr<ngraph::Node> data_node = std::make_shared<ngraph::op::CropIE> (data_output, axes, dim, offset);
data_node->set_friendly_name(slice->get_friendly_name());
new_ops.push_back(data_node);
if (!shrink_axis_mask.empty()) {
auto new_shape = std::make_shared<ngraph::opset1::Constant>(element::i64, ngraph::Shape{output_shape.size()},
output_shape);
- data_node = std::make_shared<ngraph::opset1::Reshape>(data_node, new_shape, true);
+ data_node = std::make_shared<ngraph::opset1::Reshape>(data_node->output(0), new_shape, true);
crop_data_node->set_friendly_name(slice->get_friendly_name() + "/Crop");
data_node->set_friendly_name(slice->get_friendly_name());
new_ops.push_back(data_node);
return false;
}
- auto data_node = tile->get_argument(0);
- auto tiles_node = std::dynamic_pointer_cast<ngraph::opset1::Constant> (tile->get_argument(1));
+ auto data_node = tile->input_value(0).get_node_shared_ptr();
+ auto tiles_node = std::dynamic_pointer_cast<ngraph::opset1::Constant> (tile->input_value(1).get_node_shared_ptr());
if (!data_node || !tiles_node) return false;
auto tiles = tiles_node->get_vector<int64_t>();
}
StaticShapeReshape::StaticShapeReshape(const std::shared_ptr<ngraph::opset3::Reshape>& reshape)
- : StaticShapeReshape(reshape->get_argument(0), reshape->get_argument(1), reshape->get_special_zero()) {
+ : StaticShapeReshape(reshape->input_value(0), reshape->input_value(1), reshape->get_special_zero()) {
}
void StaticShapeReshape::validate_and_infer_types() {
target->get_friendly_name(), target->get_type_info());
- const auto axes_const_node = ngraph::as_type_ptr<ngraph::opset3::Constant>(target->get_argument(1));
+ const auto axes_const_node = ngraph::as_type_ptr<ngraph::opset3::Constant>(target->input_value(1).get_node_shared_ptr());
VPU_THROW_UNLESS(axes_const_node,
"dynamicToStaticShapeReduce transformation for {} of type {} expects {} as input with index {}, but it has {} node of type {} instead",
target->get_friendly_name(), target->get_type_info(), ngraph::opset3::Constant::type_info, 1,
- target->get_argument(1)->get_friendly_name(), target->get_argument(1)->get_type_info());
+ target->input_value(1).get_node_shared_ptr()->get_friendly_name(), target->input_value(1).get_node_shared_ptr()->get_type_info());
const auto axes = axes_const_node->cast_vector<int64_t>();
namespace vpu {
void dynamicToStaticShapeReshape(std::shared_ptr<ngraph::Node> target) {
- const auto dsr = target->get_argument(0);
+ const auto dsr = target->input_value(0).get_node_shared_ptr();
VPU_THROW_UNLESS(ngraph::as_type_ptr<ngraph::vpu::op::DynamicShapeResolver>(dsr),
"DynamicToStaticShape transformation for {} of type {} expects {} as input with index {}",
target->get_friendly_name(), target->get_type_info(), ngraph::vpu::op::DynamicShapeResolver::type_info, 0);
const auto reshape = std::dynamic_pointer_cast<ngraph::opset3::Reshape>(target);
- const auto outShapeDescriptor = reshape->get_argument(1);
+ const auto outShapeDescriptor = reshape->input_value(1).get_node_shared_ptr();
const auto replacement = ngraph::as_type_ptr<ngraph::opset3::Constant>(outShapeDescriptor)
? reshape->clone_with_new_inputs(reshape->input_values())
namespace vpu {
void dynamicToStaticShapeTranspose(std::shared_ptr<ngraph::Node> target) {
- const auto dsr = target->get_argument(0);
+ const auto dsr = target->input_value(0).get_node_shared_ptr();
VPU_THROW_UNLESS(ngraph::as_type_ptr<ngraph::vpu::op::DynamicShapeResolver>(dsr),
"DynamicToStaticShape transformation for {} of type {} expects {} as input with index {}",
target->get_friendly_name(), target->get_type_info(), ngraph::vpu::op::DynamicShapeResolver::type_info, 0);
- const auto transposition = target->get_argument(1);
+ const auto transposition = target->input_value(1).get_node_shared_ptr();
VPU_THROW_UNLESS(ngraph::as_type_ptr<ngraph::opset3::Constant>(transposition),
"DynamicToStaticShape transformation for {] of type {} expects {} as input with index {}",
target->get_friendly_name(), target->get_type_info(), ngraph::opset3::Constant::type_info, 1);
const auto transpose = std::dynamic_pointer_cast<ngraph::opset3::Transpose>(target);
- const auto copied = transpose->copy_with_new_args(target->get_arguments());
+ const auto copied = transpose->clone_with_new_inputs(target->input_values());
const auto shape = dsr->input(1).get_source_output();
const auto axis = std::make_shared<ngraph::opset3::Constant>(
traverse_nodes({replacement}, set_prov_new_nodes, common_args);
}
-std::shared_ptr<Node> Node::get_argument(size_t index) const
-{
- NGRAPH_CHECK(
- index < m_inputs.size(), "index '", index, "' out of range in get_argument(size_t index)");
- return input_value(index).as_single_output_node();
-}
-
Node* Node::get_input_node_ptr(size_t index) const
{
NGRAPH_CHECK(
return input(i).get_source_output();
}
-NodeVector Node::get_arguments() const
-{
- NodeVector result;
- for (size_t i = 0; i < get_input_size(); ++i)
- {
- {
- result.push_back(get_argument(i));
- }
- }
- return result;
-}
-
const std::vector<std::shared_ptr<Node>>& Node::get_control_dependencies() const
{
return m_control_dependencies;
return m_outputs[0].get_tensor_ptr();
}
-const std::vector<descriptor::Input*>& Node::get_output_inputs(size_t i) const
-{
- NGRAPH_CHECK(
- i < m_outputs.size(), "index '", i, "' out of range in get_output_inputs(size_t i)");
- return m_outputs[i].get_inputs();
-}
-
std::set<Input<Node>> Node::get_output_target_inputs(size_t i) const
{
std::set<Input<Node>> result;
"use &node->output(i).get_tensor() instead; insert a check that the node has only one "
"output, or update calling code not to assume only one output");
- /// Returns the set of inputs using output i
- const std::vector<descriptor::Input*>& get_output_inputs(size_t i) const
- NGRAPH_DEPRECATED("use node->output(i).get_target_inputs() instead");
-
std::set<Input<Node>> get_output_target_inputs(size_t i) const;
/// Returns the number of inputs for the op
std::unordered_set<descriptor::Tensor*> liveness_new_list;
std::unordered_set<descriptor::Tensor*> liveness_free_list;
- virtual NodeVector get_arguments() const NGRAPH_DEPRECATED("Use input_values().");
- std::shared_ptr<Node> get_argument(size_t index) const
- NGRAPH_DEPRECATED("use input_value(i).");
-
Node* get_input_node_ptr(size_t index) const;
std::shared_ptr<Node> get_input_node_shared_ptr(size_t index) const;
Output<Node> get_input_source_output(size_t i) const;
void check_new_args_count(const Node* node, T new_args)
{
NODE_VALIDATION_CHECK(node,
- new_args.size() == node->get_arguments().size(),
+ new_args.size() == node->input_values().size(),
"copy_with_new_args() expected ",
- node->get_arguments().size(),
+ node->input_values().size(),
" argument",
- (node->get_arguments().size() == 1 ? "" : "s"),
+ (node->input_values().size() == 1 ? "" : "s"),
" but got ",
new_args.size());
}
return input_value(0);
}
-NodeVector op::GetOutputElement::get_arguments() const
-{
- return NodeVector{input_value(0).get_node_shared_ptr()};
-}
-
NodeVector op::get_output_elements(const shared_ptr<Node>& mon)
{
NodeVector goes(mon->get_output_size());
/// \return The index of the tuple element to get.
size_t get_n() const { return m_n; }
- NodeVector get_arguments() const override;
-
protected:
size_t m_n;
};
for (auto i = 0; i < groups; ++i)
{
- if (get_arguments().size() == 3)
+ if (input_values().size() == 3)
{
conv_groups.push_back(
std::make_shared<op::v1::ConvolutionBackpropData>(sliced_data[i],
const CoordinateDiff& get_padding_below() const { return m_padding_below; }
const CoordinateDiff& get_padding_above() const { return m_padding_above; }
const Strides& get_data_dilation_strides() const { return m_data_dilation_strides; }
- std::shared_ptr<Node> get_filters() { return get_argument(1); }
- std::shared_ptr<Node> get_data_batch() { return get_argument(0); }
+ std::shared_ptr<Node> get_filters() { return input_value(1).get_node_shared_ptr(); }
+ std::shared_ptr<Node> get_data_batch()
+ {
+ return input_value(0).get_node_shared_ptr();
+ }
const ngraph::element::Type& get_output_type() const { return m_output_type; }
const ngraph::AxisSet& get_input_axes() const { return m_input_axes; }
const ngraph::AxisSet& get_filter_axes() const { return m_filter_axes; }
const AxisSet& input1_axes = ngraph::AxisSet{},
const AxisSet& output_axes = ngraph::AxisSet{});
- std::shared_ptr<Node> get_input0() { return get_argument(0); }
- std::shared_ptr<Node> get_input1() { return get_argument(1); }
+ std::shared_ptr<Node> get_input0() { return input_value(0).get_node_shared_ptr(); }
+ std::shared_ptr<Node> get_input1() { return input_value(1).get_node_shared_ptr(); }
const ngraph::element::Type& get_output_type() const { return m_output_type; }
const ngraph::AxisSet& get_input0_axes() const { return m_input0_axes; }
const ngraph::AxisSet& get_input1_axes() const { return m_input1_axes; }
}
auto subgraph_outputs = decompose_op();
- auto subgraph = extract_subgraph(subgraph_outputs, get_arguments());
+ NodeVector nodes;
+ for (auto& val : input_values())
+ nodes.emplace_back(val.get_node_shared_ptr());
+ auto subgraph = extract_subgraph(subgraph_outputs, nodes);
validate_nodes_and_infer_types(subgraph);
size_t i = 0;
auto cnst = as_type_ptr<op::Constant>(broadcast->input_value(0).get_node_shared_ptr());
if (!cnst || cnst->get_shape().size() > 0 /*not a scalar*/)
{
- NGRAPH_DEBUG << broadcast->get_argument(0)->get_name() << " isn't a scalar constant";
+ NGRAPH_DEBUG << broadcast->input_value(0).get_node_shared_ptr()->get_name()
+ << " isn't a scalar constant";
return false;
}
return {nullptr};
}
- for (auto arg : n->get_arguments())
+ for (auto val : n->input_values())
{
+ auto arg = val.get_node_shared_ptr();
if (!matcher->match(arg))
{
NGRAPH_DEBUG << arg->get_name() << " doesn't match";
sconv->get_padding_below(),
sconv->get_padding_above(),
sconv->get_data_dilation_strides(),
- n->get_arguments().size());
+ n->input_values().size());
return move(new_conv);
}
{
bool check_self_concat_op(const std::shared_ptr<Node>& op)
{
- auto input_args = op->get_arguments();
- std::set<std::shared_ptr<Node>> input_args_set(input_args.begin(), input_args.end());
+ auto input_vals = op->input_values();
+ std::set<std::shared_ptr<Node>> input_args_set;
+ for (auto val : input_vals)
+ input_args_set.emplace(val.get_node_shared_ptr());
return (input_args_set.size() == 1);
}
for (auto& concat_pattern_vec : this->m_concat_pattern_vectors)
{
auto last_op_in_pattern_vec = concat_pattern_vec.back();
- if ((concat_op->get_argument(0) == last_op_in_pattern_vec) &&
+ if ((concat_op->input_value(0).get_node_shared_ptr() == last_op_in_pattern_vec) &&
(check_concat_has_no_fan_out(last_op_in_pattern_vec)))
{
concat_pattern_vec.push_back(concat_op);
auto concat_axis_vector = get_concatenation_axis_vector(bounded_concat_ops);
auto& first_bounded_concat = (*bounded_concat_ops.begin());
- auto driver_op = first_bounded_concat->get_argument(0);
+ auto driver_op = first_bounded_concat->input_value(0);
const Shape& input_shape = first_bounded_concat->get_input_shape(0);
auto scalarized_shape = scalarize_dim(concat_axis_vector, input_shape);
NGRAPH_CHECK(revalidate_and_ensure_static(quantize_op));
- auto args = quant_match->get_arguments();
auto scale = static_pointer_cast<op::Constant>(quant_match->get_input_node_shared_ptr(1));
auto offset = static_pointer_cast<op::Constant>(quant_match->get_input_node_shared_ptr(2));
auto pattern_map = m.get_pattern_map();
auto m_bn = static_pointer_cast<op::BatchNormInference>(m.get_match_root());
- auto m_conv = static_pointer_cast<op::Convolution>(m_bn->get_argument(2));
+ auto m_conv =
+ static_pointer_cast<op::Convolution>(m_bn->input_value(2).get_node_shared_ptr());
if (m_conv->get_users().size() > 1)
{
auto get_bcast_input = [](const shared_ptr<op::Broadcast>& bcast) {
if (bcast->get_input_shape(0).size() == 1)
{
- return bcast->get_argument(0);
+ return bcast->input_value(0).get_node_shared_ptr();
}
if (bcast->get_input_shape(0).size() == 2)
{
Shape bshape{bcast->get_input_shape(0)[1]};
return static_pointer_cast<Node>(
- make_shared<op::Reshape>(bcast->get_argument(0), AxisVector{0, 1}, bshape));
+ make_shared<op::Reshape>(bcast->input_value(0), AxisVector{0, 1}, bshape));
}
throw ngraph_error("Unexpected shape for bcast input");
};
Shape shape_w1{matched_broadcast_w1->get_shape()};
shape_w1[H] /= 2;
shape_w1[W] /= 2;
- auto new_broadcast_w1 =
- std::make_shared<op::Broadcast>(matched_broadcast_w1->get_argument(0),
- shape_w1,
- matched_broadcast_w1->get_broadcast_axes());
+ auto new_broadcast_w1 = std::make_shared<op::Broadcast>(
+ matched_broadcast_w1->input_value(0), shape_w1, matched_broadcast_w1->get_broadcast_axes());
return move(new_broadcast_w1);
}
auto pattern_map = m.get_pattern_map();
auto broadcast_m = static_pointer_cast<op::Broadcast>(m.get_match_root());
- auto reshape1_m = static_pointer_cast<op::Reshape>(broadcast_m->get_argument(0));
+ auto reshape1_m =
+ static_pointer_cast<op::Reshape>(broadcast_m->input_value(0).get_node_shared_ptr());
auto input_m = m.get_pattern_value_map()[input];
// it doesn't seem to make sense to support shapes : [0] or [1]
auto pattern_map = m.get_pattern_map();
auto reshape2_m = static_pointer_cast<op::Reshape>(m.get_match_root());
- auto softmax_m = static_pointer_cast<op::Softmax>(reshape2_m->get_argument(0));
- auto reshape1_m = static_pointer_cast<op::Reshape>(softmax_m->get_argument(0));
+ auto softmax_m =
+ static_pointer_cast<op::Softmax>(reshape2_m->input_value(0).get_node_shared_ptr());
+ auto reshape1_m =
+ static_pointer_cast<op::Reshape>(softmax_m->input_value(0).get_node_shared_ptr());
auto input_m = m.get_pattern_map()[input];
if (!reshape2_m->get_is_transpose() || !reshape1_m->get_is_transpose())
<< m.get_match_root()->get_name();
auto pattern_map = m.get_pattern_map();
- auto conv_m = as_type_ptr<op::Convolution>(m.get_match_root()->get_argument(0));
+ auto conv_m =
+ as_type_ptr<op::Convolution>(m.get_match_root()->input_value(0).get_node_shared_ptr());
if (conv_m == nullptr)
{
- conv_m = static_pointer_cast<op::Convolution>(m.get_match_root()->get_argument(1));
+ conv_m = static_pointer_cast<op::Convolution>(
+ m.get_match_root()->input_value(1).get_node_shared_ptr());
}
if (conv_m->get_shape().size() > 5 || conv_m->get_element_type() != element::f32)
}
}
- auto bias = bcast_m->get_argument(0);
+ auto bias = bcast_m->input_value(0).get_node_shared_ptr();
if (bias->get_shape().size() > 1)
{
NGRAPH_DEBUG << "mpattern = " << m.get_match_root()->get_name()
auto add_m = m.get_match_root();
auto pattern_map = m.get_pattern_map();
- auto conv_m = as_type_ptr<op::ConvolutionBias>(add_m->get_argument(1));
- auto add_input_m = add_m->get_argument(0);
+ auto conv_m = as_type_ptr<op::ConvolutionBias>(add_m->input_value(1).get_node_shared_ptr());
+ auto add_input_m = add_m->input_value(0).get_node_shared_ptr();
if (!conv_m)
{
- conv_m = static_pointer_cast<op::ConvolutionBias>(add_m->get_argument(0));
- add_input_m = add_m->get_argument(1);
+ conv_m = static_pointer_cast<op::ConvolutionBias>(
+ add_m->input_value(0).get_node_shared_ptr());
+ add_input_m = add_m->input_value(1).get_node_shared_ptr();
}
if (get_user_count(conv_m.get()) > 1)
}
// Run recursively until no more fused ops
- auto subgraph = extract_subgraph(subgraph_outputs, node->get_arguments());
+ NodeVector nodes;
+ for (auto& val : node->input_values())
+ nodes.emplace_back(val.get_node_shared_ptr());
+ auto subgraph = extract_subgraph(subgraph_outputs, nodes);
for (auto subgraph_node : subgraph)
{
run_on_node(subgraph_node);
if (auto goe = as_type<op::GetOutputElement>(fop_user->get_raw_pointer_node()))
{
Output<Node> goe_output = goe->get_as_output();
- if (goe_output.get_index() == i && !goe->get_output_inputs(0).empty())
+ if (goe_output.get_index() == i &&
+ !goe->output(0).get_target_inputs().empty())
{
// Replace GOE users
set<descriptor::Input*> goe_users{
auto autob = node->get_autob();
if (autob.m_type == op::AutoBroadcastType::NONE)
{
- rc = node->get_arguments();
+ for (auto& val : node->input_values())
+ rc.emplace_back(val.get_node_shared_ptr());
}
else if (autob.m_type == op::AutoBroadcastType::NUMPY)
{
// argument
auto broadcast_like = as_type_ptr<op::BroadcastLike>(node);
replace_node(node,
- make_shared<op::Broadcast>(broadcast_like->get_argument(0),
+ make_shared<op::Broadcast>(broadcast_like->input_value(0),
broadcast_like->get_broadcast_shape(),
broadcast_like->get_broadcast_axes()));
return true;
auto gop = pattern_map[op];
auto r2 = static_pointer_cast<op::Reshape>(m.get_match_root());
- auto r1 = static_pointer_cast<op::Reshape>(r2->get_argument(0));
+ auto r1 = static_pointer_cast<op::Reshape>(r2->input_value(0).get_node_shared_ptr());
if (gop->get_shape() != m.get_match_root()->get_shape())
{
return false;
}
- auto mdot = mtranspose->get_argument(0);
+ auto mdot = mtranspose->input_value(0).get_node_shared_ptr();
if (mdot->get_shape().size() != 2)
{
NGRAPH_DEBUG << "Dot has the wrong shape. " << vector_to_string(mdot->get_shape());
return false;
}
- auto arg0 = mdot->get_argument(0);
+ auto arg0 = mdot->input_value(0).get_node_shared_ptr();
if (arg0->get_shape().size() != 2)
{
NGRAPH_DEBUG << "Arg0 has the wrong shape. " << vector_to_string(arg0->get_shape());
auto reshape0_shape = Shape{arg0->get_shape().at(1), arg0->get_shape().at(0)};
auto reshape0 = make_shared<op::Reshape>(arg0, AxisVector{1, 0}, reshape0_shape);
- auto arg1 = mdot->get_argument(1);
+ auto arg1 = mdot->input_value(1).get_node_shared_ptr();
if (arg1->get_shape().size() != 2)
{
NGRAPH_DEBUG << "Arg1 has the wrong shape. " << vector_to_string(arg1->get_shape());
auto callback = [op, reshape_label](pattern::RecurrentMatcher& m) {
NGRAPH_DEBUG << "In callback for construct_recurrent_reshape against node = "
- << reshape_label->get_argument(0)->get_name();
+ << reshape_label->input_value(0).get_node_shared_ptr()->get_name();
auto reshape_node_vector = m.get_bound_nodes_for_pattern(reshape_label);
// The bound node vector is in reverse order. It is convenient to have the
std::reverse(std::begin(reshape_node_vector), std::end(reshape_node_vector));
auto first_bound_reshape_op = reshape_node_vector.front();
- auto driver_op = first_bound_reshape_op->get_argument(0);
+ auto driver_op = first_bound_reshape_op->input_value(0);
auto last_bound_reshape_op = reshape_node_vector.back();
// Need to check if the user of the last bound op is a reshape since the last reshape is
}
auto first_reshape = as_type_ptr<op::Reshape>(sub_pattern.front());
- auto input_to_first_reshape = first_reshape->get_argument(0);
+ auto input_to_first_reshape = first_reshape->input_value(0);
auto last_reshape = as_type_ptr<op::Reshape>(sub_pattern.back());
auto new_input_order = first_reshape->get_input_order();
ss << reshape->get_name()
<< " ( axis order = " << ngraph::vector_to_string(reshape->get_input_order())
<< " , shape = " << vector_to_string(reshape->get_shape()) << " ) "
- << " , child = " << reshape->get_argument(0)->get_name();
+ << " , child = " << reshape->input_value(0).get_node_shared_ptr()->get_name();
return ss.str();
}
auto default_order = ngraph::get_default_order(r1->get_shape());
auto perm_r1 = apply_permutation(default_order, r1->get_input_order());
auto perm_r2 = apply_permutation(perm_r1, r2->get_input_order());
- auto rreshape = make_reshape(r2->get_argument(0), perm_r2, r2->get_shape());
+ auto rreshape =
+ make_reshape(r2->input_value(0).get_node_shared_ptr(), perm_r2, r2->get_shape());
NGRAPH_DEBUG << "Combining " << describe_reshape(r1) << " and " << describe_reshape(r2)
<< " into " << describe_reshape(rreshape);
return rreshape;
NGRAPH_DEBUG << "Removing reshape " << reshape->get_name();
if (!reshape->get_users().empty())
{
- ngraph::replace_node(reshape, reshape->get_argument(0));
+ ngraph::replace_node(reshape, reshape->input_value(0).get_node_shared_ptr());
}
}
Swimmer nsw{n->input(0), csw.reshape};
work_queue.push_back(nsw);
NGRAPH_DEBUG << "Propagating reshape " << describe_reshape(csw.reshape) << " for "
- << n->get_name() << " to " << n->get_argument(0);
+ << n->get_name() << " to " << n->input_value(0).get_node_shared_ptr();
}
else if (is_type<op::Broadcast>(n))
{
}
}
- auto broadcast_input = old_broadcast->get_argument(0);
+ auto broadcast_input = old_broadcast->input_value(0).get_node_shared_ptr();
if (!in_order)
{
AxisVector new_source_axes_sorted{new_source_axes};
return;
}
- for (size_t i = 0; i < n->get_arguments().size(); i++)
+ for (size_t i = 0; i < n->input_values().size(); i++)
{
// materialize all pending reshapes, flush pending reshapes
- auto arg = n->get_argument(i);
+ auto arg = n->input_value(i).get_node_shared_ptr();
if (reorders.count(arg) != 0)
{
auto arg_reshape = reorders.at(arg);
set<shared_ptr<Node>>& reshapes_to_delete)
{
NGRAPH_DEBUG << "Sinking Reshape :" << describe_reshape(reshape);
- auto orig_reshape = reorders.at(reshape->get_argument(0));
+ auto orig_reshape = reorders.at(reshape->input_value(0).get_node_shared_ptr());
// 1) Not a Transpose or 2) Rank changing operation.
if ((reshape->get_output_shape(0).size() != reshape->get_input_order().size()) ||
(!reshape->get_is_transpose()))
ReshapeMap& reorders,
set<shared_ptr<Node>>& /* reshapes_to_delete */)
{
- auto arg_reshape = read_reshapemap(reorders, n->get_argument(0));
+ auto arg_reshape = read_reshapemap(reorders, n->input_value(0).get_node_shared_ptr());
NGRAPH_DEBUG << "Propagating " << describe_reshape(arg_reshape) << " for " << n->get_name();
write_reshapemap(reorders, n, arg_reshape);
}
ReshapeMap& reorders,
set<shared_ptr<Node>>& reshapes_to_delete)
{
- auto left = binary->get_argument(0);
- auto right = binary->get_argument(1);
+ auto left = binary->input_value(0).get_node_shared_ptr();
+ auto right = binary->input_value(1).get_node_shared_ptr();
if (reorders.at(left)->get_input_order() == reorders.at(right)->get_input_order())
{
ReshapeMap& reorders,
set<shared_ptr<Node>>& /* reshapes_to_delete */)
{
- auto arg_reshape = reorders.at(n->get_argument(0));
+ auto arg_reshape = reorders.at(n->input_value(0).get_node_shared_ptr());
auto order = arg_reshape->get_input_order();
// we need the correct input shape to produce the right output shape
auto new_upper = ngraph::apply_permutation(n->get_upper_bounds(), def_order);
auto new_strides = ngraph::apply_permutation(n->get_strides(), def_order);
auto new_slice = make_shared<op::Slice>(dummy_correct_shape, new_lower, new_upper, new_strides);
- ngraph::replace_node(dummy_correct_shape, n->get_argument(0));
+ ngraph::replace_node(dummy_correct_shape, n->input_value(0).get_node_shared_ptr());
NGRAPH_DEBUG << "Replacing " << n->get_name() << " with " << new_slice->get_name();
ngraph::replace_node(n, new_slice);
ReshapeMap& reorders,
set<shared_ptr<Node>>& /* reshapes_to_delete */)
{
- auto arg_reshape = reorders.at(n->get_argument(0));
+ auto arg_reshape = reorders.at(n->input_value(0).get_node_shared_ptr());
auto order = arg_reshape->get_input_order();
// we need the correct input shape to produce the right output shape
// we are going to create a label of the right input shape,
auto new_lower = ngraph::apply_permutation(n->get_padding_below(), def_order);
auto new_upper = ngraph::apply_permutation(n->get_padding_above(), def_order);
- auto new_pad = make_shared<op::Pad>(
- dummy_correct_shape, n->get_argument(1), new_lower, new_upper, n->get_pad_mode());
- ngraph::replace_node(dummy_correct_shape, n->get_argument(0));
+ auto new_pad = make_shared<op::Pad>(dummy_correct_shape,
+ n->input_value(1).get_node_shared_ptr(),
+ new_lower,
+ new_upper,
+ n->get_pad_mode());
+ ngraph::replace_node(dummy_correct_shape, n->input_value(0).get_node_shared_ptr());
NGRAPH_DEBUG << "Replacing " << n->get_name() << " with " << new_pad->get_name();
ngraph::replace_node(n, new_pad);
auto new_reshape = make_reshape(new_pad, order, n->get_shape());
ReshapeMap& reorders,
set<shared_ptr<Node>>& /* reshapes_to_delete */)
{
- auto arg_reshape = reorders.at(quantize->get_argument(0));
+ auto arg_reshape = reorders.at(quantize->input_value(0).get_node_shared_ptr());
AxisSet axes_in_def_order =
get_quantization_axes_in_default_order(arg_reshape, quantize->get_axes());
- auto new_quantize = make_shared<op::Quantize>(quantize->get_argument(0),
- quantize->get_argument(1),
- quantize->get_argument(2),
+ auto new_quantize = make_shared<op::Quantize>(quantize->input_value(0),
+ quantize->input_value(1),
+ quantize->input_value(2),
quantize->get_element_type(),
axes_in_def_order,
quantize->get_round_mode());
ReshapeMap& reorders,
set<shared_ptr<Node>>& reshapes_to_delete)
{
- auto arg_reshape = reorders.at(n->get_argument(0));
+ auto arg_reshape = reorders.at(n->input_value(0).get_node_shared_ptr());
auto order = arg_reshape->get_input_order();
// we need the correct input shape to produce the right output shape
// we are going to create a label of the right input shape,
for (size_t i = 1; i < n->get_input_size(); i++)
{
- auto iarg_reshape = reorders.at(n->get_argument(i));
+ auto iarg_reshape = reorders.at(n->input_value(i).get_node_shared_ptr());
auto iorder = iarg_reshape->get_input_order();
if (iorder != order)
{
// put back the original arguments
for (size_t i = 0; i < new_concat->get_input_size(); i++)
{
- ngraph::replace_node(new_args.at(i), n->get_argument(i));
+ ngraph::replace_node(new_args.at(i), n->input_value(i).get_node_shared_ptr());
}
NGRAPH_DEBUG << "Replacing " << n->get_name() << " with " << new_concat->get_name();
ngraph::replace_node(n, new_concat);
ReshapeMap& reorders,
set<shared_ptr<Node>>& /* reshapes_to_delete */)
{
- auto arg_reshape = reorders.at(dequantize->get_argument(0));
+ auto arg_reshape = reorders.at(dequantize->input_value(0).get_node_shared_ptr());
AxisSet axes_in_def_order =
get_quantization_axes_in_default_order(arg_reshape, dequantize->get_axes());
- auto new_dequantize = make_shared<op::Dequantize>(dequantize->get_argument(0),
- dequantize->get_argument(1),
- dequantize->get_argument(2),
+ auto new_dequantize = make_shared<op::Dequantize>(dequantize->input_value(0),
+ dequantize->input_value(1),
+ dequantize->input_value(2),
dequantize->get_element_type(),
axes_in_def_order);
// significant time increase on graphs with many slice ops,
// so for now we are removing "true" check and let backend
// handle reshape sinking for slice operation.
- if (slice->get_argument(0)->get_users().size() == 1)
+ if (slice->input_value(0).get_node_shared_ptr()->get_users().size() == 1)
{
sink_slice(slice, reorders, reshapes_to_delete);
}
for (auto r : results)
{
NGRAPH_CHECK(r->get_shape() == r->get_input_shape(0) &&
- r->get_element_type() == r->get_argument(0)->get_element_type(),
+ r->get_element_type() ==
+ r->input_value(0).get_node_shared_ptr()->get_element_type(),
" op::Result = ",
*r,
", Arg = ",
- *r->get_argument(0));
+ *r->input_value(0).get_node_shared_ptr());
}
// STEP 3: fix wrong shape info wholesale
if (auto concat = as_type_ptr<op::Concat>(n))
{
OutputVector non_zero_dim_args;
- for (auto arg : concat->get_arguments())
+ for (auto arg : concat->input_values())
{
if (!has_zero_dim(arg))
{
static std::shared_ptr<T> unique_match(std::shared_ptr<Node> node)
{
std::shared_ptr<T> matched;
- for (auto arg : node->get_arguments())
+ for (auto arg : node->input_values())
{
- if (auto t_casted = as_type_ptr<T>(arg))
+ if (auto t_casted = as_type_ptr<T>(arg.get_node_shared_ptr()))
{
if (matched)
{
auto results = f->get_results();
for (size_t i = 0; i < results.size(); i++)
{
- ASSERT_EQ(expected.at(i),
- (results.at(i)->get_argument(0)->input_values().size()
- ? results.at(i)->get_argument(0)->get_argument(0)
- : results.at(i)->get_argument(0)));
+ ASSERT_EQ(
+ expected.at(i),
+ (results.at(i)->input_value(0).get_node_shared_ptr()->input_values().size()
+ ? results.at(i)
+ ->input_value(0)
+ .get_node_shared_ptr()
+ ->input_value(0)
+ .get_node_shared_ptr()
+ : results.at(i)->input_value(0).get_node_shared_ptr()));
}
}
}
auto results = f->get_results();
for (size_t i = 0; i < results.size(); i++)
{
- ASSERT_EQ(expected.at(i),
- (results.at(i)->get_argument(0)->input_values().size()
- ? results.at(i)->get_argument(0)->get_argument(0)
- : results.at(i)->get_argument(0)));
+ ASSERT_EQ(
+ expected.at(i),
+ (results.at(i)->input_value(0).get_node_shared_ptr()->input_values().size()
+ ? results.at(i)
+ ->input_value(0)
+ .get_node_shared_ptr()
+ ->input_value(0)
+ .get_node_shared_ptr()
+ : results.at(i)->input_value(0).get_node_shared_ptr()));
}
}
}
for (size_t i = 0; i < results.size(); i++)
{
ASSERT_EQ(expected.at(i),
- (results.at(i)->get_argument(0)->input_values().size()
- ? results.at(i)->get_argument(0)->get_argument(0)
- : results.at(i)->get_argument(0)));
+ (results.at(i)->input_value(0).get_node_shared_ptr()->input_values().size()
+ ? results.at(i)
+ ->input_value(0)
+ .get_node_shared_ptr()
+ ->input_value(0)
+ .get_node_shared_ptr()
+ : results.at(i)->input_value(0).get_node_shared_ptr()));
}
}
for (size_t i = 0; i < results.size(); i++)
{
ASSERT_EQ(expected.at(i),
- (results.at(i)->get_argument(0)->input_values().size()
- ? results.at(i)->get_argument(0)->get_argument(0)
- : results.at(i)->get_argument(0)));
+ (results.at(i)->input_value(0).get_node_shared_ptr()->input_values().size()
+ ? results.at(i)
+ ->input_value(0)
+ .get_node_shared_ptr()
+ ->input_value(0)
+ .get_node_shared_ptr()
+ : results.at(i)->input_value(0).get_node_shared_ptr()));
}
}
for (size_t i = 0; i < results.size(); i++)
{
ASSERT_EQ(expected.at(i),
- (results.at(i)->get_argument(0)->input_values().size()
- ? results.at(i)->get_argument(0)->get_argument(0)
- : results.at(i)->get_argument(0)));
+ (results.at(i)->input_value(0).get_node_shared_ptr()->input_values().size()
+ ? results.at(i)
+ ->input_value(0)
+ .get_node_shared_ptr()
+ ->input_value(0)
+ .get_node_shared_ptr()
+ : results.at(i)->input_value(0).get_node_shared_ptr()));
}
}
for (size_t i = 0; i < results.size(); i++)
{
ASSERT_EQ(expected.at(i),
- (results.at(i)->get_argument(0)->input_values().size()
- ? results.at(i)->get_argument(0)->get_argument(0)
- : results.at(i)->get_argument(0)));
+ (results.at(i)->input_value(0).get_node_shared_ptr()->input_values().size()
+ ? results.at(i)
+ ->input_value(0)
+ .get_node_shared_ptr()
+ ->input_value(0)
+ .get_node_shared_ptr()
+ : results.at(i)->input_value(0).get_node_shared_ptr()));
}
}
for (size_t i = 0; i < results.size(); i++)
{
ASSERT_EQ(expected.at(i),
- (results.at(i)->get_argument(0)->input_values().size()
- ? results.at(i)->get_argument(0)->get_argument(0)
- : results.at(i)->get_argument(0)));
+ (results.at(i)->input_value(0).get_node_shared_ptr()->input_values().size()
+ ? results.at(i)
+ ->input_value(0)
+ .get_node_shared_ptr()
+ ->input_value(0)
+ .get_node_shared_ptr()
+ : results.at(i)->input_value(0).get_node_shared_ptr()));
}
}
for (size_t i = 0; i < results.size(); i++)
{
ASSERT_EQ(expected.at(i),
- (results.at(i)->get_argument(0)->input_values().size()
- ? results.at(i)->get_argument(0)->get_argument(0)
- : results.at(i)->get_argument(0)));
+ (results.at(i)->input_value(0).get_node_shared_ptr()->input_values().size()
+ ? results.at(i)
+ ->input_value(0)
+ .get_node_shared_ptr()
+ ->input_value(0)
+ .get_node_shared_ptr()
+ : results.at(i)->input_value(0).get_node_shared_ptr()));
}
}
ParameterVector{a, b, c});
pass_manager.run_passes(f);
- ASSERT_TRUE(ngraph::is_zero(f->get_results().at(2)->get_argument(0)->get_argument(0)));
- ASSERT_EQ(f->get_results().at(4)->get_argument(0)->get_argument(0), b);
+ ASSERT_TRUE(ngraph::is_zero(f->get_results()
+ .at(2)
+ ->input_value(0)
+ .get_node_shared_ptr()
+ ->input_value(0)
+ .get_node_shared_ptr()));
+ ASSERT_EQ(f->get_results()
+ .at(4)
+ ->input_value(0)
+ .get_node_shared_ptr()
+ ->input_value(0)
+ .get_node_shared_ptr(),
+ b);
}
TEST(algebraic_simplification, DISABLED_zero_plus_zero_commutativity_v1)
ParameterVector{a, b, c});
pass_manager.run_passes(f);
- ASSERT_TRUE(ngraph::is_zero(f->get_results().at(2)->get_argument(0)->get_argument(0)));
- ASSERT_EQ(f->get_results().at(4)->get_argument(0)->get_argument(0), b);
+ ASSERT_TRUE(ngraph::is_zero(f->get_results()
+ .at(2)
+ ->input_value(0)
+ .get_node_shared_ptr()
+ ->input_value(0)
+ .get_node_shared_ptr()));
+ ASSERT_EQ(f->get_results()
+ .at(4)
+ ->input_value(0)
+ .get_node_shared_ptr()
+ ->input_value(0)
+ .get_node_shared_ptr(),
+ b);
}
TEST(algebraic_simplification, zero_multiply_zero_one)
ParameterVector{a, b, c});
pass_manager.run_passes(f);
- ASSERT_TRUE(ngraph::is_zero(f->get_results().at(2)->get_argument(0)->get_argument(0)));
- ASSERT_TRUE(ngraph::is_zero(f->get_results().at(4)->get_argument(0)->get_argument(0)));
+ ASSERT_TRUE(ngraph::is_zero(f->get_results()
+ .at(2)
+ ->input_value(0)
+ .get_node_shared_ptr()
+ ->input_value(0)
+ .get_node_shared_ptr()));
+ ASSERT_TRUE(ngraph::is_zero(f->get_results()
+ .at(4)
+ ->input_value(0)
+ .get_node_shared_ptr()
+ ->input_value(0)
+ .get_node_shared_ptr()));
}
TEST(algebraic_simplification, DISABLED_zero_multiply_zero_one_v1)
ParameterVector{a, b, c});
pass_manager.run_passes(f);
- ASSERT_TRUE(ngraph::is_zero(f->get_results().at(2)->get_argument(0)->get_argument(0)));
- ASSERT_TRUE(ngraph::is_zero(f->get_results().at(4)->get_argument(0)->get_argument(0)));
+ ASSERT_TRUE(ngraph::is_zero(f->get_results()
+ .at(2)
+ ->input_value(0)
+ .get_node_shared_ptr()
+ ->input_value(0)
+ .get_node_shared_ptr()));
+ ASSERT_TRUE(ngraph::is_zero(f->get_results()
+ .at(4)
+ ->input_value(0)
+ .get_node_shared_ptr()
+ ->input_value(0)
+ .get_node_shared_ptr()));
}
TEST(algebraic_simplification, add_negative_tests)
auto results = f->get_results();
for (size_t i = 0; i < results.size(); i++)
{
- ASSERT_EQ(expected.at(i), results.at(i)->get_argument(0));
+ ASSERT_EQ(expected.at(i), results.at(i)->input_value(0).get_node_shared_ptr());
}
}
auto results = f->get_results();
for (size_t i = 0; i < results.size(); i++)
{
- ASSERT_EQ(expected.at(i), results.at(i)->get_argument(0));
+ ASSERT_EQ(expected.at(i), results.at(i)->input_value(0).get_node_shared_ptr());
}
}
auto results = f->get_results();
for (size_t i = 0; i < results.size(); i++)
{
- ASSERT_EQ(expected.at(i), results.at(i)->get_argument(0));
+ ASSERT_EQ(expected.at(i), results.at(i)->input_value(0).get_node_shared_ptr());
}
}
auto results = f->get_results();
for (size_t i = 0; i < results.size(); i++)
{
- ASSERT_EQ(expected.at(i), results.at(i)->get_argument(0));
+ ASSERT_EQ(expected.at(i), results.at(i)->input_value(0).get_node_shared_ptr());
}
}
auto f = std::make_shared<Function>(ngraph::NodeVector{prod_fconst1}, ParameterVector{});
pass_manager.run_passes(f);
- auto new_broadcast = as_type_ptr<op::Broadcast>(f->get_results().at(0)->get_argument(0));
+ auto new_broadcast =
+ as_type_ptr<op::Broadcast>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_broadcast);
- auto new_const = as_type_ptr<op::Constant>(new_broadcast->get_argument(0));
+ auto new_const = as_type_ptr<op::Constant>(new_broadcast->input_value(0).get_node_shared_ptr());
auto values = new_const->get_vector<double>();
ASSERT_EQ(values.size(), 1);
ASSERT_EQ(values.at(0), 32);
auto f = std::make_shared<Function>(ngraph::NodeVector{prod_fconst1}, ParameterVector{});
pass_manager.run_passes(f);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values = new_const->get_vector<double>();
ASSERT_EQ(values.size(), 1);
auto f = std::make_shared<Function>(ngraph::NodeVector{prod_fconst1}, ParameterVector{});
pass_manager.run_passes(f);
- auto f_prod = f->get_results().at(0)->get_argument(0);
+ auto f_prod = f->get_results().at(0)->input_value(0).get_node_shared_ptr();
ASSERT_EQ(f_prod, prod_fconst1);
}
auto f = std::make_shared<Function>(ngraph::NodeVector{sum_fconst1}, ParameterVector{});
pass_manager.run_passes(f);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values = new_const->get_vector<double>();
ASSERT_EQ(values.size(), 1);
auto f = std::make_shared<Function>(ngraph::NodeVector{sum_fconst1}, ParameterVector{});
pass_manager.run_passes(f);
- auto new_broadcast = as_type_ptr<op::Broadcast>(f->get_results().at(0)->get_argument(0));
+ auto new_broadcast =
+ as_type_ptr<op::Broadcast>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_broadcast);
- auto new_const = as_type_ptr<op::Constant>(new_broadcast->get_argument(0));
+ auto new_const = as_type_ptr<op::Constant>(new_broadcast->input_value(0).get_node_shared_ptr());
auto values = new_const->get_vector<double>();
ASSERT_EQ(values.size(), 1);
ASSERT_EQ(values.at(0), 5);
auto f = std::make_shared<Function>(ngraph::NodeVector{sum_fconst1}, ParameterVector{});
pass_manager.run_passes(f);
- auto f_sum = f->get_results().at(0)->get_argument(0);
+ auto f_sum = f->get_results().at(0)->input_value(0).get_node_shared_ptr();
ASSERT_EQ(f_sum, sum_fconst1);
}
auto f = std::make_shared<Function>(ngraph::NodeVector{concat}, ParameterVector{a});
pass_manager.run_passes(f);
- ASSERT_TRUE(is_type<op::Reshape>(f->get_results().at(0)->get_argument(0)));
+ ASSERT_TRUE(is_type<op::Reshape>(f->get_results().at(0)->input_value(0).get_node_shared_ptr()));
}
TEST(algebraic_simplification, concat_slice)
auto f = std::make_shared<Function>(ngraph::NodeVector{concat}, ParameterVector{a});
pass_manager.run_passes(f);
- ASSERT_EQ(f->get_results().at(0)->get_argument(0), a);
+ ASSERT_EQ(f->get_results().at(0)->input_value(0).get_node_shared_ptr(), a);
}
TEST(algebraic_simplification, concat_parameter_slice)
auto f = std::make_shared<Function>(ngraph::NodeVector{concat}, ParameterVector{a});
pass_manager.run_passes(f);
- ASSERT_EQ(f->get_results().at(0)->get_argument(0), a);
+ ASSERT_EQ(f->get_results().at(0)->input_value(0).get_node_shared_ptr(), a);
}
TEST(algebraic_simplification, concat_parameter_slices_reversed)
auto f = std::make_shared<Function>(ngraph::NodeVector{concat}, ParameterVector{a});
pass_manager.run_passes(f);
- ASSERT_EQ(f->get_results().at(0)->get_argument(0), concat);
+ ASSERT_EQ(f->get_results().at(0)->input_value(0).get_node_shared_ptr(), concat);
}
TEST(algebraic_simplification, concat_parameter_slices_element_count)
auto f = std::make_shared<Function>(ngraph::NodeVector{concat}, ParameterVector{a});
pass_manager.run_passes(f);
- ASSERT_EQ(f->get_results().at(0)->get_argument(0), concat);
+ ASSERT_EQ(f->get_results().at(0)->input_value(0).get_node_shared_ptr(), concat);
}
TEST(algebraic_simplification, concat_parameter_non_uniform_slices)
auto f = std::make_shared<Function>(ngraph::NodeVector{concat}, ParameterVector{a});
pass_manager.run_passes(f);
- ASSERT_EQ(f->get_results().at(0)->get_argument(0), concat);
+ ASSERT_EQ(f->get_results().at(0)->input_value(0).get_node_shared_ptr(), concat);
}
TEST(algebraic_simplification, concat_different_inputs)
auto f = std::make_shared<Function>(ngraph::NodeVector{concat}, ParameterVector{a});
pass_manager.run_passes(f);
- ASSERT_EQ(f->get_results().at(0)->get_argument(0), concat);
+ ASSERT_EQ(f->get_results().at(0)->input_value(0).get_node_shared_ptr(), concat);
}
TEST(algebraic_simplification, log_neg_neg)
auto f = std::make_shared<Function>(ngraph::NodeVector{neg4}, ParameterVector{a, b});
pass_manager.run_passes(f);
- auto sub = as_type_ptr<op::Subtract>(neg_inner->get_argument(0));
+ auto sub = as_type_ptr<op::Subtract>(neg_inner->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(sub != nullptr);
- ASSERT_EQ(sub->get_argument(0), a);
- auto new_log = as_type_ptr<op::Log>(sub->get_argument(1));
+ ASSERT_EQ(sub->input_value(0).get_node_shared_ptr(), a);
+ auto new_log = as_type_ptr<op::Log>(sub->input_value(1).get_node_shared_ptr());
ASSERT_TRUE(new_log != nullptr);
- ASSERT_EQ(new_log->get_argument(0), b);
+ ASSERT_EQ(new_log->input_value(0).get_node_shared_ptr(), b);
}
TEST(algebraic_simplification, log_no_exp)
auto f = std::make_shared<Function>(ngraph::NodeVector{neg4}, ParameterVector{a, b});
pass_manager.run_passes(f);
- ASSERT_EQ(neg_inner->get_argument(0), log_div);
+ ASSERT_EQ(neg_inner->input_value(0).get_node_shared_ptr(), log_div);
}
TEST(algebraic_simplification, log_no_divide)
auto f = std::make_shared<Function>(ngraph::NodeVector{neg4}, ParameterVector{a, b});
pass_manager.run_passes(f);
- ASSERT_EQ(neg_inner->get_argument(0), log_mul);
+ ASSERT_EQ(neg_inner->input_value(0).get_node_shared_ptr(), log_mul);
}
TEST(algebraic_simplification, pass_property)
ASSERT_EQ(count_ops_of_type<op::v1::Gather>(baseline_f), 1) << casename;
- auto last_node = optimized_f->get_results()[0]->get_argument(0);
+ auto last_node = optimized_f->get_results()[0]->input_value(0).get_node_shared_ptr();
if (is_scalar_index)
{
ASSERT_EQ(count_ops_of_type<op::v3::ShapeOf>(optimized_f), 1) << casename;
ASSERT_EQ(count_ops_of_type<op::v1::Gather>(optimized_f), 1) << casename;
- EXPECT_TRUE(as_type_ptr<op::v1::Gather>(last_node->get_argument(0))) << casename;
+ EXPECT_TRUE(
+ as_type_ptr<op::v1::Gather>(last_node->input_value(0).get_node_shared_ptr()))
+ << casename;
}
else
{
ASSERT_EQ(count_ops_of_type<op::v0::Concat>(optimized_f), 1) << casename;
- EXPECT_TRUE(as_type_ptr<op::v0::Concat>(last_node->get_argument(0))) << casename;
+ EXPECT_TRUE(
+ as_type_ptr<op::v0::Concat>(last_node->input_value(0).get_node_shared_ptr()))
+ << casename;
}
};
auto broadcast_1 = make_shared<op::Broadcast>(arg3, Shape{10, 32, 7}, AxisSet{0});
auto b1 = make_shared<op::Broadcast>(arg3, Shape{10, 32, 7}, AxisSet{0});
auto dot = make_shared<op::Dot>(arg2, arg0);
- ASSERT_EQ(dot->get_arguments()[0], arg2);
- ASSERT_EQ(dot->get_arguments()[1], arg0);
+ ASSERT_EQ(dot->input_value(0).get_node_shared_ptr(), arg2);
+ ASSERT_EQ(dot->input_value(1).get_node_shared_ptr(), arg0);
auto cluster_0 = make_shared<Function>(dot, ParameterVector{arg0, arg1, arg2, arg3});
- ASSERT_EQ(cluster_0->get_output_op(0)->get_argument(0), dot);
+ ASSERT_EQ(cluster_0->get_output_op(0)->input_value(0).get_node_shared_ptr(), dot);
}
// Check node comparisons
ASSERT_EQ(float0->get_element_type(), element::f32);
ASSERT_EQ(float0->get_shape(), Shape{});
auto d = make_shared<op::Dot>(float0, float0);
- ASSERT_EQ(d->get_arguments().at(0), float0);
- ASSERT_EQ(d->get_arguments().at(1), float0);
+ ASSERT_EQ(d->input_values().at(0).get_node_shared_ptr(), float0);
+ ASSERT_EQ(d->input_values().at(1).get_node_shared_ptr(), float0);
vector<int32_t> int32{3};
auto int32_0 = make_shared<op::Constant>(element::i32, Shape{}, int32);
ASSERT_EQ(float0->get_element_type(), element::f32);
ASSERT_EQ(float0->get_shape(), shape);
auto d = make_shared<op::Add>(float0, float0);
- ASSERT_EQ(d->get_arguments().at(0), float0);
- ASSERT_EQ(d->get_arguments().at(1), float0);
+ ASSERT_EQ(d->input_values().at(0).get_node_shared_ptr(), float0);
+ ASSERT_EQ(d->input_values().at(1).get_node_shared_ptr(), float0);
Shape ishape{3, 5};
vector<int32_t> idata(shape_size(ishape), 0);
auto broadcast_1 = make_shared<op::Broadcast>(arg3, Shape{10, 32, 7}, AxisSet{0});
auto b1 = make_shared<op::Broadcast>(arg3, Shape{10, 32, 7}, AxisSet{0});
auto dot = make_shared<op::Dot>(arg2, arg0);
- ASSERT_EQ(dot->get_arguments()[0], arg2);
- ASSERT_EQ(dot->get_arguments()[1], arg0);
+ ASSERT_EQ(dot->input_values()[0].get_node_shared_ptr(), arg2);
+ ASSERT_EQ(dot->input_values()[1].get_node_shared_ptr(), arg0);
try
{
auto f = make_shared<Function>(dot, ParameterVector{arg0, arg1, arg3});
template <typename T>
static std::vector<T> get_result_constant(std::shared_ptr<Function> f, size_t pos)
{
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(pos)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(pos)->input_value(0).get_node_shared_ptr());
return new_const->cast_vector<T>();
}
EXPECT_EQ(count_ops_of_type<op::Constant>(f), 1);
ASSERT_EQ(f->get_results().size(), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results()[0]->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results()[0]->input_value(0).get_node_shared_ptr());
EXPECT_TRUE(new_const);
auto values_out = new_const->get_vector<float>();
EXPECT_EQ(count_ops_of_type<op::Constant>(f), 1);
ASSERT_EQ(f->get_results().size(), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results()[0]->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results()[0]->input_value(0).get_node_shared_ptr());
EXPECT_TRUE(new_const);
auto values_out = new_const->get_vector<float>();
EXPECT_EQ(count_ops_of_type<op::Constant>(f), 1);
ASSERT_EQ(f->get_results().size(), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results()[0]->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results()[0]->input_value(0).get_node_shared_ptr());
EXPECT_TRUE(new_const);
auto values_out = new_const->get_vector<float>();
ASSERT_EQ(count_ops_of_type<op::Squeeze>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
ASSERT_EQ(new_const->get_shape(), shape_out);
ASSERT_EQ(count_ops_of_type<op::Unsqueeze>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
ASSERT_EQ(new_const->get_shape(), shape_out);
ASSERT_EQ(count_ops_of_type<op::Reshape>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<float>();
ASSERT_EQ(count_ops_of_type<op::Reshape>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<double>();
ASSERT_EQ(count_ops_of_type<op::Broadcast>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<int>();
ASSERT_EQ(count_ops_of_type<op::v1::Broadcast>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<int32_t>();
ASSERT_EQ(count_ops_of_type<op::v1::Broadcast>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<int32_t>();
ASSERT_EQ(count_ops_of_type<op::v1::Broadcast>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<int32_t>();
ASSERT_EQ(count_ops_of_type<op::Pad>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<int>();
ASSERT_EQ(count_ops_of_type<op::Dequantize>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<output_c_type>();
ASSERT_EQ(count_ops_of_type<op::Quantize>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<output_c_type>();
ASSERT_EQ(count_ops_of_type<op::Convert>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
ASSERT_EQ(new_const->get_output_element_type(0), element::u64);
auto values_out = new_const->get_vector<uint64_t>();
ASSERT_EQ(count_ops_of_type<op::v0::ShapeOf>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
ASSERT_EQ(new_const->get_output_element_type(0), element::i64);
auto values_out = new_const->get_vector<int64_t>();
ASSERT_EQ(count_ops_of_type<op::v3::ShapeOf>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
ASSERT_EQ(new_const->get_output_element_type(0), element::i64);
auto values_out = new_const->get_vector<int64_t>();
ASSERT_EQ(count_ops_of_type<op::v3::ShapeOf>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
ASSERT_EQ(new_const->get_output_element_type(0), element::i32);
auto values_out = new_const->get_vector<int32_t>();
ASSERT_EQ(count_ops_of_type<op::Concat>(f), 1);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 8);
- auto result_as_concat = as_type_ptr<op::Concat>(f->get_results().at(0)->get_argument(0));
+ auto result_as_concat =
+ as_type_ptr<op::Concat>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(result_as_concat);
ASSERT_EQ(result_as_concat->get_output_shape(0), Shape{7});
}
ASSERT_EQ(count_ops_of_type<op::Concat>(f), 1);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 8);
- auto result_as_concat = as_type_ptr<op::Concat>(f->get_results().at(0)->get_argument(0));
+ auto result_as_concat =
+ as_type_ptr<op::Concat>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(result_as_concat);
ASSERT_EQ(result_as_concat->get_output_shape(0), Shape{7});
ASSERT_EQ(result_as_concat->get_output_element_type(0), element::i64);
ASSERT_EQ(count_ops_of_type<op::Concat>(f), 1);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 8);
- auto result_as_concat = as_type_ptr<op::Concat>(f->get_results().at(0)->get_argument(0));
+ auto result_as_concat =
+ as_type_ptr<op::Concat>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(result_as_concat);
ASSERT_EQ(result_as_concat->get_output_shape(0), Shape{7});
ASSERT_EQ(result_as_concat->get_output_element_type(0), element::i32);
ASSERT_EQ(count_ops_of_type<op::Concat>(f), 1);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 8);
- auto result_as_concat = as_type_ptr<op::Concat>(f->get_results().at(0)->get_argument(0));
+ auto result_as_concat =
+ as_type_ptr<op::Concat>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(result_as_concat);
ASSERT_EQ(result_as_concat->get_output_shape(0), Shape{7});
}
ASSERT_EQ(count_ops_of_type<op::Concat>(f), 1);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 8);
- auto result_as_concat = as_type_ptr<op::Concat>(f->get_results().at(0)->get_argument(0));
+ auto result_as_concat =
+ as_type_ptr<op::Concat>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(result_as_concat);
ASSERT_EQ(result_as_concat->get_output_shape(0), Shape{7});
}
ASSERT_EQ(count_ops_of_type<op::Reverse>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<int32_t>();
ASSERT_EQ(count_ops_of_type<op::Product>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<int32_t>();
ASSERT_EQ(count_ops_of_type<op::v1::ReduceProd>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
ASSERT_EQ(new_const->get_shape(), output_shape);
ASSERT_EQ(count_ops_of_type<op::v1::ReduceProd>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
ASSERT_EQ(new_const->get_shape(), output_shape);
ASSERT_EQ(count_ops_of_type<op::Sum>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<int32_t>();
ASSERT_EQ(count_ops_of_type<op::v1::ReduceSum>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
ASSERT_EQ(new_const->get_shape(), output_shape);
ASSERT_EQ(count_ops_of_type<op::v1::ReduceSum>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
ASSERT_EQ(new_const->get_shape(), output_shape);
ASSERT_EQ(count_ops_of_type<op::Max>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<int32_t>();
ASSERT_EQ(count_ops_of_type<op::v1::ReduceMax>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
ASSERT_EQ(new_const->get_shape(), output_shape);
ASSERT_EQ(count_ops_of_type<op::v1::ReduceMax>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
ASSERT_EQ(new_const->get_shape(), output_shape);
ASSERT_EQ(count_ops_of_type<op::Min>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<int32_t>();
ASSERT_EQ(count_ops_of_type<op::v1::ReduceMin>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
ASSERT_EQ(new_const->get_shape(), output_shape);
ASSERT_EQ(count_ops_of_type<op::v1::ReduceMin>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
ASSERT_EQ(new_const->get_shape(), output_shape);
ASSERT_EQ(count_ops_of_type<op::v1::ReduceMean>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
ASSERT_EQ(new_const->get_shape(), output_shape);
ASSERT_EQ(count_ops_of_type<op::v1::ReduceMean>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
ASSERT_EQ(new_const->get_shape(), output_shape);
ASSERT_EQ(count_ops_of_type<op::v1::ReduceLogicalAnd>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- const auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ const auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
const Shape expected_out_shape{3};
ASSERT_EQ(count_ops_of_type<op::v1::ReduceLogicalAnd>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- const auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ const auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
// the output shape is expected to have 'ones' at the positions specified in the reduction axes
ASSERT_EQ(count_ops_of_type<op::v1::ReduceLogicalAnd>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- const auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ const auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
const Shape expected_out_shape{1, 2, 1};
ASSERT_EQ(count_ops_of_type<op::Any>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<char>();
ASSERT_EQ(count_ops_of_type<op::v1::ReduceLogicalAnd>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- const auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ const auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
const Shape expected_out_shape{3};
ASSERT_EQ(count_ops_of_type<op::Concat>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<int32_t>();
ASSERT_EQ(count_ops_of_type<op::Not>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<char>();
ASSERT_EQ(count_ops_of_type<op::Equal>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<char>();
ASSERT_EQ(count_ops_of_type<op::NotEqual>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<char>();
ASSERT_EQ(count_ops_of_type<op::Greater>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<char>();
ASSERT_EQ(count_ops_of_type<op::GreaterEq>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<char>();
ASSERT_EQ(count_ops_of_type<op::Less>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<char>();
ASSERT_EQ(count_ops_of_type<op::LessEq>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<char>();
ASSERT_EQ(count_ops_of_type<op::Or>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<char>();
ASSERT_EQ(count_ops_of_type<op::Xor>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<char>();
ASSERT_EQ(count_ops_of_type<op::Ceiling>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<float>();
ASSERT_EQ(count_ops_of_type<op::Floor>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<float>();
ASSERT_EQ(count_ops_of_type<op::v0::Gather>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<float>();
ASSERT_EQ(count_ops_of_type<op::v1::Gather>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<float>();
ASSERT_EQ(count_ops_of_type<op::v1::Gather>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<float>();
ASSERT_EQ(count_ops_of_type<op::v1::Gather>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- const auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ const auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
const auto values_out = new_const->get_vector<float>();
ASSERT_EQ(count_ops_of_type<op::v1::Gather>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- const auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ const auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
const auto values_out = new_const->get_vector<float>();
ASSERT_EQ(count_ops_of_type<op::Slice>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<int>();
ASSERT_EQ(count_ops_of_type<op::v1::Reshape>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<float>();
ASSERT_EQ(count_ops_of_type<op::v1::Reshape>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<float>();
ASSERT_EQ(count_ops_of_type<op::Transpose>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<double>();
ASSERT_EQ(count_ops_of_type<op::Range>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->template get_vector<T>();
ASSERT_EQ(count_ops_of_type<op::Select>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<int64_t>();
ASSERT_EQ(count_ops_of_type<op::Select>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<int64_t>();
ASSERT_EQ(count_ops_of_type<op::v1::Split>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), num_splits);
- auto res1 = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
- auto res2 = as_type_ptr<op::Constant>(f->get_results().at(1)->get_argument(0));
- auto res3 = as_type_ptr<op::Constant>(f->get_results().at(2)->get_argument(0));
+ auto res1 =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
+ auto res2 =
+ as_type_ptr<op::Constant>(f->get_results().at(1)->input_value(0).get_node_shared_ptr());
+ auto res3 =
+ as_type_ptr<op::Constant>(f->get_results().at(2)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(res1);
ASSERT_TRUE(res2);
ASSERT_TRUE(res3);
ASSERT_EQ(count_ops_of_type<op::v1::Split>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), num_splits);
- auto res1 = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
- auto res2 = as_type_ptr<op::Constant>(f->get_results().at(1)->get_argument(0));
- auto res3 = as_type_ptr<op::Constant>(f->get_results().at(2)->get_argument(0));
+ auto res1 =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
+ auto res2 =
+ as_type_ptr<op::Constant>(f->get_results().at(1)->input_value(0).get_node_shared_ptr());
+ auto res3 =
+ as_type_ptr<op::Constant>(f->get_results().at(2)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(res1);
ASSERT_TRUE(res2);
ASSERT_TRUE(res3);
ASSERT_EQ(count_ops_of_type<op::v1::Split>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), num_splits);
- auto res1 = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
- auto res2 = as_type_ptr<op::Constant>(f->get_results().at(1)->get_argument(0));
- auto res3 = as_type_ptr<op::Constant>(f->get_results().at(2)->get_argument(0));
- auto res4 = as_type_ptr<op::Constant>(f->get_results().at(3)->get_argument(0));
+ auto res1 =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
+ auto res2 =
+ as_type_ptr<op::Constant>(f->get_results().at(1)->input_value(0).get_node_shared_ptr());
+ auto res3 =
+ as_type_ptr<op::Constant>(f->get_results().at(2)->input_value(0).get_node_shared_ptr());
+ auto res4 =
+ as_type_ptr<op::Constant>(f->get_results().at(3)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(res1);
ASSERT_TRUE(res2);
ASSERT_TRUE(res3);
ASSERT_EQ(count_ops_of_type<op::v1::Split>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), num_splits);
- auto res1 = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
- auto res2 = as_type_ptr<op::Constant>(f->get_results().at(1)->get_argument(0));
+ auto res1 =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
+ auto res2 =
+ as_type_ptr<op::Constant>(f->get_results().at(1)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(res1);
ASSERT_TRUE(res2);
ASSERT_EQ(count_ops_of_type<op::v1::VariadicSplit>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), values_lengths.size());
- auto res1 = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
- auto res2 = as_type_ptr<op::Constant>(f->get_results().at(1)->get_argument(0));
+ auto res1 =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
+ auto res2 =
+ as_type_ptr<op::Constant>(f->get_results().at(1)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(res1);
ASSERT_TRUE(res2);
ASSERT_EQ(count_ops_of_type<op::v1::VariadicSplit>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), values_lengths.size());
- auto res1 = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
- auto res2 = as_type_ptr<op::Constant>(f->get_results().at(1)->get_argument(0));
- auto res3 = as_type_ptr<op::Constant>(f->get_results().at(2)->get_argument(0));
+ auto res1 =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
+ auto res2 =
+ as_type_ptr<op::Constant>(f->get_results().at(1)->input_value(0).get_node_shared_ptr());
+ auto res3 =
+ as_type_ptr<op::Constant>(f->get_results().at(2)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(res1);
ASSERT_TRUE(res2);
ASSERT_TRUE(res3);
ASSERT_EQ(count_ops_of_type<op::v1::OneHot>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto res = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto res =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(res);
ASSERT_EQ((Shape{3, 3}), res->get_output_shape(0));
ASSERT_EQ(count_ops_of_type<op::v1::OneHot>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto res = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto res =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(res);
ASSERT_EQ((Shape{4, 3}), res->get_output_shape(0));
ASSERT_EQ(count_ops_of_type<op::v1::OneHot>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto res = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto res =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(res);
ASSERT_EQ((Shape{2, 2, 3}), res->get_output_shape(0));
ASSERT_EQ(count_ops_of_type<op::Tile>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<int>();
ASSERT_EQ(count_ops_of_type<op::Tile>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<int>();
ASSERT_EQ(count_ops_of_type<op::Tile>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<int>();
ASSERT_EQ(count_ops_of_type<op::Tile>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<int>();
ASSERT_EQ(count_ops_of_type<op::Tile>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<int>();
ASSERT_EQ(count_ops_of_type<op::v3::NonZero>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- const auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ const auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
const auto values_out = new_const->get_vector<int64_t>();
ASSERT_EQ(count_ops_of_type<op::v3::NonZero>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- const auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ const auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
const auto values_out = new_const->get_vector<int64_t>();
ASSERT_EQ(count_ops_of_type<op::v3::NonZero>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- const auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ const auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
ASSERT_EQ(element::i32, new_const->get_element_type());
const auto values_out = new_const->get_vector<int32_t>();
ASSERT_EQ(count_ops_of_type<op::v3::NonZero>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- const auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ const auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
const auto values_out = new_const->get_vector<int64_t>();
ASSERT_EQ(count_ops_of_type<op::v3::NonZero>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- const auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ const auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
const auto values_out = new_const->get_vector<int64_t>();
ASSERT_EQ(count_ops_of_type<op::v3::NonZero>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- const auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ const auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
const auto values_out = new_const->get_vector<int64_t>();
ASSERT_EQ(count_ops_of_type<op::v3::NonZero>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- const auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ const auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
ASSERT_EQ(shape_size(new_const->get_shape()), 0);
}
ASSERT_EQ(count_ops_of_type<op::v3::NonZero>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- const auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ const auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
const auto values_out = new_const->get_vector<int64_t>();
ASSERT_EQ(count_ops_of_type<op::v3::ScatterElementsUpdate>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto result_node = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto result_node =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(result_node);
ASSERT_EQ(data_shape, result_node->get_output_shape(0));
std::vector<float> expected{2.f, 1.1f, 0.0f, 1.f, 0.0f, 2.2f, 0.f, 2.1f, 1.2f};
ASSERT_EQ(count_ops_of_type<op::v3::ScatterElementsUpdate>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto result_node = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto result_node =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(result_node);
ASSERT_EQ(data_shape, result_node->get_output_shape(0));
std::vector<float> expected{1.1f, 1.0f, 1.2f, 2.0f, 2.2f, 2.1f, 0.0f, 0.0f, 0.0f};
ASSERT_EQ(count_ops_of_type<op::v3::ScatterElementsUpdate>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto result_node = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto result_node =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(result_node);
ASSERT_EQ(data_shape, result_node->get_output_shape(0));
std::vector<float> expected{2.f, 1.1f, 0.0f, 1.f, 0.0f, 2.2f, 0.f, 2.1f, 1.2f};
ASSERT_EQ(count_ops_of_type<op::v3::ScatterElementsUpdate>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto result_node = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto result_node =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(result_node);
ASSERT_EQ(data_shape, result_node->get_output_shape(0));
std::vector<int16_t> expected{4, 2, 0, 1, 0, 6, 0, 5, 3, 10, 0, 12, 0, 11,
ASSERT_EQ(count_ops_of_type<op::v3::ScatterElementsUpdate>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto result_node = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto result_node =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(result_node);
ASSERT_EQ(data_shape, result_node->get_output_shape(0));
std::vector<int32_t> expected{input_data};
ASSERT_EQ(count_ops_of_type<op::v1::Reshape>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_const = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto new_const =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_const);
auto values_out = new_const->get_vector<float>();
test_ordered_ops(f, NodeVector{absn});
auto clone = ngraph::clone_function(*f.get());
auto matcher = std::make_shared<pattern::Matcher>(cdop);
- auto cdop_clone = clone->get_results().at(0)->get_argument(0);
+ auto cdop_clone = clone->get_results().at(0)->input_value(0).get_node_shared_ptr();
ASSERT_TRUE(matcher->match(cdop_clone));
auto cloned_deps = cdop_clone->get_control_dependencies();
ASSERT_EQ(cloned_deps.size(), 1);
auto f = make_shared<Function>(absn_cdop, ParameterVector{A, B});
auto clone = ngraph::clone_function(*f.get());
auto matcher = std::make_shared<pattern::Matcher>(cdop);
- auto cdop_clone = clone->get_results().at(0)->get_argument(0)->get_argument(0);
+ auto cdop_clone = clone->get_results()
+ .at(0)
+ ->input_value(0)
+ .get_node_shared_ptr()
+ ->input_value(0)
+ .get_node_shared_ptr();
ASSERT_TRUE(matcher->match(cdop_clone));
auto cloned_deps = cdop_clone->get_control_dependencies();
ASSERT_EQ(cloned_deps.size(), 2);
shared_ptr<Function> clone = deserialize(js);
auto matcher = std::make_shared<pattern::Matcher>(cdop);
- auto cdop_clone = clone->get_results().at(0)->get_argument(0);
+ auto cdop_clone = clone->get_results().at(0)->input_value(0).get_node_shared_ptr();
ASSERT_TRUE(matcher->match(cdop_clone));
auto cloned_deps = cdop_clone->get_control_dependencies();
ASSERT_EQ(cloned_deps.size(), 1);
string js = serialize(f, 4);
shared_ptr<Function> clone = deserialize(js);
auto matcher = std::make_shared<pattern::Matcher>(cdop);
- auto cdop_clone = clone->get_results().at(0)->get_argument(0)->get_argument(0);
+ auto cdop_clone = clone->get_results()
+ .at(0)
+ ->input_value(0)
+ .get_node_shared_ptr()
+ ->input_value(0)
+ .get_node_shared_ptr();
ASSERT_TRUE(matcher->match(cdop_clone));
auto cloned_deps = cdop_clone->get_control_dependencies();
ASSERT_EQ(cloned_deps.size(), 2);
auto node_cast = as_type_ptr<op::Constant>(new_node);
ASSERT_NE(node_cast, nullptr);
ASSERT_TRUE(nullptr != new_node);
- ASSERT_TRUE(NodeVector{} == new_node->get_arguments());
+ ASSERT_TRUE(OutputVector{} == new_node->input_values());
ASSERT_TRUE(node_cast->get_vector<float>() == c);
ASSERT_TRUE(node_cast->get_shape() == shape);
ASSERT_TRUE(node_cast->get_element_type() == et);
ASSERT_NE(node_cast, nullptr);
ASSERT_TRUE(nullptr != new_node);
- ASSERT_TRUE(new_args == as_output_vector(new_node->get_arguments()));
+ ASSERT_TRUE(new_args == new_node->input_values());
ASSERT_TRUE(et == node_cast->get_convert_element_type());
}
ASSERT_NE(node_cast, nullptr);
ASSERT_TRUE(nullptr != new_node);
- ASSERT_TRUE(new_node->get_arguments().size() == 0);
+ ASSERT_TRUE(new_node->input_values().size() == 0);
ASSERT_TRUE(node->has_same_type(new_node));
}
ASSERT_NE(node_cast, nullptr);
ASSERT_TRUE(nullptr != new_node);
- ASSERT_TRUE(new_args == as_output_vector(new_node->get_arguments()));
+ ASSERT_TRUE(new_args == new_node->input_values());
ASSERT_TRUE(axes == node_cast->get_input_order());
ASSERT_TRUE(shape_out == node_cast->get_output_shape(0));
}
ASSERT_NE(node_cast, nullptr);
ASSERT_TRUE(nullptr != new_node);
- ASSERT_TRUE(new_args == as_output_vector(new_node->get_arguments()));
+ ASSERT_TRUE(new_args == new_node->input_values());
ASSERT_TRUE(lower == node_cast->get_lower_bounds());
ASSERT_TRUE(upper == node_cast->get_upper_bounds());
ASSERT_TRUE(strides == node_cast->get_strides());
auto arg0 = make_shared<op::Parameter>(element::f32, shape);
auto node = make_shared<op::Sum>(arg0, axes);
- OutputVector new_args{make_shared<op::Parameter>(element::f32, shape), node->get_argument(1)};
+ OutputVector new_args{make_shared<op::Parameter>(element::f32, shape),
+ node->input_value(1).get_node_shared_ptr()};
auto new_node = node->clone_with_new_inputs(new_args);
auto node_cast = as_type_ptr<op::Sum>(new_node);
ASSERT_NE(node_cast, nullptr);
ASSERT_TRUE(nullptr != new_node);
- ASSERT_TRUE(new_args == as_output_vector(new_node->get_arguments()));
+ ASSERT_TRUE(new_args == new_node->input_values());
ASSERT_TRUE(axes == node_cast->get_reduction_axes());
}
pass_manager.register_pass<ngraph::pass::CommonSubexpressionElimination>();
pass_manager.run_passes(f);
- ASSERT_EQ(f->get_results().at(0)->get_argument(0), f->get_results().at(1)->get_argument(0));
+ ASSERT_EQ(f->get_results().at(0)->input_value(0).get_node_shared_ptr(),
+ f->get_results().at(1)->input_value(0).get_node_shared_ptr());
}
TEST(CSE, abs_abs_negative)
pass_manager.register_pass<ngraph::pass::CommonSubexpressionElimination>();
pass_manager.run_passes(f);
- ASSERT_EQ(f->get_results().at(0)->get_argument(0), abs1);
- ASSERT_EQ(f->get_results().at(1)->get_argument(0), abs2);
+ ASSERT_EQ(f->get_results().at(0)->input_value(0).get_node_shared_ptr(), abs1);
+ ASSERT_EQ(f->get_results().at(1)->input_value(0).get_node_shared_ptr(), abs2);
}
TEST(CSE, add_add)
pass_manager.register_pass<ngraph::pass::CommonSubexpressionElimination>();
pass_manager.run_passes(f);
- ASSERT_EQ(f->get_results().at(0)->get_argument(0), f->get_results().at(1)->get_argument(0));
+ ASSERT_EQ(f->get_results().at(0)->input_value(0).get_node_shared_ptr(),
+ f->get_results().at(1)->input_value(0).get_node_shared_ptr());
}
TEST(CSE, add_add_commutative)
pass_manager.register_pass<ngraph::pass::CommonSubexpressionElimination>();
pass_manager.run_passes(f);
- ASSERT_EQ(f->get_results().at(0)->get_argument(0), f->get_results().at(1)->get_argument(0));
+ ASSERT_EQ(f->get_results().at(0)->input_value(0).get_node_shared_ptr(),
+ f->get_results().at(1)->input_value(0).get_node_shared_ptr());
}
TEST(CSE, add_add_negative)
pass_manager.register_pass<ngraph::pass::CommonSubexpressionElimination>();
pass_manager.run_passes(f);
- ASSERT_EQ(f->get_results().at(0)->get_argument(0), add1);
- ASSERT_EQ(f->get_results().at(1)->get_argument(0), add2);
+ ASSERT_EQ(f->get_results().at(0)->input_value(0).get_node_shared_ptr(), add1);
+ ASSERT_EQ(f->get_results().at(1)->input_value(0).get_node_shared_ptr(), add2);
}
TEST(CSE, abs_add)
pass_manager.register_pass<ngraph::pass::CommonSubexpressionElimination>();
pass_manager.run_passes(f);
- ASSERT_EQ(f->get_results().at(0)->get_argument(0), f->get_results().at(1)->get_argument(0));
+ ASSERT_EQ(f->get_results().at(0)->input_value(0).get_node_shared_ptr(),
+ f->get_results().at(1)->input_value(0).get_node_shared_ptr());
}
TEST(CSE, abs_add_reshape_broadcast)
pass_manager.register_pass<ngraph::pass::CommonSubexpressionElimination>();
pass_manager.run_passes(f);
- ASSERT_EQ(f->get_results().at(0)->get_argument(0), f->get_results().at(1)->get_argument(0));
+ ASSERT_EQ(f->get_results().at(0)->input_value(0).get_node_shared_ptr(),
+ f->get_results().at(1)->input_value(0).get_node_shared_ptr());
}
{
// fail case
pass_manager.register_pass<ngraph::pass::CommonSubexpressionElimination>();
pass_manager.run_passes(f);
- ASSERT_NE(f->get_results().at(0)->get_argument(0), f->get_results().at(1)->get_argument(0));
+ ASSERT_NE(f->get_results().at(0)->input_value(0).get_node_shared_ptr(),
+ f->get_results().at(1)->input_value(0).get_node_shared_ptr());
}
{
// fail case
pass_manager.register_pass<ngraph::pass::CommonSubexpressionElimination>();
pass_manager.run_passes(f);
- ASSERT_NE(f->get_results().at(0)->get_argument(0), f->get_results().at(1)->get_argument(0));
+ ASSERT_NE(f->get_results().at(0)->input_value(0).get_node_shared_ptr(),
+ f->get_results().at(1)->input_value(0).get_node_shared_ptr());
}
}
pass_manager.register_pass<ngraph::pass::CommonSubexpressionElimination>();
pass_manager.run_passes(f);
- ASSERT_EQ(f->get_results().at(0)->get_argument(0), f->get_results().at(1)->get_argument(0));
+ ASSERT_EQ(f->get_results().at(0)->input_value(0).get_node_shared_ptr(),
+ f->get_results().at(1)->input_value(0).get_node_shared_ptr());
}
TEST(CSE, abs_add_abs_add_negative)
pass_manager.register_pass<ngraph::pass::CommonSubexpressionElimination>();
pass_manager.run_passes(f);
- auto oadd3 = f->get_results().at(0)->get_argument(0);
- auto oadd4 = f->get_results().at(1)->get_argument(0);
+ auto oadd3 = f->get_results().at(0)->input_value(0).get_node_shared_ptr();
+ auto oadd4 = f->get_results().at(1)->input_value(0).get_node_shared_ptr();
ASSERT_EQ(oadd3, add3);
ASSERT_EQ(oadd4, add4);
- ASSERT_EQ(oadd3->get_argument(1), C);
- ASSERT_EQ(oadd4->get_argument(1), D);
- ASSERT_EQ(oadd3->get_argument(0), oadd4->get_argument(0));
+ ASSERT_EQ(oadd3->input_value(1).get_node_shared_ptr(), C);
+ ASSERT_EQ(oadd4->input_value(1).get_node_shared_ptr(), D);
+ ASSERT_EQ(oadd3->input_value(0).get_node_shared_ptr(),
+ oadd4->input_value(0).get_node_shared_ptr());
}
template <typename T>
pass_manager.register_pass<ngraph::pass::CommonSubexpressionElimination>();
pass_manager.run_passes(f);
- ASSERT_EQ(sub_aa->get_argument(0), sub_aa->get_argument(1));
- ASSERT_NE(sub_ab->get_argument(0), sub_ab->get_argument(1));
- ASSERT_NE(f->get_results().at(2)->get_argument(0), sub_aa->get_argument(0));
+ ASSERT_EQ(sub_aa->input_value(0).get_node_shared_ptr(),
+ sub_aa->input_value(1).get_node_shared_ptr());
+ ASSERT_NE(sub_ab->input_value(0).get_node_shared_ptr(),
+ sub_ab->input_value(1).get_node_shared_ptr());
+ ASSERT_NE(f->get_results().at(2)->input_value(0).get_node_shared_ptr(),
+ sub_aa->input_value(0).get_node_shared_ptr());
}
TEST(CSE, reduction_ops)
pass_manager.register_pass<ngraph::pass::CommonSubexpressionElimination>();
pass_manager.run_passes(f);
- ASSERT_EQ(abs0->get_argument(0), abs0_1->get_argument(0));
- ASSERT_EQ(abs1->get_argument(0), abs1_1->get_argument(0));
- ASSERT_NE(abs0->get_argument(0), abs1->get_argument(0));
- ASSERT_NE(abs0->get_argument(0), absf->get_argument(0));
- ASSERT_NE(abs111->get_argument(0), abs112->get_argument(0));
+ ASSERT_EQ(abs0->input_value(0).get_node_shared_ptr(),
+ abs0_1->input_value(0).get_node_shared_ptr());
+ ASSERT_EQ(abs1->input_value(0).get_node_shared_ptr(),
+ abs1_1->input_value(0).get_node_shared_ptr());
+ ASSERT_NE(abs0->input_value(0).get_node_shared_ptr(),
+ abs1->input_value(0).get_node_shared_ptr());
+ ASSERT_NE(abs0->input_value(0).get_node_shared_ptr(),
+ absf->input_value(0).get_node_shared_ptr());
+ ASSERT_NE(abs111->input_value(0).get_node_shared_ptr(),
+ abs112->input_value(0).get_node_shared_ptr());
}
TEST(CSE, one_hot)
auto onehot2 = std::make_shared<op::OneHot>(A, out_shape, 1);
auto f = std::make_shared<Function>(NodeVector{onehot1, onehot2}, ParameterVector{A});
pass_manager.run_passes(f);
- ASSERT_EQ(f->get_results().at(0)->get_argument(0), f->get_results().at(1)->get_argument(0));
+ ASSERT_EQ(f->get_results().at(0)->input_value(0).get_node_shared_ptr(),
+ f->get_results().at(1)->input_value(0).get_node_shared_ptr());
}
{
Shape param_shape{8, 1};
auto onehot2 = std::make_shared<op::OneHot>(reshape2, out_shape, 1);
auto f = std::make_shared<Function>(NodeVector{onehot1, onehot2}, ParameterVector{A});
pass_manager.run_passes(f);
- ASSERT_EQ(f->get_results().at(0)->get_argument(0), f->get_results().at(1)->get_argument(0));
+ ASSERT_EQ(f->get_results().at(0)->input_value(0).get_node_shared_ptr(),
+ f->get_results().at(1)->input_value(0).get_node_shared_ptr());
}
}
ASSERT_EQ(count_ops_of_type<op::Transpose>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Reshape>(f), 1);
- auto new_reshape = as_type_ptr<op::Reshape>(f->get_results().at(0)->get_argument(0));
+ auto new_reshape =
+ as_type_ptr<op::Reshape>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_reshape);
ASSERT_EQ(new_reshape->get_input_order(), (AxisVector{2, 3, 1, 0}));
ASSERT_EQ(count_ops_of_type<op::Transpose>(f), 1);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto new_transpose = as_type_ptr<op::Transpose>(f->get_results().at(0)->get_argument(0));
+ auto new_transpose =
+ as_type_ptr<op::Transpose>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_transpose);
ASSERT_EQ(new_transpose->get_output_element_type(0), element::boolean);
ASSERT_EQ(count_ops_of_type<op::Range>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto replacement = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto replacement =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_NE(replacement, nullptr);
ASSERT_EQ(replacement->get_element_type(), element::i64);
ASSERT_EQ(count_ops_of_type<op::Range>(f), 0);
ASSERT_EQ(count_ops_of_type<op::Constant>(f), 1);
- auto replacement = as_type_ptr<op::Constant>(f->get_results().at(0)->get_argument(0));
+ auto replacement =
+ as_type_ptr<op::Constant>(f->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_NE(replacement, nullptr);
ASSERT_EQ(replacement->get_element_type(), element::f64);
ASSERT_EQ(2, add->get_input_size());
for (size_t i = 0; i < add->get_input_size(); i++)
{
- ASSERT_EQ(add->get_argument(i), nodes.at(i));
+ ASSERT_EQ(add->input_value(i).get_node_shared_ptr(), nodes.at(i));
}
}
auto callback = [pattern](pattern::Matcher& m) {
NGRAPH_DEBUG << "In a callback for construct_multiply_by_one against "
<< m.get_match_root()->get_name();
- NGRAPH_CHECK(m.get_match_root()->get_arguments().size() == 2);
+ NGRAPH_CHECK(m.get_match_root()->input_values().size() == 2);
auto pattern_map = m.get_pattern_map();
size_t const_node_index =
- m.get_match_root()->get_arguments().at(0) == pattern_map[pattern];
- auto const_node =
- as_type_ptr<op::Constant>(m.get_match_root()->get_arguments().at(const_node_index));
- auto second_node = m.get_match_root()->get_arguments().at(const_node_index);
+ m.get_match_root()->input_value(0).get_node_shared_ptr() == pattern_map[pattern];
+ auto const_node = as_type_ptr<op::Constant>(
+ m.get_match_root()->input_value(const_node_index).get_node_shared_ptr());
+ auto second_node =
+ m.get_match_root()->input_value(const_node_index).get_node_shared_ptr();
NGRAPH_DEBUG << "second_node = " << second_node->get_name()
<< " , pattern = " << pattern_map[pattern]->get_name();
auto callback = [pattern](pattern::Matcher& m) {
NGRAPH_DEBUG << "In a callback for construct_add_zero against "
<< m.get_match_root()->get_name();
- NGRAPH_CHECK(m.get_match_root()->get_arguments().size() == 2);
+ NGRAPH_CHECK(m.get_match_root()->input_values().size() == 2);
auto pattern_map = m.get_pattern_map();
size_t const_node_index =
- m.get_match_root()->get_arguments().at(0) == pattern_map[pattern];
- auto const_node =
- as_type_ptr<op::Constant>(m.get_match_root()->get_arguments().at(const_node_index));
- auto second_node = m.get_match_root()->get_arguments().at(const_node_index);
+ m.get_match_root()->input_value(0).get_node_shared_ptr() == pattern_map[pattern];
+ auto const_node = as_type_ptr<op::Constant>(
+ m.get_match_root()->input_value(const_node_index).get_node_shared_ptr());
+ auto second_node =
+ m.get_match_root()->input_value(const_node_index).get_node_shared_ptr();
NGRAPH_DEBUG << "second_node = " << second_node->get_name()
<< " , pattern = " << pattern_map[pattern]->get_name();
auto sum = (a + iconst0);
auto graph = b + sum;
run_passes(pass_manager, graph, {a, b});
- ASSERT_EQ(graph->get_arguments().at(1), a);
+ ASSERT_EQ(graph->input_value(1).get_node_shared_ptr(), a);
ASSERT_EQ(graph->input_value(1), a->output(0)); // graph's input points to a's output
ASSERT_TRUE(sum->output(0)
.get_target_inputs()
auto mul = (a * iconst1);
auto graph = b + mul;
run_passes(pass_manager, graph, {a, b});
- ASSERT_EQ(graph->get_arguments().at(1), a);
+ ASSERT_EQ(graph->input_value(1).get_node_shared_ptr(), a);
ASSERT_EQ(graph->input_value(1), a->output(0)); // graph's input points to a's output
ASSERT_TRUE(mul->output(0)
.get_target_inputs()
auto iconst1 = construct_constant_node(1);
auto graph = ((((a * iconst1) * iconst1) * iconst1) * iconst1) + b;
run_passes(pass_manager, graph, {a, b});
- ASSERT_EQ(graph->get_arguments().at(0), a);
+ ASSERT_EQ(graph->input_value(0).get_node_shared_ptr(), a);
ASSERT_EQ(graph->input_value(0), a->output(0)); // graph's input points to a's output
ASSERT_TRUE(a->get_output_target_inputs(0).count(
graph->input(0))); // a's output feeds into graph's input
auto iconst1 = construct_constant_node(1);
auto graph = b + (iconst0 + ((a + iconst0) * iconst1));
run_passes(pass_manager, graph, {a, b});
- ASSERT_EQ(graph->get_arguments().at(1), a);
+ ASSERT_EQ(graph->input_value(1).get_node_shared_ptr(), a);
ASSERT_EQ(graph->input_value(1), a->output(0)); // graph's input points to a's output
ASSERT_TRUE(a->get_output_target_inputs(0).count(
graph->input(1))); // a's output feeds into graph's input
auto iconst1 = construct_constant_node(1);
auto graph = b + (iconst1 * (iconst1 * (iconst1 * (iconst1 * a))));
run_passes(pass_manager, graph, {a, b});
- ASSERT_EQ(graph->get_arguments().at(1), a);
+ ASSERT_EQ(graph->input_value(1).get_node_shared_ptr(), a);
ASSERT_EQ(graph->input_value(1), a->output(0)); // graph's input points to a's output
ASSERT_TRUE(a->get_output_target_inputs(0).count(
graph->input(1))); // a's output feeds into graph's input
auto f = std::make_shared<Function>(ngraph::NodeVector{graph}, ParameterVector{a, b});
pass_manager.run_passes(f);
- auto left_abs = graph->get_argument(0);
- auto add_a = left_abs->get_argument(0);
+ auto left_abs = graph->input_value(0).get_node_shared_ptr();
+ auto add_a = left_abs->input_value(0).get_node_shared_ptr();
ASSERT_EQ(add_a, a);
- auto right_abs = graph->get_argument(1);
- auto add_b = right_abs->get_argument(0);
+ auto right_abs = graph->input_value(1).get_node_shared_ptr();
+ auto add_b = right_abs->input_value(0).get_node_shared_ptr();
ASSERT_EQ(add_b, b);
}
}
pass_manager.register_pass<pass::ReshapeElimination>();
auto func = make_shared<Function>(graph, ParameterVector{W, x});
pass_manager.run_passes(func);
- auto gdot = graph->get_argument(0);
+ auto gdot = graph->input_value(0).get_node_shared_ptr();
ASSERT_TRUE(as_type_ptr<op::Dot>(gdot));
- ASSERT_TRUE(as_type_ptr<op::Reshape>(gdot->get_argument(0)));
- ASSERT_TRUE(as_type_ptr<op::Reshape>(gdot->get_argument(1)));
- ASSERT_EQ(gdot->get_argument(0)->get_argument(0), x);
- ASSERT_EQ(gdot->get_argument(1)->get_argument(0), W);
+ ASSERT_TRUE(as_type_ptr<op::Reshape>(gdot->input_value(0).get_node_shared_ptr()));
+ ASSERT_TRUE(as_type_ptr<op::Reshape>(gdot->input_value(1).get_node_shared_ptr()));
+ ASSERT_EQ(gdot->input_value(0).get_node_shared_ptr()->input_value(0).get_node_shared_ptr(), x);
+ ASSERT_EQ(gdot->input_value(1).get_node_shared_ptr()->input_value(0).get_node_shared_ptr(), W);
ASSERT_EQ(gdot->get_shape(), (Shape{1, 2}));
}
pass_manager.register_pass<pass::ReshapeElimination>();
pass_manager.register_pass<pass::CommonSubexpressionElimination>();
pass_manager.run_passes(func);
- ASSERT_EQ(func->get_results().at(1)->get_argument(0), sum);
- auto new_reshape = as_type_ptr<op::Reshape>(func->get_results().at(0)->get_argument(0));
+ ASSERT_EQ(func->get_results().at(1)->input_value(0).get_node_shared_ptr(), sum);
+ auto new_reshape =
+ as_type_ptr<op::Reshape>(func->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(new_reshape);
ASSERT_EQ(new_reshape->get_shape(), shape_nchw);
}
ASSERT_EQ(add->get_shape(), conv_nchw);
ASSERT_EQ(add->get_input_shape(0), conv_nchw);
- ASSERT_EQ(add->get_argument(1), conv);
+ ASSERT_EQ(add->input_value(1).get_node_shared_ptr(), conv);
}
TEST(reshape_sinking, concat)
ASSERT_EQ(g->get_output_shape(0), (Shape{1, 2, 3}));
ASSERT_EQ(g->get_output_element_type(0), element::f32);
- auto plus_node = as_type_ptr<op::Add>(g->get_results().at(0)->get_argument(0));
+ auto plus_node =
+ as_type_ptr<op::Add>(g->get_results().at(0)->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(plus_node);
- auto convert_node = as_type_ptr<op::Convert>(plus_node->get_argument(1));
+ auto convert_node = as_type_ptr<op::Convert>(plus_node->input_value(1).get_node_shared_ptr());
ASSERT_TRUE(convert_node);
- auto const_node = as_type_ptr<op::Constant>(convert_node->get_argument(0));
+ auto const_node = as_type_ptr<op::Constant>(convert_node->input_value(0).get_node_shared_ptr());
ASSERT_TRUE(const_node);
ASSERT_EQ(const_node->get_output_element_type(0), element::i32);
auto test_binary_good_arguments = [&](const shared_ptr<Node>& x, const shared_ptr<Node>& y) {
auto node = f(x, y);
- EXPECT_TRUE(node->has_same_type(node->get_arguments()[0]));
+ EXPECT_TRUE(node->has_same_type(node->input_values()[0].get_node_shared_ptr()));
};
test_binary_good_arguments(tv0_2_4_param_0, tv0_2_4_param_1);
}
auto test_binary_good_arguments = [&](const shared_ptr<Node>& x, const shared_ptr<Node>& y) {
auto node = f(x, y);
- EXPECT_TRUE(node->has_same_type(node->get_arguments()[0]));
+ EXPECT_TRUE(node->has_same_type(node->input_values()[0].get_node_shared_ptr()));
};
test_binary_good_arguments(tv0_2_4_param_0, tv0_2_4_param_1);
}
for (auto it = nodes.rbegin(); it != nodes.rend(); it++)
{
auto node_tmp = *it;
- auto dependencies_tmp = node_tmp->get_arguments();
+ NodeVector dependencies_tmp;
+ for (auto& val : node_tmp->input_values())
+ dependencies_tmp.emplace_back(val.get_node_shared_ptr());
vector<Node*> dependencies;
for (shared_ptr<Node> n : dependencies_tmp)
projects / platform / upstream / dldt.git / commitdiff