providers register API

source/common/unified_malloc_framework/CMakeLists.txt

@@ -5,7 +5,7 @@
 
 set(UMF_SOURCES
  src/memory_pool.c
- src/memory_provider.c
+ src/memory_provider.cpp
  src/memory_tracker.cpp
  src/memory_provider_get_last_failed.cpp
 )

source/common/unified_malloc_framework/include/umf/memory_pool_ops.h

@@ -18,6 +18,8 @@
 extern "C" {
 #endif
 
+typedef struct umf_memory_provider_t *umf_memory_provider_handle_t;
+
 /// \brief This structure comprises function pointers used by corresponding umfPool*
 /// calls. Each memory pool implementation should initialize all function
 /// pointers.

source/common/unified_malloc_framework/include/umf/memory_provider.h

@@ -37,6 +37,17 @@ umfMemoryProviderCreate(const struct umf_memory_provider_ops_t *ops,
 ///
 void umfMemoryProviderDestroy(umf_memory_provider_handle_t hProvider);
 
+// TODO comment
+enum umf_result_t
+umfMemoryProviderRegister(struct umf_memory_provider_ops_t *ops);
+
+enum umf_result_t
+umfMemoryProvidersRegistryGet(struct umf_memory_provider_ops_t *providers,
+ size_t *numProviders);
+
+const struct umf_memory_provider_ops_t *
+umfMemoryProvidersRegistryGetOps(char *name);
+
 ///
 /// \brief Allocates size bytes of uninitialized storage from memory provider
 /// with specified alignment.

source/common/unified_malloc_framework/include/umf/memory_provider_ops.h

@@ -11,6 +11,7 @@
 #ifndef UMF_MEMORY_PROVIDER_OPS_H
 #define UMF_MEMORY_PROVIDER_OPS_H 1
 
+#include <stdbool.h>
 #include <umf/base.h>
 
 #ifdef __cplusplus
@@ -50,6 +51,7 @@ struct umf_memory_provider_ops_t {
  enum umf_result_t (*purge_lazy)(void *provider, void *ptr, size_t size);
  enum umf_result_t (*purge_force)(void *provider, void *ptr, size_t size);
  const char *(*get_name)(void *provider);
+ bool (*supports_device)(const char *name);
 };
 
 #ifdef __cplusplus

source/common/unified_malloc_framework/src/memory_provider.c → source/common/unified_malloc_framework/src/memory_provider.cpp

@@ -8,22 +8,30 @@
  *
  */
 
-#include "memory_provider_internal.h"
-#include <umf/memory_provider.h>
-
 #include <assert.h>
 #include <stdlib.h>
 
+#include <algorithm>
+#include <cstring>
+#include <string>
+#include <vector>
+
+#include "umf/memory_provider.h"
+
+#include "memory_provider_internal.h"
+
 struct umf_memory_provider_t {
  struct umf_memory_provider_ops_t ops;
  void *provider_priv;
 };
 
+std::vector<struct umf_memory_provider_ops_t> globalProviders;
+
 enum umf_result_t
 umfMemoryProviderCreate(const struct umf_memory_provider_ops_t *ops,
  void *params, umf_memory_provider_handle_t *hProvider) {
  umf_memory_provider_handle_t provider =
- malloc(sizeof(struct umf_memory_provider_t));
+ (umf_memory_provider_t *)malloc(sizeof(struct umf_memory_provider_t));
  if (!provider) {
  return UMF_RESULT_ERROR_OUT_OF_HOST_MEMORY;
  }
@@ -46,6 +54,42 @@ umfMemoryProviderCreate(const struct umf_memory_provider_ops_t *ops,
  return UMF_RESULT_SUCCESS;
 }
 
+enum umf_result_t umfMemoryProviderRegister(umf_memory_provider_ops_t *ops) {
+
+ // TODO check if this provider isn't already registered
+ globalProviders.push_back(*ops);
+
+ return UMF_RESULT_SUCCESS;
+}
+
+enum umf_result_t
+umfMemoryProvidersRegistryGet(umf_memory_provider_ops_t *providers,
+ size_t *numProviders) {
+
+ if (providers == NULL) {
+ *numProviders = globalProviders.size();
+ } else {
+ memcpy(providers, globalProviders.data(),
+ sizeof(umf_memory_provider_ops_t) * *numProviders);
+ }
+
+ return UMF_RESULT_SUCCESS;
+}
+
+// TODO rename ;)
+const umf_memory_provider_ops_t *umfMemoryProvidersRegistryGetOps(char *name) {
+ auto it = std::find_if(
+ std::begin(globalProviders), std::end(globalProviders),
+ [&](auto &ops) { return std::strcmp(ops.get_name(NULL), name) == 0; });
+
+ if (it != globalProviders.end()) {
+ return &(*it);
+ }
+
+ // else
+ return NULL;
+}
+
 void umfMemoryProviderDestroy(umf_memory_provider_handle_t hProvider) {
  hProvider->ops.finalize(hProvider->provider_priv);
  free(hProvider);