Use the RSC to replicate EVALSHA unmodified.

This commit uses the Replication Script Cache in order to avoid
translating EVALSHA into EVAL whenever possible for both the AOF and
slaves.

src/aof.c

@@ -998,6 +998,7 @@ int rewriteAppendOnlyFileBackground(void) {
          * accumulated by the parent into server.aof_rewrite_buf will start
          * with a SELECT statement and it will be safe to merge. */
         server.aof_selected_db = -1;
+        replicationScriptCacheFlush();
         return REDIS_OK;
     }
     return REDIS_OK; /* unreached */

src/redis.c

@@ -565,10 +565,10 @@ dictType keylistDictType = {
  * Keys are sds SHA1 strings, while values are not used at all in the current
  * implementation. */
 dictType replScriptCacheDictType = {
-    dictSdsHash,                /* hash function */
+    dictSdsCaseHash,            /* hash function */
     NULL,                       /* key dup */
     NULL,                       /* val dup */
-    dictSdsKeyCompare,          /* key compare */
+    dictSdsKeyCaseCompare,      /* key compare */
     dictSdsDestructor,          /* key destructor */
     NULL                        /* val destructor */
 };

src/redis.h

@@ -999,6 +999,10 @@ void replicationHandleMasterDisconnection(void);
 void replicationCacheMaster(redisClient *c);
 void resizeReplicationBacklog(long long newsize);
 void refreshGoodSlavesCount(void);
+void replicationScriptCacheInit(void);
+void replicationScriptCacheFlush(void);
+void replicationScriptCacheAdd(sds sha1);
+int replicationScriptCacheExists(sds sha1);
 
 /* Generic persistence functions */
 void startLoading(FILE *fp);

src/replication.c

@@ -546,6 +546,8 @@ void syncCommand(redisClient *c) {
             return;
         }
         c->replstate = REDIS_REPL_WAIT_BGSAVE_END;
+        /* Flush the script cache for the new slave. */
+        replicationScriptCacheFlush();
     }
 
     if (server.repl_disable_tcp_nodelay)
@@ -711,6 +713,11 @@ void updateSlavesWaitingBgsave(int bgsaveerr) {
         }
     }
     if (startbgsave) {
+        /* Since we are starting a new background save for one or more slaves,
+         * we flush the Replication Script Cache to use EVAL to propagate every
+         * new EVALSHA for the first time, since all the new slaves don't know
+         * about previous scripts. */
+        replicationScriptCacheFlush();
         if (rdbSaveBackground(server.rdb_filename) != REDIS_OK) {
             listIter li;
 
@@ -1451,10 +1458,16 @@ void replicationScriptCacheInit(void) {
 }
 
 /* Empty the script cache. Should be called every time we are no longer sure
- * that every slave knows about all the scripts in our set, for example
- * every time a new slave connects to this master and performs a full
- * resynchronization. There is no need to flush the cache when a partial
- * resynchronization is performed. */
+ * that every slave knows about all the scripts in our set, or when the
+ * current AOF "context" is no longer aware of the script. In general we
+ * should flush the cache:
+ *
+ * 1) Every time a new slave reconnects to this master and performs a
+ *    full SYNC (PSYNC does not require flushing).
+ * 2) Every time an AOF rewrite is performed.
+ * 3) Every time we are left without slaves at all, and AOF is off, in order
+ *    to reclaim otherwise unused memory.
+ */
 void replicationScriptCacheFlush(void) {
     dictEmpty(server.repl_scriptcache_dict);
     listRelease(server.repl_scriptcache_fifo);
@@ -1487,7 +1500,7 @@ void replicationScriptCacheAdd(sds sha1) {
 /* Returns non-zero if the specified entry exists inside the cache, that is,
  * if all the slaves are aware of this script SHA1. */
 int replicationScriptCacheExists(sds sha1) {
-    return dictFetchValue(server.repl_scriptcache_dict,sha1) != NULL;
+    return dictFind(server.repl_scriptcache_dict,sha1) != NULL;
 }
 
 /* --------------------------- REPLICATION CRON  ----------------------------- */
@@ -1604,6 +1617,16 @@ void replicationCron(void) {
         }
     }
 
+    /* If AOF is disabled and we no longer have attached slaves, we can
+     * free our Replication Script Cache as there is no need to propagate
+     * EVALSHA at all. */
+    if (listLength(server.slaves) == 0 &&
+        server.aof_state == REDIS_AOF_OFF &&
+        listLength(server.repl_scriptcache_fifo) != 0)
+    {
+        replicationScriptCacheFlush();
+    }
+
     /* Refresh the number of slaves with lag <= min-slaves-max-lag. */
     refreshGoodSlavesCount();
 }

src/scripting.c

@@ -655,6 +655,10 @@ void scriptingInit(void) {
      * to global variables. */
     scriptingEnableGlobalsProtection(lua);
 
+    /* Initialize the Replication Script Cache for EVALSHA propagation to
+     * slaves and AOF. */
+    replicationScriptCacheInit();
+
     server.lua = lua;
 }
 
@@ -931,23 +935,29 @@ void evalGenericCommand(redisClient *c, int evalsha) {
         luaReplyToRedisReply(c,lua);
     }
 
-    /* If we have slaves attached we want to replicate this command as
-     * EVAL instead of EVALSHA. We do this also in the AOF as currently there
-     * is no easy way to propagate a command in a different way in the AOF
-     * and in the replication link.
+    /* EVALSHA should be propagated to Slave and AOF file as full EVAL, unless
+     * we are sure that the script was already in the context of all the
+     * attached slaves *and* the current AOF file if enabled.
+     *
+     * To do so we use a cache of SHA1s of scripts that we already propagated
+     * as full EVAL, that's called the Replication Script Cache.
      *
-     * IMPROVEMENT POSSIBLE:
-     * 1) Replicate this command as EVALSHA in the AOF.
-     * 2) Remember what slave already received a given script, and replicate
-     *    the EVALSHA against this slaves when possible.
-     */
+     * For repliation, everytime a new slave attaches to the master, we need to
+     * flush our cache of scripts that can be replicated as EVALSHA, while
+     * for AOF we need to do so every time we rewrite the AOF file. */
     if (evalsha) {
-        robj *script = dictFetchValue(server.lua_scripts,c->argv[1]->ptr);
-
-        redisAssertWithInfo(c,NULL,script != NULL);
-        rewriteClientCommandArgument(c,0,
-            resetRefCount(createStringObject("EVAL",4)));
-        rewriteClientCommandArgument(c,1,script);
+        if (!replicationScriptCacheExists(c->argv[1]->ptr)) {
+            /* This script is not in our script cache, replicate it as
+             * EVAL, then add it into the script cache, as from now on
+             * slaves and AOF know about it. */
+            robj *script = dictFetchValue(server.lua_scripts,c->argv[1]->ptr);
+
+            replicationScriptCacheAdd(c->argv[1]->ptr);
+            redisAssertWithInfo(c,NULL,script != NULL);
+            rewriteClientCommandArgument(c,0,
+                resetRefCount(createStringObject("EVAL",4)));
+            rewriteClientCommandArgument(c,1,script);
+        }
     }
 }