816 lines
20 KiB
C
816 lines
20 KiB
C
/* EINA - EFL data type library
|
|
* Copyright (C) 2008-2010 Cedric BAIL, Vincent Torri
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library;
|
|
* if not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
# include "config.h"
|
|
#endif
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#ifdef EINA_HAVE_DEBUG_THREADS
|
|
# include <assert.h>
|
|
#endif
|
|
|
|
#ifdef EINA_DEBUG_MALLOC
|
|
# ifdef __linux__
|
|
# include <malloc.h>
|
|
# endif
|
|
# ifdef __FreeBSD__
|
|
# include <malloc_np.h>
|
|
# endif
|
|
#endif
|
|
|
|
#include "eina_config.h"
|
|
#include "eina_inlist.h"
|
|
#include "eina_module.h"
|
|
#include "eina_mempool.h"
|
|
#include "eina_trash.h"
|
|
#include "eina_rbtree.h"
|
|
#include "eina_lock.h"
|
|
#include "eina_thread.h"
|
|
#include "eina_cpu.h"
|
|
|
|
#include "eina_private.h"
|
|
|
|
#ifndef NVALGRIND
|
|
# include <memcheck.h>
|
|
#endif
|
|
|
|
#if defined DEBUG || defined EINA_DEBUG_MALLOC
|
|
#include <assert.h>
|
|
#include "eina_log.h"
|
|
|
|
static int _eina_chained_mp_log_dom = -1;
|
|
|
|
#ifdef INF
|
|
#undef INF
|
|
#endif
|
|
#define INF(...) EINA_LOG_DOM_INFO(_eina_chained_mp_log_dom, __VA_ARGS__)
|
|
|
|
#ifdef ERR
|
|
#undef ERR
|
|
#endif
|
|
#define ERR(...) EINA_LOG_DOM_ERR(_eina_chained_mp_log_dom, __VA_ARGS__)
|
|
|
|
#endif
|
|
|
|
static int aligned_chained_pool = 0;
|
|
static int page_size = 0;
|
|
|
|
typedef struct _Chained_Pool Chained_Pool;
|
|
struct _Chained_Pool
|
|
{
|
|
EINA_INLIST;
|
|
EINA_RBTREE;
|
|
Eina_Trash *base;
|
|
unsigned int usage;
|
|
|
|
unsigned char *last;
|
|
unsigned char *limit;
|
|
};
|
|
|
|
typedef struct _Chained_Mempool Chained_Mempool;
|
|
struct _Chained_Mempool
|
|
{
|
|
Eina_Inlist *first;
|
|
Eina_Rbtree *root;
|
|
const char *name;
|
|
unsigned int item_alloc;
|
|
unsigned int pool_size;
|
|
unsigned int alloc_size;
|
|
unsigned int group_size;
|
|
unsigned int usage;
|
|
Chained_Pool* first_fill; //All allocation will happen in this chain,unless it is filled
|
|
#ifdef EINA_DEBUG_MALLOC
|
|
int minimal_size;
|
|
#endif
|
|
#ifdef EINA_HAVE_DEBUG_THREADS
|
|
Eina_Thread self;
|
|
#endif
|
|
Eina_Spinlock mutex;
|
|
};
|
|
|
|
|
|
static inline Eina_Rbtree_Direction
|
|
_eina_chained_mp_pool_cmp(const Eina_Rbtree *left, const Eina_Rbtree *right, EINA_UNUSED void *data)
|
|
{
|
|
if (left < right) return EINA_RBTREE_LEFT;
|
|
return EINA_RBTREE_RIGHT;
|
|
}
|
|
|
|
static inline int
|
|
_eina_chained_mp_pool_key_cmp(const Eina_Rbtree *node, const void *key,
|
|
EINA_UNUSED int length, EINA_UNUSED void *data)
|
|
{
|
|
const Chained_Pool *r = EINA_RBTREE_CONTAINER_GET(node, const Chained_Pool);
|
|
|
|
if (key > (void *) r->limit) return -1;
|
|
if (key < (void *) r) return 1;
|
|
return 0;
|
|
}
|
|
|
|
static inline Chained_Pool *
|
|
_eina_chained_mp_pool_new(Chained_Mempool *pool)
|
|
{
|
|
Chained_Pool *p;
|
|
unsigned char *ptr;
|
|
|
|
p = malloc(pool->alloc_size);
|
|
if (!p) return NULL;
|
|
|
|
#if defined(EINA_DEBUG_MALLOC) && defined (HAVE_MALLOC_USABLE_SIZE)
|
|
{
|
|
size_t sz;
|
|
sz = malloc_usable_size(p);
|
|
if (sz - pool->minimal_size > 0)
|
|
INF("Just allocated %0.2f%% to much memory in '%s' for one block of size %i that means %lu bytes to much.",
|
|
((float)(sz - pool->minimal_size) * 100) / (float) (pool->alloc_size),
|
|
pool->name,
|
|
pool->alloc_size,
|
|
(unsigned long) sz - pool->minimal_size);
|
|
}
|
|
#endif
|
|
|
|
ptr = (unsigned char *)(p + 1);
|
|
p->usage = 0;
|
|
p->base = NULL;
|
|
|
|
p->last = ptr;
|
|
p->limit = ptr + pool->item_alloc * pool->pool_size;
|
|
|
|
#ifndef NVALGRIND
|
|
VALGRIND_MAKE_MEM_NOACCESS(ptr, pool->alloc_size - aligned_chained_pool);
|
|
#endif
|
|
|
|
return p;
|
|
}
|
|
|
|
static inline void
|
|
_eina_chained_mp_pool_free(Chained_Pool *p)
|
|
{
|
|
free(p);
|
|
}
|
|
|
|
static int
|
|
_eina_chained_mempool_usage_cmp(const Eina_Inlist *l1, const Eina_Inlist *l2)
|
|
{
|
|
const Chained_Pool *p1;
|
|
const Chained_Pool *p2;
|
|
|
|
p1 = EINA_INLIST_CONTAINER_GET(l1, const Chained_Pool);
|
|
p2 = EINA_INLIST_CONTAINER_GET(l2, const Chained_Pool);
|
|
|
|
return p2->usage - p1->usage;
|
|
}
|
|
|
|
static void *
|
|
_eina_chained_mempool_alloc_in(Chained_Mempool *pool, Chained_Pool *p)
|
|
{
|
|
void *mem = NULL;
|
|
|
|
// Let's try to first recycle memory
|
|
if (p->base)
|
|
{
|
|
#ifndef NVALGRIND
|
|
VALGRIND_MAKE_MEM_DEFINED(p->base, pool->item_alloc);
|
|
#endif
|
|
// Request a free pointer
|
|
mem = eina_trash_pop(&p->base);
|
|
}
|
|
else if (p->last)
|
|
{
|
|
mem = p->last;
|
|
p->last += pool->item_alloc;
|
|
if (p->last >= p->limit)
|
|
p->last = NULL;
|
|
}
|
|
|
|
// move to end - it just filled up
|
|
if (!p->base && !p->last)
|
|
pool->first = eina_inlist_demote(pool->first, EINA_INLIST_GET(p));
|
|
|
|
p->usage++;
|
|
pool->usage++;
|
|
|
|
#ifndef NVALGRIND
|
|
VALGRIND_MEMPOOL_ALLOC(pool, mem, pool->item_alloc);
|
|
#endif
|
|
|
|
return mem;
|
|
}
|
|
|
|
static Eina_Bool
|
|
_eina_chained_mempool_free_in(Chained_Mempool *pool, Chained_Pool *p, void *ptr)
|
|
{
|
|
#ifdef DEBUG
|
|
void *pmem;
|
|
|
|
// pool mem base
|
|
pmem = (void *)(((unsigned char *)p) + sizeof(Chained_Pool));
|
|
|
|
// is it in pool mem?
|
|
if (ptr < pmem)
|
|
{
|
|
ERR("%p is inside the private part of %p pool from %p '%s' Chained_Mempool (could be the sign of a buffer underrun).", ptr, p, pool, pool->name);
|
|
return EINA_FALSE;
|
|
}
|
|
|
|
// is it really a pointer returned by malloc
|
|
if ((((unsigned char *)ptr) - (unsigned char *)(p + 1)) % pool->item_alloc)
|
|
{
|
|
ERR("%p is %lu bytes inside a pointer served by %p '%s' Chained_Mempool (You are freeing the wrong pointer man !).",
|
|
ptr, ((((unsigned char *)ptr) - (unsigned char *)(p + 1)) % pool->item_alloc), pool, pool->name);
|
|
return EINA_FALSE;
|
|
}
|
|
#endif
|
|
|
|
// freed node points to prev free node
|
|
eina_trash_push(&p->base, ptr);
|
|
// next free node is now the one we freed
|
|
p->usage--;
|
|
pool->usage--;
|
|
if (p->usage == 0)
|
|
{
|
|
// free bucket
|
|
pool->first = eina_inlist_remove(pool->first, EINA_INLIST_GET(p));
|
|
pool->root = eina_rbtree_inline_remove(pool->root, EINA_RBTREE_GET(p),
|
|
_eina_chained_mp_pool_cmp, NULL);
|
|
if (pool->first_fill == p)
|
|
{
|
|
pool->first_fill = NULL;
|
|
pool->first_fill = EINA_INLIST_CONTAINER_GET(pool->first, Chained_Pool);
|
|
}
|
|
_eina_chained_mp_pool_free(p);
|
|
|
|
return EINA_TRUE;
|
|
}
|
|
else
|
|
{
|
|
// move to front
|
|
pool->first = eina_inlist_promote(pool->first, EINA_INLIST_GET(p));
|
|
}
|
|
|
|
return EINA_FALSE;
|
|
}
|
|
|
|
static void *
|
|
eina_chained_mempool_malloc(void *data, EINA_UNUSED unsigned int size)
|
|
{
|
|
Chained_Mempool *pool = data;
|
|
Chained_Pool *p = NULL;
|
|
void *mem = NULL;
|
|
|
|
if (!eina_spinlock_take(&pool->mutex))
|
|
{
|
|
#ifdef EINA_HAVE_DEBUG_THREADS
|
|
assert(eina_thread_equal(pool->self, eina_thread_self()));
|
|
#endif
|
|
}
|
|
|
|
//we have some free space in first fill chain
|
|
if (pool->first_fill) p = pool->first_fill;
|
|
|
|
// base is not NULL - has a free slot
|
|
if (p && !p->base && !p->last)
|
|
{
|
|
//Current pointed chain is filled , so point it to first one
|
|
pool->first_fill = EINA_INLIST_CONTAINER_GET(pool->first, Chained_Pool);
|
|
//Either first one has some free space or every chain is filled
|
|
if (pool->first_fill && !pool->first_fill->base && !pool->first_fill->last)
|
|
{
|
|
p = NULL;
|
|
pool->first_fill = NULL;
|
|
}
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
if (p == NULL)
|
|
EINA_INLIST_FOREACH(pool->first, p)
|
|
assert(!p->base && !p->last);
|
|
#endif
|
|
|
|
// we have reached the end of the list - no free pools
|
|
if (!p)
|
|
{
|
|
//new chain created ,point it to be the first_fill chain
|
|
pool->first_fill = _eina_chained_mp_pool_new(pool);
|
|
if (!pool->first_fill)
|
|
{
|
|
eina_spinlock_release(&pool->mutex);
|
|
return NULL;
|
|
}
|
|
|
|
pool->first = eina_inlist_prepend(pool->first, EINA_INLIST_GET(pool->first_fill));
|
|
pool->root = eina_rbtree_inline_insert(pool->root, EINA_RBTREE_GET(pool->first_fill),
|
|
_eina_chained_mp_pool_cmp, NULL);
|
|
}
|
|
|
|
if (pool->first_fill)
|
|
mem = _eina_chained_mempool_alloc_in(pool, pool->first_fill);
|
|
|
|
eina_spinlock_release(&pool->mutex);
|
|
return mem;
|
|
}
|
|
|
|
static void
|
|
eina_chained_mempool_free(void *data, void *ptr)
|
|
{
|
|
Chained_Mempool *pool = data;
|
|
Eina_Rbtree *r;
|
|
Chained_Pool *p;
|
|
|
|
// look 4 pool
|
|
if (!eina_spinlock_take(&pool->mutex))
|
|
{
|
|
#ifdef EINA_HAVE_DEBUG_THREADS
|
|
assert(eina_thread_equal(pool->self, eina_thread_self()));
|
|
#endif
|
|
}
|
|
|
|
// searching for the right mempool
|
|
r = eina_rbtree_inline_lookup(pool->root, ptr, 0, _eina_chained_mp_pool_key_cmp, NULL);
|
|
|
|
// related mempool not found
|
|
if (!r)
|
|
{
|
|
#ifdef DEBUG
|
|
ERR("%p is not the property of %p Chained_Mempool", ptr, pool);
|
|
#endif
|
|
goto on_error;
|
|
}
|
|
|
|
p = EINA_RBTREE_CONTAINER_GET(r, Chained_Pool);
|
|
|
|
_eina_chained_mempool_free_in(pool, p, ptr);
|
|
|
|
on_error:
|
|
#ifndef NVALGRIND
|
|
if (ptr)
|
|
{
|
|
VALGRIND_MEMPOOL_FREE(pool, ptr);
|
|
}
|
|
#endif
|
|
|
|
eina_spinlock_release(&pool->mutex);
|
|
return;
|
|
}
|
|
|
|
static void *
|
|
eina_chained_mempool_malloc_near(void *data,
|
|
void *after, void *before,
|
|
unsigned int size EINA_UNUSED)
|
|
{
|
|
Chained_Mempool *pool = data;
|
|
Chained_Pool *p = NULL;
|
|
void *mem = NULL;
|
|
|
|
if (!eina_spinlock_take(&pool->mutex))
|
|
{
|
|
#ifdef EINA_HAVE_DEBUG_THREADS
|
|
assert(eina_thread_equal(pool->self, eina_thread_self()));
|
|
#endif
|
|
}
|
|
|
|
if (after)
|
|
{
|
|
Eina_Rbtree *r = eina_rbtree_inline_lookup(pool->root, after,
|
|
0, _eina_chained_mp_pool_key_cmp, NULL);
|
|
|
|
if (r)
|
|
{
|
|
p = EINA_RBTREE_CONTAINER_GET(r, Chained_Pool);
|
|
|
|
if (!p->base && !p->last)
|
|
p = NULL;
|
|
}
|
|
}
|
|
|
|
if (before && p == NULL)
|
|
{
|
|
Eina_Rbtree *r = eina_rbtree_inline_lookup(pool->root, before,
|
|
0, _eina_chained_mp_pool_key_cmp, NULL);
|
|
if (r)
|
|
{
|
|
p = EINA_RBTREE_CONTAINER_GET(r, Chained_Pool);
|
|
if (!p->base && !p->last)
|
|
p = NULL;
|
|
}
|
|
}
|
|
|
|
if (p) mem = _eina_chained_mempool_alloc_in(pool, p);
|
|
|
|
eina_spinlock_release(&pool->mutex);
|
|
|
|
if (!mem) return eina_chained_mempool_malloc(pool, size);
|
|
return mem;
|
|
}
|
|
|
|
static Eina_Bool
|
|
eina_chained_mempool_from(void *data, void *ptr)
|
|
{
|
|
Chained_Mempool *pool = data;
|
|
Eina_Rbtree *r;
|
|
Chained_Pool *p;
|
|
Eina_Trash *t;
|
|
#ifndef NVALGRIND
|
|
Eina_Trash *last = NULL;
|
|
#endif
|
|
void *pmem;
|
|
Eina_Bool ret = EINA_FALSE;
|
|
|
|
// look 4 pool
|
|
if (!eina_spinlock_take(&pool->mutex))
|
|
{
|
|
#ifdef EINA_HAVE_DEBUG_THREADS
|
|
assert(eina_thread_equal(pool->self, eina_thread_self()));
|
|
#endif
|
|
}
|
|
|
|
// searching for the right mempool
|
|
r = eina_rbtree_inline_lookup(pool->root, ptr, 0, _eina_chained_mp_pool_key_cmp, NULL);
|
|
|
|
// related mempool not found
|
|
if (!r) goto end;
|
|
|
|
p = EINA_RBTREE_CONTAINER_GET(r, Chained_Pool);
|
|
|
|
// pool mem base
|
|
pmem = (void *)(((unsigned char *)p) + sizeof(Chained_Pool));
|
|
|
|
// is it in pool mem?
|
|
if (ptr < pmem)
|
|
{
|
|
#ifdef DEBUG
|
|
ERR("%p is inside the private part of %p pool from %p '%s' Chained_Mempool (could be the sign of a buffer underrun).", ptr, p, pool, pool->name);
|
|
#endif
|
|
goto end;
|
|
}
|
|
|
|
// is the pointer in the allocated zone of the mempool
|
|
if (p->last != NULL && ((unsigned char *)ptr >= p->last))
|
|
{
|
|
#ifdef DEBUG
|
|
ERR("%p has not been allocated yet from %p pool of %p '%s' Chained_Mempool.", ptr, p, pool, pool->name);
|
|
#endif
|
|
goto end;
|
|
}
|
|
|
|
// is it really a pointer returned by malloc
|
|
if ((((unsigned char *)ptr) - (unsigned char *)(p + 1)) % pool->item_alloc)
|
|
{
|
|
#ifdef DEBUG
|
|
ERR("%p is %lu bytes inside a pointer served by %p '%s' Chained_Mempool (You are freeing the wrong pointer man !).",
|
|
ptr, ((((unsigned char *)ptr) - (unsigned char *)(p + 1)) % pool->item_alloc), pool, pool->name);
|
|
#endif
|
|
goto end;
|
|
}
|
|
|
|
// Check if the pointer was freed
|
|
for (t = p->base; t != NULL; t = t->next)
|
|
{
|
|
#ifndef NVALGRIND
|
|
VALGRIND_MAKE_MEM_DEFINED(t, pool->item_alloc);
|
|
if (last) VALGRIND_MAKE_MEM_NOACCESS(last, pool->item_alloc);
|
|
last = t;
|
|
#endif
|
|
|
|
if (t == ptr) goto end;
|
|
}
|
|
#ifndef NVALGRIND
|
|
if (last) VALGRIND_MAKE_MEM_NOACCESS(last, pool->item_alloc);
|
|
#endif
|
|
|
|
// Seems like we have a valid pointer actually
|
|
ret = EINA_TRUE;
|
|
|
|
end:
|
|
eina_spinlock_release(&pool->mutex);
|
|
return ret;
|
|
}
|
|
|
|
typedef struct _Eina_Iterator_Chained_Mempool Eina_Iterator_Chained_Mempool;
|
|
struct _Eina_Iterator_Chained_Mempool
|
|
{
|
|
Eina_Iterator iterator;
|
|
|
|
Eina_Iterator *walker;
|
|
Chained_Pool *current;
|
|
Chained_Mempool *pool;
|
|
|
|
unsigned int offset;
|
|
};
|
|
|
|
static Eina_Bool
|
|
eina_mempool_iterator_next(Eina_Iterator_Chained_Mempool *it, void **data)
|
|
{
|
|
if (!it->current)
|
|
{
|
|
if (!eina_iterator_next(it->walker, (void**) &it->current))
|
|
return EINA_FALSE;
|
|
if (!it->current) return EINA_FALSE;
|
|
}
|
|
|
|
retry:
|
|
if (it->offset < it->pool->group_size)
|
|
{
|
|
unsigned char *ptr = (unsigned char *) (it->current + 1);
|
|
|
|
ptr += it->offset;
|
|
it->offset += it->pool->item_alloc;
|
|
|
|
if (!eina_chained_mempool_from(it->pool, ptr)) goto retry;
|
|
|
|
if (data) *data = (void *) ptr;
|
|
return EINA_TRUE;
|
|
}
|
|
|
|
if (!eina_iterator_next(it->walker, (void**) &it->current))
|
|
return EINA_FALSE;
|
|
|
|
it->offset = 0;
|
|
goto retry;
|
|
}
|
|
|
|
static Chained_Mempool *
|
|
eina_mempool_iterator_get_container(Eina_Iterator_Chained_Mempool *it)
|
|
{
|
|
return it->pool;
|
|
}
|
|
|
|
static void
|
|
eina_mempool_iterator_free(Eina_Iterator_Chained_Mempool *it)
|
|
{
|
|
eina_iterator_free(it->walker);
|
|
free(it);
|
|
}
|
|
|
|
static Eina_Iterator *
|
|
eina_chained_mempool_iterator_new(void *data)
|
|
{
|
|
Eina_Iterator_Chained_Mempool *it;
|
|
Chained_Mempool *pool = data;
|
|
|
|
it = calloc(1, sizeof (Eina_Iterator_Chained_Mempool));
|
|
if (!it) return NULL;
|
|
|
|
it->walker = eina_inlist_iterator_new(pool->first);
|
|
it->pool = pool;
|
|
|
|
it->iterator.version = EINA_ITERATOR_VERSION;
|
|
it->iterator.next = FUNC_ITERATOR_NEXT(eina_mempool_iterator_next);
|
|
it->iterator.get_container = FUNC_ITERATOR_GET_CONTAINER(
|
|
eina_mempool_iterator_get_container);
|
|
it->iterator.free = FUNC_ITERATOR_FREE(eina_mempool_iterator_free);
|
|
|
|
EINA_MAGIC_SET(&it->iterator, EINA_MAGIC_ITERATOR);
|
|
|
|
return &it->iterator;
|
|
}
|
|
|
|
static void
|
|
eina_chained_mempool_repack(void *data,
|
|
Eina_Mempool_Repack_Cb cb,
|
|
void *cb_data)
|
|
{
|
|
Chained_Mempool *pool = data;
|
|
Chained_Pool *start;
|
|
Chained_Pool *tail;
|
|
|
|
/* FIXME: Improvement - per Chained_Pool lock */
|
|
if (!eina_spinlock_take(&pool->mutex))
|
|
{
|
|
#ifdef EINA_HAVE_DEBUG_THREADS
|
|
assert(eina_thread_equal(pool->self, eina_thread_self()));
|
|
#endif
|
|
}
|
|
|
|
pool->first = eina_inlist_sort(pool->first,
|
|
(Eina_Compare_Cb) _eina_chained_mempool_usage_cmp);
|
|
|
|
/*
|
|
idea : remove the almost empty pool at the beginning of the list by
|
|
moving data in the last pool with empty slot
|
|
*/
|
|
tail = EINA_INLIST_CONTAINER_GET(pool->first->last, Chained_Pool);
|
|
while (tail && tail->usage == pool->pool_size)
|
|
tail = EINA_INLIST_CONTAINER_GET((EINA_INLIST_GET(tail)->prev), Chained_Pool);
|
|
|
|
while (tail)
|
|
{
|
|
unsigned char *src;
|
|
unsigned char *dst;
|
|
|
|
start = EINA_INLIST_CONTAINER_GET(pool->first, Chained_Pool);
|
|
|
|
if (start == tail || start->usage == pool->pool_size)
|
|
break;
|
|
|
|
for (src = start->limit - pool->group_size;
|
|
src != start->limit;
|
|
src += pool->item_alloc)
|
|
{
|
|
Eina_Bool is_free = EINA_FALSE;
|
|
Eina_Bool is_dead;
|
|
|
|
/* Do we have something inside that piece of memory */
|
|
if (start->last != NULL && src >= start->last)
|
|
{
|
|
is_free = EINA_TRUE;
|
|
}
|
|
else
|
|
{
|
|
Eina_Trash *over = start->base;
|
|
|
|
while (over != NULL && (unsigned char*) over != src)
|
|
over = over->next;
|
|
|
|
if (over == NULL)
|
|
is_free = EINA_TRUE;
|
|
}
|
|
|
|
if (is_free) continue ;
|
|
|
|
/* get a new memory pointer from the latest most occuped pool */
|
|
dst = _eina_chained_mempool_alloc_in(pool, tail);
|
|
/* move data from one to another */
|
|
memcpy(dst, src, pool->item_alloc);
|
|
/* notify caller */
|
|
cb(dst, src, cb_data);
|
|
/* destroy old pointer */
|
|
is_dead = _eina_chained_mempool_free_in(pool, start, src);
|
|
|
|
/* search last tail with empty slot */
|
|
while (tail && tail->usage == pool->pool_size)
|
|
tail = EINA_INLIST_CONTAINER_GET((EINA_INLIST_GET(tail)->prev),
|
|
Chained_Pool);
|
|
/* no more free space */
|
|
if (!tail || tail == start) break;
|
|
if (is_dead) break;
|
|
}
|
|
}
|
|
|
|
/* FIXME: improvement - reorder pool so that the most used one get in front */
|
|
eina_spinlock_release(&pool->mutex);
|
|
}
|
|
|
|
static void *
|
|
eina_chained_mempool_realloc(EINA_UNUSED void *data,
|
|
EINA_UNUSED void *element,
|
|
EINA_UNUSED unsigned int size)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
static void *
|
|
eina_chained_mempool_init(const char *context,
|
|
EINA_UNUSED const char *option,
|
|
va_list args)
|
|
{
|
|
Chained_Mempool *mp;
|
|
int item_size;
|
|
size_t length;
|
|
|
|
length = context ? strlen(context) + 1 : 0;
|
|
|
|
mp = calloc(1, sizeof(Chained_Mempool) + length);
|
|
if (!mp)
|
|
return NULL;
|
|
|
|
item_size = va_arg(args, int);
|
|
mp->pool_size = va_arg(args, int);
|
|
|
|
if (length)
|
|
{
|
|
mp->name = (const char *)(mp + 1);
|
|
memcpy((char *)mp->name, context, length);
|
|
}
|
|
|
|
mp->item_alloc = MAX(eina_mempool_alignof(item_size), sizeof(void *));
|
|
|
|
mp->pool_size = (((((mp->item_alloc * mp->pool_size + aligned_chained_pool) / page_size)
|
|
+ 1) * page_size)
|
|
- aligned_chained_pool) / mp->item_alloc;
|
|
|
|
#ifdef EINA_DEBUG_MALLOC
|
|
mp->minimal_size = item_size * mp->pool_size + sizeof(Chained_Pool);
|
|
#endif
|
|
|
|
mp->group_size = mp->item_alloc * mp->pool_size;
|
|
mp->alloc_size = mp->group_size + aligned_chained_pool;
|
|
|
|
#ifndef NVALGRIND
|
|
VALGRIND_CREATE_MEMPOOL(mp, 0, 1);
|
|
#endif
|
|
|
|
#ifdef EINA_HAVE_DEBUG_THREADS
|
|
mp->self = eina_thread_self();
|
|
#endif
|
|
mp->first_fill = NULL;
|
|
eina_spinlock_new(&mp->mutex);
|
|
|
|
return mp;
|
|
}
|
|
|
|
static void
|
|
eina_chained_mempool_shutdown(void *data)
|
|
{
|
|
Chained_Mempool *mp;
|
|
|
|
mp = (Chained_Mempool *)data;
|
|
|
|
while (mp->first)
|
|
{
|
|
Chained_Pool *p = (Chained_Pool *)mp->first;
|
|
|
|
#ifdef DEBUG
|
|
if (p->usage > 0)
|
|
INF("Bad news we are destroying a non-empty mempool [%s]\n",
|
|
mp->name);
|
|
|
|
#endif
|
|
|
|
mp->first = eina_inlist_remove(mp->first, mp->first);
|
|
mp->root = eina_rbtree_inline_remove(mp->root, EINA_RBTREE_GET(p),
|
|
_eina_chained_mp_pool_cmp, NULL);
|
|
_eina_chained_mp_pool_free(p);
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
if (mp->root)
|
|
ERR("Bad news, list of pool and rbtree are out of sync for %p !", mp);
|
|
#endif
|
|
|
|
#ifndef NVALGRIND
|
|
VALGRIND_DESTROY_MEMPOOL(mp);
|
|
#endif
|
|
|
|
eina_spinlock_free(&mp->mutex);
|
|
|
|
free(mp);
|
|
}
|
|
|
|
static Eina_Mempool_Backend _eina_chained_mp_backend = {
|
|
"chained_mempool",
|
|
&eina_chained_mempool_init,
|
|
&eina_chained_mempool_free,
|
|
&eina_chained_mempool_malloc,
|
|
&eina_chained_mempool_realloc,
|
|
NULL,
|
|
NULL,
|
|
&eina_chained_mempool_shutdown,
|
|
&eina_chained_mempool_repack,
|
|
&eina_chained_mempool_from,
|
|
&eina_chained_mempool_iterator_new,
|
|
&eina_chained_mempool_malloc_near
|
|
};
|
|
|
|
Eina_Bool chained_init(void)
|
|
{
|
|
#if defined DEBUG || defined EINA_DEBUG_MALLOC
|
|
_eina_chained_mp_log_dom = eina_log_domain_register("eina_mempool",
|
|
EINA_LOG_COLOR_DEFAULT);
|
|
if (_eina_chained_mp_log_dom < 0)
|
|
{
|
|
EINA_LOG_ERR("Could not register log domain: eina_mempool");
|
|
return EINA_FALSE;
|
|
}
|
|
|
|
#endif
|
|
aligned_chained_pool = eina_mempool_alignof(sizeof(Chained_Pool));
|
|
page_size = eina_cpu_page_size();
|
|
|
|
return eina_mempool_register(&_eina_chained_mp_backend);
|
|
}
|
|
|
|
void chained_shutdown(void)
|
|
{
|
|
eina_mempool_unregister(&_eina_chained_mp_backend);
|
|
#if defined DEBUG || defined EINA_DEBUG_MALLOC
|
|
eina_log_domain_unregister(_eina_chained_mp_log_dom);
|
|
_eina_chained_mp_log_dom = -1;
|
|
#endif
|
|
}
|
|
|
|
#ifndef EINA_STATIC_BUILD_CHAINED_POOL
|
|
|
|
EINA_MODULE_INIT(chained_init);
|
|
EINA_MODULE_SHUTDOWN(chained_shutdown);
|
|
|
|
#endif /* ! EINA_STATIC_BUILD_CHAINED_POOL */
|