[WIP] mem props

docs/config/api.rst

@@ -28,6 +28,14 @@ memory as well as functions that create, destroy and operate on the pool.
 .. doxygenfile:: memory_pool.h
     :sections: define enum typedef func var
 
+TODO
+------------------------------------------
+
+TODO
+
+.. doxygenfile:: memory_props.h
+    :sections: define enum typedef func var
+
 Disjoint Pool
 ------------------------------------------
 

include/umf/memory_props.h

@@ -0,0 +1,64 @@
+/*
+ *
+ * Copyright (C) 2025 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_PROPS_H
+#define UMF_MEMORY_PROPS_H 1
+
+#include <umf/base.h>
+#include <umf/memory_pool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/// @brief TODO
+// write about experimental api
+typedef enum umf_memory_property_id_t {
+    UMF_MEMORY_PROPERTY_INVALID = -1, ///< TODO
+
+    // UMF specyfic
+    UMF_MEMORY_PROPERTIES_HANDLE,
+    UMF_MEMORY_PROVIDER_HANDLE,
+    UMF_MEMORY_PROVIDER_OPS, // == type?
+    UMF_MEMORY_POOL_HANDLE,
+    UMF_MEMORY_POOL_OPS, // == type?
+
+    // generic pointer properties
+    UMF_MEMORY_PROPERTY_POINTER_TYPE, /// unr host, reg host ??, dev, managed or umf_usm_memory_type_t?
+    UMF_MEMORY_PROPERTY_BASE_ADDRESS, ///< base address
+    UMF_MEMORY_PROPERTY_BASE_SIZE,    ///< base size
+
+    // GPU specyfic
+    UMF_MEMORY_PROPERTY_DEVICE, ///< handle (ze) or id (cuda)
+    UMF_MEMORY_PROPERTY_BUFFER_ID, /// unique id NOTE: this id is unique across all UMF allocs and != L0 or CUDA ID
+    UMF_MEMORY_PROPERTY_DEVICE_ATTRIBUTES, ///< ze_memory_allocation_properties_t ?
+
+    // all cuda + l0
+    // next other providers?
+    // todo return type?
+
+    /// @cond
+    UMF_MEMORY_PROPERTY_MAX_RESERVED = 0x1000, ///< Maximum reserved value
+    /// @endcond
+
+} umf_memory_property_id_t;
+
+typedef struct umf_memory_properties_t *umf_memory_properties_handle_t;
+
+/// @brief TODO
+umf_result_t
+umfGetMemoryProperty(void *ptr, umf_memory_property_id_t memory_property_id,
+                     umf_memory_properties_handle_t props_handle /* optional */,
+                     void *value);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_MEMORY_PROPS_H */

src/CMakeLists.txt

@@ -66,6 +66,7 @@ set(UMF_SOURCES
     ipc.c
     ipc_cache.c
     memory_pool.c
+    memory_props.c
     memory_provider.c
     memory_provider_get_last_failed.c
     memtarget.c

src/ipc.c

@@ -65,7 +65,7 @@ umf_result_t umfGetIPCHandle(const void *ptr, umf_ipc_handle_t *umfIPCHandle,
         return ret;
     }
 
-    ret = umfPoolGetIPCHandleSize(allocInfo.pool, &ipcHandleSize);
+    ret = umfPoolGetIPCHandleSize(allocInfo.props->pool, &ipcHandleSize);
     if (ret != UMF_RESULT_SUCCESS) {
         LOG_ERR("cannot get IPC handle size.");
         return ret;
@@ -79,7 +79,7 @@ umf_result_t umfGetIPCHandle(const void *ptr, umf_ipc_handle_t *umfIPCHandle,
 
     // We cannot use umfPoolGetMemoryProvider function because it returns
     // upstream provider but we need tracking one
-    umf_memory_provider_handle_t provider = allocInfo.pool->provider;
+    umf_memory_provider_handle_t provider = allocInfo.props->pool->provider;
     assert(provider);
 
     ret = umfMemoryProviderGetIPCHandle(provider, allocInfo.base,

src/libumf.def

@@ -139,6 +139,7 @@ EXPORTS
     umfCtlExec
     umfCtlGet
     umfCtlSet
+    umfGetMemoryProperty
     umfJemallocPoolParamsCreate
     umfJemallocPoolParamsDestroy
     umfJemallocPoolParamsSetNumArenas

src/libumf.map

@@ -139,6 +139,7 @@ UMF_0.12 {
         umfCtlExec;
         umfCtlGet;
         umfCtlSet;
+        umfGetMemoryProperty;
         umfJemallocPoolParamsCreate;
         umfJemallocPoolParamsDestroy;
         umfJemallocPoolParamsSetNumArenas;

src/memory_props.c

@@ -0,0 +1,109 @@
+/*
+ *
+ * Copyright (C) 2025 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ */
+
+#include <umf/memory_props.h>
+#include <umf/providers/provider_level_zero.h>
+
+#include "memory_props_internal.h"
+#include "memory_provider_internal.h"
+#include "provider/provider_level_zero_internal.h"
+#include "provider/provider_tracking.h"
+
+umf_result_t
+umfGetMemoryProperty(void *ptr, umf_memory_property_id_t memory_property_id,
+                     umf_memory_properties_handle_t props_handle /* optional */,
+                     void *value) {
+
+    if ((ptr == NULL) || (value == NULL) ||
+        (memory_property_id == UMF_MEMORY_PROPERTY_INVALID) ||
+        (memory_property_id >= UMF_MEMORY_PROPERTY_MAX_RESERVED)) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    umf_memory_properties_handle_t props = NULL;
+    if (props_handle != NULL) {
+        props = props_handle;
+    } else {
+        umf_alloc_info_t allocInfo = {NULL, 0, NULL};
+        umf_result_t ret = umfMemoryTrackerGetAllocInfo(ptr, &allocInfo);
+        if (ret != UMF_RESULT_SUCCESS) {
+            return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        }
+        props = allocInfo.props;
+    }
+
+    switch (memory_property_id) {
+    case UMF_MEMORY_PROPERTIES_HANDLE:
+        *(umf_memory_properties_handle_t *)value = props;
+        return UMF_RESULT_SUCCESS;
+
+    case UMF_MEMORY_POOL_HANDLE:
+        *(umf_memory_pool_handle_t *)value = props->pool;
+        return UMF_RESULT_SUCCESS;
+
+    case UMF_MEMORY_PROPERTY_BUFFER_ID:
+        *(uint64_t *)value = props->id;
+        return UMF_RESULT_SUCCESS;
+
+    default:
+        break;
+    }
+
+    // properties that are related to the memory provider
+    umf_memory_provider_t *provider = NULL;
+    umfPoolGetMemoryProvider(props->pool, &provider);
+    assert(provider != NULL);
+
+    switch (memory_property_id) {
+    case UMF_MEMORY_PROPERTY_POINTER_TYPE:
+        if (provider->ops.get_name(provider) ==
+            umfLevelZeroMemoryProviderOps()->get_name(provider)) {
+            ze_memory_provider_t *ze_provider =
+                (ze_memory_provider_t *)provider->provider_priv;
+            *(umf_usm_memory_type_t *)value = ze_provider->memory_type;
+            return UMF_RESULT_SUCCESS;
+        }
+        break;
+
+    case UMF_MEMORY_PROPERTY_DEVICE:
+        if (provider->ops.get_name(provider) ==
+            umfLevelZeroMemoryProviderOps()->get_name(provider)) {
+            ze_memory_provider_t *ze_provider =
+                (ze_memory_provider_t *)provider->provider_priv;
+            *(ze_device_handle_t *)value = ze_provider->device;
+            return UMF_RESULT_SUCCESS;
+        }
+        break;
+
+    case UMF_MEMORY_PROPERTY_DEVICE_ATTRIBUTES:
+        if (provider->ops.get_name(provider) ==
+            umfLevelZeroMemoryProviderOps()->get_name(provider)) {
+            // TODO comment
+            if (props->gpu_properties_initialized == false) {
+                ze_memory_provider_t *ze_provider =
+                    (ze_memory_provider_t *)provider->provider_priv;
+                props->gpu.ze_properties.stype =
+                    ZE_STRUCTURE_TYPE_MEMORY_ALLOCATION_PROPERTIES;
+                ze_provider->ze_ops->zeMemGetAllocProperties(
+                    ze_provider->context, ptr, &props->gpu.ze_properties, NULL);
+                props->gpu_properties_initialized = true;
+            }
+            ze_memory_allocation_properties_t *ze_properties =
+                &props->gpu.ze_properties;
+            *(ze_memory_allocation_properties_t **)value = ze_properties;
+            return UMF_RESULT_SUCCESS;
+        }
+        break;
+
+    default:
+        return UMF_RESULT_ERROR_NOT_SUPPORTED;
+    }
+
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}

src/memory_props_internal.h

@@ -0,0 +1,39 @@
+/*
+ *
+ * Copyright (C) 2025 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_PROPS_INTERNAL_H
+#define UMF_MEMORY_PROPS_INTERNAL_H 1
+
+#include <stdbool.h>
+
+#include <umf/base.h>
+#include <umf/memory_props.h>
+
+#include "ze_api.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct umf_memory_properties_t {
+    umf_memory_pool_handle_t pool;
+    uint64_t id;
+
+    // TODO
+    bool gpu_properties_initialized;
+    union {
+        ze_memory_allocation_properties_t ze_properties;
+    } gpu;
+} umf_memory_properties_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // UMF_MEMORY_PROPS_INTERNAL_H

src/memory_provider.c

@@ -12,13 +12,13 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+#include <umf/base.h>
 #include <umf/memory_provider.h>
 
 #include "base_alloc.h"
 #include "base_alloc_global.h"
 #include "libumf.h"
 #include "memory_provider_internal.h"
-#include "umf/base.h"
 #include "utils_assert.h"
 
 static int CTL_SUBTREE_HANDLER(by_handle_provider)(

src/provider/provider_level_zero.c

@@ -140,54 +140,6 @@ typedef struct umf_level_zero_memory_provider_params_t {
     uint32_t device_ordinal;
 } umf_level_zero_memory_provider_params_t;
 
-typedef struct ze_memory_provider_t {
-    ze_context_handle_t context;
-    ze_device_handle_t device;
-    ze_memory_type_t memory_type;
-
-    ze_device_handle_t *resident_device_handles;
-    uint32_t resident_device_count;
-
-    ze_device_properties_t device_properties;
-
-    ze_driver_memory_free_policy_ext_flags_t freePolicyFlags;
-
-    size_t min_page_size;
-
-    uint32_t device_ordinal;
-} ze_memory_provider_t;
-
-typedef struct ze_ops_t {
-    ze_result_t (*zeMemAllocHost)(ze_context_handle_t,
-                                  const ze_host_mem_alloc_desc_t *, size_t,
-                                  size_t, void *);
-    ze_result_t (*zeMemAllocDevice)(ze_context_handle_t,
-                                    const ze_device_mem_alloc_desc_t *, size_t,
-                                    size_t, ze_device_handle_t, void *);
-    ze_result_t (*zeMemAllocShared)(ze_context_handle_t,
-                                    const ze_device_mem_alloc_desc_t *,
-                                    const ze_host_mem_alloc_desc_t *, size_t,
-                                    size_t, ze_device_handle_t, void *);
-    ze_result_t (*zeMemFree)(ze_context_handle_t, void *);
-    ze_result_t (*zeMemGetIpcHandle)(ze_context_handle_t, const void *,
-                                     ze_ipc_mem_handle_t *);
-    ze_result_t (*zeMemPutIpcHandle)(ze_context_handle_t, ze_ipc_mem_handle_t);
-    ze_result_t (*zeMemOpenIpcHandle)(ze_context_handle_t, ze_device_handle_t,
-                                      ze_ipc_mem_handle_t,
-                                      ze_ipc_memory_flags_t, void **);
-    ze_result_t (*zeMemCloseIpcHandle)(ze_context_handle_t, void *);
-    ze_result_t (*zeContextMakeMemoryResident)(ze_context_handle_t,
-                                               ze_device_handle_t, void *,
-                                               size_t);
-    ze_result_t (*zeDeviceGetProperties)(ze_device_handle_t,
-                                         ze_device_properties_t *);
-    ze_result_t (*zeMemFreeExt)(ze_context_handle_t,
-                                ze_memory_free_ext_desc_t *, void *);
-    ze_result_t (*zeMemGetAllocProperties)(ze_context_handle_t, const void *,
-                                           ze_memory_allocation_properties_t *,
-                                           ze_device_handle_t *);
-} ze_ops_t;
-
 static ze_ops_t g_ze_ops;
 static UTIL_ONCE_FLAG ze_is_initialized = UTIL_ONCE_FLAG_INIT;
 static bool Init_ze_global_state_failed;
@@ -584,7 +536,7 @@ static umf_result_t ze_memory_provider_initialize(const void *params,
 
     ze_provider->context = ze_params->level_zero_context_handle;
     ze_provider->device = ze_params->level_zero_device_handle;
-    ze_provider->memory_type = (ze_memory_type_t)ze_params->memory_type;
+    ze_provider->memory_type = ze_params->memory_type;
     ze_provider->freePolicyFlags =
         umfFreePolicyToZePolicy(ze_params->freePolicy);
     ze_provider->min_page_size = 0;
@@ -632,6 +584,8 @@ static umf_result_t ze_memory_provider_initialize(const void *params,
         return result;
     }
 
+    ze_provider->ze_ops = &g_ze_ops;
+
     *provider = ze_provider;
 
     return UMF_RESULT_SUCCESS;