test: add copy offload parameter to benchmarks

Related-To: VCV-13562

Signed-off-by: Alicja Lukaszewicz <[email protected]>

Author: AlicjaLukaszewicz

TESTS.md

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022-2023 Intel Corporation
+ * Copyright (C) 2022-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -18,14 +18,16 @@ struct ExecuteCommandListImmediateCopyQueueArguments : TestCaseArgumentContainer
     UsmMemoryPlacementArgument destinationPlacement;
     ByteSizeArgument size;
     BooleanArgument useIoq;
+    BooleanArgument withCopyOffload;
 
     ExecuteCommandListImmediateCopyQueueArguments()
         : isCopyOnly(*this, "IsCopyOnly", "If true, Copy Engine is selected. If false, Compute Engine is selected"),
           measureCompletionTime(*this, "MeasureCompletionTime", "Measures time taken to complete the submission (default is to measure only Immediate call)"),
           sourcePlacement(*this, "src", "Placement of the source buffer"),
           destinationPlacement(*this, "dst", "Placement of the destination buffer"),
           size(*this, "size", "Size of the buffer"),
-          useIoq(*this, "ioq", "Use In order queue") {}
+          useIoq(*this, "ioq", "Use In order queue"),
+          withCopyOffload(*this, "withCopyOffload", "Enable driver copy offload (only valid for L0)") {}
 };
 
 struct ExecuteCommandListImmediateCopyQueue : TestCase<ExecuteCommandListImmediateCopyQueueArguments> {

source/benchmarks/api_overhead_benchmark/definitions/execute_command_list_immediate_copy_queue.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022-2023 Intel Corporation
+ * Copyright (C) 2022-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -16,7 +16,7 @@
 
 [[maybe_unused]] static const inline RegisterTestCase<ExecuteCommandListImmediateCopyQueue> registerTestCase{};
 
-class ExecuteCommandListImmediateCopyQueueTest : public ::testing::TestWithParam<std::tuple<Api, bool, bool, UsmMemoryPlacement, UsmMemoryPlacement, size_t, bool, TestType>> {
+class ExecuteCommandListImmediateCopyQueueTest : public ::testing::TestWithParam<std::tuple<Api, bool, bool, UsmMemoryPlacement, UsmMemoryPlacement, size_t, bool, bool, TestType>> {
 };
 
 TEST_P(ExecuteCommandListImmediateCopyQueueTest, Test) {
@@ -28,11 +28,15 @@ TEST_P(ExecuteCommandListImmediateCopyQueueTest, Test) {
     args.destinationPlacement = std::get<4>(GetParam());
     args.size = std::get<5>(GetParam());
     args.useIoq = std::get<6>(GetParam());
+    args.withCopyOffload = std::get<7>(GetParam());
 
-    const auto testType = std::get<7>(GetParam());
+    const auto testType = std::get<8>(GetParam());
     if (isTestSkipped(Configuration::get().reducedSizeCAL, testType)) {
         GTEST_SKIP();
     }
+    if (args.isCopyOnly && args.withCopyOffload) {
+        GTEST_SKIP(); // If copy offload were to be executed on blitter
+    }
 
     ExecuteCommandListImmediateCopyQueue test;
     test.run(args);
@@ -51,4 +55,5 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::ValuesIn(UsmMemoryPlacementArgument::limitedTargets),
         ::testing::Values(64 * megaByte),
         ::testing::Values(false, true),
+        ::testing::Values(false, true),
         ::testing::Values(TestType::Regular)));

source/benchmarks/api_overhead_benchmark/gtest/execute_command_list_immediate_copy_queue.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022-2024 Intel Corporation
+ * Copyright (C) 2022-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -61,6 +61,12 @@ static TestResult run(const ExecuteCommandListImmediateCopyQueueArguments &argum
     if (arguments.useIoq) {
         commandQueueDesc->desc.flags = ZE_COMMAND_QUEUE_FLAG_IN_ORDER;
     }
+
+    zex_intel_queue_copy_operations_offload_hint_exp_desc_t copyOffload = {ZEX_INTEL_STRUCTURE_TYPE_QUEUE_COPY_OPERATIONS_OFFLOAD_HINT_EXP_PROPERTIES, nullptr, true};
+    if (arguments.withCopyOffload) {
+        commandQueueDesc->desc.flags = ZE_COMMAND_QUEUE_FLAG_IN_ORDER;
+        commandQueueDesc->desc.pNext = &copyOffload;
+    }
     ASSERT_ZE_RESULT_SUCCESS(zeCommandListCreateImmediate(levelzero.context, levelzero.device, &commandQueueDesc->desc, &cmdList));
 
     // Warmup

source/benchmarks/api_overhead_benchmark/implementations/l0/execute_command_list_immediate_copy_queue_l0.cpp

@@ -19,13 +19,6 @@
 #include <level_zero/ze_api.h>
 #include <math.h>
 
-typedef struct _zex_intel_queue_copy_operations_offload_hint_exp_desc_t {
-    ze_structure_type_t stype;
-    const void *pNext;
-    ze_bool_t copyOffloadEnabled;
-} zex_intel_queue_copy_operations_offload_hint_exp_desc_t;
-#define ZEX_INTEL_STRUCTURE_TYPE_QUEUE_COPY_OPERATIONS_OFFLOAD_HINT_EXP_PROPERTIES (ze_structure_type_t)0x0003001B
-
 SinKernelGraphL0::DataFloatPtr SinKernelGraphL0::allocDevice(uint32_t count) {
     return mem_helper::alloc(UsmMemoryPlacement::Device, levelzero, count);
 }

source/benchmarks/graph_api_benchmark/implementations/l0/sin_kernel_impl_l0.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -17,13 +17,15 @@ struct QueueInOrderMemcpyArguments : TestCaseArgumentContainer {
     UsmMemoryPlacementArgument destinationPlacement;
     ByteSizeArgument size;
     PositiveIntegerArgument count;
+    BooleanArgument withCopyOffload;
 
     QueueInOrderMemcpyArguments()
         : isCopyOnly(*this, "IsCopyOnly", "If true, Copy Engine is selected. If false, Compute Engine is selected"),
           sourcePlacement(*this, "sourcePlacement", "Placement of the source buffer"),
           destinationPlacement(*this, "destinationPlacement", "Placement of the destination buffer"),
           size(*this, "size", "Size of memory allocation"),
-          count(*this, "count", "Number of memcpy operations") {}
+          count(*this, "count", "Number of memcpy operations"),
+          withCopyOffload(*this, "withCopyOffload", "Enable driver copy offload (only valid for L0)") {}
 };
 
 struct QueueInOrderMemcpy : TestCase<QueueInOrderMemcpyArguments> {

source/benchmarks/memory_benchmark/definitions/queue_in_order_memcpy.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -16,11 +16,13 @@ struct UsmConcurrentCopyArguments : TestCaseArgumentContainer {
     ByteSizeArgument size;
     EngineArgument h2dEngine;
     EngineArgument d2hEngine;
+    BooleanArgument withCopyOffload;
 
     UsmConcurrentCopyArguments()
         : size(*this, "size", "Size of the buffer"),
           h2dEngine(*this, "h2dEngine", "Engine used for host to device copy"),
-          d2hEngine(*this, "d2hEngine", "Engine used for device to host copy") {}
+          d2hEngine(*this, "d2hEngine", "Engine used for device to host copy"),
+          withCopyOffload(*this, "withCopyOffload", "Enable driver copy offload (only valid for L0)") {}
 };
 
 struct UsmConcurrentCopy : TestCase<UsmConcurrentCopyArguments> {

source/benchmarks/memory_benchmark/definitions/usm_copy_concurrent.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 Intel Corporation
+ * Copyright (C) 2022-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -20,14 +20,16 @@ struct UsmCopyImmediateArguments : TestCaseArgumentContainer {
     BufferContentsArgument contents;
     BooleanArgument forceBlitter;
     BooleanArgument useEvents;
+    BooleanArgument withCopyOffload;
 
     UsmCopyImmediateArguments()
         : sourcePlacement(*this, "src", "Placement of the source buffer"),
           destinationPlacement(*this, "dst", "Placement of the destination buffer"),
           size(*this, "size", "Size of the buffer"),
           contents(*this, "contents", "Contents of the buffers"),
           forceBlitter(*this, "forceBlitter", CommonHelpMessage::forceBlitter()),
-          useEvents(*this, "useEvents", CommonHelpMessage::useEvents()) {}
+          useEvents(*this, "useEvents", CommonHelpMessage::useEvents()),
+          withCopyOffload(*this, "withCopyOffload", "Enable driver copy offload (only valid for L0)") {}
 };
 
 struct UsmCopyImmediate : TestCase<UsmCopyImmediateArguments> {

source/benchmarks/memory_benchmark/definitions/usm_copy_immediate.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 Intel Corporation
+ * Copyright (C) 2022-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -17,12 +17,14 @@ struct UsmCopyStagingBuffersArguments : TestCaseArgumentContainer {
     UsmMemoryPlacementArgument dstPlacement;
     ByteSizeArgument size;
     PositiveIntegerArgument chunks;
+    BooleanArgument withCopyOffload;
 
     UsmCopyStagingBuffersArguments()
         : forceBlitter(*this, "forceBlitter", CommonHelpMessage::forceBlitter()),
           dstPlacement(*this, "dst", "Memory placement of destination"),
           size(*this, "size", "Size of the buffer"),
-          chunks(*this, "chunks", "How much memory chunks should the buffer be splitted into") {}
+          chunks(*this, "chunks", "How much memory chunks should the buffer be splitted into"),
+          withCopyOffload(*this, "withCopyOffload", "Enable driver copy offload (only valid for L0)") {}
 };
 
 struct UsmCopyStagingBuffers : TestCase<UsmCopyStagingBuffersArguments> {

source/benchmarks/memory_benchmark/definitions/usm_copy_staging_buffers.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -14,7 +14,7 @@
 
 [[maybe_unused]] static const inline RegisterTestCase<QueueInOrderMemcpy> registerTestCase{};
 
-class QueueInOrderMemcpyTest : public ::testing::TestWithParam<std::tuple<Api, UsmMemoryPlacement, UsmMemoryPlacement, size_t, size_t, bool>> {};
+class QueueInOrderMemcpyTest : public ::testing::TestWithParam<std::tuple<Api, UsmMemoryPlacement, UsmMemoryPlacement, size_t, size_t, bool, bool>> {};
 
 TEST_P(QueueInOrderMemcpyTest, Test) {
     QueueInOrderMemcpyArguments args{};
@@ -24,6 +24,12 @@ TEST_P(QueueInOrderMemcpyTest, Test) {
     args.size = std::get<3>(GetParam());
     args.count = std::get<4>(GetParam());
     args.isCopyOnly = std::get<5>(GetParam());
+    args.withCopyOffload = std::get<6>(GetParam());
+
+    if (args.isCopyOnly && args.withCopyOffload) {
+        GTEST_SKIP(); // If copy offload were to be executed on blitter
+    }
+
     QueueInOrderMemcpy test;
     test.run(args);
 }
@@ -37,4 +43,5 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(UsmMemoryPlacement::Host, UsmMemoryPlacement::Shared, UsmMemoryPlacement::Device),
         ::testing::Values(1 * MemoryConstants::megaByte),
         ::testing::Values(10),
+        ::testing::Values(true, false),
         ::testing::Values(true, false)));

source/benchmarks/memory_benchmark/gtest/queue_in_order_memcpy.cpp

@@ -14,7 +14,7 @@
 
 #include <gtest/gtest.h>
 
-class UsmConcurrentCopyTest : public ::testing::TestWithParam<std::tuple<Api, size_t, Engine, Engine>> {
+class UsmConcurrentCopyTest : public ::testing::TestWithParam<std::tuple<Api, size_t, Engine, Engine, bool>> {
 };
 
 TEST_P(UsmConcurrentCopyTest, Test) {
@@ -23,6 +23,7 @@ TEST_P(UsmConcurrentCopyTest, Test) {
     args.size = std::get<1>(GetParam());
     args.h2dEngine = std::get<2>(GetParam());
     args.d2hEngine = std::get<3>(GetParam());
+    args.withCopyOffload = std::get<4>(GetParam());
 
     UsmConcurrentCopy test;
     test.run(args);
@@ -35,4 +36,5 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(Api::L0),
         ::testing::Values(256 * megaByte),
         ::testing::Values(Engine::Ccs0, Engine::Bcs),
-        ::testing::Values(Engine::Ccs0, Engine::Bcs)));
+        ::testing::Values(Engine::Ccs0, Engine::Bcs),
+        ::testing::Values(true, false)));

source/benchmarks/memory_benchmark/gtest/usm_copy_concurrent.cpp

@@ -14,7 +14,7 @@
 
 #include <gtest/gtest.h>
 
-class UsmCopyImmediateTest : public ::testing::TestWithParam<std::tuple<UsmMemoryPlacement, UsmMemoryPlacement, size_t, BufferContents, bool, bool>> {
+class UsmCopyImmediateTest : public ::testing::TestWithParam<std::tuple<UsmMemoryPlacement, UsmMemoryPlacement, size_t, BufferContents, bool, bool, bool>> {
 };
 
 TEST_P(UsmCopyImmediateTest, Test) {
@@ -26,6 +26,11 @@ TEST_P(UsmCopyImmediateTest, Test) {
     args.contents = std::get<3>(GetParam());
     args.forceBlitter = std::get<4>(GetParam());
     args.useEvents = std::get<5>(GetParam());
+    args.withCopyOffload = std::get<6>(GetParam());
+
+    if (args.forceBlitter && args.withCopyOffload) {
+        GTEST_SKIP(); // If copy offload were to be executed on blitter
+    }
 
     UsmCopyImmediate test;
     test.run(args);
@@ -41,7 +46,8 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(512 * megaByte),
         ::testing::Values(BufferContents::Zeros),
         ::testing::Values(false, true),
-        ::testing::Values(true)));
+        ::testing::Values(true),
+        ::testing::Values(false, true)));
 
 INSTANTIATE_TEST_SUITE_P(
     UsmCopyImmediateTestLIMITED,
@@ -52,4 +58,5 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(512 * megaByte),
         ::testing::Values(BufferContents::Zeros),
         ::testing::Values(false),
-        ::testing::Values(true)));
+        ::testing::Values(true),
+        ::testing::Values(false, true)));

source/benchmarks/memory_benchmark/gtest/usm_copy_immediate.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022-2023 Intel Corporation
+ * Copyright (C) 2022-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -14,7 +14,7 @@
 
 #include <gtest/gtest.h>
 
-class UsmCopyStagingBuffersTest : public ::testing::TestWithParam<std::tuple<Api, bool, UsmMemoryPlacement, size_t, size_t>> {
+class UsmCopyStagingBuffersTest : public ::testing::TestWithParam<std::tuple<Api, bool, UsmMemoryPlacement, size_t, size_t, bool>> {
 };
 
 TEST_P(UsmCopyStagingBuffersTest, DISABLED_Test) {
@@ -24,6 +24,11 @@ TEST_P(UsmCopyStagingBuffersTest, DISABLED_Test) {
     args.dstPlacement = std::get<2>(GetParam());
     args.size = std::get<3>(GetParam());
     args.chunks = std::get<4>(GetParam());
+    args.withCopyOffload = std::get<5>(GetParam());
+
+    if (args.forceBlitter && args.withCopyOffload) {
+        GTEST_SKIP(); // If copy offload were to be executed on blitter
+    }
 
     UsmCopyStagingBuffers test;
     test.run(args);
@@ -38,4 +43,5 @@ INSTANTIATE_TEST_SUITE_P(
         ::testing::Values(false, true),
         ::testing::Values(UsmMemoryPlacement::Device, UsmMemoryPlacement::Host),
         ::testing::Values(1 * kiloByte, 2 * kiloByte, 4 * kiloByte, 128 * kiloByte, 1 * megaByte, 2 * megaByte, 16 * megaByte, 32 * megaByte, 128 * megaByte, 512 * megaByte),
-        ::testing::Values(1, 2, 4, 8)));
+        ::testing::Values(1, 2, 4, 8),
+        ::testing::Values(true, false)));

source/benchmarks/memory_benchmark/gtest/usm_copy_staging_buffers.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023-2024 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -60,6 +60,11 @@ static TestResult run(const QueueInOrderMemcpyArguments &arguments, Statistics &
     }
 
     ze_command_list_handle_t cmdList{};
+    zex_intel_queue_copy_operations_offload_hint_exp_desc_t copyOffload = {ZEX_INTEL_STRUCTURE_TYPE_QUEUE_COPY_OPERATIONS_OFFLOAD_HINT_EXP_PROPERTIES, nullptr, true};
+    if (arguments.withCopyOffload) {
+        levelzero.commandQueueDesc.flags |= ZE_COMMAND_QUEUE_FLAG_IN_ORDER;
+        levelzero.commandQueueDesc.pNext = &copyOffload;
+    }
     ASSERT_ZE_RESULT_SUCCESS(zeCommandListCreateImmediate(levelzero.context, levelzero.device, &levelzero.commandQueueDesc, &cmdList));
     // Warmup
     ze_event_handle_t signalEvent = events[0];

source/benchmarks/memory_benchmark/implementations/l0/queue_in_order_memcpy_l0.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2023 Intel Corporation
+ * Copyright (C) 2023-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -37,6 +37,15 @@ static TestResult run(const UsmConcurrentCopyArguments &arguments, Statistics &s
         return TestResult::DeviceNotCapable;
     }
 
+    zex_intel_queue_copy_operations_offload_hint_exp_desc_t copyOffload = {ZEX_INTEL_STRUCTURE_TYPE_QUEUE_COPY_OPERATIONS_OFFLOAD_HINT_EXP_PROPERTIES, nullptr, true};
+    if (arguments.withCopyOffload) {
+        h2dQueueDesc->desc.flags |= ZE_COMMAND_QUEUE_FLAG_IN_ORDER;
+        d2hQueueDesc->desc.flags |= ZE_COMMAND_QUEUE_FLAG_IN_ORDER;
+
+        h2dQueueDesc->desc.pNext = &copyOffload;
+        d2hQueueDesc->desc.pNext = &copyOffload;
+    }
+
     // Create events
     ze_event_pool_desc_t eventPoolDesc{ZE_STRUCTURE_TYPE_EVENT_POOL_DESC};
     eventPoolDesc.flags = ZE_EVENT_POOL_FLAG_HOST_VISIBLE;

source/benchmarks/memory_benchmark/implementations/l0/usm_copy_concurrent_l0.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022-2024 Intel Corporation
+ * Copyright (C) 2022-2025 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -67,6 +67,11 @@ static TestResult run(const UsmCopyImmediateArguments &arguments, Statistics &st
     // Create an immediate command list
     ze_command_list_handle_t cmdList{};
     auto commandQueueDesc = QueueFamiliesHelper::getPropertiesForSelectingEngine(levelzero.device, queueProperties.selectedEngine);
+    zex_intel_queue_copy_operations_offload_hint_exp_desc_t copyOffload = {ZEX_INTEL_STRUCTURE_TYPE_QUEUE_COPY_OPERATIONS_OFFLOAD_HINT_EXP_PROPERTIES, nullptr, true};
+    if (arguments.withCopyOffload) {
+        commandQueueDesc->desc.flags |= ZE_COMMAND_QUEUE_FLAG_IN_ORDER;
+        commandQueueDesc->desc.pNext = &copyOffload;
+    }
     ASSERT_ZE_RESULT_SUCCESS(zeCommandListCreateImmediate(levelzero.context, levelzero.device, &commandQueueDesc->desc, &cmdList));
 
     // Fill buffer