Redis源码解读（十二）——淘汰策略

fayadexinqing

已于 2022-05-21 15:03:51 修改

阅读量178

点赞数

分类专栏： redis 文章标签： redis 缓存数据结构数据库 database

于 2020-01-01 11:59:24 首次发布

本文链接：https://blog.csdn.net/yh88623131/article/details/103775348

版权

redis 专栏收录该内容

31 篇文章 17 订阅

订阅专栏

键何时被淘汰

健的淘汰实现在evic.c中
在Redis源码解读（四）——命令端到端的过程中，processCommand命令处理函数从命令表中查找对应的命令之后，做的第一件事就是调用freeMemoryIfNeededAndSafe函数尝试对淘汰对应的键，进行内存释放：

int processCommand(client *c) {
	...
	c->cmd = c->lastcmd = lookupCommand(c->argv[0]->ptr);
	...
	//内存管理
    if (server.maxmemory && !server.lua_timedout) {
        int out_of_memory = freeMemoryIfNeededAndSafe() == C_ERR;
        if (server.current_client == NULL) return C_ERR;
        if (out_of_memory &&
            (c->cmd->flags & CMD_DENYOOM ||
             (c->flags & CLIENT_MULTI && c->cmd->proc != execCommand))) {
            flagTransaction(c);
            addReply(c, shared.oomerr);
            return C_OK;
        }
    }
    ...
}

当满足以下三个条件时，键需要被淘汰：
1、server设置来最大最大内存使用量
2、内存使用阈值达到最大值
3、server目前没有执行lua脚本
freeMemoryIfNeededAndSafe函数的另一个调用地方是在客户端发送config set maxmemory xxx时，进行一次键的淘汰。

淘汰策略

//缓存淘汰策略
#define MAXMEMORY_VOLATILE_LRU ((0<<8)|MAXMEMORY_FLAG_LRU)
#define MAXMEMORY_VOLATILE_LFU ((1<<8)|MAXMEMORY_FLAG_LFU)
#define MAXMEMORY_VOLATILE_TTL (2<<8)
#define MAXMEMORY_VOLATILE_RANDOM (3<<8)
#define MAXMEMORY_ALLKEYS_LRU ((4<<8)|MAXMEMORY_FLAG_LRU|MAXMEMORY_FLAG_ALLKEYS)
#define MAXMEMORY_ALLKEYS_LFU ((5<<8)|MAXMEMORY_FLAG_LFU|MAXMEMORY_FLAG_ALLKEYS)
#define MAXMEMORY_ALLKEYS_RANDOM ((6<<8)|MAXMEMORY_FLAG_ALLKEYS)
#define MAXMEMORY_NO_EVICTION (7<<8)

一共有8种：
1、MAXMEMORY_VOLATILE_LRU：从设置了过期时间的键中根据LRU淘汰
2、MAXMEMORY_VOLATILE_LFU：从设置了过期时间的键中根据LFU淘汰
3、MAXMEMORY_VOLATILE_TTL：从设置了过期时间的键中根据最长生存时间淘汰
4、MAXMEMORY_VOLATILE_RANDOM：从设置了过期时间的键中任意选择键淘汰
5、MAXMEMORY_FLAG_LRU：从所有键中根据LRU淘汰
6、MAXMEMORY_FLAG_LFU：从所有键中根据LFU淘汰
7、MAXMEMORY_ALLKEYS_RANDOM：从所有键中任意选择键淘汰
8、MAXMEMORY_NO_EVICTION：不进行键淘汰，如果内存不够，直接OOM

淘汰算法

在对象结构体中，lru字段表示键的访问时间（频率），这是一个24位的无符号数，在redis.conf中设置maxmemory_policy（即上面的8中策略，默认为不淘汰）后，lru可以表示键的访问时间或者访问频率，对应lru（最近最少使用算法）和lfu（最近最不经常使用算法）。

typedef struct redisObject {
    unsigned type:4;
    unsigned encoding:4;
    unsigned lru:LRU_BITS;
    int refcount;
    void *ptr;
} robj;

一般来说，lru字段在以下情况下被更新：
1、创建对象的时候，给对象的lru字段初始化：

robj *createObject(int type, void *ptr) {
	...
	if (server.maxmemory_policy & MAXMEMORY_FLAG_LFU) {
        o->lru = (LFUGetTimeInMinutes()<<8) | LFU_INIT_VAL;
    } else {
        o->lru = LRU_CLOCK();
    }
    ...
}

2、在访问数据库，对键值对进行增删查改时，都会调用底层的lookupKey函数去判断数据库中是否有该键，在这时，对lru字段进行更新

robj *lookupKey(redisDb *db, robj *key, int flags) {
    dictEntry *de = dictFind(db->dict,key->ptr);
    if (de) {
        robj *val = dictGetVal(de);

        if (server.rdb_child_pid == -1 &&
            server.aof_child_pid == -1 &&
            !(flags & LOOKUP_NOTOUCH))
        {
            //更新lru字段
            if (server.maxmemory_policy & MAXMEMORY_FLAG_LFU) {
                updateLFU(val);
            } else {
                val->lru = LRU_CLOCK();
            }
        }
        return val;
    } else {
        return NULL;
    }
}

注意这里再判断如果存在RDB/AOF子进程时，不会更新lru，原因是避免fork的COW放大

lru

lru算法中，lru表示上一次访问键的时间，以ms为单位，每次访问到键时，就把键的lru更新为当前的时间。

unsigned int LRU_CLOCK(void) {
    unsigned int lruclock;
    //serverCron()执行周期大于lru精度
    if (1000/server.hz <= LRU_CLOCK_RESOLUTION) {
        atomicGet(server.lruclock,lruclock);
    } else {
        lruclock = getLRUClock();
    }
    return lruclock;
}
unsigned int getLRUClock(void) {
    return (mstime()/LRU_CLOCK_RESOLUTION) & LRU_CLOCK_MAX;
}

这里首先判断serverCron的执行周期是否大于lru精度，如果是则直接将server.lruclock返回，省去一次获取系统时间的系统调用，因为server.lruclock在serverCron函数中每次都会被更新。

lfu

在lfu算法中，lru字段分为两部分，前16位表示上一次访问时间，单位为分，后8位表示键最近的访问频率。每次访问到键时，其更新方式如下：
1、前16位更新为当前时间

unsigned long LFUGetTimeInMinutes(void) {
    return (server.unixtime/60) & 65535;
}

2、后8位先进行一次塌缩，因为后8位表示最近的访问频率，所以如果最近没有对键访问，随着时间的流逝，键的访问频率应该缩小。可以看出，塌缩的值为距离上一次访问时间经过的分钟数。

unsigned long LFUDecrAndReturn(robj *o) {
    unsigned long ldt = o->lru >> 8;
    unsigned long counter = o->lru & 255;
    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;
}
unsigned long LFUTimeElapsed(unsigned long ldt) {
    unsigned long now = LFUGetTimeInMinutes();
    if (now >= ldt) return now-ldt;
    //发生回绕
    return 65535-ldt+now;
}

3、然后因为本次访问到键了，要对键的访问频率增加，这里redis用了一个技巧：因为后8位即使最大也是256，用来表示访问次数可能不够，所以“对键的访问频率增加”并不是一定会增大后8位的值，只是发出这个增加的动作，具体是否增加取决于概率，概率与后8位的值有关，值越大，增加的概率越小。从代码中看出，概率为 1/((counter-LFU_INIT_VAL)*server.lfu_log_factor+1)

uint8_t LFULogIncr(uint8_t counter) {
    if (counter == 255) return 255;
    double r = (double)rand()/RAND_MAX;
    double baseval = counter - LFU_INIT_VAL;
    if (baseval < 0) baseval = 0;
    double p = 1.0/(baseval*server.lfu_log_factor+1);
    if (r < p) counter++;
    return counter;
}

总的lfu更新函数：

void updateLFU(robj *val) {
    unsigned long counter = LFUDecrAndReturn(val);
    counter = LFULogIncr(counter);
    val->lru = (LFUGetTimeInMinutes()<<8) | counter;
}

键的淘汰步骤

键的具体淘汰在freeMemoryIfNeeded函数中执行，里面重要的一步是要选取出要淘汰的键，如何根据lru或者lfu或者ttl来判断键需要被淘汰呢？这就需要计算键的idle(空闲)时间：

void evictionPoolPopulate(int dbid, dict *sampledict, dict *keydict, struct evictionPoolEntry *pool) {
    int j, k, count;
    dictEntry *samples[server.maxmemory_samples];

    //随机选取count个键
    count = dictGetSomeKeys(sampledict,samples,server.maxmemory_samples);
    for (j = 0; j < count; j++) {
        unsigned long long idle;
        sds key;
        robj *o;
        dictEntry *de;

        de = samples[j];
        key = dictGetKey(de);
        //MAXMEMORY_VOLATILE_TTL策略只需要知道键的过期时间即可
        if (server.maxmemory_policy != MAXMEMORY_VOLATILE_TTL) {
            if (sampledict != keydict) de = dictFind(keydict, key);
            o = dictGetVal(de);
        }
        //对于lru，就是上一次访问时间到现在的经历时间
        if (server.maxmemory_policy & MAXMEMORY_FLAG_LRU) {
            idle = estimateObjectIdleTime(o);
        } else if (server.maxmemory_policy & MAXMEMORY_FLAG_LFU) {
        	//对于lfu策略，用255-访问频率来表示空闲时间
            idle = 255-LFUDecrAndReturn(o);
        else if (server.maxmemory_policy == MAXMEMORY_VOLATILE_TTL) {
            //MAXMEMORY_VOLATILE_TTL策略下，看对象最大生存时间ttl
            idle = ULLONG_MAX - (long)dictGetVal(de);
        } else {
            serverPanic("Unknown eviction policy in evictionPoolPopulate()");
        }
        //按照idle的升序将key插入pool中
        k = 0;
        while (k < EVPOOL_SIZE &&
               pool[k].key &&
               pool[k].idle < idle) k++;
        if (k == 0 && pool[EVPOOL_SIZE-1].key != NULL) {
        	//idle最小，不插入
        	continue;
        } else if (k < EVPOOL_SIZE && pool[k].key == NULL) {
            //要插入的位置刚好空闲
        } else {
            if (pool[EVPOOL_SIZE-1].key == NULL) {
                //要插入的位置不为空，且pool中还有位置
                //为要插入的key空出位置并缓存前一个key
                sds cached = pool[EVPOOL_SIZE-1].cached;
                memmove(pool+k+1,pool+k,
                    sizeof(pool[0])*(EVPOOL_SIZE-k-1));
                pool[k].cached = cached;
            } else {
                //pool中没有空闲位置，则把第一个位置上的key移除
                k--;
                sds cached = pool[0].cached; /* Save SDS before overwriting. */
                if (pool[0].key != pool[0].cached) sdsfree(pool[0].key);
                memmove(pool,pool+1,sizeof(pool[0])*k);
                pool[k].cached = cached;
            }
        }
        //插入元素
        int klen = sdslen(key);
        if (klen > EVPOOL_CACHED_SDS_SIZE) {
            pool[k].key = sdsdup(key);
        } else {
            memcpy(pool[k].cached,key,klen+1);
            sdssetlen(pool[k].cached,klen);
            pool[k].key = pool[k].cached;
        }
        pool[k].idle = idle;
        pool[k].dbid = dbid;
    }
}

evictionPoolPopulate函数每次随机选取count个键，并尝试插入pool中等待删除，pool数组是一个按照idle生序的数组。
当选出要被淘汰的键之后，接下来执行具体的键释放。

int freeMemoryIfNeeded(void) {
    if (server.masterhost && server.repl_slave_ignore_maxmemory) return C_OK;

    size_t mem_reported, mem_tofree, mem_freed;
    mstime_t latency, eviction_latency;
    long long delta;
    int slaves = listLength(server.slaves);
    //暂停客户端状态下，不进行内存管理
    if (clientsArePaused()) return C_OK;
    //不需要内存清理
    if (getMaxmemoryState(&mem_reported,NULL,&mem_tofree,NULL) == C_OK)
        return C_OK;

    mem_freed = 0;

    if (server.maxmemory_policy == MAXMEMORY_NO_EVICTION)
        goto cant_free; /* We need to free memory, but policy forbids. */

    latencyStartMonitor(latency);
    //需要内存清理
    while (mem_freed < mem_tofree) {
        int j, k, i, keys_freed = 0;
        static unsigned int next_db = 0;
        sds bestkey = NULL;
        int bestdbid;
        redisDb *db;
        dict *dict;
        dictEntry *de;

        //如果使用LRU、LFU或者是volatile-ttl策略清除内存空间，那么使用辅助函数以idle为标准收集需要释放的键
        if (server.maxmemory_policy & (MAXMEMORY_FLAG_LRU|MAXMEMORY_FLAG_LFU) ||
            server.maxmemory_policy == MAXMEMORY_VOLATILE_TTL)
        {
            struct evictionPoolEntry *pool = EvictionPoolLRU;

            //每次选择出一个key进行淘汰
            while(bestkey == NULL) {
                unsigned long total_keys = 0, keys;
                //选取出一定数量的idle最大的key，并填入pool中
                for (i = 0; i < server.dbnum; i++) {
                    db = server.db+i;
                    dict = (server.maxmemory_policy & MAXMEMORY_FLAG_ALLKEYS) ?
                            db->dict : db->expires;
                    if ((keys = dictSize(dict)) != 0) {
                        //选出要淘汰的键
                        evictionPoolPopulate(i, dict, db->dict, pool);
                        total_keys += keys;
                    }
                }
                if (!total_keys) break;
                //选择出目前pool中最适合删除的key，也就是idle时间最大的键
                for (k = EVPOOL_SIZE-1; k >= 0; k--) {
                    if (pool[k].key == NULL) continue;
                    bestdbid = pool[k].dbid;

                    if (server.maxmemory_policy & MAXMEMORY_FLAG_ALLKEYS) {
                        de = dictFind(server.db[pool[k].dbid].dict,
                            pool[k].key);
                    } else {
                        de = dictFind(server.db[pool[k].dbid].expires,
                            pool[k].key);
                    }
                    if (pool[k].key != pool[k].cached)
                        sdsfree(pool[k].key);
                    pool[k].key = NULL;
                    pool[k].idle = 0;
                    if (de) {
                        bestkey = dictGetKey(de);
                        break;
                    } else {
                        /* Ghost... Iterate again. */
                    }
                }
            }
        
        //任意键删除策略
        else if (server.maxmemory_policy == MAXMEMORY_ALLKEYS_RANDOM ||
                 server.maxmemory_policy == MAXMEMORY_VOLATILE_RANDOM)
        {
            for (i = 0; i < server.dbnum; i++) {
                j = (++next_db) % server.dbnum;
                db = server.db+j;
                dict = (server.maxmemory_policy == MAXMEMORY_ALLKEYS_RANDOM) ?
                        db->dict : db->expires;
                if (dictSize(dict) != 0) {
                    //任意选出一个键即可
                    de = dictGetRandomKey(dict);
                    bestkey = dictGetKey(de);
                    bestdbid = j;
                    break;
                }
            }
        }

        //选出key之后，进行删除
        if (bestkey) {
            db = server.db+bestdbid;
            robj *keyobj = createStringObject(bestkey,sdslen(bestkey));
            //将过期命令传播到slave和aof中
            //propagateExpire() 可能会导致内存的分配，所以在zmalloc_used_memory之前执行
            propagateExpire(db,keyobj,server.lazyfree_lazy_eviction);
            delta = (long long) zmalloc_used_memory();
            latencyStartMonitor(eviction_latency);
            if (server.lazyfree_lazy_eviction)
                dbAsyncDelete(db,keyobj);
            else
                dbSyncDelete(db,keyobj);
            latencyEndMonitor(eviction_latency);
            latencyAddSampleIfNeeded("eviction-del",eviction_latency);
            latencyRemoveNestedEvent(latency,eviction_latency);
            delta -= (long long) zmalloc_used_memory();
            mem_freed += delta;
            server.stat_evictedkeys++;
            notifyKeyspaceEvent(NOTIFY_EVICTED, "evicted",
                keyobj, db->id);
            decrRefCount(keyobj);
            keys_freed++;
            //如果要删除的键比较多，并且把回写slave客户端的动作放到eventloop中做
            //那么可能回造成在eventloop中较长时间的阻塞
            //所以放在这里强制发送客户端
            if (slaves) flushSlavesOutputBuffers();
            //在懒释放情况下，key的释放在其他的线程中，所以需要时不时的检测是否已经达到循坏条件
            if (server.lazyfree_lazy_eviction && !(keys_freed % 16)) {
                if (getMaxmemoryState(NULL,NULL,NULL,NULL) == C_OK) {
                    /* Let's satisfy our stop condition. */
                    mem_freed = mem_tofree;
                }
            }
        }

        if (!keys_freed) {
            latencyEndMonitor(latency);
            latencyAddSampleIfNeeded("eviction-cycle",latency);
            goto cant_free; /* nothing to free... */
        }
    }
    latencyEndMonitor(latency);
    latencyAddSampleIfNeeded("eviction-cycle",latency);
    return C_OK;

cant_free:
    //执行到这里，说明目前数据库中没有可释放的内存，只能尽可能的等待其他懒释放线程中释放内存
    while(bioPendingJobsOfType(BIO_LAZY_FREE)) {
        if (((mem_reported - zmalloc_used_memory()) + mem_freed) >= mem_tofree)
            break;
        usleep(1000);
    }
    return C_ERR;
}