From 97d608b2c5082944fe1eb7cf49733c6b0dff2d2e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C5=81ukasz=20Plewa?= Date: Fri, 19 Jul 2024 16:55:57 +0200 Subject: [PATCH 1/3] rename mem_target to memtarget As we want to export memtarget api, it's name should be consistent with other api (memspace, mempolicy) --- src/CMakeLists.txt | 6 +-- src/memory_target.h | 51 ------------------- src/memspace.c | 32 ++++++------ src/memspace_internal.h | 13 +++-- src/memspaces/memspace_highest_bandwidth.c | 8 +-- src/memspaces/memspace_highest_capacity.c | 2 +- src/memspaces/memspace_host_all.c | 2 +- src/memspaces/memspace_lowest_latency.c | 8 +-- src/memspaces/memspace_numa.c | 10 ++-- src/{memory_target.c => memtarget.c} | 37 +++++++------- src/memtarget.h | 47 +++++++++++++++++ src/{memory_target_ops.h => memtarget_ops.h} | 12 ++--- .../memtarget_numa.c} | 39 +++++++------- .../memtarget_numa.h} | 14 ++--- test/memspaces/memspace_highest_capacity.cpp | 2 +- test/memspaces/memspace_host_all.cpp | 6 +-- 16 files changed, 140 insertions(+), 149 deletions(-) delete mode 100644 src/memory_target.h rename src/{memory_target.c => memtarget.c} (65%) create mode 100644 src/memtarget.h rename src/{memory_target_ops.h => memtarget_ops.h} (85%) rename src/{memory_targets/memory_target_numa.c => memtargets/memtarget_numa.c} (89%) rename src/{memory_targets/memory_target_numa.h => memtargets/memtarget_numa.h} (54%) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 751792db4..7c19133f1 100644 --- a/src/CMakeLists.txt +++ b/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( $ $ $ - $ + $ $) install(TARGETS umf EXPORT ${PROJECT_NAME}-targets) diff --git a/src/memory_target.h b/src/memory_target.h deleted file mode 100644 index c522cce24..000000000 --- a/src/memory_target.h +++ /dev/null @@ -1,51 +0,0 @@ -/* - * - * Copyright (C) 2023-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_MEMORY_TARGET_H -#define UMF_MEMORY_TARGET_H 1 - -#include - -#ifdef __cplusplus -extern "C" { -#endif - -struct umf_memory_target_ops_t; -typedef struct umf_memory_target_ops_t umf_memory_target_ops_t; - -typedef struct umf_memory_target_t { - const umf_memory_target_ops_t *ops; - void *priv; -} umf_memory_target_t; - -typedef umf_memory_target_t *umf_memory_target_handle_t; - -umf_result_t umfMemoryTargetCreate(const umf_memory_target_ops_t *ops, - void *params, - umf_memory_target_handle_t *memoryTarget); -void umfMemoryTargetDestroy(umf_memory_target_handle_t memoryTarget); - -umf_result_t umfMemoryTargetClone(umf_memory_target_handle_t memoryTarget, - umf_memory_target_handle_t *outHandle); -umf_result_t umfMemoryTargetGetCapacity(umf_memory_target_handle_t memoryTarget, - size_t *capacity); -umf_result_t -umfMemoryTargetGetBandwidth(umf_memory_target_handle_t srcMemoryTarget, - umf_memory_target_handle_t dstMemoryTarget, - size_t *bandwidth); -umf_result_t -umfMemoryTargetGetLatency(umf_memory_target_handle_t srcMemoryTarget, - umf_memory_target_handle_t dstMemoryTarget, - size_t *latency); - -#ifdef __cplusplus -} -#endif - -#endif /* UMF_MEMORY_TARGET_H */ diff --git a/src/memspace.c b/src/memspace.c index 03e716c84..ea4fe1775 100644 --- a/src/memspace.c +++ b/src/memspace.c @@ -13,9 +13,9 @@ #include #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) { diff --git a/src/memspace_internal.h b/src/memspace_internal.h index b570a7472..7cc62fac2 100644 --- a/src/memspace_internal.h +++ b/src/memspace_internal.h @@ -13,7 +13,7 @@ #include #include "base_alloc.h" -#include "memory_target.h" +#include "memtarget.h" #ifdef __cplusplus extern "C" { @@ -21,7 +21,7 @@ extern "C" { struct umf_memspace_t { size_t size; - umf_memory_target_handle_t *nodes; + umf_memtarget_handle_t *nodes; }; /// @@ -30,8 +30,7 @@ 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 @@ -39,10 +38,10 @@ typedef umf_result_t (*umfGetPropertyFn)(umf_memory_target_handle_t, 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 diff --git a/src/memspaces/memspace_highest_bandwidth.c b/src/memspaces/memspace_highest_bandwidth.c index d82e5f4f1..9790dbe8b 100644 --- a/src/memspaces/memspace_highest_bandwidth.c +++ b/src/memspaces/memspace_highest_bandwidth.c @@ -12,17 +12,17 @@ #include #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++) { diff --git a/src/memspaces/memspace_highest_capacity.c b/src/memspaces/memspace_highest_capacity.c index 0b8f3522e..862ae5a8e 100644 --- a/src/memspaces/memspace_highest_capacity.c +++ b/src/memspaces/memspace_highest_capacity.c @@ -11,8 +11,8 @@ #include #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" diff --git a/src/memspaces/memspace_host_all.c b/src/memspaces/memspace_host_all.c index 62c968743..63d4611a8 100644 --- a/src/memspaces/memspace_host_all.c +++ b/src/memspaces/memspace_host_all.c @@ -11,8 +11,8 @@ #include #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" diff --git a/src/memspaces/memspace_lowest_latency.c b/src/memspaces/memspace_lowest_latency.c index 2c6656ab2..d9c918712 100644 --- a/src/memspaces/memspace_lowest_latency.c +++ b/src/memspaces/memspace_lowest_latency.c @@ -12,17 +12,17 @@ #include #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++) { diff --git a/src/memspaces/memspace_numa.c b/src/memspaces/memspace_numa.c index 52dc85b64..e4346a4db 100644 --- a/src/memspaces/memspace_numa.c +++ b/src/memspaces/memspace_numa.c @@ -9,8 +9,8 @@ #include -#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,8 +27,8 @@ 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; @@ -36,8 +36,8 @@ umf_result_t umfMemspaceCreateFromNumaArray(unsigned *nodeIds, size_t numIds, 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; diff --git a/src/memory_target.c b/src/memtarget.c similarity index 65% rename from src/memory_target.c rename to src/memtarget.c index 3cbdb09d9..cf9b30818 100644 --- a/src/memory_target.c +++ b/src/memtarget.c @@ -12,20 +12,19 @@ #include "base_alloc_global.h" #include "libumf.h" -#include "memory_target.h" -#include "memory_target_ops.h" +#include "memtarget.h" +#include "memtarget_ops.h" #include "utils_concurrency.h" -umf_result_t umfMemoryTargetCreate(const umf_memory_target_ops_t *ops, - void *params, - umf_memory_target_handle_t *memoryTarget) { +umf_result_t umfMemoryTargetCreate(const umf_memtarget_ops_t *ops, void *params, + umf_memtarget_handle_t *memoryTarget) { libumfInit(); if (!ops || !memoryTarget) { return UMF_RESULT_ERROR_INVALID_ARGUMENT; } - umf_memory_target_handle_t target = - umf_ba_global_alloc(sizeof(umf_memory_target_t)); + umf_memtarget_handle_t target = + umf_ba_global_alloc(sizeof(umf_memtarget_t)); if (!target) { return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY; } @@ -48,18 +47,18 @@ umf_result_t umfMemoryTargetCreate(const umf_memory_target_ops_t *ops, return UMF_RESULT_SUCCESS; } -void umfMemoryTargetDestroy(umf_memory_target_handle_t memoryTarget) { +void umfMemoryTargetDestroy(umf_memtarget_handle_t memoryTarget) { assert(memoryTarget); memoryTarget->ops->finalize(memoryTarget->priv); umf_ba_global_free(memoryTarget); } -umf_result_t umfMemoryTargetClone(umf_memory_target_handle_t memoryTarget, - umf_memory_target_handle_t *outHandle) { +umf_result_t umfMemoryTargetClone(umf_memtarget_handle_t memoryTarget, + umf_memtarget_handle_t *outHandle) { assert(memoryTarget); assert(outHandle); - *outHandle = umf_ba_global_alloc(sizeof(umf_memory_target_t)); + *outHandle = umf_ba_global_alloc(sizeof(umf_memtarget_t)); if (!*outHandle) { return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY; } @@ -77,7 +76,7 @@ umf_result_t umfMemoryTargetClone(umf_memory_target_handle_t memoryTarget, return UMF_RESULT_SUCCESS; } -umf_result_t umfMemoryTargetGetCapacity(umf_memory_target_handle_t memoryTarget, +umf_result_t umfMemoryTargetGetCapacity(umf_memtarget_handle_t memoryTarget, size_t *capacity) { if (!memoryTarget || !capacity) { return UMF_RESULT_ERROR_INVALID_ARGUMENT; @@ -86,10 +85,9 @@ umf_result_t umfMemoryTargetGetCapacity(umf_memory_target_handle_t memoryTarget, return memoryTarget->ops->get_capacity(memoryTarget->priv, capacity); } -umf_result_t -umfMemoryTargetGetBandwidth(umf_memory_target_handle_t srcMemoryTarget, - umf_memory_target_handle_t dstMemoryTarget, - size_t *bandwidth) { +umf_result_t umfMemoryTargetGetBandwidth(umf_memtarget_handle_t srcMemoryTarget, + umf_memtarget_handle_t dstMemoryTarget, + size_t *bandwidth) { if (!srcMemoryTarget || !dstMemoryTarget || !bandwidth) { return UMF_RESULT_ERROR_INVALID_ARGUMENT; } @@ -98,10 +96,9 @@ umfMemoryTargetGetBandwidth(umf_memory_target_handle_t srcMemoryTarget, srcMemoryTarget->priv, dstMemoryTarget->priv, bandwidth); } -umf_result_t -umfMemoryTargetGetLatency(umf_memory_target_handle_t srcMemoryTarget, - umf_memory_target_handle_t dstMemoryTarget, - size_t *latency) { +umf_result_t umfMemoryTargetGetLatency(umf_memtarget_handle_t srcMemoryTarget, + umf_memtarget_handle_t dstMemoryTarget, + size_t *latency) { if (!srcMemoryTarget || !dstMemoryTarget || !latency) { return UMF_RESULT_ERROR_INVALID_ARGUMENT; } diff --git a/src/memtarget.h b/src/memtarget.h new file mode 100644 index 000000000..69125c21f --- /dev/null +++ b/src/memtarget.h @@ -0,0 +1,47 @@ +/* + * + * Copyright (C) 2023-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_MEMTARGET_H +#define UMF_MEMTARGET_H 1 + +#include +#ifdef __cplusplus +extern "C" { +#endif + +struct umf_memtarget_ops_t; +typedef struct umf_memtarget_ops_t umf_memtarget_ops_t; + +typedef struct umf_memtarget_t { + const umf_memtarget_ops_t *ops; + void *priv; +} umf_memtarget_t; + +typedef umf_memtarget_t *umf_memtarget_handle_t; + +umf_result_t umfMemoryTargetCreate(const umf_memtarget_ops_t *ops, void *params, + umf_memtarget_handle_t *memoryTarget); +void umfMemoryTargetDestroy(umf_memtarget_handle_t memoryTarget); + +umf_result_t umfMemoryTargetClone(umf_memtarget_handle_t memoryTarget, + umf_memtarget_handle_t *outHandle); +umf_result_t umfMemoryTargetGetCapacity(umf_memtarget_handle_t memoryTarget, + size_t *capacity); +umf_result_t umfMemoryTargetGetBandwidth(umf_memtarget_handle_t srcMemoryTarget, + umf_memtarget_handle_t dstMemoryTarget, + size_t *bandwidth); +umf_result_t umfMemoryTargetGetLatency(umf_memtarget_handle_t srcMemoryTarget, + umf_memtarget_handle_t dstMemoryTarget, + size_t *latency); + +#ifdef __cplusplus +} +#endif + +#endif /* UMF_MEMTARGET_H */ diff --git a/src/memory_target_ops.h b/src/memtarget_ops.h similarity index 85% rename from src/memory_target_ops.h rename to src/memtarget_ops.h index 24e4e8108..f53b80524 100644 --- a/src/memory_target_ops.h +++ b/src/memtarget_ops.h @@ -7,8 +7,8 @@ * */ -#ifndef UMF_MEMORY_TARGET_OPS_H -#define UMF_MEMORY_TARGET_OPS_H 1 +#ifndef UMF_MEMTARGET_OPS_H +#define UMF_MEMTARGET_OPS_H 1 #include #include @@ -17,9 +17,9 @@ extern "C" { #endif -typedef struct umf_memory_target_t *umf_memory_target_handle_t; +typedef struct umf_memtarget_t *umf_memtarget_handle_t; -typedef struct umf_memory_target_ops_t { +typedef struct umf_memtarget_ops_t { /// Version of the ops structure. /// Should be initialized using UMF_VERSION_CURRENT uint32_t version; @@ -44,10 +44,10 @@ typedef struct umf_memory_target_ops_t { size_t *bandwidth); umf_result_t (*get_latency)(void *srcMemoryTarget, void *dstMemoryTarget, size_t *latency); -} umf_memory_target_ops_t; +} umf_memtarget_ops_t; #ifdef __cplusplus } #endif -#endif /* #ifndef UMF_MEMORY_TARGET_OPS_H */ +#endif /* #ifndef UMF_MEMTARGET_OPS_H */ diff --git a/src/memory_targets/memory_target_numa.c b/src/memtargets/memtarget_numa.c similarity index 89% rename from src/memory_targets/memory_target_numa.c rename to src/memtargets/memtarget_numa.c index aa33a1853..553c780bc 100644 --- a/src/memory_targets/memory_target_numa.c +++ b/src/memtargets/memtarget_numa.c @@ -16,13 +16,13 @@ #include "../memory_pool_internal.h" #include "base_alloc.h" #include "base_alloc_global.h" -#include "memory_target_numa.h" #include "mempolicy_internal.h" +#include "memtarget_numa.h" #include "topology.h" #include "utils_assert.h" #include "utils_log.h" -struct numa_memory_target_t { +struct numa_memtarget_t { unsigned physical_id; }; @@ -31,11 +31,11 @@ static umf_result_t numa_initialize(void *params, void **memTarget) { return UMF_RESULT_ERROR_INVALID_ARGUMENT; } - struct umf_numa_memory_target_config_t *config = - (struct umf_numa_memory_target_config_t *)params; + struct umf_numa_memtarget_config_t *config = + (struct umf_numa_memtarget_config_t *)params; - struct numa_memory_target_t *numaTarget = - umf_ba_global_alloc(sizeof(struct numa_memory_target_t)); + struct numa_memtarget_t *numaTarget = + umf_ba_global_alloc(sizeof(struct numa_memtarget_t)); if (!numaTarget) { return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY; } @@ -52,8 +52,8 @@ static umf_result_t numa_memory_provider_create_from_memspace( umf_const_mempolicy_handle_t policy, umf_memory_provider_handle_t *provider) { - struct numa_memory_target_t **numaTargets = - (struct numa_memory_target_t **)memTargets; + struct numa_memtarget_t **numaTargets = + (struct numa_memtarget_t **)memTargets; size_t numNodesProvider; @@ -161,10 +161,9 @@ static umf_result_t numa_pool_create_from_memspace( } static umf_result_t numa_clone(void *memTarget, void **outMemTarget) { - struct numa_memory_target_t *numaTarget = - (struct numa_memory_target_t *)memTarget; - struct numa_memory_target_t *newNumaTarget = - umf_ba_global_alloc(sizeof(struct numa_memory_target_t)); + struct numa_memtarget_t *numaTarget = (struct numa_memtarget_t *)memTarget; + struct numa_memtarget_t *newNumaTarget = + umf_ba_global_alloc(sizeof(struct numa_memtarget_t)); if (!newNumaTarget) { return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY; } @@ -185,7 +184,7 @@ static umf_result_t numa_get_capacity(void *memTarget, size_t *capacity) { } hwloc_obj_t numaNode = hwloc_get_numanode_obj_by_os_index( - topology, ((struct numa_memory_target_t *)memTarget)->physical_id); + topology, ((struct numa_memtarget_t *)memTarget)->physical_id); if (!numaNode) { return UMF_RESULT_ERROR_INVALID_ARGUMENT; } @@ -226,7 +225,7 @@ static umf_result_t query_attribute_value(void *srcMemoryTarget, hwloc_obj_t srcNumaNode = hwloc_get_obj_by_type( topology, HWLOC_OBJ_NUMANODE, - ((struct numa_memory_target_t *)srcMemoryTarget)->physical_id); + ((struct numa_memtarget_t *)srcMemoryTarget)->physical_id); if (!srcNumaNode) { LOG_PERR("Getting HWLOC object by type failed"); return UMF_RESULT_ERROR_INVALID_ARGUMENT; @@ -234,7 +233,7 @@ static umf_result_t query_attribute_value(void *srcMemoryTarget, hwloc_obj_t dstNumaNode = hwloc_get_obj_by_type( topology, HWLOC_OBJ_NUMANODE, - ((struct numa_memory_target_t *)dstMemoryTarget)->physical_id); + ((struct numa_memtarget_t *)dstMemoryTarget)->physical_id); if (!dstNumaNode) { LOG_PERR("Getting HWLOC object by type failed"); return UMF_RESULT_ERROR_INVALID_ARGUMENT; @@ -292,8 +291,8 @@ static umf_result_t numa_get_bandwidth(void *srcMemoryTarget, bandwidth, MEMATTR_TYPE_BANDWIDTH); if (ret) { LOG_ERR("Retrieving bandwidth for initiator node %u to node %u failed.", - ((struct numa_memory_target_t *)srcMemoryTarget)->physical_id, - ((struct numa_memory_target_t *)dstMemoryTarget)->physical_id); + ((struct numa_memtarget_t *)srcMemoryTarget)->physical_id, + ((struct numa_memtarget_t *)dstMemoryTarget)->physical_id); return ret; } @@ -310,15 +309,15 @@ static umf_result_t numa_get_latency(void *srcMemoryTarget, latency, MEMATTR_TYPE_LATENCY); if (ret) { LOG_ERR("Retrieving latency for initiator node %u to node %u failed.", - ((struct numa_memory_target_t *)srcMemoryTarget)->physical_id, - ((struct numa_memory_target_t *)dstMemoryTarget)->physical_id); + ((struct numa_memtarget_t *)srcMemoryTarget)->physical_id, + ((struct numa_memtarget_t *)dstMemoryTarget)->physical_id); return ret; } return UMF_RESULT_SUCCESS; } -struct umf_memory_target_ops_t UMF_MEMORY_TARGET_NUMA_OPS = { +struct umf_memtarget_ops_t UMF_MEMTARGET_NUMA_OPS = { .version = UMF_VERSION_CURRENT, .initialize = numa_initialize, .finalize = numa_finalize, diff --git a/src/memory_targets/memory_target_numa.h b/src/memtargets/memtarget_numa.h similarity index 54% rename from src/memory_targets/memory_target_numa.h rename to src/memtargets/memtarget_numa.h index 843610a2a..c4902d23e 100644 --- a/src/memory_targets/memory_target_numa.h +++ b/src/memtargets/memtarget_numa.h @@ -7,27 +7,27 @@ * */ -#ifndef UMF_MEMORY_TARGET_NUMA_H -#define UMF_MEMORY_TARGET_NUMA_H 1 +#ifndef UMF_MEMTARGET_NUMA_H +#define UMF_MEMTARGET_NUMA_H 1 #include #include -#include "../memory_target.h" -#include "../memory_target_ops.h" +#include "../memtarget.h" +#include "../memtarget_ops.h" #ifdef __cplusplus extern "C" { #endif -struct umf_numa_memory_target_config_t { +struct umf_numa_memtarget_config_t { size_t physical_id; }; -extern struct umf_memory_target_ops_t UMF_MEMORY_TARGET_NUMA_OPS; +extern struct umf_memtarget_ops_t UMF_MEMTARGET_NUMA_OPS; #ifdef __cplusplus } #endif -#endif /* UMF_MEMORY_TARGET_NUMA_H */ +#endif /* UMF_MEMTARGET_NUMA_H */ diff --git a/test/memspaces/memspace_highest_capacity.cpp b/test/memspaces/memspace_highest_capacity.cpp index 3f3e99c76..fdfed91ec 100644 --- a/test/memspaces/memspace_highest_capacity.cpp +++ b/test/memspaces/memspace_highest_capacity.cpp @@ -2,10 +2,10 @@ // Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception -#include "memory_target_numa.h" #include "memspace_fixtures.hpp" #include "memspace_helpers.hpp" #include "memspace_internal.h" +#include "memtarget_numa.h" #include "numa_helpers.h" #include "test_helpers.h" diff --git a/test/memspaces/memspace_host_all.cpp b/test/memspaces/memspace_host_all.cpp index 8d11aca0b..bf7dbbe8b 100644 --- a/test/memspaces/memspace_host_all.cpp +++ b/test/memspaces/memspace_host_all.cpp @@ -9,10 +9,10 @@ #include -#include "memory_target_numa.h" #include "memspace_fixtures.hpp" #include "memspace_helpers.hpp" #include "memspace_internal.h" +#include "memtarget_numa.h" #include "numa_helpers.h" #include "test_helpers.h" #include "utils_sanitizers.h" @@ -58,8 +58,8 @@ TEST_F(numaNodesTest, memspaceGet) { for (size_t i = 0; i < hMemspace->size; i++) { // NUMA memory target internally casts the config directly into priv. // TODO: Use the memory target API when it becomes available. - struct umf_numa_memory_target_config_t *numaTargetCfg = - (struct umf_numa_memory_target_config_t *)hMemspace->nodes[i]->priv; + struct umf_numa_memtarget_config_t *numaTargetCfg = + (struct umf_numa_memtarget_config_t *)hMemspace->nodes[i]->priv; UT_ASSERT(std::find(nodeIds.begin(), nodeIds.end(), numaTargetCfg->physical_id) != nodeIds.end()); } From dcfc94f5e43540807b5ddd5483deb275a15a2258 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C5=81ukasz=20Plewa?= Date: Fri, 19 Jul 2024 17:03:41 +0200 Subject: [PATCH 2/3] Create public header with memtarget declaration Also rename internal header to memtarget_internal.h --- include/umf/memtarget.h | 24 +++++++++++++++++++++++ src/memspace.c | 2 +- src/memspace_internal.h | 2 +- src/memtarget.c | 2 +- src/{memtarget.h => memtarget_internal.h} | 9 ++++----- src/memtarget_ops.h | 3 +-- src/memtargets/memtarget_numa.h | 2 +- 7 files changed, 33 insertions(+), 11 deletions(-) create mode 100644 include/umf/memtarget.h rename src/{memtarget.h => memtarget_internal.h} (91%) diff --git a/include/umf/memtarget.h b/include/umf/memtarget.h new file mode 100644 index 000000000..47f938691 --- /dev/null +++ b/include/umf/memtarget.h @@ -0,0 +1,24 @@ +/* + * + * 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_MEMTARGET_H +#define UMF_MEMTARGET_H 1 + +#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; + +#ifdef __cplusplus +} +#endif + +#endif /* UMF_MEMTARGET_H */ diff --git a/src/memspace.c b/src/memspace.c index ea4fe1775..e56a69c33 100644 --- a/src/memspace.c +++ b/src/memspace.c @@ -14,7 +14,7 @@ #include "base_alloc_global.h" #include "memspace_internal.h" -#include "memtarget.h" +#include "memtarget_internal.h" #include "memtarget_ops.h" #ifndef NDEBUG diff --git a/src/memspace_internal.h b/src/memspace_internal.h index 7cc62fac2..0cb28b92f 100644 --- a/src/memspace_internal.h +++ b/src/memspace_internal.h @@ -13,7 +13,7 @@ #include #include "base_alloc.h" -#include "memtarget.h" +#include "memtarget_internal.h" #ifdef __cplusplus extern "C" { diff --git a/src/memtarget.c b/src/memtarget.c index cf9b30818..d11e14e2f 100644 --- a/src/memtarget.c +++ b/src/memtarget.c @@ -12,7 +12,7 @@ #include "base_alloc_global.h" #include "libumf.h" -#include "memtarget.h" +#include "memtarget_internal.h" #include "memtarget_ops.h" #include "utils_concurrency.h" diff --git a/src/memtarget.h b/src/memtarget_internal.h similarity index 91% rename from src/memtarget.h rename to src/memtarget_internal.h index 69125c21f..45d547bf7 100644 --- a/src/memtarget.h +++ b/src/memtarget_internal.h @@ -7,10 +7,11 @@ * */ -#ifndef UMF_MEMTARGET_H -#define UMF_MEMTARGET_H 1 +#ifndef UMF_MEMTARGET_INTERNAL_H +#define UMF_MEMTARGET_INTERNAL_H 1 #include +#include #ifdef __cplusplus extern "C" { #endif @@ -23,8 +24,6 @@ typedef struct umf_memtarget_t { void *priv; } umf_memtarget_t; -typedef umf_memtarget_t *umf_memtarget_handle_t; - umf_result_t umfMemoryTargetCreate(const umf_memtarget_ops_t *ops, void *params, umf_memtarget_handle_t *memoryTarget); void umfMemoryTargetDestroy(umf_memtarget_handle_t memoryTarget); @@ -44,4 +43,4 @@ umf_result_t umfMemoryTargetGetLatency(umf_memtarget_handle_t srcMemoryTarget, } #endif -#endif /* UMF_MEMTARGET_H */ +#endif /* UMF_MEMTARGET_INTERNAL_H */ diff --git a/src/memtarget_ops.h b/src/memtarget_ops.h index f53b80524..85555f0ce 100644 --- a/src/memtarget_ops.h +++ b/src/memtarget_ops.h @@ -12,13 +12,12 @@ #include #include +#include #ifdef __cplusplus extern "C" { #endif -typedef struct umf_memtarget_t *umf_memtarget_handle_t; - typedef struct umf_memtarget_ops_t { /// Version of the ops structure. /// Should be initialized using UMF_VERSION_CURRENT diff --git a/src/memtargets/memtarget_numa.h b/src/memtargets/memtarget_numa.h index c4902d23e..2d3e3fd70 100644 --- a/src/memtargets/memtarget_numa.h +++ b/src/memtargets/memtarget_numa.h @@ -13,7 +13,7 @@ #include #include -#include "../memtarget.h" +#include "../memtarget_internal.h" #include "../memtarget_ops.h" #ifdef __cplusplus From a4b0766e7f3e6550a3e62b7c0e060c3f26a7ad4f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=C5=81ukasz=20Plewa?= Date: Mon, 22 Jul 2024 15:12:49 +0200 Subject: [PATCH 3/3] Rename umfMemoryTarget functions --- src/memspace.c | 12 +++++----- src/memspaces/memspace_highest_bandwidth.c | 2 +- src/memspaces/memspace_highest_capacity.c | 2 +- src/memspaces/memspace_lowest_latency.c | 2 +- src/memspaces/memspace_numa.c | 6 ++--- src/memtarget.c | 26 ++++++++++---------- src/memtarget_internal.h | 28 +++++++++++----------- 7 files changed, 39 insertions(+), 39 deletions(-) diff --git a/src/memspace.c b/src/memspace.c index e56a69c33..0dfbfeae3 100644 --- a/src/memspace.c +++ b/src/memspace.c @@ -105,7 +105,7 @@ umfMemoryProviderCreateFromMemspace(umf_const_memspace_handle_t memspace, void umfMemspaceDestroy(umf_memspace_handle_t memspace) { assert(memspace); for (size_t i = 0; i < memspace->size; i++) { - umfMemoryTargetDestroy(memspace->nodes[i]); + umfMemtargetDestroy(memspace->nodes[i]); } umf_ba_global_free(memspace->nodes); @@ -136,7 +136,7 @@ umf_result_t umfMemspaceClone(umf_const_memspace_handle_t hMemspace, umf_result_t ret; for (i = 0; i < clone->size; i++) { - ret = umfMemoryTargetClone(hMemspace->nodes[i], &clone->nodes[i]); + ret = umfMemtargetClone(hMemspace->nodes[i], &clone->nodes[i]); if (ret != UMF_RESULT_SUCCESS) { goto err; } @@ -148,7 +148,7 @@ umf_result_t umfMemspaceClone(umf_const_memspace_handle_t hMemspace, err: while (i != 0) { i--; - umfMemoryTargetDestroy(clone->nodes[i]); + umfMemtargetDestroy(clone->nodes[i]); } umf_ba_global_free(clone->nodes); umf_ba_global_free(clone); @@ -268,8 +268,8 @@ umf_result_t umfMemspaceFilter(umf_const_memspace_handle_t hMemspace, size_t cloneIdx = 0; for (cloneIdx = 0; cloneIdx < newMemspace->size; cloneIdx++) { - ret = umfMemoryTargetClone(uniqueBestNodes[cloneIdx], - &newMemspace->nodes[cloneIdx]); + ret = umfMemtargetClone(uniqueBestNodes[cloneIdx], + &newMemspace->nodes[cloneIdx]); if (ret != UMF_RESULT_SUCCESS) { goto err_free_cloned_nodes; } @@ -283,7 +283,7 @@ umf_result_t umfMemspaceFilter(umf_const_memspace_handle_t hMemspace, err_free_cloned_nodes: while (cloneIdx != 0) { cloneIdx--; - umfMemoryTargetDestroy(newMemspace->nodes[cloneIdx]); + umfMemtargetDestroy(newMemspace->nodes[cloneIdx]); } umf_ba_global_free(newMemspace->nodes); err_free_new_memspace: diff --git a/src/memspaces/memspace_highest_bandwidth.c b/src/memspaces/memspace_highest_bandwidth.c index 9790dbe8b..3fb721717 100644 --- a/src/memspaces/memspace_highest_bandwidth.c +++ b/src/memspaces/memspace_highest_bandwidth.c @@ -28,7 +28,7 @@ static umf_result_t getBestBandwidthTarget(umf_memtarget_handle_t initiator, for (size_t nodeIdx = 0; nodeIdx < numNodes; nodeIdx++) { size_t bandwidth = 0; umf_result_t ret = - umfMemoryTargetGetBandwidth(initiator, nodes[nodeIdx], &bandwidth); + umfMemtargetGetBandwidth(initiator, nodes[nodeIdx], &bandwidth); if (ret) { return ret; } diff --git a/src/memspaces/memspace_highest_capacity.c b/src/memspaces/memspace_highest_capacity.c index 862ae5a8e..2469ba496 100644 --- a/src/memspaces/memspace_highest_capacity.c +++ b/src/memspaces/memspace_highest_capacity.c @@ -34,7 +34,7 @@ umfMemspaceHighestCapacityCreate(umf_memspace_handle_t *hMemspace) { } ret = umfMemspaceSortDesc(highCapacityMemspace, - (umfGetPropertyFn)&umfMemoryTargetGetCapacity); + (umfGetPropertyFn)&umfMemtargetGetCapacity); if (ret != UMF_RESULT_SUCCESS) { return ret; } diff --git a/src/memspaces/memspace_lowest_latency.c b/src/memspaces/memspace_lowest_latency.c index d9c918712..9a34e3f83 100644 --- a/src/memspaces/memspace_lowest_latency.c +++ b/src/memspaces/memspace_lowest_latency.c @@ -28,7 +28,7 @@ static umf_result_t getBestLatencyTarget(umf_memtarget_handle_t initiator, for (size_t nodeIdx = 0; nodeIdx < numNodes; nodeIdx++) { size_t latency = SIZE_MAX; umf_result_t ret = - umfMemoryTargetGetLatency(initiator, nodes[nodeIdx], &latency); + umfMemtargetGetLatency(initiator, nodes[nodeIdx], &latency); if (ret) { return ret; } diff --git a/src/memspaces/memspace_numa.c b/src/memspaces/memspace_numa.c index e4346a4db..306851d7c 100644 --- a/src/memspaces/memspace_numa.c +++ b/src/memspaces/memspace_numa.c @@ -37,8 +37,8 @@ umf_result_t umfMemspaceCreateFromNumaArray(unsigned *nodeIds, size_t numIds, size_t nodeIdx; for (nodeIdx = 0; nodeIdx < numIds; nodeIdx++) { struct umf_numa_memtarget_config_t config = {nodeIds[nodeIdx]}; - ret = umfMemoryTargetCreate(&UMF_MEMTARGET_NUMA_OPS, &config, - &memspace->nodes[nodeIdx]); + ret = umfMemtargetCreate(&UMF_MEMTARGET_NUMA_OPS, &config, + &memspace->nodes[nodeIdx]); if (ret) { goto err_target_create; } @@ -51,7 +51,7 @@ umf_result_t umfMemspaceCreateFromNumaArray(unsigned *nodeIds, size_t numIds, err_target_create: umf_ba_global_free(memspace->nodes); for (size_t i = 0; i < nodeIdx; i++) { - umfMemoryTargetDestroy(memspace->nodes[i]); + umfMemtargetDestroy(memspace->nodes[i]); } err_nodes_alloc: umf_ba_global_free(memspace); diff --git a/src/memtarget.c b/src/memtarget.c index d11e14e2f..33c737ae0 100644 --- a/src/memtarget.c +++ b/src/memtarget.c @@ -16,8 +16,8 @@ #include "memtarget_ops.h" #include "utils_concurrency.h" -umf_result_t umfMemoryTargetCreate(const umf_memtarget_ops_t *ops, void *params, - umf_memtarget_handle_t *memoryTarget) { +umf_result_t umfMemtargetCreate(const umf_memtarget_ops_t *ops, void *params, + umf_memtarget_handle_t *memoryTarget) { libumfInit(); if (!ops || !memoryTarget) { return UMF_RESULT_ERROR_INVALID_ARGUMENT; @@ -47,14 +47,14 @@ umf_result_t umfMemoryTargetCreate(const umf_memtarget_ops_t *ops, void *params, return UMF_RESULT_SUCCESS; } -void umfMemoryTargetDestroy(umf_memtarget_handle_t memoryTarget) { +void umfMemtargetDestroy(umf_memtarget_handle_t memoryTarget) { assert(memoryTarget); memoryTarget->ops->finalize(memoryTarget->priv); umf_ba_global_free(memoryTarget); } -umf_result_t umfMemoryTargetClone(umf_memtarget_handle_t memoryTarget, - umf_memtarget_handle_t *outHandle) { +umf_result_t umfMemtargetClone(umf_memtarget_handle_t memoryTarget, + umf_memtarget_handle_t *outHandle) { assert(memoryTarget); assert(outHandle); @@ -76,8 +76,8 @@ umf_result_t umfMemoryTargetClone(umf_memtarget_handle_t memoryTarget, return UMF_RESULT_SUCCESS; } -umf_result_t umfMemoryTargetGetCapacity(umf_memtarget_handle_t memoryTarget, - size_t *capacity) { +umf_result_t umfMemtargetGetCapacity(umf_memtarget_handle_t memoryTarget, + size_t *capacity) { if (!memoryTarget || !capacity) { return UMF_RESULT_ERROR_INVALID_ARGUMENT; } @@ -85,9 +85,9 @@ umf_result_t umfMemoryTargetGetCapacity(umf_memtarget_handle_t memoryTarget, return memoryTarget->ops->get_capacity(memoryTarget->priv, capacity); } -umf_result_t umfMemoryTargetGetBandwidth(umf_memtarget_handle_t srcMemoryTarget, - umf_memtarget_handle_t dstMemoryTarget, - size_t *bandwidth) { +umf_result_t umfMemtargetGetBandwidth(umf_memtarget_handle_t srcMemoryTarget, + umf_memtarget_handle_t dstMemoryTarget, + size_t *bandwidth) { if (!srcMemoryTarget || !dstMemoryTarget || !bandwidth) { return UMF_RESULT_ERROR_INVALID_ARGUMENT; } @@ -96,9 +96,9 @@ umf_result_t umfMemoryTargetGetBandwidth(umf_memtarget_handle_t srcMemoryTarget, srcMemoryTarget->priv, dstMemoryTarget->priv, bandwidth); } -umf_result_t umfMemoryTargetGetLatency(umf_memtarget_handle_t srcMemoryTarget, - umf_memtarget_handle_t dstMemoryTarget, - size_t *latency) { +umf_result_t umfMemtargetGetLatency(umf_memtarget_handle_t srcMemoryTarget, + umf_memtarget_handle_t dstMemoryTarget, + size_t *latency) { if (!srcMemoryTarget || !dstMemoryTarget || !latency) { return UMF_RESULT_ERROR_INVALID_ARGUMENT; } diff --git a/src/memtarget_internal.h b/src/memtarget_internal.h index 45d547bf7..bad309723 100644 --- a/src/memtarget_internal.h +++ b/src/memtarget_internal.h @@ -24,20 +24,20 @@ typedef struct umf_memtarget_t { void *priv; } umf_memtarget_t; -umf_result_t umfMemoryTargetCreate(const umf_memtarget_ops_t *ops, void *params, - umf_memtarget_handle_t *memoryTarget); -void umfMemoryTargetDestroy(umf_memtarget_handle_t memoryTarget); - -umf_result_t umfMemoryTargetClone(umf_memtarget_handle_t memoryTarget, - umf_memtarget_handle_t *outHandle); -umf_result_t umfMemoryTargetGetCapacity(umf_memtarget_handle_t memoryTarget, - size_t *capacity); -umf_result_t umfMemoryTargetGetBandwidth(umf_memtarget_handle_t srcMemoryTarget, - umf_memtarget_handle_t dstMemoryTarget, - size_t *bandwidth); -umf_result_t umfMemoryTargetGetLatency(umf_memtarget_handle_t srcMemoryTarget, - umf_memtarget_handle_t dstMemoryTarget, - size_t *latency); +umf_result_t umfMemtargetCreate(const umf_memtarget_ops_t *ops, void *params, + umf_memtarget_handle_t *memoryTarget); +void umfMemtargetDestroy(umf_memtarget_handle_t memoryTarget); + +umf_result_t umfMemtargetClone(umf_memtarget_handle_t memoryTarget, + umf_memtarget_handle_t *outHandle); +umf_result_t umfMemtargetGetCapacity(umf_memtarget_handle_t memoryTarget, + size_t *capacity); +umf_result_t umfMemtargetGetBandwidth(umf_memtarget_handle_t srcMemoryTarget, + umf_memtarget_handle_t dstMemoryTarget, + size_t *bandwidth); +umf_result_t umfMemtargetGetLatency(umf_memtarget_handle_t srcMemoryTarget, + umf_memtarget_handle_t dstMemoryTarget, + size_t *latency); #ifdef __cplusplus }