int id_keeper_gen(struct id_keeper *keeper, void *data){
if(keeper->free_id)
return ((int64_t*)eina_trash_pop(&keeper->free_id)) - keeper->id_array;
else {
keeper->id_array[keeper->counter] = (int64_t)data;
//FIXME сделать расширение с помощью realloc
return keeper->counter++;
}
}
static void *
_eio_pool_malloc(Eio_Alloc_Pool *pool, size_t sz)
{
void *result = NULL;
if (pool->count)
{
EIO_MUTEX_LOCK(pool);
result = eina_trash_pop(&pool->trash);
if (result) pool->count--;
EIO_MUTEX_UNLOCK(pool);
}
if (!result) result = malloc(sz);
return result;
}
Eina_Bool
eina_rectangle_shutdown(void)
{
Eina_Rectangle *del;
while ((del = eina_trash_pop(&_eina_rectangles)))
eina_mempool_free(_eina_rectangle_mp, del);
_eina_rectangles_count = 0;
eina_mempool_del(_eina_rectangle_alloc_mp);
eina_mempool_del(_eina_rectangle_mp);
eina_log_domain_unregister(_eina_rectangle_log_dom);
_eina_rectangle_log_dom = -1;
return EINA_TRUE;
}
EAPI Eina_Rectangle *
eina_rectangle_new(int x, int y, int w, int h)
{
Eina_Rectangle *rect;
if (_eina_rectangles)
{
rect = eina_trash_pop(&_eina_rectangles);
_eina_rectangles_count--;
}
else
rect = eina_mempool_malloc(_eina_rectangle_mp, sizeof (Eina_Rectangle));
if (!rect)
return NULL;
EINA_RECTANGLE_SET(rect, x, y, w, h);
return rect;
}
static void *
_eio_pool_malloc(Eio_Alloc_Pool *pool)
{
void *result = NULL;
if (pool->count)
{
eina_lock_take(&(pool->lock));
result = eina_trash_pop(&pool->trash);
if (result) pool->count--;
eina_lock_release(&(pool->lock));
}
if (!result)
{
result = malloc(pool->mem_size);
eina_spinlock_take(&memory_pool_lock);
if (result) memory_pool_usage += pool->mem_size;
eina_spinlock_release(&memory_pool_lock);
}
return result;
}
static void *
eina_one_big_malloc(void *data, EINA_UNUSED unsigned int size)
{
One_Big *pool = data;
unsigned char *mem = NULL;
if (!eina_lock_take(&pool->mutex))
{
#ifdef EINA_HAVE_DEBUG_THREADS
assert(eina_thread_equal(pool->self, eina_thread_self()));
#endif
}
if (pool->empty)
{
#ifndef NVALGRIND
VALGRIND_MAKE_MEM_DEFINED(pool->empty, pool->item_size);
#endif
mem = eina_trash_pop(&pool->empty);
pool->usage++;
goto on_exit;
}
if (!pool->base)
{
pool->base = malloc(pool->item_size * pool->max);
if (!pool->base) goto retry_smaller;
#ifndef NVALGRIND
VALGRIND_MAKE_MEM_NOACCESS(pool->base, pool->item_size * pool->max);
#endif
}
if (pool->served < pool->max)
{
mem = pool->base + (pool->served++ *pool->item_size);
pool->usage++;
goto on_exit;
}
retry_smaller:
mem = malloc(sizeof(Eina_Inlist) + pool->offset_to_item_inlist);
if (mem)
{
Eina_Inlist *node = OVER_MEM_TO_LIST(pool, mem);
pool->over++;
/* Only need to zero list elements and not the payload here */
memset(node, 0, sizeof(Eina_Inlist));
pool->over_list = eina_inlist_append(pool->over_list, node);
}
#ifndef NVALGRIND
VALGRIND_MAKE_MEM_NOACCESS(mem, pool->item_size);
#endif
on_exit:
eina_lock_release(&pool->mutex);
#ifndef NVALGRIND
VALGRIND_MEMPOOL_ALLOC(pool, mem, pool->item_size);
#endif
return mem;
}
