Redis timer interrupt frequency configurable as REDIS_HZ.

Redis uses a function called serverCron() that is very similar to the
timer interrupt of an operating system. This function is used to handle
a number of asynchronous things, like active expired keys collection,
clients timeouts, update of statistics, things related to the cluster
and replication, triggering of BGSAVE and AOF rewrite process, and so
forth.

In the past the timer was called 1 time per second. At some point it was
raised to 10 times per second, but it still was fixed and could not be
changed even at compile time, because different functions called from
serverCron() assumed a given fixed frequency.

This commmit makes the frequency configurable, so that it is simpler to
pick a good tradeoff between overhead of this function (that is usually
very small) and the responsiveness of Redis during a few critical
circumstances where a lot of work is done inside the timer.

An example of such a critical condition is mass-expire of a lot of keys
in the same second. Up to a given percentage of CPU time is used to
perform expired keys collection per expire cylce. Now changing the
REDIS_HZ macro it is possible to do less work but more times per second
in order to block the server for less time.

If this patch will work well in our tests it will enter Redis 2.6-final.

diff --git a/src/redis.c b/src/redis.c
index ecf02e0a3782189278461b9543219257efd7514b..7505de489f3571113ace547b7e35890bed995bf7 100644 (file)
--- a/src/redis.c
+++ b/src/redis.c
@@ -609,7 +609,14 @@ void updateDictResizePolicy(void) {
  * keys that can be removed from the keyspace. */
 void activeExpireCycle(void) {
     int j;
  * keys that can be removed from the keyspace. */
 void activeExpireCycle(void) {
     int j;

-    long long start = mstime();
+    long long start = mstime(), timelimit;
+
+    /* We can use at max REDIS_EXPIRELOOKUPS_TIME_PERC percentage of CPU time
+     * per iteration. Since this function gets called with a frequency of
+     * REDIS_HZ times per second, the following is the max amount of
+     * milliseconds we can spend here: */
+    timelimit = (1000/REDIS_HZ/100)*REDIS_EXPIRELOOKUPS_TIME_PERC;
+    if (timelimit <= 0) timelimit = 1;

 
     for (j = 0; j < server.dbnum; j++) {
         int expired, iteration = 0;
 
     for (j = 0; j < server.dbnum; j++) {
         int expired, iteration = 0;


@@ -646,7 +653,7 @@ void activeExpireCycle(void) {
              * caller waiting for the other active expire cycle. */
             iteration++;
             if ((iteration & 0xff) == 0 && /* Check once every 255 iterations */
              * caller waiting for the other active expire cycle. */
             iteration++;
             if ((iteration & 0xff) == 0 && /* Check once every 255 iterations */

-                (mstime()-start) > REDIS_EXPIRELOOKUPS_TIME_LIMIT) return;
+                (mstime()-start) > timelimit) return;

         } while (expired > REDIS_EXPIRELOOKUPS_PER_CRON/4);
     }
 }
         } while (expired > REDIS_EXPIRELOOKUPS_PER_CRON/4);
     }
 }


@@ -732,13 +739,13 @@ int clientsCronResizeQueryBuffer(redisClient *c) {
 }
 
 void clientsCron(void) {
 }
 
 void clientsCron(void) {

-    /* Make sure to process at least 1/100 of clients per call.
-     * Since this function is called 10 times per second we are sure that
+    /* Make sure to process at least 1/(REDIS_HZ*10) of clients per call.
+     * Since this function is called REDIS_HZ times per second we are sure that

      * in the worst case we process all the clients in 10 seconds.
      * In normal conditions (a reasonable number of clients) we process
      * all the clients in a shorter time. */
     int numclients = listLength(server.clients);
      * in the worst case we process all the clients in 10 seconds.
      * In normal conditions (a reasonable number of clients) we process
      * all the clients in a shorter time. */
     int numclients = listLength(server.clients);

-    int iterations = numclients/100;
+    int iterations = numclients/(REDIS_HZ*10);

 
     if (iterations < 50)
         iterations = (numclients < 50) ? numclients : 50;
 
     if (iterations < 50)
         iterations = (numclients < 50) ? numclients : 50;


@@ -760,6 +767,30 @@ void clientsCron(void) {
     }
 }
 
     }
 }
 

+/* This is our timer interrupt, called REDIS_HZ times per second.
+ * Here is where we do a number of things that need to be done asynchronously.
+ * For instance:
+ *
+ * - Active expired keys collection (it is also performed in a lazy way on
+ *   lookup).
+ * - Software watchdong.
+ * - Update some statistic.
+ * - Incremental rehashing of the DBs hash tables.
+ * - Triggering BGSAVE / AOF rewrite, and handling of terminated children.
+ * - Clients timeout of differnet kinds.
+ * - Replication reconnection.
+ * - Many more...
+ *
+ * Everything directly called here will be called REDIS_HZ times per second,
+ * so in order to throttle execution of things we want to do less frequently
+ * a macro is used: run_with_period(milliseconds) { .... }
+ */
+
+/* Using the following macro you can run code inside serverCron() with the
+ * specified period, specified in milliseconds.
+ * The actual resolution depends on REDIS_HZ. */
+#define run_with_period(_ms_) if (!(loops % ((_ms_)/(1000/REDIS_HZ))))
+

 int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
     int j, loops = server.cronloops;
     REDIS_NOTUSED(eventLoop);
 int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
     int j, loops = server.cronloops;
     REDIS_NOTUSED(eventLoop);


@@ -776,7 +807,7 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
      * To access a global var is faster than calling time(NULL) */
     server.unixtime = time(NULL);
 
      * To access a global var is faster than calling time(NULL) */
     server.unixtime = time(NULL);
 

-    trackOperationsPerSecond();
+    run_with_period(100) trackOperationsPerSecond();

 
     /* We have just 22 bits per object for LRU information.
      * So we use an (eventually wrapping) LRU clock with 10 seconds resolution.
 
     /* We have just 22 bits per object for LRU information.
      * So we use an (eventually wrapping) LRU clock with 10 seconds resolution.


@@ -804,15 +835,17 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
     }
 
     /* Show some info about non-empty databases */
     }
 
     /* Show some info about non-empty databases */

-    for (j = 0; j < server.dbnum; j++) {
-        long long size, used, vkeys;
-
-        size = dictSlots(server.db[j].dict);
-        used = dictSize(server.db[j].dict);
-        vkeys = dictSize(server.db[j].expires);
-        if (!(loops % 50) && (used || vkeys)) {
-            redisLog(REDIS_VERBOSE,"DB %d: %lld keys (%lld volatile) in %lld slots HT.",j,used,vkeys,size);
-            /* dictPrintStats(server.dict); */
+    run_with_period(5000) {
+        for (j = 0; j < server.dbnum; j++) {
+            long long size, used, vkeys;
+
+            size = dictSlots(server.db[j].dict);
+            used = dictSize(server.db[j].dict);
+            vkeys = dictSize(server.db[j].expires);
+            if (used || vkeys) {
+                redisLog(REDIS_VERBOSE,"DB %d: %lld keys (%lld volatile) in %lld slots HT.",j,used,vkeys,size);
+                /* dictPrintStats(server.dict); */
+            }

         }
     }
 
         }
     }
 


@@ -823,12 +856,12 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
      * a lot of memory movements in the parent will cause a lot of pages
      * copied. */
     if (server.rdb_child_pid == -1 && server.aof_child_pid == -1) {
      * a lot of memory movements in the parent will cause a lot of pages
      * copied. */
     if (server.rdb_child_pid == -1 && server.aof_child_pid == -1) {

-        if (!(loops % 10)) tryResizeHashTables();
+        run_with_period(1000) tryResizeHashTables();

         if (server.activerehashing) incrementallyRehash();
     }
 
     /* Show information about connected clients */
         if (server.activerehashing) incrementallyRehash();
     }
 
     /* Show information about connected clients */

-    if (!(loops % 50)) {
+    run_with_period(5000) {

         redisLog(REDIS_VERBOSE,"%d clients connected (%d slaves), %zu bytes in use",
             listLength(server.clients)-listLength(server.slaves),
             listLength(server.slaves),
         redisLog(REDIS_VERBOSE,"%d clients connected (%d slaves), %zu bytes in use",
             listLength(server.clients)-listLength(server.slaves),
             listLength(server.slaves),


@@ -910,10 +943,10 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
 
     /* Replication cron function -- used to reconnect to master and
      * to detect transfer failures. */
 
     /* Replication cron function -- used to reconnect to master and
      * to detect transfer failures. */

-    if (!(loops % 10)) replicationCron();
+    run_with_period(1000) replicationCron();

 
     server.cronloops++;
 
     server.cronloops++;

-    return 100;
+    return 1000/REDIS_HZ;

 }
 
 /* This function gets called every time Redis is entering the
 }
 
 /* This function gets called every time Redis is entering the

diff --git a/src/redis.h b/src/redis.h
index b842b5f79057772f5d1b4e2e64f8724ac3e127d6..d476c72478f3dfce081198fdeb954e9a2cce8f23 100644 (file)
--- a/src/redis.h
+++ b/src/redis.h
@@ -38,12 +38,13 @@
 #define REDIS_ERR               -1
 
 /* Static server configuration */
 #define REDIS_ERR               -1
 
 /* Static server configuration */

+#define REDIS_HZ                10      /* Time interrupt calls/sec. */

 #define REDIS_SERVERPORT        6379    /* TCP port */
 #define REDIS_MAXIDLETIME       0       /* default client timeout: infinite */
 #define REDIS_DEFAULT_DBNUM     16
 #define REDIS_CONFIGLINE_MAX    1024
 #define REDIS_EXPIRELOOKUPS_PER_CRON    10 /* lookup 10 expires per loop */
 #define REDIS_SERVERPORT        6379    /* TCP port */
 #define REDIS_MAXIDLETIME       0       /* default client timeout: infinite */
 #define REDIS_DEFAULT_DBNUM     16
 #define REDIS_CONFIGLINE_MAX    1024
 #define REDIS_EXPIRELOOKUPS_PER_CRON    10 /* lookup 10 expires per loop */

-#define REDIS_EXPIRELOOKUPS_TIME_LIMIT 25  /* Time limit in milliseconds */
+#define REDIS_EXPIRELOOKUPS_TIME_PERC   25 /* CPU max % for keys collection */

 #define REDIS_MAX_WRITE_PER_EVENT (1024*64)
 #define REDIS_SHARED_SELECT_CMDS 10
 #define REDIS_SHARED_INTEGERS 10000
 #define REDIS_MAX_WRITE_PER_EVENT (1024*64)
 #define REDIS_SHARED_SELECT_CMDS 10
 #define REDIS_SHARED_INTEGERS 10000