diff options
Diffstat (limited to 'src/tests/eina_bench_array.c')
| -rw-r--r-- | src/tests/eina_bench_array.c | 699 |
1 files changed, 699 insertions, 0 deletions
diff --git a/src/tests/eina_bench_array.c b/src/tests/eina_bench_array.c new file mode 100644 index 0000000..2e32e98 --- /dev/null +++ b/src/tests/eina_bench_array.c @@ -0,0 +1,699 @@ +/* EINA - EFL data type library + * Copyright (C) 2008 Cedric Bail + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; + * if not, see <http://www.gnu.org/licenses/>. + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include <stdlib.h> +#include <stdio.h> +#include <time.h> + +#ifdef EINA_BENCH_HAVE_GLIB +# include <glib.h> +#endif + +#include "Evas_Data.h" +#include "Ecore_Data.h" + +#include "eina_bench.h" +#include "eina_array.h" +#include "eina_list.h" +#include "eina_inlist.h" +#include "eina_main.h" + +typedef struct _Eina_Bench_Object Eina_Bench_Object; +struct _Eina_Bench_Object +{ + EINA_INLIST; + + void *somewhere; + int data; + Eina_Bool keep; +}; + +static Eina_Bool keep(void *data, __UNUSED__ void *gdata) +{ + Eina_Bench_Object *bo = data; + + if (bo->keep == EINA_TRUE) + return EINA_TRUE; + + free(bo); + return EINA_FALSE; +} + +static void +eina_bench_array_4evas_render_inline(int request) +{ + Eina_Array *array; + Eina_Bench_Object *ebo; + Eina_Array_Iterator it; + unsigned int i; + unsigned int j; + + srand(time(NULL)); + + eina_init(); + + array = eina_array_new(64); + + for (i = 0; i < 1000; ++i) + { + for (j = 0; j < (unsigned int)request; ++j) + { + ebo = malloc(sizeof (Eina_Bench_Object)); + if (!ebo) + continue; + + ebo->keep = rand() < (RAND_MAX / 2) ? EINA_TRUE : EINA_FALSE; + + eina_array_push(array, ebo); + } + + if (i == 500) + { + EINA_ARRAY_ITER_NEXT(array, j, ebo, it) + free(ebo); + + eina_array_clean(array); + } + else if (i % 30 == 0) + eina_array_remove(array, keep, NULL); + + EINA_ARRAY_ITER_NEXT(array, j, ebo, it) + ebo->keep = rand() < (RAND_MAX / 2) ? ebo->keep : EINA_FALSE; + } + + EINA_ARRAY_ITER_NEXT(array, j, ebo, it) + free(ebo); + + eina_array_free(array); + + eina_shutdown(); +} + +static Eina_Bool +eina_iterator_ebo_free(__UNUSED__ const Eina_Array *array, + Eina_Bench_Object *ebo, __UNUSED__ void *fdata) +{ + free(ebo); + return EINA_TRUE; +} + +static Eina_Bool +eina_iterator_ebo_rand(__UNUSED__ const void *container, + Eina_Bench_Object *ebo, __UNUSED__ void *fdata) +{ + ebo->keep = rand() < (RAND_MAX / 2) ? ebo->keep : EINA_FALSE; + return EINA_TRUE; +} + +static void +eina_bench_array_4evas_render_iterator(int request) +{ + Eina_Array *array; + Eina_Bench_Object *ebo; + Eina_Iterator *it; + unsigned int i; + unsigned int j; + + srand(time(NULL)); + + eina_init(); + + array = eina_array_new(64); + + for (i = 0; i < 1000; ++i) + { + for (j = 0; j < (unsigned int)request; ++j) + { + ebo = malloc(sizeof (Eina_Bench_Object)); + if (!ebo) + continue; + + ebo->keep = rand() < (RAND_MAX / 2) ? EINA_TRUE : EINA_FALSE; + + eina_array_push(array, ebo); + } + + if (i == 500) + { + it = eina_array_iterator_new(array); + eina_iterator_foreach(it, EINA_EACH_CB(eina_iterator_ebo_free), NULL); + eina_iterator_free(it); + + eina_array_clean(array); + } + else if (i % 30 == 0) + eina_array_remove(array, keep, NULL); + + it = eina_array_iterator_new(array); + eina_iterator_foreach(it, EINA_EACH_CB(eina_iterator_ebo_rand), NULL); + eina_iterator_free(it); + } + + it = eina_array_iterator_new(array); + eina_iterator_foreach(it, EINA_EACH_CB(eina_iterator_ebo_free), NULL); + eina_iterator_free(it); + + eina_array_free(array); + + eina_shutdown(); +} + +static void +eina_bench_list_4evas_render(int request) +{ + Eina_List *list = NULL; + Eina_List *tmp; + Eina_Bench_Object *ebo; + int i; + int j; + + eina_init(); + + for (i = 0; i < 1000; ++i) + { + for (j = 0; j < request; ++j) + { + ebo = malloc(sizeof (Eina_Bench_Object)); + if (!ebo) + continue; + + ebo->keep = rand() < (RAND_MAX / 2) ? EINA_TRUE : EINA_FALSE; + + list = eina_list_prepend(list, ebo); + } + + if (i == 500) + while (list) + { + free(eina_list_data_get(list)); + list = eina_list_remove_list(list, list); + } + else if (i % 30 == 0) + { + tmp = list; + while (tmp) + { + Eina_List *reminder = tmp; + + ebo = eina_list_data_get(reminder); + tmp = eina_list_next(tmp); + + if (ebo->keep == EINA_FALSE) + { + list = eina_list_remove_list(list, reminder); + free(ebo); + } + } + } + + for (tmp = list; tmp; tmp = eina_list_next(tmp)) + { + ebo = eina_list_data_get(tmp); + + ebo->keep = rand() < (RAND_MAX / 2) ? ebo->keep : EINA_FALSE; + } + } + + while (list) + { + free(eina_list_data_get(list)); + list = eina_list_remove_list(list, list); + } + + eina_shutdown(); +} + +static void +eina_bench_list_4evas_render_iterator(int request) +{ + Eina_List *list = NULL; + Eina_List *tmp; + Eina_Bench_Object *ebo; + Eina_Iterator *it; + int i; + int j; + + eina_init(); + + for (i = 0; i < 1000; ++i) + { + for (j = 0; j < request; ++j) + { + ebo = malloc(sizeof (Eina_Bench_Object)); + if (!ebo) + continue; + + ebo->keep = rand() < (RAND_MAX / 2) ? EINA_TRUE : EINA_FALSE; + + list = eina_list_prepend(list, ebo); + } + + if (i == 500) + while (list) + { + free(eina_list_data_get(list)); + list = eina_list_remove_list(list, list); + } + else if (i % 30 == 0) + { + tmp = list; + while (tmp) + { + Eina_List *reminder = tmp; + + ebo = eina_list_data_get(reminder); + tmp = eina_list_next(tmp); + + if (ebo->keep == EINA_FALSE) + { + list = eina_list_remove_list(list, reminder); + free(ebo); + } + } + } + + it = eina_list_iterator_new(list); + eina_iterator_foreach(it, EINA_EACH_CB(eina_iterator_ebo_rand), NULL); + eina_iterator_free(it); + } + + while (list) + { + free(eina_list_data_get(list)); + list = eina_list_remove_list(list, list); + } + + eina_shutdown(); +} + +static void +eina_bench_inlist_4evas_render(int request) +{ + Eina_Inlist *head = NULL; + Eina_Inlist *tmp; + Eina_Bench_Object *ebo; + int i; + int j; + + for (i = 0; i < 1000; ++i) + { + for (j = 0; j < request; ++j) + { + ebo = malloc(sizeof (Eina_Bench_Object)); + if (!ebo) + continue; + + ebo->keep = rand() < (RAND_MAX / 2) ? EINA_TRUE : EINA_FALSE; + + head = eina_inlist_prepend(head, EINA_INLIST_GET(ebo)); + } + + if (i == 500) + while (head) + { + tmp = head; + head = head->next; + free(tmp); + } + else if (i % 30 == 0) + { + tmp = head; + while(tmp) + { + ebo = (Eina_Bench_Object *)tmp; + + tmp = tmp->next; + if (ebo->keep == EINA_FALSE) + { + head = eina_inlist_remove(head, EINA_INLIST_GET(ebo)); + free(ebo); + } + } + } + + EINA_INLIST_FOREACH(head, ebo) + ebo->keep = rand() < (RAND_MAX / 2) ? ebo->keep : EINA_FALSE; + } + + while (head) + { + tmp = head; + head = head->next; + free(tmp); + } +} + +static void +eina_bench_inlist_4evas_render_iterator(int request) +{ + Eina_Inlist *head = NULL; + Eina_Inlist *tmp; + Eina_Bench_Object *ebo; + Eina_Iterator *it; + int i; + int j; + + for (i = 0; i < 1000; ++i) + { + for (j = 0; j < request; ++j) + { + ebo = malloc(sizeof (Eina_Bench_Object)); + if (!ebo) + continue; + + ebo->keep = rand() < (RAND_MAX / 2) ? EINA_TRUE : EINA_FALSE; + + head = eina_inlist_prepend(head, EINA_INLIST_GET(ebo)); + } + + if (i == 500) + while (head) + { + tmp = head; + head = head->next; + free(tmp); + } + else if (i % 30 == 0) + { + tmp = head; + while(tmp) + { + ebo = (Eina_Bench_Object *)tmp; + + tmp = tmp->next; + if (ebo->keep == EINA_FALSE) + { + head = eina_inlist_remove(head, EINA_INLIST_GET(ebo)); + free(ebo); + } + } + } + + it = eina_inlist_iterator_new(head); + eina_iterator_foreach(it, EINA_EACH_CB(eina_iterator_ebo_rand), NULL); + eina_iterator_free(it); + } + + while (head) + { + tmp = head; + head = head->next; + free(tmp); + } +} + +#ifdef EINA_BENCH_HAVE_GLIB +static void +eina_bench_glist_4evas_render(int request) +{ + GList *list = NULL; + GList *tmp; + Eina_Bench_Object *ebo; + int i; + int j; + + for (i = 0; i < 1000; ++i) + { + for (j = 0; j < request; ++j) + { + ebo = malloc(sizeof (Eina_Bench_Object)); + if (!ebo) + continue; + + ebo->keep = rand() < (RAND_MAX / 2) ? EINA_TRUE : EINA_FALSE; + + list = g_list_prepend(list, ebo); + } + + if (i == 500) + while (list) + { + free(list->data); + list = g_list_delete_link(list, list); + } + else if (i % 30 == 0) + { + tmp = list; + while (tmp) + { + GList *reminder = tmp; + + ebo = reminder->data; + tmp = g_list_next(tmp); + + if (ebo->keep == EINA_FALSE) + { + list = g_list_delete_link(list, reminder); + free(ebo); + } + } + } + + for (tmp = list; tmp; tmp = g_list_next(tmp)) + { + ebo = tmp->data; + + ebo->keep = rand() < (RAND_MAX / 2) ? ebo->keep : EINA_FALSE; + } + } + + while (list) + { + free(list->data); + list = g_list_delete_link(list, list); + } +} + +static void +eina_bench_gptrarray_4evas_render(int request) +{ + GPtrArray *array = NULL; + Eina_Bench_Object *ebo; + unsigned int j; + int i; + + array = g_ptr_array_new(); + + for (i = 0; i < 1000; ++i) + { + for (j = 0; j < (unsigned int)request; ++j) + { + ebo = malloc(sizeof (Eina_Bench_Object)); + if (!ebo) + continue; + + ebo->keep = rand() < (RAND_MAX / 2) ? EINA_TRUE : EINA_FALSE; + + g_ptr_array_add(array, ebo); + } + + if (i == 500) + { + for (j = 0; j < array->len; ++j) + free(g_ptr_array_index(array, j)); + g_ptr_array_remove_range(array, 0, array->len); + } + else if (i % 30 == 0) + for (j = 0; j < array->len; ) + { + ebo = g_ptr_array_index(array, j); + + if (ebo->keep == EINA_FALSE) + free(g_ptr_array_remove_index_fast(array, j)); + else + j++; + } + + for (j = 0; j < array->len; ++j) + { + ebo = g_ptr_array_index(array, j); + + ebo->keep = rand() < (RAND_MAX / 2) ? ebo->keep : EINA_FALSE; + } + } + + for (j = 0; j < array->len; ++j) + free(g_ptr_array_index(array, j)); + g_ptr_array_free(array, TRUE); +} +#endif + +static void +eina_bench_evas_list_4evas_render(int request) +{ + Evas_List *list = NULL; + Evas_List *tmp; + Eina_Bench_Object *ebo; + int i; + int j; + + for (i = 0; i < 1000; ++i) + { + for (j = 0; j < request; ++j) + { + ebo = malloc(sizeof (Eina_Bench_Object)); + if (!ebo) + continue; + + ebo->keep = rand() < (RAND_MAX / 2) ? EINA_TRUE : EINA_FALSE; + + list = evas_list_prepend(list, ebo); + } + + if (i == 500) + while (list) + { + free(evas_list_data(list)); + list = evas_list_remove_list(list, list); + } + else if (i % 30 == 0) + { + tmp = list; + while (tmp) + { + Evas_List *reminder = tmp; + + ebo = evas_list_data(reminder); + tmp = evas_list_next(tmp); + + if (ebo->keep == EINA_FALSE) + { + list = evas_list_remove_list(list, reminder); + free(ebo); + } + } + } + + for (tmp = list; tmp; tmp = evas_list_next(tmp)) + { + ebo = evas_list_data(tmp); + + ebo->keep = rand() < (RAND_MAX / 2) ? ebo->keep : EINA_FALSE; + } + } + + while (list) + { + free(evas_list_data(list)); + list = evas_list_remove_list(list, list); + } +} + +static void +_eina_ecore_for_each_remove(void *value, void *user_data) +{ + Eina_Bench_Object *ebo = value; + Ecore_List *list = user_data; + + if (ebo->keep == EINA_FALSE) + ecore_list_remove_destroy(list); +} + +static void +_eina_ecore_for_each_rand(void *value, __UNUSED__ void *user_data) +{ + Eina_Bench_Object *ebo = value; + + ebo->keep = rand() < (RAND_MAX / 2) ? ebo->keep : EINA_FALSE; +} + +static void +eina_bench_ecore_list_4evas_render(int request) +{ + Ecore_List *list = NULL; + Eina_Bench_Object *ebo; + int i; + int j; + + list = ecore_list_new(); + ecore_list_free_cb_set(list, free); + + for (i = 0; i < 1000; ++i) + { + for (j = 0; j < request; ++j) + { + ebo = malloc(sizeof (Eina_Bench_Object)); + if (!ebo) + continue; + + ebo->keep = rand() < (RAND_MAX / 2) ? EINA_TRUE : EINA_FALSE; + + ecore_list_prepend(list, ebo); + } + + if (i == 500) + ecore_list_clear(list); + else if (i % 30 == 0) + ecore_list_for_each(list, _eina_ecore_for_each_remove, list); + + ecore_list_for_each(list, _eina_ecore_for_each_rand, list); + } + + ecore_list_destroy(list); +} + +void eina_bench_array(Eina_Benchmark *bench) +{ + eina_benchmark_register(bench, "array-inline", + EINA_BENCHMARK( + eina_bench_array_4evas_render_inline), 200, + 4000, 100); + eina_benchmark_register(bench, "array-iterator", + EINA_BENCHMARK( + eina_bench_array_4evas_render_iterator), 200, + 4000, 100); + eina_benchmark_register(bench, "list", + EINA_BENCHMARK( + eina_bench_list_4evas_render), 200, + 4000, 100); + eina_benchmark_register(bench, "list-iterator", + EINA_BENCHMARK( + eina_bench_list_4evas_render_iterator), 200, + 4000, 100); + eina_benchmark_register(bench, "inlist", + EINA_BENCHMARK( + eina_bench_inlist_4evas_render), 200, + 4000, 100); + eina_benchmark_register(bench, "inlist-iterator", + EINA_BENCHMARK( + eina_bench_inlist_4evas_render_iterator), 200, + 4000, 100); +#ifdef EINA_BENCH_HAVE_GLIB + eina_benchmark_register(bench, "glist", + EINA_BENCHMARK( + eina_bench_glist_4evas_render), 200, + 4000, 100); + eina_benchmark_register(bench, "gptrarray", + EINA_BENCHMARK( + eina_bench_gptrarray_4evas_render), 200, + 4000, 100); +#endif + eina_benchmark_register(bench, "evas", + EINA_BENCHMARK( + eina_bench_evas_list_4evas_render), 200, + 4000, 100); + /* eina_benchmark_register(bench, "ecore", */ + /* EINA_BENCHMARK( */ + /* eina_bench_ecore_list_4evas_render), 200, */ + /* 1000, 100); */ +} + |