Introduce UMF_MEMSPACE_HIGHEST_BANDWIDTH env var

This environment variable is used to forcefully assign NUMA nodes
to the memspace "highest bandwidth". The ordering of memory targets
within this memspace will correspond to the sequence of NUMA nodes
specified in the environment variable.

Author: kswiecicki

src/memspaces/memspace_highest_bandwidth.c

@@ -8,6 +8,7 @@
  */
 
 #include <assert.h>
+#include <ctype.h>
 #include <hwloc.h>
 #include <stdlib.h>
 
@@ -16,22 +17,84 @@
 #include "memspace_internal.h"
 #include "memspace_numa.h"
 #include "topology.h"
+#include "utils_common.h"
 #include "utils_concurrency.h"
 
+#define MAX_NODES 512
+
+static bool is_number_str(const char *token) {
+    if (*token == '\0') {
+        return false;
+    }
+
+    while (*token != '\0') {
+        if (*token < '0' || *token > '9') {
+            return false;
+        }
+
+        token++;
+    }
+
+    return true;
+}
+
+static umf_result_t getenv_to_nodes_array(char *envStr, size_t *arr,
+                                          size_t arrSize, size_t *outSize) {
+    if (envStr == NULL || arr == NULL || arrSize == 0 || outSize == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    char *value = getenv(envStr);
+    if (!value) {
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    }
+
+    size_t nNodes = 0;
+    char *token = strtok(value, " ,");
+    while (token != NULL) {
+        if (!is_number_str(token)) {
+            fprintf(stderr, "Error: Parsing env variable %s\n", envStr);
+            return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        }
+
+        if (arrSize > nNodes) {
+            size_t node = (size_t)strtoul(token, NULL, 10);
+            arr[nNodes] = node;
+        }
+
+        nNodes++;
+        token = strtok(NULL, " ,");
+    }
+
+    *outSize = nNodes;
+
+    return UMF_RESULT_SUCCESS;
+}
+
 static umf_result_t
 umfMemspaceHighestBandwidthCreate(umf_memspace_handle_t *hMemspace) {
     if (!hMemspace) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
+    // Check env var 'UMF_MEMSPACE_HIGHEST_BANDWIDTH' for the nodes assigned
+    // by the user.
+    size_t nodeIds[MAX_NODES];
+    size_t nNodes = 0;
+    umf_result_t ret = getenv_to_nodes_array("UMF_MEMSPACE_HIGHEST_BANDWIDTH",
+                                             nodeIds, MAX_NODES, &nNodes);
+    if (ret == UMF_RESULT_SUCCESS) {
+        assert(nNodes > 0 && nNodes <= MAX_NODES);
+        return umfMemspaceCreateFromNumaArray(nodeIds, nNodes, hMemspace);
+    }
+
     umf_memspace_handle_t hostAllMemspace = umfMemspaceHostAllGet();
     if (!hostAllMemspace) {
         return UMF_RESULT_ERROR_UNKNOWN;
     }
 
     umf_memspace_handle_t highBandwidthMemspace = NULL;
-    umf_result_t ret =
-        umfMemspaceClone(hostAllMemspace, &highBandwidthMemspace);
+    ret = umfMemspaceClone(hostAllMemspace, &highBandwidthMemspace);
     if (ret != UMF_RESULT_SUCCESS) {
         return ret;
     }