add memtargetGetType

Author: lplewa

include/umf/memtarget.h

@@ -10,13 +10,27 @@
 #ifndef UMF_MEMTARGET_H
 #define UMF_MEMTARGET_H 1
 
+#include <umf/base.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 typedef struct umf_memtarget_t *umf_memtarget_handle_t;
 typedef const struct umf_memtarget_t *umf_const_memtarget_handle_t;
 
+typedef enum umf_memtarget_type_t {
+    UMF_MEMTARGET_TYPE_UNKNOWN = 0,
+    UMF_MEMTARGET_TYPE_NUMA = 1,
+} umf_memtarget_type_t;
+
+/// \brief Gets the type of the memory target.
+/// \param hMemtarget handle to the memory target
+/// \param type [out] type of the memory target
+/// \return UMF_RESULT_SUCCESS on success or appropriate error code on failure.
+umf_result_t umfMemtargetGetType(umf_const_memtarget_handle_t hMemtarget,
+                                 umf_memtarget_type_t *type);
+
 #ifdef __cplusplus
 }
 #endif

src/libumf.def.in

@@ -43,6 +43,7 @@ EXPORTS
     umfMemspaceDestroy
     umfMemspaceMemtargetNum
     umfMemspaceMemtargetGet
+    umfMemtargetGetType
     umfOpenIPCHandle    
     umfOsMemoryProviderOps
     umfPoolAlignedMalloc

src/libumf.map

@@ -43,6 +43,7 @@ UMF_1.0 {
         umfMemspaceHighestCapacityGet;
         umfMemspaceHostAllGet;
         umfMemspaceLowestLatencyGet;
+        umfMemtargetGetType;
         umfOpenIPCHandle;
         umfOsMemoryProviderOps;
         umfPoolAlignedMalloc;

src/memtarget.c

@@ -106,3 +106,12 @@ umf_result_t umfMemtargetGetLatency(umf_memtarget_handle_t srcMemoryTarget,
     return srcMemoryTarget->ops->get_latency(srcMemoryTarget->priv,
                                              dstMemoryTarget->priv, latency);
 }
+
+umf_result_t umfMemtargetGetType(umf_const_memtarget_handle_t memoryTarget,
+                                 umf_memtarget_type_t *type) {
+    if (!memoryTarget || !type) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    return memoryTarget->ops->get_type(memoryTarget->priv, type);
+}

src/memtarget_ops.h

@@ -43,6 +43,8 @@ typedef struct umf_memtarget_ops_t {
                                   size_t *bandwidth);
     umf_result_t (*get_latency)(void *srcMemoryTarget, void *dstMemoryTarget,
                                 size_t *latency);
+
+    umf_result_t (*get_type)(void *memoryTarget, umf_memtarget_type_t *type);
 } umf_memtarget_ops_t;
 
 #ifdef __cplusplus

src/memtargets/memtarget_numa.c

@@ -317,6 +317,15 @@ static umf_result_t numa_get_latency(void *srcMemoryTarget,
     return UMF_RESULT_SUCCESS;
 }
 
+static umf_result_t numa_get_type(void *memTarget, umf_memtarget_type_t *type) {
+    if (!memTarget || !type) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    *type = UMF_MEMTARGET_TYPE_NUMA;
+    return UMF_RESULT_SUCCESS;
+}
+
 struct umf_memtarget_ops_t UMF_MEMTARGET_NUMA_OPS = {
     .version = UMF_VERSION_CURRENT,
     .initialize = numa_initialize,
@@ -326,5 +335,6 @@ struct umf_memtarget_ops_t UMF_MEMTARGET_NUMA_OPS = {
     .get_capacity = numa_get_capacity,
     .get_bandwidth = numa_get_bandwidth,
     .get_latency = numa_get_latency,
+    .get_type = numa_get_type,
     .memory_provider_create_from_memspace =
         numa_memory_provider_create_from_memspace};

test/memspaces/memtarget.cpp

@@ -3,7 +3,37 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 #include "memspace_helpers.hpp"
+
+#include <umf/base.h>
 #include <umf/memspace.h>
 #include <umf/memtarget.h>
 
 using umf_test::test;
+
+TEST_F(test, memTargetNuma) {
+    auto memspace = umfMemspaceHostAllGet();
+    ASSERT_NE(memspace, nullptr);
+
+    for (size_t i = 0; i < umfMemspaceMemtargetNum(memspace); i++) {
+        auto hTarget = umfMemspaceMemtargetGet(memspace, i);
+        ASSERT_NE(hTarget, nullptr);
+        umf_memtarget_type_t type;
+        auto ret = umfMemtargetGetType(hTarget, &type);
+        EXPECT_EQ(ret, UMF_RESULT_SUCCESS);
+        EXPECT_EQ(type, UMF_MEMTARGET_TYPE_NUMA);
+    }
+}
+
+TEST_F(test, memTargetInvalid) {
+    auto memspace = umfMemspaceHostAllGet();
+    ASSERT_NE(memspace, nullptr);
+    umf_memtarget_type_t type;
+    auto ret = umfMemtargetGetType(NULL, &type);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    ret = umfMemtargetGetType(NULL, NULL);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+    auto hTarget = umfMemspaceMemtargetGet(memspace, 0);
+    ASSERT_NE(hTarget, nullptr);
+    ret = umfMemtargetGetType(hTarget, NULL);
+    EXPECT_EQ(ret, UMF_RESULT_ERROR_INVALID_ARGUMENT);
+}