Enable OS memory provider on Windows

ldorau · ldorau · commit 90dd57e5b888 · 2024-03-01T14:27:58.000+01:00
Signed-off-by: Lukasz Dorau &lt;lukasz.dorau@intel.com&gt;
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -111,6 +111,11 @@ install(
     TARGETS umf_headers
     EXPORT ${PROJECT_NAME}-targets)
 
+if(UMF_BUILD_OS_MEMORY_PROVIDER AND (LINUX OR WINDOWS))
+    # Do not use pkgconfig, because it sets wrong paths on Windows
+    find_package(LIBHWLOC REQUIRED hwloc)
+endif()
+
 add_subdirectory(src)
 
 if(UMF_BUILD_TESTS)
diff --git a/cmake/FindLIBHWLOC.cmake b/cmake/FindLIBHWLOC.cmake
@@ -7,8 +7,23 @@ message(STATUS "Checking for module 'libhwloc' using find_library()")
 find_library(LIBHWLOC_LIBRARY NAMES libhwloc hwloc)
 set(LIBHWLOC_LIBRARIES ${LIBHWLOC_LIBRARY})
 
+find_file(LIBHWLOC_HEADER NAMES hwloc.h HINTS /usr/include/ ${CMAKE_PREFIX_PATH}/include)
+get_filename_component(LIBHWLOC_INCLUDE_DIR ${LIBHWLOC_HEADER} DIRECTORY)
+set(LIBHWLOC_INCLUDE_DIRS ${LIBHWLOC_INCLUDE_DIR})
+
+if(WINDOWS)
+	find_file(LIBHWLOC_DLL NAMES hwloc-15.dll libhwloc-15.dll HINTS ${CMAKE_PREFIX_PATH}/bin)
+	get_filename_component(LIBHWLOC_DLL_DIR ${LIBHWLOC_DLL} DIRECTORY)
+	set(LIBHWLOC_DLL_DIRS ${LIBHWLOC_DLL_DIR})
+endif()
+
 if(LIBHWLOC_LIBRARY)
 	message(STATUS "  Found libhwloc using find_library()")
+	message(STATUS "    LIBHWLOC_LIBRARIES = ${LIBHWLOC_LIBRARIES}")
+	message(STATUS "    LIBHWLOC_INCLUDE_DIRS = ${LIBHWLOC_INCLUDE_DIRS}")
+	if(WINDOWS)
+		message(STATUS "    LIBHWLOC_DLL_DIRS = ${LIBHWLOC_DLL_DIRS}")
+	endif()
 else()
 	set(MSG_NOT_FOUND "libhwloc NOT found (set CMAKE_PREFIX_PATH to point the location)")
 	if(LIBHWLOC_FIND_REQUIRED)
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
@@ -53,8 +53,8 @@ set(UMF_SOURCES_MACOSX
 )
 
 # Compile definitions for UMF library
-# TODO: Cleanup the compile definitions across all the Cmake files
-set(UMF_COMPILE_DEFINITIONS "")
+# TODO: Cleanup the compile definitions across all the CMake files
+set(UMF_PUBLIC_COMPILE_DEFINITIONS "")
 
 if(UMF_BUILD_OS_MEMORY_PROVIDER)
     set(UMF_SOURCES_LINUX ${UMF_SOURCES_LINUX}
@@ -64,16 +64,14 @@ if(UMF_BUILD_OS_MEMORY_PROVIDER)
         memspaces/memspace_numa.c
         memspaces/memspace_host_all.c)
 
-    if(LINUX)
-        if(PkgConfig_FOUND)
-            pkg_check_modules(LIBHWLOC hwloc)
-        endif()
-        if(NOT LIBHWLOC_FOUND)
-            find_package(LIBHWLOC REQUIRED hwloc)
-        endif()
+    set(UMF_SOURCES_WINDOWS ${UMF_SOURCES_WINDOWS}
+        provider/provider_os_memory.c
+        provider/provider_os_memory_windows.c)
+
+    if(LINUX OR WINDOWS)
         set(UMF_LIBS ${UMF_LIBS} ${LIBHWLOC_LIBRARIES})
-        # Currently, OS provider is only built for Linux
-        set(UMF_COMPILE_DEFINITIONS ${UMF_COMPILE_DEFINITIONS} "UMF_BUILD_OS_MEMORY_PROVIDER=1")
+        # Currently, OS provider is only built for Linux and Windows
+        set(UMF_PUBLIC_COMPILE_DEFINITIONS ${UMF_PUBLIC_COMPILE_DEFINITIONS} "UMF_BUILD_OS_MEMORY_PROVIDER=1")
     endif()
 endif()
 
@@ -86,13 +84,22 @@ elseif(MACOSX)
 endif()
 
 if(UMF_BUILD_SHARED_LIBRARY)
+    if(WINDOWS)
+        # TODO: replace that with generating def and map files
+        if(UMF_BUILD_OS_MEMORY_PROVIDER)
+            set(UMF_DEF_FILE "libumf.def")
+        else()
+            set(UMF_DEF_FILE "libumf_noOS.def")
+        endif()
+    endif()
+
     add_umf_library(NAME umf
                     TYPE SHARED
                     SRCS ${UMF_SOURCES}
                     LIBS ${UMF_LIBS}
                     LINUX_MAP_FILE ${CMAKE_CURRENT_SOURCE_DIR}/libumf.map
-                    WINDOWS_DEF_FILE ${CMAKE_CURRENT_SOURCE_DIR}/libumf.def)
-    set(UMF_COMPILE_DEFINITIONS ${UMF_COMPILE_DEFINITIONS} "UMF_SHARED_LIBRARY")
+                    WINDOWS_DEF_FILE ${CMAKE_CURRENT_SOURCE_DIR}/${UMF_DEF_FILE})
+    set(UMF_PUBLIC_COMPILE_DEFINITIONS ${UMF_PUBLIC_COMPILE_DEFINITIONS} "UMF_SHARED_LIBRARY")
     set_target_properties(umf PROPERTIES
         RUNTIME_OUTPUT_DIRECTORY ${CMAKE_UMF_OUTPUT_DIRECTORY})
 else()
@@ -102,7 +109,7 @@ else()
                     LIBS ${UMF_LIBS})
 endif()
 
-target_compile_definitions(umf PUBLIC ${UMF_COMPILE_DEFINITIONS})
+target_compile_definitions(umf PUBLIC ${UMF_PUBLIC_COMPILE_DEFINITIONS})
 
 if (UMF_ENABLE_POOL_TRACKING)
     target_sources(umf PRIVATE memory_pool_tracking.c)
@@ -112,6 +119,10 @@ endif()
 
 add_library(${PROJECT_NAME}::umf ALIAS umf)
 
+if(LIBHWLOC_INCLUDE_DIRS)
+    target_include_directories(umf PRIVATE ${LIBHWLOC_INCLUDE_DIRS})
+endif()
+
 target_include_directories(umf PUBLIC
     $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
diff --git a/src/libumf.def b/src/libumf.def
@@ -39,3 +39,4 @@ EXPORTS
     umfPoolMallocUsableSize
     umfPoolRealloc
     umfProxyPoolOps
+    umfOsMemoryProviderOps
diff --git a/src/libumf_noOS.def b/src/libumf_noOS.def
@@ -0,0 +1,47 @@
+;;;; Begin Copyright Notice
+; Copyright (C) 2024 Intel Corporation
+; Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+; SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+;;;;  End Copyright Notice
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+; TODO: this is a TEMPORARY solution.
+; The def file should be generated
+; depending on the chosen configuration.
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+LIBRARY umf
+
+VERSION 1.0
+
+EXPORTS
+    DllMain
+    umfFree
+    umfGetLastFailedMemoryProvider
+    umfMemoryProviderAlloc
+    umfMemoryProviderAllocationMerge
+    umfMemoryProviderAllocationSplit
+    umfMemoryProviderCreate
+    umfMemoryProviderCreateFromMemspace
+    umfMemoryProviderDestroy
+    umfMemoryProviderFree
+    umfMemoryProviderGetLastNativeError
+    umfMemoryProviderGetMinPageSize
+    umfMemoryProviderGetName
+    umfMemoryProviderGetRecommendedPageSize
+    umfMemoryProviderPurgeForce
+    umfMemoryProviderPurgeLazy
+    umfMemspaceDestroy
+    umfPoolAlignedMalloc
+    umfPoolByPtr
+    umfPoolCalloc
+    umfPoolCreate
+    umfPoolCreateFromMemspace
+    umfPoolDestroy
+    umfPoolFree
+    umfPoolGetLastAllocationError
+    umfPoolGetMemoryProvider
+    umfPoolMalloc
+    umfPoolMallocUsableSize
+    umfPoolRealloc
+    umfProxyPoolOps
diff --git a/src/provider/provider_os_memory.c b/src/provider/provider_os_memory.c
@@ -5,6 +5,19 @@
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 */
 
+#ifdef _WIN32
+#pragma warning(push)
+// Disable the warning:
+// hwloc-win64-build-2.10.0\include\hwloc/helper.h(1266):
+// warning C4996: 'sscanf': This function or variable may be unsafe.
+// Consider using sscanf_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS.
+#pragma warning(disable : 4996)
+#include <hwloc.h>
+#pragma warning(pop)
+#else
+#include <hwloc.h>
+#endif
+
 #include <assert.h>
 #include <errno.h>
 #include <hwloc.h>
@@ -464,7 +477,9 @@ static umf_result_t os_alloc(void *provider, size_t size, size_t alignment,
         if (os_provider->traces) {
             perror("binding memory to NUMA node failed");
         }
-        if (errno != ENOSYS) { // ENOSYS - Function not implemented
+        // TODO: (errno == 0) when hwloc_set_area_membind() fails on Windows - ignore this temporarily
+        if (errno != ENOSYS &&
+            errno != 0) { // ENOSYS - Function not implemented
             // Do not error out if memory binding is not implemented at all (like in case of WSL on Windows).
             goto err_unmap;
         }
diff --git a/src/provider/provider_os_memory_windows.c b/src/provider/provider_os_memory_windows.c
@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2023 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+*/
+
+#include <windows.h>
+
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+#include <sysinfoapi.h>
+
+#include <umf/providers/provider_os_memory.h>
+
+#include "utils_concurrency.h"
+
+static UTIL_ONCE_FLAG Page_size_is_initialized = UTIL_ONCE_FLAG_INIT;
+static size_t Page_size;
+
+int os_translate_mem_protection_flags(unsigned protection) {
+    switch (protection) {
+    case UMF_PROTECTION_NONE:
+        return PAGE_NOACCESS;
+    case UMF_PROTECTION_EXEC:
+        return PAGE_EXECUTE;
+    case (UMF_PROTECTION_EXEC | UMF_PROTECTION_READ):
+        return PAGE_EXECUTE_READ;
+    case (UMF_PROTECTION_EXEC | UMF_PROTECTION_READ | UMF_PROTECTION_WRITE):
+        return PAGE_EXECUTE_READWRITE;
+    case (UMF_PROTECTION_EXEC | UMF_PROTECTION_WRITE):
+        return PAGE_EXECUTE_WRITECOPY;
+    case UMF_PROTECTION_READ:
+        return PAGE_READONLY;
+    case (UMF_PROTECTION_READ | UMF_PROTECTION_WRITE):
+        return PAGE_READWRITE;
+    case UMF_PROTECTION_WRITE:
+        return PAGE_WRITECOPY;
+    }
+    fprintf(stderr,
+            "os_translate_mem_protection_flags(): unsupported protection flag: "
+            "%u\n",
+            protection);
+    assert(0);
+    return -1;
+}
+
+void *os_mmap(void *hint_addr, size_t length, int prot) {
+    return VirtualAlloc(hint_addr, length, MEM_RESERVE | MEM_COMMIT, prot);
+}
+
+int os_munmap(void *addr, size_t length) {
+    // If VirtualFree() succeeds, the return value is nonzero.
+    // If VirtualFree() fails, the return value is 0 (zero).
+    (void)length; // unused
+    return (VirtualFree(addr, 0, MEM_RELEASE) == 0);
+}
+
+int os_purge(void *addr, size_t length, int advice) {
+    // If VirtualFree() succeeds, the return value is nonzero.
+    // If VirtualFree() fails, the return value is 0 (zero).
+    (void)advice; // unused
+    return (VirtualFree(addr, length, MEM_DECOMMIT) == 0);
+}
+
+static void _os_get_page_size(void) {
+    SYSTEM_INFO SystemInfo;
+    GetSystemInfo(&SystemInfo);
+    Page_size = SystemInfo.dwPageSize;
+}
+
+size_t os_get_page_size(void) {
+    util_init_once(&Page_size_is_initialized, _os_get_page_size);
+    return Page_size;
+}
+
+void os_strerror(int errnum, char *buf, size_t buflen) {
+    strerror_s(buf, buflen, errnum);
+}
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
@@ -50,8 +50,11 @@ function(add_umf_test)
     set_tests_properties(${TEST_NAME} PROPERTIES LABELS "umf")
 
     if(WIN32)
-        set_property(TEST ${TEST_NAME} PROPERTY ENVIRONMENT_MODIFICATION
-            "PATH=path_list_append:../bin/$<CONFIG>")
+        set(PATH_LIST "PATH=path_list_append:../bin/$<CONFIG>")
+        if(LIBHWLOC_DLL_DIRS)
+            set(PATH_LIST "${PATH_LIST};PATH=path_list_append:${LIBHWLOC_DLL_DIRS}")
+        endif()
+        set_property(TEST ${TEST_NAME} PROPERTY ENVIRONMENT_MODIFICATION "${PATH_LIST}")
     endif()
 
     if (UMF_ENABLE_POOL_TRACKING)
