multi bulk requests in redis-benchmark, default fsync policy changed to everysec...

diff --git a/TODO b/TODO
index f904821a2e730343ed4317076ab4b495f5092f62..7c66ddcbe5d3f11b0ae1535b576682f454198743 100644 (file)
--- a/TODO
+++ b/TODO
@@ -1,7 +1,7 @@
 Redis TODO and Roadmap
 
-VERSION 1.4 TODO (Hash type)
-============================
+VERSION 2.0 TODO
+================
 
 * BRPOPLPUSH
 * List ops like L/RPUSH L/RPOP should return the new list length.
@@ -21,7 +21,9 @@ Virtual Memory sub-TODO:
 * Check what happens performance-wise if instead to create threads again and again the same threads are reused forever. Note: this requires a way to disable this clients in the child, but waiting for empty new jobs queue can be enough.
 * Sets of integers are slow to load, for a number of reasons. Fix it. (use slow_sets.rdb file for debugging).
 
-* Hashes (GET/SET/DEL/INCRBY/EXISTS/FIELDS/LEN/MSET/MGET). Special encoding for hashes with < N keys.
+* Hashes (GET/SET/DEL/INCRBY/EXISTS/FIELDS/LEN/MSET/MGET). Special encoding for hashes with less than N elements.
+* Write documentation for APPEND
+* Implement LEN, SUBSTR, PEEK, POKE, SETBIT, GETBIT
 
 VERSION 2.2 TODO (Fault tolerant sharding)
 ===========================================

diff --git a/redis-benchmark.c b/redis-benchmark.c
index 2984efe4139c9fc6740a3f7cdfbfd1ab4310d23b..5bde1c35397096ca6f0c3364db4036072512addb 100644 (file)
--- a/redis-benchmark.c
+++ b/redis-benchmark.c
@@ -525,6 +525,24 @@ int main(int argc, char **argv) {
     }
 
     do {
+        prepareForBenchmark();
+        c = createClient();
+        if (!c) exit(1);
+        c->obuf = sdscat(c->obuf,"PING\r\n");
+        prepareClientForReply(c,REPLY_RETCODE);
+        createMissingClients(c);
+        aeMain(config.el);
+        endBenchmark("PING");
+
+        prepareForBenchmark();
+        c = createClient();
+        if (!c) exit(1);
+        c->obuf = sdscat(c->obuf,"*1\r\n$4\r\nPING\r\n");
+        prepareClientForReply(c,REPLY_RETCODE);
+        createMissingClients(c);
+        aeMain(config.el);
+        endBenchmark("PING (multi bulk)");
+
         prepareForBenchmark();
         c = createClient();
         if (!c) exit(1);
@@ -577,15 +595,6 @@ int main(int argc, char **argv) {
         aeMain(config.el);
         endBenchmark("LPOP");
 
-        prepareForBenchmark();
-        c = createClient();
-        if (!c) exit(1);
-        c->obuf = sdscat(c->obuf,"PING\r\n");
-        prepareClientForReply(c,REPLY_RETCODE);
-        createMissingClients(c);
-        aeMain(config.el);
-        endBenchmark("PING");
-
         prepareForBenchmark();
         c = createClient();
         if (!c) exit(1);

diff --git a/redis.c b/redis.c
index 3326516864a206582ee685823d034a9143fffbfc..2f5abc8a332b3c8d8676a0aeefc5b75523e7a246 100644 (file)
--- a/redis.c
+++ b/redis.c
@@ -873,7 +873,7 @@ static void redisLog(int level, const char *fmt, ...) {
 
     va_start(ap, fmt);
     if (level >= server.verbosity) {
-        char *c = ".-*";
+        char *c = ".-*#";
         char buf[64];
         time_t now;
 

diff --git a/redis.conf b/redis.conf
index 8b8f34a7d05ae4ea63975728a36ca7ada3ca7da3..0f5fe34efd886abef1a199571b16542cbd17bf92 100644 (file)
--- a/redis.conf
+++ b/redis.conf
@@ -158,14 +158,18 @@ appendonly no
 # always: fsync after every write to the append only log . Slow, Safest.
 # everysec: fsync only if one second passed since the last fsync. Compromise.
 #
-# The default is "always" that's the safer of the options. It's up to you to
-# understand if you can relax this to "everysec" that will fsync every second
-# or to "no" that will let the operating system flush the output buffer when
-# it want, for better performances (but if you can live with the idea of
-# some data loss consider the default persistence mode that's snapshotting).
-
-appendfsync always
-# appendfsync everysec
+# The default is "everysec" that's usually the right compromise between
+# speed and data safety. It's up to you to understand if you can relax this to
+# "no" that will will let the operating system flush the output buffer when
+# it wants, for better performances (but if you can live with the idea of
+# some data loss consider the default persistence mode that's snapshotting),
+# or on the contrary, use "always" that's very slow but a bit safer than
+# everysec.
+#
+# If unsure, use "everysec".
+
+# appendfsync always
+appendfsync everysec
 # appendfsync no
 
 ################################ VIRTUAL MEMORY ###############################