/* hash - hashing table processing.
- Copyright (C) 1998 Free Software Foundation, Inc.
+
+ Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2006 Free
+ Software Foundation, Inc.
+
Written by Jim Meyering, 1992.
This program is free software; you can redistribute it and/or modify
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software Foundation,
- Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+ Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
/* A generic hash table package. */
/* Define USE_OBSTACK to 1 if you want the allocator to use obstacks instead
of malloc. If you change USE_OBSTACK, you have to recompile! */
-#if HAVE_CONFIG_H
-# include <config.h>
-#endif
-#if HAVE_STDLIB_H
-# include <stdlib.h>
-#endif
-#if HAVE_STDBOOL_H
-# include <stdbool.h>
-#else
-typedef enum {false = 0, true = 1} bool;
-#endif
-#include <stdio.h>
-#include <assert.h>
+#include <config.h>
-#if !HAVE_DECL_FREE
-void free ();
-#endif
-#if !HAVE_DECL_MALLOC
-char *malloc ();
-#endif
+#include "hash.h"
+#include "xalloc.h"
+
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
#if USE_OBSTACK
# include "obstack.h"
# endif
#endif
-#include "hash.h"
+#ifndef SIZE_MAX
+# define SIZE_MAX ((size_t) -1)
+#endif
+
+struct hash_table
+ {
+ /* The array of buckets starts at BUCKET and extends to BUCKET_LIMIT-1,
+ for a possibility of N_BUCKETS. Among those, N_BUCKETS_USED buckets
+ are not empty, there are N_ENTRIES active entries in the table. */
+ struct hash_entry *bucket;
+ struct hash_entry const *bucket_limit;
+ size_t n_buckets;
+ size_t n_buckets_used;
+ size_t n_entries;
+
+ /* Tuning arguments, kept in a physicaly separate structure. */
+ const Hash_tuning *tuning;
+
+ /* Three functions are given to `hash_initialize', see the documentation
+ block for this function. In a word, HASHER randomizes a user entry
+ into a number up from 0 up to some maximum minus 1; COMPARATOR returns
+ true if two user entries compare equally; and DATA_FREER is the cleanup
+ function for a user entry. */
+ Hash_hasher hasher;
+ Hash_comparator comparator;
+ Hash_data_freer data_freer;
+
+ /* A linked list of freed struct hash_entry structs. */
+ struct hash_entry *free_entry_list;
+
+#if USE_OBSTACK
+ /* Whenever obstacks are used, it is possible to allocate all overflowed
+ entries into a single stack, so they all can be freed in a single
+ operation. It is not clear if the speedup is worth the trouble. */
+ struct obstack entry_stack;
+#endif
+ };
-/* An hash table contains many internal entries, each holding a pointer to
+/* A hash table contains many internal entries, each holding a pointer to
some user provided data (also called a user entry). An entry indistinctly
refers to both the internal entry and its associated user entry. A user
- entry contents may be hashed by a randomisation function (the hashing
+ entry contents may be hashed by a randomization function (the hashing
function, or just `hasher' for short) into a number (or `slot') between 0
and the current table size. At each slot position in the hash table,
starts a linked chain of entries for which the user data all hash to this
A good `hasher' function will distribute entries rather evenly in buckets.
In the ideal case, the length of each bucket is roughly the number of
entries divided by the table size. Finding the slot for a data is usually
- done at constant speed by the `hasher', and the later finding of a precise
+ done in constant time by the `hasher', and the later finding of a precise
entry is linear in time with the size of the bucket. Consequently, a
- bigger hash table size (that is, a bigger number of buckets) is prone to
- yielding shorter buckets, *given* the `hasher' function behaves properly.
+ larger hash table size (that is, a larger number of buckets) is prone to
+ yielding shorter chains, *given* the `hasher' function behaves properly.
Long buckets slow down the lookup algorithm. One might use big hash table
sizes in hope to reduce the average length of buckets, but this might
become inordinate, as unused slots in the hash table take some space. The
best bet is to make sure you are using a good `hasher' function (beware
- that those are not that easy to write! :-), and to use a table size at
- least bigger than the actual number of entries.
-
- Currently, whenever the addition of an entry gets 80% of buckets to be
- non-empty, this package automatically doubles the number of buckets. */
+ that those are not that easy to write! :-), and to use a table size
+ larger than the actual number of entries. */
+
+/* If an insertion makes the ratio of nonempty buckets to table size larger
+ than the growth threshold (a number between 0.0 and 1.0), then increase
+ the table size by multiplying by the growth factor (a number greater than
+ 1.0). The growth threshold defaults to 0.8, and the growth factor
+ defaults to 1.414, meaning that the table will have doubled its size
+ every second time 80% of the buckets get used. */
+#define DEFAULT_GROWTH_THRESHOLD 0.8
+#define DEFAULT_GROWTH_FACTOR 1.414
+
+/* If a deletion empties a bucket and causes the ratio of used buckets to
+ table size to become smaller than the shrink threshold (a number between
+ 0.0 and 1.0), then shrink the table by multiplying by the shrink factor (a
+ number greater than the shrink threshold but smaller than 1.0). The shrink
+ threshold and factor default to 0.0 and 1.0, meaning that the table never
+ shrinks. */
+#define DEFAULT_SHRINK_THRESHOLD 0.0
+#define DEFAULT_SHRINK_FACTOR 1.0
+
+/* Use this to initialize or reset a TUNING structure to
+ some sensible values. */
+static const Hash_tuning default_tuning =
+ {
+ DEFAULT_SHRINK_THRESHOLD,
+ DEFAULT_SHRINK_FACTOR,
+ DEFAULT_GROWTH_THRESHOLD,
+ DEFAULT_GROWTH_FACTOR,
+ false
+ };
/* Information and lookup. */
/* The following few functions provide information about the overall hash
- table organisation: the number of entries, number of buckets and maximum
+ table organization: the number of entries, number of buckets and maximum
length of buckets. */
/* Return the number of buckets in the hash table. The table size, the total
number of buckets (used plus unused), or the maximum number of slots, are
the same quantity. */
-unsigned int
+size_t
hash_get_n_buckets (const Hash_table *table)
{
return table->n_buckets;
/* Return the number of slots in use (non-empty buckets). */
-unsigned int
+size_t
hash_get_n_buckets_used (const Hash_table *table)
{
return table->n_buckets_used;
/* Return the number of active entries. */
-unsigned int
+size_t
hash_get_n_entries (const Hash_table *table)
{
return table->n_entries;
}
-/* Return the length of the most lenghty chain (bucket). */
+/* Return the length of the longest chain (bucket). */
-unsigned int
+size_t
hash_get_max_bucket_length (const Hash_table *table)
{
- struct hash_entry *bucket;
- unsigned int max_bucket_length = 0;
+ struct hash_entry const *bucket;
+ size_t max_bucket_length = 0;
for (bucket = table->bucket; bucket < table->bucket_limit; bucket++)
{
if (bucket->data)
{
- struct hash_entry *cursor = bucket;
- unsigned int bucket_length = 1;
+ struct hash_entry const *cursor = bucket;
+ size_t bucket_length = 1;
while (cursor = cursor->next, cursor)
bucket_length++;
return max_bucket_length;
}
-/* Do a mild validation of an hash table, by traversing it and checking two
+/* Do a mild validation of a hash table, by traversing it and checking two
statistics. */
bool
hash_table_ok (const Hash_table *table)
{
- struct hash_entry *bucket;
- unsigned int n_buckets_used = 0;
- unsigned int n_entries = 0;
+ struct hash_entry const *bucket;
+ size_t n_buckets_used = 0;
+ size_t n_entries = 0;
for (bucket = table->bucket; bucket < table->bucket_limit; bucket++)
{
if (bucket->data)
{
- struct hash_entry *cursor = bucket;
+ struct hash_entry const *cursor = bucket;
/* Count bucket head. */
n_buckets_used++;
void
hash_print_statistics (const Hash_table *table, FILE *stream)
{
- unsigned int n_entries = hash_get_n_entries (table);
- unsigned int n_buckets = hash_get_n_buckets (table);
- unsigned int n_buckets_used = hash_get_n_buckets_used (table);
- unsigned int max_bucket_length = hash_get_max_bucket_length (table);
-
- fprintf (stream, "# entries: %u\n", n_entries);
- fprintf (stream, "# buckets: %u\n", n_buckets);
- fprintf (stream, "# buckets used: %u (%.2f%%)\n", n_buckets_used,
+ size_t n_entries = hash_get_n_entries (table);
+ size_t n_buckets = hash_get_n_buckets (table);
+ size_t n_buckets_used = hash_get_n_buckets_used (table);
+ size_t max_bucket_length = hash_get_max_bucket_length (table);
+
+ fprintf (stream, "# entries: %lu\n", (unsigned long int) n_entries);
+ fprintf (stream, "# buckets: %lu\n", (unsigned long int) n_buckets);
+ fprintf (stream, "# buckets used: %lu (%.2f%%)\n",
+ (unsigned long int) n_buckets_used,
(100.0 * n_buckets_used) / n_buckets);
- fprintf (stream, "max bucket length: %u\n", max_bucket_length);
+ fprintf (stream, "max bucket length: %lu\n",
+ (unsigned long int) max_bucket_length);
}
-/* Return the user entry from the hash table, if some entry in the hash table
- compares equally with ENTRY, or NULL otherwise. */
+/* If ENTRY matches an entry already in the hash table, return the
+ entry from the table. Otherwise, return NULL. */
void *
hash_lookup (const Hash_table *table, const void *entry)
{
- struct hash_entry *bucket
+ struct hash_entry const *bucket
= table->bucket + table->hasher (entry, table->n_buckets);
- struct hash_entry *cursor;
+ struct hash_entry const *cursor;
- assert (bucket < table->bucket_limit);
+ if (! (bucket < table->bucket_limit))
+ abort ();
if (bucket->data == NULL)
return NULL;
void *
hash_get_first (const Hash_table *table)
{
- struct hash_entry *bucket;
+ struct hash_entry const *bucket;
if (table->n_entries == 0)
return NULL;
- for (bucket = table->bucket; bucket < table->bucket_limit; bucket++)
- if (bucket->data)
+ for (bucket = table->bucket; ; bucket++)
+ if (! (bucket < table->bucket_limit))
+ abort ();
+ else if (bucket->data)
return bucket->data;
-
- abort ();
}
/* Return the user data for the entry following ENTRY, where ENTRY has been
returned by a previous call to either `hash_get_first' or `hash_get_next'.
- Return NULL if there is no more entries. */
+ Return NULL if there are no more entries. */
void *
hash_get_next (const Hash_table *table, const void *entry)
{
- struct hash_entry *bucket
+ struct hash_entry const *bucket
= table->bucket + table->hasher (entry, table->n_buckets);
- struct hash_entry *cursor;
+ struct hash_entry const *cursor;
- assert (bucket < table->bucket_limit);
+ if (! (bucket < table->bucket_limit))
+ abort ();
/* Find next entry in the same bucket. */
for (cursor = bucket; cursor; cursor = cursor->next)
return cursor->next->data;
/* Find first entry in any subsequent bucket. */
- for (; bucket < table->bucket_limit; bucket++)
+ while (++bucket < table->bucket_limit)
if (bucket->data)
return bucket->data;
return the number of pointers copied. Do not copy more than BUFFER_SIZE
pointers. */
-unsigned int
+size_t
hash_get_entries (const Hash_table *table, void **buffer,
- unsigned int buffer_size)
+ size_t buffer_size)
{
- unsigned int counter = 0;
- struct hash_entry *bucket;
- struct hash_entry *cursor;
+ size_t counter = 0;
+ struct hash_entry const *bucket;
+ struct hash_entry const *cursor;
for (bucket = table->bucket; bucket < table->bucket_limit; bucket++)
{
return counter;
}
-/* Call a PROCESSOR function for each entry of an hash table, and return the
+/* Call a PROCESSOR function for each entry of a hash table, and return the
number of entries for which the processor function returned success. A
pointer to some PROCESSOR_DATA which will be made available to each call to
the processor function. The PROCESSOR accepts two arguments: the first is
as received. The walking continue for as long as the PROCESSOR function
returns nonzero. When it returns zero, the walking is interrupted. */
-unsigned int
+size_t
hash_do_for_each (const Hash_table *table, Hash_processor processor,
void *processor_data)
{
- unsigned int counter = 0;
- struct hash_entry *bucket;
- struct hash_entry *cursor;
+ size_t counter = 0;
+ struct hash_entry const *bucket;
+ struct hash_entry const *cursor;
for (bucket = table->bucket; bucket < table->bucket_limit; bucket++)
{
algorithms tend to be domain-specific, so what's good for [diffutils'] io.c
may not be good for your application." */
-unsigned int
-hash_string (const char *string, unsigned int n_buckets)
+size_t
+hash_string (const char *string, size_t n_buckets)
{
-# ifndef CHAR_BIT
-# define CHAR_BIT 8
-# endif
# define ROTATE_LEFT(Value, Shift) \
- ((Value) << (Shift) | (Value) >> ((sizeof (unsigned) * CHAR_BIT) - (Shift)))
+ ((Value) << (Shift) | (Value) >> ((sizeof (size_t) * CHAR_BIT) - (Shift)))
# define HASH_ONE_CHAR(Value, Byte) \
((Byte) + ROTATE_LEFT (Value, 7))
- unsigned value = 0;
+ size_t value = 0;
+ unsigned char ch;
- for (; *string; string++)
- value = HASH_ONE_CHAR (value, *(const unsigned char *) string);
+ for (; (ch = *string); string++)
+ value = HASH_ONE_CHAR (value, ch);
return value % n_buckets;
# undef ROTATE_LEFT
very old Cyber `snoop', itself written in typical Greg Mansfield style.
(By the way, what happened to this excellent man? Is he still alive?) */
-unsigned int
-hash_string (const char *string, unsigned int n_buckets)
+size_t
+hash_string (const char *string, size_t n_buckets)
{
- unsigned value = 0;
+ size_t value = 0;
+ unsigned char ch;
- while (*string)
- value = ((value * 31 + (int) *(const unsigned char *) string++)
- % n_buckets);
+ for (; (ch = *string); string++)
+ value = (value * 31 + ch) % n_buckets;
return value;
}
/* Return true if CANDIDATE is a prime number. CANDIDATE should be an odd
number at least equal to 11. */
-static int
-is_prime (unsigned long candidate)
+static bool
+is_prime (size_t candidate)
{
- unsigned long divisor = 3;
- unsigned long square = divisor * divisor;
+ size_t divisor = 3;
+ size_t square = divisor * divisor;
while (square < candidate && (candidate % divisor))
{
divisor++;
}
- return candidate % divisor != 0;
+ return (candidate % divisor ? true : false);
}
/* Round a given CANDIDATE number up to the nearest prime, and return that
- prime. CANDIDATE should be at least equal to 10. */
+ prime. Primes lower than 10 are merely skipped. */
-static unsigned long
-next_prime (unsigned long candidate)
+static size_t
+next_prime (size_t candidate)
{
- assert (candidate >= 10);
+ /* Skip small primes. */
+ if (candidate < 10)
+ candidate = 10;
/* Make it definitely odd. */
candidate |= 1;
return candidate;
}
-/* Allocate and return a new hash table, or NULL if an error is met. The
- initial number of buckets would be at least CANDIDATE (which need not be
- prime).
+void
+hash_reset_tuning (Hash_tuning *tuning)
+{
+ *tuning = default_tuning;
+}
- If DATA_FREER is not NULL, this function may be later called with the data
- as an argument, just before they entry containing the data gets freed. The
- HASHER function should be supplied, and FIXME. The COMPARATOR function
- should also be supplied, and FIXME. */
+/* For the given hash TABLE, check the user supplied tuning structure for
+ reasonable values, and return true if there is no gross error with it.
+ Otherwise, definitively reset the TUNING field to some acceptable default
+ in the hash table (that is, the user loses the right of further modifying
+ tuning arguments), and return false. */
- /* User-supplied function for freeing datas. It is specified in
- hash_initialize. If non-null, it is used by hash_free and hash_clear.
- You should specify `free' here only if you want these functions to free
- all of your `data' data. This is typically the case when your data is
- simply an auxilliary struct that you have malloc'd to aggregate several
- values. */
+static bool
+check_tuning (Hash_table *table)
+{
+ const Hash_tuning *tuning = table->tuning;
+
+ /* Be a bit stricter than mathematics would require, so that
+ rounding errors in size calculations do not cause allocations to
+ fail to grow or shrink as they should. The smallest allocation
+ is 11 (due to next_prime's algorithm), so an epsilon of 0.1
+ should be good enough. */
+ float epsilon = 0.1f;
+
+ if (epsilon < tuning->growth_threshold
+ && tuning->growth_threshold < 1 - epsilon
+ && 1 + epsilon < tuning->growth_factor
+ && 0 <= tuning->shrink_threshold
+ && tuning->shrink_threshold + epsilon < tuning->shrink_factor
+ && tuning->shrink_factor <= 1
+ && tuning->shrink_threshold + epsilon < tuning->growth_threshold)
+ return true;
- /* User-supplied hash function that hashes entry ENTRY to an integer in
- the range 0..TABLE_SIZE-1. */
+ table->tuning = &default_tuning;
+ return false;
+}
- /* User-supplied function that determines whether a new entry is unique by
- comparing the new entry to entries that hashed to the same bucket
- index. It should return zero for a pair of entries that compare equal,
- non-zero otherwise. */
+/* Allocate and return a new hash table, or NULL upon failure. The initial
+ number of buckets is automatically selected so as to _guarantee_ that you
+ may insert at least CANDIDATE different user entries before any growth of
+ the hash table size occurs. So, if have a reasonably tight a-priori upper
+ bound on the number of entries you intend to insert in the hash table, you
+ may save some table memory and insertion time, by specifying it here. If
+ the IS_N_BUCKETS field of the TUNING structure is true, the CANDIDATE
+ argument has its meaning changed to the wanted number of buckets.
+
+ TUNING points to a structure of user-supplied values, in case some fine
+ tuning is wanted over the default behavior of the hasher. If TUNING is
+ NULL, the default tuning parameters are used instead.
+
+ The user-supplied HASHER function should be provided. It accepts two
+ arguments ENTRY and TABLE_SIZE. It computes, by hashing ENTRY contents, a
+ slot number for that entry which should be in the range 0..TABLE_SIZE-1.
+ This slot number is then returned.
+
+ The user-supplied COMPARATOR function should be provided. It accepts two
+ arguments pointing to user data, it then returns true for a pair of entries
+ that compare equal, or false otherwise. This function is internally called
+ on entries which are already known to hash to the same bucket index.
+
+ The user-supplied DATA_FREER function, when not NULL, may be later called
+ with the user data as an argument, just before the entry containing the
+ data gets freed. This happens from within `hash_free' or `hash_clear'.
+ You should specify this function only if you want these functions to free
+ all of your `data' data. This is typically the case when your data is
+ simply an auxiliary struct that you have malloc'd to aggregate several
+ values. */
Hash_table *
-hash_initialize (unsigned int candidate, Hash_hasher hasher,
- Hash_comparator comparator, Hash_data_freer data_freer)
+hash_initialize (size_t candidate, const Hash_tuning *tuning,
+ Hash_hasher hasher, Hash_comparator comparator,
+ Hash_data_freer data_freer)
{
Hash_table *table;
- struct hash_entry *bucket;
if (hasher == NULL || comparator == NULL)
return NULL;
- table = (Hash_table *) malloc (sizeof (Hash_table));
+ table = malloc (sizeof *table);
if (table == NULL)
return NULL;
- table->n_buckets = next_prime (candidate < 10 ? 10 : candidate);
- table->bucket = (struct hash_entry *)
- malloc (table->n_buckets * sizeof (struct hash_entry));
- if (table->bucket == NULL)
+ if (!tuning)
+ tuning = &default_tuning;
+ table->tuning = tuning;
+ if (!check_tuning (table))
{
- free (table);
- return NULL;
+ /* Fail if the tuning options are invalid. This is the only occasion
+ when the user gets some feedback about it. Once the table is created,
+ if the user provides invalid tuning options, we silently revert to
+ using the defaults, and ignore further request to change the tuning
+ options. */
+ goto fail;
}
- table->bucket_limit = table->bucket + table->n_buckets;
- for (bucket = table->bucket; bucket < table->bucket_limit; bucket++)
+ if (!tuning->is_n_buckets)
{
- bucket->data = NULL;
- bucket->next = NULL;
+ float new_candidate = candidate / tuning->growth_threshold;
+ if (SIZE_MAX <= new_candidate)
+ goto fail;
+ candidate = new_candidate;
}
+
+ if (xalloc_oversized (candidate, sizeof *table->bucket))
+ goto fail;
+ table->n_buckets = next_prime (candidate);
+ if (xalloc_oversized (table->n_buckets, sizeof *table->bucket))
+ goto fail;
+
+ table->bucket = calloc (table->n_buckets, sizeof *table->bucket);
+ table->bucket_limit = table->bucket + table->n_buckets;
table->n_buckets_used = 0;
table->n_entries = 0;
obstack_init (&table->entry_stack);
#endif
return table;
+
+ fail:
+ free (table);
+ return NULL;
}
/* Make all buckets empty, placing any chained entries on the free list.
hash_clear (Hash_table *table)
{
struct hash_entry *bucket;
- struct hash_entry *cursor;
for (bucket = table->bucket; bucket < table->bucket_limit; bucket++)
{
if (bucket->data)
{
+ struct hash_entry *cursor;
+ struct hash_entry *next;
+
/* Free the bucket overflow. */
- for (cursor = bucket->next; cursor; cursor = cursor->next)
+ for (cursor = bucket->next; cursor; cursor = next)
{
if (table->data_freer)
(*table->data_freer) (cursor->data);
cursor->data = NULL;
+ next = cursor->next;
/* Relinking is done one entry at a time, as it is to be expected
that overflows are either rare or short. */
cursor->next = table->free_entry_list;
table->n_entries = 0;
}
-/* Reclaim all storage associated with an hash table. If a data_freer
+/* Reclaim all storage associated with a hash table. If a data_freer
function has been supplied by the user when the hash table was created,
this function applies it to the data of each entry before freeing that
entry. */
else
{
#if USE_OBSTACK
- new = (struct hash_entry *)
- obstack_alloc (&table->entry_stack, sizeof (struct hash_entry));
+ new = obstack_alloc (&table->entry_stack, sizeof *new);
#else
- new = (struct hash_entry *) malloc (sizeof (struct hash_entry));
+ new = malloc (sizeof *new);
#endif
}
= table->bucket + table->hasher (entry, table->n_buckets);
struct hash_entry *cursor;
- assert (bucket < table->bucket_limit);
+ if (! (bucket < table->bucket_limit))
+ abort ();
+
*bucket_head = bucket;
/* Test for empty bucket. */
if (bucket->data == NULL)
return NULL;
- /* Check if then entry is found as the bucket head. */
+ /* See if the entry is the first in the bucket. */
if ((*table->comparator) (entry, bucket->data))
{
void *data = bucket->data;
return NULL;
}
-/* For an already existing hash table, change the number of buckets and make
- it NEW_TABLE_SIZE. The contents of the hash table are preserved. */
+/* For an already existing hash table, change the number of buckets through
+ specifying CANDIDATE. The contents of the hash table are preserved. The
+ new number of buckets is automatically selected so as to _guarantee_ that
+ the table may receive at least CANDIDATE different user entries, including
+ those already in the table, before any other growth of the hash table size
+ occurs. If TUNING->IS_N_BUCKETS is true, then CANDIDATE specifies the
+ exact number of buckets desired. */
bool
-hash_rehash (Hash_table *table, unsigned int new_n_buckets)
+hash_rehash (Hash_table *table, size_t candidate)
{
Hash_table *new_table;
struct hash_entry *bucket;
struct hash_entry *cursor;
struct hash_entry *next;
- if (table->n_buckets <= 0 || new_n_buckets == 0)
- return false;
-
- new_table = hash_initialize (new_n_buckets, table->hasher,
+ new_table = hash_initialize (candidate, table->tuning, table->hasher,
table->comparator, table->data_freer);
if (new_table == NULL)
return false;
new_table->free_entry_list = table->free_entry_list;
for (bucket = table->bucket; bucket < table->bucket_limit; bucket++)
- {
- if (bucket->data)
+ if (bucket->data)
+ for (cursor = bucket; cursor; cursor = next)
{
- for (cursor = bucket; cursor; cursor = next)
- {
- void *data = cursor->data;
- struct hash_entry *new_bucket
- = new_table->bucket + new_table->hasher (data, new_n_buckets);
+ void *data = cursor->data;
+ struct hash_entry *new_bucket
+ = (new_table->bucket
+ + new_table->hasher (data, new_table->n_buckets));
- assert (new_bucket < new_table->bucket_limit);
+ if (! (new_bucket < new_table->bucket_limit))
+ abort ();
- /* Free overflow entries as soon as possible, moving them from the
- old hash table into the new one, as they may be needed now. */
- next = cursor->next;
- if (cursor != bucket)
- free_entry (new_table, cursor);
+ next = cursor->next;
- /* Insert the entry into the new hash table. */
- if (new_bucket->data)
+ if (new_bucket->data)
+ {
+ if (cursor == bucket)
{
+ /* Allocate or recycle an entry, when moving from a bucket
+ header into a bucket overflow. */
struct hash_entry *new_entry = allocate_entry (new_table);
if (new_entry == NULL)
}
else
{
- new_bucket->data = data;
- new_table->n_buckets_used++;
+ /* Merely relink an existing entry, when moving from a
+ bucket overflow into a bucket overflow. */
+ cursor->next = new_bucket->next;
+ new_bucket->next = cursor;
}
}
+ else
+ {
+ /* Free an existing entry, when moving from a bucket
+ overflow into a bucket header. Also take care of the
+ simple case of moving from a bucket header into a bucket
+ header. */
+ new_bucket->data = data;
+ new_table->n_buckets_used++;
+ if (cursor != bucket)
+ free_entry (new_table, cursor);
+ }
}
- }
free (table->bucket);
table->bucket = new_table->bucket;
table->bucket_limit = new_table->bucket_limit;
table->n_buckets = new_table->n_buckets;
table->n_buckets_used = new_table->n_buckets_used;
+ table->free_entry_list = new_table->free_entry_list;
/* table->n_entries already holds its value. */
#if USE_OBSTACK
table->entry_stack = new_table->entry_stack;
return true;
}
-/* If ENTRY matches an entry already in the hash table, don't modify the table
- and return the matched entry. Otherwise, insert ENTRY and return NULL.
- *DONE is set to true in all cases, unless the storage required for
- insertion cannot be allocated. */
+/* If ENTRY matches an entry already in the hash table, return the pointer
+ to the entry from the table. Otherwise, insert ENTRY and return ENTRY.
+ Return NULL if the storage required for insertion cannot be allocated. */
void *
-hash_insert (Hash_table *table, const void *entry, bool *done)
+hash_insert (Hash_table *table, const void *entry)
{
void *data;
struct hash_entry *bucket;
- assert (entry); /* cannot insert a NULL data */
+ /* The caller cannot insert a NULL entry. */
+ if (! entry)
+ abort ();
- if (data = hash_find_entry (table, entry, &bucket, false), data)
- {
- *done = true;
- return data;
- }
+ /* If there's a matching entry already in the table, return that. */
+ if ((data = hash_find_entry (table, entry, &bucket, false)) != NULL)
+ return data;
/* ENTRY is not matched, it should be inserted. */
- table->n_entries++;
-
if (bucket->data)
{
struct hash_entry *new_entry = allocate_entry (table);
if (new_entry == NULL)
- {
- *done = false;
- return NULL;
- }
+ return NULL;
/* Add ENTRY in the overflow of the bucket. */
new_entry->data = (void *) entry;
new_entry->next = bucket->next;
bucket->next = new_entry;
- *done = true;
- return NULL;
+ table->n_entries++;
+ return (void *) entry;
}
/* Add ENTRY right in the bucket head. */
bucket->data = (void *) entry;
+ table->n_entries++;
table->n_buckets_used++;
- /* If more than 80% of the buckets are in use, rehash the table two
- times bigger. It's no real use checking the number of entries, as if
- the hashing function is ill-conditioned, rehashing is not likely to
- improve it. */
+ /* If the growth threshold of the buckets in use has been reached, increase
+ the table size and rehash. There's no point in checking the number of
+ entries: if the hashing function is ill-conditioned, rehashing is not
+ likely to improve it. */
- if (5 * table->n_buckets_used > 4 * table->n_buckets)
+ if (table->n_buckets_used
+ > table->tuning->growth_threshold * table->n_buckets)
{
- unsigned int new_n_buckets = next_prime (2 * table->n_buckets + 1);
-
- *done = hash_rehash (table, new_n_buckets);
- return NULL;
+ /* Check more fully, before starting real work. If tuning arguments
+ became invalid, the second check will rely on proper defaults. */
+ check_tuning (table);
+ if (table->n_buckets_used
+ > table->tuning->growth_threshold * table->n_buckets)
+ {
+ const Hash_tuning *tuning = table->tuning;
+ float candidate =
+ (tuning->is_n_buckets
+ ? (table->n_buckets * tuning->growth_factor)
+ : (table->n_buckets * tuning->growth_factor
+ * tuning->growth_threshold));
+
+ if (SIZE_MAX <= candidate)
+ return NULL;
+
+ /* If the rehash fails, arrange to return NULL. */
+ if (!hash_rehash (table, candidate))
+ entry = NULL;
+ }
}
- *done = true;
- return NULL;
+ return (void *) entry;
}
/* If ENTRY is already in the table, remove it and return the just-deleted
void *data;
struct hash_entry *bucket;
- if (data = hash_find_entry (table, entry, &bucket, true), !data)
+ data = hash_find_entry (table, entry, &bucket, true);
+ if (!data)
return NULL;
- if (!bucket->data)
- table->n_buckets_used--;
table->n_entries--;
+ if (!bucket->data)
+ {
+ table->n_buckets_used--;
+
+ /* If the shrink threshold of the buckets in use has been reached,
+ rehash into a smaller table. */
+
+ if (table->n_buckets_used
+ < table->tuning->shrink_threshold * table->n_buckets)
+ {
+ /* Check more fully, before starting real work. If tuning arguments
+ became invalid, the second check will rely on proper defaults. */
+ check_tuning (table);
+ if (table->n_buckets_used
+ < table->tuning->shrink_threshold * table->n_buckets)
+ {
+ const Hash_tuning *tuning = table->tuning;
+ size_t candidate =
+ (tuning->is_n_buckets
+ ? table->n_buckets * tuning->shrink_factor
+ : (table->n_buckets * tuning->shrink_factor
+ * tuning->growth_threshold));
+
+ hash_rehash (table, candidate);
+ }
+ }
+ }
return data;
}
void
hash_print (const Hash_table *table)
{
- struct hash_entry *bucket;
+ struct hash_entry const *bucket;
for (bucket = table->bucket; bucket < table->bucket_limit; bucket++)
{
struct hash_entry *cursor;
if (bucket)
- printf ("%d:\n", slot);
+ printf ("%lu:\n", (unsigned long int) (bucket - table->bucket));
for (cursor = bucket; cursor; cursor = cursor->next)
{
- char *s = (char *) cursor->data;
+ char const *s = cursor->data;
/* FIXME */
- printf (" %s\n", s);
+ if (s)
+ printf (" %s\n", s);
}
}
}
projects / gnulib.git / blobdiff