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

188 lines
5.8 KiB
C
Raw Normal View History

Eo: pointers indirection mechanism for objects and classes Summary: This feature replaces Eo pointers with ids to prevent bad usage or reuse of these pointers. It doesn't change API. The mechanism uses tables storing the real pointers to the objects. See the src/lib/eo/eo_ptr_indirection.c file for more details on the mechanism.
2013-04-18 04:19:02 -07:00
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include "eo_ptr_indirection.h"
eo invalid err - make the thread self more useful like main.
2016-09-16 13:49:32 -07:00
extern Eina_Thread _efl_object_main_thread;
eo - make eo id table TLS private data for thread safety and speed This moved all the eoid tables, eoid lookup caches, generation count information ad eo_isa cache into a TLS segment of memory that is thread private. There is also a shared domain for EO objects that all threads can access, but it has an added cost of a lock. This means objects accessed outside the thread they were created in cannot be accessed by another thread unless they are adopted in temporarily, or create4d with the shared domain active at the time of creation. child objects will use their parent object domain if created with a parent object passed in. If you were accessing EO (EFL) objects across threads before then this will actually now cause your code to fail as it was invalid before to do this as no actual objects were threadsafe in EFL, so this will force things to "fail early". ecore_thread_main_loop_begin() and end() still work as this uses the eo domain adoption features to temporarily adopt a domain during this section and then return it when done. This returns speed back to eo brining the overhead in my tests of lookup for the elm genlist autobounce test in elementary from about 5-7% down to 2.5-2.6%. A steep drop. This does not mean everything is perfect. Still to do are: 1. Tests in the test suite 2. Some API's to help for sending objects from thread to thread 3. Make the eo call cache TLS data to make it also safe 4. Look at other locks in eo and probably move them to TLS data 5. Make eo resolve and call wrappers that call the real method func do recursive mutex wrapping of the given object IF it is a shared object to provide threadsafety transparently for shared objects (but adding some overhead as a result) 6. Test test est, and that is why this commit is going in now for wider testing 7. Decide how to make this work with sending IPC (between threads) 8. Deciding what makes an object sendable (a sendable property in base?) 9. Deciding what makes an object shareable (a sharable property in base?)
2016-09-07 01:53:33 -07:00
//////////////////////////////////////////////////////////////////////////
eo ptr ind: speed up by caching last used table - keep a reference to the last used table and it's indexes - use this table prior to normal search through table arrays
2013-05-05 06:08:55 -07:00
eo id and shared domain objects - do locking properly and better so there were a few issues. one we had a spinlokc on the eoid table for shared objects AND then had a mutex for accessing those objects (released on return from any eo function). BUT this missed some funcs like eo_ref, eo_unref and so on in eo.c ... oops. so fixed. but then i realized there was a race condition. we locked the eoid table then unlocked with our pointer THEN locked the sharted object mutex ... then unlocked it. that was a race condtion gap. so we should share the same lock anyway - if it's a shared object, grab the shared object mutex then do a lookup and if the lookup does not fail, KEEP the lock until it is released by the return from eo function or by some special macro/funcs that released a matching lock. since its a recursive lock this is all fine. as its also a universal single lock for all objects we just need the eoid to know if it's shared and needs locking based on the domain bits. so now do this locking properly with just a single mutex, not both a spinlock and mutex and keep the lock around until totally done with the object. this plugs the race condition holes and goes from 1 spinlock lock and unlock then a mutex lock and unlokc to just a single mutex lock and unlock. this means shared objects are actually truly safe across threads and only have the overhead of a single recursive mutex to lock and unlock in every api call.
2016-09-27 21:25:26 -07:00
Eina_TLS _eo_table_data;
Eo_Id_Data *_eo_table_data_shared = NULL;
Eo_Id_Table_Data *_eo_table_data_shared_data = NULL;
Eo: pointers indirection mechanism for objects and classes Summary: This feature replaces Eo pointers with ids to prevent bad usage or reuse of these pointers. It doesn't change API. The mechanism uses tables storing the real pointers to the objects. See the src/lib/eo/eo_ptr_indirection.c file for more details on the mechanism.
2013-04-18 04:19:02 -07:00
eo - make eo id table TLS private data for thread safety and speed This moved all the eoid tables, eoid lookup caches, generation count information ad eo_isa cache into a TLS segment of memory that is thread private. There is also a shared domain for EO objects that all threads can access, but it has an added cost of a lock. This means objects accessed outside the thread they were created in cannot be accessed by another thread unless they are adopted in temporarily, or create4d with the shared domain active at the time of creation. child objects will use their parent object domain if created with a parent object passed in. If you were accessing EO (EFL) objects across threads before then this will actually now cause your code to fail as it was invalid before to do this as no actual objects were threadsafe in EFL, so this will force things to "fail early". ecore_thread_main_loop_begin() and end() still work as this uses the eo domain adoption features to temporarily adopt a domain during this section and then return it when done. This returns speed back to eo brining the overhead in my tests of lookup for the elm genlist autobounce test in elementary from about 5-7% down to 2.5-2.6%. A steep drop. This does not mean everything is perfect. Still to do are: 1. Tests in the test suite 2. Some API's to help for sending objects from thread to thread 3. Make the eo call cache TLS data to make it also safe 4. Look at other locks in eo and probably move them to TLS data 5. Make eo resolve and call wrappers that call the real method func do recursive mutex wrapping of the given object IF it is a shared object to provide threadsafety transparently for shared objects (but adding some overhead as a result) 6. Test test est, and that is why this commit is going in now for wider testing 7. Decide how to make this work with sending IPC (between threads) 8. Deciding what makes an object sendable (a sendable property in base?) 9. Deciding what makes an object shareable (a sharable property in base?)
2016-09-07 01:53:33 -07:00
//////////////////////////////////////////////////////////////////////////
Eo: Add internal function call on pointer errors Useful for GDB: break on this function when things go wrong. Similar to eina_safety. I guess we could set some Eina_Error and maybe even have error callbacks for easier application debugging. Later.
2015-12-29 02:42:05 -08:00
void
_eo_pointer_error(const char *msg)
{
ERR("%s", msg);
}
eo - move eoid lookup to ptr indir file and clean up some code this improves the readability of some of the new domain related and ptr indir code..
2016-09-09 02:44:21 -07:00
eo - id lookup failure expansive error print for ebbter debug whenan eoid lookup fails, now print a lot of information on the issue like the actual id, generation of the id, if its a class or object (the class bit), if its ref or super bit is set, the actual id (which includes the table heirachy), which thread id it is, what domain the object id is and the current and local domains as well as what domains are mapped in.
2016-09-16 02:51:22 -07:00
#ifdef HAVE_EO_ID
static void
_eo_obj_pointer_invalid(const Eo_Id obj_id,
Eo_Id_Data *data,
unsigned char domain)
{
eo invalid err - make the thread self more useful like main.
2016-09-16 13:49:32 -07:00
Eina_Thread thread = eina_thread_self();
const char *tself = "main";
eo - id lookup failure expansive error print for ebbter debug whenan eoid lookup fails, now print a lot of information on the issue like the actual id, generation of the id, if its a class or object (the class bit), if its ref or super bit is set, the actual id (which includes the table heirachy), which thread id it is, what domain the object id is and the current and local domains as well as what domains are mapped in.
2016-09-16 02:51:22 -07:00
const char *type = "object";
eo invalid err - make the thread self more useful like main.
2016-09-16 13:49:32 -07:00
char tbuf[128];
eo - id lookup failure expansive error print for ebbter debug whenan eoid lookup fails, now print a lot of information on the issue like the actual id, generation of the id, if its a class or object (the class bit), if its ref or super bit is set, the actual id (which includes the table heirachy), which thread id it is, what domain the object id is and the current and local domains as well as what domains are mapped in.
2016-09-16 02:51:22 -07:00
if (obj_id & ((Eo_Id)1 << (REF_TAG_SHIFT - 1))) type = "class";
eo invalid err - make the thread self more useful like main.
2016-09-16 13:49:32 -07:00
if (thread != _efl_object_main_thread)
{
snprintf(tbuf, sizeof(tbuf), "%p", (void *)thread);
tself = tbuf;
}
eo - id lookup failure expansive error print for ebbter debug whenan eoid lookup fails, now print a lot of information on the issue like the actual id, generation of the id, if its a class or object (the class bit), if its ref or super bit is set, the actual id (which includes the table heirachy), which thread id it is, what domain the object id is and the current and local domains as well as what domains are mapped in.
2016-09-16 02:51:22 -07:00
ERR("EOID %p is not a valid %s. "
"EOID domain=%i, current_domain=%i, local_domain=%i. "
"EOID generation=%lx, id=%lx, ref=%i, super=%i. "
eo invalid err - make the thread self more useful like main.
2016-09-16 13:49:32 -07:00
"Thread self=%s. "
eo - id lookup failure expansive error print for ebbter debug whenan eoid lookup fails, now print a lot of information on the issue like the actual id, generation of the id, if its a class or object (the class bit), if its ref or super bit is set, the actual id (which includes the table heirachy), which thread id it is, what domain the object id is and the current and local domains as well as what domains are mapped in.
2016-09-16 02:51:22 -07:00
"Available domains [%s %s %s %s]. "
"Maybe it has been deleted or does not belong to your thread?",
(void *)obj_id,
type,
(int)domain,
(int)data->domain_stack[data->stack_top],
(int)data->local_domain,
(unsigned long)(obj_id & MASK_GENERATIONS),
(unsigned long)(obj_id >> SHIFT_ENTRY_ID) & (MAX_ENTRY_ID | MAX_TABLE_ID | MAX_MID_TABLE_ID),
(int)(obj_id >> REF_TAG_SHIFT) & 0x1,
(int)(obj_id >> SUPER_TAG_SHIFT) & 0x1,
eo invalid err - make the thread self more useful like main.
2016-09-16 13:49:32 -07:00
tself,
eo - id lookup failure expansive error print for ebbter debug whenan eoid lookup fails, now print a lot of information on the issue like the actual id, generation of the id, if its a class or object (the class bit), if its ref or super bit is set, the actual id (which includes the table heirachy), which thread id it is, what domain the object id is and the current and local domains as well as what domains are mapped in.
2016-09-16 02:51:22 -07:00
(data->tables[0]) ? "0" : " ",
(data->tables[1]) ? "1" : " ",
(data->tables[2]) ? "2" : " ",
(data->tables[3]) ? "3" : " "
);
}
#endif
eo - move eoid lookup to ptr indir file and clean up some code this improves the readability of some of the new domain related and ptr indir code..
2016-09-09 02:44:21 -07:00
_Eo_Object *
_eo_obj_pointer_get(const Eo_Id obj_id)
{
#ifdef HAVE_EO_ID
_Eo_Id_Entry *entry;
Generation_Counter generation;
Table_Index mid_table_id, table_id, entry_id;
Eo_Id tag_bit;
Eo_Id_Data *data;
Eo_Id_Table_Data *tdata;
unsigned char domain;
// NULL objects will just be sensibly ignored. not worth complaining
// every single time.
data = _eo_table_data_get();
eo - eo ptr lookup - do some prefetches to get some micro-speedups prefetching a bit helps.. a bit like 0.2% or so... but it does help. :)
2016-10-01 07:37:34 -07:00
EINA_PREFETCH(&(data->tables[0]));
domain = (obj_id >> SHIFT_DOMAIN) & MASK_DOMAIN;
eo - move eoid lookup to ptr indir file and clean up some code this improves the readability of some of the new domain related and ptr indir code..
2016-09-09 02:44:21 -07:00
tdata = _eo_table_data_table_get(data, domain);
eo - eo ptr lookup - do some prefetches to get some micro-speedups prefetching a bit helps.. a bit like 0.2% or so... but it does help. :)
2016-10-01 07:37:34 -07:00
EINA_PREFETCH(&(tdata->cache.id));
if (EINA_UNLIKELY(!tdata)) goto err;
eo - move eoid lookup to ptr indir file and clean up some code this improves the readability of some of the new domain related and ptr indir code..
2016-09-09 02:44:21 -07:00
if (EINA_LIKELY(domain != EFL_ID_DOMAIN_SHARED))
{
if (obj_id == tdata->cache.id)
eo - eo ptr lookup - do some prefetches to get some micro-speedups prefetching a bit helps.. a bit like 0.2% or so... but it does help. :)
2016-10-01 07:37:34 -07:00
return tdata->cache.object;
mid_table_id = (obj_id >> SHIFT_MID_TABLE_ID) & MASK_MID_TABLE_ID;
EINA_PREFETCH(&(tdata->eo_ids_tables[mid_table_id]));
table_id = (obj_id >> SHIFT_TABLE_ID) & MASK_TABLE_ID;
entry_id = (obj_id >> SHIFT_ENTRY_ID) & MASK_ENTRY_ID;
generation = obj_id & MASK_GENERATIONS;
eo - move eoid lookup to ptr indir file and clean up some code this improves the readability of some of the new domain related and ptr indir code..
2016-09-09 02:44:21 -07:00
// get tag bit to check later down below - pipelining
tag_bit = (obj_id) & MASK_OBJ_TAG;
if (!obj_id) goto err_null;
eo ptr indir - handle unlock on error with shared eoids correctly this fixes the error handling for shared objects which would fail to unlock on lookup error.
2016-09-25 17:16:21 -07:00
else if (!tag_bit) goto err;
eo - move eoid lookup to ptr indir file and clean up some code this improves the readability of some of the new domain related and ptr indir code..
2016-09-09 02:44:21 -07:00
// Check the validity of the entry
if (tdata->eo_ids_tables[mid_table_id])
{
_Eo_Ids_Table *tab = TABLE_FROM_IDS;
if (tab)
{
entry = &(tab->entries[entry_id]);
if (entry->active && (entry->generation == generation))
{
// Cache the result of that lookup
tdata->cache.object = entry->ptr;
tdata->cache.id = obj_id;
eo - eo ptr lookup - do some prefetches to get some micro-speedups prefetching a bit helps.. a bit like 0.2% or so... but it does help. :)
2016-10-01 07:37:34 -07:00
return entry->ptr;
eo - move eoid lookup to ptr indir file and clean up some code this improves the readability of some of the new domain related and ptr indir code..
2016-09-09 02:44:21 -07:00
}
}
}
goto err;
}
else
{
eo id and shared domain objects - do locking properly and better so there were a few issues. one we had a spinlokc on the eoid table for shared objects AND then had a mutex for accessing those objects (released on return from any eo function). BUT this missed some funcs like eo_ref, eo_unref and so on in eo.c ... oops. so fixed. but then i realized there was a race condition. we locked the eoid table then unlocked with our pointer THEN locked the sharted object mutex ... then unlocked it. that was a race condtion gap. so we should share the same lock anyway - if it's a shared object, grab the shared object mutex then do a lookup and if the lookup does not fail, KEEP the lock until it is released by the return from eo function or by some special macro/funcs that released a matching lock. since its a recursive lock this is all fine. as its also a universal single lock for all objects we just need the eoid to know if it's shared and needs locking based on the domain bits. so now do this locking properly with just a single mutex, not both a spinlock and mutex and keep the lock around until totally done with the object. this plugs the race condition holes and goes from 1 spinlock lock and unlock then a mutex lock and unlokc to just a single mutex lock and unlock. this means shared objects are actually truly safe across threads and only have the overhead of a single recursive mutex to lock and unlock in every api call.
2016-09-27 21:25:26 -07:00
eina_lock_take(&(_eo_table_data_shared_data->obj_lock));
eo - move eoid lookup to ptr indir file and clean up some code this improves the readability of some of the new domain related and ptr indir code..
2016-09-09 02:44:21 -07:00
if (obj_id == tdata->cache.id)
eo - eo ptr lookup - do some prefetches to get some micro-speedups prefetching a bit helps.. a bit like 0.2% or so... but it does help. :)
2016-10-01 07:37:34 -07:00
// yes we return keeping the lock locked. thats why
// you must call _eo_obj_pointer_done() wrapped
// by EO_OBJ_DONE() to release
return tdata->cache.object;
mid_table_id = (obj_id >> SHIFT_MID_TABLE_ID) & MASK_MID_TABLE_ID;
EINA_PREFETCH(&(tdata->eo_ids_tables[mid_table_id]));
table_id = (obj_id >> SHIFT_TABLE_ID) & MASK_TABLE_ID;
entry_id = (obj_id >> SHIFT_ENTRY_ID) & MASK_ENTRY_ID;
generation = obj_id & MASK_GENERATIONS;
eo - move eoid lookup to ptr indir file and clean up some code this improves the readability of some of the new domain related and ptr indir code..
2016-09-09 02:44:21 -07:00
// get tag bit to check later down below - pipelining
tag_bit = (obj_id) & MASK_OBJ_TAG;
eo ptr indir - handle unlock on error with shared eoids correctly this fixes the error handling for shared objects which would fail to unlock on lookup error.
2016-09-25 17:16:21 -07:00
if (!obj_id) goto err_shared_null;
else if (!tag_bit) goto err_shared;
eo - move eoid lookup to ptr indir file and clean up some code this improves the readability of some of the new domain related and ptr indir code..
2016-09-09 02:44:21 -07:00
// Check the validity of the entry
if (tdata->eo_ids_tables[mid_table_id])
{
_Eo_Ids_Table *tab = TABLE_FROM_IDS;
if (tab)
{
entry = &(tab->entries[entry_id]);
if (entry->active && (entry->generation == generation))
{
// Cache the result of that lookup
tdata->cache.object = entry->ptr;
tdata->cache.id = obj_id;
eo id and shared domain objects - do locking properly and better so there were a few issues. one we had a spinlokc on the eoid table for shared objects AND then had a mutex for accessing those objects (released on return from any eo function). BUT this missed some funcs like eo_ref, eo_unref and so on in eo.c ... oops. so fixed. but then i realized there was a race condition. we locked the eoid table then unlocked with our pointer THEN locked the sharted object mutex ... then unlocked it. that was a race condtion gap. so we should share the same lock anyway - if it's a shared object, grab the shared object mutex then do a lookup and if the lookup does not fail, KEEP the lock until it is released by the return from eo function or by some special macro/funcs that released a matching lock. since its a recursive lock this is all fine. as its also a universal single lock for all objects we just need the eoid to know if it's shared and needs locking based on the domain bits. so now do this locking properly with just a single mutex, not both a spinlock and mutex and keep the lock around until totally done with the object. this plugs the race condition holes and goes from 1 spinlock lock and unlock then a mutex lock and unlokc to just a single mutex lock and unlock. this means shared objects are actually truly safe across threads and only have the overhead of a single recursive mutex to lock and unlock in every api call.
2016-09-27 21:25:26 -07:00
// yes we return keeping the lock locked. thats why
// you must call _eo_obj_pointer_done() wrapped
// by EO_OBJ_DONE() to release
eo - eo ptr lookup - do some prefetches to get some micro-speedups prefetching a bit helps.. a bit like 0.2% or so... but it does help. :)
2016-10-01 07:37:34 -07:00
return entry->ptr;
eo - move eoid lookup to ptr indir file and clean up some code this improves the readability of some of the new domain related and ptr indir code..
2016-09-09 02:44:21 -07:00
}
}
}
eo ptr indir - handle unlock on error with shared eoids correctly this fixes the error handling for shared objects which would fail to unlock on lookup error.
2016-09-25 17:16:21 -07:00
goto err_shared;
eo - move eoid lookup to ptr indir file and clean up some code this improves the readability of some of the new domain related and ptr indir code..
2016-09-09 02:44:21 -07:00
}
eo ptr indir - handle unlock on error with shared eoids correctly this fixes the error handling for shared objects which would fail to unlock on lookup error.
2016-09-25 17:16:21 -07:00
err_shared_null:
eo id and shared domain objects - do locking properly and better so there were a few issues. one we had a spinlokc on the eoid table for shared objects AND then had a mutex for accessing those objects (released on return from any eo function). BUT this missed some funcs like eo_ref, eo_unref and so on in eo.c ... oops. so fixed. but then i realized there was a race condition. we locked the eoid table then unlocked with our pointer THEN locked the sharted object mutex ... then unlocked it. that was a race condtion gap. so we should share the same lock anyway - if it's a shared object, grab the shared object mutex then do a lookup and if the lookup does not fail, KEEP the lock until it is released by the return from eo function or by some special macro/funcs that released a matching lock. since its a recursive lock this is all fine. as its also a universal single lock for all objects we just need the eoid to know if it's shared and needs locking based on the domain bits. so now do this locking properly with just a single mutex, not both a spinlock and mutex and keep the lock around until totally done with the object. this plugs the race condition holes and goes from 1 spinlock lock and unlock then a mutex lock and unlokc to just a single mutex lock and unlock. this means shared objects are actually truly safe across threads and only have the overhead of a single recursive mutex to lock and unlock in every api call.
2016-09-27 21:25:26 -07:00
eina_lock_release(&(_eo_table_data_shared_data->obj_lock));
eo - move eoid lookup to ptr indir file and clean up some code this improves the readability of some of the new domain related and ptr indir code..
2016-09-09 02:44:21 -07:00
err_null:
DBG("obj_id is NULL. Possibly unintended access?");
return NULL;
eo ptr indir - handle unlock on error with shared eoids correctly this fixes the error handling for shared objects which would fail to unlock on lookup error.
2016-09-25 17:16:21 -07:00
err_shared:
eo id and shared domain objects - do locking properly and better so there were a few issues. one we had a spinlokc on the eoid table for shared objects AND then had a mutex for accessing those objects (released on return from any eo function). BUT this missed some funcs like eo_ref, eo_unref and so on in eo.c ... oops. so fixed. but then i realized there was a race condition. we locked the eoid table then unlocked with our pointer THEN locked the sharted object mutex ... then unlocked it. that was a race condtion gap. so we should share the same lock anyway - if it's a shared object, grab the shared object mutex then do a lookup and if the lookup does not fail, KEEP the lock until it is released by the return from eo function or by some special macro/funcs that released a matching lock. since its a recursive lock this is all fine. as its also a universal single lock for all objects we just need the eoid to know if it's shared and needs locking based on the domain bits. so now do this locking properly with just a single mutex, not both a spinlock and mutex and keep the lock around until totally done with the object. this plugs the race condition holes and goes from 1 spinlock lock and unlock then a mutex lock and unlokc to just a single mutex lock and unlock. this means shared objects are actually truly safe across threads and only have the overhead of a single recursive mutex to lock and unlock in every api call.
2016-09-27 21:25:26 -07:00
eina_lock_release(&(_eo_table_data_shared_data->obj_lock));
eo - move eoid lookup to ptr indir file and clean up some code this improves the readability of some of the new domain related and ptr indir code..
2016-09-09 02:44:21 -07:00
err:
eo - id lookup failure expansive error print for ebbter debug whenan eoid lookup fails, now print a lot of information on the issue like the actual id, generation of the id, if its a class or object (the class bit), if its ref or super bit is set, the actual id (which includes the table heirachy), which thread id it is, what domain the object id is and the current and local domains as well as what domains are mapped in.
2016-09-16 02:51:22 -07:00
_eo_obj_pointer_invalid(obj_id, data, domain);
eo - move eoid lookup to ptr indir file and clean up some code this improves the readability of some of the new domain related and ptr indir code..
2016-09-09 02:44:21 -07:00
return NULL;
#else
return (_Eo_Object *) obj_id;
#endif
}
eo id and shared domain objects - do locking properly and better so there were a few issues. one we had a spinlokc on the eoid table for shared objects AND then had a mutex for accessing those objects (released on return from any eo function). BUT this missed some funcs like eo_ref, eo_unref and so on in eo.c ... oops. so fixed. but then i realized there was a race condition. we locked the eoid table then unlocked with our pointer THEN locked the sharted object mutex ... then unlocked it. that was a race condtion gap. so we should share the same lock anyway - if it's a shared object, grab the shared object mutex then do a lookup and if the lookup does not fail, KEEP the lock until it is released by the return from eo function or by some special macro/funcs that released a matching lock. since its a recursive lock this is all fine. as its also a universal single lock for all objects we just need the eoid to know if it's shared and needs locking based on the domain bits. so now do this locking properly with just a single mutex, not both a spinlock and mutex and keep the lock around until totally done with the object. this plugs the race condition holes and goes from 1 spinlock lock and unlock then a mutex lock and unlokc to just a single mutex lock and unlock. this means shared objects are actually truly safe across threads and only have the overhead of a single recursive mutex to lock and unlock in every api call.
2016-09-27 21:25:26 -07:00
void
_eo_obj_pointer_done(const Eo_Id obj_id)
{
#ifdef HAVE_EO_ID
Efl_Id_Domain domain = (obj_id >> SHIFT_DOMAIN) & MASK_DOMAIN;
if (EINA_LIKELY(domain != EFL_ID_DOMAIN_SHARED)) return;
eina_lock_release(&(_eo_table_data_shared_data->obj_lock));
#endif
}