/[gcl]/gcl/binutils/libiberty/hashtab.c
ViewVC logotype

Diff of /gcl/binutils/libiberty/hashtab.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.1.1.1 by camm, Fri Aug 9 05:36:28 2002 UTC revision 1.1.1.1.20.1 by camm, Fri Sep 30 02:10:43 2005 UTC
# Line 1  Line 1 
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.
# Line 40  Boston, MA 02111-1307, USA.  */ Line 41  Boston, MA 02111-1307, USA.  */
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)
# Line 59  Boston, MA 02111-1307, USA.  */ Line 73  Boston, MA 02111-1307, USA.  */
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));
# Line 71  static PTR *find_empty_slot_for_expand Line 88  static PTR *find_empty_slot_for_expand
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.  */
# Line 155  eq_pointer (p1, p2) Line 220  eq_pointer (p1, p2)
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
# Line 170  htab_create_alloc (size, hash_f, eq_f, d Line 305  htab_create_alloc (size, hash_f, eq_f, d
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;
# Line 183  htab_create_alloc (size, hash_f, eq_f, d Line 321  htab_create_alloc (size, hash_f, eq_f, d
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;
# Line 191  htab_create_alloc (size, hash_f, eq_f, d Line 330  htab_create_alloc (size, hash_f, eq_f, d
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
# Line 221  void Line 421  void
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.  */
# Line 242  void Line 448  void
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:
# Line 265  find_empty_slot_for_expand (htab, hash) Line 472  find_empty_slot_for_expand (htab, hash)
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    
# Line 275  find_empty_slot_for_expand (htab, hash) Line 482  find_empty_slot_for_expand (htab, hash)
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;
# Line 306  htab_expand (htab) Line 513  htab_expand (htab)
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    
# Line 338  htab_expand (htab) Line 566  htab_expand (htab)
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    
# Line 350  htab_find_with_hash (htab, element, hash Line 580  htab_find_with_hash (htab, element, hash
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++;
# Line 393  htab_find (htab, element) Line 621  htab_find (htab, element)
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)
# Line 407  htab_find_slot_with_hash (htab, element, Line 635  htab_find_slot_with_hash (htab, element,
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;
# Line 430  htab_find_slot_with_hash (htab, element, Line 660  htab_find_slot_with_hash (htab, element,
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++;
# Line 454  htab_find_slot_with_hash (htab, element, Line 684  htab_find_slot_with_hash (htab, element,
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    
# Line 479  htab_find_slot (htab, element, insert) Line 709  htab_find_slot (htab, element, insert)
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    
# Line 509  htab_clear_slot (htab, slot) Line 753  htab_clear_slot (htab, slot)
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    
# Line 526  htab_clear_slot (htab, slot) Line 770  htab_clear_slot (htab, slot)
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      {      {
# Line 545  htab_traverse (htab, callback, info) Line 792  htab_traverse (htab, callback, info)
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
# Line 614  htab_hash_string (p) Line 858  htab_hash_string (p)
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    }

Legend:
Removed from v.1.1.1.1  
changed lines
  Added in v.1.1.1.1.20.1

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26