Add to L0v2 and fix compile errors.

martygrant · martygrant · commit dc52dce9f817 · 2025-06-05T15:58:16.000+01:00
diff --git a/unified-runtime/source/adapters/hip/adapter.cpp b/unified-runtime/source/adapters/hip/adapter.cpp
@@ -69,7 +69,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urAdapterGet(
 }
 
 UR_APIEXPORT ur_result_t UR_APICALL urAdapterRelease(ur_adapter_handle_t) {
-  if (--ur::hip::adapter->getRefCounter().decrement() == 0) {
+  if (ur::hip::adapter->getRefCounter().decrement() == 0) {
     delete ur::hip::adapter;
   }
 
diff --git a/unified-runtime/source/adapters/hip/memory.cpp b/unified-runtime/source/adapters/hip/memory.cpp
@@ -63,7 +63,7 @@ checkSupportedImageChannelType(ur_image_channel_type_t ImageChannelType) {
 UR_APIEXPORT ur_result_t UR_APICALL urMemRelease(ur_mem_handle_t hMem) {
   try {
     // Do nothing if there are other references
-    if (hMem->decrementReferenceCount() > 0) {
+    if (hMem->getRefCounter().decrement() > 0) {
       return UR_RESULT_SUCCESS;
     }
 
@@ -259,7 +259,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urMemGetInfo(ur_mem_handle_t hMemory,
     return ReturnValue(hMemory->getContext());
   }
   case UR_MEM_INFO_REFERENCE_COUNT: {
-    return ReturnValue(hMemory->getReferenceCount());
+    return ReturnValue(hMemory->getRefCounter().getCount());
   }
 
   default:
@@ -439,8 +439,9 @@ UR_APIEXPORT ur_result_t UR_APICALL urMemImageGetInfo(ur_mem_handle_t hMemory,
 }
 
 UR_APIEXPORT ur_result_t UR_APICALL urMemRetain(ur_mem_handle_t hMem) {
-  UR_ASSERT(hMem->getReferenceCount() > 0, UR_RESULT_ERROR_INVALID_MEM_OBJECT);
-  hMem->incrementReferenceCount();
+  UR_ASSERT(hMem->getRefCounter().getCount() > 0,
+            UR_RESULT_ERROR_INVALID_MEM_OBJECT);
+  hMem->getRefCounter().increment();
   return UR_RESULT_SUCCESS;
 }
 
diff --git a/unified-runtime/source/adapters/hip/program.cpp b/unified-runtime/source/adapters/hip/program.cpp
@@ -385,7 +385,7 @@ urProgramGetInfo(ur_program_handle_t hProgram, ur_program_info_t propName,
 
   switch (propName) {
   case UR_PROGRAM_INFO_REFERENCE_COUNT:
-    return ReturnValue(hProgram-- > getRefCounter().getCount());
+    return ReturnValue(hProgram->getRefCounter().getCount());
   case UR_PROGRAM_INFO_CONTEXT:
     return ReturnValue(hProgram->Context);
   case UR_PROGRAM_INFO_NUM_DEVICES:
diff --git a/unified-runtime/source/adapters/level_zero/v2/command_buffer.cpp b/unified-runtime/source/adapters/level_zero/v2/command_buffer.cpp
@@ -237,15 +237,15 @@ urCommandBufferCreateExp(ur_context_handle_t context, ur_device_handle_t device,
 
 ur_result_t
 urCommandBufferRetainExp(ur_exp_command_buffer_handle_t hCommandBuffer) try {
-  hCommandBuffer->RefCount.increment();
+  hCommandBuffer->getRefCounter().increment();
   return UR_RESULT_SUCCESS;
 } catch (...) {
   return exceptionToResult(std::current_exception());
 }
 
 ur_result_t
 urCommandBufferReleaseExp(ur_exp_command_buffer_handle_t hCommandBuffer) try {
-  if (!hCommandBuffer->RefCount.decrementAndTest())
+  if (!hCommandBuffer->getRefCounter().decrement() == 0)
     return UR_RESULT_SUCCESS;
 
   delete hCommandBuffer;
@@ -683,7 +683,7 @@ urCommandBufferGetInfoExp(ur_exp_command_buffer_handle_t hCommandBuffer,
 
   switch (propName) {
   case UR_EXP_COMMAND_BUFFER_INFO_REFERENCE_COUNT:
-    return ReturnValue(uint32_t{hCommandBuffer->RefCount.load()});
+    return ReturnValue(uint32_t{hCommandBuffer->getRefCounter().getCount()});
   case UR_EXP_COMMAND_BUFFER_INFO_DESCRIPTOR: {
     ur_exp_command_buffer_desc_t Descriptor{};
     Descriptor.stype = UR_STRUCTURE_TYPE_EXP_COMMAND_BUFFER_DESC;
diff --git a/unified-runtime/source/adapters/level_zero/v2/command_buffer.hpp b/unified-runtime/source/adapters/level_zero/v2/command_buffer.hpp
@@ -12,6 +12,7 @@
 #include "../helpers/mutable_helpers.hpp"
 #include "command_list_manager.hpp"
 #include "common.hpp"
+#include "common/ur_ref_counter.hpp"
 #include "context.hpp"
 #include "kernel.hpp"
 #include "lockable.hpp"
@@ -59,6 +60,8 @@ struct ur_exp_command_buffer_handle_t_ : public ur_object {
       const ur_exp_command_buffer_sync_point_t *pSyncPointWaitList,
       uint32_t numSyncPointsInWaitList);
 
+  UR_ReferenceCounter &getRefCounter() noexcept { return RefCounter; }
+
 private:
   // Stores all sync points that are created by the command buffer.
   std::vector<ur_event_handle_t> syncPoints;
@@ -77,4 +80,6 @@ struct ur_exp_command_buffer_handle_t_ : public ur_object {
   bool isFinalized = false;
 
   ur_event_handle_t currentExecution = nullptr;
+
+  UR_ReferenceCounter RefCounter;
 };
diff --git a/unified-runtime/source/adapters/level_zero/v2/context.cpp b/unified-runtime/source/adapters/level_zero/v2/context.cpp
@@ -80,12 +80,12 @@ ur_context_handle_t_::ur_context_handle_t_(ze_context_handle_t hContext,
       defaultUSMPool(this, nullptr), asyncPool(this, nullptr) {}
 
 ur_result_t ur_context_handle_t_::retain() {
-  RefCount.increment();
+  RefCounter.increment();
   return UR_RESULT_SUCCESS;
 }
 
 ur_result_t ur_context_handle_t_::release() {
-  if (!RefCount.decrementAndTest())
+  if (!RefCounter.decrement() == 0)
     return UR_RESULT_SUCCESS;
 
   delete this;
@@ -191,7 +191,7 @@ ur_result_t urContextGetInfo(ur_context_handle_t hContext,
   case UR_CONTEXT_INFO_NUM_DEVICES:
     return ReturnValue(uint32_t(hContext->getDevices().size()));
   case UR_CONTEXT_INFO_REFERENCE_COUNT:
-    return ReturnValue(uint32_t{hContext->RefCount.load()});
+    return ReturnValue(uint32_t{hContext->getRefCounter().getCount()});
   case UR_CONTEXT_INFO_USM_MEMCPY2D_SUPPORT:
     // TODO: this is currently not implemented
     return ReturnValue(uint8_t{false});
diff --git a/unified-runtime/source/adapters/level_zero/v2/context.hpp b/unified-runtime/source/adapters/level_zero/v2/context.hpp
@@ -14,6 +14,8 @@
 
 #include "command_list_cache.hpp"
 #include "common.hpp"
+#include "common/ur_ref_counter.hpp"
+
 #include "event_pool_cache.hpp"
 #include "usm.hpp"
 
@@ -53,6 +55,8 @@ struct ur_context_handle_t_ : ur_object {
   // For that the Device or its root devices need to be in the context.
   bool isValidDevice(ur_device_handle_t Device) const;
 
+  UR_ReferenceCounter &getRefCounter() noexcept { return RefCounter; }
+
 private:
   const v2::raii::ze_context_handle_t hContext;
   const std::vector<ur_device_handle_t> hDevices;
@@ -69,4 +73,6 @@ struct ur_context_handle_t_ : ur_object {
 
   ur_usm_pool_handle_t_ defaultUSMPool;
   ur_usm_pool_handle_t_ asyncPool;
+
+  UR_ReferenceCounter RefCounter;
 };
diff --git a/unified-runtime/source/adapters/level_zero/v2/event.cpp b/unified-runtime/source/adapters/level_zero/v2/event.cpp
@@ -158,12 +158,12 @@ ze_event_handle_t ur_event_handle_t_::getZeEvent() const {
 }
 
 ur_result_t ur_event_handle_t_::retain() {
-  RefCount.increment();
+  RefCounter.increment();
   return UR_RESULT_SUCCESS;
 }
 
 ur_result_t ur_event_handle_t_::release() {
-  if (!RefCount.decrementAndTest())
+  if (!RefCounter.decrement() == 0)
     return UR_RESULT_SUCCESS;
 
   if (event_pool) {
@@ -256,7 +256,7 @@ ur_result_t urEventGetInfo(ur_event_handle_t hEvent, ur_event_info_t propName,
     }
   }
   case UR_EVENT_INFO_REFERENCE_COUNT: {
-    return returnValue(hEvent->RefCount.load());
+    return returnValue(hEvent->getRefCounter().increment());
   }
   case UR_EVENT_INFO_COMMAND_QUEUE: {
     auto urQueueHandle = reinterpret_cast<uintptr_t>(hEvent->getQueue()) -
diff --git a/unified-runtime/source/adapters/level_zero/v2/event.hpp b/unified-runtime/source/adapters/level_zero/v2/event.hpp
@@ -17,6 +17,7 @@
 
 #include "adapters/level_zero/v2/queue_api.hpp"
 #include "common.hpp"
+#include "common/ur_ref_counter.hpp"
 #include "event_provider.hpp"
 
 namespace v2 {
@@ -111,10 +112,14 @@ struct ur_event_handle_t_ : ur_object {
   uint64_t getEventStartTimestmap() const;
   uint64_t getEventEndTimestamp();
 
+  UR_ReferenceCounter &getRefCounter() noexcept { return RefCounter; }
+
 private:
   ur_event_handle_t_(ur_context_handle_t hContext, event_variant hZeEvent,
                      v2::event_flags_t flags, v2::event_pool *pool);
 
+  UR_ReferenceCounter RefCounter;
+
 protected:
   ur_context_handle_t hContext;
 
diff --git a/unified-runtime/source/adapters/level_zero/v2/event_pool.cpp b/unified-runtime/source/adapters/level_zero/v2/event_pool.cpp
@@ -51,8 +51,8 @@ void event_pool::free(ur_event_handle_t event) {
   freelist.push_back(event);
 
   // The event is still in the pool, so we need to increment the refcount
-  assert(event->RefCount.load() == 0);
-  event->RefCount.increment();
+  assert(event->getRefCounter().getCount() == 0);
+  event->getRefCounter().increment();
 }
 
 event_provider *event_pool::getProvider() const { return provider.get(); }
diff --git a/unified-runtime/source/adapters/level_zero/v2/kernel.cpp b/unified-runtime/source/adapters/level_zero/v2/kernel.cpp
@@ -97,7 +97,7 @@ ur_kernel_handle_t_::ur_kernel_handle_t_(
 }
 
 ur_result_t ur_kernel_handle_t_::release() {
-  if (!RefCount.decrementAndTest())
+  if (!RefCounter.decrement() == 0)
     return UR_RESULT_SUCCESS;
 
   // manually release kernels to allow errors to be propagated
@@ -370,7 +370,7 @@ urKernelCreateWithNativeHandle(ur_native_handle_t hNativeKernel,
 ur_result_t urKernelRetain(
     /// [in] handle for the Kernel to retain
     ur_kernel_handle_t hKernel) try {
-  hKernel->RefCount.increment();
+  hKernel->getRefCounter().increment();
   return UR_RESULT_SUCCESS;
 } catch (...) {
   return exceptionToResult(std::current_exception());
@@ -634,7 +634,7 @@ ur_result_t urKernelGetInfo(ur_kernel_handle_t hKernel,
                        spills.size());
   }
   case UR_KERNEL_INFO_REFERENCE_COUNT:
-    return ReturnValue(uint32_t{hKernel->RefCount.load()});
+    return ReturnValue(uint32_t{hKernel->getRefCounter().getCount()});
   case UR_KERNEL_INFO_ATTRIBUTES: {
     auto attributes = hKernel->getSourceAttributes();
     return ReturnValue(static_cast<const char *>(attributes.data()));
diff --git a/unified-runtime/source/adapters/level_zero/v2/kernel.hpp b/unified-runtime/source/adapters/level_zero/v2/kernel.hpp
@@ -13,6 +13,7 @@
 #include "../program.hpp"
 
 #include "common.hpp"
+#include "common/ur_ref_counter.hpp"
 #include "memory.hpp"
 
 struct ur_single_device_kernel_t {
@@ -91,6 +92,8 @@ struct ur_kernel_handle_t_ : ur_object {
                                    ze_command_list_handle_t cmdList,
                                    wait_list_view &waitListView);
 
+  UR_ReferenceCounter &getRefCounter() noexcept { return RefCounter; }
+
 private:
   // Keep the program of the kernel.
   const ur_program_handle_t hProgram;
@@ -116,4 +119,6 @@ struct ur_kernel_handle_t_ : ur_object {
 
   // pointer to any non-null kernel in deviceKernels
   ur_single_device_kernel_t *nonEmptyKernel;
+
+  UR_ReferenceCounter RefCounter;
 };
diff --git a/unified-runtime/source/adapters/level_zero/v2/memory.cpp b/unified-runtime/source/adapters/level_zero/v2/memory.cpp
@@ -671,7 +671,7 @@ ur_result_t urMemGetInfo(ur_mem_handle_t hMem, ur_mem_info_t propName,
     return returnValue(size_t{hMem->getBuffer()->getSize()});
   }
   case UR_MEM_INFO_REFERENCE_COUNT: {
-    return returnValue(hMem->getObject()->RefCount.load());
+    return returnValue(hMem->getRefCounter().getCount());
   }
   default: {
     return UR_RESULT_ERROR_INVALID_ENUMERATION;
@@ -684,14 +684,14 @@ ur_result_t urMemGetInfo(ur_mem_handle_t hMem, ur_mem_info_t propName,
 }
 
 ur_result_t urMemRetain(ur_mem_handle_t hMem) try {
-  hMem->getObject()->RefCount.increment();
+  hMem->getRefCounter().increment();
   return UR_RESULT_SUCCESS;
 } catch (...) {
   return exceptionToResult(std::current_exception());
 }
 
 ur_result_t urMemRelease(ur_mem_handle_t hMem) try {
-  if (!hMem->getObject()->RefCount.decrementAndTest())
+  if (!hMem->getRefCounter().decrement() == 0)
     return UR_RESULT_SUCCESS;
 
   delete hMem;
diff --git a/unified-runtime/source/adapters/level_zero/v2/memory.hpp b/unified-runtime/source/adapters/level_zero/v2/memory.hpp
@@ -19,6 +19,7 @@
 #include "../image_common.hpp"
 #include "command_list_manager.hpp"
 #include "common.hpp"
+#include "common/ur_ref_counter.hpp"
 #include "lockable.hpp"
 
 using usm_unique_ptr_t = std::unique_ptr<void, std::function<void(void *)>>;
@@ -280,16 +281,10 @@ struct ur_mem_handle_t_ : ur::handle_base<ur::level_zero::ddi_getter> {
         mem);
   }
 
-  ur_object *getObject() {
-    return std::visit(
-        [](auto &&arg) -> ur_object * {
-          return static_cast<ur_object *>(&arg);
-        },
-        mem);
-  }
-
   bool isImage() const { return std::holds_alternative<ur_mem_image_t>(mem); }
 
+  UR_ReferenceCounter &getRefCounter() noexcept { return RefCounter; }
+
 private:
   template <typename T, typename... Args>
   ur_mem_handle_t_(std::in_place_type_t<T>, Args &&...args)
@@ -300,4 +295,6 @@ struct ur_mem_handle_t_ : ur::handle_base<ur::level_zero::ddi_getter> {
                ur_discrete_buffer_handle_t, ur_shared_buffer_handle_t,
                ur_mem_sub_buffer_t, ur_mem_image_t>
       mem;
+
+  UR_ReferenceCounter RefCounter;
 };
diff --git a/unified-runtime/source/adapters/level_zero/v2/queue_handle.hpp b/unified-runtime/source/adapters/level_zero/v2/queue_handle.hpp
@@ -48,7 +48,7 @@ struct ur_queue_handle_t_ : ur::handle_base<ur::level_zero::ddi_getter> {
   ur_result_t queueRetain() {
     return std::visit(
         [](auto &q) {
-          q.RefCount.increment();
+          q.getRefCounter().increment();
           return UR_RESULT_SUCCESS;
         },
         queue_data);
@@ -57,7 +57,7 @@ struct ur_queue_handle_t_ : ur::handle_base<ur::level_zero::ddi_getter> {
   ur_result_t queueRelease() {
     return std::visit(
         [queueHandle = this](auto &q) {
-          if (!q.RefCount.decrementAndTest())
+          if (!q.getRefCounter().decrement() == 0)
             return UR_RESULT_SUCCESS;
           delete queueHandle;
           return UR_RESULT_SUCCESS;
diff --git a/unified-runtime/source/adapters/level_zero/v2/queue_immediate_in_order.cpp b/unified-runtime/source/adapters/level_zero/v2/queue_immediate_in_order.cpp
@@ -113,7 +113,7 @@ ur_queue_immediate_in_order_t::queueGetInfo(ur_queue_info_t propName,
   case UR_QUEUE_INFO_DEVICE:
     return ReturnValue(hDevice);
   case UR_QUEUE_INFO_REFERENCE_COUNT:
-    return ReturnValue(uint32_t{RefCount.load()});
+    return ReturnValue(uint32_t{RefCounter.getCount()});
   case UR_QUEUE_INFO_FLAGS:
     return ReturnValue(flags);
   case UR_QUEUE_INFO_SIZE:
@@ -173,7 +173,7 @@ ur_result_t ur_queue_immediate_in_order_t::queueFinish() {
 void ur_queue_immediate_in_order_t::recordSubmittedKernel(
     ur_kernel_handle_t hKernel) {
   submittedKernels.push_back(hKernel);
-  hKernel->RefCount.increment();
+  hKernel->getRefCounter().increment();
 }
 
 ur_result_t ur_queue_immediate_in_order_t::queueFlush() {
@@ -852,7 +852,7 @@ ur_result_t ur_queue_immediate_in_order_t::enqueueUSMFreeExp(
   if (internalEvent == nullptr) {
     // When the output event is used instead of an internal event, we need to
     // increment the refcount.
-    (*phEvent)->RefCount.increment();
+    (*phEvent)->getRefCounter().increment();
   }
 
   if (numWaitEvents > 0) {
diff --git a/unified-runtime/source/adapters/level_zero/v2/queue_immediate_in_order.hpp b/unified-runtime/source/adapters/level_zero/v2/queue_immediate_in_order.hpp
@@ -11,6 +11,7 @@
 
 #include "../common.hpp"
 #include "../device.hpp"
+#include "common/ur_ref_counter.hpp"
 
 #include "context.hpp"
 #include "event.hpp"
@@ -284,6 +285,11 @@ struct ur_queue_immediate_in_order_t : ur_object, public ur_queue_t_ {
                           const ur_exp_enqueue_native_command_properties_t *,
                           uint32_t, const ur_event_handle_t *,
                           ur_event_handle_t *) override;
+
+  UR_ReferenceCounter &getRefCounter() noexcept { return RefCounter; }
+
+private:
+  UR_ReferenceCounter RefCounter;
 };
 
 } // namespace v2
diff --git a/unified-runtime/source/adapters/level_zero/v2/usm.cpp b/unified-runtime/source/adapters/level_zero/v2/usm.cpp
diff --git a/unified-runtime/source/adapters/level_zero/v2/usm.hpp b/unified-runtime/source/adapters/level_zero/v2/usm.hpp
diff --git a/unified-runtime/source/loader/layers/sanitizer/asan/asan_interceptor.hpp b/unified-runtime/source/loader/layers/sanitizer/asan/asan_interceptor.hpp
diff --git a/unified-runtime/source/loader/layers/sanitizer/msan/msan_interceptor.hpp b/unified-runtime/source/loader/layers/sanitizer/msan/msan_interceptor.hpp

Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urAdapterGet(`
`69`	`69`	`}`
`70`	`70`
`71`	`71`	`UR_APIEXPORT ur_result_t UR_APICALL urAdapterRelease(ur_adapter_handle_t) {`
`72`		`- if (--ur::hip::adapter->getRefCounter().decrement() == 0) {`
	`72`	`+ if (ur::hip::adapter->getRefCounter().decrement() == 0) {`
`73`	`73`	`delete ur::hip::adapter;`
`74`	`74`	`}`
`75`	`75`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ checkSupportedImageChannelType(ur_image_channel_type_t ImageChannelType) {`
`63`	`63`	`UR_APIEXPORT ur_result_t UR_APICALL urMemRelease(ur_mem_handle_t hMem) {`
`64`	`64`	`try {`
`65`	`65`	`// Do nothing if there are other references`
`66`		`- if (hMem->decrementReferenceCount() > 0) {`
	`66`	`+ if (hMem->getRefCounter().decrement() > 0) {`
`67`	`67`	`return UR_RESULT_SUCCESS;`
`68`	`68`	`}`
`69`	`69`
`@@ -259,7 +259,7 @@ UR_APIEXPORT ur_result_t UR_APICALL urMemGetInfo(ur_mem_handle_t hMemory,`
`259`	`259`	`return ReturnValue(hMemory->getContext());`
`260`	`260`	`}`
`261`	`261`	`case UR_MEM_INFO_REFERENCE_COUNT: {`
`262`		`- return ReturnValue(hMemory->getReferenceCount());`
	`262`	`+ return ReturnValue(hMemory->getRefCounter().getCount());`
`263`	`263`	`}`
`264`	`264`
`265`	`265`	`default:`
`@@ -439,8 +439,9 @@ UR_APIEXPORT ur_result_t UR_APICALL urMemImageGetInfo(ur_mem_handle_t hMemory,`
`439`	`439`	`}`
`440`	`440`
`441`	`441`	`UR_APIEXPORT ur_result_t UR_APICALL urMemRetain(ur_mem_handle_t hMem) {`
`442`		`- UR_ASSERT(hMem->getReferenceCount() > 0, UR_RESULT_ERROR_INVALID_MEM_OBJECT);`
`443`		`- hMem->incrementReferenceCount();`
	`442`	`+ UR_ASSERT(hMem->getRefCounter().getCount() > 0,`
	`443`	`+ UR_RESULT_ERROR_INVALID_MEM_OBJECT);`
	`444`	`+ hMem->getRefCounter().increment();`
`444`	`445`	`return UR_RESULT_SUCCESS;`
`445`	`446`	`}`
`446`	`447`
Original file line number	Diff line number	Diff line change
`@@ -158,12 +158,12 @@ ze_event_handle_t ur_event_handle_t_::getZeEvent() const {`
`158`	`158`	`}`
`159`	`159`
`160`	`160`	`ur_result_t ur_event_handle_t_::retain() {`
`161`		`- RefCount.increment();`
	`161`	`+ RefCounter.increment();`
`162`	`162`	`return UR_RESULT_SUCCESS;`
`163`	`163`	`}`
`164`	`164`
`165`	`165`	`ur_result_t ur_event_handle_t_::release() {`
`166`		`- if (!RefCount.decrementAndTest())`
	`166`	`+ if (!RefCounter.decrement() == 0)`
`167`	`167`	`return UR_RESULT_SUCCESS;`
`168`	`168`
`169`	`169`	`if (event_pool) {`
`@@ -256,7 +256,7 @@ ur_result_t urEventGetInfo(ur_event_handle_t hEvent, ur_event_info_t propName,`
`256`	`256`	`}`
`257`	`257`	`}`
`258`	`258`	`case UR_EVENT_INFO_REFERENCE_COUNT: {`
`259`		`- return returnValue(hEvent->RefCount.load());`
	`259`	`+ return returnValue(hEvent->getRefCounter().increment());`
`260`	`260`	`}`
`261`	`261`	`case UR_EVENT_INFO_COMMAND_QUEUE: {`
`262`	`262`	`auto urQueueHandle = reinterpret_cast<uintptr_t>(hEvent->getQueue()) -`
Original file line number	Diff line number	Diff line change
`@@ -51,8 +51,8 @@ void event_pool::free(ur_event_handle_t event) {`
`51`	`51`	`freelist.push_back(event);`
`52`	`52`
`53`	`53`	`// The event is still in the pool, so we need to increment the refcount`
`54`		`- assert(event->RefCount.load() == 0);`
`55`		`- event->RefCount.increment();`
	`54`	`+ assert(event->getRefCounter().getCount() == 0);`
	`55`	`+ event->getRefCounter().increment();`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`event_provider *event_pool::getProvider() const { return provider.get(); }`