Redis-LFU与LRU内部实现原理源码分析

// redis 的对象头

typedef struct redisObject {

    unsigned type:4; // 对象类型如 zset/set/hash 等等

    unsigned encoding:4; // 对象编码如 ziplist/intset/skiplist 等等

    unsigned lru:24; // 对象的「热度」

    int refcount; // 引用计数

    void *ptr; // 对象的 body

} robj;

unsigned long long estimateObjectIdleTime(robj *o) {

    unsigned long long lruclock = LRU_CLOCK(); // 获取 redis 时钟，也就是 server.lruclock 的值

    if (lruclock >= o->lru) {

       // 正常递增

        return (lruclock - o->lru) * LRU_CLOCK_RESOLUTION; // LRU_CLOCK_RESOLUTION 默认是 1000

   } else {

        // 折返了

        return (lruclock + (LRU_CLOCK_MAX - o->lru)) * // LRU_CLOCK_MAX 是 2^24-1

                    LRU_CLOCK_RESOLUTION;

   }

}

// nowInMinutes

// server.unixtime 为 redis 缓存的系统时间戳

unsigned long LFUGetTimeInMinutes(void) {

    return (server.unixtime/60) & 65535;

}

// idle_in_minutes

unsigned long LFUTimeElapsed(unsigned long ldt) {

   unsigned long now = LFUGetTimeInMinutes();

    if (now >= ldt) return now-ldt; // 正常比较

    return 65535-ldt+now; // 折返比较

}

// 衰减 logc

unsigned long LFUDecrAndReturn(robj *o) {

    unsigned long ldt = o->lru >> 8; // 前 16bit

    unsigned long counter = o->lru & 255; // 后 8bit 为 logc

    // num_periods 为即将衰减的数量

    unsigned long num_periods = server.lfu_decay_time ? LFUTimeElapsed(ldt) / server.lfu_decay_time : 0;

    if (num_periods)

        counter = (num_periods > counter) ? 0 : counter - num_periods;

    return counter;

}、

/* Logarithmically increment a counter. The greater is the current counter value

 * the less likely is that it gets really implemented. Saturate it at 255. */

// 对数递增计数值

uint8_t LFULogIncr(uint8_t counter) {

    if (counter == 255) return 255; // 到最大值了，不能在增加了

    double baseval = counter - LFU_INIT_VAL; // 减去新对象初始化的基数值 (LFU_INIT_VAL 默认是 5)

    // baseval 如果小于零，说明这个对象快不行了，不过本次 incr 将会延长它的寿命

    if (baseval < 0) baseval = 0;

    // 当前计数越大，想要 +1 就越困难

    // lfu_log_factor 为困难系数，默认是 10

    // 当 baseval 特别大时，最大是 (255-5)，p 值会非常小，很难会走到 counter++ 这一步

    // p 就是 counter 通往 [+1] 权力的门缝，baseval 越大，这个门缝越窄，通过就越艰难

    double p = 1.0/(baseval*server.lfu_log_factor+1);

    // 开始随机看看能不能从门缝挤进去

    double r = (double)rand()/RAND_MAX; // 0 < r < 1

    if (r < p) counter++;

    return counter;

}

unsigned int LRU_CLOCK(void) {

    unsigned int lruclock;

    if (1000/server.hz <= LRU_CLOCK_RESOLUTION) {

        // 这里原子操作，通常会走这里，我们只需要注意这里

        atomicGet(server.lruclock,lruclock); 

    } else {

        // 直接通过系统调用获取时间戳，hz 配置的太低 (一般不会这么干)，lruclock 更新不及时，需要实时获取系统时间戳

        lruclock = getLRUClock();

    }

    return lruclock;

}

> config set maxmemory-policy allkeys-lfu

OK

> set codehole yeahyeahyeah

OK

// 获取计数值，初始化为 LFU_INIT_VAL=5

> object freq codehole

(integer) 5

> get codehole  // 访问一次

"yeahyeahyeah"

// 计数值增加了

> object freq codehole  //get lfu计数值

(integer) 6