cedric pushed a commit to branch master. http://git.enlightenment.org/core/efl.git/commit/?id=08c3102dc0710e32df81f4e18586bddfdfad0cc1
commit 08c3102dc0710e32df81f4e18586bddfdfad0cc1 Author: Cedric BAIL <ced...@osg.samsung.com> Date: Mon Nov 7 10:49:02 2016 -0800 ecore: remove ecore_thread_promise_run. --- src/Makefile_Ecore.am | 1 - src/lib/ecore/Ecore_Common.h | 13 +- src/lib/ecore/ecore_thread_promise.c | 241 ----------------------------------- 3 files changed, 1 insertion(+), 254 deletions(-) diff --git a/src/Makefile_Ecore.am b/src/Makefile_Ecore.am index 28d9756..1eeab08 100644 --- a/src/Makefile_Ecore.am +++ b/src/Makefile_Ecore.am @@ -88,7 +88,6 @@ lib/ecore/ecore_poller.c \ lib/ecore/ecore_time.c \ lib/ecore/ecore_timer.c \ lib/ecore/ecore_thread.c \ -lib/ecore/ecore_thread_promise.c \ lib/ecore/ecore_throttle.c \ lib/ecore/ecore_exe.c \ lib/ecore/ecore_exe_private.h \ diff --git a/src/lib/ecore/Ecore_Common.h b/src/lib/ecore/Ecore_Common.h index a95087f..da85a68 100644 --- a/src/lib/ecore/Ecore_Common.h +++ b/src/lib/ecore/Ecore_Common.h @@ -3130,19 +3130,8 @@ typedef struct _Ecore_Job Ecore_Job; /**< A job handle */ /* * @brief Function callback type for when creating Ecore_Thread that - * uses Ecore_Promise for communication + * uses Efl_Future for communication. */ -typedef void(*Ecore_Thread_Promise_Cb)(const void* data, Eina_Promise_Owner* promise, Ecore_Thread* thread); - -/* - * @brief Function that instantiates a Ecore_Promise and automatically - * executes func_blocking callback function in another thread - */ -EAPI Ecore_Thread* ecore_thread_promise_run(Ecore_Thread_Promise_Cb func_heavy, - Ecore_Thread_Promise_Cb func_cancel, - const void* data, - Eina_Promise** promise); - typedef void (*Ecore_Thread_Future_Cb)(const void *data, Eo *promise, Ecore_Thread *thread); EAPI Efl_Future *ecore_thread_future_run(Ecore_Thread_Future_Cb heavy, const void *data, Eina_Free_Cb free_cb); diff --git a/src/lib/ecore/ecore_thread_promise.c b/src/lib/ecore/ecore_thread_promise.c deleted file mode 100644 index 9531978..0000000 --- a/src/lib/ecore/ecore_thread_promise.c +++ /dev/null @@ -1,241 +0,0 @@ -#ifdef HAVE_CONFIG_H -#include <config.h> -#endif - -#include <Eina.h> -#include <Ecore.h> - -#include <assert.h> - -#include <ecore_private.h> - -struct _Ecore_Thread_Data -{ - Ecore_Thread_Promise_Cb func_blocking; - Ecore_Thread_Promise_Cb func_cancel; - void const* data; - Ecore_Thread* thread; -}; -typedef struct _Ecore_Thread_Data _Ecore_Thread_Data; - -struct _Ecore_Thread_Promise_Owner -{ - Eina_Promise_Owner_VTable owner_vtable; - Eina_Promise_Owner* eina_owner; - Eina_Promise_VTable promise_vtable; - Eina_Promise* eina_promise; - Eina_Promise_Owner* owner_pointer; - Eina_Promise* promise_pointer; - _Ecore_Thread_Data thread_callback_data; - int ref_count; - int then_count; -}; -typedef struct _Ecore_Thread_Promise_Owner _Ecore_Thread_Promise_Owner; - -#define ECORE_PROMISE_GET_OWNER(p) (_Ecore_Thread_Promise_Owner*)((unsigned char*)p - offsetof(struct _Ecore_Thread_Promise_Owner, promise_vtable)) - -static void _ecore_promise_ref_update(_Ecore_Thread_Promise_Owner* p) -{ - if(p->ref_count < 0) - { - ERR("Reference count is negative for promise %p\n", p); - } - if(!p->ref_count) - { - eina_promise_unref(p->eina_promise); - if (!p->then_count) // Whether we still own the initial eina_promise ref - eina_promise_unref(p->eina_promise); - p->eina_promise = NULL; - p->eina_owner = NULL; - p->thread_callback_data.thread = NULL; - free(p); - } -} - -static void _ecore_promise_thread_release_ref(void* data, void* value EINA_UNUSED) -{ - _Ecore_Thread_Promise_Owner* p = data; - p->ref_count -= p->then_count; - _ecore_promise_ref_update(p); -} - -static void _ecore_promise_thread_end(void* data, Ecore_Thread* thread EINA_UNUSED) -{ - _Ecore_Thread_Promise_Owner* p = data; - if(!eina_promise_owner_pending_is(p->eina_owner)) - { - eina_promise_owner_default_manual_then_set(p->eina_owner, EINA_FALSE); - eina_promise_owner_default_call_then(p->eina_owner); - p->ref_count -= p->then_count; - _ecore_promise_ref_update(p); - } - else - { - eina_promise_owner_default_manual_then_set(p->eina_owner, EINA_FALSE); - // This then will steal the ref to the eina_promise, working - // refcount-wise like a normal then on the thread promise. - p->ref_count++; - p->then_count++; - eina_promise_then(p->eina_promise, &_ecore_promise_thread_release_ref, - (Eina_Promise_Error_Cb)&_ecore_promise_thread_release_ref, p); - } -} - -static void -_ecore_promise_thread_blocking(void* data, Ecore_Thread* thread EINA_UNUSED) -{ - _Ecore_Thread_Promise_Owner* promise = data; - (promise->thread_callback_data.func_blocking)(promise->thread_callback_data.data, promise->owner_pointer, thread); -} - -static void _ecore_promise_thread_notify(void* data, Ecore_Thread* thread EINA_UNUSED, void* msg_data) -{ - _Ecore_Thread_Promise_Owner* promise = data; - eina_promise_owner_progress(promise->eina_owner, msg_data); -} - -static void _ecore_promise_cancel_cb(void* data, Eina_Promise_Owner* promise EINA_UNUSED) -{ - _Ecore_Thread_Promise_Owner* priv = data; - (priv->thread_callback_data.func_cancel)(priv->thread_callback_data.data, priv->owner_pointer, - priv->thread_callback_data.thread); -} - -static void _ecore_promise_thread_cancel(void* data, Ecore_Thread* thread EINA_UNUSED) -{ - _Ecore_Thread_Promise_Owner* owner = data; - Eina_Promise* promise; - - promise = eina_promise_owner_promise_get(owner->eina_owner); - eina_promise_cancel(promise); -} - -static void _ecore_promise_owner_value_set(_Ecore_Thread_Promise_Owner* promise, void* data, Eina_Promise_Free_Cb free) -{ - eina_promise_owner_value_set(promise->eina_owner, data, free); -} -static void _ecore_promise_owner_error_set(_Ecore_Thread_Promise_Owner* promise, Eina_Error error) -{ - eina_promise_owner_error_set(promise->eina_owner, error); -} -static Eina_Bool _ecore_promise_owner_pending_is(_Ecore_Thread_Promise_Owner const* promise) -{ - return eina_promise_owner_pending_is(promise->eina_owner); -} -static Eina_Bool _ecore_promise_owner_cancelled_is(_Ecore_Thread_Promise_Owner const* promise) -{ - return eina_promise_owner_cancelled_is(promise->eina_owner); -} -static Eina_Promise* _ecore_thread_promise_owner_promise_get(_Ecore_Thread_Promise_Owner* promise) -{ - return promise->promise_pointer; -} -static void _ecore_thread_promise_owner_progress(_Ecore_Thread_Promise_Owner* promise, void* data) -{ - ecore_thread_feedback(promise->thread_callback_data.thread, data); -} -static void _ecore_thread_promise_owner_progress_notify(_Ecore_Thread_Promise_Owner* promise, - Eina_Promise_Progress_Notify_Cb progress_cb, - void* data, Eina_Promise_Free_Cb free_cb) -{ - eina_promise_owner_progress_notify(promise->eina_owner, progress_cb, data, free_cb); -} - -static void _ecore_promise_then(Eina_Promise* promise, Eina_Promise_Cb callback, - Eina_Promise_Error_Cb error_cb, void* data) -{ - _Ecore_Thread_Promise_Owner* v = ECORE_PROMISE_GET_OWNER(promise); - eina_promise_then(v->eina_promise, callback, error_cb, data); - v->ref_count++; - v->then_count++; -} -static void* _ecore_promise_value_get(Eina_Promise const* promise) -{ - _Ecore_Thread_Promise_Owner* v = ECORE_PROMISE_GET_OWNER(promise); - return eina_promise_value_get(v->eina_promise); -} -static Eina_Error _ecore_promise_error_get(Eina_Promise const* promise) -{ - _Ecore_Thread_Promise_Owner* v = ECORE_PROMISE_GET_OWNER(promise); - return eina_promise_error_get(v->eina_promise); -} -static Eina_Bool _ecore_promise_pending_is(Eina_Promise const* promise) -{ - _Ecore_Thread_Promise_Owner* v = ECORE_PROMISE_GET_OWNER(promise); - return eina_promise_pending_is(v->eina_promise); -} -static void _ecore_promise_progress_cb_add(Eina_Promise const* promise, Eina_Promise_Progress_Cb callback, void* data, - Eina_Promise_Free_Cb free_cb) -{ - _Ecore_Thread_Promise_Owner* v = ECORE_PROMISE_GET_OWNER(promise); - eina_promise_progress_cb_add(v->eina_promise, callback, data, free_cb); -} -static void _ecore_promise_cancel(Eina_Promise const* promise) -{ - _Ecore_Thread_Promise_Owner* v = ECORE_PROMISE_GET_OWNER(promise); - eina_promise_cancel(v->eina_promise); -} -static void _ecore_promise_ref(Eina_Promise const* promise) -{ - _Ecore_Thread_Promise_Owner* v = ECORE_PROMISE_GET_OWNER(promise); - ++v->ref_count; -} -static void _ecore_promise_unref(Eina_Promise const* promise) -{ - _Ecore_Thread_Promise_Owner* v = ECORE_PROMISE_GET_OWNER(promise); - --v->ref_count; -} - -Ecore_Thread* ecore_thread_promise_run(Ecore_Thread_Promise_Cb func_blocking, - Ecore_Thread_Promise_Cb func_cancel, - const void* data, - Eina_Promise** promise) -{ - _Ecore_Thread_Promise_Owner* priv; - - priv = malloc(sizeof(_Ecore_Thread_Promise_Owner)); - - priv->eina_owner = eina_promise_add(); - - priv->owner_vtable.version = EINA_PROMISE_VERSION; - priv->owner_vtable.value_set = EINA_FUNC_PROMISE_OWNER_VALUE_SET(&_ecore_promise_owner_value_set); - priv->owner_vtable.error_set = EINA_FUNC_PROMISE_OWNER_ERROR_SET(&_ecore_promise_owner_error_set); - priv->owner_vtable.promise_get = EINA_FUNC_PROMISE_OWNER_PROMISE_GET(&_ecore_thread_promise_owner_promise_get); - priv->owner_vtable.pending_is = EINA_FUNC_PROMISE_OWNER_PENDING_IS(&_ecore_promise_owner_pending_is); - priv->owner_vtable.cancelled_is = EINA_FUNC_PROMISE_OWNER_CANCELLED_IS(&_ecore_promise_owner_cancelled_is); - priv->owner_vtable.progress = EINA_FUNC_PROMISE_OWNER_PROGRESS(&_ecore_thread_promise_owner_progress); - priv->owner_vtable.progress_notify = EINA_FUNC_PROMISE_OWNER_PROGRESS_NOTIFY(&_ecore_thread_promise_owner_progress_notify); - EINA_MAGIC_SET(&priv->owner_vtable, EINA_MAGIC_PROMISE_OWNER); - priv->owner_pointer = eina_promise_owner_override(&priv->owner_vtable); - - priv->promise_vtable.then = EINA_FUNC_PROMISE_THEN(&_ecore_promise_then); - priv->promise_vtable.value_get = EINA_FUNC_PROMISE_VALUE_GET(&_ecore_promise_value_get); - priv->promise_vtable.error_get = EINA_FUNC_PROMISE_ERROR_GET(&_ecore_promise_error_get); - priv->promise_vtable.pending_is = EINA_FUNC_PROMISE_PENDING_IS(&_ecore_promise_pending_is); - priv->promise_vtable.progress_cb_add = EINA_FUNC_PROMISE_PROGRESS_CB_ADD(&_ecore_promise_progress_cb_add); - priv->promise_vtable.cancel = EINA_FUNC_PROMISE_CANCEL(&_ecore_promise_cancel); - priv->promise_vtable.ref = EINA_FUNC_PROMISE_REF(&_ecore_promise_ref); - priv->promise_vtable.unref = EINA_FUNC_PROMISE_UNREF(&_ecore_promise_unref); - EINA_MAGIC_SET(&priv->promise_vtable, EINA_MAGIC_PROMISE); - priv->promise_pointer = eina_promise_override(&priv->promise_vtable); - - priv->thread_callback_data.data = data; - priv->thread_callback_data.func_blocking = func_blocking; - priv->thread_callback_data.func_cancel = func_cancel; - eina_promise_owner_default_manual_then_set(priv->eina_owner, EINA_TRUE); - - priv->eina_promise = eina_promise_owner_promise_get(priv->eina_owner); - eina_promise_ref(priv->eina_promise); - priv->ref_count = 0; - priv->then_count = 0; - - if(func_cancel) - eina_promise_owner_default_cancel_cb_add(priv->eina_owner, &_ecore_promise_cancel_cb, priv, NULL); - priv->thread_callback_data.thread = - ecore_thread_feedback_run(&_ecore_promise_thread_blocking, &_ecore_promise_thread_notify, - &_ecore_promise_thread_end, &_ecore_promise_thread_cancel, priv, - EINA_FALSE); - if(promise) - *promise = priv->promise_pointer; - return priv->thread_callback_data.thread; -} --