[uma] replace list of providers with explicit

data and metadata providers in initialize. Also, replace
get_memory_providers with get_data_memory_provider and
get_metadata_memory_provider.

Implementation of get_*_provider is supposed to be supplied
by each memory pool: this is to allow ignoring passed memory
provider (especially the metadata provider).

source/common/uma_helpers.hpp

@@ -106,14 +106,16 @@ auto memoryProviderMakeUnique(Args &&...args) {
 /// replaced by dtor). All arguments passed to this function are
 /// forwarded to T::initialize().
 template <typename T, typename... Args>
-auto poolMakeUnique(uma_memory_provider_handle_t *providers,
- size_t numProviders, Args &&...args) {
+auto poolMakeUnique(uma_memory_provider_handle_t data_provider,
+ uma_memory_provider_handle_t metadata_provider,
+ Args &&...args) {
  uma_memory_pool_ops_t ops;
  auto argsTuple = std::make_tuple(std::forward<Args>(args)...);
 
  ops.version = UMA_VERSION_CURRENT;
- ops.initialize = [](uma_memory_provider_handle_t *providers,
- size_t numProviders, void *params, void **obj) {
+ ops.initialize = [](uma_memory_provider_handle_t data_provider,
+ uma_memory_provider_handle_t metadata_provider,
+ void *params, void **obj) {
  auto *tuple = reinterpret_cast<decltype(argsTuple) *>(params);
  T *pool;
 
@@ -126,10 +128,11 @@ auto poolMakeUnique(uma_memory_provider_handle_t *providers,
  *obj = pool;
 
  try {
- auto ret = std::apply(
- &T::initialize,
- std::tuple_cat(std::make_tuple(pool, providers, numProviders),
- *tuple));
+ auto ret =
+ std::apply(&T::initialize,
+ std::tuple_cat(std::make_tuple(pool, data_provider,
+ metadata_provider),
+ *tuple));
  if (ret != UMA_RESULT_SUCCESS) {
  delete pool;
  }
@@ -148,9 +151,14 @@ auto poolMakeUnique(uma_memory_provider_handle_t *providers,
  UMA_ASSIGN_OP(ops, T, malloc_usable_size, ((size_t)0));
  UMA_ASSIGN_OP_NORETURN(ops, T, free);
  UMA_ASSIGN_OP(ops, T, get_last_result, UMA_RESULT_ERROR_UNKNOWN);
+ UMA_ASSIGN_OP(ops, T, get_data_memory_provider,
+ (uma_memory_provider_handle_t) nullptr);
+ UMA_ASSIGN_OP(ops, T, get_metadata_memory_provider,
+ (uma_memory_provider_handle_t) nullptr);
 
  uma_memory_pool_handle_t hPool = nullptr;
- auto ret = umaPoolCreate(&ops, providers, numProviders, &argsTuple, &hPool);
+ auto ret = umaPoolCreate(&ops, data_provider, metadata_provider, &argsTuple,
+ &hPool);
  return std::pair<uma_result_t, pool_unique_handle_t>{
  ret, pool_unique_handle_t(hPool, &umaPoolDestroy)};
 }

source/common/uma_pools/disjoint_pool.cpp

@@ -840,14 +840,12 @@ void DisjointPool::AllocImpl::printStats(bool &TitlePrinted,
  }
 }
 
-uma_result_t DisjointPool::initialize(uma_memory_provider_handle_t *providers,
- size_t numProviders,
- DisjointPoolConfig parameters) {
- if (numProviders != 1 || !providers[0]) {
- return UMA_RESULT_ERROR_INVALID_ARGUMENT;
- }
-
- impl = std::make_unique<AllocImpl>(providers[0], parameters);
+uma_result_t
+DisjointPool::initialize(uma_memory_provider_handle_t data_provider,
+ uma_memory_provider_handle_t metadata_provider,
+ DisjointPoolConfig parameters) {
+ (void)metadata_provider;
+ impl = std::make_unique<AllocImpl>(data_provider, parameters);
  return UMA_RESULT_SUCCESS;
 }
 
@@ -920,6 +918,14 @@ enum uma_result_t DisjointPool::get_last_result(const char **ppMessage) {
  return UMA_RESULT_ERROR_UNKNOWN;
 }
 
+uma_memory_provider_handle_t DisjointPool::get_data_memory_provider() {
+ return impl->getMemHandle();
+}
+
+uma_memory_provider_handle_t DisjointPool::get_metadata_memory_provider() {
+ return nullptr;
+}
+
 DisjointPool::DisjointPool() {}
 
 // Define destructor for use with unique_ptr

source/common/uma_pools/disjoint_pool.hpp

@@ -60,15 +60,18 @@ class DisjointPool {
  class AllocImpl;
  using Config = DisjointPoolConfig;
 
- uma_result_t initialize(uma_memory_provider_handle_t *providers,
- size_t numProviders, DisjointPoolConfig parameters);
+ uma_result_t initialize(uma_memory_provider_handle_t data_provider,
+ uma_memory_provider_handle_t metadata_provider,
+ DisjointPoolConfig parameters);
  void *malloc(size_t size);
  void *calloc(size_t, size_t);
  void *realloc(void *, size_t);
  void *aligned_malloc(size_t size, size_t alignment);
  size_t malloc_usable_size(void *);
  void free(void *ptr);
  enum uma_result_t get_last_result(const char **ppMessage);
+ uma_memory_provider_handle_t get_data_memory_provider();
+ uma_memory_provider_handle_t get_metadata_memory_provider();
 
  DisjointPool();
  ~DisjointPool();

source/common/unified_memory_allocation/include/uma/memory_pool.h

@@ -25,17 +25,16 @@ struct uma_memory_pool_ops_t;
 ///
 /// \brief Creates new memory pool.
 /// \param ops instance of uma_memory_pool_ops_t
-/// \param providers array of memory providers that will be used for coarse-grain allocations.
-/// Should contain at least one memory provider.
-/// \param numProvider number of elements in the providers array
+/// \param data_provider memory provider that should be used for coarse-grain data allocation
+/// \param metadata_provider [optional] memory provider that should be used for metadata allocations
 /// \param params pointer to pool-specific parameters
 /// \param hPool [out] handle to the newly created memory pool
 /// \return UMA_RESULT_SUCCESS on success or appropriate error code on failure.
 ///
 enum uma_result_t umaPoolCreate(struct uma_memory_pool_ops_t *ops,
- uma_memory_provider_handle_t *providers,
- size_t numProviders, void *params,
- uma_memory_pool_handle_t *hPool);
+ uma_memory_provider_handle_t data_provider,
+ uma_memory_provider_handle_t metadata_provider,
+ void *params, uma_memory_pool_handle_t *hPool);
 
 ///
 /// \brief Destroys memory pool.
@@ -134,17 +133,18 @@ enum uma_result_t umaPoolGetLastResult(uma_memory_pool_handle_t hPool,
 uma_memory_pool_handle_t umaPoolByPtr(const void *ptr);
 
 ///
-/// \brief Retrieve memory providers associated with a given pool.
+/// \brief Retrieve metadata memory provider associated with a given pool.
 /// \param hPool specified memory pool
-/// \param hProviders [out] pointer to an array of memory providers. If numProviders is not equal to or
-/// greater than the real number of providers, UMA_RESULT_ERROR_INVALID_ARGUMENT is returned.
-/// \param numProviders [in] number of memory providers to return
-/// \param numProvidersRet pointer to the actual number of memory providers
-/// \return UMA_RESULT_SUCCESS on success or appropriate error code on failure.
-enum uma_result_t
-umaPoolGetMemoryProviders(uma_memory_pool_handle_t hPool, size_t numProviders,
- uma_memory_provider_handle_t *hProviders,
- size_t *numProvidersRet);
+/// \return handle to the metadata memory provider
+uma_memory_provider_handle_t
+umaPoolGetMetadataMemoryProvider(uma_memory_pool_handle_t hPool);
+
+///
+/// \brief Retrieve data memory provider associated with a given pool.
+/// \param hPool specified memory pool
+/// \return handle to the data memory provider
+uma_memory_provider_handle_t
+umaPoolGetDataMemoryProvider(uma_memory_pool_handle_t hPool);
 
 #ifdef __cplusplus
 }

source/common/unified_memory_allocation/include/uma/memory_pool_ops.h

@@ -27,15 +27,15 @@ struct uma_memory_pool_ops_t {
 
  ///
  /// \brief Intializes memory pool.
- /// \param providers array of memory providers that will be used for coarse-grain allocations.
- /// Should contain at least one memory provider.
- /// \param numProvider number of elements in the providers array
+ /// \param data_provider memory provider that should be used for coarse-grain data allocation
+ /// \param metadata_provider [optional] memory provider that should be used for metadata allocations
  /// \param params pool-specific params
  /// \param pool [out] returns pointer to the pool
  /// \return UMA_RESULT_SUCCESS on success or appropriate error code on failure.
- enum uma_result_t (*initialize)(uma_memory_provider_handle_t *providers,
- size_t numProviders, void *params,
- void **pool);
+ enum uma_result_t (*initialize)(
+ uma_memory_provider_handle_t data_provider,
+ uma_memory_provider_handle_t metadata_provider, void *params,
+ void **pool);
 
  ///
  /// \brief Finalizes memory pool
@@ -50,6 +50,8 @@ struct uma_memory_pool_ops_t {
  size_t (*malloc_usable_size)(void *pool, void *ptr);
  void (*free)(void *pool, void *);
  enum uma_result_t (*get_last_result)(void *pool, const char **ppMessage);
+ uma_memory_provider_handle_t (*get_data_memory_provider)(void *pool);
+ uma_memory_provider_handle_t (*get_metadata_memory_provider)(void *pool);
 };
 
 #ifdef __cplusplus

source/common/unified_memory_allocation/src/memory_pool.c

@@ -21,28 +21,18 @@ struct uma_memory_pool_t {
  void *pool_priv;
  struct uma_memory_pool_ops_t ops;
 
- // Holds array of memory providers. All providers are wrapped
- // by memory tracking providers (owned and released by UMA).
- uma_memory_provider_handle_t *providers;
+ // All providers are wrapped by memory tracking providers (owned and released by UMA).
+ uma_memory_provider_handle_t data_provider;
+ uma_memory_provider_handle_t metadata_provider;
 
  size_t numProviders;
 };
 
-static void
-destroyMemoryProviderWrappers(uma_memory_provider_handle_t *providers,
- size_t numProviders) {
- for (size_t i = 0; i < numProviders; i++) {
- umaMemoryProviderDestroy(providers[i]);
- }
-
- free(providers);
-}
-
 enum uma_result_t umaPoolCreate(struct uma_memory_pool_ops_t *ops,
- uma_memory_provider_handle_t *providers,
- size_t numProviders, void *params,
- uma_memory_pool_handle_t *hPool) {
- if (!numProviders || !providers) {
+ uma_memory_provider_handle_t data_provider,
+ uma_memory_provider_handle_t metadata_provider,
+ void *params, uma_memory_pool_handle_t *hPool) {
+ if (!data_provider) {
  return UMA_RESULT_ERROR_INVALID_ARGUMENT;
  }
 
@@ -54,27 +44,25 @@ enum uma_result_t umaPoolCreate(struct uma_memory_pool_ops_t *ops,
 
  assert(ops->version == UMA_VERSION_CURRENT);
 
- pool->providers =
-  calloc(numProviders, sizeof(uma_memory_provider_handle_t));
- if (!pool->providers) {
-  ret = UMA_RESULT_ERROR_OUT_OF_HOST_MEMORY;
- goto err_providers_alloc;
+ // Wrap each provider with memory tracking provider.
+ ret = umaTrackingMemoryProviderCreate(data_provider, pool,
+  &pool->data_provider);
+ if (ret != UMA_RESULT_SUCCESS) {
+ goto err_providers_wrap;
  }
 
- size_t providerInd = 0;
- pool->numProviders = numProviders;
-
- // Wrap each provider with memory tracking provider.
- for (providerInd = 0; providerInd < numProviders; providerInd++) {
- ret = umaTrackingMemoryProviderCreate(providers[providerInd], pool,
- &pool->providers[providerInd]);
+ if (metadata_provider) {
+ ret = umaTrackingMemoryProviderCreate(metadata_provider, pool,
+ &pool->metadata_provider);
  if (ret != UMA_RESULT_SUCCESS) {
- goto err_providers_init;
+ goto err_providers_metadata_wrap;
  }
+ } else {
+ pool->metadata_provider = NULL;
  }
 
  pool->ops = *ops;
- ret = ops->initialize(pool->providers, pool->numProviders, params,
+ ret = ops->initialize(pool->data_provider, pool->metadata_provider, params,
  &pool->pool_priv);
  if (ret != UMA_RESULT_SUCCESS) {
  goto err_pool_init;
@@ -84,17 +72,23 @@ enum uma_result_t umaPoolCreate(struct uma_memory_pool_ops_t *ops,
  return UMA_RESULT_SUCCESS;
 
 err_pool_init:
-err_providers_init:
- destroyMemoryProviderWrappers(pool->providers, providerInd);
-err_providers_alloc:
+ if (pool->metadata_provider) {
+ umaMemoryProviderDestroy(pool->metadata_provider);
+ }
+err_providers_metadata_wrap:
+ umaMemoryProviderDestroy(pool->data_provider);
+err_providers_wrap:
  free(pool);
 
  return ret;
 }
 
 void umaPoolDestroy(uma_memory_pool_handle_t hPool) {
  hPool->ops.finalize(hPool->pool_priv);
- destroyMemoryProviderWrappers(hPool->providers, hPool->numProviders);
+ if (hPool->metadata_provider) {
+ umaMemoryProviderDestroy(hPool->metadata_provider);
+ }
+ umaMemoryProviderDestroy(hPool->data_provider);
  free(hPool);
 }
 
@@ -139,24 +133,12 @@ uma_memory_pool_handle_t umaPoolByPtr(const void *ptr) {
  return umaMemoryTrackerGetPool(umaMemoryTrackerGet(), ptr);
 }
 
-enum uma_result_t
-umaPoolGetMemoryProviders(uma_memory_pool_handle_t hPool, size_t numProviders,
- uma_memory_provider_handle_t *hProviders,
- size_t *numProvidersRet) {
- if (hProviders && numProviders < hPool->numProviders) {
- return UMA_RESULT_ERROR_INVALID_ARGUMENT;
- }
-
- if (numProvidersRet) {
- *numProvidersRet = hPool->numProviders;
- }
-
- if (hProviders) {
- for (size_t i = 0; i < hPool->numProviders; i++) {
- umaTrackingMemoryProviderGetUpstreamProvider(
- umaMemoryProviderGetPriv(hPool->providers[i]), hProviders + i);
- }
- }
+uma_memory_provider_handle_t
+umaPoolGetMetadataMemoryProvider(uma_memory_pool_handle_t hPool) {
+ return hPool->ops.get_metadata_memory_provider(hPool->pool_priv);
+}
 
- return UMA_RESULT_SUCCESS;
+uma_memory_provider_handle_t
+umaPoolGetDataMemoryProvider(uma_memory_pool_handle_t hPool) {
+ return hPool->ops.get_data_memory_provider(hPool->pool_priv);
 }

source/common/unified_memory_allocation/src/memory_tracker.cpp

@@ -235,13 +235,4 @@ enum uma_result_t umaTrackingMemoryProviderCreate(
  return umaMemoryProviderCreate(&trackingMemoryProviderOps, &params,
  hTrackingProvider);
 }
-
-void umaTrackingMemoryProviderGetUpstreamProvider(
- uma_memory_provider_handle_t hTrackingProvider,
- uma_memory_provider_handle_t *hUpstream) {
- assert(hUpstream);
- uma_tracking_memory_provider_t *p =
- (uma_tracking_memory_provider_t *)hTrackingProvider;
- *hUpstream = p->hUpstream;
-}
 }

source/common/unified_memory_allocation/src/memory_tracker.h

@@ -31,10 +31,6 @@ enum uma_result_t umaTrackingMemoryProviderCreate(
  uma_memory_provider_handle_t hUpstream, uma_memory_pool_handle_t hPool,
  uma_memory_provider_handle_t *hTrackingProvider);
 
-void umaTrackingMemoryProviderGetUpstreamProvider(
- uma_memory_provider_handle_t hTrackingProvider,
- uma_memory_provider_handle_t *hUpstream);
-
 #ifdef __cplusplus
 }
 #endif