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

Add Abs for Snippets tokenization

This commit is contained in:
xuchen-intel 2024-05-17 09:07:34 +02:00
parent 43de73cbd6
commit 486fb2bc03
7 changed files with 87 additions and 13 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/plugins/intel_cpu/src/emitters/snippets/aarch64/cpu_generator.cpp
View File

@ -90,6 +90,7 @@ CPUTargetMachine::CPUTargetMachine(dnnl::impl::cpu::aarch64::cpu_isa_t host_isa)
jitters[op::v1::Multiply::get_type_info_static()] = CREATE_CPU_EMITTER(jit_multiply_emitter);
// unary
jitters[ov::op::v0::Abs::get_type_info_static()] = CREATE_CPU_EMITTER(jit_abs_emitter);
jitters[ov::op::v0::Exp::get_type_info_static()] = CREATE_CPU_EMITTER(jit_exp_emitter);
jitters[ov::op::v0::Relu::get_type_info_static()] = CREATE_CPU_EMITTER(jit_relu_emitter);
jitters[ov::op::v0::Tanh::get_type_info_static()] = CREATE_CPU_EMITTER(jit_tanh_emitter);

5
src/plugins/intel_cpu/src/transformations/snippets/aarch64/pass/snippets_mark_skipped.cpp
View File

@ -75,8 +75,9 @@ bool isFullyConnected(const std::shared_ptr<const ov::Node>& node) {
bool SupportsFusingWithConvolution_Simple(const std::shared_ptr<const Node> &node) {
// Note: some other operations support this fusing (Abs, Clamp, Elu, Sigmoid, SoftPlus, Sqrt).
// Skip them here, when they are supported by Snippets ARM. Ticket: 141170.
return ov::is_type<ov::op::v0::Tanh>(node) ||
ov::is_type<ov::op::v0::Relu>(node);
return ov::is_type<ov::op::v0::Abs>(node) ||
ov::is_type<ov::op::v0::Relu>(node) ||
ov::is_type<ov::op::v0::Tanh>(node);
}
// Convolution is a special case, since it supports peculiar fusings
bool isSuitableConvolutionParent(const std::shared_ptr<const Node> &node) {

3
src/plugins/intel_cpu/src/transformations/transformation_pipeline.cpp
View File

@ -945,7 +945,8 @@ void Transformations::MainSnippets(void) {
auto is_supported_op = [](const std::shared_ptr<const ov::Node> &n) -> bool {
#if defined(OPENVINO_ARCH_ARM64)
return (ov::is_type<ov::op::v1::Add>(n) ||
return (ov::is_type<ov::op::v0::Abs>(n) ||
ov::is_type<ov::op::v1::Add>(n) ||
ov::is_type<ov::op::v1::Divide>(n) ||
ov::is_type<ov::op::v1::Multiply>(n) ||
ov::is_type<ov::op::v0::Exp>(n) ||

27
src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/activation.cpp
View File

@ -4,6 +4,7 @@
#include "activation.hpp"
#include "gtest/gtest.h"
#include "internal_properties.hpp"
#include "utils/cpu_test_utils.hpp"
#include "common_test_utils/node_builders/activation.hpp"
#include "shared_test_classes/single_op/activation.hpp"
@ -19,7 +20,9 @@ std::string ActivationLayerCPUTest::getTestCaseName(const testing::TestParamInfo
std::pair<utils::ActivationTypes, std::vector<float>> activationTypeAndConstValue;
ov::element::Type netPrecision, inPrecision, outPrecision;
CPUTestUtils::CPUSpecificParams cpuParams;
std::tie(inputShapes, activationShapes, activationTypeAndConstValue, netPrecision, inPrecision, outPrecision, cpuParams) = obj.param;
bool enforceSnippets;
std::tie(inputShapes, activationShapes, activationTypeAndConstValue, netPrecision, inPrecision, outPrecision, cpuParams, enforceSnippets) =
obj.param;
std::ostringstream result;
result << activationNames[activationTypeAndConstValue.first] << "_";
@ -43,6 +46,7 @@ std::string ActivationLayerCPUTest::getTestCaseName(const testing::TestParamInfo
result << "inPRC=" << inPrecision.to_string() << "_";
result << "outPRC=" << outPrecision.to_string() << "_";
result << CPUTestUtils::CPUTestsBase::getTestCaseName(cpuParams);
result << "_enforceSnippets=" << enforceSnippets;
return result.str();
}
@ -107,7 +111,9 @@ void ActivationLayerCPUTest::SetUp() {
std::pair<utils::ActivationTypes, std::vector<float>> activationTypeAndConstValue;
ov::element::Type inPrecision, outPrecision;
CPUTestUtils::CPUSpecificParams cpuParams;
std::tie(inputShapes, activationShapes, activationTypeAndConstValue, netPrecision, inPrecision, outPrecision, cpuParams) = this->GetParam();
bool enforceSnippets;
std::tie(inputShapes, activationShapes, activationTypeAndConstValue, netPrecision, inPrecision, outPrecision, cpuParams, enforceSnippets) =
this->GetParam();
std::tie(inFmts, outFmts, priority, selectedType) = cpuParams;
activationType = activationTypeAndConstValue.first;
auto constantsValue = activationTypeAndConstValue.second;
@ -136,6 +142,12 @@ void ActivationLayerCPUTest::SetUp() {
init_input_shapes(inputShapes);
if (enforceSnippets) {
configuration.insert(ov::intel_cpu::snippets_mode(ov::intel_cpu::SnippetsMode::IGNORE_CALLBACK));
} else {
configuration.insert(ov::intel_cpu::snippets_mode(ov::intel_cpu::SnippetsMode::DISABLE));
}
auto params = std::make_shared<ov::op::v0::Parameter>(netPrecision, inputDynamicShapes.front());
auto activation = utils::make_activation(params, netPrecision, activationType, activationShapes, constantsValue);
activation->get_rt_info() = getCPUInfo();
@ -220,6 +232,17 @@ const std::map<utils::ActivationTypes, std::vector<std::vector<float>>>& activat
return activationTypes;
}
const std::map<utils::ActivationTypes, std::vector<std::vector<float>>>& activationTypesSnippets() {
static const std::map<utils::ActivationTypes, std::vector<std::vector<float>>> activationTypes {
{Abs, {{}}},
{Exp, {{}}},
{Relu, {{}}},
{Tanh, {{}}},
};
return activationTypes;
}
const std::vector<ov::element::Type>& netPrc() {
static const std::vector<ov::element::Type> netPrc{ov::element::f32};

4
src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/classes/activation.hpp
View File

@ -22,7 +22,8 @@ using ActivationLayerCPUTestParamSet =
ov::element::Type, // Net precision
ov::element::Type, // Input precision
ov::element::Type, // Output precision
CPUTestUtils::CPUSpecificParams>;
CPUTestUtils::CPUSpecificParams,
bool>;
class ActivationLayerCPUTest : public testing::WithParamInterface<ActivationLayerCPUTestParamSet>,
virtual public ov::test::SubgraphBaseTest,
@ -49,6 +50,7 @@ namespace Activation {
const std::vector<size_t> activationShapes();
const std::map<utils::ActivationTypes, std::vector<std::vector<float>>>& activationTypes();
const std::map<utils::ActivationTypes, std::vector<std::vector<float>>>& activationTypesSnippets();
const std::vector<ov::element::Type>& netPrc();

51
src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/instances/common/activation.cpp
View File

@ -19,11 +19,25 @@ const auto basicCases3D = ::testing::Combine(
::testing::ValuesIn(netPrc()),
::testing::Values(ov::element::f32),
::testing::Values(ov::element::f32),
::testing::ValuesIn(filterCPUSpecificParams(cpuParams3D()))
::testing::ValuesIn(filterCPUSpecificParams(cpuParams3D())),
::testing::Values(false)
);
INSTANTIATE_TEST_SUITE_P(smoke_Activation3D_Eltwise_CPU, ActivationLayerCPUTest, basicCases3D, ActivationLayerCPUTest::getTestCaseName);
const auto basicCasesSnippets3D = ::testing::Combine(
::testing::ValuesIn(static_shapes_to_test_representation(basic3D())),
::testing::Values(activationShapes()),
::testing::ValuesIn(ov::test::utils::combineParams(activationTypesSnippets())),
::testing::ValuesIn(netPrc()),
::testing::Values(ov::element::f32),
::testing::Values(ov::element::f32),
::testing::ValuesIn(filterCPUSpecificParams(cpuParams3D())),
::testing::Values(true)
);
INSTANTIATE_TEST_SUITE_P(smoke_Activation3D_Snippets_CPU, ActivationLayerCPUTest, basicCasesSnippets3D, ActivationLayerCPUTest::getTestCaseName);
/* ============= Activation (2D) ============= */
const auto basicCases4D = ::testing::Combine(
::testing::ValuesIn(static_shapes_to_test_representation(basic4D())),
@ -32,11 +46,25 @@ const auto basicCases4D = ::testing::Combine(
::testing::ValuesIn(netPrc()),
::testing::Values(ov::element::f32),
::testing::Values(ov::element::f32),
::testing::ValuesIn(filterCPUSpecificParams(cpuParams4D()))
::testing::ValuesIn(filterCPUSpecificParams(cpuParams4D())),
::testing::Values(false)
);
INSTANTIATE_TEST_SUITE_P(smoke_Activation4D_Eltwise_CPU, ActivationLayerCPUTest, basicCases4D, ActivationLayerCPUTest::getTestCaseName);
const auto basicCasesSnippets4D = ::testing::Combine(
::testing::ValuesIn(static_shapes_to_test_representation(basic4D())),
::testing::Values(activationShapes()),
::testing::ValuesIn(ov::test::utils::combineParams(activationTypesSnippets())),
::testing::ValuesIn(netPrc()),
::testing::Values(ov::element::f32),
::testing::Values(ov::element::f32),
::testing::ValuesIn(filterCPUSpecificParams(cpuParams4D())),
::testing::Values(true)
);
INSTANTIATE_TEST_SUITE_P(smoke_Activation4D_Snippets_CPU, ActivationLayerCPUTest, basicCasesSnippets4D, ActivationLayerCPUTest::getTestCaseName);
/* ============= Activation (5D) ============= */
const auto basicCases5D = ::testing::Combine(
::testing::ValuesIn(static_shapes_to_test_representation(basic5D())),
@ -45,11 +73,25 @@ const auto basicCases5D = ::testing::Combine(
::testing::ValuesIn(netPrc()),
::testing::Values(ov::element::f32),
::testing::Values(ov::element::f32),
::testing::ValuesIn(filterCPUSpecificParams(cpuParams5D()))
::testing::ValuesIn(filterCPUSpecificParams(cpuParams5D())),
::testing::Values(false)
);
INSTANTIATE_TEST_SUITE_P(smoke_Activation5D_Eltwise_CPU, ActivationLayerCPUTest, basicCases5D, ActivationLayerCPUTest::getTestCaseName);
const auto basicCasesSnippets5D = ::testing::Combine(
::testing::ValuesIn(static_shapes_to_test_representation(basic5D())),
::testing::Values(activationShapes()),
::testing::ValuesIn(ov::test::utils::combineParams(activationTypesSnippets())),
::testing::ValuesIn(netPrc()),
::testing::Values(ov::element::f32),
::testing::Values(ov::element::f32),
::testing::ValuesIn(filterCPUSpecificParams(cpuParams5D())),
::testing::Values(true)
);
INSTANTIATE_TEST_SUITE_P(smoke_Activation5D_Snippets_CPU, ActivationLayerCPUTest, basicCasesSnippets5D, ActivationLayerCPUTest::getTestCaseName);
const auto dynamicMathBasicCases = ::testing::Combine(
::testing::ValuesIn(dynamicMathBasic()),
::testing::Values(activationShapes()),
@ -57,7 +99,8 @@ const auto dynamicMathBasicCases = ::testing::Combine(
::testing::ValuesIn(netPrecisions()),
::testing::Values(ov::element::f32),
::testing::Values(ov::element::f32),
::testing::ValuesIn(cpuParamsDynamicMath())
::testing::ValuesIn(cpuParamsDynamicMath()),
::testing::Values(false)
);
INSTANTIATE_TEST_SUITE_P(smoke_Activation5D_dynamicMath_CPU, ActivationLayerCPUTest, dynamicMathBasicCases, ActivationLayerCPUTest::getTestCaseName);

9
src/plugins/intel_cpu/tests/functional/custom/single_layer_tests/instances/x64/activation.cpp
View File

@ -47,7 +47,8 @@ const auto blockedCases3D = ::testing::Combine(
::testing::ValuesIn(netPrc()),
::testing::Values(ov::element::f32),
::testing::Values(ov::element::f32),
::testing::ValuesIn(filterCPUSpecificParams(cpuParams3Dblocked()))
::testing::ValuesIn(filterCPUSpecificParams(cpuParams3Dblocked())),
::testing::Values(false)
);
INSTANTIATE_TEST_SUITE_P(smoke_Activation3D_Eltwise_CPU_Blocked, ActivationLayerCPUTest, blockedCases3D, ActivationLayerCPUTest::getTestCaseName);
@ -68,7 +69,8 @@ const auto basicCases4D = ::testing::Combine(
::testing::ValuesIn(netPrc()),
::testing::Values(ov::element::f32),
::testing::Values(ov::element::f32),
::testing::ValuesIn(filterCPUSpecificParams(cpuParams4Dblocked()))
::testing::ValuesIn(filterCPUSpecificParams(cpuParams4Dblocked())),
::testing::Values(false)
);
INSTANTIATE_TEST_SUITE_P(smoke_Activation4D_Eltwise_CPU_Blocked, ActivationLayerCPUTest, basicCases4D, ActivationLayerCPUTest::getTestCaseName);
@ -89,7 +91,8 @@ const auto basicCases5D = ::testing::Combine(
::testing::ValuesIn(netPrc()),
::testing::Values(ov::element::f32),
::testing::Values(ov::element::f32),
::testing::ValuesIn(filterCPUSpecificParams(cpuParams5Dblocked()))
::testing::ValuesIn(filterCPUSpecificParams(cpuParams5Dblocked())),
::testing::Values(false)
);
INSTANTIATE_TEST_SUITE_P(smoke_Activation5D_Eltwise_CPU_Blocked, ActivationLayerCPUTest, basicCases5D, ActivationLayerCPUTest::getTestCaseName);