From 1d005a0df71009b02ee6c5535a0a59faef64f339 Mon Sep 17 00:00:00 2001 From: caro Date: Fri, 26 Nov 2010 18:41:43 +0000 Subject: [PATCH] remove win7 code and fix other minor problems git-svn-id: http://svn.enlightenment.org/svn/e/trunk/ecore@55023 7cbeb6ba-43b4-40fd-8cce-4c39aea84d33 --- src/lib/ecore/ecore_thread.c | 224 ++++++++++++++++++++++++++++++++----------- 1 file changed, 167 insertions(+), 57 deletions(-) diff --git a/src/lib/ecore/ecore_thread.c b/src/lib/ecore/ecore_thread.c index ef7c225..27f6252 100644 --- a/src/lib/ecore/ecore_thread.c +++ b/src/lib/ecore/ecore_thread.c @@ -2,6 +2,8 @@ # include #endif +#include + #ifdef HAVE_EVIL # include #endif @@ -15,7 +17,6 @@ # include # ifdef __linux__ # include -# include # include # include # include @@ -99,6 +100,12 @@ int _ecore_thread_win32_join(win32_thread *x, void **res) # define PHJ(x, p) _ecore_thread_win32_join(x, (void**)(&(p))) # define PHA(x) TerminateThread(x->thread, 0) +# define LK(x) HANDLE x +# define LKI(x) x = CreateMutex(NULL, FALSE, NULL) +# define LKD(x) CloseHandle(x) +# define LKL(x) WaitForSingleObject(x, INFINITE) +# define LKU(x) ReleaseMutex(x) + typedef struct { HANDLE semaphore; @@ -139,65 +146,155 @@ do { \ LeaveCriticalSection (&x->threads_count_lock); \ } while (0) -# define CDW(x, y, t) \ -do { \ - DWORD val = t->tv_sec * 1000 + (tv_nsec / 1000000); \ - LKL(y); \ - EnterCriticalSection (&x->threads_count_lock); \ - x->threads_count++; \ - LeaveCriticalSection (&x->threads_count_lock); \ - LKU(y); \ - WaitForingleObject(x->semaphore, val); \ - } while (0) - -# define LK(x) HANDLE x -# define LKI(x) x = CreateMutex(NULL, FALSE, NULL) -# define LKD(x) CloseHandle(x) -# define LKL(x) WaitForSingleObject(x, INFINITE) -# define LKU(x) ReleaseMutex(x) +int _ecore_thread_win32_cond_timedwait(win32_cond *c, HANDLE *external_mutex, struct timeval *t) +{ + DWORD res; + DWORD val = t->tv_sec * 1000 + (t->tv_usec / 1000); + LKL(external_mutex); + EnterCriticalSection (&c->threads_count_lock); + c->threads_count++; + LeaveCriticalSection (&c->threads_count_lock); + LKU(external_mutex); + res = WaitForSingleObject(c->semaphore, val); + if (res == WAIT_OBJECT_0) + return 0; + else + return -1; +} +# define CDW(x, y, t) _ecore_thread_win32_cond_timedwait(x, y, t) typedef struct { - HANDLE semaphore_read; - HANDLE semaphore_write; - SRWLOCK l; + LONG readers_count; + LONG writers_count; + int readers; + int writers; + LK(mutex); + CD(cond_read); + CD(cond_write); } win32_rwl; # define LRWK(x) win32_rwl *x -# define LRWKI(x) \ -do { \ - x = (win32_rwl *)calloc(1, sizeof(win32_rwl)); \ - if (x) \ - { \ - InitializeSRWLock(&x->l); \ - x->semaphore_read = CreateSemaphore (NULL, 0, 1, NULL); \ - if (x->semaphore_read) \ - { \ - x->semaphore_write = CreateSemaphore (NULL, 0, 1, NULL); \ - if (!semaphore_write) \ - { \ - CloseHandle(x->semaphore_read); \ - free(x); \ - x = NULL; \ - } \ - } \ - else \ - { \ - free(x); \ - x = NULL; \ - } \ - } \ - } while (0) +# define LRWKI(x) \ + do { \ + x = (win32_rwl *)calloc(1, sizeof(win32_rwl)); \ + if (x) \ + { \ + LKI(x->mutex); \ + if (x->mutex) \ + { \ + CDI(x->cond_read); \ + if (x->cond_read) \ + { \ + CDI(x->cond_write); \ + if (!x->cond_write) \ + { \ + CDD(x->cond_read); \ + LKD(x->mutex); \ + free(x); \ + x = NULL; \ + } \ + } \ + else \ + { \ + LKD(x->mutex); \ + free(x); \ + x = NULL; \ + } \ + } \ + else \ + { \ + free(x); \ + x = NULL; \ + } \ + } \ + } while (0) # define LRWKD(x) \ do { \ - CloseHandle(x->semaphore_write); \ - CloseHandle(x->semaphore_read); \ + LKU(x->mutex); \ + LKD(x->mutex); \ + CDD(x->cond_write); \ + CDD(x->cond_read); \ free(x); \ } while (0) -# define LRWKWL(x) AcquireSRWLockExclusive(&x->l) -# define LRWKRL(x) AcquireSRWLockShared(&x->l) -# define LRWKU(x) ReleaseSRWLockExclusive(&x->l) +# define LRWKWL(x) \ + do { \ + DWORD res; \ + LKU(x->mutex); \ + if (x->writers || x->readers > 0) \ + { \ + x->writers_count++; \ + while (x->writers || x->readers > 0) \ + { \ + EnterCriticalSection(&x->cond_write->threads_count_lock); \ + x->cond_read->threads_count++; \ + LeaveCriticalSection(&x->cond_write->threads_count_lock); \ + res = WaitForSingleObject(x->cond_write->semaphore, INFINITE); \ + if (res != WAIT_OBJECT_0) break; \ + } \ + x->writers_count--; \ + } \ + if (res == 0) x->writers_count = 1; \ + LKU(x->mutex); \ + } while (0) +# define LRWKRL(x) \ + do { \ + DWORD res; \ + LKL(x->mutex); \ + if (x->writers) \ + { \ + x->readers_count++; \ + while (x->writers) \ + { \ + EnterCriticalSection(&x->cond_write->threads_count_lock); \ + x->cond_read->threads_count++; \ + LeaveCriticalSection(&x->cond_write->threads_count_lock); \ + res = WaitForSingleObject(x->cond_write->semaphore, INFINITE); \ + if (res != WAIT_OBJECT_0) break; \ + } \ + x->readers_count--; \ + } \ + if (res == 0) \ + x->readers++; \ + LKU(x->mutex); \ + } while (0) +# define LRWKU(x) \ + do { \ + LKL(x->mutex); \ + if (x->writers) \ + { \ + x->writers = 0; \ + if (x->readers_count == 1) \ + { \ + EnterCriticalSection(&x->cond_read->threads_count_lock); \ + if (x->cond_read->threads_count > 0) \ + ReleaseSemaphore(x->cond_read->semaphore, 1, 0); \ + LeaveCriticalSection(&x->cond_read->threads_count_lock); \ + } \ + else if (x->readers_count > 0) \ + CDB(x->cond_read); \ + else if (x->writers_count > 0) \ + { \ + EnterCriticalSection (&x->cond_write->threads_count_lock); \ + if (x->cond_write->threads_count > 0) \ + ReleaseSemaphore(x->cond_write->semaphore, 1, 0); \ + LeaveCriticalSection (&x->cond_write->threads_count_lock); \ + } \ + } \ + else if (x->readers > 0) \ + { \ + x->readers--; \ + if (x->readers == 0 && x->writers_count > 0) \ + { \ + EnterCriticalSection (&x->cond_write->threads_count_lock); \ + if (x->cond_write->threads_count > 0) \ + ReleaseSemaphore(x->cond_write->semaphore, 1, 0); \ + LeaveCriticalSection (&x->cond_write->threads_count_lock); \ + } \ + } \ + LKU(x->mutex); \ + } while (0) # endif @@ -480,8 +577,11 @@ _ecore_direct_worker(Ecore_Pthread_Worker *work) { Ecore_Pthread_Data *pth; +#ifdef EFL_POSIX_THREADS pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL); +#endif + eina_sched_prio_drop(); pth = malloc(sizeof (Ecore_Pthread_Data)); @@ -528,8 +628,11 @@ _ecore_thread_worker(Ecore_Pthread_Data *pth) { Ecore_Pthread_Worker *work; +#ifdef EFL_POSIX_THREADS pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL); pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL); +#endif + eina_sched_prio_drop(); LKL(_ecore_pending_job_threads_mutex); @@ -1311,7 +1414,7 @@ ecore_thread_local_data_set(Ecore_Thread *thread, const char *key, void *value, void *ret; if ((!thread) || (!key) || (!value)) return NULL; -#ifdef EFL_HAVE_PTHREAD +#ifdef EFL_HAVE_THREADS if (!PHE(worker->self, PHS())) return NULL; if (!worker->hash) @@ -1354,7 +1457,7 @@ ecore_thread_local_data_find(Ecore_Thread *thread, const char *key) if ((!thread) || (!key)) return NULL; -#ifdef EFL_HAVE_PTHREAD +#ifdef EFL_HAVE_THREADS if (!PHE(worker->self, PHS())) return NULL; if (!worker->hash) @@ -1383,7 +1486,7 @@ ecore_thread_local_data_del(Ecore_Thread *thread, const char *key) Ecore_Thread_Data *d; if ((!thread) || (!key)) return EINA_FALSE; -#ifdef EFL_HAVE_PTHREAD +#ifdef EFL_HAVE_THREADS if (!PHE(worker->self, PHS())) return EINA_FALSE; if (!worker->hash) @@ -1416,7 +1519,7 @@ ecore_thread_global_data_add(const char *key, void *value, Eina_Free_Cb cb, Eina if ((!key) || (!value)) return EINA_FALSE; -#ifdef EFL_HAVE_PTHREAD +#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); @@ -1464,7 +1567,7 @@ ecore_thread_global_data_set(const char *key, void *value, Eina_Free_Cb cb) if ((!key) || (!value)) return NULL; -#ifdef EFL_HAVE_PTHREAD +#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); @@ -1511,7 +1614,7 @@ ecore_thread_global_data_find(const char *key) Ecore_Thread_Data *ret; if (!key) return NULL; -#ifdef EFL_HAVE_PTHREAD +#ifdef EFL_HAVE_THREADS if (!_ecore_thread_global_hash) return NULL; LRWKRL(_ecore_thread_global_hash_lock); @@ -1539,7 +1642,7 @@ ecore_thread_global_data_del(const char *key) if (!key) return EINA_FALSE; -#ifdef EFL_HAVE_PTHREAD +#ifdef EFL_HAVE_THREADS if (!_ecore_thread_global_hash) return EINA_FALSE; @@ -1573,7 +1676,7 @@ ecore_thread_global_data_wait(const char *key, double seconds) Ecore_Thread_Data *ret = NULL; if (!key) return NULL; -#ifdef EFL_HAVE_PTHREAD +#ifdef EFL_HAVE_THREADS if (!_ecore_thread_global_hash) return NULL; if (seconds > 0) @@ -1581,10 +1684,17 @@ ecore_thread_global_data_wait(const char *key, double seconds) while (1) { +#ifndef _WIN32 struct timespec t = { 0, 0 }; t.tv_sec = (long int)time; t.tv_nsec = (long int)((time - (double)t.tv_sec) * 1000000000); +#else + struct timeval t = { 0, 0 }; + + t.tv_sec = (long int)time; + t.tv_usec = (long int)((time - (double)t.tv_sec) * 1000000); +#endif LRWKRL(_ecore_thread_global_hash_lock); ret = eina_hash_find(_ecore_thread_global_hash, key); LRWKU(_ecore_thread_global_hash_lock); -- 2.7.4