Mercurial > hg > dbutils / file diff

--- a/ucx/mempool.c	Thu May 29 15:59:27 2025 +0200
+++ b/ucx/mempool.c	Wed Nov 12 18:37:58 2025 +0100
@@ -116,6 +116,9 @@
     if (!ptr) return;
     struct cx_mempool_s *pool = p;
 
+    cx_destructor_func destr = pool->destr;
+    cx_destructor_func2 destr2 = pool->destr2;
+
     struct cx_mempool_memory_s *mem =
         (void*) ((char *) ptr - sizeof(struct cx_mempool_memory_s));
 
@@ -124,11 +127,11 @@
             if (mem->destructor) {
                 mem->destructor(mem->c);
             }
-            if (pool->destr) {
-                pool->destr(mem->c);
+            if (destr != NULL) {
+                destr(mem->c);
             }
-            if (pool->destr2) {
-                pool->destr2(pool->destr2_data, mem->c);
+            if (destr2 != NULL) {
+                destr2(pool->destr2_data, mem->c);
             }
             cxFree(pool->base_allocator, mem);
             size_t last_index = pool->size - 1;
@@ -179,18 +182,18 @@
 }
 
 static void cx_mempool_free_all_simple(const struct cx_mempool_s *pool) {
-    const bool has_destr = pool->destr;
-    const bool has_destr2 = pool->destr2;
+    cx_destructor_func destr = pool->destr;
+    cx_destructor_func2 destr2 = pool->destr2;
     for (size_t i = 0; i < pool->size; i++) {
         struct cx_mempool_memory_s *mem = pool->data[i];
         if (mem->destructor) {
             mem->destructor(mem->c);
         }
-        if (has_destr) {
-            pool->destr(mem->c);
+        if (destr != NULL) {
+            destr(mem->c);
         }
-        if (has_destr2) {
-            pool->destr2(pool->destr2_data, mem->c);
+        if (destr2 != NULL) {
+            destr2(pool->destr2_data, mem->c);
         }
         cxFree(pool->base_allocator, mem);
     }
@@ -247,6 +250,9 @@
     if (!ptr) return;
     struct cx_mempool_s *pool = p;
 
+    cx_destructor_func destr = pool->destr;
+    cx_destructor_func2 destr2 = pool->destr2;
+
     struct cx_mempool_memory2_s *mem =
         (void*) ((char *) ptr - sizeof(struct cx_mempool_memory2_s));
 
@@ -255,11 +261,11 @@
             if (mem->destructor) {
                 mem->destructor(mem->data, mem->c);
             }
-            if (pool->destr) {
-                pool->destr(mem->c);
+            if (destr != NULL) {
+                destr(mem->c);
             }
-            if (pool->destr2) {
-                pool->destr2(pool->destr2_data, mem->c);
+            if (destr2 != NULL) {
+                destr2(pool->destr2_data, mem->c);
             }
             cxFree(pool->base_allocator, mem);
             size_t last_index = pool->size - 1;
@@ -310,18 +316,18 @@
 }
 
 static void cx_mempool_free_all_advanced(const struct cx_mempool_s *pool) {
-    const bool has_destr = pool->destr;
-    const bool has_destr2 = pool->destr2;
+    cx_destructor_func destr = pool->destr;
+    cx_destructor_func2 destr2 = pool->destr2;
     for (size_t i = 0; i < pool->size; i++) {
         struct cx_mempool_memory2_s *mem = pool->data[i];
         if (mem->destructor) {
             mem->destructor(mem->data, mem->c);
         }
-        if (has_destr) {
-            pool->destr(mem->c);
+        if (destr != NULL) {
+            destr(mem->c);
         }
-        if (has_destr2) {
-            pool->destr2(pool->destr2_data, mem->c);
+        if (destr2 != NULL) {
+            destr2(pool->destr2_data, mem->c);
         }
         cxFree(pool->base_allocator, mem);
     }
@@ -376,13 +382,16 @@
     if (!ptr) return;
     struct cx_mempool_s *pool = p;
 
+    cx_destructor_func destr = pool->destr;
+    cx_destructor_func2 destr2 = pool->destr2;
+
     for (size_t i = 0; i < pool->size; i++) {
         if (ptr == pool->data[i]) {
-            if (pool->destr) {
-                pool->destr(ptr);
+            if (destr != NULL) {
+                destr(ptr);
             }
-            if (pool->destr2) {
-                pool->destr2(pool->destr2_data, ptr);
+            if (destr2 != NULL) {
+                destr2(pool->destr2_data, ptr);
             }
             cxFree(pool->base_allocator, ptr);
             size_t last_index = pool->size - 1;
@@ -427,15 +436,15 @@
 }
 
 static void cx_mempool_free_all_pure(const struct cx_mempool_s *pool) {
-    const bool has_destr = pool->destr;
-    const bool has_destr2 = pool->destr2;
+    cx_destructor_func destr = pool->destr;
+    cx_destructor_func2 destr2 = pool->destr2;
     for (size_t i = 0; i < pool->size; i++) {
         void *mem = pool->data[i];
-        if (has_destr) {
-            pool->destr(mem);
+        if (destr != NULL) {
+            destr(mem);
         }
-        if (has_destr2) {
-            pool->destr2(pool->destr2_data, mem);
+        if (destr2 != NULL) {
+            destr2(pool->destr2_data, mem);
         }
         cxFree(pool->base_allocator, mem);
     }
@@ -633,13 +642,19 @@
     new_source_allocator->data = source;
 
     // transfer all the data
-    memcpy(&dest->data[dest->size], source->data, sizeof(void*)*source->size);
-    dest->size += source->size;
+    if (source->size > 0) {
+        memcpy(&dest->data[dest->size], source->data,
+            sizeof(void*)*source->size);
+        dest->size += source->size;
+    }
 
     // transfer all registered memory
-    memcpy(&dest->registered[dest->registered_size], source->registered,
-           sizeof(struct cx_mempool_foreign_memory_s) * source->size);
-    dest->registered_size += source->registered_size;
+    if (source->registered_size > 0) {
+        memcpy(&dest->registered[dest->registered_size], source->registered,
+               sizeof(struct cx_mempool_foreign_memory_s)
+               * source->registered_size);
+        dest->registered_size += source->registered_size;
+    }
 
     // register the old allocator with the new pool
     // we have to remove const-ness for this, but that's okay here