Merge pull request #202 from igchor/move_rutime_init

Move global state init/deinit to libumf_.c file

Author: ldorau

src/CMakeLists.txt

@@ -22,17 +22,17 @@ set(UMF_SOURCES
 
 set(UMF_SOURCES_LINUX
     base_alloc/base_alloc_linux.c
-    provider/provider_tracking_linux.c
+    libumf_linux.c
 )
 
 set(UMF_SOURCES_WINDOWS
     base_alloc/base_alloc_windows.c
-    provider/provider_tracking_windows.c
+    libumf_windows.c
 )
 
 set(UMF_SOURCES_MACOSX
     base_alloc/base_alloc_linux.c
-    provider/provider_tracking_linux.c
+    libumf_linux.c
 )
 
 if(UMF_BUILD_OS_MEMORY_PROVIDER)

src/libumf.h

@@ -0,0 +1,24 @@
+/*
+ *
+ * Copyright (C) 2023 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_LIBUMF_H
+#define UMF_LIBUMF_H 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// initializes runtime state needed by the library (needed mostly for static libaries on windows)
+void libumfInit(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* UMF_LIBUMF_H */

src/libumf_linux.c

@@ -0,0 +1,25 @@
+/*
+ *
+ * Copyright (C) 2024 Intel Corporation
+ *
+ * Under the Apache License v2.0 with LLVM Exceptions. See LICENSE.TXT.
+ * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+ *
+ */
+
+#include "provider_tracking.h"
+
+#include <stddef.h>
+
+umf_memory_tracker_handle_t TRACKER = NULL;
+
+void __attribute__((constructor)) umfCreate(void) {
+    TRACKER = umfMemoryTrackerCreate();
+}
+void __attribute__((destructor)) umfDestroy(void) {
+    umfMemoryTrackerDestroy(TRACKER);
+}
+
+void libumfInit(void) {
+    // do nothing, additional initialization not needed
+}

src/provider/provider_tracking_windows.c renamed to src/libumf_windows.c

@@ -12,9 +12,9 @@
 #include <stdlib.h>
 #include <windows.h>
 
-static umf_memory_tracker_handle_t TRACKER = NULL;
+umf_memory_tracker_handle_t TRACKER = NULL;
 
-static void providerFini(void) { umfTrackingMemoryProviderFini(TRACKER); }
+static void providerFini(void) { umfMemoryTrackerDestroy(TRACKER); }
 
 #if defined(UMF_SHARED_LIBRARY)
 BOOL APIENTRY DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) {
@@ -26,24 +26,20 @@ BOOL APIENTRY DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) {
     return TRUE;
 }
 
-void umfTrackingMemoryProviderInit(void) {
+void libumfInit(void) {
     // do nothing, additional initialization not needed
 }
 #else
 INIT_ONCE init_once_flag = INIT_ONCE_STATIC_INIT;
 
-BOOL CALLBACK providerInit(PINIT_ONCE InitOnce, PVOID Parameter,
-                           PVOID *lpContext) {
+BOOL CALLBACK initOnceCb(PINIT_ONCE InitOnce, PVOID Parameter,
+                         PVOID *lpContext) {
     TRACKER = umfMemoryTrackerCreate();
     atexit(providerFini);
     return TRACKER ? TRUE : FALSE;
 }
 
-void umfTrackingMemoryProviderInit(void) {
-    InitOnceExecuteOnce(&init_once_flag, providerInit, NULL, NULL);
+void libumfInit(void) {
+    InitOnceExecuteOnce(&init_once_flag, initOnceCb, NULL, NULL);
 }
 #endif
-
-umf_memory_tracker_handle_t umfMemoryTrackerGet(void) {
-    return (umf_memory_tracker_handle_t)TRACKER;
-}

src/memory_pool.c

@@ -7,6 +7,7 @@
  *
  */
 
+#include "libumf.h"
 #include "memory_pool_internal.h"
 #include "utils_common.h"
 
@@ -20,6 +21,7 @@ umf_result_t umfPoolCreate(const umf_memory_pool_ops_t *ops,
                            umf_memory_provider_handle_t provider, void *params,
                            umf_pool_create_flags_t flags,
                            umf_memory_pool_handle_t *hPool) {
+    libumfInit();
     umf_result_t ret = umfPoolCreateInternal(ops, provider, params, hPool);
     if (ret != UMF_RESULT_SUCCESS) {
         return ret;

src/memory_pool_tracking.c

@@ -78,7 +78,7 @@ umf_result_t umfFree(void *ptr) {
 }
 
 umf_memory_pool_handle_t umfPoolByPtr(const void *ptr) {
-    return umfMemoryTrackerGetPool(umfMemoryTrackerGet(), ptr);
+    return umfMemoryTrackerGetPool(ptr);
 }
 
 umf_result_t umfPoolGetMemoryProvider(umf_memory_pool_handle_t hPool,

src/memory_provider.c

@@ -7,6 +7,7 @@
  *
  */
 
+#include "libumf.h"
 #include "memory_provider_internal.h"
 #include "utils_common.h"
 
@@ -24,6 +25,7 @@ typedef struct umf_memory_provider_t {
 umf_result_t umfMemoryProviderCreate(const umf_memory_provider_ops_t *ops,
                                      void *params,
                                      umf_memory_provider_handle_t *hProvider) {
+    libumfInit();
     if (!ops || !hProvider) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }

src/memory_target.c

@@ -10,12 +10,14 @@
 #include <assert.h>
 #include <stdlib.h>
 
+#include "libumf.h"
 #include "memory_target.h"
 #include "memory_target_ops.h"
 
 umf_result_t umfMemoryTargetCreate(const umf_memory_target_ops_t *ops,
                                    void *params,
                                    umf_memory_target_handle_t *memoryTarget) {
+    libumfInit();
     if (!ops || !memoryTarget) {
         return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }

src/provider/provider_tracking.c

@@ -73,13 +73,12 @@ static umf_result_t umfMemoryTrackerRemove(umf_memory_tracker_handle_t hTracker,
     return UMF_RESULT_SUCCESS;
 }
 
-umf_memory_pool_handle_t
-umfMemoryTrackerGetPool(umf_memory_tracker_handle_t hTracker, const void *ptr) {
+umf_memory_pool_handle_t umfMemoryTrackerGetPool(const void *ptr) {
     assert(ptr);
 
     uintptr_t rkey;
     tracker_value_t *rvalue;
-    int found = critnib_find(hTracker->map, (uintptr_t)ptr, FIND_LE,
+    int found = critnib_find(TRACKER->map, (uintptr_t)ptr, FIND_LE,
                              (void *)&rkey, (void **)&rvalue);
     if (!found) {
         return NULL;
@@ -425,11 +424,10 @@ umf_memory_provider_ops_t UMF_TRACKING_MEMORY_PROVIDER_OPS = {
 umf_result_t umfTrackingMemoryProviderCreate(
     umf_memory_provider_handle_t hUpstream, umf_memory_pool_handle_t hPool,
     umf_memory_provider_handle_t *hTrackingProvider) {
-    umfTrackingMemoryProviderInit();
 
     umf_tracking_memory_provider_t params;
     params.hUpstream = hUpstream;
-    params.hTracker = umfMemoryTrackerGet();
+    params.hTracker = TRACKER;
     if (!params.hTracker) {
         return UMF_RESULT_ERROR_UNKNOWN;
     }
@@ -448,11 +446,39 @@ void umfTrackingMemoryProviderGetUpstreamProvider(
     *hUpstream = p->hUpstream;
 }
 
-void umfTrackingMemoryProviderFini(void *tracker) {
-    umf_memory_tracker_handle_t hTracker = (umf_memory_tracker_handle_t)tracker;
+umf_memory_tracker_handle_t umfMemoryTrackerCreate(void) {
+    umf_memory_tracker_handle_t handle = (umf_memory_tracker_handle_t)malloc(
+        sizeof(struct umf_memory_tracker_t));
+    if (!handle) {
+        return NULL;
+    }
+
+    handle->map = critnib_new();
+    if (!handle->map) {
+        free(handle);
+        return NULL;
+    }
+
+    handle->splitMergeMutex = util_mutex_create();
+    if (!handle->splitMergeMutex) {
+        critnib_delete(handle->map);
+        free(handle);
+        return NULL;
+    }
+
+    return handle;
+}
+
+void umfMemoryTrackerDestroy(umf_memory_tracker_handle_t handle) {
+    if (!handle) {
+        return;
+    }
+
 #ifndef NDEBUG
-    check_if_tracker_is_empty(hTracker, NULL);
+    check_if_tracker_is_empty(handle, NULL);
 #endif /* NDEBUG */
 
-    umfMemoryTrackerDestroy(hTracker);
+    critnib_delete(handle->map);
+    util_mutex_destroy(handle->splitMergeMutex);
+    free(handle);
 }

src/provider/provider_tracking.h

@@ -24,63 +24,26 @@
 extern "C" {
 #endif
 
-extern umf_memory_provider_ops_t UMF_TRACKING_MEMORY_PROVIDER_OPS;
-
 struct umf_memory_tracker_t {
     critnib *map;
     os_mutex_t *splitMergeMutex;
 };
 
 typedef struct umf_memory_tracker_t *umf_memory_tracker_handle_t;
 
-static inline umf_memory_tracker_handle_t umfMemoryTrackerCreate(void) {
-    umf_memory_tracker_handle_t handle = (umf_memory_tracker_handle_t)malloc(
-        sizeof(struct umf_memory_tracker_t));
-    if (!handle) {
-        return NULL;
-    }
-
-    handle->map = critnib_new();
-    if (!handle->map) {
-        free(handle);
-        return NULL;
-    }
+extern umf_memory_tracker_handle_t TRACKER;
 
-    handle->splitMergeMutex = util_mutex_create();
-    if (!handle->splitMergeMutex) {
-        critnib_delete(handle->map);
-        free(handle);
-        return NULL;
-    }
+umf_memory_tracker_handle_t umfMemoryTrackerCreate(void);
+void umfMemoryTrackerDestroy(umf_memory_tracker_handle_t handle);
 
-    return handle;
-}
-
-static inline void umfMemoryTrackerDestroy(umf_memory_tracker_handle_t handle) {
-    if (!handle) {
-        return;
-    }
-
-    critnib_delete(handle->map);
-    util_mutex_destroy(handle->splitMergeMutex);
-    free(handle);
-}
-
-umf_memory_tracker_handle_t umfMemoryTrackerGet(void);
-umf_memory_pool_handle_t
-umfMemoryTrackerGetPool(umf_memory_tracker_handle_t hTracker, const void *ptr);
+umf_memory_pool_handle_t umfMemoryTrackerGetPool(const void *ptr);
 
 // Creates a memory provider that tracks each allocation/deallocation through umf_memory_tracker_handle_t and
 // forwards all requests to hUpstream memory Provider. hUpstream lifetime should be managed by the user of this function.
 umf_result_t umfTrackingMemoryProviderCreate(
     umf_memory_provider_handle_t hUpstream, umf_memory_pool_handle_t hPool,
     umf_memory_provider_handle_t *hTrackingProvider);
 
-// Initialize critnib for a UMF static library build on Windows
-void umfTrackingMemoryProviderInit(void);
-
-void umfTrackingMemoryProviderFini(void *tracker);
-
 void umfTrackingMemoryProviderGetUpstreamProvider(
     umf_memory_provider_handle_t hTrackingProvider,
     umf_memory_provider_handle_t *hUpstream);