[CPU][ARM] Add support for AArch64 JIT-based 3D Deconvolution and Convolution

src/plugins/intel_cpu/src/nodes/deconv.cpp

@@ -39,6 +39,10 @@
 #include "nodes/common/blocked_desc_creator.h"
 #include "nodes/common/dnnl_executor.h"
 #include "nodes/executors/deconv_list.hpp"
+#include "utils/arch_macros.h"
+#if defined(OPENVINO_ARCH_ARM64)
+#    include "nodes/executors/aarch64/jit_deconv3d.hpp"
+#endif
 #include "nodes/executors/executor.hpp"
 #include "nodes/node_config.h"
 #include "onednn/dnnl.h"
@@ -634,8 +638,8 @@ void Deconvolution::getSupportedDescriptors() {
 
         return AclDeconvExecutorBuilder::customIsSupported(deconvAttrs, srcMemoryDescs, dstMemoryDescs);
     };
-    useACL = checkDesc(LayoutType::nspc) || checkDesc(LayoutType::ncsp);
-    if (useACL) {
+
+    if (checkDesc(LayoutType::nspc) || checkDesc(LayoutType::ncsp)) {
         return;
     }
 #endif
@@ -788,22 +792,18 @@ VectorDims Deconvolution::shapeInferInternal(const VectorDims& inDims, std::vect
 }
 
 void Deconvolution::execute(const dnnl::stream& strm) {
-    if (useACL) {
+    if (execPtrFactory) {
         std::vector<MemoryCPtr> srcMemory;
-        for (size_t i = 0; i < getOriginalInputsNumber(); i++) {
+        for (size_t i = 0; i < getOriginalInputsNumber(); i++)
             srcMemory.push_back(getSrcMemoryAtPort(i));
-        }
         std::vector<MemoryPtr> dstMemory;
-        for (size_t i = 0; i < getOriginalOutputsNumber(); i++) {
+        for (size_t i = 0; i < getOriginalOutputsNumber(); i++)
             dstMemory.push_back(getDstMemoryAtPort(i));
-        }
-        // TODO: need to pass post ops data
-        execPtrDeconvACL->exec(srcMemory, dstMemory, nullptr);
+        execPtrFactory->exec(srcMemory, dstMemory, nullptr);
         return;
     }
 
     CPU_NODE_ASSERT(execPtr, "executor is not compiled");
-
     execPtr->exec(primArgs, strm);
 
     if (externOutShape) {
@@ -965,7 +965,9 @@ void Deconvolution::prepareParams() {
     auto* selected_pd = getSelectedPrimitiveDescriptor();
     CPU_NODE_ASSERT(selected_pd, "Preferable primitive descriptor is not set.");
 
-    if (useACL) {
+    // Minimal integration: always try factory path (ACL/JIT) with early-packing ctor;
+    // fall back to oneDNN path if factory does not provide an executor.
+    {
         if (isDynamicNode()) {
             initPaddingR(getParentEdgeAt(0)->getMemory().getDescPtr()->getShape(),
                          getChildEdgeAt(0)->getMemory().getDescPtr()->getShape());
@@ -979,12 +981,24 @@ void Deconvolution::prepareParams() {
             dstMemoryDescs.push_back(getChildEdgeAt(i)->getMemory().getDescWithType<DnnlMemoryDesc>());
         }
 
-        execPtrDeconvACL = selected_pd->getExecutorFactoryAs<DeconvExecutorFactory>()->makeExecutor(deconvAttrs,
-                                                                                                    srcMemoryDescs,
-                                                                                                    dstMemoryDescs,
-                                                                                                    *attr);
-        selected_pd->setImplementationType(execPtrDeconvACL->getImplType());
-        return;
+        std::vector<MemoryCPtr> srcMemoriesEarly;
+        for (size_t i = 0; i < getOriginalInputsNumber(); i++) {
+            srcMemoriesEarly.push_back(getSrcMemoryAtPort(i));
+        }
+
+        try {
+            auto factory = selected_pd->getExecutorFactoryAs<DeconvExecutorFactory>();
+            if (factory) {
+                auto exec = factory->makeExecutorWithMem(deconvAttrs, srcMemoryDescs, dstMemoryDescs, *attr, srcMemoriesEarly);
+                if (exec) {
+                    execPtrFactory = exec;
+                    selected_pd->setImplementationType(execPtrFactory->getImplType());
+                    return;
+                }
+            }
+        } catch (...) {
+            // Fallback to oneDNN path when factory isn't applicable
+        }
     }
     auto inMemoryDesc = getParentEdgeAt(0)->getMemory().getDescWithType<DnnlMemoryDesc>();
     auto outMemoryDesc = getChildEdgeAt(0)->getMemory().getDescWithType<DnnlMemoryDesc>();
@@ -1296,10 +1310,66 @@ bool Deconvolution::canFuseBias() const {
 }
 
 void Deconvolution::initSupportedPrimitiveDescriptors() {
-    if (!useACL) {
-        Node::initSupportedPrimitiveDescriptors();
-        return;
+    // Prefer AArch64 JIT deconv for 5D FP16/FP32 on ARM64 regardless of ACL
+#if defined(OPENVINO_ARCH_ARM64)
+    {
+        const auto rank = getInputShapeAtPort(0).getRank();
+        const bool is5D = (rank == 5);
+        const bool fp16_ok = getOriginalInputPrecisionAtPort(0) == ov::element::f16 &&
+                             getOriginalInputPrecisionAtPort(1) == ov::element::f16 &&
+                             getOriginalOutputPrecisionAtPort(0) == ov::element::f16;
+        const bool fp32_ok = getOriginalInputPrecisionAtPort(0) == ov::element::f32 &&
+                             getOriginalInputPrecisionAtPort(1) == ov::element::f32 &&
+                             getOriginalOutputPrecisionAtPort(0) == ov::element::f32;
+        if (is5D && (fp16_ok || fp32_ok)) {
+            auto [inDims, outDims] = makeDummyInOutShape();
+            auto tmpInShape = Shape(inDims);
+            auto tmpOutShape = Shape(outDims);
+            initPaddingR(tmpInShape, tmpOutShape);
+
+            const auto& creatorsMap = BlockedDescCreator::getCommonCreators();
+            NodeConfig config;
+            config.inConfs.resize(getParentEdges().size());
+            config.outConfs.resize(getOriginalOutputsNumber());
+
+            auto setDesc = [&](size_t port, bool isInput) {
+                const auto prec =
+                    isInput ? getOriginalInputPrecisionAtPort(port) : getOriginalOutputPrecisionAtPort(port);
+                const auto& shp = isInput ? getInputShapeAtPort(port) : getOutputShapeAtPort(port);
+                auto d = creatorsMap.at(LayoutType::ncsp)->createSharedDesc(prec, shp);
+                if (isInput)
+                    config.inConfs[port].setMemDesc(d);
+                else
+                    config.outConfs[port].setMemDesc(d);
+            };
+            setDesc(0, true);
+            setDesc(1, true);
+            for (size_t i = 2; i < getParentEdges().size(); ++i)
+                setDesc(i, true);
+            setDesc(0, false);
+
+            std::vector<MemoryDescPtr> srcMemoryDescs;
+            srcMemoryDescs.push_back(config.inConfs[0].getMemDesc()->cloneWithNewDims(tmpInShape.getDims()));
+            for (size_t i = 1; i < config.inConfs.size(); i++)
+                srcMemoryDescs.push_back(config.inConfs[i].getMemDesc()->clone());
+            std::vector<MemoryDescPtr> dstMemoryDescs;
+            dstMemoryDescs.push_back(config.outConfs[0].getMemDesc()->cloneWithNewDims(tmpOutShape.getDims()));
+            for (size_t i = 1; i < config.outConfs.size(); i++)
+                dstMemoryDescs.push_back(config.outConfs[i].getMemDesc()->clone());
+
+            auto factory =
+                std::make_shared<DeconvExecutorFactory>(deconvAttrs,
+                                                        srcMemoryDescs,
+                                                        dstMemoryDescs,
+                                                        std::make_shared<ExecutorContext>(context, getImplPriority()));
+            supportedPrimitiveDescriptors.emplace_back(config, impl_desc_type::jit_asimd, factory);
+            return;
+        }
     }
+#endif
+
+    Node::initSupportedPrimitiveDescriptors();
+    return;
 
     auto [inDims, outDims] = makeDummyInOutShape();
     auto tmpInShape = Shape(inDims);

src/plugins/intel_cpu/src/nodes/deconv.h

@@ -73,7 +73,8 @@ class Deconvolution : public Node {
     AttrPtr initPrimitiveAttr() override;
     AttrPtr makePrimitiveAttr(const VectorDims& dims);
     std::vector<dnnl::memory::format_tag> getAvailableFormatsForDims(const Shape& dims) const override;
-    std::shared_ptr<DeconvExecutor> execPtrDeconvACL = nullptr;
+    // Factory-based executor (JIT/ACL), created via DeconvExecutorFactory
+    std::shared_ptr<DeconvExecutor> execPtrFactory = nullptr;
 
 private:
     using executorPtr = std::shared_ptr<DnnlExecutorLegacy>;
@@ -101,7 +102,6 @@ class Deconvolution : public Node {
     VectorDims dnnlCompatibleWeiDims;
     VectorDims expectedBiasDims;
 
-    bool useACL = false;
     DeconvAttrs deconvAttrs;
 
     Shape inShape, outShape;