[CTS] Fix resource leaks

This patch introduces the `uur::raii::Wrapper<T>` object and per handle
aliases (`uur::raii::Context` for `ur_context_handle_t` etc.) to replace
instances of the following pattern in test bodies:

```cpp
TEST(Context, Example) {
    ur_context_handle_t context = nullptr;
    ASSERT_SUCCESS(urContextCreate(1, &device, nullptr, &context));

    // potential resource leak as `ASSERT_*` returns from this function
    ASSERT_TRUE(might_be_false);

    urContextRelease(context);
}
```

With the following:

```cpp
TEST(Context, Example) {
    uur::raii::Context context = nullptr;
    ASSERT_SUCCESS(urContextCreate(1, &device, nullptr, context.ptr()));

    // no leak because the destructor releases the context
    ASSERT_TRUE(might_be_false);
}
```

Author: kbenzie

test/adapters/cuda/context_tests.cpp

@@ -6,6 +6,7 @@
 #include "context.hpp"
 #include "fixtures.h"
 #include "queue.hpp"
+#include "uur/raii.h"
 #include <thread>
 
 using cudaUrContextCreateTest = uur::urDeviceTest;
@@ -14,14 +15,13 @@ UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(cudaUrContextCreateTest);
 constexpr unsigned int known_cuda_api_version = 3020;
 
 TEST_P(cudaUrContextCreateTest, CreateWithChildThread) {
-
-    ur_context_handle_t context = nullptr;
-    ASSERT_SUCCESS(urContextCreate(1, &device, nullptr, &context));
+    uur::raii::Context context = nullptr;
+    ASSERT_SUCCESS(urContextCreate(1, &device, nullptr, context.ptr()));
     ASSERT_NE(context, nullptr);
 
     // Retrieve the CUDA context to check information is correct
     auto checkValue = [=] {
-        CUcontext cudaContext = context->get();
+        CUcontext cudaContext = context.handle->get();
         unsigned int version = 0;
         EXPECT_SUCCESS_CUDA(cuCtxGetApiVersion(cudaContext, &version));
         EXPECT_EQ(version, known_cuda_api_version);
@@ -39,27 +39,26 @@ TEST_P(cudaUrContextCreateTest, CreateWithChildThread) {
 
     auto callContextFromOtherThread = std::thread(checkValue);
     callContextFromOtherThread.join();
-    ASSERT_SUCCESS(urContextRelease(context));
 }
 
 TEST_P(cudaUrContextCreateTest, ActiveContext) {
-    ur_context_handle_t context = nullptr;
-    ASSERT_SUCCESS(urContextCreate(1, &device, nullptr, &context));
+    uur::raii::Context context = nullptr;
+    ASSERT_SUCCESS(urContextCreate(1, &device, nullptr, context.ptr()));
     ASSERT_NE(context, nullptr);
 
-    ur_queue_handle_t queue = nullptr;
+    uur::raii::Queue queue = nullptr;
     ur_queue_properties_t queue_props{UR_STRUCTURE_TYPE_QUEUE_PROPERTIES,
                                       nullptr, 0};
-    ASSERT_SUCCESS(urQueueCreate(context, device, &queue_props, &queue));
+    ASSERT_SUCCESS(urQueueCreate(context, device, &queue_props, queue.ptr()));
     ASSERT_NE(queue, nullptr);
 
     // check that the queue has the correct context
     ASSERT_EQ(context, queue->getContext());
 
     // create a buffer
-    ur_mem_handle_t buffer = nullptr;
+    uur::raii::Mem buffer = nullptr;
     ASSERT_SUCCESS(urMemBufferCreate(context, UR_MEM_FLAG_READ_WRITE, 1024,
-                                     nullptr, &buffer));
+                                     nullptr, buffer.ptr()));
     ASSERT_NE(buffer, nullptr);
 
     // check that the context is now the active CUDA context
@@ -71,11 +70,6 @@ TEST_P(cudaUrContextCreateTest, ActiveContext) {
     ASSERT_SUCCESS(urContextGetNativeHandle(context, &native_context));
     ASSERT_NE(native_context, nullptr);
     ASSERT_EQ(cudaCtx, reinterpret_cast<CUcontext>(native_context));
-
-    // release resources
-    ASSERT_SUCCESS(urMemRelease(buffer));
-    ASSERT_SUCCESS(urQueueRelease(queue));
-    ASSERT_SUCCESS(urContextRelease(context));
 }
 
 TEST_P(cudaUrContextCreateTest, ContextLifetimeExisting) {
@@ -89,13 +83,13 @@ TEST_P(cudaUrContextCreateTest, ContextLifetimeExisting) {
     ASSERT_EQ(original, current);
 
     // create a UR context
-    ur_context_handle_t context;
-    ASSERT_SUCCESS(urContextCreate(1, &device, nullptr, &context));
+    uur::raii::Context context;
+    ASSERT_SUCCESS(urContextCreate(1, &device, nullptr, context.ptr()));
     ASSERT_NE(context, nullptr);
 
     // create a queue with the context
-    ur_queue_handle_t queue;
-    ASSERT_SUCCESS(urQueueCreate(context, device, nullptr, &queue));
+    uur::raii::Queue queue;
+    ASSERT_SUCCESS(urQueueCreate(context, device, nullptr, queue.ptr()));
     ASSERT_NE(queue, nullptr);
 
     // ensure the queue has the correct context
@@ -109,19 +103,16 @@ TEST_P(cudaUrContextCreateTest, ContextLifetimeExisting) {
     // check that context is now the active cuda context
     ASSERT_SUCCESS_CUDA(cuCtxGetCurrent(&current));
     ASSERT_EQ(current, context->get());
-
-    ASSERT_SUCCESS(urQueueRelease(queue));
-    ASSERT_SUCCESS(urContextRelease(context));
 }
 
 TEST_P(cudaUrContextCreateTest, ThreadedContext) {
     // create two new UR contexts
-    ur_context_handle_t context1;
-    ASSERT_SUCCESS(urContextCreate(1, &device, nullptr, &context1));
+    uur::raii::Context context1;
+    ASSERT_SUCCESS(urContextCreate(1, &device, nullptr, context1.ptr()));
     ASSERT_NE(context1, nullptr);
 
-    ur_context_handle_t context2;
-    ASSERT_SUCCESS(urContextCreate(1, &device, nullptr, &context2));
+    uur::raii::Context context2;
+    ASSERT_SUCCESS(urContextCreate(1, &device, nullptr, context2.ptr()));
     ASSERT_NE(context2, nullptr);
 
     // setup synchronization variables between the main thread and
@@ -138,23 +129,22 @@ TEST_P(cudaUrContextCreateTest, ThreadedContext) {
     auto test_thread = std::thread([&] {
         CUcontext current = nullptr;
 
-        // create a queue with the first context
-        ur_queue_handle_t queue;
-        ASSERT_SUCCESS(urQueueCreate(context1, device, nullptr, &queue));
-        ASSERT_NE(queue, nullptr);
-
-        // ensure that the queue has the correct context
-        ASSERT_EQ(context1, queue->getContext());
+        {
+            // create a queue with the first context
+            uur::raii::Queue queue;
+            ASSERT_SUCCESS(
+                urQueueCreate(context1, device, nullptr, queue.ptr()));
+            ASSERT_NE(queue, nullptr);
 
-        // create a buffer to set context1 as the active context
-        ur_mem_handle_t buffer;
-        ASSERT_SUCCESS(urMemBufferCreate(context1, UR_MEM_FLAG_READ_WRITE, 1024,
-                                         nullptr, &buffer));
-        ASSERT_NE(buffer, nullptr);
+            // ensure that the queue has the correct context
+            ASSERT_EQ(context1, queue->getContext());
 
-        // release the mem and queue
-        ASSERT_SUCCESS(urMemRelease(buffer));
-        ASSERT_SUCCESS(urQueueRelease(queue));
+            // create a buffer to set context1 as the active context
+            uur::raii::Mem buffer;
+            ASSERT_SUCCESS(urMemBufferCreate(context1, UR_MEM_FLAG_READ_WRITE,
+                                             1024, nullptr, buffer.ptr()));
+            ASSERT_NE(buffer, nullptr);
+        }
 
         // mark the first set of processing as done and notify the main thread
         std::unique_lock<std::mutex> lock(m);
@@ -166,31 +156,31 @@ TEST_P(cudaUrContextCreateTest, ThreadedContext) {
         lock.lock();
         cv.wait(lock, [&] { return released; });
 
-        // create a queue with the 2nd context
-        ASSERT_SUCCESS(urQueueCreate(context2, device, nullptr, &queue));
-        ASSERT_NE(queue, nullptr);
-
-        // ensure queue has correct context
-        ASSERT_EQ(context2, queue->getContext());
-
-        // create a buffer to set the active context
-        ASSERT_SUCCESS(urMemBufferCreate(context2, UR_MEM_FLAG_READ_WRITE, 1024,
-                                         nullptr, &buffer));
-
-        // check that the 2nd context is now tha active cuda context
-        ASSERT_SUCCESS_CUDA(cuCtxGetCurrent(&current));
-        ASSERT_EQ(current, context2->get());
-
-        // release
-        ASSERT_SUCCESS(urMemRelease(buffer));
-        ASSERT_SUCCESS(urQueueRelease(queue));
+        {
+            // create a queue with the 2nd context
+            uur::raii::Queue queue = nullptr;
+            ASSERT_SUCCESS(
+                urQueueCreate(context2, device, nullptr, queue.ptr()));
+            ASSERT_NE(queue, nullptr);
+
+            // ensure queue has correct context
+            ASSERT_EQ(context2, queue->getContext());
+
+            // create a buffer to set the active context
+            uur::raii::Mem buffer = nullptr;
+            ASSERT_SUCCESS(urMemBufferCreate(context2, UR_MEM_FLAG_READ_WRITE,
+                                             1024, nullptr, buffer.ptr()));
+
+            // check that the 2nd context is now tha active cuda context
+            ASSERT_SUCCESS_CUDA(cuCtxGetCurrent(&current));
+            ASSERT_EQ(current, context2->get());
+        }
     });
 
     // wait for the thread to be done with the first queue to release the first
     // context
     std::unique_lock<std::mutex> lock(m);
     cv.wait(lock, [&] { return thread_done; });
-    ASSERT_SUCCESS(urContextRelease(context1));
 
     // notify the other thread that the context was released
     released = true;
@@ -199,6 +189,4 @@ TEST_P(cudaUrContextCreateTest, ThreadedContext) {
 
     // wait for the thread to finish
     test_thread.join();
-
-    ASSERT_SUCCESS(urContextRelease(context2));
 }