Redis中LRU淘汰策略的深入分析

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;

robj *lookupkey(redisdb *db, robj *key, int flags) {
 dictentry *de = dictfind(db->dict,key->ptr);
 if (de) {
  robj *val = dictgetval(de);

  /* update the access time for the ageing algorithm.
   * don't do it if we have a saving child, as this will trigger
   * a copy on write madness. */
  if (server.rdb_child_pid == -1 &&
   server.aof_child_pid == -1 &&
   !(flags & lookup_notouch))
  {
   if (server.maxmemory_policy & maxmemory_flag_lfu) {
    updatelfu(val);
   } else {
    val->lru = lru_clock();
   }
  }
  return val;
 } else {
  return null;
 }
}

/* return the lru clock, based on the clock resolution. this is a time
 * in a reduced-bits format that can be used to set and check the
 * object->lru field of redisobject structures. */
unsigned int getlruclock(void) {
 return (mstime()/lru_clock_resolution) & lru_clock_max;
}

/* this function is used to obtain the current lru clock.
 * if the current resolution is lower than the frequency we refresh the
 * lru clock (as it should be in production servers) we return the
 * precomputed value, otherwise we need to resort to a system call. */
unsigned int lru_clock(void) {
 unsigned int lruclock;
 if (1000/server.hz <= lru_clock_resolution) {
  atomicget(server.lruclock,lruclock);
 } else {
  lruclock = getlruclock();
 }
 return lruclock;
}

int processcommand(client *c) {

 /* handle the maxmemory directive.
  *
  * note that we do not want to reclaim memory if we are here re-entering
  * the event loop since there is a busy lua script running in timeout
  * condition, to avoid mixing the propagation of scripts with the
  * propagation of dels due to eviction. */
 if (server.maxmemory && !server.lua_timedout) {
  int out_of_memory = freememoryifneededandsafe() == c_err;
  /* freememoryifneeded may flush slave output buffers. this may result
   * into a slave, that may be the active client, to be freed. */
  if (server.current_client == null) return c_err;

  /* it was impossible to free enough memory, and the command the client
   * is trying to execute is denied during oom conditions or the client
   * is in multi/exec context? error. */
  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;
  }
 }
}

int freememoryifneeded(void) {
 /* by default replicas should ignore maxmemory
  * and just be masters exact copies. */
 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);

 /* when clients are paused the dataset should be static not just from the
  * pov of clients not being able to write, but also from the pov of
  * expires and evictions of keys not being performed. */
 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;

  if (server.maxmemory_policy & (maxmemory_flag_lru|maxmemory_flag_lfu) ||
   server.maxmemory_policy == maxmemory_volatile_ttl)
  {
   struct evictionpoolentry *pool = evictionpoollru;

   while(bestkey == null) {
    unsigned long total_keys = 0, keys;

    /* 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;
     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; /* no keys to evict. */

    /* go backward from best to worst element to evict. */
    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);
     }

     /* remove the entry from the pool. */
     if (pool[k].key != pool[k].cached)
      sdsfree(pool[k].key);
     pool[k].key = null;
     pool[k].idle = 0;

     /* if the key exists, is our pick. otherwise it is
      * a ghost and we need to try the next element. */
     if (de) {
      bestkey = dictgetkey(de);
      break;
     } else {
      /* ghost... iterate again. */
     }
    }
   }
  }

  /* volatile-random and allkeys-random policy */
  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) {
   db = server.db+bestdbid;
   robj *keyobj = createstringobject(bestkey,sdslen(bestkey));
   propagateexpire(db,keyobj,server.lazyfree_lazy_eviction);
   /* we compute the amount of memory freed by db*delete() alone.
    * it is possible that actually the memory needed to propagate
    * the del in aof and replication link is greater than the one
    * we are freeing removing the key, but we can't account for
    * that otherwise we would never exit the loop.
    *
    * aof and output buffer memory will be freed eventually so
    * we only care about memory used by the key space. */
   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++;

   /* when the memory to free starts to be big enough, we may
    * start spending so much time here that is impossible to
    * deliver data to the slaves fast enough, so we force the
    * transmission here inside the loop. */
   if (slaves) flushslavesoutputbuffers();

   /* normally our stop condition is the ability to release
    * a fixed, pre-computed amount of memory. however when we
    * are deleting objects in another thread, it's better to
    * check, from time to time, if we already reached our target
    * memory, since the "mem_freed" amount is computed only
    * across the dbasyncdelete() call, while the thread can
    * release the memory all the time. */
   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:
 /* 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... */
 while(biopendingjobsoftype(bio_lazy_free)) {
  if (((mem_reported - zmalloc_used_memory()) + mem_freed) >= mem_tofree)
   break;
  usleep(1000);
 }
 return c_err;
}

/* this is a wrapper for freememoryifneeded() that only really calls the
 * function if right now there are the conditions to do so safely:
 *
 * - there must be no script in timeout condition.
 * - nor we are loading data right now.
 *
 */
int freememoryifneededandsafe(void) {
 if (server.lua_timedout || server.loading) return c_ok;
 return freememoryifneeded();
}

void evictionpoolpopulate(int dbid, dict *sampledict, dict *keydict, struct evictionpoolentry *pool) {
 int j, k, count;
 dictentry *samples[server.maxmemory_samples];

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

  /* if the dictionary we are sampling from is not the main
   * dictionary (but the expires one) we need to lookup the key
   * again in the key dictionary to obtain the value object. */
  if (server.maxmemory_policy != maxmemory_volatile_ttl) {
   if (sampledict != keydict) de = dictfind(keydict, key);
   o = dictgetval(de);
  }

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

  /* insert the element inside the pool.
   * first, find the first empty bucket or the first populated
   * bucket that has an idle time smaller than our idle time. */
  k = 0;
  while (k < evpool_size &&
    pool[k].key &&
    pool[k].idle < idle) k++;
  if (k == 0 && pool[evpool_size-1].key != null) {
   /* can't insert if the element is < the worst element we have
    * and there are no empty buckets. */
   continue;
  } else if (k < evpool_size && pool[k].key == null) {
   /* inserting into empty position. no setup needed before insert. */
  } else {
   /* inserting in the middle. now k points to the first element
    * greater than the element to insert. */
   if (pool[evpool_size-1].key == null) {
    /* free space on the right? insert at k shifting
     * all the elements from k to end to the right. */

    /* save sds before overwriting. */
    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 {
    /* no free space on right? insert at k-1 */
    k--;
    /* shift all elements on the left of k (included) to the
     * left, so we discard the element with smaller idle time. */
    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;
   }
  }

  /* try to reuse the cached sds string allocated in the pool entry,
   * because allocating and deallocating this object is costly
   * (according to the profiler, not my fantasy. remember:
   * premature optimizbla bla bla bla. */
  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;
 }
}

/* given an object returns the min number of milliseconds the object was never
 * requested, using an approximated lru algorithm. */
unsigned long long estimateobjectidletime(robj *o) {
 unsigned long long lruclock = lru_clock();
 if (lruclock >= o->lru) {
  return (lruclock - o->lru) * lru_clock_resolution;
 } else {
  return (lruclock + (lru_clock_max - o->lru)) *
     lru_clock_resolution;
 }
}