redis之intset

号外号外，新建redis交流讨论群：332160890，欢迎加入！！

类型介绍

intset是一个整型的数据集合，在这里面的结构比较简单，实际上就是一个整型数组，在添加过程中，同样给该数组按照数据大小排序，这点在查找的时候比较容易，比较符合缓存的特点，另外，这里面同样给数据按照类型进行了区分，也是为了节省内容空间人为增加了程序的复杂度，但是回报还不错，实际操作过程中，许多情况下数据是同类型的，这样避免了都是用64位整型来保存数据；

代码分析

自定义类型

typedef struct intset {
    uint32_t encoding;
    uint32_t length;
    int8_t contents[];
} intset;

函数说明

_intsetValueEncoding，获取当前value应该占用的字节数；

static uint8_t _intsetValueEncoding(int64_t v) {
    if (v < INT32_MIN || v > INT32_MAX)
        return INTSET_ENC_INT64;  //64位
    else if (v < INT16_MIN || v > INT16_MAX)
        return INTSET_ENC_INT32;  //32位
    else
        return INTSET_ENC_INT16;  //16位
}

_intsetGetEncoded，根据当前位置和编码类型，获取对应的value；

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

intsetNew，创建一个新的整数集合；

intset *intsetNew(void) {
    intset *is = zmalloc(sizeof(intset));
    is->encoding = intrev32ifbe(INTSET_ENC_INT16);
    is->length = 0;
    return is;
}

intsetResize，调整整数集合的大小，新的集合中元素个数为len；

static intset *intsetResize(intset *is, uint32_t len) {
    uint32_t size = len*intrev32ifbe(is->encoding);
    is = zrealloc(is,sizeof(intset)+size);
    return is;
}

intsetSearch，在整数集合中查找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;

    /* 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. */
        //下面的代码说明intset是按照从小到大的顺序去存放的，
        //这里面会比较当前value与set中的最大值和最小值，如果
        //当前value不在value中也能够知道是在开头或者结尾插入
        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;
        }
    }
    //下面是使用的二分查找法找到value或者是该插入的位置
    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;
    }
}

intsetUpgradeAndAdd，添加一个更大值到intset中，可能需要更新类型；

static intset *intsetUpgradeAndAdd(intset *is, int64_t value) {
    uint8_t curenc = intrev32ifbe(is->encoding);  //获取当前编码类型
    uint8_t newenc = _intsetValueEncoding(value);   //获取当前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. */
    while(length--)
        _intsetSet(is,length+prepend,_intsetGetEncoded(is,length,curenc)); //这里面是要重写之前的value，按照现在的编码类型，prepend是用来说明是存放到前面还是后面，如果是后面，那就是从最后一个元素开始挨个往后移动，不然就是存放到原来的顺序

    /* Set the value at the beginning or the end. */
    //根据前后设置value 
    if (prepend)
        _intsetSet(is,0,value);
    else
        _intsetSet(is,intrev32ifbe(is->length),value);
    is->length = intrev32ifbe(intrev32ifbe(is->length)+1); //重新设置长度
    return is;
}

intsetMoveTail，将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);
}

intsetAdd，添加一个value;

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); //设置value 
    is->length = intrev32ifbe(intrev32ifbe(is->length)+1);
    return is;
}

intsetRemove，从intset中移除value；

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)) { //只有当前的编码类型比intset的编码类型小才有查找的必要
        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;
}

intsetFind，查看value是否在intset中；

uint8_t intsetFind(intset *is, int64_t value) {
    uint8_t valenc = _intsetValueEncoding(value);
    return valenc <= intrev32ifbe(is->encoding) && intsetSearch(is,value,NULL);
}

intsetGet，获取intset的pos位置的值；

uint8_t intsetGet(intset *is, uint32_t pos, int64_t *value) {
    if (pos < intrev32ifbe(is->length)) {
        *value = _intsetGet(is,pos);
        return 1;
    }
    return 0;
}