[CPU]remove useless convert pair(Convert[a->b] -> Convert[b->a])

src/bindings/python/tests/test_graph/test_constant.py

@@ -389,6 +389,7 @@ def test_float_to_f8e8m0_constant_matrix(ov_type, numpy_dtype, opset):
 
     compressed_const = opset.constant(data, dtype=ov_type, name="fx_constant")
     convert_to_fp8 = opset.convert(compressed_const, Type.f8e8m0)
+    convert_to_fp8.get_rt_info()["DisableEliminateUselessConvert"] = "1"
     convert_back = opset.convert(convert_to_fp8, ov_type)
     parameter = opset.parameter(ov.PartialShape([-1, -1]), ov_type)
     add_op = opset.add(parameter, convert_back)
@@ -481,6 +482,7 @@ def test_float_to_f8e5m2_convert(ov_type, numpy_dtype, opset):
 
     compressed_const = opset.constant(data, dtype=ov_type, name="fx_constant")
     convert_to_fp8 = opset.convert(compressed_const, Type.f8e5m2)
+    convert_to_fp8.get_rt_info()["DisableEliminateUselessConvert"] = "1"
     convert_back = opset.convert(convert_to_fp8, ov_type)
     parameter = opset.parameter(ov.PartialShape([-1]), ov_type)
     add_op = opset.add(parameter, convert_back)
@@ -514,6 +516,7 @@ def test_float_to_f8e4m3_convert(ov_type, numpy_dtype, opset):
 
     compressed_const = opset.constant(data, dtype=ov_type, name="fx_constant")
     convert_to_fp8 = opset.convert(compressed_const, Type.f8e4m3)
+    convert_to_fp8.get_rt_info()["DisableEliminateUselessConvert"] = "1"
     convert_back = opset.convert(convert_to_fp8, ov_type)
     parameter = opset.parameter(ov.PartialShape([-1]), ov_type)
     add_op = opset.add(parameter, convert_back)
@@ -549,6 +552,7 @@ def test_float_to_f8e8m0_convert(ov_type, numpy_dtype, opset):
 
     compressed_const = opset.constant(data, dtype=ov_type, name="fx_constant")
     convert_to_fp8 = opset.convert(compressed_const, Type.f8e8m0)
+    convert_to_fp8.get_rt_info()["DisableEliminateUselessConvert"] = "1"
     convert_back = opset.convert(convert_to_fp8, ov_type)
     parameter = opset.parameter(ov.PartialShape([-1]), ov_type)
     add_op = opset.add(parameter, convert_back)

src/common/transformations/include/transformations/common_optimizations/nop_elimination.hpp

@@ -12,6 +12,7 @@ namespace pass {
 
 class TRANSFORMATIONS_API EliminateConcat;
 class TRANSFORMATIONS_API EliminateConvert;
+class TRANSFORMATIONS_API DisableEliminateUselessConvert;
 class TRANSFORMATIONS_API EliminateConvertNonZero;
 class TRANSFORMATIONS_API EliminateEltwise;
 class TRANSFORMATIONS_API EliminateScatterUpdate;
@@ -63,6 +64,17 @@ class ov::pass::EliminateConvert : public ov::pass::MatcherPass {
     EliminateConvert();
 };
 
+/**
+ * @ingroup ov_transformation_common_api
+ * @brief DisableEliminateUselessConvert eliminates convert(a->b) + convert(b->a) that does nothing. Add just for some
+ * testing.
+ */
+class ov::pass::DisableEliminateUselessConvert : public ov::pass::MatcherPass {
+public:
+    OPENVINO_RTTI("DisableEliminateUselessConvert", "0");
+    DisableEliminateUselessConvert();
+};
+
 /**
  * @ingroup ov_transformation_common_api
  * @brief EliminateConvertNonZero eliminates convert before NonZero

src/common/transformations/src/transformations/common_optimizations/nop_elimination.cpp

@@ -443,16 +443,54 @@ pass::EliminateConvert::EliminateConvert() {
         if (!convert) {
             return false;
         }
+
         if (convert->get_input_element_type(0) == convert->get_element_type()) {
             return replace_output_update_name(convert->output(0), convert->input_value(0));
         }
+
+        // Only for some test.
+        if (convert->get_rt_info().count("DisableEliminateUselessConvert") &&
+            convert->get_rt_info()["DisableEliminateUselessConvert"].as<std::string>() == std::string("1")) {
+            return false;
+        }
+
+        // Eliminate useless convert pattern, for example:
+        // Convert[fp16->fp32] -> Convert[fp32->f16]
+        if (convert && convert->get_output_size() > 0u && convert->get_input_size() > 0u) {
+            auto convert2 = ov::as_type_ptr<ov::op::v0::Convert>(
+                convert->get_output_target_inputs(0).begin()->get_node()->shared_from_this());
+            if (convert2 && convert->get_input_element_type(0) == convert2->get_output_element_type(0) &&
+                convert->get_output_partial_shape(0) == convert2->get_output_partial_shape(0)) {
+                replace_output_update_name(convert2->output(0), convert->input_value(0));
+                return true;
+            }
+        }
+
         return false;
     };
 
     auto m = make_shared<pattern::Matcher>(convert_pattern, matcher_name);
     this->register_matcher(m, callback);
 }
 
+pass::DisableEliminateUselessConvert::DisableEliminateUselessConvert() {
+    MATCHER_SCOPE(DisableEliminateUselessConvert);
+    auto convert_pattern = pattern::wrap_type<ov::op::v0::Convert>();
+
+    matcher_pass_callback callback = [](pattern::Matcher& m) {
+        auto convert = dynamic_pointer_cast<ov::op::v0::Convert>(m.get_match_root());
+        if (!convert) {
+            return false;
+        }
+        convert->get_rt_info()["DisableEliminateUselessConvert"] = "1";
+
+        return true;
+    };
+
+    auto m = make_shared<pattern::Matcher>(convert_pattern, matcher_name);
+    this->register_matcher(m, callback);
+}
+
 pass::EliminateConvertNonZero::EliminateConvertNonZero() {
     MATCHER_SCOPE(EliminateConvertNonZero);
     auto convert_pattern = pattern::wrap_type<ov::op::v0::Convert>(pattern::consumers_count(1));

src/plugins/intel_cpu/src/node.cpp

@@ -889,6 +889,11 @@ void Node::filterSupportedPrimitiveDescriptors() {
 
     auto isNotSuitableDesc = [&](const NodeDesc& desc) {
         const auto &config = desc.getConfig();
+
+        if (this->getTypeStr() == "Parameter") {
+            return false;
+        }
+
         if (inputMemoryFormatsFilter.size() > config.inConfs.size() || outputMemoryFormatsFilter.size() > config.outConfs.size())
             OPENVINO_THROW("Incorrect number of input or output memory formats");
 

src/plugins/intel_cpu/tests/functional/custom/subgraph_tests/src/common/concat_transpose_sdp_transpose.cpp

@@ -441,6 +441,26 @@ TEST_P(ConcatSDPTransposeTestSetState, CompareWithRefs) {
     for (size_t i = 0; i < actualOutputs.size(); i++) {
         ov::test::utils::compare(expectedOutputs[i], actualOutputs[i], abs_threshold, rel_threshold);
     }
+
+    // Check compileModel doesn't should contain 2 useless Convert.
+    auto check_node_type = [](std::shared_ptr<ov::Node> node, const std::string& typeName) -> bool {
+        auto rtInfo = node->get_rt_info();
+        auto it = rtInfo.find(ov::exec_model_info::LAYER_TYPE);
+        OPENVINO_ASSERT(rtInfo.end() != it);
+        return it->second.as<std::string>() == typeName;
+    };
+    EXPECT_TRUE(compiledModel.get_runtime_model() != nullptr);
+    for (const auto& node : compiledModel.get_runtime_model()->get_ops()) {
+        if (check_node_type(node, "Convert")) {
+            auto convert1 = node;
+            auto convert2 = node->get_output_target_inputs(0).begin()->get_node()->shared_from_this();
+            if (node->get_output_size() > 0u && check_node_type(convert2, "Convert")) {
+                bool useless_convert = convert1->get_input_element_type(0) == convert2->get_output_element_type(0) &&
+                                       convert1->get_output_partial_shape(0) == convert2->get_output_partial_shape(0);
+                EXPECT_FALSE(useless_convert);
+            }
+        }
+    }
 }
 
 namespace {

src/plugins/template/tests/functional/subgraph_reference/preprocess.cpp

@@ -13,6 +13,8 @@
 #include "openvino/op/add.hpp"
 #include "openvino/op/constant.hpp"
 #include "openvino/op/slice.hpp"
+#include "openvino/pass/manager.hpp"
+#include "transformations/common_optimizations/nop_elimination.hpp"
 
 using namespace ov;
 using namespace ov::preprocess;
@@ -139,6 +141,11 @@ static RefPreprocessParams convert_only() {
             .convert_element_type(element::u8)
             .convert_element_type(element::f32);
         p.build();
+
+        ov::pass::Manager manager;
+        manager.register_pass<ov::pass::DisableEliminateUselessConvert>();
+        manager.run_passes(f);
+
         return f;
     };
     res.inputs.emplace_back(Shape{1, 1, 2, 2}, element::i16, std::vector<int16_t>{2, 3, 4, 5});

src/tests/functional/plugin/shared/src/low_precision_transformations/convolution_qdq_transformation.cpp

@@ -12,6 +12,8 @@
 
 #include "common_test_utils/common_utils.hpp"
 #include "ov_lpt_models/fake_quantize_and_convolution.hpp"
+#include "transformations/common_optimizations/nop_elimination.hpp"
+#include "openvino/pass/manager.hpp"
 
 namespace LayerTestsDefinitions {
 
@@ -50,6 +52,10 @@ void ConvolutionQDqTransformation::SetUp() {
         {});
 
     this->configuration[ov::hint::inference_precision.name()] = "f32";
+
+    ov::pass::Manager manager;
+    manager.register_pass<ov::pass::DisableEliminateUselessConvert>();
+    manager.run_passes(function);
 }
 
 void ConvolutionQDqTransformation::run() {

src/tests/functional/plugin/shared/src/low_precision_transformations/fake_quantize_with_dq_not_optimal_transformation.cpp

@@ -11,6 +11,8 @@
 
 #include "transformations/init_node_info.hpp"
 #include "ov_lpt_models/fake_quantize_and_convolution.hpp"
+#include "transformations/common_optimizations/nop_elimination.hpp"
+#include "openvino/pass/manager.hpp"
 
 namespace LayerTestsDefinitions {
 
@@ -48,6 +50,10 @@ void FakeQuantizeWithNotOptimalTransformation::SetUp() {
         testValues.convertOnWeights,
         testValues.dequantizationOnWeights,
         testValues.dequantizationAfter);
+
+    ov::pass::Manager manager;
+    manager.register_pass<ov::pass::DisableEliminateUselessConvert>();
+    manager.run_passes(function);
 }
 
 void FakeQuantizeWithNotOptimalTransformation::run() {

src/tests/functional/plugin/shared/src/low_precision_transformations/groupconvolution_qdq_transformation.cpp

@@ -12,6 +12,8 @@
 
 #include "common_test_utils/common_utils.hpp"
 #include "ov_lpt_models/fake_quantize_and_convolution.hpp"
+#include "transformations/common_optimizations/nop_elimination.hpp"
+#include "openvino/pass/manager.hpp"
 
 namespace LayerTestsDefinitions {
 
@@ -48,6 +50,10 @@ void GroupConvolutionQDqTransformation::SetUp() {
         param.convertOnWeights,
         param.dequantizationOnWeights,
         {}, {}, {}, param.reshape, {}, "GroupConvolution", param.multiplyAfter);
+
+    ov::pass::Manager manager;
+    manager.register_pass<ov::pass::DisableEliminateUselessConvert>();
+    manager.run_passes(function);
 }
 
 void GroupConvolutionQDqTransformation::run() {

src/tests/functional/plugin/shared/src/low_precision_transformations/reduce_mean_transformation.cpp

@@ -8,6 +8,8 @@
 #include <vector>
 
 #include "ov_lpt_models/reduce.hpp"
+#include "transformations/common_optimizations/nop_elimination.hpp"
+#include "openvino/pass/manager.hpp"
 
 namespace LayerTestsDefinitions {
 
@@ -59,6 +61,10 @@ void ReduceMeanTransformation::SetUp() {
         param.reduceMean.constantValues,
         param.reduceMean.keepDims,
         param.dequantizationAfter);
+
+    ov::pass::Manager manager;
+    manager.register_pass<ov::pass::DisableEliminateUselessConvert>();
+    manager.run_passes(function);
 }
 
 void ReduceMeanTransformation::run() {

src/tests/functional/shared_test_classes/src/subgraph/quantized_convolution_batch_norm.cpp

@@ -7,6 +7,8 @@
 #include "openvino/core/validation_util.hpp"
 #include "openvino/runtime/exec_model_info.hpp"
 #include "shared_test_classes/subgraph/quantized_convolution_batch_norm.hpp"
+#include "transformations/common_optimizations/nop_elimination.hpp"
+#include "openvino/pass/manager.hpp"
 
 namespace ov {
 namespace test {
@@ -169,6 +171,10 @@ void QuantizedConvolutionBatchNorm::SetUp() {
     auto var = std::make_shared<ov::op::v0::Constant>(var_tensor);
     auto batch_norm = std::make_shared<ov::op::v5::BatchNormInference>(conv, gamma, beta, mean, var, 0.00001);
     function = std::make_shared<ov::Model>(batch_norm, ParameterVector{parameter});
+
+    ov::pass::Manager manager;
+    manager.register_pass<ov::pass::DisableEliminateUselessConvert>();
+    manager.run_passes(function);
 }
 
 void QuantizedConvolutionBatchNorm::TearDown() {