rte_cuckoo_hash.h

/* SPDX-License-Identifier: BSD-3-Clause
 * Copyright(c) 2016 Intel Corporation
 * Copyright(c) 2018 Arm Limited
 */
 
/* rte_cuckoo_hash.h
 * This file hold Cuckoo Hash private data structures to allows include from
 * platform specific files like rte_cuckoo_hash_x86.h
 */
 
#ifndef _RTE_CUCKOO_HASH_H_
#define _RTE_CUCKOO_HASH_H_
 
#include <stdalign.h>
#include <rte_hash_crc.h>
#include <rte_jhash.h>
 
#define RTE_HASH_BUCKET_ENTRIES     8
 
static_assert(RTE_IS_POWER_OF_2(RTE_HASH_BUCKET_ENTRIES),
          "RTE_HASH_BUCKET_ENTRIES must be a power of 2");
 
#define NULL_SIGNATURE          0
 
#define EMPTY_SLOT          0
 
#define KEY_ALIGNMENT           16
 
#define LCORE_CACHE_SIZE        64
 
#define RTE_HASH_BFS_QUEUE_MAX_LEN       1000
 
#define RTE_XABORT_CUCKOO_PATH_INVALIDED 0x4
 
#define RTE_HASH_TSX_MAX_RETRY  10
 
struct __rte_cache_aligned lcore_cache {
    unsigned len; 
    uint32_t objs[LCORE_CACHE_SIZE]; 
};
 
/* Structure that stores key-value pair */
struct rte_hash_key {
    union {
        uintptr_t idata;
        RTE_ATOMIC(void *) pdata;
    };
    /* Variable key size */
    char key[];
};
 
struct __rte_cache_aligned rte_hash_bucket {
    uint16_t sig_current[RTE_HASH_BUCKET_ENTRIES];
 
    RTE_ATOMIC(uint32_t) key_idx[RTE_HASH_BUCKET_ENTRIES];
 
    uint8_t flag[RTE_HASH_BUCKET_ENTRIES];
 
    void *next;
};
 
struct __rte_cache_aligned rte_hash {
    char name[RTE_HASH_NAMESIZE];   
    uint32_t entries;               
    uint32_t num_buckets;           
    struct rte_ring *free_slots;
    struct lcore_cache *local_free_slots;
    /* RCU config */
    struct rte_hash_rcu_config *hash_rcu_cfg;
    struct rte_rcu_qsbr_dq *dq; 
    /* Fields used in lookup */
 
    alignas(RTE_CACHE_LINE_SIZE) uint32_t key_len;
    uint8_t hw_trans_mem_support;
    uint8_t use_local_cache;
    uint8_t readwrite_concur_support;
    uint8_t ext_table_support;     
    uint8_t no_free_on_del;
    uint8_t readwrite_concur_lf_support;
    uint8_t writer_takes_lock;
    rte_hash_function hash_func;    
    uint32_t hash_func_init_val;    
    rte_hash_cmp_eq_t rte_hash_custom_cmp_eq;
    unsigned int cmp_jump_table_idx;
    unsigned int sig_cmp_fn;
    uint32_t bucket_bitmask;
    uint32_t key_entry_size;         
    void *key_store;                
    struct rte_hash_bucket *buckets;
    rte_rwlock_t *readwrite_lock; 
    struct rte_hash_bucket *buckets_ext; 
    struct rte_ring *free_ext_bkts; 
    /* Stores index of an empty ext bkt to be recycled on calling
     * rte_hash_del_xxx APIs. When lock free read-write concurrency is
     * enabled, an empty ext bkt cannot be put into free list immediately
     * (as readers might be using it still). Hence freeing of the ext bkt
     * is piggy-backed to freeing of the key index.
     */
    uint32_t *ext_bkt_to_free;
    RTE_ATOMIC(uint32_t) *tbl_chng_cnt;
};
 
struct queue_node {
    struct rte_hash_bucket *bkt; /* Current bucket on the bfs search */
    uint32_t cur_bkt_idx;
 
    struct queue_node *prev;     /* Parent(bucket) in search path */
    int prev_slot;               /* Parent(slot) in search path */
};
 
#define RTE_HASH_RCU_DQ_RECLAIM_MAX 16
 
#endif