eina - add a free queue (eina_freeq) for deferring frees of data

this adds eina_freeq api's for c land for deferring freeing of
pointers and can be used a s a simple copy & paste drop-in for free()
just to "do this later". the pointer will eveentually be freed as
eina_shutdown will free the main free queue and this will in turn free
everything in it. as long as the main lo0op keeps pumping things will
og on the queue and then be freed from it. free queues have limits so
if they get full they will clear out old pointers and free them so it
won't grow without bound. the default max is 1mb of data or 16384
items whichever limit is hit first and at that point the oldest item
will be freed to make room for the newest. the mainloop whenever it
finishes idle enterers will add an idler to spin and free while idle.
the sizes can be tuned and aruged about as to what defaults should be.

this also allows for better memory debugging too by being able to fill
freed memory with patterns if its small enough etc. etc.

@feature

3 files changed, 124 insertions, 0 deletions

diff --git a/src/tests/eina/eina_suite.c b/src/tests/eina/eina_suite.c
index 2c35a11536..7bdd62f742 100644
--- a/src/tests/eina/eina_suite.c
+++ b/src/tests/eina/eina_suite.c
@@ -81,6 +81,7 @@ static const Efl_Test_Case etc[] = {
    { "Bezier", eina_test_bezier },
    { "SafePointer", eina_test_safepointer },
    { "Slice", eina_test_slice },
+   { "Free Queue", eina_test_freeq },
    { NULL, NULL }
 };
 
diff --git a/src/tests/eina/eina_suite.h b/src/tests/eina/eina_suite.h
index 3ff362e7bd..3bda471d1f 100644
--- a/src/tests/eina/eina_suite.h
+++ b/src/tests/eina/eina_suite.h
@@ -73,5 +73,6 @@ void eina_test_promise(TCase *tc);
 void eina_test_bezier(TCase *tc);
 void eina_test_safepointer(TCase *tc);
 void eina_test_slice(TCase *tc);
+void eina_test_freeq(TCase *tc);
 
 #endif /* EINA_SUITE_H_ */
diff --git a/src/tests/eina/eina_test_freeq.c b/src/tests/eina/eina_test_freeq.c
new file mode 100644
index 0000000000..bf732b9be0
--- /dev/null
+++ b/src/tests/eina/eina_test_freeq.c
@@ -0,0 +1,122 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <Eina.h>
+
+#include "eina_suite.h"
+
+START_TEST(freeq_simple)
+{
+   Eina_FreeQ *fq, *pfq;
+
+   eina_init();
+
+   fail_if(eina_freeq_main_get() == NULL);
+   pfq = eina_freeq_main_get();
+
+   fq = eina_freeq_new();
+   fail_if(!fq);
+
+   eina_freeq_main_set(fq);
+   fail_if(eina_freeq_main_get() != fq);
+
+   eina_freeq_free(fq);
+   fail_if(eina_freeq_main_get() != NULL);
+   eina_freeq_main_set(pfq);
+
+   eina_shutdown();
+}
+END_TEST
+
+static int _n = 0;
+
+static void freefn(void *data)
+{
+   free(data);
+   _n--;
+}
+
+START_TEST(freeq_tune)
+{
+   void *p;
+
+   eina_init();
+
+   eina_freeq_count_max_set(eina_freeq_main_get(), 3);
+   fail_if(eina_freeq_count_max_get(eina_freeq_main_get()) != 3);
+
+   eina_freeq_mem_max_set(eina_freeq_main_get(), 20);
+   fail_if(eina_freeq_mem_max_get(eina_freeq_main_get()) != 20);
+
+   _n++;
+   p = malloc(9);
+   eina_freeq_ptr_main_add(p, freefn, 9);
+   _n++;
+   p = malloc(9);
+   eina_freeq_ptr_main_add(p, freefn, 9);
+   _n++;
+   p = malloc(9);
+   eina_freeq_ptr_main_add(p, freefn, 9);
+   eina_freeq_ptr_main_add(NULL, freefn, 9);
+   fail_if(_n > 2);
+
+   eina_freeq_count_max_set(eina_freeq_main_get(), 1);
+   fail_if(_n > 1);
+
+   eina_freeq_clear(eina_freeq_main_get());
+   fail_if(_n > 0);
+
+   fail_if(eina_freeq_ptr_pending(eina_freeq_main_get()) == EINA_TRUE);
+
+   eina_shutdown();
+}
+END_TEST
+
+START_TEST(freeq_reduce)
+{
+   void *p;
+
+   eina_init();
+
+   _n++;
+   p = malloc(9);
+   eina_freeq_ptr_main_add(p, freefn, 9);
+   _n++;
+   p = malloc(9);
+   eina_freeq_ptr_main_add(p, freefn, 9);
+   _n++;
+   p = malloc(9);
+   eina_freeq_ptr_main_add(p, freefn, 9);
+
+   while (eina_freeq_ptr_pending(eina_freeq_main_get()))
+     eina_freeq_reduce(eina_freeq_main_get(), 1);
+   fail_if(_n > 0);
+   fail_if(eina_freeq_ptr_pending(eina_freeq_main_get()) == EINA_TRUE);
+
+   _n++;
+   p = malloc(9);
+   eina_freeq_ptr_main_add(p, freefn, 9);
+   _n++;
+   p = malloc(9);
+   eina_freeq_ptr_main_add(p, freefn, 9);
+   _n++;
+   p = malloc(9);
+   eina_freeq_ptr_main_add(p, freefn, 9);
+
+   while (eina_freeq_ptr_pending(eina_freeq_main_get()))
+     eina_freeq_reduce(eina_freeq_main_get(), 5);
+   fail_if(_n > 0);
+   fail_if(eina_freeq_ptr_pending(eina_freeq_main_get()) == EINA_TRUE);
+
+   eina_shutdown();
+}
+END_TEST
+
+void
+eina_test_freeq(TCase *tc)
+{
+   tcase_add_test(tc, freeq_simple);
+   tcase_add_test(tc, freeq_tune);
+   tcase_add_test(tc, freeq_reduce);
+}