RSS aware maxmemory: algorith #1 implemented.

CONTRIBUTING

@@ -20,7 +20,7 @@ each source file that you contribute.
 
 # How to provide a patch for a new feature
 
-1. If it is a major feature or a semantical change, write an RCP (Redis Change Proposal). Check the documentation here: https://github.com/redis/redis-rcp
+1. Drop a message to the Redis Google Group with a proposal of semantics/API.
 
 2. If in step 1 you get an acknowledge from the project leaders, use the
    following procedure to submit a patch:
@@ -31,6 +31,4 @@ each source file that you contribute.
     d. Initiate a pull request on github ( http://help.github.com/send-pull-requests/ )
     e. Done :)
 
-For minor fixes just open a pull request on Github.
-
 Thanks!

deps/Makefile

@@ -58,7 +58,7 @@ ifeq ($(uname_S),SunOS)
 	LUA_CFLAGS= -D__C99FEATURES__=1
 endif
 
-LUA_CFLAGS+= -O2 -Wall -DLUA_ANSI -DENABLE_CJSON_GLOBAL -DREDIS_STATIC='' $(CFLAGS)
+LUA_CFLAGS+= -O2 -Wall -DLUA_ANSI $(CFLAGS)
 LUA_LDFLAGS+= $(LDFLAGS)
 # lua's Makefile defines AR="ar rcu", which is unusual, and makes it more
 # challenging to cross-compile lua (and redis).  These defines make it easier

deps/lua/src/Makefile

@@ -25,10 +25,9 @@ PLATS= aix ansi bsd freebsd generic linux macosx mingw posix solaris
 LUA_A=	liblua.a
 CORE_O=	lapi.o lcode.o ldebug.o ldo.o ldump.o lfunc.o lgc.o llex.o lmem.o \
 	lobject.o lopcodes.o lparser.o lstate.o lstring.o ltable.o ltm.o  \
-	lundump.o lvm.o lzio.o strbuf.o fpconv.o
+	lundump.o lvm.o lzio.o strbuf.o
 LIB_O=	lauxlib.o lbaselib.o ldblib.o liolib.o lmathlib.o loslib.o ltablib.o \
-	lstrlib.o loadlib.o linit.o lua_cjson.o lua_struct.o lua_cmsgpack.o \
-	lua_bit.o
+	lstrlib.o loadlib.o linit.o lua_cjson.o lua_struct.o lua_cmsgpack.o
 
 LUA_T=	lua
 LUA_O=	lua.o

deps/lua/src/fpconv.c

@@ -1,205 +0,0 @@
-/* fpconv - Floating point conversion routines
- *
- * Copyright (c) 2011-2012  Mark Pulford <mark@kyne.com.au>
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-/* JSON uses a '.' decimal separator. strtod() / sprintf() under C libraries
- * with locale support will break when the decimal separator is a comma.
- *
- * fpconv_* will around these issues with a translation buffer if required.
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <assert.h>
-#include <string.h>
-
-#include "fpconv.h"
-
-/* Lua CJSON assumes the locale is the same for all threads within a
- * process and doesn't change after initialisation.
- *
- * This avoids the need for per thread storage or expensive checks
- * for call. */
-static char locale_decimal_point = '.';
-
-/* In theory multibyte decimal_points are possible, but
- * Lua CJSON only supports UTF-8 and known locales only have
- * single byte decimal points ([.,]).
- *
- * localconv() may not be thread safe (=>crash), and nl_langinfo() is
- * not supported on some platforms. Use sprintf() instead - if the
- * locale does change, at least Lua CJSON won't crash. */
-static void fpconv_update_locale()
-{
-    char buf[8];
-
-    snprintf(buf, sizeof(buf), "%g", 0.5);
-
-    /* Failing this test might imply the platform has a buggy dtoa
-     * implementation or wide characters */
-    if (buf[0] != '0' || buf[2] != '5' || buf[3] != 0) {
-        fprintf(stderr, "Error: wide characters found or printf() bug.");
-        abort();
-    }
-
-    locale_decimal_point = buf[1];
-}
-
-/* Check for a valid number character: [-+0-9a-yA-Y.]
- * Eg: -0.6e+5, infinity, 0xF0.F0pF0
- *
- * Used to find the probable end of a number. It doesn't matter if
- * invalid characters are counted - strtod() will find the valid
- * number if it exists.  The risk is that slightly more memory might
- * be allocated before a parse error occurs. */
-static inline int valid_number_character(char ch)
-{
-    char lower_ch;
-
-    if ('0' <= ch && ch <= '9')
-        return 1;
-    if (ch == '-' || ch == '+' || ch == '.')
-        return 1;
-
-    /* Hex digits, exponent (e), base (p), "infinity",.. */
-    lower_ch = ch | 0x20;
-    if ('a' <= lower_ch && lower_ch <= 'y')
-        return 1;
-
-    return 0;
-}
-
-/* Calculate the size of the buffer required for a strtod locale
- * conversion. */
-static int strtod_buffer_size(const char *s)
-{
-    const char *p = s;
-
-    while (valid_number_character(*p))
-        p++;
-
-    return p - s;
-}
-
-/* Similar to strtod(), but must be passed the current locale's decimal point
- * character. Guaranteed to be called at the start of any valid number in a string */
-double fpconv_strtod(const char *nptr, char **endptr)
-{
-    char localbuf[FPCONV_G_FMT_BUFSIZE];
-    char *buf, *endbuf, *dp;
-    int buflen;
-    double value;
-
-    /* System strtod() is fine when decimal point is '.' */
-    if (locale_decimal_point == '.')
-        return strtod(nptr, endptr);
-
-    buflen = strtod_buffer_size(nptr);
-    if (!buflen) {
-        /* No valid characters found, standard strtod() return */
-        *endptr = (char *)nptr;
-        return 0;
-    }
-
-    /* Duplicate number into buffer */
-    if (buflen >= FPCONV_G_FMT_BUFSIZE) {
-        /* Handle unusually large numbers */
-        buf = malloc(buflen + 1);
-        if (!buf) {
-            fprintf(stderr, "Out of memory");
-            abort();
-        }
-    } else {
-        /* This is the common case.. */
-        buf = localbuf;
-    }
-    memcpy(buf, nptr, buflen);
-    buf[buflen] = 0;
-
-    /* Update decimal point character if found */
-    dp = strchr(buf, '.');
-    if (dp)
-        *dp = locale_decimal_point;
-
-    value = strtod(buf, &endbuf);
-    *endptr = (char *)&nptr[endbuf - buf];
-    if (buflen >= FPCONV_G_FMT_BUFSIZE)
-        free(buf);
-
-    return value;
-}
-
-/* "fmt" must point to a buffer of at least 6 characters */
-static void set_number_format(char *fmt, int precision)
-{
-    int d1, d2, i;
-
-    assert(1 <= precision && precision <= 14);
-
-    /* Create printf format (%.14g) from precision */
-    d1 = precision / 10;
-    d2 = precision % 10;
-    fmt[0] = '%';
-    fmt[1] = '.';
-    i = 2;
-    if (d1) {
-        fmt[i++] = '0' + d1;
-    }
-    fmt[i++] = '0' + d2;
-    fmt[i++] = 'g';
-    fmt[i] = 0;
-}
-
-/* Assumes there is always at least 32 characters available in the target buffer */
-int fpconv_g_fmt(char *str, double num, int precision)
-{
-    char buf[FPCONV_G_FMT_BUFSIZE];
-    char fmt[6];
-    int len;
-    char *b;
-
-    set_number_format(fmt, precision);
-
-    /* Pass through when decimal point character is dot. */
-    if (locale_decimal_point == '.')
-        return snprintf(str, FPCONV_G_FMT_BUFSIZE, fmt, num);
-
-    /* snprintf() to a buffer then translate for other decimal point characters */
-    len = snprintf(buf, FPCONV_G_FMT_BUFSIZE, fmt, num);
-
-    /* Copy into target location. Translate decimal point if required */
-    b = buf;
-    do {
-        *str++ = (*b == locale_decimal_point ? '.' : *b);
-    } while(*b++);
-
-    return len;
-}
-
-void fpconv_init()
-{
-    fpconv_update_locale();
-}
-
-/* vi:ai et sw=4 ts=4:
- */

deps/lua/src/fpconv.h

@@ -1,22 +0,0 @@
-/* Lua CJSON floating point conversion routines */
-
-/* Buffer required to store the largest string representation of a double.
- *
- * Longest double printed with %.14g is 21 characters long:
- * -1.7976931348623e+308 */
-# define FPCONV_G_FMT_BUFSIZE   32
-
-#ifdef USE_INTERNAL_FPCONV
-static inline void fpconv_init()
-{
-    /* Do nothing - not required */
-}
-#else
-extern void fpconv_init();
-#endif
-
-extern int fpconv_g_fmt(char*, double, int);
-extern double fpconv_strtod(const char*, char**);
-
-/* vi:ai et sw=4 ts=4:
- */

deps/lua/src/lua_bit.c

@@ -1,189 +0,0 @@
-/*
-** Lua BitOp -- a bit operations library for Lua 5.1/5.2.
-** http://bitop.luajit.org/
-**
-** Copyright (C) 2008-2012 Mike Pall. All rights reserved.
-**
-** Permission is hereby granted, free of charge, to any person obtaining
-** a copy of this software and associated documentation files (the
-** "Software"), to deal in the Software without restriction, including
-** without limitation the rights to use, copy, modify, merge, publish,
-** distribute, sublicense, and/or sell copies of the Software, and to
-** permit persons to whom the Software is furnished to do so, subject to
-** the following conditions:
-**
-** The above copyright notice and this permission notice shall be
-** included in all copies or substantial portions of the Software.
-**
-** THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-** SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-**
-** [ MIT license: http://www.opensource.org/licenses/mit-license.php ]
-*/
-
-#define LUA_BITOP_VERSION	"1.0.2"
-
-#define LUA_LIB
-#include "lua.h"
-#include "lauxlib.h"
-
-#ifdef _MSC_VER
-/* MSVC is stuck in the last century and doesn't have C99's stdint.h. */
-typedef __int32 int32_t;
-typedef unsigned __int32 uint32_t;
-typedef unsigned __int64 uint64_t;
-#else
-#include <stdint.h>
-#endif
-
-typedef int32_t SBits;
-typedef uint32_t UBits;
-
-typedef union {
-  lua_Number n;
-#ifdef LUA_NUMBER_DOUBLE
-  uint64_t b;
-#else
-  UBits b;
-#endif
-} BitNum;
-
-/* Convert argument to bit type. */
-static UBits barg(lua_State *L, int idx)
-{
-  BitNum bn;
-  UBits b;
-#if LUA_VERSION_NUM < 502
-  bn.n = lua_tonumber(L, idx);
-#else
-  bn.n = luaL_checknumber(L, idx);
-#endif
-#if defined(LUA_NUMBER_DOUBLE)
-  bn.n += 6755399441055744.0;  /* 2^52+2^51 */
-#ifdef SWAPPED_DOUBLE
-  b = (UBits)(bn.b >> 32);
-#else
-  b = (UBits)bn.b;
-#endif
-#elif defined(LUA_NUMBER_INT) || defined(LUA_NUMBER_LONG) || \
-      defined(LUA_NUMBER_LONGLONG) || defined(LUA_NUMBER_LONG_LONG) || \
-      defined(LUA_NUMBER_LLONG)
-  if (sizeof(UBits) == sizeof(lua_Number))
-    b = bn.b;
-  else
-    b = (UBits)(SBits)bn.n;
-#elif defined(LUA_NUMBER_FLOAT)
-#error "A 'float' lua_Number type is incompatible with this library"
-#else
-#error "Unknown number type, check LUA_NUMBER_* in luaconf.h"
-#endif
-#if LUA_VERSION_NUM < 502
-  if (b == 0 && !lua_isnumber(L, idx)) {
-    luaL_typerror(L, idx, "number");
-  }
-#endif
-  return b;
-}
-
-/* Return bit type. */
-#define BRET(b)  lua_pushnumber(L, (lua_Number)(SBits)(b)); return 1;
-
-static int bit_tobit(lua_State *L) { BRET(barg(L, 1)) }
-static int bit_bnot(lua_State *L) { BRET(~barg(L, 1)) }
-
-#define BIT_OP(func, opr) \
-  static int func(lua_State *L) { int i; UBits b = barg(L, 1); \
-    for (i = lua_gettop(L); i > 1; i--) b opr barg(L, i); BRET(b) }
-BIT_OP(bit_band, &=)
-BIT_OP(bit_bor, |=)
-BIT_OP(bit_bxor, ^=)
-
-#define bshl(b, n)  (b << n)
-#define bshr(b, n)  (b >> n)
-#define bsar(b, n)  ((SBits)b >> n)
-#define brol(b, n)  ((b << n) | (b >> (32-n)))
-#define bror(b, n)  ((b << (32-n)) | (b >> n))
-#define BIT_SH(func, fn) \
-  static int func(lua_State *L) { \
-    UBits b = barg(L, 1); UBits n = barg(L, 2) & 31; BRET(fn(b, n)) }
-BIT_SH(bit_lshift, bshl)
-BIT_SH(bit_rshift, bshr)
-BIT_SH(bit_arshift, bsar)
-BIT_SH(bit_rol, brol)
-BIT_SH(bit_ror, bror)
-
-static int bit_bswap(lua_State *L)
-{
-  UBits b = barg(L, 1);
-  b = (b >> 24) | ((b >> 8) & 0xff00) | ((b & 0xff00) << 8) | (b << 24);
-  BRET(b)
-}
-
-static int bit_tohex(lua_State *L)
-{
-  UBits b = barg(L, 1);
-  SBits n = lua_isnone(L, 2) ? 8 : (SBits)barg(L, 2);
-  const char *hexdigits = "0123456789abcdef";
-  char buf[8];
-  int i;
-  if (n < 0) { n = -n; hexdigits = "0123456789ABCDEF"; }
-  if (n > 8) n = 8;
-  for (i = (int)n; --i >= 0; ) { buf[i] = hexdigits[b & 15]; b >>= 4; }
-  lua_pushlstring(L, buf, (size_t)n);
-  return 1;
-}
-
-static const struct luaL_Reg bit_funcs[] = {
-  { "tobit",	bit_tobit },
-  { "bnot",	bit_bnot },
-  { "band",	bit_band },
-  { "bor",	bit_bor },
-  { "bxor",	bit_bxor },
-  { "lshift",	bit_lshift },
-  { "rshift",	bit_rshift },
-  { "arshift",	bit_arshift },
-  { "rol",	bit_rol },
-  { "ror",	bit_ror },
-  { "bswap",	bit_bswap },
-  { "tohex",	bit_tohex },
-  { NULL, NULL }
-};
-
-/* Signed right-shifts are implementation-defined per C89/C99.
-** But the de facto standard are arithmetic right-shifts on two's
-** complement CPUs. This behaviour is required here, so test for it.
-*/
-#define BAD_SAR		(bsar(-8, 2) != (SBits)-2)
-
-LUALIB_API int luaopen_bit(lua_State *L)
-{
-  UBits b;
-  lua_pushnumber(L, (lua_Number)1437217655L);
-  b = barg(L, -1);
-  if (b != (UBits)1437217655L || BAD_SAR) {  /* Perform a simple self-test. */
-    const char *msg = "compiled with incompatible luaconf.h";
-#ifdef LUA_NUMBER_DOUBLE
-#ifdef _WIN32
-    if (b == (UBits)1610612736L)
-      msg = "use D3DCREATE_FPU_PRESERVE with DirectX";
-#endif
-    if (b == (UBits)1127743488L)
-      msg = "not compiled with SWAPPED_DOUBLE";
-#endif
-    if (BAD_SAR)
-      msg = "arithmetic right-shift broken";
-    luaL_error(L, "bit library self-test failed (%s)", msg);
-  }
-#if LUA_VERSION_NUM < 502
-  luaL_register(L, "bit", bit_funcs);
-#else
-  luaL_newlib(L, bit_funcs);
-#endif
-  return 1;
-}
-

deps/lua/src/lua_cmsgpack.c

@@ -7,38 +7,14 @@
 #include "lua.h"
 #include "lauxlib.h"
 
-#define LUACMSGPACK_NAME        "cmsgpack"
-#define LUACMSGPACK_SAFE_NAME   "cmsgpack_safe"
-#define LUACMSGPACK_VERSION     "lua-cmsgpack 0.4.0"
+#define LUACMSGPACK_VERSION     "lua-cmsgpack 0.3.0"
 #define LUACMSGPACK_COPYRIGHT   "Copyright (C) 2012, Salvatore Sanfilippo"
 #define LUACMSGPACK_DESCRIPTION "MessagePack C implementation for Lua"
 
-/* Allows a preprocessor directive to override MAX_NESTING */
-#ifndef LUACMSGPACK_MAX_NESTING
-    #define LUACMSGPACK_MAX_NESTING  16 /* Max tables nesting. */
-#endif
+#define LUACMSGPACK_MAX_NESTING  16 /* Max tables nesting. */
 
-/* Check if float or double can be an integer without loss of precision */
-#define IS_INT_TYPE_EQUIVALENT(x, T) (!isinf(x) && (T)(x) == (x))
-
-#define IS_INT64_EQUIVALENT(x) IS_INT_TYPE_EQUIVALENT(x, int64_t)
-#define IS_INT_EQUIVALENT(x) IS_INT_TYPE_EQUIVALENT(x, int)
-
-/* If size of pointer is equal to a 4 byte integer, we're on 32 bits. */
-#if UINTPTR_MAX == UINT_MAX
-    #define BITS_32 1
-#else
-    #define BITS_32 0
-#endif
-
-#if BITS_32
-    #define lua_pushunsigned(L, n) lua_pushnumber(L, n)
-#else
-    #define lua_pushunsigned(L, n) lua_pushinteger(L, n)
-#endif
-
-/* =============================================================================
- * MessagePack implementation and bindings for Lua 5.1/5.2.
+/* ==============================================================================
+ * MessagePack implementation and bindings for Lua 5.1.
  * Copyright(C) 2012 Salvatore Sanfilippo <antirez@gmail.com>
  *
  * http://github.com/antirez/lua-cmsgpack
@@ -53,27 +29,23 @@
  * 20-Feb-2012 (ver 0.2.0): Tables encoding improved.
  * 20-Feb-2012 (ver 0.2.1): Minor bug fixing.
  * 20-Feb-2012 (ver 0.3.0): Module renamed lua-cmsgpack (was lua-msgpack).
- * 04-Apr-2014 (ver 0.3.1): Lua 5.2 support and minor bug fix.
- * 07-Apr-2014 (ver 0.4.0): Multiple pack/unpack, lua allocator, efficiency.
- * ========================================================================== */
+ * ============================================================================ */
 
-/* -------------------------- Endian conversion --------------------------------
- * We use it only for floats and doubles, all the other conversions performed
+/* --------------------------- Endian conversion --------------------------------
+ * We use it only for floats and doubles, all the other conversions are performed
  * in an endian independent fashion. So the only thing we need is a function
- * that swaps a binary string if arch is little endian (and left it untouched
+ * that swaps a binary string if the arch is little endian (and left it untouched
  * otherwise). */
 
 /* Reverse memory bytes if arch is little endian. Given the conceptual
- * simplicity of the Lua build system we prefer check for endianess at runtime.
+ * simplicity of the Lua build system we prefer to check for endianess at runtime.
  * The performance difference should be acceptable. */
 static void memrevifle(void *ptr, size_t len) {
-    unsigned char   *p = (unsigned char *)ptr,
-                    *e = (unsigned char *)p+len-1,
-                    aux;
+    unsigned char *p = ptr, *e = p+len-1, aux;
     int test = 1;
     unsigned char *testp = (unsigned char*) &test;
 
-    if (testp[0] == 0) return; /* Big endian, nothing to do. */
+    if (testp[0] == 0) return; /* Big endian, nothign to do. */
     len /= 2;
     while(len--) {
         aux = *p;
@@ -84,44 +56,30 @@ static void memrevifle(void *ptr, size_t len) {
     }
 }
 
-/* ---------------------------- String buffer ----------------------------------
- * This is a simple implementation of string buffers. The only operation
+/* ----------------------------- String buffer ----------------------------------
+ * This is a simple implementation of string buffers. The only opereation
  * supported is creating empty buffers and appending bytes to it.
  * The string buffer uses 2x preallocation on every realloc for O(N) append
  * behavior.  */
 
 typedef struct mp_buf {
-    lua_State *L;
     unsigned char *b;
     size_t len, free;
 } mp_buf;
 
-static void *mp_realloc(lua_State *L, void *target, size_t osize,size_t nsize) {
-    void *(*local_realloc) (void *, void *, size_t osize, size_t nsize) = NULL;
-    void *ud;
-
-    local_realloc = lua_getallocf(L, &ud);
-
-    return local_realloc(ud, target, osize, nsize);
-}
-
-static mp_buf *mp_buf_new(lua_State *L) {
-    mp_buf *buf = NULL;
-
-    /* Old size = 0; new size = sizeof(*buf) */
-    buf = (mp_buf*)mp_realloc(L, NULL, 0, sizeof(*buf));
-
-    buf->L = L;
+static mp_buf *mp_buf_new(void) {
+    mp_buf *buf = malloc(sizeof(*buf));
+    
     buf->b = NULL;
     buf->len = buf->free = 0;
     return buf;
 }
 
-static void mp_buf_append(mp_buf *buf, const unsigned char *s, size_t len) {
+void mp_buf_append(mp_buf *buf, const unsigned char *s, size_t len) {
     if (buf->free < len) {
         size_t newlen = buf->len+len;
 
-        buf->b = (unsigned char*)mp_realloc(buf->L, buf->b, buf->len, newlen*2);
+        buf->b = realloc(buf->b,newlen*2);
         buf->free = newlen;
     }
     memcpy(buf->b+buf->len,s,len);
@@ -130,11 +88,11 @@ static void mp_buf_append(mp_buf *buf, const unsigned char *s, size_t len) {
 }
 
 void mp_buf_free(mp_buf *buf) {
-    mp_realloc(buf->L, buf->b, buf->len, 0); /* realloc to 0 = free */
-    mp_realloc(buf->L, buf, sizeof(*buf), 0);
+    free(buf->b);
+    free(buf);
 }
 
-/* ---------------------------- String cursor ----------------------------------
+/* ------------------------------ String cursor ----------------------------------
  * This simple data structure is used for parsing. Basically you create a cursor
  * using a string pointer and a length, then it is possible to access the
  * current string position with cursor->p, check the remaining length
@@ -144,7 +102,7 @@ void mp_buf_free(mp_buf *buf) {
  * be used to report errors. */
 
 #define MP_CUR_ERROR_NONE   0
-#define MP_CUR_ERROR_EOF    1   /* Not enough data to complete operation. */
+#define MP_CUR_ERROR_EOF    1   /* Not enough data to complete the opereation. */
 #define MP_CUR_ERROR_BADFMT 2   /* Bad data format */
 
 typedef struct mp_cur {
@@ -153,15 +111,22 @@ typedef struct mp_cur {
     int err;
 } mp_cur;
 
-static void mp_cur_init(mp_cur *cursor, const unsigned char *s, size_t len) {
+static mp_cur *mp_cur_new(const unsigned char *s, size_t len) {
+    mp_cur *cursor = malloc(sizeof(*cursor));
+
     cursor->p = s;
     cursor->left = len;
     cursor->err = MP_CUR_ERROR_NONE;
+    return cursor;
+}
+
+static void mp_cur_free(mp_cur *cursor) {
+    free(cursor);
 }
 
 #define mp_cur_consume(_c,_len) do { _c->p += _len; _c->left -= _len; } while(0)
 
-/* When there is not enough room we set an error in the cursor and return. This
+/* When there is not enough room we set an error in the cursor and return, this
  * is very common across the code so we have a macro to make the code look
  * a bit simpler. */
 #define mp_cur_need(_c,_len) do { \
@@ -171,7 +136,7 @@ static void mp_cur_init(mp_cur *cursor, const unsigned char *s, size_t len) {
     } \
 } while(0)
 
-/* ------------------------- Low level MP encoding -------------------------- */
+/* --------------------------- Low level MP encoding -------------------------- */
 
 static void mp_encode_bytes(mp_buf *buf, const unsigned char *s, size_t len) {
     unsigned char hdr[5];
@@ -254,7 +219,7 @@ static void mp_encode_int(mp_buf *buf, int64_t n) {
         }
     } else {
         if (n >= -32) {
-            b[0] = ((signed char)n);   /* negative fixnum */
+            b[0] = ((char)n);   /* negative fixnum */
             enclen = 1;
         } else if (n >= -128) {
             b[0] = 0xd0;        /* int 8 */
@@ -334,7 +299,7 @@ static void mp_encode_map(mp_buf *buf, int64_t n) {
     mp_buf_append(buf,b,enclen);
 }
 
-/* --------------------------- Lua types encoding --------------------------- */
+/* ----------------------------- Lua types encoding --------------------------- */
 
 static void mp_encode_lua_string(lua_State *L, mp_buf *buf) {
     size_t len;
@@ -349,26 +314,13 @@ static void mp_encode_lua_bool(lua_State *L, mp_buf *buf) {
     mp_buf_append(buf,&b,1);
 }
 
-/* Lua 5.3 has a built in 64-bit integer type */
-static void mp_encode_lua_integer(lua_State *L, mp_buf *buf) {
-#if (LUA_VERSION_NUM < 503) && BITS_32
-    lua_Number i = lua_tonumber(L,-1);
-#else
-    lua_Integer i = lua_tointeger(L,-1);
-#endif
-    mp_encode_int(buf, (int64_t)i);
-}
-
-/* Lua 5.2 and lower only has 64-bit doubles, so we need to
- * detect if the double may be representable as an int
- * for Lua < 5.3 */
 static void mp_encode_lua_number(lua_State *L, mp_buf *buf) {
     lua_Number n = lua_tonumber(L,-1);
 
-    if (IS_INT64_EQUIVALENT(n)) {
-        mp_encode_lua_integer(L, buf);
-    } else {
+    if (floor(n) != n) {
         mp_encode_double(buf,(double)n);
+    } else {
+        mp_encode_int(buf,(int64_t)n);
     }
 }
 
@@ -376,11 +328,7 @@ static void mp_encode_lua_type(lua_State *L, mp_buf *buf, int level);
 
 /* Convert a lua table into a message pack list. */
 static void mp_encode_lua_table_as_array(lua_State *L, mp_buf *buf, int level) {
-#if LUA_VERSION_NUM < 502
     size_t len = lua_objlen(L,-1), j;
-#else
-    size_t len = lua_rawlen(L,-1), j;
-#endif
 
     mp_encode_array(buf,len);
     for (j = 1; j <= len; j++) {
@@ -397,7 +345,7 @@ static void mp_encode_lua_table_as_map(lua_State *L, mp_buf *buf, int level) {
     /* First step: count keys into table. No other way to do it with the
      * Lua API, we need to iterate a first time. Note that an alternative
      * would be to do a single run, and then hack the buffer to insert the
-     * map opcodes for message pack. Too hackish for this lib. */
+     * map opcodes for message pack. Too hachish for this lib. */
     lua_pushnil(L);
     while(lua_next(L,-2)) {
         lua_pop(L,1); /* remove value, keep key for next iteration. */
@@ -419,43 +367,30 @@ static void mp_encode_lua_table_as_map(lua_State *L, mp_buf *buf, int level) {
  * of keys from numerical keys from 1 up to N, with N being the total number
  * of elements, without any hole in the middle. */
 static int table_is_an_array(lua_State *L) {
-    int count = 0, max = 0;
-#if LUA_VERSION_NUM < 503
+    long count = 0, max = 0, idx = 0;
     lua_Number n;
-#else
-    lua_Integer n;
-#endif
-
-    /* Stack top on function entry */
-    int stacktop;
-
-    stacktop = lua_gettop(L);
 
     lua_pushnil(L);
     while(lua_next(L,-2)) {
         /* Stack: ... key value */
         lua_pop(L,1); /* Stack: ... key */
-        /* The <= 0 check is valid here because we're comparing indexes. */
-#if LUA_VERSION_NUM < 503
-        if ((LUA_TNUMBER != lua_type(L,-1)) || (n = lua_tonumber(L, -1)) <= 0 ||
-            !IS_INT_EQUIVALENT(n))
-#else
-        if (!lua_isinteger(L,-1) || (n = lua_tointeger(L, -1)) <= 0)
-#endif
-        {
-            lua_settop(L, stacktop);
-            return 0;
-        }
-        max = (n > max ? n : max);
+        if (lua_type(L,-1) != LUA_TNUMBER) goto not_array;
+        n = lua_tonumber(L,-1);
+        idx = n;
+        if (idx != n || idx < 1) goto not_array;
         count++;
+        max = idx;
     }
     /* We have the total number of elements in "count". Also we have
-     * the max index encountered in "max". We can't reach this code
+     * the max index encountered in "idx". We can't reach this code
      * if there are indexes <= 0. If you also note that there can not be
-     * repeated keys into a table, you have that if max==count you are sure
+     * repeated keys into a table, you have that if idx==count you are sure
      * that there are all the keys form 1 to count (both included). */
-    lua_settop(L, stacktop);
-    return max == count;
+    return idx == count;
+
+not_array:
+    lua_pop(L,1);
+    return 0;
 }
 
 /* If the length operator returns non-zero, that is, there is at least
@@ -470,7 +405,6 @@ static void mp_encode_lua_table(lua_State *L, mp_buf *buf, int level) {
 
 static void mp_encode_lua_null(lua_State *L, mp_buf *buf) {
     unsigned char b[1];
-    (void)L;
 
     b[0] = 0xc0;
     mp_buf_append(buf,b,1);
@@ -479,70 +413,33 @@ static void mp_encode_lua_null(lua_State *L, mp_buf *buf) {
 static void mp_encode_lua_type(lua_State *L, mp_buf *buf, int level) {
     int t = lua_type(L,-1);
 
-    /* Limit the encoding of nested tables to a specified maximum depth, so that
+    /* Limit the encoding of nested tables to a specfiied maximum depth, so that
      * we survive when called against circular references in tables. */
     if (t == LUA_TTABLE && level == LUACMSGPACK_MAX_NESTING) t = LUA_TNIL;
     switch(t) {
     case LUA_TSTRING: mp_encode_lua_string(L,buf); break;
     case LUA_TBOOLEAN: mp_encode_lua_bool(L,buf); break;
-    case LUA_TNUMBER:
-    #if LUA_VERSION_NUM < 503
-        mp_encode_lua_number(L,buf); break;
-    #else
-        if (lua_isinteger(L, -1)) {
-            mp_encode_lua_integer(L, buf);
-        } else {
-            mp_encode_lua_number(L, buf);
-        }
-        break;
-    #endif
+    case LUA_TNUMBER: mp_encode_lua_number(L,buf); break;
     case LUA_TTABLE: mp_encode_lua_table(L,buf,level); break;
     default: mp_encode_lua_null(L,buf); break;
     }
     lua_pop(L,1);
 }
 
-/*
- * Packs all arguments as a stream for multiple upacking later.
- * Returns error if no arguments provided.
- */
 static int mp_pack(lua_State *L) {
-    int nargs = lua_gettop(L);
-    int i;
-    mp_buf *buf;
+    mp_buf *buf = mp_buf_new();
 
-    if (nargs == 0)
-        return luaL_argerror(L, 0, "MessagePack pack needs input.");
-
-    buf = mp_buf_new(L);
-    for(i = 1; i <= nargs; i++) {
-        /* Copy argument i to top of stack for _encode processing;
-         * the encode function pops it from the stack when complete. */
-        lua_pushvalue(L, i);
-
-        mp_encode_lua_type(L,buf,0);
-
-        lua_pushlstring(L,(char*)buf->b,buf->len);
-
-        /* Reuse the buffer for the next operation by
-         * setting its free count to the total buffer size
-         * and the current position to zero. */
-        buf->free += buf->len;
-        buf->len = 0;
-    }
+    mp_encode_lua_type(L,buf,0);
+    lua_pushlstring(L,(char*)buf->b,buf->len);
     mp_buf_free(buf);
-
-    /* Concatenate all nargs buffers together */
-    lua_concat(L, nargs);
     return 1;
 }
 
-/* ------------------------------- Decoding --------------------------------- */
+/* --------------------------------- Decoding --------------------------------- */
 
 void mp_decode_to_lua_type(lua_State *L, mp_cur *c);
 
 void mp_decode_to_lua_array(lua_State *L, mp_cur *c, size_t len) {
-    assert(len <= UINT_MAX);
     int index = 1;
 
     lua_newtable(L);
@@ -555,7 +452,6 @@ void mp_decode_to_lua_array(lua_State *L, mp_cur *c, size_t len) {
 }
 
 void mp_decode_to_lua_hash(lua_State *L, mp_cur *c, size_t len) {
-    assert(len <= UINT_MAX);
     lua_newtable(L);
     while(len--) {
         mp_decode_to_lua_type(L,c); /* key */
@@ -570,44 +466,34 @@ void mp_decode_to_lua_hash(lua_State *L, mp_cur *c, size_t len) {
  * a Lua type, that is left as the only result on the stack. */
 void mp_decode_to_lua_type(lua_State *L, mp_cur *c) {
     mp_cur_need(c,1);
-
-    /* If we return more than 18 elements, we must resize the stack to
-     * fit all our return values.  But, there is no way to
-     * determine how many objects a msgpack will unpack to up front, so
-     * we request a +1 larger stack on each iteration (noop if stack is
-     * big enough, and when stack does require resize it doubles in size) */
-    luaL_checkstack(L, 1,
-        "too many return values at once; "
-        "use unpack_one or unpack_limit instead.");
-
     switch(c->p[0]) {
     case 0xcc:  /* uint 8 */
         mp_cur_need(c,2);
-        lua_pushunsigned(L,c->p[1]);
+        lua_pushnumber(L,c->p[1]);
         mp_cur_consume(c,2);
         break;
     case 0xd0:  /* int 8 */
         mp_cur_need(c,2);
-        lua_pushinteger(L,(signed char)c->p[1]);
+        lua_pushnumber(L,(char)c->p[1]);
         mp_cur_consume(c,2);
         break;
     case 0xcd:  /* uint 16 */
         mp_cur_need(c,3);
-        lua_pushunsigned(L,
+        lua_pushnumber(L,
             (c->p[1] << 8) |
              c->p[2]);
         mp_cur_consume(c,3);
         break;
     case 0xd1:  /* int 16 */
         mp_cur_need(c,3);
-        lua_pushinteger(L,(int16_t)
+        lua_pushnumber(L,(int16_t)
             (c->p[1] << 8) |
              c->p[2]);
         mp_cur_consume(c,3);
         break;
     case 0xce:  /* uint 32 */
         mp_cur_need(c,5);
-        lua_pushunsigned(L,
+        lua_pushnumber(L,
             ((uint32_t)c->p[1] << 24) |
             ((uint32_t)c->p[2] << 16) |
             ((uint32_t)c->p[3] << 8) |
@@ -616,7 +502,7 @@ void mp_decode_to_lua_type(lua_State *L, mp_cur *c) {
         break;
     case 0xd2:  /* int 32 */
         mp_cur_need(c,5);
-        lua_pushinteger(L,
+        lua_pushnumber(L,
             ((int32_t)c->p[1] << 24) |
             ((int32_t)c->p[2] << 16) |
             ((int32_t)c->p[3] << 8) |
@@ -625,7 +511,7 @@ void mp_decode_to_lua_type(lua_State *L, mp_cur *c) {
         break;
     case 0xcf:  /* uint 64 */
         mp_cur_need(c,9);
-        lua_pushunsigned(L,
+        lua_pushnumber(L,
             ((uint64_t)c->p[1] << 56) |
             ((uint64_t)c->p[2] << 48) |
             ((uint64_t)c->p[3] << 40) |
@@ -638,11 +524,7 @@ void mp_decode_to_lua_type(lua_State *L, mp_cur *c) {
         break;
     case 0xd3:  /* int 64 */
         mp_cur_need(c,9);
-#if LUA_VERSION_NUM < 503
         lua_pushnumber(L,
-#else
-        lua_pushinteger(L,
-#endif
             ((int64_t)c->p[1] << 56) |
             ((int64_t)c->p[2] << 48) |
             ((int64_t)c->p[3] << 40) |
@@ -699,14 +581,13 @@ void mp_decode_to_lua_type(lua_State *L, mp_cur *c) {
     case 0xdb:  /* raw 32 */
         mp_cur_need(c,5);
         {
-            size_t l = ((size_t)c->p[1] << 24) |
-                       ((size_t)c->p[2] << 16) |
-                       ((size_t)c->p[3] << 8) |
-                       (size_t)c->p[4];
-            mp_cur_consume(c,5);
-            mp_cur_need(c,l);
-            lua_pushlstring(L,(char*)c->p,l);
-            mp_cur_consume(c,l);
+            size_t l = (c->p[1] << 24) |
+                       (c->p[2] << 16) |
+                       (c->p[3] << 8) |
+                       c->p[4];
+            mp_cur_need(c,5+l);
+            lua_pushlstring(L,(char*)c->p+5,l);
+            mp_cur_consume(c,5+l);
         }
         break;
     case 0xdc:  /* array 16 */
@@ -720,10 +601,10 @@ void mp_decode_to_lua_type(lua_State *L, mp_cur *c) {
     case 0xdd:  /* array 32 */
         mp_cur_need(c,5);
         {
-            size_t l = ((size_t)c->p[1] << 24) |
-                       ((size_t)c->p[2] << 16) |
-                       ((size_t)c->p[3] << 8) |
-                       (size_t)c->p[4];
+            size_t l = (c->p[1] << 24) |
+                       (c->p[2] << 16) |
+                       (c->p[3] << 8) |
+                       c->p[4];
             mp_cur_consume(c,5);
             mp_decode_to_lua_array(L,c,l);
         }
@@ -739,20 +620,20 @@ void mp_decode_to_lua_type(lua_State *L, mp_cur *c) {
     case 0xdf:  /* map 32 */
         mp_cur_need(c,5);
         {
-            size_t l = ((size_t)c->p[1] << 24) |
-                       ((size_t)c->p[2] << 16) |
-                       ((size_t)c->p[3] << 8) |
-                       (size_t)c->p[4];
+            size_t l = (c->p[1] << 24) |
+                       (c->p[2] << 16) |
+                       (c->p[3] << 8) |
+                       c->p[4];
             mp_cur_consume(c,5);
             mp_decode_to_lua_hash(L,c,l);
         }
         break;
     default:    /* types that can't be idenitified by first byte value. */
         if ((c->p[0] & 0x80) == 0) {   /* positive fixnum */
-            lua_pushunsigned(L,c->p[0]);
+            lua_pushnumber(L,c->p[0]);
             mp_cur_consume(c,1);
         } else if ((c->p[0] & 0xe0) == 0xe0) {  /* negative fixnum */
-            lua_pushinteger(L,(signed char)c->p[0]);
+            lua_pushnumber(L,(signed char)c->p[0]);
             mp_cur_consume(c,1);
         } else if ((c->p[0] & 0xe0) == 0xa0) {  /* fix raw */
             size_t l = c->p[0] & 0x1f;
@@ -773,163 +654,54 @@ void mp_decode_to_lua_type(lua_State *L, mp_cur *c) {
     }
 }
 
-static int mp_unpack_full(lua_State *L, int limit, int offset) {
-    size_t len;
-    const char *s;
-    mp_cur c;
-    int cnt; /* Number of objects unpacked */
-    int decode_all = (!limit && !offset);
-
-    s = luaL_checklstring(L,1,&len); /* if no match, exits */
-
-    if (offset < 0 || limit < 0) /* requesting negative off or lim is invalid */
-        return luaL_error(L,
-            "Invalid request to unpack with offset of %d and limit of %d.",
-            offset, len);
-    else if (offset > len)
-        return luaL_error(L,
-            "Start offset %d greater than input length %d.", offset, len);
-
-    if (decode_all) limit = INT_MAX;
-
-    mp_cur_init(&c,(const unsigned char *)s+offset,len-offset);
-
-    /* We loop over the decode because this could be a stream
-     * of multiple top-level values serialized together */
-    for(cnt = 0; c.left > 0 && cnt < limit; cnt++) {
-        mp_decode_to_lua_type(L,&c);
-
-        if (c.err == MP_CUR_ERROR_EOF) {
-            return luaL_error(L,"Missing bytes in input.");
-        } else if (c.err == MP_CUR_ERROR_BADFMT) {
-            return luaL_error(L,"Bad data format in input.");
-        }
-    }
-
-    if (!decode_all) {
-        /* c->left is the remaining size of the input buffer.
-         * subtract the entire buffer size from the unprocessed size
-         * to get our next start offset */
-        int offset = len - c.left;
-        /* Return offset -1 when we have have processed the entire buffer. */
-        lua_pushinteger(L, c.left == 0 ? -1 : offset);
-        /* Results are returned with the arg elements still
-         * in place. Lua takes care of only returning
-         * elements above the args for us.
-         * In this case, we have one arg on the stack
-         * for this function, so we insert our first return
-         * value at position 2. */
-        lua_insert(L, 2);
-        cnt += 1; /* increase return count by one to make room for offset */
-    }
-
-    return cnt;
-}
-
 static int mp_unpack(lua_State *L) {
-    return mp_unpack_full(L, 0, 0);
-}
+    size_t len;
+    const unsigned char *s;
+    mp_cur *c;
 
-static int mp_unpack_one(lua_State *L) {
-    int offset = luaL_optinteger(L, 2, 0);
-    /* Variable pop because offset may not exist */
-    lua_pop(L, lua_gettop(L)-1);
-    return mp_unpack_full(L, 1, offset);
-}
-
-static int mp_unpack_limit(lua_State *L) {
-    int limit = luaL_checkinteger(L, 2);
-    int offset = luaL_optinteger(L, 3, 0);
-    /* Variable pop because offset may not exist */
-    lua_pop(L, lua_gettop(L)-1);
-
-    return mp_unpack_full(L, limit, offset);
-}
-
-static int mp_safe(lua_State *L) {
-    int argc, err, total_results;
-
-    argc = lua_gettop(L);
-
-    /* This adds our function to the bottom of the stack
-     * (the "call this function" position) */
-    lua_pushvalue(L, lua_upvalueindex(1));
-    lua_insert(L, 1);
-
-    err = lua_pcall(L, argc, LUA_MULTRET, 0);
-    total_results = lua_gettop(L);
-
-    if (!err) {
-        return total_results;
-    } else {
-        lua_pushnil(L);
-        lua_insert(L,-2);
-        return 2;
+    if (!lua_isstring(L,-1)) {
+        lua_pushstring(L,"MessagePack decoding needs a string as input.");
+        lua_error(L);
     }
+
+    s = (const unsigned char*) lua_tolstring(L,-1,&len);
+    c = mp_cur_new(s,len);
+    mp_decode_to_lua_type(L,c);
+    
+    if (c->err == MP_CUR_ERROR_EOF) {
+        mp_cur_free(c);
+        lua_pushstring(L,"Missing bytes in input.");
+        lua_error(L);
+    } else if (c->err == MP_CUR_ERROR_BADFMT) {
+        mp_cur_free(c);
+        lua_pushstring(L,"Bad data format in input.");
+        lua_error(L);
+    } else if (c->left != 0) {
+        mp_cur_free(c);
+        lua_pushstring(L,"Extra bytes in input.");
+        lua_error(L);
+    }
+    mp_cur_free(c);
+    return 1;
 }
 
-/* -------------------------------------------------------------------------- */
-static const struct luaL_Reg cmds[] = {
+/* ---------------------------------------------------------------------------- */
+
+static const struct luaL_reg thislib[] = {
     {"pack", mp_pack},
     {"unpack", mp_unpack},
-    {"unpack_one", mp_unpack_one},
-    {"unpack_limit", mp_unpack_limit},
-    {0}
+    {NULL, NULL}
 };
 
-static int luaopen_create(lua_State *L) {
-    int i;
-    /* Manually construct our module table instead of
-     * relying on _register or _newlib */
-    lua_newtable(L);
+LUALIB_API int luaopen_cmsgpack (lua_State *L) {
+    luaL_register(L, "cmsgpack", thislib);
 
-    for (i = 0; i < (sizeof(cmds)/sizeof(*cmds) - 1); i++) {
-        lua_pushcfunction(L, cmds[i].func);
-        lua_setfield(L, -2, cmds[i].name);
-    }
-
-    /* Add metadata */
-    lua_pushliteral(L, LUACMSGPACK_NAME);
-    lua_setfield(L, -2, "_NAME");
     lua_pushliteral(L, LUACMSGPACK_VERSION);
     lua_setfield(L, -2, "_VERSION");
     lua_pushliteral(L, LUACMSGPACK_COPYRIGHT);
     lua_setfield(L, -2, "_COPYRIGHT");
     lua_pushliteral(L, LUACMSGPACK_DESCRIPTION);
-    lua_setfield(L, -2, "_DESCRIPTION");
-    return 1;
-}
-
-LUALIB_API int luaopen_cmsgpack(lua_State *L) {
-    luaopen_create(L);
-
-#if LUA_VERSION_NUM < 502
-    /* Register name globally for 5.1 */
-    lua_pushvalue(L, -1);
-    lua_setglobal(L, LUACMSGPACK_NAME);
-#endif
-
-    return 1;
-}
-
-LUALIB_API int luaopen_cmsgpack_safe(lua_State *L) {
-    int i;
-
-    luaopen_cmsgpack(L);
-
-    /* Wrap all functions in the safe handler */
-    for (i = 0; i < (sizeof(cmds)/sizeof(*cmds) - 1); i++) {
-        lua_getfield(L, -1, cmds[i].name);
-        lua_pushcclosure(L, mp_safe, 1);
-        lua_setfield(L, -2, cmds[i].name);
-    }
-
-#if LUA_VERSION_NUM < 502
-    /* Register name globally for 5.1 */
-    lua_pushvalue(L, -1);
-    lua_setglobal(L, LUACMSGPACK_SAFE_NAME);
-#endif
-
+    lua_setfield(L, -2, "_DESCRIPTION"); 
     return 1;
 }
 

deps/lua/src/strbuf.c

@@ -1,6 +1,6 @@
-/* strbuf - String buffer routines
+/* strbuf - string buffer routines
  *
- * Copyright (c) 2010-2012  Mark Pulford <mark@kyne.com.au>
+ * Copyright (c) 2010-2011  Mark Pulford <mark@kyne.com.au>
  *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files (the
@@ -29,7 +29,7 @@
 
 #include "strbuf.h"
 
-static void die(const char *fmt, ...)
+void die(const char *fmt, ...)
 {
     va_list arg;
 

deps/lua/src/strbuf.h

@@ -1,6 +1,6 @@
 /* strbuf - String buffer routines
  *
- * Copyright (c) 2010-2012  Mark Pulford <mark@kyne.com.au>
+ * Copyright (c) 2010-2011  Mark Pulford <mark@kyne.com.au>
  *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files (the
@@ -62,9 +62,7 @@ extern void strbuf_resize(strbuf_t *s, int len);
 static int strbuf_empty_length(strbuf_t *s);
 static int strbuf_length(strbuf_t *s);
 static char *strbuf_string(strbuf_t *s, int *len);
-static void strbuf_ensure_empty_length(strbuf_t *s, int len);
-static char *strbuf_empty_ptr(strbuf_t *s);
-static void strbuf_extend_length(strbuf_t *s, int len);
+static  void strbuf_ensure_empty_length(strbuf_t *s, int len);
 
 /* Update */
 extern void strbuf_append_fmt(strbuf_t *s, int len, const char *fmt, ...);
@@ -98,16 +96,6 @@ static inline void strbuf_ensure_empty_length(strbuf_t *s, int len)
         strbuf_resize(s, s->length + len);
 }
 
-static inline char *strbuf_empty_ptr(strbuf_t *s)
-{
-    return s->buf + s->length;
-}
-
-static inline void strbuf_extend_length(strbuf_t *s, int len)
-{
-    s->length += len;
-}
-
 static inline int strbuf_length(strbuf_t *s)
 {
     return s->length;

redis.conf

@@ -242,10 +242,6 @@ slave-read-only yes
 
 # Replication SYNC strategy: disk or socket.
 #
-# -------------------------------------------------------
-# WARNING: DISKLESS REPLICATION IS EXPERIMENTAL CURRENTLY
-# -------------------------------------------------------
-#
 # New slaves and reconnecting slaves that are not able to continue the replication
 # process just receiving differences, need to do what is called a "full
 # synchronization". An RDB file is transmitted from the master to the slaves.
@@ -272,7 +268,7 @@ slave-read-only yes
 repl-diskless-sync no
 
 # When diskless replication is enabled, it is possible to configure the delay
-# the server waits in order to spawn the child that transfers the RDB via socket
+# the server waits in order to spawn the child that trnasfers the RDB via socket
 # to the slaves.
 #
 # This is important since once the transfer starts, it is not possible to serve
@@ -760,7 +756,7 @@ slowlog-max-len 128
 # By default latency monitoring is disabled since it is mostly not needed
 # if you don't have latency issues, and collecting data has a performance
 # impact, that while very small, can be measured under big load. Latency
-# monitoring can easily be enabled at runtime using the command
+# monitoring can easily be enalbed at runtime using the command
 # "CONFIG SET latency-monitor-threshold <milliseconds>" if needed.
 latency-monitor-threshold 0
 
@@ -818,36 +814,11 @@ notify-keyspace-events ""
 hash-max-ziplist-entries 512
 hash-max-ziplist-value 64
 
-# Lists are also encoded in a special way to save a lot of space.
-# The number of entries allowed per internal list node can be specified
-# as a fixed maximum size or a maximum number of elements.
-# For a fixed maximum size, use -5 through -1, meaning:
-# -5: max size: 64 Kb  <-- not recommended for normal workloads
-# -4: max size: 32 Kb  <-- not recommended
-# -3: max size: 16 Kb  <-- probably not recommended
-# -2: max size: 8 Kb   <-- good
-# -1: max size: 4 Kb   <-- good
-# Positive numbers mean store up to _exactly_ that number of elements
-# per list node.
-# The highest performing option is usually -2 (8 Kb size) or -1 (4 Kb size),
-# but if your use case is unique, adjust the settings as necessary.
-list-max-ziplist-size -2
-
-# Lists may also be compressed.
-# Compress depth is the number of quicklist ziplist nodes from *each* side of
-# the list to *exclude* from compression.  The head and tail of the list
-# are always uncompressed for fast push/pop operations.  Settings are:
-# 0: disable all list compression
-# 1: depth 1 means "don't start compressing until after 1 node into the list,
-#    going from either the head or tail"
-#    So: [head]->node->node->...->node->[tail]
-#    [head], [tail] will always be uncompressed; inner nodes will compress.
-# 2: [head]->[next]->node->node->...->node->[prev]->[tail]
-#    2 here means: don't compress head or head->next or tail->prev or tail,
-#    but compress all nodes between them.
-# 3: [head]->[next]->[next]->node->node->...->node->[prev]->[prev]->[tail]
-# etc.
-list-compress-depth 0
+# Similarly to hashes, small lists are also encoded in a special way in order
+# to save a lot of space. The special representation is only used when
+# you are under the following limits:
+list-max-ziplist-entries 512
+list-max-ziplist-value 64
 
 # Sets have a special encoding in just one case: when a set is composed
 # of just strings that happen to be integers in radix 10 in the range

src/Makefile

@@ -18,7 +18,7 @@ OPTIMIZATION?=-O2
 DEPENDENCY_TARGETS=hiredis linenoise lua
 
 # Default settings
-STD=-std=c99 -pedantic -DREDIS_STATIC=''
+STD=-std=c99 -pedantic
 WARN=-Wall -W
 OPT=$(OPTIMIZATION)
 
@@ -46,10 +46,6 @@ ifeq ($(USE_JEMALLOC),yes)
 	MALLOC=jemalloc
 endif
 
-ifeq ($(USE_JEMALLOC),no)
-	MALLOC=libc
-endif
-
 # Override default settings if possible
 -include .make-settings
 
@@ -117,7 +113,7 @@ endif
 
 REDIS_SERVER_NAME=redis-server
 REDIS_SENTINEL_NAME=redis-sentinel
-REDIS_SERVER_OBJ=adlist.o quicklist.o ae.o anet.o dict.o redis.o sds.o zmalloc.o lzf_c.o lzf_d.o pqsort.o zipmap.o sha1.o ziplist.o release.o networking.o util.o object.o db.o replication.o rdb.o t_string.o t_list.o t_set.o t_zset.o t_hash.o config.o aof.o pubsub.o multi.o debug.o sort.o intset.o syncio.o cluster.o crc16.o endianconv.o slowlog.o scripting.o bio.o rio.o rand.o memtest.o crc64.o bitops.o sentinel.o notify.o setproctitle.o blocked.o hyperloglog.o latency.o sparkline.o
+REDIS_SERVER_OBJ=adlist.o ae.o anet.o dict.o redis.o sds.o zmalloc.o lzf_c.o lzf_d.o pqsort.o zipmap.o sha1.o ziplist.o release.o networking.o util.o object.o db.o replication.o rdb.o t_string.o t_list.o t_set.o t_zset.o t_hash.o config.o aof.o pubsub.o multi.o debug.o sort.o intset.o syncio.o cluster.o crc16.o endianconv.o slowlog.o scripting.o bio.o rio.o rand.o memtest.o crc64.o bitops.o sentinel.o notify.o setproctitle.o blocked.o hyperloglog.o latency.o sparkline.o
 REDIS_CLI_NAME=redis-cli
 REDIS_CLI_OBJ=anet.o sds.o adlist.o redis-cli.o zmalloc.o release.o anet.o ae.o crc64.o
 REDIS_BENCHMARK_NAME=redis-benchmark
@@ -225,10 +221,6 @@ lcov:
 	@geninfo -o redis.info .
 	@genhtml --legend -o lcov-html redis.info
 
-test-sds: sds.c sds.h
-	$(REDIS_CC) sds.c zmalloc.c -DSDS_TEST_MAIN -o /tmp/sds_test
-	/tmp/sds_test
-
 .PHONY: lcov
 
 bench: $(REDIS_BENCHMARK_NAME)
@@ -259,4 +251,3 @@ install: all
 	$(REDIS_INSTALL) $(REDIS_CLI_NAME) $(INSTALL_BIN)
 	$(REDIS_INSTALL) $(REDIS_CHECK_DUMP_NAME) $(INSTALL_BIN)
 	$(REDIS_INSTALL) $(REDIS_CHECK_AOF_NAME) $(INSTALL_BIN)
-	@ln -sf $(REDIS_SERVER_NAME) $(INSTALL_BIN)/$(REDIS_SENTINEL_NAME)

src/anet.c

@@ -589,23 +589,6 @@ error:
     return -1;
 }
 
-/* Format an IP,port pair into something easy to parse. If IP is IPv6
- * (matches for ":"), the ip is surrounded by []. IP and port are just
- * separated by colons. This the standard to display addresses within Redis. */
-int anetFormatAddr(char *buf, size_t buf_len, char *ip, int port) {
-    return snprintf(buf,buf_len, strchr(ip,':') ?
-           "[%s]:%d" : "%s:%d", ip, port);
-}
-
-/* Like anetFormatAddr() but extract ip and port from the socket's peer. */
-int anetFormatPeer(int fd, char *buf, size_t buf_len) {
-    char ip[INET6_ADDRSTRLEN];
-    int port;
-
-    anetPeerToString(fd,ip,sizeof(ip),&port);
-    return anetFormatAddr(buf, buf_len, ip, port);
-}
-
 int anetSockName(int fd, char *ip, size_t ip_len, int *port) {
     struct sockaddr_storage sa;
     socklen_t salen = sizeof(sa);
@@ -627,11 +610,3 @@ int anetSockName(int fd, char *ip, size_t ip_len, int *port) {
     }
     return 0;
 }
-
-int anetFormatSock(int fd, char *fmt, size_t fmt_len) {
-    char ip[INET6_ADDRSTRLEN];
-    int port;
-
-    anetSockName(fd,ip,sizeof(ip),&port);
-    return anetFormatAddr(fmt, fmt_len, ip, port);
-}

src/anet.h

@@ -70,8 +70,5 @@ int anetSendTimeout(char *err, int fd, long long ms);
 int anetPeerToString(int fd, char *ip, size_t ip_len, int *port);
 int anetKeepAlive(char *err, int fd, int interval);
 int anetSockName(int fd, char *ip, size_t ip_len, int *port);
-int anetFormatAddr(char *fmt, size_t fmt_len, char *ip, int port);
-int anetFormatPeer(int fd, char *fmt, size_t fmt_len);
-int anetFormatSock(int fd, char *fmt, size_t fmt_len);
 
 #endif

src/aof.c

@@ -770,29 +770,52 @@ int rioWriteBulkObject(rio *r, robj *obj) {
 int rewriteListObject(rio *r, robj *key, robj *o) {
     long long count = 0, items = listTypeLength(o);
 
-    if (o->encoding == REDIS_ENCODING_QUICKLIST) {
-        quicklist *list = o->ptr;
-        quicklistIter *li = quicklistGetIterator(list, AL_START_HEAD);
-        quicklistEntry entry;
+    if (o->encoding == REDIS_ENCODING_ZIPLIST) {
+        unsigned char *zl = o->ptr;
+        unsigned char *p = ziplistIndex(zl,0);
+        unsigned char *vstr;
+        unsigned int vlen;
+        long long vlong;
 
-        while (quicklistNext(li,&entry)) {
+        while(ziplistGet(p,&vstr,&vlen,&vlong)) {
             if (count == 0) {
                 int cmd_items = (items > REDIS_AOF_REWRITE_ITEMS_PER_CMD) ?
                     REDIS_AOF_REWRITE_ITEMS_PER_CMD : items;
+
                 if (rioWriteBulkCount(r,'*',2+cmd_items) == 0) return 0;
                 if (rioWriteBulkString(r,"RPUSH",5) == 0) return 0;
                 if (rioWriteBulkObject(r,key) == 0) return 0;
             }
-
-            if (entry.value) {
-                if (rioWriteBulkString(r,(char*)entry.value,entry.sz) == 0) return 0;
+            if (vstr) {
+                if (rioWriteBulkString(r,(char*)vstr,vlen) == 0) return 0;
             } else {
-                if (rioWriteBulkLongLong(r,entry.longval) == 0) return 0;
+                if (rioWriteBulkLongLong(r,vlong) == 0) return 0;
             }
+            p = ziplistNext(zl,p);
+            if (++count == REDIS_AOF_REWRITE_ITEMS_PER_CMD) count = 0;
+            items--;
+        }
+    } else if (o->encoding == REDIS_ENCODING_LINKEDLIST) {
+        list *list = o->ptr;
+        listNode *ln;
+        listIter li;
+
+        listRewind(list,&li);
+        while((ln = listNext(&li))) {
+            robj *eleobj = listNodeValue(ln);
+
+            if (count == 0) {
+                int cmd_items = (items > REDIS_AOF_REWRITE_ITEMS_PER_CMD) ?
+                    REDIS_AOF_REWRITE_ITEMS_PER_CMD : items;
+
+                if (rioWriteBulkCount(r,'*',2+cmd_items) == 0) return 0;
+                if (rioWriteBulkString(r,"RPUSH",5) == 0) return 0;
+                if (rioWriteBulkObject(r,key) == 0) return 0;
+            }
+            if (rioWriteBulkObject(r,eleobj) == 0) return 0;
             if (++count == REDIS_AOF_REWRITE_ITEMS_PER_CMD) count = 0;
             items--;
         }
-        quicklistReleaseIterator(li);
     } else {
         redisPanic("Unknown list encoding");
     }

src/bitops.c

@@ -70,19 +70,16 @@ size_t redisPopcount(void *s, long count) {
         count--;
     }
 
-    /* Count bits 28 bytes at a time */
+    /* Count bits 16 bytes at a time */
     p4 = (uint32_t*)p;
-    while(count>=28) {
-        uint32_t aux1, aux2, aux3, aux4, aux5, aux6, aux7;
+    while(count>=16) {
+        uint32_t aux1, aux2, aux3, aux4;
 
         aux1 = *p4++;
         aux2 = *p4++;
         aux3 = *p4++;
         aux4 = *p4++;
-        aux5 = *p4++;
-        aux6 = *p4++;
-        aux7 = *p4++;
-        count -= 28;
+        count -= 16;
 
         aux1 = aux1 - ((aux1 >> 1) & 0x55555555);
         aux1 = (aux1 & 0x33333333) + ((aux1 >> 2) & 0x33333333);
@@ -92,19 +89,10 @@ size_t redisPopcount(void *s, long count) {
         aux3 = (aux3 & 0x33333333) + ((aux3 >> 2) & 0x33333333);
         aux4 = aux4 - ((aux4 >> 1) & 0x55555555);
         aux4 = (aux4 & 0x33333333) + ((aux4 >> 2) & 0x33333333);
-        aux5 = aux5 - ((aux5 >> 1) & 0x55555555);
-        aux5 = (aux5 & 0x33333333) + ((aux5 >> 2) & 0x33333333);
-        aux6 = aux6 - ((aux6 >> 1) & 0x55555555);
-        aux6 = (aux6 & 0x33333333) + ((aux6 >> 2) & 0x33333333);
-        aux7 = aux7 - ((aux7 >> 1) & 0x55555555);
-        aux7 = (aux7 & 0x33333333) + ((aux7 >> 2) & 0x33333333);
-        bits += ((((aux1 + (aux1 >> 4)) & 0x0F0F0F0F) +
-                    ((aux2 + (aux2 >> 4)) & 0x0F0F0F0F) +
-                    ((aux3 + (aux3 >> 4)) & 0x0F0F0F0F) +
-                    ((aux4 + (aux4 >> 4)) & 0x0F0F0F0F) +
-                    ((aux5 + (aux5 >> 4)) & 0x0F0F0F0F) +
-                    ((aux6 + (aux6 >> 4)) & 0x0F0F0F0F) +
-                    ((aux7 + (aux7 >> 4)) & 0x0F0F0F0F))* 0x01010101) >> 24;
+        bits += ((((aux1 + (aux1 >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24) +
+                ((((aux2 + (aux2 >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24) +
+                ((((aux3 + (aux3 >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24) +
+                ((((aux4 + (aux4 >> 4)) & 0x0F0F0F0F) * 0x01010101) >> 24);
     }
     /* Count the remaining bytes. */
     p = (unsigned char*)p4;
@@ -360,7 +348,7 @@ void bitopCommand(redisClient *c) {
          * can take a fast path that performs much better than the
          * vanilla algorithm. */
         j = 0;
-        if (minlen >= sizeof(unsigned long)*4 && numkeys <= 16) {
+        if (minlen && numkeys <= 16) {
             unsigned long *lp[16];
             unsigned long *lres = (unsigned long*) res;
 

src/cluster.c

@@ -593,7 +593,7 @@ void clusterAcceptHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
         if (cfd == ANET_ERR) {
             if (errno != EWOULDBLOCK)
                 redisLog(REDIS_VERBOSE,
-                    "Error accepting cluster node: %s", server.neterr);
+                    "Accepting cluster node: %s", server.neterr);
             return;
         }
         anetNonBlock(NULL,cfd);
@@ -1482,8 +1482,7 @@ int clusterProcessPacket(clusterLink *link) {
     } else if (type == CLUSTERMSG_TYPE_PUBLISH) {
         uint32_t explen = sizeof(clusterMsg)-sizeof(union clusterMsgData);
 
-        explen += sizeof(clusterMsgDataPublish) -
-                8 +
+        explen += sizeof(clusterMsgDataPublish) +
                 ntohl(hdr->data.publish.msg.channel_len) +
                 ntohl(hdr->data.publish.msg.message_len);
         if (totlen != explen) return 1;
@@ -1552,10 +1551,8 @@ int clusterProcessPacket(clusterLink *link) {
                 strcmp(ip,myself->ip))
             {
                 memcpy(myself->ip,ip,REDIS_IP_STR_LEN);
-
-                anetFormatAddr(ip, sizeof(ip), myself->ip, -1);
                 redisLog(REDIS_WARNING,"IP address for this node updated to %s",
-                    ip);
+                    myself->ip);
                 clusterDoBeforeSleep(CLUSTER_TODO_SAVE_CONFIG);
             }
         }
@@ -2073,7 +2070,7 @@ void clusterBuildMessageHdr(clusterMsg *hdr, int type) {
 /* Send a PING or PONG packet to the specified node, making sure to add enough
  * gossip informations. */
 void clusterSendPing(clusterLink *link, int type) {
-    unsigned char buf[sizeof(clusterMsg)+sizeof(clusterMsgDataGossip)*3];
+    unsigned char buf[sizeof(clusterMsg)];
     clusterMsg *hdr = (clusterMsg*) buf;
     int gossipcount = 0, totlen;
     /* freshnodes is the number of nodes we can still use to populate the
@@ -2187,7 +2184,7 @@ void clusterSendPublish(clusterLink *link, robj *channel, robj *message) {
 
     clusterBuildMessageHdr(hdr,CLUSTERMSG_TYPE_PUBLISH);
     totlen = sizeof(clusterMsg)-sizeof(union clusterMsgData);
-    totlen += sizeof(clusterMsgDataPublish) - 8 + channel_len + message_len;
+    totlen += sizeof(clusterMsgDataPublish) + channel_len + message_len;
 
     hdr->data.publish.msg.channel_len = htonl(channel_len);
     hdr->data.publish.msg.message_len = htonl(message_len);
@@ -2520,7 +2517,7 @@ void clusterHandleSlaveFailover(void) {
 
     /* Compute the failover timeout (the max time we have to send votes
      * and wait for replies), and the failover retry time (the time to wait
-     * before trying to get voted again).
+     * before waiting again.
      *
      * Timeout is MIN(NODE_TIMEOUT*2,2000) milliseconds.
      * Retry is two times the Timeout.
@@ -3886,7 +3883,10 @@ void clusterCommand(redisClient *c) {
             server.cluster->stats_bus_messages_sent,
             server.cluster->stats_bus_messages_received
         );
-        addReplyBulkSds(c, info);
+        addReplySds(c,sdscatprintf(sdsempty(),"$%lu\r\n",
+            (unsigned long)sdslen(info)));
+        addReplySds(c,info);
+        addReply(c,shared.crlf);
     } else if (!strcasecmp(c->argv[1]->ptr,"saveconfig") && c->argc == 2) {
         int retval = clusterSaveConfig(1);
 
@@ -4408,7 +4408,7 @@ try_again:
     /* Check if the key is here. If not we reply with success as there is
      * nothing to migrate (for instance the key expired in the meantime), but
      * we include such information in the reply string. */
-    if ((o = lookupKeyWrite(c->db,c->argv[3])) == NULL) {
+    if ((o = lookupKeyRead(c->db,c->argv[3])) == NULL) {
         addReplySds(c,sdsnew("+NOKEY\r\n"));
         return;
     }

src/cluster.h

@@ -176,10 +176,7 @@ typedef struct {
 typedef struct {
     uint32_t channel_len;
     uint32_t message_len;
-    /* We can't reclare bulk_data as bulk_data[] since this structure is
-     * nested. The 8 bytes are removed from the count during the message
-     * length computation. */
-    unsigned char bulk_data[8];
+    unsigned char bulk_data[8]; /* defined as 8 just for alignment concerns. */
 } clusterMsgDataPublish;
 
 typedef struct {

src/config.c

@@ -226,6 +226,11 @@ void loadServerConfigFromString(char *config) {
             }
         } else if (!strcasecmp(argv[0],"maxmemory") && argc == 2) {
             server.maxmemory = memtoll(argv[1],NULL);
+            server.maxmemory_enforced = (double) server.maxmemory / server.maxmemory_frag_guess;
+        } else if (!strcasecmp(argv[0],"rss-aware-maxmemory") && argc==2) {
+            if ((server.rss_aware_maxmemory = yesnotoi(argv[1])) == -1) {
+                err = "argument must be 'yes' or 'no'"; goto loaderr;
+            }
         } else if (!strcasecmp(argv[0],"maxmemory-policy") && argc == 2) {
             if (!strcasecmp(argv[1],"volatile-lru")) {
                 server.maxmemory_policy = REDIS_MAXMEMORY_VOLATILE_LRU;
@@ -397,13 +402,9 @@ void loadServerConfigFromString(char *config) {
         } else if (!strcasecmp(argv[0],"hash-max-ziplist-value") && argc == 2) {
             server.hash_max_ziplist_value = memtoll(argv[1], NULL);
         } else if (!strcasecmp(argv[0],"list-max-ziplist-entries") && argc == 2){
-            /* DEAD OPTION */
+            server.list_max_ziplist_entries = memtoll(argv[1], NULL);
         } else if (!strcasecmp(argv[0],"list-max-ziplist-value") && argc == 2) {
-            /* DEAD OPTION */
-        } else if (!strcasecmp(argv[0],"list-max-ziplist-size") && argc == 2) {
-            server.list_max_ziplist_size = atoi(argv[1]);
-        } else if (!strcasecmp(argv[0],"list-compress-depth") && argc == 2) {
-            server.list_compress_depth = atoi(argv[1]);
+            server.list_max_ziplist_value = memtoll(argv[1], NULL);
         } else if (!strcasecmp(argv[0],"set-max-intset-entries") && argc == 2) {
             server.set_max_intset_entries = memtoll(argv[1], NULL);
         } else if (!strcasecmp(argv[0],"zset-max-ziplist-entries") && argc == 2) {
@@ -635,12 +636,18 @@ void configSetCommand(redisClient *c) {
         if (getLongLongFromObject(o,&ll) == REDIS_ERR ||
             ll < 0) goto badfmt;
         server.maxmemory = ll;
+        server.maxmemory_enforced = (double) server.maxmemory / server.maxmemory_frag_guess;
         if (server.maxmemory) {
             if (server.maxmemory < zmalloc_used_memory()) {
                 redisLog(REDIS_WARNING,"WARNING: the new maxmemory value set via CONFIG SET is smaller than the current memory usage. This will result in keys eviction and/or inability to accept new write commands depending on the maxmemory-policy.");
             }
             freeMemoryIfNeeded();
         }
+    } else if (!strcasecmp(c->argv[2]->ptr,"rss-aware-maxmemory")) {
+        int yn = yesnotoi(o->ptr);
+
+        if (yn == -1) goto badfmt;
+        server.rss_aware_maxmemory = yn;
     } else if (!strcasecmp(c->argv[2]->ptr,"maxclients")) {
         int orig_value = server.maxclients;
 
@@ -799,12 +806,12 @@ void configSetCommand(redisClient *c) {
     } else if (!strcasecmp(c->argv[2]->ptr,"hash-max-ziplist-value")) {
         if (getLongLongFromObject(o,&ll) == REDIS_ERR || ll < 0) goto badfmt;
         server.hash_max_ziplist_value = ll;
-    } else if (!strcasecmp(c->argv[2]->ptr,"list-max-ziplist-size")) {
+    } else if (!strcasecmp(c->argv[2]->ptr,"list-max-ziplist-entries")) {
         if (getLongLongFromObject(o,&ll) == REDIS_ERR || ll < 0) goto badfmt;
-        server.list_max_ziplist_size = ll;
-    } else if (!strcasecmp(c->argv[2]->ptr,"list-compress-depth")) {
+        server.list_max_ziplist_entries = ll;
+    } else if (!strcasecmp(c->argv[2]->ptr,"list-max-ziplist-value")) {
         if (getLongLongFromObject(o,&ll) == REDIS_ERR || ll < 0) goto badfmt;
-        server.list_compress_depth = ll;
+        server.list_max_ziplist_value = ll;
     } else if (!strcasecmp(c->argv[2]->ptr,"set-max-intset-entries")) {
         if (getLongLongFromObject(o,&ll) == REDIS_ERR || ll < 0) goto badfmt;
         server.set_max_intset_entries = ll;
@@ -1008,20 +1015,6 @@ badfmt: /* Bad format errors */
     } \
 } while(0);
 
-char *maxmemoryToString() {
-    char *s;
-    switch(server.maxmemory_policy) {
-    case REDIS_MAXMEMORY_VOLATILE_LRU: s = "volatile-lru"; break;
-    case REDIS_MAXMEMORY_VOLATILE_TTL: s = "volatile-ttl"; break;
-    case REDIS_MAXMEMORY_VOLATILE_RANDOM: s = "volatile-random"; break;
-    case REDIS_MAXMEMORY_ALLKEYS_LRU: s = "allkeys-lru"; break;
-    case REDIS_MAXMEMORY_ALLKEYS_RANDOM: s = "allkeys-random"; break;
-    case REDIS_MAXMEMORY_NO_EVICTION: s = "noeviction"; break;
-    default: s = "unknown"; break;
-    }
-    return s;
-}
-
 void configGetCommand(redisClient *c) {
     robj *o = c->argv[2];
     void *replylen = addDeferredMultiBulkLength(c);
@@ -1051,10 +1044,10 @@ void configGetCommand(redisClient *c) {
             server.hash_max_ziplist_entries);
     config_get_numerical_field("hash-max-ziplist-value",
             server.hash_max_ziplist_value);
-    config_get_numerical_field("list-max-ziplist-size",
-            server.list_max_ziplist_size);
-    config_get_numerical_field("list-compress-depth",
-            server.list_compress_depth);
+    config_get_numerical_field("list-max-ziplist-entries",
+            server.list_max_ziplist_entries);
+    config_get_numerical_field("list-max-ziplist-value",
+            server.list_max_ziplist_value);
     config_get_numerical_field("set-max-intset-entries",
             server.set_max_intset_entries);
     config_get_numerical_field("zset-max-ziplist-entries",
@@ -1111,6 +1104,8 @@ void configGetCommand(redisClient *c) {
             server.aof_rewrite_incremental_fsync);
     config_get_bool_field("aof-load-truncated",
             server.aof_load_truncated);
+    config_get_bool_field("rss-aware-maxmemory",
+            server.rss_aware_maxmemory);
 
     /* Everything we can't handle with macros follows. */
 
@@ -1130,8 +1125,19 @@ void configGetCommand(redisClient *c) {
         matches++;
     }
     if (stringmatch(pattern,"maxmemory-policy",0)) {
+        char *s;
+
+        switch(server.maxmemory_policy) {
+        case REDIS_MAXMEMORY_VOLATILE_LRU: s = "volatile-lru"; break;
+        case REDIS_MAXMEMORY_VOLATILE_TTL: s = "volatile-ttl"; break;
+        case REDIS_MAXMEMORY_VOLATILE_RANDOM: s = "volatile-random"; break;
+        case REDIS_MAXMEMORY_ALLKEYS_LRU: s = "allkeys-lru"; break;
+        case REDIS_MAXMEMORY_ALLKEYS_RANDOM: s = "allkeys-random"; break;
+        case REDIS_MAXMEMORY_NO_EVICTION: s = "noeviction"; break;
+        default: s = "unknown"; break; /* too harmless to panic */
+        }
         addReplyBulkCString(c,"maxmemory-policy");
-        addReplyBulkCString(c,maxmemoryToString());
+        addReplyBulkCString(c,s);
         matches++;
     }
     if (stringmatch(pattern,"appendfsync",0)) {
@@ -1861,8 +1867,8 @@ int rewriteConfig(char *path) {
     rewriteConfigNotifykeyspaceeventsOption(state);
     rewriteConfigNumericalOption(state,"hash-max-ziplist-entries",server.hash_max_ziplist_entries,REDIS_HASH_MAX_ZIPLIST_ENTRIES);
     rewriteConfigNumericalOption(state,"hash-max-ziplist-value",server.hash_max_ziplist_value,REDIS_HASH_MAX_ZIPLIST_VALUE);
-    rewriteConfigNumericalOption(state,"list-max-ziplist-size",server.list_max_ziplist_size,REDIS_LIST_MAX_ZIPLIST_SIZE);
-    rewriteConfigNumericalOption(state,"list-compress-depth",server.list_compress_depth,REDIS_LIST_COMPRESS_DEPTH);
+    rewriteConfigNumericalOption(state,"list-max-ziplist-entries",server.list_max_ziplist_entries,REDIS_LIST_MAX_ZIPLIST_ENTRIES);
+    rewriteConfigNumericalOption(state,"list-max-ziplist-value",server.list_max_ziplist_value,REDIS_LIST_MAX_ZIPLIST_VALUE);
     rewriteConfigNumericalOption(state,"set-max-intset-entries",server.set_max_intset_entries,REDIS_SET_MAX_INTSET_ENTRIES);
     rewriteConfigNumericalOption(state,"zset-max-ziplist-entries",server.zset_max_ziplist_entries,REDIS_ZSET_MAX_ZIPLIST_ENTRIES);
     rewriteConfigNumericalOption(state,"zset-max-ziplist-value",server.zset_max_ziplist_value,REDIS_ZSET_MAX_ZIPLIST_VALUE);

src/config.h

@@ -48,12 +48,13 @@
 #define HAVE_PROC_STAT 1
 #define HAVE_PROC_MAPS 1
 #define HAVE_PROC_SMAPS 1
-#define HAVE_PROC_SOMAXCONN 1
+#define HAVE_RSS_REPORTING 1
 #endif
 
 /* Test for task_info() */
 #if defined(__APPLE__)
 #define HAVE_TASKINFO 1
+#define HAVE_RSS_REPORTING 1
 #endif
 
 /* Test for backtrace() */
@@ -61,11 +62,6 @@
 #define HAVE_BACKTRACE 1
 #endif
 
-/* MSG_NOSIGNAL. */
-#ifdef __linux__
-#define HAVE_MSG_NOSIGNAL 1
-#endif
-
 /* Test for polling API */
 #ifdef __linux__
 #define HAVE_EPOLL 1

src/crc64.c

@@ -181,13 +181,9 @@ uint64_t crc64(uint64_t crc, const unsigned char *s, uint64_t l) {
 }
 
 /* Test main */
-#ifdef REDIS_TEST
+#ifdef TEST_MAIN
 #include <stdio.h>
-
-#define UNUSED(x) (void)(x)
-int crc64Test(int argc, char *argv[]) {
-    UNUSED(argc);
-    UNUSED(argv);
+int main(void) {
     printf("e9c6d914c4b8d9ca == %016llx\n",
         (unsigned long long) crc64(0,(unsigned char*)"123456789",9));
     return 0;

src/crc64.h

@@ -5,8 +5,4 @@
 
 uint64_t crc64(uint64_t crc, const unsigned char *s, uint64_t l);
 
-#ifdef REDIS_TEST
-int crc64Test(int argc, char *argv[]);
-#endif
-
 #endif

src/db.c

@@ -60,32 +60,7 @@ robj *lookupKey(redisDb *db, robj *key) {
 robj *lookupKeyRead(redisDb *db, robj *key) {
     robj *val;
 
-    if (expireIfNeeded(db,key) == 1) {
-        /* Key expired. If we are in the context of a master, expireIfNeeded()
-         * returns 0 only when the key does not exist at all, so it's save
-         * to return NULL ASAP. */
-        if (server.masterhost == NULL) return NULL;
-
-        /* However if we are in the context of a slave, expireIfNeeded() will
-         * not really try to expire the key, it only returns information
-         * about the "logical" status of the key: key expiring is up to the
-         * master in order to have a consistent view of master's data set.
-         *
-         * However, if the command caller is not the master, and as additional
-         * safety measure, the command invoked is a read-only command, we can
-         * safely return NULL here, and provide a more consistent behavior
-         * to clients accessign expired values in a read-only fashion, that
-         * will say the key as non exisitng.
-         *
-         * Notably this covers GETs when slaves are used to scale reads. */
-        if (server.current_client &&
-            server.current_client != server.master &&
-            server.current_client->cmd &&
-            server.current_client->cmd->flags & REDIS_CMD_READONLY)
-        {
-            return NULL;
-        }
-    }
+    expireIfNeeded(db,key);
     val = lookupKey(db,key);
     if (val == NULL)
         server.stat_keyspace_misses++;
@@ -406,7 +381,7 @@ void scanCallback(void *privdata, const dictEntry *de) {
     } else if (o->type == REDIS_ZSET) {
         key = dictGetKey(de);
         incrRefCount(key);
-        val = createStringObjectFromLongDouble(*(double*)dictGetVal(de),0);
+        val = createStringObjectFromLongDouble(*(double*)dictGetVal(de));
     } else {
         redisPanic("Type not handled in SCAN callback.");
     }
@@ -450,8 +425,8 @@ void scanGenericCommand(redisClient *c, robj *o, unsigned long cursor) {
     list *keys = listCreate();
     listNode *node, *nextnode;
     long count = 10;
-    sds pat = NULL;
-    int patlen = 0, use_pattern = 0;
+    sds pat;
+    int patlen, use_pattern = 0;
     dict *ht;
 
     /* Object must be NULL (to iterate keys names), or the type of the object
@@ -902,7 +877,7 @@ void expireGenericCommand(redisClient *c, long long basetime, int unit) {
     when += basetime;
 
     /* No key, return zero. */
-    if (lookupKeyWrite(c->db,key) == NULL) {
+    if (lookupKeyRead(c->db,key) == NULL) {
         addReply(c,shared.czero);
         return;
     }

src/debug.c

@@ -252,12 +252,6 @@ void computeDatasetDigest(unsigned char *final) {
     }
 }
 
-void inputCatSds(void *result, const char *str) {
-    /* result is actually a (sds *), so re-cast it here */
-    sds *info = (sds *)result;
-    *info = sdscat(*info, str);
-}
-
 void debugCommand(redisClient *c) {
     if (!strcasecmp(c->argv[1]->ptr,"segfault")) {
         *((char*)-1) = 'x';
@@ -301,46 +295,13 @@ void debugCommand(redisClient *c) {
         val = dictGetVal(de);
         strenc = strEncoding(val->encoding);
 
-        char extra[128] = {0};
-        if (val->encoding == REDIS_ENCODING_QUICKLIST) {
-            char *nextra = extra;
-            int remaining = sizeof(extra);
-            quicklist *ql = val->ptr;
-            /* Add number of quicklist nodes */
-            int used = snprintf(nextra, remaining, " ql_nodes:%u", ql->len);
-            nextra += used;
-            remaining -= used;
-            /* Add average quicklist fill factor */
-            double avg = (double)ql->count/ql->len;
-            used = snprintf(nextra, remaining, " ql_avg_node:%.2f", avg);
-            nextra += used;
-            remaining -= used;
-            /* Add quicklist fill level / max ziplist size */
-            used = snprintf(nextra, remaining, " ql_ziplist_max:%d", ql->fill);
-            nextra += used;
-            remaining -= used;
-            /* Add isCompressed? */
-            int compressed = ql->compress != 0;
-            used = snprintf(nextra, remaining, " ql_compressed:%d", compressed);
-            nextra += used;
-            remaining -= used;
-            /* Add total uncompressed size */
-            unsigned long sz = 0;
-            for (quicklistNode *node = ql->head; node; node = node->next) {
-                sz += node->sz;
-            }
-            used = snprintf(nextra, remaining, " ql_uncompressed_size:%lu", sz);
-            nextra += used;
-            remaining -= used;
-        }
-
         addReplyStatusFormat(c,
             "Value at:%p refcount:%d "
             "encoding:%s serializedlength:%lld "
-            "lru:%d lru_seconds_idle:%llu%s",
+            "lru:%d lru_seconds_idle:%llu",
             (void*)val, val->refcount,
             strenc, (long long) rdbSavedObjectLen(val),
-            val->lru, estimateObjectIdleTime(val)/1000, extra);
+            val->lru, estimateObjectIdleTime(val));
     } else if (!strcasecmp(c->argv[1]->ptr,"sdslen") && c->argc == 3) {
         dictEntry *de;
         robj *val;
@@ -377,7 +338,7 @@ void debugCommand(redisClient *c) {
             snprintf(buf,sizeof(buf),"%s:%lu",
                 (c->argc == 3) ? "key" : (char*)c->argv[3]->ptr, j);
             key = createStringObject(buf,strlen(buf));
-            if (lookupKeyWrite(c->db,key) != NULL) {
+            if (lookupKeyRead(c->db,key) != NULL) {
                 decrRefCount(key);
                 continue;
             }
@@ -418,18 +379,6 @@ void debugCommand(redisClient *c) {
         errstr = sdsmapchars(errstr,"\n\r","  ",2); /* no newlines in errors. */
         errstr = sdscatlen(errstr,"\r\n",2);
         addReplySds(c,errstr);
-    } else if (!strcasecmp(c->argv[1]->ptr,"jemalloc") && c->argc == 3) {
-#if defined(USE_JEMALLOC)
-        if (!strcasecmp(c->argv[2]->ptr, "info")) {
-            sds info = sdsempty();
-            je_malloc_stats_print(inputCatSds, &info, NULL);
-            addReplyBulkSds(c, info);
-        } else {
-            addReplyErrorFormat(c, "Valid jemalloc debug fields: info");
-        }
-#else
-        addReplyErrorFormat(c, "jemalloc support not available");
-#endif
     } else {
         addReplyErrorFormat(c, "Unknown DEBUG subcommand or wrong number of arguments for '%s'",
             (char*)c->argv[1]->ptr);
@@ -908,7 +857,7 @@ void sigsegvHandler(int sig, siginfo_t *info, void *secret) {
 "  Suspect RAM error? Use redis-server --test-memory to verify it.\n\n"
 );
     /* free(messages); Don't call free() with possibly corrupted memory. */
-    if (server.daemonize && server.supervised == 0) unlink(server.pidfile);
+    if (server.daemonize) unlink(server.pidfile);
 
     /* Make sure we exit with the right signal at the end. So for instance
      * the core will be dumped if enabled. */

src/endianconv.c

@@ -101,16 +101,12 @@ uint64_t intrev64(uint64_t v) {
     return v;
 }
 
-#ifdef REDIS_TEST
+#ifdef TESTMAIN
 #include <stdio.h>
 
-#define UNUSED(x) (void)(x)
-int endianconvTest(int argc, char *argv[]) {
+int main(void) {
     char buf[32];
 
-    UNUSED(argc);
-    UNUSED(argv);
-
     sprintf(buf,"ciaoroma");
     memrev16(buf);
     printf("%s\n", buf);

src/endianconv.h

@@ -71,8 +71,4 @@ uint64_t intrev64(uint64_t v);
 #define ntohu64(v) intrev64(v)
 #endif
 
-#ifdef REDIS_TEST
-int endianconvTest(int argc, char *argv[]);
-#endif
-
 #endif

src/fmacros.h

@@ -34,7 +34,6 @@
 
 #if defined(__linux__)
 #define _GNU_SOURCE
-#define _DEFAULT_SOURCE
 #endif
 
 #if defined(_AIX)

src/help.h

@@ -651,8 +651,8 @@ struct commandHelp {
     0,
     "1.0.0" },
     { "SPOP",
-    "key [count]",
-    "Remove and return one or multiple random members from a set",
+    "key",
+    "Remove and return a random member from a set",
     3,
     "1.0.0" },
     { "SRANDMEMBER",

src/hyperloglog.c

@@ -1213,7 +1213,7 @@ void pfcountCommand(redisClient *c) {
         for (j = 1; j < c->argc; j++) {
             /* Check type and size. */
             robj *o = lookupKeyRead(c->db,c->argv[j]);
-            if (o == NULL) continue; /* Assume empty HLL for non existing var.*/
+            if (o == NULL) continue; /* Assume empty HLL for non existing var. */
             if (isHLLObjectOrReply(c,o) != REDIS_OK) return;
 
             /* Merge with this HLL with our 'max' HHL by setting max[i]
@@ -1233,7 +1233,7 @@ void pfcountCommand(redisClient *c) {
      *
      * The user specified a single key. Either return the cached value
      * or compute one and update the cache. */
-    o = lookupKeyWrite(c->db,c->argv[1]);
+    o = lookupKeyRead(c->db,c->argv[1]);
     if (o == NULL) {
         /* No key? Cardinality is zero since no element was added, otherwise
          * we would have a key as HLLADD creates it as a side effect. */
@@ -1458,7 +1458,7 @@ void pfdebugCommand(redisClient *c) {
     robj *o;
     int j;
 
-    o = lookupKeyWrite(c->db,c->argv[2]);
+    o = lookupKeyRead(c->db,c->argv[2]);
     if (o == NULL) {
         addReplyError(c,"The specified key does not exist");
         return;

src/intset.c

@@ -261,90 +261,6 @@ int64_t intsetRandom(intset *is) {
     return _intsetGet(is,rand()%intrev32ifbe(is->length));
 }
 
-/* How many times bigger should the set length be compared to the requested
- * count of members for us to use the Floyd algorithm instead of
- * the Knuth algorithm */
-#define RANDOMMEMBERS_ALGORITHM_SELECTION_RATIO (2)
-
-/* Copies 'count' random members from the set into the 'values' array.
- * 'values' must be an array of int64_t values, of length 'count'.
- * Returns the amount of items returned. If this amount is less than 'count',
- * then the remaining 'values' are left uninitialized. */
-int intsetRandomMembers(intset *is, int64_t* values, int count) {
-
-    /* We don't check that is and values are non-NULL - the caller must
-     * play nice. */
-
-    int length = intsetLen(is);
-
-    if (count > length) {
-        /* Return everything in the set */
-        count = length;
-    }
-
-    /* Choose between the Knuth shuffle algorithm, O(1) space, O(length) time,
-     * and the Floyd algorithm, O(length) space, O(count) time. */
-    if ((RANDOMMEMBERS_ALGORITHM_SELECTION_RATIO * count) > length) {
-
-        /* If the count of members requested is almost the length of the set,
-         * use the Knuth shuffle algorithm, O(1) space, O(length) time. */
-
-        /* First, fill the values array with unique random indexes inside
-         * the set. */
-        int in, im, rn, rm;
-        im = 0;
-        for (in = 0; in < length && im < count; in++) {
-
-            rn = length - in;
-            rm = count - im;
-            if (rand() % rn < rm) {
-                values[im++] = in;
-            }
-        }
-
-    } else {
-
-        /* If the length is considerably more than the count of members
-         * requested, use Robert Floyd's algorithm, O(length) space,
-         * O(count) time.
-         * Based on Jon Bentley's Programming Pearls */
-
-        int64_t *is_used = zcalloc(sizeof(int64_t) * length);
-        int in, im, r;
-
-        r = 0;
-        im = 0;
-
-        for (in = length - count; in < length && im < count; in++) {
-
-            /* Generate a random number r */
-            r = rand() % (in + 1);
-
-            /* Do we already have the value in r? */
-            if (is_used[r]) {
-                /* Use in instead of the generated number */
-                r = in;
-            }
-
-            values[im++] = r ;
-
-            /* Mark it as used */
-            is_used[r] = 1;
-        }
-
-        zfree(is_used);
-    }
-
-    /* Replace each random index with the value stored there in the intset */
-    uint8_t encoding = intrev32ifbe(is->encoding);
-    for (int currentValue = 0; currentValue < count; currentValue++) {
-        values[currentValue] =
-            _intsetGetEncoded(is, values[currentValue], encoding);
-    }
-
-    return count;
-}
-
 /* Sets the value to the value at the given position. When this position is
  * out of range the function returns 0, when in range it returns 1. */
 uint8_t intsetGet(intset *is, uint32_t pos, int64_t *value) {
@@ -365,46 +281,44 @@ size_t intsetBlobLen(intset *is) {
     return sizeof(intset)+intrev32ifbe(is->length)*intrev32ifbe(is->encoding);
 }
 
-#ifdef REDIS_TEST
+#ifdef INTSET_TEST_MAIN
 #include <sys/time.h>
-#include <time.h>
 
-#if 0
-static void intsetRepr(intset *is) {
-    for (uint32_t i = 0; i < intrev32ifbe(is->length); i++) {
+void intsetRepr(intset *is) {
+    int i;
+    for (i = 0; i < intrev32ifbe(is->length); i++) {
         printf("%lld\n", (uint64_t)_intsetGet(is,i));
     }
     printf("\n");
 }
 
-static void error(char *err) {
+void error(char *err) {
     printf("%s\n", err);
     exit(1);
 }
-#endif
 
-static void ok(void) {
+void ok(void) {
     printf("OK\n");
 }
 
-static long long usec(void) {
+long long usec(void) {
     struct timeval tv;
     gettimeofday(&tv,NULL);
     return (((long long)tv.tv_sec)*1000000)+tv.tv_usec;
 }
 
 #define assert(_e) ((_e)?(void)0:(_assert(#_e,__FILE__,__LINE__),exit(1)))
-static void _assert(char *estr, char *file, int line) {
+void _assert(char *estr, char *file, int line) {
     printf("\n\n=== ASSERTION FAILED ===\n");
     printf("==> %s:%d '%s' is not true\n",file,line,estr);
 }
 
-static intset *createSet(int bits, int size) {
+intset *createSet(int bits, int size) {
     uint64_t mask = (1<<bits)-1;
-    uint64_t value;
+    uint64_t i, value;
     intset *is = intsetNew();
 
-    for (int i = 0; i < size; i++) {
+    for (i = 0; i < size; i++) {
         if (bits > 32) {
             value = (rand()*rand()) & mask;
         } else {
@@ -415,8 +329,10 @@ static intset *createSet(int bits, int size) {
     return is;
 }
 
-static void checkConsistency(intset *is) {
-    for (uint32_t i = 0; i < (intrev32ifbe(is->length)-1); i++) {
+void checkConsistency(intset *is) {
+    int i;
+
+    for (i = 0; i < (intrev32ifbe(is->length)-1); i++) {
         uint32_t encoding = intrev32ifbe(is->encoding);
 
         if (encoding == INTSET_ENC_INT16) {
@@ -432,15 +348,11 @@ static void checkConsistency(intset *is) {
     }
 }
 
-#define UNUSED(x) (void)(x)
-int intsetTest(int argc, char **argv) {
+int main(int argc, char **argv) {
     uint8_t success;
     int i;
     intset *is;
-    srand(time(NULL));
-
-    UNUSED(argc);
-    UNUSED(argv);
+    sranddev();
 
     printf("Value encodings: "); {
         assert(_intsetValueEncoding(-32768) == INTSET_ENC_INT16);
@@ -451,10 +363,8 @@ int intsetTest(int argc, char **argv) {
         assert(_intsetValueEncoding(+2147483647) == INTSET_ENC_INT32);
         assert(_intsetValueEncoding(-2147483649) == INTSET_ENC_INT64);
         assert(_intsetValueEncoding(+2147483648) == INTSET_ENC_INT64);
-        assert(_intsetValueEncoding(-9223372036854775808ull) ==
-                    INTSET_ENC_INT64);
-        assert(_intsetValueEncoding(+9223372036854775807ull) ==
-                    INTSET_ENC_INT64);
+        assert(_intsetValueEncoding(-9223372036854775808ull) == INTSET_ENC_INT64);
+        assert(_intsetValueEncoding(+9223372036854775807ull) == INTSET_ENC_INT64);
         ok();
     }
 
@@ -468,7 +378,7 @@ int intsetTest(int argc, char **argv) {
     }
 
     printf("Large number of random adds: "); {
-        uint32_t inserts = 0;
+        int inserts = 0;
         is = intsetNew();
         for (i = 0; i < 1024; i++) {
             is = intsetAdd(is,rand()%0x800,&success);
@@ -551,8 +461,7 @@ int intsetTest(int argc, char **argv) {
 
         start = usec();
         for (i = 0; i < num; i++) intsetSearch(is,rand() % ((1<<bits)-1),NULL);
-        printf("%ld lookups, %ld element set, %lldusec\n",
-               num,size,usec()-start);
+        printf("%ld lookups, %ld element set, %lldusec\n",num,size,usec()-start);
     }
 
     printf("Stress add+delete: "); {
@@ -570,7 +479,5 @@ int intsetTest(int argc, char **argv) {
         checkConsistency(is);
         ok();
     }
-
-    return 0;
 }
 #endif

src/intset.h

@@ -43,13 +43,8 @@ intset *intsetAdd(intset *is, int64_t value, uint8_t *success);
 intset *intsetRemove(intset *is, int64_t value, int *success);
 uint8_t intsetFind(intset *is, int64_t value);
 int64_t intsetRandom(intset *is);
-int intsetRandomMembers(intset *is, int64_t* value, int count);
 uint8_t intsetGet(intset *is, uint32_t pos, int64_t *value);
 uint32_t intsetLen(intset *is);
 size_t intsetBlobLen(intset *is);
 
-#ifdef REDIS_TEST
-int intsetTest(int argc, char *argv[]);
-#endif
-
 #endif // __INTSET_H

src/latency.c

@@ -73,7 +73,6 @@ int THPIsEnabled(void) {
     fclose(fp);
     return (strstr(buf,"[never]") == NULL) ? 1 : 0;
 }
-#endif
 
 /* Report the amount of AnonHugePages in smap, in bytes. If the return
  * value of the function is non-zero, the process is being targeted by
@@ -81,6 +80,7 @@ int THPIsEnabled(void) {
 int THPGetAnonHugePagesSize(void) {
     return zmalloc_get_smap_bytes_by_field("AnonHugePages:");
 }
+#endif
 
 /* ---------------------------- Latency API --------------------------------- */
 
@@ -512,6 +512,7 @@ sds latencyCommandGenSparkeline(char *event, struct latencyTimeSeries *ts) {
     for (j = 0; j < LATENCY_TS_LEN; j++) {
         int i = (ts->idx + j) % LATENCY_TS_LEN;
         int elapsed;
+        char *label;
         char buf[64];
 
         if (ts->samples[i].time == 0) continue;
@@ -533,7 +534,8 @@ sds latencyCommandGenSparkeline(char *event, struct latencyTimeSeries *ts) {
             snprintf(buf,sizeof(buf),"%dh",elapsed/3600);
         else
             snprintf(buf,sizeof(buf),"%dd",elapsed/(3600*24));
-        sparklineSequenceAddSample(seq,ts->samples[i].latency,buf);
+        label = zstrdup(buf);
+        sparklineSequenceAddSample(seq,ts->samples[i].latency,label);
     }
 
     graph = sdscatprintf(graph,

src/lzfP.h

@@ -49,7 +49,7 @@
  * the difference between 15 and 14 is very small
  * for small blocks (and 14 is usually a bit faster).
  * For a low-memory/faster configuration, use HLOG == 13;
- * For best compression, use 15 or 16 (or more, up to 22).
+ * For best compression, use 15 or 16 (or more, up to 23).
  */
 #ifndef HLOG
 # define HLOG 16
@@ -94,7 +94,7 @@
 /*
  * Avoid assigning values to errno variable? for some embedding purposes
  * (linux kernel for example), this is necessary. NOTE: this breaks
- * the documentation in lzf.h. Avoiding errno has no speed impact.
+ * the documentation in lzf.h.
  */
 #ifndef AVOID_ERRNO
 # define AVOID_ERRNO 0
@@ -121,52 +121,16 @@
 # define CHECK_INPUT 1
 #endif
 
-/*
- * Whether to store pointers or offsets inside the hash table. On
- * 64 bit architetcures, pointers take up twice as much space,
- * and might also be slower. Default is to autodetect.
- */
-/*#define LZF_USER_OFFSETS autodetect */
-
 /*****************************************************************************/
 /* nothing should be changed below */
 
-#ifdef __cplusplus
-# include <cstring>
-# include <climits>
-using namespace std;
-#else
-# include <string.h>
-# include <limits.h>
-#endif
-
-#ifndef LZF_USE_OFFSETS
-# if defined (WIN32)
-#  define LZF_USE_OFFSETS defined(_M_X64)
-# else
-#  if __cplusplus > 199711L
-#   include <cstdint>
-#  else
-#   include <stdint.h>
-#  endif
-#  define LZF_USE_OFFSETS (UINTPTR_MAX > 0xffffffffU)
-# endif
-#endif
-
 typedef unsigned char u8;
 
-#if LZF_USE_OFFSETS
-# define LZF_HSLOT_BIAS ((const u8 *)in_data)
-  typedef unsigned int LZF_HSLOT;
-#else
-# define LZF_HSLOT_BIAS 0
-  typedef const u8 *LZF_HSLOT;
-#endif
-
-typedef LZF_HSLOT LZF_STATE[1 << (HLOG)];
+typedef const u8 *LZF_STATE[1 << (HLOG)];
 
 #if !STRICT_ALIGN
 /* for unaligned accesses we need a 16 bit datatype. */
+# include <limits.h>
 # if USHRT_MAX == 65535
     typedef unsigned short u16;
 # elif UINT_MAX == 65535
@@ -178,7 +142,17 @@ typedef LZF_HSLOT LZF_STATE[1 << (HLOG)];
 #endif
 
 #if ULTRA_FAST
-# undef VERY_FAST
+# if defined(VERY_FAST)
+#  undef VERY_FAST
+# endif
+#endif
+
+#if INIT_HTAB
+# ifdef __cplusplus
+#  include <cstring>
+# else
+#  include <string.h>
+# endif
 #endif
 
 #endif

src/lzf_c.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2010 Marc Alexander Lehmann <schmorp@schmorp.de>
+ * Copyright (c) 2000-2008 Marc Alexander Lehmann <schmorp@schmorp.de>
  *
  * Redistribution and use in source and binary forms, with or without modifica-
  * tion, are permitted provided that the following conditions are met:
@@ -40,8 +40,8 @@
 
 /*
  * don't play with this unless you benchmark!
- * the data format is not dependent on the hash function.
- * the hash function might seem strange, just believe me,
+ * decompression is not dependent on the hash function
+ * the hashing function might seem strange, just believe me
  * it works ;)
  */
 #ifndef FRST
@@ -89,9 +89,9 @@
 /*
  * compressed format
  *
- * 000LLLLL <L+1>    ; literal, L+1=1..33 octets
- * LLLooooo oooooooo ; backref L+1=1..7 octets, o+1=1..4096 offset
- * 111ooooo LLLLLLLL oooooooo ; backref L+8 octets, o+1=1..4096 offset
+ * 000LLLLL <L+1>    ; literal
+ * LLLooooo oooooooo ; backref L
+ * 111ooooo LLLLLLLL oooooooo ; backref L+7
  *
  */
 
@@ -106,6 +106,7 @@ lzf_compress (const void *const in_data, unsigned int in_len,
 #if !LZF_STATE_ARG
   LZF_STATE htab;
 #endif
+  const u8 **hslot;
   const u8 *ip = (const u8 *)in_data;
         u8 *op = (u8 *)out_data;
   const u8 *in_end  = ip + in_len;
@@ -132,6 +133,10 @@ lzf_compress (const void *const in_data, unsigned int in_len,
 
 #if INIT_HTAB
   memset (htab, 0, sizeof (htab));
+# if 0
+  for (hslot = htab; hslot < htab + HSIZE; hslot++)
+    *hslot++ = ip;
+# endif
 #endif
 
   lit = 0; op++; /* start run */
@@ -139,23 +144,24 @@ lzf_compress (const void *const in_data, unsigned int in_len,
   hval = FRST (ip);
   while (ip < in_end - 2)
     {
-      LZF_HSLOT *hslot;
-
       hval = NEXT (hval, ip);
       hslot = htab + IDX (hval);
-      ref = *hslot + LZF_HSLOT_BIAS; *hslot = ip - LZF_HSLOT_BIAS;
+      ref = *hslot; *hslot = ip;
 
       if (1
 #if INIT_HTAB
           && ref < ip /* the next test will actually take care of this, but this is faster */
 #endif
           && (off = ip - ref - 1) < MAX_OFF
+          && ip + 4 < in_end
           && ref > (u8 *)in_data
-          && ref[2] == ip[2]
 #if STRICT_ALIGN
-          && ((ref[1] << 8) | ref[0]) == ((ip[1] << 8) | ip[0])
+          && ref[0] == ip[0]
+          && ref[1] == ip[1]
+          && ref[2] == ip[2]
 #else
           && *(u16 *)ref == *(u16 *)ip
+          && ref[2] == ip[2]
 #endif
         )
         {
@@ -164,13 +170,12 @@ lzf_compress (const void *const in_data, unsigned int in_len,
           unsigned int maxlen = in_end - ip - len;
           maxlen = maxlen > MAX_REF ? MAX_REF : maxlen;
 
-          if (expect_false (op + 3 + 1 >= out_end)) /* first a faster conservative test */
-            if (op - !lit + 3 + 1 >= out_end) /* second the exact but rare test */
-              return 0;
-
           op [- lit - 1] = lit - 1; /* stop run */
           op -= !lit; /* undo run if length is zero */
 
+          if (expect_false (op + 3 + 1 >= out_end))
+            return 0;
+
           for (;;)
             {
               if (expect_true (maxlen > 16))
@@ -217,7 +222,6 @@ lzf_compress (const void *const in_data, unsigned int in_len,
             }
 
           *op++ = off;
-
           lit = 0; op++; /* start run */
 
           ip += len + 1;
@@ -233,12 +237,12 @@ lzf_compress (const void *const in_data, unsigned int in_len,
           hval = FRST (ip);
 
           hval = NEXT (hval, ip);
-          htab[IDX (hval)] = ip - LZF_HSLOT_BIAS;
+          htab[IDX (hval)] = ip;
           ip++;
 
 # if VERY_FAST && !ULTRA_FAST
           hval = NEXT (hval, ip);
-          htab[IDX (hval)] = ip - LZF_HSLOT_BIAS;
+          htab[IDX (hval)] = ip;
           ip++;
 # endif
 #else
@@ -247,7 +251,7 @@ lzf_compress (const void *const in_data, unsigned int in_len,
           do
             {
               hval = NEXT (hval, ip);
-              htab[IDX (hval)] = ip - LZF_HSLOT_BIAS;
+              htab[IDX (hval)] = ip;
               ip++;
             }
           while (len--);

src/lzf_d.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2010 Marc Alexander Lehmann <schmorp@schmorp.de>
+ * Copyright (c) 2000-2007 Marc Alexander Lehmann <schmorp@schmorp.de>
  *
  * Redistribution and use in source and binary forms, with or without modifica-
  * tion, are permitted provided that the following conditions are met:
@@ -43,14 +43,14 @@
 # define SET_ERRNO(n) errno = (n)
 #endif
 
-#if USE_REP_MOVSB /* small win on amd, big loss on intel */
+/*
 #if (__i386 || __amd64) && __GNUC__ >= 3
 # define lzf_movsb(dst, src, len)                \
    asm ("rep movsb"                              \
         : "=D" (dst), "=S" (src), "=c" (len)     \
         :  "0" (dst),  "1" (src),  "2" (len));
 #endif
-#endif
+*/
 
 unsigned int
 lzf_decompress (const void *const in_data,  unsigned int in_len,
@@ -86,17 +86,9 @@ lzf_decompress (const void *const in_data,  unsigned int in_len,
 #ifdef lzf_movsb
           lzf_movsb (op, ip, ctrl);
 #else
-          switch (ctrl)
-            {
-              case 32: *op++ = *ip++; case 31: *op++ = *ip++; case 30: *op++ = *ip++; case 29: *op++ = *ip++;
-              case 28: *op++ = *ip++; case 27: *op++ = *ip++; case 26: *op++ = *ip++; case 25: *op++ = *ip++;
-              case 24: *op++ = *ip++; case 23: *op++ = *ip++; case 22: *op++ = *ip++; case 21: *op++ = *ip++;
-              case 20: *op++ = *ip++; case 19: *op++ = *ip++; case 18: *op++ = *ip++; case 17: *op++ = *ip++;
-              case 16: *op++ = *ip++; case 15: *op++ = *ip++; case 14: *op++ = *ip++; case 13: *op++ = *ip++;
-              case 12: *op++ = *ip++; case 11: *op++ = *ip++; case 10: *op++ = *ip++; case  9: *op++ = *ip++;
-              case  8: *op++ = *ip++; case  7: *op++ = *ip++; case  6: *op++ = *ip++; case  5: *op++ = *ip++;
-              case  4: *op++ = *ip++; case  3: *op++ = *ip++; case  2: *op++ = *ip++; case  1: *op++ = *ip++;
-            }
+          do
+            *op++ = *ip++;
+          while (--ctrl);
 #endif
         }
       else /* back reference */
@@ -142,39 +134,12 @@ lzf_decompress (const void *const in_data,  unsigned int in_len,
           len += 2;
           lzf_movsb (op, ref, len);
 #else
-          switch (len)
-            {
-              default:
-                len += 2;
+          *op++ = *ref++;
+          *op++ = *ref++;
 
-                if (op >= ref + len)
-                  {
-                    /* disjunct areas */
-                    memcpy (op, ref, len);
-                    op += len;
-                  }
-                else
-                  {
-                    /* overlapping, use octte by octte copying */
-                    do
-                      *op++ = *ref++;
-                    while (--len);
-                  }
-
-                break;
-
-              case 9: *op++ = *ref++;
-              case 8: *op++ = *ref++;
-              case 7: *op++ = *ref++;
-              case 6: *op++ = *ref++;
-              case 5: *op++ = *ref++;
-              case 4: *op++ = *ref++;
-              case 3: *op++ = *ref++;
-              case 2: *op++ = *ref++;
-              case 1: *op++ = *ref++;
-              case 0: *op++ = *ref++; /* two octets more */
-                      *op++ = *ref++;
-            }
+          do
+            *op++ = *ref++;
+          while (--len);
 #endif
         }
     }

src/memtest.c

@@ -35,9 +35,6 @@
 #include <errno.h>
 #include <termios.h>
 #include <sys/ioctl.h>
-#if defined(__sun)
-#include <stropts.h>
-#endif
 #include "config.h"
 
 #if (ULONG_MAX == 4294967295UL)

src/networking.c

@@ -525,14 +525,6 @@ void addReplyBulkCBuffer(redisClient *c, void *p, size_t len) {
     addReply(c,shared.crlf);
 }
 
-/* Add sds to reply (takes ownership of sds and frees it) */
-void addReplyBulkSds(redisClient *c, sds s)  {
-    addReplySds(c,sdscatfmt(sdsempty(),"$%u\r\n",
-        (unsigned long)sdslen(s)));
-    addReplySds(c,s);
-    addReply(c,shared.crlf);
-}
-
 /* Add a C nul term string as bulk reply */
 void addReplyBulkCString(redisClient *c, char *s) {
     if (s == NULL) {
@@ -847,7 +839,6 @@ void sendReplyToClient(aeEventLoop *el, int fd, void *privdata, int mask) {
          *
          * However if we are over the maxmemory limit we ignore that and
          * just deliver as much data as it is possible to deliver. */
-        server.stat_net_output_bytes += totwritten;
         if (totwritten > REDIS_MAX_WRITE_PER_EVENT &&
             (server.maxmemory == 0 ||
              zmalloc_used_memory() < server.maxmemory)) break;
@@ -935,10 +926,8 @@ int processInlineBuffer(redisClient *c) {
     sdsrange(c->querybuf,querylen+2,-1);
 
     /* Setup argv array on client structure */
-    if (argc) {
-        if (c->argv) zfree(c->argv);
-        c->argv = zmalloc(sizeof(robj*)*argc);
-    }
+    if (c->argv) zfree(c->argv);
+    c->argv = zmalloc(sizeof(robj*)*argc);
 
     /* Create redis objects for all arguments. */
     for (c->argc = 0, j = 0; j < argc; j++) {
@@ -1190,7 +1179,6 @@ void readQueryFromClient(aeEventLoop *el, int fd, void *privdata, int mask) {
         sdsIncrLen(c->querybuf,nread);
         c->lastinteraction = server.unixtime;
         if (c->flags & REDIS_MASTER) c->reploff += nread;
-        server.stat_net_input_bytes += nread;
     } else {
         server.current_client = NULL;
         return;
@@ -1227,6 +1215,17 @@ void getClientsMaxBuffers(unsigned long *longest_output_list,
     *biggest_input_buffer = bib;
 }
 
+/* This is a helper function for genClientPeerId().
+ * It writes the specified ip/port to "peerid" as a null termiated string
+ * in the form ip:port if ip does not contain ":" itself, otherwise
+ * [ip]:port format is used (for IPv6 addresses basically). */
+void formatPeerId(char *peerid, size_t peerid_len, char *ip, int port) {
+    if (strchr(ip,':'))
+        snprintf(peerid,peerid_len,"[%s]:%d",ip,port);
+    else
+        snprintf(peerid,peerid_len,"%s:%d",ip,port);
+}
+
 /* A Redis "Peer ID" is a colon separated ip:port pair.
  * For IPv4 it's in the form x.y.z.k:port, example: "127.0.0.1:1234".
  * For IPv6 addresses we use [] around the IP part, like in "[::1]:1234".
@@ -1235,17 +1234,24 @@ void getClientsMaxBuffers(unsigned long *longest_output_list,
  * A Peer ID always fits inside a buffer of REDIS_PEER_ID_LEN bytes, including
  * the null term.
  *
+ * The function returns REDIS_OK on succcess, and REDIS_ERR on failure.
+ *
  * On failure the function still populates 'peerid' with the "?:0" string
  * in case you want to relax error checking or need to display something
  * anyway (see anetPeerToString implementation for more info). */
-void genClientPeerId(redisClient *client, char *peerid,
-                            size_t peerid_len) {
+int genClientPeerId(redisClient *client, char *peerid, size_t peerid_len) {
+    char ip[REDIS_IP_STR_LEN];
+    int port;
+
     if (client->flags & REDIS_UNIX_SOCKET) {
         /* Unix socket client. */
         snprintf(peerid,peerid_len,"%s:0",server.unixsocket);
+        return REDIS_OK;
     } else {
         /* TCP client. */
-        anetFormatPeer(client->fd,peerid,peerid_len);
+        int retval = anetPeerToString(client->fd,ip,sizeof(ip),&port);
+        formatPeerId(peerid,peerid_len,ip,port);
+        return (retval == -1) ? REDIS_ERR : REDIS_OK;
     }
 }
 

src/object.c

@@ -109,44 +109,26 @@ robj *createStringObjectFromLongLong(long long value) {
     return o;
 }
 
-/* Create a string object from a long double. If humanfriendly is non-zero
- * it does not use exponential format and trims trailing zeroes at the end,
- * however this results in loss of precision. Otherwise exp format is used
- * and the output of snprintf() is not modified.
- *
- * The 'humanfriendly' option is used for INCRBYFLOAT and HINCRBYFLOAT. */
-robj *createStringObjectFromLongDouble(long double value, int humanfriendly) {
+/* Note: this function is defined into object.c since here it is where it
+ * belongs but it is actually designed to be used just for INCRBYFLOAT */
+robj *createStringObjectFromLongDouble(long double value) {
     char buf[256];
     int len;
 
-    if (isinf(value)) {
-        /* Libc in odd systems (Hi Solaris!) will format infinite in a
-         * different way, so better to handle it in an explicit way. */
-        if (value > 0) {
-            memcpy(buf,"inf",3);
-            len = 3;
-        } else {
-            memcpy(buf,"-inf",4);
-            len = 4;
+    /* We use 17 digits precision since with 128 bit floats that precision
+     * after rounding is able to represent most small decimal numbers in a way
+     * that is "non surprising" for the user (that is, most small decimal
+     * numbers will be represented in a way that when converted back into
+     * a string are exactly the same as what the user typed.) */
+    len = snprintf(buf,sizeof(buf),"%.17Lf", value);
+    /* Now remove trailing zeroes after the '.' */
+    if (strchr(buf,'.') != NULL) {
+        char *p = buf+len-1;
+        while(*p == '0') {
+            p--;
+            len--;
         }
-    } else if (humanfriendly) {
-        /* We use 17 digits precision since with 128 bit floats that precision
-         * after rounding is able to represent most small decimal numbers in a
-         * way that is "non surprising" for the user (that is, most small
-         * decimal numbers will be represented in a way that when converted
-         * back into a string are exactly the same as what the user typed.) */
-        len = snprintf(buf,sizeof(buf),"%.17Lf", value);
-        /* Now remove trailing zeroes after the '.' */
-        if (strchr(buf,'.') != NULL) {
-            char *p = buf+len-1;
-            while(*p == '0') {
-                p--;
-                len--;
-            }
-            if (*p == '.') len--;
-        }
-    } else {
-        len = snprintf(buf,sizeof(buf),"%.17Lg", value);
+        if (*p == '.') len--;
     }
     return createStringObject(buf,len);
 }
@@ -180,10 +162,11 @@ robj *dupStringObject(robj *o) {
     }
 }
 
-robj *createQuicklistObject(void) {
-    quicklist *l = quicklistCreate();
+robj *createListObject(void) {
+    list *l = listCreate();
     robj *o = createObject(REDIS_LIST,l);
-    o->encoding = REDIS_ENCODING_QUICKLIST;
+    listSetFreeMethod(l,decrRefCountVoid);
+    o->encoding = REDIS_ENCODING_LINKEDLIST;
     return o;
 }
 
@@ -241,8 +224,11 @@ void freeStringObject(robj *o) {
 
 void freeListObject(robj *o) {
     switch (o->encoding) {
-    case REDIS_ENCODING_QUICKLIST:
-        quicklistRelease(o->ptr);
+    case REDIS_ENCODING_LINKEDLIST:
+        listRelease((list*) o->ptr);
+        break;
+    case REDIS_ENCODING_ZIPLIST:
+        zfree(o->ptr);
         break;
     default:
         redisPanic("Unknown list encoding type");
@@ -674,7 +660,7 @@ char *strEncoding(int encoding) {
     case REDIS_ENCODING_RAW: return "raw";
     case REDIS_ENCODING_INT: return "int";
     case REDIS_ENCODING_HT: return "hashtable";
-    case REDIS_ENCODING_QUICKLIST: return "quicklist";
+    case REDIS_ENCODING_LINKEDLIST: return "linkedlist";
     case REDIS_ENCODING_ZIPLIST: return "ziplist";
     case REDIS_ENCODING_INTSET: return "intset";
     case REDIS_ENCODING_SKIPLIST: return "skiplist";

src/quicklist.h

@@ -1,169 +0,0 @@
-/* quicklist.h - A generic doubly linked quicklist implementation
- *
- * Copyright (c) 2014, Matt Stancliff <matt@genges.com>
- * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *
- *   * Redistributions of source code must retain the above copyright notice,
- *     this quicklist of conditions and the following disclaimer.
- *   * Redistributions in binary form must reproduce the above copyright
- *     notice, this quicklist of conditions and the following disclaimer in the
- *     documentation and/or other materials provided with the distribution.
- *   * Neither the name of Redis nor the names of its contributors may be used
- *     to endorse or promote products derived from this software without
- *     specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
- * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
- * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
- * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- * POSSIBILITY OF SUCH DAMAGE.
- */
-
-#ifndef __QUICKLIST_H__
-#define __QUICKLIST_H__
-
-/* Node, quicklist, and Iterator are the only data structures used currently. */
-
-/* quicklistNode is a 32 byte struct describing a ziplist for a quicklist.
- * We use bit fields keep the quicklistNode at 32 bytes.
- * count: 16 bits, max 65536 (max zl bytes is 65k, so max count actually < 32k).
- * encoding: 2 bits, RAW=1, LZF=2.
- * container: 2 bits, NONE=1, ZIPLIST=2.
- * recompress: 1 bit, bool, true if node is temporarry decompressed for usage.
- * attempted_compress: 1 bit, boolean, used for verifying during testing.
- * extra: 12 bits, free for future use; pads out the remainder of 32 bits */
-typedef struct quicklistNode {
-    struct quicklistNode *prev;
-    struct quicklistNode *next;
-    unsigned char *zl;
-    unsigned int sz;             /* ziplist size in bytes */
-    unsigned int count : 16;     /* count of items in ziplist */
-    unsigned int encoding : 2;   /* RAW==1 or LZF==2 */
-    unsigned int container : 2;  /* NONE==1 or ZIPLIST==2 */
-    unsigned int recompress : 1; /* was this node previous compressed? */
-    unsigned int attempted_compress : 1; /* node can't compress; too small */
-    unsigned int extra : 10; /* more bits to steal for future usage */
-} quicklistNode;
-
-/* quicklistLZF is a 4+N byte struct holding 'sz' followed by 'compressed'.
- * 'sz' is byte length of 'compressed' field.
- * 'compressed' is LZF data with total (compressed) length 'sz'
- * NOTE: uncompressed length is stored in quicklistNode->sz.
- * When quicklistNode->zl is compressed, node->zl points to a quicklistLZF */
-typedef struct quicklistLZF {
-    unsigned int sz; /* LZF size in bytes*/
-    char compressed[];
-} quicklistLZF;
-
-/* quicklist is a 32 byte struct (on 64-bit systems) describing a quicklist.
- * 'count' is the number of total entries.
- * 'len' is the number of quicklist nodes.
- * 'compress' is: -1 if compression disabled, otherwise it's the number
- *                of quicklistNodes to leave uncompressed at ends of quicklist.
- * 'fill' is the user-requested (or default) fill factor. */
-typedef struct quicklist {
-    quicklistNode *head;
-    quicklistNode *tail;
-    unsigned long count;        /* total count of all entries in all ziplists */
-    unsigned int len;           /* number of quicklistNodes */
-    int fill : 16;              /* fill factor for individual nodes */
-    unsigned int compress : 16; /* depth of end nodes not to compress;0=off */
-} quicklist;
-
-typedef struct quicklistIter {
-    const quicklist *quicklist;
-    quicklistNode *current;
-    unsigned char *zi;
-    long offset; /* offset in current ziplist */
-    int direction;
-} quicklistIter;
-
-typedef struct quicklistEntry {
-    const quicklist *quicklist;
-    quicklistNode *node;
-    unsigned char *zi;
-    unsigned char *value;
-    unsigned int sz;
-    long long longval;
-    int offset;
-} quicklistEntry;
-
-#define QUICKLIST_HEAD 0
-#define QUICKLIST_TAIL -1
-
-/* quicklist node encodings */
-#define QUICKLIST_NODE_ENCODING_RAW 1
-#define QUICKLIST_NODE_ENCODING_LZF 2
-
-/* quicklist compression disable */
-#define QUICKLIST_NOCOMPRESS 0
-
-/* quicklist container formats */
-#define QUICKLIST_NODE_CONTAINER_NONE 1
-#define QUICKLIST_NODE_CONTAINER_ZIPLIST 2
-
-#define quicklistNodeIsCompressed(node)                                        \
-    ((node)->encoding == QUICKLIST_NODE_ENCODING_LZF)
-
-/* Prototypes */
-quicklist *quicklistCreate(void);
-quicklist *quicklistNew(int fill, int compress);
-void quicklistSetCompressDepth(quicklist *quicklist, int depth);
-void quicklistSetFill(quicklist *quicklist, int fill);
-void quicklistSetOptions(quicklist *quicklist, int fill, int depth);
-void quicklistRelease(quicklist *quicklist);
-int quicklistPushHead(quicklist *quicklist, void *value, const size_t sz);
-int quicklistPushTail(quicklist *quicklist, void *value, const size_t sz);
-void quicklistPush(quicklist *quicklist, void *value, const size_t sz,
-                   int where);
-void quicklistAppendZiplist(quicklist *quicklist, unsigned char *zl);
-quicklist *quicklistAppendValuesFromZiplist(quicklist *quicklist,
-                                            unsigned char *zl);
-quicklist *quicklistCreateFromZiplist(int fill, int compress,
-                                      unsigned char *zl);
-void quicklistInsertAfter(quicklist *quicklist, quicklistEntry *node,
-                          void *value, const size_t sz);
-void quicklistInsertBefore(quicklist *quicklist, quicklistEntry *node,
-                           void *value, const size_t sz);
-void quicklistDelEntry(quicklistIter *iter, quicklistEntry *entry);
-int quicklistReplaceAtIndex(quicklist *quicklist, long index, void *data,
-                            int sz);
-int quicklistDelRange(quicklist *quicklist, const long start, const long stop);
-quicklistIter *quicklistGetIterator(const quicklist *quicklist, int direction);
-quicklistIter *quicklistGetIteratorAtIdx(const quicklist *quicklist,
-                                         int direction, const long long idx);
-int quicklistNext(quicklistIter *iter, quicklistEntry *node);
-void quicklistReleaseIterator(quicklistIter *iter);
-quicklist *quicklistDup(quicklist *orig);
-int quicklistIndex(const quicklist *quicklist, const long long index,
-                   quicklistEntry *entry);
-void quicklistRewind(quicklist *quicklist, quicklistIter *li);
-void quicklistRewindTail(quicklist *quicklist, quicklistIter *li);
-void quicklistRotate(quicklist *quicklist);
-int quicklistPopCustom(quicklist *quicklist, int where, unsigned char **data,
-                       unsigned int *sz, long long *sval,
-                       void *(*saver)(unsigned char *data, unsigned int sz));
-int quicklistPop(quicklist *quicklist, int where, unsigned char **data,
-                 unsigned int *sz, long long *slong);
-unsigned int quicklistCount(quicklist *ql);
-int quicklistCompare(unsigned char *p1, unsigned char *p2, int p2_len);
-size_t quicklistGetLzf(const quicklistNode *node, void **data);
-
-#ifdef REDIS_TEST
-int quicklistTest(int argc, char *argv[]);
-#endif
-
-/* Directions for iterators */
-#define AL_START_HEAD 0
-#define AL_START_TAIL 1
-
-#endif /* __QUICKLIST_H__ */

src/rdb.c

@@ -40,10 +40,6 @@
 #include <arpa/inet.h>
 #include <sys/stat.h>
 
-#define RDB_LOAD_NONE   0
-#define RDB_LOAD_ENC    (1<<0)
-#define RDB_LOAD_PLAIN  (1<<1)
-
 static int rdbWriteRaw(rio *rdb, void *p, size_t len) {
     if (rdb && rioWrite(rdb,p,len) == 0)
         return -1;
@@ -165,11 +161,9 @@ int rdbEncodeInteger(long long value, unsigned char *enc) {
 }
 
 /* Loads an integer-encoded object with the specified encoding type "enctype".
- * The returned value changes according to the flags, see
- * rdbGenerincLoadStringObject() for more info. */
-void *rdbLoadIntegerObject(rio *rdb, int enctype, int flags) {
-    int plain = flags & RDB_LOAD_PLAIN;
-    int encode = flags & RDB_LOAD_ENC;
+ * If the "encode" argument is set the function may return an integer-encoded
+ * string object, otherwise it always returns a raw string object. */
+robj *rdbLoadIntegerObject(rio *rdb, int enctype, int encode) {
     unsigned char enc[4];
     long long val;
 
@@ -190,17 +184,10 @@ void *rdbLoadIntegerObject(rio *rdb, int enctype, int flags) {
         val = 0; /* anti-warning */
         redisPanic("Unknown RDB integer encoding type");
     }
-    if (plain) {
-        char buf[REDIS_LONGSTR_SIZE], *p;
-        int len = ll2string(buf,sizeof(buf),val);
-        p = zmalloc(len);
-        memcpy(p,buf,len);
-        return p;
-    } else if (encode) {
+    if (encode)
         return createStringObjectFromLongLong(val);
-    } else {
+    else
         return createObject(REDIS_STRING,sdsfromlonglong(val));
-    }
 }
 
 /* String objects in the form "2391" "-100" without any space and with a
@@ -222,33 +209,10 @@ int rdbTryIntegerEncoding(char *s, size_t len, unsigned char *enc) {
     return rdbEncodeInteger(value,enc);
 }
 
-int rdbSaveLzfBlob(rio *rdb, void *data, size_t compress_len,
-                   size_t original_len) {
-    unsigned char byte;
-    int n, nwritten = 0;
-
-    /* Data compressed! Let's save it on disk */
-    byte = (REDIS_RDB_ENCVAL<<6)|REDIS_RDB_ENC_LZF;
-    if ((n = rdbWriteRaw(rdb,&byte,1)) == -1) goto writeerr;
-    nwritten += n;
-
-    if ((n = rdbSaveLen(rdb,compress_len)) == -1) goto writeerr;
-    nwritten += n;
-
-    if ((n = rdbSaveLen(rdb,original_len)) == -1) goto writeerr;
-    nwritten += n;
-
-    if ((n = rdbWriteRaw(rdb,data,compress_len)) == -1) goto writeerr;
-    nwritten += n;
-
-    return nwritten;
-
-writeerr:
-    return -1;
-}
-
 int rdbSaveLzfStringObject(rio *rdb, unsigned char *s, size_t len) {
     size_t comprlen, outlen;
+    unsigned char byte;
+    int n, nwritten = 0;
     void *out;
 
     /* We require at least four bytes compression for this to be worth it */
@@ -260,16 +224,29 @@ int rdbSaveLzfStringObject(rio *rdb, unsigned char *s, size_t len) {
         zfree(out);
         return 0;
     }
-    size_t nwritten = rdbSaveLzfBlob(rdb, out, comprlen, len);
+    /* Data compressed! Let's save it on disk */
+    byte = (REDIS_RDB_ENCVAL<<6)|REDIS_RDB_ENC_LZF;
+    if ((n = rdbWriteRaw(rdb,&byte,1)) == -1) goto writeerr;
+    nwritten += n;
+
+    if ((n = rdbSaveLen(rdb,comprlen)) == -1) goto writeerr;
+    nwritten += n;
+
+    if ((n = rdbSaveLen(rdb,len)) == -1) goto writeerr;
+    nwritten += n;
+
+    if ((n = rdbWriteRaw(rdb,out,comprlen)) == -1) goto writeerr;
+    nwritten += n;
+
     zfree(out);
     return nwritten;
+
+writeerr:
+    zfree(out);
+    return -1;
 }
 
-/* Load an LZF compressed string in RDB format. The returned value
- * changes according to 'flags'. For more info check the
- * rdbGenericLoadStringObject() function. */
-void *rdbLoadLzfStringObject(rio *rdb, int flags) {
-    int plain = flags & RDB_LOAD_PLAIN;
+robj *rdbLoadLzfStringObject(rio *rdb) {
     unsigned int len, clen;
     unsigned char *c = NULL;
     sds val = NULL;
@@ -277,29 +254,14 @@ void *rdbLoadLzfStringObject(rio *rdb, int flags) {
     if ((clen = rdbLoadLen(rdb,NULL)) == REDIS_RDB_LENERR) return NULL;
     if ((len = rdbLoadLen(rdb,NULL)) == REDIS_RDB_LENERR) return NULL;
     if ((c = zmalloc(clen)) == NULL) goto err;
-
-    /* Allocate our target according to the uncompressed size. */
-    if (plain) {
-        val = zmalloc(len);
-    } else {
-        if ((val = sdsnewlen(NULL,len)) == NULL) goto err;
-    }
-
-    /* Load the compressed representation and uncompress it to target. */
+    if ((val = sdsnewlen(NULL,len)) == NULL) goto err;
     if (rioRead(rdb,c,clen) == 0) goto err;
     if (lzf_decompress(c,clen,val,len) == 0) goto err;
     zfree(c);
-
-    if (plain)
-        return val;
-    else
-        return createObject(REDIS_STRING,val);
+    return createObject(REDIS_STRING,val);
 err:
     zfree(c);
-    if (plain)
-        zfree(val);
-    else
-        sdsfree(val);
+    sdsfree(val);
     return NULL;
 }
 
@@ -368,21 +330,10 @@ int rdbSaveStringObject(rio *rdb, robj *obj) {
     }
 }
 
-/* Load a string object from an RDB file according to flags:
- *
- * RDB_LOAD_NONE (no flags): load an RDB object, unencoded.
- * RDB_LOAD_ENC: If the returned type is a Redis object, try to
- *               encode it in a special way to be more memory
- *               efficient. When this flag is passed the function
- *               no longer guarantees that obj->ptr is an SDS string.
- * RDB_LOAD_PLAIN: Return a plain string allocated with zmalloc()
- *                 instead of a Redis object.
- */
-void *rdbGenericLoadStringObject(rio *rdb, int flags) {
-    int encode = flags & RDB_LOAD_ENC;
-    int plain = flags & RDB_LOAD_PLAIN;
+robj *rdbGenericLoadStringObject(rio *rdb, int encode) {
     int isencoded;
     uint32_t len;
+    robj *o;
 
     len = rdbLoadLen(rdb,&isencoded);
     if (isencoded) {
@@ -390,39 +341,30 @@ void *rdbGenericLoadStringObject(rio *rdb, int flags) {
         case REDIS_RDB_ENC_INT8:
         case REDIS_RDB_ENC_INT16:
         case REDIS_RDB_ENC_INT32:
-            return rdbLoadIntegerObject(rdb,len,flags);
+            return rdbLoadIntegerObject(rdb,len,encode);
         case REDIS_RDB_ENC_LZF:
-            return rdbLoadLzfStringObject(rdb,flags);
+            return rdbLoadLzfStringObject(rdb);
         default:
             redisPanic("Unknown RDB encoding type");
         }
     }
 
     if (len == REDIS_RDB_LENERR) return NULL;
-    if (!plain) {
-        robj *o = encode ? createStringObject(NULL,len) :
-                           createRawStringObject(NULL,len);
-        if (len && rioRead(rdb,o->ptr,len) == 0) {
-            decrRefCount(o);
-            return NULL;
-        }
-        return o;
-    } else {
-        void *buf = zmalloc(len);
-        if (len && rioRead(rdb,buf,len) == 0) {
-            zfree(buf);
-            return NULL;
-        }
-        return buf;
+    o = encode ? createStringObject(NULL,len) :
+                 createRawStringObject(NULL,len);
+    if (len && rioRead(rdb,o->ptr,len) == 0) {
+        decrRefCount(o);
+        return NULL;
     }
+    return o;
 }
 
 robj *rdbLoadStringObject(rio *rdb) {
-    return rdbGenericLoadStringObject(rdb,RDB_LOAD_NONE);
+    return rdbGenericLoadStringObject(rdb,0);
 }
 
 robj *rdbLoadEncodedStringObject(rio *rdb) {
-    return rdbGenericLoadStringObject(rdb,RDB_LOAD_ENC);
+    return rdbGenericLoadStringObject(rdb,1);
 }
 
 /* Save a double value. Doubles are saved as strings prefixed by an unsigned
@@ -491,8 +433,10 @@ int rdbSaveObjectType(rio *rdb, robj *o) {
     case REDIS_STRING:
         return rdbSaveType(rdb,REDIS_RDB_TYPE_STRING);
     case REDIS_LIST:
-        if (o->encoding == REDIS_ENCODING_QUICKLIST)
-            return rdbSaveType(rdb,REDIS_RDB_TYPE_LIST_QUICKLIST);
+        if (o->encoding == REDIS_ENCODING_ZIPLIST)
+            return rdbSaveType(rdb,REDIS_RDB_TYPE_LIST_ZIPLIST);
+        else if (o->encoding == REDIS_ENCODING_LINKEDLIST)
+            return rdbSaveType(rdb,REDIS_RDB_TYPE_LIST);
         else
             redisPanic("Unknown list encoding");
     case REDIS_SET:
@@ -533,7 +477,7 @@ int rdbLoadObjectType(rio *rdb) {
 
 /* Save a Redis object. Returns -1 on error, number of bytes written on success. */
 int rdbSaveObject(rio *rdb, robj *o) {
-    int n = 0, nwritten = 0;
+    int n, nwritten = 0;
 
     if (o->type == REDIS_STRING) {
         /* Save a string value */
@@ -541,24 +485,25 @@ int rdbSaveObject(rio *rdb, robj *o) {
         nwritten += n;
     } else if (o->type == REDIS_LIST) {
         /* Save a list value */
-        if (o->encoding == REDIS_ENCODING_QUICKLIST) {
-            quicklist *ql = o->ptr;
-            quicklistNode *node = ql->head;
+        if (o->encoding == REDIS_ENCODING_ZIPLIST) {
+            size_t l = ziplistBlobLen((unsigned char*)o->ptr);
 
-            if ((n = rdbSaveLen(rdb,ql->len)) == -1) return -1;
+            if ((n = rdbSaveRawString(rdb,o->ptr,l)) == -1) return -1;
+            nwritten += n;
+        } else if (o->encoding == REDIS_ENCODING_LINKEDLIST) {
+            list *list = o->ptr;
+            listIter li;
+            listNode *ln;
+
+            if ((n = rdbSaveLen(rdb,listLength(list))) == -1) return -1;
             nwritten += n;
 
-            do {
-                if (quicklistNodeIsCompressed(node)) {
-                    void *data;
-                    size_t compress_len = quicklistGetLzf(node, &data);
-                    if ((n = rdbSaveLzfBlob(rdb,data,compress_len,node->sz)) == -1) return -1;
-                    nwritten += n;
-                } else {
-                    if ((n = rdbSaveRawString(rdb,node->zl,node->sz)) == -1) return -1;
-                    nwritten += n;
-                }
-            } while ((node = node->next));
+            listRewind(list,&li);
+            while((ln = listNext(&li))) {
+                robj *eleobj = listNodeValue(ln);
+                if ((n = rdbSaveStringObject(rdb,eleobj)) == -1) return -1;
+                nwritten += n;
+            }
         } else {
             redisPanic("Unknown list encoding");
         }
@@ -682,39 +627,6 @@ int rdbSaveKeyValuePair(rio *rdb, robj *key, robj *val,
     return 1;
 }
 
-/* Save an AUX field. */
-int rdbSaveAuxField(rio *rdb, void *key, size_t keylen, void *val, size_t vallen) {
-    if (rdbSaveType(rdb,REDIS_RDB_OPCODE_AUX) == -1) return -1;
-    if (rdbSaveRawString(rdb,key,keylen) == -1) return -1;
-    if (rdbSaveRawString(rdb,val,vallen) == -1) return -1;
-    return 1;
-}
-
-/* Wrapper for rdbSaveAuxField() used when key/val length can be obtained
- * with strlen(). */
-int rdbSaveAuxFieldStrStr(rio *rdb, char *key, char *val) {
-    return rdbSaveAuxField(rdb,key,strlen(key),val,strlen(val));
-}
-
-/* Wrapper for strlen(key) + integer type (up to long long range). */
-int rdbSaveAuxFieldStrInt(rio *rdb, char *key, long long val) {
-    char buf[REDIS_LONGSTR_SIZE];
-    int vlen = ll2string(buf,sizeof(buf),val);
-    return rdbSaveAuxField(rdb,key,strlen(key),buf,vlen);
-}
-
-/* Save a few default AUX fields with information about the RDB generated. */
-int rdbSaveInfoAuxFields(rio *rdb) {
-    int redis_bits = (sizeof(void*) == 8) ? 64 : 32;
-
-    /* Add a few fiels about the state when the RDB was created. */
-    if (rdbSaveAuxFieldStrStr(rdb,"redis-ver",REDIS_VERSION) == -1) return -1;
-    if (rdbSaveAuxFieldStrInt(rdb,"redis-bits",redis_bits) == -1) return -1;
-    if (rdbSaveAuxFieldStrInt(rdb,"ctime",time(NULL)) == -1) return -1;
-    if (rdbSaveAuxFieldStrInt(rdb,"used-mem",zmalloc_used_memory()) == -1) return -1;
-    return 1;
-}
-
 /* Produces a dump of the database in RDB format sending it to the specified
  * Redis I/O channel. On success REDIS_OK is returned, otherwise REDIS_ERR
  * is returned and part of the output, or all the output, can be
@@ -735,7 +647,6 @@ int rdbSaveRio(rio *rdb, int *error) {
         rdb->update_cksum = rioGenericUpdateChecksum;
     snprintf(magic,sizeof(magic),"REDIS%04d",REDIS_RDB_VERSION);
     if (rdbWriteRaw(rdb,magic,9) == -1) goto werr;
-    if (rdbSaveInfoAuxFields(rdb) == -1) goto werr;
 
     for (j = 0; j < server.dbnum; j++) {
         redisDb *db = server.db+j;
@@ -748,21 +659,6 @@ int rdbSaveRio(rio *rdb, int *error) {
         if (rdbSaveType(rdb,REDIS_RDB_OPCODE_SELECTDB) == -1) goto werr;
         if (rdbSaveLen(rdb,j) == -1) goto werr;
 
-        /* Write the RESIZE DB opcode. We trim the size to UINT32_MAX, which
-         * is currently the largest type we are able to represent in RDB sizes.
-         * However this does not limit the actual size of the DB to load since
-         * these sizes are just hints to resize the hash tables. */
-        uint32_t db_size, expires_size;
-        db_size = (dictSize(db->dict) <= UINT32_MAX) ?
-                                dictSize(db->dict) :
-                                UINT32_MAX;
-        expires_size = (dictSize(db->dict) <= UINT32_MAX) ?
-                                dictSize(db->expires) :
-                                UINT32_MAX;
-        if (rdbSaveType(rdb,REDIS_RDB_OPCODE_RESIZEDB) == -1) goto werr;
-        if (rdbSaveLen(rdb,db_size) == -1) goto werr;
-        if (rdbSaveLen(rdb,expires_size) == -1) goto werr;
-
         /* Iterate this DB writing every entry */
         while((de = dictNext(di)) != NULL) {
             sds keystr = dictGetKey(de);
@@ -824,7 +720,7 @@ int rdbSave(char *filename) {
     char tmpfile[256];
     FILE *fp;
     rio rdb;
-    int error = 0;
+    int error;
 
     snprintf(tmpfile,256,"temp-%d.rdb", (int) getpid());
     fp = fopen(tmpfile,"w");
@@ -935,18 +831,33 @@ robj *rdbLoadObject(int rdbtype, rio *rdb) {
         /* Read list value */
         if ((len = rdbLoadLen(rdb,NULL)) == REDIS_RDB_LENERR) return NULL;
 
-        o = createQuicklistObject();
-        quicklistSetOptions(o->ptr, server.list_max_ziplist_size,
-                            server.list_compress_depth);
+        /* Use a real list when there are too many entries */
+        if (len > server.list_max_ziplist_entries) {
+            o = createListObject();
+        } else {
+            o = createZiplistObject();
+        }
 
         /* Load every single element of the list */
         while(len--) {
             if ((ele = rdbLoadEncodedStringObject(rdb)) == NULL) return NULL;
-            dec = getDecodedObject(ele);
-            size_t len = sdslen(dec->ptr);
-            quicklistPushTail(o->ptr, dec->ptr, len);
-            decrRefCount(dec);
-            decrRefCount(ele);
+
+            /* If we are using a ziplist and the value is too big, convert
+             * the object to a real list. */
+            if (o->encoding == REDIS_ENCODING_ZIPLIST &&
+                sdsEncodedObject(ele) &&
+                sdslen(ele->ptr) > server.list_max_ziplist_value)
+                    listTypeConvert(o,REDIS_ENCODING_LINKEDLIST);
+
+            if (o->encoding == REDIS_ENCODING_ZIPLIST) {
+                dec = getDecodedObject(ele);
+                o->ptr = ziplistPush(o->ptr,dec->ptr,sdslen(dec->ptr),REDIS_TAIL);
+                decrRefCount(dec);
+                decrRefCount(ele);
+            } else {
+                ele = tryObjectEncoding(ele);
+                listAddNodeTail(o->ptr,ele);
+            }
         }
     } else if (rdbtype == REDIS_RDB_TYPE_SET) {
         /* Read list/set value */
@@ -1083,26 +994,20 @@ robj *rdbLoadObject(int rdbtype, rio *rdb) {
 
         /* All pairs should be read by now */
         redisAssert(len == 0);
-    } else if (rdbtype == REDIS_RDB_TYPE_LIST_QUICKLIST) {
-        if ((len = rdbLoadLen(rdb,NULL)) == REDIS_RDB_LENERR) return NULL;
-        o = createQuicklistObject();
-        quicklistSetOptions(o->ptr, server.list_max_ziplist_size,
-                            server.list_compress_depth);
 
-        while (len--) {
-            unsigned char *zl = rdbGenericLoadStringObject(rdb,RDB_LOAD_PLAIN);
-            if (zl == NULL) return NULL;
-            quicklistAppendZiplist(o->ptr, zl);
-        }
     } else if (rdbtype == REDIS_RDB_TYPE_HASH_ZIPMAP  ||
                rdbtype == REDIS_RDB_TYPE_LIST_ZIPLIST ||
                rdbtype == REDIS_RDB_TYPE_SET_INTSET   ||
                rdbtype == REDIS_RDB_TYPE_ZSET_ZIPLIST ||
                rdbtype == REDIS_RDB_TYPE_HASH_ZIPLIST)
     {
-        unsigned char *encoded = rdbGenericLoadStringObject(rdb,RDB_LOAD_PLAIN);
-        if (encoded == NULL) return NULL;
-        o = createObject(REDIS_STRING,encoded); /* Obj type fixed below. */
+        robj *aux = rdbLoadStringObject(rdb);
+
+        if (aux == NULL) return NULL;
+        o = createObject(REDIS_STRING,NULL); /* string is just placeholder */
+        o->ptr = zmalloc(sdslen(aux->ptr));
+        memcpy(o->ptr,aux->ptr,sdslen(aux->ptr));
+        decrRefCount(aux);
 
         /* Fix the object encoding, and make sure to convert the encoded
          * data type into the base type if accordingly to the current
@@ -1143,7 +1048,8 @@ robj *rdbLoadObject(int rdbtype, rio *rdb) {
             case REDIS_RDB_TYPE_LIST_ZIPLIST:
                 o->type = REDIS_LIST;
                 o->encoding = REDIS_ENCODING_ZIPLIST;
-                listTypeConvert(o,REDIS_ENCODING_QUICKLIST);
+                if (ziplistLen(o->ptr) > server.list_max_ziplist_entries)
+                    listTypeConvert(o,REDIS_ENCODING_LINKEDLIST);
                 break;
             case REDIS_RDB_TYPE_SET_INTSET:
                 o->type = REDIS_SET;
@@ -1181,9 +1087,8 @@ void startLoading(FILE *fp) {
     /* Load the DB */
     server.loading = 1;
     server.loading_start_time = time(NULL);
-    server.loading_loaded_bytes = 0;
     if (fstat(fileno(fp), &sb) == -1) {
-        server.loading_total_bytes = 0;
+        server.loading_total_bytes = 1; /* just to avoid division by zero */
     } else {
         server.loading_total_bytes = sb.st_size;
     }
@@ -1257,12 +1162,7 @@ int rdbLoad(char *filename) {
 
         /* Read type. */
         if ((type = rdbLoadType(&rdb)) == -1) goto eoferr;
-
-        /* Handle special types. */
         if (type == REDIS_RDB_OPCODE_EXPIRETIME) {
-            /* EXPIRETIME: load an expire associated with the next key
-             * to load. Note that after loading an expire we need to
-             * load the actual type, and continue. */
             if ((expiretime = rdbLoadTime(&rdb)) == -1) goto eoferr;
             /* We read the time so we need to read the object type again. */
             if ((type = rdbLoadType(&rdb)) == -1) goto eoferr;
@@ -1270,65 +1170,27 @@ int rdbLoad(char *filename) {
              * into milliseconds. */
             expiretime *= 1000;
         } else if (type == REDIS_RDB_OPCODE_EXPIRETIME_MS) {
-            /* EXPIRETIME_MS: milliseconds precision expire times introduced
-             * with RDB v3. Like EXPIRETIME but no with more precision. */
+            /* Milliseconds precision expire times introduced with RDB
+             * version 3. */
             if ((expiretime = rdbLoadMillisecondTime(&rdb)) == -1) goto eoferr;
             /* We read the time so we need to read the object type again. */
             if ((type = rdbLoadType(&rdb)) == -1) goto eoferr;
-        } else if (type == REDIS_RDB_OPCODE_EOF) {
-            /* EOF: End of file, exit the main loop. */
+        }
+
+        if (type == REDIS_RDB_OPCODE_EOF)
             break;
-        } else if (type == REDIS_RDB_OPCODE_SELECTDB) {
-            /* SELECTDB: Select the specified database. */
+
+        /* Handle SELECT DB opcode as a special case */
+        if (type == REDIS_RDB_OPCODE_SELECTDB) {
             if ((dbid = rdbLoadLen(&rdb,NULL)) == REDIS_RDB_LENERR)
                 goto eoferr;
             if (dbid >= (unsigned)server.dbnum) {
-                redisLog(REDIS_WARNING,
-                    "FATAL: Data file was created with a Redis "
-                    "server configured to handle more than %d "
-                    "databases. Exiting\n", server.dbnum);
+                redisLog(REDIS_WARNING,"FATAL: Data file was created with a Redis server configured to handle more than %d databases. Exiting\n", server.dbnum);
                 exit(1);
             }
             db = server.db+dbid;
-            continue; /* Read type again. */
-        } else if (type == REDIS_RDB_OPCODE_RESIZEDB) {
-            /* RESIZEDB: Hint about the size of the keys in the currently
-             * selected data base, in order to avoid useless rehashing. */
-            uint32_t db_size, expires_size;
-            if ((db_size = rdbLoadLen(&rdb,NULL)) == REDIS_RDB_LENERR)
-                goto eoferr;
-            if ((expires_size = rdbLoadLen(&rdb,NULL)) == REDIS_RDB_LENERR)
-                goto eoferr;
-            dictExpand(db->dict,db_size);
-            dictExpand(db->expires,expires_size);
-            continue; /* Read type again. */
-        } else if (type == REDIS_RDB_OPCODE_AUX) {
-            /* AUX: generic string-string fields. Use to add state to RDB
-             * which is backward compatible. Implementations of RDB loading
-             * are requierd to skip AUX fields they don't understand.
-             *
-             * An AUX field is composed of two strings: key and value. */
-            robj *auxkey, *auxval;
-            if ((auxkey = rdbLoadStringObject(&rdb)) == NULL) goto eoferr;
-            if ((auxval = rdbLoadStringObject(&rdb)) == NULL) goto eoferr;
-
-            if (((char*)auxkey->ptr)[0] == '%') {
-                /* All the fields with a name staring with '%' are considered
-                 * information fields and are logged at startup with a log
-                 * level of NOTICE. */
-                redisLog(REDIS_NOTICE,"RDB '%s': %s", auxkey->ptr, auxval->ptr);
-            } else {
-                /* We ignore fields we don't understand, as by AUX field
-                 * contract. */
-                redisLog(REDIS_DEBUG,"Unrecognized RDB AUX field: '%s'",
-                    auxkey->ptr);
-            }
-
-            zfree(auxkey);
-            zfree(auxval);
-            continue; /* Read type again. */
+            continue;
         }
-
         /* Read key */
         if ((key = rdbLoadStringObject(&rdb)) == NULL) goto eoferr;
         /* Read value */
@@ -1629,9 +1491,7 @@ int rdbSaveToSlavesSockets(void) {
             {
                 retval = REDIS_ERR;
             }
-            zfree(msg);
         }
-        zfree(clientids);
         exitFromChild((retval == REDIS_OK) ? 0 : 1);
     } else {
         /* Parent */

src/rdb.h

@@ -38,7 +38,7 @@
 
 /* The current RDB version. When the format changes in a way that is no longer
  * backward compatible this number gets incremented. */
-#define REDIS_RDB_VERSION 7
+#define REDIS_RDB_VERSION 6
 
 /* Defines related to the dump file format. To store 32 bits lengths for short
  * keys requires a lot of space, so we check the most significant 2 bits of
@@ -74,7 +74,6 @@
 #define REDIS_RDB_TYPE_SET    2
 #define REDIS_RDB_TYPE_ZSET   3
 #define REDIS_RDB_TYPE_HASH   4
-/* NOTE: WHEN ADDING NEW RDB TYPE, UPDATE rdbIsObjectType() BELOW */
 
 /* Object types for encoded objects. */
 #define REDIS_RDB_TYPE_HASH_ZIPMAP    9
@@ -82,15 +81,11 @@
 #define REDIS_RDB_TYPE_SET_INTSET    11
 #define REDIS_RDB_TYPE_ZSET_ZIPLIST  12
 #define REDIS_RDB_TYPE_HASH_ZIPLIST  13
-#define REDIS_RDB_TYPE_LIST_QUICKLIST 14
-/* NOTE: WHEN ADDING NEW RDB TYPE, UPDATE rdbIsObjectType() BELOW */
 
 /* Test if a type is an object type. */
-#define rdbIsObjectType(t) ((t >= 0 && t <= 4) || (t >= 9 && t <= 14))
+#define rdbIsObjectType(t) ((t >= 0 && t <= 4) || (t >= 9 && t <= 13))
 
 /* Special RDB opcodes (saved/loaded with rdbSaveType/rdbLoadType). */
-#define REDIS_RDB_OPCODE_AUX        250
-#define REDIS_RDB_OPCODE_RESIZEDB   251
 #define REDIS_RDB_OPCODE_EXPIRETIME_MS 252
 #define REDIS_RDB_OPCODE_EXPIRETIME 253
 #define REDIS_RDB_OPCODE_SELECTDB   254

src/redis-benchmark.c

@@ -90,10 +90,9 @@ typedef struct _client {
     long long start;        /* Start time of a request */
     long long latency;      /* Request latency */
     int pending;            /* Number of pending requests (replies to consume) */
-    int prefix_pending;     /* If non-zero, number of pending prefix commands. Commands
-                               such as auth and select are prefixed to the pipeline of
-                               benchmark commands and discarded after the first send. */
-    int prefixlen;          /* Size in bytes of the pending prefix commands */
+    int selectlen;  /* If non-zero, a SELECT of 'selectlen' bytes is currently
+                       used as a prefix of the pipline of commands. This gets
+                       discarded the first time it's sent. */
 } *client;
 
 /* Prototypes */
@@ -213,21 +212,20 @@ static void readHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
                 }
 
                 freeReplyObject(reply);
-                /* This is an OK for prefix commands such as auth and select.*/
-                if (c->prefix_pending > 0) {
-                    c->prefix_pending--;
+
+                if (c->selectlen) {
+                    size_t j;
+
+                    /* This is the OK from SELECT. Just discard the SELECT
+                     * from the buffer. */
                     c->pending--;
-                    /* Discard prefix commands on first response.*/
-                    if (c->prefixlen > 0) {
-                        size_t j;
-                        sdsrange(c->obuf, c->prefixlen, -1);
-                        /* We also need to fix the pointers to the strings
-                        * we need to randomize. */
-                        for (j = 0; j < c->randlen; j++)
-                            c->randptr[j] -= c->prefixlen;
-                        c->prefixlen = 0;
-                    }
-                    continue;                
+                    sdsrange(c->obuf,c->selectlen,-1);
+                    /* We also need to fix the pointers to the strings
+                     * we need to randomize. */
+                    for (j = 0; j < c->randlen; j++)
+                        c->randptr[j] -= c->selectlen;
+                    c->selectlen = 0;
+                    continue;
                 }
 
                 if (config.requests_finished < config.requests)
@@ -301,7 +299,8 @@ static void writeHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
  * 2) The offsets of the __rand_int__ elements inside the command line, used
  *    for arguments randomization.
  *
- * Even when cloning another client, prefix commands are applied if needed.*/
+ * Even when cloning another client, the SELECT command is automatically prefixed
+ * if needed. */
 static client createClient(char *cmd, size_t len, client from) {
     int j;
     client c = zmalloc(sizeof(struct _client));
@@ -326,16 +325,12 @@ static client createClient(char *cmd, size_t len, client from) {
      * Queue N requests accordingly to the pipeline size, or simply clone
      * the example client buffer. */
     c->obuf = sdsempty();
-    /* Prefix the request buffer with AUTH and/or SELECT commands, if applicable.
-     * These commands are discarded after the first response, so if the client is
-     * reused the commands will not be used again. */
-    c->prefix_pending = 0;
+
     if (config.auth) {
         char *buf = NULL;
         int len = redisFormatCommand(&buf, "AUTH %s", config.auth);
         c->obuf = sdscatlen(c->obuf, buf, len);
         free(buf);
-        c->prefix_pending++;
     }
 
     /* If a DB number different than zero is selected, prefix our request
@@ -345,23 +340,26 @@ static client createClient(char *cmd, size_t len, client from) {
     if (config.dbnum != 0) {
         c->obuf = sdscatprintf(c->obuf,"*2\r\n$6\r\nSELECT\r\n$%d\r\n%s\r\n",
             (int)sdslen(config.dbnumstr),config.dbnumstr);
-        c->prefix_pending++;
+        c->selectlen = sdslen(c->obuf);
+    } else {
+        c->selectlen = 0;
     }
-    c->prefixlen = sdslen(c->obuf);
+
     /* Append the request itself. */
     if (from) {
         c->obuf = sdscatlen(c->obuf,
-            from->obuf+from->prefixlen,
-            sdslen(from->obuf)-from->prefixlen);
+            from->obuf+from->selectlen,
+            sdslen(from->obuf)-from->selectlen);
     } else {
         for (j = 0; j < config.pipeline; j++)
             c->obuf = sdscatlen(c->obuf,cmd,len);
     }
 
     c->written = 0;
-    c->pending = config.pipeline+c->prefix_pending;
+    c->pending = config.pipeline;
     c->randptr = NULL;
     c->randlen = 0;
+    if (c->selectlen) c->pending++;
 
     /* Find substrings in the output buffer that need to be randomized. */
     if (config.randomkeys) {
@@ -373,7 +371,7 @@ static client createClient(char *cmd, size_t len, client from) {
             for (j = 0; j < (int)c->randlen; j++) {
                 c->randptr[j] = c->obuf + (from->randptr[j]-from->obuf);
                 /* Adjust for the different select prefix length. */
-                c->randptr[j] += c->prefixlen - from->prefixlen;
+                c->randptr[j] += c->selectlen - from->selectlen;
             }
         } else {
             char *p = c->obuf;
@@ -392,8 +390,7 @@ static client createClient(char *cmd, size_t len, client from) {
             }
         }
     }
-    if (config.idlemode == 0)
-        aeCreateFileEvent(config.el,c->context->fd,AE_WRITABLE,writeHandler,c);
+    aeCreateFileEvent(config.el,c->context->fd,AE_WRITABLE,writeHandler,c);
     listAddNodeTail(config.clients,c);
     config.liveclients++;
     return c;
@@ -558,7 +555,7 @@ usage:
 " -s <socket>        Server socket (overrides host and port)\n"
 " -a <password>      Password for Redis Auth\n"
 " -c <clients>       Number of parallel connections (default 50)\n"
-" -n <requests>      Total number of requests (default 100000)\n"
+" -n <requests>      Total number of requests (default 10000)\n"
 " -d <size>          Data size of SET/GET value in bytes (default 2)\n"
 " -dbnum <db>        SELECT the specified db number (default 0)\n"
 " -k <boolean>       1=keep alive 0=reconnect (default 1)\n"
@@ -603,12 +600,8 @@ int showThroughput(struct aeEventLoop *eventLoop, long long id, void *clientData
         fprintf(stderr,"All clients disconnected... aborting.\n");
         exit(1);
     }
+
     if (config.csv) return 250;
-    if (config.idlemode == 1) {
-        printf("clients: %d\r", config.liveclients);
-        fflush(stdout);
-	return 250;
-    }
     float dt = (float)(mstime()-config.start)/1000.0;
     float rps = (float)config.requests_finished/dt;
     printf("%s: %.2f\r", config.title, rps);
@@ -642,7 +635,7 @@ int main(int argc, const char **argv) {
     signal(SIGPIPE, SIG_IGN);
 
     config.numclients = 50;
-    config.requests = 100000;
+    config.requests = 10000;
     config.liveclients = 0;
     config.el = aeCreateEventLoop(1024*10);
     aeCreateTimeEvent(config.el,1,showThroughput,NULL,NULL);
@@ -700,8 +693,8 @@ int main(int argc, const char **argv) {
     }
 
     /* Run default benchmark suite. */
-    data = zmalloc(config.datasize+1);
     do {
+        data = zmalloc(config.datasize+1);
         memset(data,'x',config.datasize);
         data[config.datasize] = '\0';
 
@@ -738,24 +731,12 @@ int main(int argc, const char **argv) {
             free(cmd);
         }
 
-        if (test_is_selected("rpush")) {
-            len = redisFormatCommand(&cmd,"RPUSH mylist %s",data);
-            benchmark("RPUSH",cmd,len);
-            free(cmd);
-        }
-
         if (test_is_selected("lpop")) {
             len = redisFormatCommand(&cmd,"LPOP mylist");
             benchmark("LPOP",cmd,len);
             free(cmd);
         }
 
-        if (test_is_selected("rpop")) {
-            len = redisFormatCommand(&cmd,"RPOP mylist");
-            benchmark("RPOP",cmd,len);
-            free(cmd);
-        }
-
         if (test_is_selected("sadd")) {
             len = redisFormatCommand(&cmd,
                 "SADD myset element:__rand_int__");

src/redis-cli.c

@@ -60,8 +60,6 @@
 #define OUTPUT_CSV 2
 #define REDIS_CLI_KEEPALIVE_INTERVAL 15 /* seconds */
 #define REDIS_CLI_DEFAULT_PIPE_TIMEOUT 30 /* seconds */
-#define REDIS_CLI_HISTFILE_ENV "REDISCLI_HISTFILE"
-#define REDIS_CLI_HISTFILE_DEFAULT ".rediscli_history"
 
 static redisContext *context;
 static struct config {
@@ -130,8 +128,9 @@ static void cliRefreshPrompt(void) {
         len = snprintf(config.prompt,sizeof(config.prompt),"redis %s",
                        config.hostsocket);
     else
-        len = anetFormatAddr(config.prompt, sizeof(config.prompt),
-                           config.hostip, config.hostport);
+        len = snprintf(config.prompt,sizeof(config.prompt),
+                       strchr(config.hostip,':') ? "[%s]:%d" : "%s:%d",
+                       config.hostip, config.hostport);
     /* Add [dbnum] if needed */
     if (config.dbnum != 0 && config.last_cmd_type != REDIS_REPLY_ERROR)
         len += snprintf(config.prompt+len,sizeof(config.prompt)-len,"[%d]",
@@ -139,30 +138,6 @@ static void cliRefreshPrompt(void) {
     snprintf(config.prompt+len,sizeof(config.prompt)-len,"> ");
 }
 
-static sds getHistoryPath() {
-    char *path = NULL;
-    sds historyPath = NULL;
-
-    /* check the env for a histfile override */
-    path = getenv(REDIS_CLI_HISTFILE_ENV);
-    if (path != NULL && *path != '\0') {
-        if (!strcmp("/dev/null", path)) {
-            return NULL;
-        }
-
-        /* if the env is set, return it */
-        historyPath = sdscatprintf(sdsempty(), "%s", path);
-    } else {
-        char *home = getenv("HOME");
-        if (home != NULL && *home != '\0') {
-            /* otherwise, return the default */
-            historyPath = sdscatprintf(sdsempty(), "%s/%s", home, REDIS_CLI_HISTFILE_DEFAULT);
-        }
-    }
-
-    return historyPath;
-}
-
 /*------------------------------------------------------------------------------
  * Help functions
  *--------------------------------------------------------------------------- */
@@ -327,7 +302,7 @@ static void completionCallback(const char *buf, linenoiseCompletions *lc) {
  *--------------------------------------------------------------------------- */
 
 /* Send AUTH command to the server */
-static int cliAuth(void) {
+static int cliAuth() {
     redisReply *reply;
     if (config.auth == NULL) return REDIS_OK;
 
@@ -340,7 +315,7 @@ static int cliAuth(void) {
 }
 
 /* Send SELECT dbnum to the server */
-static int cliSelect(void) {
+static int cliSelect() {
     redisReply *reply;
     if (config.dbnum == 0) return REDIS_OK;
 
@@ -629,9 +604,6 @@ static int cliSendCommand(int argc, char **argv, int repeat) {
 
     output_raw = 0;
     if (!strcasecmp(command,"info") ||
-        (argc == 3 && !strcasecmp(command,"debug") &&
-                      (!strcasecmp(argv[1],"jemalloc") &&
-                       !strcasecmp(argv[2],"info"))) ||
         (argc == 2 && !strcasecmp(command,"cluster") &&
                       (!strcasecmp(argv[1],"nodes") ||
                        !strcasecmp(argv[1],"info"))) ||
@@ -858,7 +830,6 @@ static void usage(void) {
 "                     not a tty).\n"
 "  --no-raw           Force formatted output even when STDOUT is not a tty.\n"
 "  --csv              Output in CSV format.\n"
-"  --stat             Print rolling stats about server: mem, clients, ...\n"
 "  --latency          Enter a special mode continuously sampling latency.\n"
 "  --latency-history  Like --latency but tracking latency changes over time.\n"
 "                     Default time interval is 15 sec. Change it using -i.\n"
@@ -906,33 +877,6 @@ static char **convertToSds(int count, char** args) {
   return sds;
 }
 
-static int issueCommandRepeat(int argc, char **argv, long repeat) {
-    while (1) {
-        config.cluster_reissue_command = 0;
-        if (cliSendCommand(argc,argv,repeat) != REDIS_OK) {
-            cliConnect(1);
-
-            /* If we still cannot send the command print error.
-             * We'll try to reconnect the next time. */
-            if (cliSendCommand(argc,argv,repeat) != REDIS_OK) {
-                cliPrintContextError();
-                return REDIS_ERR;
-            }
-         }
-         /* Issue the command again if we got redirected in cluster mode */
-         if (config.cluster_mode && config.cluster_reissue_command) {
-            cliConnect(1);
-         } else {
-             break;
-        }
-    }
-    return REDIS_OK;
-}
-
-static int issueCommand(int argc, char **argv) {
-    return issueCommandRepeat(argc, argv, config.repeat);
-}
-
 static void repl(void) {
     sds historyfile = NULL;
     int history = 0;
@@ -946,9 +890,10 @@ static void repl(void) {
 
     /* Only use history when stdin is a tty. */
     if (isatty(fileno(stdin))) {
-        historyfile = getHistoryPath();
-        if (historyfile != NULL) {
-            history = 1;
+        history = 1;
+
+        if (getenv("HOME") != NULL) {
+            historyfile = sdscatprintf(sdsempty(),"%s/.rediscli_history",getenv("HOME"));
             linenoiseHistoryLoad(historyfile);
         }
     }
@@ -988,8 +933,26 @@ static void repl(void) {
                         repeat = 1;
                     }
 
-                    issueCommandRepeat(argc-skipargs, argv+skipargs, repeat);
+                    while (1) {
+                        config.cluster_reissue_command = 0;
+                        if (cliSendCommand(argc-skipargs,argv+skipargs,repeat)
+                            != REDIS_OK)
+                        {
+                            cliConnect(1);
 
+                            /* If we still cannot send the command print error.
+                             * We'll try to reconnect the next time. */
+                            if (cliSendCommand(argc-skipargs,argv+skipargs,repeat)
+                                != REDIS_OK)
+                                cliPrintContextError();
+                        }
+                        /* Issue the command again if we got redirected in cluster mode */
+                        if (config.cluster_mode && config.cluster_reissue_command) {
+                            cliConnect(1);
+                        } else {
+                            break;
+                        }
+                    }
                     elapsed = mstime()-start_time;
                     if (elapsed >= 500) {
                         printf("(%.2fs)\n",(double)elapsed/1000);
@@ -1010,9 +973,10 @@ static int noninteractive(int argc, char **argv) {
     if (config.stdinarg) {
         argv = zrealloc(argv, (argc+1)*sizeof(char*));
         argv[argc] = readArgFromStdin();
-        retval = issueCommand(argc+1, argv);
+        retval = cliSendCommand(argc+1, argv, config.repeat);
     } else {
-        retval = issueCommand(argc, argv);
+        /* stdin is probably a tty, can be tested with S_ISCHR(s.st_mode) */
+        retval = cliSendCommand(argc, argv, config.repeat);
     }
     return retval;
 }
@@ -1056,7 +1020,7 @@ static int evalMode(int argc, char **argv) {
     argv2[2] = sdscatprintf(sdsempty(),"%d",keys);
 
     /* Call it */
-    return issueCommand(argc+3-got_comma, argv2);
+    return cliSendCommand(argc+3-got_comma, argv2, config.repeat);
 }
 
 /*------------------------------------------------------------------------------
@@ -1951,6 +1915,8 @@ int main(int argc, char **argv) {
     argc -= firstarg;
     argv += firstarg;
 
+    signal(SIGPIPE, SIG_IGN);
+
     /* Latency mode */
     if (config.latency_mode) {
         if (cliConnect(0) == REDIS_ERR) exit(1);
@@ -1999,9 +1965,6 @@ int main(int argc, char **argv) {
 
     /* Start interactive mode when no command is provided */
     if (argc == 0 && !config.eval) {
-        /* Ignore SIGPIPE in interactive mode to force a reconnect */
-        signal(SIGPIPE, SIG_IGN);
-
         /* Note that in repl mode we don't abort on connection error.
          * A new attempt will be performed for every command send. */
         cliConnect(0);

src/redis-trib.rb

@@ -540,6 +540,7 @@ class RedisTrib
         nodes_count = @nodes.length
         masters_count = @nodes.length / (@replicas+1)
         masters = []
+        slaves = []
 
         # The first step is to split instances by IP. This is useful as
         # we'll try to allocate master nodes in different physical machines
@@ -557,22 +558,16 @@ class RedisTrib
 
         # Select master instances
         puts "Using #{masters_count} masters:"
-        interleaved = []
-        stop = false
-        while not stop do
-            # Take one node from each IP until we run out of nodes
-            # across every IP.
-            ips.each do |ip,nodes|
-                stop = nodes.empty? and next
-                interleaved.push nodes.shift
-            end
+        while masters.length < masters_count
+            ips.each{|ip,nodes_list|
+                next if nodes_list.length == 0
+                masters << nodes_list.shift
+                puts masters[-1]
+                nodes_count -= 1
+                break if masters.length == masters_count
+            }
         end
 
-        masters = interleaved.slice!(0, masters_count)
-        nodes_count -= masters.length
-
-        masters.each{|m| puts m}
-
         # Alloc slots on masters
         slots_per_node = ClusterHashSlots.to_f / masters_count
         first = 0
@@ -599,8 +594,8 @@ class RedisTrib
         # all nodes will be used.
         assignment_verbose = false
 
-        [:requested,:unused].each do |assign|
-            masters.each do |m|
+        [:requested,:unused].each{|assign|
+            masters.each{|m|
                 assigned_replicas = 0
                 while assigned_replicas < @replicas
                     break if nodes_count == 0
@@ -614,33 +609,21 @@ class RedisTrib
                                  "role too (#{nodes_count} remaining)."
                         end
                     end
-
-                    # Return the first node not matching our current master
-                    node = interleaved.find{|n| n.info[:host] != m.info[:host]}
-
-                    # If we found a node, use it as a best-first match.
-                    # Otherwise, we didn't find a node on a different IP, so we
-                    # go ahead and use a same-IP replica.
-                    if node
-                        slave = node
-                        interleaved.delete node
-                    else
-                        slave = interleaved.shift
-                    end
-                    slave.set_as_replica(m.info[:name])
-                    nodes_count -= 1
-                    assigned_replicas += 1
-                    puts "Adding replica #{slave} to #{m}"
-
-                    # If we are in the "assign extra nodes" loop,
-                    # we want to assign one extra replica to each
-                    # master before repeating masters.
-                    # This break lets us assign extra replicas to masters
-                    # in a round-robin way.
-                    break if assign == :unused
+                    ips.each{|ip,nodes_list|
+                        next if nodes_list.length == 0
+                        # Skip instances with the same IP as the master if we
+                        # have some more IPs available.
+                        next if ip == m.info[:host] && nodes_count > nodes_list.length
+                        slave = nodes_list.shift
+                        slave.set_as_replica(m.info[:name])
+                        nodes_count -= 1
+                        assigned_replicas += 1
+                        puts "Adding replica #{slave} to #{m}"
+                        break
+                    }
                 end
-            end
-        end
+            }
+        }
     end
 
     def flush_nodes_config
@@ -1156,7 +1139,7 @@ class RedisTrib
         # right node as needed.
         cursor = nil
         while cursor != 0
-            cursor,keys = source.scan(cursor, :count => 1000)
+            cursor,keys = source.scan(cursor,:count,1000)
             cursor = cursor.to_i
             keys.each{|k|
                 # Migrate keys using the MIGRATE command.

src/redis.c

@@ -46,14 +46,12 @@
 #include <sys/time.h>
 #include <sys/resource.h>
 #include <sys/uio.h>
-#include <sys/un.h>
 #include <limits.h>
 #include <float.h>
 #include <math.h>
 #include <sys/resource.h>
 #include <sys/utsname.h>
 #include <locale.h>
-#include <sys/sysctl.h>
 
 /* Our shared "common" objects */
 
@@ -162,7 +160,7 @@ struct redisCommand redisCommandTable[] = {
     {"smove",smoveCommand,4,"wF",0,NULL,1,2,1,0,0},
     {"sismember",sismemberCommand,3,"rF",0,NULL,1,1,1,0,0},
     {"scard",scardCommand,2,"rF",0,NULL,1,1,1,0,0},
-    {"spop",spopCommand,-2,"wRsF",0,NULL,1,1,1,0,0},
+    {"spop",spopCommand,2,"wRsF",0,NULL,1,1,1,0,0},
     {"srandmember",srandmemberCommand,-2,"rR",0,NULL,1,1,1,0,0},
     {"sinter",sinterCommand,-2,"rS",0,NULL,1,-1,1,0,0},
     {"sinterstore",sinterstoreCommand,-3,"wm",0,NULL,1,-1,1,0,0},
@@ -249,7 +247,7 @@ struct redisCommand redisCommandTable[] = {
     {"pttl",pttlCommand,2,"rF",0,NULL,1,1,1,0,0},
     {"persist",persistCommand,2,"wF",0,NULL,1,1,1,0,0},
     {"slaveof",slaveofCommand,3,"ast",0,NULL,0,0,0,0,0},
-    {"role",roleCommand,1,"lst",0,NULL,0,0,0,0,0},
+    {"role",roleCommand,1,"last",0,NULL,0,0,0,0,0},
     {"debug",debugCommand,-2,"as",0,NULL,0,0,0,0,0},
     {"config",configCommand,-2,"art",0,NULL,0,0,0,0,0},
     {"subscribe",subscribeCommand,-2,"rpslt",0,NULL,0,0,0,0,0},
@@ -261,19 +259,19 @@ struct redisCommand redisCommandTable[] = {
     {"watch",watchCommand,-2,"rsF",0,NULL,1,-1,1,0,0},
     {"unwatch",unwatchCommand,1,"rsF",0,NULL,0,0,0,0,0},
     {"cluster",clusterCommand,-2,"ar",0,NULL,0,0,0,0,0},
-    {"restore",restoreCommand,-4,"wm",0,NULL,1,1,1,0,0},
-    {"restore-asking",restoreCommand,-4,"wmk",0,NULL,1,1,1,0,0},
-    {"migrate",migrateCommand,-6,"w",0,NULL,0,0,0,0,0},
+    {"restore",restoreCommand,-4,"awm",0,NULL,1,1,1,0,0},
+    {"restore-asking",restoreCommand,-4,"awmk",0,NULL,1,1,1,0,0},
+    {"migrate",migrateCommand,-6,"aw",0,NULL,0,0,0,0,0},
     {"asking",askingCommand,1,"r",0,NULL,0,0,0,0,0},
     {"readonly",readonlyCommand,1,"rF",0,NULL,0,0,0,0,0},
     {"readwrite",readwriteCommand,1,"rF",0,NULL,0,0,0,0,0},
-    {"dump",dumpCommand,2,"r",0,NULL,1,1,1,0,0},
+    {"dump",dumpCommand,2,"ar",0,NULL,1,1,1,0,0},
     {"object",objectCommand,3,"r",0,NULL,2,2,2,0,0},
-    {"client",clientCommand,-2,"rs",0,NULL,0,0,0,0,0},
+    {"client",clientCommand,-2,"ars",0,NULL,0,0,0,0,0},
     {"eval",evalCommand,-3,"s",0,evalGetKeys,0,0,0,0,0},
     {"evalsha",evalShaCommand,-3,"s",0,evalGetKeys,0,0,0,0,0},
     {"slowlog",slowlogCommand,-2,"r",0,NULL,0,0,0,0,0},
-    {"script",scriptCommand,-2,"rs",0,NULL,0,0,0,0,0},
+    {"script",scriptCommand,-2,"ras",0,NULL,0,0,0,0,0},
     {"time",timeCommand,1,"rRF",0,NULL,0,0,0,0,0},
     {"bitop",bitopCommand,-4,"wm",0,NULL,2,-1,1,0,0},
     {"bitcount",bitcountCommand,-2,"r",0,NULL,1,1,1,0,0},
@@ -282,7 +280,7 @@ struct redisCommand redisCommandTable[] = {
     {"command",commandCommand,0,"rlt",0,NULL,0,0,0,0,0},
     {"pfselftest",pfselftestCommand,1,"r",0,NULL,0,0,0,0,0},
     {"pfadd",pfaddCommand,-2,"wmF",0,NULL,1,1,1,0,0},
-    {"pfcount",pfcountCommand,-2,"r",0,NULL,1,1,1,0,0},
+    {"pfcount",pfcountCommand,-2,"w",0,NULL,1,1,1,0,0},
     {"pfmerge",pfmergeCommand,-2,"wm",0,NULL,1,-1,1,0,0},
     {"pfdebug",pfdebugCommand,-3,"w",0,NULL,0,0,0,0,0},
     {"latency",latencyCommand,-2,"arslt",0,NULL,0,0,0,0,0}
@@ -878,30 +876,27 @@ unsigned int getLRUClock(void) {
 }
 
 /* Add a sample to the operations per second array of samples. */
-void trackInstantaneousMetric(int metric, long long current_reading) {
-    long long t = mstime() - server.inst_metric[metric].last_sample_time;
-    long long ops = current_reading -
-                    server.inst_metric[metric].last_sample_count;
+void trackOperationsPerSecond(void) {
+    long long t = mstime() - server.ops_sec_last_sample_time;
+    long long ops = server.stat_numcommands - server.ops_sec_last_sample_ops;
     long long ops_sec;
 
     ops_sec = t > 0 ? (ops*1000/t) : 0;
 
-    server.inst_metric[metric].samples[server.inst_metric[metric].idx] =
-        ops_sec;
-    server.inst_metric[metric].idx++;
-    server.inst_metric[metric].idx %= REDIS_METRIC_SAMPLES;
-    server.inst_metric[metric].last_sample_time = mstime();
-    server.inst_metric[metric].last_sample_count = current_reading;
+    server.ops_sec_samples[server.ops_sec_idx] = ops_sec;
+    server.ops_sec_idx = (server.ops_sec_idx+1) % REDIS_OPS_SEC_SAMPLES;
+    server.ops_sec_last_sample_time = mstime();
+    server.ops_sec_last_sample_ops = server.stat_numcommands;
 }
 
 /* Return the mean of all the samples. */
-long long getInstantaneousMetric(int metric) {
+long long getOperationsPerSecond(void) {
     int j;
     long long sum = 0;
 
-    for (j = 0; j < REDIS_METRIC_SAMPLES; j++)
-        sum += server.inst_metric[metric].samples[j];
-    return sum / REDIS_METRIC_SAMPLES;
+    for (j = 0; j < REDIS_OPS_SEC_SAMPLES; j++)
+        sum += server.ops_sec_samples[j];
+    return sum / REDIS_OPS_SEC_SAMPLES;
 }
 
 /* Check for timeouts. Returns non-zero if the client was terminated */
@@ -1073,13 +1068,7 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
     /* Update the time cache. */
     updateCachedTime();
 
-    run_with_period(100) {
-        trackInstantaneousMetric(REDIS_METRIC_COMMAND,server.stat_numcommands);
-        trackInstantaneousMetric(REDIS_METRIC_NET_INPUT,
-                server.stat_net_input_bytes);
-        trackInstantaneousMetric(REDIS_METRIC_NET_OUTPUT,
-                server.stat_net_output_bytes);
-    }
+    run_with_period(100) trackOperationsPerSecond();
 
     /* We have just REDIS_LRU_BITS bits per object for LRU information.
      * So we use an (eventually wrapping) LRU clock.
@@ -1415,7 +1404,6 @@ void initServerConfig(void) {
     server.syslog_ident = zstrdup(REDIS_DEFAULT_SYSLOG_IDENT);
     server.syslog_facility = LOG_LOCAL0;
     server.daemonize = REDIS_DEFAULT_DAEMONIZE;
-    server.supervised = 0;
     server.aof_state = REDIS_AOF_OFF;
     server.aof_fsync = REDIS_DEFAULT_AOF_FSYNC;
     server.aof_no_fsync_on_rewrite = REDIS_DEFAULT_AOF_NO_FSYNC_ON_REWRITE;
@@ -1445,12 +1433,15 @@ void initServerConfig(void) {
     server.maxclients = REDIS_MAX_CLIENTS;
     server.bpop_blocked_clients = 0;
     server.maxmemory = REDIS_DEFAULT_MAXMEMORY;
+    server.maxmemory_frag_guess = REDIS_DEFAULT_MAXMEMORY_FRAG_GUESS;
+    server.maxmemory_enforced = (double) REDIS_DEFAULT_MAXMEMORY / server.maxmemory_frag_guess;
     server.maxmemory_policy = REDIS_DEFAULT_MAXMEMORY_POLICY;
     server.maxmemory_samples = REDIS_DEFAULT_MAXMEMORY_SAMPLES;
+    server.rss_aware_maxmemory = REDIS_DEFAULT_RSS_AWARE_MAXMEMORY;
     server.hash_max_ziplist_entries = REDIS_HASH_MAX_ZIPLIST_ENTRIES;
     server.hash_max_ziplist_value = REDIS_HASH_MAX_ZIPLIST_VALUE;
-    server.list_max_ziplist_size = REDIS_LIST_MAX_ZIPLIST_SIZE;
-    server.list_compress_depth = REDIS_LIST_COMPRESS_DEPTH;
+    server.list_max_ziplist_entries = REDIS_LIST_MAX_ZIPLIST_ENTRIES;
+    server.list_max_ziplist_value = REDIS_LIST_MAX_ZIPLIST_VALUE;
     server.set_max_intset_entries = REDIS_SET_MAX_INTSET_ENTRIES;
     server.zset_max_ziplist_entries = REDIS_ZSET_MAX_ZIPLIST_ENTRIES;
     server.zset_max_ziplist_value = REDIS_ZSET_MAX_ZIPLIST_VALUE;
@@ -1566,33 +1557,33 @@ void adjustOpenFilesLimit(void) {
         /* Set the max number of files if the current limit is not enough
          * for our needs. */
         if (oldlimit < maxfiles) {
-            rlim_t bestlimit;
+            rlim_t f;
             int setrlimit_error = 0;
 
             /* Try to set the file limit to match 'maxfiles' or at least
              * to the higher value supported less than maxfiles. */
-            bestlimit = maxfiles;
-            while(bestlimit > oldlimit) {
+            f = maxfiles;
+            while(f > oldlimit) {
                 rlim_t decr_step = 16;
 
-                limit.rlim_cur = bestlimit;
-                limit.rlim_max = bestlimit;
+                limit.rlim_cur = f;
+                limit.rlim_max = f;
                 if (setrlimit(RLIMIT_NOFILE,&limit) != -1) break;
                 setrlimit_error = errno;
 
-                /* We failed to set file limit to 'bestlimit'. Try with a
+                /* We failed to set file limit to 'f'. Try with a
                  * smaller limit decrementing by a few FDs per iteration. */
-                if (bestlimit < decr_step) break;
-                bestlimit -= decr_step;
+                if (f < decr_step) break;
+                f -= decr_step;
             }
 
             /* Assume that the limit we get initially is still valid if
              * our last try was even lower. */
-            if (bestlimit < oldlimit) bestlimit = oldlimit;
+            if (f < oldlimit) f = oldlimit;
 
-            if (bestlimit < maxfiles) {
+            if (f != maxfiles) {
                 int old_maxclients = server.maxclients;
-                server.maxclients = bestlimit-REDIS_MIN_RESERVED_FDS;
+                server.maxclients = f-REDIS_MIN_RESERVED_FDS;
                 if (server.maxclients < 1) {
                     redisLog(REDIS_WARNING,"Your current 'ulimit -n' "
                         "of %llu is not enough for Redis to start. "
@@ -1613,7 +1604,7 @@ void adjustOpenFilesLimit(void) {
                     "maxclients has been reduced to %d to compensate for "
                     "low ulimit. "
                     "If you need higher maxclients increase 'ulimit -n'.",
-                    (unsigned long long) bestlimit, server.maxclients);
+                    (unsigned long long) oldlimit, server.maxclients);
             } else {
                 redisLog(REDIS_NOTICE,"Increased maximum number of open files "
                     "to %llu (it was originally set to %llu).",
@@ -1624,23 +1615,6 @@ void adjustOpenFilesLimit(void) {
     }
 }
 
-/* Check that server.tcp_backlog can be actually enforced in Linux according
- * to the value of /proc/sys/net/core/somaxconn, or warn about it. */
-void checkTcpBacklogSettings(void) {
-#ifdef HAVE_PROC_SOMAXCONN
-    FILE *fp = fopen("/proc/sys/net/core/somaxconn","r");
-    char buf[1024];
-    if (!fp) return;
-    if (fgets(buf,sizeof(buf),fp) != NULL) {
-        int somaxconn = atoi(buf);
-        if (somaxconn > 0 && somaxconn < server.tcp_backlog) {
-            redisLog(REDIS_WARNING,"WARNING: The TCP backlog setting of %d cannot be enforced because /proc/sys/net/core/somaxconn is set to the lower value of %d.", server.tcp_backlog, somaxconn);
-        }
-    }
-    fclose(fp);
-#endif
-}
-
 /* Initialize a set of file descriptors to listen to the specified 'port'
  * binding the addresses specified in the Redis server configuration.
  *
@@ -1711,8 +1685,6 @@ int listenToPort(int port, int *fds, int *count) {
  * to reset via CONFIG RESETSTAT. The function is also used in order to
  * initialize these fields in initServer() at server startup. */
 void resetServerStats(void) {
-    int j;
-
     server.stat_numcommands = 0;
     server.stat_numconnections = 0;
     server.stat_expiredkeys = 0;
@@ -1725,15 +1697,10 @@ void resetServerStats(void) {
     server.stat_sync_full = 0;
     server.stat_sync_partial_ok = 0;
     server.stat_sync_partial_err = 0;
-    for (j = 0; j < REDIS_METRIC_COUNT; j++) {
-        server.inst_metric[j].idx = 0;
-        server.inst_metric[j].last_sample_time = mstime();
-        server.inst_metric[j].last_sample_count = 0;
-        memset(server.inst_metric[j].samples,0,
-            sizeof(server.inst_metric[j].samples));
-    }
-    server.stat_net_input_bytes = 0;
-    server.stat_net_output_bytes = 0;
+    memset(server.ops_sec_samples,0,sizeof(server.ops_sec_samples));
+    server.ops_sec_idx = 0;
+    server.ops_sec_last_sample_time = mstime();
+    server.ops_sec_last_sample_ops = 0;
 }
 
 void initServer(void) {
@@ -1760,7 +1727,6 @@ void initServer(void) {
     server.clients_waiting_acks = listCreate();
     server.get_ack_from_slaves = 0;
     server.clients_paused = 0;
-    server.system_memory_size = zmalloc_get_memory_size();
 
     createSharedObjects();
     adjustOpenFilesLimit();
@@ -2035,7 +2001,7 @@ void call(redisClient *c, int flags) {
      * not generated from reading an AOF. */
     if (listLength(server.monitors) &&
         !server.loading &&
-        !(c->cmd->flags & (REDIS_CMD_SKIP_MONITOR|REDIS_CMD_ADMIN)))
+        !(c->cmd->flags & REDIS_CMD_SKIP_MONITOR))
     {
         replicationFeedMonitors(c,server.monitors,c->db->id,c->argv,c->argc);
     }
@@ -2481,6 +2447,7 @@ void timeCommand(redisClient *c) {
     addReplyBulkLongLong(c,tv.tv_usec);
 }
 
+
 /* Helper function for addReplyCommand() to output flags. */
 int addReplyCommandFlag(redisClient *c, struct redisCommand *cmd, int f, char *reply) {
     if (cmd->flags & f) {
@@ -2699,10 +2666,7 @@ sds genRedisInfoString(char *section) {
     if (allsections || defsections || !strcasecmp(section,"memory")) {
         char hmem[64];
         char peak_hmem[64];
-        char total_system_hmem[64];
         size_t zmalloc_used = zmalloc_used_memory();
-        size_t total_system_mem = server.system_memory_size;
-        char *evict_policy = maxmemoryToString();
 
         /* Peak memory is updated from time to time by serverCron() so it
          * may happen that the instantaneous value is slightly bigger than
@@ -2713,8 +2677,6 @@ sds genRedisInfoString(char *section) {
 
         bytesToHuman(hmem,zmalloc_used);
         bytesToHuman(peak_hmem,server.stat_peak_memory);
-        bytesToHuman(total_system_hmem,total_system_mem);
-
         if (sections++) info = sdscat(info,"\r\n");
         info = sdscatprintf(info,
             "# Memory\r\n"
@@ -2723,23 +2685,17 @@ sds genRedisInfoString(char *section) {
             "used_memory_rss:%zu\r\n"
             "used_memory_peak:%zu\r\n"
             "used_memory_peak_human:%s\r\n"
-            "total_system_memory:%lu\r\n"
-            "total_system_memory_human:%s\r\n"
             "used_memory_lua:%lld\r\n"
             "mem_fragmentation_ratio:%.2f\r\n"
-            "mem_allocator:%s\r\n"
-            "maxmemory_policy:%s\r\n",
+            "mem_allocator:%s\r\n",
             zmalloc_used,
             hmem,
             server.resident_set_size,
             server.stat_peak_memory,
             peak_hmem,
-            (unsigned long)total_system_mem,
-            total_system_hmem,
             ((long long)lua_gc(server.lua,LUA_GCCOUNT,0))*1024LL,
             zmalloc_get_fragmentation_ratio(server.resident_set_size),
-            ZMALLOC_LIB,
-            evict_policy
+            ZMALLOC_LIB
             );
     }
 
@@ -2804,14 +2760,14 @@ sds genRedisInfoString(char *section) {
                                     server.loading_loaded_bytes;
 
             perc = ((double)server.loading_loaded_bytes /
-                   (server.loading_total_bytes+1)) * 100;
+                   server.loading_total_bytes) * 100;
 
-            elapsed = time(NULL)-server.loading_start_time;
+            elapsed = server.unixtime-server.loading_start_time;
             if (elapsed == 0) {
                 eta = 1; /* A fake 1 second figure if we don't have
                             enough info */
             } else {
-                eta = (elapsed*remaining_bytes)/(server.loading_loaded_bytes+1);
+                eta = (elapsed*remaining_bytes)/server.loading_loaded_bytes;
             }
 
             info = sdscatprintf(info,
@@ -2837,10 +2793,6 @@ sds genRedisInfoString(char *section) {
             "total_connections_received:%lld\r\n"
             "total_commands_processed:%lld\r\n"
             "instantaneous_ops_per_sec:%lld\r\n"
-            "total_net_input_bytes:%lld\r\n"
-            "total_net_output_bytes:%lld\r\n"
-            "instantaneous_input_kbps:%.2f\r\n"
-            "instantaneous_output_kbps:%.2f\r\n"
             "rejected_connections:%lld\r\n"
             "sync_full:%lld\r\n"
             "sync_partial_ok:%lld\r\n"
@@ -2855,11 +2807,7 @@ sds genRedisInfoString(char *section) {
             "migrate_cached_sockets:%ld\r\n",
             server.stat_numconnections,
             server.stat_numcommands,
-            getInstantaneousMetric(REDIS_METRIC_COMMAND),
-            server.stat_net_input_bytes,
-            server.stat_net_output_bytes,
-            (float)getInstantaneousMetric(REDIS_METRIC_NET_INPUT)/1024,
-            (float)getInstantaneousMetric(REDIS_METRIC_NET_OUTPUT)/1024,
+            getOperationsPerSecond(),
             server.stat_rejected_conn,
             server.stat_sync_full,
             server.stat_sync_partial_ok,
@@ -3058,7 +3006,11 @@ void infoCommand(redisClient *c) {
         addReply(c,shared.syntaxerr);
         return;
     }
-    addReplyBulkSds(c, genRedisInfoString(section));
+    sds info = genRedisInfoString(section);
+    addReplySds(c,sdscatprintf(sdsempty(),"$%lu\r\n",
+        (unsigned long)sdslen(info)));
+    addReplySds(c,info);
+    addReply(c,shared.crlf);
 }
 
 void monitorCommand(redisClient *c) {
@@ -3205,7 +3157,7 @@ void evictionPoolPopulate(dict *sampledict, dict *keydict, struct evictionPoolEn
 }
 
 int freeMemoryIfNeeded(void) {
-    size_t mem_used, mem_tofree, mem_freed;
+    size_t mem_used, mem_tofree, mem_freed, mem_target = server.maxmemory;
     int slaves = listLength(server.slaves);
     mstime_t latency;
 
@@ -3231,14 +3183,72 @@ int freeMemoryIfNeeded(void) {
         mem_used -= aofRewriteBufferSize();
     }
 
+    /* If we use RSS aware maxmemory, update the target memory using
+     * the current fragmentation figure. */
+#ifdef HAVE_RSS_REPORTING
+    if (server.rss_aware_maxmemory &&
+        server.maxmemory_policy != REDIS_MAXMEMORY_NO_EVICTION)
+    {
+        static unsigned long iterations = 0;
+        static unsigned long sampling_stage = 1;
+        static float last_observed_frag = 0;
+
+        /* For some time, we analyze what happens during memory pressure, when
+         * objects are evicted and reallocated. */
+        if (mem_used > server.maxmemory_enforced) {
+            unsigned long sample_cycles = 1000000;
+
+            /* Every sample_cycle cycles we sample the fragmentation, and
+             * compare it with the previos one. If it is no longer raising,
+             * we take it as a guess of the fragmentation with this workload. */
+            if (sampling_stage && iterations < sample_cycles) {
+                iterations++;
+                if (iterations == sample_cycles) {
+                    float current_frag = zmalloc_get_fragmentation_ratio(server.resident_set_size);
+                    if (last_observed_frag == 0) {
+                        /* First sample we get. */
+                        last_observed_frag = current_frag;
+                    } else {
+                        if (current_frag <= last_observed_frag) {
+                            size_t enforced_new;
+
+                            sampling_stage = 0;
+                            server.maxmemory_frag_guess = current_frag;
+                            /* Update the global fragmentation guess and use
+                             * it (also used it for successive
+                             * "CONFIG SET maxmemory" commands). */
+                            if (server.maxmemory_frag_guess < 1)
+                                server.maxmemory_frag_guess = 1;
+                            else if (server.maxmemory_frag_guess > 2)
+                                server.maxmemory_frag_guess = 2;
+
+                            /* Only set the new limit if it is higher than our
+                             * initial guess, otherwise it is futile: RSS will
+                             * not go backward anyway. */
+                            enforced_new = (double) server.maxmemory /
+                                           server.maxmemory_frag_guess;
+                            if (enforced_new > server.maxmemory_enforced)
+                                server.maxmemory_enforced = enforced_new;
+                            redisLog(REDIS_NOTICE,"RSS aware maxmemory, fragmentation looks stable at: %f", server.maxmemory_frag_guess);
+                        }
+                        last_observed_frag = current_frag;
+                    }
+                    iterations = 0;
+                }
+            }
+        }
+        mem_target = server.maxmemory_enforced;
+    }
+#endif
+
     /* Check if we are over the memory limit. */
-    if (mem_used <= server.maxmemory) return REDIS_OK;
+    if (mem_used <= mem_target) return REDIS_OK;
 
     if (server.maxmemory_policy == REDIS_MAXMEMORY_NO_EVICTION)
         return REDIS_ERR; /* We need to free memory, but policy forbids. */
 
     /* Compute how much memory we need to free. */
-    mem_tofree = mem_used - server.maxmemory;
+    mem_tofree = mem_used - mem_target;
     mem_freed = 0;
     latencyStartMonitor(latency);
     while (mem_freed < mem_tofree) {
@@ -3455,27 +3465,15 @@ void redisAsciiArt(void) {
     else if (server.sentinel_mode) mode = "sentinel";
     else mode = "standalone";
 
-    if (server.syslog_enabled) {
-        redisLog(REDIS_NOTICE,
-            "Redis %s (%s/%d) %s bit, %s mode, port %d, pid %ld ready to start.",
-            REDIS_VERSION,
-            redisGitSHA1(),
-            strtol(redisGitDirty(),NULL,10) > 0,
-            (sizeof(long) == 8) ? "64" : "32",
-            mode, server.port,
-            (long) getpid()
-        );
-    } else {
-        snprintf(buf,1024*16,ascii_logo,
-            REDIS_VERSION,
-            redisGitSHA1(),
-            strtol(redisGitDirty(),NULL,10) > 0,
-            (sizeof(long) == 8) ? "64" : "32",
-            mode, server.port,
-            (long) getpid()
-        );
-        redisLogRaw(REDIS_NOTICE|REDIS_LOG_RAW,buf);
-    }
+    snprintf(buf,1024*16,ascii_logo,
+        REDIS_VERSION,
+        redisGitSHA1(),
+        strtol(redisGitDirty(),NULL,10) > 0,
+        (sizeof(long) == 8) ? "64" : "32",
+        mode, server.port,
+        (long) getpid()
+    );
+    redisLogRaw(REDIS_NOTICE|REDIS_LOG_RAW,buf);
     zfree(buf);
 }
 
@@ -3584,103 +3582,9 @@ void redisSetProcTitle(char *title) {
 #endif
 }
 
-/*
- * Check whether systemd or upstart have been used to start redis.
- */
-int redisIsSupervised(void) {
-    const char *upstart_job = getenv("UPSTART_JOB");
-    const char *notify_socket = getenv("NOTIFY_SOCKET");
-    int fd = 1;
-    struct sockaddr_un su;
-    struct iovec iov;
-    struct msghdr hdr;
-    int sendto_flags = 0;
-
-    if (upstart_job == NULL && notify_socket == NULL)
-        return 0;
-
-    if (upstart_job != NULL) {
-        redisLog(REDIS_NOTICE, "supervised by upstart, will stop to signal readyness");
-        raise(SIGSTOP);
-        unsetenv("UPSTART_JOB");
-
-        return 1;
-    }
-
-    /*
-     * If we got here, we're supervised by systemd.
-     */
-    if ((strchr("@/", notify_socket[0])) == NULL ||
-        strlen(notify_socket) < 2)
-        return 0;
-
-    redisLog(REDIS_NOTICE, "supervised by systemd, will signal readyness");
-    if ((fd = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0) {
-        redisLog(REDIS_WARNING, "cannot contact systemd socket %s", notify_socket);
-        return 0;
-    }
-
-    bzero(&su, sizeof(su));
-    su.sun_family = AF_UNIX;
-    strncpy (su.sun_path, notify_socket, sizeof(su.sun_path) -1);
-    su.sun_path[sizeof(su.sun_path) - 1] = '\0';
-
-    if (notify_socket[0] == '@')
-        su.sun_path[0] = '\0';
-
-    bzero(&iov, sizeof(iov));
-    iov.iov_base = "READY=1";
-    iov.iov_len = strlen("READY=1");
-
-    bzero(&hdr, sizeof(hdr));
-    hdr.msg_name = &su;
-    hdr.msg_namelen = offsetof(struct sockaddr_un, sun_path) +
-        strlen(notify_socket);
-    hdr.msg_iov = &iov;
-    hdr.msg_iovlen = 1;
-
-    unsetenv("NOTIFY_SOCKET");
-#ifdef HAVE_MSG_NOSIGNAL
-    sendto_flags |= MSG_NOSIGNAL;
-#endif
-    if (sendmsg(fd, &hdr, sendto_flags) < 0) {
-        redisLog(REDIS_WARNING, "Cannot send notification to systemd");
-        close(fd);
-        return 0;
-    }
-    close(fd);
-    return 1;
-}
-
 int main(int argc, char **argv) {
     struct timeval tv;
 
-#ifdef REDIS_TEST
-    if (argc == 3 && !strcasecmp(argv[1], "test")) {
-        if (!strcasecmp(argv[2], "ziplist")) {
-            return ziplistTest(argc, argv);
-        } else if (!strcasecmp(argv[2], "quicklist")) {
-            quicklistTest(argc, argv);
-        } else if (!strcasecmp(argv[2], "intset")) {
-            return intsetTest(argc, argv);
-        } else if (!strcasecmp(argv[2], "zipmap")) {
-            return zipmapTest(argc, argv);
-        } else if (!strcasecmp(argv[2], "sha1test")) {
-            return sha1Test(argc, argv);
-        } else if (!strcasecmp(argv[2], "util")) {
-            return utilTest(argc, argv);
-        } else if (!strcasecmp(argv[2], "sds")) {
-            return sdsTest(argc, argv);
-        } else if (!strcasecmp(argv[2], "endianconv")) {
-            return endianconvTest(argc, argv);
-        } else if (!strcasecmp(argv[2], "crc64")) {
-            return crc64Test(argc, argv);
-        }
-
-        return -1; /* test not found */
-    }
-#endif
-
     /* We need to initialize our libraries, and the server configuration. */
 #ifdef INIT_SETPROCTITLE_REPLACEMENT
     spt_init(argc, argv);
@@ -3757,11 +3661,9 @@ int main(int argc, char **argv) {
     } else {
         redisLog(REDIS_WARNING, "Warning: no config file specified, using the default config. In order to specify a config file use %s /path/to/%s.conf", argv[0], server.sentinel_mode ? "sentinel" : "redis");
     }
-
-    server.supervised = redisIsSupervised();
-    if (server.daemonize && server.supervised == 0) daemonize();
+    if (server.daemonize) daemonize();
     initServer();
-    if (server.daemonize && server.supervised == 0) createPidFile();
+    if (server.daemonize) createPidFile();
     redisSetProcTitle(argv[0]);
     redisAsciiArt();
 
@@ -3771,7 +3673,6 @@ int main(int argc, char **argv) {
     #ifdef __linux__
         linuxMemoryWarnings();
     #endif
-        checkTcpBacklogSettings();
         loadDataFromDisk();
         if (server.cluster_enabled) {
             if (verifyClusterConfigWithData() == REDIS_ERR) {

src/redis.h

@@ -65,13 +65,6 @@ typedef long long mstime_t; /* millisecond time type. */
 #include "util.h"    /* Misc functions useful in many places */
 #include "latency.h" /* Latency monitor API */
 #include "sparkline.h" /* ASII graphs API */
-#include "quicklist.h"
-
-/* Following includes allow test functions to be called from Redis main() */
-#include "zipmap.h"
-#include "sha1.h"
-#include "endianconv.h"
-#include "crc64.h"
 
 /* Error codes */
 #define REDIS_OK                0
@@ -104,6 +97,7 @@ typedef long long mstime_t; /* millisecond time type. */
 #define REDIS_REPL_PING_SLAVE_PERIOD 10
 #define REDIS_RUN_ID_SIZE 40
 #define REDIS_EOF_MARK_SIZE 40
+#define REDIS_OPS_SEC_SAMPLES 16
 #define REDIS_DEFAULT_REPL_BACKLOG_SIZE (1024*1024)    /* 1mb */
 #define REDIS_DEFAULT_REPL_BACKLOG_TIME_LIMIT (60*60)  /* 1 hour */
 #define REDIS_REPL_BACKLOG_MIN_SIZE (1024*16)          /* 16k */
@@ -127,6 +121,8 @@ typedef long long mstime_t; /* millisecond time type. */
 #define REDIS_DEFAULT_REPL_DISABLE_TCP_NODELAY 0
 #define REDIS_DEFAULT_MAXMEMORY 0
 #define REDIS_DEFAULT_MAXMEMORY_SAMPLES 5
+#define REDIS_DEFAULT_MAXMEMORY_FRAG_GUESS 1.4
+#define REDIS_DEFAULT_RSS_AWARE_MAXMEMORY 0
 #define REDIS_DEFAULT_AOF_FILENAME "appendonly.aof"
 #define REDIS_DEFAULT_AOF_NO_FSYNC_ON_REWRITE 0
 #define REDIS_DEFAULT_AOF_LOAD_TRUNCATED 1
@@ -146,13 +142,6 @@ typedef long long mstime_t; /* millisecond time type. */
 #define ACTIVE_EXPIRE_CYCLE_SLOW 0
 #define ACTIVE_EXPIRE_CYCLE_FAST 1
 
-/* Instantaneous metrics tracking. */
-#define REDIS_METRIC_SAMPLES 16     /* Number of samples per metric. */
-#define REDIS_METRIC_COMMAND 0      /* Number of commands executed. */
-#define REDIS_METRIC_NET_INPUT 1    /* Bytes read to network .*/
-#define REDIS_METRIC_NET_OUTPUT 2   /* Bytes written to network. */
-#define REDIS_METRIC_COUNT 3
-
 /* Protocol and I/O related defines */
 #define REDIS_MAX_QUERYBUF_LEN  (1024*1024*1024) /* 1GB max query buffer. */
 #define REDIS_IOBUF_LEN         (1024*16)  /* Generic I/O buffer size */
@@ -205,7 +194,6 @@ typedef long long mstime_t; /* millisecond time type. */
 #define REDIS_ENCODING_INTSET 6  /* Encoded as intset */
 #define REDIS_ENCODING_SKIPLIST 7  /* Encoded as skiplist */
 #define REDIS_ENCODING_EMBSTR 8  /* Embedded sds string encoding */
-#define REDIS_ENCODING_QUICKLIST 9 /* Encoded as linked list of ziplists */
 
 /* Defines related to the dump file format. To store 32 bits lengths for short
  * keys requires a lot of space, so we check the most significant 2 bits of
@@ -331,14 +319,12 @@ typedef long long mstime_t; /* millisecond time type. */
 /* Zip structure related defaults */
 #define REDIS_HASH_MAX_ZIPLIST_ENTRIES 512
 #define REDIS_HASH_MAX_ZIPLIST_VALUE 64
+#define REDIS_LIST_MAX_ZIPLIST_ENTRIES 512
+#define REDIS_LIST_MAX_ZIPLIST_VALUE 64
 #define REDIS_SET_MAX_INTSET_ENTRIES 512
 #define REDIS_ZSET_MAX_ZIPLIST_ENTRIES 128
 #define REDIS_ZSET_MAX_ZIPLIST_VALUE 64
 
-/* List defaults */
-#define REDIS_LIST_MAX_ZIPLIST_SIZE -2
-#define REDIS_LIST_COMPRESS_DEPTH 0
-
 /* HyperLogLog defines */
 #define REDIS_DEFAULT_HLL_SPARSE_MAX_BYTES 3000
 
@@ -726,16 +712,12 @@ struct redisServer {
     long long slowlog_log_slower_than; /* SLOWLOG time limit (to get logged) */
     unsigned long slowlog_max_len;     /* SLOWLOG max number of items logged */
     size_t resident_set_size;       /* RSS sampled in serverCron(). */
-    long long stat_net_input_bytes; /* Bytes read from network. */
-    long long stat_net_output_bytes; /* Bytes written to network. */
-    /* The following two are used to track instantaneous metrics, like
-     * number of operations per second, network traffic. */
-    struct {
-        long long last_sample_time; /* Timestamp of last sample in ms */
-        long long last_sample_count;/* Count in last sample */
-        long long samples[REDIS_METRIC_SAMPLES];
-        int idx;
-    } inst_metric[REDIS_METRIC_COUNT];
+    /* The following two are used to track instantaneous "load" in terms
+     * of operations per second. */
+    long long ops_sec_last_sample_time; /* Timestamp of last sample (in ms) */
+    long long ops_sec_last_sample_ops;  /* numcommands in last sample */
+    long long ops_sec_samples[REDIS_OPS_SEC_SAMPLES];
+    int ops_sec_idx;
     /* Configuration */
     int verbosity;                  /* Loglevel in redis.conf */
     int maxidletime;                /* Client timeout in seconds */
@@ -743,7 +725,6 @@ struct redisServer {
     int active_expire_enabled;      /* Can be disabled for testing purposes. */
     size_t client_max_querybuf_len; /* Limit for client query buffer length */
     int dbnum;                      /* Total number of configured DBs */
-    int supervised;                 /* True if supervised by upstart or systemd */
     int daemonize;                  /* True if running as a daemon */
     clientBufferLimitsConfig client_obuf_limits[REDIS_CLIENT_TYPE_COUNT];
     /* AOF persistence */
@@ -860,6 +841,10 @@ struct redisServer {
     unsigned long long maxmemory;   /* Max number of memory bytes to use */
     int maxmemory_policy;           /* Policy for key eviction */
     int maxmemory_samples;          /* Pricision of random sampling */
+    /* RSS aware maxmemory additional state. */
+    int rss_aware_maxmemory;                /* Non zero if enabled. */
+    unsigned long long maxmemory_enforced;  /* Currently enforced maxmemory. */
+    float maxmemory_frag_guess;             /* Guessed fragmentation. */
     /* Blocked clients */
     unsigned int bpop_blocked_clients; /* Number of clients blocked by lists */
     list *unblocked_clients; /* list of clients to unblock before next loop */
@@ -873,14 +858,12 @@ struct redisServer {
     /* Zip structure config, see redis.conf for more information  */
     size_t hash_max_ziplist_entries;
     size_t hash_max_ziplist_value;
+    size_t list_max_ziplist_entries;
+    size_t list_max_ziplist_value;
     size_t set_max_intset_entries;
     size_t zset_max_ziplist_entries;
     size_t zset_max_ziplist_value;
     size_t hll_sparse_max_bytes;
-    /* List parameters */
-    int list_max_ziplist_size;
-    int list_compress_depth;
-    /* time cache */
     time_t unixtime;        /* Unix time sampled every cron cycle. */
     long long mstime;       /* Like 'unixtime' but with milliseconds resolution. */
     /* Pubsub */
@@ -920,8 +903,6 @@ struct redisServer {
     int assert_line;
     int bug_report_start; /* True if bug report header was already logged. */
     int watchdog_period;  /* Software watchdog period in ms. 0 = off */
-    /* System hardware info */
-    size_t system_memory_size;  /* Total memory in system as reported by OS */
 };
 
 typedef struct pubsubPattern {
@@ -970,13 +951,15 @@ typedef struct {
     robj *subject;
     unsigned char encoding;
     unsigned char direction; /* Iteration direction */
-    quicklistIter *iter;
+    unsigned char *zi;
+    listNode *ln;
 } listTypeIterator;
 
 /* Structure for an entry while iterating over a list. */
 typedef struct {
     listTypeIterator *li;
-    quicklistEntry entry; /* Entry in quicklist */
+    unsigned char *zi;  /* Entry in ziplist */
+    listNode *ln;       /* Entry in linked list */
 } listTypeEntry;
 
 /* Structure to hold set iteration abstraction. */
@@ -1053,7 +1036,6 @@ void addReplyBulkCBuffer(redisClient *c, void *p, size_t len);
 void addReplyBulkLongLong(redisClient *c, long long ll);
 void addReply(redisClient *c, robj *obj);
 void addReplySds(redisClient *c, sds s);
-void addReplyBulkSds(redisClient *c, sds s);
 void addReplyError(redisClient *c, char *err);
 void addReplyStatus(redisClient *c, char *status);
 void addReplyDouble(redisClient *c, double d);
@@ -1103,7 +1085,7 @@ int listTypeNext(listTypeIterator *li, listTypeEntry *entry);
 robj *listTypeGet(listTypeEntry *entry);
 void listTypeInsert(listTypeEntry *entry, robj *value, int where);
 int listTypeEqual(listTypeEntry *entry, robj *o);
-void listTypeDelete(listTypeIterator *iter, listTypeEntry *entry);
+void listTypeDelete(listTypeEntry *entry);
 void listTypeConvert(robj *subject, int enc);
 void unblockClientWaitingData(redisClient *c);
 void handleClientsBlockedOnLists(void);
@@ -1140,8 +1122,8 @@ robj *tryObjectEncoding(robj *o);
 robj *getDecodedObject(robj *o);
 size_t stringObjectLen(robj *o);
 robj *createStringObjectFromLongLong(long long value);
-robj *createStringObjectFromLongDouble(long double value, int humanfriendly);
-robj *createQuicklistObject(void);
+robj *createStringObjectFromLongDouble(long double value);
+robj *createListObject(void);
 robj *createZiplistObject(void);
 robj *createSetObject(void);
 robj *createIntsetObject(void);
@@ -1268,7 +1250,6 @@ void closeListeningSockets(int unlink_unix_socket);
 void updateCachedTime(void);
 void resetServerStats(void);
 unsigned int getLRUClock(void);
-char *maxmemoryToString(void);
 
 /* Set data type */
 robj *setTypeCreate(robj *value);
@@ -1280,7 +1261,6 @@ void setTypeReleaseIterator(setTypeIterator *si);
 int setTypeNext(setTypeIterator *si, robj **objele, int64_t *llele);
 robj *setTypeNextObject(setTypeIterator *si);
 int setTypeRandomElement(robj *setobj, robj **objele, int64_t *llele);
-unsigned long setTypeRandomElements(robj *set, unsigned long count, robj *aux_set);
 unsigned long setTypeSize(robj *subject);
 void setTypeConvert(robj *subject, int enc);
 

src/replication.c

@@ -56,7 +56,7 @@ char *replicationGetSlaveName(redisClient *c) {
     buf[0] = '\0';
     if (anetPeerToString(c->fd,ip,sizeof(ip),NULL) != -1) {
         if (c->slave_listening_port)
-            anetFormatAddr(buf,sizeof(buf),ip,c->slave_listening_port);
+            snprintf(buf,sizeof(buf),"%s:%d",ip,c->slave_listening_port);
         else
             snprintf(buf,sizeof(buf),"%s:<unknown-slave-port>",ip);
     } else {
@@ -690,7 +690,6 @@ void sendBulkToSlave(aeEventLoop *el, int fd, void *privdata, int mask) {
             freeClient(slave);
             return;
         }
-        server.stat_net_output_bytes += nwritten;
         sdsrange(slave->replpreamble,nwritten,-1);
         if (sdslen(slave->replpreamble) == 0) {
             sdsfree(slave->replpreamble);
@@ -719,7 +718,6 @@ void sendBulkToSlave(aeEventLoop *el, int fd, void *privdata, int mask) {
         return;
     }
     slave->repldboff += nwritten;
-    server.stat_net_output_bytes += nwritten;
     if (slave->repldboff == slave->repldbsize) {
         close(slave->repldbfd);
         slave->repldbfd = -1;
@@ -940,7 +938,6 @@ void readSyncBulkPayload(aeEventLoop *el, int fd, void *privdata, int mask) {
         replicationAbortSyncTransfer();
         return;
     }
-    server.stat_net_input_bytes += nread;
 
     /* When a mark is used, we want to detect EOF asap in order to avoid
      * writing the EOF mark into the file... */

src/scripting.c

@@ -537,7 +537,6 @@ void luaLoadLib(lua_State *lua, const char *libname, lua_CFunction luafunc) {
 LUALIB_API int (luaopen_cjson) (lua_State *L);
 LUALIB_API int (luaopen_struct) (lua_State *L);
 LUALIB_API int (luaopen_cmsgpack) (lua_State *L);
-LUALIB_API int (luaopen_bit) (lua_State *L);
 
 void luaLoadLibraries(lua_State *lua) {
     luaLoadLib(lua, "", luaopen_base);
@@ -548,7 +547,6 @@ void luaLoadLibraries(lua_State *lua) {
     luaLoadLib(lua, "cjson", luaopen_cjson);
     luaLoadLib(lua, "struct", luaopen_struct);
     luaLoadLib(lua, "cmsgpack", luaopen_cmsgpack);
-    luaLoadLib(lua, "bit", luaopen_bit);
 
 #if 0 /* Stuff that we don't load currently, for sandboxing concerns. */
     luaLoadLib(lua, LUA_LOADLIBNAME, luaopen_package);

src/sds.c

@@ -295,7 +295,7 @@ sds sdscpy(sds s, const char *t) {
  * conversion. 's' must point to a string with room for at least
  * SDS_LLSTR_SIZE bytes.
  *
- * The function returns the length of the null-terminated string
+ * The function returns the lenght of the null-terminated string
  * representation stored at 's'. */
 #define SDS_LLSTR_SIZE 21
 int sdsll2str(char *s, long long value) {
@@ -369,7 +369,7 @@ sds sdsfromlonglong(long long value) {
     return sdsnewlen(buf,len);
 }
 
-/* Like sdscatprintf() but gets va_list instead of being variadic. */
+/* Like sdscatpritf() but gets va_list instead of being variadic. */
 sds sdscatvprintf(sds s, const char *fmt, va_list ap) {
     va_list cpy;
     char staticbuf[1024], *buf = staticbuf, *t;
@@ -390,7 +390,7 @@ sds sdscatvprintf(sds s, const char *fmt, va_list ap) {
         buf[buflen-2] = '\0';
         va_copy(cpy,ap);
         vsnprintf(buf, buflen, fmt, cpy);
-        va_end(cpy);
+        va_end(ap);
         if (buf[buflen-2] != '\0') {
             if (buf != staticbuf) zfree(buf);
             buflen *= 2;
@@ -415,7 +415,7 @@ sds sdscatvprintf(sds s, const char *fmt, va_list ap) {
  *
  * Example:
  *
- * s = sdsnew("Sum is: ");
+ * s = sdsempty("Sum is: ");
  * s = sdscatprintf(s,"%d+%d = %d",a,b,a+b).
  *
  * Often you need to create a string from scratch with the printf-alike
@@ -570,7 +570,7 @@ sds sdstrim(sds s, const char *cset) {
     sp = start = s;
     ep = end = s+sdslen(s)-1;
     while(sp <= end && strchr(cset, *sp)) sp++;
-    while(ep > sp && strchr(cset, *ep)) ep--;
+    while(ep > start && strchr(cset, *ep)) ep--;
     len = (sp > ep) ? 0 : ((ep-sp)+1);
     if (sh->buf != sp) memmove(sh->buf, sp, len);
     sh->buf[len] = '\0';
@@ -643,8 +643,8 @@ void sdstoupper(sds s) {
  *
  * Return value:
  *
- *     positive if s1 > s2.
- *     negative if s1 < s2.
+ *     1 if s1 > s2.
+ *    -1 if s1 < s2.
  *     0 if s1 and s2 are exactly the same binary string.
  *
  * If two strings share exactly the same prefix, but one of the two has
@@ -962,15 +962,12 @@ sds sdsjoin(char **argv, int argc, char *sep) {
     return join;
 }
 
-#if defined(REDIS_TEST) || defined(SDS_TEST_MAIN)
+#ifdef SDS_TEST_MAIN
 #include <stdio.h>
 #include "testhelp.h"
 #include "limits.h"
 
-#define UNUSED(x) (void)(x)
-int sdsTest(int argc, char *argv[]) {
-    UNUSED(argc);
-    UNUSED(argv);
+int main(void) {
     {
         struct sdshdr *sh;
         sds x = sdsnew("foo"), y;
@@ -1016,18 +1013,6 @@ int sdsTest(int argc, char *argv[]) {
             sdslen(x) == 35 &&
             memcmp(x,"--4294967295,18446744073709551615--",35) == 0)
 
-        sdsfree(x);
-        x = sdsnew(" x ");
-        sdstrim(x," x");
-        test_cond("sdstrim() works when all chars match",
-            sdslen(x) == 0)
-
-        sdsfree(x);
-        x = sdsnew(" x ");
-        sdstrim(x," ");
-        test_cond("sdstrim() works when a single char remains",
-            sdslen(x) == 1 && x[0] == 'x')
-
         sdsfree(x);
         x = sdsnew("xxciaoyyy");
         sdstrim(x,"xy");
@@ -1095,7 +1080,7 @@ int sdsTest(int argc, char *argv[]) {
             memcmp(y,"\"\\a\\n\\x00foo\\r\"",15) == 0)
 
         {
-            unsigned int oldfree;
+            int oldfree;
 
             sdsfree(x);
             x = sdsnew("0");
@@ -1116,9 +1101,3 @@ int sdsTest(int argc, char *argv[]) {
     return 0;
 }
 #endif
-
-#ifdef SDS_TEST_MAIN
-int main(void) {
-    return sdsTest();
-}
-#endif

src/sds.h

@@ -98,8 +98,4 @@ void sdsIncrLen(sds s, int incr);
 sds sdsRemoveFreeSpace(sds s);
 size_t sdsAllocSize(sds s);
 
-#ifdef REDIS_TEST
-int sdsTest(int argc, char *argv[]);
-#endif
-
 #endif

src/sentinel.c

@@ -190,7 +190,6 @@ typedef struct sentinelRedisInstance {
      * are set to NULL no script is executed. */
     char *notification_script;
     char *client_reconfig_script;
-    sds info; /* cached INFO output */
 } sentinelRedisInstance;
 
 /* Main state. */
@@ -577,7 +576,7 @@ void sentinelEvent(int level, char *type, sentinelRedisInstance *ri,
     if (level == REDIS_WARNING && ri != NULL) {
         sentinelRedisInstance *master = (ri->flags & SRI_MASTER) ?
                                          ri : ri->master;
-        if (master && master->notification_script) {
+        if (master->notification_script) {
             sentinelScheduleScriptExecution(master->notification_script,
                 type,msg,NULL);
         }
@@ -897,7 +896,7 @@ sentinelRedisInstance *createSentinelRedisInstance(char *name, int flags, char *
     sentinelRedisInstance *ri;
     sentinelAddr *addr;
     dict *table = NULL;
-    char slavename[REDIS_PEER_ID_LEN], *sdsname;
+    char slavename[128], *sdsname;
 
     redisAssert(flags & (SRI_MASTER|SRI_SLAVE|SRI_SENTINEL));
     redisAssert((flags & SRI_MASTER) || master != NULL);
@@ -908,7 +907,9 @@ sentinelRedisInstance *createSentinelRedisInstance(char *name, int flags, char *
 
     /* For slaves and sentinel we use ip:port as name. */
     if (flags & (SRI_SLAVE|SRI_SENTINEL)) {
-        anetFormatAddr(slavename, sizeof(slavename), hostname, port);
+        snprintf(slavename,sizeof(slavename),
+            strchr(hostname,':') ? "[%s]:%d" : "%s:%d",
+            hostname,port);
         name = slavename;
     }
 
@@ -982,7 +983,6 @@ sentinelRedisInstance *createSentinelRedisInstance(char *name, int flags, char *
     ri->promoted_slave = NULL;
     ri->notification_script = NULL;
     ri->client_reconfig_script = NULL;
-    ri->info = NULL;
 
     /* Role */
     ri->role_reported = ri->flags & (SRI_MASTER|SRI_SLAVE);
@@ -1015,7 +1015,6 @@ void releaseSentinelRedisInstance(sentinelRedisInstance *ri) {
     sdsfree(ri->slave_master_host);
     sdsfree(ri->leader);
     sdsfree(ri->auth_pass);
-    sdsfree(ri->info);
     releaseSentinelAddr(ri->addr);
 
     /* Clear state into the master if needed. */
@@ -1031,11 +1030,11 @@ sentinelRedisInstance *sentinelRedisInstanceLookupSlave(
 {
     sds key;
     sentinelRedisInstance *slave;
-    char buf[REDIS_PEER_ID_LEN];
 
     redisAssert(ri->flags & SRI_MASTER);
-    anetFormatAddr(buf,sizeof(buf),ip,port);
-    key = sdsnew(buf);
+    key = sdscatprintf(sdsempty(),
+        strchr(ip,':') ? "[%s]:%d" : "%s:%d",
+        ip,port);
     slave = dictFetchValue(ri->slaves,key);
     sdsfree(key);
     return slave;
@@ -1786,10 +1785,6 @@ void sentinelRefreshInstanceInfo(sentinelRedisInstance *ri, const char *info) {
     int numlines, j;
     int role = 0;
 
-    /* cache full INFO output for instance */
-    sdsfree(ri->info);
-    ri->info = sdsnew(info);
-
     /* The following fields must be reset to a given value in the case they
      * are not found at all in the INFO output. */
     ri->master_link_down_time = 0;
@@ -2782,67 +2777,6 @@ void sentinelCommand(redisClient *c) {
     } else if (!strcasecmp(c->argv[1]->ptr,"set")) {
         if (c->argc < 3 || c->argc % 2 == 0) goto numargserr;
         sentinelSetCommand(c);
-    } else if (!strcasecmp(c->argv[1]->ptr,"info-cache")) {
-        if (c->argc < 2) goto numargserr;
-        mstime_t now = mstime();
-
-        /* Create an ad-hoc dictionary type so that we can iterate
-         * a dictionary composed of just the master groups the user
-         * requested. */
-        dictType copy_keeper = instancesDictType;
-        copy_keeper.valDestructor = NULL;
-        dict *masters_local = sentinel.masters;
-        if (c->argc > 2) {
-            masters_local = dictCreate(&copy_keeper, NULL);
-
-            for (int i = 2; i < c->argc; i++) {
-                sentinelRedisInstance *ri;
-                ri = sentinelGetMasterByName(c->argv[i]->ptr);
-                if (!ri) continue; /* ignore non-existing names */
-                dictAdd(masters_local, ri->name, ri);
-            }
-        }
-
-        /* Reply format:
-         *   1.) master name
-         *   2.) 1.) info from master
-         *       2.) info from replica
-         *       ...
-         *   3.) other master name
-         *   ...
-         */
-        addReplyMultiBulkLen(c,dictSize(masters_local) * 2);
-
-        dictIterator  *di;
-        dictEntry *de;
-        di = dictGetIterator(masters_local);
-        while ((de = dictNext(di)) != NULL) {
-            sentinelRedisInstance *ri = dictGetVal(de);
-            addReplyBulkCBuffer(c,ri->name,strlen(ri->name));
-            addReplyMultiBulkLen(c,dictSize(ri->slaves) + 1); /* +1 for self */
-            addReplyMultiBulkLen(c,2);
-            addReplyLongLong(c, now - ri->info_refresh);
-            if (ri->info)
-                addReplyBulkCBuffer(c,ri->info,sdslen(ri->info));
-            else
-                addReply(c,shared.nullbulk);
-
-            dictIterator *sdi;
-            dictEntry *sde;
-            sdi = dictGetIterator(ri->slaves);
-            while ((sde = dictNext(sdi)) != NULL) {
-                sentinelRedisInstance *sri = dictGetVal(sde);
-                addReplyMultiBulkLen(c,2);
-                addReplyLongLong(c, now - sri->info_refresh);
-                if (sri->info)
-                    addReplyBulkCBuffer(c,sri->info,sdslen(sri->info));
-                else
-                    addReply(c,shared.nullbulk);
-            }
-            dictReleaseIterator(sdi);
-        }
-        dictReleaseIterator(di);
-        if (masters_local != sentinel.masters) dictRelease(masters_local);
     } else {
         addReplyErrorFormat(c,"Unknown sentinel subcommand '%s'",
                                (char*)c->argv[1]->ptr);
@@ -2908,7 +2842,10 @@ void sentinelInfoCommand(redisClient *c) {
         dictReleaseIterator(di);
     }
 
-    addReplyBulkSds(c, info);
+    addReplySds(c,sdscatprintf(sdsempty(),"$%lu\r\n",
+        (unsigned long)sdslen(info)));
+    addReplySds(c,info);
+    addReply(c,shared.crlf);
 }
 
 /* Implements Sentinel verison of the ROLE command. The output is

src/sha1.c

@@ -199,19 +199,16 @@ void SHA1Final(unsigned char digest[20], SHA1_CTX* context)
 }
 /* ================ end of sha1.c ================ */
 
-#ifdef REDIS_TEST
+#if 0
 #define BUFSIZE 4096
 
-#define UNUSED(x) (void)(x)
-int sha1Test(int argc, char **argv)
+int
+main(int argc, char **argv)
 {
     SHA1_CTX ctx;
     unsigned char hash[20], buf[BUFSIZE];
     int i;
 
-    UNUSED(argc);
-    UNUSED(argv);
-
     for(i=0;i<BUFSIZE;i++)
         buf[i] = i;
 
@@ -226,4 +223,6 @@ int sha1Test(int argc, char **argv)
     printf("\n");
     return 0;
 }
+
 #endif
+

src/sha1.h

@@ -1,5 +1,3 @@
-#ifndef SHA1_H
-#define SHA1_H
 /* ================ sha1.h ================ */
 /*
 SHA-1 in C
@@ -17,8 +15,3 @@ void SHA1Transform(u_int32_t state[5], const unsigned char buffer[64]);
 void SHA1Init(SHA1_CTX* context);
 void SHA1Update(SHA1_CTX* context, const unsigned char* data, u_int32_t len);
 void SHA1Final(unsigned char digest[20], SHA1_CTX* context);
-
-#ifdef REDIS_TEST
-int sha1Test(int argc, char **argv);
-#endif
-#endif

src/sort.c

@@ -220,7 +220,7 @@ void sortCommand(redisClient *c) {
     if (sortval)
         incrRefCount(sortval);
     else
-        sortval = createQuicklistObject();
+        sortval = createListObject();
 
     /* The SORT command has an SQL-alike syntax, parse it */
     while(j < c->argc) {
@@ -285,15 +285,16 @@ void sortCommand(redisClient *c) {
         return;
     }
 
-    /* When sorting a set with no sort specified, we must sort the output
-     * so the result is consistent across scripting and replication.
+    /* For the STORE option, or when SORT is called from a Lua script,
+     * we want to force a specific ordering even when no explicit ordering
+     * was asked (SORT BY nosort). This guarantees that replication / AOF
+     * is deterministic.
      *
-     * The other types (list, sorted set) will retain their native order
-     * even if no sort order is requested, so they remain stable across
-     * scripting and replication. */
-    if (dontsort &&
-        sortval->type == REDIS_SET &&
-        (storekey || c->flags & REDIS_LUA_CLIENT))
+     * However in the case 'dontsort' is true, but the type to sort is a
+     * sorted set, we don't need to do anything as ordering is guaranteed
+     * in this special case. */
+    if ((storekey || c->flags & REDIS_LUA_CLIENT) &&
+        (dontsort && sortval->type != REDIS_ZSET))
     {
         /* Force ALPHA sorting */
         dontsort = 0;
@@ -420,7 +421,6 @@ void sortCommand(redisClient *c) {
     } else {
         redisPanic("Unknown type");
     }
-    printf("j: %d; vectorlen: %d\n", j, vectorlen);
     redisAssertWithInfo(c,sortval,j == vectorlen);
 
     /* Now it's time to load the right scores in the sorting vector */
@@ -510,7 +510,7 @@ void sortCommand(redisClient *c) {
             }
         }
     } else {
-        robj *sobj = createQuicklistObject();
+        robj *sobj = createZiplistObject();
 
         /* STORE option specified, set the sorting result as a List object */
         for (j = start; j <= end; j++) {

src/sparkline.c

@@ -49,7 +49,7 @@ static int label_margin_top = 1;
  * sparklineSequenceAddSample(seq, 10, NULL);
  * sparklineSequenceAddSample(seq, 20, NULL);
  * sparklineSequenceAddSample(seq, 30, "last sample label");
- * sds output = sparklineRender(sdsempty(), seq, 80, 4, SPARKLINE_FILL);
+ * sds output = sparklineRender(seq, 80, 4);
  * freeSparklineSequence(seq);
  * ------------------------------------------------------------------------- */
 
@@ -63,7 +63,6 @@ struct sequence *createSparklineSequence(void) {
 
 /* Add a new sample into a sequence. */
 void sparklineSequenceAddSample(struct sequence *seq, double value, char *label) {
-    label = (label == NULL || label[0] == '\0') ? NULL : zstrdup(label);
     if (seq->length == 0) {
         seq->min = seq->max = value;
     } else {

src/t_hash.c

@@ -565,7 +565,7 @@ void hincrbyfloatCommand(redisClient *c) {
     }
 
     value += incr;
-    new = createStringObjectFromLongDouble(value,1);
+    new = createStringObjectFromLongDouble(value);
     hashTypeTryObjectEncoding(o,&c->argv[2],NULL);
     hashTypeSet(o,c->argv[2],new);
     addReplyBulk(c,new);

src/t_list.c

@@ -33,37 +33,75 @@
  * List API
  *----------------------------------------------------------------------------*/
 
+/* Check the argument length to see if it requires us to convert the ziplist
+ * to a real list. Only check raw-encoded objects because integer encoded
+ * objects are never too long. */
+void listTypeTryConversion(robj *subject, robj *value) {
+    if (subject->encoding != REDIS_ENCODING_ZIPLIST) return;
+    if (sdsEncodedObject(value) &&
+        sdslen(value->ptr) > server.list_max_ziplist_value)
+            listTypeConvert(subject,REDIS_ENCODING_LINKEDLIST);
+}
+
 /* The function pushes an element to the specified list object 'subject',
  * at head or tail position as specified by 'where'.
  *
  * There is no need for the caller to increment the refcount of 'value' as
  * the function takes care of it if needed. */
 void listTypePush(robj *subject, robj *value, int where) {
-    if (subject->encoding == REDIS_ENCODING_QUICKLIST) {
-        int pos = (where == REDIS_HEAD) ? QUICKLIST_HEAD : QUICKLIST_TAIL;
+    /* Check if we need to convert the ziplist */
+    listTypeTryConversion(subject,value);
+    if (subject->encoding == REDIS_ENCODING_ZIPLIST &&
+        ziplistLen(subject->ptr) >= server.list_max_ziplist_entries)
+            listTypeConvert(subject,REDIS_ENCODING_LINKEDLIST);
+
+    if (subject->encoding == REDIS_ENCODING_ZIPLIST) {
+        int pos = (where == REDIS_HEAD) ? ZIPLIST_HEAD : ZIPLIST_TAIL;
         value = getDecodedObject(value);
-        size_t len = sdslen(value->ptr);
-        quicklistPush(subject->ptr, value->ptr, len, pos);
+        subject->ptr = ziplistPush(subject->ptr,value->ptr,sdslen(value->ptr),pos);
         decrRefCount(value);
+    } else if (subject->encoding == REDIS_ENCODING_LINKEDLIST) {
+        if (where == REDIS_HEAD) {
+            listAddNodeHead(subject->ptr,value);
+        } else {
+            listAddNodeTail(subject->ptr,value);
+        }
+        incrRefCount(value);
     } else {
         redisPanic("Unknown list encoding");
     }
 }
 
-void *listPopSaver(unsigned char *data, unsigned int sz) {
-    return createStringObject((char*)data,sz);
-}
-
 robj *listTypePop(robj *subject, int where) {
-    long long vlong;
     robj *value = NULL;
-
-    int ql_where = where == REDIS_HEAD ? QUICKLIST_HEAD : QUICKLIST_TAIL;
-    if (subject->encoding == REDIS_ENCODING_QUICKLIST) {
-        if (quicklistPopCustom(subject->ptr, ql_where, (unsigned char **)&value,
-                               NULL, &vlong, listPopSaver)) {
-            if (!value)
+    if (subject->encoding == REDIS_ENCODING_ZIPLIST) {
+        unsigned char *p;
+        unsigned char *vstr;
+        unsigned int vlen;
+        long long vlong;
+        int pos = (where == REDIS_HEAD) ? 0 : -1;
+        p = ziplistIndex(subject->ptr,pos);
+        if (ziplistGet(p,&vstr,&vlen,&vlong)) {
+            if (vstr) {
+                value = createStringObject((char*)vstr,vlen);
+            } else {
                 value = createStringObjectFromLongLong(vlong);
+            }
+            /* We only need to delete an element when it exists */
+            subject->ptr = ziplistDelete(subject->ptr,&p);
+        }
+    } else if (subject->encoding == REDIS_ENCODING_LINKEDLIST) {
+        list *list = subject->ptr;
+        listNode *ln;
+        if (where == REDIS_HEAD) {
+            ln = listFirst(list);
+        } else {
+            ln = listLast(list);
+        }
+        if (ln != NULL) {
+            value = listNodeValue(ln);
+            incrRefCount(value);
+            listDelNode(list,ln);
         }
     } else {
         redisPanic("Unknown list encoding");
@@ -72,28 +110,25 @@ robj *listTypePop(robj *subject, int where) {
 }
 
 unsigned long listTypeLength(robj *subject) {
-    if (subject->encoding == REDIS_ENCODING_QUICKLIST) {
-        return quicklistCount(subject->ptr);
+    if (subject->encoding == REDIS_ENCODING_ZIPLIST) {
+        return ziplistLen(subject->ptr);
+    } else if (subject->encoding == REDIS_ENCODING_LINKEDLIST) {
+        return listLength((list*)subject->ptr);
     } else {
         redisPanic("Unknown list encoding");
     }
 }
 
 /* Initialize an iterator at the specified index. */
-listTypeIterator *listTypeInitIterator(robj *subject, long index,
-                                       unsigned char direction) {
+listTypeIterator *listTypeInitIterator(robj *subject, long index, unsigned char direction) {
     listTypeIterator *li = zmalloc(sizeof(listTypeIterator));
     li->subject = subject;
     li->encoding = subject->encoding;
     li->direction = direction;
-    li->iter = NULL;
-    /* REDIS_HEAD means start at TAIL and move *towards* head.
-     * REDIS_TAIL means start at HEAD and move *towards tail. */
-    int iter_direction =
-        direction == REDIS_HEAD ? AL_START_TAIL : AL_START_HEAD;
-    if (li->encoding == REDIS_ENCODING_QUICKLIST) {
-        li->iter = quicklistGetIteratorAtIdx(li->subject->ptr,
-                                             iter_direction, index);
+    if (li->encoding == REDIS_ENCODING_ZIPLIST) {
+        li->zi = ziplistIndex(subject->ptr,index);
+    } else if (li->encoding == REDIS_ENCODING_LINKEDLIST) {
+        li->ln = listIndex(subject->ptr,index);
     } else {
         redisPanic("Unknown list encoding");
     }
@@ -102,7 +137,6 @@ listTypeIterator *listTypeInitIterator(robj *subject, long index,
 
 /* Clean up the iterator. */
 void listTypeReleaseIterator(listTypeIterator *li) {
-    zfree(li->iter);
     zfree(li);
 }
 
@@ -114,8 +148,24 @@ int listTypeNext(listTypeIterator *li, listTypeEntry *entry) {
     redisAssert(li->subject->encoding == li->encoding);
 
     entry->li = li;
-    if (li->encoding == REDIS_ENCODING_QUICKLIST) {
-        return quicklistNext(li->iter, &entry->entry);
+    if (li->encoding == REDIS_ENCODING_ZIPLIST) {
+        entry->zi = li->zi;
+        if (entry->zi != NULL) {
+            if (li->direction == REDIS_TAIL)
+                li->zi = ziplistNext(li->subject->ptr,li->zi);
+            else
+                li->zi = ziplistPrev(li->subject->ptr,li->zi);
+            return 1;
+        }
+    } else if (li->encoding == REDIS_ENCODING_LINKEDLIST) {
+        entry->ln = li->ln;
+        if (entry->ln != NULL) {
+            if (li->direction == REDIS_TAIL)
+                li->ln = li->ln->next;
+            else
+                li->ln = li->ln->prev;
+            return 1;
+        }
     } else {
         redisPanic("Unknown list encoding");
     }
@@ -124,14 +174,24 @@ int listTypeNext(listTypeIterator *li, listTypeEntry *entry) {
 
 /* Return entry or NULL at the current position of the iterator. */
 robj *listTypeGet(listTypeEntry *entry) {
+    listTypeIterator *li = entry->li;
     robj *value = NULL;
-    if (entry->li->encoding == REDIS_ENCODING_QUICKLIST) {
-        if (entry->entry.value) {
-            value = createStringObject((char *)entry->entry.value,
-                                       entry->entry.sz);
-        } else {
-            value = createStringObjectFromLongLong(entry->entry.longval);
+    if (li->encoding == REDIS_ENCODING_ZIPLIST) {
+        unsigned char *vstr;
+        unsigned int vlen;
+        long long vlong;
+        redisAssert(entry->zi != NULL);
+        if (ziplistGet(entry->zi,&vstr,&vlen,&vlong)) {
+            if (vstr) {
+                value = createStringObject((char*)vstr,vlen);
+            } else {
+                value = createStringObjectFromLongLong(vlong);
+            }
         }
+    } else if (li->encoding == REDIS_ENCODING_LINKEDLIST) {
+        redisAssert(entry->ln != NULL);
+        value = listNodeValue(entry->ln);
+        incrRefCount(value);
     } else {
         redisPanic("Unknown list encoding");
     }
@@ -139,18 +199,30 @@ robj *listTypeGet(listTypeEntry *entry) {
 }
 
 void listTypeInsert(listTypeEntry *entry, robj *value, int where) {
-    if (entry->li->encoding == REDIS_ENCODING_QUICKLIST) {
+    robj *subject = entry->li->subject;
+    if (entry->li->encoding == REDIS_ENCODING_ZIPLIST) {
         value = getDecodedObject(value);
-        sds str = value->ptr;
-        size_t len = sdslen(str);
         if (where == REDIS_TAIL) {
-            quicklistInsertAfter((quicklist *)entry->entry.quicklist,
-                                 &entry->entry, str, len);
-        } else if (where == REDIS_HEAD) {
-            quicklistInsertBefore((quicklist *)entry->entry.quicklist,
-                                  &entry->entry, str, len);
+            unsigned char *next = ziplistNext(subject->ptr,entry->zi);
+
+            /* When we insert after the current element, but the current element
+             * is the tail of the list, we need to do a push. */
+            if (next == NULL) {
+                subject->ptr = ziplistPush(subject->ptr,value->ptr,sdslen(value->ptr),REDIS_TAIL);
+            } else {
+                subject->ptr = ziplistInsert(subject->ptr,next,value->ptr,sdslen(value->ptr));
+            }
+        } else {
+            subject->ptr = ziplistInsert(subject->ptr,entry->zi,value->ptr,sdslen(value->ptr));
         }
         decrRefCount(value);
+    } else if (entry->li->encoding == REDIS_ENCODING_LINKEDLIST) {
+        if (where == REDIS_TAIL) {
+            listInsertNode(subject->ptr,entry->ln,value,AL_START_TAIL);
+        } else {
+            listInsertNode(subject->ptr,entry->ln,value,AL_START_HEAD);
+        }
+        incrRefCount(value);
     } else {
         redisPanic("Unknown list encoding");
     }
@@ -158,33 +230,59 @@ void listTypeInsert(listTypeEntry *entry, robj *value, int where) {
 
 /* Compare the given object with the entry at the current position. */
 int listTypeEqual(listTypeEntry *entry, robj *o) {
-    if (entry->li->encoding == REDIS_ENCODING_QUICKLIST) {
+    listTypeIterator *li = entry->li;
+    if (li->encoding == REDIS_ENCODING_ZIPLIST) {
         redisAssertWithInfo(NULL,o,sdsEncodedObject(o));
-        return quicklistCompare(entry->entry.zi,o->ptr,sdslen(o->ptr));
+        return ziplistCompare(entry->zi,o->ptr,sdslen(o->ptr));
+    } else if (li->encoding == REDIS_ENCODING_LINKEDLIST) {
+        return equalStringObjects(o,listNodeValue(entry->ln));
     } else {
         redisPanic("Unknown list encoding");
     }
 }
 
 /* Delete the element pointed to. */
-void listTypeDelete(listTypeIterator *iter, listTypeEntry *entry) {
-    if (entry->li->encoding == REDIS_ENCODING_QUICKLIST) {
-        quicklistDelEntry(iter->iter, &entry->entry);
+void listTypeDelete(listTypeEntry *entry) {
+    listTypeIterator *li = entry->li;
+    if (li->encoding == REDIS_ENCODING_ZIPLIST) {
+        unsigned char *p = entry->zi;
+        li->subject->ptr = ziplistDelete(li->subject->ptr,&p);
+
+        /* Update position of the iterator depending on the direction */
+        if (li->direction == REDIS_TAIL)
+            li->zi = p;
+        else
+            li->zi = ziplistPrev(li->subject->ptr,p);
+    } else if (entry->li->encoding == REDIS_ENCODING_LINKEDLIST) {
+        listNode *next;
+        if (li->direction == REDIS_TAIL)
+            next = entry->ln->next;
+        else
+            next = entry->ln->prev;
+        listDelNode(li->subject->ptr,entry->ln);
+        li->ln = next;
     } else {
         redisPanic("Unknown list encoding");
     }
 }
 
-/* Create a quicklist from a single ziplist */
 void listTypeConvert(robj *subject, int enc) {
-    redisAssertWithInfo(NULL,subject,subject->type==REDIS_LIST);
-    redisAssertWithInfo(NULL,subject,subject->encoding==REDIS_ENCODING_ZIPLIST);
+    listTypeIterator *li;
+    listTypeEntry entry;
+    redisAssertWithInfo(NULL,subject,subject->type == REDIS_LIST);
 
-    if (enc == REDIS_ENCODING_QUICKLIST) {
-        size_t zlen = server.list_max_ziplist_size;
-        int depth = server.list_compress_depth;
-        subject->ptr = quicklistCreateFromZiplist(zlen, depth, subject->ptr);
-        subject->encoding = REDIS_ENCODING_QUICKLIST;
+    if (enc == REDIS_ENCODING_LINKEDLIST) {
+        list *l = listCreate();
+        listSetFreeMethod(l,decrRefCountVoid);
+
+        /* listTypeGet returns a robj with incremented refcount */
+        li = listTypeInitIterator(subject,0,REDIS_TAIL);
+        while (listTypeNext(li,&entry)) listAddNodeTail(l,listTypeGet(&entry));
+        listTypeReleaseIterator(li);
+
+        subject->encoding = REDIS_ENCODING_LINKEDLIST;
+        zfree(subject->ptr);
+        subject->ptr = l;
     } else {
         redisPanic("Unsupported list conversion");
     }
@@ -206,9 +304,7 @@ void pushGenericCommand(redisClient *c, int where) {
     for (j = 2; j < c->argc; j++) {
         c->argv[j] = tryObjectEncoding(c->argv[j]);
         if (!lobj) {
-            lobj = createQuicklistObject();
-            quicklistSetOptions(lobj->ptr, server.list_max_ziplist_size,
-                                server.list_compress_depth);
+            lobj = createZiplistObject();
             dbAdd(c->db,c->argv[1],lobj);
         }
         listTypePush(lobj,c->argv[j],where);
@@ -238,10 +334,17 @@ void pushxGenericCommand(redisClient *c, robj *refval, robj *val, int where) {
     listTypeEntry entry;
     int inserted = 0;
 
-    if ((subject = lookupKeyWriteOrReply(c,c->argv[1],shared.czero)) == NULL ||
+    if ((subject = lookupKeyReadOrReply(c,c->argv[1],shared.czero)) == NULL ||
         checkType(c,subject,REDIS_LIST)) return;
 
     if (refval != NULL) {
+        /* We're not sure if this value can be inserted yet, but we cannot
+         * convert the list inside the iterator. We don't want to loop over
+         * the list twice (once to see if the value can be inserted and once
+         * to do the actual insert), so we assume this value can be inserted
+         * and convert the ziplist to a regular list if necessary. */
+        listTypeTryConversion(subject,val);
+
         /* Seek refval from head to tail */
         iter = listTypeInitIterator(subject,0,REDIS_TAIL);
         while (listTypeNext(iter,&entry)) {
@@ -254,6 +357,10 @@ void pushxGenericCommand(redisClient *c, robj *refval, robj *val, int where) {
         listTypeReleaseIterator(iter);
 
         if (inserted) {
+            /* Check if the length exceeds the ziplist length threshold. */
+            if (subject->encoding == REDIS_ENCODING_ZIPLIST &&
+                ziplistLen(subject->ptr) > server.list_max_ziplist_entries)
+                    listTypeConvert(subject,REDIS_ENCODING_LINKEDLIST);
             signalModifiedKey(c->db,c->argv[1]);
             notifyKeyspaceEvent(REDIS_NOTIFY_LIST,"linsert",
                                 c->argv[1],c->db->id);
@@ -311,19 +418,31 @@ void lindexCommand(redisClient *c) {
     if ((getLongFromObjectOrReply(c, c->argv[2], &index, NULL) != REDIS_OK))
         return;
 
-    if (o->encoding == REDIS_ENCODING_QUICKLIST) {
-        quicklistEntry entry;
-        if (quicklistIndex(o->ptr, index, &entry)) {
-            if (entry.value) {
-                value = createStringObject((char*)entry.value,entry.sz);
+    if (o->encoding == REDIS_ENCODING_ZIPLIST) {
+        unsigned char *p;
+        unsigned char *vstr;
+        unsigned int vlen;
+        long long vlong;
+        p = ziplistIndex(o->ptr,index);
+        if (ziplistGet(p,&vstr,&vlen,&vlong)) {
+            if (vstr) {
+                value = createStringObject((char*)vstr,vlen);
             } else {
-                value = createStringObjectFromLongLong(entry.longval);
+                value = createStringObjectFromLongLong(vlong);
             }
             addReplyBulk(c,value);
             decrRefCount(value);
         } else {
             addReply(c,shared.nullbulk);
         }
+    } else if (o->encoding == REDIS_ENCODING_LINKEDLIST) {
+        listNode *ln = listIndex(o->ptr,index);
+        if (ln != NULL) {
+            value = listNodeValue(ln);
+            addReplyBulk(c,value);
+        } else {
+            addReply(c,shared.nullbulk);
+        }
     } else {
         redisPanic("Unknown list encoding");
     }
@@ -333,18 +452,35 @@ void lsetCommand(redisClient *c) {
     robj *o = lookupKeyWriteOrReply(c,c->argv[1],shared.nokeyerr);
     if (o == NULL || checkType(c,o,REDIS_LIST)) return;
     long index;
-    robj *value = c->argv[3];
+    robj *value = (c->argv[3] = tryObjectEncoding(c->argv[3]));
 
     if ((getLongFromObjectOrReply(c, c->argv[2], &index, NULL) != REDIS_OK))
         return;
 
-    if (o->encoding == REDIS_ENCODING_QUICKLIST) {
-        quicklist *ql = o->ptr;
-        int replaced = quicklistReplaceAtIndex(ql, index,
-                                               value->ptr, sdslen(value->ptr));
-        if (!replaced) {
+    listTypeTryConversion(o,value);
+    if (o->encoding == REDIS_ENCODING_ZIPLIST) {
+        unsigned char *p, *zl = o->ptr;
+        p = ziplistIndex(zl,index);
+        if (p == NULL) {
             addReply(c,shared.outofrangeerr);
         } else {
+            o->ptr = ziplistDelete(o->ptr,&p);
+            value = getDecodedObject(value);
+            o->ptr = ziplistInsert(o->ptr,p,value->ptr,sdslen(value->ptr));
+            decrRefCount(value);
+            addReply(c,shared.ok);
+            signalModifiedKey(c->db,c->argv[1]);
+            notifyKeyspaceEvent(REDIS_NOTIFY_LIST,"lset",c->argv[1],c->db->id);
+            server.dirty++;
+        }
+    } else if (o->encoding == REDIS_ENCODING_LINKEDLIST) {
+        listNode *ln = listIndex(o->ptr,index);
+        if (ln == NULL) {
+            addReply(c,shared.outofrangeerr);
+        } else {
+            decrRefCount((robj*)listNodeValue(ln));
+            listNodeValue(ln) = value;
+            incrRefCount(value);
             addReply(c,shared.ok);
             signalModifiedKey(c->db,c->argv[1]);
             notifyKeyspaceEvent(REDIS_NOTIFY_LIST,"lset",c->argv[1],c->db->id);
@@ -413,28 +549,43 @@ void lrangeCommand(redisClient *c) {
 
     /* Return the result in form of a multi-bulk reply */
     addReplyMultiBulkLen(c,rangelen);
-    if (o->encoding == REDIS_ENCODING_QUICKLIST) {
-        listTypeIterator *iter = listTypeInitIterator(o, start, REDIS_TAIL);
+    if (o->encoding == REDIS_ENCODING_ZIPLIST) {
+        unsigned char *p = ziplistIndex(o->ptr,start);
+        unsigned char *vstr;
+        unsigned int vlen;
+        long long vlong;
 
         while(rangelen--) {
-            listTypeEntry entry;
-            listTypeNext(iter, &entry);
-            quicklistEntry *qe = &entry.entry;
-            if (qe->value) {
-                addReplyBulkCBuffer(c,qe->value,qe->sz);
+            ziplistGet(p,&vstr,&vlen,&vlong);
+            if (vstr) {
+                addReplyBulkCBuffer(c,vstr,vlen);
             } else {
-                addReplyBulkLongLong(c,qe->longval);
+                addReplyBulkLongLong(c,vlong);
             }
+            p = ziplistNext(o->ptr,p);
+        }
+    } else if (o->encoding == REDIS_ENCODING_LINKEDLIST) {
+        listNode *ln;
+
+        /* If we are nearest to the end of the list, reach the element
+         * starting from tail and going backward, as it is faster. */
+        if (start > llen/2) start -= llen;
+        ln = listIndex(o->ptr,start);
+
+        while(rangelen--) {
+            addReplyBulk(c,ln->value);
+            ln = ln->next;
         }
-        listTypeReleaseIterator(iter);
     } else {
-        redisPanic("List encoding is not QUICKLIST!");
+        redisPanic("List encoding is not LINKEDLIST nor ZIPLIST!");
     }
 }
 
 void ltrimCommand(redisClient *c) {
     robj *o;
-    long start, end, llen, ltrim, rtrim;
+    long start, end, llen, j, ltrim, rtrim;
+    list *list;
+    listNode *ln;
 
     if ((getLongFromObjectOrReply(c, c->argv[2], &start, NULL) != REDIS_OK) ||
         (getLongFromObjectOrReply(c, c->argv[3], &end, NULL) != REDIS_OK)) return;
@@ -461,9 +612,19 @@ void ltrimCommand(redisClient *c) {
     }
 
     /* Remove list elements to perform the trim */
-    if (o->encoding == REDIS_ENCODING_QUICKLIST) {
-        quicklistDelRange(o->ptr,0,ltrim);
-        quicklistDelRange(o->ptr,-rtrim,rtrim);
+    if (o->encoding == REDIS_ENCODING_ZIPLIST) {
+        o->ptr = ziplistDeleteRange(o->ptr,0,ltrim);
+        o->ptr = ziplistDeleteRange(o->ptr,-rtrim,rtrim);
+    } else if (o->encoding == REDIS_ENCODING_LINKEDLIST) {
+        list = o->ptr;
+        for (j = 0; j < ltrim; j++) {
+            ln = listFirst(list);
+            listDelNode(list,ln);
+        }
+        for (j = 0; j < rtrim; j++) {
+            ln = listLast(list);
+            listDelNode(list,ln);
+        }
     } else {
         redisPanic("Unknown list encoding");
     }
@@ -480,9 +641,10 @@ void ltrimCommand(redisClient *c) {
 
 void lremCommand(redisClient *c) {
     robj *subject, *obj;
-    obj = c->argv[3];
+    obj = c->argv[3] = tryObjectEncoding(c->argv[3]);
     long toremove;
     long removed = 0;
+    listTypeEntry entry;
 
     if ((getLongFromObjectOrReply(c, c->argv[2], &toremove, NULL) != REDIS_OK))
         return;
@@ -490,6 +652,10 @@ void lremCommand(redisClient *c) {
     subject = lookupKeyWriteOrReply(c,c->argv[1],shared.czero);
     if (subject == NULL || checkType(c,subject,REDIS_LIST)) return;
 
+    /* Make sure obj is raw when we're dealing with a ziplist */
+    if (subject->encoding == REDIS_ENCODING_ZIPLIST)
+        obj = getDecodedObject(obj);
+
     listTypeIterator *li;
     if (toremove < 0) {
         toremove = -toremove;
@@ -498,10 +664,9 @@ void lremCommand(redisClient *c) {
         li = listTypeInitIterator(subject,0,REDIS_TAIL);
     }
 
-    listTypeEntry entry;
     while (listTypeNext(li,&entry)) {
         if (listTypeEqual(&entry,obj)) {
-            listTypeDelete(li, &entry);
+            listTypeDelete(&entry);
             server.dirty++;
             removed++;
             if (toremove && removed == toremove) break;
@@ -509,10 +674,11 @@ void lremCommand(redisClient *c) {
     }
     listTypeReleaseIterator(li);
 
-    if (listTypeLength(subject) == 0) {
-        dbDelete(c->db,c->argv[1]);
-    }
+    /* Clean up raw encoded object */
+    if (subject->encoding == REDIS_ENCODING_ZIPLIST)
+        decrRefCount(obj);
 
+    if (listTypeLength(subject) == 0) dbDelete(c->db,c->argv[1]);
     addReplyLongLong(c,removed);
     if (removed) signalModifiedKey(c->db,c->argv[1]);
 }
@@ -536,9 +702,7 @@ void lremCommand(redisClient *c) {
 void rpoplpushHandlePush(redisClient *c, robj *dstkey, robj *dstobj, robj *value) {
     /* Create the list if the key does not exist */
     if (!dstobj) {
-        dstobj = createQuicklistObject();
-        quicklistSetOptions(dstobj->ptr, server.list_max_ziplist_size,
-                            server.list_compress_depth);
+        dstobj = createZiplistObject();
         dbAdd(c->db,dstkey,dstobj);
     }
     signalModifiedKey(c->db,dstkey);
@@ -846,9 +1010,7 @@ void handleClientsBlockedOnLists(void) {
                     }
                 }
 
-                if (listTypeLength(o) == 0) {
-                    dbDelete(rl->db,rl->key);
-                }
+                if (listTypeLength(o) == 0) dbDelete(rl->db,rl->key);
                 /* We don't call signalModifiedKey() as it was already called
                  * when an element was pushed on the list. */
             }

src/t_set.c

@@ -33,8 +33,7 @@
  * Set Commands
  *----------------------------------------------------------------------------*/
 
-void sunionDiffGenericCommand(redisClient *c, robj **setkeys, int setnum,
-                              robj *dstkey, int op);
+void sunionDiffGenericCommand(redisClient *c, robj **setkeys, int setnum, robj *dstkey, int op);
 
 /* Factory method to return a set that *can* hold "value". When the object has
  * an integer-encodable value, an intset will be returned. Otherwise a regular
@@ -69,8 +68,7 @@ int setTypeAdd(robj *subject, robj *value) {
 
             /* The set *was* an intset and this value is not integer
              * encodable, so dictAdd should always work. */
-            redisAssertWithInfo(NULL,value,
-                                dictAdd(subject->ptr,value,NULL) == DICT_OK);
+            redisAssertWithInfo(NULL,value,dictAdd(subject->ptr,value,NULL) == DICT_OK);
             incrRefCount(value);
             return 1;
         }
@@ -207,106 +205,6 @@ int setTypeRandomElement(robj *setobj, robj **objele, int64_t *llele) {
     return setobj->encoding;
 }
 
-/* Return a number of random elements from a non empty set.
- *
- * This is a version of setTypeRandomElement() that is modified in order to
- * return multiple entries, using dictGetRandomKeys() and intsetRandomMembers().
- *
- * The elements are stored into 'aux_set' which should be of a set type.
- *
- * The function returns the number of items stored into 'aux_set', that may
- * be less than 'count' if the hash table has less than 'count' elements
- * inside.
- *
- * Note that this function is not suitable when you need a good distribution
- * of the returned items, but only when you need to "sample" a given number
- * of continuous elements to run some kind of algorithm or to produce
- * statistics. However the function is much faster than setTypeRandomElement()
- * at producing N elements, and the elements are guaranteed to be non
- * repeating.
- */
-unsigned long setTypeRandomElements(robj *set, unsigned long count,
-                                    robj *aux_set) {
-    unsigned long set_size;
-    unsigned long elements_to_return = count;
-    unsigned long elements_copied = 0;
-    unsigned long current_element = 0;
-
-    /* Like all setType* functions, we assume good behavior on part of the
-     * caller, so no extra parameter checks are made. */
-
-    /* If the number of elements in the the set is less than the count
-     * requested, just return all of them. */
-    set_size = setTypeSize(set);
-    if (set_size < count) {
-        elements_to_return = set_size;
-    }
-
-    /* TODO: It is definitely faster adding items to the set by directly
-     * handling the Dict or intset inside it, avoiding the constant encoding
-     * checks inside setTypeAdd(). However, We don't want to touch the set
-     * internals in non setType* functions. So, we just call setTypeAdd()
-     * multiple times, but this isn't an optimal solution.
-     * Another option would be to create a bulk-add function:
-     * setTypeAddBulk(). */
-    if (set->encoding == REDIS_ENCODING_HT) {
-        /* Allocate result array */
-        dictEntry **random_elements =
-            zmalloc(sizeof(dictEntry*) * elements_to_return);
-
-        /* Get the random elements */
-        elements_copied =
-            dictGetRandomKeys(set->ptr, random_elements, elements_to_return);
-        redisAssert(elements_copied == elements_to_return);
-
-        /* Put them into the set */
-        for (current_element = 0; current_element < elements_copied;
-             current_element++) {
-
-            /* We get the key and duplicate it, as we know it is a string */
-            setTypeAdd(aux_set,
-                dictGetKey(random_elements[current_element]));
-        }
-
-        zfree(random_elements);
-
-    } else if (set->encoding == REDIS_ENCODING_INTSET) {
-        /* Allocate result array */
-        int64_t *random_elements =
-            zmalloc(sizeof(int64_t) * elements_to_return);
-        robj* element_as_str = NULL;
-
-        elements_copied =
-            intsetRandomMembers((intset*) set->ptr,
-                                random_elements,
-                                elements_to_return);
-
-        redisAssert(elements_copied == elements_to_return);
-
-        /* Put them into the set */
-        for (current_element = 0; current_element < elements_copied;
-             current_element++) {
-
-            element_as_str = createStringObjectFromLongLong(
-                    random_elements[current_element]);
-
-            /* Put the values in the set */
-            setTypeAdd(aux_set,
-                       element_as_str);
-
-            decrRefCount(element_as_str);
-        }
-
-        zfree(random_elements);
-    } else {
-        redisPanic("Unknown set encoding");
-    }
-
-    /* We have a set with random elements. Return the actual elements in
-       the aux_set. */
-    return elements_copied;
-}
-
 unsigned long setTypeSize(robj *subject) {
     if (subject->encoding == REDIS_ENCODING_HT) {
         return dictSize((dict*)subject->ptr);
@@ -337,8 +235,7 @@ void setTypeConvert(robj *setobj, int enc) {
         si = setTypeInitIterator(setobj);
         while (setTypeNext(si,NULL,&intele) != -1) {
             element = createStringObjectFromLongLong(intele);
-            redisAssertWithInfo(NULL,element,
-                                dictAdd(d,element,NULL) == DICT_OK);
+            redisAssertWithInfo(NULL,element,dictAdd(d,element,NULL) == DICT_OK);
         }
         setTypeReleaseIterator(si);
 
@@ -480,147 +377,15 @@ void scardCommand(redisClient *c) {
     addReplyLongLong(c,setTypeSize(o));
 }
 
-/* handle the "SPOP key <count>" variant. The normal version of the
- * command is handled by the spopCommand() function itself. */
-
-void spopWithCountCommand(redisClient *c) {
-    long l;
-    unsigned long count, size;
-    unsigned long elements_returned;
-    robj *set, *aux, *aux_set;
-    int64_t llele;
-
-    /* Get the count argument */
-    if (getLongFromObjectOrReply(c,c->argv[2],&l,NULL) != REDIS_OK) return;
-    if (l >= 0) {
-        count = (unsigned) l;
-    } else {
-        addReply(c,shared.outofrangeerr);
-        return;
-    }
-
-    /* Make sure a key with the name inputted exists, and that it's type is
-     * indeed a set. Otherwise, return nil */
-    if ((set = lookupKeyReadOrReply(c,c->argv[1],shared.emptymultibulk))
-        == NULL || checkType(c,set,REDIS_SET)) return;
-
-    /* If count is zero, serve an empty multibulk ASAP to avoid special
-     * cases later. */
-    if (count == 0) {
-        addReply(c,shared.emptymultibulk);
-        return;
-    }
-
-    /* Get the size of the set. It is always > 0, as empty sets get
-     * deleted.  */
-    size = setTypeSize(set);
-
-    /* Generate an SPOP keyspace notification */
-    notifyKeyspaceEvent(REDIS_NOTIFY_SET,"spop",c->argv[1],c->db->id);
-
-    /* CASE 1:
-     * The number of requested elements is greater than or equal to
-     * the number of elements inside the set: simply return the whole set. */
-    if (count >= size) {
-
-        /* We just return the entire set */
-        sunionDiffGenericCommand(c,c->argv+1,1,NULL,REDIS_OP_UNION);
-
-        /* Delete the set as it is now empty */
-        dbDelete(c->db,c->argv[1]);
-        notifyKeyspaceEvent(REDIS_NOTIFY_GENERIC,"del",c->argv[1],c->db->id);
-
-        /* Replicate/AOF this command as an SREM operation */
-        aux = createStringObject("DEL",3);
-        rewriteClientCommandVector(c,2,aux,c->argv[1]);
-        decrRefCount(aux);
-
-        return;
-    }
-
-    /* CASE 2:
-     * The number of requested elements is less than the number
-     * of elements inside the set. */
-
-    /* We need an auxiliary set. Optimistically, we create a set using an
-     * Intset internally. */
-    aux = createStringObjectFromLongLong(0);
-    aux_set = setTypeCreate(aux);
-    decrRefCount(aux);
-
-    /* Get the count requested of random elements from the set into our
-     * auxiliary set. */
-    elements_returned = setTypeRandomElements(set, count, aux_set);
-    redisAssert(elements_returned == count);
-
-    {
-        setTypeIterator *si;
-        robj *objele;
-        int element_encoding;
-
-        addReplyMultiBulkLen(c, elements_returned);
-
-        /* Replicate/AOF this command as an SREM operation */
-        aux = createStringObject("SREM",4);
-
-        si = setTypeInitIterator(aux_set);
-        while ((element_encoding = setTypeNext(si, &objele, &llele)) != -1) {
-            if (element_encoding == REDIS_ENCODING_HT) {
-
-                addReplyBulk(c, objele);
-
-                /* Replicate/AOF this command as an SREM commands */
-                rewriteClientCommandVector(c, 3, aux, c->argv[1], objele);
-                setTypeRemove(set, objele);
-            }
-            else if (element_encoding == REDIS_ENCODING_INTSET) {
-                /* TODO: setTypeRemove() forces us to convert all of the ints
-                 *       to string... isn't there a nicer way to do this? */
-                objele = createStringObjectFromLongLong(llele);
-                addReplyBulk(c, objele);
-
-                /* Replicate/AOF this command as an SREM commands */
-                rewriteClientCommandVector(c, 3, aux, c->argv[1], objele);
-                setTypeRemove(set, objele);
-
-                /* We created it, we kill it. */
-                decrRefCount(objele);
-            }
-            else {
-                redisPanic("Unknown set encoding");
-            }
-        }
-        setTypeReleaseIterator(si);
-
-        decrRefCount(aux);
-    }
-
-    /* Free the auxiliary set - we need it no more. */
-    decrRefCount(aux_set);
-}
-
 void spopCommand(redisClient *c) {
     robj *set, *ele, *aux;
     int64_t llele;
     int encoding;
 
-    if (c->argc == 3) {
-        spopWithCountCommand(c);
-        return;
-    } else if (c->argc > 3) {
-        addReply(c,shared.syntaxerr);
-        return;
-    }
-
-    /* Make sure a key with the name inputted exists, and that it's type is
-     * indeed a set */
     if ((set = lookupKeyWriteOrReply(c,c->argv[1],shared.nullbulk)) == NULL ||
         checkType(c,set,REDIS_SET)) return;
 
-    /* Get a random element from the set */
     encoding = setTypeRandomElement(set,&ele,&llele);
-
-    /* Remove the element from the set */
     if (encoding == REDIS_ENCODING_INTSET) {
         ele = createStringObjectFromLongLong(llele);
         set->ptr = intsetRemove(set->ptr,llele,NULL);
@@ -628,7 +393,6 @@ void spopCommand(redisClient *c) {
         incrRefCount(ele);
         setTypeRemove(set,ele);
     }
-
     notifyKeyspaceEvent(REDIS_NOTIFY_SET,"spop",c->argv[1],c->db->id);
 
     /* Replicate/AOF this command as an SREM operation */
@@ -637,16 +401,11 @@ void spopCommand(redisClient *c) {
     decrRefCount(ele);
     decrRefCount(aux);
 
-    /* Add the element to the reply */
     addReplyBulk(c,ele);
-
-    /* Delete the set if it's empty */
     if (setTypeSize(set) == 0) {
         dbDelete(c->db,c->argv[1]);
         notifyKeyspaceEvent(REDIS_NOTIFY_GENERIC,"del",c->argv[1],c->db->id);
     }
-
-    /* Set has been modified */
     signalModifiedKey(c->db,c->argv[1]);
     server.dirty++;
 }
@@ -828,8 +587,7 @@ int qsortCompareSetsByRevCardinality(const void *s1, const void *s2) {
     return  (o2 ? setTypeSize(o2) : 0) - (o1 ? setTypeSize(o1) : 0);
 }
 
-void sinterGenericCommand(redisClient *c, robj **setkeys,
-                          unsigned long setnum, robj *dstkey) {
+void sinterGenericCommand(redisClient *c, robj **setkeys, unsigned long setnum, robj *dstkey) {
     robj **sets = zmalloc(sizeof(robj*)*setnum);
     setTypeIterator *si;
     robj *eleobj, *dstset = NULL;
@@ -976,8 +734,7 @@ void sinterstoreCommand(redisClient *c) {
 #define REDIS_OP_DIFF 1
 #define REDIS_OP_INTER 2
 
-void sunionDiffGenericCommand(redisClient *c, robj **setkeys, int setnum,
-                              robj *dstkey, int op) {
+void sunionDiffGenericCommand(redisClient *c, robj **setkeys, int setnum, robj *dstkey, int op) {
     robj **sets = zmalloc(sizeof(robj*)*setnum);
     setTypeIterator *si;
     robj *ele, *dstset = NULL;

src/t_string.c

@@ -397,7 +397,7 @@ void incrbyfloatCommand(redisClient *c) {
         addReplyError(c,"increment would produce NaN or Infinity");
         return;
     }
-    new = createStringObjectFromLongDouble(value,1);
+    new = createStringObjectFromLongDouble(value);
     if (o)
         dbOverwrite(c->db,c->argv[1],new);
     else

src/t_zset.c

@@ -1382,7 +1382,7 @@ void zremrangeGenericCommand(redisClient *c, int rangetype) {
     robj *key = c->argv[1];
     robj *zobj;
     int keyremoved = 0;
-    unsigned long deleted = 0;
+    unsigned long deleted;
     zrangespec range;
     zlexrangespec lexrange;
     long start, end, llen;

src/util.c

@@ -529,10 +529,10 @@ int pathIsBaseName(char *path) {
     return strchr(path,'/') == NULL && strchr(path,'\\') == NULL;
 }
 
-#ifdef REDIS_TEST
+#ifdef UTIL_TEST_MAIN
 #include <assert.h>
 
-static void test_string2ll(void) {
+void test_string2ll(void) {
     char buf[32];
     long long v;
 
@@ -587,7 +587,7 @@ static void test_string2ll(void) {
     assert(string2ll(buf,strlen(buf),&v) == 0);
 }
 
-static void test_string2l(void) {
+void test_string2l(void) {
     char buf[32];
     long v;
 
@@ -636,55 +636,9 @@ static void test_string2l(void) {
 #endif
 }
 
-static void test_ll2string(void) {
-    char buf[32];
-    long long v;
-    int sz;
-
-    v = 0;
-    sz = ll2string(buf, sizeof buf, v);
-    assert(sz == 1);
-    assert(!strcmp(buf, "0"));
-
-    v = -1;
-    sz = ll2string(buf, sizeof buf, v);
-    assert(sz == 2);
-    assert(!strcmp(buf, "-1"));
-
-    v = 99;
-    sz = ll2string(buf, sizeof buf, v);
-    assert(sz == 2);
-    assert(!strcmp(buf, "99"));
-
-    v = -99;
-    sz = ll2string(buf, sizeof buf, v);
-    assert(sz == 3);
-    assert(!strcmp(buf, "-99"));
-
-    v = -2147483648;
-    sz = ll2string(buf, sizeof buf, v);
-    assert(sz == 11);
-    assert(!strcmp(buf, "-2147483648"));
-
-    v = LLONG_MIN;
-    sz = ll2string(buf, sizeof buf, v);
-    assert(sz == 20);
-    assert(!strcmp(buf, "-9223372036854775808"));
-
-    v = LLONG_MAX;
-    sz = ll2string(buf, sizeof buf, v);
-    assert(sz == 19);
-    assert(!strcmp(buf, "9223372036854775807"));
-}
-
-#define UNUSED(x) (void)(x)
-int utilTest(int argc, char **argv) {
-    UNUSED(argc);
-    UNUSED(argv);
-
+int main(int argc, char **argv) {
     test_string2ll();
     test_string2l();
-    test_ll2string();
     return 0;
 }
 #endif

src/util.h

@@ -42,8 +42,4 @@ int d2string(char *buf, size_t len, double value);
 sds getAbsolutePath(char *filename);
 int pathIsBaseName(char *path);
 
-#ifdef REDIS_TEST
-int utilTest(int argc, char **argv);
-#endif
-
 #endif

src/ziplist.c

@@ -143,7 +143,6 @@
 #define ZIPLIST_TAIL_OFFSET(zl) (*((uint32_t*)((zl)+sizeof(uint32_t))))
 #define ZIPLIST_LENGTH(zl)      (*((uint16_t*)((zl)+sizeof(uint32_t)*2)))
 #define ZIPLIST_HEADER_SIZE     (sizeof(uint32_t)*2+sizeof(uint16_t))
-#define ZIPLIST_END_SIZE        (sizeof(uint8_t))
 #define ZIPLIST_ENTRY_HEAD(zl)  ((zl)+ZIPLIST_HEADER_SIZE)
 #define ZIPLIST_ENTRY_TAIL(zl)  ((zl)+intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl)))
 #define ZIPLIST_ENTRY_END(zl)   ((zl)+intrev32ifbe(ZIPLIST_BYTES(zl))-1)
@@ -163,13 +162,6 @@ typedef struct zlentry {
     unsigned char *p;
 } zlentry;
 
-#define ZIPLIST_ENTRY_ZERO(zle) { \
-    (zle)->prevrawlensize = (zle)->prevrawlen = 0; \
-    (zle)->lensize = (zle)->len = (zle)->headersize = 0; \
-    (zle)->encoding = 0; \
-    (zle)->p = NULL; \
-}
-
 /* Extract the encoding from the byte pointed by 'ptr' and set it into
  * 'encoding'. */
 #define ZIP_ENTRY_ENCODING(ptr, encoding) do {  \
@@ -177,8 +169,6 @@ typedef struct zlentry {
     if ((encoding) < ZIP_STR_MASK) (encoding) &= ZIP_STR_MASK; \
 } while(0)
 
-void ziplistRepr(unsigned char *zl);
-
 /* Return bytes needed to store integer encoded by 'encoding' */
 static unsigned int zipIntSize(unsigned char encoding) {
     switch(encoding) {
@@ -414,12 +404,14 @@ static int64_t zipLoadInteger(unsigned char *p, unsigned char encoding) {
 }
 
 /* Return a struct with all information about an entry. */
-static void zipEntry(unsigned char *p, zlentry *e) {
+static zlentry zipEntry(unsigned char *p) {
+    zlentry e;
 
-    ZIP_DECODE_PREVLEN(p, e->prevrawlensize, e->prevrawlen);
-    ZIP_DECODE_LENGTH(p + e->prevrawlensize, e->encoding, e->lensize, e->len);
-    e->headersize = e->prevrawlensize + e->lensize;
-    e->p = p;
+    ZIP_DECODE_PREVLEN(p, e.prevrawlensize, e.prevrawlen);
+    ZIP_DECODE_LENGTH(p + e.prevrawlensize, e.encoding, e.lensize, e.len);
+    e.headersize = e.prevrawlensize + e.lensize;
+    e.p = p;
+    return e;
 }
 
 /* Create a new empty ziplist. */
@@ -468,13 +460,13 @@ static unsigned char *__ziplistCascadeUpdate(unsigned char *zl, unsigned char *p
     zlentry cur, next;
 
     while (p[0] != ZIP_END) {
-        zipEntry(p, &cur);
+        cur = zipEntry(p);
         rawlen = cur.headersize + cur.len;
         rawlensize = zipPrevEncodeLength(NULL,rawlen);
 
         /* Abort if there is no next entry. */
         if (p[rawlen] == ZIP_END) break;
-        zipEntry(p+rawlen, &next);
+        next = zipEntry(p+rawlen);
 
         /* Abort when "prevlen" has not changed. */
         if (next.prevrawlen == rawlen) break;
@@ -529,7 +521,7 @@ static unsigned char *__ziplistDelete(unsigned char *zl, unsigned char *p, unsig
     int nextdiff = 0;
     zlentry first, tail;
 
-    zipEntry(p, &first);
+    first = zipEntry(p);
     for (i = 0; p[0] != ZIP_END && i < num; i++) {
         p += zipRawEntryLength(p);
         deleted++;
@@ -553,7 +545,7 @@ static unsigned char *__ziplistDelete(unsigned char *zl, unsigned char *p, unsig
             /* When the tail contains more than one entry, we need to take
              * "nextdiff" in account as well. Otherwise, a change in the
              * size of prevlen doesn't have an effect on the *tail* offset. */
-            zipEntry(p, &tail);
+            tail = zipEntry(p);
             if (p[tail.headersize+tail.len] != ZIP_END) {
                 ZIPLIST_TAIL_OFFSET(zl) =
                    intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+nextdiff);
@@ -643,7 +635,7 @@ static unsigned char *__ziplistInsert(unsigned char *zl, unsigned char *p, unsig
         /* When the tail contains more than one entry, we need to take
          * "nextdiff" in account as well. Otherwise, a change in the
          * size of prevlen doesn't have an effect on the *tail* offset. */
-        zipEntry(p+reqlen, &tail);
+        tail = zipEntry(p+reqlen);
         if (p[reqlen+tail.headersize+tail.len] != ZIP_END) {
             ZIPLIST_TAIL_OFFSET(zl) =
                 intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+nextdiff);
@@ -673,121 +665,6 @@ static unsigned char *__ziplistInsert(unsigned char *zl, unsigned char *p, unsig
     return zl;
 }
 
-/* Merge ziplists 'first' and 'second' by appending 'second' to 'first'.
- *
- * NOTE: The larger ziplist is reallocated to contain the new merged ziplist.
- * Either 'first' or 'second' can be used for the result.  The parameter not
- * used will be free'd and set to NULL.
- *
- * After calling this function, the input parameters are no longer valid since
- * they are changed and free'd in-place.
- *
- * The result ziplist is the contents of 'first' followed by 'second'.
- *
- * On failure: returns NULL if the merge is impossible.
- * On success: returns the merged ziplist (which is expanded version of either
- * 'first' or 'second', also frees the other unused input ziplist, and sets the
- * input ziplist argument equal to newly reallocated ziplist return value. */
-unsigned char *ziplistMerge(unsigned char **first, unsigned char **second) {
-    /* If any params are null, we can't merge, so NULL. */
-    if (first == NULL || *first == NULL || second == NULL || *second == NULL)
-        return NULL;
-
-    /* Can't merge same list into itself. */
-    if (*first == *second)
-        return NULL;
-
-    size_t first_bytes = intrev32ifbe(ZIPLIST_BYTES(*first));
-    size_t first_len = intrev16ifbe(ZIPLIST_LENGTH(*first));
-
-    size_t second_bytes = intrev32ifbe(ZIPLIST_BYTES(*second));
-    size_t second_len = intrev16ifbe(ZIPLIST_LENGTH(*second));
-
-    int append;
-    unsigned char *source, *target;
-    size_t target_bytes, source_bytes;
-    /* Pick the largest ziplist so we can resize easily in-place.
-     * We must also track if we are now appending or prepending to
-     * the target ziplist. */
-    if (first_len >= second_len) {
-        /* retain first, append second to first. */
-        target = *first;
-        target_bytes = first_bytes;
-        source = *second;
-        source_bytes = second_bytes;
-        append = 1;
-    } else {
-        /* else, retain second, prepend first to second. */
-        target = *second;
-        target_bytes = second_bytes;
-        source = *first;
-        source_bytes = first_bytes;
-        append = 0;
-    }
-
-    /* Calculate final bytes (subtract one pair of metadata) */
-    size_t zlbytes = first_bytes + second_bytes -
-                     ZIPLIST_HEADER_SIZE - ZIPLIST_END_SIZE;
-    size_t zllength = first_len + second_len;
-
-    /* Combined zl length should be limited within UINT16_MAX */
-    zllength = zllength < UINT16_MAX ? zllength : UINT16_MAX;
-
-    /* Save offset positions before we start ripping memory apart. */
-    size_t first_offset = intrev32ifbe(ZIPLIST_TAIL_OFFSET(*first));
-    size_t second_offset = intrev32ifbe(ZIPLIST_TAIL_OFFSET(*second));
-
-    /* Extend target to new zlbytes then append or prepend source. */
-    target = zrealloc(target, zlbytes);
-    if (append) {
-        /* append == appending to target */
-        /* Copy source after target (copying over original [END]):
-         *   [TARGET - END, SOURCE - HEADER] */
-        memcpy(target + target_bytes - ZIPLIST_END_SIZE,
-               source + ZIPLIST_HEADER_SIZE,
-               source_bytes - ZIPLIST_HEADER_SIZE);
-    } else {
-        /* !append == prepending to target */
-        /* Move target *contents* exactly size of (source - [END]),
-         * then copy source into vacataed space (source - [END]):
-         *   [SOURCE - END, TARGET - HEADER] */
-        memmove(target + source_bytes - ZIPLIST_END_SIZE,
-                target + ZIPLIST_HEADER_SIZE,
-                target_bytes - ZIPLIST_HEADER_SIZE);
-        memcpy(target, source, source_bytes - ZIPLIST_END_SIZE);
-    }
-
-    /* Update header metadata. */
-    ZIPLIST_BYTES(target) = intrev32ifbe(zlbytes);
-    ZIPLIST_LENGTH(target) = intrev16ifbe(zllength);
-    /* New tail offset is:
-     *   + N bytes of first ziplist
-     *   - 1 byte for [END] of first ziplist
-     *   + M bytes for the offset of the original tail of the second ziplist
-     *   - J bytes for HEADER because second_offset keeps no header. */
-    ZIPLIST_TAIL_OFFSET(target) = intrev32ifbe(
-                                   (first_bytes - ZIPLIST_END_SIZE) +
-                                   (second_offset - ZIPLIST_HEADER_SIZE));
-
-    /* __ziplistCascadeUpdate just fixes the prev length values until it finds a
-     * correct prev length value (then it assumes the rest of the list is okay).
-     * We tell CascadeUpdate to start at the first ziplist's tail element to fix
-     * the merge seam. */
-    target = __ziplistCascadeUpdate(target, target+first_offset);
-
-    /* Now free and NULL out what we didn't realloc */
-    if (append) {
-        zfree(*second);
-        *second = NULL;
-        *first = target;
-    } else {
-        zfree(*first);
-        *first = NULL;
-        *second = target;
-    }
-    return target;
-}
-
 unsigned char *ziplistPush(unsigned char *zl, unsigned char *s, unsigned int slen, int where) {
     unsigned char *p;
     p = (where == ZIPLIST_HEAD) ? ZIPLIST_ENTRY_HEAD(zl) : ZIPLIST_ENTRY_END(zl);
@@ -871,7 +748,7 @@ unsigned int ziplistGet(unsigned char *p, unsigned char **sstr, unsigned int *sl
     if (p == NULL || p[0] == ZIP_END) return 0;
     if (sstr) *sstr = NULL;
 
-    zipEntry(p, &entry);
+    entry = zipEntry(p);
     if (ZIP_IS_STR(entry.encoding)) {
         if (sstr) {
             *slen = entry.len;
@@ -906,7 +783,7 @@ unsigned char *ziplistDelete(unsigned char *zl, unsigned char **p) {
 }
 
 /* Delete a range of entries from the ziplist. */
-unsigned char *ziplistDeleteRange(unsigned char *zl, int index, unsigned int num) {
+unsigned char *ziplistDeleteRange(unsigned char *zl, unsigned int index, unsigned int num) {
     unsigned char *p = ziplistIndex(zl,index);
     return (p == NULL) ? zl : __ziplistDelete(zl,p,num);
 }
@@ -919,7 +796,7 @@ unsigned int ziplistCompare(unsigned char *p, unsigned char *sstr, unsigned int
     long long zval, sval;
     if (p[0] == ZIP_END) return 0;
 
-    zipEntry(p, &entry);
+    entry = zipEntry(p);
     if (ZIP_IS_STR(entry.encoding)) {
         /* Raw compare */
         if (entry.len == slen) {
@@ -1036,7 +913,7 @@ void ziplistRepr(unsigned char *zl) {
         intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl)));
     p = ZIPLIST_ENTRY_HEAD(zl);
     while(*p != ZIP_END) {
-        zipEntry(p, &entry);
+        entry = zipEntry(p);
         printf(
             "{"
                 "addr 0x%08lx, "
@@ -1075,14 +952,14 @@ void ziplistRepr(unsigned char *zl) {
     printf("{end}\n\n");
 }
 
-#ifdef REDIS_TEST
+#ifdef ZIPLIST_TEST_MAIN
 #include <sys/time.h>
 #include "adlist.h"
 #include "sds.h"
 
 #define debug(f, ...) { if (DEBUG) printf(f, __VA_ARGS__); }
 
-static unsigned char *createList() {
+unsigned char *createList() {
     unsigned char *zl = ziplistNew();
     zl = ziplistPush(zl, (unsigned char*)"foo", 3, ZIPLIST_TAIL);
     zl = ziplistPush(zl, (unsigned char*)"quux", 4, ZIPLIST_TAIL);
@@ -1091,7 +968,7 @@ static unsigned char *createList() {
     return zl;
 }
 
-static unsigned char *createIntList() {
+unsigned char *createIntList() {
     unsigned char *zl = ziplistNew();
     char buf[32];
 
@@ -1110,13 +987,13 @@ static unsigned char *createIntList() {
     return zl;
 }
 
-static long long usec(void) {
+long long usec(void) {
     struct timeval tv;
     gettimeofday(&tv,NULL);
     return (((long long)tv.tv_sec)*1000000)+tv.tv_usec;
 }
 
-static void stress(int pos, int num, int maxsize, int dnum) {
+void stress(int pos, int num, int maxsize, int dnum) {
     int i,j,k;
     unsigned char *zl;
     char posstr[2][5] = { "HEAD", "TAIL" };
@@ -1139,7 +1016,7 @@ static void stress(int pos, int num, int maxsize, int dnum) {
     }
 }
 
-static unsigned char *pop(unsigned char *zl, int where) {
+void pop(unsigned char *zl, int where) {
     unsigned char *p, *vstr;
     unsigned int vlen;
     long long vlong;
@@ -1151,22 +1028,20 @@ static unsigned char *pop(unsigned char *zl, int where) {
         else
             printf("Pop tail: ");
 
-        if (vstr) {
+        if (vstr)
             if (vlen && fwrite(vstr,vlen,1,stdout) == 0) perror("fwrite");
-        }
-        else {
+        else
             printf("%lld", vlong);
-        }
 
         printf("\n");
-        return ziplistDelete(zl,&p);
+        ziplistDeleteRange(zl,-1,1);
     } else {
         printf("ERROR: Could not pop\n");
         exit(1);
     }
 }
 
-static int randstring(char *target, unsigned int min, unsigned int max) {
+int randstring(char *target, unsigned int min, unsigned int max) {
     int p = 0;
     int len = min+rand()%(max-min+1);
     int minval, maxval;
@@ -1192,24 +1067,23 @@ static int randstring(char *target, unsigned int min, unsigned int max) {
     return len;
 }
 
-static void verify(unsigned char *zl, zlentry *e) {
+void verify(unsigned char *zl, zlentry *e) {
+    int i;
     int len = ziplistLen(zl);
     zlentry _e;
 
-    ZIPLIST_ENTRY_ZERO(&_e);
-
-    for (int i = 0; i < len; i++) {
+    for (i = 0; i < len; i++) {
         memset(&e[i], 0, sizeof(zlentry));
-        zipEntry(ziplistIndex(zl, i), &e[i]);
+        e[i] = zipEntry(ziplistIndex(zl, i));
 
         memset(&_e, 0, sizeof(zlentry));
-        zipEntry(ziplistIndex(zl, -len+i), &_e);
+        _e = zipEntry(ziplistIndex(zl, -len+i));
 
         assert(memcmp(&e[i], &_e, sizeof(zlentry)) == 0);
     }
 }
 
-int ziplistTest(int argc, char **argv) {
+int main(int argc, char **argv) {
     unsigned char *zl, *p;
     unsigned char *entry;
     unsigned int elen;
@@ -1222,25 +1096,21 @@ int ziplistTest(int argc, char **argv) {
     zl = createIntList();
     ziplistRepr(zl);
 
-    zfree(zl);
-
     zl = createList();
     ziplistRepr(zl);
 
-    zl = pop(zl,ZIPLIST_TAIL);
+    pop(zl,ZIPLIST_TAIL);
     ziplistRepr(zl);
 
-    zl = pop(zl,ZIPLIST_HEAD);
+    pop(zl,ZIPLIST_HEAD);
     ziplistRepr(zl);
 
-    zl = pop(zl,ZIPLIST_TAIL);
+    pop(zl,ZIPLIST_TAIL);
     ziplistRepr(zl);
 
-    zl = pop(zl,ZIPLIST_TAIL);
+    pop(zl,ZIPLIST_TAIL);
     ziplistRepr(zl);
 
-    zfree(zl);
-
     printf("Get element at index 3:\n");
     {
         zl = createList();
@@ -1256,7 +1126,6 @@ int ziplistTest(int argc, char **argv) {
             printf("%lld\n", value);
         }
         printf("\n");
-        zfree(zl);
     }
 
     printf("Get element at index 4 (out of range):\n");
@@ -1270,7 +1139,6 @@ int ziplistTest(int argc, char **argv) {
             return 1;
         }
         printf("\n");
-        zfree(zl);
     }
 
     printf("Get element at index -1 (last element):\n");
@@ -1288,7 +1156,6 @@ int ziplistTest(int argc, char **argv) {
             printf("%lld\n", value);
         }
         printf("\n");
-        zfree(zl);
     }
 
     printf("Get element at index -4 (first element):\n");
@@ -1306,7 +1173,6 @@ int ziplistTest(int argc, char **argv) {
             printf("%lld\n", value);
         }
         printf("\n");
-        zfree(zl);
     }
 
     printf("Get element at index -5 (reverse out of range):\n");
@@ -1320,7 +1186,6 @@ int ziplistTest(int argc, char **argv) {
             return 1;
         }
         printf("\n");
-        zfree(zl);
     }
 
     printf("Iterate list from 0 to end:\n");
@@ -1338,7 +1203,6 @@ int ziplistTest(int argc, char **argv) {
             printf("\n");
         }
         printf("\n");
-        zfree(zl);
     }
 
     printf("Iterate list from 1 to end:\n");
@@ -1356,7 +1220,6 @@ int ziplistTest(int argc, char **argv) {
             printf("\n");
         }
         printf("\n");
-        zfree(zl);
     }
 
     printf("Iterate list from 2 to end:\n");
@@ -1374,7 +1237,6 @@ int ziplistTest(int argc, char **argv) {
             printf("\n");
         }
         printf("\n");
-        zfree(zl);
     }
 
     printf("Iterate starting out of range:\n");
@@ -1387,7 +1249,6 @@ int ziplistTest(int argc, char **argv) {
             printf("ERROR\n");
         }
         printf("\n");
-        zfree(zl);
     }
 
     printf("Iterate from back to front:\n");
@@ -1405,7 +1266,6 @@ int ziplistTest(int argc, char **argv) {
             printf("\n");
         }
         printf("\n");
-        zfree(zl);
     }
 
     printf("Iterate from back to front, deleting all items:\n");
@@ -1424,7 +1284,6 @@ int ziplistTest(int argc, char **argv) {
             printf("\n");
         }
         printf("\n");
-        zfree(zl);
     }
 
     printf("Delete inclusive range 0,0:\n");
@@ -1432,7 +1291,6 @@ int ziplistTest(int argc, char **argv) {
         zl = createList();
         zl = ziplistDeleteRange(zl, 0, 1);
         ziplistRepr(zl);
-        zfree(zl);
     }
 
     printf("Delete inclusive range 0,1:\n");
@@ -1440,7 +1298,6 @@ int ziplistTest(int argc, char **argv) {
         zl = createList();
         zl = ziplistDeleteRange(zl, 0, 2);
         ziplistRepr(zl);
-        zfree(zl);
     }
 
     printf("Delete inclusive range 1,2:\n");
@@ -1448,7 +1305,6 @@ int ziplistTest(int argc, char **argv) {
         zl = createList();
         zl = ziplistDeleteRange(zl, 1, 2);
         ziplistRepr(zl);
-        zfree(zl);
     }
 
     printf("Delete with start index out of range:\n");
@@ -1456,7 +1312,6 @@ int ziplistTest(int argc, char **argv) {
         zl = createList();
         zl = ziplistDeleteRange(zl, 5, 1);
         ziplistRepr(zl);
-        zfree(zl);
     }
 
     printf("Delete with num overflow:\n");
@@ -1464,7 +1319,6 @@ int ziplistTest(int argc, char **argv) {
         zl = createList();
         zl = ziplistDeleteRange(zl, 1, 5);
         ziplistRepr(zl);
-        zfree(zl);
     }
 
     printf("Delete foo while iterating:\n");
@@ -1489,12 +1343,11 @@ int ziplistTest(int argc, char **argv) {
         }
         printf("\n");
         ziplistRepr(zl);
-        zfree(zl);
     }
 
     printf("Regression test for >255 byte strings:\n");
     {
-        char v1[257] = {0}, v2[257] = {0};
+        char v1[257],v2[257];
         memset(v1,'x',256);
         memset(v2,'y',256);
         zl = ziplistNew();
@@ -1509,15 +1362,13 @@ int ziplistTest(int argc, char **argv) {
         assert(ziplistGet(p,&entry,&elen,&value));
         assert(strncmp(v2,(char*)entry,elen) == 0);
         printf("SUCCESS\n\n");
-        zfree(zl);
     }
 
     printf("Regression test deleting next to last entries:\n");
     {
-        char v[3][257] = {{0}};
-        zlentry e[3] = {{.prevrawlensize = 0, .prevrawlen = 0, .lensize = 0,
-                         .len = 0, .headersize = 0, .encoding = 0, .p = NULL}};
-        size_t i;
+        char v[3][257];
+        zlentry e[3];
+        int i;
 
         for (i = 0; i < (sizeof(v)/sizeof(v[0])); i++) {
             memset(v[i], 'a' + i, sizeof(v[0]));
@@ -1548,7 +1399,6 @@ int ziplistTest(int argc, char **argv) {
         assert(e[1].prevrawlensize == 5);
 
         printf("SUCCESS\n\n");
-        zfree(zl);
     }
 
     printf("Create long list and check indices:\n");
@@ -1570,7 +1420,6 @@ int ziplistTest(int argc, char **argv) {
             assert(999-i == value);
         }
         printf("SUCCESS\n\n");
-        zfree(zl);
     }
 
     printf("Compare strings with ziplist entries:\n");
@@ -1596,82 +1445,6 @@ int ziplistTest(int argc, char **argv) {
             return 1;
         }
         printf("SUCCESS\n\n");
-        zfree(zl);
-    }
-
-    printf("Merge test:\n");
-    {
-        /* create list gives us: [hello, foo, quux, 1024] */
-        zl = createList();
-        unsigned char *zl2 = createList();
-
-        unsigned char *zl3 = ziplistNew();
-        unsigned char *zl4 = ziplistNew();
-
-        if (ziplistMerge(&zl4, &zl4)) {
-            printf("ERROR: Allowed merging of one ziplist into itself.\n");
-            return 1;
-        }
-
-        /* Merge two empty ziplists, get empty result back. */
-        zl4 = ziplistMerge(&zl3, &zl4);
-        ziplistRepr(zl4);
-        if (ziplistLen(zl4)) {
-            printf("ERROR: Merging two empty ziplists created entries.\n");
-            return 1;
-        }
-        zfree(zl4);
-
-        zl2 = ziplistMerge(&zl, &zl2);
-        /* merge gives us: [hello, foo, quux, 1024, hello, foo, quux, 1024] */
-        ziplistRepr(zl2);
-
-        if (ziplistLen(zl2) != 8) {
-            printf("ERROR: Merged length not 8, but: %u\n", ziplistLen(zl2));
-            return 1;
-        }
-
-        p = ziplistIndex(zl2,0);
-        if (!ziplistCompare(p,(unsigned char*)"hello",5)) {
-            printf("ERROR: not \"hello\"\n");
-            return 1;
-        }
-        if (ziplistCompare(p,(unsigned char*)"hella",5)) {
-            printf("ERROR: \"hella\"\n");
-            return 1;
-        }
-
-        p = ziplistIndex(zl2,3);
-        if (!ziplistCompare(p,(unsigned char*)"1024",4)) {
-            printf("ERROR: not \"1024\"\n");
-            return 1;
-        }
-        if (ziplistCompare(p,(unsigned char*)"1025",4)) {
-            printf("ERROR: \"1025\"\n");
-            return 1;
-        }
-
-        p = ziplistIndex(zl2,4);
-        if (!ziplistCompare(p,(unsigned char*)"hello",5)) {
-            printf("ERROR: not \"hello\"\n");
-            return 1;
-        }
-        if (ziplistCompare(p,(unsigned char*)"hella",5)) {
-            printf("ERROR: \"hella\"\n");
-            return 1;
-        }
-
-        p = ziplistIndex(zl2,7);
-        if (!ziplistCompare(p,(unsigned char*)"1024",4)) {
-            printf("ERROR: not \"1024\"\n");
-            return 1;
-        }
-        if (ziplistCompare(p,(unsigned char*)"1025",4)) {
-            printf("ERROR: \"1025\"\n");
-            return 1;
-        }
-        printf("SUCCESS\n\n");
-        zfree(zl);
     }
 
     printf("Stress with random payloads of different encoding:\n");
@@ -1691,7 +1464,7 @@ int ziplistTest(int argc, char **argv) {
         for (i = 0; i < 20000; i++) {
             zl = ziplistNew();
             ref = listCreate();
-            listSetFreeMethod(ref,(void (*)(void*))sdsfree);
+            listSetFreeMethod(ref,sdsfree);
             len = rand() % 256;
 
             /* Create lists */
@@ -1759,4 +1532,5 @@ int ziplistTest(int argc, char **argv) {
 
     return 0;
 }
+
 #endif

src/ziplist.h

@@ -32,7 +32,6 @@
 #define ZIPLIST_TAIL 1
 
 unsigned char *ziplistNew(void);
-unsigned char *ziplistMerge(unsigned char **first, unsigned char **second);
 unsigned char *ziplistPush(unsigned char *zl, unsigned char *s, unsigned int slen, int where);
 unsigned char *ziplistIndex(unsigned char *zl, int index);
 unsigned char *ziplistNext(unsigned char *zl, unsigned char *p);
@@ -40,12 +39,8 @@ unsigned char *ziplistPrev(unsigned char *zl, unsigned char *p);
 unsigned int ziplistGet(unsigned char *p, unsigned char **sval, unsigned int *slen, long long *lval);
 unsigned char *ziplistInsert(unsigned char *zl, unsigned char *p, unsigned char *s, unsigned int slen);
 unsigned char *ziplistDelete(unsigned char *zl, unsigned char **p);
-unsigned char *ziplistDeleteRange(unsigned char *zl, int index, unsigned int num);
+unsigned char *ziplistDeleteRange(unsigned char *zl, unsigned int index, unsigned int num);
 unsigned int ziplistCompare(unsigned char *p, unsigned char *s, unsigned int slen);
 unsigned char *ziplistFind(unsigned char *p, unsigned char *vstr, unsigned int vlen, unsigned int skip);
 unsigned int ziplistLen(unsigned char *zl);
 size_t ziplistBlobLen(unsigned char *zl);
-
-#ifdef REDIS_TEST
-int ziplistTest(int argc, char *argv[]);
-#endif

src/zipmap.c

@@ -51,9 +51,10 @@
  * <len> is the length of the following string (key or value).
  * <len> lengths are encoded in a single value or in a 5 bytes value.
  * If the first byte value (as an unsigned 8 bit value) is between 0 and
- * 253, it's a single-byte length. If it is 254 then a four bytes unsigned
+ * 252, it's a single-byte length. If it is 253 then a four bytes unsigned
  * integer follows (in the host byte ordering). A value of 255 is used to
- * signal the end of the hash.
+ * signal the end of the hash. The special value 254 is used to mark
+ * empty space that can be used to add new key/value pairs.
  *
  * <free> is the number of free unused bytes after the string, resulting
  * from modification of values associated to a key. For instance if "foo"
@@ -370,8 +371,8 @@ size_t zipmapBlobLen(unsigned char *zm) {
     return totlen;
 }
 
-#ifdef REDIS_TEST
-static void zipmapRepr(unsigned char *p) {
+#ifdef ZIPMAP_TEST_MAIN
+void zipmapRepr(unsigned char *p) {
     unsigned int l;
 
     printf("{status %u}",*p++);
@@ -404,13 +405,9 @@ static void zipmapRepr(unsigned char *p) {
     printf("\n");
 }
 
-#define UNUSED(x) (void)(x)
-int zipmapTest(int argc, char *argv[]) {
+int main(void) {
     unsigned char *zm;
 
-    UNUSED(argc);
-    UNUSED(argv);
-
     zm = zipmapNew();
 
     zm = zipmapSet(zm,(unsigned char*) "name",4, (unsigned char*) "foo",3,NULL);

src/zipmap.h

@@ -46,8 +46,4 @@ unsigned int zipmapLen(unsigned char *zm);
 size_t zipmapBlobLen(unsigned char *zm);
 void zipmapRepr(unsigned char *p);
 
-#ifdef REDIS_TEST
-int zipmapTest(int argc, char *argv[]);
-#endif
-
 #endif

src/zmalloc.c

@@ -356,7 +356,7 @@ size_t zmalloc_get_smap_bytes_by_field(char *field) {
 }
 #else
 size_t zmalloc_get_smap_bytes_by_field(char *field) {
-    ((void) field);
+    REDIS_NOTUSED(field);
     return 0;
 }
 #endif
@@ -364,60 +364,3 @@ size_t zmalloc_get_smap_bytes_by_field(char *field) {
 size_t zmalloc_get_private_dirty(void) {
     return zmalloc_get_smap_bytes_by_field("Private_Dirty:");
 }
-
-/* Returns the size of physical memory (RAM) in bytes.
- * It looks ugly, but this is the cleanest way to achive cross platform results.
- * Cleaned up from:
- *
- * http://nadeausoftware.com/articles/2012/09/c_c_tip_how_get_physical_memory_size_system
- *
- * Note that this function:
- * 1) Was released under the following CC attribution license:
- *    http://creativecommons.org/licenses/by/3.0/deed.en_US.
- * 2) Was originally implemented by David Robert Nadeau.
- * 3) Was modified for Redis by Matt Stancliff.
- * 4) This note exists in order to comply with the original license.
- */
-size_t zmalloc_get_memory_size(void) {
-#if defined(__unix__) || defined(__unix) || defined(unix) || \
-    (defined(__APPLE__) && defined(__MACH__))
-#if defined(CTL_HW) && (defined(HW_MEMSIZE) || defined(HW_PHYSMEM64))
-    int mib[2];
-    mib[0] = CTL_HW;
-#if defined(HW_MEMSIZE)
-    mib[1] = HW_MEMSIZE;            /* OSX. --------------------- */
-#elif defined(HW_PHYSMEM64)
-    mib[1] = HW_PHYSMEM64;          /* NetBSD, OpenBSD. --------- */
-#endif
-    int64_t size = 0;               /* 64-bit */
-    size_t len = sizeof(size);
-    if (sysctl( mib, 2, &size, &len, NULL, 0) == 0)
-        return (size_t)size;
-    return 0L;          /* Failed? */
-
-#elif defined(_SC_PHYS_PAGES) && defined(_SC_PAGESIZE)
-    /* FreeBSD, Linux, OpenBSD, and Solaris. -------------------- */
-    return (size_t)sysconf(_SC_PHYS_PAGES) * (size_t)sysconf(_SC_PAGESIZE);
-
-#elif defined(CTL_HW) && (defined(HW_PHYSMEM) || defined(HW_REALMEM))
-    /* DragonFly BSD, FreeBSD, NetBSD, OpenBSD, and OSX. -------- */
-    int mib[2];
-    mib[0] = CTL_HW;
-#if defined(HW_REALMEM)
-    mib[1] = HW_REALMEM;        /* FreeBSD. ----------------- */
-#elif defined(HW_PYSMEM)
-    mib[1] = HW_PHYSMEM;        /* Others. ------------------ */
-#endif
-    unsigned int size = 0;      /* 32-bit */
-    size_t len = sizeof(size);
-    if (sysctl(mib, 2, &size, &len, NULL, 0) == 0)
-        return (size_t)size;
-    return 0L;          /* Failed? */
-#endif /* sysctl and sysconf variants */
-
-#else
-    return 0L;          /* Unknown OS. */
-#endif
-}
-
-

src/zmalloc.h

@@ -77,7 +77,6 @@ float zmalloc_get_fragmentation_ratio(size_t rss);
 size_t zmalloc_get_rss(void);
 size_t zmalloc_get_private_dirty(void);
 size_t zmalloc_get_smap_bytes_by_field(char *field);
-size_t zmalloc_get_memory_size(void);
 void zlibc_free(void *ptr);
 
 #ifndef HAVE_MALLOC_SIZE

tests/integration/aof.tcl

@@ -204,30 +204,6 @@ tags {"aof"} {
         }
     }
 
-    ## Test that SPOP with <count> (that modifies the client's argc/argv) is correctly free'd
-    create_aof {
-        append_to_aof [formatCommand sadd set foo]
-        append_to_aof [formatCommand sadd set bar]
-        append_to_aof [formatCommand sadd set gah]
-        append_to_aof [formatCommand spop set 2]
-    }
-
-    start_server_aof [list dir $server_path] {
-        test "AOF+SPOP: Server should have been started" {
-            assert_equal 1 [is_alive $srv]
-        }
-
-        test "AOF+SPOP: Set should have 1 member" {
-            set client [redis [dict get $srv host] [dict get $srv port]]
-            wait_for_condition 50 100 {
-                [catch {$client ping} e] == 0
-            } else {
-                fail "Loading DB is taking too much time."
-            }
-            assert_equal 1 [$client scard set]
-        }
-    }
-
     ## Test that EXPIREAT is loaded correctly
     create_aof {
         append_to_aof [formatCommand rpush list foo]

tests/integration/replication.tcl

@@ -118,8 +118,7 @@ foreach dl {no yes} {
                         [lindex $slaves 1] slaveof $master_host $master_port
                         [lindex $slaves 2] slaveof $master_host $master_port
 
-                        # Wait for all the three slaves to reach the "online"
-                        # state from the POV of the master.
+                        # Wait for all the three slaves to reach the "online" state
                         set retry 500
                         while {$retry} {
                             set info [r -3 info]
@@ -134,17 +133,6 @@ foreach dl {no yes} {
                             error "assertion:Slaves not correctly synchronized"
                         }
 
-                        # Wait that slaves acknowledge they are online so
-                        # we are sure that DBSIZE and DEBUG DIGEST will not
-                        # fail because of timing issues.
-                        wait_for_condition 500 100 {
-                            [lindex [[lindex $slaves 0] role] 3] eq {connected} &&
-                            [lindex [[lindex $slaves 1] role] 3] eq {connected} &&
-                            [lindex [[lindex $slaves 2] role] 3] eq {connected}
-                        } else {
-                            fail "Slaves still not connected after some time"
-                        }
-
                         # Stop the write load
                         stop_write_load $load_handle0
                         stop_write_load $load_handle1
@@ -152,8 +140,16 @@ foreach dl {no yes} {
                         stop_write_load $load_handle3
                         stop_write_load $load_handle4
 
-                        # Make sure that slaves and master have same
-                        # number of keys
+                        # Wait that slaves exit the "loading" state
+                        wait_for_condition 500 100 {
+                            ![string match {*loading:1*} [[lindex $slaves 0] info]] &&
+                            ![string match {*loading:1*} [[lindex $slaves 1] info]] &&
+                            ![string match {*loading:1*} [[lindex $slaves 2] info]]
+                        } else {
+                            fail "Slaves still loading data after too much time"
+                        }
+
+                        # Make sure that slaves and master have same number of keys
                         wait_for_condition 500 100 {
                             [$master dbsize] == [[lindex $slaves 0] dbsize] &&
                             [$master dbsize] == [[lindex $slaves 1] dbsize] &&

tests/support/server.tcl

@@ -70,9 +70,6 @@ proc kill_server config {
     if {$::valgrind} {
         check_valgrind_errors [dict get $config stderr]
     }
-
-    # Remove this pid from the set of active pids in the test server.
-    send_data_packet $::test_server_fd server-killed $pid
 }
 
 proc is_alive config {
@@ -207,14 +204,11 @@ proc start_server {options {code undefined}} {
     set stderr [format "%s/%s" [dict get $config "dir"] "stderr"]
 
     if {$::valgrind} {
-        set pid [exec valgrind --suppressions=src/valgrind.sup --show-reachable=no --show-possibly-lost=no --leak-check=full src/redis-server $config_file > $stdout 2> $stderr &]
+        exec valgrind --suppressions=src/valgrind.sup --show-reachable=no --show-possibly-lost=no --leak-check=full src/redis-server $config_file > $stdout 2> $stderr &
     } else {
-        set pid [exec src/redis-server $config_file > $stdout 2> $stderr &]
+        exec src/redis-server $config_file > $stdout 2> $stderr &
     }
 
-    # Tell the test server about this new instance.
-    send_data_packet $::test_server_fd server-spawned $pid
-
     # check that the server actually started
     # ugly but tries to be as fast as possible...
     if {$::valgrind} {set retrynum 1000} else {set retrynum 100}
@@ -240,9 +234,9 @@ proc start_server {options {code undefined}} {
         return
     }
 
-    # Wait for actual startup
-    while {![info exists _pid]} {
-        regexp {PID:\s(\d+)} [exec cat $stdout] _ _pid
+    # find out the pid
+    while {![info exists pid]} {
+        regexp {PID:\s(\d+)} [exec cat $stdout] _ pid
         after 100
     }
 

tests/support/test.tcl

@@ -19,12 +19,9 @@ proc assert_match {pattern value} {
     }
 }
 
-proc assert_equal {expected value {detail ""}} {
+proc assert_equal {expected value} {
     if {$expected ne $value} {
-        if {$detail ne ""} {
-            set detail " (detail: $detail)"
-        }
-        error "assertion:Expected '$value' to be equal to '$expected'$detail"
+        error "assertion:Expected '$value' to be equal to '$expected'"
     }
 }
 

tests/test_helper.tcl

@@ -65,9 +65,6 @@ set ::file ""; # If set, runs only the tests in this comma separated list
 set ::curfile ""; # Hold the filename of the current suite
 set ::accurate 0; # If true runs fuzz tests with more iterations
 set ::force_failure 0
-set ::timeout 600; # 10 minutes without progresses will quit the test.
-set ::last_progress [clock seconds]
-set ::active_servers {} ; # Pids of active Redis instances.
 
 # Set to 1 when we are running in client mode. The Redis test uses a
 # server-client model to run tests simultaneously. The server instance
@@ -203,19 +200,11 @@ proc test_server_main {} {
     vwait forever
 }
 
-# This function gets called 10 times per second.
+# This function gets called 10 times per second, for now does nothing but
+# may be used in the future in order to detect test clients taking too much
+# time to execute the task.
 proc test_server_cron {} {
-    set elapsed [expr {[clock seconds]-$::last_progress}]
-
-    if {$elapsed > $::timeout} {
-        set err "\[[colorstr red TIMEOUT]\]: clients state report follows."
-        puts $err
-        show_clients_state
-        kill_clients
-        force_kill_all_servers
-        the_end
-    }
-
+    # Do some work here.
     after 100 test_server_cron
 }
 
@@ -241,8 +230,6 @@ proc read_from_test_client fd {
     set bytes [gets $fd]
     set payload [read $fd $bytes]
     foreach {status data} $payload break
-    set ::last_progress [clock seconds]
-
     if {$status eq {ready}} {
         if {!$::quiet} {
             puts "\[$status\]: $data"
@@ -269,15 +256,12 @@ proc read_from_test_client fd {
         set ::active_clients_task($fd) "(ERR) $data"
     } elseif {$status eq {exception}} {
         puts "\[[colorstr red $status]\]: $data"
-        kill_clients
-        force_kill_all_servers
+        foreach p $::clients_pids {
+            catch {exec kill -9 $p}
+        }
         exit 1
     } elseif {$status eq {testing}} {
         set ::active_clients_task($fd) "(IN PROGRESS) $data"
-    } elseif {$status eq {server-spawned}} {
-        lappend ::active_servers $data
-    } elseif {$status eq {server-killed}} {
-        set ::active_servers [lsearch -all -inline -not -exact $::active_servers $data]
     } else {
         if {!$::quiet} {
             puts "\[$status\]: $data"
@@ -285,31 +269,6 @@ proc read_from_test_client fd {
     }
 }
 
-proc show_clients_state {} {
-    # The following loop is only useful for debugging tests that may
-    # enter an infinite loop. Commented out normally.
-    foreach x $::active_clients {
-        if {[info exist ::active_clients_task($x)]} {
-            puts "$x => $::active_clients_task($x)"
-        } else {
-            puts "$x => ???"
-        }
-    }
-}
-
-proc kill_clients {} {
-    foreach p $::clients_pids {
-        catch {exec kill $p}
-    }
-}
-
-proc force_kill_all_servers {} {
-    foreach p $::active_servers {
-        puts "Killing still running Redis server $p"
-        catch {exec kill -9 $p}
-    }
-}
-
 # A new client is idle. Remove it from the list of active clients and
 # if there are still test units to run, launch them.
 proc signal_idle_client fd {
@@ -317,7 +276,17 @@ proc signal_idle_client fd {
     set ::active_clients \
         [lsearch -all -inline -not -exact $::active_clients $fd]
 
-    if 0 {show_clients_state}
+    if 0 {
+        # The following loop is only useful for debugging tests that may
+        # enter an infinite loop. Commented out normally.
+        foreach x $::active_clients {
+            if {[info exist ::active_clients_task($x)]} {
+                puts "$x => $::active_clients_task($x)"
+            } else {
+                puts "$x => ???"
+            }
+        }
+    }
 
     # New unit to process?
     if {$::next_test != [llength $::all_tests]} {
@@ -392,8 +361,7 @@ proc print_help_screen {} {
         "--quiet            Don't show individual tests."
         "--single <unit>    Just execute the specified unit (see next option)."
         "--list-tests       List all the available test units."
-        "--clients <num>    Number of test clients (default 16)."
-        "--timeout <sec>    Test timeout in seconds (default 10 min)."
+        "--clients <num>    Number of test clients (16)."
         "--force-failure    Force the execution of a test that always fails."
         "--help             Print this help screen."
     } "\n"]
@@ -442,9 +410,6 @@ for {set j 0} {$j < [llength $argv]} {incr j} {
     } elseif {$opt eq {--clients}} {
         set ::numclients $arg
         incr j
-    } elseif {$opt eq {--timeout}} {
-        set ::timeout $arg
-        incr j
     } elseif {$opt eq {--help}} {
         print_help_screen
         exit 0

tests/unit/aofrw.tcl

@@ -77,10 +77,10 @@ start_server {tags {"aofrw"}} {
     }
 
     foreach d {string int} {
-        foreach e {quicklist} {
+        foreach e {ziplist linkedlist} {
             test "AOF rewrite of list with $e encoding, $d data" {
                 r flushall
-                set len 1000
+                if {$e eq {ziplist}} {set len 10} else {set len 1000}
                 for {set j 0} {$j < $len} {incr j} {
                     if {$d eq {string}} {
                         set data [randstring 0 16 alpha]

tests/unit/dump.tcl

@@ -157,7 +157,7 @@ start_server {tags {"dump"}} {
     test {MIGRATE can correctly transfer large values} {
         set first [srv 0 client]
         r del key
-        for {set j 0} {$j < 40000} {incr j} {
+        for {set j 0} {$j < 5000} {incr j} {
             r rpush key 1 2 3 4 5 6 7 8 9 10
             r rpush key "item 1" "item 2" "item 3" "item 4" "item 5" \
                         "item 6" "item 7" "item 8" "item 9" "item 10"
@@ -175,7 +175,7 @@ start_server {tags {"dump"}} {
             assert {[$first exists key] == 0}
             assert {[$second exists key] == 1}
             assert {[$second ttl key] == -1}
-            assert {[$second llen key] == 40000*20}
+            assert {[$second llen key] == 5000*20}
         }
     }
 

tests/unit/scan.tcl

@@ -226,14 +226,4 @@ start_server {tags {"scan"}} {
         set res [r zscan mykey 0 MATCH foo* COUNT 10000]
         lsort -unique [lindex $res 1]
     }
-
-    test "ZSCAN scores: regression test for issue #2175" {
-        r del mykey
-        for {set j 0} {$j < 500} {incr j} {
-            r zadd mykey 9.8813129168249309e-323 $j
-        }
-        set res [lindex [r zscan mykey 0] 1]
-        set first_score [lindex $res 1]
-        assert {$first_score != 0}
-    }
 }

tests/unit/scripting.tcl

@@ -184,94 +184,6 @@ start_server {tags {"scripting"}} {
         set e
     } {*against a key*}
 
-    test {EVAL - JSON numeric decoding} {
-        # We must return the table as a string because otherwise
-        # Redis converts floats to ints and we get 0 and 1023 instead
-        # of 0.0003 and 1023.2 as the parsed output.
-        r eval {return
-                 table.concat(
-                   cjson.decode(
-                    "[0.0, -5e3, -1, 0.3e-3, 1023.2, 0e10]"), " ")
-        } 0
-    } {0 -5000 -1 0.0003 1023.2 0}
-
-    test {EVAL - JSON string decoding} {
-        r eval {local decoded = cjson.decode('{"keya": "a", "keyb": "b"}')
-                return {decoded.keya, decoded.keyb}
-        } 0
-    } {a b}
-
-    test {EVAL - cmsgpack can pack double?} {
-        r eval {local encoded = cmsgpack.pack(0.1)
-                local h = ""
-                for i = 1, #encoded do
-                    h = h .. string.format("%02x",string.byte(encoded,i))
-                end
-                return h
-        } 0
-    } {cb3fb999999999999a}
-
-    test {EVAL - cmsgpack can pack negative int64?} {
-        r eval {local encoded = cmsgpack.pack(-1099511627776)
-                local h = ""
-                for i = 1, #encoded do
-                    h = h .. string.format("%02x",string.byte(encoded,i))
-                end
-                return h
-        } 0
-    } {d3ffffff0000000000}
-
-    test {EVAL - cmsgpack can pack and unpack circular references?} {
-        r eval {local a = {x=nil,y=5}
-                local b = {x=a}
-                a['x'] = b
-                local encoded = cmsgpack.pack(a)
-                local h = ""
-                -- cmsgpack encodes to a depth of 16, but can't encode
-                -- references, so the encoded object has a deep copy recusive
-                -- depth of 16.
-                for i = 1, #encoded do
-                    h = h .. string.format("%02x",string.byte(encoded,i))
-                end
-                -- when unpacked, re.x.x != re because the unpack creates
-                -- individual tables down to a depth of 16.
-                -- (that's why the encoded output is so large)
-                local re = cmsgpack.unpack(encoded)
-                assert(re)
-                assert(re.x)
-                assert(re.x.x.y == re.y)
-                assert(re.x.x.x.x.y == re.y)
-                assert(re.x.x.x.x.x.x.y == re.y)
-                assert(re.x.x.x.x.x.x.x.x.x.x.y == re.y)
-                -- maximum working depth:
-                assert(re.x.x.x.x.x.x.x.x.x.x.x.x.x.x.y == re.y)
-                -- now the last x would be b above and has no y
-                assert(re.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x)
-                -- so, the final x.x is at the depth limit and was assigned nil
-                assert(re.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x.x == nil)
-                return {h, re.x.x.x.x.x.x.x.x.y == re.y, re.y == 5}
-        } 0
-    } {82a17905a17881a17882a17905a17881a17882a17905a17881a17882a17905a17881a17882a17905a17881a17882a17905a17881a17882a17905a17881a17882a17905a17881a178c0 1 1}
-
-    test {EVAL - Numerical sanity check from bitop} {
-        r eval {assert(0x7fffffff == 2147483647, "broken hex literals");
-                assert(0xffffffff == -1 or 0xffffffff == 2^32-1,
-                    "broken hex literals");
-                assert(tostring(-1) == "-1", "broken tostring()");
-                assert(tostring(0xffffffff) == "-1" or
-                    tostring(0xffffffff) == "4294967295",
-                    "broken tostring()")
-        } 0
-    } {}
-
-    test {EVAL - Verify minimal bitop functionality} {
-        r eval {assert(bit.tobit(1) == 1);
-                assert(bit.band(1) == 1);
-                assert(bit.bxor(1,2) == 3);
-                assert(bit.bor(1,2,4,8,16,32,64,128) == 255)
-        } 0
-    } {}
-
     test {SCRIPTING FLUSH - is able to clear the scripts cache?} {
         r set mykey myval
         set v [r evalsha fd758d1589d044dd850a6f05d52f2eefd27f033f 1 mykey]
@@ -413,7 +325,7 @@ start_server {tags {"scripting"}} {
         r sadd myset a b c
         r mset a 1 b 2 c 3 d 4
         assert {[r spop myset] ne {}}
-        assert {[r spop myset 1] ne {}}
+        assert {[r spop myset] ne {}}
         assert {[r spop myset] ne {}}
         assert {[r mget a b c d] eq {1 2 3 4}}
         assert {[r spop myset] eq {}}

tests/unit/sort.tcl

@@ -1,7 +1,8 @@
 start_server {
     tags {"sort"}
     overrides {
-        "list-max-ziplist-size" 32
+        "list-max-ziplist-value" 16
+        "list-max-ziplist-entries" 32
         "set-max-intset-entries" 32
     }
 } {
@@ -35,9 +36,9 @@ start_server {
     }
 
     foreach {num cmd enc title} {
-        16 lpush quicklist "Old Ziplist"
-        1000 lpush quicklist "Old Linked list"
-        10000 lpush quicklist "Old Big Linked list"
+        16 lpush ziplist "Ziplist"
+        1000 lpush linkedlist "Linked list"
+        10000 lpush linkedlist "Big Linked list"
         16 sadd intset "Intset"
         1000 sadd hashtable "Hash table"
         10000 sadd hashtable "Big Hash table"
@@ -84,14 +85,14 @@ start_server {
         r sort tosort BY weight_* store sort-res
         assert_equal $result [r lrange sort-res 0 -1]
         assert_equal 16 [r llen sort-res]
-        assert_encoding quicklist sort-res
+        assert_encoding ziplist sort-res
     }
 
     test "SORT BY hash field STORE" {
         r sort tosort BY wobj_*->weight store sort-res
         assert_equal $result [r lrange sort-res 0 -1]
         assert_equal 16 [r llen sort-res]
-        assert_encoding quicklist sort-res
+        assert_encoding ziplist sort-res
     }
 
     test "SORT extracts STORE correctly" {
@@ -245,24 +246,6 @@ start_server {
         r sort mylist by num get x:*->
     } {100}
 
-    test "SORT by nosort retains native order for lists" {
-        r del testa
-        r lpush testa 2 1 4 3 5
-        r sort testa by nosort
-    } {5 3 4 1 2}
-
-    test "SORT by nosort plus store retains native order for lists" {
-        r del testa
-        r lpush testa 2 1 4 3 5
-        r sort testa by nosort store testb
-        r lrange testb 0 -1
-    } {5 3 4 1 2}
-
-    test "SORT by nosort with limit returns based on original list order" {
-        r sort testa by nosort limit 0 3 store testb
-        r lrange testb 0 -1
-    } {5 3 4}
-
     tags {"slow"} {
         set num 100
         set res [create_random_dataset $num lpush]

tests/unit/type/list-2.tcl

@@ -1,7 +1,8 @@
 start_server {
     tags {"list"}
     overrides {
-        "list-max-ziplist-size" 4
+        "list-max-ziplist-value" 16
+        "list-max-ziplist-entries" 256
     }
 } {
     source "tests/unit/type/list-common.tcl"
@@ -27,18 +28,14 @@ start_server {
                 for {set i 0} {$i < 1000} {incr i} {
                     set min [expr {int(rand()*$startlen)}]
                     set max [expr {$min+int(rand()*$startlen)}]
-                    set before_len [llength $mylist]
-                    set before_len_r [r llen mylist]
                     set mylist [lrange $mylist $min $max]
                     r ltrim mylist $min $max
-                    assert_equal $mylist [r lrange mylist 0 -1] "failed trim"
+                    assert_equal $mylist [r lrange mylist 0 -1]
 
-                    set starting [r llen mylist]
                     for {set j [r llen mylist]} {$j < $startlen} {incr j} {
                         set str [randomInt 9223372036854775807]
                         r rpush mylist $str
                         lappend mylist $str
-                        assert_equal $mylist [r lrange mylist 0 -1] "failed append match"
                     }
                 }
             }

tests/unit/type/list-3.tcl

@@ -1,7 +1,8 @@
 start_server {
     tags {list ziplist}
     overrides {
-        "list-max-ziplist-size" 16
+        "list-max-ziplist-value" 200000
+        "list-max-ziplist-entries" 256
     }
 } {
     test {Explicit regression for a list bug} {

tests/unit/type/list.tcl

@@ -1,24 +1,25 @@
 start_server {
     tags {"list"}
     overrides {
-        "list-max-ziplist-size" 5
+        "list-max-ziplist-value" 16
+        "list-max-ziplist-entries" 256
     }
 } {
     source "tests/unit/type/list-common.tcl"
 
     test {LPUSH, RPUSH, LLENGTH, LINDEX, LPOP - ziplist} {
         # first lpush then rpush
-        assert_equal 1 [r lpush myziplist1 aa]
-        assert_equal 2 [r rpush myziplist1 bb]
-        assert_equal 3 [r rpush myziplist1 cc]
+        assert_equal 1 [r lpush myziplist1 a]
+        assert_equal 2 [r rpush myziplist1 b]
+        assert_equal 3 [r rpush myziplist1 c]
         assert_equal 3 [r llen myziplist1]
-        assert_equal aa [r lindex myziplist1 0]
-        assert_equal bb [r lindex myziplist1 1]
-        assert_equal cc [r lindex myziplist1 2]
+        assert_equal a [r lindex myziplist1 0]
+        assert_equal b [r lindex myziplist1 1]
+        assert_equal c [r lindex myziplist1 2]
         assert_equal {} [r lindex myziplist2 3]
-        assert_equal cc [r rpop myziplist1]
-        assert_equal aa [r lpop myziplist1]
-        assert_encoding quicklist myziplist1
+        assert_equal c [r rpop myziplist1]
+        assert_equal a [r lpop myziplist1]
+        assert_encoding ziplist myziplist1
 
         # first rpush then lpush
         assert_equal 1 [r rpush myziplist2 a]
@@ -31,13 +32,13 @@ start_server {
         assert_equal {} [r lindex myziplist2 3]
         assert_equal a [r rpop myziplist2]
         assert_equal c [r lpop myziplist2]
-        assert_encoding quicklist myziplist2
+        assert_encoding ziplist myziplist2
     }
 
     test {LPUSH, RPUSH, LLENGTH, LINDEX, LPOP - regular list} {
         # first lpush then rpush
         assert_equal 1 [r lpush mylist1 $largevalue(linkedlist)]
-        assert_encoding quicklist mylist1
+        assert_encoding linkedlist mylist1
         assert_equal 2 [r rpush mylist1 b]
         assert_equal 3 [r rpush mylist1 c]
         assert_equal 3 [r llen mylist1]
@@ -50,7 +51,7 @@ start_server {
 
         # first rpush then lpush
         assert_equal 1 [r rpush mylist2 $largevalue(linkedlist)]
-        assert_encoding quicklist mylist2
+        assert_encoding linkedlist mylist2
         assert_equal 2 [r lpush mylist2 b]
         assert_equal 3 [r lpush mylist2 c]
         assert_equal 3 [r llen mylist2]
@@ -73,22 +74,34 @@ start_server {
         assert_equal {d c b a 0 1 2 3} [r lrange mylist 0 -1]
     }
 
-    test {DEL a list} {
+    test {DEL a list - ziplist} {
+        assert_equal 1 [r del myziplist2]
+        assert_equal 0 [r exists myziplist2]
+        assert_equal 0 [r llen myziplist2]
+    }
+
+    test {DEL a list - regular list} {
         assert_equal 1 [r del mylist2]
         assert_equal 0 [r exists mylist2]
         assert_equal 0 [r llen mylist2]
     }
 
-    proc create_list {key entries} {
+    proc create_ziplist {key entries} {
         r del $key
         foreach entry $entries { r rpush $key $entry }
-        assert_encoding quicklist $key
+        assert_encoding ziplist $key
+    }
+
+    proc create_linkedlist {key entries} {
+        r del $key
+        foreach entry $entries { r rpush $key $entry }
+        assert_encoding linkedlist $key
     }
 
     foreach {type large} [array get largevalue] {
         test "BLPOP, BRPOP: single existing list - $type" {
             set rd [redis_deferring_client]
-            create_list blist "a b $large c d"
+            create_$type blist "a b $large c d"
 
             $rd blpop blist 1
             assert_equal {blist a} [$rd read]
@@ -103,8 +116,8 @@ start_server {
 
         test "BLPOP, BRPOP: multiple existing lists - $type" {
             set rd [redis_deferring_client]
-            create_list blist1 "a $large c"
-            create_list blist2 "d $large f"
+            create_$type blist1 "a $large c"
+            create_$type blist2 "d $large f"
 
             $rd blpop blist1 blist2 1
             assert_equal {blist1 a} [$rd read]
@@ -124,7 +137,7 @@ start_server {
         test "BLPOP, BRPOP: second list has an entry - $type" {
             set rd [redis_deferring_client]
             r del blist1
-            create_list blist2 "d $large f"
+            create_$type blist2 "d $large f"
 
             $rd blpop blist1 blist2 1
             assert_equal {blist2 d} [$rd read]
@@ -138,7 +151,7 @@ start_server {
             r del target
 
             set rd [redis_deferring_client]
-            create_list blist "a b $large c d"
+            create_$type blist "a b $large c d"
 
             $rd brpoplpush blist target 1
             assert_equal d [$rd read]
@@ -504,28 +517,28 @@ start_server {
 
     foreach {type large} [array get largevalue] {
         test "LPUSHX, RPUSHX - $type" {
-            create_list xlist "$large c"
+            create_$type xlist "$large c"
             assert_equal 3 [r rpushx xlist d]
             assert_equal 4 [r lpushx xlist a]
             assert_equal "a $large c d" [r lrange xlist 0 -1]
         }
 
         test "LINSERT - $type" {
-            create_list xlist "a $large c d"
-            assert_equal 5 [r linsert xlist before c zz] "before c"
-            assert_equal "a $large zz c d" [r lrange xlist 0 10] "lrangeA"
-            assert_equal 6 [r linsert xlist after c yy] "after c"
-            assert_equal "a $large zz c yy d" [r lrange xlist 0 10] "lrangeB"
-            assert_equal 7 [r linsert xlist after d dd] "after d"
-            assert_equal -1 [r linsert xlist after bad ddd] "after bad"
-            assert_equal "a $large zz c yy d dd" [r lrange xlist 0 10] "lrangeC"
-            assert_equal 8 [r linsert xlist before a aa] "before a"
-            assert_equal -1 [r linsert xlist before bad aaa] "before bad"
-            assert_equal "aa a $large zz c yy d dd" [r lrange xlist 0 10] "lrangeD"
+            create_$type xlist "a $large c d"
+            assert_equal 5 [r linsert xlist before c zz]
+            assert_equal "a $large zz c d" [r lrange xlist 0 10]
+            assert_equal 6 [r linsert xlist after c yy]
+            assert_equal "a $large zz c yy d" [r lrange xlist 0 10]
+            assert_equal 7 [r linsert xlist after d dd]
+            assert_equal -1 [r linsert xlist after bad ddd]
+            assert_equal "a $large zz c yy d dd" [r lrange xlist 0 10]
+            assert_equal 8 [r linsert xlist before a aa]
+            assert_equal -1 [r linsert xlist before bad aaa]
+            assert_equal "aa a $large zz c yy d dd" [r lrange xlist 0 10]
 
             # check inserting integer encoded value
-            assert_equal 9 [r linsert xlist before aa 42] "before aa"
-            assert_equal 42 [r lrange xlist 0 0] "lrangeE"
+            assert_equal 9 [r linsert xlist before aa 42]
+            assert_equal 42 [r lrange xlist 0 0]
         }
     }
 
@@ -534,7 +547,55 @@ start_server {
         set e
     } {*ERR*syntax*error*}
 
-    foreach {type num} {quicklist 250 quicklist 500} {
+    test {LPUSHX, RPUSHX convert from ziplist to list} {
+        set large $largevalue(linkedlist)
+
+        # convert when a large value is pushed
+        create_ziplist xlist a
+        assert_equal 2 [r rpushx xlist $large]
+        assert_encoding linkedlist xlist
+        create_ziplist xlist a
+        assert_equal 2 [r lpushx xlist $large]
+        assert_encoding linkedlist xlist
+
+        # convert when the length threshold is exceeded
+        create_ziplist xlist [lrepeat 256 a]
+        assert_equal 257 [r rpushx xlist b]
+        assert_encoding linkedlist xlist
+        create_ziplist xlist [lrepeat 256 a]
+        assert_equal 257 [r lpushx xlist b]
+        assert_encoding linkedlist xlist
+    }
+
+    test {LINSERT convert from ziplist to list} {
+        set large $largevalue(linkedlist)
+
+        # convert when a large value is inserted
+        create_ziplist xlist a
+        assert_equal 2 [r linsert xlist before a $large]
+        assert_encoding linkedlist xlist
+        create_ziplist xlist a
+        assert_equal 2 [r linsert xlist after a $large]
+        assert_encoding linkedlist xlist
+
+        # convert when the length threshold is exceeded
+        create_ziplist xlist [lrepeat 256 a]
+        assert_equal 257 [r linsert xlist before a a]
+        assert_encoding linkedlist xlist
+        create_ziplist xlist [lrepeat 256 a]
+        assert_equal 257 [r linsert xlist after a a]
+        assert_encoding linkedlist xlist
+
+        # don't convert when the value could not be inserted
+        create_ziplist xlist [lrepeat 256 a]
+        assert_equal -1 [r linsert xlist before foo a]
+        assert_encoding ziplist xlist
+        create_ziplist xlist [lrepeat 256 a]
+        assert_equal -1 [r linsert xlist after foo a]
+        assert_encoding ziplist xlist
+    }
+
+    foreach {type num} {ziplist 250 linkedlist 500} {
         proc check_numbered_list_consistency {key} {
             set len [r llen $key]
             for {set i 0} {$i < $len} {incr i} {
@@ -603,16 +664,16 @@ start_server {
     foreach {type large} [array get largevalue] {
         test "RPOPLPUSH base case - $type" {
             r del mylist1 mylist2
-            create_list mylist1 "a $large c d"
+            create_$type mylist1 "a $large c d"
             assert_equal d [r rpoplpush mylist1 mylist2]
             assert_equal c [r rpoplpush mylist1 mylist2]
             assert_equal "a $large" [r lrange mylist1 0 -1]
             assert_equal "c d" [r lrange mylist2 0 -1]
-            assert_encoding quicklist mylist2
+            assert_encoding ziplist mylist2
         }
 
         test "RPOPLPUSH with the same list as src and dst - $type" {
-            create_list mylist "a $large c"
+            create_$type mylist "a $large c"
             assert_equal "a $large c" [r lrange mylist 0 -1]
             assert_equal c [r rpoplpush mylist mylist]
             assert_equal "c a $large" [r lrange mylist 0 -1]
@@ -620,8 +681,8 @@ start_server {
 
         foreach {othertype otherlarge} [array get largevalue] {
             test "RPOPLPUSH with $type source and existing target $othertype" {
-                create_list srclist "a b c $large"
-                create_list dstlist "$otherlarge"
+                create_$type srclist "a b c $large"
+                create_$othertype dstlist "$otherlarge"
                 assert_equal $large [r rpoplpush srclist dstlist]
                 assert_equal c [r rpoplpush srclist dstlist]
                 assert_equal "a b" [r lrange srclist 0 -1]
@@ -630,7 +691,7 @@ start_server {
                 # When we rpoplpush'ed a large value, dstlist should be
                 # converted to the same encoding as srclist.
                 if {$type eq "linkedlist"} {
-                    assert_encoding quicklist dstlist
+                    assert_encoding linkedlist dstlist
                 }
             }
         }
@@ -652,7 +713,7 @@ start_server {
     }
 
     test {RPOPLPUSH against non list dst key} {
-        create_list srclist {a b c d}
+        create_ziplist srclist {a b c d}
         r set dstlist x
         assert_error WRONGTYPE* {r rpoplpush srclist dstlist}
         assert_type string dstlist
@@ -666,7 +727,7 @@ start_server {
 
     foreach {type large} [array get largevalue] {
         test "Basic LPOP/RPOP - $type" {
-            create_list mylist "$large 1 2"
+            create_$type mylist "$large 1 2"
             assert_equal $large [r lpop mylist]
             assert_equal 2 [r rpop mylist]
             assert_equal 1 [r lpop mylist]
@@ -684,7 +745,7 @@ start_server {
         assert_error WRONGTYPE* {r rpop notalist}
     }
 
-    foreach {type num} {quicklist 250 quicklist 500} {
+    foreach {type num} {ziplist 250 linkedlist 500} {
         test "Mass RPOP/LPOP - $type" {
             r del mylist
             set sum1 0
@@ -704,24 +765,24 @@ start_server {
 
     foreach {type large} [array get largevalue] {
         test "LRANGE basics - $type" {
-            create_list mylist "$large 1 2 3 4 5 6 7 8 9"
+            create_$type mylist "$large 1 2 3 4 5 6 7 8 9"
             assert_equal {1 2 3 4 5 6 7 8} [r lrange mylist 1 -2]
             assert_equal {7 8 9} [r lrange mylist -3 -1]
             assert_equal {4} [r lrange mylist 4 4]
         }
 
         test "LRANGE inverted indexes - $type" {
-            create_list mylist "$large 1 2 3 4 5 6 7 8 9"
+            create_$type mylist "$large 1 2 3 4 5 6 7 8 9"
             assert_equal {} [r lrange mylist 6 2]
         }
 
         test "LRANGE out of range indexes including the full list - $type" {
-            create_list mylist "$large 1 2 3"
+            create_$type mylist "$large 1 2 3"
             assert_equal "$large 1 2 3" [r lrange mylist -1000 1000]
         }
 
         test "LRANGE out of range negative end index - $type" {
-            create_list mylist "$large 1 2 3"
+            create_$type mylist "$large 1 2 3"
             assert_equal $large [r lrange mylist 0 -4]
             assert_equal {} [r lrange mylist 0 -5]
         }
@@ -735,7 +796,7 @@ start_server {
         proc trim_list {type min max} {
             upvar 1 large large
             r del mylist
-            create_list mylist "1 2 3 4 $large"
+            create_$type mylist "1 2 3 4 $large"
             r ltrim mylist $min $max
             r lrange mylist 0 -1
         }
@@ -764,7 +825,7 @@ start_server {
 
     foreach {type large} [array get largevalue] {
         test "LSET - $type" {
-            create_list mylist "99 98 $large 96 95"
+            create_$type mylist "99 98 $large 96 95"
             r lset mylist 1 foo
             r lset mylist -1 bar
             assert_equal "99 foo $large 96 bar" [r lrange mylist 0 -1]
@@ -786,7 +847,7 @@ start_server {
 
     foreach {type e} [array get largevalue] {
         test "LREM remove all the occurrences - $type" {
-            create_list mylist "$e foo bar foobar foobared zap bar test foo"
+            create_$type mylist "$e foo bar foobar foobared zap bar test foo"
             assert_equal 2 [r lrem mylist 0 bar]
             assert_equal "$e foo foobar foobared zap test foo" [r lrange mylist 0 -1]
         }
@@ -802,7 +863,7 @@ start_server {
         }
 
         test "LREM starting from tail with negative count - $type" {
-            create_list mylist "$e foo bar foobar foobared zap bar test foo foo"
+            create_$type mylist "$e foo bar foobar foobared zap bar test foo foo"
             assert_equal 1 [r lrem mylist -1 bar]
             assert_equal "$e foo bar foobar foobared zap test foo foo" [r lrange mylist 0 -1]
         }
@@ -813,7 +874,7 @@ start_server {
         }
 
         test "LREM deleting objects that may be int encoded - $type" {
-            create_list myotherlist "$e 1 2 3"
+            create_$type myotherlist "$e 1 2 3"
             assert_equal 1 [r lrem myotherlist 1 2]
             assert_equal 3 [r llen myotherlist]
         }

tests/unit/type/set.tcl

@@ -293,13 +293,6 @@ start_server {
             assert_equal 0 [r scard myset]
         }
 
-        test "SPOP with <count>=1 - $type" {
-            create_set myset $contents
-            assert_encoding $type myset
-            assert_equal $contents [lsort [list [r spop myset 1] [r spop myset 1] [r spop myset 1]]]
-            assert_equal 0 [r scard myset]
-        }
-
         test "SRANDMEMBER - $type" {
             create_set myset $contents
             unset -nocomplain myset
@@ -311,41 +304,6 @@ start_server {
         }
     }
 
-    foreach {type contents} {
-        hashtable {a b c d e f g h i j k l m n o p q r s t u v w x y z} 
-        intset {1 10 11 12 13 14 15 16 17 18 19 2 20 21 22 23 24 25 26 3 4 5 6 7 8 9}
-    } {
-        test "SPOP with <count>" {
-            create_set myset $contents
-            assert_encoding $type myset
-            assert_equal $contents [lsort [concat [r spop myset 11] [r spop myset 9] [r spop myset 0] [r spop myset 4] [r spop myset 1] [r spop myset 0] [r spop myset 1] [r spop myset 0]]]
-            assert_equal 0 [r scard myset]
-        }
-    }
-
-    # As seen in intsetRandomMembers
-    test "SPOP using integers, testing Knuth's and Floyd's algorithm" {
-        create_set myset {1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20}
-        assert_encoding intset myset
-        assert_equal 20 [r scard myset]
-        r spop myset 1
-        assert_equal 19 [r scard myset]
-        r spop myset 2
-        assert_equal 17 [r scard myset]
-        r spop myset 3
-        assert_equal 14 [r scard myset]
-        r spop myset 10
-        assert_equal 4 [r scard myset]
-        r spop myset 10
-        assert_equal 0 [r scard myset]
-        r spop myset 1
-        assert_equal 0 [r scard myset]
-    } {}
-
-    test "SPOP using integers with Knuth's algorithm" {
-        r spop nonexisting_key 100
-    } {}
-
     test "SRANDMEMBER with <count> against non existing key" {
         r srandmember nonexisting_key 100
     } {}

utils/redis_init_script.tpl

@@ -26,12 +26,11 @@ case "$1" in
         fi
         ;;
     status)
-        PID=$(cat $PIDFILE)
-        if [ ! -x /proc/${PID} ]
+        if [ ! -f $PIDFILE ]
         then
             echo 'Redis is not running'
         else
-            echo "Redis is running ($PID)"
+            echo "Redis is running ($(<$PIDFILE))"
         fi
         ;;
     restart)

utils/whatisdoing.sh

@@ -1,15 +1,9 @@
 # This script is from http://poormansprofiler.org/
-#
-# NOTE: Instead of using this script, you should use the Redis
-# Software Watchdog, which provides a similar functionality but in
-# a more reliable / easy to use way.
-#
-# Check http://redis.io/topics/latency for more information.
 
 #!/bin/bash
 nsamples=1
 sleeptime=0
-pid=$(ps auxww | grep '[r]edis-server' | awk '{print $2}')
+pid=$(pidof redis-server)
 
 for x in $(seq 1 $nsamples)
   do