efl

1
/* EINA - EFL data type library
2
 * Copyright (C) 2008 Cedric Bail
3
 *
4
 * This library is free software; you can redistribute it and/or
5
 * modify it under the terms of the GNU Lesser General Public
6
 * License as published by the Free Software Foundation; either
7
 * version 2.1 of the License, or (at your option) any later version.
8
 *
9
 * This library is distributed in the hope that it will be useful,
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12
 * Lesser General Public License for more details.
13
 *
14
 * You should have received a copy of the GNU Lesser General Public
15
 * License along with this library;
16
 * if not, see <http://www.gnu.org/licenses/>.
17
 */
18

19
#ifdef HAVE_CONFIG_H
20
# include "config.h"
21
#endif
22

23
#include <stdlib.h>
24
#include <stdio.h>
25
#include <time.h>
26

27
#ifdef EINA_BENCH_HAVE_GLIB
28
# include <glib.h>
29
#endif
30

31
#include "Evas_Data.h"
32
#include "Ecore_Data.h"
33

34
#include "eina_bench.h"
35
#include "eina_array.h"
36
#include "eina_list.h"
37
#include "eina_inlist.h"
38
#include "eina_main.h"
39

40
typedef struct _Eina_Bench_Object Eina_Bench_Object;
41
struct _Eina_Bench_Object
42
{
43
   EINA_INLIST;
44

45
   void *somewhere;
46
   int data;
47
   Eina_Bool keep;
48
};
49

50
static Eina_Bool keep(void *data, EINA_UNUSED void *gdata)
51
{
52
   Eina_Bench_Object *bo = data;
53

54
   if (bo->keep == EINA_TRUE)
55
      return EINA_TRUE;
56

57
   free(bo);
58
   return EINA_FALSE;
59
}
60

61
static void
62
eina_bench_array_4evas_render_inline(int request)
63
{
64
   Eina_Array *array;
65
   Eina_Bench_Object *ebo;
66
   Eina_Array_Iterator it;
67
   unsigned int i;
68
   unsigned int j;
69

70
   eina_init();
71

72
   array = eina_array_new(64);
73

74
   for (i = 0; i < 1000; ++i)
75
     {
76
        for (j = 0; j < (unsigned int)request; ++j)
77
          {
78
             ebo = malloc(sizeof (Eina_Bench_Object));
79
             if (!ebo)
80
                continue;
81

82
             ebo->keep = rand() < (RAND_MAX / 2) ? EINA_TRUE : EINA_FALSE;
83

84
             eina_array_push(array, ebo);
85
          }
86

87
        if (i == 500)
88
          {
89
             EINA_ARRAY_ITER_NEXT(array, j, ebo, it) free(ebo);
90
             eina_array_clean(array);
91
          }
92
        else if ((i % 30) == 0)
93
          {
94
             eina_array_remove(array, keep, NULL);
95
          }
96

97
        EINA_ARRAY_ITER_NEXT(array, j, ebo, it)
98
          ebo->keep = rand() < (RAND_MAX / 2) ? ebo->keep : EINA_FALSE;
99
     }
100

101
        EINA_ARRAY_ITER_NEXT(array, j, ebo, it)
102
          free(ebo);
103

104
   eina_array_free(array);
105

106
   eina_shutdown();
107
}
108

109
static Eina_Bool
110
eina_iterator_ebo_free(EINA_UNUSED const Eina_Array *array,
111
                       Eina_Bench_Object *ebo,  EINA_UNUSED void *fdata)
112
{
113
   free(ebo);
114
   return EINA_TRUE;
115
}
116

117
static Eina_Bool
118
eina_iterator_ebo_rand(EINA_UNUSED const void *container,
119
                       Eina_Bench_Object *ebo,  EINA_UNUSED void *fdata)
120
{
121
   ebo->keep = rand() < (RAND_MAX / 2) ? ebo->keep : EINA_FALSE;
122
   return EINA_TRUE;
123
}
124

125
static void
126
eina_bench_array_4evas_render_iterator(int request)
127
{
128
   Eina_Array *array;
129
   Eina_Bench_Object *ebo;
130
   Eina_Iterator *it;
131
   unsigned int i;
132
   unsigned int j;
133

134
   eina_init();
135

136
   array = eina_array_new(64);
137

138
   for (i = 0; i < 1000; ++i)
139
     {
140
        for (j = 0; j < (unsigned int)request; ++j)
141
          {
142
             ebo = malloc(sizeof (Eina_Bench_Object));
143
             if (!ebo)
144
                continue;
145

146
             ebo->keep = rand() < (RAND_MAX / 2) ? EINA_TRUE : EINA_FALSE;
147

148
             eina_array_push(array, ebo);
149
          }
150

151
        if (i == 500)
152
          {
153
             it = eina_array_iterator_new(array);
154
             eina_iterator_foreach(it, EINA_EACH_CB(eina_iterator_ebo_free), NULL);
155
             eina_iterator_free(it);
156

157
             eina_array_clean(array);
158
          }
159
        else if ((i % 30) == 0)
160
          {
161
             eina_array_remove(array, keep, NULL);
162
          }
163

164
        it = eina_array_iterator_new(array);
165
        eina_iterator_foreach(it, EINA_EACH_CB(eina_iterator_ebo_rand), NULL);
166
        eina_iterator_free(it);
167
     }
168

169
   it = eina_array_iterator_new(array);
170
   eina_iterator_foreach(it, EINA_EACH_CB(eina_iterator_ebo_free), NULL);
171
   eina_iterator_free(it);
172

173
   eina_array_free(array);
174

175
   eina_shutdown();
176
}
177

178
static void
179
eina_bench_list_4evas_render(int request)
180
{
181
   Eina_List *list = NULL;
182
   Eina_List *tmp;
183
   Eina_Bench_Object *ebo;
184
   int i;
185
   int j;
186

187
   eina_init();
188

189
   for (i = 0; i < 1000; ++i)
190
     {
191
        for (j = 0; j < request; ++j)
192
          {
193
             ebo = malloc(sizeof (Eina_Bench_Object));
194
             if (!ebo)
195
                continue;
196

197
             ebo->keep = rand() < (RAND_MAX / 2) ? EINA_TRUE : EINA_FALSE;
198

199
             list = eina_list_prepend(list, ebo);
200
          }
201

202
        if (i == 500)
203
           while (list)
204
             {
205
                       free(eina_list_data_get(list));
206
                list = eina_list_remove_list(list, list);
207
             }
208
        else if ((i % 30) == 0)
209
          {
210
             tmp = list;
211
             while (tmp)
212
               {
213
                  Eina_List *reminder = tmp;
214

215
                  ebo = eina_list_data_get(reminder);
216
                  tmp = eina_list_next(tmp);
217

218
                  if (ebo->keep == EINA_FALSE)
219
                    {
220
                       list = eina_list_remove_list(list, reminder);
221
                       free(ebo);
222
                    }
223
               }
224
          }
225

226
        for (tmp = list; tmp; tmp = eina_list_next(tmp))
227
          {
228
             ebo = eina_list_data_get(tmp);
229

230
             ebo->keep = rand() < (RAND_MAX / 2) ? ebo->keep : EINA_FALSE;
231
          }
232
     }
233

234
   while (list)
235
     {
236
                       free(eina_list_data_get(list));
237
        list = eina_list_remove_list(list, list);
238
     }
239

240
   eina_shutdown();
241
}
242

243
static void
244
eina_bench_list_4evas_render_iterator(int request)
245
{
246
   Eina_List *list = NULL;
247
   Eina_List *tmp;
248
   Eina_Bench_Object *ebo;
249
   Eina_Iterator *it;
250
   int i;
251
   int j;
252

253
   eina_init();
254

255
   for (i = 0; i < 1000; ++i)
256
     {
257
        for (j = 0; j < request; ++j)
258
          {
259
             ebo = malloc(sizeof (Eina_Bench_Object));
260
             if (!ebo)
261
                continue;
262

263
             ebo->keep = rand() < (RAND_MAX / 2) ? EINA_TRUE : EINA_FALSE;
264

265
             list = eina_list_prepend(list, ebo);
266
          }
267

268
        if (i == 500)
269
           while (list)
270
             {
271
                       free(eina_list_data_get(list));
272
                list = eina_list_remove_list(list, list);
273
             }
274
        else if ((i % 30) == 0)
275
          {
276
             tmp = list;
277
             while (tmp)
278
               {
279
                  Eina_List *reminder = tmp;
280

281
                  ebo = eina_list_data_get(reminder);
282
                  tmp = eina_list_next(tmp);
283

284
                  if (ebo->keep == EINA_FALSE)
285
                    {
286
                       list = eina_list_remove_list(list, reminder);
287
                       free(ebo);
288
                    }
289
               }
290
          }
291

292
        it = eina_list_iterator_new(list);
293
        eina_iterator_foreach(it, EINA_EACH_CB(eina_iterator_ebo_rand), NULL);
294
        eina_iterator_free(it);
295
     }
296

297
   while (list)
298
     {
299
        free(eina_list_data_get(list));
300
        list = eina_list_remove_list(list, list);
301
     }
302

303
   eina_shutdown();
304
}
305

306
static void
307
eina_bench_inlist_4evas_render(int request)
308
{
309
   Eina_Inlist *head = NULL;
310
   Eina_Inlist *tmp;
311
   Eina_Bench_Object *ebo;
312
   int i;
313
   int j;
314

315
   for (i = 0; i < 1000; ++i)
316
     {
317
        for (j = 0; j < request; ++j)
318
          {
319
             ebo = malloc(sizeof (Eina_Bench_Object));
320
             if (!ebo)
321
                continue;
322

323
             ebo->keep = rand() < (RAND_MAX / 2) ? EINA_TRUE : EINA_FALSE;
324

325
             head = eina_inlist_prepend(head, EINA_INLIST_GET(ebo));
326
          }
327

328
        if (i == 500)
329
           while (head)
330
             {
331
                tmp = head;
332
                head = head->next;
333
                       free(tmp);
334
             }
335
        else if ((i % 30) == 0)
336
          {
337
             tmp = head;
338
             while(tmp)
339
               {
340
                  ebo = (Eina_Bench_Object *)tmp;
341

342
                  tmp = tmp->next;
343
                  if (ebo->keep == EINA_FALSE)
344
                    {
345
                       head = eina_inlist_remove(head, EINA_INLIST_GET(ebo));
346
                       free(ebo);
347
                    }
348
               }
349
          }
350

351
        EINA_INLIST_FOREACH(head, ebo)
352
        ebo->keep = rand() < (RAND_MAX / 2) ? ebo->keep : EINA_FALSE;
353
     }
354

355
   while (head)
356
     {
357
        tmp = head;
358
        head = head->next;
359
                       free(tmp);
360
     }
361
}
362

363
static void
364
eina_bench_inlist_4evas_render_iterator(int request)
365
{
366
   Eina_Inlist *head = NULL;
367
   Eina_Inlist *tmp;
368
   Eina_Bench_Object *ebo;
369
   Eina_Iterator *it;
370
   int i;
371
   int j;
372

373
   for (i = 0; i < 1000; ++i)
374
     {
375
        for (j = 0; j < request; ++j)
376
          {
377
             ebo = malloc(sizeof (Eina_Bench_Object));
378
             if (!ebo)
379
                continue;
380

381
             ebo->keep = rand() < (RAND_MAX / 2) ? EINA_TRUE : EINA_FALSE;
382

383
             head = eina_inlist_prepend(head, EINA_INLIST_GET(ebo));
384
          }
385

386
        if (i == 500)
387
           while (head)
388
             {
389
                tmp = head;
390
                head = head->next;
391
                       free(tmp);
392
             }
393
        else if ((i % 30) == 0)
394
          {
395
             tmp = head;
396
             while(tmp)
397
               {
398
                  ebo = (Eina_Bench_Object *)tmp;
399

400
                  tmp = tmp->next;
401
                  if (ebo->keep == EINA_FALSE)
402
                    {
403
                       head = eina_inlist_remove(head, EINA_INLIST_GET(ebo));
404
                       free(ebo);
405
                    }
406
               }
407
          }
408

409
        it = eina_inlist_iterator_new(head);
410
        eina_iterator_foreach(it, EINA_EACH_CB(eina_iterator_ebo_rand), NULL);
411
        eina_iterator_free(it);
412
     }
413

414
   while (head)
415
     {
416
        tmp = head;
417
        head = head->next;
418
                       free(tmp);
419
     }
420
}
421

422
#ifdef EINA_BENCH_HAVE_GLIB
423
static void
424
eina_bench_glist_4evas_render(int request)
425
{
426
   GList *list = NULL;
427
   GList *tmp;
428
   Eina_Bench_Object *ebo;
429
   int i;
430
   int j;
431

432
   for (i = 0; i < 1000; ++i)
433
     {
434
        for (j = 0; j < request; ++j)
435
          {
436
             ebo = malloc(sizeof (Eina_Bench_Object));
437
             if (!ebo)
438
                continue;
439

440
             ebo->keep = rand() < (RAND_MAX / 2) ? EINA_TRUE : EINA_FALSE;
441

442
             list = g_list_prepend(list, ebo);
443
          }
444

445
        if (i == 500)
446
           while (list)
447
             {
448
                       free(list->data);
449
                list = g_list_delete_link(list, list);
450
             }
451
        else if ((i % 30) == 0)
452
          {
453
             tmp = list;
454
             while (tmp)
455
               {
456
                  GList *reminder = tmp;
457

458
                  ebo = reminder->data;
459
                  tmp = g_list_next(tmp);
460

461
                  if (ebo->keep == EINA_FALSE)
462
                    {
463
                       list = g_list_delete_link(list, reminder);
464
                       free(ebo);
465
                    }
466
               }
467
          }
468

469
        for (tmp = list; tmp; tmp = g_list_next(tmp))
470
          {
471
             ebo = tmp->data;
472

473
             ebo->keep = rand() < (RAND_MAX / 2) ? ebo->keep : EINA_FALSE;
474
          }
475
     }
476

477
   while (list)
478
     {
479
                       free(list->data);
480
        list = g_list_delete_link(list, list);
481
     }
482
}
483

484
static void
485
eina_bench_gptrarray_4evas_render(int request)
486
{
487
   GPtrArray *array = NULL;
488
   Eina_Bench_Object *ebo;
489
   unsigned int j;
490
   int i;
491

492
   array = g_ptr_array_new();
493

494
   for (i = 0; i < 1000; ++i)
495
     {
496
        for (j = 0; j < (unsigned int)request; ++j)
497
          {
498
             ebo = malloc(sizeof (Eina_Bench_Object));
499
             if (!ebo)
500
                continue;
501

502
             ebo->keep = rand() < (RAND_MAX / 2) ? EINA_TRUE : EINA_FALSE;
503

504
             g_ptr_array_add(array, ebo);
505
          }
506

507
        if (i == 500)
508
          {
509
             for (j = 0; j < array->len; ++j)
510
                free(g_ptr_array_index(array, j));
511
             g_ptr_array_remove_range(array, 0, array->len);
512
          }
513
        else if ((i % 30) == 0)
514
           for (j = 0; j < array->len; )
515
             {
516
                ebo = g_ptr_array_index(array, j);
517

518
                if (ebo->keep == EINA_FALSE)
519
                   free(g_ptr_array_remove_index_fast(array, j));
520
                else
521
                   j++;
522
             }
523

524
        for (j = 0; j < array->len; ++j)
525
          {
526
             ebo = g_ptr_array_index(array, j);
527

528
             ebo->keep = rand() < (RAND_MAX / 2) ? ebo->keep : EINA_FALSE;
529
          }
530
     }
531

532
   for (j = 0; j < array->len; ++j)
533
                   free(g_ptr_array_index(array, j));
534
                   g_ptr_array_free(array, TRUE);
535
}
536
#endif
537

538
static void
539
eina_bench_evas_list_4evas_render(int request)
540
{
541
   Evas_List *list = NULL;
542
   Evas_List *tmp;
543
   Eina_Bench_Object *ebo;
544
   int i;
545
   int j;
546

547
   for (i = 0; i < 1000; ++i)
548
     {
549
        for (j = 0; j < request; ++j)
550
          {
551
             ebo = malloc(sizeof (Eina_Bench_Object));
552
             if (!ebo)
553
                continue;
554

555
             ebo->keep = rand() < (RAND_MAX / 2) ? EINA_TRUE : EINA_FALSE;
556

557
             list = evas_list_prepend(list, ebo);
558
          }
559

560
        if (i == 500)
561
           while (list)
562
             {
563
                       free(evas_list_data(list));
564
                list = evas_list_remove_list(list, list);
565
             }
566
        else if ((i % 30) == 0)
567
          {
568
             tmp = list;
569
             while (tmp)
570
               {
571
                  Evas_List *reminder = tmp;
572

573
                  ebo = evas_list_data(reminder);
574
                  tmp = evas_list_next(tmp);
575

576
                  if (ebo->keep == EINA_FALSE)
577
                    {
578
                       list = evas_list_remove_list(list, reminder);
579
                       free(ebo);
580
                    }
581
               }
582
          }
583

584
        for (tmp = list; tmp; tmp = evas_list_next(tmp))
585
          {
586
             ebo = evas_list_data(tmp);
587

588
             ebo->keep = rand() < (RAND_MAX / 2) ? ebo->keep : EINA_FALSE;
589
          }
590
     }
591

592
   while (list)
593
     {
594
                       free(evas_list_data(list));
595
        list = evas_list_remove_list(list, list);
596
     }
597
}
598

599
static void
600
_eina_ecore_for_each_remove(void *value, void *user_data)
601
{
602
   Eina_Bench_Object *ebo = value;
603
   Ecore_List *list = user_data;
604

605
   if (ebo->keep == EINA_FALSE)
606
      ecore_list_remove_destroy(list);
607
}
608

609
static void
610
_eina_ecore_for_each_rand(void *value, EINA_UNUSED void *user_data)
611
{
612
   Eina_Bench_Object *ebo = value;
613

614
   ebo->keep = rand() < (RAND_MAX / 2) ? ebo->keep : EINA_FALSE;
615
}
616

617
static void
618
eina_bench_ecore_list_4evas_render(int request)
619
{
620
   Ecore_List *list = NULL;
621
   Eina_Bench_Object *ebo;
622
   int i;
623
   int j;
624

625
   list = ecore_list_new();
626
   ecore_list_free_cb_set(list, free);
627

628
   for (i = 0; i < 1000; ++i)
629
     {
630
        for (j = 0; j < request; ++j)
631
          {
632
             ebo = malloc(sizeof (Eina_Bench_Object));
633
             if (!ebo)
634
                continue;
635

636
             ebo->keep = rand() < (RAND_MAX / 2) ? EINA_TRUE : EINA_FALSE;
637

638
             ecore_list_prepend(list, ebo);
639
          }
640

641
        if (i == 500)
642
           ecore_list_clear(list);
643
        else if ((i % 30) == 0)
644
          {
645
             ecore_list_for_each(list, _eina_ecore_for_each_remove, list);
646
          }
647

648
        ecore_list_for_each(list, _eina_ecore_for_each_rand,   list);
649
     }
650

651
           ecore_list_destroy(list);
652
}
653

654
void eina_bench_array(Eina_Benchmark *bench)
655
{
656
   eina_benchmark_register(bench, "array-inline",
657
                           EINA_BENCHMARK(
658
                              eina_bench_array_4evas_render_inline),    200,
659
                           4000, 100);
660
   eina_benchmark_register(bench, "array-iterator",
661
                           EINA_BENCHMARK(
662
                              eina_bench_array_4evas_render_iterator),  200,
663
                           4000, 100);
664
   eina_benchmark_register(bench, "list",
665
                           EINA_BENCHMARK(
666
                              eina_bench_list_4evas_render),            200,
667
                           4000, 100);
668
   eina_benchmark_register(bench, "list-iterator",
669
                           EINA_BENCHMARK(
670
                              eina_bench_list_4evas_render_iterator),   200,
671
                           4000, 100);
672
   eina_benchmark_register(bench, "inlist",
673
                           EINA_BENCHMARK(
674
                              eina_bench_inlist_4evas_render),          200,
675
                           4000, 100);
676
   eina_benchmark_register(bench, "inlist-iterator",
677
                           EINA_BENCHMARK(
678
                              eina_bench_inlist_4evas_render_iterator), 200,
679
                           4000, 100);
680
#ifdef EINA_BENCH_HAVE_GLIB
681
   eina_benchmark_register(bench, "glist",
682
                           EINA_BENCHMARK(
683
                              eina_bench_glist_4evas_render),           200,
684
                           4000, 100);
685
   eina_benchmark_register(bench, "gptrarray",
686
                           EINA_BENCHMARK(
687
                              eina_bench_gptrarray_4evas_render),       200,
688
                           4000, 100);
689
#endif
690
   eina_benchmark_register(bench, "evas",
691
                           EINA_BENCHMARK(
692
                              eina_bench_evas_list_4evas_render),       200,
693
                           4000, 100);
694
   eina_benchmark_register(bench, "ecore",
695
                           EINA_BENCHMARK(
696
                              eina_bench_ecore_list_4evas_render),      200,
697
                           500, 100);
698
}
699

700