forked from enlightenment/efl
evas: Use Eina_Spinlock for Evas_Scalecache, Evas_Async_Events and Image_Entry.
This commit is contained in:
parent
12d34309c7
commit
6dcffec491
|
@ -4,6 +4,7 @@
|
|||
use Eina_Spinlock in Eina_Log, replace Eina_Lock by Eina_Spinlock in Eina_Stringshare,
|
||||
Eina_Chained_Mempool.
|
||||
* Eet: replace Eina_Lock by Eina_Spinlock in Eet_Dictionnary.
|
||||
* Evas: replace Eina_Lock by Eina_Spinlock in Evas_ScaleCache, Evas_Async_Events and Image_Entry.
|
||||
|
||||
2013-10-10 Carsten Haitzler (The Rasterman)
|
||||
|
||||
|
|
1
NEWS
1
NEWS
|
@ -224,6 +224,7 @@ Improvements:
|
|||
- Add neon assembly for upscaling and map routines
|
||||
- Use mmap/munmap for image data allocation on system that have mmap.
|
||||
- Add iterator for walking child of smart objects, table and a box.
|
||||
- Use Eina_Spinlock for Evas_ScaleCache, Evas_Async_Events and Image_Entry.
|
||||
* Ecore_Con:
|
||||
- Rebase dns.c against upstream
|
||||
- URL support now dynamically loads libcurl at runtime via eina_module.
|
||||
|
|
|
@ -25,7 +25,7 @@ struct _Evas_Cache_Preload
|
|||
Image_Entry *ie;
|
||||
};
|
||||
|
||||
static LK(engine_lock);
|
||||
static SLK(engine_lock);
|
||||
static LK(wakeup);
|
||||
static int _evas_cache_mutex_init = 0;
|
||||
|
||||
|
@ -199,9 +199,9 @@ _evas_cache_image_entry_delete(Evas_Cache_Image *cache, Image_Entry *ie)
|
|||
ie->cache = NULL;
|
||||
cache->func.surface_delete(ie);
|
||||
|
||||
LKD(ie->lock);
|
||||
LKD(ie->lock_cancel);
|
||||
LKD(ie->lock_task);
|
||||
SLKD(ie->lock);
|
||||
SLKD(ie->lock_cancel);
|
||||
SLKD(ie->lock_task);
|
||||
cache->func.dealloc(ie);
|
||||
}
|
||||
|
||||
|
@ -271,9 +271,9 @@ _evas_cache_image_entry_new(Evas_Cache_Image *cache,
|
|||
if (tstamp) ie->tstamp = *tstamp;
|
||||
else memset(&ie->tstamp, 0, sizeof(Image_Timestamp));
|
||||
|
||||
LKI(ie->lock);
|
||||
LKI(ie->lock_cancel);
|
||||
LKI(ie->lock_task);
|
||||
SLKI(ie->lock);
|
||||
SLKI(ie->lock_cancel);
|
||||
SLKI(ie->lock_task);
|
||||
|
||||
if (lo) ie->load_opts = *lo;
|
||||
if (ie->file || ie->f)
|
||||
|
@ -315,9 +315,9 @@ _evas_cache_image_entry_surface_alloc(Evas_Cache_Image *cache,
|
|||
{
|
||||
int wmin = w > 0 ? w : 1;
|
||||
int hmin = h > 0 ? h : 1;
|
||||
LKL(engine_lock);
|
||||
SLKL(engine_lock);
|
||||
_evas_cache_image_entry_surface_alloc__locked(cache, ie, wmin, hmin);
|
||||
LKU(engine_lock);
|
||||
SLKU(engine_lock);
|
||||
}
|
||||
|
||||
static void
|
||||
|
@ -331,7 +331,7 @@ _evas_cache_image_async_heavy(void *data)
|
|||
|
||||
current = data;
|
||||
|
||||
LKL(current->lock);
|
||||
SLKL(current->lock);
|
||||
pchannel = current->channel;
|
||||
current->channel++;
|
||||
cache = current->cache;
|
||||
|
@ -352,7 +352,7 @@ _evas_cache_image_async_heavy(void *data)
|
|||
{
|
||||
current->flags.loaded = 1;
|
||||
|
||||
LKL(current->lock_task);
|
||||
SLKL(current->lock_task);
|
||||
EINA_LIST_FREE(current->tasks, task)
|
||||
{
|
||||
if (task != &dummy_task)
|
||||
|
@ -361,12 +361,12 @@ _evas_cache_image_async_heavy(void *data)
|
|||
free(task);
|
||||
}
|
||||
}
|
||||
LKU(current->lock_task);
|
||||
SLKU(current->lock_task);
|
||||
}
|
||||
}
|
||||
current->channel = pchannel;
|
||||
// check the unload cancel flag
|
||||
LKL(current->lock_cancel);
|
||||
SLKL(current->lock_cancel);
|
||||
if (current->flags.unload_cancel)
|
||||
{
|
||||
current->flags.unload_cancel = EINA_FALSE;
|
||||
|
@ -374,8 +374,8 @@ _evas_cache_image_async_heavy(void *data)
|
|||
current->flags.loaded = 0;
|
||||
current->flags.preload_done = 0;
|
||||
}
|
||||
LKU(current->lock_cancel);
|
||||
LKU(current->lock);
|
||||
SLKU(current->lock_cancel);
|
||||
SLKU(current->lock);
|
||||
}
|
||||
|
||||
static void
|
||||
|
@ -460,9 +460,9 @@ _evas_cache_image_entry_preload_add(Image_Entry *ie, const Eo *target,
|
|||
|
||||
ie->targets = (Evas_Cache_Target *)
|
||||
eina_inlist_append(EINA_INLIST_GET(ie->targets), EINA_INLIST_GET(tg));
|
||||
LKL(ie->lock_task);
|
||||
SLKL(ie->lock_task);
|
||||
ie->tasks = eina_list_append(ie->tasks, task);
|
||||
LKU(ie->lock_task);
|
||||
SLKU(ie->lock_task);
|
||||
|
||||
if (!ie->preload)
|
||||
{
|
||||
|
@ -485,7 +485,7 @@ _evas_cache_image_entry_preload_remove(Image_Entry *ie, const Eo *target)
|
|||
|
||||
if (target)
|
||||
{
|
||||
LKL(ie->lock_task);
|
||||
SLKL(ie->lock_task);
|
||||
l = ie->tasks;
|
||||
EINA_INLIST_FOREACH(ie->targets, tg)
|
||||
{
|
||||
|
@ -499,7 +499,7 @@ _evas_cache_image_entry_preload_remove(Image_Entry *ie, const Eo *target)
|
|||
task = eina_list_data_get(l);
|
||||
ie->tasks = eina_list_remove_list(ie->tasks, l);
|
||||
if (task != &dummy_task) free(task);
|
||||
LKU(ie->lock_task);
|
||||
SLKU(ie->lock_task);
|
||||
|
||||
free(tg);
|
||||
break;
|
||||
|
@ -507,7 +507,7 @@ _evas_cache_image_entry_preload_remove(Image_Entry *ie, const Eo *target)
|
|||
|
||||
l = eina_list_next(l);
|
||||
}
|
||||
LKU(ie->lock_task);
|
||||
SLKU(ie->lock_task);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -520,10 +520,10 @@ _evas_cache_image_entry_preload_remove(Image_Entry *ie, const Eo *target)
|
|||
free(tg);
|
||||
}
|
||||
|
||||
LKL(ie->lock_task);
|
||||
SLKL(ie->lock_task);
|
||||
EINA_LIST_FREE(ie->tasks, task)
|
||||
if (task != &dummy_task) free(task);
|
||||
LKU(ie->lock_task);
|
||||
SLKU(ie->lock_task);
|
||||
}
|
||||
|
||||
if ((!ie->targets) && (ie->preload) && (!ie->flags.pending))
|
||||
|
@ -565,7 +565,7 @@ evas_cache_image_init(const Evas_Cache_Image_Func *cb)
|
|||
|
||||
if (_evas_cache_mutex_init++ == 0)
|
||||
{
|
||||
LKI(engine_lock);
|
||||
SLKI(engine_lock);
|
||||
LKI(wakeup);
|
||||
eina_condition_new(&cond_wakeup, &wakeup);
|
||||
}
|
||||
|
@ -649,7 +649,7 @@ evas_cache_image_shutdown(Evas_Cache_Image *cache)
|
|||
if (--_evas_cache_mutex_init == 0)
|
||||
{
|
||||
eina_condition_free(&cond_wakeup);
|
||||
LKD(engine_lock);
|
||||
SLKD(engine_lock);
|
||||
LKD(wakeup);
|
||||
}
|
||||
}
|
||||
|
@ -1170,11 +1170,11 @@ evas_cache_image_load_data(Image_Entry *im)
|
|||
|
||||
if ((im->flags.loaded) && (!im->animated.animated)) return error;
|
||||
|
||||
LKL(im->lock);
|
||||
SLKL(im->lock);
|
||||
im->flags.in_progress = EINA_TRUE;
|
||||
error = im->cache->func.load(im);
|
||||
im->flags.in_progress = EINA_FALSE;
|
||||
LKU(im->lock);
|
||||
SLKU(im->lock);
|
||||
|
||||
im->flags.loaded = 1;
|
||||
if (im->cache->func.debug) im->cache->func.debug("load", im);
|
||||
|
@ -1193,23 +1193,23 @@ evas_cache_image_unload_data(Image_Entry *im)
|
|||
if (im->flags.in_progress) return;
|
||||
evas_cache_image_preload_cancel(im, NULL);
|
||||
|
||||
LKL(im->lock_cancel);
|
||||
if (LKT(im->lock) == EINA_FALSE) /* can't get image lock - busy async load */
|
||||
SLKL(im->lock_cancel);
|
||||
if (SLKT(im->lock) == EINA_FALSE) /* can't get image lock - busy async load */
|
||||
{
|
||||
im->flags.unload_cancel = EINA_TRUE;
|
||||
LKU(im->lock_cancel);
|
||||
SLKU(im->lock_cancel);
|
||||
return;
|
||||
}
|
||||
LKU(im->lock_cancel);
|
||||
SLKU(im->lock_cancel);
|
||||
|
||||
if ((!im->flags.loaded) || (!im->file && !im->f) || (!im->info.module) ||
|
||||
(im->flags.dirty))
|
||||
{
|
||||
LKU(im->lock);
|
||||
SLKU(im->lock);
|
||||
return;
|
||||
}
|
||||
im->cache->func.destructor(im);
|
||||
LKU(im->lock);
|
||||
SLKU(im->lock);
|
||||
//FIXME: imagedataunload - inform owners
|
||||
}
|
||||
|
||||
|
|
|
@ -37,7 +37,7 @@ static Eina_Condition _thread_feedback_cond;
|
|||
|
||||
static int _thread_loop = 0;
|
||||
|
||||
static Eina_Lock _thread_id_lock;
|
||||
static Eina_Spinlock _thread_id_lock;
|
||||
static int _thread_id = -1;
|
||||
static int _thread_id_max = 0;
|
||||
static int _thread_id_update = 0;
|
||||
|
@ -46,7 +46,7 @@ static int _fd_write = -1;
|
|||
static int _fd_read = -1;
|
||||
static pid_t _fd_pid = 0;
|
||||
|
||||
static Eina_Lock async_lock;
|
||||
static Eina_Spinlock async_lock;
|
||||
static Eina_Inarray async_queue;
|
||||
static Evas_Event_Async *async_queue_cache = NULL;
|
||||
static unsigned int async_queue_cache_max = 0;
|
||||
|
@ -99,7 +99,7 @@ evas_async_events_init(void)
|
|||
fcntl(_fd_read, F_SETFL, O_NONBLOCK);
|
||||
#endif
|
||||
|
||||
eina_lock_new(&async_lock);
|
||||
eina_spinlock_new(&async_lock);
|
||||
eina_inarray_step_set(&async_queue, sizeof (Eina_Inarray), sizeof (Evas_Event_Async), 16);
|
||||
|
||||
eina_lock_new(&_thread_mutex);
|
||||
|
@ -108,7 +108,7 @@ evas_async_events_init(void)
|
|||
eina_lock_new(&_thread_feedback_mutex);
|
||||
eina_condition_new(&_thread_feedback_cond, &_thread_feedback_mutex);
|
||||
|
||||
eina_lock_new(&_thread_id_lock);
|
||||
eina_spinlock_new(&_thread_id_lock);
|
||||
|
||||
return _init_evas_event;
|
||||
}
|
||||
|
@ -123,9 +123,9 @@ evas_async_events_shutdown(void)
|
|||
eina_lock_free(&_thread_mutex);
|
||||
eina_condition_free(&_thread_feedback_cond);
|
||||
eina_lock_free(&_thread_feedback_mutex);
|
||||
eina_lock_free(&_thread_id_lock);
|
||||
eina_spinlock_free(&_thread_id_lock);
|
||||
|
||||
eina_lock_free(&async_lock);
|
||||
eina_spinlock_free(&async_lock);
|
||||
eina_inarray_flush(&async_queue);
|
||||
free(async_queue_cache);
|
||||
|
||||
|
@ -180,7 +180,7 @@ _evas_async_events_process_single(void)
|
|||
unsigned int len, max;
|
||||
int nr;
|
||||
|
||||
eina_lock_take(&async_lock);
|
||||
eina_spinlock_take(&async_lock);
|
||||
|
||||
ev = async_queue.members;
|
||||
async_queue.members = async_queue_cache;
|
||||
|
@ -193,7 +193,7 @@ _evas_async_events_process_single(void)
|
|||
len = async_queue.len;
|
||||
async_queue.len = 0;
|
||||
|
||||
eina_lock_release(&async_lock);
|
||||
eina_spinlock_release(&async_lock);
|
||||
|
||||
DBG("Evas async events queue length: %u", len);
|
||||
nr = len;
|
||||
|
@ -269,13 +269,13 @@ evas_async_events_put(const void *target, Evas_Callback_Type type, void *event_i
|
|||
|
||||
_evas_async_events_fork_handle();
|
||||
|
||||
eina_lock_take(&async_lock);
|
||||
eina_spinlock_take(&async_lock);
|
||||
|
||||
count = async_queue.len;
|
||||
ev = eina_inarray_grow(&async_queue, 1);
|
||||
if (!ev)
|
||||
{
|
||||
eina_lock_release(&async_lock);
|
||||
eina_spinlock_release(&async_lock);
|
||||
return EINA_FALSE;
|
||||
}
|
||||
|
||||
|
@ -284,7 +284,7 @@ evas_async_events_put(const void *target, Evas_Callback_Type type, void *event_i
|
|||
ev->type = type;
|
||||
ev->event_info = event_info;
|
||||
|
||||
eina_lock_release(&async_lock);
|
||||
eina_spinlock_release(&async_lock);
|
||||
|
||||
if (count == 0)
|
||||
{
|
||||
|
@ -365,14 +365,14 @@ evas_thread_main_loop_begin(void)
|
|||
order = malloc(sizeof (Evas_Safe_Call));
|
||||
if (!order) return -1;
|
||||
|
||||
eina_lock_take(&_thread_id_lock);
|
||||
eina_spinlock_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_spinlock_release(&_thread_id_lock);
|
||||
|
||||
eina_lock_new(&order->m);
|
||||
eina_condition_new(&order->c, &order->m);
|
||||
|
|
|
@ -57,7 +57,7 @@ struct _Scaleitem
|
|||
#ifdef SCALECACHE
|
||||
static unsigned long long use_counter = 0;
|
||||
|
||||
static LK(cache_lock);
|
||||
static SLK(cache_lock);
|
||||
static Eina_Inlist *cache_list = NULL;
|
||||
static unsigned int cache_size = 0;
|
||||
static int init = 0;
|
||||
|
@ -121,7 +121,7 @@ evas_common_scalecache_init(void)
|
|||
init++;
|
||||
if (init > 1) return;
|
||||
use_counter = 0;
|
||||
LKI(cache_lock);
|
||||
SLKI(cache_lock);
|
||||
s = getenv("EVAS_SCALECACHE_SIZE");
|
||||
if (s) max_cache_size = atoi(s) * 1024;
|
||||
s = getenv("EVAS_SCALECACHE_MAX_DIMENSION");
|
||||
|
@ -141,7 +141,7 @@ evas_common_scalecache_shutdown(void)
|
|||
#ifdef SCALECACHE
|
||||
init--;
|
||||
if (init ==0)
|
||||
LKD(cache_lock);
|
||||
SLKD(cache_lock);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
@ -151,7 +151,7 @@ evas_common_rgba_image_scalecache_init(Image_Entry *ie)
|
|||
#ifdef SCALECACHE
|
||||
RGBA_Image *im = (RGBA_Image *)ie;
|
||||
// NOTE: this conflicts with evas image cache init and del of lock
|
||||
LKI(im->cache.lock);
|
||||
SLKI(im->cache.lock);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
@ -162,7 +162,7 @@ evas_common_rgba_image_scalecache_shutdown(Image_Entry *ie)
|
|||
RGBA_Image *im = (RGBA_Image *)ie;
|
||||
evas_common_rgba_image_scalecache_dirty(ie);
|
||||
// NOTE: this conflicts with evas image cache init and del of lock
|
||||
LKD(im->cache.lock);
|
||||
SLKD(im->cache.lock);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
@ -172,7 +172,7 @@ evas_common_rgba_image_scalecache_dirty(Image_Entry *ie)
|
|||
#ifdef SCALECACHE
|
||||
RGBA_Image *im = (RGBA_Image *)ie;
|
||||
|
||||
LKL(im->cache.lock);
|
||||
SLKL(im->cache.lock);
|
||||
while (im->cache.list)
|
||||
{
|
||||
Scaleitem *sci = im->cache.list->data;
|
||||
|
@ -180,7 +180,7 @@ evas_common_rgba_image_scalecache_dirty(Image_Entry *ie)
|
|||
im->cache.list = eina_list_remove(im->cache.list, sci);
|
||||
if ((sci->im) && (sci->im->cache_entry.references == 0))
|
||||
{
|
||||
LKL(cache_lock);
|
||||
SLKL(cache_lock);
|
||||
|
||||
evas_common_rgba_image_free(&sci->im->cache_entry);
|
||||
sci->im = NULL;
|
||||
|
@ -191,7 +191,7 @@ evas_common_rgba_image_scalecache_dirty(Image_Entry *ie)
|
|||
cache_size -= sci->size_adjust;
|
||||
cache_list = eina_inlist_remove(cache_list, (Eina_Inlist *)sci);
|
||||
|
||||
LKU(cache_lock);
|
||||
SLKU(cache_lock);
|
||||
}
|
||||
|
||||
if (!sci->im)
|
||||
|
@ -199,7 +199,7 @@ evas_common_rgba_image_scalecache_dirty(Image_Entry *ie)
|
|||
}
|
||||
eina_hash_free(im->cache.hash);
|
||||
im->cache.hash = NULL;
|
||||
LKU(im->cache.lock);
|
||||
SLKU(im->cache.lock);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
@ -208,13 +208,13 @@ evas_common_rgba_image_scalecache_orig_use(Image_Entry *ie)
|
|||
{
|
||||
#ifdef SCALECACHE
|
||||
RGBA_Image *im = (RGBA_Image *)ie;
|
||||
LKL(im->cache.lock);
|
||||
SLKL(im->cache.lock);
|
||||
use_counter++;
|
||||
// FIXME: if orig not loaded, reload
|
||||
// FIXME: mark orig with current used counter
|
||||
im->cache.orig_usage++;
|
||||
im->cache.usage_count = use_counter;
|
||||
LKU(im->cache.lock);
|
||||
SLKU(im->cache.lock);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
@ -226,12 +226,12 @@ evas_common_rgba_image_scalecache_usage_get(Image_Entry *ie)
|
|||
int size = 0;
|
||||
Eina_List *l;
|
||||
Scaleitem *sci;
|
||||
LKL(im->cache.lock);
|
||||
SLKL(im->cache.lock);
|
||||
EINA_LIST_FOREACH(im->cache.list, l, sci)
|
||||
{
|
||||
if (sci->im) size += sci->key.dst_w * sci->key.dst_h * 4;
|
||||
}
|
||||
LKU(im->cache.lock);
|
||||
SLKU(im->cache.lock);
|
||||
return size;
|
||||
#else
|
||||
return 0;
|
||||
|
@ -247,7 +247,7 @@ evas_common_rgba_image_scalecache_items_ref(Image_Entry *ie, Eina_Array *ret)
|
|||
Eina_List *l;
|
||||
Scaleitem *sci;
|
||||
|
||||
LKL(im->cache.lock);
|
||||
SLKL(im->cache.lock);
|
||||
EINA_LIST_FOREACH(im->cache.list, l, sci)
|
||||
{
|
||||
if (sci->im)
|
||||
|
@ -258,7 +258,7 @@ evas_common_rgba_image_scalecache_items_ref(Image_Entry *ie, Eina_Array *ret)
|
|||
eina_array_push(ret, scie);
|
||||
}
|
||||
}
|
||||
LKU(im->cache.lock);
|
||||
SLKU(im->cache.lock);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
@ -435,13 +435,13 @@ EAPI void
|
|||
evas_common_rgba_image_scalecache_size_set(unsigned int size)
|
||||
{
|
||||
#ifdef SCALECACHE
|
||||
LKL(cache_lock);
|
||||
SLKL(cache_lock);
|
||||
if (size != max_cache_size)
|
||||
{
|
||||
max_cache_size = size;
|
||||
_cache_prune(NULL, 1);
|
||||
}
|
||||
LKU(cache_lock);
|
||||
SLKU(cache_lock);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
@ -450,9 +450,9 @@ evas_common_rgba_image_scalecache_size_get(void)
|
|||
{
|
||||
#ifdef SCALECACHE
|
||||
int t;
|
||||
LKL(cache_lock);
|
||||
SLKL(cache_lock);
|
||||
t = max_cache_size;
|
||||
LKU(cache_lock);
|
||||
SLKU(cache_lock);
|
||||
return t;
|
||||
#else
|
||||
return 0;
|
||||
|
@ -463,9 +463,9 @@ EAPI void
|
|||
evas_common_rgba_image_scalecache_prune(void)
|
||||
{
|
||||
#ifdef SCALECACHE
|
||||
LKL(cache_lock);
|
||||
SLKL(cache_lock);
|
||||
_cache_prune(NULL, 0);
|
||||
LKU(cache_lock);
|
||||
SLKU(cache_lock);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
@ -474,12 +474,12 @@ evas_common_rgba_image_scalecache_dump(void)
|
|||
{
|
||||
#ifdef SCALECACHE
|
||||
int t;
|
||||
LKL(cache_lock);
|
||||
SLKL(cache_lock);
|
||||
t = max_cache_size;
|
||||
max_cache_size = 0;
|
||||
_cache_prune(NULL, 0);
|
||||
max_cache_size = t;
|
||||
LKU(cache_lock);
|
||||
SLKU(cache_lock);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
@ -488,12 +488,12 @@ evas_common_rgba_image_scalecache_flush(void)
|
|||
{
|
||||
#ifdef SCALECACHE
|
||||
int t;
|
||||
LKL(cache_lock);
|
||||
SLKL(cache_lock);
|
||||
t = max_cache_size;
|
||||
max_cache_size = 0;
|
||||
_cache_prune(NULL, 1);
|
||||
max_cache_size = t;
|
||||
LKU(cache_lock);
|
||||
SLKU(cache_lock);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
@ -513,11 +513,11 @@ evas_common_rgba_image_scalecache_prepare(Image_Entry *ie, RGBA_Image *dst EINA_
|
|||
if (!im->image.data) return;
|
||||
if ((dst_region_w == 0) || (dst_region_h == 0) ||
|
||||
(src_region_w == 0) || (src_region_h == 0)) return;
|
||||
// was having major lock issues here - LKL was deadlocking. what was
|
||||
// was having major lock issues here - SLKL was deadlocking. what was
|
||||
// going on? it may have been an eina treads badness but this will stay here
|
||||
// for now for debug
|
||||
#if 1
|
||||
ret = LKT(im->cache.lock);
|
||||
ret = SLKT(im->cache.lock);
|
||||
if (ret == EINA_FALSE) /* can't get image lock */
|
||||
{
|
||||
useconds_t slp = 1, slpt = 0;
|
||||
|
@ -531,7 +531,7 @@ evas_common_rgba_image_scalecache_prepare(Image_Entry *ie, RGBA_Image *dst EINA_
|
|||
#endif
|
||||
slpt += slp;
|
||||
slp++;
|
||||
ret = LKT(im->cache.lock);
|
||||
ret = SLKT(im->cache.lock);
|
||||
if (ret == EINA_LOCK_DEADLOCK)
|
||||
{
|
||||
printf("WARNING: DEADLOCK on image %p (%s)\n", im, ie->file);
|
||||
|
@ -546,7 +546,7 @@ evas_common_rgba_image_scalecache_prepare(Image_Entry *ie, RGBA_Image *dst EINA_
|
|||
{
|
||||
printf("WARNING: lock still there after %i usec\n", slpt);
|
||||
printf("WARNING: stucklock on image %p (%s)\n", im, ie->file);
|
||||
LKDBG(im->cache.lock);
|
||||
/* SLKDBG(im->cache.lock); */
|
||||
}
|
||||
}
|
||||
else if (ret == EINA_LOCK_DEADLOCK)
|
||||
|
@ -555,14 +555,14 @@ evas_common_rgba_image_scalecache_prepare(Image_Entry *ie, RGBA_Image *dst EINA_
|
|||
}
|
||||
else locked = 1;
|
||||
#endif
|
||||
if (!locked) { LKL(im->cache.lock); locked = 1; }
|
||||
if (!locked) { SLKL(im->cache.lock); locked = 1; }
|
||||
use_counter++;
|
||||
if ((src_region_w == dst_region_w) && (src_region_h == dst_region_h))
|
||||
{
|
||||
// 1:1 scale.
|
||||
im->cache.orig_usage++;
|
||||
im->cache.usage_count = use_counter;
|
||||
if (locked) LKU(im->cache.lock);
|
||||
if (locked) SLKU(im->cache.lock);
|
||||
return;
|
||||
}
|
||||
if ((!im->cache_entry.flags.alpha) && (!smooth))
|
||||
|
@ -571,17 +571,17 @@ evas_common_rgba_image_scalecache_prepare(Image_Entry *ie, RGBA_Image *dst EINA_
|
|||
// or in some cases faster not cached
|
||||
im->cache.orig_usage++;
|
||||
im->cache.usage_count = use_counter;
|
||||
if (locked) LKU(im->cache.lock);
|
||||
if (locked) SLKU(im->cache.lock);
|
||||
return;
|
||||
}
|
||||
LKL(cache_lock);
|
||||
SLKL(cache_lock);
|
||||
sci = _sci_find(im, dc, smooth,
|
||||
src_region_x, src_region_y, src_region_w, src_region_h,
|
||||
dst_region_w, dst_region_h);
|
||||
if (!sci)
|
||||
{
|
||||
LKU(cache_lock);
|
||||
if (locked) LKU(im->cache.lock);
|
||||
SLKU(cache_lock);
|
||||
if (locked) SLKU(im->cache.lock);
|
||||
return;
|
||||
}
|
||||
// INF("%10i | %4i %4i %4ix%4i -> %4i %4i %4ix%4i | %i",
|
||||
|
@ -609,7 +609,7 @@ evas_common_rgba_image_scalecache_prepare(Image_Entry *ie, RGBA_Image *dst EINA_
|
|||
}
|
||||
sci->usage++;
|
||||
sci->usage_count = use_counter;
|
||||
LKU(cache_lock);
|
||||
SLKU(cache_lock);
|
||||
if (sci->usage > im->cache.newest_usage)
|
||||
im->cache.newest_usage = sci->usage;
|
||||
// INF("newset? %p %i > %i", im,
|
||||
|
@ -618,7 +618,7 @@ evas_common_rgba_image_scalecache_prepare(Image_Entry *ie, RGBA_Image *dst EINA_
|
|||
if (sci->usage_count > im->cache.newest_usage_count)
|
||||
im->cache.newest_usage_count = sci->usage_count;
|
||||
// INF(" -------------- used %8i#, %8i@", (int)sci->usage, (int)sci->usage_count);
|
||||
if (locked) LKU(im->cache.lock);
|
||||
if (locked) SLKU(im->cache.lock);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
@ -682,11 +682,11 @@ evas_common_rgba_image_scalecache_do_cbs(Image_Entry *ie, RGBA_Image *dst,
|
|||
}
|
||||
return EINA_FALSE;
|
||||
}
|
||||
LKL(cache_lock);
|
||||
SLKL(cache_lock);
|
||||
sci = _sci_find(im, dc, smooth,
|
||||
src_region_x, src_region_y, src_region_w, src_region_h,
|
||||
dst_region_w, dst_region_h);
|
||||
LKU(cache_lock);
|
||||
SLKU(cache_lock);
|
||||
if (!sci)
|
||||
{
|
||||
if (im->cache_entry.space == EVAS_COLORSPACE_ARGB8888)
|
||||
|
@ -718,7 +718,7 @@ evas_common_rgba_image_scalecache_do_cbs(Image_Entry *ie, RGBA_Image *dst,
|
|||
}
|
||||
return EINA_FALSE;
|
||||
}
|
||||
LKL(im->cache.lock);
|
||||
SLKL(im->cache.lock);
|
||||
if (sci->populate_me)
|
||||
{
|
||||
int size, osize, used;
|
||||
|
@ -768,7 +768,7 @@ evas_common_rgba_image_scalecache_do_cbs(Image_Entry *ie, RGBA_Image *dst,
|
|||
{
|
||||
static RGBA_Draw_Context *ct = NULL;
|
||||
|
||||
LKL(cache_lock);
|
||||
SLKL(cache_lock);
|
||||
im->cache.orig_usage++;
|
||||
im->cache.usage_count = use_counter;
|
||||
im->cache.populate_count--;
|
||||
|
@ -780,7 +780,7 @@ evas_common_rgba_image_scalecache_do_cbs(Image_Entry *ie, RGBA_Image *dst,
|
|||
ct = evas_common_draw_context_new();
|
||||
evas_common_draw_context_set_render_op(ct, _EVAS_RENDER_COPY);
|
||||
}
|
||||
LKU(im->cache.lock);
|
||||
SLKU(im->cache.lock);
|
||||
if (im->cache_entry.space == EVAS_COLORSPACE_ARGB8888)
|
||||
{
|
||||
#ifdef EVAS_CSERVE2
|
||||
|
@ -790,7 +790,7 @@ evas_common_rgba_image_scalecache_do_cbs(Image_Entry *ie, RGBA_Image *dst,
|
|||
#endif
|
||||
evas_cache_image_load_data(&im->cache_entry);
|
||||
}
|
||||
LKL(im->cache.lock);
|
||||
SLKL(im->cache.lock);
|
||||
evas_common_image_colorspace_normalize(im);
|
||||
if (im->image.data)
|
||||
{
|
||||
|
@ -845,7 +845,7 @@ evas_common_rgba_image_scalecache_do_cbs(Image_Entry *ie, RGBA_Image *dst,
|
|||
// sci->dst_w * sci->dst_h * 4, sci->flop,
|
||||
// sci->dst_w, sci->dst_h);
|
||||
cache_list = eina_inlist_append(cache_list, (Eina_Inlist *)sci);
|
||||
LKU(cache_lock);
|
||||
SLKU(cache_lock);
|
||||
didpop = 1;
|
||||
}
|
||||
}
|
||||
|
@ -853,17 +853,17 @@ evas_common_rgba_image_scalecache_do_cbs(Image_Entry *ie, RGBA_Image *dst,
|
|||
{
|
||||
if (!didpop)
|
||||
{
|
||||
LKL(cache_lock);
|
||||
SLKL(cache_lock);
|
||||
cache_list = eina_inlist_remove(cache_list, (Eina_Inlist *)sci);
|
||||
cache_list = eina_inlist_append(cache_list, (Eina_Inlist *)sci);
|
||||
LKU(cache_lock);
|
||||
SLKU(cache_lock);
|
||||
}
|
||||
else
|
||||
{
|
||||
if (sci->flop >= FLOP_DEL) sci->flop -= FLOP_DEL;
|
||||
}
|
||||
// INF("use cached!");
|
||||
LKU(im->cache.lock);
|
||||
SLKU(im->cache.lock);
|
||||
ret |= cb_sample(sci->im, dst, dc,
|
||||
0, 0,
|
||||
dst_region_w, dst_region_h,
|
||||
|
@ -909,7 +909,7 @@ evas_common_rgba_image_scalecache_do_cbs(Image_Entry *ie, RGBA_Image *dst,
|
|||
}
|
||||
else
|
||||
{
|
||||
LKU(im->cache.lock);
|
||||
SLKU(im->cache.lock);
|
||||
if (im->cache_entry.space == EVAS_COLORSPACE_ARGB8888)
|
||||
{
|
||||
#ifdef EVAS_CSERVE2
|
||||
|
|
|
@ -156,6 +156,13 @@ extern EAPI int _evas_log_dom_global;
|
|||
# define __ARM_ARCH__ 73
|
||||
#endif
|
||||
|
||||
#define SLK(x) Eina_Spinlock x
|
||||
#define SLKI(x) eina_spinlock_new(&(x))
|
||||
#define SLKD(x) eina_spinlock_free(&(x))
|
||||
#define SLKL(x) eina_spinlock_take(&(x))
|
||||
#define SLKT(x) eina_spinlock_take_try(&(x))
|
||||
#define SLKU(x) eina_spinlock_release(&(x))
|
||||
|
||||
#define LK(x) Eina_Lock x
|
||||
#define LKI(x) eina_lock_new(&(x))
|
||||
#define LKD(x) eina_lock_free(&(x))
|
||||
|
@ -600,9 +607,9 @@ struct _Image_Entry
|
|||
Evas_Image_Load_Func *loader;
|
||||
} info;
|
||||
|
||||
LK(lock);
|
||||
LK(lock_cancel);
|
||||
LK(lock_task);
|
||||
SLK(lock);
|
||||
SLK(lock_cancel);
|
||||
SLK(lock_task);
|
||||
|
||||
/* for animation feature */
|
||||
Evas_Image_Animated animated;
|
||||
|
@ -796,7 +803,7 @@ struct _RGBA_Image
|
|||
} image;
|
||||
|
||||
struct {
|
||||
LK(lock);
|
||||
SLK(lock);
|
||||
Eina_List *list;
|
||||
Eina_Hash *hash;
|
||||
unsigned long long orig_usage;
|
||||
|
|
Loading…
Reference in New Issue