[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 getTestParam() and getQueueFlag() helpers to the fixture for
  clean access to the two parts of the parameter tuple.
- 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 getTestParam() instead of
  std::get<1>(this->GetParam()), and restoring the numQueues parameter
  in SuccessMt to getTestParam().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,18 @@ 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 = getParam();
 
+    ur_queue_properties_t props = {UR_STRUCTURE_TYPE_QUEUE_PROPERTIES, nullptr,
+                                   getQueueFlag()};
     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 +97,20 @@ struct urL0EnqueueAllocMultiQueueSameDeviceTest
     UUR_RETURN_ON_FATAL_FAILURE(urContextTestWithParam::TearDown());
   }
 
+  const uur::MultiQueueParam<EnqueueAllocMultiQueueTestParam> &
+  getParamTuple() const {
+    return urContextTestWithParam<
+        uur::MultiQueueParam<EnqueueAllocMultiQueueTestParam>>::getParam();
+  }
+
+  const EnqueueAllocMultiQueueTestParam &getParam() const {
+    return std::get<0>(this->getParamTuple());
+  }
+
+  ur_queue_flag_t getQueueFlag() const {
+    return std::get<1>(this->getParamTuple());
+  }
+
   std::vector<ur_queue_handle_t> queues;
 };
 
@@ -322,7 +338,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 +350,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 = getParam().allocSize;
+  const size_t numQueues = getParam().numQueues;
+  const size_t iterations = getParam().iterations;
   const auto enqueueUSMAllocFunc =
-      std::get<1>(this->GetParam()).funcParams.enqueueUSMAllocFunc;
+      getParam().funcParams.enqueueUSMAllocFunc;
   const auto checkUSMSupportFunc =
-      std::get<1>(this->GetParam()).funcParams.checkUSMSupportFunc;
-
-  if (numQueues > 0) {
-    SKIP_IF_BATCHED_QUEUE(queues[0]);
-  }
+      getParam().funcParams.checkUSMSupportFunc;
 
   ur_device_usm_access_capability_flags_t USMSupport = 0;
   ASSERT_SUCCESS(checkUSMSupportFunc(device, USMSupport));
@@ -394,11 +406,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 = getParam().allocSize;
   const auto enqueueUSMAllocFunc =
-      std::get<1>(this->GetParam()).funcParams.enqueueUSMAllocFunc;
+      getParam().funcParams.enqueueUSMAllocFunc;
   const auto checkUSMSupportFunc =
-      std::get<1>(this->GetParam()).funcParams.checkUSMSupportFunc;
+      getParam().funcParams.checkUSMSupportFunc;
 
   ur_device_usm_access_capability_flags_t USMSupport = 0;
   ASSERT_SUCCESS(checkUSMSupportFunc(device, USMSupport));
@@ -457,12 +469,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 = getParam().allocSize;
+  const size_t iterations = getParam().iterations;
   const auto enqueueUSMAllocFunc =
-      std::get<1>(this->GetParam()).funcParams.enqueueUSMAllocFunc;
+      getParam().funcParams.enqueueUSMAllocFunc;
   const auto checkUSMSupportFunc =
-      std::get<1>(this->GetParam()).funcParams.checkUSMSupportFunc;
+      getParam().funcParams.checkUSMSupportFunc;
 
   ur_device_usm_access_capability_flags_t USMSupport = 0;
   ASSERT_SUCCESS(checkUSMSupportFunc(device, USMSupport));