[RISCV64] integrate SHL eltwise add op into OV

[RISCV64] add shlExecutor option for eltwise node

[RISCV64] fix some errors with eltwise executor

[RISCV64] add constructor def and vector initialization for ShlTensor

[RISCV64] remove redundant debug print

[RISCV64] skip failed tests

[RISCV64] change way of invoking kernels

[RISCV64] set shapes for ShlTensor before SHL add

[RISCV64] simplify eltwise kernel invocation

[RISCV64] integrate other eltwise ops

[RISCV64] fix tests for some eltwise and activation ops

[RISCV64] integrate PRelu and LeakyRelu op and fix related tests

[RISCV64] integrate Maximum and Minimum op for the need of some tests

[RISCV64] fix some tests

[RISCV64] fix inaccurate problem with LeakyReLu op

[RISCV64] fix some tests

[RISCV64] enable debugging for riscv64

Author: BHbean

src/plugins/intel_cpu/src/nodes/eltwise.cpp

@@ -2266,7 +2266,7 @@ void Eltwise::initSupportedPrimitiveDescriptors() {
         if (outputPrecision == ov::element::bf16 || hasBF16)
             OPENVINO_THROW("Eltwise node with name `", getName(), "` doesn't support BF16 precision on this target.");
     }
-#if defined(OV_CPU_WITH_ACL)
+#if defined(OV_CPU_WITH_ACL) || defined(OV_CPU_WITH_SHL)
     const bool useJit = false;
 #endif
 #elif defined(OPENVINO_ARCH_ARM64)
@@ -2318,6 +2318,41 @@ void Eltwise::initSupportedPrimitiveDescriptors() {
     outputPrecision = filterPrecision(outputPrecision, forcedPrec);
     } else {
 #endif
+#if defined(OV_CPU_WITH_SHL)
+    auto filterPrecision = [&](const ov::element::Type& prc, const ov::element::Type& forcedPrec) {
+        if (isBitwise(algorithm)) {
+            if (std::find(supportedPrecisions.begin(), supportedPrecisions.end(), prc) == supportedPrecisions.end()) {
+                OPENVINO_THROW("Eltwise node with name `", getName(), "` doesn't support ", prc, " precision.");
+            }
+            return prc;
+        }
+        return forcedPrec;
+    };
+
+    const bool useShl = !useJit;
+    if (useShl) {
+    // Use original output precision as a reference point since some eltwise algorithms have non-float inputs (i.e. EltwiseSelect)
+    ov::element::Type forcedPrec = getOriginalOutputPrecisionAtPort(0) == ov::element::f16 ? ov::element::f16 : ov::element::f32;
+    // SHL implementation supports only identical precisions on inputs/outputs so they are aligned it to highest one
+    if (ShlEltwiseExecutor::isEltwiseAlgorithmSupported(getAlgorithm())) {
+        for (size_t i = 0; i < getParentEdges().size(); i++) {
+            if (!getParentEdgeAt(i)->getParent()->isConstant()) {
+                if (getOriginalInputPrecisionAtPort(i).size() > forcedPrec.size()) {
+                    forcedPrec = getOriginalInputPrecisionAtPort(i);
+                }
+            }
+        }
+        if (!forcedPrec.is_real()) {
+            forcedPrec = ov::element::f32;
+        }
+    }
+
+    for (size_t i = 0; i < inputPrecisions.size(); i++) {
+        inputPrecisions[i] = filterPrecision(inputPrecisions[i], forcedPrec);
+    }
+    outputPrecision = filterPrecision(outputPrecision, forcedPrec);
+    } else {
+#endif
     auto filterPrecision = [&](const ov::element::Type& prc) {
         if (implType == EltwiseImplType::reference) {
             if (isBitwise(algorithm)) {
@@ -2344,7 +2379,7 @@ void Eltwise::initSupportedPrimitiveDescriptors() {
         inputPrecisions[i] = filterPrecision(inputPrecisions[i]);
     }
     outputPrecision = filterPrecision(outputPrecision);
-#if defined(OV_CPU_WITH_ACL)
+#if defined(OV_CPU_WITH_ACL) || defined(OV_CPU_WITH_SHL)
     }
 #endif
 
@@ -2493,7 +2528,7 @@ void Eltwise::initSupportedPrimitiveDescriptors() {
                                                                                      getInputShapeAtPort(i).getRank());
     }
 
-#if defined(OPENVINO_ARCH_ARM64)
+#if defined(OPENVINO_ARCH_ARM64) || defined(OPENVINO_ARCH_RISCV64)
     bool isBlockedApplicable = (!useJit) && one_of(getOutputShapeAtPort(0).getRank(), 1u, 3u, 4u, 5u);
 #else
     bool isBlockedApplicable = one_of(getOutputShapeAtPort(0).getRank(), 1u, 3u, 4u, 5u);
@@ -2512,7 +2547,7 @@ void Eltwise::initSupportedPrimitiveDescriptors() {
     inputNum = getParentEdges().size();
     currentInBlkDims.resize(inputNum);
 
-#if defined (OV_CPU_WITH_ACL)
+#if defined(OV_CPU_WITH_ACL)
     if (useAcl || useJit) {
     eltwiseAttrs = {algorithm, alpha, beta, gamma};
 
@@ -2539,6 +2574,24 @@ void Eltwise::initSupportedPrimitiveDescriptors() {
     }
 #endif
 
+#if defined(OV_CPU_WITH_SHL)
+    if (useShl || useJit) {
+    eltwiseAttrs = {algorithm, alpha, beta, gamma};
+
+    auto addDesc = [&initDesc, &useJit](std::vector<NodeDesc>& supportedPrimitiveDescriptors, const LayoutType layoutType) {
+        auto nodeDesc = initDesc(layoutType, !useJit, useJit);
+        if (nodeDesc.getExecutorFactory())
+            supportedPrimitiveDescriptors.emplace_back(nodeDesc);
+    };
+
+    addDesc(supportedPrimitiveDescriptors, Planar);
+
+    canUseShlExecutor = !supportedPrimitiveDescriptors.empty() && !useJit;
+    if (!supportedPrimitiveDescriptors.empty())
+        return;
+    }
+#endif
+
     if (isChannelsFirstApplicable)
         supportedPrimitiveDescriptors.emplace_back(initDesc(ChannelsFirst));
     if (isBlockedApplicable)
@@ -2570,7 +2623,7 @@ void Eltwise::createPrimitive() {
 }
 
 void Eltwise::prepareParams() {
-    if (canUseAclExecutor) {
+    if (canUseAclExecutor || canUseShlExecutor) {
         std::vector<MemoryDescPtr> srcMemoryDescs;
         for (size_t i = 0; i < getParentEdges().size(); i++) {
             srcMemoryDescs.push_back(getSrcMemoryAtPort(i)->getDescPtr());
@@ -2579,8 +2632,13 @@ void Eltwise::prepareParams() {
         dstMemoryDescs.push_back(getDstMemoryAtPort(0)->getDescPtr());
 
         auto selectedPD = getSelectedPrimitiveDescriptor();
-        aclExecPtr = selectedPD->getExecutorFactoryAs<EltwiseExecutorFactory>()->makeExecutor(eltwiseAttrs, srcMemoryDescs, dstMemoryDescs, {});
-        selectedPD->setImplementationType(aclExecPtr->getImplType());
+        if (canUseAclExecutor) {
+            aclExecPtr = selectedPD->getExecutorFactoryAs<EltwiseExecutorFactory>()->makeExecutor(eltwiseAttrs, srcMemoryDescs, dstMemoryDescs, {});
+            selectedPD->setImplementationType(aclExecPtr->getImplType());
+        } else if (canUseShlExecutor) {
+            shlExecPtr = selectedPD->getExecutorFactoryAs<EltwiseExecutorFactory>()->makeExecutor(eltwiseAttrs, srcMemoryDescs, dstMemoryDescs, {});
+            selectedPD->setImplementationType(shlExecPtr->getImplType());
+        }
 
         return;
     }
@@ -2757,6 +2815,15 @@ void Eltwise::execute(dnnl::stream strm) {
         dstMemory.push_back(getDstMemoryAtPort(0));
 
         aclExecPtr->exec(srcMemory, dstMemory, fqDataPtrs.data());
+    } else if (shlExecPtr) {
+        std::vector<MemoryCPtr> srcMemory;
+        for (size_t i = 0; i < getParentEdges().size(); i++) {
+            srcMemory.push_back(getSrcMemoryAtPort(i));
+        }
+        std::vector<MemoryPtr> dstMemory;
+        dstMemory.push_back(getDstMemoryAtPort(0));
+
+        shlExecPtr->exec(srcMemory, dstMemory, fqDataPtrs.data());
     } else {
         OPENVINO_THROW("Can't execute eltwise node with name: ", getName(), ". Primitive isn't created");
     }

src/plugins/intel_cpu/src/nodes/eltwise.h

@@ -187,8 +187,10 @@ class Eltwise : public Node {
     void appendMemory(const std::vector<float> &data, MemoryPtr &memPtr, std::vector<const void*>& postOpsMem);
 
     bool canUseAclExecutor = false;
+    bool canUseShlExecutor = false;
     EltwiseAttrs eltwiseAttrs;
     std::shared_ptr<EltwiseExecutor> aclExecPtr = nullptr;
+    std::shared_ptr<EltwiseExecutor> shlExecPtr = nullptr;
 };
 
 class eltwise_precision_helper {

src/plugins/intel_cpu/src/nodes/executors/eltwise_list.cpp

@@ -10,6 +10,7 @@ namespace intel_cpu {
 const std::vector<EltwiseExecutorDesc>& getEltwiseExecutorsList() {
     static std::vector<EltwiseExecutorDesc> descs = {
         OV_CPU_INSTANCE_ACL(ExecutorType::Acl, std::make_shared<AclEltwiseExecutorBuilder>())
+        OV_CPU_INSTANCE_SHL(ExecutorType::Shl, std::make_shared<ShlEltwiseExecutorBuilder>())
     };
 
     return descs;

src/plugins/intel_cpu/src/nodes/executors/eltwise_list.hpp

@@ -11,6 +11,9 @@
 #include "aarch64/jit_eltwise.hpp"
 #include "acl/acl_eltwise.hpp"
 #endif
+#if defined(OV_CPU_WITH_SHL)
+#include "shl/shl_eltwise.hpp"
+#endif
 
 #include "onednn/iml_type_mapper.h"
 #include "common/primitive_cache.hpp"

src/plugins/intel_cpu/src/nodes/executors/shl/shl.hpp

@@ -163,6 +163,47 @@ struct ShlTensor : public ShlStructure<csinn_tensor*> {
         OPENVINO_ASSERT(get()->dim_count < MAX_DIM, "Shl supports shapes with rank less or equal to 8");
         for (int i = 0; i < get()->dim_count; ++i)
             get()->dim[i] = static_cast<int32_t>(shape[i]);
+    };
+};
+
+// virtual base class for different kinds of params
+struct IShlParams {
+public:
+    virtual ~IShlParams() = default;
+    virtual void reset(void* t) = 0;
+    virtual void* get(bool allow_empty = false) const = 0;
+    virtual void setAPI(csinn_api_enum api) = 0;
+};
+
+template <typename T, typename traits = ShlStructureTraits<T>>
+struct ShlParams : public ShlStructure<T>, public IShlParams {
+    ShlParams() {
+        T params = static_cast<T>(csinn_alloc_params(sizeof(typename std::remove_pointer<T>::type), nullptr));
+        OPENVINO_ASSERT(params != nullptr, "Failed to create csinn_params");
+        this->reset(params);
+    }
+
+    ShlParams(const ShlSession& session) {
+        T params = static_cast<T>(csinn_alloc_params(sizeof(typename std::remove_pointer<T>::type), session.get()));
+        OPENVINO_ASSERT(params != nullptr, "Failed to create csinn_params");
+        this->reset(params);
+    }
+
+    ShlParams(const ShlSession& session, csinn_api_enum api) : ShlParams(session) {
+        setAPI(api);
+    }
+
+    void reset(void* t) override {
+        this->ShlStructure<T, traits>::reset(static_cast<T>(t));
+    }
+
+    void* get(bool allow_empty = false) const override {
+        return this->ShlStructure<T, traits>::get(allow_empty);
+    }
+
+    void setAPI(csinn_api_enum api) override {
+        auto params = static_cast<typename std::remove_pointer<T>::type*>(this->get());
+        params->base.api = api;
     }
 };
 
@@ -172,18 +213,69 @@ struct ShlStructureTraits<csinn_fc_params*> {
         return csinn_free_params(p);
     }
 };
-struct ShlFCParams : public ShlStructure<csinn_fc_params*> {
-    ShlFCParams() {
-        csinn_fc_params* params = static_cast<csinn_fc_params*>(csinn_alloc_params(sizeof(csinn_fc_params), nullptr));
-        OPENVINO_ASSERT(params != nullptr, "Failed to create csinn_fc_params");
-        reset(params);
+struct ShlFCParams : public ShlParams<csinn_fc_params*> {
+    using ShlParams<csinn_fc_params*>::ShlParams;
+};
+
+template <>
+struct ShlStructureTraits<csinn_diso_params*> {
+    static void destructor(csinn_diso_params* p) {
+        return csinn_free_params(p);
     }
+};
+struct ShlDisoParams : public ShlParams<csinn_diso_params*> {
+    using ShlParams<csinn_diso_params*>::ShlParams;
+};
 
-    ShlFCParams(const ShlSession& session, csinn_api_enum api) {
-        csinn_fc_params* params = static_cast<csinn_fc_params*>(csinn_alloc_params(sizeof(csinn_fc_params), session.get()));
-        OPENVINO_ASSERT(params != nullptr, "Failed to create csinn_fc_params");
-        params->base.api = api;
-        reset(params);
+template <>
+struct ShlStructureTraits<csinn_siso_params*> {
+    static void destructor(csinn_siso_params* p) {
+        return csinn_free_params(p);
+    }
+};
+struct ShlSisoParams : public ShlParams<csinn_siso_params*> {
+    using ShlParams<csinn_siso_params*>::ShlParams;
+};
+
+template <>
+struct ShlStructureTraits<csinn_relu_params*> {
+    static void destructor(csinn_relu_params* p) {
+        return csinn_free_params(p);
+    }
+};
+struct ShlReluParams : public ShlParams<csinn_relu_params*> {
+    using ShlParams<csinn_relu_params*>::ShlParams;
+
+    ShlReluParams(float alpha) : ShlParams<csinn_relu_params*>() {
+        auto params = static_cast<csinn_relu_params*>(this->get());
+        params->n = alpha;
+    }
+
+    ShlReluParams(const ShlSession& session, float alpha) : ShlParams<csinn_relu_params*>(session) {
+        auto params = static_cast<csinn_relu_params*>(this->get());
+        params->n = alpha;
+    }
+
+    ShlReluParams(const ShlSession& session, csinn_api_enum api, float alpha) : ShlParams<csinn_relu_params*>(session, api) {
+        auto params = static_cast<csinn_relu_params*>(this->get());
+        params->n = alpha;
+    }
+};
+
+template <>
+struct ShlStructureTraits<csinn_prelu_params*> {
+    static void destructor(csinn_prelu_params* p) {
+        return csinn_free_params(p);
+    }
+};
+struct ShlPReluParams : public ShlParams<csinn_prelu_params*> {
+    using ShlParams<csinn_prelu_params*>::ShlParams;
+};
+
+template <>
+struct ShlStructureTraits<csinn_conv2d_params*> {
+    static void destructor(csinn_conv2d_params* p) {
+        return csinn_free_params(p);
     }
 };