From bd1337f4cdb57c7838bea704ccbed9f1e5f631c9 Mon Sep 17 00:00:00 2001 From: Cedric BAIL Date: Sun, 24 Apr 2011 16:49:48 +0000 Subject: [PATCH] eina: fix api to actually work as expected. SVN revision: 58871 --- .../eina/src/include/eina_inline_lock_posix.x | 16 +-- .../eina/src/include/eina_inline_lock_win32.x | 16 +-- .../eina/src/include/eina_inline_lock_wince.x | 16 +-- legacy/eina/src/include/eina_lock.h | 8 +- legacy/eina/src/lib/eina_main.c | 14 +-- legacy/eina/src/lib/eina_share_common.c | 73 +++++------- legacy/eina/src/lib/eina_stringshare.c | 41 ++----- .../mp/chained_pool/eina_chained_mempool.c | 16 +-- .../src/modules/mp/one_big/eina_one_big.c | 111 ++++-------------- 9 files changed, 105 insertions(+), 206 deletions(-) diff --git a/legacy/eina/src/include/eina_inline_lock_posix.x b/legacy/eina/src/include/eina_inline_lock_posix.x index c746d91c1d..72d3ab3a31 100644 --- a/legacy/eina/src/include/eina_inline_lock_posix.x +++ b/legacy/eina/src/include/eina_inline_lock_posix.x @@ -32,32 +32,32 @@ eina_lock_new(Eina_Lock *mutex) } static inline void -eina_lock_free(Eina_Lock mutex) +eina_lock_free(Eina_Lock *mutex) { - pthread_mutex_destroy(&mutex); + pthread_mutex_destroy(mutex); } static inline Eina_Bool -eina_lock_take(Eina_Lock mutex) +eina_lock_take(Eina_Lock *mutex) { if (_threads_activated) - return (pthread_mutex_lock(&mutex) == 0) ? EINA_TRUE : EINA_FALSE; + return (pthread_mutex_lock(mutex) == 0) ? EINA_TRUE : EINA_FALSE; return EINA_FALSE; } static inline Eina_Bool -eina_lock_take_try(Eina_Lock mutex) +eina_lock_take_try(Eina_Lock *mutex) { if (_threads_activated) - return (pthread_mutex_trylock(&mutex) == 0) ? EINA_TRUE : EINA_FALSE; + return (pthread_mutex_trylock(mutex) == 0) ? EINA_TRUE : EINA_FALSE; return EINA_FALSE; } static inline Eina_Bool -eina_lock_release(Eina_Lock mutex) +eina_lock_release(Eina_Lock *mutex) { if (_threads_activated) - return (pthread_mutex_unlock(&mutex) == 0) ? EINA_TRUE : EINA_FALSE; + return (pthread_mutex_unlock(mutex) == 0) ? EINA_TRUE : EINA_FALSE; return EINA_FALSE; } diff --git a/legacy/eina/src/include/eina_inline_lock_win32.x b/legacy/eina/src/include/eina_inline_lock_win32.x index 26a32aa775..4d6786187e 100644 --- a/legacy/eina/src/include/eina_inline_lock_win32.x +++ b/legacy/eina/src/include/eina_inline_lock_win32.x @@ -34,35 +34,35 @@ eina_lock_new(Eina_Lock *mutex) } static inline void -eina_lock_free(Eina_Lock mutex) +eina_lock_free(Eina_Lock *mutex) { - DeleteCriticalSection(&mutex); + DeleteCriticalSection(mutex); } static inline Eina_Bool -eina_lock_take(Eina_Lock mutex) +eina_lock_take(Eina_Lock *mutex) { if (!_threads_activated) return EINA_FALSE; - EnterCriticalSection(&mutex); + EnterCriticalSection(mutex); return EINA_TRUE; } static inline Eina_Bool -eina_lock_take_try(Eina_Lock mutex) +eina_lock_take_try(Eina_Lock *mutex) { if (!_threads_activated) return EINA_FALSE; - return TryEnterCriticalSection(&mutex) == 0 ? EINA_FALSE : EINA_TRUE; + return TryEnterCriticalSection(mutex) == 0 ? EINA_FALSE : EINA_TRUE; } static inline Eina_Bool -eina_lock_release(Eina_Lock mutex) +eina_lock_release(Eina_Lock *mutex) { if (!_threads_activated) return EINA_FALSE; - LeaveCriticalSection(&mutex); + LeaveCriticalSection(mutex); return EINA_TRUE; } diff --git a/legacy/eina/src/include/eina_inline_lock_wince.x b/legacy/eina/src/include/eina_inline_lock_wince.x index 8be980de9a..de21dea939 100644 --- a/legacy/eina/src/include/eina_inline_lock_wince.x +++ b/legacy/eina/src/include/eina_inline_lock_wince.x @@ -36,19 +36,19 @@ eina_lock_new(Eina_Lock *mutex) } static inline void -eina_lock_free(Eina_Lock mutex) +eina_lock_free(Eina_Lock *mutex) { - CloseHandle(mutex); + CloseHandle(*mutex); } static inline Eina_Bool -eina_lock_take(Eina_Lock mutex) +eina_lock_take(Eina_Lock *mutex) { DWORD res; if (!_threads_activated) return EINA_FALSE; - res = WaitForSingleObject(mutex, INFINITE); + res = WaitForSingleObject(*mutex, INFINITE); if ((res == WAIT_ABANDONED) || (res == WAIT_FAILED)) return EINA_FALSE; @@ -56,17 +56,17 @@ eina_lock_take(Eina_Lock mutex) } static inline Eina_Bool -eina_lock_take_try(Eina_Lock mutex) +eina_lock_take_try(Eina_Lock *mutex) { - return eina_lock_take(mutex); + return eina_lock_take(*mutex); } static inline Eina_Bool -eina_lock_release(Eina_Lock mutex) +eina_lock_release(Eina_Lock *mutex) { if (!_threads_activated) return EINA_FALSE; - return ReleaseMutex(mutex); + return ReleaseMutex(*mutex); } diff --git a/legacy/eina/src/include/eina_lock.h b/legacy/eina/src/include/eina_lock.h index 90bbf63d17..b6e35a8809 100644 --- a/legacy/eina/src/include/eina_lock.h +++ b/legacy/eina/src/include/eina_lock.h @@ -46,10 +46,10 @@ #endif static inline Eina_Bool eina_lock_new(Eina_Lock *mutex); -static inline void eina_lock_free(Eina_Lock mutex); -static inline Eina_Bool eina_lock_take(Eina_Lock mutex); -static inline Eina_Bool eina_lock_take_try(Eina_Lock mutex); -static inline Eina_Bool eina_lock_release(Eina_Lock mutex); +static inline void eina_lock_free(Eina_Lock *mutex); +static inline Eina_Bool eina_lock_take(Eina_Lock *mutex); +static inline Eina_Bool eina_lock_take_try(Eina_Lock *mutex); +static inline Eina_Bool eina_lock_release(Eina_Lock *mutex); /** * @} diff --git a/legacy/eina/src/lib/eina_main.c b/legacy/eina/src/lib/eina_main.c index f439326312..101dbb2347 100644 --- a/legacy/eina/src/lib/eina_main.c +++ b/legacy/eina/src/lib/eina_main.c @@ -226,7 +226,7 @@ eina_shutdown(void) { _eina_shutdown_from_desc(_eina_desc_setup + _eina_desc_setup_len); - eina_lock_free(_mutex); + eina_lock_free(&_mutex); } return _eina_main_count; @@ -240,13 +240,13 @@ eina_threads_init(void) int ret; - eina_lock_take(_mutex); + eina_lock_take(&_mutex); ++_eina_main_thread_count; ret = _eina_main_thread_count; if(_eina_main_thread_count > 1) { - eina_lock_release(_mutex); + eina_lock_release(&_mutex); return ret; } @@ -254,7 +254,7 @@ eina_threads_init(void) eina_log_threads_init(); _threads_activated = EINA_TRUE; - eina_lock_release(_mutex); + eina_lock_release(&_mutex); return ret; #else @@ -268,18 +268,18 @@ eina_threads_shutdown(void) #ifdef EFL_HAVE_THREADS int ret; - eina_lock_take(_mutex); + eina_lock_take(&_mutex); ret = --_eina_main_thread_count; if(_eina_main_thread_count > 0) { - eina_lock_release(_mutex); + eina_lock_release(&_mutex); return ret; } eina_share_common_threads_shutdown(); eina_log_threads_shutdown(); - eina_lock_release(_mutex); + eina_lock_release(&_mutex); _threads_activated = EINA_FALSE; diff --git a/legacy/eina/src/lib/eina_share_common.c b/legacy/eina/src/lib/eina_share_common.c index 86fb377b9d..8fefbebd1c 100644 --- a/legacy/eina/src/lib/eina_share_common.c +++ b/legacy/eina/src/lib/eina_share_common.c @@ -77,6 +77,7 @@ #include "eina_rbtree.h" #include "eina_error.h" #include "eina_log.h" +#include "eina_lock.h" /* undefs EINA_ARG_NONULL() so NULL checks are not compiled out! */ #include "eina_safety_checks.h" @@ -169,27 +170,9 @@ struct _Eina_Share_Common_Head Eina_Share_Common_Node builtin_node; }; -#ifdef EFL_HAVE_THREADS Eina_Bool _share_common_threads_activated = EINA_FALSE; -# ifdef EFL_HAVE_POSIX_THREADS -static pthread_mutex_t _mutex_big = PTHREAD_MUTEX_INITIALIZER; -# define SHARE_COMMON_LOCK_BIG() if(_share_common_threads_activated) \ - pthread_mutex_lock(&_mutex_big) -# define SHARE_COMMON_UNLOCK_BIG() if(_share_common_threads_activated) \ - pthread_mutex_unlock(&_mutex_big) -# else /* EFL_HAVE_WIN32_THREADS */ -static HANDLE _mutex_big = NULL; -# define SHARE_COMMON_LOCK_BIG() if(_share_common_threads_activated) \ - WaitForSingleObject(_mutex_big, INFINITE) -# define SHARE_COMMON_UNLOCK_BIG() if(_share_common_threads_activated) \ - ReleaseMutex(_mutex_big) - -# endif /* EFL_HAVE_WIN32_THREADS */ -#else /* EFL_HAVE_THREADS */ -# define SHARE_COMMON_LOCK_BIG() do {} while (0) -# define SHARE_COMMON_UNLOCK_BIG() do {} while (0) -#endif +static Eina_Lock _mutex_big; #ifdef EINA_SHARE_COMMON_USAGE struct _Eina_Share_Common_Population @@ -269,7 +252,7 @@ _eina_share_common_population_stats(Eina_Share *share) void eina_share_common_population_add(Eina_Share *share, int slen) { - SHARE_COMMON_LOCK_BIG(); + eina_lock_take(&_mutex_big); share->population.count++; if (share->population.count > share->population.max) @@ -284,19 +267,19 @@ eina_share_common_population_add(Eina_Share *share, int slen) share->population_group[slen].count; } - SHARE_COMMON_UNLOCK_BIG(); + eina_lock_release(&_mutex_big); } void eina_share_common_population_del(Eina_Share *share, int slen) { - SHARE_COMMON_LOCK_BIG(); + eina_lock_take(&_mutex_big); share->population.count--; if (slen < 4) share->population_group[slen].count--; - SHARE_COMMON_UNLOCK_BIG(); + eina_lock_release(&_mutex_big); } static void @@ -571,7 +554,7 @@ eina_iterator_array_check(const Eina_Rbtree *rbtree __UNUSED__, { Eina_Share_Common_Node *node; - SHARE_COMMON_LOCK_BIG(); + eina_lock_take(&_mutex_big); fdata->used += sizeof(Eina_Share_Common_Head); for (node = head->head; node; node = node->next) @@ -585,7 +568,7 @@ eina_iterator_array_check(const Eina_Rbtree *rbtree __UNUSED__, fdata->unique++; } - SHARE_COMMON_UNLOCK_BIG(); + eina_lock_release(&_mutex_big); return EINA_TRUE; } @@ -652,6 +635,8 @@ eina_share_common_init(Eina_Share **_share, EINA_MAGIC_SET(share->share, EINA_MAGIC_SHARE); _eina_share_common_population_init(share); + + eina_lock_new(&_mutex_big); return EINA_TRUE; } @@ -672,7 +657,7 @@ eina_share_common_shutdown(Eina_Share **_share) unsigned int i; Eina_Share *share = *_share; - SHARE_COMMON_LOCK_BIG(); + eina_lock_take(&_mutex_big); _eina_share_common_population_stats(share); @@ -694,7 +679,9 @@ eina_share_common_shutdown(Eina_Share **_share) _eina_share_common_log_dom = -1; } - SHARE_COMMON_UNLOCK_BIG(); + eina_lock_release(&_mutex_big); + + eina_lock_free(&_mutex_big); free(*_share); *_share = NULL; @@ -765,7 +752,7 @@ eina_share_common_add_length(Eina_Share *share, hash_num = hash & 0xFF; hash = (hash >> 8) & EINA_SHARE_COMMON_MASK; - SHARE_COMMON_LOCK_BIG(); + eina_lock_take(&_mutex_big); p_bucket = share->share->buckets + hash_num; ed = _eina_share_common_find_hash(*p_bucket, hash); @@ -777,27 +764,27 @@ eina_share_common_add_length(Eina_Share *share, str, slen, null_size); - SHARE_COMMON_UNLOCK_BIG(); + eina_lock_release(&_mutex_big); return s; } - EINA_MAGIC_CHECK_SHARE_COMMON_HEAD(ed, SHARE_COMMON_UNLOCK_BIG(), NULL); + EINA_MAGIC_CHECK_SHARE_COMMON_HEAD(ed, eina_lock_release(&_mutex_big), NULL); el = _eina_share_common_head_find(ed, str, slen); if (el) { EINA_MAGIC_CHECK_SHARE_COMMON_NODE(el, share->node_magic, - SHARE_COMMON_UNLOCK_BIG()); + eina_lock_release(&_mutex_big)); el->references++; - SHARE_COMMON_UNLOCK_BIG(); + eina_lock_release(&_mutex_big); return el->str; } el = _eina_share_common_node_alloc(slen, null_size); if (!el) { - SHARE_COMMON_UNLOCK_BIG(); + eina_lock_release(&_mutex_big); return NULL; } @@ -806,7 +793,7 @@ eina_share_common_add_length(Eina_Share *share, ed->head = el; _eina_share_common_population_head_add(share, ed); - SHARE_COMMON_UNLOCK_BIG(); + eina_lock_release(&_mutex_big); return el->str; } @@ -819,13 +806,13 @@ eina_share_common_ref(Eina_Share *share, const char *str) if (!str) return NULL; - SHARE_COMMON_LOCK_BIG(); + eina_lock_take(&_mutex_big); node = _eina_share_common_node_from_str(str, share->node_magic); if (!node) return str; node->references++; DBG("str=%p refs=%u", str, node->references); - SHARE_COMMON_UNLOCK_BIG(); + eina_lock_release(&_mutex_big); eina_share_common_population_add(share, node->length); @@ -845,7 +832,7 @@ eina_share_common_del(Eina_Share *share, const char *str) if (!str) return; - SHARE_COMMON_LOCK_BIG(); + eina_lock_take(&_mutex_big); node = _eina_share_common_node_from_str(str, share->node_magic); if (!node) @@ -857,7 +844,7 @@ eina_share_common_del(Eina_Share *share, const char *str) { node->references--; DBG("str=%p refs=%u", str, node->references); - SHARE_COMMON_UNLOCK_BIG(); + eina_lock_release(&_mutex_big); return; } @@ -873,7 +860,7 @@ eina_share_common_del(Eina_Share *share, const char *str) if (!ed) goto on_error; - EINA_MAGIC_CHECK_SHARE_COMMON_HEAD(ed, SHARE_COMMON_UNLOCK_BIG()); + EINA_MAGIC_CHECK_SHARE_COMMON_HEAD(ed, eina_lock_release(&_mutex_big)); if (!_eina_share_common_head_remove_node(ed, node)) goto on_error; @@ -886,12 +873,12 @@ eina_share_common_del(Eina_Share *share, const char *str) else _eina_share_common_population_head_del(share, ed); - SHARE_COMMON_UNLOCK_BIG(); + eina_lock_release(&_mutex_big); return; on_error: - SHARE_COMMON_UNLOCK_BIG(); + eina_lock_release(&_mutex_big); /* possible segfault happened before here, but... */ CRITICAL("EEEK trying to del non-shared share_common \"%s\"", str); } @@ -927,7 +914,7 @@ eina_share_common_dump(Eina_Share *share, void (*additional_dump)( printf("DDD: len ref string\n"); printf("DDD:-------------------\n"); - SHARE_COMMON_LOCK_BIG(); + eina_lock_take(&_mutex_big); for (i = 0; i < EINA_SHARE_COMMON_BUCKETS; i++) { if (!share->share->buckets[i]) @@ -971,7 +958,7 @@ eina_share_common_dump(Eina_Share *share, void (*additional_dump)( share->population_group[i].max); #endif - SHARE_COMMON_UNLOCK_BIG(); + eina_lock_release(&_mutex_big); } /** diff --git a/legacy/eina/src/lib/eina_stringshare.c b/legacy/eina/src/lib/eina_stringshare.c index 63236f4a50..5488945e20 100644 --- a/legacy/eina/src/lib/eina_stringshare.c +++ b/legacy/eina/src/lib/eina_stringshare.c @@ -47,10 +47,6 @@ void *alloca (size_t); #include #include -#ifdef EFL_HAVE_POSIX_THREADS -# include -#endif - #ifdef HAVE_EVIL # include #endif @@ -62,6 +58,7 @@ void *alloca (size_t); #include "eina_error.h" #include "eina_log.h" #include "eina_stringshare.h" +#include "eina_lock.h" /* undefs EINA_ARG_NONULL() so NULL checks are not compiled out! */ #include "eina_safety_checks.h" @@ -71,27 +68,8 @@ void *alloca (size_t); static Eina_Share *stringshare_share; static const char EINA_MAGIC_STRINGSHARE_NODE_STR[] = "Eina Stringshare Node"; -#ifdef EFL_HAVE_THREADS extern Eina_Bool _share_common_threads_activated; - -# ifdef EFL_HAVE_POSIX_THREADS -static pthread_mutex_t _mutex_small = PTHREAD_MUTEX_INITIALIZER; -# define STRINGSHARE_LOCK_SMALL() if(_share_common_threads_activated) \ - pthread_mutex_lock(&_mutex_small) -# define STRINGSHARE_UNLOCK_SMALL() if(_share_common_threads_activated) \ - pthread_mutex_unlock(&_mutex_small) -# else /* EFL_HAVE_WIN32_THREADS */ -static HANDLE _mutex_small = NULL; -# define STRINGSHARE_LOCK_SMALL() if(_share_common_threads_activated) \ - WaitForSingleObject(_mutex_small, INFINITE) -# define STRINGSHARE_UNLOCK_SMALL() if(_share_common_threads_activated) \ - ReleaseMutex(_mutex_small) - -# endif /* EFL_HAVE_WIN32_THREADS */ -#else /* EFL_HAVE_THREADS */ -# define STRINGSHARE_LOCK_SMALL() do {} while (0) -# define STRINGSHARE_UNLOCK_SMALL() do {} while (0) -#endif +static Eina_Lock _mutex_small; /* Stringshare optimizations */ static const unsigned char _eina_stringshare_single[512] = { @@ -418,6 +396,7 @@ error: static void _eina_stringshare_small_init(void) { + eina_lock_new(&_mutex_small); memset(&_eina_small_share, 0, sizeof(_eina_small_share)); } @@ -448,6 +427,8 @@ _eina_stringshare_small_shutdown(void) free(bucket); *p_bucket = NULL; } + + eina_lock_free(&_mutex_small); } static void @@ -579,9 +560,9 @@ eina_stringshare_del(const char *str) else if (slen < 4) { eina_share_common_population_del(stringshare_share, slen); - STRINGSHARE_LOCK_SMALL(); + eina_lock_take(&_mutex_small); _eina_stringshare_small_del(str, slen); - STRINGSHARE_UNLOCK_SMALL(); + eina_lock_release(&_mutex_small); return; } @@ -601,9 +582,9 @@ eina_stringshare_add_length(const char *str, unsigned int slen) { const char *s; - STRINGSHARE_LOCK_SMALL(); + eina_lock_take(&_mutex_small); s = _eina_stringshare_small_add(str, slen); - STRINGSHARE_UNLOCK_SMALL(); + eina_lock_release(&_mutex_small); return s; } @@ -734,9 +715,9 @@ eina_stringshare_ref(const char *str) const char *s; eina_share_common_population_add(stringshare_share, slen); - STRINGSHARE_LOCK_SMALL(); + eina_lock_take(&_mutex_small); s = _eina_stringshare_small_add(str, slen); - STRINGSHARE_UNLOCK_SMALL(); + eina_lock_release(&_mutex_small); return s; } diff --git a/legacy/eina/src/modules/mp/chained_pool/eina_chained_mempool.c b/legacy/eina/src/modules/mp/chained_pool/eina_chained_mempool.c index a8f90f920a..009b62b2d8 100644 --- a/legacy/eina/src/modules/mp/chained_pool/eina_chained_mempool.c +++ b/legacy/eina/src/modules/mp/chained_pool/eina_chained_mempool.c @@ -241,7 +241,7 @@ eina_chained_mempool_malloc(void *data, __UNUSED__ unsigned int size) Chained_Pool *p = NULL; void *mem; - if (!eina_lock_take(pool->mutex)) + if (!eina_lock_take(&pool->mutex)) { #ifdef EFL_DEBUG_THREADS assert(pthread_equal(pool->self, pthread_self())); @@ -267,7 +267,7 @@ eina_chained_mempool_malloc(void *data, __UNUSED__ unsigned int size) p = _eina_chained_mp_pool_new(pool); if (!p) { - eina_lock_release(pool->mutex); + eina_lock_release(&pool->mutex); return NULL; } @@ -278,7 +278,7 @@ eina_chained_mempool_malloc(void *data, __UNUSED__ unsigned int size) mem = _eina_chained_mempool_alloc_in(pool, p); - eina_lock_release(pool->mutex); + eina_lock_release(&pool->mutex); return mem; } @@ -291,7 +291,7 @@ eina_chained_mempool_free(void *data, void *ptr) Chained_Pool *p; // look 4 pool - if (!eina_lock_take(pool->mutex)) + if (!eina_lock_take(&pool->mutex)) { #ifdef EFL_DEBUG_THREADS assert(pthread_equal(pool->self, pthread_self())); @@ -322,7 +322,7 @@ eina_chained_mempool_free(void *data, void *ptr) } #endif - eina_lock_release(pool->mutex); + eina_lock_release(&pool->mutex); return; } @@ -336,7 +336,7 @@ eina_chained_mempool_repack(void *data, Chained_Pool *tail; /* FIXME: Improvement - per Chained_Pool lock */ - if (!eina_lock_take(pool->mutex)) + if (!eina_lock_take(&pool->mutex)) { #ifdef EFL_DEBUG_THREADS assert(pthread_equal(pool->self, pthread_self())); @@ -409,7 +409,7 @@ eina_chained_mempool_repack(void *data, } /* FIXME: improvement - reorder pool so that the most used one get in front */ - eina_lock_release(pool->mutex); + eina_lock_release(&pool->mutex); } static void * @@ -494,7 +494,7 @@ eina_chained_mempool_shutdown(void *data) VALGRIND_DESTROY_MEMPOOL(mp); #endif - eina_lock_free(mp->mutex); + eina_lock_free(&mp->mutex); #ifdef EFL_DEBUG_THREADS assert(pthread_equal(mp->self, pthread_self())); diff --git a/legacy/eina/src/modules/mp/one_big/eina_one_big.c b/legacy/eina/src/modules/mp/one_big/eina_one_big.c index d920fe720a..dadec652a2 100644 --- a/legacy/eina/src/modules/mp/one_big/eina_one_big.c +++ b/legacy/eina/src/modules/mp/one_big/eina_one_big.c @@ -39,6 +39,7 @@ #include "eina_trash.h" #include "eina_inlist.h" #include "eina_log.h" +#include "eina_lock.h" #ifndef NVALGRIND # include @@ -75,16 +76,10 @@ struct _One_Big Eina_Trash *empty; Eina_Inlist *over_list; -#ifdef EFL_HAVE_THREADS -# ifdef EFL_HAVE_POSIX_THREADS -# ifdef EFL_DEBUG_THREADS +#ifdef EFL_DEBUG_THREADS pthread_t self; -# endif - pthread_mutex_t mutex; -# else - HANDLE mutex; -# endif #endif + Eina_Lock mutex; }; static void * @@ -93,22 +88,12 @@ eina_one_big_malloc(void *data, __UNUSED__ unsigned int size) One_Big *pool = data; unsigned char *mem = NULL; -#ifdef EFL_HAVE_THREADS - if (_threads_activated) + if (!eina_lock_take(&pool->mutex)) { -# ifdef EFL_HAVE_POSIX_THREADS - pthread_mutex_lock(&pool->mutex); -# else - WaitForSingleObject(pool->mutex, INFINITE); -# endif - } -# ifdef EFL_HAVE_POSIX_THREADS -# ifdef EFL_DEBUG_THREADS - else - assert(pthread_equal(pool->self, pthread_self())); -# endif -# endif +#ifdef EFL_DEBUG_THREADS + assert(pthread_equal(pool->self, pthread_self())); #endif + } if (pool->empty) { @@ -158,16 +143,7 @@ eina_one_big_malloc(void *data, __UNUSED__ unsigned int size) #endif on_exit: -#ifdef EFL_HAVE_THREADS - if (_threads_activated) - { -# ifdef EFL_HAVE_POSIX_THREADS - pthread_mutex_unlock(&pool->mutex); -# else - ReleaseMutex(pool->mutex); -# endif - } -#endif + eina_lock_release(&pool->mutex); #ifndef NVALGRIND VALGRIND_MEMPOOL_ALLOC(pool, mem, pool->item_size); @@ -180,22 +156,12 @@ eina_one_big_free(void *data, void *ptr) { One_Big *pool = data; -#ifdef EFL_HAVE_THREADS - if (_threads_activated) + if (!eina_lock_take(&pool->mutex)) { -# ifdef EFL_HAVE_POSIX_THREADS - pthread_mutex_lock(&pool->mutex); -# else - WaitForSingleObject(pool->mutex, INFINITE); -# endif - } -# ifdef EFL_HAVE_POSIX_THREADS -# ifdef EFL_DEBUG_THREADS - else - assert(pthread_equal(pool->self, pthread_self())); -# endif -# endif +#ifdef EFL_DEBUG_THREADS + assert(pthread_equal(pool->self, pthread_self())); #endif + } if ((void *)pool->base <= ptr && ptr < (void *)(pool->base + (pool->max * pool->item_size))) @@ -228,16 +194,7 @@ eina_one_big_free(void *data, void *ptr) VALGRIND_MEMPOOL_FREE(pool, ptr); #endif -#ifdef EFL_HAVE_THREADS - if (_threads_activated) - { -# ifdef EFL_HAVE_POSIX_THREADS - pthread_mutex_unlock(&pool->mutex); -# else - ReleaseMutex(pool->mutex); -# endif - } -#endif + eina_lock_release(&pool->mutex); } static void * @@ -274,16 +231,10 @@ eina_one_big_init(const char *context, memcpy((char *)pool->name, context, length); } -#ifdef EFL_HAVE_THREADS -# ifdef EFL_HAVE_POSIX_THREADS -# ifdef EFL_DEBUG_THREADS +#ifdef EFL_DEBUG_THREADS pool->self = pthread_self(); -# endif - pthread_mutex_init(&pool->mutex, NULL); -# else - pool->mutex = CreateMutex(NULL, FALSE, NULL); -# endif #endif + eina_lock_new(&pool->mutex); #ifndef NVALGRIND VALGRIND_CREATE_MEMPOOL(pool, 0, 1); @@ -298,22 +249,12 @@ eina_one_big_shutdown(void *data) One_Big *pool = data; if (!pool) return; -#ifdef EFL_HAVE_THREADS - if (_threads_activated) + if (!eina_lock_take(&pool->mutex)) { -# ifdef EFL_HAVE_POSIX_THREADS - pthread_mutex_lock(&pool->mutex); -# else - WaitForSingleObject(pool->mutex, INFINITE); -# endif - } -# ifdef EFL_HAVE_POSIX_THREADS -# ifdef EFL_DEBUG_THREADS - else - assert(pthread_equal(pool->self, pthread_self())); -# endif -# endif +#ifdef EFL_DEBUG_THREADS + assert(pthread_equal(pool->self, pthread_self())); #endif + } if (pool->over > 0) { @@ -344,18 +285,8 @@ eina_one_big_shutdown(void *data) if (pool->base) free(pool->base); -#ifdef EFL_HAVE_THREADS - if (_threads_activated) - { -# ifdef EFL_HAVE_POSIX_THREADS - pthread_mutex_unlock(&pool->mutex); - pthread_mutex_destroy(&pool->mutex); -# else - ReleaseMutex(pool->mutex); - CloseHandle(pool->mutex); -# endif - } -#endif + eina_lock_release(&pool->mutex); + eina_lock_free(&pool->mutex); free(pool); }