a

Author: bratpiorka

benchmark/ubench.c

@@ -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
 ------------------------------------------
 

docs/config/api.rst

@@ -0,0 +1,67 @@
+/*
+ *
+ * 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_PROVIDER_HANDLE,
+    UMF_MEMORY_PROVIDER_OPS, // == type?
+    UMF_MEMORY_POOL_HANDLE,
+    UMF_MEMORY_POOL_OPS, // == type?
+
+    // generic pointer properties
+    UMF_MEMORY_PROPERTY_POINTER_TYPE, // unreg 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
+umfGetMemoryPropertiesHandle(void *ptr,
+                             umf_memory_properties_handle_t *props_handle);
+
+/// @brief TODO
+umf_result_t umfGetMemoryProperty(umf_memory_properties_handle_t props_handle,
+                                  umf_memory_property_id_t memory_property_id,
+                                  void *value);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_MEMORY_PROPS_H */

include/umf/memory_props.h

@@ -8,6 +8,7 @@
 #ifndef UMF_PROVIDER_LEVEL_ZERO_H
 #define UMF_PROVIDER_LEVEL_ZERO_H
 
+#include <umf/memory_props.h>
 #include <umf/memory_provider_gpu.h>
 
 #ifdef __cplusplus
@@ -91,6 +92,11 @@ umf_result_t umfLevelZeroMemoryProviderParamsSetDeviceOrdinal(
     umf_level_zero_memory_provider_params_handle_t hParams,
     uint32_t deviceOrdinal);
 
+/// TODO
+umf_result_t umfLevelZeroMemoryProviderGetMemoryProperty(
+    umf_memory_properties_handle_t props_handle,
+    umf_memory_property_id_t memory_property_id, void *value);
+
 const umf_memory_provider_ops_t *umfLevelZeroMemoryProviderOps(void);
 
 #ifdef __cplusplus

include/umf/providers/provider_level_zero.h

@@ -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/CMakeLists.txt

@@ -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/ipc.c

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

src/libumf.def

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

src/libumf.map

@@ -0,0 +1,82 @@
+/*
+ *
+ * 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_cuda.h>
+#include <umf/providers/provider_level_zero.h>
+
+#include "memory_props_internal.h"
+#include "memory_provider_internal.h"
+#include "provider/provider_tracking.h"
+
+umf_result_t
+umfGetMemoryPropertiesHandle(void *ptr,
+                             umf_memory_properties_handle_t *props_handle) {
+    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_handle = allocInfo.props;
+    return UMF_RESULT_SUCCESS;
+}
+
+umf_result_t umfGetMemoryProperty(umf_memory_properties_handle_t props_handle,
+                                  umf_memory_property_id_t memory_property_id,
+                                  void *value) {
+    if ((value == NULL) ||
+        (memory_property_id == UMF_MEMORY_PROPERTY_INVALID) ||
+        (memory_property_id >= UMF_MEMORY_PROPERTY_MAX_RESERVED) ||
+        props_handle == NULL) {
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    switch (memory_property_id) {
+    case UMF_MEMORY_POOL_HANDLE:
+        *(umf_memory_pool_handle_t *)value = props_handle->pool;
+        return UMF_RESULT_SUCCESS;
+
+    case UMF_MEMORY_PROPERTY_BUFFER_ID:
+        *(uint64_t *)value = props_handle->id;
+        return UMF_RESULT_SUCCESS;
+
+    default:
+        break;
+    }
+
+    // properties that are related to the memory provider
+    umf_memory_provider_t *provider = NULL;
+    umfPoolGetMemoryProvider(props_handle->pool, &provider);
+    assert(provider != NULL);
+
+    switch (memory_property_id) {
+    // GPU Memory Provider specyfic properties
+    case UMF_MEMORY_PROPERTY_POINTER_TYPE:
+    case UMF_MEMORY_PROPERTY_DEVICE:
+    case UMF_MEMORY_PROPERTY_DEVICE_ATTRIBUTES:
+        if (provider->ops.get_name(provider) ==
+            umfLevelZeroMemoryProviderOps()->get_name(provider)) {
+            return umfLevelZeroMemoryProviderGetMemoryProperty(
+                props_handle, memory_property_id, value);
+        } else if (provider->ops.get_name(provider) ==
+                   umfCUDAMemoryProviderOps()->get_name(provider)) {
+            // TODO
+            assert(0);
+            return UMF_RESULT_SUCCESS;
+        }
+        // no provider found
+        return UMF_RESULT_ERROR_UNKNOWN;
+
+    default:
+        break;
+    }
+
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}

src/memory_props.c

@@ -0,0 +1,45 @@
+/*
+ *
+ * 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>
+
+#if UMF_BUILD_LEVEL_ZERO_PROVIDER
+#include "ze_api.h"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct umf_memory_properties_t {
+    void *ptr;
+    umf_memory_pool_handle_t pool;
+    uint64_t id;
+
+    // TODO
+    bool gpu_properties_initialized;
+    union {
+#if UMF_BUILD_LEVEL_ZERO_PROVIDER
+        ze_memory_allocation_properties_t ze_properties;
+#endif
+        int unused; // in case of no GPU support
+    } gpu;
+} umf_memory_properties_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // UMF_MEMORY_PROPS_INTERNAL_H

src/memory_props_internal.h

@@ -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/memory_provider.c

@@ -11,10 +11,13 @@
 #include <string.h>
 
 #include <umf.h>
+#include <umf/memory_props.h>
 #include <umf/memory_provider_ops.h>
 #include <umf/providers/provider_level_zero.h>
 
-#include "provider_level_zero_internal.h"
+#include "memory_props_internal.h"
+#include "memory_provider_internal.h"
+#include "provider/provider_level_zero_internal.h"
 #include "utils_load_library.h"
 #include "utils_log.h"
 
@@ -31,6 +34,7 @@ void fini_ze_global_state(void) {
 
 #include "base_alloc_global.h"
 #include "libumf.h"
+#include "provider_level_zero_internal.h"
 #include "utils_assert.h"
 #include "utils_common.h"
 #include "utils_concurrency.h"
@@ -61,7 +65,7 @@ typedef struct 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;
+    umf_usm_memory_type_t memory_type;
 
     ze_device_handle_t *resident_device_handles;
     uint32_t resident_device_count;
@@ -502,7 +506,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;
@@ -760,6 +764,50 @@ ze_memory_provider_close_ipc_handle(void *provider, void *ptr, size_t size) {
     return UMF_RESULT_SUCCESS;
 }
 
+umf_result_t umfLevelZeroMemoryProviderGetMemoryProperty(
+    umf_memory_properties_handle_t props_handle,
+    umf_memory_property_id_t memory_property_id, void *value) {
+
+    umf_memory_provider_t *provider = NULL;
+    umfPoolGetMemoryProvider(props_handle->pool, &provider);
+    assert(provider != NULL);
+    assert(provider->ops.get_name(provider) ==
+           umfLevelZeroMemoryProviderOps()->get_name(provider));
+
+    ze_memory_provider_t *ze_provider =
+        (ze_memory_provider_t *)provider->provider_priv;
+
+    switch (memory_property_id) {
+    case UMF_MEMORY_PROPERTY_POINTER_TYPE:
+        *(umf_usm_memory_type_t *)value = ze_provider->memory_type;
+        return UMF_RESULT_SUCCESS;
+
+    case UMF_MEMORY_PROPERTY_DEVICE:
+        *(ze_device_handle_t *)value = ze_provider->device;
+        return UMF_RESULT_SUCCESS;
+
+    case UMF_MEMORY_PROPERTY_DEVICE_ATTRIBUTES:
+        // TODO comment
+        if (props_handle->gpu_properties_initialized == false) {
+            props_handle->gpu.ze_properties.stype =
+                ZE_STRUCTURE_TYPE_MEMORY_ALLOCATION_PROPERTIES;
+            g_ze_ops.zeMemGetAllocProperties(
+                ze_provider->context, props_handle->ptr,
+                &props_handle->gpu.ze_properties, NULL);
+            props_handle->gpu_properties_initialized = true;
+        }
+        ze_memory_allocation_properties_t *ze_properties =
+            &props_handle->gpu.ze_properties;
+        *(ze_memory_allocation_properties_t **)value = ze_properties;
+        return UMF_RESULT_SUCCESS;
+
+    default:
+        break;
+    }
+
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
 static umf_memory_provider_ops_t UMF_LEVEL_ZERO_MEMORY_PROVIDER_OPS = {
     .version = UMF_PROVIDER_OPS_VERSION_CURRENT,
     .initialize = ze_memory_provider_initialize,
@@ -867,4 +915,13 @@ const umf_memory_provider_ops_t *umfLevelZeroMemoryProviderOps(void) {
     return NULL;
 }
 
+umf_result_t umfLevelZeroMemoryProviderGetMemoryProperty(
+    umf_memory_properties_handle_t props_handle,
+    umf_memory_property_id_t memory_property_id, void *value) {
+    (void)props_handle;
+    (void)memory_property_id;
+    (void)value;
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
 #endif // !UMF_BUILD_LEVEL_ZERO_PROVIDER