[GPU] Reinterpret from 1 dim mem to 0 dim mem instead of allocating 0 bytes layout to OpenCL

Author: kelvinchoi-intel

src/plugins/intel_gpu/include/intel_gpu/plugin/common_utils.hpp

@@ -6,6 +6,7 @@
 
 #include <ostream>
 #include <tuple>
+#include "intel_gpu/runtime/engine.hpp"
 #include "intel_gpu/runtime/layout.hpp"
 #include "intel_gpu/runtime/memory.hpp"
 #include "intel_gpu/runtime/optionals.hpp"
@@ -111,6 +112,21 @@ inline ov::Shape predict_shape(const std::string& name, const cldnn::layout layo
     return layout.get_shape();
 }
 
+inline cldnn::memory::ptr allocate_memory_evenif_zero_bytes(cldnn::engine& _engine, const cldnn::layout& layout, cldnn::allocation_type type, bool reset = true) {
+    if (layout.bytes_count() == 0) {
+        auto non_zero_layout = cldnn::layout({1}, layout.data_type, layout.format);
+        auto res = _engine.allocate_memory(non_zero_layout, type, reset);
+        return _engine.reinterpret_buffer(*res, layout);
+    } else {
+        return _engine.allocate_memory(layout, type, reset);
+    }
+}
+
+inline cldnn::memory::ptr allocate_memory_evenif_zero_bytes(cldnn::engine& _engine, const cldnn::layout& layout, bool reset = true) {
+    cldnn::allocation_type type = _engine.get_lockable_preferred_memory_allocation_type(layout.format.is_image_2d());
+    return allocate_memory_evenif_zero_bytes(_engine, layout, type, reset);
+}
+
 /// WA: Force exit. Any opencl api call can be hang after CL_OUT_OF_RESOURCES.
 inline void ForceExit() {
     std::cerr << "[GPU] force exit.\n"

src/plugins/intel_gpu/src/graph/loop.cpp

@@ -7,6 +7,7 @@
 #include "mutable_data_inst.h"
 #include "json_object.h"
 #include "primitive_type_base.h"
+#include "intel_gpu/plugin/common_utils.hpp"
 #include "intel_gpu/primitives/data.hpp"
 #include "intel_gpu/primitives/mutable_data.hpp"
 #include "intel_gpu/runtime/error_handler.hpp"
@@ -319,7 +320,7 @@ void loop_inst::update_backedge_mapped_memory() {
                             // generally, shouldn't go this way, but...
                             auto output_prim = body_network->get_primitive(back_edge.from);
                             layout output_layout = output_prim->output_memory().get_layout();
-                            backedge_mem = body_network->get_engine().allocate_memory(output_layout, 0);
+                            backedge_mem = ov::intel_gpu::allocate_memory_evenif_zero_bytes(body_network->get_engine(), output_layout, false);
                         }
                     } else {
                         auto external_id = output_mapping.front()->external_id;
@@ -397,7 +398,7 @@ loop_inst::concatenated_memory_mapping::ptr loop_inst::create_concat_memory_map(
                             << sliced_layout.get_partial_shape().to_string()
                             << " to " << updated_sliced_layout.to_string() << std::endl;
             sliced_layout.set_partial_shape(updated_sliced_layout);
-            inter_mem_ptr = engine.allocate_memory(sliced_layout);
+            inter_mem_ptr = ov::intel_gpu::allocate_memory_evenif_zero_bytes(engine, sliced_layout);
             intern_prim->set_output_layout(sliced_layout, internal_id.idx);
         }
 
@@ -408,7 +409,7 @@ loop_inst::concatenated_memory_mapping::ptr loop_inst::create_concat_memory_map(
             sliced_mems.reserve(num_iterations);
             sliced_mems.push_back(inter_mem_ptr);
             for (int j=1; j < num_iterations; ++j) {
-                memory::ptr sliced_mem = engine.allocate_memory(sliced_layout);
+                memory::ptr sliced_mem = ov::intel_gpu::allocate_memory_evenif_zero_bytes(engine, sliced_layout);
                 sliced_mems.push_back(sliced_mem);
             }
         }
@@ -500,7 +501,7 @@ void loop_inst::preprocess_input_memory(const int64_t num_iterations) {
                 // if internal input memory is in backedge, allocate new memory.
                 // Because internal input memory's data will be updated through backedge process.
                 if (iter != _back_edges.end()) {
-                    internal_input_memory = body_network->get_engine().allocate_memory(memory->get_layout(), false);
+                    internal_input_memory = ov::intel_gpu::allocate_memory_evenif_zero_bytes(body_network->get_engine(), memory->get_layout(), false);
                     internal_input_memory->copy_from(body_network->get_stream(), *memory);
                     GPU_DEBUG_LOG << "Input memory of internal node(" << internal_id.to_string() << ") is set to new memory("
                                     << internal_input_memory << ", " << internal_input_memory->get_layout().to_short_string()
@@ -722,7 +723,7 @@ void loop_inst::postprocess_output_memory(bool is_dynamic, int64_t current_itera
             } else {
                 if (!output_allocated || shape_changed()) {
                     auto concat_layout = _impl_params->get_output_layout(external_id.idx);
-                    auto concat_mem = _network.get_engine().allocate_memory(concat_layout, false);
+                    auto concat_mem = ov::intel_gpu::allocate_memory_evenif_zero_bytes(_network.get_engine(), concat_layout, false);
                     external_outputs[external_id.idx] = concat_mem;
                     auto iter = std::find_if(concatenated_output_mem_mappings.begin(),
                                                 concatenated_output_mem_mappings.end(),
@@ -1080,7 +1081,7 @@ std::vector<event::ptr> loop_inst::handle_buffers_for_next_iteration(const loop_
                 auto to_id = mapping.to_primitive->id();
                 // Check backedge_to shape needs to be updated by initial_mem
                 if (mapping.initial_mem != nullptr && !mapping.initial_mem->get_layout().identical(to_mem->get_layout())) {
-                    to_mem = body_network->get_engine().allocate_memory(mapping.initial_mem->get_layout(), false);
+                    to_mem = ov::intel_gpu::allocate_memory_evenif_zero_bytes(body_network->get_engine(), mapping.initial_mem->get_layout(), false);
                     body_network->set_input_data(to_id, to_mem);
                     ev = to_mem->copy_from(body_network->get_stream(), *(mapping.initial_mem));
                     GPU_DEBUG_LOG << iter << ") [SINGLE] Backedge_to node(" << to_id << ") is set to new memory("
@@ -1102,7 +1103,7 @@ std::vector<event::ptr> loop_inst::handle_buffers_for_next_iteration(const loop_
 
                 // Check backedge_to shape needs to be updated by backedge_from
                 if (!from_mem->get_layout().identical(to_mem->get_layout())) {
-                    to_mem = body_network->get_engine().allocate_memory(from_mem->get_layout(), false);
+                    to_mem = ov::intel_gpu::allocate_memory_evenif_zero_bytes(body_network->get_engine(), from_mem->get_layout(), false);
                     GPU_DEBUG_LOG << iter << ") [SINGLE] Backedge_to node(" << to_id << ") is set to new memory("
                                     << to_mem << ", " << to_mem->get_layout().to_short_string()
                                     << ") because of shape update from backedge_from()" << from_id

src/plugins/intel_gpu/src/graph/primitive_inst.cpp

@@ -1959,11 +1959,11 @@ memory::ptr primitive_inst::allocate_output(engine& _engine,
             if ((_node.is_output() && is_reorder_weights) || (!_node.is_output() && _node.is_type<input_layout>()))
                 reset = false;
             GPU_DEBUG_LOG << "[" << _node.id() << ": constant]" << std::endl;
-            return _engine.allocate_memory(layout, alloc_type, reset);
+            return ov::intel_gpu::allocate_memory_evenif_zero_bytes(_engine, layout, alloc_type, reset);
         }
     } else if (!_node.can_share_buffer() || _node.can_be_optimized() || _node.is_output()) {
         GPU_DEBUG_LOG << "[" << _node.id() << ": output]" << std::endl;
-        return _engine.allocate_memory(layout, alloc_type, reset);
+        return ov::intel_gpu::allocate_memory_evenif_zero_bytes(_engine, layout, alloc_type, reset);
     } else {
         return get_memory_from_pool(_engine,
                                     net_id,

src/plugins/intel_gpu/tests/unit/test_cases/loop_gpu_test.cpp

@@ -7,6 +7,7 @@
 #include <intel_gpu/runtime/memory.hpp>
 #include <intel_gpu/runtime/engine.hpp>
 #include <intel_gpu/graph/network.hpp>
+#include "intel_gpu/plugin/common_utils.hpp"
 #include <intel_gpu/primitives/input_layout.hpp>
 #include "intel_gpu/primitives/eltwise.hpp"
 #include <intel_gpu/primitives/data.hpp>
@@ -1212,3 +1213,108 @@ TEST(loop_gpu, support_loop_w_dynamic_input_update_primitive_id) {
         std::vector<float>(),
         2, 3);
 }
+
+template <typename T>
+void test_loop_gpu_zero_bytes_layout(bool is_caching_test)
+{
+    auto& engine = get_test_engine();
+
+    // shape for zero bytes layout
+    auto trip_count_mem = ov::intel_gpu::allocate_memory_evenif_zero_bytes(engine, { cldnn::layout{ ov::PartialShape({0}), data_types::i32, format::bfyx } });
+
+    auto input_mem = engine.allocate_memory({ data_types::f32, format::bfyx, { 1, 1, 4, 5 } });
+    auto operand_mem = engine.allocate_memory({ data_types::f32, format::bfyx, { 1, 1, 4, 5 } });
+    auto initial_condition_mem = engine.allocate_memory({ data_types::i32, format::bfyx, { 1, 1, 1, 1 } });
+    auto num_iteration_mem = engine.allocate_memory({ data_types::i32, format::bfyx, { 1, 1, 1, 1 } });
+
+    std::vector<T> input_data{
+        1.0f,  2.0f, -15.f,  3.0f, 4.0f, -15.f, 5.0f,  6.0f, -15.f, 7.0f,
+        -15.f, 0.0f,  0.0f, -15.f, 0.5f, -0.5f, -15.f, 8.0f,  1.5f,  5.2f
+    };
+    std::vector<T> eltwise_operand {
+        1.f, -2.f, 3.f, -4.f, 3.0f, -2.0f, 1.f, -2.f, 3.0f, -4.0f,
+        3.f, -2.f, 1.f, -2.f, 3.5f, -4.5f, 5.f, -4.f, 3.5f, -2.2f
+    };
+    int trip_count = 8;
+    int initial_condition = 1;
+
+    // initialize input buffers
+    set_values(input_mem, input_data);
+    set_values(operand_mem, eltwise_operand);
+    set_values(trip_count_mem, { trip_count });
+    set_values(initial_condition_mem, {initial_condition});
+
+    topology body(
+        input_layout("input", input_mem->get_layout()),
+        data("eltwise_operand", operand_mem),
+        eltwise("eltwise", input_info("input"), input_info("eltwise_operand"), eltwise_mode::sum)
+    );
+
+    std::vector<loop::io_primitive_map> input_primitive_maps { loop::io_primitive_map("input", "input") };
+    std::vector<loop::io_primitive_map> output_primitive_maps { loop::io_primitive_map("loop", "eltwise") };
+    std::vector<loop::backedge_mapping> back_edges { loop::backedge_mapping("eltwise", "input") };
+
+    auto body_program = build_program(engine, body, "", output_primitive_maps, back_edges);
+
+    topology topology(
+        input_layout("input", input_mem->get_layout()),
+        input_layout("trip_count", trip_count_mem->get_layout()),
+        input_layout("initial_condition", initial_condition_mem->get_layout()),
+        mutable_data("num_iteration", num_iteration_mem),
+        loop("loop", { input_info("num_iteration"), input_info("trip_count"), input_info("initial_condition"), input_info("input") }, body_program,
+             "trip_count", "initial_condition", "num_iteration",
+             input_primitive_maps, output_primitive_maps, back_edges, 8)
+    );
+
+    cldnn::network::ptr network = get_network(engine, topology, get_test_default_config(engine), get_test_stream_ptr(), is_caching_test);
+
+    network->set_input_data("input", input_mem);
+    network->set_input_data("trip_count", trip_count_mem);
+    network->set_input_data("initial_condition", initial_condition_mem);
+
+    auto outputs = network->execute();
+    ASSERT_EQ(outputs.size(), 1);
+    auto output = outputs.begin()->second.get_memory();
+    auto output_layout = output->get_layout();
+
+    ASSERT_EQ(output_layout.batch(), 1);
+    ASSERT_EQ(output_layout.feature(), 1);
+    ASSERT_EQ(output_layout.spatial(0), 4);
+    ASSERT_EQ(output_layout.spatial(1), 5);
+
+    // value check
+    {
+        mem_lock<T> output_ptr{ output, get_test_stream() };
+        ASSERT_EQ(output_ptr.size(), input_data.size());
+        for (size_t i = 0, iend = input_data.size(); i < iend; ++i) {
+            ASSERT_FLOAT_EQ(output_ptr[i], input_data[i] + eltwise_operand[i] * trip_count);
+        }
+    }
+
+    // allocate new output memory
+    layout loop_l = network->get_output_memory("loop")->get_layout();
+    auto output_mem = engine.allocate_memory(loop_l);
+    network->set_output_memory("loop", output_mem);
+
+    //one more execute
+    set_values(input_mem, input_data);
+    set_values(operand_mem, eltwise_operand);
+    set_values(trip_count_mem, { trip_count });
+    set_values(initial_condition_mem, { initial_condition });
+    outputs = network->execute();
+
+    // check everything once again
+    ASSERT_EQ(outputs.size(), 1);
+    auto output2 = outputs.begin()->second.get_memory();
+    {
+        mem_lock<T> output_ptr2{ output2, get_test_stream() };
+        ASSERT_EQ(output_ptr2.size(), input_data.size());
+        for (size_t i = 0, iend = input_data.size(); i < iend; ++i) {
+            ASSERT_FLOAT_EQ(output_ptr2[i], input_data[i] + eltwise_operand[i] * trip_count);
+        }
+    }
+}
+
+TEST(loop_gpu, zero_bytes_layout) {
+    test_loop_gpu_zero_bytes_layout<float>(false);
+}