1 /* Based on work Copyright 2002 Christopher Clark */
2 /* Copyright 2005-2012 Nick Mathewson */
3 /* Copyright 2009-2012 Niels Provos and Nick Mathewson */
4 /* See license at end. */
5
6 /* Based on ideas by Christopher Clark and interfaces from Niels Provos. */
7
8 #ifndef _EVENT_HT_H
9 #define _EVENT_HT_H
10
11 #define HT_HEAD(name, type) \
12 struct name { \
13 /* The hash table itself. */ \
14 struct type **hth_table; \
15 /* How long is the hash table? */ \
16 unsigned hth_table_length; \
17 /* How many elements does the table contain? */ \
18 unsigned hth_n_entries; \
19 /* How many elements will we allow in the table before resizing it? */ \
20 unsigned hth_load_limit; \
21 /* Position of hth_table_length in the primes table. */ \
22 int hth_prime_idx; \
23 }
24
25 #define HT_INITIALIZER() \
26 { NULL, 0, 0, 0, -1 }
27
28 #ifdef HT_CACHE_HASH_VALUES
29 #define HT_ENTRY(type) \
30 struct { \
31 struct type *hte_next; \
32 unsigned hte_hash; \
33 }
34 #else
35 #define HT_ENTRY(type) \
36 struct { \
37 struct type *hte_next; \
38 }
39 #endif
40
41 #define HT_EMPTY(head) \
42 ((head)->hth_n_entries == 0)
43
44 /* How many elements in 'head'? */
45 #define HT_SIZE(head) \
46 ((head)->hth_n_entries)
47
48 #define HT_FIND(name, head, elm) name##_HT_FIND((head), (elm))
49 #define HT_INSERT(name, head, elm) name##_HT_INSERT((head), (elm))
50 #define HT_REPLACE(name, head, elm) name##_HT_REPLACE((head), (elm))
51 #define HT_REMOVE(name, head, elm) name##_HT_REMOVE((head), (elm))
52 #define HT_START(name, head) name##_HT_START(head)
53 #define HT_NEXT(name, head, elm) name##_HT_NEXT((head), (elm))
54 #define HT_NEXT_RMV(name, head, elm) name##_HT_NEXT_RMV((head), (elm))
55 #define HT_CLEAR(name, head) name##_HT_CLEAR(head)
56 #define HT_INIT(name, head) name##_HT_INIT(head)
57 /* Helper: */
58 static inline unsigned
59 ht_improve_hash(unsigned h)
60 {
61 /* Aim to protect against poor hash functions by adding logic here
62 * - logic taken from java 1.4 hashtable source */
63 h += ~(h << 9);
64 h ^= ((h >> 14) | (h << 18)); /* >>> */
65 h += (h << 4);
66 h ^= ((h >> 10) | (h << 22)); /* >>> */
67 return h;
68 }
69
70 #if 0
71 /** Basic string hash function, from Java standard String.hashCode(). */
72 static inline unsigned
73 ht_string_hash(const char *s)
74 {
75 unsigned h = 0;
76 int m = 1;
77 while (*s) {
78 h += ((signed char)*s++)*m;
79 m = (m<<5)-1; /* m *= 31 */
80 }
81 return h;
82 }
83 #endif
84
85 /** Basic string hash function, from Python's str.__hash__() */
86 static inline unsigned
87 ht_string_hash(const char *s)
88 {
89 unsigned h;
90 const unsigned char *cp = (const unsigned char *)s;
91 h = *cp << 7;
92 while (*cp) {
93 h = (1000003*h) ^ *cp++;
94 }
95 /* This conversion truncates the length of the string, but that's ok. */
96 h ^= (unsigned)(cp-(const unsigned char*)s);
97 return h;
98 }
99
100 #ifdef HT_CACHE_HASH_VALUES
101 #define _HT_SET_HASH(elm, field, hashfn) \
102 do { (elm)->field.hte_hash = hashfn(elm); } while (0)
103 #define _HT_SET_HASHVAL(elm, field, val) \
104 do { (elm)->field.hte_hash = (val); } while (0)
105 #define _HT_ELT_HASH(elm, field, hashfn) \
106 ((elm)->field.hte_hash)
107 #else
108 #define _HT_SET_HASH(elm, field, hashfn) \
109 ((void)0)
110 #define _HT_ELT_HASH(elm, field, hashfn) \
111 (hashfn(elm))
112 #define _HT_SET_HASHVAL(elm, field, val) \
113 ((void)0)
114 #endif
115
116 /* Helper: alias for the bucket containing 'elm'. */
117 #define _HT_BUCKET(head, field, elm, hashfn) \
118 ((head)->hth_table[_HT_ELT_HASH(elm,field,hashfn) % head->hth_table_length])
119
120 #define HT_FOREACH(x, name, head) \
121 for ((x) = HT_START(name, head); \
122 (x) != NULL; \
123 (x) = HT_NEXT(name, head, x))
124
125 #define HT_PROTOTYPE(name, type, field, hashfn, eqfn) \
126 int name##_HT_GROW(struct name *ht, unsigned min_capacity); \
127 void name##_HT_CLEAR(struct name *ht); \
128 int _##name##_HT_REP_IS_BAD(const struct name *ht); \
129 static inline void \
130 name##_HT_INIT(struct name *head) { \
131 head->hth_table_length = 0; \
132 head->hth_table = NULL; \
133 head->hth_n_entries = 0; \
134 head->hth_load_limit = 0; \
135 head->hth_prime_idx = -1; \
136 } \
137 /* Helper: returns a pointer to the right location in the table \
138 * 'head' to find or insert the element 'elm'. */ \
139 static inline struct type ** \
140 _##name##_HT_FIND_P(struct name *head, struct type *elm) \
141 { \
142 struct type **p; \
143 if (!head->hth_table) \
144 return NULL; \
145 p = &_HT_BUCKET(head, field, elm, hashfn); \
146 while (*p) { \
147 if (eqfn(*p, elm)) \
148 return p; \
149 p = &(*p)->field.hte_next; \
150 } \
151 return p; \
152 } \
153 /* Return a pointer to the element in the table 'head' matching 'elm', \
154 * or NULL if no such element exists */ \
155 static inline struct type * \
156 name##_HT_FIND(const struct name *head, struct type *elm) \
157 { \
158 struct type **p; \
159 struct name *h = (struct name *) head; \
160 _HT_SET_HASH(elm, field, hashfn); \
161 p = _##name##_HT_FIND_P(h, elm); \
162 return p ? *p : NULL; \
163 } \
164 /* Insert the element 'elm' into the table 'head'. Do not call this \
165 * function if the table might already contain a matching element. */ \
166 static inline void \
167 name##_HT_INSERT(struct name *head, struct type *elm) \
168 { \
169 struct type **p; \
170 if (!head->hth_table || head->hth_n_entries >= head->hth_load_limit) \
171 name##_HT_GROW(head, head->hth_n_entries+1); \
172 ++head->hth_n_entries; \
173 _HT_SET_HASH(elm, field, hashfn); \
174 p = &_HT_BUCKET(head, field, elm, hashfn); \
175 elm->field.hte_next = *p; \
176 *p = elm; \
177 } \
178 /* Insert the element 'elm' into the table 'head'. If there already \
179 * a matching element in the table, replace that element and return \
180 * it. */ \
181 static inline struct type * \
182 name##_HT_REPLACE(struct name *head, struct type *elm) \
183 { \
184 struct type **p, *r; \
185 if (!head->hth_table || head->hth_n_entries >= head->hth_load_limit) \
186 name##_HT_GROW(head, head->hth_n_entries+1); \
187 _HT_SET_HASH(elm, field, hashfn); \
188 p = _##name##_HT_FIND_P(head, elm); \
189 r = *p; \
190 *p = elm; \
191 if (r && (r!=elm)) { \
192 elm->field.hte_next = r->field.hte_next; \
193 r->field.hte_next = NULL; \
194 return r; \
195 } else { \
196 ++head->hth_n_entries; \
197 return NULL; \
198 } \
199 } \
200 /* Remove any element matching 'elm' from the table 'head'. If such \
201 * an element is found, return it; otherwise return NULL. */ \
202 static inline struct type * \
203 name##_HT_REMOVE(struct name *head, struct type *elm) \
204 { \
205 struct type **p, *r; \
206 _HT_SET_HASH(elm, field, hashfn); \
207 p = _##name##_HT_FIND_P(head,elm); \
208 if (!p || !*p) \
209 return NULL; \
210 r = *p; \
211 *p = r->field.hte_next; \
212 r->field.hte_next = NULL; \
213 --head->hth_n_entries; \
214 return r; \
215 } \
216 /* Invoke the function 'fn' on every element of the table 'head', \
217 * using 'data' as its second argument. If the function returns \
218 * nonzero, remove the most recently examined element before invoking \
219 * the function again. */ \
220 static inline void \
221 name##_HT_FOREACH_FN(struct name *head, \
222 int (*fn)(struct type *, void *), \
223 void *data) \
224 { \
225 unsigned idx; \
226 struct type **p, **nextp, *next; \
227 if (!head->hth_table) \
228 return; \
229 for (idx=0; idx < head->hth_table_length; ++idx) { \
230 p = &head->hth_table[idx]; \
231 while (*p) { \
232 nextp = &(*p)->field.hte_next; \
233 next = *nextp; \
234 if (fn(*p, data)) { \
235 --head->hth_n_entries; \
236 *p = next; \
237 } else { \
238 p = nextp; \
239 } \
240 } \
241 } \
242 } \
243 /* Return a pointer to the first element in the table 'head', under \
244 * an arbitrary order. This order is stable under remove operations, \
245 * but not under others. If the table is empty, return NULL. */ \
246 static inline struct type ** \
247 name##_HT_START(struct name *head) \
248 { \
249 unsigned b = 0; \
250 while (b < head->hth_table_length) { \
251 if (head->hth_table[b]) \
252 return &head->hth_table[b]; \
253 ++b; \
254 } \
255 return NULL; \
256 } \
257 /* Return the next element in 'head' after 'elm', under the arbitrary \
258 * order used by HT_START. If there are no more elements, return \
259 * NULL. If 'elm' is to be removed from the table, you must call \
260 * this function for the next value before you remove it. \
261 */ \
262 static inline struct type ** \
263 name##_HT_NEXT(struct name *head, struct type **elm) \
264 { \
265 if ((*elm)->field.hte_next) { \
266 return &(*elm)->field.hte_next; \
267 } else { \
268 unsigned b = (_HT_ELT_HASH(*elm, field, hashfn) % head->hth_table_length)+1; \
269 while (b < head->hth_table_length) { \
270 if (head->hth_table[b]) \
271 return &head->hth_table[b]; \
272 ++b; \
273 } \
274 return NULL; \
275 } \
276 } \
277 static inline struct type ** \
278 name##_HT_NEXT_RMV(struct name *head, struct type **elm) \
279 { \
280 unsigned h = _HT_ELT_HASH(*elm, field, hashfn); \
281 *elm = (*elm)->field.hte_next; \
282 --head->hth_n_entries; \
283 if (*elm) { \
284 return elm; \
285 } else { \
286 unsigned b = (h % head->hth_table_length)+1; \
287 while (b < head->hth_table_length) { \
288 if (head->hth_table[b]) \
289 return &head->hth_table[b]; \
290 ++b; \
291 } \
292 return NULL; \
293 } \
294 }
295
296 #define HT_GENERATE(name, type, field, hashfn, eqfn, load, mallocfn, \
297 reallocfn, freefn) \
298 static unsigned name##_PRIMES[] = { \
299 53, 97, 193, 389, \
300 769, 1543, 3079, 6151, \
301 12289, 24593, 49157, 98317, \
302 196613, 393241, 786433, 1572869, \
303 3145739, 6291469, 12582917, 25165843, \
304 50331653, 100663319, 201326611, 402653189, \
305 805306457, 1610612741 \
306 }; \
307 static unsigned name##_N_PRIMES = \
308 (unsigned)(sizeof(name##_PRIMES)/sizeof(name##_PRIMES[0])); \
309 /* Expand the internal table of 'head' until it is large enough to \
310 * hold 'size' elements. Return 0 on success, -1 on allocation \
311 * failure. */ \
312 int \
313 name##_HT_GROW(struct name *head, unsigned size) \
314 { \
315 unsigned new_len, new_load_limit; \
316 int prime_idx; \
317 struct type **new_table; \
318 if (head->hth_prime_idx == (int)name##_N_PRIMES - 1) \
319 return 0; \
320 if (head->hth_load_limit > size) \
321 return 0; \
322 prime_idx = head->hth_prime_idx; \
323 do { \
324 new_len = name##_PRIMES[++prime_idx]; \
325 new_load_limit = (unsigned)(load*new_len); \
326 } while (new_load_limit <= size && \
327 prime_idx < (int)name##_N_PRIMES); \
328 if ((new_table = mallocfn(new_len*sizeof(struct type*)))) { \
329 unsigned b; \
330 memset(new_table, 0, new_len*sizeof(struct type*)); \
331 for (b = 0; b < head->hth_table_length; ++b) { \
332 struct type *elm, *next; \
333 unsigned b2; \
334 elm = head->hth_table[b]; \
335 while (elm) { \
336 next = elm->field.hte_next; \
337 b2 = _HT_ELT_HASH(elm, field, hashfn) % new_len; \
338 elm->field.hte_next = new_table[b2]; \
339 new_table[b2] = elm; \
340 elm = next; \
341 } \
342 } \
343 if (head->hth_table) \
344 freefn(head->hth_table); \
345 head->hth_table = new_table; \
346 } else { \
347 unsigned b, b2; \
348 new_table = reallocfn(head->hth_table, new_len*sizeof(struct type*)); \
349 if (!new_table) return -1; \
350 memset(new_table + head->hth_table_length, 0, \
351 (new_len - head->hth_table_length)*sizeof(struct type*)); \
352 for (b=0; b < head->hth_table_length; ++b) { \
353 struct type *e, **pE; \
354 for (pE = &new_table[b], e = *pE; e != NULL; e = *pE) { \
355 b2 = _HT_ELT_HASH(e, field, hashfn) % new_len; \
356 if (b2 == b) { \
357 pE = &e->field.hte_next; \
358 } else { \
359 *pE = e->field.hte_next; \
360 e->field.hte_next = new_table[b2]; \
361 new_table[b2] = e; \
362 } \
363 } \
364 } \
365 head->hth_table = new_table; \
366 } \
367 head->hth_table_length = new_len; \
368 head->hth_prime_idx = prime_idx; \
369 head->hth_load_limit = new_load_limit; \
370 return 0; \
371 } \
372 /* Free all storage held by 'head'. Does not free 'head' itself, or \
373 * individual elements. */ \
374 void \
375 name##_HT_CLEAR(struct name *head) \
376 { \
377 if (head->hth_table) \
378 freefn(head->hth_table); \
379 head->hth_table_length = 0; \
380 name##_HT_INIT(head); \
381 } \
382 /* Debugging helper: return false iff the representation of 'head' is \
383 * internally consistent. */ \
384 int \
385 _##name##_HT_REP_IS_BAD(const struct name *head) \
386 { \
387 unsigned n, i; \
388 struct type *elm; \
389 if (!head->hth_table_length) { \
390 if (!head->hth_table && !head->hth_n_entries && \
391 !head->hth_load_limit && head->hth_prime_idx == -1) \
392 return 0; \
393 else \
394 return 1; \
395 } \
396 if (!head->hth_table || head->hth_prime_idx < 0 || \
397 !head->hth_load_limit) \
398 return 2; \
399 if (head->hth_n_entries > head->hth_load_limit) \
400 return 3; \
401 if (head->hth_table_length != name##_PRIMES[head->hth_prime_idx]) \
402 return 4; \
403 if (head->hth_load_limit != (unsigned)(load*head->hth_table_length)) \
404 return 5; \
405 for (n = i = 0; i < head->hth_table_length; ++i) { \
406 for (elm = head->hth_table[i]; elm; elm = elm->field.hte_next) { \
407 if (_HT_ELT_HASH(elm, field, hashfn) != hashfn(elm)) \
408 return 1000 + i; \
409 if ((_HT_ELT_HASH(elm, field, hashfn) % head->hth_table_length) != i) \
410 return 10000 + i; \
411 ++n; \
412 } \
413 } \
414 if (n != head->hth_n_entries) \
415 return 6; \
416 return 0; \
417 }
418
419 /** Implements an over-optimized "find and insert if absent" block;
420 * not meant for direct usage by typical code, or usage outside the critical
421 * path.*/
422 #define _HT_FIND_OR_INSERT(name, field, hashfn, head, eltype, elm, var, y, n) \
423 { \
424 struct name *_##var##_head = head; \
425 struct eltype **var; \
426 if (!_##var##_head->hth_table || \
427 _##var##_head->hth_n_entries >= _##var##_head->hth_load_limit) \
428 name##_HT_GROW(_##var##_head, _##var##_head->hth_n_entries+1); \
429 _HT_SET_HASH((elm), field, hashfn); \
430 var = _##name##_HT_FIND_P(_##var##_head, (elm)); \
431 if (*var) { \
432 y; \
433 } else { \
434 n; \
435 } \
436 }
437 #define _HT_FOI_INSERT(field, head, elm, newent, var) \
438 { \
439 _HT_SET_HASHVAL(newent, field, (elm)->field.hte_hash); \
440 newent->field.hte_next = NULL; \
441 *var = newent; \
442 ++((head)->hth_n_entries); \
443 }
444
445 /*
446 * Copyright 2005, Nick Mathewson. Implementation logic is adapted from code
447 * by Cristopher Clark, retrofit to allow drop-in memory management, and to
448 * use the same interface as Niels Provos's tree.h. This is probably still
449 * a derived work, so the original license below still applies.
450 *
451 * Copyright (c) 2002, Christopher Clark
452 * All rights reserved.
453 *
454 * Redistribution and use in source and binary forms, with or without
455 * modification, are permitted provided that the following conditions
456 * are met:
457 *
458 * * Redistributions of source code must retain the above copyright
459 * notice, this list of conditions and the following disclaimer.
460 *
461 * * Redistributions in binary form must reproduce the above copyright
462 * notice, this list of conditions and the following disclaimer in the
463 * documentation and/or other materials provided with the distribution.
464 *
465 * * Neither the name of the original author; nor the names of any contributors
466 * may be used to endorse or promote products derived from this software
467 * without specific prior written permission.
468 *
469 *
470 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
471 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
472 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
473 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
474 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
475 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
476 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
477 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
478 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
479 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
480 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
481 */
482
483 #endif
484