HASH表实现

1.  概述

以邻接表管理（adjacency.c）为例，描述一种HASH表中的HASH桶、冲突链表等要素的管理方式。推荐以示例中的方式实现HASH表。
冲突链表采用linux_list.h中定义的hlist接口实现，相比list（参考双向循环链表），头节点仅有一个指针，也就节省了HASH桶的空间。
另外，桶的大小应定义为2的n次幂减1，这样在计算HASH值时，可以用与运算替代取模运算，避免除法提高效率。

2. 冲突链表管理

2.1. 位置

list.h

2.2. 数据结构

?

/*  * Double linked lists with a single pointer list head.  * Mostly useful for hash tables where the two pointer list head is  * too wasteful.  * You lose the ability to access the tail in O(1).  */    struct hlist_head {     struct hlist_node *first; };    struct hlist_node {     struct hlist_node *next, **pprev; };

 

2.3. 使用方法

1. 应用时，在链表的头节点数据结构中包含struct hlist_head成员；中间节点的数据结构中包含struct hlist_node成员；

2. 头节点的struct hlist_head成员应初始化（将first置为NULL）；

3. 在并行执行环境下使用时，需考虑对链表进行加锁保护；

4. 插入、删除、遍历等操作见下面的接口。

2.4. 接口

2.4.1. HLIST_HEAD

· 原型
     HLIST_HEAD(name)

· 功能
     定义链表头节点变量，并初始化

· 参数
     name：头节点变量名

2.4.2. INIT_HLIST_HEAD

· 原型
     INIT_HLIST_HEAD(ptr)

· 功能
     初始化链表头节点

· 参数
     ptr：头节点指针

2.4.3.  INIT_HLIST_NODE

· 原型
     void INIT_HLIST_NODE(struct hlist_node *h)

· 功能
     初始化中间节点（将next、pprev置NULL）

· 参数
     h：节点指针

2.4.4.  hlist_unhashed

· 原型
     int hlist_unhashed(const struct hlist_node *h)

· 功能
     节点是否没有加入到链表

· 参数
     h：节点指针

2.4.5. hlist_empty

· 原型
     int hlist_empty(const struct hlist_head *h)

· 功能
     链表是否为空

· 参数
     h：头节点指针

2.4.6. hlist_del

· 原型
     void hlist_del(struct hlist_node *n)

· 功能
     删除节点，并将节点的next、pprev置为非空的无效指针。

· 参数
     h：待删除节点的指针

2.4.7. hlist_del_init

· 原型
     void hlist_del_init(struct hlist_node *n)

· 功能
     删除节点，并将节点的next、pprev置为NULL。

· 参数
     h：待删除节点的指针

2.4.8.  hlist_add_head

· 原型
     void hlist_add_head(struct hlist_node *n, struct hlist_head *h)

· 功能
     将节点加入到链表的头部

· 参数
     n：节点的指针
     h：头节点的指针

2.4.9.  hlist_add_before

· 原型
     void hlist_add_before(struct hlist_node *n, struct hlist_node *next)

· 功能
     将新节点加入到当前节点之前

· 参数
     n：新节点
     next：当前节点

· 说明
     n、next不能为空

2.4.10. hlist_add_after

· 原型
     void hlist_add_after(struct hlist_node *n, struct hlist_node *next)

· 功能
     将新节点加入到当前节点之后

· 参数
     n：当前节点
     next：新节点

· 说明
     n、next不能为空

2.4.11. hlist_entry

· 原型
     hlist_entry(ptr, type, member)

· 功能
     获取包含该节点成员的数据结构的指针

· 参数
     ptr：struct hlist_node成员的指针
     type：struct hlist_node所在数据结构的类型
     member：struct hlist_node的成员名

2.4.12. hlist_for_each

· 原型
     hlist_for_each(pos, head)

· 功能
     遍历链表所有节点

· 参数
     pos：struct hlist_node成员的指针
     head：链表的头节点指针

· 说明
     需根据pos调用hlist_entry转换为struct hlist_node所在数据结构的指针后再使用；
     遍历完后，pos指向的是空。

2.4.13.  hlist_for_each_safe

· 原型
     hlist_for_each_safe(pos, n, head)

· 功能
     遍历链表所有节点，允许有节点删除的操作

· 参数
     pos：struct hlist_node成员的指针
     n：临时变量，struct hlist_node的指针
     head：链表的头节点指针

· 说明
     需根据pos调用hlist_entry转换为struct hlist_node所在数据结构的指针后再使用；
     遍历完后，pos指向的是空。

2.4.14.  hlist_for_each_entry

· 原型
     hlist_for_each_entry(tpos, pos, head, member)

· 功能
     遍历链表所有节点

· 参数
     tpos：struct hlist_node所在数据结构的指针
     pos：struct hlist_node成员的指针
     head：链表的头节点指针
     member：struct hlist_node的成员名

· 说明
     遍历完后，pos指向的是空。

2.4.15.  hlist_for_each_entry_continue

· 原型
     hlist_for_each_entry_continue(tpos, pos, member)

· 功能
     从当前节点之后遍历链表

· 参数
     tpos：struct hlist_node所在数据结构的指针
     pos：struct hlist_node成员的指针，当前节点
     member：struct hlist_node的成员名

· 说明
     遍历完后，pos指向的是空。

2.4.16. hlist_for_each_entry_from

· 原型
     hlist_for_each_entry_from(tpos, pos, member)

· 功能
     从当前节点开始遍历链表

· 参数
     tpos：struct hlist_node所在数据结构的指针,当前节点
     pos：struct hlist_node成员的指针，当前节点（也就是&tpos->member)
     member：struct hlist_node的成员名

· 说明
     遍历完后，pos指向的是空。

2.4.17. hlist_for_each_entry_safe

· 原型
     hlist_for_each_entry_safe(tpos, pos, n, head, member)

· 功能
     遍历链表所有节点，允许有节点删除的操作。

· 参数
     tpos：struct hlist_node所在数据结构的指针
     pos：struct hlist_node成员的指针
     n：临时变量，struct hlist_node成员的指针
     head：链表的头节点指针
     member：struct hlist_node的成员名

· 说明
     遍历完后，pos指向的是空。

3.  示例

HASH实现

/*
  注：本例重点是HASH表的实现，忽略了其他一些代码
*/
  
#include <stlc/linux_list.h>
  
#define ADJ_TBL_HASH_MASK 0x1FFFF /* 定义桶大小 */
  
/* 关键字 */
struct adj_key{
    u16 vrf_id;
    u16 l3_ifindex;
    u16 l2_ifindex;
    u16 pad1;
  
    union{
        u32   addr4;
        struct in6_addr   addr6;
    } nexthop;
};
  
/* 定义链表节点 */
struct adjacency
{
    struct hlist_node hlist;
    struct adj_key key;
};
  
/* HASH表 */
struct adjacency_table {
    struct hlist_head  *buckets;
    int mask;
    int cnt;
};
  
struct adjacency_table adj_tbl;
  
/* 计算HASH值 */
u32 adj_hash(struct adj_key *pkey)
{
    int i, *p32, hash_val;
  
    for (i = 0, p32=(int *)pkey, hash_val = 0; i < (sizeof(struct adj_key) / sizeof(int)); i++)
        hash_val ^= *p32++;
    return hash_val & ADJ_TBL_HASH_MASK;
}
  
/* 分配并初始化HASH桶 */
void adj_table_init()
{
    adj_tbl.buckets = malloc(sizeof(struct hlist_head) * (ADJ_TBL_HASH_MASK + 1));
    memset(adj_tbl.buckets, 0, sizeof(struct hlist_head) * (ADJ_TBL_HASH_MASK + 1));
    adj_tbl.mask = ADJ_TBL_HASH_MASK;
    adj_tbl.cnt = 0;
}
  
/* 根据关键字查找节点 */
struct adjacency *adj_lookup(struct adj_key *pkey)
{
    struct adjacency *e;
    struct hlist_node *node;
    u32 hash_val = adj_hash(pkey);
  
    adj_lock();
    hlist_for_each_entry(e, node, &adj_tbl.buckets[hash_val], hlist) {
        if (memcmp(pkey, &e->key, sizeof(struct adj_key)) == 0) {
            adj_unlock();
            return e;
        }
    }
    adj_unlock();
    return NULL;
}
  
/* 创建节点并加入HASH表 */
struct adjacency *adj_create(struct adj_key *pkey)
{
    struct adjacency *e;
    int ret;
  
    e = adj_alloc();
    if (e == NULL) {
        return NULL;
    }
  
    e->key = *pkey;
  
    adj_lock();
    hlist_add_head(&e->hlist, &adj_tbl.buckets[adj_hash(pkey)]);
    adj_tbl.cnt++;
    adj_unlock();
    return e;
}
  
/* 删除节点 */
void adj_destroy(struct adjacency *e)
{
    adj_lock();
    hlist_del(&e->hlist);
    adj_tbl.cnt--;
    adj_unlock();
}