Redis源码（五）——整数集合

一、整数集合（intset）的定义与实现

 

 整数集合是Redis中集合的底层实现之一，当集合只包含整数且集合的元素数目不大是，Redis是使用整数集合作为集合的底层实现的。

整数集合的实现在src的intset.h和intset.c中：

typedef struct intset {
   
    // 编码方式
   uint32_t encoding;
 
    // 集合包含的元素数量
   uint32_t length;
 
    // 保存元素的数组
    int8_tcontents[];
 
} intset;

其中encoding属性表示编码方式；contents数组用来保存元素，各个元素在contents数组中按值的从小到大排列，而且不会有重复值，虽然contents数组被声明为int8_t，但是contents数组真正类型是右encoding来决定的，intset.c中定义了三种编码：

#define INTSET_ENC_INT16 (sizeof(int16_t))
#define INTSET_ENC_INT32 (sizeof(int32_t))
#define INTSET_ENC_INT64 (sizeof(int64_t))

length属性保存 contents数组中的元素数目。

 

二、整数集合中的重要逻辑

 

    1. 添加元素时的升级逻辑

    我们在将元素（整数）加入集合时，一般是不需要考虑放入的整数的类型的，原因是因为整数集合中做了升级（upgrade）逻辑：当加入元素到整数集合时，如果新元素的类型比现有的类型要大时，整数集合会进行升级，升级的步骤如下：

1）根据新元素类型更新编码方式

2）根据新编码对整数集合底层数组进行空间调整

3）将新元素加入底层数组中，这个过程会升级原本元素的类型

具体代码如下：

/* Upgrades the intset to a larger encoding andinserts the given integer.
 *
 * 根据值 value 所使用的编码方式，对整数集合的编码进行升级，
 * 并将值 value 添加到升级后的整数集合中。
 *
 * 返回值：添加新元素之后的整数集合
 *
 * T = O(N)
 */
static intset *intsetUpgradeAndAdd(intset *is,int64_t value) {
   
    // 当前的编码方式
    uint8_tcurenc = intrev32ifbe(is->encoding);
 
    // 新值所需的编码方式
    uint8_tnewenc = _intsetValueEncoding(value);
 
    // 当前集合的元素数量
    intlength = intrev32ifbe(is->length);
 
    // 根据 value 的值，决定是将它添加到底层数组的最前端还是最后端
    // 注意，因为 value 的编码比集合原有的其他元素的编码都要大
    // 所以 value 要么大于集合中的所有元素，要么小于集合中的所有元素
    // 因此，value 只能添加到底层数组的最前端或最后端
    intprepend = value < 0 ? 1 : 0;
 
    /*First set new encoding and resize */
    // 更新集合的编码方式
   is->encoding = intrev32ifbe(newenc);
    // 根据新编码对集合（的底层数组）进行空间调整
    // T =O(N)
    is =intsetResize(is,intrev32ifbe(is->length)+1);
 
    /*Upgrade back-to-front so we don't overwrite values.
     * Notethat the "prepend" variable is used to make sure we have an empty
     *space at either the beginning or the end of the intset. */
    // 根据集合原来的编码方式，从底层数组中取出集合元素
    // 然后再将元素以新编码的方式添加到集合中
    // 当完成了这个步骤之后，集合中所有原有的元素就完成了从旧编码到新编码的转换
    // 因为新分配的空间都放在数组的后端，所以程序先从后端向前端移动元素
    // 举个例子，假设原来有 curenc 编码的三个元素，它们在数组中排列如下：
    // | x| y | z |
    // 当程序对数组进行重分配之后，数组就被扩容了（符号 ？ 表示未使用的内存）：
    // | x| y | z | ? |   ?   |  ?   |
    // 这时程序从数组后端开始，重新插入元素：
    // | x| y | z | ? |   z   |  ?   |
    // | x| y |   y   |  z   |   ?   |
    //|   x  |   y   |  z   |   ?   |
    // 最后，程序可以将新元素添加到最后 ？ 号标示的位置中：
    //|   x  |   y   |  z   |  new  |
    // 上面演示的是新元素比原来的所有元素都大的情况，也即是 prepend == 0
    // 当新元素比原来的所有元素都小时（prepend == 1），调整的过程如下：
    // | x| y | z | ? |   ?   |  ?   |
    // | x| y | z | ? |   ?   |  z   |
    // | x| y | z | ? |   y   |  z   |
    // | x| y |   x   |  y   |   z   |
    // 当添加新值时，原本的 | x | y | 的数据将被新值代替
    //|  new |   x   |  y   |   z   |
    // T =O(N)
   while(length--)
       _intsetSet(is,length+prepend,_intsetGetEncoded(is,length,curenc));
 
    /* Setthe value at the beginning or the end. */
    // 设置新值，根据 prepend 的值来决定是添加到数组头还是数组尾
    if(prepend)
       _intsetSet(is,0,value);
    else
       _intsetSet(is,intrev32ifbe(is->length),value);
 
    // 更新整数集合的元素数量
   is->length = intrev32ifbe(intrev32ifbe(is->length)+1);
 
    returnis;
}

向整数集合中添加元素的整体逻辑如下：

/* Insert an integer in the intset
 *
 * 尝试将元素 value 添加到整数集合中。
 *
 * *success 的值指示添加是否成功：
 * - 如果添加成功，那么将 *success 的值设为 1 。
 * - 因为元素已存在而造成添加失败时，将 *success 的值设为 0 。
 *
 * T = O(N)
 */
intset *intsetAdd(intset *is, int64_t value, uint8_t *success) {
 
    // 计算编码 value 所需的长度
    uint8_t valenc =_intsetValueEncoding(value);
    uint32_t pos;
 
    // 默认设置插入为成功
    if (success) *success = 1;
 
    /* Upgrade encoding ifnecessary. If we need to upgrade, we know that
     * this value should be eitherappended (if > 0) or prepended (if < 0),
     * because it lies outside therange of existing values. */
    // 如果 value 的编码比整数集合现在的编码要大
    // 那么表示 value 必然可以添加到整数集合中
    // 并且整数集合需要对自身进行升级，才能满足 value 所需的编码
    if (valenc >intrev32ifbe(is->encoding)) {
        /* This always succeeds, sowe don't need to curry *success. */
        // T = O(N)
        returnintsetUpgradeAndAdd(is,value);
    } else {
        // 运行到这里，表示整数集合现有的编码方式适用于 value
 
        /* Abort if the value isalready present in the set.
         * This call will populate"pos" with the right position to insert
         * the value when it cannotbe found. */
        // 在整数集合中查找 value ，看他是否存在：
        // - 如果存在，那么将 *success 设置为 0 ，并返回未经改动的整数集合
        // - 如果不存在，那么可以插入 value 的位置将被保存到 pos 指针中
        //   等待后续程序使用
        if(intsetSearch(is,value,&pos)) {
            if (success) *success =0;
            return is;
        }
 
        // 运行到这里，表示 value 不存在于集合中
        // 程序需要将 value 添加到整数集合中
   
        // 为 value 在集合中分配空间
        is =intsetResize(is,intrev32ifbe(is->length)+1);
        // 如果新元素不是被添加到底层数组的末尾
        // 那么需要对现有元素的数据进行移动，空出 pos 上的位置，用于设置新值
        // 举个例子
        // 如果数组为：
        // | x | y | z | ? |
        //     |<----->|
        // 而新元素 n 的 pos 为 1 ，那么数组将移动 y 和 z 两个元素
        // | x | y | y | z |
        //         |<----->|
        // 这样就可以将新元素设置到 pos 上了：
        // | x | n | y | z |
        // T = O(N)
        if (pos <intrev32ifbe(is->length)) intsetMoveTail(is,pos,pos+1);
    }
 
    // 将新值设置到底层数组的指定位置中
    _intsetSet(is,pos,value);
 
    // 增一集合元素数量的计数器
    is->length =intrev32ifbe(intrev32ifbe(is->length)+1);
 
    // 返回添加新元素后的整数集合
    return is;
 
    /* p.s. 上面的代码可以重构成以下更简单的形式：
   
    if (valenc >intrev32ifbe(is->encoding)) {
        returnintsetUpgradeAndAdd(is,value);
    }
    
    if(intsetSearch(is,value,&pos)) {
        if (success) *success = 0;
        return is;
    } else {
        is =intsetResize(is,intrev32ifbe(is->length)+1);
        if (pos <intrev32ifbe(is->length)) intsetMoveTail(is,pos,pos+1);
        _intsetSet(is,pos,value);
 
        is->length =intrev32ifbe(intrev32ifbe(is->length)+1);
        return is;
    }
    */
}

升级逻辑的好处显而易见：首先是提高了灵活性，我们可以不关心底层数组中具体的类型，从而可以防止类型转化的错误；第二从某种角度来说是节约了内存的，因为最简单解决类型的问题就是讲底层数组类型定义为int64_t，而如果存放的都是int8_t的数就会浪费内存，升级的逻辑比较好地协调了这一点。

需要注意的是一旦升级，编码会一直保持升级后状态，不存在所谓的“降级”。

 

    2. 查找元素

 

    整数集合中查找元素使用了二分查找：

/* Search for the position of "value".
 *
 * 在集合 is 的底层数组中查找值 value 所在的索引。
 *
 * Return 1 when the value wasfound and
 * sets "pos" to theposition of the value within the intset.
 *
 * 成功找到 value 时，函数返回 1 ，并将 *pos 的值设为 value 所在的索引。
 *
 * Return 0 when the value is notpresent in the intset
 * and sets "pos" to theposition where "value" can be inserted.
 *
 * 当在数组中没找到 value 时，返回 0 。
 * 并将 *pos 的值设为 value 可以插入到数组中的位置。
 *
 * T = O(log N)
 */
static uint8_t intsetSearch(intset *is, int64_t value, uint32_t *pos) {
    int min = 0, max =intrev32ifbe(is->length)-1, mid = -1;
    int64_t cur = -1;
 
    /* The value can never be foundwhen the set is empty */
    // 处理 is 为空时的情况
    if (intrev32ifbe(is->length)== 0) {
        if (pos) *pos = 0;
        return 0;
    } else {
        /* Check for the case wherewe know we cannot find the value,
         * but do know the insertposition. */
        // 因为底层数组是有序的，如果 value 比数组中最后一个值都要大
        // 那么 value 肯定不存在于集合中，
        // 并且应该将 value 添加到底层数组的最末端
        if (value >_intsetGet(is,intrev32ifbe(is->length)-1)) {
            if (pos) *pos =intrev32ifbe(is->length);
            return 0;
        // 因为底层数组是有序的，如果 value 比数组中最前一个值都要小
        // 那么 value 肯定不存在于集合中，
        // 并且应该将它添加到底层数组的最前端
        } else if (value <_intsetGet(is,0)) {
            if (pos) *pos = 0;
            return 0;
        }
    }
 
    // 在有序数组中进行二分查找
    // T = O(log N)
    while(max >= min) {
        mid = (min+max)/2;
        cur = _intsetGet(is,mid);
        if (value > cur) {
            min = mid+1;
        } else if (value < cur){
            max = mid-1;
        } else {
            break;
        }
    }
 
    // 检查是否已经找到了 value
    if (value == cur) {
        if (pos) *pos = mid;
        return 1;
    } else {
        if (pos) *pos = min;
        return 0;
    }
}