Enable OS memory provider on Windows

Signed-off-by: Lukasz Dorau <[email protected]>

Author: ldorau

CMakeLists.txt

@@ -111,6 +111,13 @@ 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)
+    message(STATUS "  LIBHWLOC_LIBRARIES = ${LIBHWLOC_LIBRARIES}")
+    message(STATUS "  LIBHWLOC_INCLUDE_DIRS = ${LIBHWLOC_INCLUDE_DIRS}")
+endif()
+
 add_subdirectory(src)
 
 if(UMF_BUILD_TESTS)

cmake/FindLIBHWLOC.cmake

@@ -7,6 +7,10 @@ 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(LIBHWLOC_LIBRARY)
 	message(STATUS "  Found libhwloc using find_library()")
 else()

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()
 
@@ -92,7 +90,7 @@ if(UMF_BUILD_SHARED_LIBRARY)
                     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")
+    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 +100,15 @@ else()
                     LIBS ${UMF_LIBS})
 endif()
 
-target_compile_definitions(umf PUBLIC ${UMF_COMPILE_DEFINITIONS})
+target_compile_definitions(umf PUBLIC ${UMF_PUBLIC_COMPILE_DEFINITIONS})
+
+if(UMF_BUILD_OS_MEMORY_PROVIDER AND WINDOWS)
+    # 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.
+    target_compile_definitions(umf PRIVATE _CRT_SECURE_NO_WARNINGS)
+endif()
 
 if (UMF_ENABLE_POOL_TRACKING)
     target_sources(umf PRIVATE memory_pool_tracking.c)
@@ -112,6 +118,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}>

src/libumf.def

@@ -39,3 +39,4 @@ EXPORTS
     umfPoolMallocUsableSize
     umfPoolRealloc
     umfProxyPoolOps
+    umfOsMemoryProviderOps

src/provider/provider_os_memory_windows.c

@@ -0,0 +1,64 @@
+/*
+ * 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 <umf/providers/provider_os_memory.h>
+
+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) {
+    fprintf(stderr, "os_purge() NOT IMPLEMENTED\n");
+    // assert(0);
+    return -1;
+}
+
+size_t os_get_page_size(void) { return 4096; } // TODO fix this
+
+void os_strerror(int errnum, char *buf, size_t buflen) {
+    fprintf(stderr, "os_strerror() NOT IMPLEMENTED\n");
+    // assert(0);
+}