Redis 数据结构之dict（2）

本文及后续文章，Redis版本均是v3.2.8

上篇文章《Redis 数据结构之dict》，我们对dict的结构有了大致的印象。此篇文章对dict是如何维护数据结构的做个详细的理解。

老规矩还是打开Redis的源码，文件dict.c

一、dict数据结构的维护

1、dictCreate - 创建一个新的哈希表

/* Reset a hash table already initialized with ht_init().

 * NOTE: This function should only be called by ht_destroy(). */

static void _dictReset(dictht *ht)

{

    ht->table = NULL;// hash table初始化

    ht->size = 0;

    ht->sizemask = 0;

    ht->used = 0;

}

 

/* Create a new hash table */

dict *dictCreate(dictType *type,

        void *privDataPtr)

{

    dict *d = zmalloc(sizeof(*d)); // 分配内存

 

    _dictInit(d,type,privDataPtr);// dict初始化

    return d;

}

 

/* Initialize the hash table */

int _dictInit(dict *d, dictType *type,

        void *privDataPtr)

{

    _dictReset(&d->ht[0]);

    _dictReset(&d->ht[1]);

    d->type = type;

    d->privdata = privDataPtr;

    d->rehashidx = -1;

    d->iterators = 0;

    return DICT_OK;

}

 

从上述的代码中，可以看出dictCreate为dict的数据结构分配空间并为各个变量赋初值。其中两个哈希表ht[0]和ht[1]起始都没有分配空间，table指针都赋为NULL。这就说明要等第一个数据插入时才会真正分配空间。

 

2、dictFind - dict查找

dictEntry *dictFind(dict *d, const void *key)

{

    dictEntry *he;

    unsigned int h, idx, table;

 

    if (d->ht[0].used + d->ht[1].used == 0) return NULL; /* dict is empty */

    if (dictIsRehashing(d)) _dictRehashStep(d);

    h = dictHashKey(d, key);

    for (table = 0; table <= 1; table++) {

        idx = h & d->ht[table].sizemask;

        he = d->ht[table].table[idx];

        while(he) {

            if (key==he->key || dictCompareKeys(d, key, he->key))

                return he;

            he = he->next;

        }

        if (!dictIsRehashing(d)) return NULL;

    }

    return NULL;

}

 

从上述的代码中，dictFind主要是根据dict是否正在重哈希，进行如下操作：

• 如果当前正在重哈希，那么就调用_dictRehashStep(d)【稍后在详细看下实现】。

• 调用dictHashKey，计算key的哈希值

• 两层for循环，其实就是上面定义的两个hash table。首先在在第一个哈希表h[0]上查找，在table数组上定位到哈希值所对应的位置（通过哈希值与sizemask进行按位与计算），然后在对应的dictEntry链表上查找。在遍历dictEntry链表时，需要对key进行比较即调用dictCompareKeys(d, key, he->key)，dictCompareKeys里面的实现会调用keyCompare。如果找到就返回该项。否则，进行下一步。

• 接下来判断是否正在重哈希，如果没有，那么在ht[0]上找的结果就是最终的结果（如果没有找到，就返回NULL）；否则，执行第二次遍历即在ht[1]上查找，过程如ht[0]一致。

 

3、dictAdd和dictReplace - dict插入

/* Add an element to the target hash table */

int dictAdd(dict *d, void *key, void *val)

{

    dictEntry *entry = dictAddRaw(d,key);

 

    if (!entry) return DICT_ERR;

    dictSetVal(d, entry, val);

    return DICT_OK;

}

 

/* Low level add. This function adds the entry but instead of setting

 * a value returns the dictEntry structure to the user, that will make

 * sure to fill the value field as he wishes.

 *

 * This function is also directly exposed to the user API to be called

 * mainly in order to store non-pointers inside the hash value, example:

 *

 * entry = dictAddRaw(dict,mykey);

 * if (entry != NULL) dictSetSignedIntegerVal(entry,1000);

 *

 * Return values:

 *

 * If key already exists NULL is returned.

 * If key was added, the hash entry is returned to be manipulated by the caller.

 */

dictEntry *dictAddRaw(dict *d, void *key)

{

    int index;

    dictEntry *entry;

    dictht *ht;

 

    if (dictIsRehashing(d)) _dictRehashStep(d);

 

    /* Get the index of the new element, or -1 if

     * the element already exists. */

    if ((index = _dictKeyIndex(d, key)) == -1)

        return NULL;

 

    /* Allocate the memory and store the new entry.

     * Insert the element in top, with the assumption that in a database

     * system it is more likely that recently added entries are accessed

     * more frequently. */

    ht = dictIsRehashing(d) ? &d->ht[1] : &d->ht[0];

    entry = zmalloc(sizeof(*entry));

    entry->next = ht->table[index];//将新元素添加到桶中链表的头节点

    ht->table[index] = entry;

    ht->used++;

 

    /* Set the hash entry fields. */

    dictSetKey(d, entry, key);

    return entry;

}

 

 

_dictKeyIndex

/* Returns the index of a free slot that can be populated with

 * a hash entry for the given 'key'.

 * If the key already exists, -1 is returned.

 *

 * Note that if we are in the process of rehashing the hash table, the

 * index is always returned in the context of the second (new) hash table. */

static int _dictKeyIndex(dict *d, const void *key)

{

    unsigned int h, idx, table;

    dictEntry *he;

 

    /* Expand the hash table if needed */

    if (_dictExpandIfNeeded(d) == DICT_ERR)

        return -1;

    /* Compute the key hash value */

    h = dictHashKey(d, key);

    for (table = 0; table <= 1; table++) {

        idx = h & d->ht[table].sizemask;

        /* Search if this slot does not already contain the given key */

        he = d->ht[table].table[idx];

        while(he) {

            if (key==he->key || dictCompareKeys(d, key, he->key))

                return -1;

            he = he->next;

        }

        if (!dictIsRehashing(d)) break;

    }

    return idx;

}

 

 

/* Add an element, discarding the old if the key already exists.

 * Return 1 if the key was added from scratch, 0 if there was already an

 * element with such key and dictReplace() just performed a value update

 * operation. */

int dictReplace(dict *d, void *key, void *val)

{

    dictEntry *entry, auxentry;

 

    /* Try to add the element. If the key

     * does not exists dictAdd will suceed. */

    if (dictAdd(d, key, val) == DICT_OK)

        return 1;

    /* It already exists, get the entry */

    entry = dictFind(d, key);

    /* Set the new value and free the old one. Note that it is important

     * to do that in this order, as the value may just be exactly the same

     * as the previous one. In this context, think to reference counting,

     * you want to increment (set), and then decrement (free), and not the

     * reverse. */

    auxentry = *entry;

    dictSetVal(d, entry, val);

    dictFreeVal(d, &auxentry);

    return 0;

}

 

dictAdd和dictReplace都有插入的功能，它们又有何区别：

• dictAdd插入新的一对key和value，如果key已经存在，则插入失败。

• dictReplace是在dictAdd的基础上实现的。dictReplace也是插入一对key和value，不过在key存在的时候，它会更新value。这其实相当于两次查找过程dictFind。

从dictAdd和dictReplace的代码的注释，我们大致了解函数的实现过程和原理：

• dictAdd和dictReplace也会调用_dictRehashStep(d)，触发推进一步重哈希

• 如果正在重哈希中，则会把数据插入到ht[1]，否则数据插入到ht[0]。

• 在对应bucket中插入数据的时候，数据总是插入dictEntry链表的头部，因为最近添加的数据更可能被访问的概率更频繁。

• dictKeyIndex，可能会存在哈希表的内存扩展。_dictExpandIfNeeded(d)，它将哈希表的长度扩展为原来的两倍。

• _dictKeyIndex，在dict查找元素插入的位置。从代码中，看到ht[0]、ht[1]的遍历，如果不在重哈希过程中，它只查找ht[0]；否则查找ht[0]和ht[1]。

 

4、dictDelete - dict删除

/* Search and remove an element */

static int dictGenericDelete(dict *d, const void *key, int nofree)

{

    unsigned int h, idx;

    dictEntry *he, *prevHe;

    int table;

 

    if (d->ht[0].size == 0) return DICT_ERR; /* d->ht[0].table is NULL */

    if (dictIsRehashing(d)) _dictRehashStep(d);

    h = dictHashKey(d, key);

 

    for (table = 0; table <= 1; table++) {

        idx = h & d->ht[table].sizemask;

        he = d->ht[table].table[idx];

        prevHe = NULL;

        while(he) {

            if (key==he->key || dictCompareKeys(d, key, he->key)) {

                /* Unlink the element from the list */

                if (prevHe)

                    prevHe->next = he->next;

                else

                    d->ht[table].table[idx] = he->next;

                if (!nofree) {

                    dictFreeKey(d, he);

                    dictFreeVal(d, he);

                }

                zfree(he);

                d->ht[table].used--;

                return DICT_OK;

            }

            prevHe = he;

            he = he->next;

        }

        if (!dictIsRehashing(d)) break;

    }

    return DICT_ERR; /* not found */

}

 

int dictDelete(dict *ht, const void *key) {

    return dictGenericDelete(ht,key,0);

}

 

int dictDeleteNoFree(dict *ht, const void *key) {

    return dictGenericDelete(ht,key,1);

}

 

从dictDelete代码中，可以看到

• dictDelete也会触发推进一步重哈希（_dictRehashStep）

• 如果当前不在重哈希过程中，它只在ht[0]中查找要删除的key；否则ht[0]和ht[1]它都要查找。

• 删除成功后会调用key和value的析构函数（keyDestructor和valDestructor）。

 

从dictCreate、dictFind、dictAdd\dictReplace、dictDelete代码中，看到这些函数中都有_dictRehashStep(d)函数的调用(将哈希推进一步)。此举的目的就将重哈希过程分散到各个查找、插入和删除操作中去了，而不是集中在某一个操作中一次性做完。

 

5、_dictRehashStep源码实现

/* This function performs just a step of rehashing, and only if there are

 * no safe iterators bound to our hash table. When we have iterators in the

 * middle of a rehashing we can't mess with the two hash tables otherwise

 * some element can be missed or duplicated.

 *

 * This function is called by common lookup or update operations in the

 * dictionary so that the hash table automatically migrates from H1 to H2

 * while it is actively used. */

static void _dictRehashStep(dict *d) {

    if (d->iterators == 0) dictRehash(d,1);

}

 

/* Performs N steps of incremental rehashing. Returns 1 if there are still

 * keys to move from the old to the new hash table, otherwise 0 is returned.

 *

 * Note that a rehashing step consists in moving a bucket (that may have more

 * than one key as we use chaining) from the old to the new hash table, however

 * since part of the hash table may be composed of empty spaces, it is not

 * guaranteed that this function will rehash even a single bucket, since it

 * will visit at max N*10 empty buckets in total, otherwise the amount of

 * work it does would be unbound and the function may block for a long time. */

int dictRehash(dict *d, int n) {

    int empty_visits = n*10; /* Max number of empty buckets to visit. */

    if (!dictIsRehashing(d)) return 0;

 

    while(n-- && d->ht[0].used != 0) {

        dictEntry *de, *nextde;

 

        /* Note that rehashidx can't overflow as we are sure there are more

         * elements because ht[0].used != 0 */

        assert(d->ht[0].size > (unsigned long)d->rehashidx);

        while(d->ht[0].table[d->rehashidx] == NULL) {//跳过数组中为空的桶

            d->rehashidx++;

            if (--empty_visits == 0) return 1;//如果访问空桶次数超过限制，则直接返回

        }

        de = d->ht[0].table[d->rehashidx];//ht[0]中正在rehash的桶元素的头节点

        /* Move all the keys in this bucket from the old to the new hash HT */

        while(de) {

            unsigned int h;

 

            nextde = de->next;

            /* Get the index in the new hash table */

            h = dictHashKey(d, de->key) & d->ht[1].sizemask;//计算ht[0]中元素进行rehash后在ht[1]中的索引

            de->next = d->ht[1].table[h];//并插入到链表的头部

            d->ht[1].table[h] = de;

            d->ht[0].used--;

            d->ht[1].used++;

            de = nextde;

        }

        d->ht[0].table[d->rehashidx] = NULL;

        d->rehashidx++;//该桶处理完成后，准备处理下一个桶    }

    }

 

    /* Check if we already rehashed the whole table... */

//ht[0]剩余元素个数为0，表明ht[0]中的元素已经全部rehash到ht[1]中，因此rehash过程已经完成

    if (d->ht[0].used == 0) {

        zfree(d->ht[0].table);//可以释放ht[0]，并将ht[1]赋给ht[0]后重置ht[1]

        d->ht[0] = d->ht[1];

        _dictReset(&d->ht[1]);

        d->rehashidx = -1;//表明rehash已经结束

        return 0;

    }

 

    /* More to rehash... */

    return 1;//否则还处于rehash过程中

}

 

 

_dictRehashStep，可以理解为增量式重哈希。

dictRehash每次将重哈希至少向前推进N步（除非不到N步整个重哈希就结束了），每一步都将ht[0]上某一个bucket（即一个dictEntry链表）上的每一个dictEntry移动到ht[1]上，它在ht[1]上的新位置根据ht[1]的sizemask进行重新计算。rehashidx记录了当前尚未迁移（有待迁移）的ht[0]的bucket位置。

如果dictRehash被调用的时候，rehashidx指向的bucket里一个dictEntry也没有，那么它就没有可迁移的数据。这时它尝试在ht[0].table数组中不断向后遍历，直到找到下一个存有数据的bucket位置。如果一直找不到，则最多走N*10步，本次重哈希暂告结束。

最后，如果ht[0]上的数据都迁移到ht[1]上了（即d->ht[0].used == 0），那么整个重哈希结束，ht[0]变成ht[1]的内容，而ht[1]重置为空。

对于重哈希过程的分析，正如上篇文章对dict结构图中所展示的正是rehashidx=2时的情况，前面两个bucket（ht[0].table[0]和ht[0].table[1]）都已经迁移到ht[1]上去了。

 

总结

Rehash操作分为扩展和收缩两种情况，

dict中有两个hash表，ht[0]和ht[1]。从代码中看出，dict的rehash并不是一次性完成的，而是分多次、渐进式的完成的。具体的说dict有两种不同的策略：

1、_dictRehashStep：所有的数据都是存在放dict的ht[0]中，ht[1]只在rehash的时候使用。dict进行rehash的时候，将ht[0]中的所有数据rehash到ht[1]中。

2、dictRehashMilliseconds：每次执行一段固定的时间，时间到了就暂停rehash操作。

为什么要Rehash？

1、从感性上说，随着HashTable中的数据增多，冲突的元素增多，ht[0]的链表增长，查找元素效率就越低，因此就需要Rehash。

2、从代码角度看，哈希表利用负载因子loadfactor = used/size来表明hash表当前的存储情况。当负载因子过大时操作的时间复杂度增大，负载因子过小时说明hash表的填充率很低，浪费内存。由于Redis中的数据都是存储在内存中的，因此我们必须尽量的节省内存。因此我们必须将loadfactor控制在一定的范围内，同时保证操作的时间复杂度接近O(1)和内存尽量被占用。

 

-EOF-