hashmap: expose helper for releasing memory pools independently of valgrind

Let's clean this up and export this always, so that we can later call
when we are under memory pressure.

diff --git a/src/basic/hashmap.c b/src/basic/hashmap.c
index b9efaafa3cc5f686cc0cafd372e5fa1f05c0f8ed..c18c75d78ccd2592cd3fe7766b7a6edce14d3da9 100644 (file)
--- a/src/basic/hashmap.c
+++ b/src/basic/hashmap.c
@@ -274,28 +274,32 @@ static _used_ const struct hashmap_type_info hashmap_type_info[_HASHMAP_TYPE_MAX
         },
 };
 
-#if VALGRIND
-_destructor_ static void cleanup_pools(void) {
-        _cleanup_free_ char *t = NULL;
+void hashmap_cleanup_pools(void) {
+        int r;
 
-        /* Be nice to valgrind */
+        /* The pool is only allocated by the main thread, but the memory can be passed to other
+         * threads. Let's clean up if we are the main thread and no other threads are live. */
 
-        /* The pool is only allocated by the main thread, but the memory can
-         * be passed to other threads. Let's clean up if we are the main thread
-         * and no other threads are live. */
-        /* We build our own is_main_thread() here, which doesn't use C11
-         * TLS based caching of the result. That's because valgrind apparently
-         * doesn't like malloc() (which C11 TLS internally uses) to be called
-         * from a GCC destructors. */
+        /* We build our own is_main_thread() here, which doesn't use C11 TLS based caching of the
+         * result. That's because valgrind apparently doesn't like TLS to be used from a GCC destructor. */
         if (getpid() != gettid())
-                return;
+                return (void) log_debug("Not cleaning up memory pools, not in main thread.");
 
-        if (get_process_threads(0) != 1)
-                return;
+        r = get_process_threads(0);
+        if (r < 0)
+                return (void) log_debug_errno(r, "Failed to determine number of threads, not cleaning up memory pools: %m");
+        if (r != 1)
+                return (void) log_debug("Not cleaning up memory pools, running in multi-threaded process.");
 
         mempool_drop(&hashmap_pool);
         mempool_drop(&ordered_hashmap_pool);
 }
+
+#if VALGRIND
+_destructor_ static void cleanup_pools(void) {
+        /* Be nice to valgrind */
+        hashmap_cleanup_pools();
+}
 #endif
 
 static unsigned n_buckets(HashmapBase *h) {

diff --git a/src/basic/hashmap.h b/src/basic/hashmap.h
index ebb5a63eb447765254ab9f4c761f834b7b4cc7e1..1b944e93b578a0f09302fd99d187c54831b381aa 100644 (file)
--- a/src/basic/hashmap.h
+++ b/src/basic/hashmap.h
@@ -443,3 +443,5 @@ DEFINE_TRIVIAL_CLEANUP_FUNC(OrderedHashmap*, ordered_hashmap_free_free_free);
 DEFINE_TRIVIAL_CLEANUP_FUNC(IteratedCache*, iterated_cache_free);
 
 #define _cleanup_iterated_cache_free_ _cleanup_(iterated_cache_freep)
+
+void hashmap_cleanup_pools(void);

diff --git a/src/basic/mempool.c b/src/basic/mempool.c
index fff23fdbacb063ae8128cb706a666e998d4c3e2e..92d8822bd94745d274aef145e1d7dd0c50e04239 100644 (file)
--- a/src/basic/mempool.c
+++ b/src/basic/mempool.c
@@ -70,7 +70,6 @@ void mempool_free_tile(struct mempool *mp, void *p) {
         mp->freelist = p;
 }
 
-#if VALGRIND
 void mempool_drop(struct mempool *mp) {
         struct pool *p = mp->first_pool;
         while (p) {
@@ -80,4 +79,3 @@ void mempool_drop(struct mempool *mp) {
                 p = n;
         }
 }
-#endif

diff --git a/src/basic/mempool.h b/src/basic/mempool.h
index 539ccbdf06b7d35708aef0a7fba55172e8f5dec6..80925cb95a854274ac409602b560228b86918bb4 100644 (file)
--- a/src/basic/mempool.h
+++ b/src/basic/mempool.h
@@ -25,6 +25,4 @@ static struct mempool pool_name = { \
 
 __attribute__((weak)) bool mempool_enabled(void);
 
-#if VALGRIND
 void mempool_drop(struct mempool *mp);
-#endif