Assert if tracking provider is not empty

src/provider/provider_tracking.c

@@ -322,7 +322,50 @@ static umf_result_t trackingInitialize(void *params, void **ret) {
     return UMF_RESULT_SUCCESS;
 }
 
-static void trackingFinalize(void *provider) { free(provider); }
+#ifndef NDEBUG
+static void check_if_tracker_is_empty(umf_memory_tracker_handle_t hTracker,
+                                      umf_memory_pool_handle_t pool) {
+    uintptr_t rkey;
+    void *rvalue;
+    size_t n_items = 0;
+    uintptr_t last_key = 0;
+
+    while (1 == critnib_find((critnib *)hTracker->map, last_key, FIND_G, &rkey,
+                             &rvalue)) {
+        tracker_value_t *value = (tracker_value_t *)rvalue;
+        if (value->pool == pool || pool == NULL) {
+            n_items++;
+        }
+
+        last_key = rkey;
+    }
+
+    if (n_items) {
+        if (pool) {
+            fprintf(stderr,
+                    "ASSERT: tracking provider of pool %p is not empty! (%zu "
+                    "items left)\n",
+                    (void *)pool, n_items);
+        } else {
+            fprintf(
+                stderr,
+                "ASSERT: tracking provider is not empty! (%zu items left)\n",
+                n_items);
+        }
+        assert(n_items == 0);
+    }
+}
+#endif /* NDEBUG */
+
+static void trackingFinalize(void *provider) {
+#ifndef NDEBUG
+    umf_tracking_memory_provider_t *p =
+        (umf_tracking_memory_provider_t *)provider;
+    check_if_tracker_is_empty(p->hTracker, p->pool);
+#endif /* NDEBUG */
+
+    free(provider);
+}
 
 static void trackingGetLastError(void *provider, const char **msg,
                                  int32_t *pError) {
@@ -404,3 +447,12 @@ void umfTrackingMemoryProviderGetUpstreamProvider(
         (umf_tracking_memory_provider_t *)hTrackingProvider;
     *hUpstream = p->hUpstream;
 }
+
+void umfTrackingMemoryProviderFini(void *tracker) {
+    umf_memory_tracker_handle_t hTracker = (umf_memory_tracker_handle_t)tracker;
+#ifndef NDEBUG
+    check_if_tracker_is_empty(hTracker, NULL);
+#endif /* NDEBUG */
+
+    umfMemoryTrackerDestroy(hTracker);
+}

src/provider/provider_tracking.h

@@ -78,6 +78,8 @@ umf_result_t umfTrackingMemoryProviderCreate(
 // 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);

src/provider/provider_tracking_linux.c

@@ -17,7 +17,7 @@ void __attribute__((constructor)) createLibTracker(void) {
     TRACKER = umfMemoryTrackerCreate();
 }
 void __attribute__((destructor)) deleteLibTracker(void) {
-    umfMemoryTrackerDestroy(TRACKER);
+    umfTrackingMemoryProviderFini(TRACKER);
 }
 
 void umfTrackingMemoryProviderInit(void) {

src/provider/provider_tracking_windows.c

@@ -14,10 +14,12 @@
 
 static umf_memory_tracker_handle_t TRACKER = NULL;
 
+static void providerFini(void) { umfTrackingMemoryProviderFini(TRACKER); }
+
 #if defined(UMF_SHARED_LIBRARY)
 BOOL APIENTRY DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) {
     if (fdwReason == DLL_PROCESS_DETACH) {
-        umfMemoryTrackerDestroy(TRACKER);
+        providerFini();
     } else if (fdwReason == DLL_PROCESS_ATTACH) {
         TRACKER = umfMemoryTrackerCreate();
     }
@@ -30,8 +32,6 @@ void umfTrackingMemoryProviderInit(void) {
 #else
 INIT_ONCE init_once_flag = INIT_ONCE_STATIC_INIT;
 
-static void providerFini(void) { umfMemoryTrackerDestroy(TRACKER); }
-
 BOOL CALLBACK providerInit(PINIT_ONCE InitOnce, PVOID Parameter,
                            PVOID *lpContext) {
     TRACKER = umfMemoryTrackerCreate();