1 /* An expandable hash tables datatype.
2 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004
3 Free Software Foundation, Inc.
4 Contributed by Vladimir Makarov (vmakarov@cygnus.com).
6 This file is part of the libiberty library.
7 Libiberty is free software; you can redistribute it and/or
8 modify it under the terms of the GNU Library General Public
9 License as published by the Free Software Foundation; either
10 version 2 of the License, or (at your option) any later version.
12 Libiberty is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Library General Public License for more details.
17 You should have received a copy of the GNU Library General Public
18 License along with libiberty; see the file COPYING.LIB. If
19 not, write to the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
20 Boston, MA 02110-1301, USA. */
22 /* This package implements basic hash table functionality. It is possible
23 to search for an entry, create an entry and destroy an entry.
25 Elements in the table are generic pointers.
27 The size of the table is not fixed; if the occupancy of the table
28 grows too high the hash table will be expanded.
30 The abstract data implementation is based on generalized Algorithm D
31 from Knuth's book "The art of computer programming". Hash table is
32 expanded by creation of new hash table and transferring elements from
33 the old table to the new table. */
39 #include <sys/types.h>
59 #include "libiberty.h"
67 /* This macro defines reserved value for empty table entry. */
69 #define EMPTY_ENTRY ((PTR) 0)
71 /* This macro defines reserved value for table entry which contained
74 #define DELETED_ENTRY ((PTR) 1)
76 static unsigned int higher_prime_index (unsigned long);
77 static hashval_t
htab_mod_1 (hashval_t
, hashval_t
, hashval_t
, int);
78 static hashval_t
htab_mod (hashval_t
, htab_t
);
79 static hashval_t
htab_mod_m2 (hashval_t
, htab_t
);
80 static hashval_t
hash_pointer (const void *);
81 static int eq_pointer (const void *, const void *);
82 static int htab_expand (htab_t
);
83 static PTR
*find_empty_slot_for_expand (htab_t
, hashval_t
);
85 /* At some point, we could make these be NULL, and modify the
86 hash-table routines to handle NULL specially; that would avoid
87 function-call overhead for the common case of hashing pointers. */
88 htab_hash htab_hash_pointer
= hash_pointer
;
89 htab_eq htab_eq_pointer
= eq_pointer
;
91 /* Table of primes and multiplicative inverses.
93 Note that these are not minimally reduced inverses. Unlike when generating
94 code to divide by a constant, we want to be able to use the same algorithm
95 all the time. All of these inverses (are implied to) have bit 32 set.
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. */
102 ceil_log2 (unsigned int x
)
105 for (i
= 31; i
>= 0 ; --i
)
112 choose_multiplier (unsigned int d
, unsigned int *mlp
, unsigned char *shiftp
)
114 unsigned long long mhigh
;
116 int lgup
, post_shift
;
118 int n
= 32, precision
= 32;
120 lgup
= ceil_log2 (d
);
122 pow2
= n
+ lgup
- precision
;
124 nx
= ldexp (1.0, pow
) + ldexp (1.0, pow2
);
137 hashval_t inv_m2
; /* inverse of prime-2 */
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 }
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. */
179 higher_prime_index (unsigned long n
)
181 unsigned int low
= 0;
182 unsigned int high
= sizeof(prime_tab
) / sizeof(prime_tab
[0]);
186 unsigned int mid
= low
+ (high
- low
) / 2;
187 if (n
> prime_tab
[mid
].prime
)
193 /* If we've run out of primes, abort. */
194 if (n
> prime_tab
[low
].prime
)
196 fprintf (stderr
, "Cannot find prime bigger than %lu\n", n
);
203 /* Returns a hash code for P. */
206 hash_pointer (const PTR p
)
208 return (hashval_t
) ((long)p
>> 3);
211 /* Returns non-zero if P1 and P2 are equal. */
214 eq_pointer (const PTR p1
, const PTR p2
)
220 /* The parens around the function names in the next two definitions
221 are essential in order to prevent macro expansions of the name.
222 The bodies, however, are expanded as expected, so they are not
223 recursive definitions. */
225 /* Return the current size of given hash table. */
227 #define htab_size(htab) ((htab)->size)
230 (htab_size
) (htab_t htab
)
232 return htab_size (htab
);
235 /* Return the current number of elements in given hash table. */
237 #define htab_elements(htab) ((htab)->n_elements - (htab)->n_deleted)
240 (htab_elements
) (htab_t htab
)
242 return htab_elements (htab
);
247 static inline hashval_t
248 htab_mod_1 (hashval_t x
, hashval_t y
, hashval_t inv
, int shift
)
250 /* The multiplicative inverses computed above are for 32-bit types, and
251 requires that we be able to compute a highpart multiply. */
252 #ifdef UNSIGNED_64BIT_TYPE
253 __extension__
typedef UNSIGNED_64BIT_TYPE ull
;
254 if (sizeof (hashval_t
) * CHAR_BIT
<= 32)
256 hashval_t t1
, t2
, t3
, t4
, q
, r
;
258 t1
= ((ull
)x
* inv
) >> 32;
269 /* Otherwise just use the native division routines. */
273 /* Compute the primary hash for HASH given HTAB's current size. */
275 static inline hashval_t
276 htab_mod (hashval_t hash
, htab_t htab
)
278 const struct prime_ent
*p
= &prime_tab
[htab
->size_prime_index
];
279 return htab_mod_1 (hash
, p
->prime
, p
->inv
, p
->shift
);
282 /* Compute the secondary hash for HASH given HTAB's current size. */
284 static inline hashval_t
285 htab_mod_m2 (hashval_t hash
, htab_t htab
)
287 const struct prime_ent
*p
= &prime_tab
[htab
->size_prime_index
];
288 return 1 + htab_mod_1 (hash
, p
->prime
- 2, p
->inv_m2
, p
->shift
);
291 /* This function creates table with length slightly longer than given
292 source length. Created hash table is initiated as empty (all the
293 hash table entries are EMPTY_ENTRY). The function returns the
294 created hash table, or NULL if memory allocation fails. */
297 htab_create_alloc (size_t size
, htab_hash hash_f
, htab_eq eq_f
,
298 htab_del del_f
, htab_alloc alloc_f
, htab_free free_f
)
301 unsigned int size_prime_index
;
303 size_prime_index
= higher_prime_index (size
);
304 size
= prime_tab
[size_prime_index
].prime
;
306 result
= (htab_t
) (*alloc_f
) (1, sizeof (struct htab
));
309 result
->entries
= (PTR
*) (*alloc_f
) (size
, sizeof (PTR
));
310 if (result
->entries
== NULL
)
317 result
->size_prime_index
= size_prime_index
;
318 result
->hash_f
= hash_f
;
320 result
->del_f
= del_f
;
321 result
->alloc_f
= alloc_f
;
322 result
->free_f
= free_f
;
326 /* As above, but use the variants of alloc_f and free_f which accept
327 an extra argument. */
330 htab_create_alloc_ex (size_t size
, htab_hash hash_f
, htab_eq eq_f
,
331 htab_del del_f
, void *alloc_arg
,
332 htab_alloc_with_arg alloc_f
,
333 htab_free_with_arg free_f
)
336 unsigned int size_prime_index
;
338 size_prime_index
= higher_prime_index (size
);
339 size
= prime_tab
[size_prime_index
].prime
;
341 result
= (htab_t
) (*alloc_f
) (alloc_arg
, 1, sizeof (struct htab
));
344 result
->entries
= (PTR
*) (*alloc_f
) (alloc_arg
, size
, sizeof (PTR
));
345 if (result
->entries
== NULL
)
348 (*free_f
) (alloc_arg
, result
);
352 result
->size_prime_index
= size_prime_index
;
353 result
->hash_f
= hash_f
;
355 result
->del_f
= del_f
;
356 result
->alloc_arg
= alloc_arg
;
357 result
->alloc_with_arg_f
= alloc_f
;
358 result
->free_with_arg_f
= free_f
;
362 /* Update the function pointers and allocation parameter in the htab_t. */
365 htab_set_functions_ex (htab_t htab
, htab_hash hash_f
, htab_eq eq_f
,
366 htab_del del_f
, PTR alloc_arg
,
367 htab_alloc_with_arg alloc_f
, htab_free_with_arg free_f
)
369 htab
->hash_f
= hash_f
;
372 htab
->alloc_arg
= alloc_arg
;
373 htab
->alloc_with_arg_f
= alloc_f
;
374 htab
->free_with_arg_f
= free_f
;
377 /* These functions exist solely for backward compatibility. */
381 htab_create (size_t size
, htab_hash hash_f
, htab_eq eq_f
, htab_del del_f
)
383 return htab_create_alloc (size
, hash_f
, eq_f
, del_f
, xcalloc
, free
);
387 htab_try_create (size_t size
, htab_hash hash_f
, htab_eq eq_f
, htab_del del_f
)
389 return htab_create_alloc (size
, hash_f
, eq_f
, del_f
, calloc
, free
);
392 /* This function frees all memory allocated for given hash table.
393 Naturally the hash table must already exist. */
396 htab_delete (htab_t htab
)
398 size_t size
= htab_size (htab
);
399 PTR
*entries
= htab
->entries
;
403 for (i
= size
- 1; i
>= 0; i
--)
404 if (entries
[i
] != EMPTY_ENTRY
&& entries
[i
] != DELETED_ENTRY
)
405 (*htab
->del_f
) (entries
[i
]);
407 if (htab
->free_f
!= NULL
)
409 (*htab
->free_f
) (entries
);
410 (*htab
->free_f
) (htab
);
412 else if (htab
->free_with_arg_f
!= NULL
)
414 (*htab
->free_with_arg_f
) (htab
->alloc_arg
, entries
);
415 (*htab
->free_with_arg_f
) (htab
->alloc_arg
, htab
);
419 /* This function clears all entries in the given hash table. */
422 htab_empty (htab_t htab
)
424 size_t size
= htab_size (htab
);
425 PTR
*entries
= htab
->entries
;
429 for (i
= size
- 1; i
>= 0; i
--)
430 if (entries
[i
] != EMPTY_ENTRY
&& entries
[i
] != DELETED_ENTRY
)
431 (*htab
->del_f
) (entries
[i
]);
433 memset (entries
, 0, size
* sizeof (PTR
));
436 /* Similar to htab_find_slot, but without several unwanted side effects:
437 - Does not call htab->eq_f when it finds an existing entry.
438 - Does not change the count of elements/searches/collisions in the
440 This function also assumes there are no deleted entries in the table.
441 HASH is the hash value for the element to be inserted. */
444 find_empty_slot_for_expand (htab_t htab
, hashval_t hash
)
446 hashval_t index
= htab_mod (hash
, htab
);
447 size_t size
= htab_size (htab
);
448 PTR
*slot
= htab
->entries
+ index
;
451 if (*slot
== EMPTY_ENTRY
)
453 else if (*slot
== DELETED_ENTRY
)
456 hash2
= htab_mod_m2 (hash
, htab
);
463 slot
= htab
->entries
+ index
;
464 if (*slot
== EMPTY_ENTRY
)
466 else if (*slot
== DELETED_ENTRY
)
471 /* The following function changes size of memory allocated for the
472 entries and repeatedly inserts the table elements. The occupancy
473 of the table after the call will be about 50%. Naturally the hash
474 table must already exist. Remember also that the place of the
475 table entries is changed. If memory allocation failures are allowed,
476 this function will return zero, indicating that the table could not be
477 expanded. If all goes well, it will return a non-zero value. */
480 htab_expand (htab_t htab
)
486 size_t nsize
, osize
, elts
;
487 unsigned int oindex
, nindex
;
489 oentries
= htab
->entries
;
490 oindex
= htab
->size_prime_index
;
492 olimit
= oentries
+ osize
;
493 elts
= htab_elements (htab
);
495 /* Resize only when table after removal of unused elements is either
496 too full or too empty. */
497 if (elts
* 2 > osize
|| (elts
* 8 < osize
&& osize
> 32))
499 nindex
= higher_prime_index (elts
* 2);
500 nsize
= prime_tab
[nindex
].prime
;
508 if (htab
->alloc_with_arg_f
!= NULL
)
509 nentries
= (PTR
*) (*htab
->alloc_with_arg_f
) (htab
->alloc_arg
, nsize
,
512 nentries
= (PTR
*) (*htab
->alloc_f
) (nsize
, sizeof (PTR
*));
513 if (nentries
== NULL
)
515 htab
->entries
= nentries
;
517 htab
->size_prime_index
= nindex
;
518 htab
->n_elements
-= htab
->n_deleted
;
526 if (x
!= EMPTY_ENTRY
&& x
!= DELETED_ENTRY
)
528 PTR
*q
= find_empty_slot_for_expand (htab
, (*htab
->hash_f
) (x
));
537 if (htab
->free_f
!= NULL
)
538 (*htab
->free_f
) (oentries
);
539 else if (htab
->free_with_arg_f
!= NULL
)
540 (*htab
->free_with_arg_f
) (htab
->alloc_arg
, oentries
);
544 /* This function searches for a hash table entry equal to the given
545 element. It cannot be used to insert or delete an element. */
548 htab_find_with_hash (htab_t htab
, const PTR element
, hashval_t hash
)
550 hashval_t index
, hash2
;
555 size
= htab_size (htab
);
556 index
= htab_mod (hash
, htab
);
558 entry
= htab
->entries
[index
];
559 if (entry
== EMPTY_ENTRY
560 || (entry
!= DELETED_ENTRY
&& (*htab
->eq_f
) (entry
, element
)))
563 hash2
= htab_mod_m2 (hash
, htab
);
571 entry
= htab
->entries
[index
];
572 if (entry
== EMPTY_ENTRY
573 || (entry
!= DELETED_ENTRY
&& (*htab
->eq_f
) (entry
, element
)))
578 /* Like htab_find_slot_with_hash, but compute the hash value from the
582 htab_find (htab_t htab
, const PTR element
)
584 return htab_find_with_hash (htab
, element
, (*htab
->hash_f
) (element
));
587 /* This function searches for a hash table slot containing an entry
588 equal to the given element. To delete an entry, call this with
589 insert=NO_INSERT, then call htab_clear_slot on the slot returned
590 (possibly after doing some checks). To insert an entry, call this
591 with insert=INSERT, then write the value you want into the returned
592 slot. When inserting an entry, NULL may be returned if memory
596 htab_find_slot_with_hash (htab_t htab
, const PTR element
,
597 hashval_t hash
, enum insert_option insert
)
599 PTR
*first_deleted_slot
;
600 hashval_t index
, hash2
;
604 size
= htab_size (htab
);
605 if (insert
== INSERT
&& size
* 3 <= htab
->n_elements
* 4)
607 if (htab_expand (htab
) == 0)
609 size
= htab_size (htab
);
612 index
= htab_mod (hash
, htab
);
615 first_deleted_slot
= NULL
;
617 entry
= htab
->entries
[index
];
618 if (entry
== EMPTY_ENTRY
)
620 else if (entry
== DELETED_ENTRY
)
621 first_deleted_slot
= &htab
->entries
[index
];
622 else if ((*htab
->eq_f
) (entry
, element
))
623 return &htab
->entries
[index
];
625 hash2
= htab_mod_m2 (hash
, htab
);
633 entry
= htab
->entries
[index
];
634 if (entry
== EMPTY_ENTRY
)
636 else if (entry
== DELETED_ENTRY
)
638 if (!first_deleted_slot
)
639 first_deleted_slot
= &htab
->entries
[index
];
641 else if ((*htab
->eq_f
) (entry
, element
))
642 return &htab
->entries
[index
];
646 if (insert
== NO_INSERT
)
649 if (first_deleted_slot
)
652 *first_deleted_slot
= EMPTY_ENTRY
;
653 return first_deleted_slot
;
657 return &htab
->entries
[index
];
660 /* Like htab_find_slot_with_hash, but compute the hash value from the
664 htab_find_slot (htab_t htab
, const PTR element
, enum insert_option insert
)
666 return htab_find_slot_with_hash (htab
, element
, (*htab
->hash_f
) (element
),
670 /* This function deletes an element with the given value from hash
671 table (the hash is computed from the element). If there is no matching
672 element in the hash table, this function does nothing. */
675 htab_remove_elt (htab_t htab
, PTR element
)
677 htab_remove_elt_with_hash (htab
, element
, (*htab
->hash_f
) (element
));
681 /* This function deletes an element with the given value from hash
682 table. If there is no matching element in the hash table, this
683 function does nothing. */
686 htab_remove_elt_with_hash (htab_t htab
, PTR element
, hashval_t hash
)
690 slot
= htab_find_slot_with_hash (htab
, element
, hash
, NO_INSERT
);
691 if (*slot
== EMPTY_ENTRY
)
695 (*htab
->del_f
) (*slot
);
697 *slot
= DELETED_ENTRY
;
701 /* This function clears a specified slot in a hash table. It is
702 useful when you've already done the lookup and don't want to do it
706 htab_clear_slot (htab_t htab
, PTR
*slot
)
708 if (slot
< htab
->entries
|| slot
>= htab
->entries
+ htab_size (htab
)
709 || *slot
== EMPTY_ENTRY
|| *slot
== DELETED_ENTRY
)
713 (*htab
->del_f
) (*slot
);
715 *slot
= DELETED_ENTRY
;
719 /* This function scans over the entire hash table calling
720 CALLBACK for each live entry. If CALLBACK returns false,
721 the iteration stops. INFO is passed as CALLBACK's second
725 htab_traverse_noresize (htab_t htab
, htab_trav callback
, PTR info
)
730 slot
= htab
->entries
;
731 limit
= slot
+ htab_size (htab
);
737 if (x
!= EMPTY_ENTRY
&& x
!= DELETED_ENTRY
)
738 if (!(*callback
) (slot
, info
))
741 while (++slot
< limit
);
744 /* Like htab_traverse_noresize, but does resize the table when it is
745 too empty to improve effectivity of subsequent calls. */
748 htab_traverse (htab_t htab
, htab_trav callback
, PTR info
)
750 if (htab_elements (htab
) * 8 < htab_size (htab
))
753 htab_traverse_noresize (htab
, callback
, info
);
756 /* Return the fraction of fixed collisions during all work with given
760 htab_collisions (htab_t htab
)
762 if (htab
->searches
== 0)
765 return (double) htab
->collisions
/ (double) htab
->searches
;
768 /* Hash P as a null-terminated string.
770 Copied from gcc/hashtable.c. Zack had the following to say with respect
771 to applicability, though note that unlike hashtable.c, this hash table
772 implementation re-hashes rather than chain buckets.
774 http://gcc.gnu.org/ml/gcc-patches/2001-08/msg01021.html
775 From: Zack Weinberg <zackw@panix.com>
776 Date: Fri, 17 Aug 2001 02:15:56 -0400
778 I got it by extracting all the identifiers from all the source code
779 I had lying around in mid-1999, and testing many recurrences of
780 the form "H_n = H_{n-1} * K + c_n * L + M" where K, L, M were either
781 prime numbers or the appropriate identity. This was the best one.
782 I don't remember exactly what constituted "best", except I was
783 looking at bucket-length distributions mostly.
785 So it should be very good at hashing identifiers, but might not be
786 as good at arbitrary strings.
788 I'll add that it thoroughly trounces the hash functions recommended
789 for this use at http://burtleburtle.net/bob/hash/index.html, both
790 on speed and bucket distribution. I haven't tried it against the
791 function they just started using for Perl's hashes. */
794 htab_hash_string (const PTR p
)
796 const unsigned char *str
= (const unsigned char *) p
;
800 while ((c
= *str
++) != 0)
801 r
= r
* 67 + c
- 113;
807 --------------------------------------------------------------------
808 lookup2.c, by Bob Jenkins, December 1996, Public Domain.
809 hash(), hash2(), hash3, and mix() are externally useful functions.
810 Routines to test the hash are included if SELF_TEST is defined.
811 You can use this free for any purpose. It has no warranty.
812 --------------------------------------------------------------------
816 --------------------------------------------------------------------
817 mix -- mix 3 32-bit values reversibly.
818 For every delta with one or two bit set, and the deltas of all three
819 high bits or all three low bits, whether the original value of a,b,c
820 is almost all zero or is uniformly distributed,
821 * If mix() is run forward or backward, at least 32 bits in a,b,c
822 have at least 1/4 probability of changing.
823 * If mix() is run forward, every bit of c will change between 1/3 and
824 2/3 of the time. (Well, 22/100 and 78/100 for some 2-bit deltas.)
825 mix() was built out of 36 single-cycle latency instructions in a
826 structure that could supported 2x parallelism, like so:
834 Unfortunately, superscalar Pentiums and Sparcs can't take advantage
835 of that parallelism. They've also turned some of those single-cycle
836 latency instructions into multi-cycle latency instructions. Still,
837 this is the fastest good hash I could find. There were about 2^^68
838 to choose from. I only looked at a billion or so.
839 --------------------------------------------------------------------
841 /* same, but slower, works on systems that might have 8 byte hashval_t's */
844 a -= b; a -= c; a ^= (c>>13); \
845 b -= c; b -= a; b ^= (a<< 8); \
846 c -= a; c -= b; c ^= ((b&0xffffffff)>>13); \
847 a -= b; a -= c; a ^= ((c&0xffffffff)>>12); \
848 b -= c; b -= a; b = (b ^ (a<<16)) & 0xffffffff; \
849 c -= a; c -= b; c = (c ^ (b>> 5)) & 0xffffffff; \
850 a -= b; a -= c; a = (a ^ (c>> 3)) & 0xffffffff; \
851 b -= c; b -= a; b = (b ^ (a<<10)) & 0xffffffff; \
852 c -= a; c -= b; c = (c ^ (b>>15)) & 0xffffffff; \
856 --------------------------------------------------------------------
857 hash() -- hash a variable-length key into a 32-bit value
858 k : the key (the unaligned variable-length array of bytes)
859 len : the length of the key, counting by bytes
860 level : can be any 4-byte value
861 Returns a 32-bit value. Every bit of the key affects every bit of
862 the return value. Every 1-bit and 2-bit delta achieves avalanche.
863 About 36+6len instructions.
865 The best hash table sizes are powers of 2. There is no need to do
866 mod a prime (mod is sooo slow!). If you need less than 32 bits,
867 use a bitmask. For example, if you need only 10 bits, do
868 h = (h & hashmask(10));
869 In which case, the hash table should have hashsize(10) elements.
871 If you are hashing n strings (ub1 **)k, do it like this:
872 for (i=0, h=0; i<n; ++i) h = hash( k[i], len[i], h);
874 By Bob Jenkins, 1996. bob_jenkins@burtleburtle.net. You may use this
875 code any way you wish, private, educational, or commercial. It's free.
877 See http://burtleburtle.net/bob/hash/evahash.html
878 Use for hash table lookup, or anything where one collision in 2^32 is
879 acceptable. Do NOT use for cryptographic purposes.
880 --------------------------------------------------------------------
884 iterative_hash (const PTR k_in
/* the key */,
885 register size_t length
/* the length of the key */,
886 register hashval_t initval
/* the previous hash, or
887 an arbitrary value */)
889 register const unsigned char *k
= (const unsigned char *)k_in
;
890 register hashval_t a
,b
,c
,len
;
892 /* Set up the internal state */
894 a
= b
= 0x9e3779b9; /* the golden ratio; an arbitrary value */
895 c
= initval
; /* the previous hash value */
897 /*---------------------------------------- handle most of the key */
898 #ifndef WORDS_BIGENDIAN
899 /* On a little-endian machine, if the data is 4-byte aligned we can hash
900 by word for better speed. This gives nondeterministic results on
901 big-endian machines. */
902 if (sizeof (hashval_t
) == 4 && (((size_t)k
)&3) == 0)
903 while (len
>= 12) /* aligned */
905 a
+= *(hashval_t
*)(k
+0);
906 b
+= *(hashval_t
*)(k
+4);
907 c
+= *(hashval_t
*)(k
+8);
915 a
+= (k
[0] +((hashval_t
)k
[1]<<8) +((hashval_t
)k
[2]<<16) +((hashval_t
)k
[3]<<24));
916 b
+= (k
[4] +((hashval_t
)k
[5]<<8) +((hashval_t
)k
[6]<<16) +((hashval_t
)k
[7]<<24));
917 c
+= (k
[8] +((hashval_t
)k
[9]<<8) +((hashval_t
)k
[10]<<16)+((hashval_t
)k
[11]<<24));
922 /*------------------------------------- handle the last 11 bytes */
924 switch(len
) /* all the case statements fall through */
926 case 11: c
+=((hashval_t
)k
[10]<<24);
927 case 10: c
+=((hashval_t
)k
[9]<<16);
928 case 9 : c
+=((hashval_t
)k
[8]<<8);
929 /* the first byte of c is reserved for the length */
930 case 8 : b
+=((hashval_t
)k
[7]<<24);
931 case 7 : b
+=((hashval_t
)k
[6]<<16);
932 case 6 : b
+=((hashval_t
)k
[5]<<8);
934 case 4 : a
+=((hashval_t
)k
[3]<<24);
935 case 3 : a
+=((hashval_t
)k
[2]<<16);
936 case 2 : a
+=((hashval_t
)k
[1]<<8);
938 /* case 0: nothing left to add */
941 /*-------------------------------------------- report the result */