rte_fbk_hash.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright(c) 2010-2014 Intel Corporation
 */
 
#ifndef _RTE_FBK_HASH_H_
#define _RTE_FBK_HASH_H_

 
#include <stdint.h>
#include <errno.h>
 
#include <string.h>
 
#include <rte_common.h>
#include <rte_hash_crc.h>
#include <rte_jhash.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#ifndef RTE_FBK_HASH_INIT_VAL_DEFAULT
#define RTE_FBK_HASH_INIT_VAL_DEFAULT       0xFFFFFFFF
#endif

#define RTE_FBK_HASH_ENTRIES_MAX        (1 << 20)

#define RTE_FBK_HASH_ENTRIES_PER_BUCKET_MAX 256

#define RTE_FBK_HASH_NAMESIZE           32

typedef uint32_t (*rte_fbk_hash_fn)(uint32_t key, uint32_t init_val);

struct rte_fbk_hash_params {
    const char *name;       
    uint32_t entries;       
    uint32_t entries_per_bucket;    
    int socket_id;          
    rte_fbk_hash_fn hash_func;  
    uint32_t init_val;      
};

union rte_fbk_hash_entry {
    uint64_t whole_entry;       
    struct {
        uint16_t is_entry;  
        uint16_t value;     
        uint32_t key;       
    } entry;            
};
 

struct rte_fbk_hash_table {
    char name[RTE_FBK_HASH_NAMESIZE];   
    uint32_t entries;       
    uint32_t entries_per_bucket;    
    uint32_t used_entries;      
    uint32_t bucket_mask;       
    uint32_t bucket_shift;      
    rte_fbk_hash_fn hash_func;  
    uint32_t init_val;      

    union rte_fbk_hash_entry t[];
};

static inline uint32_t
rte_fbk_hash_get_bucket(const struct rte_fbk_hash_table *ht, uint32_t key)
{
    return (ht->hash_func(key, ht->init_val) & ht->bucket_mask) <<
            ht->bucket_shift;
}

static inline int
rte_fbk_hash_add_key_with_bucket(struct rte_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
rte_fbk_hash_add_key(struct rte_fbk_hash_table *ht,
            uint32_t key, uint16_t value)
{
    return rte_fbk_hash_add_key_with_bucket(ht,
                key, value, rte_fbk_hash_get_bucket(ht, key));
}

static inline int
rte_fbk_hash_delete_key_with_bucket(struct rte_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
rte_fbk_hash_delete_key(struct rte_fbk_hash_table *ht, uint32_t key)
{
    return rte_fbk_hash_delete_key_with_bucket(ht,
                key, rte_fbk_hash_get_bucket(ht, key));
}

static inline int
rte_fbk_hash_lookup_with_bucket(const struct rte_fbk_hash_table *ht,
                uint32_t key, uint32_t bucket)
{
    union rte_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
rte_fbk_hash_lookup(const struct rte_fbk_hash_table *ht, uint32_t key)
{
    return rte_fbk_hash_lookup_with_bucket(ht,
                key, rte_fbk_hash_get_bucket(ht, key));
}

static inline void
rte_fbk_hash_clear_all(struct rte_fbk_hash_table *ht)
{
    memset(ht->t, 0, sizeof(ht->t[0]) * ht->entries);
    ht->used_entries = 0;
}

static inline double
rte_fbk_hash_get_load_factor(struct rte_fbk_hash_table *ht)
{
    return (double)ht->used_entries / (double)ht->entries;
}

struct rte_fbk_hash_table *rte_fbk_hash_find_existing(const char *name);

void rte_fbk_hash_free(struct rte_fbk_hash_table *ht);

struct rte_fbk_hash_table *
rte_fbk_hash_create(const struct rte_fbk_hash_params *params)
    __rte_malloc __rte_dealloc(rte_fbk_hash_free, 1);
 
#ifdef __cplusplus
}
#endif
 
#endif /* _RTE_FBK_HASH_H_ */