From f9b57e55698cae1b22f8a474b18d3c3113a63830 Mon Sep 17 00:00:00 2001 From: caiosignor Date: Fri, 13 Mar 2020 12:57:56 -0300 Subject: [PATCH] merged from devs/coquinho/lock --- src/lib/eina/eina_debug.c | 13 +++++-- src/lib/eina/eina_debug_bt.c | 10 +++-- src/lib/eina/eina_debug_cpu.c | 10 ++++- src/lib/eina/eina_debug_timer.c | 17 ++++++-- src/lib/eina/eina_evlog.c | 3 +- src/lib/eina/eina_main.c | 3 +- src/lib/eina/eina_thread.c | 11 ++++-- src/lib/eina/eina_thread.h | 17 ++++++++ src/lib/eina/eina_thread_win32.c | 47 +++++++++++++++-------- src/lib/eina/meson.build | 2 + src/lib/evil/unposix/pthread.h | 66 +++----------------------------- 11 files changed, 103 insertions(+), 96 deletions(-) diff --git a/src/lib/eina/eina_debug.c b/src/lib/eina/eina_debug.c index c811c5fe2a..6d077723bc 100644 --- a/src/lib/eina/eina_debug.c +++ b/src/lib/eina/eina_debug.c @@ -556,14 +556,17 @@ _monitor(void *_data) // set a name for this thread for system debugging #ifdef EINA_HAVE_PTHREAD_SETNAME +/* # ifndef __linux__ pthread_set_name_np # else pthread_setname_np # endif (pthread_self(), "Edbg-mon"); -#endif +*/ +#endif + eina_thread_name_set(eina_thread_self(), "Edbg-mon"); // sit forever processing commands or timeouts in the debug monitor // thread - this is separate to the rest of the app so it shouldn't // impact the application specifically @@ -704,14 +707,16 @@ eina_debug_session_data_get(Eina_Debug_Session *session) Eina_Bool eina_debug_init(void) { - pthread_t self; + + Eina_Thread self;//pthread_t self; eina_threads_init(); // For Windows support GetModuleFileName can be used // set up thread things eina_spinlock_new(&_eina_debug_lock); eina_spinlock_new(&_eina_debug_thread_lock); - self = pthread_self(); + + self = eina_thread_self(); //self = pthread_self(); _eina_debug_thread_mainloop_set(&self); _eina_debug_thread_add(&self); _eina_debug_cpu_init(); @@ -735,7 +740,7 @@ Eina_Bool eina_debug_shutdown(void) { Eina_Debug_Session *session; - pthread_t self = pthread_self(); + Eina_Thread self = eina_thread_self(); //pthread_t self = pthread_self(); EINA_LIST_FREE(sessions, session) eina_debug_session_terminate(session); diff --git a/src/lib/eina/eina_debug_bt.c b/src/lib/eina/eina_debug_bt.c index a2510e9123..b30111d357 100644 --- a/src/lib/eina/eina_debug_bt.c +++ b/src/lib/eina/eina_debug_bt.c @@ -197,7 +197,9 @@ _signal_handler(int sig EINA_UNUSED, siginfo_t *si EINA_UNUSED, void *foo EINA_UNUSED) { int i, slot = 0; - pthread_t self = pthread_self(); + + //pthread_t self = pthread_self(); + Eina_Thread self = eina_thread_self(); #if defined(HAVE_CLOCK_GETTIME) && defined(HAVE_SCHED_GETCPU) && defined(__clockid_t_defined) clockid_t cid; #endif @@ -235,7 +237,9 @@ found: _bt_cpu[slot] = sched_getcpu(); # ifdef HAVE_PTHREAD_GETCPUCLOCKID /* Try pthread_getcpuclockid() first */ - pthread_getcpuclockid(self, &cid); + #ifndef _WIN32 + pthread_getcpuclockid(self, &cid); + #endif # elif defined(_POSIX_THREAD_CPUTIME) /* Fallback to POSIX clock id. */ cid = CLOCK_THREAD_CPUTIME_ID; @@ -292,7 +296,7 @@ _signal_shutdown(void) } static void -_collect_bt(pthread_t pth) +_collect_bt(Eina_Thread pth)// _collect_bt(pthread_t pth) { // this async signals the thread to switch to the deebug signal handler // and collect a backtrace and other info from inside the thread diff --git a/src/lib/eina/eina_debug_cpu.c b/src/lib/eina/eina_debug_cpu.c index 931139f5c0..27e52f7199 100644 --- a/src/lib/eina/eina_debug_cpu.c +++ b/src/lib/eina/eina_debug_cpu.c @@ -80,7 +80,10 @@ _sysmon(void *data EINA_UNUSED, Eina_Thread thr EINA_UNUSED) for (i = 0; i < _eina_debug_thread_active_num; i++) { // get the correct clock id to use for the target thread - pthread_getcpuclockid + #ifndef _WIN32 + pthread_getcpuclockid(self, &cid); + #endif + // pthread_getcpuclockid (_eina_debug_thread_active[i].thread, &cid); // get the clock cpu time accumulation for that threas clock_gettime(cid, &t); @@ -126,7 +129,10 @@ _sysmon(void *data EINA_UNUSED, Eina_Thread thr EINA_UNUSED) { Eina_Thread thread = _eina_debug_thread_active[i].thread; // get the clock for the thread and its cpu time usage - pthread_getcpuclockid(thread, &cid); + #ifndef _WIN32 + pthread_getcpuclockid(thread, &cid); + #endif + //pthread_getcpuclockid(thread, &cid); clock_gettime(cid, &t); // calculate a long timestamp (64bits) tim1 = (_eina_debug_thread_active[i].clok.tv_sec * 1000000000LL) + diff --git a/src/lib/eina/eina_debug_timer.c b/src/lib/eina/eina_debug_timer.c index 8d03c0e57b..4d97690b96 100644 --- a/src/lib/eina/eina_debug_timer.c +++ b/src/lib/eina/eina_debug_timer.c @@ -56,7 +56,8 @@ struct _Eina_Debug_Timer static Eina_List *_timers = NULL; static Eina_Bool _thread_runs = EINA_FALSE; -static pthread_t _thread; +//static pthread_t _thread; +static Eina_Thread _thread; static int pipeToThread[2]; @@ -95,17 +96,22 @@ _monitor(void *_data EINA_UNUSED) ret = epoll_ctl(epfd, EPOLL_CTL_ADD, event.data.fd, &event); if (ret) perror("epoll_ctl/add"); #ifdef EINA_HAVE_PTHREAD_SETNAME +/* # ifndef __linux__ pthread_set_name_np # else pthread_setname_np # endif (pthread_self(), "Edbg-tim"); +*/ #endif + eina_thread_name_set(eina_thread_self(), "Edbg-tim"); while (1) { int timeout = -1; //in milliseconds - pthread_testcancel(); + #ifndef _WIN32 + pthread_testcancel(); + #endif eina_spinlock_take(&_lock); if (_timers) { @@ -115,7 +121,9 @@ _monitor(void *_data EINA_UNUSED) eina_spinlock_release(&_lock); ret = epoll_wait(epfd, events, MAX_EVENTS, timeout); - pthread_testcancel(); + #ifndef _WIN32 + pthread_testcancel(); + #endif /* Some timer has been add/removed or we need to exit */ if (ret) @@ -228,7 +236,8 @@ _eina_debug_timer_shutdown(void) close(pipeToThread[0]); close(pipeToThread[1]); if (_thread_runs) - pthread_cancel(_thread); + eina_thread_cancel(_thread);//pthread_cancel(_thread); + _thread_runs = 0; eina_spinlock_release(&_lock); eina_spinlock_free(&_lock); diff --git a/src/lib/eina/eina_evlog.c b/src/lib/eina/eina_evlog.c index eb32dfc27b..bebf8e9d41 100644 --- a/src/lib/eina/eina_evlog.c +++ b/src/lib/eina/eina_evlog.c @@ -176,7 +176,8 @@ eina_evlog(const char *event, void *obj, double srctime, const char *detail) item = (Eina_Evlog_Item *)strings; item->tim = SWAP_DBL(now); item->srctim = SWAP_DBL(srctime); - item->thread = SWAP_64((unsigned long long)(uintptr_t)pthread_self()); + //item->thread = SWAP_64((unsigned long long)(uintptr_t)pthread_self()); + item->thread = SWAP_64((unsigned long long)(uintptr_t)eina_thread_self()); item->obj = SWAP_64((unsigned long long)(uintptr_t)obj); item->event_offset = SWAP_16(sizeof(Eina_Evlog_Item)); item->detail_offset = SWAP_16(detail_offset); diff --git a/src/lib/eina/eina_main.c b/src/lib/eina/eina_main.c index 47dd80a898..1db66a6e4e 100644 --- a/src/lib/eina/eina_main.c +++ b/src/lib/eina/eina_main.c @@ -65,6 +65,7 @@ #include "eina_freeq.h" #include "eina_slstr.h" #include "eina_vpath.h" +#include "eina_thread.h" /*============================================================================* * Local * @@ -98,7 +99,7 @@ EAPI Eina_Error EINA_ERROR_NOT_IMPLEMENTED = 0; EAPI unsigned int eina_seed = 0; #ifdef EFL_HAVE_THREADS -EAPI pthread_t _eina_main_loop; +EAPI Eina_Thread _eina_main_loop; //EAPI pthread_t _eina_main_loop; #endif #ifdef MT diff --git a/src/lib/eina/eina_thread.c b/src/lib/eina/eina_thread.c index 5871449929..8e83cd798e 100644 --- a/src/lib/eina/eina_thread.c +++ b/src/lib/eina/eina_thread.c @@ -140,16 +140,17 @@ eina_thread_cancel(Eina_Thread t) EAPI Eina_Bool eina_thread_cancellable_set(Eina_Bool cancellable, Eina_Bool *was_cancellable) { - int state = cancellable ? PTHREAD_CANCEL_ENABLE : PTHREAD_CANCEL_DISABLE; + int state = cancellable ? EINA_THREAD_CANCEL_ENABLE : EINA_THREAD_CANCEL_DISABLE; int old = 0; int r; #ifndef _WIN32 /* enforce deferred in case users changed to asynchronous themselves */ - pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, &old); + + pthread_setcanceltype(EINA_THREAD_CANCEL_DEFERRED, &old); r = pthread_setcancelstate(state, &old); if (was_cancellable && r == 0) - *was_cancellable = (old == PTHREAD_CANCEL_ENABLE); + *was_cancellable = (old == EINA_THREAD_CANCEL_ENABLE); return r == 0; #else if(!state){ @@ -185,7 +186,9 @@ eina_thread_cancellable_run(Eina_Thread_Cancellable_Run_Cb cb, Eina_Free_Cb clea return ret; } -EAPI const void *EINA_THREAD_JOIN_CANCELED = PTHREAD_CANCELED; + +EAPI const void *EINA_THREAD_JOIN_CANCELED = EINA_THREAD_CANCELED; + Eina_Bool eina_thread_init(void) diff --git a/src/lib/eina/eina_thread.h b/src/lib/eina/eina_thread.h index 856b623770..e5859c3a0d 100644 --- a/src/lib/eina/eina_thread.h +++ b/src/lib/eina/eina_thread.h @@ -351,6 +351,23 @@ struct _Eina_Thread_Call }; + +#ifdef _WIN32 +# define EINA_THREAD_CANCEL_ENABLE 0 +# define EINA_THREAD_CANCEL_DISABLE 1 +# define EINA_THREAD_CANCEL_DEFERRED 0 +# define EINA_THREAD_CANCEL_ASYNCHRONOUS 1 +# define EINA_THREAD_CANCELED ((void *) -1) +#else +# define EINA_THREAD_CANCEL_ENABLE PTHREAD_CANCEL_ENABLE +# define EINA_THREAD_CANCEL_DISABLE PTHREAD_CANCEL_DISABLE +# define EINA_THREAD_CANCEL_DEFERRED PTHREAD_CANCEL_DEFERRED +# define EINA_THREAD_CANCEL_ASYNCHRONOUS PTHREAD_CANCEL_ASYNCHRONOUS +# define EINA_THREAD_CANCELED PTHREAD_CANCELED +#endif + + + /** * @} */ diff --git a/src/lib/eina/eina_thread_win32.c b/src/lib/eina/eina_thread_win32.c index 4b2c9b695f..4a329c1774 100644 --- a/src/lib/eina/eina_thread_win32.c +++ b/src/lib/eina/eina_thread_win32.c @@ -49,10 +49,16 @@ #endif #endif -typedef struct _Eina_win32_thread_attr{ +typedef struct _Eina_win32_thread_func{ void *data; void *(*func)(void *data); +}Eina_win32_thread_func; + +typedef struct _Eina_win32_thread_attr{ + LPSECURITY_ATTRIBUTES lpThreadAttributes; + SIZE_T dwStackSize; + DWORD dwCreationFlags; }Eina_win32_thread_attr; @@ -69,18 +75,9 @@ _eina_thread_join(Eina_Thread t) - - DWORD WINAPI _eina_thread_func(void *params) { - // // Code - //Eina_Thread_Call *c = params; - //void *r; - //r = c->func((void*) c->data, eina_thread_self()); - //return (DWORD) r; - //return (DWORD) _eina_internal_call(params); - - return (DWORD) ((Eina_win32_thread_attr *)params)->func( (void*) ((Eina_win32_thread_attr *)params)->data); + return (DWORD) ((Eina_win32_thread_func *)params)->func( (void*) ((Eina_win32_thread_func *)params)->data); } @@ -102,19 +99,35 @@ inline Eina_Bool _eina_thread_create(Eina_Thread *t, int affinity, void *(*func)(void *data), void *data) { Eina_Bool ret; + Eina_win32_thread_attr thread_attr; + + SECURITY_ATTRIBUTES sec_attributes; + + sec_attributes.nLength = sizeof(SECURITY_ATTRIBUTES); + sec_attributes.lpSecurityDescriptor = NULL; + sec_attributes.bInheritHandle = EINA_TRUE; + + thread_attr.lpThreadAttributes = &sec_attributes; + + thread_attr.dwStackSize = 4000; + thread_attr.dwCreationFlags = 0; LPDWORD threadID; - Eina_win32_thread_attr *thread_attr = (Eina_win32_thread_attr*) malloc(sizeof(Eina_win32_thread_attr)); + //Eina_win32_thread_func *thread_func = (Eina_win32_thread_func*) malloc(sizeof(Eina_win32_thread_func)); + Eina_win32_thread_func thread_func; Eina_Thread_Call *c = (Eina_Thread_Call*)(data); - thread_attr->func = func; - thread_attr->data = data; + thread_func.func = func; + thread_func.data = data; - *t =(HANDLE) CreateThread(NULL, 0, &_eina_thread_func,thread_attr,0,threadID); - - free(thread_attr); + + + *t =(HANDLE) CreateThread(thread_attr.lpThreadAttributes,thread_attr.dwStackSize, &_eina_thread_func,&thread_func,thread_attr.dwCreationFlags,threadID); + //free(thread_func); + + _eina_thread_set_priority(c->prio,t); //SetThreadPriority(*t, c->prio); diff --git a/src/lib/eina/meson.build b/src/lib/eina/meson.build index 386d0423b1..0b3b495bd1 100644 --- a/src/lib/eina/meson.build +++ b/src/lib/eina/meson.build @@ -200,9 +200,11 @@ sources = [ if sys_windows == true sources += 'eina_file_win32.c' sources += 'eina_thread_win32.c' + sources += 'eina_lock_win32.c' else sources += 'eina_file.c' sources += 'eina_thread_posix.c' + sources += 'eina_lock_posix.c' endif eina_config = configuration_data() diff --git a/src/lib/evil/unposix/pthread.h b/src/lib/evil/unposix/pthread.h index e970da5226..12d43c3e2f 100644 --- a/src/lib/evil/unposix/pthread.h +++ b/src/lib/evil/unposix/pthread.h @@ -142,79 +142,25 @@ UNIMPLEMENTED inline int pthread_getschedparam(void* a, ...) #warning pthread_getschedparam is not implemented. return 0; } - +/* UNIMPLEMENTED inline int pthread_self() { #warning pthread_self is not implemented. return 0; -} +}*/ UNIMPLEMENTED inline int pthread_setschedparam(void* c, void* d, void* e) { #warning pthread_ is not implemented. return 0; } - -UNIMPLEMENTED inline int pthread_rwlock_init(void* a, ...) -{ - #warning pthread_rwlock_init is not implemented. - return 0; -} - -UNIMPLEMENTED inline int pthread_mutexattr_settype(void* a, ...) -{ - #warning pthread_mutexattr_settype is not implemented. - return 0; -} - -UNIMPLEMENTED inline int pthread_mutex_init(void* a, ...) -{ - #warning pthread_mutex_init is not implemented. - return 0; -} - -UNIMPLEMENTED inline int pthread_mutex_destroy(void* a, ...) -{ - #warning pthread_mutex_destroy is not implemented. - return 0; -} - -UNIMPLEMENTED inline int pthread_condattr_init(void* a, ...) -{ - #warning pthread_condattr_init is not implemented. - return 0; -} - -UNIMPLEMENTED inline int pthread_cond_init(void* a, ...) -{ - #warning pthread_cond_init is not implemented. - return 0; -} - -UNIMPLEMENTED inline int pthread_condattr_destroy(void* a, ...) -{ - #warning pthread_condattr_destroy is not implemented. - return 0; -} - -UNIMPLEMENTED inline int pthread_cond_destroy(void* a, ...) -{ - #warning pthread_cond_destroy is not implemented. - return 0; -} - -UNIMPLEMENTED inline int pthread_rwlock_destroy(void* a, ...) -{ - #warning pthread_rwlock_destroy is not implemented. - return 0; -} - +/* UNIMPLEMENTED inline int pthread_cancel(void* a, ...) { #warning pthread_cancel is not implemented. return 0; } - +*/ UNIMPLEMENTED inline int pthread_setcancelstate(void* a, ...) { #warning pthread_setcancelstate is not implemented. @@ -244,7 +190,7 @@ UNIMPLEMENTED inline int pthread_attr_init(void* a, ...) #warning pthread_attr_init is not implemented. return 0; } - +/* UNIMPLEMENTED inline int pthread_join(void* a, ...) { #warning pthread_join is not implemented. @@ -262,7 +208,7 @@ UNIMPLEMENTED inline int pthread_equal(void* a, ...) #warning pthread_equal is not implemented. return 0; } - +*/ UNIMPLEMENTED inline int pthread_setcanceltype(void* a, ...) { #warning pthread_setcanceltype is not implemented.