Redis源码阅读--整数集合

发表于 | 分类于 | | 浏览 次
字数统计: 2,146 字 | 阅读时长 ≈ 10 分钟

整数集合（intset）是集合键的底层实现之一，当一个集合只包含整数值元素， 并且这个集合的元素数量不多时， Redis就会使用整数集合作为集合键的底层实现。本文主要介绍Redis源码中的整数数组。主要内容如下：

  • Redis中的整数集合实现及特点
  • Redis中的整数集合源码难点分析
  • Redis中的整数集合源码部分节选

Redis中的整数集合实现及特点

整数集合的具体实现
在头文件intset.h中，相关API在intset.c中；整数集合的数据结构定义如下：

1
2
3
4
5
typedef struct intset {
    uint32_t encoding;//保存元素所使用类型的长度
    uint32_t length;//保存元素的个数
    int8_t contents[];//保存元素的数组
} intset;

整数集合相关API

函数 作用 时间复杂度
intsetNew 创建一个新的整数集合 O(1)
intsetAdd 将指定元素添加到整数集合中 O(N)
intsetRemove 从整数集合中移除指定元素 O(N)
intsetFind 查找指定的值是否在集合中 因数组有序，可通过二分查找法来进行，故复杂度为O(logN)
intsetRandom 从整数集合中随机返回一个元素 O(1)
intsetGet 获取指定索引上的元素 O(1)
intsetLen 返回整数集合包含的元素个数 O(1)
intsetBlobLen 返回整数集合占用的内存字节数 O(1)

整数集合特点

  • 新建整数集合时，其encoding是int16_t类型
  • 只支持升级，不支持降级
  • 查找使用二分查找法
  • 整数集合的底层实现为数组，这个数组以有序、无重复的方式保存集合元素， 在有需要时， 程序会根据新添加元素的类型，改变这个数组的类型。
  • 升级操作为整数集合带来了操作上的灵活性， 并且尽可能地节约了内存。

创建一个空的inset

1
2
3
4
5
6
7
/* Create an empty intset. */
intset *intsetNew(void) {
    intset *is = zmalloc(sizeof(intset));
    is->encoding = intrev32ifbe(INTSET_ENC_INT16);
    is->length = 0;
    return is;
}

Redis中的整数集合源码难点分析

小端模式与大端模式
小端模式：按照从低地址到高地址的顺序，依次存放数据的低字节到高字节
大端模式：按照从低地址到高地址的顺序，依次存放数据的高字节到低字节
详细介绍可参考计算机中的小端模式和大端模式
比如0x1234abcd，分别用大小端表示如下：

低地址 高地址
小端模式 0xcd 0xab 0x34 0x12
大端模式 0x12 0x34 0xab 0xcd

Redis中有关大小端的部分代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

/* Toggle the 16 bit unsigned integer pointed by *p from little endian to
 * big endian */
void memrev16(void *p) {
    unsigned char *x = p, t;

    t = x[0];
    x[0] = x[1];
    x[1] = t;
}

/* Toggle the 32 bit unsigned integer pointed by *p from little endian to
 * big endian */
void memrev32(void *p) {
    unsigned char *x = p, t;

    t = x[0];
    x[0] = x[3];
    x[3] = t;
    t = x[1];
    x[1] = x[2];
    x[2] = t;
}


/* variants of the function doing the actual convertion only if the target
 * host is big endian */
#if (BYTE_ORDER == LITTLE_ENDIAN)
#define memrev16ifbe(p)
#define memrev32ifbe(p)
#define memrev64ifbe(p)
#define intrev16ifbe(v) (v)
#define intrev32ifbe(v) (v)
#define intrev64ifbe(v) (v)
#else
#define memrev16ifbe(p) memrev16(p)
#define memrev32ifbe(p) memrev32(p)
#define memrev64ifbe(p) memrev64(p)
#define intrev16ifbe(v) intrev16(v)
#define intrev32ifbe(v) intrev32(v)
#define intrev64ifbe(v) intrev64(v)
#endif

Redis中的整数集合源码部分节选

在整数集合中查找一个值，利用二分查找
如果找到返回1，pos返回该值在整数集合中的位置；如果没有找到返回0，pos值为当前值value应该插入的位置。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
/* Search for the position of "value". Return 1 when the value was found and
 * sets "pos" to the position of the value within the intset. Return 0 when
 * the value is not present in the intset and sets "pos" to the position
 * where "value" can be inserted. */
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;
    }
}

因为整数集合是有序的，所以其中数组最后一个元素是最大的，第一个元素是最小的，如果当前value值比最大值还大，那当前插入位置应该是pos = intrev32ifbe(is->length);如果比最小值还小，那么插入位置就应该是 pos = 0;
再下面就是一个二分查找。

升级集合并往整数集合中添加给定的整数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/* Upgrades the intset to a larger encoding and inserts the given integer. */
static intset *intsetUpgradeAndAdd(intset *is, int64_t value) {
    uint8_t curenc = intrev32ifbe(is->encoding);
    uint8_t newenc = _intsetValueEncoding(value);
    int length = intrev32ifbe(is->length);
	/*1表示头，0表示尾*/
	/*如果是小于0的数，那自然比所有数都小，所以添加到头部*/
    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. */
    /*从后往前，按原来的curenc把值取出来，重新按占newenc大小放到数组中去
    prepend为1，表示添加的元素要放到最前面，所以原来位置的值都往后移动一个位置*/
    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;
}

往集合中添加元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/* 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;
}

其中intsetMoveTail是将pos位置往后的所有元素移动到pos+1位置，就是为当前要加入的元素挪出一个位置。具体实现如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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);
}

需要说明的是，intsetMoveTail这个函数也可以往前挪动，比如删除元素的时候：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/* 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;
}

返回整数集合含有元素个数
1
2
3
4
/* Return intset length */
uint32_t intsetLen(intset *is) {
    return intrev32ifbe(is->length);
}

返回整数集合占用的内存字节数
1
2
3
4
/* Return intset blob size in bytes. */
size_t intsetBlobLen(intset *is) {
    return sizeof(intset)+intrev32ifbe(is->length)*intrev32ifbe(is->encoding);
}

查找指定元素
1
2
3
4
5
/* Determine whether a value belongs to this set */
uint8_t intsetFind(intset *is, int64_t value) {
    uint8_t valenc = _intsetValueEncoding(value);
    return valenc <= intrev32ifbe(is->encoding) && intsetSearch(is,value,NULL);
}

如果查找的元素的类型使用的长度比当前集合的使用的类型长度encoding都还大，肯定就不在集合中咯，intsetSearch参考前面的说明。

参考资料

Redis设计与实现
Redis源码3.0.6
计算机中的小端模式和大端模式

如果你觉得本文对你有帮助，欢迎打赏