Adapt project to work on windows with L0 and GPU

Author: szadam

src/libumf.def

@@ -14,6 +14,7 @@ EXPORTS
     umfFree
     umfGetIPCHandle
     umfGetLastFailedMemoryProvider
+    umfLevelZeroMemoryProviderOps
     umfMemoryProviderAlloc
     umfMemoryProviderAllocationMerge
     umfMemoryProviderAllocationSplit

src/utils/utils_load_library.h

@@ -39,11 +39,15 @@ static inline void *util_open_library(const char *filename) {
 static inline int util_close_library(void *handle) {
     // If the FreeLibrary function succeeds, the return value is nonzero.
     // If the FreeLibrary function fails, the return value is zero.
-    return (FreeLibrary(handle) == 0);
+    return (FreeLibrary((HMODULE)handle) == 0);
 }
 
 static inline void *util_get_symbol_addr(void *handle, const char *symbol) {
-    return GetProcAddress(handle, symbol);
+    if (handle == NULL) {
+        // handle can't be null
+        handle = GetModuleHandle("ze_loader.dll");
+    }
+    return GetProcAddress((HMODULE)handle, symbol);
 }
 
 #else /* Linux */

test/CMakeLists.txt

@@ -58,7 +58,7 @@ function(add_umf_test)
         NAME ${TEST_TARGET_NAME}
         SRCS ${ARG_SRCS}
         LIBS ${TEST_LIBS})
-
+    
     target_link_directories(${TEST_TARGET_NAME} PRIVATE ${LIB_DIRS})
 
     target_include_directories(
@@ -183,8 +183,7 @@ endif()
 
 # TODO add support for Windows
 if(UMF_BUILD_GPU_TESTS
-   AND UMF_BUILD_LEVEL_ZERO_PROVIDER
-   AND LINUX)
+   AND UMF_BUILD_LEVEL_ZERO_PROVIDER)
     # we have two test binaries here that use the same sources, but differ in
     # the way they are linked to the Level Zero (statically or at runtime using
     # dlopen)

test/providers/provider_level_zero.cpp

@@ -2,11 +2,12 @@
 // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-#include <dlfcn.h>
-#include <level_zero/ze_api.h>
+#define NOMINMAX
+#include <ze_api.h>
 
 #include "pool.hpp"
 #include "umf/providers/provider_level_zero.h"
+#include "utils_load_library.h"
 
 using umf_test::test;
 using namespace umf_test;
@@ -66,63 +67,66 @@ struct umfLevelZeroProviderTest : umf_test::test {
         // NOTE that we use RTLD_GLOBAL which add all loaded symbols to the
         // global symbol table. These symbols would be used by the Level Zero
         // provider later
-        zeDlHandle = dlopen("libze_loader.so", RTLD_GLOBAL | RTLD_LAZY);
-
-        *(void **)&libze_ops.zeInit = dlsym(zeDlHandle, "zeInit");
+        #ifdef _WIN32
+            zeDlHandle = util_open_library("ze_loader.dll");
+        #else
+            zeDlHandle = util_open_library("libze_loader.so");
+        #endif
+        *(void **)&libze_ops.zeInit = util_get_symbol_addr(zeDlHandle, "zeInit");
         ASSERT_NE(libze_ops.zeInit, nullptr);
-        *(void **)&libze_ops.zeDriverGet = dlsym(zeDlHandle, "zeDriverGet");
+        *(void **)&libze_ops.zeDriverGet = util_get_symbol_addr(zeDlHandle, "zeDriverGet");
         ASSERT_NE(libze_ops.zeDriverGet, nullptr);
-        *(void **)&libze_ops.zeDeviceGet = dlsym(zeDlHandle, "zeDeviceGet");
+        *(void **)&libze_ops.zeDeviceGet = util_get_symbol_addr(zeDlHandle, "zeDeviceGet");
         ASSERT_NE(libze_ops.zeDeviceGet, nullptr);
         *(void **)&libze_ops.zeDeviceGetProperties =
-            dlsym(zeDlHandle, "zeDeviceGetProperties");
+            util_get_symbol_addr(zeDlHandle, "zeDeviceGetProperties");
         ASSERT_NE(libze_ops.zeDeviceGetProperties, nullptr);
         *(void **)&libze_ops.zeContextCreate =
-            dlsym(zeDlHandle, "zeContextCreate");
+            util_get_symbol_addr(zeDlHandle, "zeContextCreate");
         ASSERT_NE(libze_ops.zeContextCreate, nullptr);
         *(void **)&libze_ops.zeContextDestroy =
-            dlsym(zeDlHandle, "zeContextDestroy");
+            util_get_symbol_addr(zeDlHandle, "zeContextDestroy");
         ASSERT_NE(libze_ops.zeContextDestroy, nullptr);
         *(void **)&libze_ops.zeCommandQueueCreate =
-            dlsym(zeDlHandle, "zeCommandQueueCreate");
+            util_get_symbol_addr(zeDlHandle, "zeCommandQueueCreate");
         ASSERT_NE(libze_ops.zeCommandQueueCreate, nullptr);
         *(void **)&libze_ops.zeCommandQueueDestroy =
-            dlsym(zeDlHandle, "zeCommandQueueDestroy");
+            util_get_symbol_addr(zeDlHandle, "zeCommandQueueDestroy");
         ASSERT_NE(libze_ops.zeCommandQueueDestroy, nullptr);
         *(void **)&libze_ops.zeCommandQueueExecuteCommandLists =
-            dlsym(zeDlHandle, "zeCommandQueueExecuteCommandLists");
+            util_get_symbol_addr(zeDlHandle, "zeCommandQueueExecuteCommandLists");
         ASSERT_NE(libze_ops.zeCommandQueueExecuteCommandLists, nullptr);
         *(void **)&libze_ops.zeCommandQueueSynchronize =
-            dlsym(zeDlHandle, "zeCommandQueueSynchronize");
+            util_get_symbol_addr(zeDlHandle, "zeCommandQueueSynchronize");
         ASSERT_NE(libze_ops.zeCommandQueueSynchronize, nullptr);
         *(void **)&libze_ops.zeCommandListCreate =
-            dlsym(zeDlHandle, "zeCommandListCreate");
+            util_get_symbol_addr(zeDlHandle, "zeCommandListCreate");
         ASSERT_NE(libze_ops.zeCommandListCreate, nullptr);
         *(void **)&libze_ops.zeCommandListDestroy =
-            dlsym(zeDlHandle, "zeCommandListDestroy");
+            util_get_symbol_addr(zeDlHandle, "zeCommandListDestroy");
         ASSERT_NE(libze_ops.zeCommandListDestroy, nullptr);
         *(void **)&libze_ops.zeCommandListClose =
-            dlsym(zeDlHandle, "zeCommandListClose");
+            util_get_symbol_addr(zeDlHandle, "zeCommandListClose");
         ASSERT_NE(libze_ops.zeCommandListClose, nullptr);
         *(void **)&libze_ops.zeCommandListAppendMemoryCopy =
-            dlsym(zeDlHandle, "zeCommandListAppendMemoryCopy");
+            util_get_symbol_addr(zeDlHandle, "zeCommandListAppendMemoryCopy");
         ASSERT_NE(libze_ops.zeCommandListAppendMemoryCopy, nullptr);
         *(void **)&libze_ops.zeCommandListAppendMemoryFill =
-            dlsym(zeDlHandle, "zeCommandListAppendMemoryFill");
+            util_get_symbol_addr(zeDlHandle, "zeCommandListAppendMemoryFill");
         ASSERT_NE(libze_ops.zeCommandListAppendMemoryFill, nullptr);
         *(void **)&libze_ops.zeMemGetAllocProperties =
-            dlsym(zeDlHandle, "zeMemGetAllocProperties");
+            util_get_symbol_addr(zeDlHandle, "zeMemGetAllocProperties");
         ASSERT_NE(libze_ops.zeMemGetAllocProperties, nullptr);
         *(void **)&libze_ops.zeMemAllocDevice =
-            dlsym(zeDlHandle, "zeMemAllocDevice");
+            util_get_symbol_addr(zeDlHandle, "zeMemAllocDevice");
         ASSERT_NE(libze_ops.zeMemAllocDevice, nullptr);
-        *(void **)&libze_ops.zeMemFree = dlsym(zeDlHandle, "zeMemFree");
+        *(void **)&libze_ops.zeMemFree = util_get_symbol_addr(zeDlHandle, "zeMemFree");
         ASSERT_NE(libze_ops.zeMemFree, nullptr);
     }
 
     void DestroyLevelZeroOps() {
         // Just close the handle here
-        dlclose(zeDlHandle);
+        util_close_library(zeDlHandle);
     }
 #else  // USE_DLOPEN
     void InitLevelZeroOps() {