Bump version

Merge branch 'unstable' into RELEASE_5
Fix issue #83
2019-11-21 20:16:42 -05:00 · 2019-11-21 20:16:23 -05:00 · 2019-11-21 20:05:16 -05:00 · 2019-11-20 20:35:14 -05:00 · 2019-11-20 19:44:43 -05:00 · 2019-11-20 19:44:31 -05:00
59 changed files with 1739 additions and 1041 deletions
@@ -0,0 +1,20 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+** Log Files **
+These should be KeyDB logs, not syslogs or logs from your container manager.  If you are reporting a crash there will be a line in your log stating:
+"=== KEYDB BUG REPORT START: Cut & paste starting from here ==="
+
+Please copy everything after this line.
+
+**To Reproduce**
+Do you know how to reproduce this?  If so please provide repro steps.
@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.
@@ -1,58 +0,0 @@
-{
-    "files.associations": {
-        "zmalloc.h": "c",
-        "stat.h": "c",
-        "array": "cpp",
-        "atomic": "cpp",
-        "*.tcc": "cpp",
-        "cctype": "cpp",
-        "chrono": "cpp",
-        "clocale": "cpp",
-        "cmath": "cpp",
-        "condition_variable": "cpp",
-        "cstdarg": "cpp",
-        "cstddef": "cpp",
-        "cstdint": "cpp",
-        "cstdio": "cpp",
-        "cstdlib": "cpp",
-        "cstring": "cpp",
-        "ctime": "cpp",
-        "cwchar": "cpp",
-        "cwctype": "cpp",
-        "deque": "cpp",
-        "list": "cpp",
-        "unordered_map": "cpp",
-        "vector": "cpp",
-        "exception": "cpp",
-        "fstream": "cpp",
-        "functional": "cpp",
-        "future": "cpp",
-        "initializer_list": "cpp",
-        "iomanip": "cpp",
-        "iosfwd": "cpp",
-        "iostream": "cpp",
-        "istream": "cpp",
-        "limits": "cpp",
-        "memory": "cpp",
-        "mutex": "cpp",
-        "new": "cpp",
-        "numeric": "cpp",
-        "optional": "cpp",
-        "ostream": "cpp",
-        "ratio": "cpp",
-        "scoped_allocator": "cpp",
-        "sstream": "cpp",
-        "stdexcept": "cpp",
-        "streambuf": "cpp",
-        "string_view": "cpp",
-        "system_error": "cpp",
-        "thread": "cpp",
-        "cinttypes": "cpp",
-        "tuple": "cpp",
-        "type_traits": "cpp",
-        "typeinfo": "cpp",
-        "utility": "cpp",
-        "set": "cpp",
-        "algorithm": "cpp"
-    }
-}
@@ -4,7 +4,7 @@ FROM ubuntu:18.04

 RUN apt-get update \
    && DEBIAN_FRONTEND=noninteractive apt-get install -qqy \
-        build-essential nasm autotools-dev autoconf libjemalloc-dev tcl tcl-dev uuid-dev \
+        build-essential nasm autotools-dev autoconf libcurl4-openssl-dev libjemalloc-dev tcl tcl-dev uuid-dev libcurl4-openssl-dev \
    && apt-get clean

 CMD make
@@ -18,7 +18,7 @@ On the same hardware KeyDB can perform twice as many queries per second as Redis
 Why fork Redis?
 ---------------

-KeyDB has a different philosophy on how the codebase should evolve.  We feel that ease of use, high performance, and a "batteries included" approach is the best way to create a good user experience.  While we have great respect for the Redis maintainers it is our opinion that the Redis approach focusses too much on simplicity of the code base at the expense of complexity for the user.  This results in the need for external components and workarounds to solve common problems - resulting in more complexity overall.
+KeyDB has a different philosophy on how the codebase should evolve.  We feel that ease of use, high performance, and a "batteries included" approach is the best way to create a good user experience.  While we have great respect for the Redis maintainers it is our opinion that the Redis approach focuses too much on simplicity of the code base at the expense of complexity for the user.  This results in the need for external components and workarounds to solve common problems - resulting in more complexity overall.

 Because of this difference of opinion features which are right for KeyDB may not be appropriate for Redis.  A fork allows us to explore this new development path and implement features which may never be a part of Redis.  KeyDB keeps in sync with upstream Redis changes, and where applicable we upstream bug fixes and changes. It is our hope that the two projects can continue to grow and learn from each other.

@@ -0,0 +1,13 @@
+="repl-stream-db"
+="repl-id"
+="repl-offset"
+="lua"
+="redis-ver"
+="ctime"
+="used-mem"
+="aof-preamble"
+="redis-bits"
+="mvcc-tstamp"
+="keydb-subexpire-key"
+="keydb-subexpire-when"
+
@@ -47,8 +47,6 @@ endif
 USEASM?=true

 ifneq ($(SANITIZE),)
-	CC=clang
-	CXX=clang++
 	CFLAGS+= -fsanitize=$(SANITIZE) -DSANITIZE
 	CXXFLAGS+= -fsanitize=$(SANITIZE) -DSANITIZE
 	LDFLAGS+= -fsanitize=$(SANITIZE)
@@ -190,7 +188,7 @@ endif

 REDIS_CC=$(QUIET_CC)$(CC) $(FINAL_CFLAGS)
 REDIS_CXX=$(QUIET_CC)$(CC) $(FINAL_CXXFLAGS)
-REDIS_NASM=$(QUIET_CC)nasm -felf64 
+KEYDB_AS=$(QUIET_CC) as --64 -g
 REDIS_LD=$(QUIET_LINK)$(CXX) $(FINAL_LDFLAGS)
 REDIS_INSTALL=$(QUIET_INSTALL)$(INSTALL)

@@ -295,7 +293,7 @@ dict-benchmark: dict.cpp zmalloc.cpp sds.c siphash.c
 	$(REDIS_CXX) -c $<

 %.o: %.asm .make-prerequisites
-	$(REDIS_NASM) $<
+	$(KEYDB_AS) $< -o $@

 clean:
 	rm -rf $(REDIS_SERVER_NAME) $(REDIS_SENTINEL_NAME) $(REDIS_CLI_NAME) $(REDIS_BENCHMARK_NAME) $(REDIS_CHECK_RDB_NAME) $(REDIS_CHECK_AOF_NAME) *.o *.gcda *.gcno *.gcov redis.info lcov-html Makefile.dep dict-benchmark
@@ -80,11 +80,11 @@ public:
 mutex_wrapper g_lock;

 #else
-fastlock g_lock;
+fastlock g_lock("AE (global)");
 #endif
 thread_local aeEventLoop *g_eventLoopThisThread = NULL;

-#define AE_ASSERT(x) if (!(x)) do { fprintf(stderr, "AE_ASSER FAILURE\n"); *((volatile int*)0) = 1; } while(0)
+#define AE_ASSERT(x) if (!(x)) do { fprintf(stderr, "AE_ASSERT FAILURE %s: %d\n", __FILE__, __LINE__); *((volatile int*)0) = 1; } while(0)

 /* Include the best multiplexing layer supported by this system.
 * The following should be ordered by performances, descending. */
@@ -327,7 +327,7 @@ aeEventLoop *aeCreateEventLoop(int setsize) {
    for (i = 0; i < setsize; i++)
        eventLoop->events[i].mask = AE_NONE;

-    fastlock_init(&eventLoop->flock);
+    fastlock_init(&eventLoop->flock, "event loop");
    int rgfd[2];
    if (pipe(rgfd) < 0)
        goto err;
@@ -61,6 +61,11 @@ public:
        return m_fArmed;
    }

+    void release()
+    {
+        m_fArmed = false;
+    }
+
    ~AeLocker()
    {
        if (m_fArmed)
@@ -476,7 +476,7 @@ static int anetV6Only(char *err, int s) {
    return ANET_OK;
 }

-static int _anetTcpServer(char *err, int port, char *bindaddr, int af, int backlog, int fReusePort)
+static int _anetTcpServer(char *err, int port, char *bindaddr, int af, int backlog, int fReusePort, int fFirstListen)
 {
    int s = -1, rv;
    char _port[6];  /* strlen("65535") */
@@ -498,8 +498,12 @@ static int _anetTcpServer(char *err, int port, char *bindaddr, int af, int backl

        if (af == AF_INET6 && anetV6Only(err,s) == ANET_ERR) goto error;
        if (anetSetReuseAddr(err,s) == ANET_ERR) goto error;
-        if (fReusePort && anetSetReusePort(err,s) == ANET_ERR) goto error;
-        if (anetListen(err,s,p->ai_addr,p->ai_addrlen,backlog) == ANET_ERR) s = ANET_ERR;
+        if (fReusePort && !fFirstListen && anetSetReusePort(err,s) == ANET_ERR) goto error;
+        if (anetListen(err,s,p->ai_addr,p->ai_addrlen,backlog) == ANET_ERR) {
+            s = ANET_ERR;
+            goto end;
+        }
+        if (fReusePort && fFirstListen && anetSetReusePort(err,s) == ANET_ERR) goto error;
        goto end;
    }
    if (p == NULL) {
@@ -515,14 +519,14 @@ end:
    return s;
 }

-int anetTcpServer(char *err, int port, char *bindaddr, int backlog, int fReusePort)
+int anetTcpServer(char *err, int port, char *bindaddr, int backlog, int fReusePort, int fFirstListen)
 {
-    return _anetTcpServer(err, port, bindaddr, AF_INET, backlog, fReusePort);
+    return _anetTcpServer(err, port, bindaddr, AF_INET, backlog, fReusePort, fFirstListen);
 }

-int anetTcp6Server(char *err, int port, char *bindaddr, int backlog, int fReusePort)
+int anetTcp6Server(char *err, int port, char *bindaddr, int backlog, int fReusePort, int fFirstListen)
 {
-    return _anetTcpServer(err, port, bindaddr, AF_INET6, backlog, fReusePort);
+    return _anetTcpServer(err, port, bindaddr, AF_INET6, backlog, fReusePort, fFirstListen);
 }

 int anetUnixServer(char *err, char *path, mode_t perm, int backlog)
@@ -62,8 +62,8 @@ int anetUnixNonBlockConnect(char *err, char *path);
 int anetRead(int fd, char *buf, int count);
 int anetResolve(char *err, char *host, char *ipbuf, size_t ipbuf_len);
 int anetResolveIP(char *err, char *host, char *ipbuf, size_t ipbuf_len);
-int anetTcpServer(char *err, int port, char *bindaddr, int backlog, int fReusePort);
-int anetTcp6Server(char *err, int port, char *bindaddr, int backlog, int fReusePort);
+int anetTcpServer(char *err, int port, char *bindaddr, int backlog, int fReusePort, int fFirstListen);
+int anetTcp6Server(char *err, int port, char *bindaddr, int backlog, int fReusePort, int fFirstListen);
 int anetUnixServer(char *err, char *path, mode_t perm, int backlog);
 int anetTcpAccept(char *err, int serversock, char *ip, size_t ip_len, int *port);
 int anetUnixAccept(char *err, int serversock);
@@ -97,6 +97,7 @@ void aofChildWriteDiffData(aeEventLoop *el, int fd, void *privdata, int mask) {
    aofrwblock *block;
    ssize_t nwritten;
    serverAssert(GlobalLocksAcquired());
+    serverAssert(el == g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el); // MUST run on main thread

    UNUSED(el);
    UNUSED(fd);
@@ -164,10 +165,7 @@ void aofRewriteBufferAppend(unsigned char *s, unsigned long len) {

    /* Install a file event to send data to the rewrite child if there is
     * not one already. */
-    if (aeGetFileEvents(serverTL->el,g_pserver->aof_pipe_write_data_to_child) == 0) {
-        aeCreateFileEvent(serverTL->el, g_pserver->aof_pipe_write_data_to_child,
-            AE_WRITABLE, aofChildWriteDiffData, NULL);
-    }
+    aeCreateRemoteFileEvent(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el, g_pserver->aof_pipe_write_data_to_child, AE_WRITABLE, aofChildWriteDiffData, NULL, FALSE);
 }

 /* Write the buffer (possibly composed of multiple blocks) into the specified
@@ -668,7 +666,7 @@ client *createFakeClient(void) {
    c->flags = 0;
    c->fPendingAsyncWrite = FALSE;
    c->btype = BLOCKED_NONE;
-    /* We set the fake client as a slave waiting for the synchronization
+    /* We set the fake client as a replica waiting for the synchronization
     * so that Redis will not try to send replies to this client. */
    c->replstate = SLAVE_STATE_WAIT_BGSAVE_START;
    c->reply = listCreate();
@@ -680,7 +678,7 @@ client *createFakeClient(void) {
    c->puser = NULL;
    listSetFreeMethod(c->reply,freeClientReplyValue);
    listSetDupMethod(c->reply,dupClientReplyValue);
-    fastlock_init(&c->lock);
+    fastlock_init(&c->lock, "fake client");
    fastlock_lock(&c->lock);
    initClientMultiState(c);
    return c;
@@ -1519,7 +1517,7 @@ void aofChildPipeReadable(aeEventLoop *el, int fd, void *privdata, int mask) {
    }
    /* Remove the handler since this can be called only one time during a
     * rewrite. */
-    aeDeleteFileEventAsync(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el,g_pserver->aof_pipe_read_ack_from_child,AE_READABLE);
+    aeDeleteFileEvent(el,g_pserver->aof_pipe_read_ack_from_child,AE_READABLE);
 }

 /* Create the pipes used for parent - child process IPC during rewrite.
@@ -1557,12 +1555,20 @@ error:
 }

 void aofClosePipes(void) {
-    aeDeleteFileEventAsync(g_pserver->el_alf_pip_read_ack_from_child,g_pserver->aof_pipe_read_ack_from_child,AE_READABLE);
-    aeDeleteFileEventAsync(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el,g_pserver->aof_pipe_write_data_to_child,AE_WRITABLE);
-    close(g_pserver->aof_pipe_write_data_to_child);
+    int fdAofAckPipe = g_pserver->aof_pipe_read_ack_from_child;
+    aePostFunction(g_pserver->el_alf_pip_read_ack_from_child, [fdAofAckPipe]{
+        aeDeleteFileEventAsync(serverTL->el,fdAofAckPipe,AE_READABLE);
+        close (fdAofAckPipe);
+    });
+
+    int fdAofWritePipe = g_pserver->aof_pipe_write_data_to_child;
+    aePostFunction(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el, [fdAofWritePipe]{
+        aeDeleteFileEventAsync(serverTL->el,fdAofWritePipe,AE_WRITABLE);
+        close(fdAofWritePipe);
+    });
+    
    close(g_pserver->aof_pipe_read_data_from_parent);
    close(g_pserver->aof_pipe_write_ack_to_parent);
-    close(g_pserver->aof_pipe_read_ack_from_child);
    close(g_pserver->aof_pipe_write_ack_to_child);
    close(g_pserver->aof_pipe_read_ack_from_parent);
 }
@@ -396,7 +396,8 @@ void printBits(unsigned char *p, unsigned long count) {
 #define BITOP_OR    1
 #define BITOP_XOR   2
 #define BITOP_NOT   3
-#define BITOP_INVALID 4
+#define BITOP_LSHIFT 4
+#define BITOP_RSHIFT 5

 #define BITFIELDOP_GET 0
 #define BITFIELDOP_SET 1
@@ -588,277 +589,34 @@ void getbitCommand(client *c) {
    addReply(c, bitval ? shared.cone : shared.czero);
 }

-unsigned char *bitopCore(unsigned long op, unsigned long minlen, unsigned long maxlen, unsigned long numkeys, unsigned char **src, unsigned long *len)
-{
-    unsigned char *res = NULL; /* Resulting string. */
-    unsigned long j;
-
-    /* Compute the bit operation, if at least one string is not empty. */
-    if (maxlen) {
-        res = (unsigned char*) sdsnewlen(NULL,maxlen);
-        unsigned char output, byte;
-        unsigned long i;
-
-        /* Fast path: as far as we have data for all the input bitmaps we
-         * can take a fast path that performs much better than the
-         * vanilla algorithm. On ARM we skip the fast path since it will
-         * result in GCC compiling the code using multiple-words load/store
-         * operations that are not supported even in ARM >= v6. */
-        j = 0;
-        #ifndef USE_ALIGNED_ACCESS
-        if (minlen >= sizeof(unsigned long)*4 && numkeys <= 16) {
-            unsigned long *lp[16];
-            unsigned long *lres = (unsigned long*) res;
-
-            /* Note: sds pointer is always aligned to 8 byte boundary. */
-            memcpy(lp,src,sizeof(unsigned long*)*numkeys);
-            memcpy(res,src[0],minlen);
-
-            /* Different branches per different operations for speed (sorry). */
-            if (op == BITOP_AND) {
-                while(minlen >= sizeof(unsigned long)*4) {
-                    for (i = 1; i < numkeys; i++) {
-                        lres[0] &= lp[i][0];
-                        lres[1] &= lp[i][1];
-                        lres[2] &= lp[i][2];
-                        lres[3] &= lp[i][3];
-                        lp[i]+=4;
-                    }
-                    lres+=4;
-                    j += sizeof(unsigned long)*4;
-                    minlen -= sizeof(unsigned long)*4;
-                }
-            } else if (op == BITOP_OR) {
-                while(minlen >= sizeof(unsigned long)*4) {
-                    for (i = 1; i < numkeys; i++) {
-                        lres[0] |= lp[i][0];
-                        lres[1] |= lp[i][1];
-                        lres[2] |= lp[i][2];
-                        lres[3] |= lp[i][3];
-                        lp[i]+=4;
-                    }
-                    lres+=4;
-                    j += sizeof(unsigned long)*4;
-                    minlen -= sizeof(unsigned long)*4;
-                }
-            } else if (op == BITOP_XOR) {
-                while(minlen >= sizeof(unsigned long)*4) {
-                    for (i = 1; i < numkeys; i++) {
-                        lres[0] ^= lp[i][0];
-                        lres[1] ^= lp[i][1];
-                        lres[2] ^= lp[i][2];
-                        lres[3] ^= lp[i][3];
-                        lp[i]+=4;
-                    }
-                    lres+=4;
-                    j += sizeof(unsigned long)*4;
-                    minlen -= sizeof(unsigned long)*4;
-                }
-            } else if (op == BITOP_NOT) {
-                while(minlen >= sizeof(unsigned long)*4) {
-                    lres[0] = ~lres[0];
-                    lres[1] = ~lres[1];
-                    lres[2] = ~lres[2];
-                    lres[3] = ~lres[3];
-                    lres+=4;
-                    j += sizeof(unsigned long)*4;
-                    minlen -= sizeof(unsigned long)*4;
-                }
-            }
-        }
-        #endif
-
-        /* j is set to the next byte to process by the previous loop. */
-        for (; j < maxlen; j++) {
-            output = (len[0] <= j) ? 0 : src[0][j];
-            if (op == BITOP_NOT) output = ~output;
-            for (i = 1; i < numkeys; i++) {
-                byte = (len[i] <= j) ? 0 : src[i][j];
-                switch(op) {
-                case BITOP_AND: output &= byte; break;
-                case BITOP_OR:  output |= byte; break;
-                case BITOP_XOR: output ^= byte; break;
-                }
-            }
-            res[j] = output;
-        }
-    }
-
-    return res;
-}
-
-unsigned bitopFromStr(const char *opname)
-{
-    if ((opname[0] == 'a' || opname[0] == 'A') && !strcasecmp(opname,"and"))
-        return BITOP_AND;
-    else if((opname[0] == 'o' || opname[0] == 'O') && !strcasecmp(opname,"or"))
-        return BITOP_OR;
-    else if((opname[0] == 'x' || opname[0] == 'X') && !strcasecmp(opname,"xor"))
-        return BITOP_XOR;
-    else if((opname[0] == 'n' || opname[0] == 'N') && !strcasecmp(opname,"not"))
-        return BITOP_NOT;
-    return BITOP_INVALID;
-}
-
-// Format (long):(long)
-std::pair<long long, long long> parseRange(robj *o)
-{
-    const char *sz = szFromObj(o);
-    
-    const char *pchCheck = sz;
-    while (*pchCheck != '\0' && *pchCheck != ':')
-        ++pchCheck;
-
-    if (*pchCheck != ':')
-        throw shared.syntaxerr;
-
-    long long min,max;
-    if (!string2ll(sz, pchCheck - sz, &min))
-        throw shared.syntaxerr;
-
-    if (!string2ll(pchCheck+1, strlen(pchCheck+1), &max))
-        throw shared.syntaxerr;
-
-    return std::make_pair(min, max);
-}
-
-void bitopRangeCommand(client *c)
-{
-    char *opname = szFromObj(c->argv[1]);
-    robj *targetkey = c->argv[2];
-    unsigned long minlen = 0, maxlen = 0;
-
-    /* Parse the operation name. */
-    unsigned long op = bitopFromStr(opname);
-    if (op == BITOP_INVALID) {
-        addReply(c,shared.syntaxerr);
-        return;
-    }
-
-    /* Sanity check: NOT accepts only a single key argument. */
-    if (op == BITOP_NOT && c->argc != 4) {
-        addReplyError(c,"BITOP NOT must be called with a single source key.");
-        return;
-    }
-
-    if ((c->argc % 2) == 0)
-    {   // did someone forget a range?
-        addReply(c,shared.syntaxerr);
-        return;
-    }
-
-    /* Lookup keys, and store pointers to the string objects into an array. */
-    unsigned numkeys = (c->argc - 3) / 2;
-    std::vector<unsigned char*> vecsrc(numkeys);
-    std::vector<unsigned long> veclen(numkeys);
-    std::vector<robj_rorefptr> vecobjects(numkeys);
-    std::vector<std::unique_ptr<const char, void(*)(const char*)>> vecspsz;   // temp storage so we free allocated strings
-    
-    for (unsigned long j = 0; j < numkeys; j++) {
-        size_t iarg = (j*2)+3;
-        robj_roptr o = lookupKeyRead(c->db,c->argv[iarg]);
-        /* Handle non-existing keys as empty strings. */
-        if (o == nullptr) {
-            vecobjects[j] = nullptr;
-            vecsrc[j] = NULL;
-            veclen[j] = 0;
-            minlen = 0;
-            continue;
-        }
-        /* Return an error if one of the keys is not a string. */
-        if (checkType(c,o,OBJ_STRING))
-            return;
-        
-        vecobjects[j] = getDecodedObject(o);
-
-        auto range = parseRange(c->argv[iarg+1]);
-        if (range.first < 0 || (range.second < range.first && range.second != -1))
-            throw shared.syntaxerr;
-
-        vecsrc[j] = (unsigned char*)ptrFromObj(vecobjects[j]);
-        veclen[j] = sdslen(szFromObj(vecobjects[j]));
-
-        // Handle the offset
-        if ((size_t)range.first >= (veclen[j]*CHAR_BIT))
-        {   // the start position is longer than the string
-            vecsrc[j] = nullptr;
-            veclen[j] = 0;
-        }
-        else
-        {
-            vecsrc[j] += range.first/CHAR_BIT;
-            veclen[j] -= range.first/CHAR_BIT;
-            int bitshift = range.first % CHAR_BIT;
-            if (bitshift)
-            {
-                sds newstr = sdsnewlen(nullptr, veclen[j]);
-                for (size_t ich = 0; ich < veclen[j]; ++ich)
-                    newstr[ich] = static_cast<unsigned char>(vecsrc[j][ich]) >> bitshift;
-                vecsrc[j] = (unsigned char*)newstr;
-                auto spT = std::unique_ptr<const char, void(*)(const char*)>(newstr, sdsfree);
-                vecspsz.emplace_back(std::move(spT));
-            }
-        }
-
-        // Now the max char
-        if (range.second != -1)
-        {
-            if (range.second < 0)
-                throw shared.syntaxerr;
-            range.second -= range.first;    // make relative
-            int mod = range.second % CHAR_BIT;
-            if ((size_t)range.second < (veclen[j]*CHAR_BIT))
-            {
-                veclen[j] = range.second/CHAR_BIT;
-                if (mod)
-                    veclen[j]++;
-            }
-            if (mod && veclen[j] > 0)
-            {
-                sds newstr = sdsnewlen(nullptr, veclen[j]);
-                memcpy(newstr, vecsrc[j], veclen[j]);
-                newstr[sdslen(newstr)-1] &= ((1U << mod)-1);
-                vecsrc[j] = (unsigned char*)newstr;
-                auto spT = std::unique_ptr<const char, void(*)(const char*)>(newstr, sdsfree);
-                vecspsz.emplace_back(std::move(spT));
-            }
-        }
-
-        if (veclen[j] > maxlen) maxlen = veclen[j];
-        if (j == 0 || veclen[j] < minlen) minlen = veclen[j];
-    }
-
-    unsigned char *res = bitopCore(op, minlen, maxlen, numkeys, vecsrc.data(), veclen.data());
-
-    /* Store the computed value into the target key */
-    if (maxlen) {
-        robj *o = createObject(OBJ_STRING,res);
-        setKey(c->db,targetkey,o);
-        notifyKeyspaceEvent(NOTIFY_STRING,"set",targetkey,c->db->id);
-        decrRefCount(o);
-    } else if (dbDelete(c->db,targetkey)) {
-        signalModifiedKey(c->db,targetkey);
-        notifyKeyspaceEvent(NOTIFY_GENERIC,"del",targetkey,c->db->id);
-    }
-    g_pserver->dirty++;
-    addReplyLongLong(c,maxlen); /* Return the output string length in bytes. */
-}
-
 /* BITOP op_name target_key src_key1 src_key2 src_key3 ... src_keyN */
 void bitopCommand(client *c) {
    char *opname = szFromObj(c->argv[1]);
    robj *targetkey = c->argv[2];
    robj_roptr o;
-    unsigned long op, numkeys;
+    int op;
+    unsigned long j, numkeys;
    robj_roptr *objects;      /* Array of source objects. */
    unsigned char **src; /* Array of source strings pointers. */
    unsigned long *len, maxlen = 0; /* Array of length of src strings,
                                       and max len. */
    unsigned long minlen = 0;    /* Min len among the input keys. */
+    unsigned char *res = NULL; /* Resulting string. */

    /* Parse the operation name. */
-    op = bitopFromStr(opname);
-    if (op == BITOP_INVALID) {
+    if ((opname[0] == 'a' || opname[0] == 'A') && !strcasecmp(opname,"and"))
+        op = BITOP_AND;
+    else if((opname[0] == 'o' || opname[0] == 'O') && !strcasecmp(opname,"or"))
+        op = BITOP_OR;
+    else if((opname[0] == 'x' || opname[0] == 'X') && !strcasecmp(opname,"xor"))
+        op = BITOP_XOR;
+    else if((opname[0] == 'n' || opname[0] == 'N') && !strcasecmp(opname,"not"))
+        op = BITOP_NOT;
+    else if (!strcasecmp(opname, "lshift"))
+        op = BITOP_LSHIFT;
+    else if (!strcasecmp(opname, "rshift"))
+        op = BITOP_RSHIFT;
+    else {
        addReply(c,shared.syntaxerr);
        return;
    }
@@ -869,13 +627,29 @@ void bitopCommand(client *c) {
        return;
    }

+    bool fShiftOp = (op == BITOP_LSHIFT) || (op == BITOP_RSHIFT);
+    long long shift = 0;
+    
+    /* Sanity check: SHIFTS only accept a single arg and an integer */
+    if (fShiftOp) {
+        if (c->argc != 5) {
+            addReplyError(c,"BITOP SHIFT must be called with a single source key and an integer shift.");
+            return;
+        }
+        if (getLongLongFromObject(c->argv[4], &shift) != C_OK) {
+            addReplyError(c, "BITOP SHIFT's last parameter must be an integer");
+            return;
+        }
+        if (op == BITOP_RSHIFT)
+            shift = -shift;
+    }
+
    /* Lookup keys, and store pointers to the string objects into an array. */
-    numkeys = c->argc - 3;
+    numkeys = c->argc - (fShiftOp ? 4 : 3);
    src = (unsigned char**)zmalloc(sizeof(unsigned char*) * numkeys, MALLOC_LOCAL);
    len = (unsigned long*)zmalloc(sizeof(long) * numkeys, MALLOC_LOCAL);
    objects = (robj_roptr*)zmalloc(sizeof(robj_roptr) * numkeys, MALLOC_LOCAL);
-
-    for (unsigned long j = 0; j < numkeys; j++) {
+    for (j = 0; j < numkeys; j++) {
        o = lookupKeyRead(c->db,c->argv[j+3]);
        /* Handle non-existing keys as empty strings. */
        if (o == nullptr) {
@@ -904,9 +678,146 @@ void bitopCommand(client *c) {
        if (j == 0 || len[j] < minlen) minlen = len[j];
    }

-    unsigned char *res = bitopCore(op, minlen, maxlen, numkeys, src, len);
-    
-    for (unsigned long j = 0; j < numkeys; j++) {
+    if (fShiftOp)
+    {
+        long newlen = (long)maxlen + shift/CHAR_BIT;
+        if (shift > 0 && (shift % CHAR_BIT) != 0)
+            newlen++;
+
+        if (newlen < 0)
+            newlen = 0;
+        
+        if (newlen)
+        {
+            res = (unsigned char*) sdsnewlen(NULL,newlen);
+            if (shift >= 0)
+            {   // left shift
+                long byteoffset = shift/CHAR_BIT;
+                memset(res, 0, byteoffset);
+                long srcLen = newlen - byteoffset - ((shift % CHAR_BIT) ? 1 : 0);
+
+                // now the bitshift+copy
+                unsigned bitshift = shift % CHAR_BIT;
+                unsigned char carry = 0;
+                for (long iSrc = 0; iSrc < srcLen; ++iSrc)
+                {
+                    res[byteoffset+iSrc] = (src[0][iSrc] << bitshift) | carry;
+                    carry = src[0][iSrc] >> (CHAR_BIT - bitshift);
+                }
+                if (bitshift)
+                    res[newlen-1] = carry;
+            } 
+            else 
+            {   // right shift
+                long byteoffset = -shift/CHAR_BIT;
+                unsigned bitshift = -shift % CHAR_BIT;
+                if (bitshift)
+                    ++byteoffset;
+                res[0] = (src[0][byteoffset] << (CHAR_BIT-bitshift));
+                if (byteoffset > 0)
+                    res[0] |= (src[0][byteoffset-1] >> bitshift);
+                for (long idx = 1; idx < newlen; ++idx)
+                {
+                    res[idx] = (src[0][byteoffset+idx] << (CHAR_BIT-bitshift)) | (src[0][byteoffset+idx-1] >> bitshift);
+                }
+            }
+        }
+        maxlen = newlen;    // this is to ensure we DEL below if newlen was 0
+    }
+    else
+    {
+        /* Compute the bit operation, if at least one string is not empty. */
+        if (maxlen) {
+            res = (unsigned char*) sdsnewlen(NULL,maxlen);
+            unsigned char output, byte;
+            unsigned long i;
+
+            /* Fast path: as far as we have data for all the input bitmaps we
+            * can take a fast path that performs much better than the
+            * vanilla algorithm. On ARM we skip the fast path since it will
+            * result in GCC compiling the code using multiple-words load/store
+            * operations that are not supported even in ARM >= v6. */
+            j = 0;
+            #ifndef USE_ALIGNED_ACCESS
+            if (minlen >= sizeof(unsigned long)*4 && numkeys <= 16) {
+                unsigned long *lp[16];
+                unsigned long *lres = (unsigned long*) res;
+
+                /* Note: sds pointer is always aligned to 8 byte boundary. */
+                memcpy(lp,src,sizeof(unsigned long*)*numkeys);
+                memcpy(res,src[0],minlen);
+
+                /* Different branches per different operations for speed (sorry). */
+                if (op == BITOP_AND) {
+                    while(minlen >= sizeof(unsigned long)*4) {
+                        for (i = 1; i < numkeys; i++) {
+                            lres[0] &= lp[i][0];
+                            lres[1] &= lp[i][1];
+                            lres[2] &= lp[i][2];
+                            lres[3] &= lp[i][3];
+                            lp[i]+=4;
+                        }
+                        lres+=4;
+                        j += sizeof(unsigned long)*4;
+                        minlen -= sizeof(unsigned long)*4;
+                    }
+                } else if (op == BITOP_OR) {
+                    while(minlen >= sizeof(unsigned long)*4) {
+                        for (i = 1; i < numkeys; i++) {
+                            lres[0] |= lp[i][0];
+                            lres[1] |= lp[i][1];
+                            lres[2] |= lp[i][2];
+                            lres[3] |= lp[i][3];
+                            lp[i]+=4;
+                        }
+                        lres+=4;
+                        j += sizeof(unsigned long)*4;
+                        minlen -= sizeof(unsigned long)*4;
+                    }
+                } else if (op == BITOP_XOR) {
+                    while(minlen >= sizeof(unsigned long)*4) {
+                        for (i = 1; i < numkeys; i++) {
+                            lres[0] ^= lp[i][0];
+                            lres[1] ^= lp[i][1];
+                            lres[2] ^= lp[i][2];
+                            lres[3] ^= lp[i][3];
+                            lp[i]+=4;
+                        }
+                        lres+=4;
+                        j += sizeof(unsigned long)*4;
+                        minlen -= sizeof(unsigned long)*4;
+                    }
+                } else if (op == BITOP_NOT) {
+                    while(minlen >= sizeof(unsigned long)*4) {
+                        lres[0] = ~lres[0];
+                        lres[1] = ~lres[1];
+                        lres[2] = ~lres[2];
+                        lres[3] = ~lres[3];
+                        lres+=4;
+                        j += sizeof(unsigned long)*4;
+                        minlen -= sizeof(unsigned long)*4;
+                    }
+                }
+            }
+            #endif
+
+            /* j is set to the next byte to process by the previous loop. */
+            for (; j < maxlen; j++) {
+                output = (len[0] <= j) ? 0 : src[0][j];
+                if (op == BITOP_NOT) output = ~output;
+                for (i = 1; i < numkeys; i++) {
+                    byte = (len[i] <= j) ? 0 : src[i][j];
+                    switch(op) {
+                    case BITOP_AND: output &= byte; break;
+                    case BITOP_OR:  output |= byte; break;
+                    case BITOP_XOR: output ^= byte; break;
+                    }
+                }
+                res[j] = output;
+            }
+        }
+    }
+    for (j = 0; j < numkeys; j++) {
        if (objects[j])
            decrRefCount(objects[j]);
    }
@@ -221,8 +221,8 @@ void replyToBlockedClientTimedOut(client *c) {

 /* Mass-unblock clients because something changed in the instance that makes
 * blocking no longer safe. For example clients blocked in list operations
- * in an instance which turns from master to slave is unsafe, so this function
- * is called when a master turns into a slave.
+ * in an instance which turns from master to replica is unsafe, so this function
+ * is called when a master turns into a replica.
 *
 * The semantics is to send an -UNBLOCKED error to the client, disconnecting
 * it at the same time. */
@@ -499,7 +499,7 @@ void clusterInit(void) {
    }

    if (listenToPort(g_pserver->port+CLUSTER_PORT_INCR,
-        g_pserver->cfd,&g_pserver->cfd_count, 0 /*fReusePort*/) == C_ERR)
+        g_pserver->cfd,&g_pserver->cfd_count, 0 /*fReusePort*/, 0 /*fFirstListen*/) == C_ERR)
    {
        exit(1);
    } else {
@@ -617,6 +617,17 @@ clusterLink *createClusterLink(clusterNode *node) {
 * This function will just make sure that the original node associated
 * with this link will have the 'link' field set to NULL. */
 void freeClusterLink(clusterLink *link) {
+    if (ielFromEventLoop(serverTL->el) != IDX_EVENT_LOOP_MAIN)
+    {
+        // we can't perform this operation on this thread, queue it on the main thread
+        if (link->node)
+            link->node->link = NULL;
+        link->node = nullptr;
+        aePostFunction(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el, [link]{
+            freeClusterLink(link);
+        });
+        return;
+    }
    if (link->fd != -1) {
        aeDeleteFileEvent(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el, link->fd, AE_READABLE|AE_WRITABLE);
    }
@@ -2139,21 +2150,35 @@ void handleLinkIOError(clusterLink *link) {
 * consumed by write(). We don't try to optimize this for speed too much
 * as this is a very low traffic channel. */
 void clusterWriteHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
+    serverAssert(ielFromEventLoop(el) == IDX_EVENT_LOOP_MAIN);
    clusterLink *link = (clusterLink*) privdata;
    ssize_t nwritten;
    UNUSED(el);
    UNUSED(mask);

-    nwritten = write(fd, link->sndbuf, sdslen(link->sndbuf));
+    // We're about to release the lock, so the link's sndbuf needs to be owned fully by us
+    //  allocate a new one in case anyone tries to write while we're waiting
+    sds sndbuf = link->sndbuf;
+    link->sndbuf = sdsempty();
+
+    aeReleaseLock();
+    nwritten = write(fd, sndbuf, sdslen(sndbuf));
+    aeAcquireLock();
+
    if (nwritten <= 0) {
        serverLog(LL_DEBUG,"I/O error writing to node link: %s",
            (nwritten == -1) ? strerror(errno) : "short write");
+        sdsfree(sndbuf);
        handleLinkIOError(link);
        return;
    }
-    sdsrange(link->sndbuf,nwritten,-1);
+    sdsrange(sndbuf,nwritten,-1);
+    // Restore our send buffer, ensuring any unsent data is first
+    sndbuf = sdscat(sndbuf, link->sndbuf);
+    sdsfree(link->sndbuf);
+    link->sndbuf = sndbuf;
    if (sdslen(link->sndbuf) == 0)
-        aeDeleteFileEvent(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el, link->fd, AE_WRITABLE);
+        aeDeleteFileEvent(el, link->fd, AE_WRITABLE);
 }

 /* Read data. Try to read the first field of the header first to check the
@@ -2228,9 +2253,10 @@ void clusterReadHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
 * the link to be invalidated, so it is safe to call this function
 * from event handlers that will do stuff with the same link later. */
 void clusterSendMessage(clusterLink *link, unsigned char *msg, size_t msglen) {
+    serverAssert(GlobalLocksAcquired());
    if (sdslen(link->sndbuf) == 0 && msglen != 0)
-        aeCreateFileEvent(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el,link->fd,AE_WRITABLE|AE_BARRIER,
-                    clusterWriteHandler,link);
+        aeCreateRemoteFileEvent(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el,link->fd,AE_WRITABLE|AE_BARRIER,
+                    clusterWriteHandler,link,false);

    link->sndbuf = sdscatlen(link->sndbuf, msg, msglen);

@@ -3284,7 +3310,7 @@ void clusterHandleSlaveMigration(int max_slaves) {
 void resetManualFailover(void) {
    if (g_pserver->cluster->mf_end && clientsArePaused()) {
        g_pserver->clients_pause_end_time = 0;
-        clientsArePaused(); /* Just use the side effect of the function. */
+        unpauseClientsIfNecessary();
    }
    g_pserver->cluster->mf_end = 0; /* No manual failover in progress. */
    g_pserver->cluster->mf_can_start = 0;
@@ -4154,57 +4180,76 @@ void clusterReplyMultiBulkSlots(client *c) {
    dictIterator *di = dictGetSafeIterator(g_pserver->cluster->nodes);
    while((de = dictNext(di)) != NULL) {
        clusterNode *node = (clusterNode*)dictGetVal(de);
-        int j = 0, start = -1;
+        int start = -1;

        /* Skip slaves (that are iterated when producing the output of their
         * master) and  masters not serving any slot. */
        if (!nodeIsMaster(node) || node->numslots == 0) continue;
+        
+        static_assert((CLUSTER_SLOTS % (sizeof(uint32_t)*8)) == 0, "code below assumes the bitfield is a multiple of sizeof(unsinged)");

-        for (j = 0; j < CLUSTER_SLOTS; j++) {
-            int bit, i;
-
-            if ((bit = clusterNodeGetSlotBit(node,j)) != 0) {
-                if (start == -1) start = j;
+        for (unsigned iw = 0; iw < (CLUSTER_SLOTS/sizeof(uint32_t)/8); ++iw)
+        {
+            uint32_t wordCur = reinterpret_cast<uint32_t*>(node->slots)[iw];
+            if (iw != ((CLUSTER_SLOTS/sizeof(uint32_t)/8)-1))
+            {
+                if (start == -1 && wordCur == 0)
+                    continue;
+                if (start != -1 && (wordCur+1)==0)
+                    continue;
            }
-            if (start != -1 && (!bit || j == CLUSTER_SLOTS-1)) {
-                int nested_elements = 3; /* slots (2) + master addr (1). */
-                void *nested_replylen = addReplyDeferredLen(c);

-                if (bit && j == CLUSTER_SLOTS-1) j++;
-
-                /* If slot exists in output map, add to it's list.
-                 * else, create a new output map for this slot */
-                if (start == j-1) {
-                    addReplyLongLong(c, start); /* only one slot; low==high */
-                    addReplyLongLong(c, start);
-                } else {
-                    addReplyLongLong(c, start); /* low */
-                    addReplyLongLong(c, j-1);   /* high */
+            unsigned ibitStartLoop = iw*sizeof(uint32_t)*8;
+    
+            for (unsigned j = ibitStartLoop; j < (iw+1)*sizeof(uint32_t)*8; j++) {
+                int i;
+                int bit = (int)(wordCur & 1);
+                wordCur >>= 1;
+                if (bit != 0) {
+                    if (start == -1) start = j;
                }
-                start = -1;
+                if (start != -1 && (!bit || j == CLUSTER_SLOTS-1)) {
+                    int nested_elements = 3; /* slots (2) + master addr (1). */
+                    void *nested_replylen = addReplyDeferredLen(c);

-                /* First node reply position is always the master */
-                addReplyArrayLen(c, 3);
-                addReplyBulkCString(c, node->ip);
-                addReplyLongLong(c, node->port);
-                addReplyBulkCBuffer(c, node->name, CLUSTER_NAMELEN);
+                    if (bit && j == CLUSTER_SLOTS-1) j++;

-                /* Remaining nodes in reply are replicas for slot range */
-                for (i = 0; i < node->numslaves; i++) {
-                    /* This loop is copy/pasted from clusterGenNodeDescription()
-                     * with modifications for per-slot node aggregation */
-                    if (nodeFailed(node->slaves[i])) continue;
+                    /* If slot exists in output map, add to it's list.
+                    * else, create a new output map for this slot */
+                    if (start == j-1) {
+                        addReplyLongLong(c, start); /* only one slot; low==high */
+                        addReplyLongLong(c, start);
+                    } else {
+                        addReplyLongLong(c, start); /* low */
+                        addReplyLongLong(c, j-1);   /* high */
+                    }
+                    start = -1;
+
+                    /* First node reply position is always the master */
                    addReplyArrayLen(c, 3);
-                    addReplyBulkCString(c, node->slaves[i]->ip);
-                    addReplyLongLong(c, node->slaves[i]->port);
-                    addReplyBulkCBuffer(c, node->slaves[i]->name, CLUSTER_NAMELEN);
-                    nested_elements++;
+                    addReplyBulkCString(c, node->ip);
+                    addReplyLongLong(c, node->port);
+                    addReplyBulkCBuffer(c, node->name, CLUSTER_NAMELEN);
+
+                    /* Remaining nodes in reply are replicas for slot range */
+                    for (i = 0; i < node->numslaves; i++) {
+                        /* This loop is copy/pasted from clusterGenNodeDescription()
+                        * with modifications for per-slot node aggregation */
+                        if (nodeFailed(node->slaves[i])) continue;
+                        addReplyArrayLen(c, 3);
+                        addReplyBulkCString(c, node->slaves[i]->ip);
+                        addReplyLongLong(c, node->slaves[i]->port);
+                        addReplyBulkCBuffer(c, node->slaves[i]->name, CLUSTER_NAMELEN);
+                        nested_elements++;
+                    }
+                    setDeferredArrayLen(c, nested_replylen, nested_elements);
+                    num_masters++;
                }
-                setDeferredArrayLen(c, nested_replylen, nested_elements);
-                num_masters++;
            }
        }
+        serverAssert(start == -1);
    }
+    
    dictReleaseIterator(di);
    setDeferredArrayLen(c, slot_replylen, num_masters);
 }
@@ -96,7 +96,7 @@ configEnum aof_fsync_enum[] = {
 /* Output buffer limits presets. */
 clientBufferLimitsConfig clientBufferLimitsDefaults[CLIENT_TYPE_OBUF_COUNT] = {
    {0, 0, 0}, /* normal */
-    {1024*1024*256, 1024*1024*64, 60}, /* slave */
+    {1024*1024*256, 1024*1024*64, 60}, /* replica */
    {1024*1024*32, 1024*1024*8, 60}  /* pubsub */
 };

@@ -800,6 +800,8 @@ void loadServerConfigFromString(char *config) {
            serverLog(LL_WARNING, "Warning version is overriden to: %s\n", KEYDB_SET_VERSION);
        } else if (!strcasecmp(argv[0],"testmode") && argc == 2){
            g_fTestMode = yesnotoi(argv[1]);
+        } else if (!strcasecmp(argv[0],"rdbfuzz-mode")) {
+            // NOP, handled in main
        } else {
            err = "Bad directive or wrong number of arguments"; goto loaderr;
        }
@@ -30,6 +30,7 @@
 #include "server.h"
 #include "cluster.h"
 #include "atomicvar.h"
+#include "aelocker.h"

 #include <signal.h>
 #include <ctype.h>
@@ -114,7 +115,7 @@ static robj *lookupKey(redisDb *db, robj *key, int flags) {
 *  LOOKUP_NOTOUCH: don't alter the last access time of the key.
 *
 * Note: this function also returns NULL if the key is logically expired
- * but still existing, in case this is a slave, since this API is called only
+ * but still existing, in case this is a replica, since this API is called only
 * for read operations. Even if the key expiry is master-driven, we can
 * correctly report a key is expired on slaves even if the master is lagging
 * expiring our key via DELs in the replication link. */
@@ -132,7 +133,7 @@ robj_roptr lookupKeyReadWithFlags(redisDb *db, robj *key, int flags) {
            return NULL;
        }

-        /* However if we are in the context of a slave, expireIfNeeded() will
+        /* However if we are in the context of a replica, 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.
@@ -343,7 +344,7 @@ robj *dbRandomKey(redisDb *db) {
            if (allvolatile && listLength(g_pserver->masters) && --maxtries == 0) {
                /* If the DB is composed only of keys with an expire set,
                    * it could happen that all the keys are already logically
-                    * expired in the slave, so the function cannot stop because
+                    * expired in the replica, so the function cannot stop because
                    * expireIfNeeded() is false, nor it can stop because
                    * dictGetRandomKey() returns NULL (there are keys to return).
                    * To prevent the infinite loop we do some tries, but if there
@@ -1132,7 +1133,8 @@ int dbSwapDatabases(int id1, int id2) {
    if (id1 < 0 || id1 >= cserver.dbnum ||
        id2 < 0 || id2 >= cserver.dbnum) return C_ERR;
    if (id1 == id2) return C_OK;
-    redisDb aux = g_pserver->db[id1];
+    redisDb aux; 
+    memcpy(&aux, &g_pserver->db[id1], sizeof(redisDb));
    redisDb *db1 = &g_pserver->db[id1], *db2 = &g_pserver->db[id2];

    /* Swap hash tables. Note that we don't swap blocking_keys,
@@ -1217,6 +1219,39 @@ int removeExpireCore(redisDb *db, robj *key, dictEntry *de) {
    return 1;
 }

+int removeSubkeyExpire(redisDb *db, robj *key, robj *subkey) {
+    dictEntry *de = dictFind(db->pdict,ptrFromObj(key));
+    serverAssertWithInfo(NULL,key,de != NULL);
+    
+    robj *val = (robj*)dictGetVal(de);
+    if (!val->FExpires())
+        return 0;
+    
+    auto itr = db->setexpire->find((sds)dictGetKey(de));
+    serverAssert(itr != db->setexpire->end());
+    serverAssert(itr->key() == (sds)dictGetKey(de));
+    if (!itr->FFat())
+        return 0;
+
+    int found = 0;
+    for (auto subitr : *itr)
+    {
+        if (subitr.subkey() == nullptr)
+            continue;
+        if (sdscmp((sds)subitr.subkey(), szFromObj(subkey)) == 0)
+        {
+            itr->erase(subitr);
+            found = 1;
+            break;
+        }
+    }
+
+    if (itr->pfatentry()->size() == 0)
+        removeExpireCore(db, key, de);
+
+    return found;
+}
+
 /* Set an expire to the specified key. If the expire is set in the context
 * of an user calling a command 'c' is the client, otherwise 'c' is set
 * to NULL. The 'when' parameter is the absolute unix time in milliseconds
@@ -1325,7 +1360,7 @@ expireEntry *getExpire(redisDb *db, robj_roptr key) {
 * to all the slaves and the AOF file if enabled.
 *
 * This way the key expiry is centralized in one place, and since both
- * AOF and the master->slave link guarantee operation ordering, everything
+ * AOF and the master->replica link guarantee operation ordering, everything
 * will be consistent even if we allow write operations against expiring
 * keys. */
 void propagateExpire(redisDb *db, robj *key, int lazy) {
@@ -1339,7 +1374,9 @@ void propagateExpire(redisDb *db, robj *key, int lazy) {

    if (g_pserver->aof_state != AOF_OFF)
        feedAppendOnlyFile(cserver.delCommand,db->id,argv,2);
-    replicationFeedSlaves(g_pserver->slaves,db->id,argv,2);
+    // Active replicas do their own expiries, do not propogate
+    if (!g_pserver->fActiveReplica)
+        replicationFeedSlaves(g_pserver->slaves,db->id,argv,2);

    decrRefCount(argv[0]);
    decrRefCount(argv[1]);
@@ -1383,10 +1420,10 @@ int keyIsExpired(redisDb *db, robj *key) {
 * is via lookupKey*() family of functions.
 *
 * The behavior of the function depends on the replication role of the
- * instance, because slave instances do not expire keys, they wait
+ * instance, because replica instances do not expire keys, they wait
 * for DELs from the master for consistency matters. However even
 * slaves will try to have a coherent return value for the function,
- * so that read commands executed in the slave side will be able to
+ * so that read commands executed in the replica side will be able to
 * behave like if the key is expired even if still present (because the
 * master has yet to propagate the DEL).
 *
@@ -1399,15 +1436,15 @@ int keyIsExpired(redisDb *db, robj *key) {
 int expireIfNeeded(redisDb *db, robj *key) {
    if (!keyIsExpired(db,key)) return 0;

-    /* If we are running in the context of a slave, instead of
+    /* If we are running in the context of a replica, instead of
     * evicting the expired key from the database, we return ASAP:
-     * the slave key expiration is controlled by the master that will
+     * the replica key expiration is controlled by the master that will
     * send us synthesized DEL operations for expired keys.
     *
     * Still we try to return the right information to the caller,
     * that is, 0 if we think the key should be still valid, 1 if
     * we think the key is expired at this time. */
-    if (listLength(g_pserver->masters)) return 1;
+    if (listLength(g_pserver->masters) && !g_pserver->fActiveReplica) return 1;

    /* Delete the key */
    g_pserver->stat_expiredkeys++;
@@ -55,7 +55,7 @@ typedef ucontext_t sigcontext_t;
 #endif
 #endif

-bool g_fInCrash = false;
+int g_fInCrash = false;

 /* ================================= Debugging ============================== */

@@ -682,10 +682,12 @@ NULL
        changeReplicationId();
        clearReplicationId2();
        addReply(c,shared.ok);
-    } else if (!strcasecmp(szFromObj(c->argv[1]),"stringmatch-test") && c->argc == 2)
-    {
+    } else if (!strcasecmp(szFromObj(c->argv[1]),"stringmatch-test") && c->argc == 2) {
        stringmatchlen_fuzz_test();
        addReplyStatus(c,"Apparently Redis did not crash: test passed");
+    } else if (!strcasecmp(szFromObj(c->argv[1]), "force-master") && c->argc == 2) {
+        c->flags |= CLIENT_MASTER | CLIENT_MASTER_FORCE_REPLY;
+        addReply(c, shared.ok);
    } else {
        addReplySubcommandSyntaxError(c);
        return;
@@ -374,8 +374,8 @@ size_t freeMemoryGetNotCountedMemory(void) {

        listRewind(g_pserver->slaves,&li);
        while((ln = listNext(&li))) {
-            client *slave = (client*)listNodeValue(ln);
-            overhead += getClientOutputBufferMemoryUsage(slave);
+            client *replica = (client*)listNodeValue(ln);
+            overhead += getClientOutputBufferMemoryUsage(replica);
        }
    }
    if (g_pserver->aof_state != AOF_OFF) {
@@ -130,28 +130,44 @@ void activeExpireCycleExpire(redisDb *db, expireEntry &e, long long now) {
    }
 }

-void expireMemberCommand(client *c)
+int parseUnitString(const char *sz)
 {
-    long long when;
-    if (getLongLongFromObjectOrReply(c, c->argv[3], &when, NULL) != C_OK)
-        return;
+    if (strcasecmp(sz, "s") == 0)
+        return UNIT_SECONDS;
+    if (strcasecmp(sz, "ms") == 0)
+        return UNIT_MILLISECONDS;
+    return -1;
+}

-    when *= 1000;
-    when += mstime();
-
-    /* No key, return zero. */
-    dictEntry *de = dictFind(c->db->pdict, szFromObj(c->argv[1]));
-    if (de == NULL) {
-        addReply(c,shared.czero);
+void expireMemberCore(client *c, robj *key, robj *subkey, long long basetime, long long when, int unit)
+{
+    switch (unit)
+    {
+    case UNIT_SECONDS:
+        when *= 1000;
+    case UNIT_MILLISECONDS:
+        break;
+    
+    default:
+        addReplyError(c, "Invalid unit arg");
        return;
    }
+    
+    when += basetime;

-    robj *val = (robj*)dictGetVal(de);
+    /* No key, return zero. */
+    robj *val = lookupKeyWriteOrReply(c, key, shared.czero);
+    if (val == NULL) {
+        return;
+    }

    switch (val->type)
    {
    case OBJ_SET:
-        // these types are safe
+        if (!setTypeIsMember(val, szFromObj(subkey))) {
+            addReply(c,shared.czero);
+            return;
+        }
        break;

    default:
@@ -159,11 +175,40 @@ void expireMemberCommand(client *c)
        return;
    }

-    setExpire(c, c->db, c->argv[1], c->argv[2], when);
+    setExpire(c, c->db, key, subkey, when);

-    addReply(c, shared.ok);
+    addReply(c, shared.cone);
 }

+void expireMemberCommand(client *c)
+{
+    long long when;
+    if (getLongLongFromObjectOrReply(c, c->argv[3], &when, NULL) != C_OK)
+        return;
+
+    if (c->argc > 5) {
+        addReplyError(c, "Invalid number of arguments");
+        return;
+    }
+
+    int unit = UNIT_SECONDS;
+    if (c->argc == 5) {
+        unit = parseUnitString(szFromObj(c->argv[4]));
+    }
+
+    expireMemberCore(c, c->argv[1], c->argv[2], mstime(), when, unit);
+}
+
+void expireMemberAtCommand(client *c)
+{
+    long long when;
+    if (getLongLongFromObjectOrReply(c, c->argv[3], &when, NULL) != C_OK)
+        return;
+
+    expireMemberCore(c, c->argv[1], c->argv[2], 0, when, UNIT_SECONDS);
+}
+
+
 /* Try to expire a few timed out keys. The algorithm used is adaptive and
 * will use few CPU cycles if there are few expiring keys, otherwise
 * it will get more aggressive to avoid that too much memory is used by
@@ -307,17 +352,17 @@ void activeExpireCycle(int type) {
 *
 * Normally slaves do not process expires: they wait the masters to synthesize
 * DEL operations in order to retain consistency. However writable slaves are
- * an exception: if a key is created in the slave and an expire is assigned
+ * an exception: if a key is created in the replica and an expire is assigned
 * to it, we need a way to expire such a key, since the master does not know
 * anything about such a key.
 *
- * In order to do so, we track keys created in the slave side with an expire
+ * In order to do so, we track keys created in the replica side with an expire
 * set, and call the expireSlaveKeys() function from time to time in order to
 * reclaim the keys if they already expired.
 *
 * Note that the use case we are trying to cover here, is a popular one where
 * slaves are put in writable mode in order to compute slow operations in
- * the slave side that are mostly useful to actually read data in a more
+ * the replica side that are mostly useful to actually read data in a more
 * processed way. Think at sets intersections in a tmp key, with an expire so
 * that it is also used as a cache to avoid intersecting every time.
 *
@@ -326,7 +371,7 @@ void activeExpireCycle(int type) {
 *----------------------------------------------------------------------------*/

 /* The dictionary where we remember key names and database ID of keys we may
- * want to expire from the slave. Since this function is not often used we
+ * want to expire from the replica. Since this function is not often used we
 * don't even care to initialize the database at startup. We'll do it once
 * the feature is used the first time, that is, when rememberSlaveKeyWithExpire()
 * is called.
@@ -389,7 +434,7 @@ void expireSlaveKeys(void) {
        }

        /* Set the new bitmap as value of the key, in the dictionary
-         * of keys with an expire set directly in the writable slave. Otherwise
+         * of keys with an expire set directly in the writable replica. Otherwise
         * if the bitmap is zero, we no longer need to keep track of it. */
        if (new_dbids)
            dictSetUnsignedIntegerVal(de,new_dbids);
@@ -406,7 +451,7 @@ void expireSlaveKeys(void) {
 }

 /* Track keys that received an EXPIRE or similar command in the context
- * of a writable slave. */
+ * of a writable replica. */
 void rememberSlaveKeyWithExpire(redisDb *db, robj *key) {
    if (slaveKeysWithExpire == NULL) {
        static dictType dt = {
@@ -448,7 +493,7 @@ size_t getSlaveKeyWithExpireCount(void) {
 *
 * Note: technically we should handle the case of a single DB being flushed
 * but it is not worth it since anyway race conditions using the same set
- * of key names in a wriatable slave and in its master will lead to
+ * of key names in a wriatable replica and in its master will lead to
 * inconsistencies. This is just a best-effort thing we do. */
 void flushSlaveKeysWithExpireList(void) {
    if (slaveKeysWithExpire) {
@@ -486,11 +531,11 @@ void expireGenericCommand(client *c, long long basetime, int unit) {

    /* EXPIRE with negative TTL, or EXPIREAT with a timestamp into the past
     * should never be executed as a DEL when load the AOF or in the context
-     * of a slave instance.
+     * of a replica instance.
     *
     * Instead we take the other branch of the IF statement setting an expire
     * (possibly in the past) and wait for an explicit DEL from the master. */
-    if (when <= mstime() && !g_pserver->loading && !listLength(g_pserver->masters)) {
+    if (when <= mstime() && !g_pserver->loading && (!listLength(g_pserver->masters) || g_pserver->fActiveReplica)) {
        robj *aux;

        int deleted = g_pserver->lazyfree_lazy_expire ? dbAsyncDelete(c->db,key) :
@@ -544,11 +589,32 @@ void ttlGenericCommand(client *c, int output_ms) {
        addReplyLongLong(c,-2);
        return;
    }
+
    /* The key exists. Return -1 if it has no expire, or the actual
-     * TTL value otherwise. */
+        * TTL value otherwise. */
    expireEntry *pexpire = getExpire(c->db,c->argv[1]);
-    if (pexpire != nullptr)
-        pexpire->FGetPrimaryExpire(&expire);
+
+    if (c->argc == 2) {
+        // primary expire    
+        if (pexpire != nullptr)
+            pexpire->FGetPrimaryExpire(&expire);
+    } else if (c->argc == 3) {
+        // We want a subkey expire
+        if (pexpire && pexpire->FFat()) {
+            for (auto itr : *pexpire) {
+                if (itr.subkey() == nullptr)
+                    continue;
+                if (sdscmp((sds)itr.subkey(), szFromObj(c->argv[2])) == 0) {
+                    expire = itr.when();
+                    break;
+                }
+            }
+        }
+    } else {
+        addReplyError(c, "Invalid arguments");
+        return;
+    }
+
    
    if (expire != -1) {
        ttl = expire-mstime();
@@ -574,11 +640,22 @@ void pttlCommand(client *c) {
 /* PERSIST key */
 void persistCommand(client *c) {
    if (lookupKeyWrite(c->db,c->argv[1])) {
-        if (removeExpire(c->db,c->argv[1])) {
-            addReply(c,shared.cone);
-            g_pserver->dirty++;
+        if (c->argc == 2) {
+            if (removeExpire(c->db,c->argv[1])) {
+                addReply(c,shared.cone);
+                g_pserver->dirty++;
+            } else {
+                addReply(c,shared.czero);
+            }
+        } else if (c->argc == 3) {
+            if (removeSubkeyExpire(c->db, c->argv[1], c->argv[2])) {
+                addReply(c,shared.cone);
+                g_pserver->dirty++;
+            } else {
+                addReply(c,shared.czero);
+            }
        } else {
-            addReply(c,shared.czero);
+            addReplyError(c, "Invalid arguments");
        }
    } else {
        addReply(c,shared.czero);
@@ -36,10 +36,13 @@
 #include <assert.h>
 #include <pthread.h>
 #include <limits.h>
+#include <map>
 #ifdef __linux__
 #include <linux/futex.h>
 #endif
 #include <string.h>
+#include <stdarg.h>
+#include <stdio.h>

 #ifdef __APPLE__
 #include <TargetConditionals.h>
@@ -57,6 +60,7 @@
 #define UNUSED(x) ((void)x)
 #endif

+extern int g_fInCrash;

 /****************************************************
 *
@@ -125,6 +129,80 @@

 #endif

+#pragma weak _serverPanic
+extern "C"  __attribute__((weak)) void _serverPanic(const char * /*file*/, int /*line*/, const char * /*msg*/, ...)
+{
+    *((char*)-1) = 'x';
+}
+
+#pragma weak serverLog
+__attribute__((weak)) void serverLog(int , const char *fmt, ...)
+{
+    va_list args;
+    va_start(args, fmt);
+    vprintf(fmt, args);
+    va_end(args);
+    printf("\n");
+}
+
+class DeadlockDetector
+{
+    std::map<pid_t, fastlock *> m_mapwait;
+    fastlock m_lock { "deadlock detector" };
+public:
+    void registerwait(fastlock *lock, pid_t thispid)
+    {
+        if (lock == &m_lock || g_fInCrash)
+            return;
+        fastlock_lock(&m_lock);
+        m_mapwait.insert(std::make_pair(thispid, lock));
+
+        // Detect cycles
+        pid_t pidCheck = thispid;
+        size_t cchecks = 0;
+        for (;;)
+        {
+            auto itr = m_mapwait.find(pidCheck);
+            if (itr == m_mapwait.end())
+                break;
+            pidCheck = itr->second->m_pidOwner;
+            if (pidCheck == thispid)
+            {
+                // Deadlock detected, printout some debugging info and crash
+                serverLog(3 /*LL_WARNING*/, "\n\n");
+                serverLog(3 /*LL_WARNING*/, "!!! ERROR: Deadlock detected !!!");
+                pidCheck = thispid;
+                for (;;)
+                {
+                    auto itr = m_mapwait.find(pidCheck);
+                    serverLog(3 /* LL_WARNING */, "\t%d: (%p) %s", pidCheck, itr->second, itr->second->szName);
+                    pidCheck = itr->second->m_pidOwner;
+                    if (pidCheck == thispid)
+                        break;
+                }
+                serverLog(3 /*LL_WARNING*/, "!!! KeyDB Will Now Crash !!!");
+                _serverPanic(__FILE__, __LINE__, "Deadlock detected");
+            }
+
+            if (cchecks > m_mapwait.size())
+                break;  // There is a cycle but we're not in it
+            ++cchecks;
+        }
+        fastlock_unlock(&m_lock);
+    }
+
+    void clearwait(fastlock *lock, pid_t thispid)
+    {
+        if (lock == &m_lock || g_fInCrash)
+            return;
+        fastlock_lock(&m_lock);
+        m_mapwait.erase(thispid);
+        fastlock_unlock(&m_lock);
+    }
+};
+
+DeadlockDetector g_dlock;
+
 static_assert(sizeof(pid_t) <= sizeof(fastlock::m_pidOwner), "fastlock::m_pidOwner not large enough");
 uint64_t g_longwaits = 0;

@@ -135,7 +213,6 @@ uint64_t fastlock_getlongwaitcount()
    return rval;
 }

-#ifndef ASM_SPINLOCK
 #ifdef __linux__
 static int futex(volatile unsigned *uaddr, int futex_op, int val,
    const struct timespec *timeout, int val3)
@@ -144,7 +221,6 @@ static int futex(volatile unsigned *uaddr, int futex_op, int val,
                    timeout, uaddr, val3);
 }
 #endif
-#endif

 extern "C" pid_t gettid()
 {
@@ -163,13 +239,29 @@ extern "C" pid_t gettid()
    return pidCache;
 }

-extern "C" void fastlock_init(struct fastlock *lock)
+extern "C" void fastlock_sleep(fastlock *lock, pid_t pid, unsigned wake, unsigned mask)
+{
+#ifdef __linux__
+    g_dlock.registerwait(lock, pid);
+    __atomic_fetch_or(&lock->futex, mask, __ATOMIC_ACQUIRE);
+    futex(&lock->m_ticket.u, FUTEX_WAIT_BITSET_PRIVATE, wake, nullptr, mask);
+    __atomic_fetch_and(&lock->futex, ~mask, __ATOMIC_RELEASE);
+    g_dlock.clearwait(lock, pid);
+#endif
+    __atomic_fetch_add(&g_longwaits, 1, __ATOMIC_RELAXED);
+}
+
+extern "C" void fastlock_init(struct fastlock *lock, const char *name)
 {
    lock->m_ticket.m_active = 0;
    lock->m_ticket.m_avail = 0;
    lock->m_depth = 0;
    lock->m_pidOwner = -1;
    lock->futex = 0;
+    int cch = strlen(name);
+    cch = std::min<int>(cch, sizeof(lock->szName)-1);
+    memcpy(lock->szName, name, cch);
+    lock->szName[cch] = '\0';
    ANNOTATE_RWLOCK_CREATE(lock);
 }

@@ -184,12 +276,12 @@ extern "C" void fastlock_lock(struct fastlock *lock)
        return;
    }

+    int tid = gettid();
    unsigned myticket = __atomic_fetch_add(&lock->m_ticket.m_avail, 1, __ATOMIC_RELEASE);
-#ifdef __linux__
    unsigned mask = (1U << (myticket % 32));
-#endif
    int cloops = 0;
    ticket ticketT;
+
    for (;;)
    {
        __atomic_load(&lock->m_ticket.u, &ticketT.u, __ATOMIC_ACQUIRE);
@@ -201,17 +293,11 @@ extern "C" void fastlock_lock(struct fastlock *lock)
 #endif
        if ((++cloops % 1024*1024) == 0)
        {
-#ifdef __linux__
-            __atomic_fetch_or(&lock->futex, mask, __ATOMIC_ACQUIRE);
-            futex(&lock->m_ticket.u, FUTEX_WAIT_BITSET_PRIVATE, ticketT.u, nullptr, mask);
-            __atomic_fetch_and(&lock->futex, ~mask, __ATOMIC_RELEASE);
-#endif
-            __atomic_fetch_add(&g_longwaits, 1, __ATOMIC_RELAXED);
+            fastlock_sleep(lock, tid, ticketT.u, mask);
        }
    }

    lock->m_depth = 1;
-    int tid = gettid();
    __atomic_store(&lock->m_pidOwner, &tid, __ATOMIC_RELEASE);
    ANNOTATE_RWLOCK_ACQUIRED(lock, true);
    std::atomic_thread_fence(std::memory_order_acquire);
@@ -1,5 +1,6 @@
 #pragma once
 #include <inttypes.h>
+#include <stddef.h>

 #ifdef __cplusplus
 extern "C" {
@@ -7,7 +8,7 @@ extern "C" {

 /* Begin C API */
 struct fastlock;
-void fastlock_init(struct fastlock *lock);
+void fastlock_init(struct fastlock *lock, const char *name);
 void fastlock_lock(struct fastlock *lock);
 int fastlock_trylock(struct fastlock *lock, int fWeak);
 void fastlock_unlock(struct fastlock *lock);
@@ -40,29 +41,31 @@ struct ticket

 struct fastlock
 {
-    volatile struct ticket m_ticket;
-
    volatile int m_pidOwner;
    volatile int m_depth;
+    char szName[56];
+    /* Volatile data on seperate cache line */
+    volatile struct ticket m_ticket;
    unsigned futex;
+    char padding[56];   // ensure ticket and futex are on their own independent cache line

 #ifdef __cplusplus
-    fastlock()
+    fastlock(const char *name)
    {
-        fastlock_init(this);
+        fastlock_init(this, name);
    }

-    void lock()
+    inline void lock()
    {
        fastlock_lock(this);
    }

-    bool try_lock(bool fWeak = false)
+    inline bool try_lock(bool fWeak = false)
    {
        return !!fastlock_trylock(this, fWeak);
    }

-    void unlock()
+    inline void unlock()
    {
        fastlock_unlock(this);
    }
@@ -80,3 +83,5 @@ struct fastlock
    bool fOwnLock();   // true if this thread owns the lock, NOTE: not 100% reliable, use for debugging only
 #endif
 };
+
+static_assert(offsetof(struct fastlock, m_ticket) == 64, "ensure padding is correct");
@@ -1,156 +1,164 @@
-section .text
+.intel_syntax noprefix
+.text

-extern gettid
-extern sched_yield
-extern g_longwaits
+.extern gettid
+.extern fastlock_sleep

-;	This is the first use of assembly in this codebase, a valid question is WHY?
-;	The spinlock we implement here is performance critical, and simply put GCC
-;	emits awful code.  The original C code is left in fastlock.cpp for reference
-;	and x-plat.
+#	This is the first use of assembly in this codebase, a valid question is WHY?
+#	The spinlock we implement here is performance critical, and simply put GCC
+#	emits awful code.  The original C code is left in fastlock.cpp for reference
+#	and x-plat.

-ALIGN 16
-global fastlock_lock
+.ALIGN 16
+.global fastlock_lock
+.type   fastlock_lock,@function
 fastlock_lock:
-	; RDI points to the struct:
-	;	uint16_t active
-	;	uint16_t avail
-	;	int32_t m_pidOwner
-	;	int32_t m_depth
+	.cfi_startproc
+	.cfi_def_cfa rsp, 8
+	# RDI points to the struct:
+	#	int32_t m_pidOwner
+	#	int32_t m_depth
+	# [rdi+64] ...
+	#	uint16_t active
+	#	uint16_t avail
 	
-	; First get our TID and put it in ecx
-	push rdi                ; we need our struct pointer (also balance the stack for the call)
-	call gettid             ; get our thread ID (TLS is nasty in ASM so don't bother inlining)
-	mov esi, eax            ; back it up in esi
-	pop rdi                 ; get our pointer back
+	# First get our TID and put it in ecx
+	push rdi                # we need our struct pointer (also balance the stack for the call)
+	.cfi_adjust_cfa_offset 8
+	call gettid             # get our thread ID (TLS is nasty in ASM so don't bother inlining)
+	mov esi, eax            # back it up in esi
+	pop rdi                 # get our pointer back
+	.cfi_adjust_cfa_offset -8

-	cmp [rdi+4], esi        ; Is the TID we got back the owner of the lock?
-	je .LLocked             ; Don't spin in that case
+	cmp [rdi], esi          # Is the TID we got back the owner of the lock?
+	je .LLocked             # Don't spin in that case

-	xor eax, eax            ; eliminate partial register dependency
-	inc eax                 ; we want to add one
-	lock xadd [rdi+2], ax   ; do the xadd, ax contains the value before the addition
-	; ax now contains the ticket
-ALIGN 16
+	xor eax, eax            # eliminate partial register dependency
+	inc eax                 # we want to add one
+	lock xadd [rdi+66], ax  # do the xadd, ax contains the value before the addition
+	# ax now contains the ticket
+	# OK Start the wait loop
+	xor ecx, ecx
+.ALIGN 16
 .LLoop:
-	mov edx, [rdi]
-	cmp dx, ax              ; is our ticket up?
-	je .LLocked             ; leave the loop
+	mov edx, [rdi+64]
+	cmp dx, ax              # is our ticket up?
+	je .LLocked             # leave the loop
 	pause
-	add ecx, 1000h          ; Have we been waiting a long time? (oflow if we have)
-	                        ;	1000h is set so we overflow on the 1024*1024'th iteration (like the C code)
-	jnc .LLoop              ; If so, give up our timeslice to someone who's doing real work
-	; Like the compiler, you're probably thinking: "Hey! I should take these pushs out of the loop"
-	;	But the compiler doesn't know that we rarely hit this, and when we do we know the lock is
-	;	taking a long time to be released anyways.  We optimize for the common case of short
-	;	lock intervals.  That's why we're using a spinlock in the first place
-	; If we get here we're going to sleep in the kernel with a futex
+	add ecx, 0x1000         # Have we been waiting a long time? (oflow if we have)
+	                        #	1000h is set so we overflow on the 1024*1024'th iteration (like the C code)
+	jnc .LLoop              # If so, give up our timeslice to someone who's doing real work
+	# Like the compiler, you're probably thinking: "Hey! I should take these pushs out of the loop"
+	#	But the compiler doesn't know that we rarely hit this, and when we do we know the lock is
+	#	taking a long time to be released anyways.  We optimize for the common case of short
+	#	lock intervals.  That's why we're using a spinlock in the first place
+	# If we get here we're going to sleep in the kernel with a futex
+	push rdi
 	push rsi
 	push rax
-	; Setup the syscall args
-                            ; rdi ARG1 futex (already in rdi)
-	mov esi, (9 | 128)      ; rsi ARG2 FUTEX_WAIT_BITSET_PRIVATE
-                            ; rdx ARG3 ticketT.u (already in edx)
-	xor r10d, r10d          ; r10 ARG4 NULL
-	mov r8, rdi	            ; r8 ARG5 dup rdi
-	xor r9d, r9d
-	bts r9d, eax            ; r9 ARG6 mask
-	mov eax, 202            ; sys_futex
-	; Do the syscall
-	lock or [rdi+12], r9d   ; inform the unlocking thread we're waiting
-	syscall	                ; wait for the futex
-	not r9d	                ; convert our flag into a mask of bits not to touch
-	lock and [rdi+12], r9d  ; clear the flag in the futex control mask
-	; cleanup and continue
-	mov rcx, g_longwaits
-	inc qword [rcx]         ; increment our long wait counter
+	.cfi_adjust_cfa_offset 24
+	# Setup the syscall args
+
+                            # rdi ARG1 futex (already in rdi)
+	                        # rsi ARG2 tid (already in esi)
+                            # rdx ARG3 ticketT.u (already in edx)
+	bts ecx, eax            # rcx ARG4 mask
+	call fastlock_sleep
+	# cleanup and continue
 	pop rax
 	pop rsi
-	xor ecx, ecx            ; Reset our loop counter
-	jmp .LLoop              ; Get back in the game
-ALIGN 16
+	pop rdi
+	.cfi_adjust_cfa_offset -24
+	xor ecx, ecx            # Reset our loop counter
+	jmp .LLoop              # Get back in the game
+.ALIGN 16
 .LLocked:
-	mov [rdi+4], esi        ; lock->m_pidOwner = gettid()
-	inc dword [rdi+8]       ; lock->m_depth++
+	mov [rdi], esi          # lock->m_pidOwner = gettid()
+	inc dword ptr [rdi+4]   # lock->m_depth++
 	ret
+.cfi_endproc

-ALIGN 16
-global fastlock_trylock
+.ALIGN 16
+.global fastlock_trylock
+.type   fastlock_trylock,@function
 fastlock_trylock:
-	; RDI points to the struct:
-	;	uint16_t active
-	;	uint16_t avail
-	;	int32_t m_pidOwner
-	;	int32_t m_depth
+	# RDI points to the struct:
+	#	int32_t m_pidOwner
+	#	int32_t m_depth
+	# [rdi+64] ...
+	#	uint16_t active
+	#	uint16_t avail
 	
-	; First get our TID and put it in ecx
-	push rdi                ; we need our struct pointer (also balance the stack for the call)
-	call gettid             ; get our thread ID (TLS is nasty in ASM so don't bother inlining)
-	mov esi, eax            ; back it up in esi
-	pop rdi                 ; get our pointer back
+	# First get our TID and put it in ecx
+	push rdi                # we need our struct pointer (also balance the stack for the call)
+	call gettid             # get our thread ID (TLS is nasty in ASM so don't bother inlining)
+	mov esi, eax            # back it up in esi
+	pop rdi                 # get our pointer back

-	cmp [rdi+4], esi        ; Is the TID we got back the owner of the lock?
-	je .LRecursive          ; Don't spin in that case
+	cmp [rdi], esi          # Is the TID we got back the owner of the lock?
+	je .LRecursive          # Don't spin in that case

-	mov eax, [rdi]          ; get both active and avail counters
-	mov ecx, eax            ; duplicate in ecx
-	ror ecx, 16             ; swap upper and lower 16-bits
-	cmp eax, ecx            ; are the upper and lower 16-bits the same?
-	jnz .LAlreadyLocked     ;	If not return failure
+	mov eax, [rdi+64]       # get both active and avail counters
+	mov ecx, eax            # duplicate in ecx
+	ror ecx, 16             # swap upper and lower 16-bits
+	cmp eax, ecx            # are the upper and lower 16-bits the same?
+	jnz .LAlreadyLocked     #	If not return failure

-	; at this point we know eax+ecx have [avail][active] and they are both the same
-	add ecx, 10000h         ; increment avail, ecx is now our wanted value
-	lock cmpxchg [rdi], ecx ;	If rdi still contains the value in eax, put in ecx (inc avail)
-	jnz .LAlreadyLocked     ; If Z is not set then someone locked it while we were preparing
+	# at this point we know eax+ecx have [avail][active] and they are both the same
+	add ecx, 0x10000            # increment avail, ecx is now our wanted value
+	lock cmpxchg [rdi+64], ecx  #	If rdi still contains the value in eax, put in ecx (inc avail)
+	jnz .LAlreadyLocked         # If Z is not set then someone locked it while we were preparing
 	xor eax, eax
-	inc eax                 ; return SUCCESS! (eax=1)
-	mov [rdi+4], esi        ; lock->m_pidOwner = gettid()
-	mov dword [rdi+8], eax  ; lock->m_depth = 1
+	inc eax                     # return SUCCESS! (eax=1)
+	mov [rdi], esi              # lock->m_pidOwner = gettid()
+	mov dword ptr [rdi+4], eax  # lock->m_depth = 1
 	ret
-ALIGN 16
+.ALIGN 16
 .LRecursive:
 	xor eax, eax
-	inc eax                 ; return SUCCESS! (eax=1)
-	inc dword [rdi+8]       ; lock->m_depth++
+	inc eax                 # return SUCCESS! (eax=1)
+	inc dword ptr [rdi+4]   # lock->m_depth++
 	ret
-ALIGN 16
+.ALIGN 16
 .LAlreadyLocked:
-	xor eax, eax            ; return 0;
+	xor eax, eax            # return 0
 	ret

-ALIGN 16
-global fastlock_unlock
+.ALIGN 16
+.global fastlock_unlock
 fastlock_unlock:
-	; RDI points to the struct:
-	;	uint16_t active
-	;	uint16_t avail
-	;	int32_t m_pidOwner
-	;	int32_t m_depth
+	# RDI points to the struct:
+	#	int32_t m_pidOwner
+	#	int32_t m_depth
+	# [rdi+64] ...
+	#	uint16_t active
+	#	uint16_t avail
 	push r11
-	sub dword [rdi+8], 1         ; decrement m_depth, don't use dec because it partially writes the flag register and we don't know its state
-	jnz .LDone                   ; if depth is non-zero this is a recursive unlock, and we still hold it
-	mov dword [rdi+4], -1        ; pidOwner = -1 (we don't own it anymore)
-	mov ecx, [rdi]               ; get current active (this one)
-	inc ecx                      ; bump it to the next thread
-	mov [rdi], cx                ; give up our ticket (note: lock is not required here because the spinlock itself guards this variable)
-	; At this point the lock is removed, however we must wake up any pending futexs
-	mov r9d, 1                   ; eax is the bitmask for 2 threads
-	rol r9d, cl                  ; place the mask in the right spot for the next 2 threads
-ALIGN 16
+	sub dword ptr [rdi+4], 1     # decrement m_depth, don't use dec because it partially writes the flag register and we don't know its state
+	jnz .LDone                   # if depth is non-zero this is a recursive unlock, and we still hold it
+	mov dword ptr [rdi], -1      # pidOwner = -1 (we don't own it anymore)
+	mov ecx, [rdi+64]            # get current active (this one)
+	inc ecx                      # bump it to the next thread
+	mov [rdi+64], cx             # give up our ticket (note: lock is not required here because the spinlock itself guards this variable)
+	# At this point the lock is removed, however we must wake up any pending futexs
+	mov r9d, 1                   # eax is the bitmask for 2 threads
+	rol r9d, cl                  # place the mask in the right spot for the next 2 threads
+	add rdi, 64                  # rdi now points to the token
+.ALIGN 16
 .LRetryWake:
-	mov r11d, [rdi+12]           ; load the futex mask
-	and r11d, r9d                ; are any threads waiting on a futex?
-	jz .LDone                    ; if not we're done.
-	; we have to wake the futexs
-                                 ; rdi ARG1 futex (already in rdi)
-	mov esi, (10 | 128)          ; rsi ARG2 FUTEX_WAKE_BITSET_PRIVATE
-	mov edx, 0x7fffffff          ; rdx ARG3 INT_MAX (number of threads to wake)
-	xor r10d, r10d               ; r10 ARG4 NULL
-	mov r8, rdi                  ; r8 ARG5 dup rdi
-                                 ; r9 ARG6 mask (already set above)
-	mov eax, 202                 ; sys_futex
+	mov r11d, [rdi+4]            # load the futex mask
+	and r11d, r9d                # are any threads waiting on a futex?
+	jz .LDone                    # if not we're done.
+	# we have to wake the futexs
+                                 # rdi ARG1 futex (already in rdi)
+	mov esi, (10 | 128)          # rsi ARG2 FUTEX_WAKE_BITSET_PRIVATE
+	mov edx, 0x7fffffff          # rdx ARG3 INT_MAX (number of threads to wake)
+	xor r10d, r10d               # r10 ARG4 NULL
+	mov r8, rdi                  # r8 ARG5 dup rdi
+                                 # r9 ARG6 mask (already set above)
+	mov eax, 202                 # sys_futex
 	syscall
-	cmp eax, 1                   ; did we wake as many as we expected?
+	cmp eax, 1                   # did we wake as many as we expected?
 	jnz .LRetryWake
 .LDone:
 	pop r11
@@ -63,11 +63,6 @@ struct commandHelp {
    "Perform bitwise operations between strings",
    1,
    "2.6.0" },
-    { "BITOPRANGE",
-    "operation destkey key start:end [key ...]",
-    "Perform bitwise operations between strings with offset and range",
-    1,
-    "5.1.0" },
    { "BITPOS",
    "key bit [start] [end]",
    "Find first bit set or clear in a string",
@@ -349,8 +344,11 @@ struct commandHelp {
    0,
    "1.2.0" },
    { "EXPIREMEMBER",
-    "key subkey seconds",
-    "set a subkey's time to live in seconds"},
+    "key subkey delay [Unit: s,ms]",
+    "set a subkey's time to live in seconds (or milliseconds)"},
+    { "EXPIREMEMBERAT",
+    "key subkey timestamp",
+    "Set the expiration for a subkey as a UNIX timestamp"},
    { "FLUSHALL",
    "[ASYNC]",
    "Remove all keys from all databases",
@@ -637,8 +635,8 @@ struct commandHelp {
    0,
    "2.2.3" },
    { "PERSIST",
-    "key",
-    "Remove the expiration from a key",
+    "key [subkey]",
+    "Remove the expiration from a key or subkey",
    0,
    "2.2.0" },
    { "PEXPIRE",
@@ -682,8 +680,8 @@ struct commandHelp {
    6,
    "2.0.0" },
    { "PTTL",
-    "key",
-    "Get the time to live for a key in milliseconds",
+    "key [subkey]",
+    "Get the time to live for a key or subkey in milliseconds",
    0,
    "2.6.0" },
    { "PUBLISH",
@@ -957,8 +955,8 @@ struct commandHelp {
    0,
    "3.2.1" },
    { "TTL",
-    "key",
-    "Get the time to live for a key",
+    "key [subkey]",
+    "Get the time to live for a key or subkey",
    0,
    "1.0.0" },
    { "TYPE",
@@ -1439,7 +1439,7 @@ int RM_GetSelectedDb(RedisModuleCtx *ctx) {
 *
 *  * REDISMODULE_CTX_FLAGS_MASTER: The Redis instance is a master
 *
- *  * REDISMODULE_CTX_FLAGS_SLAVE: The Redis instance is a slave
+ *  * REDISMODULE_CTX_FLAGS_SLAVE: The Redis instance is a replica
 *
 *  * REDISMODULE_CTX_FLAGS_READONLY: The Redis instance is read-only
 *
@@ -4289,7 +4289,7 @@ size_t RM_GetClusterSize(void) {
 *
 * The arguments ip, master_id, port and flags can be NULL in case we don't
 * need to populate back certain info. If an ip and master_id (only populated
- * if the instance is a slave) are specified, they point to buffers holding
+ * if the instance is a replica) are specified, they point to buffers holding
 * at least REDISMODULE_NODE_ID_LEN bytes. The strings written back as ip
 * and master_id are not null terminated.
 *
@@ -4300,7 +4300,7 @@ size_t RM_GetClusterSize(void) {
 * * REDISMODULE_NODE_SLAVE         The node is a replica
 * * REDISMODULE_NODE_PFAIL         We see the node as failing
 * * REDISMODULE_NODE_FAIL          The cluster agrees the node is failing
- * * REDISMODULE_NODE_NOFAILOVER    The slave is configured to never failover
+ * * REDISMODULE_NODE_NOFAILOVER    The replica is configured to never failover
 */

 clusterNode *clusterLookupNode(const char *name); /* We need access to internals */
@@ -5181,7 +5181,7 @@ void moduleInitModulesSystem(void) {
 * The function aborts the server on errors, since to start with missing
 * modules is not considered sane: clients may rely on the existence of
 * given commands, loading AOF also may need some modules to exist, and
- * if this instance is a slave, it must understand commands from master. */
+ * if this instance is a replica, it must understand commands from master. */
 void moduleLoadFromQueue(void) {
    listIter li;
    listNode *ln;
@@ -142,7 +142,7 @@ void execCommand(client *c) {
    }

    /* If there are write commands inside the transaction, and this is a read
-     * only slave, we want to send an error. This happens when the transaction
+     * only replica, we want to send an error. This happens when the transaction
     * was initiated when the instance was a master or a writable replica and
     * then the configuration changed (for example instance was turned into
     * a replica). */
@@ -195,7 +195,7 @@ void execCommand(client *c) {
        int is_master = listLength(g_pserver->masters) == 0;
        g_pserver->dirty++;
        /* If inside the MULTI/EXEC block this instance was suddenly
-         * switched from master to slave (using the SLAVEOF command), the
+         * switched from master to replica (using the SLAVEOF command), the
         * initial MULTI was propagated into the replication backlog, but the
         * rest was not. We need to make sure to at least terminate the
         * backlog with the final EXEC. */
@@ -99,6 +99,7 @@ client *createClient(int fd, int iel) {
     * in the context of a client. When commands are executed in other
     * contexts (for instance a Lua script) we need a non connected client. */
    if (fd != -1) {
+        serverAssert(iel == (serverTL - g_pserver->rgthreadvar));
        anetNonBlock(NULL,fd);
        anetEnableTcpNoDelay(NULL,fd);
        if (cserver.tcpkeepalive)
@@ -116,7 +117,7 @@ client *createClient(int fd, int iel) {
    uint64_t client_id;
    client_id = g_pserver->next_client_id.fetch_add(1);
    c->iel = iel;
-    fastlock_init(&c->lock);
+    fastlock_init(&c->lock, "client");
    c->id = client_id;
    c->resp = 2;
    c->fd = fd;
@@ -195,7 +196,7 @@ client *createClient(int fd, int iel) {
 * buffers can hold, then we'll really install the handler. */
 void clientInstallWriteHandler(client *c) {
    /* Schedule the client to write the output buffers to the socket only
-     * if not already done and, for slaves, if the slave can actually receive
+     * if not already done and, for slaves, if the replica can actually receive
     * writes at this stage. */
    if (!(c->flags & CLIENT_PENDING_WRITE) &&
        (c->replstate == REPL_STATE_NONE ||
@@ -239,7 +240,7 @@ void clientInstallAsyncWriteHandler(client *c) {
 *
 * 1) The event handler should already be installed since the output buffer
 *    already contains something.
- * 2) The client is a slave but not yet online, so we want to just accumulate
+ * 2) The client is a replica but not yet online, so we want to just accumulate
 *    writes in the buffer but not actually sending them yet.
 *
 * Typically gets called every time a reply is built, before adding more
@@ -247,8 +248,12 @@ void clientInstallAsyncWriteHandler(client *c) {
 * data should be appended to the output buffers. */
 int prepareClientToWrite(client *c, bool fAsync) {
    fAsync = fAsync && !FCorrectThread(c);  // Not async if we're on the right thread
-    serverAssert(!fAsync || GlobalLocksAcquired());
-    serverAssert(c->fd <= 0 || c->lock.fOwnLock());
+    serverAssert(FCorrectThread(c) || fAsync);
+	if (FCorrectThread(c)) {
+		serverAssert(c->fd <= 0 || c->lock.fOwnLock());
+	} else {
+		serverAssert(GlobalLocksAcquired());
+	}

    if (c->flags & CLIENT_FORCE_REPLY) return C_OK; // FORCE REPLY means we're doing something else with the buffer.
                                                // do not install a write handler
@@ -442,7 +447,7 @@ void addReplyErrorLengthCore(client *c, const char *s, size_t len, bool fAsync)
    addReplyProtoCore(c,s,len,fAsync);
    addReplyProtoCore(c,"\r\n",2,fAsync);

-    /* Sometimes it could be normal that a slave replies to a master with
+    /* Sometimes it could be normal that a replica replies to a master with
     * an error and this function gets called. Actually the error will never
     * be sent because addReply*() against master clients has no effect...
     * A notable example is:
@@ -1214,7 +1219,7 @@ void unlinkClient(client *c) {

        /* In the case of diskless replication the fork is writing to the
         * sockets and just closing the fd isn't enough, if we don't also
-         * shutdown the socket the fork will continue to write to the slave
+         * shutdown the socket the fork will continue to write to the replica
         * and the salve will only find out that it was disconnected when
         * it will finish reading the rdb. */
        if ((c->flags & CLIENT_SLAVE) &&
@@ -1299,7 +1304,7 @@ bool freeClient(client *c) {
        }
    }

-    /* Log link disconnection with slave */
+    /* Log link disconnection with replica */
    if ((c->flags & CLIENT_SLAVE) && !(c->flags & CLIENT_MONITOR)) {
        serverLog(LL_WARNING,"Connection with replica %s lost.",
            replicationGetSlaveName(c));
@@ -1333,8 +1338,8 @@ bool freeClient(client *c) {
     * places where active clients may be referenced. */
    unlinkClient(c);

-    /* Master/slave cleanup Case 1:
-     * we lost the connection with a slave. */
+    /* Master/replica cleanup Case 1:
+     * we lost the connection with a replica. */
    if (c->flags & CLIENT_SLAVE) {
        if (c->replstate == SLAVE_STATE_SEND_BULK) {
            if (c->repldbfd != -1) close(c->repldbfd);
@@ -1352,7 +1357,7 @@ bool freeClient(client *c) {
        refreshGoodSlavesCount();
    }

-    /* Master/slave cleanup Case 2:
+    /* Master/replica cleanup Case 2:
     * we lost the connection with the master. */
    if (c->flags & CLIENT_MASTER) replicationHandleMasterDisconnection(MasterInfoFromClient(c));

@@ -1494,7 +1499,7 @@ int writeToClient(int fd, client *c, int handler_installed) {
         * just deliver as much data as it is possible to deliver.
         *
         * Moreover, we also send as much as possible if the client is
-         * a slave (otherwise, on high-speed traffic, the replication
+         * a replica (otherwise, on high-speed traffic, the replication
         * buffer will grow indefinitely) */
        if (totwritten > NET_MAX_WRITES_PER_EVENT &&
            (g_pserver->maxmemory == 0 ||
@@ -1509,7 +1514,6 @@ int writeToClient(int fd, client *c, int handler_installed) {
        } else {
            serverLog(LL_VERBOSE,
                "Error writing to client: %s", strerror(errno));
-            lock.unlock();
            freeClientAsync(c);
            
            return C_ERR;
@@ -1528,7 +1532,6 @@ int writeToClient(int fd, client *c, int handler_installed) {

        /* Close connection after entire reply has been sent. */
        if (c->flags & CLIENT_CLOSE_AFTER_REPLY) {
-            lock.unlock();
            freeClientAsync(c);
            return C_ERR;
        }
@@ -1805,7 +1808,7 @@ int processInlineBuffer(client *c) {
    }

    /* Newline from slaves can be used to refresh the last ACK time.
-     * This is useful for a slave to ping back while loading a big
+     * This is useful for a replica to ping back while loading a big
     * RDB file. */
    if (querylen == 0 && c->flags & CLIENT_SLAVE)
        c->repl_ack_time = g_pserver->unixtime;
@@ -2038,8 +2041,8 @@ int processCommandAndResetClient(client *c, int flags) {
    }
    if (serverTL->current_client == NULL) deadclient = 1;
    serverTL->current_client = NULL;
-    /* freeMemoryIfNeeded may flush slave output buffers. This may
-     * result into a slave, that may be the active client, to be
+    /* freeMemoryIfNeeded may flush replica output buffers. This may
+     * result into a replica, that may be the active client, to be
     * freed. */
    return deadclient ? C_ERR : C_OK;
 }
@@ -2060,7 +2063,7 @@ void processInputBuffer(client *c, int callFlags) {
        if (c->flags & CLIENT_BLOCKED) break;

        /* Don't process input from the master while there is a busy script
-         * condition on the slave. We want just to accumulate the replication
+         * condition on the replica. We want just to accumulate the replication
         * stream (instead of replying -BUSY like we do with other clients) and
         * later resume the processing. */
        if (g_pserver->lua_timedout && c->flags & CLIENT_MASTER) break;
@@ -2519,9 +2522,17 @@ NULL
                close_this_client = 1;
            } else {
                if (FCorrectThread(client))
+                {
                    freeClient(client);
+                }
                else
+                {
+                    int iel = client->iel;
                    freeClientAsync(client);
+                    aePostFunction(g_pserver->rgthreadvar[client->iel].el, [iel] {
+                        freeClientsInAsyncFreeQueue(iel);
+                    });
+                }
            }
            killed++;
        }
@@ -2910,10 +2921,10 @@ void flushSlavesOutputBuffers(void) {

    listRewind(g_pserver->slaves,&li);
    while((ln = listNext(&li))) {
-        client *slave = (client*)listNodeValue(ln);
+        client *replica = (client*)listNodeValue(ln);
        int events;

-        if (!FCorrectThread(slave))
+        if (!FCorrectThread(replica))
            continue;   // we cannot synchronously flush other thread's clients

        /* Note that the following will not flush output buffers of slaves
@@ -2922,12 +2933,12 @@ void flushSlavesOutputBuffers(void) {
         * of put_online_on_ack is to postpone the moment it is installed.
         * This is what we want since slaves in this state should not receive
         * writes before the first ACK. */
-        events = aeGetFileEvents(g_pserver->rgthreadvar[slave->iel].el,slave->fd);
+        events = aeGetFileEvents(g_pserver->rgthreadvar[replica->iel].el,replica->fd);
        if (events & AE_WRITABLE &&
-            slave->replstate == SLAVE_STATE_ONLINE &&
-            clientHasPendingReplies(slave))
+            replica->replstate == SLAVE_STATE_ONLINE &&
+            clientHasPendingReplies(replica))
        {
-            writeToClient(slave->fd,slave,0);
+            writeToClient(replica->fd,replica,0);
        }
    }
 }
@@ -2950,38 +2961,48 @@ void flushSlavesOutputBuffers(void) {
 * than the time left for the previous pause, no change is made to the
 * left duration. */
 void pauseClients(mstime_t end) {
-    if (!g_pserver->clients_paused || end > g_pserver->clients_pause_end_time)
+    serverAssert(GlobalLocksAcquired());
+    if (!serverTL->clients_paused || end > g_pserver->clients_pause_end_time)
        g_pserver->clients_pause_end_time = end;
-    g_pserver->clients_paused = 1;
+    
+    for (int iel = 0; iel < cserver.cthreads; ++iel)
+    {
+        g_pserver->rgthreadvar[iel].clients_paused = true;
+    }
 }

 /* Return non-zero if clients are currently paused. As a side effect the
 * function checks if the pause time was reached and clear it. */
 int clientsArePaused(void) {
-    if (g_pserver->clients_paused &&
+    return serverTL->clients_paused;
+}
+
+void unpauseClientsIfNecessary()
+{
+    serverAssert(GlobalLocksAcquired());
+    if (serverTL->clients_paused &&
        g_pserver->clients_pause_end_time < g_pserver->mstime)
    {
-        aeAcquireLock();
        listNode *ln;
        listIter li;
        client *c;

-        g_pserver->clients_paused = 0;
+        serverTL->clients_paused = 0;

        /* Put all the clients in the unblocked clients queue in order to
         * force the re-processing of the input buffer if any. */
        listRewind(g_pserver->clients,&li);
        while ((ln = listNext(&li)) != NULL) {
            c = (client*)listNodeValue(ln);
+            if (!FCorrectThread(c))
+                continue;

            /* Don't touch slaves and blocked clients.
             * The latter pending requests will be processed when unblocked. */
            if (c->flags & (CLIENT_SLAVE|CLIENT_BLOCKED)) continue;
            queueClientForReprocessing(c);
        }
-        aeReleaseLock();
    }
-    return g_pserver->clients_paused;
 }

 /* This function is called by Redis in order to process a few events from
@@ -3000,6 +3021,12 @@ int processEventsWhileBlocked(int iel) {
    int iterations = 4; /* See the function top-comment. */
    int count = 0;

+    client *c = serverTL->current_client;
+    if (c != nullptr)
+    {
+        serverAssert(c->flags & CLIENT_PROTECTED);
+        c->lock.unlock();
+    }
    aeReleaseLock();
    while (iterations--) {
        int events = 0;
@@ -3008,7 +3035,11 @@ int processEventsWhileBlocked(int iel) {
        if (!events) break;
        count += events;
    }
-    aeAcquireLock();
+    AeLocker locker;
+    if (c != nullptr)
+        c->lock.lock();
+    locker.arm(c);
+    locker.release();
    return count;
 }

@@ -714,6 +714,34 @@ int getLongLongFromObject(robj *o, long long *target) {
    return C_OK;
 }

+int getUnsignedLongLongFromObject(robj *o, uint64_t *target) {
+    uint64_t value;
+
+    if (o == NULL) {
+        value = 0;
+    } else {
+        serverAssertWithInfo(NULL,o,o->type == OBJ_STRING);
+        if (sdsEncodedObject(o)) {
+            char *pchEnd = nullptr;
+            errno = 0;
+            value = strtoull(szFromObj(o), &pchEnd, 10);
+            if (value == 0) {
+                // potential error
+                if (errno != 0)
+                    return C_ERR;
+                if (pchEnd == szFromObj(o))
+                    return C_ERR;
+            }
+        } else if (o->encoding == OBJ_ENCODING_INT) {
+            value = (long)ptrFromObj(o);
+        } else {
+            serverPanic("Unknown string encoding");
+        }
+    }
+    if (target) *target = value;
+    return C_OK;
+}
+
 int getLongLongFromObjectOrReply(client *c, robj *o, long long *target, const char *msg) {
    long long value;
    if (getLongLongFromObject(o, &value) != C_OK) {
@@ -1302,6 +1330,10 @@ NULL
         * because we update the access time only
         * when the key is read or overwritten. */
        addReplyLongLong(c,LFUDecrAndReturn(o));
+    } else if (!strcasecmp(szFromObj(c->argv[1]), "lastmodified") && c->argc == 3) {
+        if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.null[c->resp]))
+                == NULL) return;
+        addReplyLongLong(c, (g_pserver->mstime - (o->mvcc_tstamp >> MVCC_MS_SHIFT)) / 1000);
    } else {
        addReplySubcommandSyntaxError(c);
    }
@@ -301,9 +301,11 @@ int pubsubPublishMessage(robj *channel, robj *message) {
            client *c = reinterpret_cast<client*>(ln->value);
            if (c->flags & CLIENT_CLOSE_ASAP)   // avoid blocking if the write will be ignored
                continue;
-            fastlock_lock(&c->lock);
+            if (FCorrectThread(c))
+                fastlock_lock(&c->lock);
            addReplyPubsubMessage(c,channel,message);
-            fastlock_unlock(&c->lock);
+            if (FCorrectThread(c))
+                fastlock_unlock(&c->lock);
            receivers++;
        }
    }
@@ -321,10 +323,12 @@ int pubsubPublishMessage(robj *channel, robj *message) {
            {
                if (pat->pclient->flags & CLIENT_CLOSE_ASAP)
                    continue;
-                fastlock_lock(&pat->pclient->lock);
+                if (FCorrectThread(pat->pclient))
+                    fastlock_lock(&pat->pclient->lock);
                addReplyPubsubPatMessage(pat->pclient,
                    pat->pattern,channel,message);
-                fastlock_unlock(&pat->pclient->lock);
+                if (FCorrectThread(pat->pclient))
+                    fastlock_unlock(&pat->pclient->lock);
                receivers++;
            }
        }
@@ -2107,19 +2107,31 @@ int rdbLoadRio(rio *rdb, rdbSaveInfo *rsi, int loading_aof) {

        /* Read key */
        if (key != nullptr)
+        {
            decrRefCount(key);
+            key = nullptr;
+        }

        if ((key = rdbLoadStringObject(rdb)) == NULL) goto eoferr;
        /* Read value */
        if ((val = rdbLoadObject(type,rdb,key, mvcc_tstamp)) == NULL) goto eoferr;
+        bool fStaleMvccKey = val->mvcc_tstamp < rsi->mvccMinThreshold;
        /* Check if the key already expired. This function is used when loading
         * an RDB file from disk, either at startup, or when an RDB was
         * received from the master. In the latter case, the master is
         * responsible for key expiry. If we would expire keys here, the
-         * snapshot taken by the master may not be reflected on the slave. */
-        if (listLength(g_pserver->masters) == 0 && !loading_aof && expiretime != -1 && expiretime < now) {
+         * snapshot taken by the master may not be reflected on the replica. */
+        bool fExpiredKey = (listLength(g_pserver->masters) == 0 || g_pserver->fActiveReplica) && !loading_aof && expiretime != -1 && expiretime < now;
+        if (fStaleMvccKey || fExpiredKey) {
+            if (fStaleMvccKey && !fExpiredKey && rsi->mi != nullptr && rsi->mi->staleKeyMap != nullptr && lookupKeyRead(db, key) == nullptr) {
+                // We have a key that we've already deleted and is not back in our database.
+                //  We'll need to inform the sending master of the delete if it is also a replica of us
+                rsi->mi->staleKeyMap->operator[](db - g_pserver->db).push_back(key);
+            }
            decrRefCount(key);
+            key = nullptr;
            decrRefCount(val);
+            val = nullptr;
        } else {
            /* Add the new object in the hash table */
            int fInserted = dbMerge(db, key, val, rsi->fForceSetKey);   // Note: dbMerge will incrRef
@@ -2136,6 +2148,7 @@ int rdbLoadRio(rio *rdb, rdbSaveInfo *rsi, int loading_aof) {
            else
            {
                decrRefCount(val);
+                val = nullptr;
            }
        }

@@ -2179,7 +2192,6 @@ eoferr: /* unexpected end of file is handled here with a fatal exit */
    return C_ERR; /* Just to avoid warning */
 }

-int rdbLoadFile(char *filename, rdbSaveInfo *rsi);
 int rdbLoad(rdbSaveInfo *rsi)
 {
    int err = C_ERR;
@@ -2199,7 +2211,7 @@ int rdbLoad(rdbSaveInfo *rsi)
 *
 * If you pass an 'rsi' structure initialied with RDB_SAVE_OPTION_INIT, the
 * loading code will fiil the information fields in the structure. */
-int rdbLoadFile(char *filename, rdbSaveInfo *rsi) {
+int rdbLoadFile(const char *filename, rdbSaveInfo *rsi) {
    FILE *fp;
    rio rdb;
    int retval;
@@ -2268,7 +2280,7 @@ void backgroundSaveDoneHandlerSocket(int exitcode, int bysignal) {
    g_pserver->rdb_child_type = RDB_CHILD_TYPE_NONE;
    g_pserver->rdb_save_time_start = -1;

-    /* If the child returns an OK exit code, read the set of slave client
+    /* If the child returns an OK exit code, read the set of replica client
     * IDs and the associated status code. We'll terminate all the slaves
     * in error state.
     *
@@ -2307,35 +2319,35 @@ void backgroundSaveDoneHandlerSocket(int exitcode, int bysignal) {

    listRewind(g_pserver->slaves,&li);
    while((ln = listNext(&li))) {
-        client *slave = (client*)ln->value;
+        client *replica = (client*)ln->value;

-        if (slave->replstate == SLAVE_STATE_WAIT_BGSAVE_END) {
+        if (replica->replstate == SLAVE_STATE_WAIT_BGSAVE_END) {
            uint64_t j;
            int errorcode = 0;

-            /* Search for the slave ID in the reply. In order for a slave to
+            /* Search for the replica ID in the reply. In order for a replica to
             * continue the replication process, we need to find it in the list,
             * and it must have an error code set to 0 (which means success). */
            for (j = 0; j < ok_slaves[0]; j++) {
-                if (slave->id == ok_slaves[2*j+1]) {
+                if (replica->id == ok_slaves[2*j+1]) {
                    errorcode = ok_slaves[2*j+2];
                    break; /* Found in slaves list. */
                }
            }
            if (j == ok_slaves[0] || errorcode != 0) {
                serverLog(LL_WARNING,
-                "Closing slave %s: child->slave RDB transfer failed: %s",
-                    replicationGetSlaveName(slave),
+                "Closing replica %s: child->replica RDB transfer failed: %s",
+                    replicationGetSlaveName(replica),
                    (errorcode == 0) ? "RDB transfer child aborted"
                                     : strerror(errorcode));
-                freeClient(slave);
+                freeClient(replica);
            } else {
                serverLog(LL_WARNING,
                "Slave %s correctly received the streamed RDB file.",
-                    replicationGetSlaveName(slave));
+                    replicationGetSlaveName(replica));
                /* Restore the socket as non-blocking. */
-                anetNonBlock(NULL,slave->fd);
-                anetSendTimeout(NULL,slave->fd,0);
+                anetNonBlock(NULL,replica->fd);
+                anetSendTimeout(NULL,replica->fd,0);
            }
        }
    }
@@ -2402,17 +2414,17 @@ int rdbSaveToSlavesSockets(rdbSaveInfo *rsi) {

    listRewind(g_pserver->slaves,&li);
    while((ln = listNext(&li))) {
-        client *slave = (client*)ln->value;
+        client *replica = (client*)ln->value;

-        if (slave->replstate == SLAVE_STATE_WAIT_BGSAVE_START) {
-            clientids[numfds] = slave->id;
-            fds[numfds++] = slave->fd;
-            replicationSetupSlaveForFullResync(slave,getPsyncInitialOffset());
+        if (replica->replstate == SLAVE_STATE_WAIT_BGSAVE_START) {
+            clientids[numfds] = replica->id;
+            fds[numfds++] = replica->fd;
+            replicationSetupSlaveForFullResync(replica,getPsyncInitialOffset());
            /* Put the socket in blocking mode to simplify RDB transfer.
             * We'll restore it when the children returns (since duped socket
             * will share the O_NONBLOCK attribute with the parent). */
-            anetBlock(NULL,slave->fd);
-            anetSendTimeout(NULL,slave->fd,g_pserver->repl_timeout*1000);
+            anetBlock(NULL,replica->fd);
+            anetSendTimeout(NULL,replica->fd,g_pserver->repl_timeout*1000);
        }
    }

@@ -2446,19 +2458,19 @@ int rdbSaveToSlavesSockets(rdbSaveInfo *rsi) {
            g_pserver->child_info_data.cow_size = private_dirty;
            sendChildInfo(CHILD_INFO_TYPE_RDB);

-            /* If we are returning OK, at least one slave was served
+            /* If we are returning OK, at least one replica was served
             * with the RDB file as expected, so we need to send a report
             * to the parent via the pipe. The format of the message is:
             *
-             * <len> <slave[0].id> <slave[0].error> ...
+             * <len> <replica[0].id> <replica[0].error> ...
             *
-             * len, slave IDs, and slave errors, are all uint64_t integers,
+             * len, replica IDs, and replica errors, are all uint64_t integers,
             * so basically the reply is composed of 64 bits for the len field
             * plus 2 additional 64 bit integers for each entry, for a total
             * of 'len' entries.
             *
-             * The 'id' represents the slave's client ID, so that the master
-             * can match the report with a specific slave, and 'error' is
+             * The 'id' represents the replica's client ID, so that the master
+             * can match the report with a specific replica, and 'error' is
             * set to 0 if the replication process terminated with a success
             * or the error code if an error occurred. */
            void *msg = zmalloc(sizeof(uint64_t)*(1+2*numfds), MALLOC_LOCAL);
@@ -2499,12 +2511,12 @@ int rdbSaveToSlavesSockets(rdbSaveInfo *rsi) {
             * replicationSetupSlaveForFullResync() turned it into BGSAVE_END */
            listRewind(g_pserver->slaves,&li);
            while((ln = listNext(&li))) {
-                client *slave = (client*)ln->value;
+                client *replica = (client*)ln->value;
                int j;

                for (j = 0; j < numfds; j++) {
-                    if (slave->id == clientids[j]) {
-                        slave->replstate = SLAVE_STATE_WAIT_BGSAVE_START;
+                    if (replica->id == clientids[j]) {
+                        replica->replstate = SLAVE_STATE_WAIT_BGSAVE_START;
                        break;
                    }
                }
@@ -2598,17 +2610,17 @@ rdbSaveInfo *rdbPopulateSaveInfo(rdbSaveInfo *rsi) {
    /* If the instance is a master, we can populate the replication info
     * only when repl_backlog is not NULL. If the repl_backlog is NULL,
     * it means that the instance isn't in any replication chains. In this
-     * scenario the replication info is useless, because when a slave
+     * scenario the replication info is useless, because when a replica
     * connects to us, the NULL repl_backlog will trigger a full
     * synchronization, at the same time we will use a new replid and clear
     * replid2. */
    if (g_pserver->fActiveReplica || (!listLength(g_pserver->masters) && g_pserver->repl_backlog)) {
-        /* Note that when g_pserver->slaveseldb is -1, it means that this master
+        /* Note that when g_pserver->replicaseldb is -1, it means that this master
         * didn't apply any write commands after a full synchronization.
-         * So we can let repl_stream_db be 0, this allows a restarted slave
+         * So we can let repl_stream_db be 0, this allows a restarted replica
         * to reload replication ID/offset, it's safe because the next write
         * command must generate a SELECT statement. */
-        rsi->repl_stream_db = g_pserver->slaveseldb == -1 ? 0 : g_pserver->slaveseldb;
+        rsi->repl_stream_db = g_pserver->replicaseldb == -1 ? 0 : g_pserver->replicaseldb;
        return rsi;
    }

@@ -2619,7 +2631,7 @@ rdbSaveInfo *rdbPopulateSaveInfo(rdbSaveInfo *rsi) {
    }
    struct redisMaster *miFirst = (redisMaster*)(listLength(g_pserver->masters) ? listNodeValue(listFirst(g_pserver->masters)) : NULL);

-    /* If the instance is a slave we need a connected master
+    /* If the instance is a replica we need a connected master
     * in order to fetch the currently selected DB. */
    if (miFirst && miFirst->master) {
        rsi->repl_stream_db = miFirst->master->db->id;
@@ -2627,7 +2639,7 @@ rdbSaveInfo *rdbPopulateSaveInfo(rdbSaveInfo *rsi) {
    }

    /* If we have a cached master we can use it in order to populate the
-     * replication selected DB info inside the RDB file: the slave can
+     * replication selected DB info inside the RDB file: the replica can
     * increment the master_repl_offset only from data arriving from the
     * master, so if we are disconnected the offset in the cached master
     * is valid. */
@@ -136,6 +136,7 @@ int rdbLoadLenByRef(rio *rdb, int *isencoded, uint64_t *lenptr);
 int rdbSaveObjectType(rio *rdb, robj_roptr o);
 int rdbLoadObjectType(rio *rdb);
 int rdbLoad(rdbSaveInfo *rsi);
+int rdbLoadFile(const char *filename, rdbSaveInfo *rsi);
 int rdbSaveBackground(rdbSaveInfo *rsi);
 int rdbSaveToSlavesSockets(rdbSaveInfo *rsi);
 void rdbRemoveTempFile(pid_t childpid);
@@ -152,7 +152,7 @@ typedef struct clusterNode {
    int port;
    sds name;
    int flags;
-    sds replicate;  /* Master ID if node is a slave */
+    sds replicate;  /* Master ID if node is a replica */
    int *slots;
    int slots_count;
    int current_slot_index;
@@ -173,6 +173,8 @@ typedef struct redisConfig {
    sds appendonly;
 } redisConfig;

+int g_fInCrash = false;
+
 /* Prototypes */
 static void writeHandler(aeEventLoop *el, int fd, void *privdata, int mask);
 static void createMissingClients(client c);
@@ -124,8 +124,8 @@ extern "C" void freeClusterManager(void) {
 *
 * The score is calculated as follows:
 *
- * SAME_AS_MASTER = 10000 * each slave in the same IP of its master.
- * SAME_AS_SLAVE  = 1 * each slave having the same IP as another slave
+ * SAME_AS_MASTER = 10000 * each replica in the same IP of its master.
+ * SAME_AS_SLAVE  = 1 * each replica having the same IP as another replica
                      of the same master.
 * FINAL_SCORE = SAME_AS_MASTER + SAME_AS_SLAVE
 *
@@ -90,6 +90,8 @@ int spectrum_palette_mono[] = {0,233,234,235,237,239,241,243,245,247,249,251,253
 int *spectrum_palette;
 int spectrum_palette_size;

+int g_fInCrash = 0;
+
 /*------------------------------------------------------------------------------
 * Utility functions
 *--------------------------------------------------------------------------- */
@@ -187,7 +187,7 @@ typedef struct clusterManagerNode {
    time_t ping_recv;
    int flags;
    list *flags_str; /* Flags string representations */
-    sds replicate;  /* Master ID if node is a slave */
+    sds replicate;  /* Master ID if node is a replica */
    int dirty;      /* Node has changes that can be flushed */
    uint8_t slots[CLUSTER_MANAGER_SLOTS];
    int slots_count;
@@ -71,9 +71,9 @@ extern "C" {
 #define REDISMODULE_CTX_FLAGS_MULTI (1<<1)
 /* The instance is a master */
 #define REDISMODULE_CTX_FLAGS_MASTER (1<<2)
-/* The instance is a slave */
+/* The instance is a replica */
 #define REDISMODULE_CTX_FLAGS_SLAVE (1<<3)
-/* The instance is read-only (usually meaning it's a slave as well) */
+/* The instance is read-only (usually meaning it's a replica as well) */
 #define REDISMODULE_CTX_FLAGS_READONLY (1<<4)
 /* The instance is running in cluster mode */
 #define REDISMODULE_CTX_FLAGS_CLUSTER (1<<5)
@@ -1479,7 +1479,7 @@ void evalGenericCommand(client *c, int evalsha) {
     * To do so we use a cache of SHA1s of scripts that we already propagated
     * as full EVAL, that's called the Replication Script Cache.
     *
-     * For repliation, everytime a new slave attaches to the master, we need to
+     * For repliation, everytime a new replica attaches to the master, we need to
     * flush our cache of scripts that can be replicated as EVALSHA, while
     * for AOF we need to do so every time we rewrite the AOF file. */
    if (evalsha && !g_pserver->lua_replicate_commands) {
@@ -59,6 +59,7 @@
 #include <sys/socket.h>
 #include <algorithm>
 #include <uuid/uuid.h>
+#include <mutex>
 #include "aelocker.h"

 int g_fTestMode = false;
@@ -153,7 +154,7 @@ volatile unsigned long lru_clock; /* Server global current LRU time. */
 *
 * ok-loading:  Allow the command while loading the database.
 *
- * ok-stale:    Allow the command while a slave has stale data but is not
+ * ok-stale:    Allow the command while a replica has stale data but is not
 *              allowed to serve this data. Normally no command is accepted
 *              in this condition but just a few.
 *
@@ -228,6 +229,10 @@ struct redisCommand redisCommandTable[] = {
     "write @keyspace",
     0,NULL,1,-1,1,0,0,0},

+    {"expdel",delCommand,-2,
+     "write @keyspace",
+     0,NULL,1,-1,1,0,0,0},
+
    {"unlink",unlinkCommand,-2,
     "write fast @keyspace",
     0,NULL,1,-1,1,0,0,0},
@@ -618,7 +623,11 @@ struct redisCommand redisCommandTable[] = {
     "write fast @keyspace",
     0,NULL,1,1,1,0,0,0},

-    {"expiremember", expireMemberCommand, 4,
+    {"expiremember", expireMemberCommand, -4,
+     "write fast @keyspace",
+     0,NULL,1,1,1,0,0,0},
+    
+    {"expirememberat", expireMemberAtCommand, 4,
     "write fast @keyspace",
     0,NULL,1,1,1,0,0,0},

@@ -725,7 +734,7 @@ struct redisCommand redisCommandTable[] = {
     "admin no-script",
     0,NULL,0,0,0,0,0,0},

-    {"ttl",ttlCommand,2,
+    {"ttl",ttlCommand,-2,
     "read-only fast random @keyspace",
     0,NULL,1,1,1,0,0,0},

@@ -733,11 +742,11 @@ struct redisCommand redisCommandTable[] = {
     "read-only fast @keyspace",
     0,NULL,1,-1,1,0,0,0},

-    {"pttl",pttlCommand,2,
+    {"pttl",pttlCommand,-2,
     "read-only fast random @keyspace",
     0,NULL,1,1,1,0,0,0},

-    {"persist",persistCommand,2,
+    {"persist",persistCommand,-2,
     "write fast @keyspace",
     0,NULL,1,1,1,0,0,0},

@@ -867,10 +876,6 @@ struct redisCommand redisCommandTable[] = {
     "write use-memory @bitmap",
     0,NULL,2,-1,1,0,0,0},

-    {"bitoprange",bitopRangeCommand,-5,
-     "write use-memory @bitmap",
-     0,NULL,2,-1,1,0,0,0},
-
    {"bitcount",bitcountCommand,-2,
     "read-only @bitmap",
     0,NULL,1,1,1,0,0,0},
@@ -1687,6 +1692,9 @@ void clientsCron(int iel) {
            fastlock_unlock(&c->lock);
        }        
    }
+
+    /* Free any pending clients */
+    freeClientsInAsyncFreeQueue(iel);
 }

 /* This function handles 'background' operations we are required to do
@@ -1695,9 +1703,9 @@ void clientsCron(int iel) {
 void databasesCron(void) {
    /* Expire keys by random sampling. Not required for slaves
     * as master will synthesize DELs for us. */
-    if (g_pserver->active_expire_enabled && listLength(g_pserver->masters) == 0) {
+    if (g_pserver->active_expire_enabled && (listLength(g_pserver->masters) == 0 || g_pserver->fActiveReplica)) {
        activeExpireCycle(ACTIVE_EXPIRE_CYCLE_SLOW);
-    } else if (listLength(g_pserver->masters)) {
+    } else if (listLength(g_pserver->masters) && !g_pserver->fActiveReplica) {
        expireSlaveKeys();
    }

@@ -1807,6 +1815,9 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
    /* Update the time cache. */
    updateCachedTime();

+    /* Unpause clients if enough time has elapsed */
+    unpauseClientsIfNecessary();
+
    g_pserver->hz = g_pserver->config_hz;
    /* Adapt the g_pserver->hz value to the number of configured clients. If we have
     * many clients, we want to call serverCron() with an higher frequency. */
@@ -1814,7 +1825,7 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
        while (listLength(g_pserver->clients) / g_pserver->hz >
               MAX_CLIENTS_PER_CLOCK_TICK)
        {
-            g_pserver->hz *= 2;
+            g_pserver->hz += g_pserver->hz; // *= 2
            if (g_pserver->hz > CONFIG_MAX_HZ) {
                g_pserver->hz = CONFIG_MAX_HZ;
                break;
@@ -2014,9 +2025,6 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
            flushAppendOnlyFile(0);
    }

-    /* Clear the paused clients flag if needed. */
-    clientsArePaused(); /* Don't check return value, just use the side effect.*/
-
    /* Replication cron function -- used to reconnect to master,
     * detect transfer failures, start background RDB transfers and so forth. */
    run_with_period(1000) replicationCron();
@@ -2073,6 +2081,9 @@ int serverCronLite(struct aeEventLoop *eventLoop, long long id, void *clientData
    {
        processUnblockedClients(iel);
    }
+
+    /* Unpause clients if enough time has elapsed */
+    unpauseClientsIfNecessary();
    
    ProcessPendingAsyncWrites();    // A bug but leave for now, events should clean up after themselves
    clientsCron(iel);
@@ -2094,7 +2105,7 @@ void beforeSleep(struct aeEventLoop *eventLoop) {

    /* Run a fast expire cycle (the called function will return
     * ASAP if a fast cycle is not needed). */
-    if (g_pserver->active_expire_enabled && listLength(g_pserver->masters) == 0)
+    if (g_pserver->active_expire_enabled && (listLength(g_pserver->masters) == 0 || g_pserver->fActiveReplica))
        activeExpireCycle(ACTIVE_EXPIRE_CYCLE_FAST);

    /* Send all the slaves an ACK request if at least one client blocked
@@ -2105,7 +2116,7 @@ void beforeSleep(struct aeEventLoop *eventLoop) {
        argv[0] = createStringObject("REPLCONF",8);
        argv[1] = createStringObject("GETACK",6);
        argv[2] = createStringObject("*",1); /* Not used argument. */
-        replicationFeedSlaves(g_pserver->slaves, g_pserver->slaveseldb, argv, 3);
+        replicationFeedSlaves(g_pserver->slaves, g_pserver->replicaseldb, argv, 3);
        decrRefCount(argv[0]);
        decrRefCount(argv[1]);
        decrRefCount(argv[2]);
@@ -2308,6 +2319,7 @@ void initMasterInfo(redisMaster *master)

    master->repl_state = REPL_STATE_NONE;
    master->repl_down_since = 0; /* Never connected, repl is down since EVER. */
+    master->mvccLastSync = 0;
 }

 void initServerConfig(void) {
@@ -2510,7 +2522,7 @@ void initServerConfig(void) {

    /* By default we want scripts to be always replicated by effects
     * (single commands executed by the script), and not by sending the
-     * script to the slave / AOF. This is the new way starting from
+     * script to the replica / AOF. This is the new way starting from
     * Redis 5. However it is possible to revert it via redis.conf. */
    g_pserver->lua_always_replicate_commands = 1;

@@ -2703,7 +2715,7 @@ void checkTcpBacklogSettings(void) {
 * impossible to bind, or no bind addresses were specified in the server
 * configuration but the function is not able to bind * for at least
 * one of the IPv4 or IPv6 protocols. */
-int listenToPort(int port, int *fds, int *count, int fReusePort) {
+int listenToPort(int port, int *fds, int *count, int fReusePort, int fFirstListen) {
    int j;

    /* Force binding of 0.0.0.0 if no bind address is specified, always
@@ -2715,7 +2727,7 @@ int listenToPort(int port, int *fds, int *count, int fReusePort) {
            /* Bind * for both IPv6 and IPv4, we enter here only if
             * g_pserver->bindaddr_count == 0. */
            fds[*count] = anetTcp6Server(serverTL->neterr,port,NULL,
-                g_pserver->tcp_backlog, fReusePort);
+                g_pserver->tcp_backlog, fReusePort, fFirstListen);
            if (fds[*count] != ANET_ERR) {
                anetNonBlock(NULL,fds[*count]);
                (*count)++;
@@ -2727,7 +2739,7 @@ int listenToPort(int port, int *fds, int *count, int fReusePort) {
            if (*count == 1 || unsupported) {
                /* Bind the IPv4 address as well. */
                fds[*count] = anetTcpServer(serverTL->neterr,port,NULL,
-                    g_pserver->tcp_backlog, fReusePort);
+                    g_pserver->tcp_backlog, fReusePort, fFirstListen);
                if (fds[*count] != ANET_ERR) {
                    anetNonBlock(NULL,fds[*count]);
                    (*count)++;
@@ -2743,11 +2755,11 @@ int listenToPort(int port, int *fds, int *count, int fReusePort) {
        } else if (strchr(g_pserver->bindaddr[j],':')) {
            /* Bind IPv6 address. */
            fds[*count] = anetTcp6Server(serverTL->neterr,port,g_pserver->bindaddr[j],
-                g_pserver->tcp_backlog, fReusePort);
+                g_pserver->tcp_backlog, fReusePort, fFirstListen);
        } else {
            /* Bind IPv4 address. */
            fds[*count] = anetTcpServer(serverTL->neterr,port,g_pserver->bindaddr[j],
-                g_pserver->tcp_backlog, fReusePort);
+                g_pserver->tcp_backlog, fReusePort, fFirstListen);
        }
        if (fds[*count] == ANET_ERR) {
            serverLog(LL_WARNING,
@@ -2809,7 +2821,7 @@ static void initNetworkingThread(int iel, int fReusePort)
    if (fReusePort || (iel == IDX_EVENT_LOOP_MAIN))
    {
        if (g_pserver->port != 0 &&
-            listenToPort(g_pserver->port,g_pserver->rgthreadvar[iel].ipfd,&g_pserver->rgthreadvar[iel].ipfd_count, fReusePort) == C_ERR)
+            listenToPort(g_pserver->port,g_pserver->rgthreadvar[iel].ipfd,&g_pserver->rgthreadvar[iel].ipfd_count, fReusePort, (iel == IDX_EVENT_LOOP_MAIN)) == C_ERR)
            exit(1);
    }
    else
@@ -2866,6 +2878,7 @@ static void initServerThread(struct redisServerThreadVars *pvar, int fMain)
    pvar->cclients = 0;
    pvar->el = aeCreateEventLoop(g_pserver->maxclients+CONFIG_FDSET_INCR);
    pvar->current_client = nullptr;
+    pvar->clients_paused = 0;
    if (pvar->el == NULL) {
        serverLog(LL_WARNING,
            "Failed creating the event loop. Error message: '%s'",
@@ -2873,7 +2886,7 @@ static void initServerThread(struct redisServerThreadVars *pvar, int fMain)
        exit(1);
    }

-    fastlock_init(&pvar->lockPendingWrite);
+    fastlock_init(&pvar->lockPendingWrite, "lockPendingWrite");

    if (!fMain)
    {
@@ -2920,12 +2933,11 @@ void initServer(void) {
    signal(SIGPIPE, SIG_IGN);
    setupSignalHandlers();

-    fastlock_init(&g_pserver->flock);
-
    g_pserver->db = (redisDb*)zmalloc(sizeof(redisDb)*cserver.dbnum, MALLOC_LOCAL);

    /* Create the Redis databases, and initialize other internal state. */
    for (int j = 0; j < cserver.dbnum; j++) {
+        new (&g_pserver->db[j]) redisDb;
        g_pserver->db[j].pdict = dictCreate(&dbDictType,NULL);
        g_pserver->db[j].setexpire = new(MALLOC_LOCAL) expireset();
        g_pserver->db[j].expireitr = g_pserver->db[j].setexpire->end();
@@ -2959,11 +2971,10 @@ void initServer(void) {
    cserver.pid = getpid();
    g_pserver->clients_index = raxNew();
    g_pserver->clients_to_close = listCreate();
-    g_pserver->slaveseldb = -1; /* Force to emit the first SELECT command. */
+    g_pserver->replicaseldb = -1; /* Force to emit the first SELECT command. */
    g_pserver->ready_keys = listCreate();
    g_pserver->clients_waiting_acks = listCreate();
    g_pserver->get_ack_from_slaves = 0;
-    g_pserver->clients_paused = 0;
    cserver.system_memory_size = zmalloc_get_memory_size();

    createSharedObjects();
@@ -3350,16 +3361,7 @@ void call(client *c, int flags) {
    /* Call the command. */
    dirty = g_pserver->dirty;
    start = ustime();
-    try
-    {
-        c->cmd->proc(c);
-    } 
-    catch (robj *obj)
-    {
-        addReply(c, obj);
-        decrRefCount(obj);
-    }
-    
+    c->cmd->proc(c);
    serverTL->commandsExecuted++;
    duration = ustime()-start;
    dirty = g_pserver->dirty-dirty;
@@ -3595,8 +3597,8 @@ int processCommand(client *c, int callFlags) {
     * propagation of DELs due to eviction. */
    if (g_pserver->maxmemory && !g_pserver->lua_timedout) {
        int out_of_memory = freeMemoryIfNeededAndSafe() == C_ERR;
-        /* freeMemoryIfNeeded may flush slave output buffers. This may result
-         * into a slave, that may be the active client, to be freed. */
+        /* freeMemoryIfNeeded may flush replica output buffers. This may result
+         * into a replica, that may be the active client, to be freed. */
        if (serverTL->current_client == NULL) return C_ERR;

        /* It was impossible to free enough memory, and the command the client
@@ -3643,7 +3645,7 @@ int processCommand(client *c, int callFlags) {
        return C_OK;
    }

-    /* Don't accept write commands if this is a read only slave. But
+    /* Don't accept write commands if this is a read only replica. But
     * accept write commands if this is our master. */
    if (listLength(g_pserver->masters) && g_pserver->repl_slave_ro &&
        !(c->flags & CLIENT_MASTER) &&
@@ -3666,7 +3668,7 @@ int processCommand(client *c, int callFlags) {
    }

    /* Only allow commands with flag "t", such as INFO, SLAVEOF and so on,
-     * when slave-serve-stale-data is no and we are a slave with a broken
+     * when replica-serve-stale-data is no and we are a replica with a broken
     * link with master. */
    if (FBrokenLinkToMaster() &&
        g_pserver->repl_serve_stale_data == 0 &&
@@ -3798,7 +3800,7 @@ int prepareForShutdown(int flags) {
        unlink(cserver.pidfile);
    }

-    /* Best effort flush of slave output buffers, so that we hopefully
+    /* Best effort flush of replica output buffers, so that we hopefully
     * send them pending writes. */
    flushSlavesOutputBuffers();

@@ -4093,7 +4095,7 @@ sds genRedisInfoString(const char *section) {
            g_pserver->port,
            (intmax_t)uptime,
            (intmax_t)(uptime/(3600*24)),
-            g_pserver->hz,
+            g_pserver->hz.load(),
            g_pserver->config_hz,
            (unsigned long) lruclock,
            cserver.executable ? cserver.executable : "",
@@ -4110,10 +4112,12 @@ sds genRedisInfoString(const char *section) {
            "connected_clients:%lu\r\n"
            "client_recent_max_input_buffer:%zu\r\n"
            "client_recent_max_output_buffer:%zu\r\n"
-            "blocked_clients:%d\r\n",
+            "blocked_clients:%d\r\n"
+            "current_client_thread:%d\r\n",
            listLength(g_pserver->clients)-listLength(g_pserver->slaves),
            maxin, maxout,
-            g_pserver->blocked_clients);
+            g_pserver->blocked_clients,
+            static_cast<int>(serverTL - g_pserver->rgthreadvar));
        for (int ithread = 0; ithread < cserver.cthreads; ++ithread)
        {
            info = sdscatprintf(info,
@@ -4474,18 +4478,18 @@ sds genRedisInfoString(const char *section) {

            listRewind(g_pserver->slaves,&li);
            while((ln = listNext(&li))) {
-                client *slave = (client*)listNodeValue(ln);
+                client *replica = (client*)listNodeValue(ln);
                const char *state = NULL;
-                char ip[NET_IP_STR_LEN], *slaveip = slave->slave_ip;
+                char ip[NET_IP_STR_LEN], *slaveip = replica->slave_ip;
                int port;
                long lag = 0;

                if (slaveip[0] == '\0') {
-                    if (anetPeerToString(slave->fd,ip,sizeof(ip),&port) == -1)
+                    if (anetPeerToString(replica->fd,ip,sizeof(ip),&port) == -1)
                        continue;
                    slaveip = ip;
                }
-                switch(slave->replstate) {
+                switch(replica->replstate) {
                case SLAVE_STATE_WAIT_BGSAVE_START:
                case SLAVE_STATE_WAIT_BGSAVE_END:
                    state = "wait_bgsave";
@@ -4498,14 +4502,14 @@ sds genRedisInfoString(const char *section) {
                    break;
                }
                if (state == NULL) continue;
-                if (slave->replstate == SLAVE_STATE_ONLINE)
-                    lag = time(NULL) - slave->repl_ack_time;
+                if (replica->replstate == SLAVE_STATE_ONLINE)
+                    lag = time(NULL) - replica->repl_ack_time;

                info = sdscatprintf(info,
                    "slave%d:ip=%s,port=%d,state=%s,"
                    "offset=%lld,lag=%ld\r\n",
-                    slaveid,slaveip,slave->slave_listening_port,state,
-                    (slave->repl_ack_off + slave->reploff_skipped), lag);
+                    slaveid,slaveip,replica->slave_listening_port,state,
+                    (replica->repl_ack_off + replica->reploff_skipped), lag);
                slaveid++;
            }
        }
@@ -4613,7 +4617,7 @@ void infoCommand(client *c) {
 }

 void monitorCommand(client *c) {
-    /* ignore MONITOR if already slave or in monitor mode */
+    /* ignore MONITOR if already replica or in monitor mode */
    serverAssert(GlobalLocksAcquired());
    if (c->flags & CLIENT_SLAVE) return;

@@ -4840,7 +4844,7 @@ void loadDataFromDisk(void) {
                while ((ln = listNext(&li)))
                {
                    redisMaster *mi = (redisMaster*)listNodeValue(ln);
-                    /* If we are a slave, create a cached master from this
+                    /* If we are a replica, create a cached master from this
                    * information, in order to allow partial resynchronizations
                    * with masters. */
                    replicationCacheMasterUsingMyself(mi);
@@ -4860,6 +4864,12 @@ void redisOutOfMemoryHandler(size_t allocation_size) {
    serverPanic("Redis aborting for OUT OF MEMORY");
 }

+void fuzzOutOfMemoryHandler(size_t allocation_size) {
+    serverLog(LL_WARNING,"Out Of Memory allocating %zu bytes!",
+        allocation_size);
+    exit(EXIT_FAILURE); // don't crash because it causes false positives
+}
+
 void redisSetProcTitle(const char *title) {
 #ifdef USE_SETPROCTITLE
    const char *server_mode = "";
@@ -4982,7 +4992,7 @@ void incrementMvccTstamp()
 {
    uint64_t msPrev;
    __atomic_load(&g_pserver->mvcc_tstamp, &msPrev, __ATOMIC_ACQUIRE);
-    msPrev >>= 20;  // convert to milliseconds
+    msPrev >>= MVCC_MS_SHIFT;  // convert to milliseconds

    long long mst;
    __atomic_load(&g_pserver->mstime, &mst, __ATOMIC_RELAXED);
@@ -4992,7 +5002,7 @@ void incrementMvccTstamp()
    }
    else
    {
-        atomicSet(g_pserver->mvcc_tstamp, ((uint64_t)g_pserver->mstime) << 20);
+        atomicSet(g_pserver->mvcc_tstamp, ((uint64_t)g_pserver->mstime) << MVCC_MS_SHIFT);
    }
 }

@@ -5214,6 +5224,23 @@ int main(int argc, char **argv) {
    #endif
        moduleLoadFromQueue();
        ACLLoadUsersAtStartup();
+
+        // special case of FUZZING load from stdin then quit
+        if (argc > 1 && strstr(argv[1],"rdbfuzz-mode") != NULL)
+        {
+            zmalloc_set_oom_handler(fuzzOutOfMemoryHandler);
+#ifdef __AFL_HAVE_MANUAL_CONTROL
+            __AFL_INIT();
+#endif
+            rio rdb;
+            rdbSaveInfo rsi = RDB_SAVE_INFO_INIT;
+            startLoading(stdin);
+            rioInitWithFile(&rdb,stdin);
+            rdbLoadRio(&rdb,&rsi,0);
+            stopLoading();
+            return EXIT_SUCCESS;
+        }
+
        loadDataFromDisk();
        if (g_pserver->cluster_enabled) {
            if (verifyClusterConfigWithData() == C_ERR) {
@@ -5250,7 +5277,7 @@ int main(int argc, char **argv) {

    aeReleaseLock();    //Finally we can dump the lock
    moduleReleaseGIL(true);
-
+    
    serverAssert(cserver.cthreads > 0 && cserver.cthreads <= MAX_EVENT_LOOPS);
    pthread_t rgthread[MAX_EVENT_LOOPS];
    for (int iel = 0; iel < cserver.cthreads; ++iel)
@@ -54,6 +54,7 @@
 #include <vector>
 #include <algorithm>
 #include <memory>
+#include <map>
 #ifdef __cplusplus
 extern "C" {
 #include <lua.h>
@@ -95,8 +96,7 @@ extern int g_fTestMode;
 struct redisObject;
 class robj_roptr
 {
-protected:
-    const redisObject *m_ptr = nullptr;
+    const redisObject *m_ptr;

 public:
    robj_roptr()
@@ -145,43 +145,85 @@ public:
    }
 };

-void incrRefCount(robj_roptr o);
 void decrRefCount(robj_roptr o);
-class robj_rorefptr : public robj_roptr
+void incrRefCount(robj_roptr o);
+class robj_sharedptr
 {
+    redisObject *m_ptr;
+
 public:
-    robj_rorefptr() = default;
-    robj_rorefptr(const redisObject *ref)
-        : robj_roptr(ref)
+    robj_sharedptr()
+        : m_ptr(nullptr)
        {}
-
-    robj_rorefptr(const robj_rorefptr& other)
-        : robj_roptr(other)
-    {
-        if (m_ptr)
-            incrRefCount(m_ptr);
-    }
-    robj_rorefptr(robj_rorefptr&& other)
-        : robj_roptr(other)
-    {}
-
-    ~robj_rorefptr()
+    robj_sharedptr(redisObject *ptr)
+        : m_ptr(ptr)
+        {
+            incrRefCount(ptr);
+        }
+    ~robj_sharedptr()
    {
        if (m_ptr)
            decrRefCount(m_ptr);
    }
-
-    robj_rorefptr &operator=(robj_rorefptr &other)
+    robj_sharedptr(const robj_sharedptr& other)
+    {
+        m_ptr = other.m_ptr;
+        incrRefCount(m_ptr);
+    }
+
+    robj_sharedptr(robj_sharedptr&& other)
+    {
+        m_ptr = other.m_ptr;
+        other.m_ptr = nullptr;
+    }
+
+    robj_sharedptr &operator=(const robj_sharedptr& other)
    {
-        robj_roptr::operator=(other.m_ptr);
        if (m_ptr)
-            incrRefCount(other);
+            decrRefCount(m_ptr);
+        m_ptr = other.m_ptr;
+        incrRefCount(m_ptr);
        return *this;
    }
-    
-    using robj_roptr::operator=;
-    using robj_roptr::operator==;
-    using robj_roptr::operator->;
+    robj_sharedptr &operator=(redisObject *ptr)
+    {
+        if (m_ptr)
+            decrRefCount(m_ptr);
+        m_ptr = ptr;
+        incrRefCount(m_ptr);
+        return *this;
+    }
+
+    bool operator==(const robj_sharedptr &other) const
+    {
+        return m_ptr == other.m_ptr;
+    }
+
+    bool operator!=(const robj_sharedptr &other) const
+    {
+        return m_ptr != other.m_ptr;
+    }
+
+    redisObject* operator->() const
+    {
+        return m_ptr;
+    }
+
+    bool operator!() const
+    {
+        return !m_ptr;
+    }
+
+    operator bool() const{
+        return !!m_ptr;
+    }
+
+    operator redisObject *()
+    {
+        return (redisObject*)m_ptr;
+    }
+
+    redisObject *get() { return m_ptr; }
 };

 /* Error codes */
@@ -371,7 +413,7 @@ public:
 /* Client flags */
 #define CLIENT_SLAVE (1<<0)   /* This client is a repliaca */
 #define CLIENT_MASTER (1<<1)  /* This client is a master */
-#define CLIENT_MONITOR (1<<2) /* This client is a slave monitor, see MONITOR */
+#define CLIENT_MONITOR (1<<2) /* This client is a replica monitor, see MONITOR */
 #define CLIENT_MULTI (1<<3)   /* This client is in a MULTI context */
 #define CLIENT_BLOCKED (1<<4) /* The client is waiting in a blocking operation */
 #define CLIENT_DIRTY_CAS (1<<5) /* Watched keys modified. EXEC will fail. */
@@ -435,7 +477,7 @@ public:
 #define CLIENT_TYPE_MASTER 3 /* Master. */
 #define CLIENT_TYPE_OBUF_COUNT 3 /* Number of clients to expose to output
                                    buffer configuration. Just the first
-                                    three: normal, slave, pubsub. */
+                                    three: normal, replica, pubsub. */

 /* Slave replication state. Used in g_pserver->repl_state for slaves to remember
 * what to do next. */
@@ -461,20 +503,21 @@ public:
 #define REPL_STATE_CONNECTED 17 /* Connected to master */

 /* State of slaves from the POV of the master. Used in client->replstate.
- * In SEND_BULK and ONLINE state the slave receives new updates
+ * In SEND_BULK and ONLINE state the replica receives new updates
 * in its output queue. In the WAIT_BGSAVE states instead the server is waiting
 * to start the next background saving in order to send updates to it. */
 #define SLAVE_STATE_WAIT_BGSAVE_START 6 /* We need to produce a new RDB file. */
 #define SLAVE_STATE_WAIT_BGSAVE_END 7 /* Waiting RDB file creation to finish. */
-#define SLAVE_STATE_SEND_BULK 8 /* Sending RDB file to slave. */
+#define SLAVE_STATE_SEND_BULK 8 /* Sending RDB file to replica. */
 #define SLAVE_STATE_ONLINE 9 /* RDB file transmitted, sending just updates. */

 /* Slave capabilities. */
 #define SLAVE_CAPA_NONE 0
 #define SLAVE_CAPA_EOF (1<<0)    /* Can parse the RDB EOF streaming format. */
 #define SLAVE_CAPA_PSYNC2 (1<<1) /* Supports PSYNC2 protocol. */
+#define SLAVE_CAPA_ACTIVE_EXPIRE (1<<2) /* Will the slave perform its own expirations? (Don't send delete) */

-/* Synchronous read timeout - slave side */
+/* Synchronous read timeout - replica side */
 #define CONFIG_REPL_SYNCIO_TIMEOUT 5

 /* List related stuff */
@@ -583,7 +626,7 @@ public:
 /* RDB active child save type. */
 #define RDB_CHILD_TYPE_NONE 0
 #define RDB_CHILD_TYPE_DISK 1     /* RDB is written to disk. */
-#define RDB_CHILD_TYPE_SOCKET 2   /* RDB is written to slave socket. */
+#define RDB_CHILD_TYPE_SOCKET 2   /* RDB is written to replica socket. */

 /* Keyspace changes notification classes. Every class is associated with a
 * character for configuration purposes. */
@@ -762,6 +805,8 @@ typedef struct RedisModuleDigest {
 #define OBJ_SHARED_REFCOUNT (0x7FFFFFFF) 
 #define OBJ_MVCC_INVALID (0xFFFFFFFFFFFFFFFFULL)

+#define MVCC_MS_SHIFT 20
+
 typedef struct redisObject {
    unsigned type:4;
    unsigned encoding:4;
@@ -769,7 +814,7 @@ typedef struct redisObject {
                            * LFU data (least significant 8 bits frequency
                            * and most significant 16 bits access time). */
 private:
-    mutable std::atomic<unsigned> refcount;
+    mutable std::atomic<unsigned> refcount {0};
 public:
    uint64_t mvcc_tstamp;
    void *m_ptr;
@@ -840,6 +885,24 @@ public:

    void expireSubKey(const char *szSubkey, long long when)
    {
+        // First check if the subkey already has an expiration
+        for (auto &entry : m_vecexpireEntries)
+        {
+            if (szSubkey != nullptr)
+            {
+                // if this is a subkey expiry then its not a match if the expireEntry is either for the
+                //  primary key or a different subkey
+                if (entry.spsubkey == nullptr || sdscmp((sds)entry.spsubkey.get(), (sds)szSubkey) != 0)
+                    continue;
+            }
+            else
+            {
+                if (entry.spsubkey != nullptr)
+                    continue;
+            }
+            m_vecexpireEntries.erase(m_vecexpireEntries.begin() + (&entry - m_vecexpireEntries.data()));
+            break;
+        }
        auto itrInsert = std::lower_bound(m_vecexpireEntries.begin(), m_vecexpireEntries.end(), when);
        const char *subkey = (szSubkey) ? sdsdup(szSubkey) : nullptr;
        m_vecexpireEntries.emplace(itrInsert, when, subkey);
@@ -863,6 +926,7 @@ class expireEntry {
 public:
    class iter
    {
+        friend class expireEntry;
        expireEntry *m_pentry = nullptr;
        size_t m_idx = 0;

@@ -998,6 +1062,14 @@ public:
            return iter(this, u.m_pfatentry->size());
        return iter(this, 1);
    }
+    
+    void erase(iter &itr)
+    {
+        if (!FFat())
+            throw -1;   // assert
+        pfatentry()->m_vecexpireEntries.erase(
+            pfatentry()->m_vecexpireEntries.begin() + itr.m_idx);
+    }

    bool FGetPrimaryExpire(long long *pwhen)
    {
@@ -1054,6 +1126,9 @@ typedef struct clientReplyBlock {
 * by integers from 0 (the default database) up to the max configured
 * database. The database number is the 'id' field in the structure. */
 typedef struct redisDb {
+    redisDb() 
+        : expireitr(nullptr)
+    {};
    dict *pdict;                 /* The keyspace for this DB */
    expireset *setexpire;
    expireset::setiter expireitr;
@@ -1208,8 +1283,8 @@ typedef struct client {
    int casyncOpsPending;
    int fPendingAsyncWrite; /* NOTE: Not a flag because it is written to outside of the client lock (locked by the global lock instead) */
    int authenticated;      /* Needed when the default user requires auth. */
-    int replstate;          /* Replication state if this is a slave. */
-    int repl_put_online_on_ack; /* Install slave write handler on ACK. */
+    int replstate;          /* Replication state if this is a replica. */
+    int repl_put_online_on_ack; /* Install replica write handler on ACK. */
    int repldbfd;           /* Replication DB file descriptor. */
    off_t repldboff;        /* Replication DB file offset. */
    off_t repldbsize;       /* Replication DB file size. */
@@ -1217,10 +1292,10 @@ typedef struct client {
    long long read_reploff; /* Read replication offset if this is a master. */
    long long reploff;      /* Applied replication offset if this is a master. */
    long long reploff_skipped;  /* Repl backlog we did not send to this client */
-    long long repl_ack_off; /* Replication ack offset, if this is a slave. */
-    long long repl_ack_time;/* Replication ack time, if this is a slave. */
+    long long repl_ack_off; /* Replication ack offset, if this is a replica. */
+    long long repl_ack_time;/* Replication ack time, if this is a replica. */
    long long psync_initial_offset; /* FULLRESYNC reply offset other slaves
-                                       copying this slave output buffer
+                                       copying this replica output buffer
                                       should use. */
    char replid[CONFIG_RUN_ID_SIZE+1]; /* Master replication ID (if master). */
    int slave_listening_port; /* As configured with: SLAVECONF listening-port */
@@ -1398,9 +1473,11 @@ typedef struct rdbSaveInfo {
    char repl_id[CONFIG_RUN_ID_SIZE+1];     /* Replication ID. */
    long long repl_offset;                  /* Replication offset. */
    int fForceSetKey;
+    uint64_t mvccMinThreshold;
+    struct redisMaster *mi;
 } rdbSaveInfo;

-#define RDB_SAVE_INFO_INIT {-1,0,"000000000000000000000000000000",-1, TRUE}
+#define RDB_SAVE_INFO_INIT {-1,0,"000000000000000000000000000000",-1, TRUE, 0, nullptr}

 struct malloc_stats {
    size_t zmalloc_used;
@@ -1434,6 +1511,7 @@ struct redisServerThreadVars {
    aeEventLoop *el;
    int ipfd[CONFIG_BINDADDR_MAX]; /* TCP socket file descriptors */
    int ipfd_count;             /* Used slots in ipfd[] */
+    int clients_paused;         /* True if clients are currently paused */
    std::vector<client*> clients_pending_write; /* There is to write or install handler. */
    list *unblocked_clients;     /* list of clients to unblock before next loop NOT THREADSAFE */
    list *clients_pending_asyncwrite;
@@ -1443,7 +1521,7 @@ struct redisServerThreadVars {
                                client blocked on a module command needs
                                to be processed. */
    client *lua_client = nullptr;   /* The "fake client" to query Redis from Lua */
-    struct fastlock lockPendingWrite;
+    struct fastlock lockPendingWrite { "thread pending write" };
    char neterr[ANET_ERR_LEN];   /* Error buffer for anet.c */
    long unsigned commandsExecuted = 0;
 };
@@ -1461,7 +1539,7 @@ struct redisMaster {
    char master_replid[CONFIG_RUN_ID_SIZE+1];  /* Master PSYNC runid. */
    long long master_initial_offset;           /* Master PSYNC offset. */

-    int repl_state;          /* Replication status if the instance is a slave */
+    int repl_state;          /* Replication status if the instance is a replica */
    off_t repl_transfer_size; /* Size of RDB to read from master during sync. */
    off_t repl_transfer_read; /* Amount of RDB read from master during sync. */
    off_t repl_transfer_last_fsync_off; /* Offset when we fsync-ed last time. */
@@ -1473,6 +1551,9 @@ struct redisMaster {

    unsigned char master_uuid[UUID_BINARY_LEN];  /* Used during sync with master, this is our master's UUID */
                                                /* After we've connected with our master use the UUID in g_pserver->master */
+    uint64_t mvccLastSync;
+    /* During a handshake the server may have stale keys, we track these here to share once a reciprocal connection is made */
+    std::map<int, std::vector<robj_sharedptr>> *staleKeyMap;
 };

 // Const vars are not changed after worker threads are launched
@@ -1526,7 +1607,7 @@ struct redisServer {
    int config_hz;              /* Configured HZ value. May be different than
                                   the actual 'hz' field value if dynamic-hz
                                   is enabled. */
-    int hz;                     /* serverCron() calls frequency in hertz */
+    std::atomic<int> hz;                     /* serverCron() calls frequency in hertz */
    redisDb *db;
    dict *commands;             /* Command table */
    dict *orig_commands;        /* Command table before command renaming. */
@@ -1561,7 +1642,6 @@ struct redisServer {
    list *clients_to_close;     /* Clients to close asynchronously */
    list *slaves, *monitors;    /* List of slaves and MONITORs */
    rax *clients_index;         /* Active clients dictionary by client ID. */
-    int clients_paused;         /* True if clients are currently paused */
    mstime_t clients_pause_end_time; /* Time when we undo clients_paused */
    dict *migrate_cached_sockets;/* MIGRATE cached sockets */
    std::atomic<uint64_t> next_client_id; /* Next client unique ID. Incremental. */
@@ -1671,7 +1751,7 @@ struct redisServer {
    int lastbgsave_status;          /* C_OK or C_ERR */
    int stop_writes_on_bgsave_err;  /* Don't allow writes if can't BGSAVE */
    int rdb_pipe_write_result_to_parent; /* RDB pipes used to return the state */
-    int rdb_pipe_read_result_from_child; /* of each slave in diskless SYNC. */
+    int rdb_pipe_read_result_from_child; /* of each replica in diskless SYNC. */
    /* Pipe and data structures for child -> parent info sharing. */
    int child_info_pipe[2];         /* Pipe used to write the child_info_data. */
    struct {
@@ -1691,8 +1771,8 @@ struct redisServer {
    char replid2[CONFIG_RUN_ID_SIZE+1]; /* replid inherited from master*/
    long long master_repl_offset;   /* My current replication offset */
    long long second_replid_offset; /* Accept offsets up to this for replid2. */
-    int slaveseldb;                 /* Last SELECTed DB in replication output */
-    int repl_ping_slave_period;     /* Master pings the slave every N seconds */
+    int replicaseldb;                 /* Last SELECTed DB in replication output */
+    int repl_ping_slave_period;     /* Master pings the replica every N seconds */
    char *repl_backlog;             /* Replication backlog for partial syncs */
    long long repl_backlog_size;    /* Backlog circular buffer size */
    long long repl_backlog_histlen; /* Backlog actual data length */
@@ -1709,7 +1789,7 @@ struct redisServer {
    int repl_good_slaves_count;     /* Number of slaves with lag <= max_lag. */
    int repl_diskless_sync;         /* Send RDB to slaves sockets directly. */
    int repl_diskless_sync_delay;   /* Delay to start a diskless repl BGSAVE. */
-    /* Replication (slave) */
+    /* Replication (replica) */
    list *masters;
    int enable_multimaster; 
    int repl_timeout;               /* Timeout after N seconds of master idle */
@@ -1780,7 +1860,7 @@ struct redisServer {
    int cluster_slave_validity_factor; /* Slave max data age for failover. */
    int cluster_require_full_coverage; /* If true, put the cluster down if
                                          there is at least an uncovered slot.*/
-    int cluster_slave_no_failover;  /* Prevent slave from starting a failover
+    int cluster_slave_no_failover;  /* Prevent replica from starting a failover
                                       if the master is in failure state. */
    char *cluster_announce_ip;  /* IP address to announce on cluster bus. */
    int cluster_announce_port;     /* base port to announce on cluster bus. */
@@ -1825,8 +1905,6 @@ struct redisServer {

    int fActiveReplica;                          /* Can this replica also be a master? */

-    struct fastlock flock;
-
    // Format:
    //  Lower 20 bits: a counter incrementing for each command executed in the same millisecond
    //  Upper 44 bits: mstime (least significant 44-bits) enough for ~500 years before rollover from date of addition
@@ -2049,9 +2127,10 @@ const char *getClientTypeName(int cclass);
 void flushSlavesOutputBuffers(void);
 void disconnectSlaves(void);
 void disconnectSlavesExcept(unsigned char *uuid);
-int listenToPort(int port, int *fds, int *count, int fReusePort);
+int listenToPort(int port, int *fds, int *count, int fReusePort, int fFirstListen);
 void pauseClients(mstime_t duration);
 int clientsArePaused(void);
+void unpauseClientsIfNecessary();
 int processEventsWhileBlocked(int iel);
 int handleClientsWithPendingWrites(int iel);
 int clientHasPendingReplies(client *c);
@@ -2164,6 +2243,7 @@ int getLongLongFromObjectOrReply(client *c, robj *o, long long *target, const ch
 int getDoubleFromObjectOrReply(client *c, robj *o, double *target, const char *msg);
 int getDoubleFromObject(const robj *o, double *target);
 int getLongLongFromObject(robj *o, long long *target);
+int getUnsignedLongLongFromObject(robj *o, uint64_t *target);
 int getLongDoubleFromObject(robj *o, long double *target);
 int getLongDoubleFromObjectOrReply(client *c, robj *o, long double *target, const char *msg);
 const char *strEncoding(int encoding);
@@ -2203,9 +2283,10 @@ void replicationSendNewlineToMaster(struct redisMaster *mi);
 long long replicationGetSlaveOffset(struct redisMaster *mi);
 char *replicationGetSlaveName(client *c);
 long long getPsyncInitialOffset(void);
-int replicationSetupSlaveForFullResync(client *slave, long long offset);
+int replicationSetupSlaveForFullResync(client *replica, long long offset);
 void changeReplicationId(void);
 void clearReplicationId2(void);
+void mergeReplicationId(const char *);
 void chopReplicationBacklog(void);
 void replicationCacheMasterUsingMyself(struct redisMaster *mi);
 void feedReplicationBacklog(const void *ptr, size_t len);
@@ -2442,6 +2523,7 @@ int rewriteConfig(char *path);
 /* db.c -- Keyspace access API */
 int removeExpire(redisDb *db, robj *key);
 int removeExpireCore(redisDb *db, robj *key, dictEntry *de);
+int removeSubkeyExpire(redisDb *db, robj *key, robj *subkey);
 void propagateExpire(redisDb *db, robj *key, int lazy);
 int expireIfNeeded(redisDb *db, robj *key);
 expireEntry *getExpire(redisDb *db, robj_roptr key);
@@ -2642,6 +2724,7 @@ void monitorCommand(client *c);
 void expireCommand(client *c);
 void expireatCommand(client *c);
 void expireMemberCommand(client *c);
+void expireMemberAtCommand(client *c);
 void pexpireCommand(client *c);
 void pexpireatCommand(client *c);
 void getsetCommand(client *c);
@@ -2727,7 +2810,6 @@ void evalShaCommand(client *c);
 void scriptCommand(client *c);
 void timeCommand(client *c);
 void bitopCommand(client *c);
-void bitopRangeCommand(client *c);
 void bitcountCommand(client *c);
 void bitposCommand(client *c);
 void replconfCommand(client *c);
@@ -2803,7 +2885,7 @@ void xorDigest(unsigned char *digest, const void *ptr, size_t len);
 int populateCommandTableParseFlags(struct redisCommand *c, const char *strflags);

 int moduleGILAcquiredByModule(void);
-extern bool g_fInCrash;
+extern int g_fInCrash;
 static inline int GlobalLocksAcquired(void)  // Used in asserts to verify all global locks are correctly acquired for a server-thread to operate
 {
    return aeThreadOwnsLock() || moduleGILAcquiredByModule() || g_fInCrash;
@@ -33,7 +33,7 @@
 /* ----------------- Blocking sockets I/O with timeouts --------------------- */

 /* Redis performs most of the I/O in a nonblocking way, with the exception
- * of the SYNC command where the slave does it in a blocking way, and
+ * of the SYNC command where the replica does it in a blocking way, and
 * the MIGRATE command that must be blocking in order to be atomic from the
 * point of view of the two instances (one migrating the key and one receiving
 * the key). This is why need the following blocking I/O functions.
@@ -803,7 +803,7 @@ void streamPropagateXCLAIM(client *c, robj *key, streamCG *group, robj *groupnam
     *        RETRYCOUNT <count> FORCE JUSTID LASTID <id>.
     *
     * Note that JUSTID is useful in order to avoid that XCLAIM will do
-     * useless work in the slave side, trying to fetch the stream item. */
+     * useless work in the replica side, trying to fetch the stream item. */
    robj *argv[14];
    argv[0] = createStringObject("XCLAIM",6);
    argv[1] = key;
@@ -1,3 +1,3 @@
-#define KEYDB_REAL_VERSION "0.0.0"
+#define KEYDB_REAL_VERSION "5.2.0"
 extern const char *KEYDB_SET_VERSION;   // Unlike real version, this can be overriden by the config

@@ -14,6 +14,8 @@ proc main {} {
    spawn_instance redis $::redis_base_port $::instances_count {
        "cluster-enabled yes"
        "appendonly yes"
+	"testmode yes"
+	"server-threads 3"
    }
    run_tests
    cleanup
@@ -6,7 +6,7 @@ if {$system_name eq {linux} || $system_name eq {darwin}} {
        test "Server is able to generate a stack trace on selected systems" {
            r config set watchdog-period 200
            r debug sleep 1
-            set pattern "*debugCommand*"
+            set pattern "*watchdogSignalHandler*"
            set retry 10
            while {$retry} {
                set result [exec tail -100 < [srv 0 stdout]]
@@ -9,6 +9,7 @@ start_server {tags {"active-repl"} overrides {active-replica yes}} {
        set master [srv 0 client]
        set master_host [srv 0 host]
        set master_port [srv 0 port]
+    	set master_pid [s process_id]

        # Use a short replication timeout on the slave, so that if there
        # are no bugs the timeout is triggered in a reasonable amount
@@ -93,5 +94,38 @@ start_server {tags {"active-repl"} overrides {active-replica yes}} {
            assert_equal {0} [$master del testkey1]
            assert_equal {0} [$slave del testkey1]
        }
+
+	test {Active replica expire propogates when source is down} {
+            $slave flushall
+	    $slave set testkey2 foo
+            $slave set testkey1 foo
+            wait_for_condition 50 1000 {
+                [string match *foo* [$master get testkey1]]
+            } else {
+                fail "Replication failed to propogate"
+            }
+            $slave expire testkey1 2
+	    assert_equal {1} [$slave wait 1 500] { "value should propogate
+		                    within 0.5 seconds" }
+	    exec kill -SIGSTOP $slave_pid
+            after 3000
+	    # Ensure testkey1 is gone.  Note, we can't do this directly as the normal commands lie to us
+	    # about what is actually in the dict.  The only way to know is with a count from info
+            assert_equal {1} [expr [string first {keys=1} [$master info keyspace]] >= 0]  {"slave expired"}
+	}
+	exec kill -SIGCONT $slave_pid
+
+        test {Active replica different databases} {
+            $master select 3
+            $master set testkey abcd
+            $master select 2
+            $master del testkey
+            $slave select 3
+            wait_for_condition 50 1000 {
+                [string match abcd [$slave get testkey]]
+            } else {
+                fail "Replication failed to propogate DB 3"
+            }
+        }
    }
 }
@@ -35,6 +35,7 @@ set ::all_tests {
    unit/quit
    unit/aofrw
    unit/acl
+    unit/rreplay
    integration/block-repl
    integration/replication
    integration/replication-2
@@ -214,6 +214,64 @@ start_server {tags {"bitops"}} {
        r bitop or x a b
    } {32}

+    test {BITOP lshift size} {
+        r set a " "
+        r bitop lshift x a 1
+    } {2}
+
+    test {BITOP rshift size} {
+        r set a " "
+        r bitop rshift x a 1
+    } {1}
+
+    test {BITOP rshift 0 byte} {
+        r set a " "
+        r bitop rshift x a 8
+    } {0}
+
+    test {BITOP rshift underflow} {
+        r set a " "
+        r bitop rshift x a 65
+    } {0}
+
+    test {BITOP lshift string} {
+        r set a "abcdefg"
+        r bitop lshift x a 8
+        r get x
+    } "\000abcdefg"
+
+    test {BITOP lshift char} {
+        r set a "\xAA"
+        r bitop lshift x a 4
+        r get x
+    } "\xA0\x0A"
+
+    test {BITOP rshift char} {
+        r set a "\xAA"
+        r bitop rshift x a 3
+        r get x
+    } "\x15"
+
+    test {BITOP lshift carry} {
+        r set a "\xFF"
+        r bitop lshift x a 1
+        r get x
+    } "\xFE\x01"
+
+    test {BITOP rshift carry} {
+        r set a "\x00\xFF"
+        r bitop rshift x a 1
+        r get x
+    } "\x80\x7F"
+
+    test {BITOP rshift reciprocal} {
+        r flushdb
+        r set a "abcdefg"
+        r bitop lshift b a 14
+        r bitop rshift res b 14
+        r get res
+    } "abcdefg\x00"
+
    test {BITPOS bit=0 with empty key returns 0} {
        r del str
        r bitpos str 0
@@ -0,0 +1,30 @@
+start_server {tags {"rreplay"}} {
+
+    test {RREPLAY use current db} {
+        r debug force-master
+        r select 4
+        r set dbnum invalid
+        r rreplay "f4d5b2b5-4f07-4ee5-a4f2-5dc98507dfce" "*3\r\n\$3\r\nSET\r\n\$5\r\ndbnum\r\n\$4\r\nfour\r\n"
+        r get dbnum
+    } {four}
+    reconnect
+
+    test {RREPLAY db different} {
+        r debug force-master
+        r select 4
+        r set testkey four
+        r rreplay "f4d5b2b5-4f07-4ee5-a4f2-5dc98507dfce" "*3\r\n\$3\r\nSET\r\n\$7\r\ntestkey\r\n\$4\r\nbebe\r\n" 2
+        r select 4
+        assert { [r get testkey] == "four" }
+        r select 2
+        r get testkey
+    } {bebe}
+
+    reconnect
+
+    test {RREPLAY not master} {
+        assert_error "*master*" {r rreplay "f4d5b2b5-4f07-4ee5-a4f2-5dc98507dfce" "*3\r\n\$3\r\nSET\r\n\$7\r\ntestkey\r\n\$4\r\nbebe\r\n" 2}
+    }
+
+    r flushdb
+}
@@ -202,7 +202,7 @@ REDIS_CHKCONFIG_INFO=\
 # chkconfig: - 58 74\n
 # description: redis_${REDIS_PORT} is the redis daemon.\n
 ### BEGIN INIT INFO\n
-# Provides: redis_6379\n
+# Provides: redis_${REDIS_PORT}\n
 # Required-Start: \$network \$local_fs \$remote_fs\n
 # Required-Stop: \$network \$local_fs \$remote_fs\n
 # Default-Start: 2 3 4 5\n
Author	SHA1	Message	Date
John Sully	7dd53182e0	Bump version	2019-11-21 20:16:42 -05:00
John Sully	53b95d830a	Merge branch 'unstable' into RELEASE_5	2019-11-21 20:16:23 -05:00
John Sully	3028a890ef	Fix issue #83	2019-11-21 20:05:16 -05:00
John Sully	39c6fbddb1	Add missing dependency to dockerfile	2019-11-20 20:35:14 -05:00
John Sully	704cb4e929	Merge branch 'unstable' of https://github.com/JohnSully/KeyDB into unstable	2019-11-20 19:44:43 -05:00
John Sully	8e4f323439	Fix issue #107 , active replicas do their own expires	2019-11-20 19:44:31 -05:00
John Sully	937702ea1d	Additional asserts ensuring the client is creating on the correct thread	2019-11-20 17:00:40 -05:00
John Sully	3ea56ffb38	Update issue templates	2019-11-20 16:25:33 -05:00
John Sully	becd3fc5a3	Update issue templates	2019-11-20 16:24:23 -05:00
John Sully	4c8603815c	Fix failure to wakeup from futex sleep due to fastlock_unlock reading the wrong offset in the asm version. Also fix false sharing in spinlock	2019-11-17 16:06:49 -05:00
John Sully	3ae75c2d2b	Revert "Debug sleep should apply to all threads" This reverts commit `41b678814b`.	2019-11-17 15:39:47 -05:00
John Sully	9371c005aa	Improve perf of reading cluster bitfield	2019-11-17 14:52:12 -05:00
John Sully	16bd6b3f5d	Merge branch 'unstable' of https://github.com/JohnSully/KeyDB into unstable	2019-11-14 21:21:46 -05:00
John Sully	3dd78a6101	Cluster multithreading fixes	2019-11-14 20:14:24 -05:00
John Sully	41b678814b	Debug sleep should apply to all threads	2019-11-14 19:57:29 -05:00
John Sully	d0ccb074d5	killing clients should take effect ASAP	2019-11-14 19:49:32 -05:00
John Sully	cb0fc7cca2	Improve AE Assert message	2019-11-14 19:34:13 -05:00
John Sully	5e40ea6ee7	Fix test failure with tcl8.5 (test only issue)	2019-11-04 17:31:29 -08:00
John Sully	427c5999f1	Fix potential race in pubsub	2019-10-25 02:50:30 -04:00
John Sully	a91f58b8fd	Fix potential race in pubsub	2019-10-25 02:44:14 -04:00
John Sully	3013799664	bump version	2019-10-25 01:00:28 -04:00
John Sully	f8220a658e	Merge branch 'unstable' into RELEASE_5	2019-10-24 23:39:18 -04:00
John Sully	f1d2b29450	Signals can happen on any thread, so look for the signal handler not the command on the callstack	2019-10-24 23:30:08 -04:00
John Sully	cb93752aff	Two fixes: 1) Remove race conditions by not locking clients when async writing. 2) Don't derefence dangling pointers in lambda	2019-10-24 23:07:02 -04:00
John Sully	549cad378d	Sanitizers work with GCC too	2019-10-24 23:05:39 -04:00
John Sully	631f863dd8	Remove the DB lock, its unnecessary	2019-10-24 20:18:48 -04:00
John Sully	4396682c07	Remove unlocked KEYS command support, we will do this with snapshotting	2019-10-24 20:18:11 -04:00
John Sully	ca4ee4e3e4	Build break, ensure C99 compatibility	2019-10-23 13:38:07 -04:00
John Sully	2da09e0732	Fix build break in TravisCI	2019-10-23 13:31:39 -04:00
John Sully	4986dc6da9	If a replica is about to be closed, don't wait on its lock (potential deadlock)	2019-10-23 13:20:23 -04:00
John Sully	1a70af2ae1	processEventsWhileBlocked needs to release the lock in a safe way	2019-10-23 13:19:57 -04:00
John Sully	5a8cb77d0d	Remove race conditions	2019-10-22 23:26:37 -04:00
John Sully	600fc241cf	Optimize deadlock detection, fix callstack for ASM, and annotate locks Note: This change moves our assembly code to use the GNU Assembler because NASM seems to be incapable of emitting the necessary debug information for callstack unwinding to work.	2019-10-22 21:34:51 -04:00
John Sully	fa797408d9	Implement deadlock detection	2019-10-22 00:43:32 -04:00
John Sully	3fac516950	Disable multithreaded KEYS due to bugs	2019-10-21 12:21:46 -04:00
John Sully	2f65aa2337	Merge branch 'unstable' into RELEASE_5	2019-10-16 12:47:06 -04:00
john@csquare.ca	f5210a8fb0	Fix: ExpireMember does not update MVCC timestamp	2019-10-16 12:38:15 -04:00
John Sully	8f1295c00f	expiremember should return the same results as expire	2019-10-16 12:27:04 -04:00
John Sully	18a3768e07	Fix crash adding expire to key with a subkey expire already set	2019-10-16 12:26:48 -04:00
eric-weaver	95e3dbc104	add missing dependency	2019-10-13 21:30:06 +02:00
Segmond	40355eac3e	Update README.md Typo, focuses spelled as focusses	2019-10-13 21:29:15 +02:00
John Sully	3a3b59a054	Implement the lastmodified query for the OBJECT command	2019-10-13 14:12:09 -04:00
John Sully	12e17cfd6e	You are not allowed to set a subkey expire if the subkey does not exist	2019-10-13 14:11:43 -04:00
John Sully	203e341bf4	Implement the EXPIREMEMBERAT command	2019-10-13 13:15:13 -04:00
John Sully	6e6cd84ad7	Add millisecond support for EXPIREMEMBER command	2019-10-13 12:57:50 -04:00
John Sully	252725d50f	Update more slave instances to use replica (Issue #75 )	2019-10-13 12:29:20 -04:00
John Sully	c15633ea9e	Update a few uses of slave to use the new replica terminology (Issue #75 )	2019-10-13 12:12:05 -04:00
John Sully	27c9ae667e	Fix an intermittent crash when replicationCron happens before slavesdb is update	2019-10-13 12:04:54 -04:00
John Sully	16f96efbe7	Implement TTL and PERSIST commands for subkeys. Also ensure expiremember replaces any old subkey expiries	2019-10-13 12:03:25 -04:00
John Sully	5787e7adc7	Merge branch 'unstable' of https://github.com/JohnSully/redis2 into unstable	2019-10-13 10:03:01 -04:00
John Sully	4631119179	Fix issue #88 - don't let seperate KeyDB processes listen on the same port	2019-10-13 10:02:21 -04:00
John Sully	0a0c2146c8	Bump version	2019-10-01 17:53:48 -04:00
Edgard Lorraine Messias	cedea7e400	Fixed "Provides" name in chkconfig info	2019-10-01 13:44:58 -04:00
John Sully	66cef6646c	Merge branch 'unstable' into RELEASE_5	2019-09-30 00:28:12 -04:00
John Sully	64aa4b80e6	Expire DEL command place holder	2019-09-30 00:01:23 -04:00
John Sully	551a3cb1aa	Fuzz mode is now an argument not based on the exe name	2019-09-30 00:00:29 -04:00
John Sully	0942188b0a	finish up the RDB fuzz	2019-09-28 17:38:46 -04:00
John Sully	070c481871	Fix double free in RDB load	2019-09-28 17:38:26 -04:00
John Sully	6df4d29422	RDB fuzz test cases	2019-09-28 17:04:08 -04:00
John Sully	6e1e5bd08b	RREPLAY command now takes a DB argument	2019-09-28 14:59:44 -04:00
John Sully	ba365298ed	Implement left and right shift BITOP operators	2019-09-28 00:10:46 -04:00
John Sully	e1c9620951	Fix leaking stale RDBs during multimaster sync	2019-09-27 13:17:29 -04:00
John Sully	e776474f68	Fix multi master bugs: 1. we fail to create the temp file. 2. We use a master RDB as our backup even though we merged databases (and therefore it is not representitive)	2019-09-26 20:35:51 -04:00
John Sully	4589e861ab	Fix issue where AOF events are posted to the wrong event loop and not properly cleaned up	2019-09-19 15:40:09 -04:00
John Sully	55324aa56a	Fix issue where AOF events are posted to the wrong event loop and not properly cleaned up	2019-09-19 15:39:52 -04:00
John Sully	18d42a5c35	KEYS now only blocks one database	2019-09-12 18:51:10 -04:00
John Sully	71d5a10621	bump version	2019-09-06 13:31:40 -04:00
John Sully	ac595ebe37	Fix issue where Active Replicas were commiting data to the wrong database under load	2019-09-06 13:30:28 -04:00
John Sully	50a6a3ca38	Fix issue where Active Replicas were commiting data to the wrong database under load	2019-09-06 13:30:15 -04:00
John Sully	f83a89f82a	Acquire the lock for modules that don't acquire it before calling like they are supposed to	2019-08-29 15:41:03 -04:00
John Sully	bf905a78f0	Bump version	2019-08-27 15:32:24 -04:00
John Sully	fad9483fc9	Fix race condition in PUB/SUB and other async reply commands where the client can be freed before our handler is executed on the client thread. When this occurs the client pointer is dangling	2019-08-27 15:31:47 -04:00
John Sully	6b6e6f6c1e	Fix crash in RediSearch	2019-07-29 15:08:57 -04:00
John Sully	b0a0f03b96	RREPLAY failures should be logged	2019-07-24 22:49:55 -04:00
John Sully	f1982ca63d	Issue #64 RREPLAY isn't binary safe. Add fix and test.	2019-07-24 22:31:44 -04:00
John Sully	25e18a7de9	Release version 5	2019-07-18 20:50:40 -04:00