intset
intset为Redis中的整数集合, 当一个集合只包含整数值元素, 并且这个集合的元素数量不多时, Redis 就会使用整数集合作为集合键的底层实现。intset采用一段连续内存空间实现,默认采用16bit的整数,当新加入的整数16bit放不下时会对整个空间进行扩容,因为每加入/删除一个元素就要进行扩容/缩容,频繁的进行内存释放、拷贝,很明显不适用于频繁的增删元素
大小端存储
大端存储:数据的低位在内存的高地址中
小端存储:数据的低位在内存的低地址中
大多数机器如intel x86架构采用的小端字节序
Redis为了文件存储统一,将intset的存储顺序都用小端存储,若是大端则转化为小端
#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
以memrev32为例:
// 将字节序逆转
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;
}
基本结构
typedef struct intset {
// 编码方式
uint32_t encoding;
// 集合包含的元素数量
uint32_t length;
// 保存元素的数组
int8_t contents[];
} intset;
用图表示如下:
基本函数
函数 | 功能 | 复杂度 |
---|---|---|
intsetNew | 新建整数集合 | O(1) |
intsetAdd | 增加元素 | O(N) |
intsetRemove | 删除元素 | O(N) |
intsetFind | 查找元素 | O(log(N)) |
…… | …… | …… |
intsetNew
// 创建新的整数集合
intset *intsetNew(void) {
// 为整数集合结构分配空间
intset *is = zmalloc(sizeof(intset));
// 设置初始编码
is->encoding = intrev32ifbe(INTSET_ENC_INT16);
// 初始化元素数量
is->length = 0;
return is;
}
intsetAdd
intset *intsetAdd(intset *is, int64_t value, uint8_t *success) {
// 计算编码 value 所需的长度
uint8_t valenc = _intsetValueEncoding(value);
uint32_t pos;
// 默认设置插入为成功
if (success) *success = 1;
// 如果 value 的编码比整数集合现在的编码要大
// 那么表示 value 必然可以添加到整数集合中
// 并且整数集合需要对自身进行升级,才能满足 value 所需的编码
if (valenc > intrev32ifbe(is->encoding)) {
return intsetUpgradeAndAdd(is,value);
} else {
// 在整数集合中查找 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 上的位置,用于设置新值
if (pos < intrev32ifbe(is->length)) intsetMoveTail(is,pos,pos+1);
}
// 将新值设置到底层数组的指定位置中
_intsetSet(is,pos,value);
// 长度加一
is->length = intrev32ifbe(intrev32ifbe(is->length)+1);
// 返回添加新元素后的整数集合
return is;
}
用图表示增加元素的过程
先分析新值编码长度大于原有编码长度的情况
编码范围不够,整型升级
因为原有类型空间存放不下新值,需要进行整型升级,扩增空间
intsetUpgradeAndAdd代码如下:
static intset *intsetUpgradeAndAdd(intset *is, int64_t value) {
// 当前的编码方式 命名为oldenc较好,我读到后面代码时引起了误解
uint8_t curenc = intrev32ifbe(is->encoding);
// 新值所需的编码方式
uint8_t newenc = _intsetValueEncoding(value);
// 当前集合的元素数量
int length = intrev32ifbe(is->length);
// 根据 value 的值,决定是将它添加到底层数组的最前端还是最后端
// 注意,因为 value 的编码比集合原有的其他元素的编码都要大
// 所以 value 要么大于集合中的所有元素,要么小于集合中的所有元素
// 因此,value 只能添加到底层数组的最前端或最后端
int prepend = value < 0 ? 1 : 0;
// 更新集合的编码方式
is->encoding = intrev32ifbe(newenc);
// 根据新编码对集合(的底层数组)进行空间调整
is = intsetResize(is,intrev32ifbe(is->length)+1);
// 根据集合原来的编码方式,从底层数组中取出集合元素
// 然后再将元素以新编码的方式添加到集合中
// 当完成了这个步骤之后,集合中所有原有的元素就完成了从旧编码到新编码的转换
// 因为新分配的空间都放在数组的后端,所以程序先从后端向前端移动元素
// 举个例子,假设原来有 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 |
while(length--)
_intsetSet(is,length+prepend,_intsetGetEncoded(is,length,curenc));
// 设置新值,根据 prepend 的值来决定是添加到数组头还是数组尾
if (prepend)
_intsetSet(is,0,value);
else
_intsetSet(is,intrev32ifbe(is->length),value);
// 更新整数集合的元素数量
is->length = intrev32ifbe(intrev32ifbe(is->length)+1);
return is;
}
intsetUpgradeAndAdd的过程大致如下:
1. 根据目前编码重分配空间,足以容纳下原来的元素和新值,并进行内存拷贝
2. 如果新值比原来所有值都大,则末尾空间留给新值,逆向拷贝
3. 如果新值比原来所有值都小,则开头空间留给新值,逆向拷贝
intsetResize代码如下:
static intset *intsetResize(intset *is, uint32_t len) {
// 计算数组的空间大小
uint32_t size = len*intrev32ifbe(is->encoding);
// 根据空间大小,重新分配空间
// 注意这里使用的是 zrealloc ,
// 所以如果新空间大小比原来的空间大小要大,
// 那么数组原有的数据会被保留
is = zrealloc(is,sizeof(intset)+size);
return is;
}
很简单,计算出需要的空间,再重分配空间并拷贝原空间即可
_intsetSet代码如下:
// 根据编码类型将值放入指定位置
static void _intsetSet(intset *is, int pos, int64_t value) {
// 取出集合的编码方式
uint32_t encoding = intrev32ifbe(is->encoding);
// 根据编码 ((Enc_t*)is->contents) 将数组转换回正确的类型
// 然后 ((Enc_t*)is->contents)[pos] 定位到数组索引上
// 接着 ((Enc_t*)is->contents)[pos] = value 将值赋给数组
// 最后, ((Enc_t*)is->contents)+pos 定位到刚刚设置的新值上
// 如果有需要的话, memrevEncifbe 将对值进行大小端转换
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] = value;
memrev32ifbe(((int32_t*)is->contents)+pos);
} else {
((int16_t*)is->contents)[pos] = value;
memrev16ifbe(((int16_t*)is->contents)+pos);
}
}
_intsetGetEncoded代码如下:
// 根据给定编码类型和位置返回该位置上的数字
static int64_t _intsetGetEncoded(intset *is, int pos, uint8_t enc) {
int64_t v64;
int32_t v32;
int16_t v16;
// ((ENCODING*)is->contents) 首先将数组转换回被编码的类型
// 然后 ((ENCODING*)is->contents)+pos 计算出元素在数组中的正确位置
// 之后 member(&vEnc, ..., sizeof(vEnc)) 再从数组中拷贝出正确数量的字节
// 如果有需要的话, memrevEncifbe(&vEnc) 会对拷贝出的字节进行大小端转换
// 最后将值返回
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;
}
}
编码范围够
- 查找value是否存在,若存在返回,不存在则到2
- resize扩容,为了容纳新值
- 将新值插入点后的所有元素右移
- 插入新值
intsetSearch代码如下
// 查找到了返回1
// value应该插入的位置编号保存在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;
// 处理 is 为空时的情况
if (intrev32ifbe(is->length) == 0) {
if (pos) *pos = 0;
return 0;
} else {
// 因为底层数组是有序的,如果 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;
}
}
// 在有序数组中进行二分查找
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;
}
}
intsetMoveTail代码如下:
// 计算出要移动的字节数,底层调用memmove函数
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);
// 根据不同的编码
// src = (Enc_t*)is->contents+from 记录移动开始的位置
// dst = (Enc_t*)is_.contents+to 记录移动结束的位置
// bytes *= sizeof(Enc_t) 计算一共要移动多少字节
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);
}
intsetRemove
// 从集合中删除value
intset *intsetRemove(intset *is, int64_t value, int *success) {
// 计算 value 的编码方式
uint8_t valenc = _intsetValueEncoding(value);
uint32_t pos;
// 默认设置标识值为删除失败
if (success) *success = 0;
// 当 value 的编码小于或等于集合的当前编码方式(说明 value 有可能存在于集合)
// 并且 intsetSearch 的结果为真,那么执行删除
if (valenc <= intrev32ifbe(is->encoding) && intsetSearch(is,value,&pos)) {
// 取出集合当前的元素数量
uint32_t len = intrev32ifbe(is->length);
// 设置标识值为删除成功
if (success) *success = 1;
// 如果 value 不是位于数组的末尾
// 那么需要对原本位于 value 之后的元素进行移动
//
// 举个例子,如果数组表示如下,而 b 为删除的目标
// | a | b | c | d |
// 那么 intsetMoveTail 将 b 之后的所有数据向前移动一个元素的空间,
// 覆盖 b 原来的数据
// | a | c | d | d |
// 之后 intsetResize 缩小内存大小时,
// 数组末尾多出来的一个元素的空间将被移除
// | a | c | d |
if (pos < (len-1)) intsetMoveTail(is,pos+1,pos);
// 缩小数组的大小,移除被删除元素占用的空间
// T = O(N)
is = intsetResize(is,len-1);
// 更新集合的元素数量
is->length = intrev32ifbe(len-1);
}
return is;
}
intsetFind
// 很明显转调用intsetSearch即可
uint8_t intsetFind(intset *is, int64_t value) {
// 计算 value 的编码
uint8_t valenc = _intsetValueEncoding(value);
// 如果 value 的编码大于集合的当前编码,那么 value 一定不存在于集合
// 当 value 的编码小于等于集合的当前编码时,
// 才再使用 intsetSearch 进行查找
return valenc <= intrev32ifbe(is->encoding) && intsetSearch(is,value,NULL);
}
小结
整数集合intset表示简单,但是要进行频繁的内存分配、拷贝、销毁操作。优点是可以动态的对整数范围进行升级,一定程度上节约了内存,缺点是没有降级、没有预留空间。并且若有大量的16bit就能存储的整数,而新插入一个64bit才能存储的整数则会进行升级对所有整数都用64bit存储。