bench/tests/BenchQueue.c


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

#include <BH/Bench.h>
#include <BH/Queue.h>


#define NUM_ENTRIES 1000


static int values[NUM_ENTRIES];
static BH_Queue *queue;
static void *frontValue;
static void *iter;
static void *iterValue;


static void setupData()
{
    int i;
    queue = BH_QueueNew();
    for (i = 0; i < NUM_ENTRIES; ++i)
    {
        values[i] = i + 1;
        BH_QueueInsert(queue, &values[i]);
    }
}


BH_BENCH_TEST(NewFree)
{
    while (BH_BenchIter(state))
    {
        queue = BH_QueueNew();
        BH_BenchDoNotOptimize(queue);
        if (queue) BH_QueueFree(queue);
    }
}


BH_BENCH_TEST(ReserveInsert)
{
    BH_BenchSubcount(state, NUM_ENTRIES);
    while (BH_BenchIter(state))
    {
        int i;
        queue = BH_QueueNew();
        BH_QueueReserve(queue, NUM_ENTRIES);

        for (i = 0; i < NUM_ENTRIES; ++i)
        {
            values[i] = i + 1;
            BH_QueueInsert(queue, &values[i]);
        }

        BH_BenchDoNotOptimize(queue);
        BH_QueueFree(queue);
    }
}


BH_BENCH_TEST(FrontRemove)
{
    BH_BenchSubcount(state, NUM_ENTRIES);
    while (BH_BenchIter(state))
    {
        int i;
        queue = BH_QueueNew();
        for (i = 0; i < NUM_ENTRIES; ++i)
        {
            values[i] = i + 1;
            BH_QueueInsert(queue, &values[i]);
        }

        for (i = 0; i < NUM_ENTRIES; ++i)
        {
            if (BH_QueueFront(queue, &frontValue) == 0)
            {
                BH_QueueRemove(queue);
            }
        }

        BH_BenchDoNotOptimize(frontValue);
        BH_BenchDoNotOptimize(queue);
        BH_QueueFree(queue);
    }
}


BH_BENCH_TEST(Iterate)
{
    setupData();
    BH_BenchSubcount(state, NUM_ENTRIES);
    while (BH_BenchIter(state))
    {
        iter = NULL;
        iterValue = NULL;
        while ((iter = BH_QueueIterNext(queue, iter)) != NULL)
        {
            iterValue = BH_QueueIterValue(iter);
        }
        BH_BenchDoNotOptimize(iterValue);
    }

    BH_QueueFree(queue);
}


int main(int argc, char **argv)
{
    BH_UNUSED(argc);
    BH_UNUSED(argv);

    BH_BENCH_ADD(NewFree);
    BH_BENCH_ADD(ReserveInsert);
    BH_BENCH_ADD(FrontRemove);
    BH_BENCH_ADD(Iterate);

    return BH_BenchRun();
}