[UR][L0v2] Parameterize urL0EnqueueAllocMultiQueueSameDeviceTest over all queue types

Enable the urL0EnqueueAllocMultiQueueSameDeviceTest and parameterize it
over all queue submission modes (UR_QUEUE_FLAG_SUBMISSION_BATCHED and
UR_QUEUE_FLAG_SUBMISSION_IMMEDIATE) by:

- Removing SKIP_IF_BATCHED_QUEUE to enable the test for batched queues.
- Changing the base class template parameter from
  EnqueueAllocMultiQueueTestParam to
  uur::MultiQueueParam<EnqueueAllocMultiQueueTestParam> so that the
  queue mode becomes part of the test parameter.
- Adding getMultiQueueParam(), getAllocParam() and getQueueFlags() helpers
  to the fixture for clean access to the two parts of the parameter tuple.
  getMultiQueueParam() calls the base class getter using the fully qualified
  name uur::urContextTestWithParam<...>::getParam() to avoid ambiguity.
  The names are specific enough to not be confused with GoogleTest's
  conventional GetParam().
- Creating queues with the parameterized flag via ur_queue_properties_t
  instead of a hardcoded UR_QUEUE_FLAG_SUBMISSION_BATCHED.
- Switching the test suite macro from UUR_DEVICE_TEST_SUITE_WITH_PARAM
  to UUR_MULTI_QUEUE_TYPE_TEST_SUITE_WITH_PARAM and the printer to
  deviceTestWithParamPrinterMulti, which expands the suite to cover
  both queue modes automatically.
- Updating all three test bodies (SuccessMt, SuccessReuse,
  SuccessDependantMt) to use getAllocParam() instead of
  std::get<1>(this->GetParam()), and restoring the numQueues parameter
  in SuccessMt to getAllocParam().numQueues.

This ensures both batched and immediate queues are covered by default
test runs without requiring UR_L0_V2_FORCE_BATCHED=1.

Signed-off-by: Lukasz Dorau <lukasz.dorau@intel.com>

Author: ldorau

unified-runtime/test/adapters/level_zero/enqueue_alloc.cpp

@@ -73,16 +73,19 @@ std::ostream &operator<<(std::ostream &os,
 }
 
 struct urL0EnqueueAllocMultiQueueSameDeviceTest
-    : uur::urContextTestWithParam<EnqueueAllocMultiQueueTestParam> {
+    : uur::urContextTestWithParam<
+          uur::MultiQueueParam<EnqueueAllocMultiQueueTestParam>> {
   void SetUp() override {
     UUR_RETURN_ON_FATAL_FAILURE(urContextTestWithParam::SetUp());
-    auto param = std::get<1>(this->GetParam());
 
+    const auto &param = getAllocParam();
+
+    ur_queue_properties_t props = {UR_STRUCTURE_TYPE_QUEUE_PROPERTIES, nullptr,
+                                   getQueueFlags()};
     queues.reserve(param.numQueues);
     for (size_t i = 0; i < param.numQueues; i++) {
       ur_queue_handle_t queue = nullptr;
-      ASSERT_SUCCESS(urQueueCreate(context, device, 0, &queue));
-      SKIP_IF_BATCHED_QUEUE(queue);
+      ASSERT_SUCCESS(urQueueCreate(context, device, &props, &queue));
       queues.push_back(queue);
     }
   }
@@ -95,6 +98,20 @@ struct urL0EnqueueAllocMultiQueueSameDeviceTest
     UUR_RETURN_ON_FATAL_FAILURE(urContextTestWithParam::TearDown());
   }
 
+  const uur::MultiQueueParam<EnqueueAllocMultiQueueTestParam> &
+  getMultiQueueParam() const {
+    return uur::urContextTestWithParam<
+        uur::MultiQueueParam<EnqueueAllocMultiQueueTestParam>>::getParam();
+  }
+
+  const EnqueueAllocMultiQueueTestParam &getAllocParam() const {
+    return std::get<0>(this->getMultiQueueParam());
+  }
+
+  ur_queue_flag_t getQueueFlags() const {
+    return std::get<1>(this->getMultiQueueParam());
+  }
+
   std::vector<ur_queue_handle_t> queues;
 };
 
@@ -322,7 +339,7 @@ TEST_P(urL0EnqueueAllocTest, SuccessWithKernelRepeat) {
   ValidateEnqueueFree(ptr2);
 }
 
-UUR_DEVICE_TEST_SUITE_WITH_PARAM(
+UUR_MULTI_QUEUE_TYPE_TEST_SUITE_WITH_PARAM(
     urL0EnqueueAllocMultiQueueSameDeviceTest,
     ::testing::ValuesIn({
         EnqueueAllocMultiQueueTestParam{1024, 256, 8, urEnqueueUSMHostAllocExp,
@@ -334,20 +351,16 @@ UUR_DEVICE_TEST_SUITE_WITH_PARAM(
                                         urEnqueueUSMDeviceAllocExp,
                                         uur::GetDeviceUSMDeviceSupport},
     }),
-    uur::deviceTestWithParamPrinter<EnqueueAllocMultiQueueTestParam>);
+    uur::deviceTestWithParamPrinterMulti<EnqueueAllocMultiQueueTestParam>);
 
 TEST_P(urL0EnqueueAllocMultiQueueSameDeviceTest, SuccessMt) {
-  const size_t allocSize = std::get<1>(this->GetParam()).allocSize;
-  const size_t numQueues = std::get<1>(this->GetParam()).numQueues;
-  const size_t iterations = std::get<1>(this->GetParam()).iterations;
+  const size_t allocSize = getAllocParam().allocSize;
+  const size_t numQueues = getAllocParam().numQueues;
+  const size_t iterations = getAllocParam().iterations;
   const auto enqueueUSMAllocFunc =
-      std::get<1>(this->GetParam()).funcParams.enqueueUSMAllocFunc;
+      getAllocParam().funcParams.enqueueUSMAllocFunc;
   const auto checkUSMSupportFunc =
-      std::get<1>(this->GetParam()).funcParams.checkUSMSupportFunc;
-
-  if (numQueues > 0) {
-    SKIP_IF_BATCHED_QUEUE(queues[0]);
-  }
+      getAllocParam().funcParams.checkUSMSupportFunc;
 
   ur_device_usm_access_capability_flags_t USMSupport = 0;
   ASSERT_SUCCESS(checkUSMSupportFunc(device, USMSupport));
@@ -394,11 +407,11 @@ TEST_P(urL0EnqueueAllocMultiQueueSameDeviceTest, SuccessMt) {
 TEST_P(urL0EnqueueAllocMultiQueueSameDeviceTest, SuccessReuse) {
   GTEST_SKIP() << "Multi queue reuse is not supported.";
 
-  const size_t allocSize = std::get<1>(this->GetParam()).allocSize;
+  const size_t allocSize = getAllocParam().allocSize;
   const auto enqueueUSMAllocFunc =
-      std::get<1>(this->GetParam()).funcParams.enqueueUSMAllocFunc;
+      getAllocParam().funcParams.enqueueUSMAllocFunc;
   const auto checkUSMSupportFunc =
-      std::get<1>(this->GetParam()).funcParams.checkUSMSupportFunc;
+      getAllocParam().funcParams.checkUSMSupportFunc;
 
   ur_device_usm_access_capability_flags_t USMSupport = 0;
   ASSERT_SUCCESS(checkUSMSupportFunc(device, USMSupport));
@@ -457,12 +470,12 @@ TEST_P(urL0EnqueueAllocMultiQueueSameDeviceTest, SuccessReuse) {
 }
 
 TEST_P(urL0EnqueueAllocMultiQueueSameDeviceTest, SuccessDependantMt) {
-  const size_t allocSize = std::get<1>(this->GetParam()).allocSize;
-  const size_t iterations = std::get<1>(this->GetParam()).iterations;
+  const size_t allocSize = getAllocParam().allocSize;
+  const size_t iterations = getAllocParam().iterations;
   const auto enqueueUSMAllocFunc =
-      std::get<1>(this->GetParam()).funcParams.enqueueUSMAllocFunc;
+      getAllocParam().funcParams.enqueueUSMAllocFunc;
   const auto checkUSMSupportFunc =
-      std::get<1>(this->GetParam()).funcParams.checkUSMSupportFunc;
+      getAllocParam().funcParams.checkUSMSupportFunc;
 
   ur_device_usm_access_capability_flags_t USMSupport = 0;
   ASSERT_SUCCESS(checkUSMSupportFunc(device, USMSupport));