1 files changed, 699 insertions, 0 deletions

diff --git a/libraries/eina/src/tests/eina_bench_array.c b/libraries/eina/src/tests/eina_bench_array.c
new file mode 100644
index 0000000..425eddd
--- /dev/null
+++ b/libraries/eina/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,
+                           500, 100);
+}
+