[Op] Extend CPU Plugin with Col2Im reference implementation

src/core/reference/include/openvino/reference/col2im.hpp

@@ -48,10 +48,10 @@ void col2im(const T* data,
             const auto channel_idx = column / kernel_product;
 
             for (int64_t column_height_idx = 0; column_height_idx < original_height; ++column_height_idx) {
-                const int64_t image_height_idx = get_image_dimension_index(column_height_idx, height_offset, 0);
+                const T_idx image_height_idx = get_image_dimension_index(column_height_idx, height_offset, 0);
                 if (image_height_idx >= 0 && image_height_idx < output_size[0]) {
                     for (int64_t column_width_idx = 0; column_width_idx < original_width; ++column_width_idx) {
-                        const int64_t image_width_idx = get_image_dimension_index(column_width_idx, width_offset, 1);
+                        const T_idx image_width_idx = get_image_dimension_index(column_width_idx, width_offset, 1);
                         if (image_width_idx >= 0 && image_width_idx < output_size[1]) {
                             const int64_t img_idx =
                                 ((batch * channel_count + channel_idx) * output_size[0] + image_height_idx) *

src/plugins/intel_cpu/src/cpu_types.cpp

@@ -142,6 +142,7 @@ static const TypeToNameMap& get_type_to_name_tbl() {
         {"NV12toBGR", Type::ColorConvert},
         {"I420toRGB", Type::ColorConvert},
         {"I420toBGR", Type::ColorConvert},
+        {"Col2Im", Type::Col2Im},
         {"MVN", Type::MVN},
         {"NormalizeL2", Type::NormalizeL2},
         {"ScatterUpdate", Type::ScatterUpdate},
@@ -305,6 +306,7 @@ std::string NameFromType(const Type type) {
         CASE(MVN);
         CASE(TensorIterator);
         CASE(Convert);
+        CASE(Col2Im);
         CASE(ColorConvert);
         CASE(NormalizeL2);
         CASE(ScatterUpdate);

src/plugins/intel_cpu/src/cpu_types.h

@@ -61,6 +61,7 @@ enum class Type {
     TensorIterator,
     Convert,
     ColorConvert,
+    Col2Im,
     MVN,
     NormalizeL2,
     ScatterUpdate,

src/plugins/intel_cpu/src/nodes/col2im.cpp

@@ -0,0 +1,124 @@
+// Copyright (C) 2018-2024 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#include "col2im.h"
+#include "common/cpu_convert.h"
+#include "openvino/reference/col2im.hpp"
+#include "openvino/op/col2im.hpp"
+
+namespace ov {
+namespace intel_cpu {
+namespace node {
+Col2Im::Col2Im(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context)
+    : Node(op, context, NgraphShapeInferFactory(op, EMPTY_PORT_MASK)) {
+    const auto col2Im = ov::as_type_ptr<const ov::op::v15::Col2Im>(op);
+    strides = col2Im->get_strides();
+    dilations = col2Im->get_dilations();
+    padsBegin = col2Im->get_pads_begin();
+    padsEnd = col2Im->get_pads_end();
+}
+
+bool Col2Im::isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept {
+    try {
+        const auto col2Im = std::dynamic_pointer_cast<const ov::op::v15::Col2Im>(op);
+        if (!col2Im) {
+            errorMessage = "Only opset15 Col2Im operation is supported";
+            return false;
+        }
+    } catch (...) {
+        return false;
+    }
+    return true;
+}
+
+void Col2Im::getSupportedDescriptors() {
+    // Validation is already done in the ov::opset15::Col2Im.
+}
+
+void Col2Im::initSupportedPrimitiveDescriptors() {
+    if (!supportedPrimitiveDescriptors.empty())
+        return;
+
+    ov::element::Type dataPrecision = getOriginalInputPrecisionAtPort(0);
+    ov::element::Type indexPrecision = getOriginalInputPrecisionAtPort(1);
+    ov::element::Type outputPrecision = getOriginalOutputPrecisionAtPort(0);
+
+    addSupportedPrimDesc(
+        {{LayoutType::ncsp, dataPrecision}, {LayoutType::ncsp, indexPrecision}, {LayoutType::ncsp, indexPrecision}},
+        {{LayoutType::ncsp, outputPrecision}},
+        impl_desc_type::ref);
+}
+
+bool Col2Im::created() const {
+    return getType() == Type::Col2Im;
+}
+
+bool Col2Im::needPrepareParams() const {
+    return false;
+}
+
+void Col2Im::executeDynamicImpl(dnnl::stream strm) {
+    execute(strm);
+}
+
+template <class T, class T_idx>
+void Col2Im::executeImpl() {
+    const auto indexPrecision = getSrcMemoryAtPort(1)->getPrecision();
+    std::vector<T_idx> outputSizeVector(2);
+    cpu_convert(getSrcMemoryAtPort(1)->getData(),
+                outputSizeVector.data(),
+                indexPrecision,
+                ov::element::i64,
+                2);
+
+    std::vector<T_idx> kernelSizeVector(2);
+    cpu_convert(getSrcMemoryAtPort(2)->getData(),
+                kernelSizeVector.data(),
+                indexPrecision,
+                ov::element::i64,
+                2);
+
+    ov::reference::col2im<T, T_idx>(
+        getSrcDataAtPortAs<const T>(0),
+        ov::Shape{getSrcMemoryAtPort(0)->getStaticDims()},
+        outputSizeVector.data(),
+        kernelSizeVector.data(),
+        getDstDataAtPortAs<T>(0),
+        strides,
+        dilations,
+        padsBegin,
+        padsEnd);
+}
+
+namespace {
+struct Col2ImContext {
+    Col2Im &node;
+};
+}
+
+template<typename T>
+struct Col2Im::Col2ImExecute {
+    using TData = typename std::tuple_element<0, T>::type;
+    using TIndex = typename std::tuple_element<1, T>::type;
+
+    void operator()(Col2ImContext & ctx) {
+            ctx.node.executeImpl<TData, TIndex>();
+        }
+};
+void Col2Im::execute(dnnl::stream strm) {
+    auto dataPrecision = getParentEdgeAt(0)->getMemory().getDesc().getPrecision();
+    auto indexPrecision = getParentEdgeAt(1)->getMemory().getDesc().getPrecision();
+
+    Col2ImContext ctx = {
+            *this
+    };
+
+    OV_SWITCH(intel_cpu, Col2ImExecute, ctx, std::tie(dataPrecision, indexPrecision),
+              OV_CASE2(ov::element::f32, ov::element::i32, float, uint64_t),
+              OV_CASE2(ov::element::f16, ov::element::i32, float, uint64_t),
+              OV_CASE2(ov::element::i32, ov::element::i32, uint32_t, uint64_t))
+}
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov

src/plugins/intel_cpu/src/nodes/col2im.h

@@ -0,0 +1,40 @@
+// Copyright (C) 2018-2024 Intel Corporation
+// SPDX-License-Identifier: Apache-2.0
+//
+
+#pragma once
+
+#include "node.h"
+
+namespace ov {
+namespace intel_cpu {
+namespace node {
+
+class Col2Im : public Node {
+public:
+    Col2Im(const std::shared_ptr<ov::Node>& op, const GraphContext::CPtr context);
+
+    static bool isSupportedOperation(const std::shared_ptr<const ov::Node>& op, std::string& errorMessage) noexcept;
+    void getSupportedDescriptors() override;
+    void initSupportedPrimitiveDescriptors() override;
+    void execute(dnnl::stream strm) override;
+    bool created() const override;
+    bool needPrepareParams() const override;
+    void executeDynamicImpl(dnnl::stream strm) override;
+
+private:
+    template <class OV_DATA_TYPE, class OV_INDEX_TYPE>
+    void executeImpl();
+
+    template<typename T>
+    struct Col2ImExecute;
+
+    ov::Strides strides;
+    ov::Strides dilations;
+    ov::Shape padsBegin;
+    ov::Shape padsEnd;
+};
+
+}  // namespace node
+}  // namespace intel_cpu
+}  // namespace ov

src/plugins/intel_cpu/src/nodes_factory.cpp

@@ -7,6 +7,7 @@
 #include "nodes/bin_conv.h"
 #include "nodes/broadcast.h"
 #include "nodes/bucketize.h"
+#include "nodes/col2im.h"
 #include "nodes/color_convert.h"
 #include "nodes/concat.h"
 #include "nodes/conv.h"
@@ -160,6 +161,7 @@ Node::NodesFactory::NodesFactory() : Factory("NodesFactory") {
     INTEL_CPU_NODE(Math, Type::Math);
     INTEL_CPU_NODE(MultiClassNms, Type::MulticlassNms);
     INTEL_CPU_NODE(Convert, Type::Convert);
+    INTEL_CPU_NODE(Col2Im, Type::Col2Im);
     INTEL_CPU_NODE(ColorConvert, Type::ColorConvert);
     INTEL_CPU_NODE(EmbeddingBagOffset, Type::EmbeddingBagOffsetsSum);
     INTEL_CPU_NODE(EmbeddingBagOffset, Type::EmbeddingBagOffsets);