Hopefully fix more CI issues.

aarongreig · aarongreig · commit 1bc7a96cb4f7 · 2024-07-09T16:56:08.000+01:00
diff --git a/scripts/templates/mockddi.cpp.mako b/scripts/templates/mockddi.cpp.mako
@@ -95,15 +95,25 @@ namespace driver
                 *ppMem = mock::createDummyHandle<void *>(size);
             %elif re.search(r"USMPitchedAllocExp$", fname):
                 *ppMem = mock::createDummyHandle<void *>(widthInBytes * height);
-            %else:
-                %if fname == 'urAdapterGet' or fname == 'urDeviceGet' or fname == 'urPlatformGet':
+            ## We need a special case for USM free since it doesn't have the handle release tag
+            %elif re.search(r"USMFree$", fname):
+                mock::releaseDummyHandle(pMem);
+            ## adapter, platform and device have special lifetime considerations
+            %elif 'urAdapter' in fname or 'urDevice' in fname or 'urPlatform' in fname:
+                %if re.match(r"ur(.*)Get$", fname):
                     <%
                         num_param = th.find_param_name(".*pNum.*", n, tags, obj)
+                        object = re.match(r"ur(.*)Get", fname).group(1)
+                        out_param = "ph" + object + "s"
                     %>
                     if(${num_param}) {
                         *${num_param} = 1;
                     }
+                    if(${out_param}) {
+                        *${out_param} = d_context.${object.lower()};
+                    }
                 %endif
+            %else:
                 %for item in epilogue:
                     %if item['release']:
                         mock::releaseDummyHandle(${item['name']});
diff --git a/source/adapters/mock/ur_mock.hpp b/source/adapters/mock/ur_mock.hpp
@@ -25,6 +25,10 @@ class __urdlllocal context_t {
     ur_dditable_t urDdiTable = {};
     context_t();
     ~context_t() = default;
+
+    ur_adapter_handle_t adapter = reinterpret_cast<ur_adapter_handle_t>(1);
+    ur_device_handle_t device = reinterpret_cast<ur_device_handle_t>(2);
+    ur_platform_handle_t platform = reinterpret_cast<ur_platform_handle_t>(3);
 };
 
 extern context_t d_context;
diff --git a/source/adapters/mock/ur_mockddi.cpp b/source/adapters/mock/ur_mockddi.cpp
@@ -50,9 +50,8 @@ __urdlllocal ur_result_t UR_APICALL urAdapterGet(
         if (pNumAdapters) {
             *pNumAdapters = 1;
         }
-        // optional output handle
         if (phAdapters) {
-            *phAdapters = mock::createDummyHandle<ur_adapter_handle_t>();
+            *phAdapters = d_context.adapter;
         }
         result = UR_RESULT_SUCCESS;
     }
@@ -96,7 +95,6 @@ __urdlllocal ur_result_t UR_APICALL urAdapterRelease(
         result = replaceCallback(&params);
     } else {
 
-        mock::releaseDummyHandle(hAdapter);
         result = UR_RESULT_SUCCESS;
     }
 
@@ -139,7 +137,6 @@ __urdlllocal ur_result_t UR_APICALL urAdapterRetain(
         result = replaceCallback(&params);
     } else {
 
-        mock::retainDummyHandle(hAdapter);
         result = UR_RESULT_SUCCESS;
     }
 
@@ -301,9 +298,8 @@ __urdlllocal ur_result_t UR_APICALL urPlatformGet(
         if (pNumPlatforms) {
             *pNumPlatforms = 1;
         }
-        // optional output handle
         if (phPlatforms) {
-            *phPlatforms = mock::createDummyHandle<ur_platform_handle_t>();
+            *phPlatforms = d_context.platform;
         }
         result = UR_RESULT_SUCCESS;
     }
@@ -609,9 +605,8 @@ __urdlllocal ur_result_t UR_APICALL urDeviceGet(
         if (pNumDevices) {
             *pNumDevices = 1;
         }
-        // optional output handle
         if (phDevices) {
-            *phDevices = mock::createDummyHandle<ur_device_handle_t>();
+            *phDevices = d_context.device;
         }
         result = UR_RESULT_SUCCESS;
     }
@@ -710,7 +705,6 @@ __urdlllocal ur_result_t UR_APICALL urDeviceRetain(
         result = replaceCallback(&params);
     } else {
 
-        mock::retainDummyHandle(hDevice);
         result = UR_RESULT_SUCCESS;
     }
 
@@ -754,7 +748,6 @@ __urdlllocal ur_result_t UR_APICALL urDeviceRelease(
         result = replaceCallback(&params);
     } else {
 
-        mock::releaseDummyHandle(hDevice);
         result = UR_RESULT_SUCCESS;
     }
 
@@ -808,10 +801,6 @@ __urdlllocal ur_result_t UR_APICALL urDevicePartition(
         result = replaceCallback(&params);
     } else {
 
-        // optional output handle
-        if (phSubDevices) {
-            *phSubDevices = mock::createDummyHandle<ur_device_handle_t>();
-        }
         result = UR_RESULT_SUCCESS;
     }
 
@@ -2355,6 +2344,7 @@ __urdlllocal ur_result_t UR_APICALL urUSMFree(
         result = replaceCallback(&params);
     } else {
 
+        mock::releaseDummyHandle(pMem);
         result = UR_RESULT_SUCCESS;
     }
 
diff --git a/source/loader/ur_lib.hpp b/source/loader/ur_lib.hpp
@@ -48,7 +48,7 @@ struct ur_loader_config_handle_t_ {
     std::set<std::string> &getEnabledLayerNames() { return enabledLayers; }
 
     codeloc_data codelocData;
-    bool enableMock;
+    bool enableMock = false;
 };
 
 namespace ur_lib {
diff --git a/test/conformance/source/environment.cpp b/test/conformance/source/environment.cpp
@@ -65,7 +65,8 @@ uur::PlatformEnvironment::PlatformEnvironment(int argc, char **argv)
 
     ur_loader_config_handle_t config;
     if (urLoaderConfigCreate(&config) == UR_RESULT_SUCCESS) {
-        if (urLoaderConfigEnableLayer(config, "UR_LAYER_FULL_VALIDATION")) {
+        if (urLoaderConfigEnableLayer(config, "UR_LAYER_FULL_VALIDATION") !=
+            UR_RESULT_SUCCESS) {
             urLoaderConfigRelease(config);
             error = "Failed to enable validation layer";
             return;
diff --git a/test/layers/validation/fixtures.hpp b/test/layers/validation/fixtures.hpp
@@ -132,7 +132,7 @@ inline ur_result_t genericSuccessCallback(void *) { return UR_RESULT_SUCCESS; };
 
 // This returns valid (non-null) handles that we can safely leak.
 inline ur_result_t fakeContext_urContextCreate(void *pParams) {
-    static std::atomic_int handle = 1;
+    static std::atomic_int handle = 42;
     auto params = *static_cast<ur_context_create_params_t *>(pParams);
     **params.pphContext = reinterpret_cast<ur_context_handle_t>(handle++);
     return UR_RESULT_SUCCESS;
diff --git a/test/mock/mock.cpp b/test/mock/mock.cpp
@@ -51,27 +51,24 @@ TEST(Mock, DefaultBehavior) {
     ASSERT_EQ(urDeviceRelease(device), UR_RESULT_SUCCESS);
 }
 
-void checkPreInitAdapter(ur_adapter_handle_t adapter) {
-    ur_adapter_handle_t preInitAdapter =
-        reinterpret_cast<ur_adapter_handle_t>(0xF00DCAFE);
-    ASSERT_EQ(adapter, preInitAdapter);
-}
-
 ur_result_t beforeUrAdapterGet(void *pParams) {
     auto params = reinterpret_cast<ur_adapter_get_params_t *>(pParams);
-    checkPreInitAdapter(**params->pphAdapters);
+    ur_adapter_handle_t preInitAdapter =
+        reinterpret_cast<ur_adapter_handle_t>(uintptr_t(0xF00DCAFE));
+    EXPECT_EQ(**params->pphAdapters, preInitAdapter);
     return UR_RESULT_SUCCESS;
 }
 
 ur_result_t replaceUrAdapterGet(void *pParams) {
     auto params = reinterpret_cast<ur_adapter_get_params_t *>(pParams);
-    **params->pphAdapters = reinterpret_cast<ur_adapter_handle_t>(0xDEADBEEF);
+    **params->pphAdapters =
+        reinterpret_cast<ur_adapter_handle_t>(uintptr_t(0xDEADBEEF));
     return UR_RESULT_SUCCESS;
 }
 
 void checkPostInitAdapter(ur_adapter_handle_t adapter) {
     ur_adapter_handle_t postInitAdapter =
-        reinterpret_cast<ur_adapter_handle_t>(0xDEADBEEF);
+        reinterpret_cast<ur_adapter_handle_t>(uintptr_t(0xDEADBEEF));
     ASSERT_EQ(adapter, postInitAdapter);
 }
 
@@ -102,6 +99,6 @@ TEST(Mock, Callbacks) {
     mock::getCallbacks().set_after_callback("urAdapterGet", &afterUrAdapterGet);
 
     ur_adapter_handle_t adapter =
-        reinterpret_cast<ur_adapter_handle_t>(0xF00DCAFE);
+        reinterpret_cast<ur_adapter_handle_t>(uintptr_t(0xF00DCAFE));
     ASSERT_EQ(urAdapterGet(1, &adapter, nullptr), UR_RESULT_SUCCESS);
 }

Original file line number	Diff line number	Diff line change
`@@ -50,9 +50,8 @@ __urdlllocal ur_result_t UR_APICALL urAdapterGet(`
`50`	`50`	`if (pNumAdapters) {`
`51`	`51`	`*pNumAdapters = 1;`
`52`	`52`	`}`
`53`		`- // optional output handle`
`54`	`53`	`if (phAdapters) {`
`55`		`- *phAdapters = mock::createDummyHandle<ur_adapter_handle_t>();`
	`54`	`+ *phAdapters = d_context.adapter;`
`56`	`55`	`}`
`57`	`56`	`result = UR_RESULT_SUCCESS;`
`58`	`57`	`}`
`@@ -96,7 +95,6 @@ __urdlllocal ur_result_t UR_APICALL urAdapterRelease(`
`96`	`95`	`result = replaceCallback(&params);`
`97`	`96`	`} else {`
`98`	`97`
`99`		`- mock::releaseDummyHandle(hAdapter);`
`100`	`98`	`result = UR_RESULT_SUCCESS;`
`101`	`99`	`}`
`102`	`100`
`@@ -139,7 +137,6 @@ __urdlllocal ur_result_t UR_APICALL urAdapterRetain(`
`139`	`137`	`result = replaceCallback(&params);`
`140`	`138`	`} else {`
`141`	`139`
`142`		`- mock::retainDummyHandle(hAdapter);`
`143`	`140`	`result = UR_RESULT_SUCCESS;`
`144`	`141`	`}`
`145`	`142`
`@@ -301,9 +298,8 @@ __urdlllocal ur_result_t UR_APICALL urPlatformGet(`
`301`	`298`	`if (pNumPlatforms) {`
`302`	`299`	`*pNumPlatforms = 1;`
`303`	`300`	`}`
`304`		`- // optional output handle`
`305`	`301`	`if (phPlatforms) {`
`306`		`- *phPlatforms = mock::createDummyHandle<ur_platform_handle_t>();`
	`302`	`+ *phPlatforms = d_context.platform;`
`307`	`303`	`}`
`308`	`304`	`result = UR_RESULT_SUCCESS;`
`309`	`305`	`}`
`@@ -609,9 +605,8 @@ __urdlllocal ur_result_t UR_APICALL urDeviceGet(`
`609`	`605`	`if (pNumDevices) {`
`610`	`606`	`*pNumDevices = 1;`
`611`	`607`	`}`
`612`		`- // optional output handle`
`613`	`608`	`if (phDevices) {`
`614`		`- *phDevices = mock::createDummyHandle<ur_device_handle_t>();`
	`609`	`+ *phDevices = d_context.device;`
`615`	`610`	`}`
`616`	`611`	`result = UR_RESULT_SUCCESS;`
`617`	`612`	`}`
`@@ -710,7 +705,6 @@ __urdlllocal ur_result_t UR_APICALL urDeviceRetain(`
`710`	`705`	`result = replaceCallback(&params);`
`711`	`706`	`} else {`
`712`	`707`
`713`		`- mock::retainDummyHandle(hDevice);`
`714`	`708`	`result = UR_RESULT_SUCCESS;`
`715`	`709`	`}`
`716`	`710`
`@@ -754,7 +748,6 @@ __urdlllocal ur_result_t UR_APICALL urDeviceRelease(`
`754`	`748`	`result = replaceCallback(&params);`
`755`	`749`	`} else {`
`756`	`750`
`757`		`- mock::releaseDummyHandle(hDevice);`
`758`	`751`	`result = UR_RESULT_SUCCESS;`
`759`	`752`	`}`
`760`	`753`
`@@ -808,10 +801,6 @@ __urdlllocal ur_result_t UR_APICALL urDevicePartition(`
`808`	`801`	`result = replaceCallback(&params);`
`809`	`802`	`} else {`
`810`	`803`
`811`		`- // optional output handle`
`812`		`- if (phSubDevices) {`
`813`		`- *phSubDevices = mock::createDummyHandle<ur_device_handle_t>();`
`814`		`- }`
`815`	`804`	`result = UR_RESULT_SUCCESS;`
`816`	`805`	`}`
`817`	`806`
`@@ -2355,6 +2344,7 @@ __urdlllocal ur_result_t UR_APICALL urUSMFree(`
`2355`	`2344`	`result = replaceCallback(&params);`
`2356`	`2345`	`} else {`
`2357`	`2346`
	`2347`	`+ mock::releaseDummyHandle(pMem);`
`2358`	`2348`	`result = UR_RESULT_SUCCESS;`
`2359`	`2349`	`}`
`2360`	`2350`