CNDP  22.08.0
cne_hash.h File Reference
#include <stdint.h>
#include <stddef.h>

Go to the source code of this file.

Data Structures

struct  cne_hash_parameters
 

Macros

#define CNE_HASH_ENTRIES_MAX   (1 << 30)
 
#define CNE_HASH_NAMESIZE   32
 
#define CNE_HASH_LOOKUP_BULK_MAX   64
 
#define CNE_HASH_EXTRA_FLAGS_TRANS_MEM_SUPPORT   0x01
 
#define CNE_HASH_EXTRA_FLAGS_MULTI_WRITER_ADD   0x02
 
#define CNE_HASH_EXTRA_FLAGS_RW_CONCURRENCY   0x04
 
#define CNE_HASH_EXTRA_FLAGS_EXT_TABLE   0x08
 
#define CNE_HASH_EXTRA_FLAGS_NO_FREE_ON_DEL   0x10
 
#define CNE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF   0x20
 

Typedefs

typedef uint32_t hash_sig_t
 
typedef uint32_t(* cne_hash_function) (const void *key, uint32_t key_len, uint32_t init_val)
 
typedef int(* cne_hash_cmp_eq_t) (const void *key1, const void *key2, size_t key_len)
 

Functions

struct cne_hashcne_hash_create (const struct cne_hash_parameters *params)
 
void cne_hash_set_cmp_func (struct cne_hash *h, cne_hash_cmp_eq_t func)
 
struct cne_hashcne_hash_find_existing (const char *name)
 
void cne_hash_free (struct cne_hash *h)
 
void cne_hash_reset (struct cne_hash *h)
 
int32_t cne_hash_count (const struct cne_hash *h)
 
int32_t cne_hash_max_key_id (const struct cne_hash *h)
 
int cne_hash_add_key_data (const struct cne_hash *h, const void *key, void *data)
 
int32_t cne_hash_add_key_with_hash_data (const struct cne_hash *h, const void *key, hash_sig_t sig, void *data)
 
int32_t cne_hash_add_key (const struct cne_hash *h, const void *key)
 
int32_t cne_hash_add_key_with_hash (const struct cne_hash *h, const void *key, hash_sig_t sig)
 
int32_t cne_hash_del_key (const struct cne_hash *h, const void *key)
 
int32_t cne_hash_del_key_with_hash (const struct cne_hash *h, const void *key, hash_sig_t sig)
 
int cne_hash_get_key_with_position (const struct cne_hash *h, const int32_t position, void **key)
 
int cne_hash_free_key_with_position (const struct cne_hash *h, const int32_t position)
 
int cne_hash_lookup_data (const struct cne_hash *h, const void *key, void **data)
 
int cne_hash_lookup_with_hash_data (const struct cne_hash *h, const void *key, hash_sig_t sig, void **data)
 
int32_t cne_hash_lookup (const struct cne_hash *h, const void *key)
 
int32_t cne_hash_lookup_with_hash (const struct cne_hash *h, const void *key, hash_sig_t sig)
 
hash_sig_t cne_hash_hash (const struct cne_hash *h, const void *key)
 
int cne_hash_lookup_bulk_data (const struct cne_hash *h, const void **keys, uint32_t num_keys, uint64_t *hit_mask, void *data[])
 
int cne_hash_lookup_with_hash_bulk (const struct cne_hash *h, const void **keys, hash_sig_t *sig, uint32_t num_keys, int32_t *positions)
 
int cne_hash_lookup_with_hash_bulk_data (const struct cne_hash *h, const void **keys, hash_sig_t *sig, uint32_t num_keys, uint64_t *hit_mask, void *data[])
 
int cne_hash_lookup_bulk (const struct cne_hash *h, const void **keys, uint32_t num_keys, int32_t *positions)
 
int32_t cne_hash_iterate (const struct cne_hash *h, const void **key, void **data, uint32_t *next)
 

Detailed Description

A hashmap set of routines for string keywords.

Definition in file cne_hash.h.

Macro Definition Documentation

◆ CNE_HASH_ENTRIES_MAX

#define CNE_HASH_ENTRIES_MAX   (1 << 30)

Maximum size of hash table that can be created.

Definition at line 21 of file cne_hash.h.

◆ CNE_HASH_NAMESIZE

#define CNE_HASH_NAMESIZE   32

Maximum number of characters in hash name.

Definition at line 24 of file cne_hash.h.

◆ CNE_HASH_LOOKUP_BULK_MAX

#define CNE_HASH_LOOKUP_BULK_MAX   64

Maximum number of keys that can be searched for using cne_hash_lookup_bulk.

Definition at line 27 of file cne_hash.h.

◆ CNE_HASH_EXTRA_FLAGS_TRANS_MEM_SUPPORT

#define CNE_HASH_EXTRA_FLAGS_TRANS_MEM_SUPPORT   0x01

Enable Hardware transactional memory support.

Definition at line 31 of file cne_hash.h.

◆ CNE_HASH_EXTRA_FLAGS_MULTI_WRITER_ADD

#define CNE_HASH_EXTRA_FLAGS_MULTI_WRITER_ADD   0x02

Default behavior of insertion, single writer/multi writer

Definition at line 34 of file cne_hash.h.

◆ CNE_HASH_EXTRA_FLAGS_RW_CONCURRENCY

#define CNE_HASH_EXTRA_FLAGS_RW_CONCURRENCY   0x04

Flag to support reader writer concurrency

Definition at line 37 of file cne_hash.h.

◆ CNE_HASH_EXTRA_FLAGS_EXT_TABLE

#define CNE_HASH_EXTRA_FLAGS_EXT_TABLE   0x08

Flag to indicate the extendable bucket table feature should be used

Definition at line 40 of file cne_hash.h.

◆ CNE_HASH_EXTRA_FLAGS_NO_FREE_ON_DEL

#define CNE_HASH_EXTRA_FLAGS_NO_FREE_ON_DEL   0x10

Flag to disable freeing of key index on hash delete. Refer to cne_hash_del_xxx APIs for more details. This is enabled by default when CNE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF is enabled.

Definition at line 47 of file cne_hash.h.

◆ CNE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF

#define CNE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF   0x20

Flag to support lock free reader writer concurrency. Both single writer and multi writer use cases are supported.

Definition at line 52 of file cne_hash.h.

Typedef Documentation

◆ hash_sig_t

typedef uint32_t hash_sig_t

The type of hash value of a key. It should be a value of at least 32bit with fully random pattern.

Definition at line 58 of file cne_hash.h.

◆ cne_hash_function

typedef uint32_t(* cne_hash_function) (const void *key, uint32_t key_len, uint32_t init_val)

Type of function that can be used for calculating the hash value.

Definition at line 61 of file cne_hash.h.

◆ cne_hash_cmp_eq_t

typedef int(* cne_hash_cmp_eq_t) (const void *key1, const void *key2, size_t key_len)

Type of function used to compare the hash key.

Definition at line 64 of file cne_hash.h.

Function Documentation

◆ cne_hash_create()

struct cne_hash* cne_hash_create ( const struct cne_hash_parameters params)

Create a new hash table.

Parameters
paramsParameters used to create and initialise the hash table.
Returns
Pointer to hash table structure that is used in future hash table operations, or NULL on error, with error code set in errno. Possible errno errors include:
  • E_CNE_NO_CONFIG - function could not get pointer to cne_config structure
  • E_CNE_SECONDARY - function was called from a secondary process instance
  • ENOENT - missing entry
  • EINVAL - invalid parameter passed to function
  • ENOSPC - the maximum number of memzones has already been allocated
  • EEXIST - a memzone with the same name already exists
  • ENOMEM - no appropriate memory area found in which to create memzone

◆ cne_hash_set_cmp_func()

void cne_hash_set_cmp_func ( struct cne_hash h,
cne_hash_cmp_eq_t  func 
)

Set a new hash compare function other than the default one.

Note
Function pointer does not work with multi-process, so do not use it in multi-process mode.
Parameters
hHash table for which the function is to be changed
funcNew compare function

◆ cne_hash_find_existing()

struct cne_hash* cne_hash_find_existing ( const char *  name)

Find an existing hash table object and return a pointer to it.

Parameters
nameName of the hash table as passed to cne_hash_create()
Returns
Pointer to hash table or NULL if object not found with errno set appropriately. Possible errno values include:
  • ENOENT - value not available for return

◆ cne_hash_free()

void cne_hash_free ( struct cne_hash h)

De-allocate all memory used by hash table.

Parameters
hHash table to free

◆ cne_hash_reset()

void cne_hash_reset ( struct cne_hash h)

Reset all hash structure, by zeroing all entries. When CNE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF is enabled, it is application's responsibility to make sure that none of the readers are referencing the hash table while calling this API.

Parameters
hHash table to reset

◆ cne_hash_count()

int32_t cne_hash_count ( const struct cne_hash h)

Return the number of keys in the hash table

Parameters
hHash table to query from
Returns
  • -EINVAL if parameters are invalid
  • A value indicating how many keys were inserted in the table.

◆ cne_hash_max_key_id()

int32_t cne_hash_max_key_id ( const struct cne_hash h)

Return the maximum key value ID that could possibly be returned by cne_hash_add_key function.

Parameters
hHash table to query from
Returns
  • -EINVAL if parameters are invalid
  • A value indicating the max key ID of key slots present in the table.

◆ cne_hash_add_key_data()

int cne_hash_add_key_data ( const struct cne_hash h,
const void *  key,
void *  data 
)

Add a key-value pair to an existing hash table. This operation is not multi-thread safe and should only be called from one thread by default. Thread safety can be enabled by setting flag during table creation. If the key exists already in the table, this API updates its value with 'data' passed in this API. It is the responsibility of the application to manage any memory associated with the old value. The readers might still be using the old value even after this API has returned.

Parameters
hHash table to add the key to.
keyKey to add to the hash table.
dataData to add to the hash table.
Returns
  • 0 if added successfully
  • -EINVAL if the parameters are invalid.
  • -ENOSPC if there is no space in the hash for this key.

◆ cne_hash_add_key_with_hash_data()

int32_t cne_hash_add_key_with_hash_data ( const struct cne_hash h,
const void *  key,
hash_sig_t  sig,
void *  data 
)

Add a key-value pair with a pre-computed hash value to an existing hash table. This operation is not multi-thread safe and should only be called from one thread by default. Thread safety can be enabled by setting flag during table creation. If the key exists already in the table, this API updates its value with 'data' passed in this API. It is the responsibility of the application to manage any memory associated with the old value. The readers might still be using the old value even after this API has returned.

Parameters
hHash table to add the key to.
keyKey to add to the hash table.
sigPrecomputed hash value for 'key'
dataData to add to the hash table.
Returns
  • 0 if added successfully
  • -EINVAL if the parameters are invalid.
  • -ENOSPC if there is no space in the hash for this key.

◆ cne_hash_add_key()

int32_t cne_hash_add_key ( const struct cne_hash h,
const void *  key 
)

Add a key to an existing hash table. This operation is not multi-thread safe and should only be called from one thread by default. Thread safety can be enabled by setting flag during table creation.

Parameters
hHash table to add the key to.
keyKey to add to the hash table.
Returns
  • -EINVAL if the parameters are invalid.
  • -ENOSPC if there is no space in the hash for this key.
  • A positive value that can be used by the caller as an offset into an array of user data. This value is unique for this key. This unique key id may be larger than the user specified entry count when CNE_HASH_EXTRA_FLAGS_MULTI_WRITER_ADD flag is set.

◆ cne_hash_add_key_with_hash()

int32_t cne_hash_add_key_with_hash ( const struct cne_hash h,
const void *  key,
hash_sig_t  sig 
)

Add a key to an existing hash table. This operation is not multi-thread safe and should only be called from one thread by default. Thread safety can be enabled by setting flag during table creation.

Parameters
hHash table to add the key to.
keyKey to add to the hash table.
sigPrecomputed hash value for 'key'.
Returns
  • -EINVAL if the parameters are invalid.
  • -ENOSPC if there is no space in the hash for this key.
  • A positive value that can be used by the caller as an offset into an array of user data. This value is unique for this key. This unique key ID may be larger than the user specified entry count when CNE_HASH_EXTRA_FLAGS_MULTI_WRITER_ADD flag is set.

◆ cne_hash_del_key()

int32_t cne_hash_del_key ( const struct cne_hash h,
const void *  key 
)

Remove a key from an existing hash table. This operation is not multi-thread safe and should only be called from one thread by default. Thread safety can be enabled by setting flag during table creation. If CNE_HASH_EXTRA_FLAGS_NO_FREE_ON_DEL or CNE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF is enabled, the key index returned by cne_hash_add_key_xxx APIs will not be freed by this API. cne_hash_free_key_with_position API must be called additionally to free the index associated with the key. cne_hash_free_key_with_position API should be called after all the readers have stopped referencing the entry corresponding to this key. RCU mechanisms could be used to determine such a state.

Parameters
hHash table to remove the key from.
keyKey to remove from the hash table.
Returns
  • -EINVAL if the parameters are invalid.
  • -ENOENT if the key is not found.
  • A positive value that can be used by the caller as an offset into an array of user data. This value is unique for this key, and is the same value that was returned when the key was added.

◆ cne_hash_del_key_with_hash()

int32_t cne_hash_del_key_with_hash ( const struct cne_hash h,
const void *  key,
hash_sig_t  sig 
)

Remove a key from an existing hash table. This operation is not multi-thread safe and should only be called from one thread by default. Thread safety can be enabled by setting flag during table creation. If CNE_HASH_EXTRA_FLAGS_NO_FREE_ON_DEL or CNE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF is enabled, the key index returned by cne_hash_add_key_xxx APIs will not be freed by this API. cne_hash_free_key_with_position API must be called additionally to free the index associated with the key. cne_hash_free_key_with_position API should be called after all the readers have stopped referencing the entry corresponding to this key. RCU mechanisms could be used to determine such a state.

Parameters
hHash table to remove the key from.
keyKey to remove from the hash table.
sigPrecomputed hash value for 'key'.
Returns
  • -EINVAL if the parameters are invalid.
  • -ENOENT if the key is not found.
  • A positive value that can be used by the caller as an offset into an array of user data. This value is unique for this key, and is the same value that was returned when the key was added.

◆ cne_hash_get_key_with_position()

int cne_hash_get_key_with_position ( const struct cne_hash h,
const int32_t  position,
void **  key 
)

Find a key in the hash table given the position. This operation is multi-thread safe with regarding to other lookup threads. Read-write concurrency can be enabled by setting flag during table creation.

Parameters
hHash table to get the key from.
positionPosition returned when the key was inserted.
keyOutput containing a pointer to the key
Returns
  • 0 if retrieved successfully
  • -EINVAL if the parameters are invalid.
  • -ENOENT if no valid key is found in the given position.

◆ cne_hash_free_key_with_position()

int cne_hash_free_key_with_position ( const struct cne_hash h,
const int32_t  position 
)

Free a hash key in the hash table given the position of the key. This operation is not multi-thread safe and should only be called from one thread by default. Thread safety can be enabled by setting flag during table creation. If CNE_HASH_EXTRA_FLAGS_NO_FREE_ON_DEL or CNE_HASH_EXTRA_FLAGS_RW_CONCURRENCY_LF is enabled, the key index returned by cne_hash_del_key_xxx APIs must be freed using this API. This API should be called after all the readers have stopped referencing the entry corresponding to this key. RCU mechanisms could be used to determine such a state. This API does not validate if the key is already freed.

Parameters
hHash table to free the key from.
positionPosition returned when the key was deleted.
Returns
  • 0 if freed successfully
  • -EINVAL if the parameters are invalid.

◆ cne_hash_lookup_data()

int cne_hash_lookup_data ( const struct cne_hash h,
const void *  key,
void **  data 
)

Find a key-value pair in the hash table. This operation is multi-thread safe with regarding to other lookup threads. Read-write concurrency can be enabled by setting flag during table creation.

Parameters
hHash table to look in.
keyKey to find.
dataOutput with pointer to data returned from the hash table.
Returns
  • A positive value that can be used by the caller as an offset into an array of user data. This value is unique for this key, and is the same value that was returned when the key was added.
  • -EINVAL if the parameters are invalid.
  • -ENOENT if the key is not found.

◆ cne_hash_lookup_with_hash_data()

int cne_hash_lookup_with_hash_data ( const struct cne_hash h,
const void *  key,
hash_sig_t  sig,
void **  data 
)

Find a key-value pair with a pre-computed hash value to an existing hash table. This operation is multi-thread safe with regarding to other lookup threads. Read-write concurrency can be enabled by setting flag during table creation.

Parameters
hHash table to look in.
keyKey to find.
sigPrecomputed hash value for 'key'
dataOutput with pointer to data returned from the hash table.
Returns
  • A positive value that can be used by the caller as an offset into an array of user data. This value is unique for this key, and is the same value that was returned when the key was added.
  • -EINVAL if the parameters are invalid.
  • -ENOENT if the key is not found.

◆ cne_hash_lookup()

int32_t cne_hash_lookup ( const struct cne_hash h,
const void *  key 
)

Find a key in the hash table. This operation is multi-thread safe with regarding to other lookup threads. Read-write concurrency can be enabled by setting flag during table creation.

Parameters
hHash table to look in.
keyKey to find.
Returns
  • -EINVAL if the parameters are invalid.
  • -ENOENT if the key is not found.
  • A positive value that can be used by the caller as an offset into an array of user data. This value is unique for this key, and is the same value that was returned when the key was added.

◆ cne_hash_lookup_with_hash()

int32_t cne_hash_lookup_with_hash ( const struct cne_hash h,
const void *  key,
hash_sig_t  sig 
)

Find a key in the hash table. This operation is multi-thread safe with regarding to other lookup threads. Read-write concurrency can be enabled by setting flag during table creation.

Parameters
hHash table to look in.
keyKey to find.
sigPrecomputed hash value for 'key'.
Returns
  • -EINVAL if the parameters are invalid.
  • -ENOENT if the key is not found.
  • A positive value that can be used by the caller as an offset into an array of user data. This value is unique for this key, and is the same value that was returned when the key was added.

◆ cne_hash_hash()

hash_sig_t cne_hash_hash ( const struct cne_hash h,
const void *  key 
)

Calc a hash value by key. This operation is not multi-process safe.

Parameters
hHash table to look in.
keyKey to find.
Returns
  • hash value

◆ cne_hash_lookup_bulk_data()

int cne_hash_lookup_bulk_data ( const struct cne_hash h,
const void **  keys,
uint32_t  num_keys,
uint64_t *  hit_mask,
void *  data[] 
)

Find multiple keys in the hash table. This operation is multi-thread safe with regarding to other lookup threads. Read-write concurrency can be enabled by setting flag during table creation.

Parameters
hHash table to look in.
keysA pointer to a list of keys to look for.
num_keysHow many keys are in the keys list (less than CNE_HASH_LOOKUP_BULK_MAX).
hit_maskOutput containing a bitmask with all successful lookups.
dataOutput containing array of data returned from all the successful lookups.
Returns
-EINVAL if there's an error, otherwise number of successful lookups.

◆ cne_hash_lookup_with_hash_bulk()

int cne_hash_lookup_with_hash_bulk ( const struct cne_hash h,
const void **  keys,
hash_sig_t sig,
uint32_t  num_keys,
int32_t *  positions 
)

Find multiple keys in the hash table with precomputed hash value array. This operation is multi-thread safe with regarding to other lookup threads. Read-write concurrency can be enabled by setting flag during table creation.

Parameters
hHash table to look in.
keysA pointer to a list of keys to look for.
sigA pointer to a list of precomputed hash values for keys.
num_keysHow many keys are in the keys list (less than CNE_HASH_LOOKUP_BULK_MAX).
positionsOutput containing a list of values, corresponding to the list of keys that can be used by the caller as an offset into an array of user data. These values are unique for each key, and are the same values that were returned when each key was added. If a key in the list was not found, then -ENOENT will be the value.
Returns
-EINVAL if there's an error, otherwise 0.

◆ cne_hash_lookup_with_hash_bulk_data()

int cne_hash_lookup_with_hash_bulk_data ( const struct cne_hash h,
const void **  keys,
hash_sig_t sig,
uint32_t  num_keys,
uint64_t *  hit_mask,
void *  data[] 
)

Find multiple keys in the hash table with precomputed hash value array. This operation is multi-thread safe with regarding to other lookup threads. Read-write concurrency can be enabled by setting flag during table creation.

Parameters
hHash table to look in.
keysA pointer to a list of keys to look for.
sigA pointer to a list of precomputed hash values for keys.
num_keysHow many keys are in the keys list (less than CNE_HASH_LOOKUP_BULK_MAX).
hit_maskOutput containing a bitmask with all successful lookups.
dataOutput containing array of data returned from all the successful lookups.
Returns
-EINVAL if there's an error, otherwise number of successful lookups.

◆ cne_hash_lookup_bulk()

int cne_hash_lookup_bulk ( const struct cne_hash h,
const void **  keys,
uint32_t  num_keys,
int32_t *  positions 
)

Find multiple keys in the hash table. This operation is multi-thread safe with regarding to other lookup threads. Read-write concurrency can be enabled by setting flag during table creation.

Parameters
hHash table to look in.
keysA pointer to a list of keys to look for.
num_keysHow many keys are in the keys list (less than CNE_HASH_LOOKUP_BULK_MAX).
positionsOutput containing a list of values, corresponding to the list of keys that can be used by the caller as an offset into an array of user data. These values are unique for each key, and are the same values that were returned when each key was added. If a key in the list was not found, then -ENOENT will be the value.
Returns
-EINVAL if there's an error, otherwise 0.

◆ cne_hash_iterate()

int32_t cne_hash_iterate ( const struct cne_hash h,
const void **  key,
void **  data,
uint32_t *  next 
)

Iterate through the hash table, returning key-value pairs.

Parameters
hHash table to iterate
keyOutput containing the key where current iterator was pointing at
dataOutput containing the data associated with key. Returns NULL if data was not stored.
nextPointer to iterator. Should be 0 to start iterating the hash table. Iterator is incremented after each call of this function.
Returns
Position where key was stored, if successful.
  • -EINVAL if the parameters are invalid.
  • -ENOENT if end of the hash table.