Add predefined HOST ALL memspace

A predefined memspace backed by all NUMA nodes discovered by
HWLOC. It can be obtained using umfMemspaceHostAllGet() function.

Author: kswiecicki

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_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 */