Add provider/pool create from memspace functions

Author: kswiecicki

src/memory_targets/memory_target_numa.c

@@ -7,15 +7,23 @@
  *
  */
 
+#include <assert.h>
 #include <stdlib.h>
 
+#include "../memory_pool_internal.h"
 #include "memory_target_numa.h"
+#include <umf/pools/pool_disjoint.h>
+#include <umf/providers/provider_os_memory.h>
 
 struct numa_memory_target_t {
     size_t id;
 };
 
 static enum umf_result_t numa_initialize(void *params, void **memTarget) {
+    if (params == NULL || memTarget == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
     struct umf_numa_memory_target_config_t *config =
         (struct umf_numa_memory_target_config_t *)params;
 
@@ -32,32 +40,90 @@ static enum umf_result_t numa_initialize(void *params, void **memTarget) {
 
 static void numa_finalize(void *memTarget) { free(memTarget); }
 
-static enum umf_result_t numa_pool_create_from_memspace(
-    umf_memspace_handle_t memspace, void **memTargets, size_t numTargets,
-    umf_memspace_policy_handle_t policy, umf_memory_pool_handle_t *pool) {
-    // TODO: cast memTargets to (struct numa_memory_target_t**), parse ids and initialize os provider
-    (void)memspace;
-    (void)memTargets;
-    (void)numTargets;
-    (void)policy;
-    (void)pool;
-    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+static const umf_os_memory_provider_params_t
+    UMF_OS_MEMORY_PROVIDER_PARAMS_DEFAULT = {
+        // Visibility & protection
+        .protection = UMF_PROTECTION_READ | UMF_PROTECTION_WRITE,
+        .visibility = UMF_VISIBILITY_PRIVATE,
+
+        // NUMA config
+        .nodemask = NULL,
+        .maxnode = 0, // TODO: numa_max_node/GetNumaHighestNodeNumber
+        .numa_mode = UMF_NUMA_MODE_DEFAULT,
+        .numa_flags = UMF_NUMA_FLAGS_STRICT, // TODO: determine default behavior
+
+        // Logging
+        .traces = 0, // TODO: parse env variable for log level?
+};
+
+static unsigned long
+numa_targets_get_nodemask(struct numa_memory_target_t **targets,
+                          size_t num_targets) {
+    assert(targets);
+    unsigned long nodemask = 0;
+    for (size_t i = 0; i < num_targets; i++) {
+        nodemask |= (1UL << targets[i]->id);
+    }
+
+    return nodemask;
+}
+
+static unsigned long numa_nodemask_get_maxnode(unsigned long nodemask) {
+    for (int bitIdx = sizeof(nodemask) * 8 - 1; bitIdx >= 0; bitIdx--) {
+        if ((nodemask & (1UL << bitIdx)) != 0) {
+            return (unsigned long)bitIdx;
+        }
+    }
+
+    return 0;
 }
 
 static enum umf_result_t numa_memory_provider_create_from_memspace(
     umf_memspace_handle_t memspace, void **memTargets, size_t numTargets,
     umf_memspace_policy_handle_t policy,
     umf_memory_provider_handle_t *provider) {
+    (void)memspace;
+    // TODO: apply policy
+    (void)policy;
+
+    struct numa_memory_target_t **numaTargets =
+        (struct numa_memory_target_t **)memTargets;
+
+    // Create node mask from IDs
+    unsigned long nodemask = numa_targets_get_nodemask(numaTargets, numTargets);
+    unsigned long maxnode = numa_nodemask_get_maxnode(nodemask);
+
+    umf_os_memory_provider_params_t params =
+        UMF_OS_MEMORY_PROVIDER_PARAMS_DEFAULT;
+    params.nodemask = &nodemask;
+    params.maxnode = maxnode;
+
+    umf_memory_provider_handle_t numaProvider = NULL;
+    enum umf_result_t ret = umfMemoryProviderCreate(&UMF_OS_MEMORY_PROVIDER_OPS,
+                                                    &params, &numaProvider);
+    if (ret) {
+        return ret;
+    }
+
+    *provider = numaProvider;
+
+    return UMF_RESULT_SUCCESS;
+}
+
+static enum umf_result_t numa_pool_create_from_memspace(
+    umf_memspace_handle_t memspace, void **memTargets, size_t numTargets,
+    umf_memspace_policy_handle_t policy, umf_memory_pool_handle_t *pool) {
     // TODO: cast memTargets to (struct numa_memory_target_t**), parse ids and initialize os provider
     (void)memspace;
     (void)memTargets;
     (void)numTargets;
     (void)policy;
-    (void)provider;
+    (void)pool;
     return UMF_RESULT_ERROR_NOT_SUPPORTED;
 }
 
 struct umf_memory_target_ops_t UMF_MEMORY_TARGET_NUMA_OPS = {
+    .version = UMF_VERSION_CURRENT,
     .initialize = numa_initialize,
     .finalize = numa_finalize,
     .pool_create_from_memspace = numa_pool_create_from_memspace,

src/memspace.c

@@ -51,6 +51,8 @@ memoryTargetHandlesToPriv(umf_memspace_handle_t memspace, void ***pPrivs) {
     }
     *pPrivs = privs;
 
+    *pPrivs = privs;
+
     return UMF_RESULT_SUCCESS;
 }