[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>

src/common/low_precision_transformations/src/low_precision.cpp

@@ -74,15 +74,14 @@
 #include "low_precision/move_fake_quantize.hpp"
 
 // cleanup transformations
+#include "itt.hpp"
 #include "low_precision/convert.hpp"
 #include "low_precision/fold_fake_quantize.hpp"
 #include "low_precision/fuse_convert.hpp"
-#include "low_precision/fuse_subtract_to_fake_quantize.hpp"
 #include "low_precision/fuse_multiply_to_fake_quantize.hpp"
+#include "low_precision/fuse_subtract_to_fake_quantize.hpp"
 #include "low_precision/multiply_to_group_convolution.hpp"
 
-#include "itt.hpp"
-
 ngraph::pass::low_precision::LowPrecision::LowPrecision(
     const std::vector<PrecisionsRestriction>& precisionRestrictions,
     const std::vector<QuantizationGranularityRestriction>& quantizationRestrictions,
@@ -200,62 +199,70 @@ bool ngraph::pass::low_precision::LowPrecision::run_on_model(const std::shared_p
 
     auto prerequisites = manager.register_pass<ngraph::pass::GraphRewrite>();
     const std::vector<ngraph::element::Type> supportedTypes = {ngraph::element::i8, ngraph::element::u8};
-    prerequisites->add_matcher<PullReshapeThroughDequantization>(supportedTypes);
-    prerequisites->add_matcher<PullTransposeThroughDequantization>(supportedTypes);
-    prerequisites->add_matcher<ngraph::pass::LinOpSequenceFusion>();
-    prerequisites->add_matcher<ngraph::pass::low_precision::MoveFakeQuantize>();
+    ADD_MATCHER(prerequisites, PullReshapeThroughDequantization, supportedTypes)
+    ADD_MATCHER(prerequisites, PullTransposeThroughDequantization, supportedTypes)
+    using namespace ngraph::pass;
+    using namespace ngraph::pass::low_precision;
+    ADD_MATCHER(prerequisites, LinOpSequenceFusion)
+    ADD_MATCHER(prerequisites, MoveFakeQuantize)
 
     manager.register_pass<TypeRelaxedReplacer>();
 
     AttributeParameters attributeParams(params.deqPrecision, params.defaultPrecisions);
-    manager.register_pass<ngraph::pass::low_precision::MarkupOptimizations>(precisionRestrictions, quantizationRestrictions, attributeParams);
+    manager.register_pass<ngraph::pass::low_precision::MarkupOptimizations>(precisionRestrictions,
+                                                                            quantizationRestrictions,
+                                                                            attributeParams);
 
     std::shared_ptr<ngraph::pass::GraphRewrite> common = manager.register_pass<ngraph::pass::GraphRewrite>();
-    common->add_matcher<ngraph::pass::low_precision::AddTransformation>(params);
-    common->add_matcher<ngraph::pass::low_precision::AssignAndReadValueTransformation>(f, params);
-    common->add_matcher<ngraph::pass::low_precision::AvgPoolTransformation>(params);
-    common->add_matcher<ngraph::pass::low_precision::ClampTransformation>(params);
-    common->add_matcher<ngraph::pass::low_precision::ConcatTransformation>(params);
-    common->add_matcher<ngraph::pass::low_precision::ConvolutionTransformation>(params);
-    common->add_matcher<ngraph::pass::low_precision::ConvolutionBackpropDataTransformation>(params);
-    common->add_matcher<ngraph::pass::low_precision::DepthToSpaceTransformation>(params);
-    common->add_matcher<ngraph::pass::low_precision::FakeQuantizeDecompositionTransformation>(params);
-    common->add_matcher<ngraph::pass::low_precision::FakeQuantizeTransformation>(params);
-    common->add_matcher<ngraph::pass::low_precision::InterpolateTransformation>(params);
-    common->add_matcher<ngraph::pass::low_precision::GroupConvolutionTransformation>(params);
-    common->add_matcher<ngraph::pass::low_precision::MatMulTransformation>(params);
-    common->add_matcher<ngraph::pass::low_precision::MaxPoolTransformation>(params);
-    common->add_matcher<ngraph::pass::low_precision::MultiplyTransformation>(params);
-    common->add_matcher<ngraph::pass::low_precision::MVNTransformation>(params);
-    common->add_matcher<ngraph::pass::low_precision::NormalizeL2Transformation>(params);
-    common->add_matcher<ngraph::pass::low_precision::PadTransformation>(params);
-    common->add_matcher<ngraph::pass::low_precision::PReluTransformation>(params);
-    common->add_matcher<ngraph::pass::low_precision::RecurrentCellTransformation>(params);
-    common->add_matcher<ngraph::pass::low_precision::ReduceMaxTransformation>(params);
-    common->add_matcher<ngraph::pass::low_precision::ReduceMeanTransformation>(params);
-    common->add_matcher<ngraph::pass::low_precision::ReduceMinTransformation>(params);
-    common->add_matcher<ngraph::pass::low_precision::ReduceSumTransformation>(params);
-    common->add_matcher<ngraph::pass::low_precision::ReluTransformation>(params);
-    common->add_matcher<ngraph::pass::low_precision::ReshapeTransformation>(params);
-    common->add_matcher<ngraph::pass::low_precision::SqueezeTransformation>(params);
-    common->add_matcher<ngraph::pass::low_precision::ShuffleChannelsTransformation>(params);
-    common->add_matcher<ngraph::pass::low_precision::SplitTransformation>(params);
-    common->add_matcher<ngraph::pass::low_precision::StridedSliceTransformation>(params);
-    common->add_matcher<ngraph::pass::low_precision::TransposeTransformation>(params);
-    common->add_matcher<ngraph::pass::low_precision::UnsqueezeTransformation>(params);
-    common->add_matcher<ngraph::pass::low_precision::VariadicSplitTransformation>(params);
+
+    ADD_MATCHER(common, AddTransformation, params)
+    ADD_MATCHER(common, AssignAndReadValueTransformation, f, params)
+    ADD_MATCHER(common, AvgPoolTransformation, params)
+    ADD_MATCHER(common, ClampTransformation, params)
+    ADD_MATCHER(common, ConcatTransformation, params)
+    ADD_MATCHER(common, ConvolutionTransformation, params)
+    ADD_MATCHER(common, ConvolutionBackpropDataTransformation, params)
+    ADD_MATCHER(common, DepthToSpaceTransformation, params)
+    ADD_MATCHER(common, FakeQuantizeDecompositionTransformation, params)
+    ADD_MATCHER(common, FakeQuantizeTransformation, params)
+    ADD_MATCHER(common, InterpolateTransformation, params)
+    ADD_MATCHER(common, GroupConvolutionTransformation, params)
+    ADD_MATCHER(common, MatMulTransformation, params)
+    ADD_MATCHER(common, MaxPoolTransformation, params)
+    ADD_MATCHER(common, MultiplyTransformation, params)
+    ADD_MATCHER(common, MVNTransformation, params)
+    ADD_MATCHER(common, NormalizeL2Transformation, params)
+    ADD_MATCHER(common, PadTransformation, params)
+    ADD_MATCHER(common, PReluTransformation, params)
+    ADD_MATCHER(common, RecurrentCellTransformation, params)
+    ADD_MATCHER(common, ReduceMaxTransformation, params)
+    ADD_MATCHER(common, ReduceMeanTransformation, params)
+    ADD_MATCHER(common, ReduceMinTransformation, params)
+    ADD_MATCHER(common, ReduceSumTransformation, params)
+    ADD_MATCHER(common, ReluTransformation, params)
+    ADD_MATCHER(common, ReshapeTransformation, params)
+    ADD_MATCHER(common, SqueezeTransformation, params)
+    ADD_MATCHER(common, ShuffleChannelsTransformation, params)
+    ADD_MATCHER(common, SplitTransformation, params)
+    ADD_MATCHER(common, StridedSliceTransformation, params)
+    ADD_MATCHER(common, TransposeTransformation, params)
+    ADD_MATCHER(common, UnsqueezeTransformation, params)
+    ADD_MATCHER(common, VariadicSplitTransformation, params)
 
     std::shared_ptr<ngraph::pass::GraphRewrite> cleanup = manager.register_pass<ngraph::pass::GraphRewrite>();
-    cleanup->add_matcher<ngraph::pass::low_precision::FoldConvertTransformation>(params);
-    cleanup->add_matcher<ngraph::pass::low_precision::FuseConvertTransformation>(params);
-    cleanup->add_matcher<ngraph::pass::low_precision::FuseSubtractToFakeQuantizeTransformation>(params);
-    cleanup->add_matcher<ngraph::pass::low_precision::FuseMultiplyToFakeQuantizeTransformation>(params);
+    ADD_MATCHER(cleanup, FoldConvertTransformation, params)
+    ADD_MATCHER(cleanup, FuseConvertTransformation, params)
+    ADD_MATCHER(cleanup, FuseSubtractToFakeQuantizeTransformation, params)
+    ADD_MATCHER(cleanup, FuseMultiplyToFakeQuantizeTransformation, params)
+
     // WA: precision restrictions for groupConv must be propagated to MultiplyToGroupConvolution transformation
-    cleanup->add_matcher<ngraph::pass::low_precision::MultiplyToGroupConvolutionTransformation>(
-        params,
-        PrecisionsRestriction::getPrecisionsByOperationType<opset1::GroupConvolution>(precisionRestrictions));
-    manager.register_pass<ngraph::pass::low_precision::FoldFakeQuantizeTransformation>(params);
-    manager.register_pass<ngraph::pass::ConstantFolding>();
+    ADD_MATCHER(cleanup,
+                MultiplyToGroupConvolutionTransformation,
+                params,
+                PrecisionsRestriction::getPrecisionsByOperationType<opset1::GroupConvolution>(precisionRestrictions))
+
+    REGISTER_PASS(manager, FoldFakeQuantizeTransformation, params)
+    REGISTER_PASS(manager, ConstantFolding)
 
     manager.run_passes(f);
     return false;