Merge pull request #205 from kswiecicki/memspace-hwloc

Add predefined HOST ALL memspace

Author: bratpiorka

README.md

@@ -161,6 +161,19 @@ The `UMF_BUILD_LIBUMF_POOL_SCALABLE` option has to be turned `ON` to build this
 2) Required packages:
    - libtbb-dev (libraries: libtbbmalloc.so.2)
 
+### Memspaces (Linux-only)
+
+TODO: Add general information about memspaces.
+
+#### Host all memspace
+
+Memspace backed by all available NUMA nodes discovered on the platform. Can be retrieved
+using umfMemspaceHostAllGet.
+
+##### Requirements
+
+This feature relies on the OS memory provider.
+
 ## Contributions
 
 All contributions to the UMF project are most welcome! Before submitting

include/umf/memspace.h

@@ -44,6 +44,12 @@ umfMemoryProviderCreateFromMemspace(umf_memspace_handle_t hMemspace,
                                     umf_memspace_policy_handle_t hPolicy,
                                     umf_memory_provider_handle_t *hProvider);
 
+///
+/// \brief Retrieves predefined host all memspace.
+/// \return host all memspace handle on success or NULL on failure.
+///
+umf_memspace_handle_t umfMemspaceHostAllGet(void);
+
 #ifdef __cplusplus
 }
 #endif

src/CMakeLists.txt

@@ -52,12 +52,17 @@ set(UMF_SOURCES_MACOSX
     libumf_linux.c
 )
 
+# Compile definitions for UMF library
+# TODO: Cleanup the compile definitions across all the Cmake files
+set(UMF_COMPILE_DEFINITIONS "")
+
 if(UMF_BUILD_OS_MEMORY_PROVIDER)
     set(UMF_SOURCES_LINUX ${UMF_SOURCES_LINUX}
         provider/provider_os_memory.c
         provider/provider_os_memory_linux.c
         memory_targets/memory_target_numa.c
-        memspaces/memspace_numa.c)
+        memspaces/memspace_numa.c
+        memspaces/memspace_host_all.c)
 
     if(LINUX)
         if(PkgConfig_FOUND)
@@ -67,6 +72,8 @@ if(UMF_BUILD_OS_MEMORY_PROVIDER)
             find_package(LIBHWLOC REQUIRED hwloc)
         endif()
         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")
     endif()
 endif()
 
@@ -85,16 +92,18 @@ 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)
-    target_compile_definitions(umf PUBLIC UMF_SHARED_LIBRARY)
+    set(UMF_COMPILE_DEFINITIONS ${UMF_COMPILE_DEFINITIONS} "UMF_SHARED_LIBRARY")
     set_target_properties(umf PROPERTIES
         RUNTIME_OUTPUT_DIRECTORY ${CMAKE_UMF_OUTPUT_DIRECTORY})
 else()
     add_umf_library(NAME umf
-                    TYPE STATIC 
-                    SRCS ${UMF_SOURCES} 
+                    TYPE STATIC
+                    SRCS ${UMF_SOURCES}
                     LIBS ${UMF_LIBS})
 endif()
 
+target_compile_definitions(umf PUBLIC ${UMF_COMPILE_DEFINITIONS})
+
 if (UMF_ENABLE_POOL_TRACKING)
     target_sources(umf PRIVATE memory_pool_tracking.c)
 else()
@@ -103,10 +112,13 @@ endif()
 
 add_library(${PROJECT_NAME}::umf ALIAS umf)
 
-target_include_directories(umf PUBLIC 
+target_include_directories(umf PUBLIC
     $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/critnib>
     $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/provider>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/memspaces>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/memory_targets>
     $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
 )
 

src/libumf.def

@@ -16,6 +16,7 @@ EXPORTS
     umfMemoryProviderAllocationMerge
     umfMemoryProviderAllocationSplit
     umfMemoryProviderCreate
+    umfMemoryProviderCreateFromMemspace
     umfMemoryProviderDestroy
     umfMemoryProviderFree
     umfMemoryProviderGetLastNativeError
@@ -24,18 +25,17 @@ EXPORTS
     umfMemoryProviderGetRecommendedPageSize
     umfMemoryProviderPurgeForce
     umfMemoryProviderPurgeLazy
+    umfMemspaceDestroy
     umfPoolAlignedMalloc
     umfPoolByPtr
     umfPoolCalloc
     umfPoolCreate
+    umfPoolCreateFromMemspace
     umfPoolDestroy
     umfPoolFree
     umfPoolGetLastAllocationError
     umfPoolGetMemoryProvider
     umfPoolMalloc
     umfPoolMallocUsableSize
     umfPoolRealloc
-    umfPoolCreateFromMemspace
-    umfMemoryProviderCreateFromMemspace
-    umfMemspaceDestroy
     umfProxyPoolOps

src/libumf.map

@@ -10,6 +10,7 @@ UMF_1.0 {
         umfMemoryProviderAllocationMerge;
         umfMemoryProviderAllocationSplit;
         umfMemoryProviderCreate;
+        umfMemoryProviderCreateFromMemspace;
         umfMemoryProviderDestroy;
         umfMemoryProviderFree;
         umfMemoryProviderGetLastNativeError;
@@ -18,23 +19,23 @@ UMF_1.0 {
         umfMemoryProviderGetRecommendedPageSize;
         umfMemoryProviderPurgeForce;
         umfMemoryProviderPurgeLazy;
+        umfMemspaceCreateFromNumaArray;
+        umfMemspaceDestroy;
+        umfMemspaceHostAllGet;
+        umfOsMemoryProviderOps;
         umfPoolAlignedMalloc;
         umfPoolByPtr;
         umfPoolCalloc;
         umfPoolCreate;
+        umfPoolCreateFromMemspace;
         umfPoolDestroy;
         umfPoolFree;
         umfPoolGetLastAllocationError;
         umfPoolGetMemoryProvider;
         umfPoolMalloc;
         umfPoolMallocUsableSize;
         umfPoolRealloc;
-        umfOsMemoryProviderOps;
         umfProxyPoolOps;
-        umfPoolCreateFromMemspace;
-        umfMemoryProviderCreateFromMemspace;
-        umfMemspaceCreateFromNumaArray;
-        umfMemspaceDestroy;
     local:
         *;
 };

src/libumf_linux.c

@@ -10,6 +10,7 @@
 #include <stddef.h>
 
 #include "base_alloc_global.h"
+#include "memspace_host_all_internal.h"
 #include "provider_tracking.h"
 
 umf_memory_tracker_handle_t TRACKER = NULL;
@@ -23,6 +24,10 @@ void __attribute__((destructor)) umfDestroy(void) {
     // make sure TRACKER is not used after being destroyed
     TRACKER = NULL;
     umfMemoryTrackerDestroy(t);
+
+#if defined(UMF_BUILD_OS_MEMORY_PROVIDER)
+    umfMemspaceHostAllDestroy();
+#endif
 }
 
 void libumfInit(void) {

src/memspaces/memspace_host_all.c

@@ -0,0 +1,95 @@
+/*
+ *
+ * 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
+ *
+ */
+
+#include <assert.h>
+#include <hwloc.h>
+#include <stdlib.h>
+
+#include "base_alloc_global.h"
+#include "memory_target_numa.h"
+#include "memspace_host_all_internal.h"
+#include "memspace_internal.h"
+#include "memspace_numa.h"
+#include "utils_concurrency.h"
+
+static umf_result_t umfMemspaceHostAllCreate(umf_memspace_handle_t *hMemspace) {
+    if (!hMemspace) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    umf_result_t umf_ret = UMF_RESULT_SUCCESS;
+
+    hwloc_topology_t topology;
+    if (hwloc_topology_init(&topology)) {
+        // TODO: What would be an approrpiate err?
+        return UMF_RESULT_ERROR_UNKNOWN;
+    }
+
+    if (hwloc_topology_load(topology)) {
+        umf_ret = UMF_RESULT_ERROR_UNKNOWN;
+        goto err_topology_destroy;
+    }
+
+    // Shouldn't return -1, as 'HWLOC_OBJ_NUMANODE' doesn't appear to be an
+    // object that can be present on multiple levels.
+    // Source: https://www.open-mpi.org/projects/hwloc/doc/hwloc-v2.10.0-letter.pdf
+    int nNodes = hwloc_get_nbobjs_by_type(topology, HWLOC_OBJ_NUMANODE);
+    assert(nNodes != -1);
+
+    size_t *nodeIds = umf_ba_global_alloc(nNodes * sizeof(size_t));
+    if (!nodeIds) {
+        umf_ret = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
+        goto err_topology_destroy;
+    }
+
+    // Collect all available NUMA node ids on the platform
+    int nodeIdx = 0;
+    hwloc_obj_t numaNodeObj = NULL;
+    while ((numaNodeObj = hwloc_get_next_obj_by_type(
+                topology, HWLOC_OBJ_NUMANODE, numaNodeObj)) != NULL) {
+        // Shouldn't be possible to iterate over more 'HWLOC_OBJ_NUMANODE' objects
+        // than the number returned by hwloc_get_nbobjs_by_type.
+        assert(nodeIdx < nNodes);
+        nodeIds[nodeIdx++] = numaNodeObj->os_index;
+    }
+
+    umf_ret =
+        umfMemspaceCreateFromNumaArray(nodeIds, (size_t)nNodes, hMemspace);
+
+    umf_ba_global_free(nodeIds, nNodes * sizeof(size_t));
+
+err_topology_destroy:
+    hwloc_topology_destroy(topology);
+    return umf_ret;
+}
+
+static umf_memspace_handle_t UMF_MEMSPACE_HOST_ALL = NULL;
+static UTIL_ONCE_FLAG UMF_MEMSPACE_HOST_ALL_INITIALIZED = UTIL_ONCE_FLAG_INIT;
+
+void umfMemspaceHostAllDestroy(void) {
+    if (UMF_MEMSPACE_HOST_ALL) {
+        umfMemspaceDestroy(UMF_MEMSPACE_HOST_ALL);
+        UMF_MEMSPACE_HOST_ALL = NULL;
+    }
+}
+
+static void umfMemspaceHostAllInit(void) {
+    umf_result_t ret = umfMemspaceHostAllCreate(&UMF_MEMSPACE_HOST_ALL);
+    assert(ret == UMF_RESULT_SUCCESS);
+    (void)ret;
+
+    // TODO: Setup appropriate cleanup when 'HOST ALL' memspace becomes available
+    // on Windows. 'HOST ALL' memspace depends on OS provider, which currently
+    // doesn't support Windows.
+}
+
+umf_memspace_handle_t umfMemspaceHostAllGet(void) {
+    util_init_once(&UMF_MEMSPACE_HOST_ALL_INITIALIZED, umfMemspaceHostAllInit);
+    return UMF_MEMSPACE_HOST_ALL;
+}

src/memspaces/memspace_host_all_internal.h

@@ -0,0 +1,26 @@
+/*
+ *
+ * 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
+ *
+ */
+
+#ifndef UMF_MEMSPACE_HOST_ALL_INTERNAL_H
+#define UMF_MEMSPACE_HOST_ALL_INTERNAL_H 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+///
+/// \brief Destroys the predefined host all memspace.
+///
+void umfMemspaceHostAllDestroy(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_MEMSPACE_HOST_ALL_INTERNAL_H */

test/CMakeLists.txt

@@ -50,7 +50,7 @@ function(add_umf_test)
     set_tests_properties(${TEST_NAME} PROPERTIES LABELS "umf")
 
     if(WIN32)
-        set_property(TEST ${TEST_NAME} PROPERTY ENVIRONMENT_MODIFICATION 
+        set_property(TEST ${TEST_NAME} PROPERTY ENVIRONMENT_MODIFICATION
             "PATH=path_list_append:../bin/$<CONFIG>")
     endif()
 
@@ -61,7 +61,7 @@ endfunction()
 
 add_subdirectory(common)
 
-add_umf_test(NAME base 
+add_umf_test(NAME base
              SRCS base.cpp)
 add_umf_test(NAME memoryPool
              SRCS memoryPoolAPI.cpp malloc_compliance_tests.cpp)
@@ -129,6 +129,9 @@ if(UMF_BUILD_OS_MEMORY_PROVIDER AND LINUX) # OS-specific functions are implement
     add_umf_test(NAME provider_os_memory_config
                  SRCS provider_os_memory_config.cpp
                  LIBS umf_utils ${LIBNUMA_LIBRARIES})
+    add_umf_test(NAME memspace_host_all
+                 SRCS memspace_host_all.cpp
+                 LIBS ${LIBNUMA_LIBRARIES})
 endif()
 
 if(UMF_BUILD_SHARED_LIBRARY)

test/memspace_host_all.cpp

@@ -0,0 +1,65 @@
+// 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
+
+#include "base.hpp"
+#include "test_helpers.h"
+
+#include <umf/memspace.h>
+
+using umf_test::test;
+
+#define SIZE_4K (4096)
+
+struct predefinedMemspaceTest : test {
+
+    void SetUp() override {
+        ::test::SetUp();
+
+        hMemspace = umfMemspaceHostAllGet();
+        UT_ASSERTne(hMemspace, nullptr);
+    }
+
+    umf_memspace_handle_t hMemspace;
+};
+
+struct predefinedMemspaceProviderTest : predefinedMemspaceTest {
+
+    void SetUp() override {
+        ::predefinedMemspaceTest::SetUp();
+
+        enum umf_result_t ret =
+            umfMemoryProviderCreateFromMemspace(hMemspace, nullptr, &provider);
+        UT_ASSERTeq(ret, UMF_RESULT_SUCCESS);
+        UT_ASSERTne(provider, nullptr);
+    }
+
+    void TearDown() override {
+        ::predefinedMemspaceTest::TearDown();
+
+        umfMemoryProviderDestroy(provider);
+    }
+
+    umf_memory_provider_handle_t provider = nullptr;
+};
+
+TEST_F(test, memspaceGet) {
+    umf_memspace_handle_t hMemspace = umfMemspaceHostAllGet();
+    UT_ASSERTne(hMemspace, nullptr);
+}
+
+TEST_F(predefinedMemspaceProviderTest, allocFree) {
+    void *ptr = nullptr;
+    size_t size = SIZE_4K;
+    size_t alignment = 0;
+
+    enum umf_result_t ret =
+        umfMemoryProviderAlloc(provider, size, alignment, &ptr);
+    UT_ASSERTeq(ret, UMF_RESULT_SUCCESS);
+    UT_ASSERTne(ptr, nullptr);
+
+    memset(ptr, 0xFF, size);
+
+    ret = umfMemoryProviderFree(provider, ptr, size);
+    UT_ASSERTeq(ret, UMF_RESULT_SUCCESS);
+}