kimcinoo
/
efl
forked from enlightenment/efl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
efl/src/lib/eina/eina_thread.c

46 lines
1.4 KiB
C
Raw Normal View History

efl: add Eina_Thread API. SVN revision: 78225
2012-10-18 22:47:33 -07:00
/* EINA - EFL data type library
* Copyright (C) 2012 Cedric Bail
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library;
* if not, see <http://www.gnu.org/licenses/>.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
eina: Implement Eina_Thread for native windows The implementation design respects the fact that Eina_Thread is an uintptr_t. Thus we allocate the thread struct in the heap and return a pointer to it. As such, we store the created thread structure in the target thread TLS slot. For threads that were not created through eina API, in eina_thread_self we allocate a new structure, push it to the TLS slot and mark it to be freed on thread exit. Reviewers: jptiz, walac, vtorri, woohyun, lucas Reviewed By: jptiz, cedric Subscribers: raster, cedric, #reviewers, #committers, lucas Tags: #efl Differential Revision: https://phab.enlightenment.org/D12037
2020-12-15 11:13:48 -08:00
#include <stddef.h>
efl: add Eina_Thread API. SVN revision: 78225
2012-10-18 22:47:33 -07:00
eina: Implement Eina_Thread for native windows The implementation design respects the fact that Eina_Thread is an uintptr_t. Thus we allocate the thread struct in the heap and return a pointer to it. As such, we store the created thread structure in the target thread TLS slot. For threads that were not created through eina API, in eina_thread_self we allocate a new structure, push it to the TLS slot and mark it to be freed on thread exit. Reviewers: jptiz, walac, vtorri, woohyun, lucas Reviewed By: jptiz, cedric Subscribers: raster, cedric, #reviewers, #committers, lucas Tags: #efl Differential Revision: https://phab.enlightenment.org/D12037
2020-12-15 11:13:48 -08:00
#ifdef HAVE_PTHREAD_H
# include <pthread.h>
eina - dont use SCHED_BATCH or SCHED_IDLE unless they are defined
2020-05-25 02:27:19 -07:00
#endif
efl: add Eina_Thread API. SVN revision: 78225
2012-10-18 22:47:33 -07:00
eina: Implement Eina_Thread for native windows The implementation design respects the fact that Eina_Thread is an uintptr_t. Thus we allocate the thread struct in the heap and return a pointer to it. As such, we store the created thread structure in the target thread TLS slot. For threads that were not created through eina API, in eina_thread_self we allocate a new structure, push it to the TLS slot and mark it to be freed on thread exit. Reviewers: jptiz, walac, vtorri, woohyun, lucas Reviewed By: jptiz, cedric Subscribers: raster, cedric, #reviewers, #committers, lucas Tags: #efl Differential Revision: https://phab.enlightenment.org/D12037
2020-12-15 11:13:48 -08:00
#include "eina_types.h"
#include "eina_config.h"
#include "eina_thread.h"
eina/ecore: allow threads to be canceled, use in ecore_con. As discussed in the mailing list, many people will use worker threads to execute blocking syscalls and mandating ecore_thread_check() for voluntary preemption reduces the ecore_thread usefulness a lot. A clear example is ecore_con usage of connect() and getaddrinfo() in threads. If the connect timeout expires, the thread will be cancelled, but it was blocked on syscalls and they will hang around for long time. If the application exits, ecore will print an error saying it can SEGV. Then enable access to pthread_setcancelstate(PTHREAD_CANCEL_ENABLE) via eina_thread_cancellable_set(EINA_TRUE), to pthread_cancel() via eina_thread_cancel(), to pthread_cleanup_push()/pthread_cleanup_pop() via EINA_THREAD_CLEANUP_PUSH()/EINA_THREAD_CLEANUP_POP() and so on. Ecore threads will enforce non-cancellable threads on its own code, but the user may decide to enable that and allow cancellation, that's not an issue since ecore_thread now plays well and use cleanup functions. Ecore con connect/resolve make use of that and enable cancellable state, efl_net_dialer_tcp benefits a lot from that. A good comparison of the benefit is to run: ./src/examples/ecore/efl_io_copier_example tcp://google.com:1234 :stdout: before and after. It will timeout after 30s and with this patch the thread is gone, no ecore error is printed about possible SEGV.
2016-09-13 21:38:58 -07:00
eina: Rename EAPI macro to EINA_API in Eina library Summary: Patch from a series of patches to rename EAPI symbols to specific library DSOs. EAPI was designed to be able to pass `__attribute__ ((visibility ("default")))` for symbols with GCC, which would mean that even if -fvisibility=hidden was used when compiling the library, the needed symbols would get exported. MSVC __almost__ works like GCC (or mingw) in which you can declare everything as export and it will just work (slower, but it will work). But there's a caveat: global variables will not work the same way for MSVC, but works for mingw and GCC. For global variables (as opposed to functions), MSVC requires correct DSO visibility for MSVC: instead of declaring a symbol as export for everything, you need to declare it as import when importing from another DSO and export when defining it locally. With current EAPI definitions, we get the following example working in mingw and MSVC (observe it doesn't define any global variables as exported symbols). Example 1: dll1: ``` EAPI void foo(void); EAPI void bar() { foo(); } ``` dll2: ``` EAPI void foo() { printf ("foo\n"); } ``` This works fine with API defined as __declspec(dllexport) in both cases and for gcc defining as `__atttribute__((visibility("default")))` However, the following: Example 2: dll1: ``` EAPI extern int foo; EAPI void foobar(void); EAPI void bar() { foo = 5; foobar(); } ``` dll2: ``` EAPI int foo = 0; EAPI void foobar() { printf ("foo %d\n", foo); } ``` This will work on mingw but will not work for MSVC. And that's why EAPI is the only solution that worked for MSVC. Co-authored-by: João Paulo Taylor Ienczak Zanette <jpaulotiz@gmail.com> Co-authored-by: Ricardo Campos <ricardo.campos@expertise.dev> Co-authored-by: Lucas Cavalcante de Sousa <lucks.sousa@gmail.com> Reviewers: jptiz, lucas, woohyun, vtorri, raster Reviewed By: jptiz, lucas, vtorri Subscribers: ProhtMeyhet, cedric, #reviewers, #committers Tags: #efl Differential Revision: https://phab.enlightenment.org/D12188
2020-11-25 04:35:48 -08:00
EINA_API void *
eina: don't make eina_thread_cancellable_run() inline Seems to me there is little benefit of inlining this function, but this also had a pervert effect on Windows and C++ with some recent mingw versions. Mingw failed its implementation of pthread_cleanup_pop(). It does not compile when compiled in C++. There is a type mismatch that is caught by the compiler, and everything goes nuts... This made the EFL build fail because some files of ecore_win32 are C++ sources, and they require Eina... so this macro appears in a C++ code indirectly, because of its inlining. By removing the inlining, this build issue is fixed. Will also fix builds of other programs that would have used Eina.h in their C++ programs :)
2016-11-15 10:59:54 -08:00
eina_thread_cancellable_run(Eina_Thread_Cancellable_Run_Cb cb, Eina_Free_Cb cleanup_cb, void *data)
{
Eina_Bool old = EINA_FALSE;
void *ret;
EINA_THREAD_CLEANUP_PUSH(cleanup_cb, data);
eina_thread_cancellable_set(EINA_TRUE, &old); // is a cancellation point
ret = cb(data); // may not run if was previously canceled
EINA_THREAD_CLEANUP_POP(EINA_TRUE);
eina_thread_cancellable_set(old, NULL);
return ret;
}