OpenMPI  0.1.1
ht-internal.h
1 /* Based on work Copyright 2002 Christopher Clark */
2 /* Copyright 2005-2010 Nick Mathewson */
3 /* Copyright 2009-2010 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