Eina_List *
eio_pack_send(Ecore_Thread *thread, Eina_List *pack, double *start)
{
double current;
current = ecore_time_get();
if (current - *start > EIO_PACKED_TIME)
{
*start = current;
ecore_thread_feedback(thread, pack);
return NULL;
}
if (memory_pool_limit > 0 &&
memory_pool_usage > memory_pool_limit)
{
eina_lock_take(&(memory_pool_mutex));
memory_pool_suspended = EINA_TRUE;
eina_condition_wait(&(memory_pool_cond));
memory_pool_suspended = EINA_FALSE;
eina_lock_release(&(memory_pool_mutex));
}
return pack;
}
Eina_Bool enesim_barrier_wait(Enesim_Barrier *barrier)
{
eina_lock_take(&(barrier->cond_lock));
barrier->called++;
if (barrier->called == barrier->needed)
{
barrier->called = 0;
eina_condition_broadcast(&(barrier->cond));
}
else
eina_condition_wait(&(barrier->cond));
eina_lock_release(&(barrier->cond_lock));
return EINA_TRUE;
}
EAPI void *
ecore_main_loop_thread_safe_call_sync(Ecore_Data_Cb callback,
void *data)
{
Ecore_Safe_Call *order;
void *ret;
if (!callback) return NULL;
if (eina_main_loop_is())
{
return callback(data);
}
order = malloc(sizeof (Ecore_Safe_Call));
if (!order) return NULL;
order->cb.sync = callback;
order->data = data;
eina_lock_new(&order->m);
eina_condition_new(&order->c, &order->m);
order->sync = EINA_TRUE;
order->suspend = EINA_FALSE;
_ecore_main_loop_thread_safe_call(order);
eina_lock_take(&order->m);
eina_condition_wait(&order->c);
eina_lock_release(&order->m);
ret = order->data;
order->sync = EINA_FALSE;
order->cb.async = _thread_safe_cleanup;
order->data = order;
_ecore_main_loop_thread_safe_call(order);
return ret;
}
EAPI int
ecore_thread_main_loop_begin(void)
{
Ecore_Safe_Call *order;
if (eina_main_loop_is())
{
return ++_thread_loop;
}
order = malloc(sizeof (Ecore_Safe_Call));
if (!order) return -1;
eina_lock_take(&_thread_id_lock);
order->current_id = ++_thread_id_max;
if (order->current_id < 0)
{
_thread_id_max = 0;
order->current_id = ++_thread_id_max;
}
eina_lock_release(&_thread_id_lock);
eina_lock_new(&order->m);
eina_condition_new(&order->c, &order->m);
order->suspend = EINA_TRUE;
_ecore_main_loop_thread_safe_call(order);
eina_lock_take(&order->m);
while (order->current_id != _thread_id)
eina_condition_wait(&order->c);
eina_lock_release(&order->m);
eina_main_loop_define();
_thread_loop = 1;
return EINA_TRUE;
}
EINA_LIST_FREE(callback, call)
{
if (call->suspend)
{
eina_lock_take(&_thread_mutex);
eina_lock_take(&call->m);
_thread_id = call->current_id;
eina_condition_broadcast(&call->c);
eina_lock_release(&call->m);
while (_thread_id_update != _thread_id)
eina_condition_wait(&_thread_cond);
eina_lock_release(&_thread_mutex);
eina_main_loop_define();
eina_lock_take(&_thread_feedback_mutex);
_thread_id = -1;
eina_condition_broadcast(&_thread_feedback_cond);
eina_lock_release(&_thread_feedback_mutex);
_thread_safe_cleanup(call);
free(call);
}
else if (call->sync)
{
call->data = call->cb.sync(call->data);
eina_condition_broadcast(&call->c);
}
else
{
call->cb.async(call->data);
free(call);
}
}
EAPI int
ecore_thread_main_loop_end(void)
{
int current_id;
if (_thread_loop == 0)
{
ERR("the main loop is not locked ! No matching call to ecore_thread_main_loop_begin().");
return -1;
}
/* until we unlock the main loop, this thread has the main loop id */
if (!eina_main_loop_is())
{
ERR("Not in a locked thread !");
return -1;
}
_thread_loop--;
if (_thread_loop > 0)
return _thread_loop;
current_id = _thread_id;
eina_lock_take(&_thread_mutex);
_thread_id_update = _thread_id;
eina_condition_broadcast(&_thread_cond);
eina_lock_release(&_thread_mutex);
eina_lock_take(&_thread_feedback_mutex);
while (current_id == _thread_id && _thread_id != -1)
eina_condition_wait(&_thread_feedback_cond);
eina_lock_release(&_thread_feedback_mutex);
return 0;
}
