diff options
| -rw-r--r-- | src/benchmarks/eo/eo_bench.c | 4 | ||||
| -rw-r--r-- | src/benchmarks/eo/eo_bench_eo_do.c | 46 | ||||
| -rw-r--r-- | src/lib/eo/Eo.h | 44 | ||||
| -rw-r--r-- | src/lib/eo/eo.c | 882 |
4 files changed, 515 insertions, 461 deletions
diff --git a/src/benchmarks/eo/eo_bench.c b/src/benchmarks/eo/eo_bench.c index 3b6584e2b1..5836c64a5b 100644 --- a/src/benchmarks/eo/eo_bench.c +++ b/src/benchmarks/eo/eo_bench.c @@ -20,8 +20,8 @@ struct _Eina_Benchmark_Case static const Eina_Benchmark_Case etc[] = { { "eo_do", eo_bench_eo_do }, - { "eo_add", eo_bench_eo_add }, - { "eo_callbacks", eo_bench_callbacks }, + /* { "eo_add", eo_bench_eo_add }, */ + /* { "eo_callbacks", eo_bench_callbacks }, */ { NULL, NULL } }; diff --git a/src/benchmarks/eo/eo_bench_eo_do.c b/src/benchmarks/eo/eo_bench_eo_do.c index 0c15b716b2..7045d2aeb4 100644 --- a/src/benchmarks/eo/eo_bench_eo_do.c +++ b/src/benchmarks/eo/eo_bench_eo_do.c @@ -20,6 +20,34 @@ bench_eo_do_simple(int request) } static void +bench_eo_do_multi_simple(int request) +{ + int i; + Eo *obj = eo_add(SIMPLE_CLASS, NULL); + for (i = 0 ; i < request ; i++) + { + eo_do(obj, simple_a_set(i) // 1 + ;simple_a_set(i) // 2 + ;simple_a_set(i) // 3 + ;simple_a_set(i) // 4 + ;simple_a_set(i) // 5 + /* ;simple_a_set(i) // 6 */ + /* ;simple_a_set(i) // 7 */ + /* ;simple_a_set(i) // 8 */ + /* ;simple_a_set(i) // 9 */ + /* ;simple_a_set(i) // 10 */ + /* ;simple_a_set(i) // 11 */ + /* ;simple_a_set(i) // 12 */ + /* ;simple_a_set(i) // 13 */ + /* ;simple_a_set(i) // 14 */ + /* ;simple_a_set(i) // 15 */ + ); + } + + eo_unref(obj); +} + +static void bench_eo_do_two_objs(int request) { int i; @@ -91,12 +119,14 @@ bench_eo_do_super(int request) void eo_bench_eo_do(Eina_Benchmark *bench) { - eina_benchmark_register(bench, "simple", - EINA_BENCHMARK(bench_eo_do_simple), _EO_BENCH_TIMES(1000, 10, 500000)); - eina_benchmark_register(bench, "super", - EINA_BENCHMARK(bench_eo_do_super), _EO_BENCH_TIMES(1000, 10, 500000)); - eina_benchmark_register(bench, "two_objs", - EINA_BENCHMARK(bench_eo_do_two_objs), _EO_BENCH_TIMES(1000, 10, 500000)); - eina_benchmark_register(bench, "two_objs_growing_stack", - EINA_BENCHMARK(bench_eo_do_two_objs_growing_stack), _EO_BENCH_TIMES(1000, 10, 40000)); + /* eina_benchmark_register(bench, "simple", */ + /* EINA_BENCHMARK(bench_eo_do_simple), _EO_BENCH_TIMES(1000, 10, 500000)); */ + eina_benchmark_register(bench, "simple_multi", + EINA_BENCHMARK(bench_eo_do_multi_simple), _EO_BENCH_TIMES(1000, 10, 500000)); + /* eina_benchmark_register(bench, "super", */ + /* EINA_BENCHMARK(bench_eo_do_super), _EO_BENCH_TIMES(1000, 10, 500000)); */ + /* eina_benchmark_register(bench, "two_objs", */ + /* EINA_BENCHMARK(bench_eo_do_two_objs), _EO_BENCH_TIMES(1000, 10, 500000)); */ + /* eina_benchmark_register(bench, "two_objs_growing_stack", */ + /* EINA_BENCHMARK(bench_eo_do_two_objs_growing_stack), _EO_BENCH_TIMES(1000, 10, 40000)); */ } diff --git a/src/lib/eo/Eo.h b/src/lib/eo/Eo.h index 3ff7b8bf20..046f4e463b 100644 --- a/src/lib/eo/Eo.h +++ b/src/lib/eo/Eo.h @@ -489,7 +489,7 @@ typedef struct _Eo_Call_Cache ___cache.op = _eo_api_op_id_get(EO_FUNC_COMMON_OP_FUNC(_EO_##Name)); \ if (___cache.op == EO_NOOP) return DefRet; \ } \ - if (!_eo_call_resolve(#Name, &___call, &___cache, eo_stack, \ + if (!_eo_call_resolve(#Name, &___call, &___cache, (Eo*)eo_stack, \ __FILE__, __LINE__)) return DefRet; \ _Eo_##Name##_func _func_ = (_Eo_##Name##_func) ___call.func; \ @@ -549,37 +549,37 @@ typedef struct _Eo_Call_Cache EAPI Eo_Op _eo_api_op_id_get(const void *api_func); // gets the real function pointer and the object data -EAPI Eina_Bool _eo_call_resolve(const char *func_name, Eo_Op_Call_Data *call, Eo_Call_Cache *cache, void *eo_stack, const char *file, int line); +EAPI Eina_Bool _eo_call_resolve(const char *func_name, Eo_Op_Call_Data *call, Eo_Call_Cache *cache, Eo* eo_stack, const char *file, int line); -// start of eo_do barrier, gets the object pointer and ref it, put it on the stask -EAPI Eina_Bool _eo_do_start(const Eo *obj, const Eo_Class *cur_klass, Eina_Bool is_super, void *eo_stack); +// // start of eo_do barrier, gets the object pointer and ref it, put it on the stask +// EAPI Eina_Bool _eo_do_start(const Eo *obj, const Eo_Class *cur_klass, Eina_Bool is_super, void *eo_stack); -// end of the eo_do barrier, unref the obj, move the stack pointer -EAPI void _eo_do_end(void *eo_stack); +// // end of the eo_do barrier, unref the obj, move the stack pointer +// EAPI void _eo_do_end(void *eo_stack); -// end of the eo_add. Calls finalize among others -EAPI Eo * _eo_add_end(void *eo_stack); +// // end of the eo_add. Calls finalize among others +// EAPI Eo * _eo_add_end(void *eo_stack); -// XXX: We cheat and make it const to indicate to the compiler that the value never changes -EAPI EINA_CONST void *_eo_stack_get(void); +// // XXX: We cheat and make it const to indicate to the compiler that the value never changes +// EAPI EINA_CONST void *_eo_stack_get(void); // eo object method calls batch, #define _eo_do_common(eoid, clsid, is_super, ...) \ do { \ - void *__eo_ctx = _eo_stack_get(); \ + Eo *__eo_ctx = eoid; \ (void)__eo_ctx; \ - _eo_do_start(eoid, clsid, is_super, _eo_stack_get()); \ + /*_eo_do_start(eoid, clsid, is_super, _eo_stack_get());*/ \ __VA_ARGS__; \ - _eo_do_end(_eo_stack_get()); \ + /*_eo_do_end(_eo_stack_get());*/ \ } while (0) #define _eo_do_common_ret(eoid, clsid, is_super, ret_tmp, func) \ ({ \ - void *__eo_ctx = _eo_stack_get(); \ - _eo_do_start(eoid, clsid, is_super, _eo_stack_get()), \ + void *__eo_ctx = eoid; \ + /*_eo_do_start(eoid, clsid, is_super, _eo_stack_get()),*/ \ ret_tmp = func, \ - _eo_do_end(_eo_stack_get()), \ + /*_eo_do_end(_eo_stack_get()),*/ \ ret_tmp; \ }) @@ -612,11 +612,13 @@ EAPI const Eo_Class *eo_class_get(const Eo *obj); #define _eo_add_common(klass, parent, is_ref, ...) \ ({ \ - void *__eo_ctx = _eo_stack_get(); (void) __eo_ctx; \ - _eo_do_start(_eo_add_internal_start(__FILE__, __LINE__, klass, parent, is_ref), \ - klass, EINA_FALSE, _eo_stack_get()) \ - , ##__VA_ARGS__, \ - (Eo *) _eo_add_end(_eo_stack_get()); \ + /*void *__eo_ctx = _eo_stack_get(); (void) __eo_ctx;*/ \ + Eo* __eo_ctx = _eo_add_internal_start(__FILE__, __LINE__, klass, parent, is_ref); \ + /*_eo_do_start(_eo_add_internal_start(__FILE__, __LINE__, klass, parent, is_ref), \ + klass, EINA_FALSE, _eo_stack_get())*/ \ + __VA_ARGS__; \ + /*(Eo *) _eo_add_end(_eo_stack_get());*/ \ + __eo_ctx; \ }) /** diff --git a/src/lib/eo/eo.c b/src/lib/eo/eo.c index e76f4398c7..af2b7288ca 100644 --- a/src/lib/eo/eo.c +++ b/src/lib/eo/eo.c @@ -246,340 +246,362 @@ _eo_kls_itr_next(const _Eo_Class *orig_kls, const _Eo_Class *cur_klass, Eo_Op op return NULL; } -/************************************ EO ************************************/ +/* /\************************************ EO ************************************\/ */ + +/* // 1024 entries == 16k or 32k (32 or 64bit) for eo call stack. that's 1023 */ +/* // imbricated/recursive calls it can handle before barfing. i'd say that's ok */ +/* #define EO_CALL_STACK_DEPTH_MIN 1024 */ +/* #define EO_CALL_STACK_SHRINK_DROP (EO_CALL_STACK_DEPTH_MIN >> 1) */ + +/* typedef struct _Eo_Stack_Frame */ +/* { */ +/* union { */ +/* _Eo_Object *obj; */ +/* const _Eo_Class *kls; */ +/* } o; */ +/* const _Eo_Class *cur_klass; */ +/* Eina_Bool is_obj : 1; */ +/* } Eo_Stack_Frame; */ + +/* #define EO_CALL_STACK_SIZE (EO_CALL_STACK_DEPTH_MIN * sizeof(Eo_Stack_Frame)) */ + +/* static Eina_TLS _eo_call_stack_key = 0; */ + +/* typedef struct _Eo_Call_Stack { */ +/* Eo_Stack_Frame *frames; */ +/* Eo_Stack_Frame *frame_ptr; */ +/* Eo_Stack_Frame *last_frame; */ +/* Eo_Stack_Frame *shrink_frame; */ +/* } Eo_Call_Stack; */ + +/* #define MEM_PAGE_SIZE 4096 */ + +/* static void * */ +/* _eo_call_stack_mem_alloc(size_t size) */ +/* { */ +/* #ifdef HAVE_MMAP */ +/* // allocate eo call stack via mmped anon segment if on linux - more */ +/* // secure and safe. also gives page aligned memory allowing madvise */ +/* void *ptr; */ +/* size_t newsize; */ +/* newsize = MEM_PAGE_SIZE * ((size + MEM_PAGE_SIZE - 1) / */ +/* MEM_PAGE_SIZE); */ +/* ptr = mmap(NULL, newsize, PROT_READ | PROT_WRITE, */ +/* MAP_PRIVATE | MAP_ANON, -1, 0); */ +/* if (ptr == MAP_FAILED) */ +/* { */ +/* ERR("eo call stack mmap failed."); */ +/* return NULL; */ +/* } */ +/* return ptr; */ +/* #else */ +/* //in regular cases just use malloc */ +/* return calloc(1, size); */ +/* #endif */ +/* } */ + +/* #ifdef HAVE_MMAP */ +/* static void */ +/* _eo_call_stack_mem_resize(void **ptr EINA_UNUSED, size_t newsize, size_t size) */ +/* { */ +/* if (newsize > size) */ +/* { */ +/* CRI("eo call stack overflow, abort."); */ +/* abort(); */ +/* } */ +/* return; // Do nothing, code for actual implementation in history. See commit message for details. */ +/* #else */ +/* static void */ +/* _eo_call_stack_mem_resize(void **ptr, size_t newsize, size_t size EINA_UNUSED) */ +/* { */ +/* *ptr = realloc(*ptr, newsize); */ +/* if (!*ptr) */ +/* { */ +/* CRI("eo call stack resize failed, abort."); */ +/* abort(); */ +/* } */ +/* #endif */ +/* } */ + +/* #ifdef HAVE_MMAP */ +/* static void */ +/* _eo_call_stack_mem_free(void *ptr, size_t size) */ +/* { */ +/* // free mmaped memory */ +/* munmap(ptr, size); */ +/* #else */ +/* static void */ +/* _eo_call_stack_mem_free(void *ptr, size_t size EINA_UNUSED) */ +/* { */ +/* // free regular memory */ +/* free(ptr); */ +/* #endif */ +/* } */ + +/* static Eo_Call_Stack * */ +/* _eo_call_stack_create() */ +/* { */ +/* Eo_Call_Stack *stack; */ + +/* stack = calloc(1, sizeof(Eo_Call_Stack)); */ +/* if (!stack) */ +/* return NULL; */ + +/* stack->frames = _eo_call_stack_mem_alloc(EO_CALL_STACK_SIZE); */ +/* if (!stack->frames) */ +/* { */ +/* free(stack); */ +/* return NULL; */ +/* } */ + +/* // first frame is never used */ +/* stack->frame_ptr = stack->frames; */ +/* stack->last_frame = &stack->frames[EO_CALL_STACK_DEPTH_MIN - 1]; */ +/* stack->shrink_frame = stack->frames; */ + +/* return stack; */ +/* } */ + +/* static void */ +/* _eo_call_stack_free(void *ptr) */ +/* { */ +/* Eo_Call_Stack *stack = (Eo_Call_Stack *) ptr; */ + +/* if (!stack) return; */ + +/* if (stack->frames) */ +/* _eo_call_stack_mem_free(stack->frames, EO_CALL_STACK_SIZE); */ + +/* free(stack); */ +/* } */ + +/* #ifdef HAVE_THREAD_SPECIFIER */ +/* static __thread Eo_Call_Stack *_eo_thread_stack = NULL; */ + +/* #define _EO_CALL_STACK_GET() ((_eo_thread_stack) ? _eo_thread_stack : (_eo_thread_stack = _eo_call_stack_create())) */ + +/* #else */ + +/* static Eo_Call_Stack *main_loop_stack = NULL; */ + +/* #define _EO_CALL_STACK_GET() ((EINA_LIKELY(eina_main_loop_is())) ? main_loop_stack : _eo_call_stack_get_thread()) */ + +/* static inline Eo_Call_Stack * */ +/* _eo_call_stack_get_thread(void) */ +/* { */ +/* Eo_Call_Stack *stack = eina_tls_get(_eo_call_stack_key); */ + +/* if (stack) return stack; */ + +/* stack = _eo_call_stack_create(); */ +/* eina_tls_set(_eo_call_stack_key, stack); */ + +/* return stack; */ +/* } */ +/* #endif */ + +/* EAPI EINA_CONST void * */ +/* _eo_stack_get(void) */ +/* { */ +/* return _EO_CALL_STACK_GET(); */ +/* } */ + +/* static inline void */ +/* _eo_call_stack_resize(Eo_Call_Stack *stack, Eina_Bool grow) */ +/* { */ +/* size_t sz, next_sz; */ +/* int frame_offset; */ + +/* sz = stack->last_frame - stack->frames + 1; */ +/* if (grow) */ +/* next_sz = sz * 2; */ +/* else */ +/* next_sz = sz / 2; */ +/* frame_offset = stack->frame_ptr - stack->frames; */ + +/* _eo_call_stack_mem_resize((void **)&(stack->frames), */ +/* next_sz * sizeof(Eo_Stack_Frame), */ +/* sz * sizeof(Eo_Stack_Frame)); */ + +/* stack->frame_ptr = &stack->frames[frame_offset]; */ +/* stack->last_frame = &stack->frames[next_sz - 1]; */ + +/* if (next_sz == EO_CALL_STACK_DEPTH_MIN) */ +/* frame_offset = 0; */ +/* else */ +/* { */ +/* if (grow) */ +/* frame_offset = sz - EO_CALL_STACK_SHRINK_DROP; */ +/* else */ +/* frame_offset = (next_sz / 2) - EO_CALL_STACK_SHRINK_DROP; */ +/* } */ +/* stack->shrink_frame = &stack->frames[frame_offset]; */ +/* } */ + +/* static inline Eina_Bool */ +/* _eo_do_internal(const Eo *eo_id, const Eo_Class *cur_klass_id, */ +/* Eina_Bool is_super, Eo_Stack_Frame *fptr) */ +/* { */ +/* fptr->is_obj = _eo_is_a_obj(eo_id); */ + +/* /\* If we are already in the same object context, we inherit info from it. *\/ */ +/* if (fptr->is_obj) */ +/* { */ +/* EO_OBJ_POINTER_RETURN_VAL(eo_id, _obj, EINA_FALSE); */ +/* fptr->o.obj = _obj; */ +/* _eo_ref(_obj); */ +/* } */ +/* else */ +/* { */ +/* EO_CLASS_POINTER_RETURN_VAL(eo_id, _klass, EINA_FALSE); */ +/* fptr->o.kls = _klass; */ +/* } */ + +/* if (is_super) */ +/* { */ +/* EO_CLASS_POINTER_RETURN_VAL(cur_klass_id, cur_klass, EINA_FALSE); */ +/* fptr->cur_klass = cur_klass; */ +/* } */ +/* else */ +/* { */ +/* fptr->cur_klass = NULL; */ +/* } */ + +/* return EINA_TRUE; */ +/* } */ + +/* EAPI Eina_Bool */ +/* _eo_do_start(const Eo *eo_id, const Eo_Class *cur_klass_id, Eina_Bool is_super, void *eo_stack) */ +/* { */ +/* Eina_Bool ret = EINA_TRUE; */ +/* /\* Eo_Stack_Frame *fptr; *\/ */ +/* /\* Eo_Call_Stack *stack = eo_stack; *\/ */ + +/* /\* if (stack->frame_ptr == stack->last_frame) *\/ */ +/* /\* _eo_call_stack_resize(stack, EINA_TRUE); *\/ */ + +/* /\* fptr = stack->frame_ptr; *\/ */ + +/* /\* fptr++; *\/ */ + +/* /\* if (!_eo_do_internal(eo_id, cur_klass_id, is_super, fptr)) *\/ */ +/* /\* { *\/ */ +/* /\* fptr->o.obj = NULL; *\/ */ +/* /\* fptr->cur_klass = NULL; *\/ */ + +/* /\* ret = EINA_FALSE; *\/ */ +/* /\* } *\/ */ + +/* /\* stack->frame_ptr++; *\/ */ + +/* return ret; */ +/* } */ + +/* EAPI void */ +/* _eo_do_end(void *eo_stack) */ +/* { */ +/* /\* Eo_Stack_Frame *fptr; *\/ */ +/* /\* Eo_Call_Stack *stack = eo_stack; *\/ */ + +/* /\* fptr = stack->frame_ptr; *\/ */ + +/* /\* if (fptr->is_obj && fptr->o.obj) *\/ */ +/* /\* _eo_unref(fptr->o.obj); *\/ */ + +/* /\* stack->frame_ptr--; *\/ */ + +/* /\* if (fptr == stack->shrink_frame) *\/ */ +/* /\* _eo_call_stack_resize(stack, EINA_FALSE); *\/ */ +/* } */ -// 1024 entries == 16k or 32k (32 or 64bit) for eo call stack. that's 1023 -// imbricated/recursive calls it can handle before barfing. i'd say that's ok -#define EO_CALL_STACK_DEPTH_MIN 1024 -#define EO_CALL_STACK_SHRINK_DROP (EO_CALL_STACK_DEPTH_MIN >> 1) - -typedef struct _Eo_Stack_Frame -{ - union { - _Eo_Object *obj; - const _Eo_Class *kls; - } o; - const _Eo_Class *cur_klass; - Eina_Bool is_obj : 1; -} Eo_Stack_Frame; - -#define EO_CALL_STACK_SIZE (EO_CALL_STACK_DEPTH_MIN * sizeof(Eo_Stack_Frame)) - -static Eina_TLS _eo_call_stack_key = 0; - -typedef struct _Eo_Call_Stack { - Eo_Stack_Frame *frames; - Eo_Stack_Frame *frame_ptr; - Eo_Stack_Frame *last_frame; - Eo_Stack_Frame *shrink_frame; -} Eo_Call_Stack; - -#define MEM_PAGE_SIZE 4096 - -static void * -_eo_call_stack_mem_alloc(size_t size) -{ -#ifdef HAVE_MMAP - // allocate eo call stack via mmped anon segment if on linux - more - // secure and safe. also gives page aligned memory allowing madvise - void *ptr; - size_t newsize; - newsize = MEM_PAGE_SIZE * ((size + MEM_PAGE_SIZE - 1) / - MEM_PAGE_SIZE); - ptr = mmap(NULL, newsize, PROT_READ | PROT_WRITE, - MAP_PRIVATE | MAP_ANON, -1, 0); - if (ptr == MAP_FAILED) - { - ERR("eo call stack mmap failed."); - return NULL; - } - return ptr; -#else - //in regular cases just use malloc - return calloc(1, size); -#endif -} - -#ifdef HAVE_MMAP -static void -_eo_call_stack_mem_resize(void **ptr EINA_UNUSED, size_t newsize, size_t size) -{ - if (newsize > size) - { - CRI("eo call stack overflow, abort."); - abort(); - } - return; // Do nothing, code for actual implementation in history. See commit message for details. -#else -static void -_eo_call_stack_mem_resize(void **ptr, size_t newsize, size_t size EINA_UNUSED) -{ - *ptr = realloc(*ptr, newsize); - if (!*ptr) - { - CRI("eo call stack resize failed, abort."); - abort(); - } -#endif -} - -#ifdef HAVE_MMAP -static void -_eo_call_stack_mem_free(void *ptr, size_t size) -{ - // free mmaped memory - munmap(ptr, size); -#else -static void -_eo_call_stack_mem_free(void *ptr, size_t size EINA_UNUSED) -{ - // free regular memory - free(ptr); -#endif -} - -static Eo_Call_Stack * -_eo_call_stack_create() -{ - Eo_Call_Stack *stack; - - stack = calloc(1, sizeof(Eo_Call_Stack)); - if (!stack) - return NULL; - - stack->frames = _eo_call_stack_mem_alloc(EO_CALL_STACK_SIZE); - if (!stack->frames) - { - free(stack); - return NULL; - } - - // first frame is never used - stack->frame_ptr = stack->frames; - stack->last_frame = &stack->frames[EO_CALL_STACK_DEPTH_MIN - 1]; - stack->shrink_frame = stack->frames; - - return stack; -} - -static void -_eo_call_stack_free(void *ptr) -{ - Eo_Call_Stack *stack = (Eo_Call_Stack *) ptr; - - if (!stack) return; - - if (stack->frames) - _eo_call_stack_mem_free(stack->frames, EO_CALL_STACK_SIZE); - - free(stack); -} - -#ifdef HAVE_THREAD_SPECIFIER -static __thread Eo_Call_Stack *_eo_thread_stack = NULL; - -#define _EO_CALL_STACK_GET() ((_eo_thread_stack) ? _eo_thread_stack : (_eo_thread_stack = _eo_call_stack_create())) - -#else - -static Eo_Call_Stack *main_loop_stack = NULL; - -#define _EO_CALL_STACK_GET() ((EINA_LIKELY(eina_main_loop_is())) ? main_loop_stack : _eo_call_stack_get_thread()) - -static inline Eo_Call_Stack * -_eo_call_stack_get_thread(void) -{ - Eo_Call_Stack *stack = eina_tls_get(_eo_call_stack_key); - - if (stack) return stack; - - stack = _eo_call_stack_create(); - eina_tls_set(_eo_call_stack_key, stack); - - return stack; -} -#endif - -EAPI EINA_CONST void * -_eo_stack_get(void) -{ - return _EO_CALL_STACK_GET(); -} - -static inline void -_eo_call_stack_resize(Eo_Call_Stack *stack, Eina_Bool grow) +EAPI Eina_Bool +_eo_call_resolve(const char *func_name, Eo_Op_Call_Data *call, Eo_Call_Cache *cache, Eo* eo_id, const char *file, int line) { - size_t sz, next_sz; - int frame_offset; - - sz = stack->last_frame - stack->frames + 1; - if (grow) - next_sz = sz * 2; - else - next_sz = sz / 2; - frame_offset = stack->frame_ptr - stack->frames; - - _eo_call_stack_mem_resize((void **)&(stack->frames), - next_sz * sizeof(Eo_Stack_Frame), - sz * sizeof(Eo_Stack_Frame)); + const _Eo_Class *klass/*, *inputklass*/; + const op_type_funcs *func; + Eina_Bool is_obj; + const _Eo_Object* _obj; - stack->frame_ptr = &stack->frames[frame_offset]; - stack->last_frame = &stack->frames[next_sz - 1]; + /* fptr = stack->frame_ptr; */ - if (next_sz == EO_CALL_STACK_DEPTH_MIN) - frame_offset = 0; - else - { - if (grow) - frame_offset = sz - EO_CALL_STACK_SHRINK_DROP; - else - frame_offset = (next_sz / 2) - EO_CALL_STACK_SHRINK_DROP; - } - stack->shrink_frame = &stack->frames[frame_offset]; -} + /* if (EINA_UNLIKELY(!fptr->o.obj)) */ + /* return EINA_FALSE; */ -static inline Eina_Bool -_eo_do_internal(const Eo *eo_id, const Eo_Class *cur_klass_id, - Eina_Bool is_super, Eo_Stack_Frame *fptr) -{ - fptr->is_obj = _eo_is_a_obj(eo_id); + is_obj = _eo_is_a_obj(eo_id); + /* is_obj = fptr->is_obj; */ - /* If we are already in the same object context, we inherit info from it. */ - if (fptr->is_obj) + if (is_obj) { - EO_OBJ_POINTER_RETURN_VAL(eo_id, _obj, EINA_FALSE); - fptr->o.obj = _obj; - _eo_ref(_obj); + _obj = _eo_obj_pointer_get((Eo_Id)eo_id); + /* EO_OBJ_POINTER_RETURN_VAL(eo_id, _obj, EINA_FALSE); */ + /* fptr->o.obj = _obj; */ + /* _eo_ref(_obj); */ } else { - EO_CLASS_POINTER_RETURN_VAL(eo_id, _klass, EINA_FALSE); - fptr->o.kls = _klass; - } - - if (is_super) - { - EO_CLASS_POINTER_RETURN_VAL(cur_klass_id, cur_klass, EINA_FALSE); - fptr->cur_klass = cur_klass; + klass = _eo_class_pointer_get(eo_id); + /* EO_CLASS_POINTER_RETURN_VAL(eo_id, _klass, EINA_FALSE); */ + /* fptr->o.kls = _klass; */ + /* assert(!!klass); */ + if(!klass) + return EINA_FALSE; } - else + if(is_obj) { - fptr->cur_klass = NULL; + /*inputklass = */klass = _obj->klass; + assert(!!klass); } - return EINA_TRUE; -} - -EAPI Eina_Bool -_eo_do_start(const Eo *eo_id, const Eo_Class *cur_klass_id, Eina_Bool is_super, void *eo_stack) -{ - Eina_Bool ret = EINA_TRUE; - Eo_Stack_Frame *fptr; - Eo_Call_Stack *stack = eo_stack; - - if (stack->frame_ptr == stack->last_frame) - _eo_call_stack_resize(stack, EINA_TRUE); + assert(!!klass); - fptr = stack->frame_ptr; + /* if (!cache->op) */ + /* { */ + /* ERR("%s:%d: unable to resolve %s api func '%s' in class '%s'.", */ + /* file, line, (!is_obj ? "class" : "regular"), */ + /* func_name, klass->desc->name); */ - fptr++; - - if (!_eo_do_internal(eo_id, cur_klass_id, is_super, fptr)) - { - fptr->o.obj = NULL; - fptr->cur_klass = NULL; - - ret = EINA_FALSE; - } - - stack->frame_ptr++; - - return ret; -} - -EAPI void -_eo_do_end(void *eo_stack) -{ - Eo_Stack_Frame *fptr; - Eo_Call_Stack *stack = eo_stack; - - fptr = stack->frame_ptr; - - if (fptr->is_obj && fptr->o.obj) - _eo_unref(fptr->o.obj); - - stack->frame_ptr--; - - if (fptr == stack->shrink_frame) - _eo_call_stack_resize(stack, EINA_FALSE); -} - -EAPI Eina_Bool -_eo_call_resolve(const char *func_name, Eo_Op_Call_Data *call, Eo_Call_Cache *cache, void *eo_stack, const char *file, int line) -{ - Eo_Call_Stack *stack = eo_stack; - Eo_Stack_Frame *fptr; - const _Eo_Class *klass, *inputklass; - const op_type_funcs *func; - Eina_Bool is_obj; - - fptr = stack->frame_ptr; - - if (EINA_UNLIKELY(!fptr->o.obj)) - return EINA_FALSE; - - is_obj = fptr->is_obj; - - inputklass = klass = (is_obj) ? fptr->o.obj->klass : fptr->o.kls; - - if (!cache->op) - { - ERR("%s:%d: unable to resolve %s api func '%s' in class '%s'.", - file, line, (!is_obj ? "class" : "regular"), - func_name, klass->desc->name); - - return EINA_FALSE; - } + /* return EINA_FALSE; */ + /* } */ /* If we have a current class, we need to itr to the next. */ - if (fptr->cur_klass) - { - func = _eo_kls_itr_next(klass, fptr->cur_klass, cache->op); - - if (!func) - goto end; - - klass = func->src; - } - else - { -# if EO_CALL_CACHE_SIZE > 0 -# if EO_CALL_CACHE_SIZE > 1 - int i; - - for (i = 0; i < EO_CALL_CACHE_SIZE; i++) -# else - const int i = 0; -# endif - { - if ((const void *)inputklass == cache->index[i].klass) - { - func = (const op_type_funcs *)cache->entry[i].func; - call->func = func->func; - if (is_obj) - { - call->obj = (Eo *) fptr->o.obj->header.id; - call->data = (char *)fptr->o.obj + cache->off[i].off; - } - else - { - call->obj = _eo_class_id_get(inputklass); - call->data = NULL; - } - return EINA_TRUE; - } - } -#endif + /* if (fptr->cur_klass) */ + /* { */ + /* func = _eo_kls_itr_next(klass, fptr->cur_klass, cache->op); */ + + /* if (!func) */ + /* goto end; */ + + /* klass = func->src; */ + /* } */ + /* else */ + { +/* # if EO_CALL_CACHE_SIZE > 0 */ +/* # if EO_CALL_CACHE_SIZE > 1 */ +/* int i; */ + +/* for (i = 0; i < EO_CALL_CACHE_SIZE; i++) */ +/* # else */ +/* const int i = 0; */ +/* # endif */ +/* { */ +/* if ((const void *)inputklass == cache->index[i].klass) */ +/* { */ +/* func = (const op_type_funcs *)cache->entry[i].func; */ +/* call->func = func->func; */ +/* if (is_obj) */ +/* { */ +/* call->obj = (Eo *) _obj->header.id; */ +/* call->data = (char *)_obj + cache->off[i].off; */ +/* } */ +/* else */ +/* { */ +/* call->obj = _eo_class_id_get(inputklass); */ +/* call->data = NULL; */ +/* } */ +/* return EINA_TRUE; */ +/* } */ +/* } */ +/* #endif */ func = _dich_func_get(klass, cache->op); @@ -593,8 +615,8 @@ _eo_call_resolve(const char *func_name, Eo_Op_Call_Data *call, Eo_Call_Cache *ca if (is_obj) { - call->obj = (Eo *) fptr->o.obj->header.id; - call->data = _eo_data_scope_get(fptr->o.obj, func->src); + call->obj = (Eo *) _obj->header.id; + call->data = _eo_data_scope_get(_obj, func->src); } else { @@ -602,22 +624,22 @@ _eo_call_resolve(const char *func_name, Eo_Op_Call_Data *call, Eo_Call_Cache *ca call->data = NULL; } -# if EO_CALL_CACHE_SIZE > 0 - if (!fptr->cur_klass) - { -# if EO_CALL_CACHE_SIZE > 1 - const int slot = cache->next_slot; -# else - const int slot = 0; -# endif - cache->index[slot].klass = (const void *)inputklass; - cache->entry[slot].func = (const void *)func; - cache->off[slot].off = (int)((long)((char *)call->data - (char *)fptr->o.obj)); -# if EO_CALL_CACHE_SIZE > 1 - cache->next_slot = (slot + 1) % EO_CALL_CACHE_SIZE; -# endif - } -#endif +/* # if EO_CALL_CACHE_SIZE > 0 */ +/* if (!fptr->cur_klass) */ +/* { */ +/* # if EO_CALL_CACHE_SIZE > 1 */ +/* const int slot = cache->next_slot; */ +/* # else */ +/* const int slot = 0; */ +/* # endif */ +/* cache->index[slot].klass = (const void *)inputklass; */ +/* cache->entry[slot].func = (const void *)func; */ +/* cache->off[slot].off = (int)((long)((char *)call->data - (char *)fptr->o.obj)); */ +/* # if EO_CALL_CACHE_SIZE > 1 */ +/* cache->next_slot = (slot + 1) % EO_CALL_CACHE_SIZE; */ +/* # endif */ +/* } */ +/* #endif */ return EINA_TRUE; } @@ -636,7 +658,7 @@ end: { Eina_List *itr; Eo *emb_obj_id; - EINA_LIST_FOREACH(((_Eo_Object *) fptr->o.obj)->composite_objects, itr, emb_obj_id) + EINA_LIST_FOREACH(((_Eo_Object *) _obj)->composite_objects, itr, emb_obj_id) { _Eo_Object *emb_obj = _eo_obj_pointer_get((Eo_Id)emb_obj_id); @@ -660,21 +682,21 @@ end: { const _Eo_Class *main_klass; - main_klass = (is_obj) ? fptr->o.obj->klass : fptr->o.kls; + main_klass = (is_obj) ? _obj->klass : klass; /* If it's a do_super call. */ - if (fptr->cur_klass) - { - ERR("in %s:%d: func '%s' (%d) could not be resolved for class '%s' for super of '%s'.", - file, line, func_name, cache->op, main_klass->desc->name, - fptr->cur_klass->desc->name); - } - else - { - /* we should not be able to take this branch */ - ERR("in %s:%d: func '%s' (%d) could not be resolved for class '%s'.", - file, line, func_name, cache->op, main_klass->desc->name); - } + /* if (fptr->cur_klass) */ + /* { */ + /* ERR("in %s:%d: func '%s' (%d) could not be resolved for class '%s' for super of '%s'.", */ + /* file, line, func_name, cache->op, main_klass->desc->name, */ + /* fptr->cur_klass->desc->name); */ + /* } */ + /* else */ + /* { */ + /* /\* we should not be able to take this branch *\/ */ + /* ERR("in %s:%d: func '%s' (%d) could not be resolved for class '%s'.", */ + /* file, line, func_name, cache->op, main_klass->desc->name); */ + /* } */ } return EINA_FALSE; } @@ -908,65 +930,65 @@ _eo_add_internal_start(const char *file, int line, const Eo_Class *klass_id, Eo return eo_id; } -static Eo * -_eo_add_internal_end(Eo *eo_id, Eo_Call_Stack *stack) -{ - Eo_Stack_Frame *fptr; - - fptr = stack->frame_ptr; - - if (EINA_UNLIKELY(!fptr->o.obj)) - { - ERR("Corrupt call stack, shouldn't happen, please report!"); - return NULL; - } - - if (!fptr->o.obj->condtor_done) - { - const _Eo_Class *klass = fptr->o.obj->klass; - - ERR("Object of class '%s' - Not all of the object constructors have been executed.", - klass->desc->name); - goto cleanup; - } - - if (!eo_id) - { - // XXX: Given EFL usage of objects, construction is a perfectly valid thing - // to do. we shouldn't complain about it as handling a NULL obj creation is - // the job of the caller. a perfect example here is ecore_con and ecore_ipc - // where you create a con or ipc obj then set up type/destination/port and - // the finalize of the constructor does the actual connect and thus this - // fails or succeeds based on if service is there. - // - // until there is a better solution - don't complain here. - // - // ERR("Object of class '%s' - Finalizing the object failed.", - // klass->desc->name); - goto cleanup; - } - - fptr->o.obj->finalized = EINA_TRUE; - - _eo_unref(fptr->o.obj); - - return (Eo *)eo_id; - -cleanup: - _eo_unref(fptr->o.obj); - eo_del((Eo *) fptr->o.obj->header.id); - return NULL; -} - -EAPI Eo * -_eo_add_end(void *eo_stack) -{ - void *__eo_ctx = _eo_stack_get(); - Eo *ret = eo_finalize(); - ret = _eo_add_internal_end(ret, eo_stack); - _eo_do_end(eo_stack); - return ret; -} +/* static Eo * */ +/* _eo_add_internal_end(Eo *eo_id, Eo_Call_Stack *stack) */ +/* { */ +/* Eo_Stack_Frame *fptr; */ + +/* fptr = stack->frame_ptr; */ + +/* if (EINA_UNLIKELY(!fptr->o.obj)) */ +/* { */ +/* ERR("Corrupt call stack, shouldn't happen, please report!"); */ +/* return NULL; */ +/* } */ + +/* if (!fptr->o.obj->condtor_done) */ +/* { */ +/* const _Eo_Class *klass = fptr->o.obj->klass; */ + +/* ERR("Object of class '%s' - Not all of the object constructors have been executed.", */ +/* klass->desc->name); */ +/* goto cleanup; */ +/* } */ + +/* if (!eo_id) */ +/* { */ +/* // XXX: Given EFL usage of objects, construction is a perfectly valid thing */ +/* // to do. we shouldn't complain about it as handling a NULL obj creation is */ +/* // the job of the caller. a perfect example here is ecore_con and ecore_ipc */ +/* // where you create a con or ipc obj then set up type/destination/port and */ +/* // the finalize of the constructor does the actual connect and thus this */ +/* // fails or succeeds based on if service is there. */ +/* // */ +/* // until there is a better solution - don't complain here. */ +/* // */ +/* // ERR("Object of class '%s' - Finalizing the object failed.", */ +/* // klass->desc->name); */ +/* goto cleanup; */ +/* } */ + +/* fptr->o.obj->finalized = EINA_TRUE; */ + +/* _eo_unref(fptr->o.obj); */ + +/* return (Eo *)eo_id; */ + +/* cleanup: */ +/* _eo_unref(fptr->o.obj); */ +/* eo_del((Eo *) fptr->o.obj->header.id); */ +/* return NULL; */ +/* } */ + +/* EAPI Eo * */ +/* _eo_add_end(void *eo_stack) */ +/* { */ +/* void *__eo_ctx = _eo_stack_get(); */ +/* Eo *ret = eo_finalize(); */ +/* ret = _eo_add_internal_end(ret, eo_stack); */ +/* _eo_do_end(eo_stack); */ +/* return ret; */ +/* } */ /*****************************************************************************/ @@ -1822,26 +1844,26 @@ eo_init(void) /* bootstrap EO_CLASS_CLASS */ (void) EO_ABSTRACT_CLASS_CLASS; - if (_eo_call_stack_key != 0) - WRN("_eo_call_stack_key already set, this should not happen."); - else - { - if (!eina_tls_cb_new(&_eo_call_stack_key, _eo_call_stack_free)) - { - EINA_LOG_ERR("Could not create TLS key for call stack."); - return EINA_FALSE; - - } - } - -#ifndef HAVE_THREAD_SPECIFIER - main_loop_stack = _eo_call_stack_create(); - if (!main_loop_stack) - { - EINA_LOG_ERR("Could not alloc eo call stack."); - return EINA_FALSE; - } -#endif +/* if (_eo_call_stack_key != 0) */ +/* WRN("_eo_call_stack_key already set, this should not happen."); */ +/* else */ +/* { */ +/* if (!eina_tls_cb_new(&_eo_call_stack_key, _eo_call_stack_free)) */ +/* { */ +/* EINA_LOG_ERR("Could not create TLS key for call stack."); */ +/* return EINA_FALSE; */ + +/* } */ +/* } */ + +/* #ifndef HAVE_THREAD_SPECIFIER */ +/* main_loop_stack = _eo_call_stack_create(); */ +/* if (!main_loop_stack) */ +/* { */ +/* EINA_LOG_ERR("Could not alloc eo call stack."); */ +/* return EINA_FALSE; */ +/* } */ +/* #endif */ return EINA_TRUE; } @@ -1873,10 +1895,10 @@ eo_shutdown(void) eina_spinlock_free(&_ops_storage_lock); eina_spinlock_free(&_eo_class_creation_lock); - if (_eo_call_stack_key != 0) - eina_tls_free(_eo_call_stack_key); + /* if (_eo_call_stack_key != 0) */ + /* eina_tls_free(_eo_call_stack_key); */ - _eo_free_ids_tables(); + /* _eo_free_ids_tables(); */ eina_log_domain_unregister(_eo_log_dom); _eo_log_dom = -1; |