[CPU][ARM] Guard ARM SVE kernel entry points (#36453)

allnes · claude · web-flow · commit 59dfcddaeed5 · 2026-06-24T18:44:24.000Z
## Cause - On AArch64 with GCC (cross-compile, gcc-10) + LTO, `-march=armv8-a+sve` target attributes from runtime-dispatched SVE clones leak into generic ARMv8-A baseline code. - GCC auto-vectorizes generic helpers (e.g. `std::vector<...>` resize in the SVE PagedAttention `AttentionExecutor::init`) with SVE instructions (`mov z0.b, #0` / `whilelo` / `st1d`). - On cores without SVE (e.g. Cortex-A72) these are illegal instructions → SIGILL at runtime (reached on a TBB worker thread). - `brgemm_kernel.cpp` ISA selection unconditionally fell back to `sve_128` without checking `mayiuse(...)`, so it built oneDNN kernels that emit SVE on cores without SVE. ## Solution - `precision_support`: add a single ARM ISA gate — `enum class ArmISA { ASIMD, SVE, DOTPROD, I8MM }` and `bool hasArmISASupport(ArmISA)` (ASIMD → always true baseline, SVE → `with_cpu_sve()`, DOTPROD/I8MM → `with_cpu_arm_*`). It consolidates the former `hasIntDotProductSupport()` / `hasInt8MMSupport()` helpers. Declared/defined for ARM targets only, so x86_64 / RISC-V are unaffected. - ACL executors: encapsulate the precondition common to every ACL executor in `aclCommonExecutorSupported()` (in `acl_utils.hpp`; today the ARMv8-A NEON/ASIMD baseline, extensible). Each ACL executor calls it in its `supports()` / `isSupported()` predicate (`VERIFY(..., UNSUPPORTED_ACL_COMMON_PRECONDITION)` or `if/return` + `DEBUG_LOG`), keeping its op-specific checks. ASIMD is always present on AArch64, so this never over-restricts. - `kleidiai_mm` / `fullyconnected` (KleidiAI path): query `hasArmISASupport` directly (ASIMD, plus DOTPROD/I8MM for ukernel selection). - `brgemm_kernel.cpp`: `getSupportedSveIsa(min_isa = sve_128)` returns the highest supported SVE ISA at or above `min_isa`, or `isa_undef` (then the caller throws) instead of the unconditional `sve_128` fallback. The main brgemm kernel uses the default `sve_128` floor; the `copy_a` / `copy_b` kernels pass `sve_256` (oneDNN only provides `sve_256`/`sve_512` for them — `create_brgemm_matmul_copy_*` asserts a superset of `sve_256`). - `paged_attn.cpp`: decline the ARM PagedAttention executor when the core has no SVE (`hasArmISASupport(ArmISA::SVE)`), in the baseline caller before `make_pa_executor` dispatches to the SVE clone, so the SVE-autovectorized `AttentionExecutor::init` is never reached. The node throws cleanly instead. - SVE codegen is unchanged: SVE-capable cores keep SVE paths; non-SVE cores decline them and fall back to ANY/NEON. ## Tickets - CVS-179098 --------- Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
diff --git a/src/plugins/intel_cpu/src/nodes/executors/acl/acl_conv.cpp b/src/plugins/intel_cpu/src/nodes/executors/acl/acl_conv.cpp
@@ -117,12 +117,13 @@ ACLConvolutionExecutor::ACLConvolutionExecutor(const ConvAttrs& attrs,
 }
 
 bool ACLConvolutionExecutor::supports(const ConvConfig& config) {
-    VERIFY(config.attrs.postOps.size() <= 1U, UNSUPPORTED_BY_EXECUTOR);
-
     const auto& srcDesc = config.descs.at(ARG_SRC);
     const auto& weiDesc = config.descs.at(ARG_WEI);
     const auto& dstDesc = config.descs.at(ARG_DST);
 
+    VERIFY(aclSupported({srcDesc, weiDesc, dstDesc}), UNSUPPORTED_ACL_COMMON_PRECONDITION);
+    VERIFY(config.attrs.postOps.size() <= 1U, UNSUPPORTED_BY_EXECUTOR);
+
     // ACL GemmConv2d supports 4D activations and 4D weight only
     VERIFY(srcDesc->getShape().getRank() == 4 && weiDesc->getShape().getRank() == 4, UNSUPPORTED_BY_EXECUTOR);
     // isQuantized verifies whether src is u8/i8, weights is i8 and FQ is fused if dst is u8/i8
diff --git a/src/plugins/intel_cpu/src/nodes/executors/acl/acl_convert.cpp b/src/plugins/intel_cpu/src/nodes/executors/acl/acl_convert.cpp
@@ -20,6 +20,7 @@
 #include "cpu_memory.h"
 #include "memory_desc/cpu_memory_desc.h"
 #include "nodes/executors/convert.hpp"
+#include "nodes/executors/debug_messages.hpp"
 #include "openvino/core/type/element_type.hpp"
 #include "utils/debug_capabilities.h"
 #include "utils/general_utils.h"
@@ -98,8 +99,9 @@ void ACLConvertExecutor::exec(const std::vector<MemoryCPtr>& src, const std::vec
 }
 
 bool ACLConvertExecutorBuilder::isSupported(const ConvertParams& convertParams,
-                                            [[maybe_unused]] const MemoryDescPtr& srcDesc,
-                                            [[maybe_unused]] const MemoryDescPtr& dstDesc) const {
+                                            const MemoryDescPtr& srcDesc,
+                                            const MemoryDescPtr& dstDesc) const {
+    VERIFY(aclSupported({srcDesc, dstDesc}), UNSUPPORTED_ACL_COMMON_PRECONDITION);
     if (convertParams.srcPrc != convertParams.dstPrc) {
         if (none_of(convertParams.srcPrc,
                     ov::element::i8,
diff --git a/src/plugins/intel_cpu/src/nodes/executors/acl/acl_deconv.cpp b/src/plugins/intel_cpu/src/nodes/executors/acl/acl_deconv.cpp
@@ -21,6 +21,7 @@
 #include "cpu_memory.h"
 #include "memory_desc/cpu_memory_desc.h"
 #include "nodes/executors/acl/acl_utils.hpp"
+#include "nodes/executors/debug_messages.hpp"
 #include "nodes/executors/deconv.hpp"
 #include "nodes/executors/executor.hpp"
 #include "openvino/core/parallel.hpp"
@@ -234,6 +235,7 @@ void AclDeconvExecutor::exec(const std::vector<MemoryCPtr>& src,
 bool AclDeconvExecutorBuilder::customIsSupported(const DeconvAttrs& deconvAttrs,
                                                  const std::vector<MemoryDescPtr>& srcDescs,
                                                  const std::vector<MemoryDescPtr>& dstDescs) {
+    VERIFY(aclSupported({srcDescs[0], dstDescs[0]}), UNSUPPORTED_ACL_COMMON_PRECONDITION);
     if (srcDescs[0]->getShape().getDims().size() != 4 || dstDescs[0]->getShape().getDims().size() != 4 ||
         srcDescs[1]->getShape().getDims().size() != 4) {
         DEBUG_LOG("AclDeconvExecutor only supports 4D tensors:",
diff --git a/src/plugins/intel_cpu/src/nodes/executors/acl/acl_eltwise.cpp b/src/plugins/intel_cpu/src/nodes/executors/acl/acl_eltwise.cpp
@@ -87,6 +87,11 @@ bool AclEltwiseExecutor::supports(const EltwiseConfig& config) {
         srcDescs[argId - ARG_SRC] = desc;
     }
 
+    if (!aclSupported({srcDescs[0], dstDescs[0]})) {
+        DEBUG_LOG("ACL common preconditions are not met");
+        return false;
+    }
+
     auto checkPrecision = [&srcDescs, &dstDescs](std::vector<ov::element::Type> srcVecPrc,
                                                  ov::element::Type dstPrc) -> bool {
         for (size_t i = 0; i < srcDescs.size(); i++) {
diff --git a/src/plugins/intel_cpu/src/nodes/executors/acl/acl_fullyconnected.cpp b/src/plugins/intel_cpu/src/nodes/executors/acl/acl_fullyconnected.cpp
@@ -75,6 +75,8 @@ ACLFullyConnectedExecutor::ACLFullyConnectedExecutor(const FCAttrs& attrs,
 }
 
 bool ACLFullyConnectedExecutor::supports(const FCConfig& config) {
+    VERIFY(aclSupported({config.descs.at(ARG_SRC), config.descs.at(ARG_WEI), config.descs.at(ARG_DST)}),
+           UNSUPPORTED_ACL_COMMON_PRECONDITION);
     VERIFY(any_of(srcType(config), ov::element::f16, ov::element::f32), UNSUPPORTED_SRC_PRECISIONS);
     VERIFY(any_of(weiType(config), ov::element::f16, ov::element::f32), UNSUPPORTED_WEI_PRECISIONS);
     VERIFY(postOpsNumbers(config) < 2, UNSUPPORTED_NUMBER_OF_POSTOPS);
diff --git a/src/plugins/intel_cpu/src/nodes/executors/acl/acl_interpolate.cpp b/src/plugins/intel_cpu/src/nodes/executors/acl/acl_interpolate.cpp
@@ -18,6 +18,7 @@
 #include "acl_utils.hpp"
 #include "cpu_memory.h"
 #include "memory_desc/cpu_memory_desc.h"
+#include "nodes/executors/debug_messages.hpp"
 #include "nodes/executors/interpolate.hpp"
 #include "openvino/core/except.hpp"
 #include "utils/debug_capabilities.h"
@@ -197,6 +198,7 @@ bool ov::intel_cpu::ACLInterpolateExecutorBuilder::isSupportedConfiguration(
 bool ov::intel_cpu::ACLInterpolateExecutorBuilder::isSupported(const ov::intel_cpu::InterpolateAttrs& interpolateAttrs,
                                                                const std::vector<MemoryDescPtr>& srcDescs,
                                                                const std::vector<MemoryDescPtr>& dstDescs) const {
+    VERIFY(aclSupported({srcDescs[0], dstDescs[0]}), UNSUPPORTED_ACL_COMMON_PRECONDITION);
     if (srcDescs[0]->getShape().getDims().size() != 4U) {
         DEBUG_LOG("ACL Interpolate does not support src shape rank: ", srcDescs[0]->getShape().getDims().size());
         return false;
diff --git a/src/plugins/intel_cpu/src/nodes/executors/acl/acl_lowp_fullyconnected.cpp b/src/plugins/intel_cpu/src/nodes/executors/acl/acl_lowp_fullyconnected.cpp
@@ -78,6 +78,8 @@ ACLLowpFullyConnectedExecutor::ACLLowpFullyConnectedExecutor(const FCAttrs& attr
 }
 
 bool ACLLowpFullyConnectedExecutor::supports(const FCConfig& config) {
+    VERIFY(aclSupported({config.descs.at(ARG_SRC), config.descs.at(ARG_WEI), config.descs.at(ARG_DST)}),
+           UNSUPPORTED_ACL_COMMON_PRECONDITION);
     VERIFY(any_of(srcType(config), ov::element::u8, ov::element::i8), UNSUPPORTED_SRC_PRECISIONS);
     VERIFY(weiType(config) == ov::element::i8, UNSUPPORTED_WEI_PRECISIONS);
     VERIFY(dstType(config) == ov::element::f32, UNSUPPORTED_DST_PRECISIONS);
diff --git a/src/plugins/intel_cpu/src/nodes/executors/acl/acl_mvn.cpp b/src/plugins/intel_cpu/src/nodes/executors/acl/acl_mvn.cpp
@@ -16,6 +16,7 @@
 #include "cpu_memory.h"
 #include "memory_desc/cpu_memory_desc.h"
 #include "nodes/executors/acl/acl_utils.hpp"
+#include "nodes/executors/debug_messages.hpp"
 #include "nodes/executors/executor.hpp"
 #include "nodes/executors/mvn.hpp"
 #include "openvino/core/type/element_type.hpp"
@@ -101,6 +102,7 @@ void AclMVNExecutor::exec(const std::vector<MemoryCPtr>& src,
 bool AclMVNExecutorBuilder::isSupported(const MVNAttrs& mvnAttrs,
                                         const std::vector<MemoryDescPtr>& srcDescs,
                                         const std::vector<MemoryDescPtr>& dstDescs) const {
+    VERIFY(aclSupported({srcDescs[0], dstDescs[0]}), UNSUPPORTED_ACL_COMMON_PRECONDITION);
     if ((srcDescs[0]->getPrecision() != ov::element::f32 && srcDescs[0]->getPrecision() != ov::element::f16) ||
         srcDescs[0]->getPrecision() != dstDescs[0]->getPrecision()) {
         DEBUG_LOG("NEMeanStdDevNormalizationLayer does not support precisions:",
diff --git a/src/plugins/intel_cpu/src/nodes/executors/acl/acl_pooling.hpp b/src/plugins/intel_cpu/src/nodes/executors/acl/acl_pooling.hpp
@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include "acl_utils.hpp"
 #include "arm_compute/runtime/NEON/NEFunctions.h"
 #include "nodes/executors/pooling.hpp"
 #include "utils/debug_capabilities.h"
@@ -53,6 +54,10 @@ class AclPoolingExecutorBuilder : public PoolingExecutorBuilder {
     [[nodiscard]] bool isSupported(const PoolingAttrs& poolingAttrs,
                                    const std::vector<MemoryDescPtr>& srcDescs,
                                    const std::vector<MemoryDescPtr>& dstDescs) const override {
+        if (!aclSupported({srcDescs[0], dstDescs[0]})) {
+            DEBUG_LOG("ACL common preconditions are not met");
+            return false;
+        }
         auto isSupportedPrecision = [](const ov::element::Type precision) {
             return any_of(precision, ov::element::f32, ov::element::f16, ov::element::u8, ov::element::i8);
         };
diff --git a/src/plugins/intel_cpu/src/nodes/executors/acl/acl_reduce.hpp b/src/plugins/intel_cpu/src/nodes/executors/acl/acl_reduce.hpp
@@ -42,6 +42,10 @@ class AclReduceExecutorBuilder : public ReduceExecutorBuilder {
     [[nodiscard]] bool isSupported(const ReduceAttrs& reduceAttrs,
                                    const std::vector<MemoryDescPtr>& srcDescs,
                                    const std::vector<MemoryDescPtr>& dstDescs) const override {
+        if (!aclSupported({srcDescs[0], dstDescs[0]})) {
+            DEBUG_LOG("ACL common preconditions are not met");
+            return false;
+        }
         if (reduceAttrs.operation == Algorithm::ReduceMean) {
             if (srcDescs[0]->getPrecision() != dstDescs[0]->getPrecision() ||
                 (srcDescs[0]->getPrecision() != ov::element::f32 && srcDescs[0]->getPrecision() != ov::element::f16)) {
diff --git a/src/plugins/intel_cpu/src/nodes/executors/acl/acl_transpose.hpp b/src/plugins/intel_cpu/src/nodes/executors/acl/acl_transpose.hpp
@@ -4,6 +4,7 @@
 
 #pragma once
 
+#include "acl_utils.hpp"
 #include "arm_compute/runtime/NEON/functions/NEPermute.h"
 #include "arm_compute/runtime/Tensor.h"
 #include "nodes/executors/transpose.hpp"
@@ -34,6 +35,10 @@ class ACLTransposeExecutorBuilder : public TransposeExecutorBuilder {
     [[nodiscard]] bool isSupported([[maybe_unused]] const TransposeParams& transposeParams,
                                    const std::vector<MemoryDescPtr>& srcDescs,
                                    const std::vector<MemoryDescPtr>& dstDescs) const override {
+        if (!aclSupported({srcDescs[0], dstDescs[0]})) {
+            DEBUG_LOG("ACL common preconditions are not met");
+            return false;
+        }
         if ((srcDescs[0]->hasLayoutType(LayoutType::ncsp) || dstDescs[0]->hasLayoutType(LayoutType::ncsp)) &&
             (srcDescs[0]->hasLayoutType(LayoutType::nspc) || dstDescs[0]->hasLayoutType(LayoutType::nspc))) {
             DEBUG_LOG("NEPermute does not support layout:",
diff --git a/src/plugins/intel_cpu/src/nodes/executors/acl/acl_utils.hpp b/src/plugins/intel_cpu/src/nodes/executors/acl/acl_utils.hpp
@@ -3,12 +3,14 @@
 //
 #pragma once
 
+#include <algorithm>
 #include <vector>
 
 #include "arm_compute/core/QuantizationInfo.h"
 #include "arm_compute/core/Types.h"
 #include "cpu_types.h"
 #include "memory_desc/cpu_memory_desc.h"
+#include "utils/arm_isa_support.h"
 
 namespace ov::intel_cpu {
 
@@ -169,6 +171,23 @@ inline arm_compute::DataType precisionToAclDataType(ov::element::Type precision)
     }
 }
 
+/**
+ * @brief Preconditions common to every ACL executor, independent of the op/config type. ACL kernels
+ * run on the ARMv8-A NEON baseline (ASIMD) and can only operate on ACL-representable precisions
+ * (precisionToAclDataType != UNKNOWN; e.g. u4/i4/nf4/string must never reach an ACL kernel), so an
+ * executor must not be selected when either is unmet. Op-specific checks (exact precisions, ranks,
+ * post ops, layouts, ...) stay in each executor's own supports()/isSupported(). Pass the executor's
+ * tensor descriptors; empty ones (e.g. an absent optional bias) are ignored. Usage:
+ *   VERIFY(aclSupported({srcDesc, weiDesc, dstDesc}), UNSUPPORTED_ACL_COMMON_PRECONDITION);
+ *   if (!aclSupported({srcDescs[0], dstDescs[0]})) { return false; }
+ * @return whether the current core and the tensor precisions meet the common ACL preconditions
+ */
+inline bool aclSupported(const std::vector<MemoryDescPtr>& descs) {
+    return hasArmISASupport(ArmISA::ASIMD) && std::all_of(descs.begin(), descs.end(), [](const MemoryDescPtr& desc) {
+               return desc->empty() || precisionToAclDataType(desc->getPrecision()) != arm_compute::DataType::UNKNOWN;
+           });
+}
+
 /**
  * @brief Return ComputeLibrary DataLayout that corresponds to MemoryDecs layout
  * @param desc MemoryDecs from which layout is retrieved
diff --git a/src/plugins/intel_cpu/src/nodes/executors/debug_messages.hpp b/src/plugins/intel_cpu/src/nodes/executors/debug_messages.hpp
@@ -21,6 +21,7 @@
 #define UNSUPPORTED_DST_STRIDES              " unsupported dst strides"
 #define UNSUPPORTED_PER_CHANNEL_QUANTIZATION " unsupported per-channel quantization"
 #define UNSUPPORTED_BY_EXECUTOR              " unsupported by executor"
+#define UNSUPPORTED_ACL_COMMON_PRECONDITION  " ACL common preconditions not met"
 #define HEURISTICS_MISMATCH                  " heuristics mismatch"
 #define MEMORY_FORMAT_MISMATCH               " memory format mismatch"
 
diff --git a/src/plugins/intel_cpu/src/nodes/executors/kleidiai/kleidiai_gathermatmul.cpp b/src/plugins/intel_cpu/src/nodes/executors/kleidiai/kleidiai_gathermatmul.cpp
@@ -23,12 +23,12 @@
 #include "nodes/executors/memory_arguments.hpp"
 #include "openvino/core/except.hpp"
 #include "openvino/core/type/element_type.hpp"
-#include "utils/precision_support.h"
+#include "utils/arm_isa_support.h"
 
 namespace ov::intel_cpu {
 
 static bool useDynamicQuantizationImpl(const MemoryDescPtr& weightDesc) {
-    if (!hasIntDotProductSupport() && !hasInt8MMSupport()) {
+    if (!hasArmISASupport(ArmISA::DOTPROD) && !hasArmISASupport(ArmISA::I8MM)) {
         return false;
     }
     return weightDesc->getPrecision() == element::i8 || weightDesc->getPrecision() == element::i4;
diff --git a/src/plugins/intel_cpu/src/nodes/executors/kleidiai/kleidiai_mm.cpp b/src/plugins/intel_cpu/src/nodes/executors/kleidiai/kleidiai_mm.cpp
@@ -28,16 +28,17 @@
 #include "nodes/common/blocked_desc_creator.h"
 #include "nodes/executors/acl/acl_fullyconnected_utils.hpp"
 #include "nodes/executors/common/offset_helper.hpp"
+#include "nodes/executors/debug_messages.hpp"
 #include "nodes/executors/executor.hpp"
 #include "nodes/executors/fullyconnected_config.hpp"
 #include "nodes/executors/memory_arguments.hpp"
 #include "openvino/core/except.hpp"
 #include "openvino/core/parallel.hpp"
 #include "openvino/core/type/element_type.hpp"
+#include "utils/arm_isa_support.h"
 #include "utils/cpu_utils.hpp"
 #include "utils/debug_capabilities.h"
 #include "utils/general_utils.h"
-#include "utils/precision_support.h"
 
 #define FLOAT_MAX 3.4028235e38f
 #define FLOAT_MIN (-3.4028235e38f)
@@ -58,14 +59,15 @@ static bool useDynamicQuantizationImpl(const FCAttrs& attrs, const MemoryDescPtr
         return false;
     }
 
-    if (!hasIntDotProductSupport() && !hasInt8MMSupport()) {
+    if (!hasArmISASupport(ArmISA::DOTPROD) && !hasArmISASupport(ArmISA::I8MM)) {
         return false;
     }
 
     return weightDesc->getPrecision() == element::i8 || weightDesc->getPrecision() == element::i4;
 }
 
 bool MatMulKleidiAIExecutor::supports(const FCConfig& config) {
+    VERIFY(hasArmISASupport(ArmISA::ASIMD), UNSUPPORTED_ISA);
     return config.descs.at(ARG_WEI)->getPrecision() == element::f32 ||
            useDynamicQuantizationImpl(config.attrs, config.descs.at(ARG_WEI));
 }
@@ -142,7 +144,7 @@ MatMulKleidiAIExecutor::MatMulKleidiAIExecutor(const FCAttrs& attrs,
         MemoryPtr weightsMemory = memory.at(ARG_WEI);
         INT4_IMPL = weightsMemory->getDescPtr()->getPrecision() == element::i4;
         if (INT4_IMPL) {
-            ukernel_i4 = hasInt8MMSupport() ? &ukernel_i4_imm : &ukernel_i4_dotprod;
+            ukernel_i4 = hasArmISASupport(ArmISA::I8MM) ? &ukernel_i4_imm : &ukernel_i4_dotprod;
             BLOCK_SIZE_M_LOWP = ukernel_i4->get_m_step();
 
             mr = ukernel_i4->get_mr();
@@ -192,7 +194,7 @@ MatMulKleidiAIExecutor::MatMulKleidiAIExecutor(const FCAttrs& attrs,
             }
 
         } else {
-            ukernel_i8 = hasInt8MMSupport() ? &ukernel_i8_imm : &ukernel_i8_dotprod;
+            ukernel_i8 = hasArmISASupport(ArmISA::I8MM) ? &ukernel_i8_imm : &ukernel_i8_dotprod;
             BLOCK_SIZE_M_LOWP = 16;
             if (!attrs.weightsNonTransposed) {
                 auto dnnlSrcDesc = MemoryDescUtils::convertToDnnlMemoryDesc(originalWeightsDesc);
diff --git a/src/plugins/intel_cpu/src/nodes/fullyconnected.cpp b/src/plugins/intel_cpu/src/nodes/fullyconnected.cpp
@@ -53,7 +53,7 @@
 #include "utils/general_utils.h"
 #if defined(OV_CPU_WITH_KLEIDIAI)
 #    include "openvino/core/shape.hpp"
-#    include "utils/precision_support.h"
+#    include "utils/arm_isa_support.h"
 #endif
 
 using namespace dnnl;
@@ -189,7 +189,7 @@ bool FullyConnected::isSupportedCompressedOperation([[maybe_unused]] const std::
         if (!isSupportedOperation(op, errorMessage)) {
             return false;
         }
-        if (!hasIntDotProductSupport()) {
+        if (!hasArmISASupport(ArmISA::DOTPROD)) {
             return false;
         }
         if (config.fcDynamicQuantizationGroupSize != UINT64_MAX) {
diff --git a/src/plugins/intel_cpu/src/nodes/gathermatmul.cpp b/src/plugins/intel_cpu/src/nodes/gathermatmul.cpp
@@ -20,7 +20,7 @@
 #    include <cstdint>
 #    include <limits>
 
-#    include "utils/precision_support.h"
+#    include "utils/arm_isa_support.h"
 #endif
 #include "graph_context.h"
 #include "memory_desc/cpu_memory_desc.h"
@@ -142,7 +142,7 @@ bool GatherMatmul::isSupportedCompressedOperation([[maybe_unused]] const std::sh
         if (!isSupportedOperation(op, errorMessage)) {
             return false;
         }
-        if (!hasIntDotProductSupport() && !hasInt8MMSupport()) {
+        if (!hasArmISASupport(ArmISA::DOTPROD) && !hasArmISASupport(ArmISA::I8MM)) {
             return false;
         }
         if (config.fcDynamicQuantizationGroupSize != std::numeric_limits<uint64_t>::max()) {
diff --git a/src/plugins/intel_cpu/src/nodes/kernels/aarch64/brgemm_kernel.cpp b/src/plugins/intel_cpu/src/nodes/kernels/aarch64/brgemm_kernel.cpp
diff --git a/src/plugins/intel_cpu/src/nodes/paged_attn.cpp b/src/plugins/intel_cpu/src/nodes/paged_attn.cpp
diff --git a/src/plugins/intel_cpu/src/utils/arm_isa_support.cpp b/src/plugins/intel_cpu/src/utils/arm_isa_support.cpp
diff --git a/src/plugins/intel_cpu/src/utils/arm_isa_support.h b/src/plugins/intel_cpu/src/utils/arm_isa_support.h
diff --git a/src/plugins/intel_cpu/src/utils/precision_support.cpp b/src/plugins/intel_cpu/src/utils/precision_support.cpp
diff --git a/src/plugins/intel_cpu/src/utils/precision_support.h b/src/plugins/intel_cpu/src/utils/precision_support.h
diff --git a/src/plugins/intel_cpu/tests/functional/CMakeLists.txt b/src/plugins/intel_cpu/tests/functional/CMakeLists.txt
diff --git a/src/plugins/intel_cpu/tests/functional/shared_tests_instances/skip_tests_config.cpp b/src/plugins/intel_cpu/tests/functional/shared_tests_instances/skip_tests_config.cpp

Original file line number	Diff line number	Diff line change
`@@ -75,6 +75,8 @@ ACLFullyConnectedExecutor::ACLFullyConnectedExecutor(const FCAttrs& attrs,`
`75`	`75`	`}`
`76`	`76`
`77`	`77`	`bool ACLFullyConnectedExecutor::supports(const FCConfig& config) {`
	`78`	`+ VERIFY(aclSupported({config.descs.at(ARG_SRC), config.descs.at(ARG_WEI), config.descs.at(ARG_DST)}),`
	`79`	`+ UNSUPPORTED_ACL_COMMON_PRECONDITION);`
`78`	`80`	`VERIFY(any_of(srcType(config), ov::element::f16, ov::element::f32), UNSUPPORTED_SRC_PRECISIONS);`
`79`	`81`	`VERIFY(any_of(weiType(config), ov::element::f16, ov::element::f32), UNSUPPORTED_WEI_PRECISIONS);`
`80`	`82`	`VERIFY(postOpsNumbers(config) < 2, UNSUPPORTED_NUMBER_OF_POSTOPS);`
Original file line number	Diff line number	Diff line change
`@@ -78,6 +78,8 @@ ACLLowpFullyConnectedExecutor::ACLLowpFullyConnectedExecutor(const FCAttrs& attr`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`bool ACLLowpFullyConnectedExecutor::supports(const FCConfig& config) {`
	`81`	`+ VERIFY(aclSupported({config.descs.at(ARG_SRC), config.descs.at(ARG_WEI), config.descs.at(ARG_DST)}),`
	`82`	`+ UNSUPPORTED_ACL_COMMON_PRECONDITION);`
`81`	`83`	`VERIFY(any_of(srcType(config), ov::element::u8, ov::element::i8), UNSUPPORTED_SRC_PRECISIONS);`
`82`	`84`	`VERIFY(weiType(config) == ov::element::i8, UNSUPPORTED_WEI_PRECISIONS);`
`83`	`85`	`VERIFY(dstType(config) == ov::element::f32, UNSUPPORTED_DST_PRECISIONS);`