Implement size limit for the cache of opened IPC handles

Author: vinser52

src/ipc.c

@@ -146,19 +146,15 @@ umf_result_t umfOpenIPCHandle(umf_ipc_handler_handle_t hIPCHandler,
 }
 
 umf_result_t umfCloseIPCHandle(void *ptr) {
-    umf_alloc_info_t allocInfo;
-    umf_result_t ret = umfMemoryTrackerGetAllocInfo(ptr, &allocInfo);
+    umf_ipc_info_t ipcInfo;
+    umf_result_t ret = umfMemoryTrackerGetIpcInfo(ptr, &ipcInfo);
     if (ret != UMF_RESULT_SUCCESS) {
-        LOG_ERR("cannot get alloc info for ptr = %p.", ptr);
+        LOG_ERR("cannot get IPC info for ptr = %p.", ptr);
         return ret;
     }
 
-    // We cannot use umfPoolGetMemoryProvider function because it returns
-    // upstream provider but we need tracking one
-    umf_memory_provider_handle_t hProvider = allocInfo.pool->provider;
-
-    return umfMemoryProviderCloseIPCHandle(hProvider, allocInfo.base,
-                                           allocInfo.baseSize);
+    return umfMemoryProviderCloseIPCHandle(ipcInfo.provider, ipcInfo.base,
+                                           ipcInfo.baseSize);
 }
 
 umf_result_t umfPoolGetIPCHandler(umf_memory_pool_handle_t hPool,

src/ipc_cache.c

@@ -54,6 +54,22 @@ typedef struct ipc_opened_cache_t {
 
 ipc_opened_cache_global_t *IPC_OPENED_CACHE_GLOBAL = NULL;
 
+// Returns value of the UMF_MAX_OPENED_IPC_HANDLES environment variable
+// or 0 if it is not set.
+static size_t umfIpcCacheGlobalInitMaxOpenedHandles(void) {
+    const char *max_size_str = getenv("UMF_MAX_OPENED_IPC_HANDLES");
+    if (max_size_str) {
+        char *endptr;
+        size_t max_size = strtoul(max_size_str, &endptr, 10);
+        if (*endptr == '\0') {
+            return max_size;
+        }
+        LOG_ERR("Invalid value of UMF_MAX_OPENED_IPC_HANDLES: %s",
+                max_size_str);
+    }
+    return 0;
+}
+
 umf_result_t umfIpcCacheGlobalInit(void) {
     umf_result_t ret = UMF_RESULT_SUCCESS;
     ipc_opened_cache_global_t *cache_global =
@@ -78,8 +94,7 @@ umf_result_t umfIpcCacheGlobalInit(void) {
         goto err_mutex_destroy;
     }
 
-    // TODO: make max_size configurable via environment variable
-    cache_global->max_size = 0;
+    cache_global->max_size = umfIpcCacheGlobalInitMaxOpenedHandles();
     cache_global->cur_size = 0;
     cache_global->lru_list = NULL;
 
@@ -191,7 +206,18 @@ umf_result_t umfIpcOpenedCacheGet(ipc_opened_cache_handle_t cache,
         if (entry == NULL && cache->global->max_size != 0 &&
             cache->global->cur_size >= cache->global->max_size) {
             // If max_size is set and the cache is full, evict the least recently used entry.
-            entry = cache->global->lru_list->prev;
+            // we need to search for the least recently used entry with ref_count == 0
+            // The utlist implementation of the doubly-linked list keeps a tail pointer in head->prev
+            ipc_opened_cache_entry_t *candidate = cache->global->lru_list->prev;
+            do {
+                uint64_t ref_count = 0;
+                utils_atomic_load_acquire(&candidate->ref_count, &ref_count);
+                if (ref_count == 0) {
+                    entry = candidate;
+                    break;
+                }
+                candidate = candidate->prev;
+            } while (candidate != cache->global->lru_list->prev);
         }
 
         if (entry) { // we have eviction candidate
@@ -244,3 +270,20 @@ umf_result_t umfIpcOpenedCacheGet(ipc_opened_cache_handle_t cache,
 
     return ret;
 }
+
+umf_result_t
+umfIpcHandleMappedCacheRelease(ipc_opened_cache_value_t *cacheValue) {
+    if (!cacheValue) {
+        LOG_ERR("cacheValue is NULL");
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+    }
+
+    // get pointer to the entry
+    ipc_opened_cache_entry_t *entry =
+        (ipc_opened_cache_entry_t *)((char *)cacheValue -
+                                     offsetof(ipc_opened_cache_entry_t, value));
+    // decrement the ref count
+    utils_atomic_decrement(&entry->ref_count);
+
+    return UMF_RESULT_SUCCESS;
+}

src/ipc_cache.h

@@ -47,4 +47,6 @@ umf_result_t umfIpcOpenedCacheGet(ipc_opened_cache_handle_t cache,
                                   uint64_t handle_id,
                                   ipc_opened_cache_value_t **retEntry);
 
+umf_result_t
+umfIpcHandleMappedCacheRelease(ipc_opened_cache_value_t *cacheValue);
 #endif /* UMF_IPC_CACHE_H */