Redis 源码解读之逐出策略

Redis 源码解读之逐出策略

背景和问题

本文想解决的问题：

1. redis 触发逐出的时机是怎样的？
2. redis 逐出策略有哪些?
3. 如何在海量的 key 中快速找到逐出评价值(idle)最高的key，并将之逐出？
4. LFU 算法的频率是如何统计的？

结论

1. redis 触发逐出的时机是怎样的？

如图，主要有两个地方会触发逐出。

• 更新 maxmemory 参数，导致实际使用内存大于该限制。
• 处理客户端请求，使用到的内存大于内存限制。

1. redis 逐出策略有哪些?

• 逐出策略主要分为两个维度：四种逐出 key 的算法和两种逐出 key 的范围。这两个维度叉乘的集合，去除 allkeys-ttl, 加上一个不逐出的策略，就是redis 支持的所有逐出策略。

  • 逐出 key 的算法：LRU，LFU，随机逐出(random)和根据 TTL 逐出(ttl)。
  • 逐出 key 的范围： 所有 key 都能被逐出(allkeys) 和 有过期时间的 key 才能被逐出(volatile)

• noeviction: return errors when the memory limit was reached and the client is trying to execute commands that could result in more memory to be used (most write commands, but DEL and a few more exceptions).

• allkeys-lru: evict keys by trying to remove the less recently used (LRU) keys first, in order to make space for the new data added.

• volatile-lru: evict keys by trying to remove the less recently used (LRU) keys first, but only among keys that have an expire set, in order to make space for the new data added.

• allkeys-random: evict keys randomly in order to make space for the new data added.

• volatile-random: evict keys randomly in order to make space for the new data added, but only evict keys with an expire set.

• volatile-ttl: evict keys with an expire set, and try to evict keys with a shorter time to live (TTL) first, in order to make space for the new data added.

• volatile-lfu: Evict using approximated LFU among the keys with an expire set.

• allkeys-lfu: Evict any key using approximated LFU.

1. 如何在海量的 key 中快速找到逐出评价值(idle)最高的key，并将之逐出？

抽样逐出：每次从数据中抽取 server.maxmemory_samples 个元素插入以 idle 值为优先级的优先队列 EvictionPoolLRU。每轮逐出优先队列的第一个 key。

/* To improve the quality of the LRU approximation we take a set of keys
* that are good candidate for eviction across freeMemoryIfNeeded() calls.
*
* Entries inside the eviction pool are taken ordered by idle time, putting
* greater idle times to the right (ascending order).
*
* When an LFU policy is used instead, a reverse frequency indication is used
* instead of the idle time, so that we still evict by larger value (larger
* inverse frequency means to evict keys with the least frequent accesses).
*
* Empty entries have the key pointer set to NULL. */
#define EVPOOL_SIZE 16
#define EVPOOL_CACHED_SDS_SIZE 255
struct evictionPoolEntry {
   unsigned long long idle;    /* Object idle time (inverse frequency for LFU) >*/
  sds key;                    /* Key name. */
  sds cached;                 /* Cached SDS object for key name. */
  int dbid;                   /* Key DB number. */
};

static struct evictionPoolEntry *EvictionPoolLRU;

1. LFU 算法的频率是如何统计的？

• redis 对象的定义如下

#define LRU_BITS 24
typedef struct redisObject {
   unsigned type:4;
   unsigned encoding:4;
   unsigned lru:LRU_BITS; /* LRU time (relative to global lru_clock) or
                           * LFU data (least significant 8 bits frequency
                           * and most significant 16 bits access time). */
   int refcount;
   void *ptr;
} robj;

• 其中 lru 字段用于计算逐出评价值 idle。在 LFU 算法中，lru 字段作为 LFU 统计的频率。

   // 根据不同的逐出策略, 计算出对应的逐出优先级数值(idle)
   /* Calculate the idle time according to the policy. This is called
    * idle just because the code initially handled LRU, but is in fact
    * just a score where an higher score means better candidate. */
   if (server.maxmemory_policy & MAXMEMORY_FLAG_LRU) {
       idle = estimateObjectIdleTime(o);
   } else if (server.maxmemory_policy & MAXMEMORY_FLAG_LFU) {
       /* When we use an LRU policy, we sort the keys by idle time
        * so that we expire keys starting from greater idle time.
        * However when the policy is an LFU one, we have a frequency
        * estimation, and we want to evict keys with lower frequency
        * first. So inside the pool we put objects using the inverted
        * frequency subtracting the actual frequency to the maximum
        * frequency of 255. */
       idle = 255-LFUDecrAndReturn(o);
   } else if (server.maxmemory_policy == MAXMEMORY_VOLATILE_TTL) {
       /* In this case the sooner the expire the better. */
       idle = ULLONG_MAX - (long)dictGetVal(de);
   } else {
       serverPanic("Unknown eviction policy in evictionPoolPopulate()");
   }

• lru 统计 LFU 频率时，作为分为两部分，第一部分(16 位)作为记录上次计数减少的时间戳。第二部分(8位)作为频率计数器(通过对数函数归一化，具体原理见 morris)。

         16 bits      8 bits
    +----------------+--------+
    + Last decr time | LOG_C  |
    +----------------+--------+
  

• 频率计数增加/减少：

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

/* If the object decrement time is reached decrement the LFU counter but
* do not update LFU fields of the object, we update the access time
* and counter in an explicit way when the object is really accessed.
* And we will times halve the counter according to the times of
* elapsed time than server.lfu_decay_time.
* Return the object frequency counter.
*
* This function is used in order to scan the dataset for the best object
* to fit: as we check for the candidate, we incrementally decrement the
* counter of the scanned objects if needed. */
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;
}

源码概览

额…… Q&A 都介绍得差不多了。简单来说，就是 freeMemoryIfNeeded 函数。

/* This is an helper function for freeMemoryIfNeeded(), it is used in order
 * to populate the evictionPool with a few entries every time we want to
 * expire a key. Keys with idle time smaller than one of the current
 * keys are added. Keys are always added if there are free entries.
 *
 * We insert keys on place in ascending order, so keys with the smaller
 * idle time are on the left, and keys with the higher idle time on the
 * right. */

void evictionPoolPopulate(int dbid, dict *sampledict, dict *keydict, struct evictionPoolEntry *pool) {
    //... ...
    count = dictGetSomeKeys(sampledict,samples,server.maxmemory_samples);
    //... ...

    // 根据不同的逐出策略, 计算出对应的逐出优先级数值(idle)
    /* Calculate the idle time according to the policy. This is called
     * idle just because the code initially handled LRU, but is in fact
     * just a score where an higher score means better candidate. */
    if (server.maxmemory_policy & MAXMEMORY_FLAG_LRU) {
        idle = estimateObjectIdleTime(o);
    } else if (server.maxmemory_policy & MAXMEMORY_FLAG_LFU) {
        /* When we use an LRU policy, we sort the keys by idle time
         * so that we expire keys starting from greater idle time.
         * However when the policy is an LFU one, we have a frequency
         * estimation, and we want to evict keys with lower frequency
         * first. So inside the pool we put objects using the inverted
         * frequency subtracting the actual frequency to the maximum
         * frequency of 255. */
        idle = 255-LFUDecrAndReturn(o);
    } else if (server.maxmemory_policy == MAXMEMORY_VOLATILE_TTL) {
        /* In this case the sooner the expire the better. */
        idle = ULLONG_MAX - (long)dictGetVal(de);
    } else {
        serverPanic("Unknown eviction policy in evictionPoolPopulate()");
    }
    // ... ...
    将抽取样本的逐出数据插入以 idle 为评价标准的优先队列 pool (长度为 EVPOOL_SIZE)...
    //... ...
}       

/* This function is periodically called to see if there is memory to free
 * according to the current "maxmemory" settings. In case we are over the
 * memory limit, the function will try to free some memory to return back
 * under the limit.
 *
 * The function returns C_OK if we are under the memory limit or if we
 * were over the limit, but the attempt to free memory was successful.
 * Otherwise if we are over the memory limit, but not enough memory
 * was freed to return back under the limit, the function returns C_ERR. */
int freeMemoryIfNeeded(void) {
    // ... ...
        if (server.maxmemory_policy == MAXMEMORY_NO_EVICTION)
        goto cant_free; /* We need to free memory, but policy forbids. */

    while (mem_freed < mem_tofree) { // 杨领well注: 每轮逐出一个 bestkey
        // ... ...
        if (server.maxmemory_policy & (MAXMEMORY_FLAG_LRU|MAXMEMORY_FLAG_LFU) ||
            server.maxmemory_policy == MAXMEMORY_VOLATILE_TTL)
        {
            //... ...
            /* We don't want to make local-db choices when expiring keys,
             * so to start populate the eviction pool sampling keys from
             * every DB. */
            for (i = 0; i < server.dbnum; i++) {
                db = server.db+i;
                // 杨领well注: MAXMEMORY_FLAG_ALLKEYS 代表所有 key 都可以逐出，
                // 因此从存全量数据的 dict 选取待逐出的 key。 如果没有标记 MAXMEMORY_FLAG_ALLKEYS
                // 则只能逐出有过期时间的 key，因此从过期 dict 中选取逐出 key
                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;
                }
            }
            // ... ...
            从 pool 保存的逐出样本中，抽取逐出评价数值(idle)最高的key进行逐出...
            //... ...
        }
        else if (server.maxmemory_policy == MAXMEMORY_ALLKEYS_RANDOM ||
                 server.maxmemory_policy == MAXMEMORY_VOLATILE_RANDOM)
        {
            /* When evicting a random key, we try to evict a key for
            * each DB, so we use the static 'next_db' variable to
            * incrementally visit all DBs. */
            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;
                }
            }
        }
        /* Finally remove the selected key. */
        if (bestkey) {
            // ... ...
            propagateExpire(db,keyobj,server.lazyfree_lazy_eviction);
            // ... ...
            if (server.lazyfree_lazy_eviction)
                dbAsyncDelete(db,keyobj);
            else
                dbSyncDelete(db,keyobj);
            // ... ...
        }
    }
cant_free:
    /* We are here if we are not able to reclaim memory. There is only one
     * last thing we can try: check if the lazyfree thread has jobs in queue
     * and wait... */
    if (result != C_OK) {
        //... ...
        while(bioPendingJobsOfType(BIO_LAZY_FREE)) { // 如果需要资源，且 lazy_free 队列有数据，就会阻塞在这里等待消费完成
            if (getMaxmemoryState(NULL,NULL,NULL,NULL) == C_OK) {
                result = C_OK;
                break;
            }
            usleep(1000);
        }
        //... ...
    }
}

扩展阅读

• lru-cache - redis.io
• Random notes on improving the Redis LRU algorithm - antirez.com
• Counting Large Numbers of Events in Small Registers - Robert Morris Bell Laboratories, Murray Hill, N.J.