OpenMPI
0.1.1
Main Page
Related Pages
Modules
Data Structures
Files
File List
Globals
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
opal
mca
event
libevent2013
libevent
ht-internal.h
Generated on Wed Dec 24 2014 12:05:28 for OpenMPI by
1.8.8