[GPU] Use usm_device for output buffer for BMG (#28865)

### Details:
- (refer to GSD-10054) Not to use usm_host for large output buffer in
BMG
 - Perf check done 
 - After this PR, MiniCPM 2.6V first token latency reduced to 1/2

### Tickets:
 - CVS-161158

Author: yeonbok

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

@@ -10,6 +10,8 @@
 #include "intel_gpu/runtime/memory.hpp"
 
 #include "intel_gpu/runtime/shape_predictor.hpp"
+#include "intel_gpu/runtime/engine.hpp"
+#include "intel_gpu/runtime/device_info.hpp"
 #include "openvino/core/layout.hpp"
 #include "openvino/core/node.hpp"
 #include "openvino/core/type/element_type.hpp"
@@ -31,6 +33,28 @@ enum class TensorType {
 
 #define TensorValue(val) static_cast<cldnn::tensor::value_type>(val)
 
+inline bool can_use_usm_host(cldnn::engine& engine, const uint64_t total_output_bytes) {
+    GPU_DEBUG_GET_INSTANCE(debug_config);
+    GPU_DEBUG_IF(debug_config->use_usm_host == 1) { return true; }
+    GPU_DEBUG_IF(debug_config->use_usm_host == 2) { return false; }
+
+    auto can_use_usm = engine.use_unified_shared_memory();
+    // When output size is large, it is better not to write to usm_host directly
+    const uint64_t LARGE_OUTPUT_BYTES_THRESHOLD = 4 * 1048576;
+
+    const auto& device_info = engine.get_device_info();
+    if ((device_info.gfx_ver.major == 12 && device_info.gfx_ver.minor == 60) ||
+        (device_info.gfx_ver.major >= 20 && device_info.dev_type == cldnn::device_type::discrete_gpu) ||
+        (device_info.dev_type == cldnn::device_type::discrete_gpu && total_output_bytes > LARGE_OUTPUT_BYTES_THRESHOLD)) {
+        // WA: Disable USM host memory for infer request`s tensors for PVC and subsequent dGPUs, as kernel access
+        // to system memory is slower than using an explicit memcpy (Host <-> Device) call with the copy engine
+        // Driver tickets with additional details: 6155, 10054
+        GPU_DEBUG_TRACE << "Do not use usm_host for performance issue" << std::endl;
+        can_use_usm = false;
+    }
+
+    return can_use_usm;
+}
 inline cldnn::tensor tensor_from_dims(const ov::Shape& dims, int def = 1) {
     switch (dims.size()) {
     case 0: return cldnn::tensor(cldnn::batch(def), cldnn::feature(def), cldnn::spatial(def, def));

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

@@ -46,6 +46,7 @@
 
 #include "intel_gpu/plugin/common_utils.hpp"
 #include "intel_gpu/plugin/multi_tensor_variable_state.hpp"
+#include "intel_gpu/plugin/sync_infer_request.hpp"
 #include "intel_gpu/graph/network.hpp"
 #include "intel_gpu/graph/serialization/set_serializer.hpp"
 #include "intel_gpu/runtime/engine.hpp"
@@ -2376,10 +2377,11 @@ memory::ptr primitive_inst::allocate_output(engine& _engine,
         return a;
     };
 
+    const auto& device_info = _engine.get_device_info();
     auto layout = out_layout.clone_with_other_shape(out_layout.get_partial_shape().get_max_shape());
     bool usm_device_allocatable = true;
     const auto& total_device_input_mem_size = std::accumulate(impl_params.input_layouts.begin(), impl_params.input_layouts.end(), (uint64_t)0, device_mem_acc);
-    if (total_device_input_mem_size > _engine.get_device_info().max_global_mem_size)
+    if (total_device_input_mem_size > device_info.max_global_mem_size)
         usm_device_allocatable = false;
 
     bool reusable_across_network = (runtime_alloc && _node.is_dynamic_output_layout())
@@ -2398,11 +2400,13 @@ memory::ptr primitive_inst::allocate_output(engine& _engine,
     // Also if the successor of a node is an cpu, then memory needs to be lockable.
     bool is_cpu = _node.get_selected_impl() ? _node.get_selected_impl()->is_cpu() :
                                               _node.get_preferred_impl_type() == impl_types::cpu;
+
+    auto total_output_bytes = layout.bytes_count();
     auto use_lockable_memory =
-        is_output_buffer || is_cpu ||
-        has_any_cpu_user_not_shape_of(_node.get_users()) ||
+        (is_output_buffer && ov::intel_gpu::can_use_usm_host(_engine, total_output_bytes)) ||
+        is_cpu || has_any_cpu_user_not_shape_of(_node.get_users()) ||
         !_engine.supports_allocation(allocation_type::usm_device) ||
-        (_node.is_shape_infer_dep() && _engine.get_device_info().dev_type == device_type::integrated_gpu);
+        (_node.is_shape_infer_dep() && device_info.dev_type == device_type::integrated_gpu);
     const auto& lockable_mem_type = _engine.get_lockable_preferred_memory_allocation_type(layout.format.is_image_2d());
 
     auto alloc_type = use_lockable_memory ? lockable_mem_type

src/plugins/intel_gpu/src/plugin/sync_infer_request.cpp

@@ -9,6 +9,7 @@
 
 #include "intel_gpu/primitives/kv_cache.hpp"
 #include "intel_gpu/primitives/read_value.hpp"
+#include "intel_gpu/plugin/common_utils.hpp"
 #include "intel_gpu/plugin/usm_host_tensor.hpp"
 #include "intel_gpu/plugin/sync_infer_request.hpp"
 #include "intel_gpu/plugin/remote_context.hpp"
@@ -32,29 +33,6 @@
 
 namespace {
 
-inline bool can_use_usm_host(const cldnn::engine& engine, const uint64_t total_output_bytes) {
-    GPU_DEBUG_GET_INSTANCE(debug_config);
-    GPU_DEBUG_IF(debug_config->use_usm_host == 1) { return true; }
-    GPU_DEBUG_IF(debug_config->use_usm_host == 2) { return false; }
-
-    auto can_use_usm = engine.use_unified_shared_memory();
-    // When output size is large, it is better not to write to usm_host directly
-    const uint64_t LARGE_OUTPUT_BYTES_THRESHOLD = 4 * 1048576;
-
-    const auto& device_info = engine.get_device_info();
-    if ((device_info.gfx_ver.major == 12 && device_info.gfx_ver.minor == 60) ||
-        (device_info.gfx_ver.major >= 20 && device_info.dev_type == cldnn::device_type::discrete_gpu) ||
-        (device_info.dev_type == cldnn::device_type::discrete_gpu && total_output_bytes > LARGE_OUTPUT_BYTES_THRESHOLD)) {
-        // WA: Disable USM host memory for infer request`s tensors for PVC and subsequent dGPUs, as kernel access
-        // to system memory is slower than using an explicit memcpy (Host <-> Device) call with the copy engine
-        // Driver tickets with additional details: 6155, 10054
-        GPU_DEBUG_TRACE << "Do not use usm_host for performance issue" << std::endl;
-        can_use_usm = false;
-    }
-
-    return can_use_usm;
-}
-
 bool is_convert_required(ov::element::Type src_et, ov::element::Type dst_et) {
     return src_et != dst_et && !(dst_et == ov::element::boolean && src_et == ov::element::u8);
 }

src/plugins/intel_gpu/tests/unit/shape_infer/broadcast_si_test.cpp

@@ -122,7 +122,7 @@ TEST_P(broadcast_test_two_inputs_blocked_format, shape_infer) {
 
     auto outputs = network.execute();
     auto output = outputs.at("output").get_memory();
-    cldnn::mem_lock<float> output_ptr(output, get_test_stream());
+    cldnn::mem_lock<float, mem_lock_type::read> output_ptr(output, get_test_stream());
 
     ASSERT_EQ(output->get_layout(), p.expected_layout);
 }

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

@@ -73,7 +73,7 @@ void start_broadcast_test(format cldnn_format, data_types cldnn_data_type, std::
     auto outputs = network.execute();
 
     auto output = outputs.at("output").get_memory();
-    cldnn::mem_lock<T> output_ptr(output, get_test_stream());
+    cldnn::mem_lock<T, mem_lock_type::read> output_ptr(output, get_test_stream());
 
     for (tensor::value_type b = 0; b < output_4d.at(0); ++b) {
         for (tensor::value_type f = 0; f < output_4d.at(1); ++f) {

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

@@ -7927,7 +7927,7 @@ TEST_P(convolution_grouped_gpu, base) {
     auto outputs = network.execute();
 
     auto out_mem = outputs.at("conv").get_memory();
-    cldnn::mem_lock<float> out_ptr(out_mem, get_test_stream());
+    cldnn::mem_lock<float, mem_lock_type::read> out_ptr(out_mem, get_test_stream());
     auto out_lay = out_mem->get_layout();
 
     ASSERT_EQ(out_mem->get_layout().format, input_data_format);
@@ -10628,10 +10628,11 @@ TEST_P(conv_dyn_test, convolution_gpu_bfyx_os_iyx_osv16_no_bias) {
     auto output_memory = outputs.at("conv").get_memory();
     ov::intel_gpu::ImplementationDesc conv_impl_ref = { format::bfyx, "convolution_gpu_ref", impl_types::ocl };
     config.set_property(ov::intel_gpu::force_implementations(ov::intel_gpu::ImplForcingMap{ { "conv", conv_impl_ref } }));
+
     auto output_memory_ref = calculate_ref(input, weights, config);
 
-    cldnn::mem_lock<float> output_ptr(output_memory, get_test_stream());
-    cldnn::mem_lock<float> output_ptr_ref(output_memory_ref, get_test_stream());
+    cldnn::mem_lock<float, mem_lock_type::read> output_ptr_ref(output_memory_ref, get_test_stream());
+    cldnn::mem_lock<float, mem_lock_type::read> output_ptr(output_memory, get_test_stream());
 
     ASSERT_EQ(outputs.at("conv").get_layout(), output_memory_ref->get_layout());
     for (size_t i = 0; i < output_ptr.size(); i++) {
@@ -10657,9 +10658,8 @@ TEST_P(conv_dyn_test, convolution_gpu_bfyx_os_iyx_osv16_no_bias) {
 
         auto output_memory = outputs.at("conv").get_memory();
         auto output_memory_ref = calculate_ref(input, weights, config);
-
-        cldnn::mem_lock<float> output_ptr(output_memory, get_test_stream());
-        cldnn::mem_lock<float> output_ptr_ref(output_memory_ref, get_test_stream());
+        cldnn::mem_lock<float, mem_lock_type::read> output_ptr_ref(output_memory_ref, get_test_stream());
+        cldnn::mem_lock<float, mem_lock_type::read> output_ptr(output_memory, get_test_stream());
 
         ASSERT_EQ(outputs.at("conv").get_layout(), output_memory_ref->get_layout());
         for (size_t i = 0; i < output_ptr.size(); i++) {

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

@@ -2704,7 +2704,7 @@ class deconvolution_random_test_base {
 
         // Compare results
         {
-            cldnn::mem_lock<OutputT> ptr(out_mem, get_test_stream());
+            cldnn::mem_lock<OutputT, mem_lock_type::read> ptr(out_mem, get_test_stream());
 
             auto b = static_cast<size_t>(out_mem->get_layout().batch());
             auto of = static_cast<size_t>(out_mem->get_layout().feature());

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

@@ -190,7 +190,7 @@ TEST(depth_to_space_fp32_gpu, d1411_bs2) {
     auto outputs = network.execute();
 
     auto output = outputs.at("depth_to_space").get_memory();
-    cldnn::mem_lock<float> output_ptr(output, get_test_stream());
+    cldnn::mem_lock<float, mem_lock_type::read> output_ptr(output, get_test_stream());
 
     std::vector<float> expected_results = {
         0.f, 1.f, 2.f, 3.f
@@ -230,7 +230,7 @@ TEST(depth_to_space_fp32_gpu, d112960540_bs2) {
     auto outputs = network_act.execute();
 
     auto output = outputs.at("depth_to_space").get_memory();
-    cldnn::mem_lock<ov::float16> output_ptr (output, get_test_stream());
+    cldnn::mem_lock<ov::float16, mem_lock_type::read> output_ptr (output, get_test_stream());
 
     std::vector<uint16_t> perm = { 0,3,4,1,5,2 };
 
@@ -255,7 +255,7 @@ TEST(depth_to_space_fp32_gpu, d112960540_bs2) {
     auto outputs_ref = network_ref.execute();
 
     auto output_ref = outputs_ref.at("reshape2").get_memory();
-    cldnn::mem_lock<ov::float16> output_ptr_ref(output_ref, get_test_stream());
+    cldnn::mem_lock<ov::float16, mem_lock_type::read> output_ptr_ref(output_ref, get_test_stream());
 
     for (size_t i = 0; i < output->get_layout().count(); ++i) {
         ASSERT_EQ(output_ptr_ref[i], output_ptr[i]);

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

@@ -155,8 +155,8 @@ class dynamic_quantization_gpu_tests: public ::testing::Test {
         std::cout << "Outputs number: " << ref_output_buffers.size() << "\n";
 
         for (size_t i = 0; i < ref_output_buffers.size(); i++) {
-            cldnn::mem_lock<ov::float16> output_ptr(output_buffers[i], get_test_stream());
-            cldnn::mem_lock<ov::float16> output_ptr_ref(ref_output_buffers[i], get_test_stream());
+            cldnn::mem_lock<ov::float16, mem_lock_type::read> output_ptr(output_buffers[i], get_test_stream());
+            cldnn::mem_lock<ov::float16, mem_lock_type::read> output_ptr_ref(ref_output_buffers[i], get_test_stream());
 
             for (size_t i = 0; i < output_ptr_ref.size(); ++i) {
                 auto abs_diff = std::abs(output_ptr_ref[i] - output_ptr[i]);

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

@@ -3814,7 +3814,7 @@ TEST(eltwise_gpu_f16, bfyx_and_fs_b_yx_fsv32_output_padding) {
 
     auto golden_outputs = golden_network.execute();
     auto golden_output = golden_outputs.at("eltwise").get_memory();
-    cldnn::mem_lock<ov::float16> golden_ptr(golden_output, get_test_stream());
+    cldnn::mem_lock<ov::float16, mem_lock_type::read> golden_ptr(golden_output, get_test_stream());
     // GOLDEN BFYX ELTWISE - END
     // MIXED INPUT, FS_B_YX_FSV32 OUTPUT
     topology FS_B_YX_FSV32_OUTPUT_topology;
@@ -3834,7 +3834,7 @@ TEST(eltwise_gpu_f16, bfyx_and_fs_b_yx_fsv32_output_padding) {
 
     auto FS_B_YX_FSV32_OUTPUT_outputs = FS_B_YX_FSV32_OUTPUT_network.execute();
     auto FS_B_YX_FSV32_OUTPUT_output = FS_B_YX_FSV32_OUTPUT_outputs.at("reorderOutput").get_memory();
-    cldnn::mem_lock<ov::float16> FS_B_YX_FSV32_OUTPUT_ptr(FS_B_YX_FSV32_OUTPUT_output, get_test_stream());
+    cldnn::mem_lock<ov::float16, mem_lock_type::read> FS_B_YX_FSV32_OUTPUT_ptr(FS_B_YX_FSV32_OUTPUT_output, get_test_stream());
     // MIXED INPUT, FS_B_YX_FSV32 OUTPUT - END
     // MIXED INPUT, BYXF OUTPUT
     topology BYXF_OUTPUT_topology;
@@ -3854,7 +3854,7 @@ TEST(eltwise_gpu_f16, bfyx_and_fs_b_yx_fsv32_output_padding) {
 
     auto BYXF_OUTPUT_outputs = BYXF_OUTPUT_network.execute();
     auto BYXF_OUTPUT_output = BYXF_OUTPUT_outputs.at("reorderOutput").get_memory();
-    cldnn::mem_lock<ov::float16> BYXF_OUTPUT_ptr(BYXF_OUTPUT_output, get_test_stream());
+    cldnn::mem_lock<ov::float16, mem_lock_type::read> BYXF_OUTPUT_ptr(BYXF_OUTPUT_output, get_test_stream());
     // MIXED INPUT, BYXF OUTPUT - END
 
     ASSERT_EQ(golden_ptr.size(), FS_B_YX_FSV32_OUTPUT_ptr.size());

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

@@ -103,7 +103,7 @@ class gather8_test : public ::testing::TestWithParam<gather8_test_param> {
         reorder_network.set_input_data("input0", input0);
         reorder_network.set_input_data("input1", input1);
         auto reorder_output = reorder_network.execute().at("reorder2").get_memory();
-        cldnn::mem_lock<T_dat> reorder_output_ptr(reorder_output, get_test_stream());
+        cldnn::mem_lock<T_dat, mem_lock_type::read> reorder_output_ptr(reorder_output, get_test_stream());
 
         topology planar_topo;
         planar_topo.add(input_layout("input0", input0->get_layout()));
@@ -114,7 +114,7 @@ class gather8_test : public ::testing::TestWithParam<gather8_test_param> {
         planar_network.set_input_data("input0", input0);
         planar_network.set_input_data("input1", input1);
         auto planar_output = planar_network.execute().at("gather").get_memory();
-        cldnn::mem_lock<T_dat> planar_output_ptr(planar_output, get_test_stream());
+        cldnn::mem_lock<T_dat, mem_lock_type::read> planar_output_ptr(planar_output, get_test_stream());
 
         ASSERT_TRUE(
             !memcmp(reorder_output_ptr.data(), planar_output_ptr.data(), get_linear_size(shape_out) * sizeof(T_dat)));

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

@@ -84,7 +84,7 @@ class GroupNormalizationGPUTest : public ::testing::TestWithParam<GroupNormaliza
         network_->set_input_data(bias_primitive_, bias_gpu_mem);
         auto outputs = network_->execute();
         auto output = outputs.at("output").get_memory();
-        cldnn::mem_lock<float> output_gpu_mem(output, get_test_stream());
+        cldnn::mem_lock<float, mem_lock_type::read> output_gpu_mem(output, get_test_stream());
 
         std::vector<float> reference_output(data_.size());
         ov::reference::group_normalization(data_.data(), scale_.data(), bias_.data(), reference_output.data(),
@@ -236,4 +236,4 @@ TEST(group_normalization, input_bfyx_output_fsv16) {
         ASSERT_NEAR(output_mem_t[i], output_mem_g[i], 0.0001);
     }
 }
-#endif // ENABLE_ONEDNN_FOR_GPU
+#endif // ENABLE_ONEDNN_FOR_GPU