Mercurial > hg > webserver / file revision

/*
 *
 */

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>

#include "mempool.h"

typedef struct {
    ucx_destructor destructor;
    char c;
} ucx_memchunk;

typedef struct {
    ucx_destructor destructor;
    void           *ptr;
} ucx_regdestr;

void ucx_mempool_shared_destr(void* ptr) {
    ucx_regdestr *rd = (ucx_regdestr*)ptr;
    rd->destructor(rd->ptr);
}

UcxMempool *ucx_mempool_new(size_t n) {
    UcxMempool *pool = (UcxMempool*)malloc(sizeof(UcxMempool));
    if (pool == NULL) return NULL;
    
    pool->data = malloc(n * sizeof(void*));
    if (pool->data == NULL) {
        free(pool);
        return NULL;
    }
    
    pool->ndata = 0;
    pool->size = n;
    return pool;
}

int ucx_mempool_chcap(UcxMempool *pool, size_t newcap) {
    void **data = realloc(pool->data, newcap*sizeof(void*));
    if (data == NULL) {
        return ENOMEM;
    } else {
        pool->data = data; 
        pool->size = newcap;
        return EXIT_SUCCESS;
    }
}

void *ucx_mempool_malloc(UcxMempool *pool, size_t n) {
    ucx_memchunk *mem = (ucx_memchunk*)malloc(sizeof(ucx_destructor) + n);
    if (mem == NULL) return NULL;

    if (pool->ndata >= pool->size) {
        ucx_mempool_chcap(pool, pool->size + 16);
     }

    mem->destructor = NULL;
    pool->data[pool->ndata] = mem;
    pool->ndata++;

    return &mem->c;
}

void *ucx_mempool_calloc(UcxMempool *pool, size_t nelem, size_t elsize) {
    void *ptr = ucx_mempool_malloc(pool, nelem*elsize);
    if(ptr == NULL) {
        return NULL;
    }
    memset(ptr, 0, nelem * elsize);
    return ptr;
}

void *ucx_mempool_realloc(UcxMempool *pool, void *ptr, size_t n) {
    char *mem = ((char*)ptr) - sizeof(ucx_destructor);
    char *newm = (char*) realloc(mem, n + sizeof(ucx_destructor));
    if (newm == NULL) return NULL;
    if (mem != newm) {
        for(int i=0;i<pool->ndata;i++) {
            if(pool->data[i] == mem) {
                pool->data[i] = newm;
                return newm + sizeof(ucx_destructor);
            }
        }
        fprintf(stderr, "FATAL: %8x not in mpool %8x\n", ptr, pool);
        exit(1);
    } else {
        return newm + sizeof(ucx_destructor);
    }
}

void ucx_mempool_free(UcxMempool *pool) {
    ucx_memchunk *chunk;
    for(int i=0;i<pool->ndata;i++) {
        chunk = (ucx_memchunk*) pool->data[i];
        if(chunk->destructor != NULL) {
            chunk->destructor(&chunk->c);
        }
        free(chunk);
    }
    free(pool->data);
    free(pool);
}

void ucx_mempool_set_destr(void *ptr, ucx_destructor func) {
    *(ucx_destructor*)((char*)ptr-sizeof(ucx_destructor)) = func;
}

void ucx_mempool_reg_destr(UcxMempool *pool, void *ptr, ucx_destructor destr) {
    ucx_regdestr *rd = (ucx_regdestr*)ucx_mempool_malloc(
            pool,
            sizeof(ucx_regdestr));
    rd->destructor = destr;
    rd->ptr = ptr;
    ucx_mempool_set_destr(rd, ucx_mempool_shared_destr);
}