Memtarget refactor

src/CMakeLists.txt

@@ -58,7 +58,7 @@ set(UMF_SOURCES
     memory_pool.c
     memory_provider.c
     memory_provider_get_last_failed.c
-    memory_target.c
+    memtarget.c
     mempolicy.c
     memspace.c
     provider/provider_tracking.c
@@ -81,7 +81,7 @@ set(UMF_PRIVATE_COMPILE_DEFINITIONS "-DUMF_SRC_VERSION=${UMF_SRC_VERSION}")
 set(UMF_SOURCES_COMMON_LINUX_MACOSX
     provider/provider_os_memory.c
     provider/provider_os_memory_posix.c
-    memory_targets/memory_target_numa.c
+    memtargets/memtarget_numa.c
     memspaces/memspace_numa.c
     memspaces/memspace_host_all.c
     memspaces/memspace_highest_capacity.c
@@ -178,7 +178,7 @@ target_include_directories(
            $<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>
+           $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/memtargets>
            $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
 
 install(TARGETS umf EXPORT ${PROJECT_NAME}-targets)

src/memspace.c

@@ -13,9 +13,9 @@
 #include <umf/memspace.h>
 
 #include "base_alloc_global.h"
-#include "memory_target.h"
-#include "memory_target_ops.h"
 #include "memspace_internal.h"
+#include "memtarget.h"
+#include "memtarget_ops.h"
 
 #ifndef NDEBUG
 static umf_result_t
@@ -25,7 +25,7 @@ verifyMemTargetsTypes(umf_const_memspace_handle_t memspace) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    const struct umf_memory_target_ops_t *ops = memspace->nodes[0]->ops;
+    const struct umf_memtarget_ops_t *ops = memspace->nodes[0]->ops;
     for (size_t i = 1; i < memspace->size; i++) {
         if (memspace->nodes[i]->ops != ops) {
             return UMF_RESULT_ERROR_INVALID_ARGUMENT;
@@ -66,7 +66,7 @@ umf_result_t umfPoolCreateFromMemspace(umf_const_memspace_handle_t memspace,
         return ret;
     }
 
-    // TODO: for now, we only support memspaces that consist of memory_targets
+    // TODO: for now, we only support memspaces that consist of memtargets
     // of the same type. Fix this.
     assert(verifyMemTargetsTypes(memspace) == UMF_RESULT_SUCCESS);
     ret = memspace->nodes[0]->ops->pool_create_from_memspace(
@@ -91,7 +91,7 @@ umfMemoryProviderCreateFromMemspace(umf_const_memspace_handle_t memspace,
         return ret;
     }
 
-    // TODO: for now, we only support memspaces that consist of memory_targets
+    // TODO: for now, we only support memspaces that consist of memtargets
     // of the same type. Fix this.
     assert(verifyMemTargetsTypes(memspace) == UMF_RESULT_SUCCESS);
     ret = memspace->nodes[0]->ops->memory_provider_create_from_memspace(
@@ -126,7 +126,7 @@ umf_result_t umfMemspaceClone(umf_const_memspace_handle_t hMemspace,
 
     clone->size = hMemspace->size;
     clone->nodes =
-        umf_ba_global_alloc(sizeof(umf_memory_target_handle_t) * clone->size);
+        umf_ba_global_alloc(sizeof(umf_memtarget_handle_t) * clone->size);
     if (!clone->nodes) {
         umf_ba_global_free(clone);
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
@@ -155,14 +155,14 @@ umf_result_t umfMemspaceClone(umf_const_memspace_handle_t hMemspace,
     return ret;
 }
 
-struct memory_target_sort_entry {
+struct memtarget_sort_entry {
     uint64_t property;
-    umf_memory_target_handle_t node;
+    umf_memtarget_handle_t node;
 };
 
 static int propertyCmp(const void *a, const void *b) {
-    const struct memory_target_sort_entry *entryA = a;
-    const struct memory_target_sort_entry *entryB = b;
+    const struct memtarget_sort_entry *entryA = a;
+    const struct memtarget_sort_entry *entryB = b;
 
     if (entryA->property < entryB->property) {
         return 1;
@@ -175,14 +175,14 @@ static int propertyCmp(const void *a, const void *b) {
 
 umf_result_t
 umfMemspaceSortDesc(umf_memspace_handle_t hMemspace,
-                    umf_result_t (*getProperty)(umf_memory_target_handle_t node,
+                    umf_result_t (*getProperty)(umf_memtarget_handle_t node,
                                                 uint64_t *property)) {
     if (!hMemspace || !getProperty) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    struct memory_target_sort_entry *entries = umf_ba_global_alloc(
-        sizeof(struct memory_target_sort_entry) * hMemspace->size);
+    struct memtarget_sort_entry *entries = umf_ba_global_alloc(
+        sizeof(struct memtarget_sort_entry) * hMemspace->size);
     if (!entries) {
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
     }
@@ -198,7 +198,7 @@ umfMemspaceSortDesc(umf_memspace_handle_t hMemspace,
         }
     }
 
-    qsort(entries, hMemspace->size, sizeof(struct memory_target_sort_entry),
+    qsort(entries, hMemspace->size, sizeof(struct memtarget_sort_entry),
           propertyCmp);
 
     // apply the order to the original array
@@ -218,7 +218,7 @@ umf_result_t umfMemspaceFilter(umf_const_memspace_handle_t hMemspace,
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    umf_memory_target_handle_t *uniqueBestNodes =
+    umf_memtarget_handle_t *uniqueBestNodes =
         umf_ba_global_alloc(hMemspace->size * sizeof(*uniqueBestNodes));
     if (!uniqueBestNodes) {
         return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
@@ -228,7 +228,7 @@ umf_result_t umfMemspaceFilter(umf_const_memspace_handle_t hMemspace,
 
     size_t numUniqueBestNodes = 0;
     for (size_t nodeIdx = 0; nodeIdx < hMemspace->size; nodeIdx++) {
-        umf_memory_target_handle_t target = NULL;
+        umf_memtarget_handle_t target = NULL;
         ret = getTarget(hMemspace->nodes[nodeIdx], hMemspace->nodes,
                         hMemspace->size, &target);
         if (ret != UMF_RESULT_SUCCESS) {

src/memspace_internal.h

@@ -13,15 +13,15 @@
 #include <umf/memspace.h>
 
 #include "base_alloc.h"
-#include "memory_target.h"
+#include "memtarget.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 struct umf_memspace_t {
     size_t size;
-    umf_memory_target_handle_t *nodes;
+    umf_memtarget_handle_t *nodes;
 };
 
 ///
@@ -30,19 +30,18 @@ struct umf_memspace_t {
 umf_result_t umfMemspaceClone(umf_const_memspace_handle_t hMemspace,
                               umf_memspace_handle_t *outHandle);
 
-typedef umf_result_t (*umfGetPropertyFn)(umf_memory_target_handle_t,
-                                         uint64_t *);
+typedef umf_result_t (*umfGetPropertyFn)(umf_memtarget_handle_t, uint64_t *);
 
 ///
 /// \brief Sorts memspace by getProperty() in descending order
 ///
 umf_result_t umfMemspaceSortDesc(umf_memspace_handle_t hMemspace,
                                  umfGetPropertyFn getProperty);
 
-typedef umf_result_t (*umfGetTargetFn)(umf_memory_target_handle_t initiator,
-                                       umf_memory_target_handle_t *nodes,
+typedef umf_result_t (*umfGetTargetFn)(umf_memtarget_handle_t initiator,
+                                       umf_memtarget_handle_t *nodes,
                                        size_t numNodes,
-                                       umf_memory_target_handle_t *target);
+                                       umf_memtarget_handle_t *target);
 
 ///
 /// \brief Filters the targets using getTarget() to create a new memspace

src/memspaces/memspace_highest_bandwidth.c

@@ -12,17 +12,17 @@
 #include <stdlib.h>
 
 #include "base_alloc_global.h"
-#include "memory_target_numa.h"
 #include "memspace_internal.h"
+#include "memtarget_numa.h"
 #include "topology.h"
 #include "utils_common.h"
 #include "utils_concurrency.h"
 #include "utils_log.h"
 
-static umf_result_t getBestBandwidthTarget(umf_memory_target_handle_t initiator,
-                                           umf_memory_target_handle_t *nodes,
+static umf_result_t getBestBandwidthTarget(umf_memtarget_handle_t initiator,
+                                           umf_memtarget_handle_t *nodes,
                                            size_t numNodes,
-                                           umf_memory_target_handle_t *target) {
+                                           umf_memtarget_handle_t *target) {
     size_t bestNodeIdx = 0;
     size_t bestBandwidth = 0;
     for (size_t nodeIdx = 0; nodeIdx < numNodes; nodeIdx++) {

src/memspaces/memspace_highest_capacity.c

@@ -11,8 +11,8 @@
 #include <stdlib.h>
 
 #include "base_alloc_global.h"
-#include "memory_target_numa.h"
 #include "memspace_internal.h"
+#include "memtarget_numa.h"
 #include "topology.h"
 #include "utils_concurrency.h"
 

src/memspaces/memspace_host_all.c

@@ -11,8 +11,8 @@
 #include <stdlib.h>
 
 #include "base_alloc_global.h"
-#include "memory_target_numa.h"
 #include "memspace_internal.h"
+#include "memtarget_numa.h"
 #include "topology.h"
 #include "utils_concurrency.h"
 

src/memspaces/memspace_lowest_latency.c

@@ -12,17 +12,17 @@
 #include <stdlib.h>
 
 #include "base_alloc_global.h"
-#include "memory_target_numa.h"
 #include "memspace_internal.h"
+#include "memtarget_numa.h"
 #include "topology.h"
 #include "utils_common.h"
 #include "utils_concurrency.h"
 #include "utils_log.h"
 
-static umf_result_t getBestLatencyTarget(umf_memory_target_handle_t initiator,
-                                         umf_memory_target_handle_t *nodes,
+static umf_result_t getBestLatencyTarget(umf_memtarget_handle_t initiator,
+                                         umf_memtarget_handle_t *nodes,
                                          size_t numNodes,
-                                         umf_memory_target_handle_t *target) {
+                                         umf_memtarget_handle_t *target) {
     size_t bestNodeIdx = 0;
     size_t bestLatency = SIZE_MAX;
     for (size_t nodeIdx = 0; nodeIdx < numNodes; nodeIdx++) {

src/memspaces/memspace_numa.c

@@ -9,8 +9,8 @@
 
 #include <stdlib.h>
 
-#include "../memory_targets/memory_target_numa.h"
 #include "../memspace_internal.h"
+#include "../memtargets/memtarget_numa.h"
 #include "base_alloc_global.h"
 
 umf_result_t umfMemspaceCreateFromNumaArray(unsigned *nodeIds, size_t numIds,
@@ -27,17 +27,17 @@ umf_result_t umfMemspaceCreateFromNumaArray(unsigned *nodeIds, size_t numIds,
     }
 
     memspace->size = numIds;
-    memspace->nodes = umf_ba_global_alloc(memspace->size *
-                                          sizeof(umf_memory_target_handle_t));
+    memspace->nodes =
+        umf_ba_global_alloc(memspace->size * sizeof(umf_memtarget_handle_t));
     if (!memspace->nodes) {
         ret = UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
         goto err_nodes_alloc;
     }
 
     size_t nodeIdx;
     for (nodeIdx = 0; nodeIdx < numIds; nodeIdx++) {
-        struct umf_numa_memory_target_config_t config = {nodeIds[nodeIdx]};
-        ret = umfMemoryTargetCreate(&UMF_MEMORY_TARGET_NUMA_OPS, &config,
+        struct umf_numa_memtarget_config_t config = {nodeIds[nodeIdx]};
+        ret = umfMemoryTargetCreate(&UMF_MEMTARGET_NUMA_OPS, &config,
                                     &memspace->nodes[nodeIdx]);
         if (ret) {
             goto err_target_create;