"Add legacy executor implementation for Interpolate node"

Author: allnes

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

@@ -42,7 +42,7 @@ enum class ExecutorType : uint8_t {
     Kleidiai,
 };
 
-enum class OperationType : uint8_t { FullyConnected, MatMul, Convolution, Eltwise };
+enum class OperationType : uint8_t { FullyConnected, MatMul, Convolution, Eltwise, Interpolate };
 
 std::string ExecutorTypeToString(ExecutorType type);
 ExecutorType ExecutorTypeFromString(const std::string& typeStr);

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

@@ -11,6 +11,7 @@
 #include "nodes/executors/eltwise_config.hpp"
 #include "nodes/executors/executor_implementation.hpp"
 #include "nodes/executors/fullyconnected_config.hpp"
+#include "nodes/executors/interpolate.hpp"
 #include "nodes/executors/matmul_config.hpp"
 
 namespace ov::intel_cpu {
@@ -41,4 +42,8 @@ const std::vector<ExecutorImplementation<EltwiseAttrs>>& getImplementations();
 template <>
 const std::vector<ExecutorImplementation<MatMulAttrs>>& getImplementations();
 
+// Interpolate
+template <>
+const std::vector<ExecutorImplementation<InterpolateAttrs>>& getImplementations();
+
 }  // namespace ov::intel_cpu

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

@@ -25,6 +25,10 @@ static constexpr int MAX_INPUT_INTERPOLATE = 8;
 
 namespace ov::intel_cpu {
 
+namespace node {
+class Interpolate;
+}  // namespace node
+
 enum InterpolateLayoutType : uint8_t { planar, block, by_channel };
 
 enum InterpolateMode : uint8_t { nearest, linear, linear_onnx, cubic, bilinear_pillow, bicubic_pillow };
@@ -63,6 +67,7 @@ struct InterpolateAttrs {
     // 2. axis alignment [1,2] to [2,3].
     // 3. config planar layout support and treated it as channel_first layout.
     bool NCHWAsNHWC = false;
+    node::Interpolate* node = nullptr;
 };
 
 inline VectorDims getPaddedInputShape(const VectorDims& srcDims,

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

@@ -0,0 +1,36 @@
+// Copyright (C) 2018-2025 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include <memory>
+
+#include "nodes/executors/implementation_utils.hpp"
+#include "nodes/executors/implementations.hpp"
+#include "nodes/executors/interpolate.hpp"
+#include "nodes/executors/interpolate_legacy.hpp"
+#include "nodes/interpolate.h"
+#include "openvino/core/except.hpp"
+
+namespace ov::intel_cpu {
+
+template <>
+const std::vector<ExecutorImplementation<InterpolateAttrs>>& getImplementations() {
+    static const std::vector<ExecutorImplementation<InterpolateAttrs>> interpolateImplementations{
+        ExecutorImplementation<InterpolateAttrs>{
+            "interpolate_legacy",
+            ExecutorType::Common,
+            OperationType::Interpolate,
+            SupportsAnyConfig<InterpolateAttrs>{},
+            HasNoOptimalConfig<InterpolateAttrs>{},
+            AcceptsAnyShape<InterpolateAttrs>,
+            [](const InterpolateAttrs& attrs,
+               [[maybe_unused]] const MemoryArgs& memory,
+               const ExecutorContext::CPtr& context) -> ExecutorPtr {
+                OPENVINO_ASSERT(attrs.node, "Interpolate legacy executor requires node");
+                return std::make_shared<InterpolateLegacyExecutor>(attrs.node, context);
+            }}};
+
+    return interpolateImplementations;
+}
+
+}  // namespace ov::intel_cpu

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

@@ -0,0 +1,33 @@
+// Copyright (C) 2018-2025 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include "interpolate_legacy.hpp"
+
+#include "nodes/interpolate.h"
+
+namespace ov::intel_cpu {
+
+InterpolateLegacyExecutor::InterpolateLegacyExecutor(node::Interpolate* node,
+                                                     [[maybe_unused]] ExecutorContext::CPtr context)
+    : m_node(node) {}
+
+bool InterpolateLegacyExecutor::update([[maybe_unused]] const MemoryArgs& memory) {
+    OPENVINO_ASSERT(m_node, "InterpolateLegacyExecutor received null node");
+    if (!m_node->shapesDefined()) {
+        return true;
+    }
+    m_implType = m_node->prepareForLegacyExecutor();
+    return true;
+}
+
+void InterpolateLegacyExecutor::execute([[maybe_unused]] const MemoryArgs& memory) {
+    OPENVINO_ASSERT(m_node, "InterpolateLegacyExecutor received null node");
+    m_node->executeLegacy();
+}
+
+impl_desc_type InterpolateLegacyExecutor::implType() const {
+    return m_implType;
+}
+
+}  // namespace ov::intel_cpu

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

@@ -0,0 +1,28 @@
+// Copyright (C) 2018-2025 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include "nodes/executors/executor.hpp"
+
+namespace ov::intel_cpu {
+
+namespace node {
+class Interpolate;
+}
+
+class InterpolateLegacyExecutor : public Executor {
+public:
+    InterpolateLegacyExecutor(node::Interpolate* node, ExecutorContext::CPtr context);
+
+    bool update(const MemoryArgs& memory) override;
+    void execute(const MemoryArgs& memory) override;
+    impl_desc_type implType() const override;
+
+private:
+    node::Interpolate* m_node = nullptr;
+    impl_desc_type m_implType = impl_desc_type::undef;
+};
+
+}  // namespace ov::intel_cpu

src/plugins/intel_cpu/src/nodes/interpolate.cpp

@@ -1919,6 +1919,7 @@ Interpolate::Interpolate(const std::shared_ptr<ov::Node>& op, const GraphContext
     if (isSupportedOperation(op, errorMessage)) {
         const auto& inputDataShape = getInputShapeAtPort(DATA_ID);
         dataRank = inputDataShape.getRank();
+        interpAttrs.node = this;
         if (const auto interp = ov::as_type_ptr<const ov::op::v4::Interpolate>(op)) {
             is_version11 = false;
             const auto numInputs = inputShapes.size();
@@ -2207,14 +2208,24 @@ void Interpolate::initSupportedPrimitiveDescriptors() {
 
     NodeConfig config;
     config.outConfs.resize(1);
+    m_atoi.clear();
+    m_atoi[ARG_SRC] = DATA_ID;
+
     if (is_version11) {
+        m_atoi[ARG_SRC_1] = SIZE_OR_SCALE_ID_V11;
+        if (isAxesSpecified) {
+            m_atoi[ARG_SRC_2] = AXES_ID_V11;
+        }
         if (isAxesSpecified) {
             config.inConfs.resize(3);
         } else {
             config.inConfs.resize(2);
         }
     } else {
+        m_atoi[ARG_SRC_1] = TARGET_SHAPE_ID;
+        m_atoi[ARG_SRC_2] = get_scale_id();
         if (isAxesSpecified) {
+            m_atoi[ARG_SRC_3] = get_axis_id();
             config.inConfs.resize(4);
         } else {
             config.inConfs.resize(3);
@@ -2441,8 +2452,16 @@ inline int Interpolate::get_axis_id() const {
     return AXES_ID;
 }
 
-void Interpolate::prepareParams() {
-    CPU_NODE_ASSERT(shapesDefined(), "input/output dims aren't defined");
+ExecutorFactoryPtr<InterpolateAttrs> Interpolate::createExecutorFactory(const MemoryDescArgs& descs,
+                                                                        const InterpolateAttrs& attrs) {
+    auto executionContext = std::make_shared<ExecutorContext>(context, getImplPriority());
+    return std::make_shared<ExecutorFactory<InterpolateAttrs>>(attrs, executionContext, descs);
+}
+
+impl_desc_type Interpolate::prepareForLegacyExecutor() {
+    if (!shapesDefined()) {
+        return impl_desc_type::undef;
+    }
 
     auto dstMemPtr = getDstMemoryAtPort(0);
     CPU_NODE_ASSERT(dstMemPtr && dstMemPtr->isDefined(), "has undefined destination memory");
@@ -2466,6 +2485,10 @@ void Interpolate::prepareParams() {
     const NodeDesc* selected_pd = getSelectedPrimitiveDescriptor();
     CPU_NODE_ASSERT(selected_pd, "did not set preferable primitive descriptor");
 
+    impl_desc_type implType = selected_pd->getImplementationType();
+
+    aclExecPtr.reset();
+
     const auto& srcDimsOrign = srcMemPtr->getStaticDims();
     const auto& dstDimsOrign = dstMemPtr->getStaticDims();
 
@@ -2546,9 +2569,11 @@ void Interpolate::prepareParams() {
                                                                                                   srcMemoryDescs,
                                                                                                   dstMemoryDescs,
                                                                                                   {});
-        selectedPD->setImplementationType(aclExecPtr->getImplType());
+        OPENVINO_ASSERT(aclExecPtr, "ACL Interpolate executor creation failed");
+        implType = aclExecPtr->getImplType();
+        selectedPD->setImplementationType(implType);
 
-        return;
+        return implType;
     }
 
     InterpolateKey key = {interpAttrs, src5DDims, dst5DDims, scales5D, dnnl::primitive_attr()};
@@ -2585,6 +2610,22 @@ void Interpolate::prepareParams() {
     execPtr = result.first;
 
     lastOutputDims = dstDimsOrign;
+
+    return implType;
+}
+
+void Interpolate::prepareParams() {
+    if (!m_executor) {
+        return;
+    }
+
+    for (const auto& entry : m_atoi) {
+        m_memory[entry.first] = getSrcMemoryAtPort(entry.second);
+    }
+    m_memory[ARG_DST] = getDstMemoryAtPort(0);
+
+    m_executor->update(m_memory);
+    getSelectedPrimitiveDescriptor()->setImplementationType(m_executor->implType());
 }
 
 void Interpolate::createPrimitive() {
@@ -2605,6 +2646,35 @@ void Interpolate::createPrimitive() {
     interpAttrs.inPrc = srcMemPtr->getDesc().getPrecision();
     interpAttrs.outPrc = dstMemPtr->getDesc().getPrecision();
 
+    const auto* selected_pd = getSelectedPrimitiveDescriptor();
+    CPU_NODE_ASSERT(selected_pd, "did not set preferable primitive descriptor");
+
+    const auto& config = selected_pd->getConfig();
+
+    MemoryDescArgs descs;
+    for (const auto& entry : m_atoi) {
+        const int argId = entry.first;
+        const int inputIdx = entry.second;
+        descs[argId] = config.inConfs.at(inputIdx).getMemDesc();
+    }
+    descs[ARG_DST] = config.outConfs[0].getMemDesc();
+
+    m_memory.clear();
+    for (const auto& entry : m_atoi) {
+        const int argId = entry.first;
+        const int inputIdx = entry.second;
+        m_memory[argId] = getSrcMemoryAtPort(inputIdx);
+    }
+    m_memory[ARG_DST] = getDstMemoryAtPort(0);
+
+    auto attrs = interpAttrs;
+    attrs.node = this;
+
+    m_factory = createExecutorFactory(descs, attrs);
+    m_executor = m_factory->make(m_memory, false);
+
+    Node::createPrimitive();
+
     if (shapesDefined() && isExecutable()) {
         if (needPrepareParams()) {
             prepareParams();
@@ -2685,6 +2755,14 @@ std::vector<float> Interpolate::getScales(const VectorDims& srcDimPad, const Vec
 }
 
 void Interpolate::execute([[maybe_unused]] const dnnl::stream& strm) {
+    if (!m_executor) {
+        return;
+    }
+
+    m_executor->execute(m_memory);
+}
+
+void Interpolate::executeLegacy() {
     auto dstMemPtr = getDstMemoryAtPort(0);
     auto srcMemPtr = getSrcMemoryAtPort(DATA_ID);
 

src/plugins/intel_cpu/src/nodes/interpolate.h

@@ -12,14 +12,21 @@
 #include <oneapi/dnnl/dnnl.hpp>
 #include <oneapi/dnnl/dnnl_common.hpp>
 #include <string>
+#include <unordered_map>
 
 #include "cpu_types.h"
 #include "executors/interpolate.hpp"
 #include "graph_context.h"
 #include "node.h"
+#include "nodes/executors/executor_factory.hpp"
+#include "nodes/executors/memory_arguments.hpp"
 #include "openvino/core/node.hpp"
 #include "openvino/core/type/element_type.hpp"
 
+namespace ov::intel_cpu {
+class InterpolateLegacyExecutor;
+}
+
 namespace ov::intel_cpu::node {
 
 struct jit_interpolate_config_params {
@@ -103,6 +110,8 @@ class Interpolate : public Node {
     inline int get_axis_id() const;
 
 private:
+    friend class ov::intel_cpu::InterpolateLegacyExecutor;
+
     bool is_version11 = true;
     InterpolateAttrs interpAttrs;
     size_t dataRank = 0;
@@ -351,6 +360,16 @@ class Interpolate : public Node {
 
     bool canUseAclExecutor = false;
     std::shared_ptr<InterpolateExecutor> aclExecPtr = nullptr;
+
+    ExecutorFactoryPtr<InterpolateAttrs> createExecutorFactory(const MemoryDescArgs& descs,
+                                                               const InterpolateAttrs& attrs);
+    impl_desc_type prepareForLegacyExecutor();
+    void executeLegacy();
+
+    ExecutorFactoryPtr<InterpolateAttrs> m_factory;
+    ExecutorPtr m_executor;
+    MemoryArgs m_memory;
+    std::unordered_map<int, int> m_atoi;
 };
 
 }  // namespace ov::intel_cpu::node