[CPU] fix most performance regression of some models on Atom

src/plugins/intel_cpu/src/nodes/conv.cpp

@@ -589,13 +589,14 @@ void Convolution::getSupportedDescriptors() {
         in_candidate = std::make_shared<DnnlBlockedMemoryDesc>(inputShape, inputDataType, ncsp);
         out_candidate = std::make_shared<DnnlBlockedMemoryDesc>(outputShape, outputDataType, ncsp);
         createDescriptor({ in_candidate }, { out_candidate });
-    } else if (IC < 4) {
-        in_candidate = std::make_shared<DnnlBlockedMemoryDesc>(inputShape, inputDataType, ncsp);
-        out_candidate = std::make_shared<DnnlBlockedMemoryDesc>(outputShape, outputDataType, nCsp16c);
-        createDescriptor({ in_candidate }, { out_candidate });
-        out_candidate = std::make_shared<DnnlBlockedMemoryDesc>(outputShape, outputDataType, nCsp8c);
-        createDescriptor({ in_candidate }, { out_candidate });
-    } else {
+    } else  {
+        if (IC < 4) {
+            in_candidate = std::make_shared<DnnlBlockedMemoryDesc>(inputShape, inputDataType, ncsp);
+            out_candidate = std::make_shared<DnnlBlockedMemoryDesc>(outputShape, outputDataType, nCsp16c);
+            createDescriptor({ in_candidate }, { out_candidate });
+            out_candidate = std::make_shared<DnnlBlockedMemoryDesc>(outputShape, outputDataType, nCsp8c);
+            createDescriptor({ in_candidate }, { out_candidate });
+        }
         in_candidate = std::make_shared<DnnlBlockedMemoryDesc>(inputShape, inputDataType, nCsp16c);
         out_candidate = std::make_shared<DnnlBlockedMemoryDesc>(outputShape, outputDataType, nCsp16c);
         createDescriptor({ in_candidate }, { out_candidate });

src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/convolution.cpp

@@ -451,6 +451,14 @@ const std::vector<InputShape>& inputShapesPlain2Blocked2d() {
                     { 1, 1, 9, 9}
                 }
             },
+            {
+                //dynamic shape
+                { -1, 2, -1, {1, 200} },
+                { //target static shapes
+                    { 2, 2, 7, 7 },
+                    { 1, 2, 9, 9}
+                }
+            },
             {
                 //dynamic shape
                 { -1, 3, -1, {1, 200} },

src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/instances/common/convolution.cpp

@@ -105,36 +105,39 @@ INSTANTIATE_TEST_SUITE_P(Conv_2D_FP32_dilated_empty_fusing, ConvolutionLayerCPUT
                                  ::testing::Values(empty_plugin_config)),
                          ConvolutionLayerCPUTest::getTestCaseName);
 
-const std::vector<CPUSpecificParams> CPUParams_2D_plain_to_blocked = {
+const std::vector<CPUSpecificParams> CPUParams_2D_small_IC = {
+        conv_sse42_2D,
         conv_sse42_plain_to_blocked_2D,
         conv_avx2_plain_to_blocked_2D,
         conv_avx512_plain_to_blocked_2D,
 };
 
-INSTANTIATE_TEST_SUITE_P(smoke_Conv_2D_PlainToBlocked_FP32, ConvolutionLayerCPUTest,
+const std::vector<InputShape>& inputShapesSmallIC2d = inputShapesPlain2Blocked2d();
+
+INSTANTIATE_TEST_SUITE_P(smoke_Conv_2D_SmallIC_FP32, ConvolutionLayerCPUTest,
                          ::testing::Combine(
                                  ::testing::Combine(
                                          convParams_ExplicitPadding_2D(),
                                          ::testing::Values(ElementType::f32),
                                          ::testing::Values(ElementType::undefined),
                                          ::testing::Values(ElementType::undefined),
-                                         ::testing::ValuesIn(inputShapesPlain2Blocked2d()),
+                                         ::testing::ValuesIn(inputShapesSmallIC2d),
                                          ::testing::Values(ov::test::utils::DEVICE_CPU)),
-                                 ::testing::ValuesIn(filterCPUInfo(CPUParams_2D_plain_to_blocked)),
+                                 ::testing::ValuesIn(filterCPUInfo(CPUParams_2D_small_IC)),
                                  ::testing::Values(emptyFusingSpec),
                                  ::testing::Values(empty_plugin_config)),
                          ConvolutionLayerCPUTest::getTestCaseName);
 
-INSTANTIATE_TEST_SUITE_P(Conv_PlainToBlocked_2D_FP32_dilated, ConvolutionLayerCPUTest,
+INSTANTIATE_TEST_SUITE_P(smoke_Conv_SmallIC_2D_FP32_dilated, ConvolutionLayerCPUTest,
                          ::testing::Combine(
                                  ::testing::Combine(
                                          convParams_ExplicitPadding_2D_dilated(),
                                          ::testing::Values(ElementType::f32),
                                          ::testing::Values(ElementType::undefined),
                                          ::testing::Values(ElementType::undefined),
-                                         ::testing::ValuesIn(inputShapesPlain2Blocked2d()),
+                                         ::testing::ValuesIn(inputShapesSmallIC2d),
                                          ::testing::Values(ov::test::utils::DEVICE_CPU)),
-                                 ::testing::ValuesIn(filterCPUInfo(CPUParams_2D_plain_to_blocked)),
+                                 ::testing::ValuesIn(filterCPUInfo(CPUParams_2D_small_IC)),
                                  ::testing::Values(emptyFusingSpec),
                                  ::testing::Values(empty_plugin_config)),
                          ConvolutionLayerCPUTest::getTestCaseName);
@@ -397,4 +400,4 @@ INSTANTIATE_TEST_SUITE_P(smoke_Conv_Large_Filter, ConvolutionLayerCPUTest,
 }  // namespace
 }  // namespace Convolution
 }  // namespace test
-}  // namespace ov
+}  // namespace ov

src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/instances/x64/convolution.cpp

@@ -407,7 +407,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_Conv_1D_I8, ConvolutionLayerCPUTest,
                                  ::testing::Values(empty_plugin_config)),
                          ConvolutionLayerCPUTest::getTestCaseName);
 
-const std::vector<CPUSpecificParams> CPUParams_1D_plain_to_blocked = {
+const std::vector<CPUSpecificParams> CPUParams_1D_small_IC = {
+        conv_sse42_1D,
         conv_sse42_plain_to_blocked_1D,
         conv_avx2_plain_to_blocked_1D,
         conv_avx512_plain_to_blocked_1D,
@@ -426,6 +427,14 @@ std::vector<InputShape> inputShapesPlain2Blocked1d = {
             }
         },
         {
+        //dynamic shapes
+            {-1, 2, {1, 200}},
+            { //target static shapes
+                {2, 2, 7},
+                {1, 2, 9}
+            }
+        },
+        {
         //dynamic shapes
             {-1, 3, {1, 200}},
             { //target static shapes
@@ -435,16 +444,18 @@ std::vector<InputShape> inputShapesPlain2Blocked1d = {
         }
 };
 
-INSTANTIATE_TEST_SUITE_P(smoke_Conv_1D_PlainToBlocked_FP32, ConvolutionLayerCPUTest,
+std::vector<InputShape> inputShapesSmallIC1d = inputShapesPlain2Blocked1d;
+
+INSTANTIATE_TEST_SUITE_P(smoke_Conv_1D_SmallIC_FP32, ConvolutionLayerCPUTest,
                          ::testing::Combine(
                                  ::testing::Combine(
                                          convParams_ExplicitPadding_1D,
                                          ::testing::Values(ElementType::f32),
                                          ::testing::Values(ElementType::undefined),
                                          ::testing::Values(ElementType::undefined),
-                                         ::testing::ValuesIn(inputShapesPlain2Blocked1d),
+                                         ::testing::ValuesIn(inputShapesSmallIC1d),
                                          ::testing::Values(ov::test::utils::DEVICE_CPU)),
-                                 ::testing::ValuesIn(filterCPUInfo(CPUParams_1D_plain_to_blocked)),
+                                 ::testing::ValuesIn(filterCPUInfo(CPUParams_1D_small_IC)),
                                  ::testing::Values(emptyFusingSpec),
                                  ::testing::Values(empty_plugin_config)),
                          ConvolutionLayerCPUTest::getTestCaseName);
@@ -808,4 +819,4 @@ INSTANTIATE_TEST_SUITE_P(Conv_3D_Jit_Planar_FP32_dilated, ConvolutionLayerCPUTes
 }  // namespace
 }  // namespace Convolution
 }  // namespace test
-}  // namespace ov
+}  // namespace ov

src/plugins/intel_cpu/tests/functional/shared_tests_instances/snippets/fake_quantize_decomposition_test.cpp

@@ -6,6 +6,7 @@
 #include <vector>
 
 #include "snippets/fake_quantize_decomposition_test.hpp"
+#include "openvino/runtime/system_conf.hpp"
 
 using namespace ov::test::snippets;
 
@@ -120,11 +121,12 @@ INSTANTIATE_TEST_SUITE_P(
     ::testing::Combine(
         ::testing::ValuesIn(testValuesLegacyFuse),
         ::testing::ValuesIn(operations),
-        // reorder (nChw[16|8]c) + MaxPool + reorder(nhwc) + Convolution(with internal weight reordering) + reorder(nchw)
-        ::testing::Values(std::pair<size_t, size_t>{5, 0}),
+        // if ISA has avx512, conv node will use brgconv, there will be a extra reorder(nhwc)
+        // for brg, reorder (nChw[16|8]c) + MaxPool + reorder(nhwc) + Convolution(with internal weight reordering) + reorder(nchw)
+        // for no brg, reorder (nChw[16|8]c) + MaxPool + Convolution(with internal weight reordering) + reorder(nchw)
+        ::testing::Values(ov::with_cpu_x86_avx512_core() ? std::pair<size_t, size_t>{5, 0} : std::pair<size_t, size_t>{4, 0}),
         ::testing::Values(ov::test::utils::DEVICE_CPU)),
     FakeQuantizeDecompositionTest::getTestCaseName);
 
 }  // namespace legacyFuse
-
 }  // namespace