cne_fbk_hash.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright (c) 2010-2022 Intel Corporation
 */
 
#ifndef _CNE_FBK_HASH_H_
#define _CNE_FBK_HASH_H_
 
#include <stdint.h>        // for uint32_t, uint16_t, uint64_t
#include <errno.h>         // for ENOENT, ENOSPC
#include <sys/queue.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <string.h>        // for memset
#include <cne_hash_crc.h>
#include <cne_jhash.h>
 
#ifndef CNE_FBK_HASH_INIT_VAL_DEFAULT
#define CNE_FBK_HASH_INIT_VAL_DEFAULT 0xFFFFFFFF
#endif
 
#define CNE_FBK_HASH_ENTRIES_MAX (1 << 20)
 
#define CNE_FBK_HASH_ENTRIES_PER_BUCKET_MAX 256
 
#define CNE_FBK_HASH_NAMESIZE 32
 
typedef uint32_t (*cne_fbk_hash_fn)(uint32_t key, uint32_t init_val);
 
struct cne_fbk_hash_params {
    const char *name;            
    uint32_t entries;            
    uint32_t entries_per_bucket; 
    int socket_id;               
    cne_fbk_hash_fn hash_func;   
    uint32_t init_val;           
};
 
union cne_fbk_hash_entry {
    uint64_t whole_entry; 
    struct {
        uint16_t is_entry; 
        uint16_t value;    
        uint32_t key;      
    } entry;               
};
 
struct cne_fbk_hash_table {
    char name[CNE_FBK_HASH_NAMESIZE]; 
    uint32_t entries;                 
    uint32_t entries_per_bucket;      
    uint32_t used_entries;            
    uint32_t bucket_mask;             
    uint32_t bucket_shift;            
    cne_fbk_hash_fn hash_func;        
    uint32_t init_val;                
    union cne_fbk_hash_entry t[];
};
 
static inline uint32_t
cne_fbk_hash_get_bucket(const struct cne_fbk_hash_table *ht, uint32_t key)
{
    return (ht->hash_func(key, ht->init_val) & ht->bucket_mask) << ht->bucket_shift;
}
 
static inline int
cne_fbk_hash_add_key_with_bucket(struct cne_fbk_hash_table *ht, uint32_t key, uint16_t value,
                                 uint32_t bucket)
{
    /*
     * The writing of a new value to the hash table is done as a single
     * 64bit operation. This should help prevent individual entries being
     * corrupted due to race conditions, but it's still possible to
     * overwrite entries that have just been made valid.
     */
    const uint64_t new_entry =
        ((uint64_t)(key) << 32) | ((uint64_t)(value) << 16) | 1; /* 1 = is_entry bit. */
    uint32_t i;
 
    for (i = 0; i < ht->entries_per_bucket; i++) {
        /* Set entry if unused. */
        if (!ht->t[bucket + i].entry.is_entry) {
            ht->t[bucket + i].whole_entry = new_entry;
            ht->used_entries++;
            return 0;
        }
        /* Change value if key already exists. */
        if (ht->t[bucket + i].entry.key == key) {
            ht->t[bucket + i].entry.value = value;
            return 0;
        }
    }
 
    return -ENOSPC; /* No space in bucket. */
}
 
static inline int
cne_fbk_hash_add_key(struct cne_fbk_hash_table *ht, uint32_t key, uint16_t value)
{
    return cne_fbk_hash_add_key_with_bucket(ht, key, value, cne_fbk_hash_get_bucket(ht, key));
}
 
static inline int
cne_fbk_hash_delete_key_with_bucket(struct cne_fbk_hash_table *ht, uint32_t key, uint32_t bucket)
{
    uint32_t last_entry = ht->entries_per_bucket - 1;
    uint32_t i, j;
 
    for (i = 0; i < ht->entries_per_bucket; i++) {
        if (ht->t[bucket + i].entry.key == key) {
            /* Find last key in bucket. */
            for (j = ht->entries_per_bucket - 1; j > i; j--) {
                if (!ht->t[bucket + j].entry.is_entry) {
                    last_entry = j - 1;
                }
            }
            /*
             * Move the last key to the deleted key's position, and
             * delete the last key. lastEntry and i may be same but
             * it doesn't matter.
             */
            ht->t[bucket + i].whole_entry          = ht->t[bucket + last_entry].whole_entry;
            ht->t[bucket + last_entry].whole_entry = 0;
 
            ht->used_entries--;
            return 0;
        }
    }
 
    return -ENOENT; /* Key didn't exist. */
}
 
static inline int
cne_fbk_hash_delete_key(struct cne_fbk_hash_table *ht, uint32_t key)
{
    return cne_fbk_hash_delete_key_with_bucket(ht, key, cne_fbk_hash_get_bucket(ht, key));
}
 
static inline int
cne_fbk_hash_lookup_with_bucket(const struct cne_fbk_hash_table *ht, uint32_t key, uint32_t bucket)
{
    union cne_fbk_hash_entry current_entry;
    uint32_t i;
 
    for (i = 0; i < ht->entries_per_bucket; i++) {
        /* Single read of entry, which should be atomic. */
        current_entry.whole_entry = ht->t[bucket + i].whole_entry;
        if (!current_entry.entry.is_entry) {
            return -ENOENT; /* Error once we hit an empty field. */
        }
        if (current_entry.entry.key == key) {
            return current_entry.entry.value;
        }
    }
    return -ENOENT; /* Key didn't exist. */
}
 
static inline int
cne_fbk_hash_lookup(const struct cne_fbk_hash_table *ht, uint32_t key)
{
    return cne_fbk_hash_lookup_with_bucket(ht, key, cne_fbk_hash_get_bucket(ht, key));
}
 
static inline void
cne_fbk_hash_clear_all(struct cne_fbk_hash_table *ht)
{
    memset(ht->t, 0, sizeof(ht->t[0]) * ht->entries);
    ht->used_entries = 0;
}
 
static inline double
cne_fbk_hash_get_load_factor(struct cne_fbk_hash_table *ht)
{
    return (double)ht->used_entries / (double)ht->entries;
}
 
struct cne_fbk_hash_table *cne_fbk_hash_find_existing(const char *name);
 
struct cne_fbk_hash_table *cne_fbk_hash_create(const struct cne_fbk_hash_params *params);
 
void cne_fbk_hash_free(struct cne_fbk_hash_table *ht);
 
#ifdef __cplusplus
}
#endif
 
#endif /* _CNE_FBK_HASH_H_ */