orbea
/
efl
forked from enlightenment/efl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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
This commit is contained in:
Gustavo Sverzut Barbieri 2012-12-31 16:14:40 +00:00
parent 12e0602452
commit 4668d04f04
7 changed files with 67 additions and 399 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

217
src/lib/ecore/ecore_thread.c
View File

@ -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 <pthread.h>
# ifdef __linux__
# include <sched.h>
# include <sys/resource.h>
# include <unistd.h>
# include <sys/syscall.h>
# include <errno.h>
# endif
# else /* EFL_HAVE_WIN32_THREADS */
# define WIN32_LEAN_AND_MEAN
# include <windows.h>
# 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
}

114
src/lib/eina/eina_log.c
View File

@ -37,10 +37,6 @@
# include <unistd.h>
#endif
#ifdef EFL_HAVE_POSIX_THREADS
# include <pthread.h>
#endif
#ifdef HAVE_EVIL
# include <Evil.h>
#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

4
src/lib/eina/eina_share_common.c
View File

@ -63,10 +63,6 @@
#include <string.h>
#include <stddef.h>
#ifdef EFL_HAVE_POSIX_THREADS
# include <pthread.h>
#endif
#ifdef HAVE_EVIL
# include <Evil.h>
#endif

26
src/modules/eina/mp/chained_pool/eina_chained_mempool.c
View File

@ -23,24 +23,14 @@
#include <stdlib.h>
#include <string.h>
#ifdef EFL_HAVE_POSIX_THREADS
#include <pthread.h>
# ifdef EINA_HAVE_DEBUG_THREADS
# include <assert.h>
# endif
#ifdef EINA_HAVE_DEBUG_THREADS
# include <assert.h>
#endif
#ifdef EINA_DEBUG_MALLOC
# include <malloc.h>
#endif
#ifdef EFL_HAVE_WIN32_THREADS
# define WIN32_LEAN_AND_MEAN
# include <windows.h>
# 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);

20
src/modules/eina/mp/one_big/eina_one_big.c
View File

@ -23,18 +23,8 @@
#include <stdlib.h>
#include <string.h>
#ifdef EFL_HAVE_POSIX_THREADS
# include <pthread.h>
#endif
#include <assert.h>
#ifdef EFL_HAVE_WIN32_THREADS
# define WIN32_LEAN_AND_MEAN
# include <windows.h>
# 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
}

72
src/tests/eet/eet_suite.c
View File

@ -13,13 +13,6 @@
#include <Eina.h>
#ifdef EINA_HAVE_THREADS
#if ((!defined(_WIN32_WCE)) && (!defined(_WIN32)))
# include <pthread.h>
# define _EET_INCLUDED_PTHREAD
#endif
#endif /* ifdef EINA_HAVE_THREADS */
#include <check.h>
#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);

13
src/tests/eina/eina_test_sched.c
View File

@ -20,8 +20,7 @@
# include "config.h"
#endif
#if defined(EFL_HAVE_THREADS) && defined __linux__
#include <pthread.h>
#ifdef __linux__
#include <errno.h>
#include <sys/resource.h>
#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);