Redis源码分析（六）——整数集合（Intset）

前面分析了Redis的几个内部数据结构，包括简单动态字符串、双端链表、字典以及跳跃表。这些数据结构。这些数据结构都非常强大，也正因为如此，创建一个完整的数据结构本身也是一件耗费内存的工作，当一个对象包含的元素不多或者元素本身的体积不大时，使用代价高昂的内部数据结构并不是最好的办法。  因此，在Reids的内部，在适当条件下会使用内存映射数据结构来代替内部数据结构。 Redis使用的内存映射数据结构主要包括 整数集合（Intset）和压缩列表（ziplist）。   

（注：在Redis的分析过程中，主要参考了《Redis设计与实现》（黄健宏）一书，分析笔记中也有一些直接引用的内容，感谢作者！ 以后不再一一注明了。）

本文主要分析整数集合。Intset用于有序、无重复地保存多个整数值（这与STL的set容器是一致的），并自动选择该用什么长度的整数类型累保存元素，元素类型将取决于其中绝对值最大的一个元素，因此在向集合中添加新要素时可能需要对集合的类型进行升级。 这就有可能，整个集合仅仅因为最大的这一个元素而触发类型升级，从而导致内存空间的浪费，并且Redis没有实现降级处理方法。     实际上，由于在集合中存入的元素个数较少（目前实现为最多存放512个元素）并且intset集合中的数据不会长时间保存，因此占用的内存空间是不会很大的。

以下将对intset的主要API函数进行分析，具体见注释。

intset.h :

//intset:一个只保存整数的集合set（元素从小到达有序存放，且无重复），保存的元素不多
typedef struct intset {
    uint32_t encoding;//保存元素所使用的类型长度
    uint32_t length;//元素个数
    int8_t contents[];//保存元素的数组 注意与int8_t* contents;的区别
} intset;

intset *intsetNew(void);//创建intset
intset *intsetAdd(intset *is, int64_t value, uint8_t *success);//添加新元素
intset *intsetRemove(intset *is, int64_t value, int *success);//删除元素
uint8_t intsetFind(intset *is, int64_t value);//查找给定元素，返回索引
int64_t intsetRandom(intset *is);//随机获取一个元素
uint8_t intsetGet(intset *is, uint32_t pos, int64_t *value);//按索引查找元素
uint32_t intsetLen(intset *is);//获取intset元素个数
size_t intsetBlobLen(intset *is);//获取集合总的空间大小

小知识：

int a[ ] 与int*a 的区别：两个a都是一个整型的指针，其中前者a指向一个数组空间的首地址，为一个指针常量，即a指向的地址是不变的，不能进行类似++a的操作，可通过a[i]来获取数组中首元素以外的其他值; 而后者a为一个整型指针，可进行类似++a改变指向地址的操作。

在作为参数时，两者是一样的，都表示需要一个整型指针，只是前者能表明期望传递一个数组指针，而后仅仅是一个整型指针。

inset.c:

/* Return the required encoding for the provided value. */
//对给定的整数value计算其需要的类型长度
static uint8_t _intsetValueEncoding(int64_t v) {
    if (v < INT32_MIN || v > INT32_MAX)
        return INTSET_ENC_INT64;
    else if (v < INT16_MIN || v > INT16_MAX)
        return INTSET_ENC_INT32;
    else
        return INTSET_ENC_INT16;
}

/* Return the value at pos, given an encoding. */
//按给定的类型长度，返回指定索引位置的元素值（按给定类型长度进行指针运算）
static int64_t _intsetGetEncoded(intset *is, int pos, uint8_t enc) {
    int64_t v64;
    int32_t v32;
    int16_t v16;

    if (enc == INTSET_ENC_INT64) {
        memcpy(&v64,((int64_t*)is->contents)+pos,sizeof(v64));
        memrev64ifbe(&v64);
        return v64;
    } else if (enc == INTSET_ENC_INT32) {
        memcpy(&v32,((int32_t*)is->contents)+pos,sizeof(v32));
        memrev32ifbe(&v32);
        return v32;
    } else {
        memcpy(&v16,((int16_t*)is->contents)+pos,sizeof(v16));
        memrev16ifbe(&v16);
        return v16;
    }
}

/* Return the value at pos, using the configured encoding. */
//按intset配置的类型长度，返回指定索引位置的元素值（按类型长度进行指针运算）
static int64_t _intsetGet(intset *is, int pos) {
    return _intsetGetEncoded(is,pos,intrev32ifbe(is->encoding));
}

/* Set the value at pos, using the configured encoding. */
//将索引pos位置上的值设为value（下标运算）
static void _intsetSet(intset *is, int pos, int64_t value) {
    uint32_t encoding = intrev32ifbe(is->encoding);

    if (encoding == INTSET_ENC_INT64) {
        ((int64_t*)is->contents)[pos] = value;
        memrev64ifbe(((int64_t*)is->contents)+pos);
    } else if (encoding == INTSET_ENC_INT32) {
        ((int32_t*)is->contents)[pos] = (int32_t)value;
        memrev32ifbe(((int32_t*)is->contents)+pos);
    } else {
        ((int16_t*)is->contents)[pos] = (int16_t)value;
        memrev16ifbe(((int16_t*)is->contents)+pos);
    }
}

//在给定intset中二分查找给定的value，如果找到将其索引存入pos并返回1，如果不存在该元素，则返回0并在pos中存入该元素应该插入的位置索引
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 found when the set is empty */
    if (intrev32ifbe(is->length) == 0) {
        if (pos) *pos = 0;
        return 0;
    } else {
        /* Check for the case where we know we cannot find the value,
         * but do know the insert position. */
        if (value > _intsetGet(is,intrev32ifbe(is->length)-1)) {//该元素大于集合中最大元素
            if (pos) *pos = intrev32ifbe(is->length);
            return 0;
        } else if (value < _intsetGet(is,0)) {//该元素小于集合中最小元素
            if (pos) *pos = 0;
            return 0;
        }
    }

    while(max >= min) {//二分查找
        mid = ((unsigned int)min + (unsigned int)max) >> 1;
        cur = _intsetGet(is,mid);//获取中间元素
        if (value > cur) {//在后半部分
            min = mid+1;
        } else if (value < cur) {//在前半部分
            max = mid-1;
        } else {//查找结束：找到 或者 不存在
            break;
        }
    }

    if (value == cur) {//如果找到
        if (pos) *pos = mid;
        return 1;
    } else {//不存在该元素
        if (pos) *pos = min;
        return 0;
    }
}

关键方法 - 类型升级函数：（当添加的新元素大于现有类型长度的最大值时）先升级类型长度（重新分配内存空间，并将原有元素按升级后的类型长度格式存放），然后添加新元素。

static intset *intsetUpgradeAndAdd(intset *is, int64_t value) {
    uint8_t curenc = intrev32ifbe(is->encoding);//当前类型长度
    uint8_t newenc = _intsetValueEncoding(value);//新类型长度
    int length = intrev32ifbe(is->length);//原有元素个数
    int prepend = value < 0 ? 1 : 0;

    /* First set new encoding and resize */
    is->encoding = intrev32ifbe(newenc);//更新类型长度
    is = intsetResize(is,intrev32ifbe(is->length)+1);//重置内存空间

    /* Upgrade back-to-front so we don't overwrite values.
     * Note that the "prepend" variable is used to make sure we have an empty
     * space at either the beginning or the end of the intset. */
	//把以后元素从后往前（确保操作过程中不会提早覆盖了原来的元素值）逐个重新按新的类型长度存放。 prepend变量用来为新加元素预留一个长度空间。
	//value为负则预留在最前面，为正则预留在最后面（由于新值的绝对值足够大，因此这样即能确保集合的有序性）
    while(length--)
        _intsetSet(is,length+prepend,_intsetGetEncoded(is,length,curenc));

    /* Set the value at the beginning or the end. */
    if (prepend)//新值为负，放在最前面
        _intsetSet(is,0,value);
    else
        _intsetSet(is,intrev32ifbe(is->length),value);//新值非负，放在最后面
    is->length = intrev32ifbe(intrev32ifbe(is->length)+1);//更新长度
    return is;
}

一个很有用很方便的函数——移动尾部元素： 将from开始后面的所有内容移动到从to开始的内存中去

static void intsetMoveTail(intset *is, uint32_t from, uint32_t to) {
    void *src, *dst;
    uint32_t bytes = intrev32ifbe(is->length)-from;
    uint32_t encoding = intrev32ifbe(is->encoding);

    if (encoding == INTSET_ENC_INT64) {
        src = (int64_t*)is->contents+from;
        dst = (int64_t*)is->contents+to;
        bytes *= sizeof(int64_t);
    } else if (encoding == INTSET_ENC_INT32) {
        src = (int32_t*)is->contents+from;
        dst = (int32_t*)is->contents+to;
        bytes *= sizeof(int32_t);
    } else {
        src = (int16_t*)is->contents+from;
        dst = (int16_t*)is->contents+to;
        bytes *= sizeof(int16_t);
    }
    memmove(dst,src,bytes);
}

/* Insert an integer in the intset */
//插入新元素（可能触发升级插入）
intset *intsetAdd(intset *is, int64_t value, uint8_t *success) {
    uint8_t valenc = _intsetValueEncoding(value);//计算需要的类型长度
    uint32_t pos;
    if (success) *success = 1;

    /* Upgrade encoding if necessary. If we need to upgrade, we know that
     * this value should be either appended (if > 0) or prepended (if < 0),
     * because it lies outside the range of existing values. */
    if (valenc > intrev32ifbe(is->encoding)) {
        /* This always succeeds, so we don't need to curry *success. */
        return intsetUpgradeAndAdd(is,value);
    } else {
        /* Abort if the value is already present in the set.
         * This call will populate "pos" with the right position to insert
         * the value when it cannot be found. */
        if (intsetSearch(is,value,&pos)) {
            if (success) *success = 0;
            return is;
        }

        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;
}

/* Delete integer from intset */
//删除元素（不会引发“降级”）
intset *intsetRemove(intset *is, int64_t value, int *success) {
    uint8_t valenc = _intsetValueEncoding(value);
    uint32_t pos;
    if (success) *success = 0;

    if (valenc <= intrev32ifbe(is->encoding) && intsetSearch(is,value,&pos)) {
        uint32_t len = intrev32ifbe(is->length);

        /* We know we can delete */
        if (success) *success = 1;

        /* Overwrite value with tail and update length */
        if (pos < (len-1)) intsetMoveTail(is,pos+1,pos);//删除点以后的全部元素整体前移一个类型长度，覆盖要删除的元素
        is = intsetResize(is,len-1);//重置集合空间大小
        is->length = intrev32ifbe(len-1);//更新元素个数
    }
    return is;
}

小结：

*  Intset用于有序、无重复的保存多个整数，根据元素的值自动选择存放元素的整数类型

*  当一个长度更大的整数值添加到集合中时，需要对Intset进行升级，新Intset中的所有元素的位长度都等于新添加值的位长度，但原有元素的值不变。

* 升级会导致整个Intset进行内存重分配，并移动集合中的所有元素，这个操作的复杂度为O（N）。

* Intset只支持升级，不支持降级。

* Intset是有序的，使用二分查找，复杂度为O(lg N)。

inset的实现比前面的几种数据结构简单多了，一共500行代码，分析起来还是很轻松的。 

再次感受到了底层语言的强大，直接对内存的操作大量存在于整个系统代码中，实现快速高效的操作。