efl

1
#ifdef HAVE_CONFIG_H
2
# include "config.h"
3
#endif
4

5
#include <stdlib.h>
6
#include <stdio.h>
7
#include <string.h>
8
#include <time.h>
9

10
#ifdef EINA_BENCH_HAVE_GLIB
11
# include <glib.h>
12
#endif
13

14
#include <Eina.h>
15
#include "Evas_Data.h"
16
#include "Ecore_Data.h"
17

18
#include "eina_hash.h"
19
#include "eina_array.h"
20
#include "eina_bench.h"
21
#include "eina_rbtree.h"
22
#include "eina_convert.h"
23

24
#ifdef CITYHASH_BENCH
25
// Hash function for a byte array.
26
uint64_t CityHash64(const char *buf, size_t len);
27
#endif
28

29
int key_size;
30
char *key_str=NULL;
31

32
void repchar(int n)
33
{
34
   key_str = (char *)malloc(n);
35
   int i;
36

37
   for (i = 0; i < n; i++)
38
      key_str[i] = 'a';
39
}
40

41
static void
42
eina_bench_murmur_hash(int request)
43
{
44
   unsigned int i;
45

46
   for (i = 0; i < (unsigned int)request; ++i)
47
     {
48
        char tmp_key[key_size];
49

50
        eina_convert_itoa(i, tmp_key);
51
        eina_strlcat(tmp_key, key_str, key_size);
52

53
        eina_hash_murmur3(tmp_key, key_size);
54
     }
55
}
56

57
#ifdef CITYHASH_BENCH
58
static void
59
eina_bench_cityhash(int request)
60
{
61
   unsigned int i;
62

63
   for (i = 0; i < (unsigned int)request; ++i)
64
     {
65
        char tmp_key[key_size];
66

67
        eina_convert_itoa(i, tmp_key);
68
        eina_strlcat(tmp_key, key_str, key_size);
69

70
        CityHash64(tmp_key, key_size);
71
     }
72
}
73
#endif
74

75
static void
76
eina_bench_superfast_hash(int request)
77
{
78
   unsigned int i;
79

80
   for (i = 0; i < (unsigned int)request; ++i)
81
     {
82
        char tmp_key[key_size];
83

84
        eina_convert_itoa(i, tmp_key);
85
        eina_strlcat(tmp_key, key_str, key_size);
86

87
        eina_hash_superfast(tmp_key, key_size);
88
     }
89
}
90

91
static void
92
eina_bench_crchash(int request)
93
{
94
   unsigned int i;
95

96
   for (i = 0; i < (unsigned int)request; ++i)
97
     {
98
        char tmp_key[key_size];
99

100
        eina_convert_itoa(i, tmp_key);
101
        eina_strlcat(tmp_key, key_str, key_size);
102

103
        eina_hash_crc(tmp_key, key_size);
104
     }
105
}
106

107
static void
108
eina_bench_djb2_hash(int request)
109
{
110
   unsigned int i;
111

112
   for (i = 0; i < (unsigned int)request; ++i)
113
     {
114
        char tmp_key[key_size];
115

116
        eina_convert_itoa(i, tmp_key);
117
        eina_strlcat(tmp_key, key_str, key_size);
118

119
        eina_hash_djb2(tmp_key, key_size);
120
     }
121
}
122

123
#ifdef EINA_BENCH_HAVE_GLIB
124
static void
125
eina_bench_ghash(int request)
126
{
127
   unsigned int i;
128

129
   for (i = 0; i < (unsigned int)request; ++i)
130
     {
131
        char tmp_key[key_size];
132

133
        eina_convert_itoa(i, tmp_key);
134
        eina_strlcat(tmp_key, key_str, key_size);
135

136
        g_str_hash(key_str);
137
     }
138
}
139
#endif
140

141
int
142
evas_hash_gen(const char *key)
143
{
144
   unsigned int hash_num = 5381;
145
   const unsigned char *ptr;
146

147
   if (!key)
148
      return 0;
149

150
   for (ptr = (unsigned char *)key; *ptr; ptr++)
151
      hash_num = (hash_num * 33) ^ *ptr;
152

153
   hash_num &= 0xff;
154
   return (int)hash_num;
155
}
156

157
static void
158
eina_bench_evas_hash(int request)
159
{
160
   unsigned int i;
161

162
   for (i = 0; i < (unsigned int)request; ++i)
163
     {
164
        char tmp_key[key_size];
165

166
        eina_convert_itoa(i, tmp_key);
167
        eina_strlcat(tmp_key, key_str, key_size);
168

169
        evas_hash_gen(tmp_key);
170
     }
171
}
172

173
typedef struct _Eina_Bench_Ecore Eina_Bench_Ecore;
174
struct _Eina_Bench_Ecore
175
{
176
   char *key;
177
   int value;
178
};
179

180
void eina_bench_crc_hash_short(Eina_Benchmark *bench)
181
{
182
   key_size = 8; /* Length of string for small strings and pointers */
183
   key_size -= 5;
184
   repchar(key_size);
185

186
   eina_benchmark_register(bench, "superfast-lookup",
187
                           EINA_BENCHMARK(
188
                              eina_bench_superfast_hash),   10, 80000, 10);
189
   eina_benchmark_register(bench, "djb2-lookup",
190
                           EINA_BENCHMARK(
191
                             eina_bench_djb2_hash),        10, 80000, 10);
192
   eina_benchmark_register(bench, "murmur",
193
                           EINA_BENCHMARK(
194
                              eina_bench_murmur_hash),      10, 80000, 10);
195
   eina_benchmark_register(bench, "crchash",
196
                           EINA_BENCHMARK(
197
			      eina_bench_crchash),         10, 80000, 10);
198
#ifdef CITYHASH_BENCH
199
   eina_benchmark_register(bench, "cityhash",
200
                           EINA_BENCHMARK(
201
                              eina_bench_cityhash),    10, 80000, 10);
202
#endif
203

204
#ifdef EINA_BENCH_HAVE_GLIB
205
   eina_benchmark_register(bench, "ghash-lookup",
206
                           EINA_BENCHMARK(
207
                              eina_bench_ghash),       10, 80000, 10);
208
#endif
209
   eina_benchmark_register(bench, "evas-lookup",
210
                           EINA_BENCHMARK(
211
                              eina_bench_evas_hash),        10, 80000, 10);
212
}
213

214
void eina_bench_crc_hash_medium(Eina_Benchmark *bench)
215
{
216
   key_size = 32; /* Length of medium sized string, normally for filenames */
217
   key_size -= 5;
218
   repchar(key_size);
219

220
   eina_benchmark_register(bench, "superfast-lookup",
221
                           EINA_BENCHMARK(
222
                              eina_bench_superfast_hash),   10, 80000, 10);
223
   eina_benchmark_register(bench, "djb2-lookup",
224
                           EINA_BENCHMARK(
225
                             eina_bench_djb2_hash),        10, 80000, 10);
226
   eina_benchmark_register(bench, "murmur",
227
                           EINA_BENCHMARK(
228
                              eina_bench_murmur_hash),      10, 80000, 10);
229
   eina_benchmark_register(bench, "crchash",
230
                           EINA_BENCHMARK(
231
			      eina_bench_crchash),         10, 80000, 10);
232
#ifdef CITYHASH_BENCH
233
   eina_benchmark_register(bench, "cityhash",
234
                           EINA_BENCHMARK(
235
                              eina_bench_cityhash),    10, 80000, 10);
236
#endif
237

238
#ifdef EINA_BENCH_HAVE_GLIB
239
   eina_benchmark_register(bench, "ghash-lookup",
240
                           EINA_BENCHMARK(
241
                              eina_bench_ghash),       10, 80000, 10);
242
#endif
243
   eina_benchmark_register(bench, "evas-lookup",
244
                           EINA_BENCHMARK(
245
                              eina_bench_evas_hash),        10, 80000, 10);
246
}
247

248
void eina_bench_crc_hash_large(Eina_Benchmark *bench)
249
{
250
   key_size = 256; /* Length of large strings, normally for filepath */
251
   key_size -= 5;
252
   repchar(key_size);
253

254
   eina_benchmark_register(bench, "superfast-lookup",
255
                           EINA_BENCHMARK(
256
                              eina_bench_superfast_hash),   10, 80000, 10);
257
   eina_benchmark_register(bench, "djb2-lookup",
258
                           EINA_BENCHMARK(
259
                             eina_bench_djb2_hash),        10, 80000, 10);
260
   eina_benchmark_register(bench, "murmur",
261
                           EINA_BENCHMARK(
262
                              eina_bench_murmur_hash),      10, 80000, 10);
263
   eina_benchmark_register(bench, "crchash",
264
                           EINA_BENCHMARK(
265
			      eina_bench_crchash),         10, 80000, 10);
266
#ifdef CITYHASH_BENCH
267
   eina_benchmark_register(bench, "cityhash",
268
                           EINA_BENCHMARK(
269
                              eina_bench_cityhash),    10, 80000, 10);
270
#endif
271

272
#ifdef EINA_BENCH_HAVE_GLIB
273
   eina_benchmark_register(bench, "ghash-lookup",
274
                           EINA_BENCHMARK(
275
                              eina_bench_ghash),       10, 80000, 10);
276
#endif
277
   eina_benchmark_register(bench, "evas-lookup",
278
                           EINA_BENCHMARK(
279
                              eina_bench_evas_hash),        10, 80000, 10);
280
}
281