This group provides thread locking and synchronization capabilities. More...
Macros | |
#define | EINA_MAIN_LOOP_CHECK_RETURN_VAL(val) |
The macro doesn't do anything unless EINA_HAVE_DEBUG_THREADS is defined. More... | |
#define | EINA_MAIN_LOOP_CHECK_RETURN |
The macro doesn't do anything unless EINA_HAVE_DEBUG_THREADS is defined. | |
Typedefs | |
typedef void(* | Eina_TLS_Delete_Cb) (void *ptr) |
A callback type for deallocation of thread level sotrage data. | |
Enumerations | |
enum | Eina_Lock_Result { EINA_LOCK_FAIL = EINA_FALSE, EINA_LOCK_SUCCEED = EINA_TRUE, EINA_LOCK_DEADLOCK } |
Return codes for lock operations. More... | |
Functions | |
static Eina_Bool | eina_lock_new (Eina_Lock *mutex) |
Initializes a new #Eina_Lock. More... | |
static void | eina_lock_free (Eina_Lock *mutex) |
Deallocates an #Eina_Lock. More... | |
static Eina_Lock_Result | eina_lock_take (Eina_Lock *mutex) |
Attempts to take a lock. More... | |
static Eina_Lock_Result | eina_lock_take_try (Eina_Lock *mutex) |
Attempts to take a lock if possible. More... | |
static Eina_Lock_Result | eina_lock_release (Eina_Lock *mutex) |
Releases a lock. More... | |
static void | eina_lock_debug (const Eina_Lock *mutex) |
Print debug information about a lock. More... | |
static Eina_Bool | eina_condition_new (Eina_Condition *cond, Eina_Lock *mutex) |
Initializes a new condition variable. More... | |
static void | eina_condition_free (Eina_Condition *cond) |
Deallocates a condition variable. More... | |
static Eina_Bool | eina_condition_wait (Eina_Condition *cond) |
Causes a thread to wait until signaled by the condition. More... | |
static Eina_Bool | eina_condition_timedwait (Eina_Condition *cond, double t) |
Causes a thread to wait until signaled by the condition or a timeout is reached. More... | |
static Eina_Bool | eina_condition_broadcast (Eina_Condition *cond) |
Signal all threads waiting for a condition. More... | |
static Eina_Bool | eina_condition_signal (Eina_Condition *cond) |
Signal a thread waiting for a condition. More... | |
static Eina_Bool | eina_rwlock_new (Eina_RWLock *mutex) |
Initializes a new #Eina_RWLock. More... | |
static void | eina_rwlock_free (Eina_RWLock *mutex) |
Deallocates an #Eina_RWLock. More... | |
static Eina_Lock_Result | eina_rwlock_take_read (Eina_RWLock *mutex) |
Attempts to take a read lock. More... | |
static Eina_Lock_Result | eina_rwlock_take_write (Eina_RWLock *mutex) |
Attempts to take a write lock. More... | |
static Eina_Lock_Result | eina_rwlock_release (Eina_RWLock *mutex) |
Releases a lock. More... | |
static Eina_Bool | eina_tls_new (Eina_TLS *key) |
Initializes a new #Eina_TLS, or thread level storage, to store thread specific data. More... | |
static Eina_Bool | eina_tls_cb_new (Eina_TLS *key, Eina_TLS_Delete_Cb delete_cb) |
Initializes a new #Eina_TLS, or thread level storage, to store thread specific data. More... | |
static void | eina_tls_free (Eina_TLS key) |
Frees an allocated #Eina_TLS. More... | |
static void * | eina_tls_get (Eina_TLS key) |
Gets the value in #Eina_TLS for this thread. More... | |
static Eina_Bool | eina_tls_set (Eina_TLS key, const void *data) |
Sets the value in Eina_TLS for this thread. More... | |
static Eina_Bool | eina_semaphore_new (Eina_Semaphore *sem, int count_init) |
Initializes a new #Eina_Semaphore. More... | |
static Eina_Bool | eina_semaphore_free (Eina_Semaphore *sem) |
Frees an allocated #Eina_Semaphore. More... | |
static Eina_Bool | eina_semaphore_lock (Eina_Semaphore *sem) |
Gets a lock on an #Eina_Semaphore. More... | |
static Eina_Bool | eina_semaphore_release (Eina_Semaphore *sem, int count_release) |
Releases a lock on an #Eina_Semaphore. More... | |
static Eina_Bool | eina_barrier_new (Eina_Barrier *barrier, int needed) |
Initializes a new #Eina_Barrier. More... | |
static void | eina_barrier_free (Eina_Barrier *barrier) |
Frees an allocated #Eina_Barrier. More... | |
static Eina_Bool | eina_barrier_wait (Eina_Barrier *barrier) |
Increments the count of threads that are waiting on barrier . More... | |
static Eina_Bool | eina_spinlock_new (Eina_Spinlock *spinlock) |
Initializes a new #Eina_Spinlock. More... | |
static Eina_Lock_Result | eina_spinlock_take (Eina_Spinlock *spinlock) |
Attempts to take a spinlock. More... | |
static Eina_Lock_Result | eina_spinlock_take_try (Eina_Spinlock *spinlock) |
Attempts to take a spinlock if possible. More... | |
static Eina_Lock_Result | eina_spinlock_release (Eina_Spinlock *spinlock) |
Releases a spinlock. More... | |
static void | eina_spinlock_free (Eina_Spinlock *spinlock) |
Deallocates an #Eina_Spinlock. More... | |
Variables | |
EAPI Eina_Error | EINA_ERROR_NOT_MAIN_LOOP |
A type definition for warning that a function was called from somewhere other than the EFL main loop. | |
This group provides thread locking and synchronization capabilities.
Similar to POISIX threads (pthreads), but it takes care of the platform specific details so you don't have to.
If you know how pthreads
work, this library will look familiar to you. If you are not familiar with pthreads
, a good overview is available here
The Eina lock functions are grouped into several categories to handle different thread locking and sychronization methods:
#define EINA_MAIN_LOOP_CHECK_RETURN_VAL | ( | val | ) |
The macro doesn't do anything unless EINA_HAVE_DEBUG_THREADS
is defined.
[in] | val | The value to be returned |
Referenced by ecore_animator_del(), ecore_animator_frametime_get(), ecore_animator_source_get(), ecore_event_add(), ecore_event_current_event_get(), ecore_event_current_type_get(), ecore_event_del(), ecore_event_filter_add(), ecore_event_filter_del(), ecore_event_handler_add(), ecore_event_handler_data_get(), ecore_event_handler_data_set(), ecore_event_handler_del(), ecore_event_type_new(), ecore_exe_cmd_get(), ecore_exe_data_get(), ecore_exe_data_set(), ecore_exe_event_data_get(), ecore_exe_flags_get(), ecore_exe_free(), ecore_exe_pid_get(), ecore_exe_pipe_run(), ecore_exe_run(), ecore_exe_run_priority_get(), ecore_exe_send(), ecore_exe_tag_get(), ecore_job_add(), ecore_job_del(), ecore_main_fd_handler_active_get(), ecore_main_fd_handler_add(), ecore_main_fd_handler_del(), ecore_main_fd_handler_fd_get(), ecore_main_fd_handler_file_add(), ecore_main_loop_iterate_may_block(), ecore_main_loop_select_func_get(), ecore_pipe_del(), ecore_pipe_full_add(), ecore_pipe_read_fd(), ecore_pipe_write_fd(), ecore_poller_del(), ecore_poller_poll_interval_get(), ecore_thread_active_get(), ecore_thread_feedback_run(), ecore_thread_max_get(), ecore_thread_pending_feedback_get(), ecore_thread_pending_get(), ecore_thread_pending_total_get(), ecore_thread_run(), ecore_throttle_get(), ecore_timer_add(), ecore_timer_del(), ecore_timer_loop_add(), and ecore_timer_precision_get().
enum Eina_Lock_Result |
|
inlinestatic |
Initializes a new #Eina_Lock.
[in] | mutex | The #Eina_Lock structure to be initialized |
This function initializes an #Eina_Lock with appropriate values. These values are platform dependent as is the structure of the #Eina_Lock itself.
Referenced by ecore_init(), ecore_main_loop_thread_safe_call_sync(), ecore_thread_main_loop_begin(), eet_init(), eio_init(), efl::eina::mutex::mutex(), and efl::eina::thread::thread().
|
inlinestatic |
Deallocates an #Eina_Lock.
[in] | mutex | The #Eina_Lock structure to be deallocated |
This function deallocates an #Eina_Lock allocated by eina_lock_new() and does any platform dependent cleanup that is required.
Referenced by elm_store_free(), emotion_shutdown(), evas_async_events_put(), evas_free(), and efl::eina::mutex::~mutex().
|
inlinestatic |
Attempts to take a lock.
[in] | mutex | The #Eina_Lock to take |
This function attempts to gain a lock on the indicated #Eina_Lock. If the underlying #Eina_Lock is locked already, this call can be blocked until the lock is released. This is appropriate in many cases, but consider using eina_lock_take_try() if you don't need to block.
Referenced by ecore_fork_reset(), ecore_main_loop_thread_safe_call_sync(), ecore_thread_main_loop_begin(), ecore_thread_main_loop_end(), efreet_desktop_free(), eina_file_dup(), eina_file_flush(), eina_file_virtual_map_all(), eina_file_virtual_map_free(), eina_file_virtual_map_new(), eina_tmpstr_add_length(), eina_tmpstr_del(), eina_tmpstr_len(), eina_tmpstr_manage_new_length(), eio_memory_burst_limit_set(), elm_store_free(), emotion_shutdown(), evas_async_events_put(), and efl::eina::mutex::lock().
|
inlinestatic |
Attempts to take a lock if possible.
[in] | mutex | The #Eina_Lock to take |
This function attempts to gain a lock on the indicated #Eina_Lock. Identical eina_lock_take(), but returns immediately if the lock is already taken.
Referenced by efl::eina::mutex::try_lock().
|
inlinestatic |
Releases a lock.
[in] | mutex | The #Eina_Lock to release |
This function releases the lock on the indicated #Eina_Lock. If successful, and EINA_HAVE_DEBUG_THREADS
is defined, mutex
is updated and information about the locking process is removed (e.g. thread number and backtrace for POSIX).
Referenced by ecore_fork_reset(), ecore_main_loop_thread_safe_call_sync(), ecore_thread_main_loop_begin(), ecore_thread_main_loop_end(), efreet_desktop_free(), eina_file_dup(), eina_file_flush(), eina_file_virtual_map_all(), eina_file_virtual_map_free(), eina_file_virtual_map_new(), eina_tmpstr_add_length(), eina_tmpstr_del(), eina_tmpstr_len(), eina_tmpstr_manage_new_length(), eio_memory_burst_limit_set(), elm_store_free(), emotion_shutdown(), evas_async_events_put(), and efl::eina::mutex::unlock().
|
inlinestatic |
Print debug information about a lock.
[in] | mutex | The #Eina_Lock to print debug info for. |
This function prints debug information for mutex
. The information is platform dependant. On POSIX systems it prints the address of mutex
, lock state, thread number and a backtrace.
EINA_HAVE_DEBUG_THREADS
is not defined, this function does nothing. EINA_HAVE_DEBUG_THREADS
being set. Referenced by efl::eina::mutex::debug(), and eina_threads_shutdown().
|
inlinestatic |
Initializes a new condition variable.
[in] | cond | The condition variable to create |
[in] | mutex | The #Eina_Lock structure that controls access to this condition variable |
This function initializes an #Eina_Condition structure and associates it with an existing lock.
Condition variables are used to coordinate actions between threads. See Condition Varable Overview for an introduction to condition variables and their use.
Referenced by efl::eina::condition_variable::condition_variable(), ecore_init(), ecore_main_loop_thread_safe_call_sync(), ecore_thread_main_loop_begin(), eio_init(), and efl::eina::thread::thread().
|
inlinestatic |
Deallocates a condition variable.
[in] | cond | The condition variable to be deallocated. |
This function deallocates a condition variable and does any platform dependent cleanup that is required.
Referenced by evas_async_events_put(), and efl::eina::condition_variable::~condition_variable().
|
inlinestatic |
Causes a thread to wait until signaled by the condition.
[in] | cond | The #Eina_Condition upon which the thread waits. |
This function makes a thread block until a signal is sent to it via cond
.
Referenced by ecore_main_loop_thread_safe_call_sync(), ecore_thread_main_loop_begin(), ecore_thread_main_loop_end(), evas_async_events_put(), and efl::eina::condition_variable::wait().
|
inlinestatic |
Causes a thread to wait until signaled by the condition or a timeout is reached.
[in] | cond | The #Eina_Condition upon which the thread waits. |
[in] | t | The maximum amount of time to wait, in seconds. |
This function makes a thread block until either a signal is sent to it via cond
or t
seconds have passed.
|
inlinestatic |
Signal all threads waiting for a condition.
[in] | cond | The #Eina_Condition that signals all its waiting threads. |
This function sends a signal to all the threads waiting on the condition cond
. If you know for sure that there is only one thread waiting, use eina_condition_signal() instead to gain a little optimization.
Referenced by ecore_thread_main_loop_end(), eio_memory_burst_limit_set(), evas_async_events_put(), and efl::eina::condition_variable::notify_all().
|
inlinestatic |
Signal a thread waiting for a condition.
[in] | cond | The #Eina_Condition that signals its waiting thread. |
This function sends a signal to a thread waiting on the condition cond
. If you do not know for sure that there is only one thread waiting, use eina_condition_broadcast() instead.
Referenced by efl::eina::condition_variable::notify_one().
|
inlinestatic |
Initializes a new #Eina_RWLock.
[in] | mutex | The #Eina_RWLock to be initialized. |
This function initializes an #Eina_RWLock with appropriate values. These values are platform dependent as is the structure of the #Eina_RWLock itself.
|
inlinestatic |
Deallocates an #Eina_RWLock.
[in] | mutex | The #Eina_RWLock structure to be deallocated. |
This function deallocates an #Eina_RWLock and does any platform dependent cleanup that is required.
|
inlinestatic |
Attempts to take a read lock.
[in] | mutex | The #Eina_RWLock to take. |
This function attempts to gain a read lock on the indicated #Eina_RWLock. If the #Eina_RWLock is write locked, this call can be blocked until the lock is released.
|
inlinestatic |
Attempts to take a write lock.
[in] | mutex | The #Eina_RWLock to take. |
This function attempts to gain a write lock on the indicated #Eina_RWLock. If the #Eina_RWLock is locked for reading or writing, this call can be blocked until the lock is released.
|
inlinestatic |
Releases a lock.
[in] | mutex | The #Eina_RWLock to release. |
This function releases the lock on the indicated #Eina_RWLock.
|
inlinestatic |
Initializes a new #Eina_TLS, or thread level storage, to store thread specific data.
[in] | key | The #Eina_TLS to be initialized. |
This function initializes an #Eina_TLS with key
but does not set a callback to deallocate key
when the thread exits. The implementation is platform dependent as is the structure of the #Eina_TLS itself.
key
.Referenced by evas_gl_new().
|
inlinestatic |
Initializes a new #Eina_TLS, or thread level storage, to store thread specific data.
[in] | key | The #Eina_TLS to be initialized. |
[in] | delete_cb | A pointer to a function that deallocates key . |
This function initializes an #Eina_TLS with key
and sets a callback to deallocate key
when the thread exits. The implementation is platform dependent as is the structure of the #Eina_TLS itself.
|
inlinestatic |
Frees an allocated #Eina_TLS.
[in] | key | The #Eina_TLS to be freed. |
This function frees the #Eina_TLS key
. The implementation is platform dependent.
|
inlinestatic |
Gets the value in #Eina_TLS for this thread.
[in] | key | The #Eina_TLS to be retrieved. |
key
.This function gets a pointer to the data associated with #Eina_TLS key
for this thread. The implementation is platform dependent.
Referenced by eina_error_get(), evas_gl_current_evas_gl_get(), and evas_gl_free().
|
inlinestatic |
Sets the value in Eina_TLS for this thread.
[in] | key | The #Eina_TLS to be set. |
[in] | data | A pointer to the data to be stored. |
This function sets the value associated with key
to the pointer to the data data
. The implementation is platform dependent.
Referenced by eina_error_set(), evas_gl_free(), evas_gl_make_current(), and evas_gl_new().
|
inlinestatic |
Initializes a new #Eina_Semaphore.
[in] | sem | The #Eina_Semaphore to be initialized. |
[in] | count_init | Indicates the initial count of threads waiting on this semaphore. |
This function initializes an unnamed #Eina_Semaphore with appropriate values. These values are platform dependent.
Referenced by eina_thread_queue_new().
|
inlinestatic |
Frees an allocated #Eina_Semaphore.
[in] | sem | The #Eina_Semaphore to be freed. |
This function frees the #Eina_Semaphore sem
. The implementation is platform dependent.
Referenced by eina_thread_queue_free().
|
inlinestatic |
Gets a lock on an #Eina_Semaphore.
[in] | sem | The #Eina_Semaphore to lock. |
This function locks the #Eina_Semaphore sem
. The implementation is platform dependent.
|
inlinestatic |
Releases a lock on an #Eina_Semaphore.
[in] | sem | The #Eina_Semaphore to release. |
[in] | count_release | Not used. |
This function releases a lock on the #Eina_Semaphore sem
. The implementation is platform dependent.
|
inlinestatic |
Initializes a new #Eina_Barrier.
[in] | barrier | The #Eina_Barrier to be initialized. |
[in] | needed | The number of thread waits that causes this barrier to be reset. |
This function initializes a new #Eina_Barrier. It sets the needed
flag to the value of needed
, sets the barrier's count
member to 0 and creates new #Eina_Lock and #Eina_Condition objects for the barrier.
|
inlinestatic |
Frees an allocated #Eina_Barrier.
[in] | barrier | The #Eina_Barrier to be freed. |
This function frees the #Eina_Barrier barrier
.
|
inlinestatic |
Increments the count of threads that are waiting on barrier
.
[in] | barrier | The #Eina_Barrier to be incremented. |
When the count of threads reaches the needed
value for the barrier, all waiting threads are notified via eina_condition_broadcast().
|
inlinestatic |
Initializes a new #Eina_Spinlock.
[in] | spinlock | The #Eina_Spinlock to be initialized. |
This function initializes a new #Eina_Spinlock, if spinlocks are available. If spinlocks are not avialable, it creates a new #Eina_Lock.
Referenced by eina_safepointer_unregister(), eina_thread_queue_new(), eio_init(), and eo_init().
|
inlinestatic |
Attempts to take a spinlock.
[in] | spinlock | The #Eina_Spinlock to take. |
This function attempts to gain a lock on the indicated #Eina_Spinlock. If the underlying #Eina_Spinlock is locked already, this call can be blocked until the lock is released. This is appropriate in many cases, but consider using eina_spinlock_take_try() if you don't need to block.
Referenced by eet_dictionary_count(), eet_dictionary_string_check(), eina_rectangle_new(), eina_safepointer_register(), eina_safepointer_unregister(), eina_stringshare_add_length(), eina_stringshare_del(), eina_stringshare_ref(), eina_thread_queue_poll(), eina_thread_queue_send(), eina_thread_queue_wait(), evas_async_events_fd_get(), evas_async_events_put(), and evas_render_updates_free().
|
inlinestatic |
Attempts to take a spinlock if possible.
[in] | spinlock | The #Eina_Spinlock to take. |
This function attempts to gain a lock on the indicated #Eina_Spinlock. Identical to eina_lock_take(), but returns immediately if the lock is already taken.
|
inlinestatic |
Releases a spinlock.
[in] | spinlock | The #Eina_Spinlock to release. |
This function will release the lock on the indicated #Eina_Spinlock. If successful, and EINA_HAVE_DEBUG_THREADS
is defined, mutex
is updated and information about the locking process is removed (e.g. thread number and backtrace for POSIX).
Referenced by eet_dictionary_count(), eet_dictionary_string_check(), eina_rectangle_new(), eina_safepointer_register(), eina_safepointer_unregister(), eina_stringshare_add_length(), eina_stringshare_del(), eina_stringshare_ref(), eina_thread_queue_poll(), eina_thread_queue_send(), eina_thread_queue_wait(), evas_async_events_fd_get(), evas_async_events_put(), and evas_render_updates_free().
|
inlinestatic |
Deallocates an #Eina_Spinlock.
[in] | spinlock | The #Eina_Spinlock to be deallocated. |
This function deallocates an #Eina_Spinlock and does any platform dependent cleanup that is required.
Referenced by eina_safepointer_unregister(), eina_thread_queue_free(), eo_class_name_get(), and evas_free().