[Snippets][CPU][RV64] Enable infrastructure

.github/workflows/linux_riscv_xuantie_dev_cpu.yml

@@ -16,6 +16,7 @@ on:
       - 'src/plugins/intel_cpu/src/emitters/plugin/aarch64/**'
       - 'src/plugins/intel_cpu/src/emitters/plugin/riscv64/**'
       - 'src/plugins/intel_cpu/src/emitters/plugin/x64/**'
+      - 'src/plugins/intel_cpu/src/emitters/snippets/riscv64/**'
       - 'src/plugins/intel_cpu/src/nodes/executors/aarch64/**'
       - 'src/plugins/intel_cpu/src/nodes/executors/shl/**'
       - 'src/plugins/intel_cpu/src/nodes/kernels/riscv64/**'
@@ -234,7 +235,7 @@ jobs:
     env:
       INSTALL_DIR: ${{ github.workspace }}/install
       INSTALL_TEST_DIR: ${{ github.workspace }}/install/tests
-      GTEST_FILTER: ${{ inputs.testFilterType == 'SMOKE' && '*smoke*' || '*ActivationLayer*:*EltwiseLayer*:*LogicalLayer*:*ComparisonLayer*:*SelectLayer*:*MatMulLayerCPUTest*:*ExtremumLayerCPUTest*' }}
+      GTEST_FILTER: ${{ inputs.testFilterType == 'SMOKE' && '*smoke*' || '*ActivationLayer*:*EltwiseLayer*:*LogicalLayer*:*ComparisonLayer*:*SelectLayer*:*MatMulLayerCPUTest*:*ExtremumLayerCPUTest*:smoke_Snippets*' }}
 
     steps:
       - name: Download OpenVINO artifacts (package)

src/plugins/intel_cpu/CMakeLists.txt

@@ -212,18 +212,23 @@ if(NOT (AARCH64 OR ARM))
                               ${CMAKE_CURRENT_SOURCE_DIR}/src/transformations/tpp/aarch64/*
                               ${CMAKE_CURRENT_SOURCE_DIR}/src/emitters/plugin/aarch64/*
                               ${CMAKE_CURRENT_SOURCE_DIR}/src/emitters/tpp/aarch64/*
-                              ${CMAKE_CURRENT_SOURCE_DIR}/src/nodes/executors/aarch64/*
                               ${CMAKE_CURRENT_SOURCE_DIR}/src/nodes/kernels/aarch64/*)
 endif()
 
+if(NOT (AARCH64 OR ARM))
+    list(APPEND EXCLUDE_PATHS ${CMAKE_CURRENT_SOURCE_DIR}/src/nodes/executors/aarch64/*)
+endif()
+
 if(NOT AARCH64)
     list(APPEND EXCLUDE_PATHS ${CMAKE_CURRENT_SOURCE_DIR}/src/transformations/snippets/aarch64/*
                               ${CMAKE_CURRENT_SOURCE_DIR}/src/emitters/snippets/aarch64/*)
 endif()
 
 if (NOT RISCV64)
     list(APPEND EXCLUDE_PATHS ${CMAKE_CURRENT_SOURCE_DIR}/src/emitters/plugin/riscv64/*
-                              ${CMAKE_CURRENT_SOURCE_DIR}/src/nodes/kernels/riscv64/*)
+                              ${CMAKE_CURRENT_SOURCE_DIR}/src/nodes/kernels/riscv64/*
+                              ${CMAKE_CURRENT_SOURCE_DIR}/src/emitters/snippets/riscv64/*
+                              ${CMAKE_CURRENT_SOURCE_DIR}/src/nodes/executors/riscv64/*)
 endif()
 
 if (NOT ENABLE_MLAS_FOR_CPU)

src/plugins/intel_cpu/src/emitters/snippets/aarch64/cpu_generator.cpp

@@ -10,7 +10,6 @@
 #include <cpu/aarch64/cpu_isa_traits.hpp>
 #include <cpu/aarch64/jit_generator.hpp>
 #include <cstddef>
-#include <cstdint>
 #include <memory>
 #include <set>
 #include <utility>
@@ -213,23 +212,6 @@ class jit_snippet : public dnnl::impl::cpu::aarch64::jit_generator {
 
 namespace intel_cpu::aarch64 {
 
-CompiledSnippetCPU::CompiledSnippetCPU(std::unique_ptr<dnnl::impl::cpu::aarch64::jit_generator> h)
-    : h_compiled(std::move(h)) {
-    OPENVINO_ASSERT(h_compiled && h_compiled->jit_ker(), "Got invalid jit generator or kernel was nopt compiled");
-}
-
-const uint8_t* CompiledSnippetCPU::get_code() const {
-    return h_compiled->jit_ker();
-}
-
-size_t CompiledSnippetCPU::get_code_size() const {
-    return h_compiled->getSize();
-}
-
-bool CompiledSnippetCPU::empty() const {
-    return get_code_size() == 0;
-}
-
 CPUTargetMachine::CPUTargetMachine(dnnl::impl::cpu::aarch64::cpu_isa_t host_isa, ov::intel_cpu::MultiCacheWeakPtr cache)
     : TargetMachine(std::make_shared<CPURuntimeConfigurator>(cache)),
       h(new jit_snippet()),

src/plugins/intel_cpu/src/emitters/snippets/aarch64/cpu_generator.hpp

@@ -12,6 +12,7 @@
 
 #include "cache/multi_cache.h"
 #include "cpu/aarch64/jit_generator.hpp"
+#include "emitters/snippets/common/compiled_snippet_cpu.hpp"
 #include "openvino/core/node.hpp"
 #include "openvino/core/node_output.hpp"
 #include "snippets/emitter.hpp"
@@ -20,16 +21,7 @@
 
 namespace ov::intel_cpu::aarch64 {
 
-class CompiledSnippetCPU : public snippets::CompiledSnippet {
-public:
-    explicit CompiledSnippetCPU(std::unique_ptr<dnnl::impl::cpu::aarch64::jit_generator> h);
-    [[nodiscard]] const uint8_t* get_code() const override;
-    [[nodiscard]] size_t get_code_size() const override;
-    [[nodiscard]] bool empty() const override;
-
-private:
-    const std::unique_ptr<const dnnl::impl::cpu::aarch64::jit_generator> h_compiled;
-};
+using CompiledSnippetCPU = ov::intel_cpu::CompiledSnippetCPUCommon<dnnl::impl::cpu::aarch64::jit_generator>;
 
 class CPUTargetMachine : public snippets::TargetMachine {
 public:

src/plugins/intel_cpu/src/emitters/snippets/aarch64/jit_memory_emitters.cpp

@@ -18,11 +18,11 @@
 #include "emitters/plugin/aarch64/jit_emitter.hpp"
 #include "emitters/plugin/aarch64/jit_load_store_emitters.hpp"
 #include "emitters/snippets/jit_snippets_call_args.hpp"
+#include "emitters/snippets/utils/utils.hpp"
 #include "emitters/utils.hpp"
 #include "openvino/core/type.hpp"
 #include "openvino/core/type/element_type.hpp"
 #include "snippets/lowered/expression.hpp"
-#include "snippets/lowered/expressions/buffer_expression.hpp"
 #include "snippets/lowered/loop_manager.hpp"
 #include "snippets/op/broadcastload.hpp"
 #include "snippets/op/load.hpp"
@@ -55,13 +55,13 @@ jit_memory_emitter::jit_memory_emitter(jit_generator* h,
         OV_CPU_JIT_EMITTER_ASSERT(memory_access->is_memory_access_input_port(0), "must be input port - memory access");
         count = memory_access->get_input_count();
         compiled_byte_offset = memory_access->get_input_offset();
-        buffer_cluster_id = get_parent_buffer_cluster_id(expr);
+        buffer_cluster_id = ov::intel_cpu::utils::get_parent_buffer_cluster_id(expr);
     } else if (in_out_type_ == emitter_in_out_map::vec_to_gpr) {
         OV_CPU_JIT_EMITTER_ASSERT(memory_access->is_memory_access_output_port(0),
                                   "must be output port - memory access");
         count = memory_access->get_output_count();
         compiled_byte_offset = memory_access->get_output_offset();
-        buffer_cluster_id = get_consumer_buffer_cluster_id(expr);
+        buffer_cluster_id = ov::intel_cpu::utils::get_consumer_buffer_cluster_id(expr);
     } else {
         OV_CPU_JIT_EMITTER_THROW("unsupported in_out_type");
     }
@@ -75,26 +75,6 @@ jit_memory_emitter::jit_memory_emitter(jit_generator* h,
     }
 }
 
-size_t jit_memory_emitter::get_parent_buffer_cluster_id(const ov::snippets::lowered::ExpressionPtr& expr) {
-    OV_CPU_JIT_EMITTER_ASSERT(expr->get_input_count() == 1, "MemoryAccess must have one parent");
-    const auto& parent_expr = expr->get_input_expr_ptr(0);
-    if (const auto buffer = ov::as_type_ptr<ov::snippets::lowered::BufferExpression>(parent_expr)) {
-        return buffer->get_cluster_id();
-    }
-    return SIZE_MAX;
-}
-
-size_t jit_memory_emitter::get_consumer_buffer_cluster_id(const ov::snippets::lowered::ExpressionPtr& expr) {
-    OV_CPU_JIT_EMITTER_ASSERT(expr->get_output_count() == 1, "MemoryAccess must have one output");
-    const auto& consumers = expr->get_output_port_connector(0)->get_consumers();
-    for (const auto& consumer : consumers) {
-        if (const auto buffer = ov::as_type_ptr<ov::snippets::lowered::BufferExpression>(consumer.get_expr())) {
-            return buffer->get_cluster_id();
-        }
-    }
-    return SIZE_MAX;
-}
-
 jit_load_memory_emitter::jit_load_memory_emitter(jit_generator* h, cpu_isa_t isa, const ExpressionPtr& expr)
     : jit_memory_emitter(h, isa, expr, emitter_in_out_map::gpr_to_vec) {
     bool is_supported_precision =

src/plugins/intel_cpu/src/emitters/snippets/aarch64/jit_memory_emitters.hpp

@@ -34,9 +34,6 @@ class jit_memory_emitter : public jit_emitter {
     std::vector<size_t> get_available_aux_gprs() const;
 
 protected:
-    static size_t get_parent_buffer_cluster_id(const ov::snippets::lowered::ExpressionPtr& expr);
-    static size_t get_consumer_buffer_cluster_id(const ov::snippets::lowered::ExpressionPtr& expr);
-
     ov::element::Type src_prc;
     ov::element::Type dst_prc;
 

src/plugins/intel_cpu/src/emitters/snippets/common/compiled_snippet_cpu.hpp

@@ -0,0 +1,40 @@
+// Copyright (C) 2018-2025 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+
+#include "openvino/core/except.hpp"
+#include "snippets/target_machine.hpp"
+
+namespace ov::intel_cpu {
+
+// A small helper that wraps a platform-specific JIT generator and exposes
+// a uniform CompiledSnippet interface. This reduces duplication across
+// x64, aarch64 and riscv64 backends.
+template <typename JitGeneratorT>
+class CompiledSnippetCPUCommon : public ov::snippets::CompiledSnippet {
+public:
+    explicit CompiledSnippetCPUCommon(std::unique_ptr<JitGeneratorT> h) : h_compiled(std::move(h)) {
+        OPENVINO_ASSERT(h_compiled && h_compiled->jit_ker(), "Got invalid jit generator or kernel was not compiled");
+    }
+
+    [[nodiscard]] const uint8_t* get_code() const override {
+        return h_compiled->jit_ker();
+    }
+    [[nodiscard]] size_t get_code_size() const override {
+        return h_compiled->getSize();
+    }
+    [[nodiscard]] bool empty() const override {
+        return get_code_size() == 0;
+    }
+
+private:
+    const std::unique_ptr<const JitGeneratorT> h_compiled;
+};
+
+}  // namespace ov::intel_cpu

src/plugins/intel_cpu/src/emitters/snippets/common/jit_loop_args_helper.hpp

@@ -0,0 +1,48 @@
+// Copyright (C) 2018-2025 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+#include "emitters/snippets/jit_snippets_call_args.hpp"
+#include "snippets/op/loop.hpp"
+#include "snippets/utils/utils.hpp"
+
+namespace ov::intel_cpu::snippets_common {
+
+inline jit_snippets_call_args::loop_args_t compose_loop_args(
+    const std::shared_ptr<ov::snippets::op::LoopEnd>& loop_end) {
+    const auto& ptr_increments = loop_end->get_ptr_increments();
+    const auto& fin_offsets = loop_end->get_finalization_offsets();
+    const auto& is_incremented = loop_end->get_is_incremented();
+    const auto wa_increment = loop_end->get_increment();
+
+    const auto int_work_amount = ov::snippets::utils::is_dynamic_value(loop_end->get_work_amount())
+                                     ? ov::snippets::utils::get_dynamic_value<int64_t>()
+                                     : static_cast<int64_t>(loop_end->get_work_amount());
+    auto loop_args = jit_snippets_call_args::loop_args_t(int_work_amount, ptr_increments, fin_offsets);
+
+    const auto& data_sizes = loop_end->get_element_type_sizes();
+    for (int64_t i = 0; i < loop_args.m_num_data_ptrs; ++i) {
+        if (!is_incremented[i]) {
+            loop_args.m_ptr_increments[i] = 0;
+            loop_args.m_finalization_offsets[i] = 0;
+            continue;
+        }
+
+        if (!ov::snippets::utils::is_dynamic_value(loop_args.m_ptr_increments[i])) {
+            loop_args.m_ptr_increments[i] *= (wa_increment * data_sizes[i]);
+        }
+        if (!ov::snippets::utils::is_dynamic_value(loop_args.m_finalization_offsets[i])) {
+            loop_args.m_finalization_offsets[i] *= data_sizes[i];
+        }
+    }
+
+    return loop_args;
+}
+
+}  // namespace ov::intel_cpu::snippets_common