static void eina_one_big_free(void *data, void *ptr) { One_Big *pool = data; if (!eina_lock_take(&pool->mutex)) { #ifdef EINA_HAVE_DEBUG_THREADS assert(eina_thread_equal(pool->self, eina_thread_self())); #endif } if ((void *)pool->base <= ptr && ptr < (void *)(pool->base + (pool->max * pool->item_size))) { eina_trash_push(&pool->empty, ptr); pool->usage--; #ifndef NVALGRIND VALGRIND_MEMPOOL_FREE(pool, ptr); #endif } else { #ifndef NDEBUG Eina_Inlist *it; #endif Eina_Inlist *il; il = OVER_MEM_TO_LIST(pool, ptr); #ifndef NDEBUG for (it = pool->over_list; it != NULL; it = it->next) if (it == il) break; assert(it != NULL); #endif pool->over_list = eina_inlist_remove(pool->over_list, il); #ifndef NVALGRIND VALGRIND_MEMPOOL_FREE(pool, ptr); #endif free(ptr); pool->over--; } eina_lock_release(&pool->mutex); }
static void eina_one_big_shutdown(void *data) { One_Big *pool = data; if (!pool) return; if (!eina_lock_take(&pool->mutex)) { #ifdef EINA_HAVE_DEBUG_THREADS assert(eina_thread_equal(pool->self, eina_thread_self())); #endif } if (pool->over > 0) { // FIXME: should we warn here? one_big mempool exceeded its alloc and now // mempool is cleaning up the mess created. be quiet for now as we were before // but edje seems to be a big offender at the moment! bad cedric! :) // WRN( // "Pool [%s] over by %i. cleaning up for you", // pool->name, pool->over); while (pool->over_list) { Eina_Inlist *il = pool->over_list; void *ptr = OVER_MEM_FROM_LIST(pool, il); pool->over_list = eina_inlist_remove(pool->over_list, il); free(ptr); pool->over--; } } if (pool->over > 0) { WRN( "Pool [%s] still over by %i\n", pool->name, pool->over); } #ifndef NVALGRIND VALGRIND_DESTROY_MEMPOOL(pool); #endif if (pool->base) free(pool->base); eina_lock_release(&pool->mutex); eina_lock_free(&pool->mutex); free(pool); }
static void * eina_one_big_init(const char *context, EINA_UNUSED const char *option, va_list args) { One_Big *pool; int item_size; size_t length; length = context ? strlen(context) + 1 : 0; pool = calloc(1, sizeof (One_Big) + length); if (!pool) return NULL; item_size = va_arg(args, int); pool->item_size = eina_mempool_alignof(item_size); pool->max = va_arg(args, int); pool->offset_to_item_inlist = pool->item_size; if (pool->offset_to_item_inlist % (int)sizeof(void *) != 0) { pool->offset_to_item_inlist = (((pool->offset_to_item_inlist / (int)sizeof(void *)) + 1) * (int)sizeof(void *)); } if (length) { pool->name = (const char *)(pool + 1); memcpy((char *)pool->name, context, length); } #ifdef EINA_HAVE_DEBUG_THREADS pool->self = eina_thread_self(); #endif eina_lock_new(&pool->mutex); #ifndef NVALGRIND VALGRIND_CREATE_MEMPOOL(pool, 0, 1); #endif return pool; }
int i, fd, freq; char buf[256], path[256]; ssize_t red; #if defined(__clockid_t_defined) static struct timespec t_last = { 0, 0 }; static Eina_Debug_Thread *prev_threads = NULL; static int prev_threads_num = 0; int j, cpu; Eina_Bool prev_threads_redo; clockid_t cid; struct timespec t, t_now; unsigned long long tim_span, tim1, tim2; #endif // set a name for this thread for system debugging eina_thread_name_set(eina_thread_self(), "Edbg-sys"); for (;;) { // wait on a mutex that will be locked for as long as this // threead is not meant to go running eina_lock_take(&_sysmon_lock); if (!_eina_debug_cpu_active) break; // if we need to reset as we just started polling system stats... if (_eina_debug_sysmon_reset) { _eina_debug_sysmon_reset = 0; // clear out all the clocks for threads #if defined(__clockid_t_defined) // reset the last clock timestamp when we checked to "now" clock_gettime(CLOCK_MONOTONIC, &t); t_last = t;
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; }