natas_hw
/
openvino
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge 8580c05337 into 43de73cbd6

This commit is contained in:
Yuan Hu 2024-06-12 03:28:07 +02:00 committed by GitHub
parent 43de73cbd6 8580c05337
commit aad868bc4a
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
32 changed files with 1187 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/inference/dev_api/openvino/runtime/system_conf.hpp
View File

@ -146,6 +146,13 @@ OPENVINO_RUNTIME_API bool with_cpu_x86_avx512_core_amx_int8();
*/
OPENVINO_RUNTIME_API bool with_cpu_x86_avx512_core_amx_bf16();
/**
* @brief Checks whether CPU supports AMX fp16 capability
* @ingroup ov_dev_api_system_conf
* @return `True` is tAMX_FP16 instructions are available, `false` otherwise
*/
OPENVINO_RUNTIME_API bool with_cpu_x86_avx512_core_amx_fp16();
/**
* @brief Checks whether CPU supports AMX capability
* @ingroup ov_dev_api_system_conf

7
src/inference/src/system_conf.cpp
View File

@ -92,6 +92,10 @@ bool with_cpu_x86_avx512_core_amx_bf16() {
return get_cpu_info().has(Xbyak::util::Cpu::tAMX_BF16);
}
bool with_cpu_x86_avx512_core_amx_fp16() {
return get_cpu_info().has(Xbyak::util::Cpu::tAMX_FP16);
}
bool with_cpu_x86_avx512_core_amx() {
return with_cpu_x86_avx512_core_amx_int8() || with_cpu_x86_avx512_core_amx_bf16();
}
@ -131,6 +135,9 @@ bool with_cpu_x86_avx512_core_amx_int8() {
bool with_cpu_x86_avx512_core_amx_bf16() {
return false;
}
bool with_cpu_x86_avx512_core_amx_fp16() {
return false;
}
bool with_cpu_x86_avx512_core_amx() {
return false;
}

4
src/plugins/intel_cpu/src/graph.cpp
View File

@ -1831,7 +1831,7 @@ void Graph::EnforceInferencePrecision() {
for (size_t i = 0; i < node->getOriginalInputsNumber(); i++) {
auto keepOriginalInputPrecisionAtPort = [](const NodePtr& node, const size_t inPort) {
// keep non-float precisions
// keep non-float32 precisions
if (node->getOriginalInputPrecisionAtPort(inPort) != ov::element::f32)
return true;
@ -1875,7 +1875,7 @@ void Graph::EnforceInferencePrecision() {
}
for (size_t i = 0; i < node->getOriginalOutputsNumber(); i++) {
// keep non-float precisions
// keep non-float32 precisions
if (node->getOriginalOutputPrecisionAtPort(i) != ov::element::f32)
continue;

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

@ -160,11 +160,16 @@ void ConvolutionLayerCPUTest::SetUp() {
init_input_shapes({inputShape});
auto it = configuration.find(ov::hint::inference_precision.name());
if (it != configuration.end() && it->second.as<ov::element::Type>() == ov::element::bf16) {
ov::element::Type inference_precision = (it != configuration.end()) ?
it->second.as<ov::element::Type>() : ov::element::undefined;
if (inference_precision == ov::element::bf16) {
selectedType += "_BF16";
rel_threshold = 1e-2f;
if (selectedType == "jit_gemm_BF16")
rel_threshold = 0.05f;
} else if (inference_precision == ov::element::f16) {
selectedType += "_FP16";
rel_threshold = 0.00125f;
} else {
selectedType = makeSelectedTypeStr(selectedType, netType);
}

8
src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/convolution_backprop_data.cpp
View File

@ -196,9 +196,15 @@ void DeconvolutionLayerCPUTest::SetUp() {
std::tie(kernel, stride, padBegin, padEnd, dilation, convOutChannels, padType, outPadding) = basicParamsSet;
if (additionalConfig[ov::hint::inference_precision.name()] == ov::element::bf16) {
auto it = configuration.find(ov::hint::inference_precision.name());
ov::element::Type inference_precision = (it != configuration.end()) ?
it->second.as<ov::element::Type>() : ov::element::undefined;
if (inference_precision == ov::element::bf16) {
inType = outType = prec = ElementType::bf16;
rel_threshold = 1e-2f;
} else if (inference_precision == ov::element::f16) {
inType = outType = prec = ElementType::f16;
rel_threshold = 0.00125f;
} else {
inType = outType = prec;
}

9
src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/matmul.cpp
View File

@ -118,9 +118,14 @@ void MatMulLayerCPUTest::SetUp() {
configuration.insert(additionalConfig.begin(), additionalConfig.end());
auto it = additionalConfig.find(ov::hint::inference_precision.name());
if (it != additionalConfig.end() && it->second.as<ov::element::Type>() == ov::element::bf16) {
ov::element::Type inference_precision = (it != additionalConfig.end()) ?
it->second.as<ov::element::Type>() : ov::element::undefined;
if (inference_precision == ov::element::bf16) {
inType = outType = netType = ElementType::bf16;
rel_threshold = abs_threshold = 1e-2f;
} else if (inference_precision == ov::element::f16) {
inType = outType = netType = ElementType::f16;
rel_threshold = abs_threshold = 1e-4f;
} else {
inType = outType = netType;
rel_threshold = 1e-4f;
@ -128,7 +133,7 @@ void MatMulLayerCPUTest::SetUp() {
}
cpuNodeType = nodeType == MatMulNodeType::MatMul ? "MatMul" : "FullyConnected";
selectedType = makeSelectedTypeStr(selectedType, outType);
selectedType = makeSelectedTypeStr(selectedType, get_default_imp_precision_type(outType, configuration));
ov::ParameterVector params{std::make_shared<ov::op::v0::Parameter>(netType, inShapeA)};

30
src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/pooling.cpp
View File

@ -19,7 +19,8 @@ std::string PoolingLayerCPUTest::getTestCaseName(const testing::TestParamInfo<po
bool isInt8;
CPUSpecificParams cpuParams;
fusingSpecificParams fusingParams;
std::tie(basicParamsSet, inputShapes, inPrc, isInt8, cpuParams, fusingParams) = obj.param;
ov::AnyMap additionalConfig;
std::tie(basicParamsSet, inputShapes, inPrc, isInt8, cpuParams, fusingParams, additionalConfig) = obj.param;
utils::PoolingTypes poolType;
std::vector<size_t> kernel, stride;
@ -53,6 +54,12 @@ std::string PoolingLayerCPUTest::getTestCaseName(const testing::TestParamInfo<po
results << "Rounding=" << roundingType << "_";
results << "AutoPad=" << padType << "_";
results << "INT8=" << isInt8 << "_";
if (!additionalConfig.empty()) {
results << "_PluginConf";
for (auto& item : additionalConfig) {
results << "_" << item.first << "=" << item.second.as<std::string>();
}
}
results << CPUTestsBase::getTestCaseName(cpuParams);
results << CpuTestWithFusing::getTestCaseName(fusingParams);
@ -68,7 +75,9 @@ void PoolingLayerCPUTest::SetUp() {
bool isInt8;
CPUSpecificParams cpuParams;
fusingSpecificParams fusingParams;
std::tie(basicParamsSet, inputShapes, inPrc, isInt8, cpuParams, fusingParams) = this->GetParam();
ov::AnyMap additionalConfig;
std::tie(basicParamsSet, inputShapes, inPrc, isInt8, cpuParams, fusingParams, additionalConfig) = this->GetParam();
configuration.insert(additionalConfig.begin(), additionalConfig.end());
utils::PoolingTypes poolType;
std::vector<size_t> kernel, stride;
@ -87,7 +96,7 @@ void PoolingLayerCPUTest::SetUp() {
if (isInt8)
selectedType = selectedType + "_I8";
else
selectedType = makeSelectedTypeStr(selectedType, inPrc);
selectedType = makeSelectedTypeStr(selectedType, get_default_imp_precision_type(inPrc, configuration));
init_input_shapes({inputShapes});
@ -119,7 +128,8 @@ std::string MaxPoolingV8LayerCPUTest::getTestCaseName(
InputShape inputShapes;
ElementType inPrc;
CPUSpecificParams cpuParams;
std::tie(basicParamsSet, inputShapes, inPrc, cpuParams) = obj.param;
ov::AnyMap additionalConfig;
std::tie(basicParamsSet, inputShapes, inPrc, cpuParams, additionalConfig) = obj.param;
std::vector<size_t> kernel, stride, dilation;
std::vector<size_t> padBegin, padEnd;
@ -146,6 +156,12 @@ std::string MaxPoolingV8LayerCPUTest::getTestCaseName(
results << "PE" << ov::test::utils::vec2str(padEnd) << "_";
results << "Rounding=" << roundingType << "_";
results << "AutoPad=" << padType << "_";
if (!additionalConfig.empty()) {
results << "_PluginConf";
for (auto& item : additionalConfig) {
results << "_" << item.first << "=" << item.second.as<std::string>();
}
}
results << CPUTestsBase::getTestCaseName(cpuParams);
return results.str();
@ -158,7 +174,9 @@ void MaxPoolingV8LayerCPUTest::SetUp() {
InputShape inputShapes;
ElementType inPrc;
CPUSpecificParams cpuParams;
std::tie(basicParamsSet, inputShapes, inPrc, cpuParams) = this->GetParam();
ov::AnyMap additionalConfig;
std::tie(basicParamsSet, inputShapes, inPrc, cpuParams, additionalConfig) = this->GetParam();
configuration.insert(additionalConfig.begin(), additionalConfig.end());
std::vector<size_t> kernel, stride, dilation;
std::vector<size_t> padBegin, padEnd;
@ -172,7 +190,7 @@ void MaxPoolingV8LayerCPUTest::SetUp() {
if (selectedType.empty()) {
selectedType = getPrimitiveType();
}
selectedType = makeSelectedTypeStr(selectedType, inPrc);
selectedType = makeSelectedTypeStr(selectedType, get_default_imp_precision_type(inPrc, configuration));
init_input_shapes({inputShapes});

7
src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/pooling.hpp
View File

@ -19,12 +19,15 @@ using poolLayerCpuTestParamsSet = std::tuple<poolSpecificParams,
ElementType, //inPrc
bool, // isInt8
CPUSpecificParams,
fusingSpecificParams>;
fusingSpecificParams,
ov::AnyMap>;
using maxPoolV8LayerCpuTestParamsSet = std::tuple<maxPoolV8SpecificParams,
InputShape,
ElementType,
CPUSpecificParams>;
CPUSpecificParams,
ov::AnyMap>;
class PoolingLayerCPUTest : public testing::WithParamInterface<poolLayerCpuTestParamsSet>,
virtual public SubgraphBaseTest, public CpuTestWithFusing {

17
src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/softmax.cpp
View File

@ -16,7 +16,8 @@ std::string SoftMaxLayerCPUTest::getTestCaseName(const testing::TestParamInfo<so
ElementType inType;
SoftMaxConfig config;
std::string targetDevice;
std::tie(inType, config, targetDevice, cpuParams) = obj.param;
ov::AnyMap additionalConfig;
std::tie(inType, config, targetDevice, cpuParams, additionalConfig) = obj.param;
std::ostringstream result;
result << "netPRC=" << inType << "_";
@ -30,6 +31,12 @@ std::string SoftMaxLayerCPUTest::getTestCaseName(const testing::TestParamInfo<so
result << "axis=" << config.axis << "_";
result << "trgDev=" << targetDevice;
result << CPUTestsBase::getTestCaseName(cpuParams);
if (!additionalConfig.empty()) {
result << "_PluginConf";
for (auto& item : additionalConfig) {
result << "_" << item.first << "=" << item.second.as<std::string>();
}
}
return result.str();
}
@ -38,7 +45,9 @@ void SoftMaxLayerCPUTest::SetUp() {
ElementType inType;
SoftMaxConfig config;
CPUSpecificParams cpuParams;
std::tie(inType, config, targetDevice, cpuParams) = this->GetParam();
ov::AnyMap additionalConfig;
std::tie(inType, config, targetDevice, cpuParams, additionalConfig) = this->GetParam();
configuration.insert(additionalConfig.begin(), additionalConfig.end());
std::tie(inFmts, outFmts, priority, selectedType) = cpuParams;
if (selectedType.empty()) {
@ -47,8 +56,10 @@ void SoftMaxLayerCPUTest::SetUp() {
if (inType == ElementType::bf16) {
rel_threshold = 2e-2f;
} else if (inType == ElementType::f16) {
rel_threshold = 0.0025f;
}
selectedType = makeSelectedTypeStr(selectedType, inType);
selectedType = makeSelectedTypeStr(selectedType, get_default_imp_precision_type(inType, configuration));
init_input_shapes({config.inputShape});
ov::ParameterVector params;
for (auto&& shape : inputDynamicShapes)

3
src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/softmax.hpp
View File

@ -18,7 +18,8 @@ struct SoftMaxConfig {
typedef std::tuple<ElementType, // netPrecision
SoftMaxConfig, // softmaxTestConfig
std::string, // targetDevice
CPUSpecificParams>
CPUSpecificParams,
ov::AnyMap> //device_config
softmaxCPUTestParams;
class SoftMaxLayerCPUTest : public testing::WithParamInterface<softmaxCPUTestParams>,

39
src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/instances/common/pooling.cpp
View File

@ -27,7 +27,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_MaxPool_CPU_3D, PoolingLayerCPUTest,
::testing::ValuesIn((inpOutPrecision())),
::testing::Values(false),
::testing::ValuesIn(vecCpuConfigs),
::testing::Values(emptyFusingSpec)),
::testing::Values(emptyFusingSpec),
::testing::Values(CPUTestUtils::empty_plugin_config)),
PoolingLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AvgPool_CPU_3D, PoolingLayerCPUTest,
@ -37,7 +38,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_AvgPool_CPU_3D, PoolingLayerCPUTest,
::testing::ValuesIn((inpOutPrecision())),
::testing::Values(false),
::testing::ValuesIn(vecCpuConfigs),
::testing::Values(emptyFusingSpec)),
::testing::Values(emptyFusingSpec),
::testing::Values(CPUTestUtils::empty_plugin_config)),
PoolingLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AvgPool_CPU_3D_NotOptimized, PoolingLayerCPUTest,
@ -47,7 +49,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_AvgPool_CPU_3D_NotOptimized, PoolingLayerCPUTest,
::testing::ValuesIn((inpOutPrecision())),
::testing::Values(false),
::testing::Values(expectedCpuConfigAnyLayout()),
::testing::Values(emptyFusingSpec)),
::testing::Values(emptyFusingSpec),
::testing::Values(CPUTestUtils::empty_plugin_config)),
PoolingLayerCPUTest::getTestCaseName);
const std::vector<poolSpecificParams> paramsAvg4D_RefOnly = {
@ -62,7 +65,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_MaxPool_CPU_4D, PoolingLayerCPUTest,
::testing::ValuesIn((inpOutPrecision())),
::testing::Values(false),
::testing::ValuesIn(filterCPUInfo(vecCpuConfigsFusing_4D())),
::testing::Values(emptyFusingSpec)),
::testing::Values(emptyFusingSpec),
::testing::Values(CPUTestUtils::empty_plugin_config)),
PoolingLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_MaxPoolV8_CPU_4D, MaxPoolingV8LayerCPUTest,
@ -70,7 +74,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_MaxPoolV8_CPU_4D, MaxPoolingV8LayerCPUTest,
::testing::ValuesIn(paramsMaxV84D()),
::testing::ValuesIn(inputShapes4D()),
::testing::ValuesIn((inpOutPrecision())),
::testing::ValuesIn(filterCPUInfo(vecCpuConfigsFusing_4D()))),
::testing::ValuesIn(filterCPUInfo(vecCpuConfigsFusing_4D())),
::testing::Values(CPUTestUtils::empty_plugin_config)),
MaxPoolingV8LayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AvgPool_CPU_4D, PoolingLayerCPUTest,
@ -80,7 +85,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_AvgPool_CPU_4D, PoolingLayerCPUTest,
::testing::ValuesIn((inpOutPrecision())),
::testing::Values(false),
::testing::ValuesIn(vecCpuConfigs),
::testing::Values(emptyFusingSpec)),
::testing::Values(emptyFusingSpec),
::testing::Values(CPUTestUtils::empty_plugin_config)),
PoolingLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AvgPool_CPU_4D_NotOptimized, PoolingLayerCPUTest,
@ -90,7 +96,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_AvgPool_CPU_4D_NotOptimized, PoolingLayerCPUTest,
::testing::ValuesIn((inpOutPrecision())),
::testing::Values(false),
::testing::Values(expectedCpuConfigAnyLayout()),
::testing::Values(emptyFusingSpec)),
::testing::Values(emptyFusingSpec),
::testing::Values(CPUTestUtils::empty_plugin_config)),
PoolingLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AvgPool_CPU_Large, PoolingLayerCPUTest,
@ -100,7 +107,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_AvgPool_CPU_Large, PoolingLayerCPUTest,
::testing::ValuesIn((inpOutPrecision())),
::testing::Values(false),
::testing::ValuesIn(vecCpuConfigs),
::testing::Values(emptyFusingSpec)),
::testing::Values(emptyFusingSpec),
::testing::Values(CPUTestUtils::empty_plugin_config)),
PoolingLayerCPUTest::getTestCaseName);
const std::vector<maxPoolV8SpecificParams> paramsMaxV85D_ref = {
@ -129,7 +137,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_MaxPool_CPU_5D, PoolingLayerCPUTest,
::testing::ValuesIn((inpOutPrecision())),
::testing::Values(false),
::testing::ValuesIn(vecCpuConfigs),
::testing::Values(emptyFusingSpec)),
::testing::Values(emptyFusingSpec),
::testing::Values(CPUTestUtils::empty_plugin_config)),
PoolingLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_MaxPoolV8_CPU_5D, MaxPoolingV8LayerCPUTest,
@ -137,7 +146,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_MaxPoolV8_CPU_5D, MaxPoolingV8LayerCPUTest,
::testing::ValuesIn(paramsMaxV85D()),
::testing::ValuesIn(inputShapes5D()),
::testing::ValuesIn((inpOutPrecision())),
::testing::ValuesIn(vecCpuConfigs)),
::testing::ValuesIn(vecCpuConfigs),
::testing::Values(CPUTestUtils::empty_plugin_config)),
MaxPoolingV8LayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_MaxPoolV8_CPU_5D_ref, MaxPoolingV8LayerCPUTest,
@ -145,7 +155,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_MaxPoolV8_CPU_5D_ref, MaxPoolingV8LayerCPUTest,
::testing::ValuesIn(paramsMaxV85D_ref),
::testing::ValuesIn(inputShapes5D()),
::testing::ValuesIn((inpOutPrecision())),
::testing::Values(expectedCpuConfigAnyLayout())),
::testing::Values(expectedCpuConfigAnyLayout()),
::testing::Values(CPUTestUtils::empty_plugin_config)),
MaxPoolingV8LayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AvgPool_CPU_5D, PoolingLayerCPUTest,
@ -155,7 +166,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_AvgPool_CPU_5D, PoolingLayerCPUTest,
::testing::ValuesIn((inpOutPrecision())),
::testing::Values(false),
::testing::ValuesIn(vecCpuConfigs),
::testing::Values(emptyFusingSpec)),
::testing::Values(emptyFusingSpec),
::testing::Values(CPUTestUtils::empty_plugin_config)),
PoolingLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AvgPool_CPU_5D_NotOptimized, PoolingLayerCPUTest,
@ -165,7 +177,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_AvgPool_CPU_5D_NotOptimized, PoolingLayerCPUTest,
::testing::ValuesIn((inpOutPrecision())),
::testing::Values(false),
::testing::Values(expectedCpuConfigAnyLayout()),
::testing::Values(emptyFusingSpec)),
::testing::Values(emptyFusingSpec),
::testing::Values(CPUTestUtils::empty_plugin_config)),
PoolingLayerCPUTest::getTestCaseName);
#endif
} // namespace Pooling

12
src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/instances/common/softmax.cpp
View File

@ -114,11 +114,11 @@ const std::vector<SoftMaxConfig> unsupportedConfigsFP32{
4},
};
const auto OptimizedParams = testing::Combine(testing::Values(ElementType::f32, ElementType::bf16),
testing::ValuesIn(optimizedConfigsFP32),
testing::Values(ov::test::utils::DEVICE_CPU),
testing::Values(notOptimizedCPUSpec));
testing::Values(notOptimizedCPUSpec),
testing::Values(CPUTestUtils::empty_plugin_config));
INSTANTIATE_TEST_SUITE_P(smoke_SoftMax_Optimized_CPU,
SoftMaxLayerCPUTest,
@ -128,7 +128,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_SoftMax_Optimized_CPU,
const auto NotOptimizedParams = testing::Combine(testing::Values(ElementType::f32, ElementType::bf16),
testing::ValuesIn(notOptimizedConfigsFP32),
testing::Values(ov::test::utils::DEVICE_CPU),
testing::Values(notOptimizedCPUSpec));
testing::Values(notOptimizedCPUSpec),
testing::Values(CPUTestUtils::empty_plugin_config));
INSTANTIATE_TEST_SUITE_P(smoke_SoftMax_CPU,
SoftMaxLayerCPUTest,
@ -138,7 +139,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_SoftMax_CPU,
const auto UnsupportedParams = testing::Combine(testing::Values(ElementType::f32, ElementType::bf16),
testing::ValuesIn(unsupportedConfigsFP32),
testing::Values(ov::test::utils::DEVICE_CPU),
testing::Values(notOptimizedCPUSpec));
testing::Values(notOptimizedCPUSpec),
testing::Values(CPUTestUtils::empty_plugin_config));
INSTANTIATE_TEST_SUITE_P(smoke_SoftMax_Unsupported_CPU,
SoftMaxLayerCPUTest,
@ -146,4 +148,4 @@ INSTANTIATE_TEST_SUITE_P(smoke_SoftMax_Unsupported_CPU,
SoftMaxLayerCPUTest::getTestCaseName);
} // namespace SoftMax
} // namespace test
} // namespace ov
} // namespace ov

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

@ -57,6 +57,7 @@ const std::vector<fusingSpecificParams> fusingParamsSetBF16{
fusingAddPerChannel
};
const std::vector<fusingSpecificParams> fusingParamsSetFP16 = fusingParamsSetBF16;
/* ============= Convolution (Gemm 1D) ============= */
INSTANTIATE_TEST_SUITE_P(smoke_Conv_1D_GEMM_FP32, ConvolutionLayerCPUTest,
::testing::Combine(
@ -393,6 +394,21 @@ INSTANTIATE_TEST_SUITE_P(smoke_Conv_1D_BF16, ConvolutionLayerCPUTest,
::testing::Values(cpu_bf16_plugin_config)),
ConvolutionLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_Conv_1D_FP16, ConvolutionLayerCPUTest,
::testing::Combine(
::testing::Combine(
convParams_ExplicitPadding_1D,
::testing::Values(ElementType::f32),
::testing::Values(ElementType::undefined),
::testing::Values(ElementType::undefined),
::testing::ValuesIn(inputShapes1d()),
::testing::Values(ov::test::utils::DEVICE_CPU)),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16({conv_avx512_1D_nspc_brgconv,
conv_avx512_1D_nspc_brgconv_amx})),
::testing::ValuesIn(fusingParamsSetFP16),
::testing::Values(cpu_f16_plugin_config)),
ConvolutionLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_Conv_1D_I8, ConvolutionLayerCPUTest,
::testing::Combine(
::testing::Combine(
@ -478,6 +494,21 @@ INSTANTIATE_TEST_SUITE_P(smoke_Conv_2D_BF16, ConvolutionLayerCPUTest,
::testing::Values(cpu_bf16_plugin_config)),
ConvolutionLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_Conv_2D_FP16, ConvolutionLayerCPUTest,
::testing::Combine(
::testing::Combine(
convParams_ExplicitPadding_2D(),
::testing::Values(ElementType::f32),
::testing::Values(ElementType::undefined),
::testing::Values(ElementType::undefined),
::testing::ValuesIn(inputShapes2d()),
::testing::Values(ov::test::utils::DEVICE_CPU)),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16({conv_avx512_2D_nspc_brgconv,
conv_avx512_2D_nspc_brgconv_amx})),
::testing::ValuesIn(fusingParamsSetFP16),
::testing::Values(cpu_f16_plugin_config)),
ConvolutionLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(Conv_2D_BF16_dilated, ConvolutionLayerCPUTest,
::testing::Combine(
::testing::Combine(
@ -493,6 +524,21 @@ INSTANTIATE_TEST_SUITE_P(Conv_2D_BF16_dilated, ConvolutionLayerCPUTest,
::testing::Values(cpu_bf16_plugin_config)),
ConvolutionLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(Conv_2D_FP16_dilated, ConvolutionLayerCPUTest,
::testing::Combine(
::testing::Combine(
convParams_ExplicitPadding_2D_dilated(),
::testing::Values(ElementType::f32),
::testing::Values(ElementType::undefined),
::testing::Values(ElementType::undefined),
::testing::ValuesIn(inputShapes2d()),
::testing::Values(ov::test::utils::DEVICE_CPU)),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16({conv_avx512_2D_nspc_brgconv,
conv_avx512_2D_nspc_brgconv_amx})),
::testing::ValuesIn(fusingParamsSetFP16),
::testing::Values(cpu_f16_plugin_config)),
ConvolutionLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_Conv_2D_PlainToBlocked_BF16, ConvolutionLayerCPUTest,
::testing::Combine(
::testing::Combine(
@ -536,6 +582,21 @@ INSTANTIATE_TEST_SUITE_P(smoke_Conv_1D_1x1_BF16, ConvolutionLayerCPUTest,
::testing::Values(cpu_bf16_plugin_config)),
ConvolutionLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_Conv_1D_1x1_FP16, ConvolutionLayerCPUTest,
::testing::Combine(
::testing::Combine(
convParams_ExplicitPadding_1x1_1D(),
::testing::Values(ElementType::f32),
::testing::Values(ElementType::undefined),
::testing::Values(ElementType::undefined),
::testing::ValuesIn(inputShapes1d()),
::testing::Values(ov::test::utils::DEVICE_CPU)),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16({conv_avx512_1D_1x1_nspc_brgconv,
conv_avx512_1D_1x1_nspc_brgconv_amx})),
::testing::ValuesIn(fusingParamsSetFP16),
::testing::Values(cpu_f16_plugin_config)),
ConvolutionLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_Conv_2D_1x1_BF16, ConvolutionLayerCPUTest,
::testing::Combine(
::testing::Combine(
@ -551,6 +612,21 @@ INSTANTIATE_TEST_SUITE_P(smoke_Conv_2D_1x1_BF16, ConvolutionLayerCPUTest,
::testing::Values(cpu_bf16_plugin_config)),
ConvolutionLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_Conv_2D_1x1_FP16, ConvolutionLayerCPUTest,
::testing::Combine(
::testing::Combine(
convParams_ExplicitPadding_1x1_2D(),
::testing::Values(ElementType::f32),
::testing::Values(ElementType::undefined),
::testing::Values(ElementType::undefined),
::testing::ValuesIn(inputShapes2d()),
::testing::Values(ov::test::utils::DEVICE_CPU)),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16({conv_avx512_2D_1x1_nspc_brgconv,
conv_avx512_2D_1x1_nspc_brgconv_amx})),
::testing::ValuesIn(fusingParamsSetFP16),
::testing::Values(cpu_f16_plugin_config)),
ConvolutionLayerCPUTest::getTestCaseName);
/* ============= Jit Planar ============= */
/* ============= Convolution planar params (2D) ============= */
const std::vector<CPUSpecificParams> CPUParams_Jit_Planar_2D = {
@ -762,6 +838,21 @@ INSTANTIATE_TEST_SUITE_P(smoke_Conv_3D_BF16, ConvolutionLayerCPUTest,
::testing::Values(cpu_bf16_plugin_config)),
ConvolutionLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_Conv_3D_FP16, ConvolutionLayerCPUTest,
::testing::Combine(
::testing::Combine(
convParams_ExplicitPadding_3D(),
::testing::Values(ElementType::f32),
::testing::Values(ElementType::undefined),
::testing::Values(ElementType::undefined),
::testing::ValuesIn(inputShapes3d()),
::testing::Values(ov::test::utils::DEVICE_CPU)),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16({conv_avx512_3D_nspc_brgconv,
conv_avx512_3D_nspc_brgconv_amx})),
::testing::ValuesIn(fusingParamsSetFP16),
::testing::Values(cpu_f16_plugin_config)),
ConvolutionLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(Conv_3D_BF16_dilated, ConvolutionLayerCPUTest,
::testing::Combine(
::testing::Combine(
@ -777,6 +868,21 @@ INSTANTIATE_TEST_SUITE_P(Conv_3D_BF16_dilated, ConvolutionLayerCPUTest,
::testing::Values(cpu_bf16_plugin_config)),
ConvolutionLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(Conv_3D_FP16_dilated, ConvolutionLayerCPUTest,
::testing::Combine(
::testing::Combine(
convParams_ExplicitPadding_3D_dilated(),
::testing::Values(ElementType::f32),
::testing::Values(ElementType::undefined),
::testing::Values(ElementType::undefined),
::testing::ValuesIn(inputShapes3d()),
::testing::Values(ov::test::utils::DEVICE_CPU)),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16({conv_avx512_3D_nspc_brgconv,
conv_avx512_3D_nspc_brgconv_amx})),
::testing::ValuesIn(fusingParamsSetFP16),
::testing::Values(cpu_f16_plugin_config)),
ConvolutionLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_Conv_3D_Jit_Planar_FP32, ConvolutionLayerCPUTest,
::testing::Combine(
::testing::Combine(
@ -808,4 +914,4 @@ INSTANTIATE_TEST_SUITE_P(Conv_3D_Jit_Planar_FP32_dilated, ConvolutionLayerCPUTes
} // namespace
} // namespace Convolution
} // namespace test
} // namespace ov
} // namespace ov

59
src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/instances/x64/convolution_backprop_data.cpp
View File

@ -11,6 +11,10 @@
using namespace CPUTestUtils;
using namespace ov::test;
namespace ov {
namespace test {
namespace DeConvolution {
namespace {
/* COMMON PARAMS */
const std::vector<fusingSpecificParams> brgDeconvFusingParamsSet{
emptyFusingSpec,
@ -207,6 +211,16 @@ INSTANTIATE_TEST_SUITE_P(smoke_Deconv_2D_NSPC_BF16_AMX,
::testing::Values(cpu_bf16_plugin_config)),
DeconvolutionLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_Deconv_2D_NSPC_FP16_AMX,
DeconvolutionLayerCPUTest,
::testing::Combine(convParams_ExplicitPadding_NSPC_2D,
::testing::ValuesIn(smoke_2D_inputs),
::testing::Values(ElementType::f32),
::testing::ValuesIn(brgDeconvFusingParamsSet),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16({conv_avx512_2D_nspc_brgconv_amx})),
::testing::Values(cpu_f16_plugin_config)),
DeconvolutionLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_Deconv_2D_NSPC_BF16_AMX_1x1,
DeconvolutionLayerCPUTest,
::testing::Combine(convParams_ExplicitPadding_NSPC_2D_1x1,
@ -217,6 +231,15 @@ INSTANTIATE_TEST_SUITE_P(smoke_Deconv_2D_NSPC_BF16_AMX_1x1,
::testing::Values(cpu_bf16_plugin_config)),
DeconvolutionLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_Deconv_2D_NSPC_FP16_AMX_1x1,
DeconvolutionLayerCPUTest,
::testing::Combine(convParams_ExplicitPadding_NSPC_2D_1x1,
::testing::ValuesIn(smoke_2D_inputs),
::testing::Values(ElementType::f32),
::testing::ValuesIn(brgDeconvFusingParamsSet),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16({conv_avx512_2D_1x1_nspc_brgconv_amx})),
::testing::Values(cpu_f16_plugin_config)),
DeconvolutionLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_Deconv_2D_NSPC_BRG,
DeconvolutionLayerCPUTest,
@ -338,6 +361,16 @@ INSTANTIATE_TEST_SUITE_P(smoke_Deconv_3D_NSPC_BF16_AMX,
::testing::Values(cpu_bf16_plugin_config)),
DeconvolutionLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_Deconv_3D_NSPC_FP16_AMX,
DeconvolutionLayerCPUTest,
::testing::Combine(convParams_ExplicitPadding_NSPC_3D,
::testing::ValuesIn(smoke_3D_inputs),
::testing::Values(ElementType::f32),
::testing::ValuesIn(brgDeconvFusingParamsSet),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16({conv_avx512_3D_nspc_brgconv_amx})),
::testing::Values(cpu_f16_plugin_config)),
DeconvolutionLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_Deconv_3D_NSPC_BF16_AMX_1x1,
DeconvolutionLayerCPUTest,
::testing::Combine(convParams_ExplicitPadding_NSPC_3D_1x1,
@ -348,6 +381,16 @@ INSTANTIATE_TEST_SUITE_P(smoke_Deconv_3D_NSPC_BF16_AMX_1x1,
::testing::Values(cpu_bf16_plugin_config)),
DeconvolutionLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_Deconv_3D_NSPC_FP16_AMX_1x1,
DeconvolutionLayerCPUTest,
::testing::Combine(convParams_ExplicitPadding_NSPC_3D_1x1,
::testing::ValuesIn(smoke_3D_inputs),
::testing::Values(ElementType::f32),
::testing::ValuesIn(brgDeconvFusingParamsSet),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16({conv_avx512_3D_1x1_nspc_brgconv_amx})),
::testing::Values(cpu_f16_plugin_config)),
DeconvolutionLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_Deconv_3D_NSPC_BRG,
DeconvolutionLayerCPUTest,
::testing::Combine(convParams_ExplicitPadding_NSPC_3D,
@ -525,3 +568,19 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(filterCPUInfoForDevice({conv_avx512_2D_nspc_brgconv_amx})),
::testing::Values(cpu_bf16_plugin_config)),
DeconvolutionLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(
smoke_Deconv_2D_AutoPadding_AMX_FP16,
DeconvolutionLayerCPUTest,
::testing::Combine(deconvParams_AutoPadding_2D_AMX,
::testing::Values(inputs_2D_AutoPadding_AMX),
::testing::Values(ElementType::f32),
::testing::Values(emptyFusingSpec),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16({conv_avx512_2D_nspc_brgconv_amx})),
::testing::Values(cpu_f16_plugin_config)),
DeconvolutionLayerCPUTest::getTestCaseName);
} // namespace
} // namespace DeConvolution
} // namespace test
} // namespace ov

273
src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/instances/x64/matmul.cpp
View File

@ -13,6 +13,15 @@ namespace ov {
namespace test {
namespace MatMul {
namespace {
const std::vector<CPUSpecificParams> specificParams_FP16 {
CPUSpecificParams{{}, {}, {"brgemm_avx512"}, "brgemm_avx512"}
};
const std::vector<CPUSpecificParams> specificParams_FP16_AMX {
CPUSpecificParams{{}, {}, {"brgemm_avx512_amx"}, "brgemm_avx512_amx"}
};
const std::vector<ShapeRelatedParams> IS_x64 = {
{static_shapes_to_test_representation({{7, 32, 120}, {3, 7, 120, 50}}), {false, false}},
{static_shapes_to_test_representation({{7, 32, 120}, {3, 7, 120, 50}}), {true, false}},
@ -47,6 +56,7 @@ std::vector<fusingSpecificParams> fusingParamsSet2DBF16 {
fusingPReluPerTensor,
};
std::vector<fusingSpecificParams> fusingParamsSet2DFP16 = fusingParamsSet2DBF16;
const std::vector<fusingSpecificParams> matmulFusingParamsNightly {
emptyFusingSpec,
fusingElu,
@ -71,6 +81,21 @@ const auto testParams_Static_IS_x64 = ::testing::Combine(matMulParams_x64,
INSTANTIATE_TEST_SUITE_P(smoke_MM_Static_IS_x64, MatMulLayerCPUTest, testParams_Static_IS_x64, MatMulLayerCPUTest::getTestCaseName);
const auto matMulParams_x64_FP16 = ::testing::Combine(::testing::ValuesIn(IS_x64),
::testing::Values(ov::element::f32),
::testing::Values(ElementType::undefined),
::testing::Values(ElementType::undefined),
::testing::Values(utils::InputLayerType::PARAMETER),
::testing::Values(ov::test::utils::DEVICE_CPU),
::testing::Values(cpu_f16_plugin_config));
const auto testParams_Static_IS_x64_FP16 = ::testing::Combine(matMulParams_x64_FP16,
::testing::Values(MatMulNodeType::MatMul),
::testing::ValuesIn(matmulFusingParams()),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16(specificParams_FP16)));
INSTANTIATE_TEST_SUITE_P(smoke_MM_Static_IS_x64_FP16, MatMulLayerCPUTest, testParams_Static_IS_x64_FP16, MatMulLayerCPUTest::getTestCaseName);
const auto testParams2D_smoke = ::testing::Combine(::testing::Combine(::testing::ValuesIn(IS2D_smoke()),
::testing::Values(ElementType::f32),
::testing::Values(ElementType::undefined),
@ -93,8 +118,20 @@ const auto testParams2DBF16_smoke = ::testing::Combine(::testing::Combine(::test
::testing::ValuesIn(fusingParamsSet2DBF16),
::testing::ValuesIn(filterCPUInfo(filterSpecificParams())));
const auto testParams2DFP16_smoke = ::testing::Combine(::testing::Combine(::testing::ValuesIn(IS2D_smoke()),
::testing::Values(ov::element::f32),
::testing::Values(ElementType::undefined),
::testing::Values(ElementType::undefined),
::testing::Values(utils::InputLayerType::CONSTANT),
::testing::Values(ov::test::utils::DEVICE_CPU),
::testing::Values(cpu_f16_plugin_config)),
::testing::Values(MatMulNodeType::FullyConnected),
::testing::ValuesIn(fusingParamsSet2DFP16),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16(specificParams_FP16)));
INSTANTIATE_TEST_SUITE_P(smoke_FC_2D, MatMulLayerCPUTest, testParams2D_smoke, MatMulLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_FC_2D_BF16, MatMulLayerCPUTest, testParams2DBF16_smoke, MatMulLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_FC_2D_FP16, MatMulLayerCPUTest, testParams2DFP16_smoke, MatMulLayerCPUTest::getTestCaseName);
const auto testParams2D_nightly = ::testing::Combine(::testing::Combine(::testing::ValuesIn(IS2D_nightly()),
::testing::Values(ElementType::f32),
@ -212,12 +249,26 @@ const auto fullyConnectedParams2D_Brgemm_smoke = ::testing::Combine(::testing::V
::testing::Values(ov::test::utils::DEVICE_CPU),
::testing::ValuesIn(filterAdditionalConfig_Brgemm()));
const auto fullyConnectedParams2D_Brgemm_FP16_smoke = ::testing::Combine(::testing::ValuesIn(IS2D_Brgemm_smoke),
::testing::Values(ElementType::f32),
::testing::Values(ElementType::undefined),
::testing::Values(ElementType::undefined),
::testing::Values(utils::InputLayerType::CONSTANT),
::testing::Values(ov::test::utils::DEVICE_CPU),
::testing::Values(cpu_f16_plugin_config));
const auto testParams2D_Brgemm_smoke = ::testing::Combine(fullyConnectedParams2D_Brgemm_smoke,
::testing::Values(MatMulNodeType::FullyConnected),
::testing::ValuesIn(fusingParamsSet2D_Brgemm_smoke),
::testing::ValuesIn(filterSpecificParams_Brgemm(true)));
const auto testParams2D_Brgemm_FP16_smoke = ::testing::Combine(fullyConnectedParams2D_Brgemm_FP16_smoke,
::testing::Values(MatMulNodeType::FullyConnected),
::testing::ValuesIn(fusingParamsSet2D_Brgemm_smoke),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16(specificParams_FP16)));
INSTANTIATE_TEST_SUITE_P(smoke_FC_2D_Brgemm, MatMulLayerCPUTest, testParams2D_Brgemm_smoke, MatMulLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_FC_2D_Brgemm_FP16, MatMulLayerCPUTest, testParams2D_Brgemm_FP16_smoke, MatMulLayerCPUTest::getTestCaseName);
const std::vector<ShapeRelatedParams> IS_brgemm_smoke = {
{static_shapes_to_test_representation({{1, 2, 32, 120}, {120, 5}}), {false, false}},
@ -248,6 +299,21 @@ const auto testBrgemmParams_smoke = ::testing::Combine(matMulBrgemmParams_smoke,
INSTANTIATE_TEST_SUITE_P(smoke_MM_Brgemm_Static, MatMulLayerCPUTest, testBrgemmParams_smoke, MatMulLayerCPUTest::getTestCaseName);
const auto matMulBrgemmParams_FP16_smoke = ::testing::Combine(::testing::ValuesIn(IS_brgemm_smoke),
::testing::Values(ElementType::f32),
::testing::Values(ElementType::undefined),
::testing::Values(ElementType::undefined),
::testing::Values(utils::InputLayerType::PARAMETER),
::testing::Values(ov::test::utils::DEVICE_CPU),
::testing::Values(cpu_f16_plugin_config));
const auto testBrgemmParams_FP16_smoke = ::testing::Combine(matMulBrgemmParams_FP16_smoke,
::testing::Values(MatMulNodeType::MatMul),
::testing::ValuesIn(matmulFusingParams()),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16(specificParams_FP16)));
INSTANTIATE_TEST_SUITE_P(smoke_MM_Brgemm_Static_FP16, MatMulLayerCPUTest, testBrgemmParams_FP16_smoke, MatMulLayerCPUTest::getTestCaseName);
const std::vector<ShapeRelatedParams> IS_brgemm_nightly = {
{static_shapes_to_test_representation({{1, 2, 32, 120}, {120, 5}}), {false, true}},
{static_shapes_to_test_representation({{1, 2, 32, 120}, {120, 5}}), {true, true}},
@ -277,6 +343,21 @@ const auto testBrgemmParams_nightly = ::testing::Combine(matMulBrgemmParams_nigh
INSTANTIATE_TEST_SUITE_P(nightly_MM_Brgemm_Static, MatMulLayerCPUTest, testBrgemmParams_nightly, MatMulLayerCPUTest::getTestCaseName);
const auto matMulBrgemmParams_FP16_nightly = ::testing::Combine(::testing::ValuesIn(IS_brgemm_nightly),
::testing::Values(ElementType::f32),
::testing::Values(ElementType::undefined),
::testing::Values(ElementType::undefined),
::testing::Values(utils::InputLayerType::PARAMETER),
::testing::Values(ov::test::utils::DEVICE_CPU),
::testing::Values(cpu_f16_plugin_config));
const auto testBrgemmParams_FP16_nightly = ::testing::Combine(matMulBrgemmParams_FP16_nightly,
::testing::Values(MatMulNodeType::MatMul),
::testing::ValuesIn(matmulFusingParams()),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16(specificParams_FP16)));
INSTANTIATE_TEST_SUITE_P(nightly_MM_Brgemm_Static_FP16, MatMulLayerCPUTest, testBrgemmParams_FP16_nightly, MatMulLayerCPUTest::getTestCaseName);
const std::vector<ShapeRelatedParams> IS_Brgemm_Dynamic = {
{
{
@ -351,6 +432,21 @@ const auto testBrgemmParamsDynamic = ::testing::Combine(matMulBrgemmParamsDynami
INSTANTIATE_TEST_SUITE_P(smoke_MM_Brgemm_Dynamic, MatMulLayerCPUTest, testBrgemmParamsDynamic, MatMulLayerCPUTest::getTestCaseName);
const auto matMulBrgemmParamsDynamic_FP16 = ::testing::Combine(::testing::ValuesIn(IS_Brgemm_Dynamic),
::testing::Values(ElementType::f32),
::testing::Values(ElementType::undefined),
::testing::Values(ElementType::undefined),
::testing::Values(utils::InputLayerType::PARAMETER),
::testing::Values(ov::test::utils::DEVICE_CPU),
::testing::Values(cpu_f16_plugin_config));
const auto testBrgemmParamsDynamic_FP16 = ::testing::Combine(matMulBrgemmParamsDynamic_FP16,
::testing::Values(MatMulNodeType::MatMul),
::testing::Values(emptyFusingSpec),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16(specificParams_FP16)));
INSTANTIATE_TEST_SUITE_P(smoke_MM_Brgemm_Dynamic_FP16, MatMulLayerCPUTest, testBrgemmParamsDynamic_FP16, MatMulLayerCPUTest::getTestCaseName);
const std::vector<ShapeRelatedParams> IS_Dynamic_Fusing = {
{
{ //dynamic case description each pair per each input has {{dynamic shape}, {{static shape case1}, {static shape case2}, ...}
@ -415,6 +511,21 @@ const auto testParamsDynamicFusing = ::testing::Combine(matMulParamsDynamicFusin
INSTANTIATE_TEST_SUITE_P(smoke_MM_Dynamic_Fusing, MatMulLayerCPUTest, testParamsDynamicFusing, MatMulLayerCPUTest::getTestCaseName);
const auto matMulParamsDynamicFusing_FP16 = ::testing::Combine(::testing::ValuesIn(IS_Dynamic_Fusing),
::testing::Values(ov::element::f32),
::testing::Values(ElementType::undefined),
::testing::Values(ElementType::undefined),
::testing::Values(utils::InputLayerType::PARAMETER),
::testing::Values(ov::test::utils::DEVICE_CPU),
::testing::Values(cpu_f16_plugin_config));
const auto testParamsDynamicFusing_FP16 = ::testing::Combine(matMulParamsDynamicFusing_FP16,
::testing::Values(MatMulNodeType::MatMul),
::testing::ValuesIn(matmulFusingParams()),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16(specificParams_FP16)));
INSTANTIATE_TEST_SUITE_P(smoke_MM_Dynamic_Fusing_FP16, MatMulLayerCPUTest, testParamsDynamicFusing_FP16, MatMulLayerCPUTest::getTestCaseName);
const auto matMulParamsBrgemmDynamicFusing = ::testing::Combine(::testing::ValuesIn(IS_Dynamic_Fusing),
::testing::Values(ElementType::f32),
::testing::Values(ElementType::undefined),
@ -430,6 +541,21 @@ const auto testParamsBrgemmDynamicFusing = ::testing::Combine(matMulParamsBrgemm
INSTANTIATE_TEST_SUITE_P(smoke_MM_Brgemm_Dynamic_Fusing, MatMulLayerCPUTest, testParamsBrgemmDynamicFusing, MatMulLayerCPUTest::getTestCaseName);
const auto matMulParamsBrgemmDynamicFusing_FP16 = ::testing::Combine(::testing::ValuesIn(IS_Dynamic_Fusing),
::testing::Values(ElementType::f32),
::testing::Values(ElementType::undefined),
::testing::Values(ElementType::undefined),
::testing::Values(utils::InputLayerType::PARAMETER),
::testing::Values(ov::test::utils::DEVICE_CPU),
::testing::Values(cpu_f16_plugin_config));
const auto testParamsBrgemmDynamicFusing_FP16 = ::testing::Combine(matMulParamsBrgemmDynamicFusing_FP16,
::testing::Values(MatMulNodeType::MatMul),
::testing::ValuesIn(matmulFusingParams()),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16(specificParams_FP16)));
INSTANTIATE_TEST_SUITE_P(smoke_MM_Brgemm_Dynamic_Fusing_FP16, MatMulLayerCPUTest, testParamsBrgemmDynamicFusing_FP16, MatMulLayerCPUTest::getTestCaseName);
std::vector<ov::AnyMap> filterAdditionalConfig_BrgemmAmx() {
std::vector<ov::AnyMap> additionalConfig;
if (with_cpu_x86_bfloat16()) {
@ -485,6 +611,21 @@ const auto testBrgemmAmxParams_smoke = ::testing::Combine(matMulBrgemmAmxParams_
INSTANTIATE_TEST_SUITE_P(smoke_MM_Brgemm_Amx_Static, MatMulLayerCPUTest, testBrgemmAmxParams_smoke, MatMulLayerCPUTest::getTestCaseName);
const auto matMulBrgemmAmxParams_FP16_smoke = ::testing::Combine(::testing::ValuesIn(IS_brgemm_Amx_smoke),
::testing::Values(ElementType::f32),
::testing::Values(ElementType::undefined),
::testing::Values(ElementType::undefined),
::testing::Values(utils::InputLayerType::PARAMETER),
::testing::Values(ov::test::utils::DEVICE_CPU),
::testing::Values(cpu_f16_plugin_config));
const auto testBrgemmAmxParams_FP16_smoke = ::testing::Combine(matMulBrgemmAmxParams_FP16_smoke,
::testing::Values(MatMulNodeType::MatMul),
::testing::ValuesIn(matmulBrgemmAmxFusingParams),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16(specificParams_FP16_AMX)));
INSTANTIATE_TEST_SUITE_P(smoke_MM_Brgemm_Amx_Static_FP16, MatMulLayerCPUTest, testBrgemmAmxParams_FP16_smoke, MatMulLayerCPUTest::getTestCaseName);
const auto matMulBrgemmAmxParams_nightly = ::testing::Combine(::testing::ValuesIn(IS_brgemm_Amx_smoke),
::testing::Values(ElementType::f32),
::testing::Values(ElementType::undefined),
@ -500,6 +641,21 @@ const auto testBrgemmAmxParams_nightly = ::testing::Combine(matMulBrgemmAmxParam
INSTANTIATE_TEST_SUITE_P(nightly_MM_Brgemm_Amx_Static, MatMulLayerCPUTest, testBrgemmAmxParams_nightly, MatMulLayerCPUTest::getTestCaseName);
const auto matMulBrgemmAmxParams_FP16_nightly = ::testing::Combine(::testing::ValuesIn(IS_brgemm_Amx_smoke),
::testing::Values(ElementType::f32),
::testing::Values(ElementType::undefined),
::testing::Values(ElementType::undefined),
::testing::Values(utils::InputLayerType::PARAMETER),
::testing::Values(ov::test::utils::DEVICE_CPU),
::testing::Values(cpu_f16_plugin_config));
const auto testBrgemmAmxParams_FP16_nightly = ::testing::Combine(matMulBrgemmAmxParams_FP16_nightly,
::testing::Values(MatMulNodeType::MatMul),
::testing::ValuesIn(matmulBrgemmAmxFusingParams),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16(specificParams_FP16_AMX)));
INSTANTIATE_TEST_SUITE_P(nightly_MM_Brgemm_Amx_Static_FP16, MatMulLayerCPUTest, testBrgemmAmxParams_FP16_nightly, MatMulLayerCPUTest::getTestCaseName);
const auto matMulBrgemmAmxParamsDynamic = ::testing::Combine(::testing::ValuesIn(IS_Brgemm_Dynamic),
::testing::Values(ElementType::f32),
::testing::Values(ElementType::undefined),
@ -515,6 +671,21 @@ const auto testBrgemmAmxParamsDynamic = ::testing::Combine(matMulBrgemmAmxParams
INSTANTIATE_TEST_SUITE_P(smoke_MM_Brgemm_Amx_Dynamic, MatMulLayerCPUTest, testBrgemmAmxParamsDynamic, MatMulLayerCPUTest::getTestCaseName);
const auto matMulBrgemmAmxParamsDynamic_FP16 = ::testing::Combine(::testing::ValuesIn(IS_Brgemm_Dynamic),
::testing::Values(ElementType::f32),
::testing::Values(ElementType::undefined),
::testing::Values(ElementType::undefined),
::testing::Values(utils::InputLayerType::PARAMETER),
::testing::Values(ov::test::utils::DEVICE_CPU),
::testing::Values(cpu_f16_plugin_config));
const auto testBrgemmAmxParamsDynamic_FP16 = ::testing::Combine(matMulBrgemmAmxParamsDynamic_FP16,
::testing::Values(MatMulNodeType::MatMul),
::testing::Values(emptyFusingSpec),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16(specificParams_FP16_AMX)));
INSTANTIATE_TEST_SUITE_P(smoke_MM_Brgemm_Amx_Dynamic_FP16, MatMulLayerCPUTest, testBrgemmAmxParamsDynamic_FP16, MatMulLayerCPUTest::getTestCaseName);
const std::vector<ShapeRelatedParams> IS2D_Brgemm_Amx_smoke = {
{static_shapes_to_test_representation({{59, 16}, {16, 120}}), {true, false}},
{static_shapes_to_test_representation({{59, 16}, {16, 120}}), {true, true}},
@ -630,6 +801,21 @@ const auto testParams2D_Brgemm_Amx_smoke = ::testing::Combine(fullyConnectedPara
INSTANTIATE_TEST_SUITE_P(smoke_FC_2D_Brgemm_Amx, MatMulLayerCPUTest, testParams2D_Brgemm_Amx_smoke, MatMulLayerCPUTest::getTestCaseName);
const auto fullyConnectedParams2D_FP16_Brgemm_Amx_smoke = ::testing::Combine(::testing::ValuesIn(IS2D_Brgemm_Amx_smoke),
::testing::Values(ElementType::f32),
::testing::Values(ElementType::undefined),
::testing::Values(ElementType::undefined),
::testing::Values(utils::InputLayerType::CONSTANT),
::testing::Values(ov::test::utils::DEVICE_CPU),
::testing::Values(cpu_f16_plugin_config));
const auto testParams2D_FP16_Brgemm_Amx_smoke = ::testing::Combine(fullyConnectedParams2D_FP16_Brgemm_Amx_smoke,
::testing::Values(MatMulNodeType::FullyConnected),
::testing::ValuesIn(fusingParamsSet2D_Brgemm_smoke),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16(specificParams_FP16_AMX)));
INSTANTIATE_TEST_SUITE_P(smoke_FC_2D_Brgemm_Amx_FP16, MatMulLayerCPUTest, testParams2D_FP16_Brgemm_Amx_smoke, MatMulLayerCPUTest::getTestCaseName);
const std::vector<ShapeRelatedParams> IS2D_Brgemm_nightly = {
{static_shapes_to_test_representation({{59, 16}, {16, 120}}), {false, false}},
{static_shapes_to_test_representation({{59, 16}, {16, 120}}), {false, true}},
@ -668,6 +854,21 @@ const auto testParams2D_Brgemm_nightly = ::testing::Combine(fullyConnectedParams
INSTANTIATE_TEST_SUITE_P(nightly_FC_2D_Brgemm, MatMulLayerCPUTest, testParams2D_Brgemm_nightly, MatMulLayerCPUTest::getTestCaseName);
const auto fullyConnectedParams2D_FP16_Brgemm_nightly = ::testing::Combine(::testing::ValuesIn(IS2D_Brgemm_nightly),
::testing::Values(ElementType::f32),
::testing::Values(ElementType::undefined),
::testing::Values(ElementType::undefined),
::testing::Values(utils::InputLayerType::CONSTANT),
::testing::Values(ov::test::utils::DEVICE_CPU),
::testing::Values(cpu_f16_plugin_config));
const auto testParams2D_FP16_Brgemm_nightly = ::testing::Combine(fullyConnectedParams2D_FP16_Brgemm_nightly,
::testing::Values(MatMulNodeType::FullyConnected),
::testing::ValuesIn(fusingParamsSet2D_nightly),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16(specificParams_FP16)));
INSTANTIATE_TEST_SUITE_P(nightly_FC_2D_Brgemm_FP16, MatMulLayerCPUTest, testParams2D_FP16_Brgemm_nightly, MatMulLayerCPUTest::getTestCaseName);
const auto fullyConnectedParams2D_Brgemm_Amx_nightly = ::testing::Combine(::testing::ValuesIn(IS2D_Brgemm_nightly),
::testing::Values(ElementType::f32),
::testing::Values(ElementType::undefined),
@ -683,6 +884,21 @@ const auto testParams2D_Brgemm_Amx_nightly = ::testing::Combine(fullyConnectedPa
INSTANTIATE_TEST_SUITE_P(nightly_FC_2D_Brgemm_Amx, MatMulLayerCPUTest, testParams2D_Brgemm_Amx_nightly, MatMulLayerCPUTest::getTestCaseName);
const auto fullyConnectedParams2D_FP16_Brgemm_Amx_nightly = ::testing::Combine(::testing::ValuesIn(IS2D_Brgemm_nightly),
::testing::Values(ElementType::f32),
::testing::Values(ElementType::undefined),
::testing::Values(ElementType::undefined),
::testing::Values(utils::InputLayerType::CONSTANT),
::testing::Values(ov::test::utils::DEVICE_CPU),
::testing::Values(cpu_f16_plugin_config));
const auto testParams2D_FP16_Brgemm_Amx_nightly = ::testing::Combine(fullyConnectedParams2D_FP16_Brgemm_Amx_nightly,
::testing::Values(MatMulNodeType::FullyConnected),
::testing::ValuesIn(fusingParamsSet2D_nightly),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16(specificParams_FP16_AMX)));
INSTANTIATE_TEST_SUITE_P(nightly_FC_2D_Brgemm_Amx_FP16, MatMulLayerCPUTest, testParams2D_FP16_Brgemm_Amx_nightly, MatMulLayerCPUTest::getTestCaseName);
const auto testParams2DBF16_nightly = ::testing::Combine(::testing::Combine(::testing::ValuesIn(IS2D_nightly()),
::testing::ValuesIn(netPRCs()),
::testing::Values(ElementType::undefined),
@ -694,8 +910,20 @@ const auto testParams2DBF16_nightly = ::testing::Combine(::testing::Combine(::te
::testing::ValuesIn(fusingParamsSet2DBF16),
::testing::ValuesIn(filterCPUInfo(filterSpecificParams())));
const auto testParams2DFP16_nightly = ::testing::Combine(::testing::Combine(::testing::ValuesIn(IS2D_nightly()),
::testing::Values(ov::element::f32),
::testing::Values(ElementType::undefined),
::testing::Values(ElementType::undefined),
::testing::Values(utils::InputLayerType::CONSTANT),
::testing::Values(ov::test::utils::DEVICE_CPU),
::testing::Values(cpu_f16_plugin_config)),
::testing::Values(MatMulNodeType::FullyConnected),
::testing::ValuesIn(fusingParamsSet2DFP16),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16(specificParams_FP16)));
INSTANTIATE_TEST_SUITE_P(nightly_FC_2D, MatMulLayerCPUTest, testParams2D_nightly, MatMulLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(nightly_FC_2D_BF16, MatMulLayerCPUTest, testParams2DBF16_nightly, MatMulLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(nightly_FC_2D_FP16, MatMulLayerCPUTest, testParams2DFP16_nightly, MatMulLayerCPUTest::getTestCaseName);
std::vector<fusingSpecificParams> fusingParamsSet3D_smoke {
// The following three patterns are convered by MLAS test
@ -714,6 +942,12 @@ std::vector<fusingSpecificParams> fusingParamsSet3DBF16 {
fusingMultiplyPerChannel,
};
std::vector<fusingSpecificParams> fusingParamsSet3DFP16 {
emptyFusingSpec,
fusingBias,
fusingMultiplyPerChannel,
};
const auto fullyConnectedParams3DBF16_smoke = ::testing::Combine(::testing::ValuesIn(IS3D_smoke()),
::testing::ValuesIn(netPRCs()),
::testing::Values(ElementType::undefined),
@ -722,12 +956,26 @@ const auto fullyConnectedParams3DBF16_smoke = ::testing::Combine(::testing::Valu
::testing::Values(ov::test::utils::DEVICE_CPU),
::testing::ValuesIn(additionalConfig()));
const auto fullyConnectedParams3DFP16_smoke = ::testing::Combine(::testing::ValuesIn(IS3D_smoke()),
::testing::Values(ov::element::f32),
::testing::Values(ElementType::undefined),
::testing::Values(ElementType::undefined),
::testing::Values(utils::InputLayerType::CONSTANT),
::testing::Values(ov::test::utils::DEVICE_CPU),
::testing::Values(cpu_f16_plugin_config));
const auto testParams3DBF16_smoke = ::testing::Combine(fullyConnectedParams3DBF16_smoke,
::testing::Values(MatMulNodeType::FullyConnected),
::testing::ValuesIn(fusingParamsSet3DBF16),
::testing::ValuesIn(filterCPUInfo(filterSpecificParams())));
const auto testParams3DFP16_smoke = ::testing::Combine(fullyConnectedParams3DFP16_smoke,
::testing::Values(MatMulNodeType::FullyConnected),
::testing::ValuesIn(fusingParamsSet3DFP16),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16(specificParams_FP16)));
INSTANTIATE_TEST_SUITE_P(smoke_FC_3D_BF16, MatMulLayerCPUTest, testParams3DBF16_smoke, MatMulLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_FC_3D_FP16, MatMulLayerCPUTest, testParams3DFP16_smoke, MatMulLayerCPUTest::getTestCaseName);
const auto fullyConnectedParams3D_smoke = ::testing::Combine(::testing::ValuesIn(IS3D_smoke()),
::testing::Values(ElementType::f32),
@ -794,19 +1042,32 @@ const auto fullyConnectedParams3DBF16_nightly = ::testing::Combine(::testing::Va
::testing::Values(ov::test::utils::DEVICE_CPU),
::testing::ValuesIn(additionalConfig()));
const auto testParams3DBF16_nightly = ::testing::Combine(fullyConnectedParams3DBF16_nightly,
::testing::Values(MatMulNodeType::FullyConnected),
::testing::ValuesIn(fusingParamsSet3DBF16),
::testing::ValuesIn(filterCPUInfo(filterSpecificParams())));
INSTANTIATE_TEST_SUITE_P(nightly_FC_3D_BF16, MatMulLayerCPUTest, testParams3DBF16_nightly, MatMulLayerCPUTest::getTestCaseName);
const auto fullyConnectedParams3DFP16_nightly = ::testing::Combine(::testing::ValuesIn(IS3D_nightly),
::testing::Values(ov::element::f32),
::testing::Values(ElementType::undefined),
::testing::Values(ElementType::undefined),
::testing::Values(utils::InputLayerType::CONSTANT),
::testing::Values(ov::test::utils::DEVICE_CPU),
::testing::Values(cpu_f16_plugin_config));
const auto testParams3D_nightly = ::testing::Combine(fullyConnectedParams3D_nightly,
::testing::Values(MatMulNodeType::FullyConnected),
::testing::ValuesIn(fusingParamsSet3D_nightly),
::testing::ValuesIn(filterCPUInfo(filterSpecificParams())));
const auto testParams3DBF16_nightly = ::testing::Combine(fullyConnectedParams3DBF16_nightly,
::testing::Values(MatMulNodeType::FullyConnected),
::testing::ValuesIn(fusingParamsSet3DBF16),
::testing::ValuesIn(filterCPUInfo(filterSpecificParams())));
const auto testParams3DFP16_nightly = ::testing::Combine(fullyConnectedParams3DFP16_nightly,
::testing::Values(MatMulNodeType::FullyConnected),
::testing::ValuesIn(fusingParamsSet3DFP16),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16(specificParams_FP16)));
INSTANTIATE_TEST_SUITE_P(nightly_FC_3D, MatMulLayerCPUTest, testParams3D_nightly, MatMulLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(nightly_FC_3D_BF16, MatMulLayerCPUTest, testParams3DBF16_nightly, MatMulLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(nightly_FC_3D_FP16, MatMulLayerCPUTest, testParams3DFP16_nightly, MatMulLayerCPUTest::getTestCaseName);
class MatMulLayerCPUTestUndefShapes : public MatMulLayerCPUTest {
};

127
src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/instances/x64/pooling.cpp
View File

@ -38,7 +38,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_MaxPoolV8_CPU_4D_ref, MaxPoolingV8LayerCPUTest,
::testing::ValuesIn(paramsMaxV84D_ref),
::testing::ValuesIn(inputShapes4D()),
::testing::ValuesIn((inpOutPrecision())),
::testing::Values(ref)),
::testing::Values(ref),
::testing::Values(CPUTestUtils::empty_plugin_config)),
MaxPoolingV8LayerCPUTest::getTestCaseName);
const auto avx512_nwc = CPUSpecificParams{{nwc}, {nwc}, {"jit_avx512"}, "jit_avx512"};
@ -100,7 +101,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_AvgPool_CPU_4D_I8, PoolingLayerCPUTest,
::testing::Values(ElementType::f32),
::testing::Values(true),
::testing::ValuesIn(filterCPUInfoForDevice(vecCpuConfigsFusing_4D)),
::testing::ValuesIn(fusingParamsSet)),
::testing::ValuesIn(fusingParamsSet),
::testing::Values(CPUTestUtils::empty_plugin_config)),
PoolingLayerCPUTest::getTestCaseName);
const std::vector<InputShape> inputShapes5D_int8 = {
@ -140,9 +142,116 @@ INSTANTIATE_TEST_SUITE_P(smoke_AvgPool_CPU_5D_I8, PoolingLayerCPUTest,
::testing::Values(ElementType::f32),
::testing::Values(true),
::testing::ValuesIn(filterCPUInfoForDevice(vecCpuConfigsFusing_5D)),
::testing::ValuesIn(fusingParamsSet)),
::testing::ValuesIn(fusingParamsSet),
::testing::Values(CPUTestUtils::empty_plugin_config)),
PoolingLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AvgPool_CPU_4D_I8_FP16, PoolingLayerCPUTest,
::testing::Combine(
::testing::ValuesIn(paramsAvg4D()),
::testing::ValuesIn(inputShapes4D_int8),
::testing::Values(ElementType::f32),
::testing::Values(true),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16(vecCpuConfigsFusing_4D)),
::testing::ValuesIn(fusingParamsSet),
::testing::Values(cpu_f16_plugin_config)),
PoolingLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AvgPool_CPU_5D_I8_FP16, PoolingLayerCPUTest,
::testing::Combine(
::testing::ValuesIn(paramsAvg5D()),
::testing::ValuesIn(inputShapes5D_int8),
::testing::Values(ElementType::f32),
::testing::Values(true),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16(vecCpuConfigsFusing_5D)),
::testing::ValuesIn(fusingParamsSet),
::testing::Values(cpu_f16_plugin_config)),
PoolingLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_MaxPool_CPU_3D_FP16, PoolingLayerCPUTest,
::testing::Combine(
::testing::ValuesIn(paramsMax3D()),
::testing::ValuesIn(inputShapes3D()),
::testing::ValuesIn(inpOutPrecision()),
::testing::Values(false),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16(vecCpuConfigs)),
::testing::Values(emptyFusingSpec),
::testing::Values(cpu_f16_plugin_config)),
PoolingLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AvgPool_CPU_3D_FP16, PoolingLayerCPUTest,
::testing::Combine(
::testing::ValuesIn(paramsAvg3D()),
::testing::ValuesIn(inputShapes3D()),
::testing::ValuesIn(inpOutPrecision()),
::testing::Values(false),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16(vecCpuConfigs)),
::testing::Values(emptyFusingSpec),
::testing::Values(cpu_f16_plugin_config)),
PoolingLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_MaxPool_CPU_4D_FP16, PoolingLayerCPUTest,
::testing::Combine(
::testing::ValuesIn(paramsMax4D()),
::testing::ValuesIn(inputShapes4D()),
::testing::ValuesIn(inpOutPrecision()),
::testing::Values(false),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16(vecCpuConfigs)),
::testing::Values(emptyFusingSpec),
::testing::Values(cpu_f16_plugin_config)),
PoolingLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_MaxPoolV8_CPU_4D_FP16, MaxPoolingV8LayerCPUTest,
::testing::Combine(
::testing::ValuesIn(paramsMaxV84D()),
::testing::ValuesIn(inputShapes4D()),
::testing::ValuesIn(inpOutPrecision()),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16(vecCpuConfigs)),
::testing::Values(cpu_f16_plugin_config)),
MaxPoolingV8LayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AvgPool_CPU_4D_FP16, PoolingLayerCPUTest,
::testing::Combine(
::testing::ValuesIn(paramsAvg4D()),
::testing::ValuesIn(inputShapes4D()),
::testing::ValuesIn(inpOutPrecision()),
::testing::Values(false),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16(vecCpuConfigs)),
::testing::Values(emptyFusingSpec),
::testing::Values(cpu_f16_plugin_config)),
PoolingLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_AvgPool_CPU_Large_FP16, PoolingLayerCPUTest,
::testing::Combine(
::testing::ValuesIn(paramsAvg4D_Large()),
::testing::ValuesIn(inputShapes4D_Large()),
::testing::ValuesIn(inpOutPrecision()),
::testing::Values(false),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16(vecCpuConfigs)),
::testing::Values(emptyFusingSpec),
::testing::Values(cpu_f16_plugin_config)),
PoolingLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_MaxPool_CPU_5D_FP16, PoolingLayerCPUTest,
::testing::Combine(
::testing::ValuesIn(paramsMax5D()),
::testing::ValuesIn(inputShapes5D()),
::testing::ValuesIn(inpOutPrecision()),
::testing::Values(false),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16(vecCpuConfigs)),
::testing::Values(emptyFusingSpec),
::testing::Values(cpu_f16_plugin_config)),
PoolingLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_MaxPoolV8_CPU_5D_FP16, MaxPoolingV8LayerCPUTest,
::testing::Combine(
::testing::ValuesIn(paramsMaxV85D()),
::testing::ValuesIn(inputShapes5D()),
::testing::ValuesIn(inpOutPrecision()),
::testing::ValuesIn(filterCPUInfoForDeviceWithFP16(vecCpuConfigs)),
::testing::Values(cpu_f16_plugin_config)),
MaxPoolingV8LayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_MaxPool_CPU_3D, PoolingLayerCPUTest,
::testing::Combine(
::testing::ValuesIn(paramsMax3D()),
@ -150,7 +259,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_MaxPool_CPU_3D, PoolingLayerCPUTest,
::testing::ValuesIn((inpOutPrecision())),
::testing::Values(false),
::testing::ValuesIn(filterCPUInfoForDevice(vecCpuConfigsFusing_3D)),
::testing::Values(emptyFusingSpec)),
::testing::Values(emptyFusingSpec),
::testing::Values(CPUTestUtils::empty_plugin_config)),
PoolingLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_MaxPoolV8_CPU_3D, MaxPoolingV8LayerCPUTest,
@ -158,7 +268,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_MaxPoolV8_CPU_3D, MaxPoolingV8LayerCPUTest,
::testing::ValuesIn(paramsMaxV83D()),
::testing::ValuesIn(inputShapes3D()),
::testing::ValuesIn((inpOutPrecision())),
::testing::ValuesIn(filterCPUInfoForDevice(vecCpuConfigsFusing_3D))),
::testing::ValuesIn(filterCPUInfoForDevice(vecCpuConfigsFusing_3D)),
::testing::Values(CPUTestUtils::empty_plugin_config)),
MaxPoolingV8LayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_MaxPool_CPU_5D, PoolingLayerCPUTest,
@ -168,7 +279,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_MaxPool_CPU_5D, PoolingLayerCPUTest,
::testing::ValuesIn((inpOutPrecision())),
::testing::Values(false),
::testing::ValuesIn(filterCPUInfoForDevice(vecCpuConfigsFusing_5D)),
::testing::Values(emptyFusingSpec)),
::testing::Values(emptyFusingSpec),
::testing::Values(CPUTestUtils::empty_plugin_config)),
PoolingLayerCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_MaxPoolV8_CPU_5D, MaxPoolingV8LayerCPUTest,
@ -176,7 +288,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_MaxPoolV8_CPU_5D, MaxPoolingV8LayerCPUTest,
::testing::ValuesIn(paramsMaxV85D()),
::testing::ValuesIn(inputShapes5D()),
::testing::ValuesIn((inpOutPrecision())),
::testing::ValuesIn(filterCPUInfoForDevice(vecCpuConfigsFusing_5D))),
::testing::ValuesIn(filterCPUInfoForDevice(vecCpuConfigsFusing_5D)),
::testing::Values(CPUTestUtils::empty_plugin_config)),
MaxPoolingV8LayerCPUTest::getTestCaseName);
} // namespace
} // namespace Pooling

168
src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/instances/x64/softmax.cpp Normal file
View File

@ -0,0 +1,168 @@
// Copyright (C) 2023 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "custom/single_layer_tests/classes/softmax.hpp"
#include <vector>
#include "utils/cpu_test_utils.hpp"
#include "utils/filter_cpu_info.hpp"
#include <vector>
using namespace CPUTestUtils;
namespace ov {
namespace test {
namespace SoftMax {
const auto optimizedCPUSpec = []()-> std::vector<CPUSpecificParams>{
const auto avx512 = CPUSpecificParams{{}, {}, {"jit"}, "jit_avx512"};
const auto avx2 = CPUSpecificParams{{}, {}, {"jit"}, "jit_avx2"};
const auto sse42 = CPUSpecificParams{{}, {}, {"jit"}, "jit_sse42"};
const std::vector<CPUSpecificParams> vecCpuConfigs = {avx512, avx2, sse42};
auto supportConfigure = CPUTestUtils::filterCPUInfoForDevice(vecCpuConfigs);
// only the MAX ISA of vecCpuConfigs will be tested
if (supportConfigure.size() > 0) {
return std::vector<CPUSpecificParams>{supportConfigure[0]};
} else {
return std::vector<CPUSpecificParams>{};
}
};
const std::vector<SoftMaxConfig> optimizedConfigsFP32 = {
// Static shapes
{ov::test::InputShape{ov::PartialShape{1, 100}, {ov::Shape{1, 100}}}, 1},
{ov::test::InputShape{ov::PartialShape{10, 10}, {ov::Shape{10, 10}}}, 1},
{ov::test::InputShape{ov::PartialShape{100, 1}, {ov::Shape{100, 1}}}, 0},
{ov::test::InputShape{ov::PartialShape{100, 1}, {ov::Shape{100, 1}}}, 1},
{ov::test::InputShape{ov::PartialShape{5, 5, 1}, {ov::Shape{5, 5, 1}}}, 1},
{ov::test::InputShape{ov::PartialShape{5, 5, 5}, {ov::Shape{5, 5, 5}}}, 2},
{ov::test::InputShape{ov::PartialShape{5, 5, 5, 5}, {ov::Shape{5, 5, 5, 5}}}, 0},
{ov::test::InputShape{ov::PartialShape{5, 5, 1, 1}, {ov::Shape{5, 5, 1, 1}}}, 1},
{ov::test::InputShape{ov::PartialShape{5, 5, 5, 5}, {ov::Shape{5, 5, 5, 5}}}, 1},
{ov::test::InputShape{ov::PartialShape{5, 5, 5, 1}, {ov::Shape{5, 5, 5, 1}}}, 2},
{ov::test::InputShape{ov::PartialShape{5, 5, 5, 5}, {ov::Shape{5, 5, 5, 5}}}, 2},
{ov::test::InputShape{ov::PartialShape{5, 5, 5, 5}, {ov::Shape{5, 5, 5, 5}}}, 3},
{ov::test::InputShape{ov::PartialShape{5, 5, 5, 5, 5}, {ov::Shape{5, 5, 5, 5, 5}}}, 0},
{ov::test::InputShape{ov::PartialShape{5, 5, 1, 1, 1}, {ov::Shape{5, 5, 1, 1, 1}}}, 1},
{ov::test::InputShape{ov::PartialShape{5, 5, 5, 5, 5}, {ov::Shape{5, 5, 5, 5, 5}}}, 1},
{ov::test::InputShape{ov::PartialShape{5, 5, 5, 1, 1}, {ov::Shape{5, 5, 5, 1, 1}}}, 2},
{ov::test::InputShape{ov::PartialShape{5, 5, 5, 5, 5}, {ov::Shape{5, 5, 5, 5, 5}}}, 2},
{ov::test::InputShape{ov::PartialShape{5, 5, 5, 1, 1}, {ov::Shape{5, 5, 5, 1, 1}}}, 3},
{ov::test::InputShape{ov::PartialShape{5, 5, 5, 5, 5}, {ov::Shape{5, 5, 5, 5, 5}}}, 3},
{ov::test::InputShape{ov::PartialShape{5, 5, 5, 5, 1}, {ov::Shape{5, 5, 5, 5, 1}}}, 4},
{ov::test::InputShape{ov::PartialShape{5, 5, 5, 5, 5}, {ov::Shape{5, 5, 5, 5, 5}}}, 4},
// Dynamic shapes
{ov::test::InputShape{// dynamic shape
ov::PartialShape{-1, -1},
{// target static shapes
ov::Shape{10, 10},
ov::Shape{15, 15},
ov::Shape{10, 10},
ov::Shape{10, 5}}},
1},
{ov::test::InputShape{// dynamic shape
ov::PartialShape{-1, -1, 1, 1, 1},
{// target static shapes
ov::Shape{5, 5, 1, 1, 1},
ov::Shape{10, 7, 1, 1, 1},
ov::Shape{5, 5, 1, 1, 1}}},
1},
{ov::test::InputShape{// dynamic shape
ov::PartialShape{{1, 10}, 10},
{// target static shapes
ov::Shape{10, 10},
ov::Shape{5, 10}}},
1},
};
const auto OptimizedParams = testing::Combine(testing::Values(ElementType::f32, ElementType::bf16),
testing::ValuesIn(optimizedConfigsFP32),
testing::Values(ov::test::utils::DEVICE_CPU),
testing::ValuesIn(optimizedCPUSpec()),
testing::Values(CPUTestUtils::empty_plugin_config));
INSTANTIATE_TEST_SUITE_P(smoke_SoftMax_Optimized_CPU,
SoftMaxLayerCPUTest,
OptimizedParams,
SoftMaxLayerCPUTest::getTestCaseName);
const auto notOptimizedCPUSpec = CPUSpecificParams{{}, {}, {"ref_any"}, "ref_any"};
const std::vector<SoftMaxConfig> notOptimizedConfigsFP32{
// Static shapes
{ov::test::InputShape{ov::PartialShape{1, 100}, {ov::Shape{1, 100}}}, 0},
{ov::test::InputShape{ov::PartialShape{10, 10}, {ov::Shape{10, 10}}}, 0},
{ov::test::InputShape{ov::PartialShape{10, 10, 10}, {ov::Shape{10, 10, 10}}}, 0},
{ov::test::InputShape{ov::PartialShape{10, 10, 10}, {ov::Shape{10, 10, 10}}}, 1},
// Dynamic shapes
{ov::test::InputShape{// dynamic shape
ov::PartialShape{-1, -1},
{// target static shapes
ov::Shape{10, 1},
ov::Shape{15, 15},
ov::Shape{10, 5},
ov::Shape{15, 15}}},
0},
{ov::test::InputShape{// dynamic shape
ov::PartialShape{ov::Dimension{1, 100}, ov::Dimension{1, 100}, -1},
{// target static shapes
ov::Shape{10, 10, 10},
ov::Shape{10, 10, 1},
ov::Shape{10, 5, 10},
ov::Shape{10, 10, 1}}},
1},
{ov::test::InputShape{// dynamic shape
ov::PartialShape{{1, 10}, 10},
{// target static shapes
ov::Shape{7, 10},
ov::Shape{10, 10}}},
0},
};
const std::vector<SoftMaxConfig> unsupportedConfigsFP32{
// Static shapes
{ov::test::InputShape{ov::PartialShape{5, 5, 5, 5, 5, 5}, {ov::Shape{5, 5, 5, 5, 5, 5}}}, 0},
{ov::test::InputShape{ov::PartialShape{5, 5, 5, 5, 5, 5}, {ov::Shape{5, 5, 5, 5, 5, 5}}}, 1},
{ov::test::InputShape{ov::PartialShape{5, 5, 5, 5, 5, 5}, {ov::Shape{5, 5, 5, 5, 5, 5}}}, 2},
{ov::test::InputShape{ov::PartialShape{5, 5, 5, 5, 5, 5}, {ov::Shape{5, 5, 5, 5, 5, 5}}}, 3},
{ov::test::InputShape{ov::PartialShape{5, 5, 5, 5, 5, 5}, {ov::Shape{5, 5, 5, 5, 5, 5}}}, 4},
{ov::test::InputShape{ov::PartialShape{5, 5, 5, 5, 5, 5}, {ov::Shape{5, 5, 5, 5, 5, 5}}}, 5},
// Dynamic shapes
{ov::test::InputShape{// dynamic shape
ov::PartialShape{-1, -1, -1, -1, -1, -1},
{// target static shapes
ov::Shape{5, 5, 5, 5, 5, 5},
ov::Shape{7, 7, 7, 7, 7, 7},
ov::Shape{5, 5, 5, 5, 5, 5}}},
4},
{ov::test::InputShape{// dynamic shape
ov::PartialShape{{1, 10}, 5, 5, 5, 5, 5},
{// target static shapes
ov::Shape{5, 5, 5, 5, 5, 5},
ov::Shape{7, 5, 5, 5, 5, 5}}},
4},
};
const auto NotOptimizedParams = testing::Combine(testing::Values(ElementType::f32),
testing::ValuesIn(notOptimizedConfigsFP32),
testing::Values(ov::test::utils::DEVICE_CPU),
testing::Values(notOptimizedCPUSpec),
testing::Values(cpu_f16_plugin_config));
INSTANTIATE_TEST_SUITE_P(smoke_SoftMax_CPU_FP16,
SoftMaxLayerCPUTest,
NotOptimizedParams,
SoftMaxLayerCPUTest::getTestCaseName);
const auto UnsupportedParams = testing::Combine(testing::Values(ElementType::f32),
testing::ValuesIn(unsupportedConfigsFP32),
testing::Values(ov::test::utils::DEVICE_CPU),
testing::Values(notOptimizedCPUSpec),
testing::Values(cpu_f16_plugin_config));
INSTANTIATE_TEST_SUITE_P(smoke_SoftMax_Unsupported_CPU_FP16,
SoftMaxLayerCPUTest,
UnsupportedParams,
SoftMaxLayerCPUTest::getTestCaseName);
} // namespace SoftMax
} // namespace test
} // namespace ov

124
src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/pad.cpp
View File

@ -2,6 +2,7 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/runtime/system_conf.hpp"
#include "common_test_utils/ov_tensor_utils.hpp"
#include "common_test_utils/test_enums.hpp"
@ -23,7 +24,8 @@ using PadLayerCPUTestParamSet = std::tuple<
std::vector<int64_t>, // padsEnd
float, // argPadValue
ov::op::PadMode, // padMode
CPUSpecificParams
CPUSpecificParams,
ov::AnyMap // cpu device config
>;
class PadLayerCPUTest : public testing::WithParamInterface<PadLayerCPUTestParamSet>,
@ -37,7 +39,8 @@ public:
ov::op::PadMode padMode;
float argPadValue;
CPUSpecificParams cpuParams;
std::tie(shapes, secondaryInputType, elementType, padsBegin, padsEnd, argPadValue, padMode, cpuParams) = obj.param;
ov::AnyMap additionalConfig;
std::tie(shapes, secondaryInputType, elementType, padsBegin, padsEnd, argPadValue, padMode, cpuParams, additionalConfig) = obj.param;
std::ostringstream results;
results << "IS=" << ov::test::utils::partialShape2str({shapes.first}) << "_";
@ -54,6 +57,12 @@ public:
}
results << "PadMode=" << padMode << "_";
results << CPUTestsBase::getTestCaseName(cpuParams);
if (!additionalConfig.empty()) {
results << "_PluginConf";
for (auto& item : additionalConfig) {
results << "_" << item.first << "=" << item.second.as<std::string>();
}
}
return results.str();
}
@ -87,10 +96,12 @@ protected:
ov::op::PadMode padMode;
ElementType dataType;
CPUSpecificParams cpuParams;
std::tie(shapes, secondaryInputType, dataType, padsBegin, padsEnd, padValue, padMode, cpuParams) = this->GetParam();
ov::AnyMap additionalConfig;
std::tie(shapes, secondaryInputType, dataType, padsBegin, padsEnd, padValue, padMode, cpuParams, additionalConfig) = this->GetParam();
configuration.insert(additionalConfig.begin(), additionalConfig.end());
std::tie(inFmts, outFmts, priority, selectedType) = cpuParams;
selectedType = makeSelectedTypeStr("ref", dataType);
selectedType = makeSelectedTypeStr("ref", get_default_imp_precision_type(dataType, configuration));
targetDevice = ov::test::utils::DEVICE_CPU;
init_input_shapes({shapes});
for (auto& targetShapes : targetStaticShapes) {
@ -159,6 +170,11 @@ const std::vector<ElementType> inputPrecisions = {
ElementType::i8
};
const std::vector<ov::AnyMap> deviceConfig = {
CPUTestUtils::empty_plugin_config,
cpu_f16_plugin_config
};
const std::vector<ov::test::utils::InputLayerType> inputLayerTypes = {
ov::test::utils::InputLayerType::CONSTANT,
ov::test::utils::InputLayerType::PARAMETER
@ -198,7 +214,7 @@ const std::vector<std::vector<int64_t>> padsEnd4D_Full = {{0, 0, -2, 0}, {0, 0
const std::vector<CPUSpecificParams> CPUParams4DBlocked = {
cpuParams_nChw16c,
cpuParams_nChw8c,
cpuParams_nChw8c
};
INSTANTIATE_TEST_SUITE_P(
@ -212,7 +228,8 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(padsEnd4DConstBlocked_Smoke),
::testing::ValuesIn(argPadValue),
::testing::Values(ov::op::PadMode::CONSTANT),
::testing::ValuesIn(CPUParams4DBlocked)),
::testing::ValuesIn(CPUParams4DBlocked),
::testing::ValuesIn(deviceConfig)),
PadLayerCPUTest::getTestCaseName
);
@ -227,7 +244,8 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(padsEnd4D_Smoke),
::testing::ValuesIn(argPadValue),
::testing::Values(ov::op::PadMode::CONSTANT),
::testing::Values(cpuParams_nhwc)),
::testing::Values(cpuParams_nhwc),
::testing::ValuesIn(deviceConfig)),
PadLayerCPUTest::getTestCaseName
);
@ -242,7 +260,8 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(padsEnd4DBlocked_Smoke),
::testing::Values(0),
::testing::ValuesIn(padMode),
::testing::ValuesIn(CPUParams4DBlocked)),
::testing::ValuesIn(CPUParams4DBlocked),
::testing::ValuesIn(deviceConfig)),
PadLayerCPUTest::getTestCaseName
);
@ -257,7 +276,8 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(padsEnd4DBlocked_Smoke),
::testing::Values(0),
::testing::ValuesIn(padMode),
::testing::Values(cpuParams_nhwc)),
::testing::Values(cpuParams_nhwc),
::testing::ValuesIn(deviceConfig)),
PadLayerCPUTest::getTestCaseName
);
@ -272,7 +292,8 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(padsEnd4DConstBlocked_Full),
::testing::ValuesIn(argPadValue),
::testing::Values(ov::op::PadMode::CONSTANT),
::testing::ValuesIn(CPUParams4DBlocked)),
::testing::ValuesIn(CPUParams4DBlocked),
::testing::ValuesIn(deviceConfig)),
PadLayerCPUTest::getTestCaseName
);
@ -287,7 +308,8 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(padsEnd4D_Full),
::testing::ValuesIn(argPadValue),
::testing::Values(ov::op::PadMode::CONSTANT),
::testing::Values(cpuParams_nhwc)),
::testing::Values(cpuParams_nhwc),
::testing::ValuesIn(deviceConfig)),
PadLayerCPUTest::getTestCaseName
);
@ -302,7 +324,8 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(padsEnd4DBlocked_Full),
::testing::Values(0),
::testing::ValuesIn(padMode),
::testing::ValuesIn(CPUParams4DBlocked)),
::testing::ValuesIn(CPUParams4DBlocked),
::testing::ValuesIn(deviceConfig)),
PadLayerCPUTest::getTestCaseName
);
@ -317,7 +340,8 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(padsEnd4DBlocked_Full),
::testing::Values(0),
::testing::ValuesIn(padMode),
::testing::Values(cpuParams_nhwc)),
::testing::Values(cpuParams_nhwc),
::testing::ValuesIn(deviceConfig)),
PadLayerCPUTest::getTestCaseName
);
@ -352,7 +376,8 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(padsEnd4D_Smoke),
::testing::ValuesIn(argPadValue),
::testing::Values(ov::op::PadMode::CONSTANT),
::testing::ValuesIn(CPUParams4DDynamic)),
::testing::ValuesIn(CPUParams4DDynamic),
::testing::ValuesIn(deviceConfig)),
PadLayerCPUTest::getTestCaseName
);
@ -367,7 +392,8 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(padsEnd4DConstBlocked_Smoke),
::testing::ValuesIn(argPadValue),
::testing::Values(ov::op::PadMode::CONSTANT),
::testing::ValuesIn(CPUParams4DBlocked)),
::testing::ValuesIn(CPUParams4DBlocked),
::testing::ValuesIn(deviceConfig)),
PadLayerCPUTest::getTestCaseName
);
@ -382,7 +408,8 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(padsEnd4D_Smoke),
::testing::Values(0),
::testing::ValuesIn(padMode),
::testing::ValuesIn(CPUParams4DDynamic)),
::testing::ValuesIn(CPUParams4DDynamic),
::testing::ValuesIn(deviceConfig)),
PadLayerCPUTest::getTestCaseName
);
@ -397,7 +424,8 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(padsEnd4DBlocked_Smoke),
::testing::Values(0),
::testing::ValuesIn(padMode),
::testing::ValuesIn(CPUParams4DBlocked)),
::testing::ValuesIn(CPUParams4DBlocked),
::testing::ValuesIn(deviceConfig)),
PadLayerCPUTest::getTestCaseName
);
@ -412,7 +440,8 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(padsEnd4D_Full),
::testing::ValuesIn(argPadValue),
::testing::Values(ov::op::PadMode::CONSTANT),
::testing::ValuesIn(CPUParams4DDynamic)),
::testing::ValuesIn(CPUParams4DDynamic),
::testing::ValuesIn(deviceConfig)),
PadLayerCPUTest::getTestCaseName
);
@ -427,7 +456,8 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(padsEnd4DConstBlocked_Full),
::testing::ValuesIn(argPadValue),
::testing::Values(ov::op::PadMode::CONSTANT),
::testing::ValuesIn(CPUParams4DBlocked)),
::testing::ValuesIn(CPUParams4DBlocked),
::testing::ValuesIn(deviceConfig)),
PadLayerCPUTest::getTestCaseName
);
@ -442,7 +472,8 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(padsEnd4D_Full),
::testing::Values(0),
::testing::ValuesIn(padMode),
::testing::ValuesIn(CPUParams4DDynamic)),
::testing::ValuesIn(CPUParams4DDynamic),
::testing::ValuesIn(deviceConfig)),
PadLayerCPUTest::getTestCaseName
);
@ -457,7 +488,8 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(padsEnd4DBlocked_Full),
::testing::Values(0),
::testing::ValuesIn(padMode),
::testing::ValuesIn(CPUParams4DBlocked)),
::testing::ValuesIn(CPUParams4DBlocked),
::testing::ValuesIn(deviceConfig)),
PadLayerCPUTest::getTestCaseName
);
@ -499,7 +531,8 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(padsEnd5DConstBlocked_Smoke),
::testing::ValuesIn(argPadValue),
::testing::Values(ov::op::PadMode::CONSTANT),
::testing::ValuesIn(CPUParams5DBlocked)),
::testing::ValuesIn(CPUParams5DBlocked),
::testing::ValuesIn(deviceConfig)),
PadLayerCPUTest::getTestCaseName
);
@ -514,7 +547,8 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(padsEnd5D_Smoke),
::testing::ValuesIn(argPadValue),
::testing::Values(ov::op::PadMode::CONSTANT),
::testing::Values(cpuParams_ndhwc)),
::testing::Values(cpuParams_ndhwc),
::testing::ValuesIn(deviceConfig)),
PadLayerCPUTest::getTestCaseName
);
@ -529,7 +563,8 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(padsEnd5DBlocked_Smoke),
::testing::Values(0),
::testing::ValuesIn(padMode),
::testing::ValuesIn(CPUParams5DBlocked)),
::testing::ValuesIn(CPUParams5DBlocked),
::testing::ValuesIn(deviceConfig)),
PadLayerCPUTest::getTestCaseName
);
@ -544,7 +579,8 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(padsEnd5D_Smoke),
::testing::Values(0),
::testing::ValuesIn(padMode),
::testing::Values(cpuParams_ndhwc)),
::testing::Values(cpuParams_ndhwc),
::testing::ValuesIn(deviceConfig)),
PadLayerCPUTest::getTestCaseName
);
@ -559,7 +595,8 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(padsEnd5DConstBlocked_Full),
::testing::ValuesIn(argPadValue),
::testing::Values(ov::op::PadMode::CONSTANT),
::testing::ValuesIn(CPUParams5DBlocked)),
::testing::ValuesIn(CPUParams5DBlocked),
::testing::ValuesIn(deviceConfig)),
PadLayerCPUTest::getTestCaseName
);
@ -574,7 +611,8 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(padsEnd5D_Full),
::testing::ValuesIn(argPadValue),
::testing::Values(ov::op::PadMode::CONSTANT),
::testing::Values(cpuParams_ndhwc)),
::testing::Values(cpuParams_ndhwc),
::testing::ValuesIn(deviceConfig)),
PadLayerCPUTest::getTestCaseName
);
@ -589,7 +627,8 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(padsEnd5DBlocked_Full),
::testing::Values(0),
::testing::ValuesIn(padMode),
::testing::ValuesIn(CPUParams5DBlocked)),
::testing::ValuesIn(CPUParams5DBlocked),
::testing::ValuesIn(deviceConfig)),
PadLayerCPUTest::getTestCaseName
);
@ -604,7 +643,8 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(padsEnd5D_Full),
::testing::Values(0),
::testing::ValuesIn(padMode),
::testing::Values(cpuParams_ndhwc)),
::testing::Values(cpuParams_ndhwc),
::testing::ValuesIn(deviceConfig)),
PadLayerCPUTest::getTestCaseName
);
@ -639,7 +679,8 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(padsEnd5D_Smoke),
::testing::ValuesIn(argPadValue),
::testing::Values(ov::op::PadMode::CONSTANT),
::testing::ValuesIn(CPUParams5DDynamic)),
::testing::ValuesIn(CPUParams5DDynamic),
::testing::ValuesIn(deviceConfig)),
PadLayerCPUTest::getTestCaseName
);
@ -654,7 +695,8 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(padsEnd5DConstBlocked_Smoke),
::testing::ValuesIn(argPadValue),
::testing::Values(ov::op::PadMode::CONSTANT),
::testing::ValuesIn(CPUParams5DBlocked)),
::testing::ValuesIn(CPUParams5DBlocked),
::testing::ValuesIn(deviceConfig)),
PadLayerCPUTest::getTestCaseName
);
@ -669,7 +711,8 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(padsEnd5D_Smoke),
::testing::Values(0),
::testing::ValuesIn(padMode),
::testing::ValuesIn(CPUParams5DDynamic)),
::testing::ValuesIn(CPUParams5DDynamic),
::testing::ValuesIn(deviceConfig)),
PadLayerCPUTest::getTestCaseName
);
@ -684,7 +727,8 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(padsEnd5DBlocked_Smoke),
::testing::Values(0),
::testing::ValuesIn(padMode),
::testing::ValuesIn(CPUParams5DBlocked)),
::testing::ValuesIn(CPUParams5DBlocked),
::testing::ValuesIn(deviceConfig)),
PadLayerCPUTest::getTestCaseName
);
@ -699,7 +743,8 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(padsEnd5D_Full),
::testing::ValuesIn(argPadValue),
::testing::Values(ov::op::PadMode::CONSTANT),
::testing::ValuesIn(CPUParams5DDynamic)),
::testing::ValuesIn(CPUParams5DDynamic),
::testing::ValuesIn(deviceConfig)),
PadLayerCPUTest::getTestCaseName
);
@ -714,7 +759,8 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(padsEnd5DConstBlocked_Full),
::testing::ValuesIn(argPadValue),
::testing::Values(ov::op::PadMode::CONSTANT),
::testing::ValuesIn(CPUParams5DBlocked)),
::testing::ValuesIn(CPUParams5DBlocked),
::testing::ValuesIn(deviceConfig)),
PadLayerCPUTest::getTestCaseName
);
@ -729,7 +775,8 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(padsEnd5D_Full),
::testing::Values(0),
::testing::ValuesIn(padMode),
::testing::ValuesIn(CPUParams5DDynamic)),
::testing::ValuesIn(CPUParams5DDynamic),
::testing::ValuesIn(deviceConfig)),
PadLayerCPUTest::getTestCaseName
);
@ -744,7 +791,8 @@ INSTANTIATE_TEST_SUITE_P(
::testing::ValuesIn(padsEnd5DBlocked_Full),
::testing::Values(0),
::testing::ValuesIn(padMode),
::testing::ValuesIn(CPUParams5DBlocked)),
::testing::ValuesIn(CPUParams5DBlocked),
::testing::ValuesIn(deviceConfig)),
PadLayerCPUTest::getTestCaseName
);

20
src/plugins/intel_cpu/tests/functional/custom/subgraph_tests/src/concat_const_inplace.cpp
View File

@ -2,6 +2,7 @@
// SPDX-License-Identifier: Apache-2.0
//
#include "openvino/runtime/system_conf.hpp"
#include "shared_test_classes/base/ov_subgraph.hpp"
#include "utils/cpu_test_utils.hpp"
#include "common_test_utils/ov_tensor_utils.hpp"
@ -37,8 +38,13 @@ public:
void SetUp() override {
targetDevice = ov::test::utils::DEVICE_CPU;
if (ov::element::bf16 == (inType = outType = this->GetParam()))
configuration.insert({ov::hint::inference_precision.name(), ov::element::bf16});
if (ov::element::bf16 == (inType = outType = this->GetParam())) {
configuration.insert({ov::hint::inference_precision(ov::element::bf16)});
} else if (ov::element::f16 == (inType = outType = this->GetParam())) {
configuration.insert({ov::hint::inference_precision(ov::element::f16)});
} else {
configuration.insert({ov::hint::inference_precision(ov::element::f32)});
}
const ov::Shape inputShape = {1, 3, 3, 11};
ov::ParameterVector inputParams{std::make_shared<ov::op::v0::Parameter>(ov::element::f32, inputShape)};
@ -73,17 +79,19 @@ public:
namespace {
TEST_P(ConcatConstantInPlaceTest, smoke_ConcatConstantInPlaceTest_CPU) {
run();
if (this->GetParam() == ov::element::bf16)
if (this->GetParam() == ov::element::bf16 ||
(this->GetParam() == ov::element::f16 && ov::with_cpu_x86_avx512_core_fp16())) {
CheckNumberOfNodesWithType(compiledModel, "Reorder", 3);
else
} else {
CheckNumberOfNodesWithType(compiledModel, "Reorder", 2);
}
}
INSTANTIATE_TEST_SUITE_P(smoke_ConcatConstantInPlaceTest_CPU,
ConcatConstantInPlaceTest,
testing::Values(ov::element::f32, ov::element::bf16),
testing::Values(ov::element::f32, ov::element::bf16, ov::element::f16),
ConcatConstantInPlaceTest::getTestCaseName);
} // namespace
} // namespace test
} // namespace ov

35
src/plugins/intel_cpu/tests/functional/custom/subgraph_tests/src/conv_sum_broadcast.cpp
View File

@ -118,8 +118,12 @@ public:
runtimeType = getNetType();
auto it = configuration.find(ov::hint::inference_precision.name());
if (it != configuration.end() && it->second.as<ov::element::Type>() == ov::element::bf16) {
ov::element::Type inference_precision = (it != configuration.end()) ?
it->second.as<ov::element::Type>() : ov::element::undefined;
if (inference_precision == ov::element::bf16) {
runtimeType = ov::element::Type_t::bf16;
} else if (inference_precision == ov::element::f16) {
runtimeType = ov::element::Type_t::f16;
}
if (inputParams.front()->get_element_type() == ov::element::i8 || inputParams.front()->get_element_type() == ov::element::u8) {
@ -138,12 +142,25 @@ public:
protected:
bool primTypeCheck(std::string primType) const override {
auto isaType = getISA(runtimeType == ov::element::Type_t::f32);
bool skip_amx = false;
switch (runtimeType) {
case ov::element::Type_t::f32:
skip_amx = true;
break;
case ov::element::Type_t::f16:
skip_amx = ov::with_cpu_x86_avx512_core_amx_fp16() ? false : true;
break;
case ov::element::Type_t::bf16:
skip_amx = false;
break;
default:
skip_amx = false;
}
auto isaType = getISA(skip_amx);
const std::regex jit_case_regex(makeSelectedTypeStr(std::string("jit_") + isaType, runtimeType),
std::regex_constants::icase);
const std::regex brgconv_case_regex(makeSelectedTypeStr(std::string("brgconv_") + isaType, runtimeType),
std::regex_constants::icase);
if (isaType == "")
return primType == "ref";
else
@ -415,6 +432,8 @@ const std::vector<fusingSpecificParams> fusingParamsSetBF16{
fusingReluScaleShift
};
const std::vector<fusingSpecificParams> fusingParamsSetFP16 = fusingParamsSetBF16;
InputShape convInpShape = {
//dynamic shapes
{-1, 32, -1, -1},
@ -465,6 +484,16 @@ INSTANTIATE_TEST_SUITE_P(smoke_Conv_Sum_Broadcast_BF16,
::testing::Values(cpu_bf16_plugin_config)),
ConvSumInPlaceTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_Conv_Sum_Broadcast_FP16,
ConvSumInPlaceTest,
::testing::Combine(
::testing::Values(convInpShape),
::testing::ValuesIn(secondInp),
::testing::Values(true, false),
::testing::ValuesIn(fusingParamsSetFP16),
::testing::Values(cpu_f16_plugin_config)),
ConvSumInPlaceTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_Conv_Sum_Broadcast_INT8, ConvSumInPlaceTestInt8,
::testing::Combine(
::testing::Values(convInpShape),

16
src/plugins/intel_cpu/tests/functional/custom/subgraph_tests/src/fullyconnected_strided_inputs_outputs.cpp
View File

@ -102,6 +102,16 @@ TEST_P(FullyConnectedStridedInputsOutputsTest, CompareWithRefs) {
run();
}
using FullyConnectedStridedInputsOutputsTest_FP16 = FullyConnectedStridedInputsOutputsTest;
TEST_P(FullyConnectedStridedInputsOutputsTest_FP16, CompareWithRefs) {
if (!(ov::with_cpu_x86_avx512_core_fp16())) {
GTEST_SKIP() << "Skipping test, platform don't support precision f16";
}
configuration.insert({ov::hint::inference_precision.name(), ov::element::f16});
run();
}
namespace {
INSTANTIATE_TEST_SUITE_P(smoke_Check,
@ -110,6 +120,12 @@ INSTANTIATE_TEST_SUITE_P(smoke_Check,
::testing::Values(2, 3)),
FullyConnectedStridedInputsOutputsTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_Check,
FullyConnectedStridedInputsOutputsTest_FP16,
::testing::Combine(::testing::Values(ov::element::f32),
::testing::Values(2, 3)),
FullyConnectedStridedInputsOutputsTest::getTestCaseName);
} // namespace
} // namespace test

2
src/plugins/intel_cpu/tests/functional/custom/subgraph_tests/src/inplace_edge.cpp
View File

@ -37,7 +37,7 @@ public:
void SetUp() override {
targetDevice = utils::DEVICE_CPU;
configuration.insert({ov::hint::inference_precision.name(), ov::element::f16.to_string()});
configuration.insert({ov::hint::inference_precision.name(), ov::element::f16});
const ov::Shape inputShape = {1, 11, 3, 3};
targetStaticShapes = {{inputShape, inputShape}};
ElementType prc = this->GetParam();

31
src/plugins/intel_cpu/tests/functional/custom/subgraph_tests/src/input_noreorder_eltwise_bf16.cpp
View File

@ -14,12 +14,15 @@ namespace test {
class InputNoReorderEltwiseBF16 : virtual public SubgraphBaseStaticTest, public CPUTestsBase {
protected:
void SetUp() override {
auto netPrecision = inType = ov::element::f32;
virtual void set_output_type_and_config() {
outType = ov::element::bf16;
targetDevice = ov::test::utils::DEVICE_CPU;
ov::AnyMap additional_config{ov::hint::inference_precision(ov::element::bf16)};
configuration.insert(additional_config.begin(), additional_config.end());
}
void SetUp() override {
auto netPrecision = inType = ov::element::f32;
set_output_type_and_config();
targetDevice = ov::test::utils::DEVICE_CPU;
ov::Shape inputShape{2, 4, 4, 1};
auto eltwiseType = ov::test::utils::EltwiseTypes::ADD;
@ -56,5 +59,27 @@ TEST_F(InputNoReorderEltwiseBF16, smoke_CompareWithRefs) {
CheckNumberOfNodesWithType(compiledModel, "Convert", 0);
CheckNumberOfNodesWithTypes(compiledModel, {"Eltwise", "Subgraph"}, 1);
}
class InputNoReorderEltwiseFP16 : public InputNoReorderEltwiseBF16 {
protected:
void set_output_type_and_config() override {
outType = ov::element::f16;
ov::AnyMap additional_config{ov::hint::inference_precision(ov::element::f16)};
configuration.insert(additional_config.begin(), additional_config.end());
}
};
TEST_F(InputNoReorderEltwiseFP16, smoke_CompareWithRefs) {
if (!(ov::with_cpu_x86_avx512_core_fp16() || ov::with_cpu_x86_avx512_core_amx_fp16())) {
GTEST_SKIP() << "Skipping test, platform don't support precision f16";
}
run();
CheckNumberOfNodesWithType(compiledModel, "Reorder", 0);
CheckNumberOfNodesWithType(compiledModel, "Convert", 0);
CheckNumberOfNodesWithTypes(compiledModel, {"Eltwise", "Subgraph"}, 1);
}
} // namespace test
} // namespace ov

16
src/plugins/intel_cpu/tests/functional/custom/subgraph_tests/src/interaction.cpp
View File

@ -171,8 +171,20 @@ TEST_P(IntertactionCPUTest, CompareWithRefs) {
CheckNumberOfNodesWithType(compiledModel, "Interaction", 1);
}
using IntertactionCPUTest_FP16 = IntertactionCPUTest;
TEST_P(IntertactionCPUTest_FP16, CompareWithRefs) {
if (!(ov::with_cpu_x86_avx512_core_fp16())) {
GTEST_SKIP() << "Skipping test, platform don't support precision f16";
}
configuration.insert({ov::hint::inference_precision.name(), ov::element::f16});
run();
CheckNumberOfNodesWithType(compiledModel, "Interaction", 1);
}
namespace {
const std::vector<ElementType> inPrecisions = {ElementType::f32, ElementType::bf16, ElementType::i32, ElementType::i8};
const std::vector<ElementType> inPrecisions_FP16 = {ElementType::f32, ElementType::i32};
// the model has 27 inputs with same shape
const std::vector<InputShape> input_shapes = {
// temporarily disable dynamic shape for performance issue
@ -194,4 +206,8 @@ INSTANTIATE_TEST_SUITE_P(smoke_Interaction,
IntertactionCPUTest,
::testing::Combine(::testing::ValuesIn(inPrecisions), ::testing::ValuesIn(input_shapes)),
IntertactionCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_Interaction,
IntertactionCPUTest_FP16,
::testing::Combine(::testing::ValuesIn(inPrecisions_FP16), ::testing::ValuesIn(input_shapes)),
IntertactionCPUTest::getTestCaseName);
} // namespace

15
src/plugins/intel_cpu/tests/functional/custom/subgraph_tests/src/matmul_strided_inputs_outputs.cpp
View File

@ -89,6 +89,16 @@ TEST_P(MatmulStridedInputsOutputsTest, CompareWithRefs) {
run();
}
using MatmulStridedInputsOutputsTest_FP16 = MatmulStridedInputsOutputsTest;
TEST_P(MatmulStridedInputsOutputsTest_FP16, CompareWithRefs) {
if (!(ov::with_cpu_x86_avx512_core_fp16())) {
GTEST_SKIP() << "Skipping test, platform don't support precision f16";
}
configuration.insert({ov::hint::inference_precision.name(), ov::element::f16});
run();
}
namespace {
INSTANTIATE_TEST_SUITE_P(smoke_Check,
@ -96,6 +106,11 @@ INSTANTIATE_TEST_SUITE_P(smoke_Check,
::testing::Values(ov::element::f32, ov::element::bf16),
MatmulStridedInputsOutputsTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_Check,
MatmulStridedInputsOutputsTest_FP16,
::testing::Values(ov::element::f32),
MatmulStridedInputsOutputsTest::getTestCaseName);
} // namespace
} // namespace test

51
src/plugins/intel_cpu/tests/functional/custom/subgraph_tests/src/remove_convert.cpp
View File

@ -12,7 +12,7 @@ using namespace CPUTestUtils;
namespace ov {
namespace test {
using RemoveConvertCPUTestParams = std::tuple<ElementType, InputShape>;
using RemoveConvertCPUTestParams = std::tuple<ElementType, InputShape, ov::AnyMap>;
class RemoveUselessBF16ConvertCPUTest : public testing::WithParamInterface<RemoveConvertCPUTestParams>,
virtual public SubgraphBaseTest,
@ -21,21 +21,27 @@ public:
static std::string getTestCaseName(const testing::TestParamInfo<RemoveConvertCPUTestParams>& obj) {
ElementType inType;
InputShape inputShape;
std::tie(inType, inputShape) = obj.param;
ov::AnyMap additionalConfig;
std::tie(inType, inputShape, additionalConfig) = obj.param;
std::ostringstream result;
result << "IS=" << inputShape << "_";
result << "Prc=" << inType;
if (!additionalConfig.empty()) {
result << "_PluginConf";
for (auto& item : additionalConfig) {
result << "_" << item.first << "=" << item.second.as<std::string>();
}
}
return result.str();
}
void SetUp() override {
ElementType inType;
InputShape inputShape;
std::tie(inType, inputShape) = this->GetParam();
ov::AnyMap additionalConfig;
std::tie(inType, inputShape, additionalConfig) = this->GetParam();
configuration.insert(additionalConfig.begin(), additionalConfig.end());
targetDevice = ov::test::utils::DEVICE_CPU;
if (inType == ElementType::bf16) {
configuration.insert({ov::hint::inference_precision(ov::element::bf16)});
}
std::tie(inFmts, outFmts, priority, selectedType) =
CPUSpecificParams{{}, {}, {}, makeSelectedTypeStr("ref", inType)};
init_input_shapes({inputShape});
@ -65,17 +71,25 @@ public:
static std::string getTestCaseName(const testing::TestParamInfo<RemoveConvertCPUTestParams>& obj) {
ElementType inType;
InputShape inputShape;
std::tie(inType, inputShape) = obj.param;
ov::AnyMap additionalConfig;
std::tie(inType, inputShape, additionalConfig) = obj.param;
std::ostringstream result;
result << "IS=" << inputShape << "_";
result << "Prc=" << inType;
if (!additionalConfig.empty()) {
result << "_PluginConf";
for (auto& item : additionalConfig) {
result << "_" << item.first << "=" << item.second.as<std::string>();
}
}
return result.str();
}
void SetUp() override {
ElementType inType;
InputShape inputShape;
std::tie(inType, inputShape) = this->GetParam();
ov::AnyMap additionalConfig;
std::tie(inType, inputShape, additionalConfig) = this->GetParam();
targetDevice = ov::test::utils::DEVICE_CPU;
init_input_shapes({inputShape});
@ -110,6 +124,15 @@ TEST_P(RemoveUselessConvertCPUTest, CompareWithRefs) {
CheckNumberOfNodesWithType(compiledModel, "Convert", 0);
}
using RemoveUselessFP16ConvertCPUTest = RemoveUselessBF16ConvertCPUTest;
TEST_P(RemoveUselessFP16ConvertCPUTest, CompareWithRefs) {
auto implType = get_default_imp_precision_type(ov::element::f16, configuration);
selectedType = makeSelectedTypeStr("ref", implType);
run();
CheckNumberOfNodesWithTypes(compiledModel, {"Convert", "Subgraph"}, 0);
CheckPluginRelatedResults(compiledModel, "StridedSlice");
}
namespace {
const std::vector<InputShape> inputShapes = {
// dynamic batch
@ -121,12 +144,20 @@ const std::vector<InputShape> inputShapes = {
INSTANTIATE_TEST_SUITE_P(smoke_RemoveConvert,
RemoveUselessBF16ConvertCPUTest,
::testing::Combine(::testing::Values(ElementType::bf16), ::testing::ValuesIn(inputShapes)),
::testing::Combine(::testing::Values(ElementType::bf16), ::testing::ValuesIn(inputShapes),
::testing::Values(cpu_bf16_plugin_config)),
RemoveUselessBF16ConvertCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_RemoveConvert,
RemoveUselessFP16ConvertCPUTest,
::testing::Combine(::testing::Values(ElementType::f16), ::testing::ValuesIn(inputShapes),
::testing::Values(cpu_f16_plugin_config)),
RemoveUselessFP16ConvertCPUTest::getTestCaseName);
INSTANTIATE_TEST_SUITE_P(smoke_RemoveConvert,
RemoveUselessConvertCPUTest,
::testing::Combine(::testing::Values(ElementType::f32), ::testing::Values(inputShapes[0])),
::testing::Combine(::testing::Values(ElementType::f32), ::testing::Values(inputShapes[0]),
::testing::Values(empty_plugin_config)),
RemoveUselessConvertCPUTest::getTestCaseName);
} // namespace
} // namespace test

18
src/plugins/intel_cpu/tests/functional/shared_tests_instances/skip_tests_config.cpp
View File

@ -539,6 +539,24 @@ std::vector<std::string> disabledTestPatterns() {
// Issue: 142465
retVector.emplace_back(R"(smoke_Reduce_MultiAxis_4D_fusing_CPU/ReduceCPULayerTest.CompareWithRefs.*INFERENCE_PRECISION_HINT=f16.*)");
retVector.emplace_back(R"(smoke_Reduce_MultiAxis_5D_fusing_CPU/ReduceCPULayerTest.CompareWithRefs.*INFERENCE_PRECISION_HINT=f16.*)");
//
retVector.emplace_back(R"((smoke|nightly)_FC_3D_FP16/.*_Fused=Multiply\(PerChannel\).*)");
retVector.emplace_back(R"(smoke_MM_Static_FP16.*TS=\(\(55\.12\)\).*_Fused=Multiply\(PerChannel\).*)");
retVector.emplace_back(R"((smoke|nightly)_MM_Brgemm_Static_FP16.*TS=\(\(55\.12\)\).*_Fused=Multiply\(PerChannel\).*)");
retVector.emplace_back(R"(smoke_MM_Dynamic_Fusing_FP16/.*TS=\(\(16\.12\)_\(33\.7\)_\(16\.12\)\).*_Fused=Multiply\(PerChannel\).*)");
retVector.emplace_back(R"(smoke_MM_Brgemm_Dynamic_Fusing_FP16/.*TS=\(\(16\.12\)_\(33\.7\)_\(16\.12\)\).*_Fused=Multiply\(PerChannel\).*)");
retVector.emplace_back(R"(smoke_Conv_.*_FP16/.*_Fused=PRelu1D\.Multiply\(PerChannel\)\.Add\(PerChannel\).*)");
retVector.emplace_back(R"(smoke_Conv_Sum_Broadcast_FP16/ConvSumInPlaceTest.*Relu\.Multiply\(PerChannel\)\.Add\(PerChannel\).*)");
retVector.emplace_back(R"(smoke_AvgPool_CPU_4D_FP16/PoolingLayerCPUTest.CompareWithRefs/IS=\(\[\?.*\).*_Prc=f32_AvgPool_ExcludePad=1_K\(4\.4\)_S\(4\.4\)_PB\(2\.2\)_PE\(2\.2\)_Rounding=ceil.*)");
retVector.emplace_back(R"(smoke_FC_(2|3)D_runtime_FP16/MatMulDecompressConvertTest.*transpose_b=1_weiLemType=f32.*)");
retVector.emplace_back(R"((smoke|nightly)_FC_(2|3)D.*_FP16/MatMulLayerCPUTest.*transpose_b=1.*)");
}
if (ov::with_cpu_x86_avx512_core_amx_fp16()) {
// Issue 131632
retVector.emplace_back(R"(smoke_MM_Brgemm_Amx_Static_FP16/.*brgemm_avx512_amx.*)");
retVector.emplace_back(R"(nightly_MM_Brgemm_Amx_Static_FP16/.*brgemm_avx512_amx.*)");
retVector.emplace_back(R"(smoke_MM_Brgemm_Amx_Dynamic_FP16/.*brgemm_avx512_amx.*)");
}
return retVector;

4
src/plugins/intel_cpu/tests/functional/utils/arm/filter_cpu_info.cpp
View File

@ -38,4 +38,8 @@ std::vector<CPUSpecificParams> filterCPUInfoForDevice(const std::vector<CPUSpeci
return CPUParams;
}
std::vector<CPUSpecificParams> filterCPUInfoForDeviceWithFP16(const std::vector<CPUSpecificParams>& allParams) {
std::vector<CPUSpecificParams> resCPUParams;
return resCPUParams;
}
} // namespace CPUTestUtils

57
src/plugins/intel_cpu/tests/functional/utils/cpu_test_utils.cpp
View File

@ -8,6 +8,7 @@
#include "cpu_test_utils.hpp"
#include "openvino/core/type/element_type.hpp"
#include "openvino/runtime/system_conf.hpp"
#include "transformations/rt_info/primitives_priority_attribute.hpp"
#include "utils/general_utils.h"
#include "utils/rt_info/memory_formats_attribute.hpp"
@ -471,4 +472,60 @@ void CheckNumberOfNodesWithType(const ov::CompiledModel& compiledModel,
size_t expectedCount) {
CheckNumberOfNodesWithTypes(compiledModel, {nodeType}, expectedCount);
}
ov::element::Type
CPUTestsBase::get_default_imp_precision_type(const ov::element::Type& in_type,
const ov::AnyMap& configuration) {
#if defined(OPENVINO_ARCH_ARM) || defined(OPENVINO_ARCH_ARM64)
return in_type;
#endif
#if defined(OPENVINO_ARCH_RISCV64)
return in_type;
#endif
#if defined(OPENVINO_ARCH_X86_64)
// if is not float
if (!in_type.is_real()) {
return in_type;
}
const std::string precison_key = ov::hint::inference_precision.name();
const auto& it = configuration.find(precison_key);
auto inferencePrecision = it != configuration.end() ? it->second.as<ov::element::Type>() : ov::element::undefined;
if (inferencePrecision == ov::element::undefined) {
const std::string perf_key = ov::hint::execution_mode.name();
const auto& perf_it = configuration.find(perf_key);
if (perf_it != configuration.end() && perf_it->second.as<ov::hint::ExecutionMode>() == ov::hint::ExecutionMode::PERFORMANCE) {
inferencePrecision = ov::element::f32;
if (ov::with_cpu_x86_bfloat16()) {
inferencePrecision = ov::element::bf16;
}
}
}
// ngraph transform pipeline stage
ov::element::Type type = in_type;
if (inferencePrecision == ov::element::f16) {
if (type == ov::element::f32) {
type = ov::element::f16;
}
}
if (type == ov::element::bf16) {
type = ov::with_cpu_x86_avx512_core() ? ov::element::bf16 : ov::element::f32;
} else if (type == ov::element::f16) {
if (inferencePrecision != ov::element::f16 && inferencePrecision != ov::element::undefined) {
type = ov::element::f32;
}
} else {
type = ov::element::f32;
}
// enforceInferPrecision stage
if (inferencePrecision == ov::element::bf16) {
type = ov::with_cpu_x86_avx512_core() ? ov::element::bf16 : ov::element::f32;
}
return type;
#endif
}
} // namespace CPUTestUtils

6
src/plugins/intel_cpu/tests/functional/utils/cpu_test_utils.hpp
View File

@ -4,6 +4,7 @@
#pragma once
#include "openvino/core/any.hpp"
#include "openvino/runtime/compiled_model.hpp"
#include "openvino/runtime/exec_model_info.hpp"
#include "openvino/runtime/system_conf.hpp"
@ -128,6 +129,8 @@ public:
const std::vector<std::string>& priority);
// TODO: change to setter method
static std::string makeSelectedTypeStr(std::string implString, ov::element::Type_t elType);
static ov::element::Type get_default_imp_precision_type(const ov::element::Type& type,
const ov::AnyMap& configuration);
void updateSelectedType(const std::string& primitiveType,
const ov::element::Type netType,
const ov::AnyMap& config);
@ -171,8 +174,9 @@ protected:
// common parameters
const auto emptyCPUSpec = CPUSpecificParams{{}, {}, {}, {}};
const ov::AnyMap empty_plugin_config{};
const ov::AnyMap cpu_bf16_plugin_config = {{ov::hint::inference_precision(ov::element::bf16)}};
const ov::AnyMap cpu_f16_plugin_config = {{ov::hint::inference_precision(ov::element::f16)}};
const ov::AnyMap cpu_bf16_plugin_config = {{ov::hint::inference_precision(ov::element::bf16)}};
const ov::AnyMap cpu_f32_plugin_config = {{ov::hint::inference_precision(ov::element::f32)}};
// utility functions
std::vector<CPUSpecificParams> filterCPUSpecificParams(const std::vector<CPUSpecificParams>& paramsVector);

1
src/plugins/intel_cpu/tests/functional/utils/filter_cpu_info.hpp
View File

@ -11,4 +11,5 @@ namespace CPUTestUtils {
std::vector<CPUSpecificParams> filterCPUInfo(const std::vector<CPUSpecificParams>& CPUParams);
std::vector<CPUSpecificParams> filterCPUInfoForArch(const std::vector<CPUSpecificParams>& CPUParams);
std::vector<CPUSpecificParams> filterCPUInfoForDevice(const std::vector<CPUSpecificParams>& CPUParams);
std::vector<CPUSpecificParams> filterCPUInfoForDeviceWithFP16(const std::vector<CPUSpecificParams>& allParams);
} // namespace CPUTestUtils

18
src/plugins/intel_cpu/tests/functional/utils/x64/filter_cpu_info.cpp
View File

@ -63,4 +63,22 @@ std::vector<CPUSpecificParams> filterCPUInfoForDevice(const std::vector<CPUSpeci
return resCPUParams;
}
std::vector<CPUSpecificParams> filterCPUInfoForDeviceWithFP16(const std::vector<CPUSpecificParams>& allParams) {
std::vector<CPUSpecificParams> specificParams;
if (!ov::with_cpu_x86_avx512_core_fp16()) {
return specificParams;
}
std::copy_if(allParams.begin(), allParams.end(), std::back_inserter(specificParams), [](const CPUSpecificParams& item) {
const auto &selected = std::get<3>(item);
bool isValid = false;
if (selected.find("avx512") != std::string::npos) {
isValid = true;
}
if ((!ov::with_cpu_x86_avx512_core_amx_fp16()) && selected.find("amx") != std::string::npos) {
isValid = false;
}
return isValid;
});
return specificParams;
}
} // namespace CPUTestUtils