Skip to content

Remove using namespace ov::op and ov::pass::pattern directives to fix UNITY build conflicts #33134

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
evkotov wants to merge 3 commits into
base: master
Choose a base branch
from
+5,193 −4,732
Open

Remove using namespace ov::op and ov::pass::pattern directives to fix UNITY build conflicts #33134

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
fcaf178
Remove using namespace ov::op and using namespace ov::pass::pattern d…
evkotov Dec 5, 2025
5937621
clang fix
evkotov Dec 5, 2025
4f9ab5d
Remove using namespace ov::op::util directives to fix UNITY build con…
evkotov Dec 5, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
49 changes: 26 additions & 23 deletions src/common/transformations/src/transformations/common_optimizations/activations_scaling.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -46,20 +46,19 @@ const auto is_non_const_node = [](const ov::Output<ov::Node>& output) -> bool {
} // namespace

using namespace ov::pass::activations_scaling;
using namespace ov::pass::pattern;
using ov::pass::pattern::op::Or;

ov::pass::activations_scaling::ScaleDownSingleLayer::ScaleDownSingleLayer(float scale_factor,
ov::element::Type scaled_prec) {
MATCHER_SCOPE(ScaleDownSingleLayer);

auto activation_m = any_input();
auto weights_m = any_input();
auto convolution_m = wrap_type<ov::op::v1::Convolution>({activation_m, weights_m});
auto matmul_m = wrap_type<ov::op::v0::MatMul>({activation_m, weights_m});
auto activation_m = ov::pass::pattern::any_input();
auto weights_m = ov::pass::pattern::any_input();
auto convolution_m = ov::pass::pattern::wrap_type<ov::op::v1::Convolution>({activation_m, weights_m});
auto matmul_m = ov::pass::pattern::wrap_type<ov::op::v0::MatMul>({activation_m, weights_m});
auto scaled_op_m = std::make_shared<Or>(OutputVector{convolution_m, matmul_m});

ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) {
ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
const auto& pattern_map = m.get_pattern_value_map();

OPENVINO_ASSERT(pattern_map.count(convolution_m) || pattern_map.count(matmul_m),
Expand Down Expand Up @@ -180,17 +179,18 @@ ov::pass::activations_scaling::ScaleDownSingleLayer::ScaleDownSingleLayer(float
ov::pass::activations_scaling::EliminateScalarMul::EliminateScalarMul() {
MATCHER_SCOPE(EliminateScalarMul);

auto activation_m = any_input(is_non_const_node);
auto activation_m = ov::pass::pattern::any_input(is_non_const_node);
auto convert_m = ov::pass::pattern::optional<ov::op::v0::Convert>(activation_m);
auto scale_const_m = ov::pass::pattern::wrap_type<ov::op::v0::Constant>(is_scalar_node);
auto mul_m = wrap_type<ov::op::v1::Multiply>({convert_m, scale_const_m});
auto mvn_m = wrap_type<ov::op::v6::MVN>({mul_m, any_input()});
auto rms_m = wrap_type<ov::op::internal::RMS>({mul_m, any_input()});
auto group_norm_m = wrap_type<ov::op::v12::GroupNormalization>({mul_m, any_input(), any_input()});
auto shape_of_m = wrap_type<ov::op::v3::ShapeOf>({mul_m});
auto mul_m = ov::pass::pattern::wrap_type<ov::op::v1::Multiply>({convert_m, scale_const_m});
auto mvn_m = ov::pass::pattern::wrap_type<ov::op::v6::MVN>({mul_m, ov::pass::pattern::any_input()});
auto rms_m = ov::pass::pattern::wrap_type<ov::op::internal::RMS>({mul_m, ov::pass::pattern::any_input()});
auto group_norm_m = ov::pass::pattern::wrap_type<ov::op::v12::GroupNormalization>(
{mul_m, ov::pass::pattern::any_input(), ov::pass::pattern::any_input()});
auto shape_of_m = ov::pass::pattern::wrap_type<ov::op::v3::ShapeOf>({mul_m});
auto norm_m = std::make_shared<Or>(OutputVector{mvn_m, rms_m, group_norm_m, shape_of_m});

ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) {
ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
const auto& pattern_map = m.get_pattern_value_map();

if (transformation_callback(m.get_match_root())) {
Expand Down Expand Up @@ -240,13 +240,16 @@ ov::pass::activations_scaling::EliminateScalarMul::EliminateScalarMul() {
ov::pass::activations_scaling::MulShareTransformation::MulShareTransformation() {
MATCHER_SCOPE(MulShareTransformation);

auto mvn_m = wrap_type<ov::op::v6::MVN>({any_input(), any_input()});
auto rms_m = wrap_type<ov::op::internal::RMS>({any_input(), any_input()});
auto group_norm_m = wrap_type<ov::op::v12::GroupNormalization>({any_input(), any_input(), any_input()});
auto shape_of_m = wrap_type<ov::op::v3::ShapeOf>({any_input()});
auto mvn_m =
ov::pass::pattern::wrap_type<ov::op::v6::MVN>({ov::pass::pattern::any_input(), ov::pass::pattern::any_input()});
auto rms_m = ov::pass::pattern::wrap_type<ov::op::internal::RMS>(
{ov::pass::pattern::any_input(), ov::pass::pattern::any_input()});
auto group_norm_m = ov::pass::pattern::wrap_type<ov::op::v12::GroupNormalization>(
{ov::pass::pattern::any_input(), ov::pass::pattern::any_input(), ov::pass::pattern::any_input()});
auto shape_of_m = ov::pass::pattern::wrap_type<ov::op::v3::ShapeOf>({ov::pass::pattern::any_input()});
auto norm_m = std::make_shared<Or>(OutputVector{mvn_m, rms_m, group_norm_m, shape_of_m});

ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) {
ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
const auto& pattern_map = m.get_pattern_value_map();

if (transformation_callback(m.get_match_root())) {
Expand Down Expand Up @@ -314,13 +317,13 @@ ov::pass::activations_scaling::MulShareTransformation::MulShareTransformation()
ov::pass::activations_scaling::MoveDownScalarMul::MoveDownScalarMul() {
MATCHER_SCOPE(MoveDownScalarMul);

auto activation_b_m = any_input(is_non_const_node);
auto activation_b_m = ov::pass::pattern::any_input(is_non_const_node);
auto mul_const_m = ov::pass::pattern::wrap_type<ov::op::v0::Constant>(is_scalar_node);
auto mul_b_m = wrap_type<ov::op::v1::Multiply>({activation_b_m, mul_const_m});
auto activation_a_m = any_input(is_non_const_node);
auto mul_a_m = wrap_type<ov::op::v1::Multiply>({activation_a_m, mul_b_m});
auto mul_b_m = ov::pass::pattern::wrap_type<ov::op::v1::Multiply>({activation_b_m, mul_const_m});
auto activation_a_m = ov::pass::pattern::any_input(is_non_const_node);
auto mul_a_m = ov::pass::pattern::wrap_type<ov::op::v1::Multiply>({activation_a_m, mul_b_m});

ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) {
ov::matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
const auto& pattern_map = m.get_pattern_value_map();

if (transformation_callback(m.get_match_root())) {
Expand Down
24 changes: 11 additions & 13 deletions ...mmon/transformations/src/transformations/common_optimizations/adaptive_pool_to_reduce.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -16,19 +16,17 @@
#include "openvino/op/reduce_mean.hpp"
#include "openvino/pass/pattern/op/wrap_type.hpp"
#include "transformations/utils/utils.hpp"

using namespace ov::op;

ov::pass::AdaptivePoolToReduce::AdaptivePoolToReduce() {
MATCHER_SCOPE(AdaptivePoolToReduce);
auto data_pattern = pattern::any_input();
auto out_spatial_shape = pattern::wrap_type<v0::Constant>();
auto a_pool = pattern::wrap_type<v8::AdaptiveAvgPool, v8::AdaptiveMaxPool>({data_pattern, out_spatial_shape});
auto data_pattern = ov::pass::pattern::any_input();
auto out_spatial_shape = ov::pass::pattern::wrap_type<ov::op::v0::Constant>();
auto a_pool = ov::pass::pattern::wrap_type<ov::op::v8::AdaptiveAvgPool, ov::op::v8::AdaptiveMaxPool>(
{data_pattern, out_spatial_shape});

ov::matcher_pass_callback callback = [=](pattern::Matcher& m) {
ov::matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
const auto& pattern_map = m.get_pattern_map();

const auto& spatial_shape_c = ov::as_type_ptr<v0::Constant>(pattern_map.at(out_spatial_shape));
const auto& spatial_shape_c = ov::as_type_ptr<ov::op::v0::Constant>(pattern_map.at(out_spatial_shape));
auto spatial_shape = spatial_shape_c->cast_vector<int64_t>();
// Verify that all dimensions in adaptive pool shape are 1
for (auto& s : spatial_shape) {
Expand All @@ -38,17 +36,17 @@ ov::pass::AdaptivePoolToReduce::AdaptivePoolToReduce() {

auto axes = std::vector<int64_t>(spatial_shape.size(), 0);
std::iota(axes.begin(), axes.end(), 2);
auto axes_const = v0::Constant::create(element::i64, {spatial_shape.size()}, axes);
auto axes_const = ov::op::v0::Constant::create(element::i64, {spatial_shape.size()}, axes);
const auto adaptive_pool = pattern_map.at(a_pool);
std::shared_ptr<Node> res_node;
if (ov::as_type_ptr<v8::AdaptiveAvgPool>(adaptive_pool)) {
res_node = std::make_shared<v1::ReduceMean>(adaptive_pool->input_value(0), axes_const, true);
} else if (ov::as_type_ptr<v8::AdaptiveMaxPool>(adaptive_pool)) {
if (ov::as_type_ptr<ov::op::v8::AdaptiveAvgPool>(adaptive_pool)) {
res_node = std::make_shared<ov::op::v1::ReduceMean>(adaptive_pool->input_value(0), axes_const, true);
} else if (ov::as_type_ptr<ov::op::v8::AdaptiveMaxPool>(adaptive_pool)) {
if (adaptive_pool->outputs().size() > 1 && adaptive_pool->output(1).get_target_inputs().size() != 0) {
// If indexes are used we can't replace it
return false;
}
res_node = std::make_shared<v1::ReduceMax>(adaptive_pool->input_value(0), axes_const, true);
res_node = std::make_shared<ov::op::v1::ReduceMax>(adaptive_pool->input_value(0), axes_const, true);
} else {
return false;
}
Expand Down
16 changes: 8 additions & 8 deletions ...mon/transformations/src/transformations/common_optimizations/add_fake_quantize_fusion.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -25,16 +25,16 @@

ov::pass::AddFakeQuantizeFusion::AddFakeQuantizeFusion() {
MATCHER_SCOPE(AddFakeQuantizeFusion);
auto input_pattern = pass::pattern::any_input();
auto input_pattern = ov::pass::pattern::any_input();
auto const_pattern = ov::pass::pattern::wrap_type<ov::op::v0::Constant>();
auto add_pattern =
ov::pass::pattern::wrap_type<ov::op::v1::Add>({input_pattern, const_pattern}, pattern::consumers_count(1));
auto add_pattern = ov::pass::pattern::wrap_type<ov::op::v1::Add>({input_pattern, const_pattern},
ov::pass::pattern::consumers_count(1));
auto fq_pattern = ov::pass::pattern::wrap_type<ov::op::v0::FakeQuantize>({add_pattern,
pass::pattern::any_input(),
pass::pattern::any_input(),
pass::pattern::any_input(),
pass::pattern::any_input()});
matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](pattern::Matcher& m) {
ov::pass::pattern::any_input(),
ov::pass::pattern::any_input(),
ov::pass::pattern::any_input(),
ov::pass::pattern::any_input()});
matcher_pass_callback callback = [OV_CAPTURE_CPY_AND_THIS](ov::pass::pattern::Matcher& m) {
const auto& pattern_value_map = m.get_pattern_value_map();
const auto& input = pattern_value_map.at(input_pattern);
const auto& type = input.get_element_type();
Expand Down
14 changes: 7 additions & 7 deletions ...on/transformations/src/transformations/common_optimizations/align_eltwise_input_ranks.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -15,13 +15,13 @@
#include "openvino/pass/pattern/op/wrap_type.hpp"

ov::pass::AlignEltwiseInputRanks::AlignEltwiseInputRanks() {
auto eltwise_pattern = pattern::wrap_type<ov::op::v0::SquaredDifference,
ov::op::util::BinaryElementwiseComparison,
ov::op::util::BinaryElementwiseLogical,
ov::op::util::BinaryElementwiseArithmetic,
ov::op::v0::FakeQuantize>(pattern::has_static_rank());
auto eltwise_pattern = ov::pass::pattern::wrap_type<ov::op::v0::SquaredDifference,
ov::op::util::BinaryElementwiseComparison,
ov::op::util::BinaryElementwiseLogical,
ov::op::util::BinaryElementwiseArithmetic,
ov::op::v0::FakeQuantize>(ov::pass::pattern::has_static_rank());

matcher_pass_callback callback = [=](pattern::Matcher& m) {
matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
auto node = m.get_match_root();

auto fq = as_type<ov::op::v0::FakeQuantize>(node.get());
Expand Down Expand Up @@ -65,6 +65,6 @@ ov::pass::AlignEltwiseInputRanks::AlignEltwiseInputRanks() {
return false;
};

auto m = std::make_shared<pattern::Matcher>(eltwise_pattern, "AlignEltwiseInputRanks");
auto m = std::make_shared<ov::pass::pattern::Matcher>(eltwise_pattern, "AlignEltwiseInputRanks");
this->register_matcher(m, callback);
}
44 changes: 23 additions & 21 deletions src/common/transformations/src/transformations/common_optimizations/augru_cell_fusion.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -27,8 +27,6 @@

using namespace std;
using namespace ov::element;
using namespace ov::pass::pattern;

// The 1st input to the Add op is automatically broadcasted
// from 1d to 2d tensor, but to be compatible with what
// the transformation code expectes we have to broadcast the
Expand Down Expand Up @@ -75,29 +73,33 @@ ov::pass::AUGRUCellFusion::AUGRUCellFusion() {
return !(p_shape.rank().is_dynamic() || p_shape[1].is_dynamic());
};

auto concat_1 = wrap_type<ov::op::v0::Concat>({any_input(is_first_dim_static), any_input(is_first_dim_static)});
auto matmul_1 = wrap_type<ov::op::v0::MatMul>({concat_1, any_input(is_first_dim_static)});
auto add_1 = wrap_type<ov::op::v1::Add>({matmul_1, any_input()});
auto concat_1 = ov::pass::pattern::wrap_type<ov::op::v0::Concat>(
{ov::pass::pattern::any_input(is_first_dim_static), ov::pass::pattern::any_input(is_first_dim_static)});
auto matmul_1 =
ov::pass::pattern::wrap_type<ov::op::v0::MatMul>({concat_1, ov::pass::pattern::any_input(is_first_dim_static)});
auto add_1 = ov::pass::pattern::wrap_type<ov::op::v1::Add>({matmul_1, ov::pass::pattern::any_input()});
// only Sigmoid is supported in the current version of AUGRUCell
auto sigmoid = wrap_type<ov::op::v0::Sigmoid>({add_1});
auto split = wrap_type<ov::op::v1::Split>({sigmoid, any_input()});
auto multiply = wrap_type<ov::op::v1::Multiply>({split, any_input()});

auto concat_2 = wrap_type<ov::op::v0::Concat>({any_input(), multiply});
auto matmul_2 = wrap_type<ov::op::v0::MatMul>({concat_2, any_input(is_first_dim_static)});
auto add_2 = wrap_type<ov::op::v1::Add>({matmul_2, any_input()});
auto sigmoid = ov::pass::pattern::wrap_type<ov::op::v0::Sigmoid>({add_1});
auto split = ov::pass::pattern::wrap_type<ov::op::v1::Split>({sigmoid, ov::pass::pattern::any_input()});
auto multiply = ov::pass::pattern::wrap_type<ov::op::v1::Multiply>({split, ov::pass::pattern::any_input()});

auto concat_2 = ov::pass::pattern::wrap_type<ov::op::v0::Concat>({ov::pass::pattern::any_input(), multiply});
auto matmul_2 =
ov::pass::pattern::wrap_type<ov::op::v0::MatMul>({concat_2, ov::pass::pattern::any_input(is_first_dim_static)});
auto add_2 = ov::pass::pattern::wrap_type<ov::op::v1::Add>({matmul_2, ov::pass::pattern::any_input()});
// only Tanh is supported in the current version of AUGRUCell
auto tanh = wrap_type<ov::op::v0::Tanh>({add_2});
auto tanh = ov::pass::pattern::wrap_type<ov::op::v0::Tanh>({add_2});

auto subtract_1 = wrap_type<ov::op::v1::Subtract>({any_input(), any_input()});
auto multiply_2 = wrap_type<ov::op::v1::Multiply>({subtract_1, split});
auto subtract_2 = wrap_type<ov::op::v1::Subtract>({any_input(), multiply_2});
auto multiply_3 = wrap_type<ov::op::v1::Multiply>({subtract_2, tanh});
auto subtract_1 = ov::pass::pattern::wrap_type<ov::op::v1::Subtract>(
{ov::pass::pattern::any_input(), ov::pass::pattern::any_input()});
auto multiply_2 = ov::pass::pattern::wrap_type<ov::op::v1::Multiply>({subtract_1, split});
auto subtract_2 = ov::pass::pattern::wrap_type<ov::op::v1::Subtract>({ov::pass::pattern::any_input(), multiply_2});
auto multiply_3 = ov::pass::pattern::wrap_type<ov::op::v1::Multiply>({subtract_2, tanh});

auto multiply_4 = wrap_type<ov::op::v1::Multiply>({multiply_2, any_input()});
auto add_3 = wrap_type<ov::op::v1::Add>({multiply_4, multiply_3});
auto multiply_4 = ov::pass::pattern::wrap_type<ov::op::v1::Multiply>({multiply_2, ov::pass::pattern::any_input()});
auto add_3 = ov::pass::pattern::wrap_type<ov::op::v1::Add>({multiply_4, multiply_3});

matcher_pass_callback callback = [=](pattern::Matcher& m) {
matcher_pass_callback callback = [=](ov::pass::pattern::Matcher& m) {
NodeRegistry rg;
auto pattern_map = m.get_pattern_map();
auto concat = pattern_map.at(concat_1);
Expand Down Expand Up @@ -148,6 +150,6 @@ ov::pass::AUGRUCellFusion::AUGRUCellFusion() {
return true;
};

auto m = make_shared<Matcher>(add_3, matcher_name);
auto m = make_shared<ov::pass::pattern::Matcher>(add_3, matcher_name);
this->register_matcher(m, callback);
}
Loading
Loading