ucx: comparison src/mempool.c

-:2cf66dee40b8
+:343eac5ac824
 if (pool->capacity > newcap
 || cx_szmul(newcap, sizeof(void*), &newmsize)) {
 errno = EOVERFLOW;
 return 1;
 } // LCOV_EXCL_STOP
-void **newdata = cxReallocDefault(pool->data, newmsize);
+void **newdata = cxRealloc(pool->base_allocator, pool->data, newmsize);
 if (newdata == NULL) return 1;
 pool->data = newdata;
 pool->capacity = newcap;
 return 0;
 }
 if (pool->registered_capacity > newcap || cx_szmul(newcap,
 sizeof(struct cx_mempool_foreign_memory_s), &newmsize)) {
 errno = EOVERFLOW;
 return 1;
 } // LCOV_EXCL_STOP
-void *newdata = cxReallocDefault(pool->registered, newmsize);
+void *newdata = cxRealloc(pool->base_allocator, pool->registered, newmsize);
 if (newdata == NULL) return 1;
 pool->registered = newdata;
 pool->registered_capacity = newcap;
 return 0;
 }
 if (cx_mempool_ensure_capacity(pool, pool->size + 1)) {
 return NULL; // LCOV_EXCL_LINE
 }
 struct cx_mempool_memory_s *mem =
-cxMallocDefault(sizeof(struct cx_mempool_memory_s) + n);
+cxMalloc(pool->base_allocator, sizeof(struct cx_mempool_memory_s) + n);
 if (mem == NULL) return NULL;
 mem->destructor = NULL;
 pool->data[pool->size] = mem;
 pool->size++;
 pool->destr(mem->c);
 }
 if (pool->destr2) {
 pool->destr2(pool->destr2_data, mem->c);
 }
-cxFreeDefault(mem);
+cxFree(pool->base_allocator, mem);
 size_t last_index = pool->size - 1;
 if (i != last_index) {
 pool->data[i] = pool->data[last_index];
 pool->data[last_index] = NULL;
 }
 const unsigned overhead = sizeof(struct cx_mempool_memory_s);
 struct cx_mempool_memory_s *mem =
 (void *) (((char *) ptr) - overhead);
 struct cx_mempool_memory_s *newm =
-cxReallocDefault(mem, n + overhead);
+cxRealloc(pool->base_allocator, mem, n + overhead);
 if (newm == NULL) return NULL;
 if (mem != newm) {
 for (size_t i = 0; i < pool->size; i++) {
 if (pool->data[i] == mem) {
 pool->destr(mem->c);
 }
 if (has_destr2) {
 pool->destr2(pool->destr2_data, mem->c);
 }
-cxFreeDefault(mem);
+cxFree(pool->base_allocator, mem);
 }
 }
 static cx_allocator_class cx_mempool_simple_allocator_class = {
 cx_mempool_malloc_simple,
 if (cx_mempool_ensure_capacity(pool, pool->size + 1)) {
 return NULL;  // LCOV_EXCL_LINE
 }
 struct cx_mempool_memory2_s *mem =
-cxMallocDefault(sizeof(struct cx_mempool_memory2_s) + n);
+cxMalloc(pool->base_allocator, sizeof(struct cx_mempool_memory2_s) + n);
 if (mem == NULL) return NULL;
 mem->destructor = NULL;
 mem->data = NULL;
 pool->data[pool->size] = mem;
 pool->size++;
 pool->destr(mem->c);
 }
 if (pool->destr2) {
 pool->destr2(pool->destr2_data, mem->c);
 }
-cxFreeDefault(mem);
+cxFree(pool->base_allocator, mem);
 size_t last_index = pool->size - 1;
 if (i != last_index) {
 pool->data[i] = pool->data[last_index];
 pool->data[last_index] = NULL;
 }
 const unsigned overhead = sizeof(struct cx_mempool_memory2_s);
 struct cx_mempool_memory2_s *mem =
 (void *) (((char *) ptr) - overhead);
 struct cx_mempool_memory2_s *newm =
-cxReallocDefault(mem, n + overhead);
+cxRealloc(pool->base_allocator, mem, n + overhead);
 if (newm == NULL) return NULL;
 if (mem != newm) {
 for (size_t i = 0; i < pool->size; i++) {
 if (pool->data[i] == mem) {
 pool->destr(mem->c);
 }
 if (has_destr2) {
 pool->destr2(pool->destr2_data, mem->c);
 }
-cxFreeDefault(mem);
+cxFree(pool->base_allocator, mem);
 }
 }
 static cx_allocator_class cx_mempool_advanced_allocator_class = {
 cx_mempool_malloc_advanced,
 if (cx_mempool_ensure_capacity(pool, pool->size + 1)) {
 return NULL; // LCOV_EXCL_LINE
 }
-void *mem = cxMallocDefault(n);
+void *mem = cxMalloc(pool->base_allocator, n);
 if (mem == NULL) return NULL;
 pool->data[pool->size] = mem;
 pool->size++;
 return mem;
 pool->destr(ptr);
 }
 if (pool->destr2) {
 pool->destr2(pool->destr2_data, ptr);
 }
-cxFreeDefault(ptr);
+cxFree(pool->base_allocator, ptr);
 size_t last_index = pool->size - 1;
 if (i != last_index) {
 pool->data[i] = pool->data[last_index];
 pool->data[last_index] = NULL;
 }
 if (n == 0) {
 cx_mempool_free_pure(p, ptr);
 return NULL;
 }
 struct cx_mempool_s *pool = p;
-void *newm = cxReallocDefault(ptr, n);
+void *newm = cxRealloc(pool->base_allocator, ptr, n);
 if (newm == NULL) return NULL;
 if (ptr != newm) {
 for (size_t i = 0; i < pool->size; i++) {
 if (pool->data[i] == ptr) {
 pool->data[i] = newm;
 pool->destr(mem);
 }
 if (has_destr2) {
 pool->destr2(pool->destr2_data, mem);
 }
-cxFreeDefault(mem);
+cxFree(pool->base_allocator, mem);
 }
 }
 static cx_allocator_class cx_mempool_pure_allocator_class = {
 cx_mempool_malloc_pure,
 cx_mempool_free_all_advanced(pool);
 } else {
 cx_mempool_free_all_pure(pool);
 }
 cx_mempool_free_foreign(pool);
-cxFreeDefault(pool->data);
+cxFree(pool->base_allocator, pool->data);
-cxFreeDefault(pool->registered);
+cxFree(pool->base_allocator, pool->registered);
-cxFreeDefault((void*) pool->allocator);
+cxFree(pool->base_allocator, (void*) pool->allocator);
-cxFreeDefault(pool);
+cxFree(pool->base_allocator, pool);
 }
 void cxMempoolSetDestructor(
 void *ptr,
 cx_destructor_func func
 cxFreeDefault(provided_allocator);
 return NULL;
 }  // LCOV_EXCL_STOP
 provided_allocator->data = pool;
+*((const CxAllocator**)&pool->base_allocator) = cxDefaultAllocator;
 pool->allocator = provided_allocator;
 if (type == CX_MEMPOOL_TYPE_SIMPLE) {
 provided_allocator->cl = &cx_mempool_simple_allocator_class;
 } else if (type == CX_MEMPOOL_TYPE_ADVANCED) {
 provided_allocator->cl = &cx_mempool_advanced_allocator_class;
 void cxMempoolGlobalDestructor2(CxMempool *pool, cx_destructor_func2 fnc, void *data) {
 pool->destr2 = fnc;
 pool->destr2_data = data;
 }
-static void cx_mempool_free_transferred_allocator(void *al) {
+static void cx_mempool_free_transferred_allocator(void *base_al, void *al) {
-cxFreeDefault(al);
+cxFree(base_al, al);
 }
 int cxMempoolTransfer(
 CxMempool *source,
 CxMempool *dest
 ) {
 // safety checks
 if (source == dest) return 1;
 if (source->allocator->cl != dest->allocator->cl) return 1;
+if (source->base_allocator->cl != dest->base_allocator->cl) return 1;
 // ensure enough capacity in the destination pool
 if (cx_mempool_ensure_capacity(dest, dest->size + source->size)) {
 return 1; // LCOV_EXCL_LINE
 }
 dest->registered_size + source->registered_size)) {
 return 1; // LCOV_EXCL_LINE
 }
 // allocate a replacement allocator for the source pool
-CxAllocator *new_source_allocator = cxMallocDefault(sizeof(CxAllocator));
+CxAllocator *new_source_allocator =
+cxMalloc(source->base_allocator, sizeof(CxAllocator));
 if (new_source_allocator == NULL) { // LCOV_EXCL_START
 return 1;
 } // LCOV_EXCL_STOP
 new_source_allocator->cl = source->allocator->cl;
 new_source_allocator->data = source;
 sizeof(struct cx_mempool_foreign_memory_s) * source->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
+// also register the base allocator, s.t. the pool knows how to free it
 CxAllocator *transferred_allocator = (CxAllocator*) source->allocator;
 transferred_allocator->data = dest;
-cxMempoolRegister(dest, transferred_allocator,
+cxMempoolRegister2(dest, transferred_allocator,
-cx_mempool_free_transferred_allocator);
+cx_mempool_free_transferred_allocator, (void*)source->base_allocator);
 // prepare the source pool for re-use
 source->allocator = new_source_allocator;
 memset(source->data, 0, source->size * sizeof(void*));
 memset(source->registered, 0,
 int cxMempoolTransferObject(
 CxMempool *source,
 CxMempool *dest,
 const void *obj
 ) {
-// safety check
+// safety checks
 if (source == dest) return 1;
+if (source->allocator->cl != dest->allocator->cl) return 1;
+if (source->base_allocator->cl != dest->base_allocator->cl) return 1;
 // search for the object
 for (size_t i = 0; i < source->size; i++) {
 struct cx_mempool_memory_s *mem = source->data[i];
 if (mem->c == obj) {

Mercurial > hg > ucx / file comparison

comparison: src/mempool.c

src/mempool.c