hash.c

   1 /* hash.c -- hash table maintenance
   2 Copyright (C) 1995, 1999, 2002 Free Software Foundation, Inc.
   3 Written by Greg McGary <gkm@gnu.org> <greg@mcgary.org>
   4
   5 GNU Make is free software; you can redistribute it and/or modify it under the
   6 terms of the GNU General Public License as published by the Free Software
   7 Foundation; either version 3 of the License, or (at your option) any later
   8 version.
   9
  10 GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
  11 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  12 A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License along with
  15 this program.  If not, see <http://www.gnu.org/licenses/>.  */
  16
  17 #include "make.h"
  18 #include "hash.h"
  19
  20 #define CALLOC(t, n) ((t *) calloc (sizeof (t), (n)))
  21 #define MALLOC(t, n) ((t *) xmalloc (sizeof (t) * (n)))
  22 #define REALLOC(o, t, n) ((t *) xrealloc ((o), sizeof (t) * (n)))
  23 #define CLONE(o, t, n) ((t *) memcpy (MALLOC (t, (n)), (o), sizeof (t) * (n)))
  24
  25 static void hash_rehash __P((struct hash_table* ht));
  26 static unsigned long round_up_2 __P((unsigned long rough));
  27
  28 /* Implement double hashing with open addressing.  The table size is
  29    always a power of two.  The secondary (`increment') hash function
  30    is forced to return an odd-value, in order to be relatively prime
  31    to the table size.  This guarantees that the increment can
  32    potentially hit every slot in the table during collision
  33    resolution.  */
  34
  35 void *hash_deleted_item = &hash_deleted_item;
  36
  37 /* Force the table size to be a power of two, possibly rounding up the
  38    given size.  */
  39
  40 void
  41 hash_init (struct hash_table *ht, unsigned long size,
  42            hash_func_t hash_1, hash_func_t hash_2, hash_cmp_func_t hash_cmp)
  43 {
  44   ht->ht_size = round_up_2 (size);
  45   ht->ht_empty_slots = ht->ht_size;
  46   ht->ht_vec = (void**) CALLOC (struct token *, ht->ht_size);
  47   if (ht->ht_vec == 0)
  48     {
  49       fprintf (stderr, _("can't allocate %ld bytes for hash table: memory exhausted"),
  50                ht->ht_size * sizeof(struct token *));
  51       exit (1);
  52     }
  53
  54   ht->ht_capacity = ht->ht_size - (ht->ht_size / 16); /* 93.75% loading factor */
  55   ht->ht_fill = 0;
  56   ht->ht_collisions = 0;
  57   ht->ht_lookups = 0;
  58   ht->ht_rehashes = 0;
  59   ht->ht_hash_1 = hash_1;
  60   ht->ht_hash_2 = hash_2;
  61   ht->ht_compare = hash_cmp;
  62 }
  63
  64 /* Load an array of items into `ht'.  */
  65
  66 void
  67 hash_load (struct hash_table *ht, void *item_table,
  68            unsigned long cardinality, unsigned long size)
  69 {
  70   char *items = (char *) item_table;
  71   while (cardinality--)
  72     {
  73       hash_insert (ht, items);
  74       items += size;
  75     }
  76 }
  77
  78 /* Returns the address of the table slot matching `key'.  If `key' is
  79    not found, return the address of an empty slot suitable for
  80    inserting `key'.  The caller is responsible for incrementing
  81    ht_fill on insertion.  */
  82
  83 void **
  84 hash_find_slot (struct hash_table *ht, const void *key)
  85 {
  86   void **slot;
  87   void **deleted_slot = 0;
  88   unsigned int hash_2 = 0;
  89   unsigned int hash_1 = (*ht->ht_hash_1) (key);
  90
  91   ht->ht_lookups++;
  92   for (;;)
  93     {
  94       hash_1 &= (ht->ht_size - 1);
  95       slot = &ht->ht_vec[hash_1];
  96
  97       if (*slot == 0)
  98         return (deleted_slot ? deleted_slot : slot);
  99       if (*slot == hash_deleted_item)
 100         {
 101           if (deleted_slot == 0)
 102             deleted_slot = slot;
 103         }
 104       else
 105         {
 106           if (key == *slot)
 107             return slot;
 108           if ((*ht->ht_compare) (key, *slot) == 0)
 109             return slot;
 110           ht->ht_collisions++;
 111         }
 112       if (!hash_2)
 113           hash_2 = (*ht->ht_hash_2) (key) | 1;
 114       hash_1 += hash_2;
 115     }
 116 }
 117
 118 void *
 119 hash_find_item (struct hash_table *ht, const void *key)
 120 {
 121   void **slot = hash_find_slot (ht, key);
 122   return ((HASH_VACANT (*slot)) ? 0 : *slot);
 123 }
 124
 125 void *
 126 hash_insert (struct hash_table *ht, const void *item)
 127 {
 128   void **slot = hash_find_slot (ht, item);
 129   const void *old_item = *slot;
 130   hash_insert_at (ht, item, slot);
 131   return (void *)((HASH_VACANT (old_item)) ? 0 : old_item);
 132 }
 133
 134 void *
 135 hash_insert_at (struct hash_table *ht, const void *item, const void *slot)
 136 {
 137   const void *old_item = *(void **) slot;
 138   if (HASH_VACANT (old_item))
 139     {
 140       ht->ht_fill++;
 141       if (old_item == 0)
 142         ht->ht_empty_slots--;
 143       old_item = item;
 144     }
 145   *(void const **) slot = item;
 146   if (ht->ht_empty_slots < ht->ht_size - ht->ht_capacity)
 147     {
 148       hash_rehash (ht);
 149       return (void *) hash_find_slot (ht, item);
 150     }
 151   else
 152     return (void *) slot;
 153 }
 154
 155 void *
 156 hash_delete (struct hash_table *ht, const void *item)
 157 {
 158   void **slot = hash_find_slot (ht, item);
 159   return hash_delete_at (ht, slot);
 160 }
 161
 162 void *
 163 hash_delete_at (struct hash_table *ht, const void *slot)
 164 {
 165   void *item = *(void **) slot;
 166   if (!HASH_VACANT (item))
 167     {
 168       *(void const **) slot = hash_deleted_item;
 169       ht->ht_fill--;
 170       return item;
 171     }
 172   else
 173     return 0;
 174 }
 175
 176 void
 177 hash_free_items (struct hash_table *ht)
 178 {
 179   void **vec = ht->ht_vec;
 180   void **end = &vec[ht->ht_size];
 181   for (; vec < end; vec++)
 182     {
 183       void *item = *vec;
 184       if (!HASH_VACANT (item))
 185         free (item);
 186       *vec = 0;
 187     }
 188   ht->ht_fill = 0;
 189   ht->ht_empty_slots = ht->ht_size;
 190 }
 191
 192 void
 193 hash_delete_items (struct hash_table *ht)
 194 {
 195   void **vec = ht->ht_vec;
 196   void **end = &vec[ht->ht_size];
 197   for (; vec < end; vec++)
 198     *vec = 0;
 199   ht->ht_fill = 0;
 200   ht->ht_collisions = 0;
 201   ht->ht_lookups = 0;
 202   ht->ht_rehashes = 0;
 203   ht->ht_empty_slots = ht->ht_size;
 204 }
 205
 206 void
 207 hash_free (struct hash_table *ht, int free_items)
 208 {
 209   if (free_items)
 210     hash_free_items (ht);
 211   else
 212     {
 213       ht->ht_fill = 0;
 214       ht->ht_empty_slots = ht->ht_size;
 215     }
 216   free (ht->ht_vec);
 217   ht->ht_vec = 0;
 218   ht->ht_capacity = 0;
 219 }
 220
 221 void
 222 hash_map (struct hash_table *ht, hash_map_func_t map)
 223 {
 224   void **slot;
 225   void **end = &ht->ht_vec[ht->ht_size];
 226
 227   for (slot = ht->ht_vec; slot < end; slot++)
 228     {
 229       if (!HASH_VACANT (*slot))
 230         (*map) (*slot);
 231     }
 232 }
 233
 234 void
 235 hash_map_arg (struct hash_table *ht, hash_map_arg_func_t map, void *arg)
 236 {
 237   void **slot;
 238   void **end = &ht->ht_vec[ht->ht_size];
 239
 240   for (slot = ht->ht_vec; slot < end; slot++)
 241     {
 242       if (!HASH_VACANT (*slot))
 243         (*map) (*slot, arg);
 244     }
 245 }
 246
 247 /* Double the size of the hash table in the event of overflow... */
 248
 249 static void
 250 hash_rehash (struct hash_table *ht)
 251 {
 252   unsigned long old_ht_size = ht->ht_size;
 253   void **old_vec = ht->ht_vec;
 254   void **ovp;
 255
 256   if (ht->ht_fill >= ht->ht_capacity)
 257     {
 258       ht->ht_size *= 2;
 259       ht->ht_capacity = ht->ht_size - (ht->ht_size >> 4);
 260     }
 261   ht->ht_rehashes++;
 262   ht->ht_vec = (void **) CALLOC (struct token *, ht->ht_size);
 263
 264   for (ovp = old_vec; ovp < &old_vec[old_ht_size]; ovp++)
 265     {
 266       if (! HASH_VACANT (*ovp))
 267         {
 268           void **slot = hash_find_slot (ht, *ovp);
 269           *slot = *ovp;
 270         }
 271     }
 272   ht->ht_empty_slots = ht->ht_size - ht->ht_fill;
 273   free (old_vec);
 274 }
 275
 276 void
 277 hash_print_stats (struct hash_table *ht, FILE *out_FILE)
 278 {
 279   /* GKM FIXME: honor NO_FLOAT */
 280   fprintf (out_FILE, _("Load=%ld/%ld=%.0f%%, "), ht->ht_fill, ht->ht_size,
 281            100.0 * (double) ht->ht_fill / (double) ht->ht_size);
 282   fprintf (out_FILE, _("Rehash=%d, "), ht->ht_rehashes);
 283   fprintf (out_FILE, _("Collisions=%ld/%ld=%.0f%%"), ht->ht_collisions, ht->ht_lookups,
 284            (ht->ht_lookups
 285             ? (100.0 * (double) ht->ht_collisions / (double) ht->ht_lookups)
 286             : 0));
 287 }
 288
 289 /* Dump all items into a NULL-terminated vector.  Use the
 290    user-supplied vector, or malloc one.  */
 291
 292 void **
 293 hash_dump (struct hash_table *ht, void **vector_0, qsort_cmp_t compare)
 294 {
 295   void **vector;
 296   void **slot;
 297   void **end = &ht->ht_vec[ht->ht_size];
 298
 299   if (vector_0 == 0)
 300     vector_0 = MALLOC (void *, ht->ht_fill + 1);
 301   vector = vector_0;
 302
 303   for (slot = ht->ht_vec; slot < end; slot++)
 304     if (!HASH_VACANT (*slot))
 305       *vector++ = *slot;
 306   *vector = 0;
 307
 308   if (compare)
 309     qsort (vector_0, ht->ht_fill, sizeof (void *), compare);
 310   return vector_0;
 311 }
 312
 313 /* Round a given number up to the nearest power of 2. */
 314
 315 static unsigned long
 316 round_up_2 (unsigned long n)
 317 {
 318   n |= (n >> 1);
 319   n |= (n >> 2);
 320   n |= (n >> 4);
 321   n |= (n >> 8);
 322   n |= (n >> 16);
 323
 324 #if !defined(HAVE_LIMITS_H) || ULONG_MAX > 4294967295
 325   /* We only need this on systems where unsigned long is >32 bits.  */
 326   n |= (n >> 32);
 327 #endif
 328
 329   return n + 1;
 330 }