[Snippets][CPU][RV64] Enable eltwise binary op tests (openvinotoolkit#34040)

### Details:
 - Implement `BroadcastMove` emitter for RISC-V
 - Attach `RankNormalization` emitter to RISC-V CPU generator
- Enable testing for `smoke_Snippets_Eltwise*` and
`smoke_Snippets_ThreeInputsEltwise*` scopes

### Tickets:
 - N/A

Author: aobolensk

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

@@ -24,6 +24,7 @@
 #include "openvino/core/node.hpp"
 #include "openvino/core/node_output.hpp"
 #include "openvino/op/abs.hpp"
+#include "openvino/op/add.hpp"
 #include "openvino/op/clamp.hpp"
 #include "openvino/op/elu.hpp"
 #include "openvino/op/erf.hpp"
@@ -36,6 +37,7 @@
 #include "openvino/op/is_inf.hpp"
 #include "openvino/op/is_nan.hpp"
 #include "openvino/op/mish.hpp"
+#include "openvino/op/multiply.hpp"
 #include "openvino/op/negative.hpp"
 #include "openvino/op/parameter.hpp"
 #include "openvino/op/relu.hpp"
@@ -47,9 +49,11 @@
 #include "snippets/generator.hpp"
 #include "snippets/lowered/expression.hpp"
 #include "snippets/op/broadcastload.hpp"
+#include "snippets/op/broadcastmove.hpp"
 #include "snippets/op/kernel.hpp"
 #include "snippets/op/load.hpp"
 #include "snippets/op/loop.hpp"
+#include "snippets/op/rank_normalization.hpp"
 #include "snippets/op/result.hpp"
 #include "snippets/op/scalar.hpp"
 #include "snippets/op/store.hpp"
@@ -154,7 +158,10 @@ CPUTargetMachine::CPUTargetMachine(ov::intel_cpu::riscv64::cpu_isa_t host_isa, o
     // data movement
     jitters[op::v0::Parameter::get_type_info_static()] = emitter_factory.from_expr<jit_nop_emitter>();
     jitters[snippets::op::Result::get_type_info_static()] = emitter_factory.from_expr<jit_nop_emitter>();
+    jitters[snippets::op::RankNormalization::get_type_info_static()] = emitter_factory.from_expr<jit_nop_emitter>();
     jitters[snippets::op::Scalar::get_type_info_static()] = emitter_factory.from_expr<jit_scalar_emitter>();
+    jitters[snippets::op::BroadcastMove::get_type_info_static()] =
+        emitter_factory.from_expr<jit_broadcast_move_emitter>();
 
     // memory access
     jitters[snippets::op::Load::get_type_info_static()] = emitter_factory.from_expr<jit_load_memory_emitter>();
@@ -174,12 +181,12 @@ CPUTargetMachine::CPUTargetMachine(ov::intel_cpu::riscv64::cpu_isa_t host_isa, o
         emitter_factory.from_expr<jit_kernel_dynamic_emitter>();
 
     // binary operations
-    // jitters[op::v1::Add::get_type_info_static()] = emitter_factory.from_node<jit_add_emitter>();
+    jitters[op::v1::Add::get_type_info_static()] = emitter_factory.from_node<jit_add_emitter>();
     // jitters[op::v1::Divide::get_type_info_static()] = emitter_factory.from_node<jit_divide_emitter>();
     // jitters[op::v1::Maximum::get_type_info_static()] = emitter_factory.from_node<jit_maximum_emitter>();
     // jitters[op::v1::Minimum::get_type_info_static()] = emitter_factory.from_node<jit_minimum_emitter>();
     // jitters[op::v1::Mod::get_type_info_static()] = emitter_factory.from_node<jit_mod_emitter>();
-    // jitters[op::v1::Multiply::get_type_info_static()] = emitter_factory.from_node<jit_multiply_emitter>();
+    jitters[op::v1::Multiply::get_type_info_static()] = emitter_factory.from_node<jit_multiply_emitter>();
     // jitters[snippets::op::PowerStatic::get_type_info_static()] =
     // emitter_factory.from_node<jit_power_static_emitter>(); jitters[op::v0::SquaredDifference::get_type_info_static()]
     // =

src/plugins/intel_cpu/src/emitters/snippets/riscv64/jit_snippets_emitters.cpp

@@ -17,6 +17,8 @@
 #include "openvino/core/type/element_type.hpp"
 #include "openvino/op/constant.hpp"
 #include "snippets/lowered/expression.hpp"
+#include "snippets/op/broadcastmove.hpp"
+#include "utils/general_utils.h"
 #include "xbyak_riscv/xbyak_riscv.hpp"
 #include "xbyak_riscv/xbyak_riscv_csr.hpp"
 
@@ -31,6 +33,47 @@ jit_nop_emitter::jit_nop_emitter(jit_generator_t* h, cpu_isa_t isa, [[maybe_unus
     in_out_type_ = emitter_in_out_map::gpr_to_gpr;
 }
 
+jit_broadcast_move_emitter::jit_broadcast_move_emitter(jit_generator_t* h, cpu_isa_t isa, const ExpressionPtr& expr)
+    : jit_emitter(h, isa) {
+    const auto n = expr->get_node();
+    OV_CPU_JIT_EMITTER_ASSERT(ov::as_type_ptr<snippets::op::BroadcastMove>(n) != nullptr,
+                              "Expects BroadcastMove expression");
+    const auto element_type = n->get_input_element_type(0);
+    OV_CPU_JIT_EMITTER_ASSERT(any_of(element_type.size(), 1U, 2U, 4U), "Unsupported element type: ", element_type);
+    byte_size = element_type.size();
+}
+
+void jit_broadcast_move_emitter::emit_impl(const std::vector<size_t>& in, const std::vector<size_t>& out) const {
+    if (host_isa_ == ov::intel_cpu::riscv64::gv) {
+        emit_isa<ov::intel_cpu::riscv64::gv>(in, out);
+    } else {
+        OV_CPU_JIT_EMITTER_THROW("Doesn't support isa ", host_isa_);
+    }
+}
+
+template <cpu_isa_t isa>
+void jit_broadcast_move_emitter::emit_isa(const std::vector<size_t>& in, const std::vector<size_t>& out) const {
+    auto src_vreg = Xbyak_riscv::VReg(in[0]);
+    auto dst_vreg = Xbyak_riscv::VReg(out[0]);
+
+    switch (byte_size) {
+    case 1:
+        h->vsetivli(Xbyak_riscv::zero, 4, Xbyak_riscv::SEW::e8, Xbyak_riscv::LMUL::m1);
+        break;
+    case 2:
+        h->vsetivli(Xbyak_riscv::zero, 4, Xbyak_riscv::SEW::e16, Xbyak_riscv::LMUL::m1);
+        break;
+    case 4:
+        h->vsetivli(Xbyak_riscv::zero, 4, Xbyak_riscv::SEW::e32, Xbyak_riscv::LMUL::m1);
+        break;
+    default:
+        OV_CPU_JIT_EMITTER_THROW("Unsupported data size ", byte_size);
+    }
+
+    // Broadcast the first element of src to all dst lanes.
+    h->vrgather_vi(dst_vreg, src_vreg, 0);
+}
+
 jit_scalar_emitter::jit_scalar_emitter(jit_generator_t* h, cpu_isa_t isa, const ExpressionPtr& expr)
     : jit_emitter(h, isa) {
     const auto n = expr->get_node();
@@ -80,4 +123,4 @@ void jit_scalar_emitter::emit_isa([[maybe_unused]] const std::vector<size_t>& in
     h->vmv_v_x(dst_vreg, tmp_gpr);
 }
 
-}  // namespace ov::intel_cpu::riscv64
+}  // namespace ov::intel_cpu::riscv64

src/plugins/intel_cpu/src/emitters/snippets/riscv64/jit_snippets_emitters.hpp

@@ -29,6 +29,25 @@ class jit_nop_emitter : public jit_emitter {
     void emit_impl(const std::vector<size_t>& in, const std::vector<size_t>& out) const override {}
 };
 
+class jit_broadcast_move_emitter : public jit_emitter {
+public:
+    jit_broadcast_move_emitter(ov::intel_cpu::riscv64::jit_generator_t* h,
+                               ov::intel_cpu::riscv64::cpu_isa_t isa,
+                               const ov::snippets::lowered::ExpressionPtr& expr);
+
+    size_t get_inputs_num() const override {
+        return 1;
+    }
+
+private:
+    void emit_impl(const std::vector<size_t>& in, const std::vector<size_t>& out) const override;
+
+    template <ov::intel_cpu::riscv64::cpu_isa_t isa>
+    void emit_isa(const std::vector<size_t>& in, const std::vector<size_t>& out) const;
+
+    size_t byte_size = 0;
+};
+
 class jit_scalar_emitter : public jit_emitter {
 public:
     jit_scalar_emitter(ov::intel_cpu::riscv64::jit_generator_t* h,
@@ -53,4 +72,4 @@ class jit_scalar_emitter : public jit_emitter {
     int32_t value;
 };
 
-}  // namespace ov::intel_cpu::riscv64
+}  // namespace ov::intel_cpu::riscv64

src/plugins/intel_cpu/src/nodes/executors/riscv64/subgraph.hpp

@@ -45,7 +45,6 @@ class SubgraphStaticExecutor : public SubgraphExecutor, public SubgraphStaticBas
     void exec_impl(const std::vector<MemoryPtr>& inMemPtrs, const std::vector<MemoryPtr>& outMemPtrs) override;
 };
 
-// Dynamic specialized executor is not used on RISCV64 yet, but keep the class for symmetry
 class SubgraphDynamicSpecializedExecutor : public SubgraphExecutor, public SubgraphDynamicSpecializedBaseExecutor {
 public:
     template <typename... Args>

src/plugins/intel_cpu/tests/functional/shared_tests_instances/skip_tests_config.cpp

@@ -474,12 +474,9 @@ const std::vector<std::regex>& disabled_test_patterns() {
             // Quantized models unsupported
             std::regex(R"(.*Quantized.*)"),
             std::regex(R"(smoke_Snippets.*\[.*\?.*\].*)"),
+            std::regex(R"(smoke_Snippets.*IS\[0\]=\[1\.1\.\.10\.1\.\.8\.1\.\.4\].*)"),
             std::regex(R"(smoke_Snippets(?!_(Eltwise|ThreeInputsEltwise)(/|_)).*)"),
             std::regex(R"(.*_enforceSnippets=1.*)"),
-            std::regex(R"(smoke_Snippets_Eltwise.*/Add.*)"),
-            std::regex(R"(smoke_Snippets_Eltwise/TwoInputsAndOutputs.*)"),
-            std::regex(R"(smoke_Snippets_Eltwise_TwoResults.*)"),
-            std::regex(R"(smoke_Snippets_ThreeInputsEltwise.*)"),
 #endif
 #if !defined(OPENVINO_ARCH_X86_64)
             // very time-consuming test