hash.c File Reference

#include <assert.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include "hash.h"

Macros
#define	NDEBUG
#define	HASH_IMPLEMENTATION
#define	INIT_BITS   6
#define	INIT_SIZE   (1UL << (INIT_BITS))
#define	INIT_MASK   ((INIT_SIZE) - 1)
#define	next   hash_next
#define	key   hash_key
#define	data   hash_data
#define	hkey   hash_hkey
#define	table   hash_table
#define	nchains   hash_nchains
#define	nodecount   hash_nodecount
#define	maxcount   hash_maxcount
#define	highmark   hash_highmark
#define	lowmark   hash_lowmark
#define	compare   hash_compare
#define	function   hash_function
#define	allocnode   hash_allocnode
#define	freenode   hash_freenode
#define	context   hash_context
#define	mask   hash_mask
#define	dynamic   hash_dynamic
#define	table   hash_table
#define	chain   hash_chain
#define	get16bits(d)

Functions
static hnode_t *	hnode_alloc (void *context)
static void	hnode_free (hnode_t *node, void *context)
static hash_val_t	hash_fun_default (const void *key)
static int	hash_comp_default (const void *key1, const void *key2)
static void	compute_bits (void)
	Compute the number of bits in the hash_val_t type.
static int	is_power_of_two (hash_val_t arg)
static void	clear_table (hash_t *hash)
static void	grow_table (hash_t *hash)
	Double the size of a dynamic table.
static void	shrink_table (hash_t *hash)
	Cut a table size in half.
hash_t *	hash_create (hashcount_t maxcount, hash_comp_t compfun, hash_fun_t hashfun)
	Create a dynamic hash table.
void	hash_set_allocator (hash_t *hash, hnode_alloc_t al, hnode_free_t fr, void *context)
void	hash_free_nodes (hash_t *hash)
void	hash_destroy (hash_t *hash)
void	hash_scan_begin (hscan_t *scan, hash_t *hash)
	Initialize a hash scanner.
hnode_t *	hash_scan_next (hscan_t *scan)
	Retrieve the next node from the hash table, and update the pointer for the next invocation of hash_scan_next().
void	hash_insert (hash_t *hash, hnode_t *node, const void *key)
	Insert a node into the hash table.
hnode_t *	hash_lookup (hash_t *hash, const void *key)
	Find a node in the hash table and return a pointer to it.
hnode_t *	hash_delete (hash_t *hash, hnode_t *node)
	Delete the given node from the hash table. Since the chains are singly linked, we must locate the start of the node's chain and traverse.
int	hash_alloc_insert (hash_t *hash, const void *key, void *data)
void	hash_delete_free (hash_t *hash, hnode_t *node)
hnode_t *	hash_scan_delete (hash_t *hash, hnode_t *node)
void	hash_scan_delfree (hash_t *hash, hnode_t *node)
int	hash_verify (hash_t *hash)
	Verify whether the given object is a valid hash table.
hnode_t *	hnode_init (hnode_t *hnode, void *data)
void *	hnode_get (hnode_t *node)
const void *	hnode_getkey (hnode_t *node)
hashcount_t	hash_count (hash_t *hash)
hashcount_t	hash_size (hash_t *hash)

Variables
int	hash_val_t_bit

Macro Definition Documentation

allocnode

#define allocnode   hash_allocnode

chain

#define chain   hash_chain

compare

#define compare   hash_compare

context

#define context   hash_context

data

#define data   hash_data

dynamic

#define dynamic   hash_dynamic

freenode

#define freenode   hash_freenode

function

#define function   hash_function

get16bits

#define get16bits

(

d

)

Value:

                      ((((uint32_t)(((const uint8_t *)(d))[1])) << 8)    \
                      +(uint32_t)(((const uint8_t *)(d))[0]) )

HASH_IMPLEMENTATION

#define HASH_IMPLEMENTATION

highmark

#define highmark   hash_highmark

hkey

#define hkey   hash_hkey

INIT_BITS

#define INIT_BITS   6

INIT_MASK

#define INIT_MASK   ((INIT_SIZE) - 1)

INIT_SIZE

#define INIT_SIZE   (1UL << (INIT_BITS))

key

#define key   hash_key

lowmark

#define lowmark   hash_lowmark

mask

#define mask   hash_mask

maxcount

#define maxcount   hash_maxcount

nchains

#define nchains   hash_nchains

NDEBUG

#define NDEBUG

next

#define next   hash_next

nodecount

#define nodecount   hash_nodecount

table [1/2]

#define table   hash_table

table [2/2]

#define table   hash_table

Function Documentation

clear_table()

void clear_table ( hash_t * hash )

static

Initialize the table of pointers to null.

compute_bits()

void compute_bits ( void )

static

Compute the number of bits in the hash_val_t type.

We know that hash_val_t is an unsigned integral type. Thus the highest value it can hold is a Mersenne number (power of two, less one). We initialize a hash_val_t object with this value and then shift bits out one by one while counting.

Note

1. HASH_VAL_T_MAX is a Mersenne number—one that is one less than a power of two. This means that its binary representation consists of all one bits, and hence 'val' is initialized to all one bits.
2. While bits remain in val, we increment the bit count and shift it to the right, replacing the topmost bit by zero.

grow_table()

void grow_table ( hash_t * hash )

static

Double the size of a dynamic table.

This works as follows. Each chain splits into two adjacent chains. The shift amount increases by one, exposing an additional bit of each hashed key. For each node in the original chain, the value of this newly exposed bit will decide which of the two new chains will receive the node: if the bit is 1, the chain with the higher index will have the node, otherwise the lower chain will receive the node. In this manner, the hash table will continue to function exactly as before without having to rehash any of the keys.

Note

1. Overflow check.
2. The new number of chains is twice the old number of chains.
3. The new mask is one bit wider than the previous, revealing a new bit in all hashed keys.
4. Allocate a new table of chain pointers that is twice as large as the previous one.
5. If the reallocation was successful, we perform the rest of the growth algorithm, otherwise we do nothing.
6. The exposed_bit variable holds a mask with which each hashed key can be AND-ed to test the value of its newly exposed bit.
7. Now loop over each chain in the table and sort its nodes into two chains based on the value of each node's newly exposed hash bit.
8. The low chain replaces the current chain. The high chain goes into the corresponding sister chain in the upper half of the table.
9. We have finished dealing with the chains and nodes. We now update the various bookeeping fields of the hash structure.

hash_alloc_insert()

int hash_alloc_insert	(	hash_t *	hash,
		const void *	key,
		void *	data )

hash_comp_default()

int hash_comp_default ( const void * key1, const void * key2 )

static

hash_count()

hashcount_t hash_count

(

hash_t *

hash

)

hash_create()

hash_t * hash_create	(	hashcount_t	maxcount,
		hash_comp_t	compfun,
		hash_fun_t	hashfun )

Create a dynamic hash table.

Both the hash table structure and the table itself are dynamically allocated. Furthermore, the table is extendible in that it will automatically grow as its load factor increases beyond a certain threshold.

Note

1. If the number of bits in the hash_val_t type has not been computed yet, we do so here, because this is likely to be the first function that the user calls.
2. Allocate a hash table control structure.
3. If a hash table control structure is successfully allocated, we proceed to initialize it. Otherwise we return a null pointer.
4. We try to allocate the table of hash chains.
5. If we were able to allocate the hash chain table, we can finish initializing the hash structure and the table. Otherwise, we must backtrack by freeing the hash structure.
6. INIT_SIZE should be a power of two. The high and low marks are always set to be twice the table size and half the table size respectively. When the number of nodes in the table grows beyond the high size (beyond load factor 2), it will double in size to cut the load factor down to about about 1. If the table shrinks down to or beneath load factor 0.5, it will shrink, bringing the load up to about 1. However, the table will never shrink beneath INIT_SIZE even if it's emptied.
7. This indicates that the table is dynamically allocated and dynamically resized on the fly. A table that has this value set to zero is assumed to be statically allocated and will not be resized.
8. The table of chains must be properly reset to all null pointers.

hash_delete()

hnode_t * hash_delete	(	hash_t *	hash,
		hnode_t *	node )

Delete the given node from the hash table. Since the chains are singly linked, we must locate the start of the node's chain and traverse.

Note

1. The node must belong to this hash table, and its key must not have been tampered with.
2. If this deletion will take the node count below the low mark, we shrink the table now.
3. Determine which chain the node belongs to, and fetch the pointer to the first node in this chain.
4. If the node being deleted is the first node in the chain, then simply update the chain head pointer.
5. Otherwise advance to the node's predecessor, and splice out by updating the predecessor's next pointer.
6. Indicate that the node is no longer in a hash table.

hash_delete_free()

void hash_delete_free	(	hash_t *	hash,
		hnode_t *	node )

hash_destroy()

void hash_destroy

(

hash_t *

hash

)

Free a dynamic hash table structure.

hash_free_nodes()

void hash_free_nodes

(

hash_t *

hash

)

Free every node in the hash using the hash->freenode() function pointer, and cause the hash to become empty.

hash_fun_default()

hash_val_t hash_fun_default ( const void * key )

static

hash_insert()

void hash_insert	(	hash_t *	hash,
		hnode_t *	node,
		const void *	key )

Insert a node into the hash table.

Note

1. It's illegal to insert more than the maximum number of nodes. The client should verify that the hash table is not full before attempting an insertion.
2. The same key may not be inserted into a table twice.
3. If the table is dynamic and the load factor is already at >= 2, grow the table.
4. We take the bottom N bits of the hash value to derive the chain index, where N is the base 2 logarithm of the size of the hash table.

hash_lookup()

hnode_t * hash_lookup	(	hash_t *	hash,
		const void *	key )

Find a node in the hash table and return a pointer to it.

Note

1. We hash the key and keep the entire hash value. As an optimization, when we descend down the chain, we can compare hash values first and only if hash values match do we perform a full key comparison.
2. To locate the chain from among 2^N chains, we look at the lower N bits of the hash value by anding them with the current mask.
3. Looping through the chain, we compare the stored hash value inside each node against our computed hash. If they match, then we do a full comparison between the unhashed keys. If these match, we have located the entry.

hash_scan_begin()

void hash_scan_begin	(	hscan_t *	scan,
		hash_t *	hash )

Initialize a hash scanner.

Reset the hash scanner so that the next element retrieved by hash_scan_next() shall be the first element on the first non-empty chain.

Note

1. Locate the first non empty chain.
2. If an empty chain is found, remember which one it is and set the next pointer to refer to its first element.
3. Otherwise if a chain is not found, set the next pointer to NULL so that hash_scan_next() shall indicate failure.

hash_scan_delete()

hnode_t * hash_scan_delete	(	hash_t *	hash,
		hnode_t *	node )

Exactly like hash_delete, except does not trigger table shrinkage. This is to be used from within a hash table scan operation. See notes for hash_delete.

hash_scan_delfree()

void hash_scan_delfree	(	hash_t *	hash,
		hnode_t *	node )

Like hash_delete_free but based on hash_scan_delete.

hash_scan_next()

hnode_t * hash_scan_next

(

hscan_t *

scan

)

Retrieve the next node from the hash table, and update the pointer for the next invocation of hash_scan_next().

Note

1. Remember the next pointer in a temporary value so that it can be returned.
2. This assertion essentially checks whether the module has been properly initialized. The first point of interaction with the module should be either hash_create() or hash_init(), both of which set hash_val_t_bit to a non zero value.
3. If the next pointer we are returning is not NULL, then the user is allowed to call hash_scan_next() again. We prepare the new next pointer for that call right now. That way the user is allowed to delete the node we are about to return, since we will no longer be needing it to locate the next node.
4. If there is a next node in the chain (next->next), then that becomes the new next node, otherwise ...
5. We have exhausted the current chain, and must locate the next subsequent non-empty chain in the table.
6. If a non-empty chain is found, the first element of that chain becomes the new next node. Otherwise there is no new next node and we set the pointer to NULL so that the next time hash_scan_next() is called, a null pointer shall be immediately returned.

hash_set_allocator()

void hash_set_allocator	(	hash_t *	hash,
		hnode_alloc_t	al,
		hnode_free_t	fr,
		void *	context )

Select a different set of node allocator routines.

hash_size()

hashcount_t hash_size

(

hash_t *

hash

)

hash_verify()

int hash_verify

(

hash_t *

hash

)

Verify whether the given object is a valid hash table.

Note

1. If the hash table is dynamic, verify whether the high and low expansion/shrinkage thresholds are powers of two.
2. Count all nodes in the table, and test each hash value to see whether it is correct for the node's chain.

hnode_alloc()

hnode_t * hnode_alloc ( void * context )

static

hnode_free()

void hnode_free ( hnode_t * node, void * context )

static

hnode_get()

void * hnode_get

(

hnode_t *

node

)

hnode_getkey()

const void * hnode_getkey

(

hnode_t *

node

)

hnode_init()

hnode_t * hnode_init	(	hnode_t *	hnode,
		void *	data )

Initialize a client-supplied node

is_power_of_two()

int is_power_of_two ( hash_val_t arg )

static

Verify whether the given argument is a power of two.

shrink_table()

void shrink_table ( hash_t * hash )

static

Cut a table size in half.

This is done by folding together adjacent chains and populating the lower half of the table with these chains. The chains are simply spliced together. Once this is done, the whole table is reallocated to a smaller object.

Note

1. It is illegal to have a hash table with one slot. This would mean that hash->shift is equal to hash_val_t_bit, an illegal shift value. Also, other things could go wrong, such as hash->lowmark becoming zero.
2. Looping over each pair of sister chains, the low_chain is set to point to the head node of the chain in the lower half of the table, and high_chain points to the head node of the sister in the upper half.
3. The intent here is to compute a pointer to the last node of the lower chain into the low_tail variable. If this chain is empty, low_tail ends up with a null value.
4. If the lower chain is not empty, we simply tack the upper chain onto it. If the upper chain is a null pointer, nothing happens.
5. Otherwise if the lower chain is empty but the upper one is not, If the low chain is empty, but the high chain is not, then the high chain is simply transferred to the lower half of the table.
6. Otherwise if both chains are empty, there is nothing to do.
7. All the chain pointers are in the lower half of the table now, so we reallocate it to a smaller object. This, of course, invalidates all pointer-to-pointers which reference into the table from the first node of each chain.
8. Though it's unlikely, the reallocation may fail. In this case we pretend that the table was reallocated to a smaller object.
9. Finally, update the various table parameters to reflect the new size.

Variable Documentation

hash_val_t_bit

int hash_val_t_bit