umf providers

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

@@ -20,6 +20,29 @@ extern "C" {
 
 typedef struct umf_memory_provider_t *umf_memory_provider_handle_t;
 
+typedef enum umf_device_type_t {
+ UMF_DEVICE_TYPE_INVALID = -1,
+ UMF_DEVICE_TYPE_NUMA,
+ UMF_DEVICE_TYPE_GPU,
+} umf_device_type_t;
+
+typedef struct umf_memory_provider_config_t {
+ umf_device_type_t type;
+
+ union {
+ struct {
+ // TODO
+ size_t id;
+ } numa;
+
+ struct {
+ char address[12]; // in format "0000:00:00.0"
+ } gpu;
+
+ // other partition types ...
+ };
+} umf_memory_provider_config_t;
+
 ///
 /// \brief Creates new memory provider.
 /// \param ops instance of umf_memory_provider_ops_t
@@ -39,14 +62,12 @@ void umfMemoryProviderDestroy(umf_memory_provider_handle_t hProvider);
 
 // TODO comment
 enum umf_result_t
-umfMemoryProviderRegister(struct umf_memory_provider_ops_t *ops);
+umfMemoryProviderRegister(umf_device_type_t type, 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);
+enum umf_result_t
+umfMemoryProvidersCreateFromType(const umf_memory_provider_config_t *config,
+ umf_memory_provider_handle_t *hProvider /* out */);
 
 ///
 /// \brief Allocates size bytes of uninitialized storage from memory provider

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

@@ -18,6 +18,8 @@
 extern "C" {
 #endif
 
+struct umf_memory_provider_config_t;
+
 /// This structure comprises function pointers used by corresponding
 /// umfMemoryProvider* calls. Each memory provider implementation should
 /// initialize all function pointers.
@@ -26,6 +28,8 @@ struct umf_memory_provider_ops_t {
  /// Should be initialized using UMF_VERSION_CURRENT
  uint32_t version;
 
+ void *priv;
+
  ///
  /// \brief Initializes memory provider.
  /// \param params provider-specific params
@@ -51,7 +55,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);
+ bool (*supports_device)(const struct umf_memory_provider_config_t *config);
 };
 
 #ifdef __cplusplus

source/common/unified_malloc_framework/src/memory_provider.cpp

@@ -13,6 +13,7 @@
 
 #include <algorithm>
 #include <cstring>
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -25,7 +26,10 @@ struct umf_memory_provider_t {
  void *provider_priv;
 };
 
-std::vector<struct umf_memory_provider_ops_t> globalProviders;
+// TODO here I use the ptr to vector because the system calls
+// globalProviders destructor twice - why?
+typedef std::pair<umf_device_type_t, struct umf_memory_provider_ops_t> umf_provider_desc_pair_t;
+std::vector<umf_provider_desc_pair_t> *globalProviders;
 
 enum umf_result_t
 umfMemoryProviderCreate(const struct umf_memory_provider_ops_t *ops,
@@ -54,40 +58,45 @@ umfMemoryProviderCreate(const struct umf_memory_provider_ops_t *ops,
  return UMF_RESULT_SUCCESS;
 }
 
-enum umf_result_t umfMemoryProviderRegister(umf_memory_provider_ops_t *ops) {
+enum umf_result_t umfMemoryProviderRegister(umf_device_type_t type, umf_memory_provider_ops_t *ops) {
+
+ if (globalProviders == NULL) {
+ // TODO this is never freed
+ globalProviders = new std::vector<umf_provider_desc_pair_t>;
+ }
 
  // TODO check if this provider isn't already registered
- globalProviders.push_back(*ops);
+ globalProviders->push_back(std::make_pair(type, *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);
- }
+umfMemoryProvidersCreateFromType(const umf_memory_provider_config_t *config,
+ umf_memory_provider_handle_t *hProvider /* out */) {
 
- return UMF_RESULT_SUCCESS;
-}
+ if (config == NULL) {
+ return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+ }
 
-// 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 (hProvider != NULL) {
+ return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+ }
 
- if (it != globalProviders.end()) {
- return &(*it);
+ if (globalProviders == NULL) {
+ return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
+ }
+
+ for(size_t i = 0; i < globalProviders->size(); i++) {
+ if (globalProviders->at(i).first == config->type &&
+ globalProviders->at(i).second.supports_device(config)) {
+ enum umf_result_t ret = umfMemoryProviderCreate(&globalProviders->at(i).second, (void*)config, hProvider);
+ if (ret == UMF_RESULT_SUCCESS)
+ return ret;
+ }
  }
 
- // else
- return NULL;
+ return UMF_RESULT_ERROR_MEMORY_PROVIDER_SPECIFIC;
 }
 
 void umfMemoryProviderDestroy(umf_memory_provider_handle_t hProvider) {