1 |
/* An expandable hash tables datatype. |
/* An expandable hash tables datatype. |
2 |
Copyright (C) 1999, 2000, 2001, 2002 Free Software Foundation, Inc. |
Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004 |
3 |
|
Free Software Foundation, Inc. |
4 |
Contributed by Vladimir Makarov (vmakarov@cygnus.com). |
Contributed by Vladimir Makarov (vmakarov@cygnus.com). |
5 |
|
|
6 |
This file is part of the libiberty library. |
This file is part of the libiberty library. |
41 |
#ifdef HAVE_STDLIB_H |
#ifdef HAVE_STDLIB_H |
42 |
#include <stdlib.h> |
#include <stdlib.h> |
43 |
#endif |
#endif |
|
|
|
44 |
#ifdef HAVE_STRING_H |
#ifdef HAVE_STRING_H |
45 |
#include <string.h> |
#include <string.h> |
46 |
#endif |
#endif |
47 |
|
#ifdef HAVE_MALLOC_H |
48 |
|
#include <malloc.h> |
49 |
|
#endif |
50 |
|
#ifdef HAVE_LIMITS_H |
51 |
|
#include <limits.h> |
52 |
|
#endif |
53 |
|
#ifdef HAVE_STDINT_H |
54 |
|
#include <stdint.h> |
55 |
|
#endif |
56 |
|
|
57 |
#include <stdio.h> |
#include <stdio.h> |
58 |
|
|
59 |
#include "libiberty.h" |
#include "libiberty.h" |
60 |
|
#include "ansidecl.h" |
61 |
#include "hashtab.h" |
#include "hashtab.h" |
62 |
|
|
63 |
|
#ifndef CHAR_BIT |
64 |
|
#define CHAR_BIT 8 |
65 |
|
#endif |
66 |
|
|
67 |
/* This macro defines reserved value for empty table entry. */ |
/* This macro defines reserved value for empty table entry. */ |
68 |
|
|
69 |
#define EMPTY_ENTRY ((PTR) 0) |
#define EMPTY_ENTRY ((PTR) 0) |
73 |
|
|
74 |
#define DELETED_ENTRY ((PTR) 1) |
#define DELETED_ENTRY ((PTR) 1) |
75 |
|
|
76 |
static unsigned long higher_prime_number PARAMS ((unsigned long)); |
static unsigned int higher_prime_index PARAMS ((unsigned long)); |
77 |
|
static hashval_t htab_mod_1 PARAMS ((hashval_t, hashval_t, hashval_t, int)); |
78 |
|
static hashval_t htab_mod PARAMS ((hashval_t, htab_t)); |
79 |
|
static hashval_t htab_mod_m2 PARAMS ((hashval_t, htab_t)); |
80 |
static hashval_t hash_pointer PARAMS ((const void *)); |
static hashval_t hash_pointer PARAMS ((const void *)); |
81 |
static int eq_pointer PARAMS ((const void *, const void *)); |
static int eq_pointer PARAMS ((const void *, const void *)); |
82 |
static int htab_expand PARAMS ((htab_t)); |
static int htab_expand PARAMS ((htab_t)); |
88 |
htab_hash htab_hash_pointer = hash_pointer; |
htab_hash htab_hash_pointer = hash_pointer; |
89 |
htab_eq htab_eq_pointer = eq_pointer; |
htab_eq htab_eq_pointer = eq_pointer; |
90 |
|
|
91 |
/* The following function returns a nearest prime number which is |
/* Table of primes and multiplicative inverses. |
|
greater than N, and near a power of two. */ |
|
92 |
|
|
93 |
static unsigned long |
Note that these are not minimally reduced inverses. Unlike when generating |
94 |
higher_prime_number (n) |
code to divide by a constant, we want to be able to use the same algorithm |
95 |
unsigned long n; |
all the time. All of these inverses (are implied to) have bit 32 set. |
96 |
|
|
97 |
|
For the record, here's the function that computed the table; it's a |
98 |
|
vastly simplified version of the function of the same name from gcc. */ |
99 |
|
|
100 |
|
#if 0 |
101 |
|
unsigned int |
102 |
|
ceil_log2 (unsigned int x) |
103 |
{ |
{ |
104 |
/* These are primes that are near, but slightly smaller than, a |
int i; |
105 |
power of two. */ |
for (i = 31; i >= 0 ; --i) |
106 |
static const unsigned long primes[] = { |
if (x > (1u << i)) |
107 |
(unsigned long) 7, |
return i+1; |
108 |
(unsigned long) 13, |
abort (); |
109 |
(unsigned long) 31, |
} |
110 |
(unsigned long) 61, |
|
111 |
(unsigned long) 127, |
unsigned int |
112 |
(unsigned long) 251, |
choose_multiplier (unsigned int d, unsigned int *mlp, unsigned char *shiftp) |
113 |
(unsigned long) 509, |
{ |
114 |
(unsigned long) 1021, |
unsigned long long mhigh; |
115 |
(unsigned long) 2039, |
double nx; |
116 |
(unsigned long) 4093, |
int lgup, post_shift; |
117 |
(unsigned long) 8191, |
int pow, pow2; |
118 |
(unsigned long) 16381, |
int n = 32, precision = 32; |
119 |
(unsigned long) 32749, |
|
120 |
(unsigned long) 65521, |
lgup = ceil_log2 (d); |
121 |
(unsigned long) 131071, |
pow = n + lgup; |
122 |
(unsigned long) 262139, |
pow2 = n + lgup - precision; |
123 |
(unsigned long) 524287, |
|
124 |
(unsigned long) 1048573, |
nx = ldexp (1.0, pow) + ldexp (1.0, pow2); |
125 |
(unsigned long) 2097143, |
mhigh = nx / d; |
126 |
(unsigned long) 4194301, |
|
127 |
(unsigned long) 8388593, |
*shiftp = lgup - 1; |
128 |
(unsigned long) 16777213, |
*mlp = mhigh; |
129 |
(unsigned long) 33554393, |
return mhigh >> 32; |
130 |
(unsigned long) 67108859, |
} |
131 |
(unsigned long) 134217689, |
#endif |
132 |
(unsigned long) 268435399, |
|
133 |
(unsigned long) 536870909, |
struct prime_ent |
134 |
(unsigned long) 1073741789, |
{ |
135 |
(unsigned long) 2147483647, |
hashval_t prime; |
136 |
/* 4294967291L */ |
hashval_t inv; |
137 |
((unsigned long) 2147483647) + ((unsigned long) 2147483644), |
hashval_t inv_m2; /* inverse of prime-2 */ |
138 |
}; |
hashval_t shift; |
139 |
|
}; |
140 |
|
|
141 |
|
static struct prime_ent const prime_tab[] = { |
142 |
|
{ 7, 0x24924925, 0x9999999b, 2 }, |
143 |
|
{ 13, 0x3b13b13c, 0x745d1747, 3 }, |
144 |
|
{ 31, 0x08421085, 0x1a7b9612, 4 }, |
145 |
|
{ 61, 0x0c9714fc, 0x15b1e5f8, 5 }, |
146 |
|
{ 127, 0x02040811, 0x0624dd30, 6 }, |
147 |
|
{ 251, 0x05197f7e, 0x073260a5, 7 }, |
148 |
|
{ 509, 0x01824366, 0x02864fc8, 8 }, |
149 |
|
{ 1021, 0x00c0906d, 0x014191f7, 9 }, |
150 |
|
{ 2039, 0x0121456f, 0x0161e69e, 10 }, |
151 |
|
{ 4093, 0x00300902, 0x00501908, 11 }, |
152 |
|
{ 8191, 0x00080041, 0x00180241, 12 }, |
153 |
|
{ 16381, 0x000c0091, 0x00140191, 13 }, |
154 |
|
{ 32749, 0x002605a5, 0x002a06e6, 14 }, |
155 |
|
{ 65521, 0x000f00e2, 0x00110122, 15 }, |
156 |
|
{ 131071, 0x00008001, 0x00018003, 16 }, |
157 |
|
{ 262139, 0x00014002, 0x0001c004, 17 }, |
158 |
|
{ 524287, 0x00002001, 0x00006001, 18 }, |
159 |
|
{ 1048573, 0x00003001, 0x00005001, 19 }, |
160 |
|
{ 2097143, 0x00004801, 0x00005801, 20 }, |
161 |
|
{ 4194301, 0x00000c01, 0x00001401, 21 }, |
162 |
|
{ 8388593, 0x00001e01, 0x00002201, 22 }, |
163 |
|
{ 16777213, 0x00000301, 0x00000501, 23 }, |
164 |
|
{ 33554393, 0x00001381, 0x00001481, 24 }, |
165 |
|
{ 67108859, 0x00000141, 0x000001c1, 25 }, |
166 |
|
{ 134217689, 0x000004e1, 0x00000521, 26 }, |
167 |
|
{ 268435399, 0x00000391, 0x000003b1, 27 }, |
168 |
|
{ 536870909, 0x00000019, 0x00000029, 28 }, |
169 |
|
{ 1073741789, 0x0000008d, 0x00000095, 29 }, |
170 |
|
{ 2147483647, 0x00000003, 0x00000007, 30 }, |
171 |
|
/* Avoid "decimal constant so large it is unsigned" for 4294967291. */ |
172 |
|
{ 0xfffffffb, 0x00000006, 0x00000008, 31 } |
173 |
|
}; |
174 |
|
|
175 |
|
/* The following function returns an index into the above table of the |
176 |
|
nearest prime number which is greater than N, and near a power of two. */ |
177 |
|
|
178 |
const unsigned long *low = &primes[0]; |
static unsigned int |
179 |
const unsigned long *high = &primes[sizeof(primes) / sizeof(primes[0])]; |
higher_prime_index (n) |
180 |
|
unsigned long n; |
181 |
|
{ |
182 |
|
unsigned int low = 0; |
183 |
|
unsigned int high = sizeof(prime_tab) / sizeof(prime_tab[0]); |
184 |
|
|
185 |
while (low != high) |
while (low != high) |
186 |
{ |
{ |
187 |
const unsigned long *mid = low + (high - low) / 2; |
unsigned int mid = low + (high - low) / 2; |
188 |
if (n > *mid) |
if (n > prime_tab[mid].prime) |
189 |
low = mid + 1; |
low = mid + 1; |
190 |
else |
else |
191 |
high = mid; |
high = mid; |
192 |
} |
} |
193 |
|
|
194 |
/* If we've run out of primes, abort. */ |
/* If we've run out of primes, abort. */ |
195 |
if (n > *low) |
if (n > prime_tab[low].prime) |
196 |
{ |
{ |
197 |
fprintf (stderr, "Cannot find prime bigger than %lu\n", n); |
fprintf (stderr, "Cannot find prime bigger than %lu\n", n); |
198 |
abort (); |
abort (); |
199 |
} |
} |
200 |
|
|
201 |
return *low; |
return low; |
202 |
} |
} |
203 |
|
|
204 |
/* Returns a hash code for P. */ |
/* Returns a hash code for P. */ |
220 |
return p1 == p2; |
return p1 == p2; |
221 |
} |
} |
222 |
|
|
223 |
|
/* Return the current size of given hash table. */ |
224 |
|
|
225 |
|
inline size_t |
226 |
|
htab_size (htab) |
227 |
|
htab_t htab; |
228 |
|
{ |
229 |
|
return htab->size; |
230 |
|
} |
231 |
|
|
232 |
|
/* Return the current number of elements in given hash table. */ |
233 |
|
|
234 |
|
inline size_t |
235 |
|
htab_elements (htab) |
236 |
|
htab_t htab; |
237 |
|
{ |
238 |
|
return htab->n_elements - htab->n_deleted; |
239 |
|
} |
240 |
|
|
241 |
|
/* Return X % Y. */ |
242 |
|
|
243 |
|
static inline hashval_t |
244 |
|
htab_mod_1 (x, y, inv, shift) |
245 |
|
hashval_t x, y, inv; |
246 |
|
int shift; |
247 |
|
{ |
248 |
|
/* The multiplicative inverses computed above are for 32-bit types, and |
249 |
|
requires that we be able to compute a highpart multiply. */ |
250 |
|
#ifdef UNSIGNED_64BIT_TYPE |
251 |
|
__extension__ typedef UNSIGNED_64BIT_TYPE ull; |
252 |
|
if (sizeof (hashval_t) * CHAR_BIT <= 32) |
253 |
|
{ |
254 |
|
hashval_t t1, t2, t3, t4, q, r; |
255 |
|
|
256 |
|
t1 = ((ull)x * inv) >> 32; |
257 |
|
t2 = x - t1; |
258 |
|
t3 = t2 >> 1; |
259 |
|
t4 = t1 + t3; |
260 |
|
q = t4 >> shift; |
261 |
|
r = x - (q * y); |
262 |
|
|
263 |
|
return r; |
264 |
|
} |
265 |
|
#endif |
266 |
|
|
267 |
|
/* Otherwise just use the native division routines. */ |
268 |
|
return x % y; |
269 |
|
} |
270 |
|
|
271 |
|
/* Compute the primary hash for HASH given HTAB's current size. */ |
272 |
|
|
273 |
|
static inline hashval_t |
274 |
|
htab_mod (hash, htab) |
275 |
|
hashval_t hash; |
276 |
|
htab_t htab; |
277 |
|
{ |
278 |
|
const struct prime_ent *p = &prime_tab[htab->size_prime_index]; |
279 |
|
return htab_mod_1 (hash, p->prime, p->inv, p->shift); |
280 |
|
} |
281 |
|
|
282 |
|
/* Compute the secondary hash for HASH given HTAB's current size. */ |
283 |
|
|
284 |
|
static inline hashval_t |
285 |
|
htab_mod_m2 (hash, htab) |
286 |
|
hashval_t hash; |
287 |
|
htab_t htab; |
288 |
|
{ |
289 |
|
const struct prime_ent *p = &prime_tab[htab->size_prime_index]; |
290 |
|
return 1 + htab_mod_1 (hash, p->prime - 2, p->inv_m2, p->shift); |
291 |
|
} |
292 |
|
|
293 |
/* This function creates table with length slightly longer than given |
/* This function creates table with length slightly longer than given |
294 |
source length. Created hash table is initiated as empty (all the |
source length. Created hash table is initiated as empty (all the |
295 |
hash table entries are EMPTY_ENTRY). The function returns the |
hash table entries are EMPTY_ENTRY). The function returns the |
305 |
htab_free free_f; |
htab_free free_f; |
306 |
{ |
{ |
307 |
htab_t result; |
htab_t result; |
308 |
|
unsigned int size_prime_index; |
309 |
|
|
310 |
|
size_prime_index = higher_prime_index (size); |
311 |
|
size = prime_tab[size_prime_index].prime; |
312 |
|
|
|
size = higher_prime_number (size); |
|
313 |
result = (htab_t) (*alloc_f) (1, sizeof (struct htab)); |
result = (htab_t) (*alloc_f) (1, sizeof (struct htab)); |
314 |
if (result == NULL) |
if (result == NULL) |
315 |
return NULL; |
return NULL; |
321 |
return NULL; |
return NULL; |
322 |
} |
} |
323 |
result->size = size; |
result->size = size; |
324 |
|
result->size_prime_index = size_prime_index; |
325 |
result->hash_f = hash_f; |
result->hash_f = hash_f; |
326 |
result->eq_f = eq_f; |
result->eq_f = eq_f; |
327 |
result->del_f = del_f; |
result->del_f = del_f; |
330 |
return result; |
return result; |
331 |
} |
} |
332 |
|
|
333 |
|
/* As above, but use the variants of alloc_f and free_f which accept |
334 |
|
an extra argument. */ |
335 |
|
|
336 |
|
htab_t |
337 |
|
htab_create_alloc_ex (size, hash_f, eq_f, del_f, alloc_arg, alloc_f, |
338 |
|
free_f) |
339 |
|
size_t size; |
340 |
|
htab_hash hash_f; |
341 |
|
htab_eq eq_f; |
342 |
|
htab_del del_f; |
343 |
|
PTR alloc_arg; |
344 |
|
htab_alloc_with_arg alloc_f; |
345 |
|
htab_free_with_arg free_f; |
346 |
|
{ |
347 |
|
htab_t result; |
348 |
|
unsigned int size_prime_index; |
349 |
|
|
350 |
|
size_prime_index = higher_prime_index (size); |
351 |
|
size = prime_tab[size_prime_index].prime; |
352 |
|
|
353 |
|
result = (htab_t) (*alloc_f) (alloc_arg, 1, sizeof (struct htab)); |
354 |
|
if (result == NULL) |
355 |
|
return NULL; |
356 |
|
result->entries = (PTR *) (*alloc_f) (alloc_arg, size, sizeof (PTR)); |
357 |
|
if (result->entries == NULL) |
358 |
|
{ |
359 |
|
if (free_f != NULL) |
360 |
|
(*free_f) (alloc_arg, result); |
361 |
|
return NULL; |
362 |
|
} |
363 |
|
result->size = size; |
364 |
|
result->size_prime_index = size_prime_index; |
365 |
|
result->hash_f = hash_f; |
366 |
|
result->eq_f = eq_f; |
367 |
|
result->del_f = del_f; |
368 |
|
result->alloc_arg = alloc_arg; |
369 |
|
result->alloc_with_arg_f = alloc_f; |
370 |
|
result->free_with_arg_f = free_f; |
371 |
|
return result; |
372 |
|
} |
373 |
|
|
374 |
|
/* Update the function pointers and allocation parameter in the htab_t. */ |
375 |
|
|
376 |
|
void |
377 |
|
htab_set_functions_ex (htab, hash_f, eq_f, del_f, alloc_arg, alloc_f, free_f) |
378 |
|
htab_t htab; |
379 |
|
htab_hash hash_f; |
380 |
|
htab_eq eq_f; |
381 |
|
htab_del del_f; |
382 |
|
PTR alloc_arg; |
383 |
|
htab_alloc_with_arg alloc_f; |
384 |
|
htab_free_with_arg free_f; |
385 |
|
{ |
386 |
|
htab->hash_f = hash_f; |
387 |
|
htab->eq_f = eq_f; |
388 |
|
htab->del_f = del_f; |
389 |
|
htab->alloc_arg = alloc_arg; |
390 |
|
htab->alloc_with_arg_f = alloc_f; |
391 |
|
htab->free_with_arg_f = free_f; |
392 |
|
} |
393 |
|
|
394 |
/* These functions exist solely for backward compatibility. */ |
/* These functions exist solely for backward compatibility. */ |
395 |
|
|
396 |
#undef htab_create |
#undef htab_create |
421 |
htab_delete (htab) |
htab_delete (htab) |
422 |
htab_t htab; |
htab_t htab; |
423 |
{ |
{ |
424 |
|
size_t size = htab_size (htab); |
425 |
|
PTR *entries = htab->entries; |
426 |
int i; |
int i; |
427 |
|
|
428 |
if (htab->del_f) |
if (htab->del_f) |
429 |
for (i = htab->size - 1; i >= 0; i--) |
for (i = size - 1; i >= 0; i--) |
430 |
if (htab->entries[i] != EMPTY_ENTRY |
if (entries[i] != EMPTY_ENTRY && entries[i] != DELETED_ENTRY) |
431 |
&& htab->entries[i] != DELETED_ENTRY) |
(*htab->del_f) (entries[i]); |
|
(*htab->del_f) (htab->entries[i]); |
|
432 |
|
|
433 |
if (htab->free_f != NULL) |
if (htab->free_f != NULL) |
434 |
{ |
{ |
435 |
(*htab->free_f) (htab->entries); |
(*htab->free_f) (entries); |
436 |
(*htab->free_f) (htab); |
(*htab->free_f) (htab); |
437 |
} |
} |
438 |
|
else if (htab->free_with_arg_f != NULL) |
439 |
|
{ |
440 |
|
(*htab->free_with_arg_f) (htab->alloc_arg, entries); |
441 |
|
(*htab->free_with_arg_f) (htab->alloc_arg, htab); |
442 |
|
} |
443 |
} |
} |
444 |
|
|
445 |
/* This function clears all entries in the given hash table. */ |
/* This function clears all entries in the given hash table. */ |
448 |
htab_empty (htab) |
htab_empty (htab) |
449 |
htab_t htab; |
htab_t htab; |
450 |
{ |
{ |
451 |
|
size_t size = htab_size (htab); |
452 |
|
PTR *entries = htab->entries; |
453 |
int i; |
int i; |
454 |
|
|
455 |
if (htab->del_f) |
if (htab->del_f) |
456 |
for (i = htab->size - 1; i >= 0; i--) |
for (i = size - 1; i >= 0; i--) |
457 |
if (htab->entries[i] != EMPTY_ENTRY |
if (entries[i] != EMPTY_ENTRY && entries[i] != DELETED_ENTRY) |
458 |
&& htab->entries[i] != DELETED_ENTRY) |
(*htab->del_f) (entries[i]); |
|
(*htab->del_f) (htab->entries[i]); |
|
459 |
|
|
460 |
memset (htab->entries, 0, htab->size * sizeof (PTR)); |
memset (entries, 0, size * sizeof (PTR)); |
461 |
} |
} |
462 |
|
|
463 |
/* Similar to htab_find_slot, but without several unwanted side effects: |
/* Similar to htab_find_slot, but without several unwanted side effects: |
472 |
htab_t htab; |
htab_t htab; |
473 |
hashval_t hash; |
hashval_t hash; |
474 |
{ |
{ |
475 |
size_t size = htab->size; |
hashval_t index = htab_mod (hash, htab); |
476 |
unsigned int index = hash % size; |
size_t size = htab_size (htab); |
477 |
PTR *slot = htab->entries + index; |
PTR *slot = htab->entries + index; |
478 |
hashval_t hash2; |
hashval_t hash2; |
479 |
|
|
482 |
else if (*slot == DELETED_ENTRY) |
else if (*slot == DELETED_ENTRY) |
483 |
abort (); |
abort (); |
484 |
|
|
485 |
hash2 = 1 + hash % (size - 2); |
hash2 = htab_mod_m2 (hash, htab); |
486 |
for (;;) |
for (;;) |
487 |
{ |
{ |
488 |
index += hash2; |
index += hash2; |
513 |
PTR *olimit; |
PTR *olimit; |
514 |
PTR *p; |
PTR *p; |
515 |
PTR *nentries; |
PTR *nentries; |
516 |
|
size_t nsize, osize, elts; |
517 |
|
unsigned int oindex, nindex; |
518 |
|
|
519 |
oentries = htab->entries; |
oentries = htab->entries; |
520 |
olimit = oentries + htab->size; |
oindex = htab->size_prime_index; |
521 |
|
osize = htab->size; |
522 |
htab->size = higher_prime_number (htab->size * 2); |
olimit = oentries + osize; |
523 |
|
elts = htab_elements (htab); |
524 |
|
|
525 |
|
/* Resize only when table after removal of unused elements is either |
526 |
|
too full or too empty. */ |
527 |
|
if (elts * 2 > osize || (elts * 8 < osize && osize > 32)) |
528 |
|
{ |
529 |
|
nindex = higher_prime_index (elts * 2); |
530 |
|
nsize = prime_tab[nindex].prime; |
531 |
|
} |
532 |
|
else |
533 |
|
{ |
534 |
|
nindex = oindex; |
535 |
|
nsize = osize; |
536 |
|
} |
537 |
|
|
538 |
nentries = (PTR *) (*htab->alloc_f) (htab->size, sizeof (PTR *)); |
if (htab->alloc_with_arg_f != NULL) |
539 |
|
nentries = (PTR *) (*htab->alloc_with_arg_f) (htab->alloc_arg, nsize, |
540 |
|
sizeof (PTR *)); |
541 |
|
else |
542 |
|
nentries = (PTR *) (*htab->alloc_f) (nsize, sizeof (PTR *)); |
543 |
if (nentries == NULL) |
if (nentries == NULL) |
544 |
return 0; |
return 0; |
545 |
htab->entries = nentries; |
htab->entries = nentries; |
546 |
|
htab->size = nsize; |
547 |
|
htab->size_prime_index = nindex; |
548 |
htab->n_elements -= htab->n_deleted; |
htab->n_elements -= htab->n_deleted; |
549 |
htab->n_deleted = 0; |
htab->n_deleted = 0; |
550 |
|
|
566 |
|
|
567 |
if (htab->free_f != NULL) |
if (htab->free_f != NULL) |
568 |
(*htab->free_f) (oentries); |
(*htab->free_f) (oentries); |
569 |
|
else if (htab->free_with_arg_f != NULL) |
570 |
|
(*htab->free_with_arg_f) (htab->alloc_arg, oentries); |
571 |
return 1; |
return 1; |
572 |
} |
} |
573 |
|
|
580 |
const PTR element; |
const PTR element; |
581 |
hashval_t hash; |
hashval_t hash; |
582 |
{ |
{ |
583 |
unsigned int index; |
hashval_t index, hash2; |
|
hashval_t hash2; |
|
584 |
size_t size; |
size_t size; |
585 |
PTR entry; |
PTR entry; |
586 |
|
|
587 |
htab->searches++; |
htab->searches++; |
588 |
size = htab->size; |
size = htab_size (htab); |
589 |
index = hash % size; |
index = htab_mod (hash, htab); |
590 |
|
|
591 |
entry = htab->entries[index]; |
entry = htab->entries[index]; |
592 |
if (entry == EMPTY_ENTRY |
if (entry == EMPTY_ENTRY |
593 |
|| (entry != DELETED_ENTRY && (*htab->eq_f) (entry, element))) |
|| (entry != DELETED_ENTRY && (*htab->eq_f) (entry, element))) |
594 |
return entry; |
return entry; |
595 |
|
|
596 |
hash2 = 1 + hash % (size - 2); |
hash2 = htab_mod_m2 (hash, htab); |
|
|
|
597 |
for (;;) |
for (;;) |
598 |
{ |
{ |
599 |
htab->collisions++; |
htab->collisions++; |
621 |
|
|
622 |
/* This function searches for a hash table slot containing an entry |
/* This function searches for a hash table slot containing an entry |
623 |
equal to the given element. To delete an entry, call this with |
equal to the given element. To delete an entry, call this with |
624 |
INSERT = 0, then call htab_clear_slot on the slot returned (possibly |
insert=NO_INSERT, then call htab_clear_slot on the slot returned |
625 |
after doing some checks). To insert an entry, call this with |
(possibly after doing some checks). To insert an entry, call this |
626 |
INSERT = 1, then write the value you want into the returned slot. |
with insert=INSERT, then write the value you want into the returned |
627 |
When inserting an entry, NULL may be returned if memory allocation |
slot. When inserting an entry, NULL may be returned if memory |
628 |
fails. */ |
allocation fails. */ |
629 |
|
|
630 |
PTR * |
PTR * |
631 |
htab_find_slot_with_hash (htab, element, hash, insert) |
htab_find_slot_with_hash (htab, element, hash, insert) |
635 |
enum insert_option insert; |
enum insert_option insert; |
636 |
{ |
{ |
637 |
PTR *first_deleted_slot; |
PTR *first_deleted_slot; |
638 |
unsigned int index; |
hashval_t index, hash2; |
|
hashval_t hash2; |
|
639 |
size_t size; |
size_t size; |
640 |
PTR entry; |
PTR entry; |
641 |
|
|
642 |
if (insert == INSERT && htab->size * 3 <= htab->n_elements * 4 |
size = htab_size (htab); |
643 |
&& htab_expand (htab) == 0) |
if (insert == INSERT && size * 3 <= htab->n_elements * 4) |
644 |
return NULL; |
{ |
645 |
|
if (htab_expand (htab) == 0) |
646 |
|
return NULL; |
647 |
|
size = htab_size (htab); |
648 |
|
} |
649 |
|
|
650 |
size = htab->size; |
index = htab_mod (hash, htab); |
|
index = hash % size; |
|
651 |
|
|
652 |
htab->searches++; |
htab->searches++; |
653 |
first_deleted_slot = NULL; |
first_deleted_slot = NULL; |
660 |
else if ((*htab->eq_f) (entry, element)) |
else if ((*htab->eq_f) (entry, element)) |
661 |
return &htab->entries[index]; |
return &htab->entries[index]; |
662 |
|
|
663 |
hash2 = 1 + hash % (size - 2); |
hash2 = htab_mod_m2 (hash, htab); |
664 |
for (;;) |
for (;;) |
665 |
{ |
{ |
666 |
htab->collisions++; |
htab->collisions++; |
684 |
if (insert == NO_INSERT) |
if (insert == NO_INSERT) |
685 |
return NULL; |
return NULL; |
686 |
|
|
|
htab->n_elements++; |
|
|
|
|
687 |
if (first_deleted_slot) |
if (first_deleted_slot) |
688 |
{ |
{ |
689 |
|
htab->n_deleted--; |
690 |
*first_deleted_slot = EMPTY_ENTRY; |
*first_deleted_slot = EMPTY_ENTRY; |
691 |
return first_deleted_slot; |
return first_deleted_slot; |
692 |
} |
} |
693 |
|
|
694 |
|
htab->n_elements++; |
695 |
return &htab->entries[index]; |
return &htab->entries[index]; |
696 |
} |
} |
697 |
|
|
709 |
} |
} |
710 |
|
|
711 |
/* This function deletes an element with the given value from hash |
/* This function deletes an element with the given value from hash |
712 |
|
table (the hash is computed from the element). If there is no matching |
713 |
|
element in the hash table, this function does nothing. */ |
714 |
|
|
715 |
|
void |
716 |
|
htab_remove_elt (htab, element) |
717 |
|
htab_t htab; |
718 |
|
PTR element; |
719 |
|
{ |
720 |
|
htab_remove_elt_with_hash (htab, element, (*htab->hash_f) (element)); |
721 |
|
} |
722 |
|
|
723 |
|
|
724 |
|
/* This function deletes an element with the given value from hash |
725 |
table. If there is no matching element in the hash table, this |
table. If there is no matching element in the hash table, this |
726 |
function does nothing. */ |
function does nothing. */ |
727 |
|
|
728 |
void |
void |
729 |
htab_remove_elt (htab, element) |
htab_remove_elt_with_hash (htab, element, hash) |
730 |
htab_t htab; |
htab_t htab; |
731 |
PTR element; |
PTR element; |
732 |
|
hashval_t hash; |
733 |
{ |
{ |
734 |
PTR *slot; |
PTR *slot; |
735 |
|
|
736 |
slot = htab_find_slot (htab, element, NO_INSERT); |
slot = htab_find_slot_with_hash (htab, element, hash, NO_INSERT); |
737 |
if (*slot == EMPTY_ENTRY) |
if (*slot == EMPTY_ENTRY) |
738 |
return; |
return; |
739 |
|
|
753 |
htab_t htab; |
htab_t htab; |
754 |
PTR *slot; |
PTR *slot; |
755 |
{ |
{ |
756 |
if (slot < htab->entries || slot >= htab->entries + htab->size |
if (slot < htab->entries || slot >= htab->entries + htab_size (htab) |
757 |
|| *slot == EMPTY_ENTRY || *slot == DELETED_ENTRY) |
|| *slot == EMPTY_ENTRY || *slot == DELETED_ENTRY) |
758 |
abort (); |
abort (); |
759 |
|
|
770 |
argument. */ |
argument. */ |
771 |
|
|
772 |
void |
void |
773 |
htab_traverse (htab, callback, info) |
htab_traverse_noresize (htab, callback, info) |
774 |
htab_t htab; |
htab_t htab; |
775 |
htab_trav callback; |
htab_trav callback; |
776 |
PTR info; |
PTR info; |
777 |
{ |
{ |
778 |
PTR *slot = htab->entries; |
PTR *slot; |
779 |
PTR *limit = slot + htab->size; |
PTR *limit; |
780 |
|
|
781 |
|
slot = htab->entries; |
782 |
|
limit = slot + htab_size (htab); |
783 |
|
|
784 |
do |
do |
785 |
{ |
{ |
792 |
while (++slot < limit); |
while (++slot < limit); |
793 |
} |
} |
794 |
|
|
795 |
/* Return the current size of given hash table. */ |
/* Like htab_traverse_noresize, but does resize the table when it is |
796 |
|
too empty to improve effectivity of subsequent calls. */ |
797 |
|
|
798 |
size_t |
void |
799 |
htab_size (htab) |
htab_traverse (htab, callback, info) |
800 |
htab_t htab; |
htab_t htab; |
801 |
|
htab_trav callback; |
802 |
|
PTR info; |
803 |
{ |
{ |
804 |
return htab->size; |
if (htab_elements (htab) * 8 < htab_size (htab)) |
805 |
} |
htab_expand (htab); |
|
|
|
|
/* Return the current number of elements in given hash table. */ |
|
806 |
|
|
807 |
size_t |
htab_traverse_noresize (htab, callback, info); |
|
htab_elements (htab) |
|
|
htab_t htab; |
|
|
{ |
|
|
return htab->n_elements - htab->n_deleted; |
|
808 |
} |
} |
809 |
|
|
810 |
/* Return the fraction of fixed collisions during all work with given |
/* Return the fraction of fixed collisions during all work with given |
858 |
|
|
859 |
return r; |
return r; |
860 |
} |
} |
861 |
|
|
862 |
|
/* DERIVED FROM: |
863 |
|
-------------------------------------------------------------------- |
864 |
|
lookup2.c, by Bob Jenkins, December 1996, Public Domain. |
865 |
|
hash(), hash2(), hash3, and mix() are externally useful functions. |
866 |
|
Routines to test the hash are included if SELF_TEST is defined. |
867 |
|
You can use this free for any purpose. It has no warranty. |
868 |
|
-------------------------------------------------------------------- |
869 |
|
*/ |
870 |
|
|
871 |
|
/* |
872 |
|
-------------------------------------------------------------------- |
873 |
|
mix -- mix 3 32-bit values reversibly. |
874 |
|
For every delta with one or two bit set, and the deltas of all three |
875 |
|
high bits or all three low bits, whether the original value of a,b,c |
876 |
|
is almost all zero or is uniformly distributed, |
877 |
|
* If mix() is run forward or backward, at least 32 bits in a,b,c |
878 |
|
have at least 1/4 probability of changing. |
879 |
|
* If mix() is run forward, every bit of c will change between 1/3 and |
880 |
|
2/3 of the time. (Well, 22/100 and 78/100 for some 2-bit deltas.) |
881 |
|
mix() was built out of 36 single-cycle latency instructions in a |
882 |
|
structure that could supported 2x parallelism, like so: |
883 |
|
a -= b; |
884 |
|
a -= c; x = (c>>13); |
885 |
|
b -= c; a ^= x; |
886 |
|
b -= a; x = (a<<8); |
887 |
|
c -= a; b ^= x; |
888 |
|
c -= b; x = (b>>13); |
889 |
|
... |
890 |
|
Unfortunately, superscalar Pentiums and Sparcs can't take advantage |
891 |
|
of that parallelism. They've also turned some of those single-cycle |
892 |
|
latency instructions into multi-cycle latency instructions. Still, |
893 |
|
this is the fastest good hash I could find. There were about 2^^68 |
894 |
|
to choose from. I only looked at a billion or so. |
895 |
|
-------------------------------------------------------------------- |
896 |
|
*/ |
897 |
|
/* same, but slower, works on systems that might have 8 byte hashval_t's */ |
898 |
|
#define mix(a,b,c) \ |
899 |
|
{ \ |
900 |
|
a -= b; a -= c; a ^= (c>>13); \ |
901 |
|
b -= c; b -= a; b ^= (a<< 8); \ |
902 |
|
c -= a; c -= b; c ^= ((b&0xffffffff)>>13); \ |
903 |
|
a -= b; a -= c; a ^= ((c&0xffffffff)>>12); \ |
904 |
|
b -= c; b -= a; b = (b ^ (a<<16)) & 0xffffffff; \ |
905 |
|
c -= a; c -= b; c = (c ^ (b>> 5)) & 0xffffffff; \ |
906 |
|
a -= b; a -= c; a = (a ^ (c>> 3)) & 0xffffffff; \ |
907 |
|
b -= c; b -= a; b = (b ^ (a<<10)) & 0xffffffff; \ |
908 |
|
c -= a; c -= b; c = (c ^ (b>>15)) & 0xffffffff; \ |
909 |
|
} |
910 |
|
|
911 |
|
/* |
912 |
|
-------------------------------------------------------------------- |
913 |
|
hash() -- hash a variable-length key into a 32-bit value |
914 |
|
k : the key (the unaligned variable-length array of bytes) |
915 |
|
len : the length of the key, counting by bytes |
916 |
|
level : can be any 4-byte value |
917 |
|
Returns a 32-bit value. Every bit of the key affects every bit of |
918 |
|
the return value. Every 1-bit and 2-bit delta achieves avalanche. |
919 |
|
About 36+6len instructions. |
920 |
|
|
921 |
|
The best hash table sizes are powers of 2. There is no need to do |
922 |
|
mod a prime (mod is sooo slow!). If you need less than 32 bits, |
923 |
|
use a bitmask. For example, if you need only 10 bits, do |
924 |
|
h = (h & hashmask(10)); |
925 |
|
In which case, the hash table should have hashsize(10) elements. |
926 |
|
|
927 |
|
If you are hashing n strings (ub1 **)k, do it like this: |
928 |
|
for (i=0, h=0; i<n; ++i) h = hash( k[i], len[i], h); |
929 |
|
|
930 |
|
By Bob Jenkins, 1996. bob_jenkins@burtleburtle.net. You may use this |
931 |
|
code any way you wish, private, educational, or commercial. It's free. |
932 |
|
|
933 |
|
See http://burtleburtle.net/bob/hash/evahash.html |
934 |
|
Use for hash table lookup, or anything where one collision in 2^32 is |
935 |
|
acceptable. Do NOT use for cryptographic purposes. |
936 |
|
-------------------------------------------------------------------- |
937 |
|
*/ |
938 |
|
|
939 |
|
hashval_t iterative_hash (k_in, length, initval) |
940 |
|
const PTR k_in; /* the key */ |
941 |
|
register size_t length; /* the length of the key */ |
942 |
|
register hashval_t initval; /* the previous hash, or an arbitrary value */ |
943 |
|
{ |
944 |
|
register const unsigned char *k = (const unsigned char *)k_in; |
945 |
|
register hashval_t a,b,c,len; |
946 |
|
|
947 |
|
/* Set up the internal state */ |
948 |
|
len = length; |
949 |
|
a = b = 0x9e3779b9; /* the golden ratio; an arbitrary value */ |
950 |
|
c = initval; /* the previous hash value */ |
951 |
|
|
952 |
|
/*---------------------------------------- handle most of the key */ |
953 |
|
#ifndef WORDS_BIGENDIAN |
954 |
|
/* On a little-endian machine, if the data is 4-byte aligned we can hash |
955 |
|
by word for better speed. This gives nondeterministic results on |
956 |
|
big-endian machines. */ |
957 |
|
if (sizeof (hashval_t) == 4 && (((size_t)k)&3) == 0) |
958 |
|
while (len >= 12) /* aligned */ |
959 |
|
{ |
960 |
|
a += *(hashval_t *)(k+0); |
961 |
|
b += *(hashval_t *)(k+4); |
962 |
|
c += *(hashval_t *)(k+8); |
963 |
|
mix(a,b,c); |
964 |
|
k += 12; len -= 12; |
965 |
|
} |
966 |
|
else /* unaligned */ |
967 |
|
#endif |
968 |
|
while (len >= 12) |
969 |
|
{ |
970 |
|
a += (k[0] +((hashval_t)k[1]<<8) +((hashval_t)k[2]<<16) +((hashval_t)k[3]<<24)); |
971 |
|
b += (k[4] +((hashval_t)k[5]<<8) +((hashval_t)k[6]<<16) +((hashval_t)k[7]<<24)); |
972 |
|
c += (k[8] +((hashval_t)k[9]<<8) +((hashval_t)k[10]<<16)+((hashval_t)k[11]<<24)); |
973 |
|
mix(a,b,c); |
974 |
|
k += 12; len -= 12; |
975 |
|
} |
976 |
|
|
977 |
|
/*------------------------------------- handle the last 11 bytes */ |
978 |
|
c += length; |
979 |
|
switch(len) /* all the case statements fall through */ |
980 |
|
{ |
981 |
|
case 11: c+=((hashval_t)k[10]<<24); |
982 |
|
case 10: c+=((hashval_t)k[9]<<16); |
983 |
|
case 9 : c+=((hashval_t)k[8]<<8); |
984 |
|
/* the first byte of c is reserved for the length */ |
985 |
|
case 8 : b+=((hashval_t)k[7]<<24); |
986 |
|
case 7 : b+=((hashval_t)k[6]<<16); |
987 |
|
case 6 : b+=((hashval_t)k[5]<<8); |
988 |
|
case 5 : b+=k[4]; |
989 |
|
case 4 : a+=((hashval_t)k[3]<<24); |
990 |
|
case 3 : a+=((hashval_t)k[2]<<16); |
991 |
|
case 2 : a+=((hashval_t)k[1]<<8); |
992 |
|
case 1 : a+=k[0]; |
993 |
|
/* case 0: nothing left to add */ |
994 |
|
} |
995 |
|
mix(a,b,c); |
996 |
|
/*-------------------------------------------- report the result */ |
997 |
|
return c; |
998 |
|
} |