• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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
ht_improve_hash(unsigned h)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
ht_string_hash(const char * s)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 
485