From 4668d04f0493b26a4cce4d307a9ed1277553c082 Mon Sep 17 00:00:00 2001 From: Gustavo Sverzut Barbieri Date: Mon, 31 Dec 2012 16:14:40 +0000 Subject: [PATCH] efl: cleanup HAVE_THREADS and pthread usage outside of eina. Eina now abstracts threads, so use that. the touched files had the EFL_HAVE_THREADS as it's mandatory now. SVN revision: 81935 --- src/lib/ecore/ecore_thread.c | 217 +----------------- src/lib/eina/eina_log.c | 114 +++------ src/lib/eina/eina_share_common.c | 4 - .../mp/chained_pool/eina_chained_mempool.c | 26 +-- src/modules/eina/mp/one_big/eina_one_big.c | 20 +- src/tests/eet/eet_suite.c | 72 +----- src/tests/eina/eina_test_sched.c | 13 +- 7 files changed, 67 insertions(+), 399 deletions(-) diff --git a/src/lib/ecore/ecore_thread.c b/src/lib/ecore/ecore_thread.c index 4937ef5290..954d3a1827 100644 --- a/src/lib/ecore/ecore_thread.c +++ b/src/lib/ecore/ecore_thread.c @@ -18,8 +18,6 @@ #include "Ecore.h" #include "ecore_private.h" -#ifdef EFL_HAVE_THREADS - # define LK(x) Eina_Lock x # define LKI(x) eina_lock_new(&(x)) # define LKD(x) eina_lock_free(&(x)) @@ -45,26 +43,6 @@ # define PHC(x, f, d) eina_thread_create(&(x), EINA_THREAD_BACKGROUND, -1, (void *)f, d) # define PHJ(x) eina_thread_join(x) -# ifdef EFL_HAVE_POSIX_THREADS -# include -# ifdef __linux__ -# include -# include -# include -# include -# include -# endif - -# else /* EFL_HAVE_WIN32_THREADS */ - -# define WIN32_LEAN_AND_MEAN -# include -# undef WIN32_LEAN_AND_MEAN - -# endif - -#endif - typedef struct _Ecore_Pthread_Worker Ecore_Pthread_Worker; typedef struct _Ecore_Pthread Ecore_Pthread; typedef struct _Ecore_Thread_Data Ecore_Thread_Data; @@ -108,20 +86,16 @@ struct _Ecore_Pthread_Worker Ecore_Thread_Cb func_cancel; Ecore_Thread_Cb func_end; -#ifdef EFL_HAVE_THREADS PH(self); Eina_Hash *hash; CD(cond); LK(mutex); -#endif const void *data; int cancel; -#ifdef EFL_HAVE_THREADS LK(cancel_mutex); -#endif Eina_Bool message_run : 1; Eina_Bool feedback_run : 1; @@ -130,7 +104,6 @@ struct _Ecore_Pthread_Worker Eina_Bool no_queue : 1; }; -#ifdef EFL_HAVE_THREADS typedef struct _Ecore_Pthread_Notify Ecore_Pthread_Notify; struct _Ecore_Pthread_Notify { @@ -156,12 +129,8 @@ struct _Ecore_Pthread_Message Eina_Bool sync : 1; }; -#endif - static int _ecore_thread_count_max = 0; -#ifdef EFL_HAVE_THREADS - static void _ecore_thread_handler(void *data); static int _ecore_thread_count = 0; @@ -498,12 +467,9 @@ restart: return NULL; } -#endif - static Ecore_Pthread_Worker * _ecore_thread_worker_new(void) { -#ifdef EFL_HAVE_THREADS Ecore_Pthread_Worker *result; result = eina_trash_pop(&_ecore_thread_worker_trash); @@ -519,9 +485,6 @@ _ecore_thread_worker_new(void) CDI(result->cond, result->mutex); return result; -#else - return malloc(sizeof (Ecore_Pthread_Worker)); -#endif } void @@ -531,20 +494,17 @@ _ecore_thread_init(void) if (_ecore_thread_count_max <= 0) _ecore_thread_count_max = 1; -#ifdef EFL_HAVE_THREADS LKI(_ecore_pending_job_threads_mutex); LRWKI(_ecore_thread_global_hash_lock); LKI(_ecore_thread_global_hash_mutex); LKI(_ecore_running_job_mutex); CDI(_ecore_thread_global_hash_cond, _ecore_thread_global_hash_mutex); -#endif } void _ecore_thread_shutdown(void) { /* FIXME: If function are still running in the background, should we kill them ? */ -#ifdef EFL_HAVE_THREADS Ecore_Pthread_Worker *work; Eina_List *l; Eina_Bool test; @@ -610,7 +570,6 @@ _ecore_thread_shutdown(void) LKD(_ecore_thread_global_hash_mutex); LKD(_ecore_running_job_mutex); CDD(_ecore_thread_global_hash_cond); -#endif } EAPI Ecore_Thread * @@ -621,12 +580,10 @@ ecore_thread_run(Ecore_Thread_Cb func_blocking, { Ecore_Pthread_Worker *work; Eina_Bool tried = EINA_FALSE; -#ifdef EFL_HAVE_THREADS PH(thread); -#endif EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL); - + if (!func_blocking) return NULL; work = _ecore_thread_worker_new(); @@ -648,7 +605,6 @@ ecore_thread_run(Ecore_Thread_Cb func_blocking, work->no_queue = EINA_FALSE; work->data = data; -#ifdef EFL_HAVE_THREADS work->self = 0; work->hash = NULL; @@ -697,33 +653,11 @@ ecore_thread_run(Ecore_Thread_Cb func_blocking, eina_threads_shutdown(); return (Ecore_Thread *)work; -#else - /* - If no thread and as we don't want to break app that rely on this - facility, we will lock the interface until we are done. - */ - do { - /* Handle reschedule by forcing it here. That would mean locking the app, - * would be better with an idler, but really to complex for a case where - * thread should really exist. - */ - work->reschedule = EINA_FALSE; - - func_blocking((void *)data, (Ecore_Thread *)work); - if (work->cancel == EINA_FALSE) func_end((void *)data, (Ecore_Thread *)work); - else func_cancel((void *)data, (Ecore_Thread *)work); - } while (work->reschedule == EINA_TRUE); - - free(work); - - return NULL; -#endif } EAPI Eina_Bool ecore_thread_cancel(Ecore_Thread *thread) { -#ifdef EFL_HAVE_THREADS Ecore_Pthread_Worker *volatile work = (Ecore_Pthread_Worker *)thread; Eina_List *l; int cancel; @@ -794,10 +728,6 @@ ecore_thread_cancel(Ecore_Thread *thread) LKU(work->cancel_mutex); return EINA_FALSE; -#else - (void) thread; - return EINA_TRUE; -#endif } EAPI Eina_Bool @@ -807,18 +737,15 @@ ecore_thread_check(Ecore_Thread *thread) int cancel; if (!worker) return EINA_TRUE; -#ifdef EFL_HAVE_THREADS LKL(worker->cancel_mutex); -#endif + cancel = worker->cancel; /* FIXME: there is an insane bug driving me nuts here. I don't know if it's a race condition, some cache issue or some alien attack on our software. But ecore_thread_check will only work correctly with a printf, all the volatile, lock and even usleep don't help here... */ /* fprintf(stderr, "wc: %i\n", cancel); */ -#ifdef EFL_HAVE_THREADS LKU(worker->cancel_mutex); -#endif return cancel; } @@ -830,13 +757,12 @@ ecore_thread_feedback_run(Ecore_Thread_Cb func_heavy, const void *data, Eina_Bool try_no_queue) { -#ifdef EFL_HAVE_THREADS Ecore_Pthread_Worker *worker; Eina_Bool tried = EINA_FALSE; PH(thread); EINA_MAIN_LOOP_CHECK_RETURN_VAL(NULL); - + if (!func_heavy) return NULL; worker = _ecore_thread_worker_new(); @@ -942,38 +868,6 @@ on_error: LKU(_ecore_pending_job_threads_mutex); return (Ecore_Thread *)worker; -#else - Ecore_Pthread_Worker worker; - - (void)try_no_queue; - - /* - If no thread and as we don't want to break app that rely on this - facility, we will lock the interface until we are done. - */ - worker.u.feedback_run.func_heavy = func_heavy; - worker.u.feedback_run.func_notify = func_notify; - worker.u.feedback_run.send = 0; - worker.u.feedback_run.received = 0; - worker.func_cancel = func_cancel; - worker.func_end = func_end; - worker.data = data; - worker.cancel = EINA_FALSE; - worker.feedback_run = EINA_TRUE; - worker.message_run = EINA_FALSE; - worker.kill = EINA_FALSE; - - do { - worker.reschedule = EINA_FALSE; - - func_heavy((void *)data, (Ecore_Thread *)&worker); - - if (worker.cancel) func_cancel((void *)data, (Ecore_Thread *)&worker); - else func_end((void *)data, (Ecore_Thread *)&worker); - } while (worker.reschedule == EINA_TRUE); - - return NULL; -#endif } EAPI Eina_Bool @@ -984,7 +878,6 @@ ecore_thread_feedback(Ecore_Thread *thread, if (!worker) return EINA_FALSE; -#ifdef EFL_HAVE_THREADS if (!PHE(worker->self, PHS())) return EINA_FALSE; if (worker->feedback_run) @@ -1027,11 +920,6 @@ ecore_thread_feedback(Ecore_Thread *thread, return EINA_FALSE; return EINA_TRUE; -#else - worker->u.feedback_run.func_notify((void *)worker->data, thread, (void *)data); - - return EINA_TRUE; -#endif } #if 0 @@ -1042,7 +930,6 @@ ecore_thread_message_run(Ecore_Thread_Cb func_main, Ecore_Thread_Cb func_cancel, const void *data) { -#ifdef EFL_HAVE_THREADS Ecore_Pthread_Worker *worker; PH(t); @@ -1087,11 +974,6 @@ ecore_thread_message_run(Ecore_Thread_Cb func_main, CDD(worker->cond); LKD(worker->mutex); -#else - /* Note: This type of thread can't and never will work without thread support */ - WRN("ecore_thread_message_run called, but threads disable in Ecore, things will go wrong. Starting now !"); -# warning "You disabled threads support in ecore, I hope you know what you are doing !" -#endif func_cancel((void *) data, NULL); @@ -1106,9 +988,7 @@ ecore_thread_reschedule(Ecore_Thread *thread) if (!worker) return EINA_FALSE; -#ifdef EFL_HAVE_THREADS if (!PHE(worker->self, PHS())) return EINA_FALSE; -#endif worker->reschedule = EINA_TRUE; return EINA_TRUE; @@ -1117,18 +997,13 @@ ecore_thread_reschedule(Ecore_Thread *thread) EAPI int ecore_thread_active_get(void) { -#ifdef EFL_HAVE_THREADS EINA_MAIN_LOOP_CHECK_RETURN_VAL(0); return _ecore_thread_count; -#else - return 0; -#endif } EAPI int ecore_thread_pending_get(void) { -#ifdef EFL_HAVE_THREADS int ret; EINA_MAIN_LOOP_CHECK_RETURN_VAL(0); @@ -1136,15 +1011,11 @@ ecore_thread_pending_get(void) ret = eina_list_count(_ecore_pending_job_threads); LKU(_ecore_pending_job_threads_mutex); return ret; -#else - return 0; -#endif } EAPI int ecore_thread_pending_feedback_get(void) { -#ifdef EFL_HAVE_THREADS int ret; EINA_MAIN_LOOP_CHECK_RETURN_VAL(0); @@ -1152,15 +1023,11 @@ ecore_thread_pending_feedback_get(void) ret = eina_list_count(_ecore_pending_job_threads_feedback); LKU(_ecore_pending_job_threads_mutex); return ret; -#else - return 0; -#endif } EAPI int ecore_thread_pending_total_get(void) { -#ifdef EFL_HAVE_THREADS int ret; EINA_MAIN_LOOP_CHECK_RETURN_VAL(0); @@ -1168,9 +1035,6 @@ ecore_thread_pending_total_get(void) ret = eina_list_count(_ecore_pending_job_threads) + eina_list_count(_ecore_pending_job_threads_feedback); LKU(_ecore_pending_job_threads_mutex); return ret; -#else - return 0; -#endif } EAPI int @@ -1201,16 +1065,12 @@ ecore_thread_max_reset(void) EAPI int ecore_thread_available_get(void) { -#ifdef EFL_HAVE_THREADS int ret; LKL(_ecore_pending_job_threads_mutex); ret = _ecore_thread_count_max - _ecore_thread_count; LKU(_ecore_pending_job_threads_mutex); return ret; -#else - return 0; -#endif } EAPI Eina_Bool @@ -1220,15 +1080,13 @@ ecore_thread_local_data_add(Ecore_Thread *thread, Eina_Free_Cb cb, Eina_Bool direct) { -#ifdef EFL_HAVE_THREADS Ecore_Pthread_Worker *worker = (Ecore_Pthread_Worker *)thread; Ecore_Thread_Data *d; Eina_Bool ret; -#endif if ((!thread) || (!key) || (!value)) return EINA_FALSE; -#ifdef EFL_HAVE_THREADS + if (!PHE(worker->self, PHS())) return EINA_FALSE; if (!worker->hash) @@ -1249,11 +1107,6 @@ ecore_thread_local_data_add(Ecore_Thread *thread, ret = eina_hash_add(worker->hash, key, d); CDB(worker->cond); return ret; -#else - (void) cb; - (void) direct; - return EINA_FALSE; -#endif } EAPI void * @@ -1262,15 +1115,13 @@ ecore_thread_local_data_set(Ecore_Thread *thread, void *value, Eina_Free_Cb cb) { -#ifdef EFL_HAVE_THREADS Ecore_Pthread_Worker *worker = (Ecore_Pthread_Worker *)thread; Ecore_Thread_Data *d, *r; void *ret; -#endif if ((!thread) || (!key) || (!value)) return NULL; -#ifdef EFL_HAVE_THREADS + if (!PHE(worker->self, PHS())) return NULL; if (!worker->hash) @@ -1290,24 +1141,18 @@ ecore_thread_local_data_set(Ecore_Thread *thread, ret = r->data; free(r); return ret; -#else - (void) cb; - return NULL; -#endif } EAPI void * ecore_thread_local_data_find(Ecore_Thread *thread, const char *key) { -#ifdef EFL_HAVE_THREADS Ecore_Pthread_Worker *worker = (Ecore_Pthread_Worker *)thread; Ecore_Thread_Data *d; -#endif if ((!thread) || (!key)) return NULL; -#ifdef EFL_HAVE_THREADS + if (!PHE(worker->self, PHS())) return NULL; if (!worker->hash) @@ -1317,30 +1162,22 @@ ecore_thread_local_data_find(Ecore_Thread *thread, if (d) return d->data; return NULL; -#else - return NULL; -#endif } EAPI Eina_Bool ecore_thread_local_data_del(Ecore_Thread *thread, const char *key) { -#ifdef EFL_HAVE_THREADS Ecore_Pthread_Worker *worker = (Ecore_Pthread_Worker *)thread; -#endif if ((!thread) || (!key)) return EINA_FALSE; -#ifdef EFL_HAVE_THREADS + if (!PHE(worker->self, PHS())) return EINA_FALSE; if (!worker->hash) return EINA_FALSE; return eina_hash_del_by_key(worker->hash, key); -#else - return EINA_TRUE; -#endif } EAPI Eina_Bool @@ -1349,14 +1186,12 @@ ecore_thread_global_data_add(const char *key, Eina_Free_Cb cb, Eina_Bool direct) { -#ifdef EFL_HAVE_THREADS Ecore_Thread_Data *d; Eina_Bool ret; -#endif if ((!key) || (!value)) return EINA_FALSE; -#ifdef EFL_HAVE_THREADS + LRWKWL(_ecore_thread_global_hash_lock); if (!_ecore_thread_global_hash) _ecore_thread_global_hash = eina_hash_string_small_new(_ecore_thread_data_free); @@ -1378,11 +1213,6 @@ ecore_thread_global_data_add(const char *key, LRWKU(_ecore_thread_global_hash_lock); CDB(_ecore_thread_global_hash_cond); return ret; -#else - (void) cb; - (void) direct; - return EINA_TRUE; -#endif } EAPI void * @@ -1390,14 +1220,12 @@ ecore_thread_global_data_set(const char *key, void *value, Eina_Free_Cb cb) { -#ifdef EFL_HAVE_THREADS Ecore_Thread_Data *d, *r; void *ret; -#endif if ((!key) || (!value)) return NULL; -#ifdef EFL_HAVE_THREADS + LRWKWL(_ecore_thread_global_hash_lock); if (!_ecore_thread_global_hash) _ecore_thread_global_hash = eina_hash_string_small_new(_ecore_thread_data_free); @@ -1420,22 +1248,16 @@ ecore_thread_global_data_set(const char *key, ret = r->data; free(r); return ret; -#else - (void) cb; - return NULL; -#endif } EAPI void * ecore_thread_global_data_find(const char *key) { -#ifdef EFL_HAVE_THREADS Ecore_Thread_Data *ret; -#endif if (!key) return NULL; -#ifdef EFL_HAVE_THREADS + if (!_ecore_thread_global_hash) return NULL; LRWKRL(_ecore_thread_global_hash_lock); @@ -1444,21 +1266,16 @@ ecore_thread_global_data_find(const char *key) if (ret) return ret->data; return NULL; -#else - return NULL; -#endif } EAPI Eina_Bool ecore_thread_global_data_del(const char *key) { -#ifdef EFL_HAVE_THREADS Eina_Bool ret; -#endif if (!key) return EINA_FALSE; -#ifdef EFL_HAVE_THREADS + if (!_ecore_thread_global_hash) return EINA_FALSE; @@ -1466,23 +1283,18 @@ ecore_thread_global_data_del(const char *key) ret = eina_hash_del_by_key(_ecore_thread_global_hash, key); LRWKU(_ecore_thread_global_hash_lock); return ret; -#else - return EINA_TRUE; -#endif } EAPI void * ecore_thread_global_data_wait(const char *key, double seconds) { -#ifdef EFL_HAVE_THREADS double tm = 0; Ecore_Thread_Data *ret = NULL; -#endif if (!key) return NULL; -#ifdef EFL_HAVE_THREADS + if (!_ecore_thread_global_hash) return NULL; if (seconds > 0) @@ -1501,9 +1313,4 @@ ecore_thread_global_data_wait(const char *key, } if (ret) return ret->data; return NULL; -#else - (void) seconds; - return NULL; -#endif } - diff --git a/src/lib/eina/eina_log.c b/src/lib/eina/eina_log.c index 0bc0df7851..f4e343688b 100644 --- a/src/lib/eina/eina_log.c +++ b/src/lib/eina/eina_log.c @@ -37,10 +37,6 @@ # include #endif -#ifdef EFL_HAVE_POSIX_THREADS -# include -#endif - #ifdef HAVE_EVIL # include #endif @@ -48,6 +44,8 @@ #include "eina_config.h" #include "eina_private.h" #include "eina_inlist.h" +#include "eina_lock.h" +#include "eina_thread.h" /* undefs EINA_ARG_NONULL() so NULL checks are not compiled out! */ #include "eina_safety_checks.h" @@ -109,32 +107,26 @@ static int _abort_level_on_critical = EINA_LOG_LEVEL_CRITICAL; static int _backtrace_level = -1; #endif -#ifdef EFL_HAVE_THREADS - static Eina_Bool _threads_enabled = EINA_FALSE; static Eina_Bool _threads_inited = EINA_FALSE; -# ifdef EFL_HAVE_POSIX_THREADS +static Eina_Thread _main_thread; -typedef pthread_t Thread; - -static pthread_t _main_thread; - -# define SELF() pthread_self() -# define IS_MAIN(t) pthread_equal(t, _main_thread) +# define SELF() eina_thread_self() +# define IS_MAIN(t) eina_thread_equal(t, _main_thread) # define IS_OTHER(t) EINA_UNLIKELY(!IS_MAIN(t)) # define CHECK_MAIN(...) \ do { \ - if (!IS_MAIN(pthread_self())) { \ + if (!IS_MAIN(eina_thread_self())) { \ fprintf(stderr, \ "ERR: not main thread! current=%lu, main=%lu\n", \ - (unsigned long)pthread_self(), \ + (unsigned long)eina_thread_self(), \ (unsigned long)_main_thread); \ return __VA_ARGS__; \ } \ } while (0) -# ifdef EFL_HAVE_POSIX_THREADS_SPINLOCK +#ifdef EFL_HAVE_POSIX_THREADS_SPINLOCK static pthread_spinlock_t _log_lock; @@ -154,7 +146,7 @@ static Eina_Bool _eina_log_spinlock_init(void) do { \ if (0) { \ fprintf(stderr, "+++LOG LOG_LOCKED! [%s, %lu]\n", \ - __FUNCTION__, (unsigned long)pthread_self()); } \ + __FUNCTION__, (unsigned long)eina_thread_self()); } \ if (EINA_UNLIKELY(_threads_enabled)) { \ pthread_spin_lock(&_log_lock); } \ } while (0) @@ -166,60 +158,20 @@ static Eina_Bool _eina_log_spinlock_init(void) if (0) { \ fprintf(stderr, \ "---LOG LOG_UNLOCKED! [%s, %lu]\n", \ - __FUNCTION__, (unsigned long)pthread_self()); } \ + __FUNCTION__, (unsigned long)eina_thread_self()); } \ } while (0) # define INIT() _eina_log_spinlock_init() # define SHUTDOWN() pthread_spin_destroy(&_log_lock) -# else /* ! EFL_HAVE_POSIX_THREADS_SPINLOCK */ +#else /* ! EFL_HAVE_POSIX_THREADS_SPINLOCK */ -static pthread_mutex_t _log_mutex = PTHREAD_MUTEX_INITIALIZER; -# define LOG_LOCK() if(_threads_enabled) {pthread_mutex_lock(&_log_mutex); } -# define LOG_UNLOCK() if(_threads_enabled) {pthread_mutex_unlock(&_log_mutex); } -# define INIT() (1) -# define SHUTDOWN() do {} while (0) +static Eina_Lock _log_mutex; +# define LOG_LOCK() if(_threads_enabled) {eina_lock_take(&_log_mutex); } +# define LOG_UNLOCK() if(_threads_enabled) {eina_lock_release(&_log_mutex); } +# define INIT() eina_lock_new(&_log_mutex) +# define SHUTDOWN() eina_lock_free(&_log_mutex) -# endif /* ! EFL_HAVE_POSIX_THREADS_SPINLOCK */ - -# else /* EFL_HAVE_WIN32_THREADS */ - -typedef DWORD Thread; - -static DWORD _main_thread; - -# define SELF() GetCurrentThreadId() -# define IS_MAIN(t) (t == _main_thread) -# define IS_OTHER(t) EINA_UNLIKELY(!IS_MAIN(t)) -# define CHECK_MAIN(...) \ - do { \ - if (!IS_MAIN(GetCurrentThreadId())) { \ - fprintf(stderr, \ - "ERR: not main thread! current=%lu, main=%lu\n", \ - GetCurrentThreadId(), _main_thread); \ - return __VA_ARGS__; \ - } \ - } while (0) - -static HANDLE _log_mutex = NULL; - -# define LOG_LOCK() if(_threads_enabled) WaitForSingleObject(_log_mutex, INFINITE) -# define LOG_UNLOCK() if(_threads_enabled) ReleaseMutex(_log_mutex) -# define INIT() ((_log_mutex = CreateMutex(NULL, FALSE, NULL)) ? 1 : 0) -# define SHUTDOWN() if (_log_mutex) CloseHandle(_log_mutex) - -# endif /* EFL_HAVE_WIN32_THREADS */ - -#else /* ! EFL_HAVE_THREADS */ - -# define LOG_LOCK() do {} while (0) -# define LOG_UNLOCK() do {} while (0) -# define IS_MAIN(t) (1) -# define IS_OTHER(t) (0) -# define CHECK_MAIN(...) do {} while (0) -# define INIT() (1) -# define SHUTDOWN() do {} while (0) - -#endif /* ! EFL_HAVE_THREADS */ +#endif /* ! EFL_HAVE_POSIX_THREADS_SPINLOCK */ // List of domains registered @@ -602,7 +554,6 @@ eina_log_print_prefix_NOthreads_color_file_NOfunc(FILE *fp, } /** threads, No color */ -#ifdef EFL_HAVE_THREADS static void eina_log_print_prefix_threads_NOcolor_file_func(FILE *fp, const Eina_Log_Domain *d, @@ -611,7 +562,7 @@ eina_log_print_prefix_threads_NOcolor_file_func(FILE *fp, const char *fnc, int line) { - Thread cur; + Eina_Thread cur; DECLARE_LEVEL_NAME(level); cur = SELF(); @@ -634,7 +585,7 @@ eina_log_print_prefix_threads_NOcolor_NOfile_func(FILE *fp, const char *fnc, int line EINA_UNUSED) { - Thread cur; + Eina_Thread cur; DECLARE_LEVEL_NAME(level); cur = SELF(); @@ -657,7 +608,7 @@ eina_log_print_prefix_threads_NOcolor_file_NOfunc(FILE *fp, const char *fnc EINA_UNUSED, int line) { - Thread cur; + Eina_Thread cur; DECLARE_LEVEL_NAME(level); cur = SELF(); @@ -682,7 +633,7 @@ eina_log_print_prefix_threads_color_file_func(FILE *fp, const char *fnc, int line) { - Thread cur; + Eina_Thread cur; DECLARE_LEVEL_NAME_COLOR(level); cur = SELF(); @@ -756,7 +707,7 @@ eina_log_print_prefix_threads_color_NOfile_func(FILE *fp, const char *fnc, int line EINA_UNUSED) { - Thread cur; + Eina_Thread cur; DECLARE_LEVEL_NAME_COLOR(level); cur = SELF(); @@ -825,7 +776,7 @@ eina_log_print_prefix_threads_color_file_NOfunc(FILE *fp, const char *fnc EINA_UNUSED, int line) { - Thread cur; + Eina_Thread cur; DECLARE_LEVEL_NAME_COLOR(level); cur = SELF(); @@ -878,7 +829,6 @@ eina_log_print_prefix_threads_color_file_NOfunc(FILE *fp, color, name, d->domain_str, file, line); # endif } -#endif /* EFL_HAVE_THREADS */ static void (*_eina_log_print_prefix)(FILE *fp, const Eina_Log_Domain *d, Eina_Log_Level level, const char *file, @@ -903,7 +853,6 @@ eina_log_print_prefix_update(void) NOfile \ ## file_ ## NOfunc ## func -#ifdef EFL_HAVE_THREADS if (_threads_enabled) { if (_disable_color) @@ -928,8 +877,6 @@ eina_log_print_prefix_update(void) return; } -#endif - if (_disable_color) { if (_disable_file) @@ -1500,8 +1447,6 @@ eina_log_shutdown(void) return EINA_TRUE; } -#ifdef EFL_HAVE_THREADS - /** * @internal * @brief Activate the log mutex. @@ -1543,8 +1488,6 @@ eina_log_threads_shutdown(void) #endif } -#endif - /*============================================================================* * API * *============================================================================*/ @@ -1562,7 +1505,7 @@ EAPI int EINA_LOG_DOMAIN_GLOBAL = 0; EAPI void eina_log_threads_enable(void) { -#if defined (EFL_HAVE_THREADS) && defined (EINA_ENABLE_LOG) +#ifdef EINA_ENABLE_LOG if (_threads_enabled) return; if (!_threads_inited) eina_log_threads_init(); _threads_enabled = EINA_TRUE; @@ -1611,7 +1554,7 @@ eina_log_level_get(void) EAPI Eina_Bool eina_log_main_thread_check(void) { -#if defined (EFL_HAVE_THREADS) && defined (EINA_ENABLE_LOG) +#ifdef EINA_ENABLE_LOG return ((!_threads_enabled) || IS_MAIN(SELF())); #else return EINA_TRUE; @@ -1947,10 +1890,9 @@ eina_log_print_cb_file(const Eina_Log_Domain *d, #ifdef EINA_ENABLE_LOG EINA_SAFETY_ON_NULL_RETURN(data); FILE *f = data; -#ifdef EFL_HAVE_THREADS if (_threads_enabled) { - Thread cur; + Eina_Thread cur; cur = SELF(); if (IS_OTHER(cur)) @@ -1961,13 +1903,11 @@ eina_log_print_cb_file(const Eina_Log_Domain *d, } } -#endif fprintf(f, "%s<%u> %s:%d %s() ", d->name, eina_log_pid_get(), file, line, fnc); DISPLAY_BACKTRACE(f, level); -#ifdef EFL_HAVE_THREADS + end: -#endif vfprintf(f, fmt, args); putc('\n', f); #else diff --git a/src/lib/eina/eina_share_common.c b/src/lib/eina/eina_share_common.c index c68e399cc9..29c9f47572 100644 --- a/src/lib/eina/eina_share_common.c +++ b/src/lib/eina/eina_share_common.c @@ -63,10 +63,6 @@ #include #include -#ifdef EFL_HAVE_POSIX_THREADS -# include -#endif - #ifdef HAVE_EVIL # include #endif diff --git a/src/modules/eina/mp/chained_pool/eina_chained_mempool.c b/src/modules/eina/mp/chained_pool/eina_chained_mempool.c index 8ed2b42214..a9be2845f1 100644 --- a/src/modules/eina/mp/chained_pool/eina_chained_mempool.c +++ b/src/modules/eina/mp/chained_pool/eina_chained_mempool.c @@ -23,24 +23,14 @@ #include #include -#ifdef EFL_HAVE_POSIX_THREADS -#include - -# ifdef EINA_HAVE_DEBUG_THREADS -# include -# endif +#ifdef EINA_HAVE_DEBUG_THREADS +# include #endif #ifdef EINA_DEBUG_MALLOC # include #endif -#ifdef EFL_HAVE_WIN32_THREADS -# define WIN32_LEAN_AND_MEAN -# include -# undef WIN32_LEAN_AND_MEAN -#endif - #include "eina_config.h" #include "eina_inlist.h" #include "eina_error.h" @@ -83,7 +73,7 @@ struct _Chained_Mempool int minimal_size; #endif #ifdef EINA_HAVE_DEBUG_THREADS - pthread_t self; + Eina_Tthread self; #endif Eina_Lock mutex; }; @@ -266,7 +256,7 @@ eina_chained_mempool_malloc(void *data, EINA_UNUSED unsigned int size) if (!eina_lock_take(&pool->mutex)) { #ifdef EINA_HAVE_DEBUG_THREADS - assert(pthread_equal(pool->self, pthread_self())); + assert(eina_thread_equal(pool->self, eina_thread_self())); #endif } @@ -316,7 +306,7 @@ eina_chained_mempool_free(void *data, void *ptr) if (!eina_lock_take(&pool->mutex)) { #ifdef EINA_HAVE_DEBUG_THREADS - assert(pthread_equal(pool->self, pthread_self())); + assert(eina_thread_equal(pool->self, eina_thread_self())); #endif } @@ -361,7 +351,7 @@ eina_chained_mempool_repack(void *data, if (!eina_lock_take(&pool->mutex)) { #ifdef EINA_HAVE_DEBUG_THREADS - assert(pthread_equal(pool->self, pthread_self())); + assert(eina_threadequal(pool->self, eina_threadself())); #endif } @@ -479,7 +469,7 @@ eina_chained_mempool_init(const char *context, #endif #ifdef EINA_HAVE_DEBUG_THREADS - mp->self = pthread_self(); + mp->self = eina_threadself(); #endif eina_lock_new(&mp->mutex); @@ -523,7 +513,7 @@ eina_chained_mempool_shutdown(void *data) eina_lock_free(&mp->mutex); #ifdef EINA_HAVE_DEBUG_THREADS - assert(pthread_equal(mp->self, pthread_self())); + assert(eina_threadequal(mp->self, eina_threadself())); #endif free(mp); diff --git a/src/modules/eina/mp/one_big/eina_one_big.c b/src/modules/eina/mp/one_big/eina_one_big.c index 42c47ee685..cc96c8ea3b 100644 --- a/src/modules/eina/mp/one_big/eina_one_big.c +++ b/src/modules/eina/mp/one_big/eina_one_big.c @@ -23,18 +23,8 @@ #include #include -#ifdef EFL_HAVE_POSIX_THREADS -# include -#endif - #include -#ifdef EFL_HAVE_WIN32_THREADS -# define WIN32_LEAN_AND_MEAN -# include -# undef WIN32_LEAN_AND_MEAN -#endif - #include "eina_config.h" #include "eina_mempool.h" #include "eina_trash.h" @@ -78,7 +68,7 @@ struct _One_Big Eina_Inlist *over_list; #ifdef EINA_HAVE_DEBUG_THREADS - pthread_t self; + Eina_Thread self; #endif Eina_Lock mutex; }; @@ -92,7 +82,7 @@ eina_one_big_malloc(void *data, EINA_UNUSED unsigned int size) if (!eina_lock_take(&pool->mutex)) { #ifdef EINA_HAVE_DEBUG_THREADS - assert(pthread_equal(pool->self, pthread_self())); + assert(eina_thread_equal(pool->self, eina_thread_self())); #endif } @@ -160,7 +150,7 @@ eina_one_big_free(void *data, void *ptr) if (!eina_lock_take(&pool->mutex)) { #ifdef EINA_HAVE_DEBUG_THREADS - assert(pthread_equal(pool->self, pthread_self())); + assert(eina_thread_equal(pool->self, eina_thread_self())); #endif } @@ -233,7 +223,7 @@ eina_one_big_init(const char *context, } #ifdef EINA_HAVE_DEBUG_THREADS - pool->self = pthread_self(); + pool->self = eina_thread_self(); #endif eina_lock_new(&pool->mutex); @@ -253,7 +243,7 @@ eina_one_big_shutdown(void *data) if (!eina_lock_take(&pool->mutex)) { #ifdef EINA_HAVE_DEBUG_THREADS - assert(pthread_equal(pool->self, pthread_self())); + assert(eina_thread_equal(pool->self, eina_thread_self())); #endif } diff --git a/src/tests/eet/eet_suite.c b/src/tests/eet/eet_suite.c index 13fc8e3dcf..f1b0dd9e69 100644 --- a/src/tests/eet/eet_suite.c +++ b/src/tests/eet/eet_suite.c @@ -13,13 +13,6 @@ #include -#ifdef EINA_HAVE_THREADS -#if ((!defined(_WIN32_WCE)) && (!defined(_WIN32))) -# include -# define _EET_INCLUDED_PTHREAD -#endif -#endif /* ifdef EINA_HAVE_THREADS */ - #include #include "eet_suite.h" @@ -1849,53 +1842,26 @@ START_TEST(eet_cipher_decipher_simple) END_TEST -#ifdef EINA_HAVE_THREADS - static Eina_Bool open_worker_stop; -# ifdef _EET_INCLUDED_PTHREAD - static void * -open_close_worker(void *path) +open_close_worker(void *path, Eina_Thread tid EINA_UNUSED) { while (!open_worker_stop) { Eet_File *ef = eet_open((char const *)path, EET_FILE_MODE_READ); if (ef == NULL) - pthread_exit("eet_open() failed"); + return "eet_open() failed"; else { Eet_Error err_code = eet_close(ef); if (err_code != EET_ERROR_NONE) - pthread_exit("eet_close() failed"); + return "eet_close() failed"; } } - pthread_exit(NULL); -} /* open_close_worker */ - -# else /* ifdef _EET_INCLUDED_PTHREAD */ - -static unsigned int __stdcall -open_close_worker(void *path) -{ - while (!open_worker_stop) - { - Eet_File *ef = eet_open((char const *)path, EET_FILE_MODE_READ); - if (ef == NULL) - _endthreadex(-1); - else - { - Eet_Error err_code = eet_close(ef); - if (err_code != EET_ERROR_NONE) - _endthreadex(-2); - } - } - - _endthreadex(0); -} /* open_close_worker */ - -# endif /* ifdef _EET_INCLUDED_PTHREAD */ + return NULL; +} START_TEST(eet_cache_concurrency) { @@ -1904,13 +1870,7 @@ START_TEST(eet_cache_concurrency) Eet_File *ef; void *thread_ret; unsigned int n; -# ifdef _EET_INCLUDED_PTHREAD - pthread_t thread; -# else /* ifdef _EET_INCLUDED_PTHREAD */ - uintptr_t thread; - unsigned int thread_id; - DWORD ret; -# endif /* ifdef _EET_INCLUDED_PTHREAD */ + Eina_Thread thread; eet_init(); eina_threads_init(); @@ -1923,11 +1883,8 @@ START_TEST(eet_cache_concurrency) /* start a thread that repeatedly opens and closes a file */ open_worker_stop = 0; -# ifdef _EET_INCLUDED_PTHREAD - pthread_create(&thread, NULL, open_close_worker, file); -# else /* ifdef _EET_INCLUDED_PTHREAD */ - thread = _beginthreadex(NULL, 0, open_close_worker, file, 0, &thread_id); -# endif /* ifdef _EET_INCLUDED_PTHREAD */ + eina_thread_create(&thread, EINA_THREAD_NORMAL, -1, open_close_worker, file); + /* clear the cache repeatedly in this thread */ for (n = 0; n < 20000; ++n) { @@ -1936,15 +1893,8 @@ START_TEST(eet_cache_concurrency) /* join the other thread, and fail if it returned an error message */ open_worker_stop = 1; -# ifdef _EET_INCLUDED_PTHREAD - fail_if(pthread_join(thread, &thread_ret) != 0); + thread_ret = eina_thread_join(thread); fail_unless(thread_ret == NULL, (char const *)thread_ret); -# else /* ifdef _EET_INCLUDED_PTHREAD */ - ret = WaitForSingleObject((HANDLE)thread, INFINITE); - fail_if(ret != WAIT_OBJECT_0); - fail_if(GetExitCodeThread((HANDLE)thread, &ret) == FALSE); - fail_if(ret != 0); -# endif /* ifdef _EET_INCLUDED_PTHREAD */ eet_close(ef); @@ -1955,8 +1905,6 @@ START_TEST(eet_cache_concurrency) } END_TEST -#endif /* EINA_HAVE_THREADS */ - typedef struct _Eet_Connection_Data Eet_Connection_Data; struct _Eet_Connection_Data { @@ -2746,11 +2694,9 @@ eet_suite(void) suite_add_tcase(s, tc); #endif /* ifdef HAVE_CIPHER */ -#ifdef EINA_HAVE_THREADS tc = tcase_create("Eet Cache"); tcase_add_test(tc, eet_cache_concurrency); suite_add_tcase(s, tc); -#endif /* ifdef EFL_HAVE_THREADS */ tc = tcase_create("Eet Connection"); tcase_add_test(tc, eet_connection_check); diff --git a/src/tests/eina/eina_test_sched.c b/src/tests/eina/eina_test_sched.c index 53a771dc70..b8ea8f216f 100644 --- a/src/tests/eina/eina_test_sched.c +++ b/src/tests/eina/eina_test_sched.c @@ -20,8 +20,7 @@ # include "config.h" #endif -#if defined(EFL_HAVE_THREADS) && defined __linux__ -#include +#ifdef __linux__ #include #include #endif @@ -29,7 +28,7 @@ #include "eina_suite.h" #include "Eina.h" -#if defined(EFL_HAVE_THREADS) && defined __linux__ +#ifdef __linux__ /* * TODO: Test if RT priorities are right. However, make check should be run as @@ -37,7 +36,7 @@ */ static void * -_thread_run(void *arg EINA_UNUSED) +_thread_run(void *arg EINA_UNUSED, Eina_Thread tid EINA_UNUSED) { int niceval = getpriority(PRIO_PROCESS, 0); int niceval2; @@ -53,17 +52,17 @@ START_TEST(eina_test_sched_prio_drop) { int niceval = getpriority(PRIO_PROCESS, 0); int niceval2; - pthread_t tid; + Eina_Thread tid; eina_init(); - pthread_create(&tid, NULL, _thread_run, NULL); + eina_thread_create(&tid, EINA_THREAD_NORMAL, -1, _thread_run, NULL); niceval2 = getpriority(PRIO_PROCESS, 0); /* niceness of main thread should not have changed */ fail_if(niceval2 != niceval); - pthread_join(tid, NULL); + eina_thread_join(tid); /* niceness of main thread should not have changed */ fail_if(niceval2 != niceval);