[Core/CC]Verify add_matcher scope for Conditinal Compilation. (#13148)

* My verification: libopenvino.so original size: 10799560 After adding this patch, new size: 10684744 Reduce: (10799560 - 10684744)/1024.0 = 112.125K. Signed-off-by: Yan, Xiping <xiping.yan@intel.com> * try to fix clang issue * Merge xuejun/cc_test Signed-off-by: Yan, Xiping <xiping.yan@intel.com> * Test Signed-off-by: xuejun <Xuejun.Zhai@intel.com> * TEST1 Signed-off-by: xuejun <Xuejun.Zhai@intel.com> * TEST2 Signed-off-by: xuejun <Xuejun.Zhai@intel.com> * Complete Add_matcher wraper. Signed-off-by: Yan, Xiping <xiping.yan@intel.com> * register_pass rebase Signed-off-by: Yan, Xiping <xiping.yan@intel.com> * fix clang issue. Signed-off-by: Yan, Xiping <xiping.yan@intel.com> * fix some replace error. Signed-off-by: Yan, Xiping <xiping.yan@intel.com> * 1: Rename ADD_MATCHER_SCOPE_WITH_OBJ -> ADD_MATCHER_SCOPE; 2: Remove debug info; 3: Fix bug: REGISTER_PASS_WITH_FALSE_ Signed-off-by: Yan, Xiping <xiping.yan@intel.com> * Add ADD_MATCHER_SCOPE_WITHOUT_NSPACE macro Signed-off-by: Yan, Xiping <xiping.yan@intel.com> * fix macro define issue. * Add register_pass for cnn_network_ngraph_impl.cpp Signed-off-by: Yan, Xiping <xiping.yan@intel.com> * Try to fix vpux plugin fail issue. Signed-off-by: Yan, Xiping <xiping.yan@intel.com> * Fix clang issue Signed-off-by: Yan, Xiping <xiping.yan@intel.com> * Merge macro "REGISTER_PASS_MODEL_SCOPE" and "REGISTER_PASS_FUNCTION_SCOPE" to "REGISTER_PASS_SCOPE" Signed-off-by: Yan, Xiping <xiping.yan@intel.com> * Rename "REGISTER_PASS_SCOPE_WITH_FALSE" to "REGISTER_DISABLED_PASS_SCOPE_WITH" Signed-off-by: Yan, Xiping <xiping.yan@intel.com> * Rename ADD_MATCHER_SCOPE_WITHOUT_OBJ to ADD_MATCHER_SCOPE_FOR_THIS ADD_MATCHER_SCOPE_WITHOUT_NSPACE to ADD_MATCHER_SCOPE_FOR_THIS_WITHOUT_NSPACE Signed-off-by: Yan, Xiping <xiping.yan@intel.com> * In order to implement CC, I have to move "StridesOptimization()" constructor to cpp file. Signed-off-by: Yan, Xiping <xiping.yan@intel.com> * Remove "SCOPE" in macro. Signed-off-by: Yan, Xiping <xiping.yan@intel.com> * Recover changes to fix clang issue. Signed-off-by: Yan, Xiping <xiping.yan@intel.com> * Remove "REGISTER_PASS_MODEL_IF" Signed-off-by: Yan, Xiping <xiping.yan@intel.com> * 1: Remove "ADD_MATCHER_FOR_THIS_WITHOUT_NSPACE"; 2: Remove param "nspace" in Macro, replace with "using namespace " in local. Signed-off-by: Yan, Xiping <xiping.yan@intel.com> * fix missing update. * For MACRO REGISTER_PASS: 1: Only keep a external macro define; 2: Judge 3 possibilities, if one of them is true, it will be disable; Signed-off-by: Yan, Xiping <xiping.yan@intel.com> * Optimize ADD_MATCHER_FOR_THIS. -# define ADD_MATCHER_FOR_THIS(region, ...) add_matcher<region>(__VA_ARGS__); +# define ADD_MATCHER_FOR_THIS(region, ...) ADD_MATCHER(this, region, __VA_ARGS__) Signed-off-by: Yan, Xiping <xiping.yan@intel.com> * Update src/common/conditional_compilation/include/openvino/cc/pass/itt.hpp Co-authored-by: Ilya Churaev <ilyachur@gmail.com> * Update src/common/conditional_compilation/include/openvino/cc/pass/itt.hpp Co-authored-by: Ilya Churaev <ilyachur@gmail.com> * Update src/common/conditional_compilation/include/openvino/cc/pass/itt.hpp Co-authored-by: Ilya Churaev <ilyachur@gmail.com> * Update src/common/conditional_compilation/include/openvino/cc/pass/itt.hpp Co-authored-by: Ilya Churaev <ilyachur@gmail.com> * clang format * Update OR defiation in MACRO, increasing code scalability. Signed-off-by: Yan, Xiping <xiping.yan@intel.com> * Fix window compiles error. Signed-off-by: Yan, Xiping <xiping.yan@intel.com> Signed-off-by: Yan, Xiping <xiping.yan@intel.com> Signed-off-by: xuejun <Xuejun.Zhai@intel.com> Co-authored-by: xuejun <Xuejun.Zhai@intel.com> Co-authored-by: Ilya Churaev <ilyachur@gmail.com>
2022-11-20 19:02:42 +03:00
1 parent 80b9a5eeae
commit 2a7dc5404b
@@ -64,11 +64,7 @@ public:
 class ov::pass::StridesOptimization : public ov::pass::BackwardGraphRewrite {
 public:
    OPENVINO_RTTI("StridesOptimization", "0");
-    StridesOptimization() {
-        add_matcher<ov::pass::ConvStridesPropagation>();
-        add_matcher<ov::pass::SupportedNodesStridesPropagation>();
-        add_matcher<ov::pass::UnsupportedNodesStridesPropagation>();
-    }
+    StridesOptimization();
 };

 namespace ngraph {
@@ -112,117 +112,115 @@ bool ov::pass::CommonOptimizations::run_on_model(const std::shared_ptr<ngraph::F
    ngraph::pass::Manager manager(get_pass_config());
    manager.set_per_pass_validation(false);

-    manager.register_pass<ov::pass::DisableDecompressionConvertConstantFolding>();
+    using namespace ngraph::pass;
+    using namespace ov::pass;
+    REGISTER_PASS(manager, DisableDecompressionConvertConstantFolding)

    // Disable low_precision_enabled as all plugins handle low-precision sub-graph manually
    // before CommonOptimization pipeline execution
-    manager.register_pass<ngraph::pass::MOCTransformations>(true, false);
+    REGISTER_PASS(manager, MOCTransformations, true, false)

    // Enabling conversion of FP16 IR to legacy representation, each plugin have to disable it
    // after support for FP16 IR is implemented
-    manager.register_pass<ov::pass::ConvertCompressedOnlyToLegacy>();
-
-    manager.register_pass<ov::pass::MarkPrecisionSensitiveDivides>();
-
-    // TODO: move to KMB
-    manager.register_pass<ngraph::pass::WeightsDequantizeToFakeQuantize>();
+    REGISTER_PASS(manager, ConvertCompressedOnlyToLegacy)
+    REGISTER_PASS(manager, MarkPrecisionSensitiveDivides)
+    REGISTER_PASS(manager, WeightsDequantizeToFakeQuantize)

    auto common_fusions = manager.register_pass<ngraph::pass::GraphRewrite>();
-    common_fusions->add_matcher<ngraph::pass::SpaceToBatchFusion>();
-    common_fusions->add_matcher<ngraph::pass::BatchToSpaceFusion>();
-    common_fusions->add_matcher<ngraph::pass::InterpolateSequenceFusion>();
-    common_fusions->add_matcher<ngraph::pass::SkipGatherBeforeTransposeAndReshape>();
-    common_fusions->add_matcher<ngraph::pass::ReduceMerge>();
+    ADD_MATCHER(common_fusions, SpaceToBatchFusion)
+    ADD_MATCHER(common_fusions, BatchToSpaceFusion)
+    ADD_MATCHER(common_fusions, InterpolateSequenceFusion)
+    ADD_MATCHER(common_fusions, SkipGatherBeforeTransposeAndReshape)
+    ADD_MATCHER(common_fusions, ReduceMerge)
    common_fusions->set_name("ngraph::pass::CommonFusions");

    manager.register_pass<ngraph::pass::ConcatReduceFusion>();
-
-    manager.register_pass<ngraph::pass::ConvertPadToGroupConvolution, false>();
-    manager.register_pass<ngraph::pass::ConvertInterpolate1ToInterpolate4, false>();
+    REGISTER_DISABLED_PASS(manager, ConvertPadToGroupConvolution)
+    REGISTER_DISABLED_PASS(manager, ConvertInterpolate1ToInterpolate4)

    auto decomp = manager.register_pass<ngraph::pass::GraphRewrite>();
-    decomp->add_matcher<ngraph::pass::Gelu7Downgrade>();
-    decomp->add_matcher<ngraph::pass::BidirectionalSequenceDecomposition>();
-    decomp->add_matcher<ngraph::pass::ReduceL1Decomposition>();
-    decomp->add_matcher<ngraph::pass::ReduceL2Decomposition>();
-    decomp->add_matcher<ngraph::pass::HSwishDecomposition>();
-    decomp->add_matcher<ngraph::pass::HSigmoidDecomposition>();
-    decomp->add_matcher<ngraph::pass::LogSoftmaxDecomposition>();
-    decomp->add_matcher<ngraph::pass::ConvertReduceToPooling>();
-    decomp->add_matcher<ngraph::pass::ConvertBroadcastToTiles>();
-    decomp->add_matcher<ngraph::pass::ConvertMod>();
-    decomp->add_matcher<ngraph::pass::ConvertGELU>();
-    decomp->add_matcher<ngraph::pass::ConvertMinimum>();
-    decomp->add_matcher<ngraph::pass::ConvertSubtract>();
-    decomp->add_matcher<ngraph::pass::ConvertDivide>();
-    decomp->add_matcher<ngraph::pass::ConvertDepthToSpace>();
-    decomp->add_matcher<ngraph::pass::ConvertSpaceToDepth>();
-    decomp->add_matcher<ngraph::pass::ConvertConvertLike>();
-    decomp->add_matcher<ngraph::pass::BatchNormDecomposition>();
-    decomp->add_matcher<ngraph::pass::MVN6Decomposition>();
+    ADD_MATCHER(decomp, Gelu7Downgrade)
+    ADD_MATCHER(decomp, BidirectionalSequenceDecomposition)
+    ADD_MATCHER(decomp, ReduceL1Decomposition)
+    ADD_MATCHER(decomp, ReduceL2Decomposition)
+    ADD_MATCHER(decomp, HSwishDecomposition)
+    ADD_MATCHER(decomp, HSigmoidDecomposition)
+    ADD_MATCHER(decomp, LogSoftmaxDecomposition)
+    ADD_MATCHER(decomp, ConvertReduceToPooling)
+    ADD_MATCHER(decomp, ConvertBroadcastToTiles)
+    ADD_MATCHER(decomp, ConvertMod)
+    ADD_MATCHER(decomp, ConvertGELU)
+    ADD_MATCHER(decomp, ConvertMinimum)
+    ADD_MATCHER(decomp, ConvertSubtract)
+    ADD_MATCHER(decomp, ConvertDivide)
+    ADD_MATCHER(decomp, ConvertDepthToSpace)
+    ADD_MATCHER(decomp, ConvertSpaceToDepth)
+    ADD_MATCHER(decomp, ConvertConvertLike)
+    ADD_MATCHER(decomp, BatchNormDecomposition)
+    ADD_MATCHER(decomp, MVN6Decomposition)
    decomp->add_matcher<ngraph::pass::NormalizeL2Decomposition, false>();
-    decomp->add_matcher<ngraph::pass::SimplifyCTCGreedyDecoderSeqLen>();
-    decomp->add_matcher<ngraph::pass::EinsumDecomposition>();
+    ADD_MATCHER(decomp, SimplifyCTCGreedyDecoderSeqLen)
+    ADD_MATCHER(decomp, EinsumDecomposition)
    decomp->add_matcher<ngraph::pass::SoftmaxDecomposition, false>();
-    decomp->add_matcher<ngraph::pass::SoftSignDecomposition>();
-    decomp->add_matcher<ngraph::pass::GatherNegativeConstIndicesNormalize>();
-    decomp->add_matcher<ngraph::pass::DropoutWithRandomUniformReplacer>();
-    decomp->add_matcher<ngraph::pass::TransposeReshapeEliminationForMatmul>();
-    decomp->add_matcher<ov::pass::EyeDecomposition>();
-    decomp->add_matcher<ov::pass::UniqueDecomposition>();
+    ADD_MATCHER(decomp, SoftSignDecomposition)
+    ADD_MATCHER(decomp, GatherNegativeConstIndicesNormalize)
+    ADD_MATCHER(decomp, DropoutWithRandomUniformReplacer)
+    ADD_MATCHER(decomp, TransposeReshapeEliminationForMatmul)
+    ADD_MATCHER(decomp, EyeDecomposition)
+    ADD_MATCHER(decomp, UniqueDecomposition)
    decomp->set_name("ngraph::pass::CommonDecompositions");

    // CF is required after all decompositions
-    manager.register_pass<ngraph::pass::ConstantFolding>();
+    REGISTER_PASS(manager, ConstantFolding)

    // LinOpSequenceFusion must be executed after all decompositions
    manager.register_pass<ngraph::pass::LinOpSequenceFusion>();
-    manager.register_pass<ngraph::pass::UnrollIf>();
+    REGISTER_PASS(manager, UnrollIf)

    auto multiply_fusions = manager.register_pass<ngraph::pass::GraphRewrite>();
-    multiply_fusions->add_matcher<ngraph::pass::ConvolutionMultiplyFusion>();
-    multiply_fusions->add_matcher<ngraph::pass::GroupConvolutionMultiplyFusion>();
-    multiply_fusions->add_matcher<ngraph::pass::ConvolutionBackpropDataMultiplyFusion>();
-    multiply_fusions->add_matcher<ngraph::pass::GroupConvolutionBackpropDataMultiplyFusion>();
-    multiply_fusions->add_matcher<ngraph::pass::MultiplyConvolutionFusion>();
-    multiply_fusions->add_matcher<ngraph::pass::MultiplyGroupConvolutionFusion>();
-    multiply_fusions->add_matcher<ngraph::pass::MultiplyConvolutionBackpropDataFusion>();
-    multiply_fusions->add_matcher<ngraph::pass::MultiplyGroupConvolutionBackpropDataFusion>();
-    multiply_fusions->add_matcher<ngraph::pass::MatMulMultiplyFusion>();
+    ADD_MATCHER(multiply_fusions, ConvolutionMultiplyFusion)
+    ADD_MATCHER(multiply_fusions, GroupConvolutionMultiplyFusion)
+    ADD_MATCHER(multiply_fusions, ConvolutionBackpropDataMultiplyFusion)
+    ADD_MATCHER(multiply_fusions, GroupConvolutionBackpropDataMultiplyFusion)
+    ADD_MATCHER(multiply_fusions, MultiplyConvolutionFusion)
+    ADD_MATCHER(multiply_fusions, MultiplyGroupConvolutionFusion)
+    ADD_MATCHER(multiply_fusions, MultiplyConvolutionBackpropDataFusion)
+    ADD_MATCHER(multiply_fusions, MultiplyGroupConvolutionBackpropDataFusion)
+    ADD_MATCHER(multiply_fusions, MatMulMultiplyFusion)
    multiply_fusions->set_name("ngraph::pass::MultiplyFusions");

-    manager.register_pass<ngraph::pass::ConstantFolding>();
-    manager.register_pass<ngraph::pass::ConvertGather8ToGather7>();  // not plugins implemented gather8
-    manager.register_pass<ngraph::pass::ConvertGather7ToGather1>();  // not plugins implemented gather7
-    manager.register_pass<ngraph::pass::ConvertGather1ToGather7, false>();
-    manager.register_pass<ngraph::pass::ConvertGather7ToGather8, false>();
-    manager.register_pass<ngraph::pass::ConvertDeformableConv8To1>();
-    manager.register_pass<ngraph::pass::ConvertSoftMax8ToSoftMax1>();
-    manager.register_pass<ngraph::pass::ConvertSoftMax1ToSoftMax8, false>();
-    manager.register_pass<ngraph::pass::ConvertMaxPool8ToMaxPool1>();
-    manager.register_pass<ngraph::pass::ConvertMaxPool1ToMaxPool8, false>();
-    manager.register_pass<ngraph::pass::ConvertPriorBox8To0>();  // not plugins implemented priorbox8
-    manager.register_pass<ngraph::pass::ConvertDetectionOutput1ToDetectionOutput8, false>();
-    manager.register_pass<ngraph::pass::ConvertDetectionOutput8ToDetectionOutput1>();
-    manager.register_pass<ngraph::pass::ConvertROIAlign3To9, false>();
-    manager.register_pass<ngraph::pass::ConvertROIAlign9To3>();
-    manager.register_pass<ngraph::pass::ConvertMulticlassNms8ToMulticlassNms9>();
+    REGISTER_PASS(manager, ConstantFolding)
+    REGISTER_PASS(manager, ConvertGather8ToGather7)  // not plugins implemented gather8
+    REGISTER_PASS(manager, ConvertGather7ToGather1)  // not plugins implemented gather7
+
+    REGISTER_DISABLED_PASS(manager, ConvertGather1ToGather7)
+    REGISTER_DISABLED_PASS(manager, ConvertGather7ToGather8)
+    REGISTER_PASS(manager, ConvertDeformableConv8To1)
+    REGISTER_PASS(manager, ConvertSoftMax8ToSoftMax1)
+    REGISTER_DISABLED_PASS(manager, ConvertSoftMax1ToSoftMax8)
+    REGISTER_PASS(manager, ConvertMaxPool8ToMaxPool1)
+    REGISTER_DISABLED_PASS(manager, ConvertMaxPool1ToMaxPool8)
+    REGISTER_PASS(manager, ConvertPriorBox8To0)
+    REGISTER_DISABLED_PASS(manager, ConvertDetectionOutput1ToDetectionOutput8)
+    REGISTER_PASS(manager, ConvertDetectionOutput8ToDetectionOutput1)
+    REGISTER_DISABLED_PASS(manager, ConvertROIAlign3To9)
+    REGISTER_PASS(manager, ConvertROIAlign9To3)
+    REGISTER_PASS(manager, ConvertMulticlassNms8ToMulticlassNms9)

    auto fq_fusions = manager.register_pass<ngraph::pass::GraphRewrite>();
-    fq_fusions->add_matcher<ngraph::pass::FakeQuantizeMulFusion>();
-    fq_fusions->add_matcher<ngraph::pass::FakeQuantizeReshapeFusion>();
-    fq_fusions->add_matcher<ngraph::pass::PullTransposeThroughFQUp>();
-    fq_fusions->add_matcher<ngraph::pass::ReluFakeQuantizeFusion>();
-    fq_fusions->add_matcher<ngraph::pass::AddFakeQuantizeFusion>();
-    fq_fusions->add_matcher<ngraph::pass::MulFakeQuantizeFusion>();
+    ADD_MATCHER(fq_fusions, FakeQuantizeMulFusion)
+    ADD_MATCHER(fq_fusions, FakeQuantizeReshapeFusion)
+    ADD_MATCHER(fq_fusions, PullTransposeThroughFQUp)
+    ADD_MATCHER(fq_fusions, ReluFakeQuantizeFusion)
+    ADD_MATCHER(fq_fusions, AddFakeQuantizeFusion)
+    ADD_MATCHER(fq_fusions, MulFakeQuantizeFusion)
    fq_fusions->set_name("ngraph::pass::FakeQuantizeFusions");

    // StridesOptimization should be at the very end
    // because we cannot insert any MaxPools since they may prevent
    // other optimizations
    manager.register_pass<ngraph::pass::StridesOptimization>();
-    manager.register_pass<ngraph::pass::Validate>();
-
+    REGISTER_PASS(manager, Validate)
    manager.run_passes(f);

    // Returning value is false because pass::Manager always apply Validation pass
@@ -130,7 +130,7 @@ ov::pass::ReplaceConcatReduceByMinOrMax::ReplaceConcatReduceByMinOrMax() {
 }

 ov::pass::ConcatReduceFusion::ConcatReduceFusion() {
-    add_matcher<ReplaceConcatReduceByMinOrMax>();
-    add_matcher<PullSqueezeThroughEltwise>();
-    add_matcher<EliminateSqueeze>();
+    ADD_MATCHER_FOR_THIS(ReplaceConcatReduceByMinOrMax)
+    ADD_MATCHER_FOR_THIS(PullSqueezeThroughEltwise)
+    ADD_MATCHER_FOR_THIS(EliminateSqueeze)
 }
@@ -35,8 +35,9 @@ bool ov::pass::ConvertCompressedOnlyToLegacy::run_on_model(const std::shared_ptr

        const precisions_array convert_precision_list{{ov::element::f32, ov::element::f16}};
        manager.register_pass<ngraph::pass::ConvertPrecision>(convert_precision_list);
-        manager.register_pass<ov::pass::EnableDecompressionConvertConstantFolding>();
-        manager.register_pass<ov::pass::ConstantFolding>();
+        using namespace ov::pass;
+        REGISTER_PASS(manager, EnableDecompressionConvertConstantFolding)
+        REGISTER_PASS(manager, ConstantFolding)

        manager.run_passes(f);
    }
@@ -103,7 +103,7 @@ public:
 }  // namespace ov

 ov::pass::ConvertNmsGatherPathToUnsigned::ConvertNmsGatherPathToUnsigned() {
-    add_matcher<InitNMSPath>();
-    add_matcher<PropagateNMSPath>();
-    add_matcher<UpdateConvertGather>();
+    ADD_MATCHER_FOR_THIS(InitNMSPath)
+    ADD_MATCHER_FOR_THIS(PropagateNMSPath)
+    ADD_MATCHER_FOR_THIS(UpdateConvertGather)
 }
@@ -13,8 +13,8 @@
 bool ov::pass::MOCLegacyTransformations::run_on_model(const std::shared_ptr<ov::Model>& f) {
    RUN_ON_MODEL_SCOPE(MOCLegacyTransformations);
    ov::pass::Manager manager(get_pass_config());
-
-    manager.register_pass<ov::pass::ChangePlaceholderTypes>(m_params_with_custom_types);
+    using namespace ov::pass;
+    REGISTER_PASS(manager, ChangePlaceholderTypes, m_params_with_custom_types)
    manager.run_passes(f);

    return false;
@@ -93,8 +93,8 @@ bool ov::pass::MOCTransformations::run_on_model(const std::shared_ptr<ngraph::Fu

    ov::pass::Manager manager(get_pass_config());
    manager.set_per_pass_validation(false);
-
-    manager.register_pass<ngraph::pass::InitNodeInfo>();
+    using namespace ngraph::pass;
+    REGISTER_PASS(manager, InitNodeInfo)
    if (m_low_precision_enabled) {
        manager.register_pass<ov::pass::MarkDequantizationSubgraph>(
            element::TypeVector{ngraph::element::i8, ngraph::element::u8, ngraph::element::i4, ngraph::element::u4});
@@ -108,125 +108,125 @@ bool ov::pass::MOCTransformations::run_on_model(const std::shared_ptr<ngraph::Fu
    // Zero dimensions in shape causes creation empty tensors, which are incorrect during CF.
    // In particular, if zero dim tensor is consumed in body of MultiSubGraphOp
    // RemoveConcatZeroDimInput and RemoveMultiSubGraphOpDanglingParams should be called together.
-    manager.register_pass<ov::pass::RemoveConcatZeroDimInput>();
-    manager.register_pass<ov::pass::Validate>();
-    manager.register_pass<ov::pass::RemoveMultiSubGraphOpDanglingParams>();
-    manager.register_pass<ov::pass::FoldSubgraphEmptyInputs>();
-    manager.register_pass<ov::pass::DisableRandomUniformConstantFolding>();
-    manager.register_pass<ov::pass::ConstantFolding>();
-    manager.register_pass<ov::pass::Validate>();
+    using namespace ov::pass;
+    REGISTER_PASS(manager, RemoveConcatZeroDimInput)
+    REGISTER_PASS(manager, Validate)
+    REGISTER_PASS(manager, RemoveMultiSubGraphOpDanglingParams)
+    REGISTER_PASS(manager, FoldSubgraphEmptyInputs)
+    REGISTER_PASS(manager, DisableRandomUniformConstantFolding)
+    REGISTER_PASS(manager, ConstantFolding)
+    REGISTER_PASS(manager, Validate)

    // FusedFilteringBoxesBySize transformation has the complex pattern
    // which can be affected by further transformations. So we have to
    // execute it at the beginning of the pipeline. Also, this pass resolves
    // dynamism, so we have to execute type/shape propagation after.
-    manager.register_pass<ov::pass::FuseFilteringBoxesBySize>();
-    manager.register_pass<ov::pass::Validate>();
+    REGISTER_PASS(manager, FuseFilteringBoxesBySize)
+    REGISTER_PASS(manager, Validate)

    if (!m_use_shapes) {  // Approved Smart Reshape
-        manager.register_pass<ov::pass::LSTMStatesBroadcast>();
-        manager.register_pass<ov::pass::Validate>();
-        manager.register_pass<ov::pass::ReshapeSinkingMatMul>();
-        manager.register_pass<ov::pass::Validate>();
+        REGISTER_PASS(manager, LSTMStatesBroadcast)
+        REGISTER_PASS(manager, Validate)
+        REGISTER_PASS(manager, ReshapeSinkingMatMul)
+        REGISTER_PASS(manager, Validate)
    }
+    REGISTER_PASS(manager, ConvertQuantizeDequantize)
+    REGISTER_PASS(manager, SimplifyShapeOfSubGraph)

-    manager.register_pass<ov::pass::ConvertQuantizeDequantize>();
-    manager.register_pass<ov::pass::SimplifyShapeOfSubGraph>();
    if (!m_use_shapes) {
        manager.register_pass<ov::pass::DisableShapeOfConstantFolding>();
    }
    // workaround until dynamism in NMS is not supported
-    manager.register_pass<ov::pass::ConvertNmsGatherPathToUnsigned>();
-    manager.register_pass<ov::pass::StridedSliceOptimization>(m_use_shapes);
-    manager.register_pass<ov::pass::BroadcastElementwiseFusion>();
-    manager.register_pass<ov::pass::PullThroughReduce>();
+    REGISTER_PASS(manager, ConvertNmsGatherPathToUnsigned)
+    REGISTER_PASS(manager, StridedSliceOptimization, m_use_shapes)
+    REGISTER_PASS(manager, BroadcastElementwiseFusion)
+    REGISTER_PASS(manager, PullThroughReduce)

    auto transpose_sinking = manager.register_pass<ov::pass::GraphRewrite>();
-    transpose_sinking->add_matcher<ov::pass::TransposeSinking>();
+    ADD_MATCHER(transpose_sinking, TransposeSinking)
+
    // SplitSqueezeConcatFusion should work in same GraphRewrite as TransposesSinking,
    // because it replaces pattern that may contain Transposes which must be optimized before
    // the transformation and it also inserts Transpose that can be optimized by TransposeSinking
-    transpose_sinking->add_matcher<ov::pass::SplitSqueezeConcatFusion>();
+    ADD_MATCHER(transpose_sinking, SplitSqueezeConcatFusion)

    auto eliminations = manager.register_pass<ov::pass::GraphRewrite>();
-    eliminations->add_matcher<ov::pass::EliminateUnsqueezeGather>();
-    eliminations->add_matcher<ov::pass::NopElimination>(m_use_shapes /* do not use shape for elimination */);
+    ADD_MATCHER(eliminations, EliminateUnsqueezeGather)
+    ADD_MATCHER(eliminations, NopElimination, m_use_shapes)
    eliminations->set_name("ov::pass::CommonEliminations");

    manager.register_pass<ov::pass::ConstantFolding>();

    auto common_fusions = manager.register_pass<ov::pass::GraphRewrite>();
-    common_fusions->add_matcher<ngraph::pass::ConvertScatterElementsToScatter>();
-    common_fusions->add_matcher<ov::pass::SoftPlusFusion>();
-    common_fusions->add_matcher<ov::pass::SoftPlusToMishFusion>();
-    common_fusions->add_matcher<ov::pass::SwishFusion>();
-    common_fusions->add_matcher<ov::pass::HSwishFusion>();
-    common_fusions->add_matcher<ov::pass::HSigmoidFusion>();
-    common_fusions->add_matcher<ov::pass::NormalizeL2Fusion>();
-    common_fusions->add_matcher<ov::pass::ClampFusion>();
-    common_fusions->add_matcher<ov::pass::PadFusion>();
-    common_fusions->add_matcher<ov::pass::SoftmaxFusion>();
-    common_fusions->add_matcher<ov::pass::ReduceReshapeFusion>();
-    common_fusions->add_matcher<ov::pass::MVNFusion>();
-    common_fusions->add_matcher<ov::pass::DilatedConvolutionConverter>();
-    common_fusions->add_matcher<ov::pass::GeluFusion>();
-    common_fusions->add_matcher<ov::pass::LeakyReluFusion>();
-    common_fusions->add_matcher<ov::pass::RandomUniformFusion>();
-    common_fusions->add_matcher<ov::pass::EliminateDuplicateTIInputs>();
-    common_fusions->add_matcher<ov::pass::GRUCellFusion>();
-    common_fusions->add_matcher<ov::pass::SequenceFusion>();
-    common_fusions->add_matcher<ngraph::pass::ConvertTensorIteratorToSequence>();
-    common_fusions->add_matcher<ngraph::pass::SplitConcatPairToInterpolateFusion>(m_use_shapes);
+    ADD_MATCHER(common_fusions, ConvertScatterElementsToScatter)
+    ADD_MATCHER(common_fusions, SoftPlusFusion)
+    ADD_MATCHER(common_fusions, SoftPlusToMishFusion)
+    ADD_MATCHER(common_fusions, SwishFusion)
+    ADD_MATCHER(common_fusions, HSwishFusion)
+    ADD_MATCHER(common_fusions, HSigmoidFusion)
+    ADD_MATCHER(common_fusions, NormalizeL2Fusion)
+    ADD_MATCHER(common_fusions, ClampFusion)
+    ADD_MATCHER(common_fusions, PadFusion)
+    ADD_MATCHER(common_fusions, SoftmaxFusion)
+    ADD_MATCHER(common_fusions, ReduceReshapeFusion)
+    ADD_MATCHER(common_fusions, MVNFusion)
+    ADD_MATCHER(common_fusions, DilatedConvolutionConverter)
+    ADD_MATCHER(common_fusions, GeluFusion)
+    ADD_MATCHER(common_fusions, LeakyReluFusion)
+    ADD_MATCHER(common_fusions, RandomUniformFusion)
+    ADD_MATCHER(common_fusions, EliminateDuplicateTIInputs)
+    ADD_MATCHER(common_fusions, GRUCellFusion)
+    ADD_MATCHER(common_fusions, SequenceFusion)
+    ADD_MATCHER(common_fusions, ConvertTensorIteratorToSequence)
+    ADD_MATCHER(common_fusions, SplitConcatPairToInterpolateFusion, m_use_shapes)
    if (m_use_shapes) {
-        common_fusions->add_matcher<ov::pass::NearestNeighborUpsamplingFusion>();
+        ADD_MATCHER(common_fusions, NearestNeighborUpsamplingFusion)
    }
-    common_fusions->add_matcher<ov::pass::DivideFusion>();
-    common_fusions->add_matcher<ov::pass::SubtractFusion>();
-    common_fusions->add_matcher<ov::pass::TransposeToReshape>();
-    common_fusions->add_matcher<ov::pass::ReshapeSequenceFusion>(m_use_shapes);
-    common_fusions->add_matcher<ov::pass::MatMulConstTransposesExtraction>();
-    common_fusions->add_matcher<ov::pass::PReluFusion>();
-    common_fusions->add_matcher<ov::pass::DepthToSpaceFusion>();
-    common_fusions->add_matcher<ov::pass::ShuffleChannelsFusion>(!m_use_shapes);
+
+    ADD_MATCHER(common_fusions, DivideFusion)
+    ADD_MATCHER(common_fusions, SubtractFusion)
+    ADD_MATCHER(common_fusions, TransposeToReshape)
+    ADD_MATCHER(common_fusions, ReshapeSequenceFusion, m_use_shapes)
+    ADD_MATCHER(common_fusions, MatMulConstTransposesExtraction)
+    ADD_MATCHER(common_fusions, PReluFusion)
+    ADD_MATCHER(common_fusions, DepthToSpaceFusion)
+    ADD_MATCHER(common_fusions, ShuffleChannelsFusion, !m_use_shapes)
    common_fusions->set_name("ov::pass::CommonFusions");

-    manager.register_pass<ov::pass::BinarizeWeights>();
-    manager.register_pass<ov::pass::ConvToBinaryConv>();
+    REGISTER_PASS(manager, BinarizeWeights)
+    REGISTER_PASS(manager, ConvToBinaryConv)

    auto decomp = manager.register_pass<ov::pass::GraphRewrite>();
-    decomp->add_matcher<ngraph::pass::BatchNormDecomposition>();
-    decomp->add_matcher<ngraph::pass::ConvertDivideWithConstant>();
-    decomp->add_matcher<ngraph::pass::ConvertNegative>();
+    ADD_MATCHER(decomp, BatchNormDecomposition)
+    ADD_MATCHER(decomp, ConvertDivideWithConstant)
+    ADD_MATCHER(decomp, ConvertNegative)

    manager.register_pass<ov::pass::LinOpSequenceFusion>();

    auto multiply_fusions = manager.register_pass<ov::pass::GraphRewrite>();
-    multiply_fusions->add_matcher<ov::pass::ConvolutionMultiplyFusion>();
-    multiply_fusions->add_matcher<ov::pass::GroupConvolutionMultiplyFusion>();
-    multiply_fusions->add_matcher<ov::pass::ConvolutionBackpropDataMultiplyFusion>();
-    multiply_fusions->add_matcher<ov::pass::GroupConvolutionBackpropDataMultiplyFusion>();
-    multiply_fusions->add_matcher<ov::pass::MultiplyConvolutionFusion>();
-    multiply_fusions->add_matcher<ov::pass::MultiplyGroupConvolutionFusion>();
-    multiply_fusions->add_matcher<ov::pass::MultiplyConvolutionBackpropDataFusion>();
-    multiply_fusions->add_matcher<ov::pass::MultiplyGroupConvolutionBackpropDataFusion>();
-    multiply_fusions->add_matcher<ov::pass::MatMulMultiplyFusion>();
+    ADD_MATCHER(multiply_fusions, ConvolutionMultiplyFusion)
+    ADD_MATCHER(multiply_fusions, GroupConvolutionMultiplyFusion)
+    ADD_MATCHER(multiply_fusions, ConvolutionBackpropDataMultiplyFusion)
+    ADD_MATCHER(multiply_fusions, GroupConvolutionBackpropDataMultiplyFusion)
+    ADD_MATCHER(multiply_fusions, MultiplyConvolutionFusion)
+    ADD_MATCHER(multiply_fusions, MultiplyGroupConvolutionFusion)
+    ADD_MATCHER(multiply_fusions, MultiplyConvolutionBackpropDataFusion)
+    ADD_MATCHER(multiply_fusions, MultiplyGroupConvolutionBackpropDataFusion)
+    ADD_MATCHER(multiply_fusions, MatMulMultiplyFusion)
    multiply_fusions->set_name("ov::pass::MultiplyFusions");
-    manager.register_pass<ov::pass::ConstantFolding>();
+    REGISTER_PASS(manager, ConstantFolding)

    auto fq_fusions = manager.register_pass<ov::pass::GraphRewrite>();
-    fq_fusions->add_matcher<ov::pass::FakeQuantizeMulFusion>();
-    fq_fusions->add_matcher<ov::pass::FakeQuantizeReshapeFusion>();
-    fq_fusions->add_matcher<ov::pass::PullTransposeThroughFQUp>();
-    fq_fusions->add_matcher<ov::pass::ReluFakeQuantizeFusion>();
-    fq_fusions->add_matcher<ov::pass::AddFakeQuantizeFusion>();
-    fq_fusions->add_matcher<ov::pass::MulFakeQuantizeFusion>();
+    ADD_MATCHER(fq_fusions, FakeQuantizeMulFusion)
+    ADD_MATCHER(fq_fusions, FakeQuantizeReshapeFusion)
+    ADD_MATCHER(fq_fusions, PullTransposeThroughFQUp)
+    ADD_MATCHER(fq_fusions, ReluFakeQuantizeFusion)
+    ADD_MATCHER(fq_fusions, AddFakeQuantizeFusion)
+    ADD_MATCHER(fq_fusions, MulFakeQuantizeFusion)
    fq_fusions->set_name("ov::pass::FakeQuantizeFusions");
-
-    manager.register_pass<ov::pass::ReverseInputChannelsFusion>();
-
-    manager.register_pass<ov::pass::AlignEltwiseInputRanks>();
-
-    manager.register_pass<ov::pass::ConstantFolding>();
+    REGISTER_PASS(manager, ReverseInputChannelsFusion)
+    REGISTER_PASS(manager, AlignEltwiseInputRanks)
+    REGISTER_PASS(manager, ConstantFolding)

    manager.run_passes(f);

@@ -720,20 +720,22 @@ pass::EliminateEltwise::EliminateEltwise() {

 ngraph::pass::NopElimination::NopElimination(bool use_shape_for_elimination) {
    // shape-agnostic transformations
-    add_matcher<EliminatePad>();
-    add_matcher<EliminateConvert>();
-    add_matcher<EliminateConvertNonZero>();
-    add_matcher<EliminateConcat>();
-    add_matcher<EliminateSplit>();
-    add_matcher<EliminateTranspose>();
-    add_matcher<EliminateEltwise>();
-    add_matcher<ov::pass::EliminateSplitConcat>();
+    ADD_MATCHER_FOR_THIS(EliminatePad)
+    ADD_MATCHER_FOR_THIS(EliminateConvert)
+    ADD_MATCHER_FOR_THIS(EliminateConvertNonZero)
+    ADD_MATCHER_FOR_THIS(EliminateConcat)
+    ADD_MATCHER_FOR_THIS(EliminateSplit)
+    ADD_MATCHER_FOR_THIS(EliminateTranspose)
+    ADD_MATCHER_FOR_THIS(EliminateEltwise)
+    using namespace ov::pass;
+    ADD_MATCHER_FOR_THIS(EliminateSplitConcat)
+
    // shape-dependent transformations
    if (use_shape_for_elimination) {
-        add_matcher<EliminateReshape>();
-        add_matcher<EliminateSqueeze>();
-        add_matcher<EliminateUnsqueeze>();
-        add_matcher<EliminateBroadcast>();
-        add_matcher<EliminateGather>();
+        ADD_MATCHER_FOR_THIS(EliminateReshape)
+        ADD_MATCHER_FOR_THIS(EliminateSqueeze)
+        ADD_MATCHER_FOR_THIS(EliminateUnsqueeze)
+        ADD_MATCHER_FOR_THIS(EliminateBroadcast)
+        ADD_MATCHER_FOR_THIS(EliminateGather)
    }
 }
@@ -257,8 +257,10 @@ ov::pass::StridedSliceOptimization::StridedSliceOptimization(bool use_shapes) {

 bool ov::pass::StridedSliceOptimization::run_on_model(const std::shared_ptr<ngraph::Function>& f) {
    RUN_ON_FUNCTION_SCOPE(StridedSliceOptimization);
+
    ov::pass::Manager manager(get_pass_config());
-    manager.register_pass<ngraph::pass::SliceToStridedSlice>(m_use_shapes);
+    using namespace ngraph::pass;
+    REGISTER_PASS(manager, SliceToStridedSlice, m_use_shapes)
    manager.run_passes(f);

    bool rewritten = false;
@@ -14,8 +14,8 @@
 #include "transformations/common_optimizations/subtract_fusion.hpp"

 ov::pass::FuseFilteringBoxesBySize::FuseFilteringBoxesBySize() {
-    add_matcher<SubtractFusion>();
-    add_matcher<RemoveFilteringBoxesBySize>();
+    ADD_MATCHER_FOR_THIS(SubtractFusion);
+    ADD_MATCHER_FOR_THIS(RemoveFilteringBoxesBySize);
 }

 ov::pass::RemoveFilteringBoxesBySize::RemoveFilteringBoxesBySize() {
@@ -823,28 +823,41 @@ bool ov::pass::ReverseInputChannelsFusion::run_on_model(const std::shared_ptr<ov
    NodeVector nodes_to_fuse;
    // First we need to initialize and propagate RIC attributes through entire graph
    auto ric_prop = m.register_pass<GraphRewrite>();
-    ric_prop->add_matcher<init::SplitConcat>(nodes_to_fuse);
-    ric_prop->add_matcher<init::Gather>(nodes_to_fuse);
-    ric_prop->add_matcher<prop::Convolution>();
-    ric_prop->add_matcher<prop::GroupConvolution>();
-    ric_prop->add_matcher<prop::Binary>();
-    ric_prop->add_matcher<prop::ShapeOf>();
-    ric_prop->add_matcher<prop::Transpose>();
-    ric_prop->add_matcher<prop::PassThrough>();
-    ric_prop->add_matcher<prop::Unsupported>();
+    {
+        using namespace init;
+        ADD_MATCHER(ric_prop, SplitConcat, nodes_to_fuse)
+        ADD_MATCHER(ric_prop, Gather, nodes_to_fuse)
+    }
+
+    {
+        using namespace prop;
+        ADD_MATCHER(ric_prop, Convolution)
+        ADD_MATCHER(ric_prop, GroupConvolution)
+        ADD_MATCHER(ric_prop, Binary)
+        ADD_MATCHER(ric_prop, ShapeOf)
+        ADD_MATCHER(ric_prop, Transpose)
+        ADD_MATCHER(ric_prop, PassThrough)
+        ADD_MATCHER(ric_prop, Unsupported)
+    }

    // Handle quantized weights case (dequantize sub-graph is on the weights path)
    auto ric_back_prop = m.register_pass<ov::pass::BackwardGraphRewrite>();
-    ric_back_prop->add_matcher<back_prop::Binary>();
-    ric_back_prop->add_matcher<back_prop::ConvertPassThrough>();
-    m.register_pass<back_prop::Constant>();
+    {
+        using namespace back_prop;
+        ADD_MATCHER(ric_back_prop, Binary)
+        ADD_MATCHER(ric_back_prop, ConvertPassThrough)
+        REGISTER_PASS(m, Constant)
+    }
    // TODO: validate attributes by request

    // Second we fuse available RIC into nodes and remove original nodes related to fused RIC
    auto ric_fuse = m.register_pass<GraphRewrite>();
-    ric_fuse->add_matcher<fuse::InsertReverseInputChannel>(nodes_to_fuse);
-    ric_fuse->add_matcher<fuse::EraseSplitConcat>();
-    ric_fuse->add_matcher<fuse::EraseGather>();
+    {
+        using namespace fuse;
+        ADD_MATCHER(ric_fuse, InsertReverseInputChannel, nodes_to_fuse)
+        ADD_MATCHER(ric_fuse, EraseSplitConcat)
+        ADD_MATCHER(ric_fuse, EraseGather)
+    }

    m.run_passes(model);
    return false;
@@ -325,17 +325,21 @@ bool ov::pass::SimplifyShapeOfSubGraph::run_on_model(const std::shared_ptr<ngrap
    RUN_ON_FUNCTION_SCOPE(SimplifyShapeOfSubGraph);
    ov::pass::Manager manager;
    manager.set_per_pass_validation(false);
-    manager.register_pass<ov::pass::EliminateGatherUnsqueeze>();
-    manager.register_pass<ov::pass::SharedShapeOf>();
-    manager.register_pass<ov::pass::GroupedGatherElimination>();
+
+    using namespace ov::pass;
+    REGISTER_PASS(manager, EliminateGatherUnsqueeze)
+    REGISTER_PASS(manager, SharedShapeOf)
+    REGISTER_PASS(manager, GroupedGatherElimination)
    // GatherNopElimination depends on shape, so it requires shape propagation
    // if previous transformations has resolved some dynamic shapes.
-    manager.register_pass<ov::pass::Validate>();
-    manager.register_pass<ov::pass::GatherNopElimination>();
-    manager.register_pass<ov::pass::SimplifyGatherShapeOf>();
-    manager.register_pass<ov::pass::SimplifySecondInputOfReshape>();
+    REGISTER_PASS(manager, Validate)
+    REGISTER_PASS(manager, GatherNopElimination)
+    REGISTER_PASS(manager, SimplifyGatherShapeOf)
+    REGISTER_PASS(manager, SimplifySecondInputOfReshape)
+
    // TODO: potentially this Validate is not needed but it requires additional validation
-    manager.register_pass<ov::pass::Validate>();
+    REGISTER_PASS(manager, Validate)
+
    manager.run_passes(f);
    return false;
 }
@@ -207,3 +207,10 @@ ov::pass::UnsupportedNodesStridesPropagation::UnsupportedNodesStridesPropagation
    auto m = std::make_shared<pattern::Matcher>(root, matcher_name);
    this->register_matcher(m, callback);
 }
+
+ov::pass::StridesOptimization::StridesOptimization() {
+    using namespace ov::pass;
+    ADD_MATCHER_FOR_THIS(ConvStridesPropagation);
+    ADD_MATCHER_FOR_THIS(SupportedNodesStridesPropagation);
+    ADD_MATCHER_FOR_THIS(UnsupportedNodesStridesPropagation);
+}