Remove virtual from L0 V2 queues

scripts/templates/queue_api.cpp.mako

@@ -23,9 +23,10 @@ from templates import helper as th
 // Do not edit. This file is auto generated from a template: scripts/templates/queue_api.cpp.mako
 
 #include "queue_api.hpp"
+#include "queue_handle.hpp"
 #include "ur_util.hpp"
 
-ur_queue_handle_t_::~ur_queue_handle_t_() {}
+ur_queue_t_::~ur_queue_t_() {}
 
 ## FUNCTION ###################################################################
 namespace ${x}::level_zero {
@@ -37,7 +38,7 @@ ${th.make_func_name(n, tags, obj)}(
     %endfor
     )
 try {
-    return ${obj['params'][0]['name']}->${th.transform_queue_related_function_name(n, tags, obj, format=["name"])};
+    return ${obj['params'][0]['name']}->get().${th.transform_queue_related_function_name(n, tags, obj, format=["name"])};
 } catch(...) {
     return exceptionToResult(std::current_exception());
 }

scripts/templates/queue_api.hpp.mako

@@ -27,8 +27,8 @@ from templates import helper as th
 #include <ur_api.h>
 #include <ze_api.h>
 
-struct ur_queue_handle_t_ {
-    virtual ~ur_queue_handle_t_();
+struct ur_queue_t_ {
+    virtual ~ur_queue_t_();
 
     virtual void deferEventFree(ur_event_handle_t hEvent) = 0;
 

source/adapters/level_zero/v2/command_buffer.cpp

@@ -12,6 +12,7 @@
 #include "../helpers/kernel_helpers.hpp"
 #include "../ur_interface_loader.hpp"
 #include "logger/ur_logger.hpp"
+#include "queue_handle.hpp"
 
 namespace {
 
@@ -141,7 +142,7 @@ ur_result_t urCommandBufferEnqueueExp(
     ur_exp_command_buffer_handle_t hCommandBuffer, ur_queue_handle_t hQueue,
     uint32_t numEventsInWaitList, const ur_event_handle_t *phEventWaitList,
     ur_event_handle_t *phEvent) try {
-  return hQueue->enqueueCommandBuffer(
+  return hQueue->get().enqueueCommandBuffer(
       hCommandBuffer->commandListManager.getZeCommandList(), phEvent,
       numEventsInWaitList, phEventWaitList);
 } catch (...) {

source/adapters/level_zero/v2/command_list_manager.cpp

@@ -17,7 +17,7 @@
 ur_command_list_manager::ur_command_list_manager(
     ur_context_handle_t context, ur_device_handle_t device,
     v2::raii::command_list_unique_handle &&commandList, v2::event_flags_t flags,
-    ur_queue_handle_t queue)
+    ur_queue_t_ *queue)
     : context(context), device(device),
       eventPool(context->eventPoolCache.borrow(device->Id.value(), flags)),
       zeCommandList(std::move(commandList)), queue(queue) {

source/adapters/level_zero/v2/command_list_manager.hpp

@@ -21,7 +21,7 @@ struct ur_command_list_manager : public _ur_object {
                           ur_device_handle_t device,
                           v2::raii::command_list_unique_handle &&commandList,
                           v2::event_flags_t flags = v2::EVENT_FLAGS_COUNTER,
-                          ur_queue_handle_t_ *queue = nullptr);
+                          ur_queue_t_ *queue = nullptr);
   ~ur_command_list_manager();
 
   ur_result_t appendKernelLaunch(ur_kernel_handle_t hKernel, uint32_t workDim,
@@ -47,6 +47,6 @@ struct ur_command_list_manager : public _ur_object {
   ur_device_handle_t device;
   v2::raii::cache_borrowed_event_pool eventPool;
   v2::raii::command_list_unique_handle zeCommandList;
-  ur_queue_handle_t queue;
+  ur_queue_t_ *queue;
   std::vector<ze_event_handle_t> waitList;
 };

source/adapters/level_zero/v2/event.cpp

@@ -15,6 +15,7 @@
 #include "event_pool.hpp"
 #include "event_provider.hpp"
 #include "queue_api.hpp"
+#include "queue_handle.hpp"
 
 #include "../ur_interface_loader.hpp"
 
@@ -93,7 +94,7 @@ ur_event_handle_t_::ur_event_handle_t_(
     : hContext(hContext), event_pool(pool), hZeEvent(std::move(hZeEvent)),
       flags(flags), profilingData(getZeEvent()) {}
 
-void ur_event_handle_t_::resetQueueAndCommand(ur_queue_handle_t hQueue,
+void ur_event_handle_t_::resetQueueAndCommand(ur_queue_t_ *hQueue,
                                               ur_command_t commandType) {
   this->hQueue = hQueue;
   this->commandType = commandType;
@@ -182,7 +183,7 @@ ur_event_handle_t_::getEventEndTimestampAndHandle() {
   return {profilingData.eventEndTimestampAddr(), getZeEvent()};
 }
 
-ur_queue_handle_t ur_event_handle_t_::getQueue() const { return hQueue; }
+ur_queue_t_ *ur_event_handle_t_::getQueue() const { return hQueue; }
 
 ur_context_handle_t ur_event_handle_t_::getContext() const { return hContext; }
 

source/adapters/level_zero/v2/event.hpp

@@ -15,6 +15,7 @@
 #include <ur_api.h>
 #include <ze_api.h>
 
+#include "adapters/level_zero/v2/queue_api.hpp"
 #include "common.hpp"
 #include "event_provider.hpp"
 
@@ -61,7 +62,7 @@ struct ur_event_handle_t_ : _ur_object {
                      const ur_event_native_properties_t *pProperties);
 
   // Set the queue and command that this event is associated with
-  void resetQueueAndCommand(ur_queue_handle_t hQueue, ur_command_t commandType);
+  void resetQueueAndCommand(ur_queue_t_ *hQueue, ur_command_t commandType);
 
   // releases event immediately
   ur_result_t forceRelease();
@@ -86,7 +87,7 @@ struct ur_event_handle_t_ : _ur_object {
   bool isProfilingEnabled() const;
 
   // Queue associated with this event. Can be nullptr (for native events)
-  ur_queue_handle_t getQueue() const;
+  ur_queue_t_ *getQueue() const;
 
   // Context associated with this event
   ur_context_handle_t getContext() const;
@@ -119,7 +120,7 @@ struct ur_event_handle_t_ : _ur_object {
 
   // queue and commandType that this event is associated with, set by enqueue
   // commands
-  ur_queue_handle_t hQueue = nullptr;
+  ur_queue_t_ *hQueue = nullptr;
   ur_command_t commandType = UR_COMMAND_FORCE_UINT32;
 
   v2::event_flags_t flags;

source/adapters/level_zero/v2/kernel.cpp

@@ -14,6 +14,7 @@
 #include "kernel.hpp"
 #include "memory.hpp"
 #include "queue_api.hpp"
+#include "queue_handle.hpp"
 
 #include "../device.hpp"
 #include "../helpers/kernel_helpers.hpp"
@@ -656,8 +657,9 @@ ur_result_t urKernelGetSuggestedLocalWorkSize(
   std::copy(pGlobalWorkSize, pGlobalWorkSize + workDim, globalWorkSize3D);
 
   ur_device_handle_t hDevice;
-  UR_CALL(hQueue->queueGetInfo(UR_QUEUE_INFO_DEVICE, sizeof(hDevice),
-                               reinterpret_cast<void *>(&hDevice), nullptr));
+  UR_CALL(hQueue->get().queueGetInfo(UR_QUEUE_INFO_DEVICE, sizeof(hDevice),
+                                     reinterpret_cast<void *>(&hDevice),
+                                     nullptr));
 
   UR_CALL(getSuggestedLocalWorkSize(hDevice, hKernel->getZeHandle(hDevice),
                                     globalWorkSize3D, localWorkSize));