use umfLevelZeroMemoryProviderResidentDeviceChange instead of ops

Author: lslusarczyk

include/umf/memory_provider.h

@@ -265,17 +265,6 @@ umf_result_t
 umfMemoryProviderAllocationMerge(umf_memory_provider_handle_t hProvider,
                                  void *lowPtr, void *highPtr, size_t totalSize);
 
-/// @brief Adds or removes devices on which allocations should be made
-///        resident.
-/// @param hProvider handle to the memory provider
-/// @param device device handle
-/// @param isAdding Boolean indicating if peer is to be removed or added
-/// @return UMF_RESULT_SUCCESS on success or appropriate error code on
-///         failure.
-umf_result_t
-umfMemoryProviderResidentDeviceChange(umf_memory_provider_handle_t hProvider,
-                                      void *device, bool isAdding);
-
 #ifdef __cplusplus
 }
 #endif

include/umf/memory_provider_ops.h

@@ -322,17 +322,6 @@ typedef struct umf_memory_provider_ops_t {
     umf_result_t (*ext_get_allocation_properties_size)(
         void *provider, umf_memory_property_id_t memory_property_id,
         size_t *size);
-
-    /// @brief Adds or removes devices on which allocations should be made
-    ///        resident.
-    /// @param provider handle to the memory provider
-    /// @param device device handle
-    /// @param is_adding Boolean indicating if peer is to be removed or added
-    /// @return UMF_RESULT_SUCCESS on success or appropriate error code on
-    ///         failure.
-    umf_result_t (*ext_resident_device_change)(void *provider, void *device,
-                                               bool is_adding);
-
 } umf_memory_provider_ops_t;
 
 #ifdef __cplusplus

include/umf/providers/provider_level_zero.h

@@ -101,6 +101,17 @@ umf_result_t umfLevelZeroMemoryProviderParamsSetDeviceOrdinal(
 umf_result_t umfLevelZeroMemoryProviderParamsSetName(
     umf_level_zero_memory_provider_params_handle_t hParams, const char *name);
 
+/// @brief Adds or removes devices on which allocations should be made
+///        resident.
+/// @param hProvider handle to the memory provider
+/// @param device device handle
+/// @param isAdding Boolean indicating if peer is to be removed or added
+/// @return UMF_RESULT_SUCCESS on success or appropriate error code on
+///         failure.
+umf_result_t umfLevelZeroMemoryProviderResidentDeviceChange(
+    umf_memory_provider_handle_t provider, ze_device_handle_t device,
+    bool is_adding);
+
 const umf_memory_provider_ops_t *umfLevelZeroMemoryProviderOps(void);
 
 #ifdef __cplusplus

src/libumf.def

@@ -42,6 +42,7 @@ EXPORTS
     umfLevelZeroMemoryProviderParamsSetDevice
     umfLevelZeroMemoryProviderParamsSetMemoryType
     umfLevelZeroMemoryProviderParamsSetResidentDevices
+    umfLevelZeroMemoryProviderResidentDeviceChange
     umfMemoryProviderAlloc
     umfMemoryProviderAllocationMerge
     umfMemoryProviderAllocationSplit
@@ -60,7 +61,6 @@ EXPORTS
     umfMemoryProviderPurgeForce
     umfMemoryProviderPurgeLazy
     umfMemoryProviderPutIPCHandle
-    umfMemoryProviderResidentDeviceChange
     umfMempolicyCreate
     umfMempolicyDestroy
     umfMempolicySetCustomSplitPartitions

src/libumf.map

@@ -151,8 +151,8 @@ UMF_1.1 {
     umfGetMemoryProperty;
     umfGetMemoryPropertySize;
     umfJemallocPoolParamsSetName;
-    umfMemoryProviderResidentDeviceChange;
     umfLevelZeroMemoryProviderParamsSetName;
+    umfLevelZeroMemoryProviderResidentDeviceChange;
     umfOsMemoryProviderParamsSetName;
     umfPoolTrimMemory;
     umfScalablePoolParamsSetName;

src/memory_provider.c

@@ -154,14 +154,6 @@ static umf_result_t umfDefaultGetAllocationPropertiesSize(
     return UMF_RESULT_ERROR_NOT_SUPPORTED;
 }
 
-static umf_result_t umfDefaultResidentDeviceChange(void *provider, void *device,
-                                                   bool is_adding) {
-    (void)provider;
-    (void)device;
-    (void)is_adding;
-    return UMF_RESULT_ERROR_NOT_SUPPORTED;
-}
-
 void assignOpsExtDefaults(umf_memory_provider_ops_t *ops) {
     if (!ops->ext_purge_lazy) {
         ops->ext_purge_lazy = umfDefaultPurgeLazy;
@@ -191,10 +183,6 @@ void assignOpsExtDefaults(umf_memory_provider_ops_t *ops) {
         ops->ext_get_allocation_properties_size =
             umfDefaultGetAllocationPropertiesSize;
     }
-
-    if (!ops->ext_resident_device_change) {
-        ops->ext_resident_device_change = umfDefaultResidentDeviceChange;
-    }
 }
 
 void assignOpsIpcDefaults(umf_memory_provider_ops_t *ops) {
@@ -617,17 +605,4 @@ umf_result_t umfMemoryProviderGetAllocationPropertiesSize(
 
     checkErrorAndSetLastProvider(res, hProvider);
     return res;
-}
-
-umf_result_t
-umfMemoryProviderResidentDeviceChange(umf_memory_provider_handle_t hProvider,
-                                      void *device, bool isAdding) {
-
-    UMF_CHECK((hProvider != NULL), UMF_RESULT_ERROR_INVALID_ARGUMENT);
-
-    umf_result_t res = hProvider->ops.ext_resident_device_change(
-        hProvider->provider_priv, device, isAdding);
-
-    checkErrorAndSetLastProvider(res, hProvider);
-    return res;
-}
+}

src/provider/provider_cuda.c

@@ -829,7 +829,6 @@ static umf_memory_provider_ops_t UMF_CUDA_MEMORY_PROVIDER_OPS = {
         cu_memory_provider_get_allocation_properties,
     .ext_get_allocation_properties_size =
         cu_memory_provider_get_allocation_properties_size,
-    .ext_resident_device_change = NULL,
 };
 
 const umf_memory_provider_ops_t *umfCUDAMemoryProviderOps(void) {

src/provider/provider_level_zero.c

@@ -178,7 +178,7 @@ static ze_memory_type_t umf2ze_memory_type(umf_usm_memory_type_t memory_type) {
 
 static void init_ze_global_state(void) {
 
-    char *lib_name = getenv("UMF_ZE_LOADER_LIB_NAME");
+    const char *lib_name = getenv("UMF_ZE_LOADER_LIB_NAME");
     if (lib_name != NULL && lib_name[0] != '\0') {
         LOG_INFO("Using custom ze_loader library name: %s", lib_name);
     } else {
@@ -371,7 +371,7 @@ umf_result_t umfLevelZeroMemoryProviderParamsSetResidentDevices(
             if (hDevices[first_idx] == hDevices[second_idx]) {
                 LOG_ERR("resident devices are not unique, idx:%u and "
                         "idx:%u both point to device:%p",
-                        first_idx, second_idx, hDevices[first_idx]);
+                        first_idx, second_idx, (void *)hDevices[first_idx]);
                 return UMF_RESULT_ERROR_INVALID_ARGUMENT;
             }
         }
@@ -527,8 +527,8 @@ static umf_result_t ze_memory_provider_alloc_helper(void *provider, size_t size,
             utils_read_unlock(&ze_provider->resident_device_rwlock);
             LOG_ERR("making resident allocation %p of size:%lu on device %p "
                     "failed with 0x%x",
-                    *resultPtr, size, ze_provider->resident_device_handles[i],
-                    ze_result);
+                    *resultPtr, size,
+                    (void *)ze_provider->resident_device_handles[i], ze_result);
             umf_result_t free_result =
                 ze_memory_provider_free(ze_provider, *resultPtr, size);
             if (free_result != UMF_RESULT_SUCCESS) {
@@ -539,7 +539,8 @@ static umf_result_t ze_memory_provider_alloc_helper(void *provider, size_t size,
             return ze2umf_result(ze_result);
         }
         LOG_DEBUG("allocation %p of size:%lu made resident on device %p",
-                  *resultPtr, size, ze_provider->resident_device_handles[i]);
+                  *resultPtr, size,
+                  (void *)ze_provider->resident_device_handles[i]);
     }
     utils_read_unlock(&ze_provider->resident_device_rwlock);
 
@@ -1034,22 +1035,21 @@ static int ze_memory_provider_resident_device_change_helper(uintptr_t key,
     return 0;
 }
 
-static umf_result_t ze_memory_provider_resident_device_change(void *provider,
-                                                              void *device,
-                                                              bool is_adding) {
-    ze_memory_provider_t *ze_provider = provider;
-    ze_device_handle_t ze_device = device;
+umf_result_t umfLevelZeroMemoryProviderResidentDeviceChange(
+    umf_memory_provider_handle_t provider, ze_device_handle_t device,
+    bool is_adding) {
+    ze_memory_provider_t *ze_provider = umfMemoryProviderGetPriv(provider);
 
     LOG_INFO("%s resident device %p, src_provider:%p, existing peers "
              "count:%d",
-             (is_adding ? "adding" : "removing"), ze_device, provider,
-             ze_provider->resident_device_count);
+             (is_adding ? "adding" : "removing"), (void *)device,
+             (void *)provider, ze_provider->resident_device_count);
 
     uint32_t existing_peer_index = 0;
     utils_write_lock(&ze_provider->resident_device_rwlock);
     while (existing_peer_index < ze_provider->resident_device_count &&
            ze_provider->resident_device_handles[existing_peer_index] !=
-               ze_device) {
+               device) {
         ++existing_peer_index;
     }
 
@@ -1060,7 +1060,7 @@ static umf_result_t ze_memory_provider_resident_device_change(void *provider,
             utils_write_unlock(&ze_provider->resident_device_rwlock);
             LOG_ERR("trying to remove resident device %p but the device "
                     "is not a peer of provider:%p currently",
-                    ze_device, provider);
+                    (void *)device, (void *)provider);
             return UMF_RESULT_ERROR_INVALID_ARGUMENT;
         }
         // adding case
@@ -1086,7 +1086,7 @@ static umf_result_t ze_memory_provider_resident_device_change(void *provider,
             ze_provider->resident_device_handles = new_handles;
             ze_provider->resident_device_capacity = new_capacity;
         }
-        ze_provider->resident_device_handles[existing_peer_index] = ze_device;
+        ze_provider->resident_device_handles[existing_peer_index] = device;
         ++ze_provider->resident_device_count;
 
     } else {
@@ -1095,7 +1095,7 @@ static umf_result_t ze_memory_provider_resident_device_change(void *provider,
             utils_write_unlock(&ze_provider->resident_device_rwlock);
             LOG_ERR("trying to add resident device:%p but the device is "
                     "already a peer of provider:%p",
-                    ze_device, provider);
+                    (void *)device, (void *)provider);
             return UMF_RESULT_ERROR_INVALID_ARGUMENT;
         }
         // removing case, put last in place of removed one
@@ -1108,7 +1108,7 @@ static umf_result_t ze_memory_provider_resident_device_change(void *provider,
 
     struct ze_memory_provider_resident_device_change_data privData = {
         .is_adding = is_adding,
-        .peer_device = ze_device,
+        .peer_device = device,
         .source_memory_provider = ze_provider,
         .success_changes = 0,
         .failed_changes = 0,
@@ -1162,7 +1162,6 @@ static umf_memory_provider_ops_t UMF_LEVEL_ZERO_MEMORY_PROVIDER_OPS = {
         ze_memory_provider_get_allocation_properties,
     .ext_get_allocation_properties_size =
         ze_memory_provider_get_allocation_properties_size,
-    .ext_resident_device_change = ze_memory_provider_resident_device_change,
 };
 
 const umf_memory_provider_ops_t *umfLevelZeroMemoryProviderOps(void) {
@@ -1258,4 +1257,14 @@ const umf_memory_provider_ops_t *umfLevelZeroMemoryProviderOps(void) {
     return NULL;
 }
 
+umf_result_t umfLevelZeroMemoryProviderResidentDeviceChange(
+    umf_memory_provider_handle_t provider, ze_device_handle_t device,
+    bool is_adding) {
+    (void)provider(void) device,
+        (void)is_adding LOG_ERR(
+            "L0 memory provider is disabled! (UMF_BUILD_LEVEL_ZERO_PROVIDER is "
+            "OFF)");
+    return UMF_RESULT_ERROR_NOT_SUPPORTED;
+}
+
 #endif // !UMF_BUILD_LEVEL_ZERO_PROVIDER

src/provider/provider_tracking.c

@@ -1358,7 +1358,6 @@ umf_memory_provider_ops_t UMF_TRACKING_MEMORY_PROVIDER_OPS = {
     .ext_ctl = NULL,
     .ext_get_allocation_properties = trackingGetAllocationProperties,
     .ext_get_allocation_properties_size = trackingGetAllocationPropertiesSize,
-    .ext_resident_device_change = NULL,
 };
 
 static void free_ipc_cache_value(void *unused, void *ipc_cache_value) {

test/common/provider_null.c

@@ -162,14 +162,6 @@ static umf_result_t nullGetAllocationPropertiesSize(
     return UMF_RESULT_SUCCESS;
 }
 
-static umf_result_t nullResidentDeviceChange(void *provider, void *device,
-                                             bool is_adding) {
-    (void)provider;
-    (void)device;
-    (void)is_adding;
-    return UMF_RESULT_SUCCESS;
-}
-
 umf_memory_provider_ops_t UMF_NULL_PROVIDER_OPS = {
     .version = UMF_PROVIDER_OPS_VERSION_CURRENT,
     .initialize = nullInitialize,
@@ -191,5 +183,4 @@ umf_memory_provider_ops_t UMF_NULL_PROVIDER_OPS = {
     .ext_close_ipc_handle = nullCloseIpcHandle,
     .ext_get_allocation_properties = nullGetAllocationProperties,
     .ext_get_allocation_properties_size = nullGetAllocationPropertiesSize,
-    .ext_resident_device_change = nullResidentDeviceChange,
 };