Remove performance zapping test code

Typo, focuses spelled as focusses

.travis.yml

@@ -4,11 +4,11 @@ matrix:
   include:
     - os: linux
       script: make
-      env: COMPILER_NAME=gcc CXX=g++-5 CC=gcc-5
+      env: COMPILER_NAME=g++-6 CXX=g++-6 CC=gcc-6
       addons:
         apt:
           packages:
-            - g++-5
+            - g++-6
             - nasm
             - uuid-dev
           sources: &sources
@@ -16,10 +16,11 @@ matrix:
             - ubuntu-toolchain-r-test
     - os: linux
       script: make MALLOC=libc
-      env: COMPILER_NAME=clang CXX=clang++-3.8 CC=clang-3.8 CXXFLAGS="-stdlib=libc++" LDFLAGS="-stdlib=libc++"
+      env: COMPILER_NAME=clang CXX=clang++-3.8 CC=clang-3.8 CXXFLAGS="-I/usr/include/libcxxabi/" LDFLAGS="-lc++"
       addons:
         apt:
           packages:
+            - libc++abi-dev
             - clang-3.8
             - libc++-dev
             - libc++abi-dev

.vscode/settings.json

@@ -51,6 +51,8 @@
         "tuple": "cpp",
         "type_traits": "cpp",
         "typeinfo": "cpp",
-        "utility": "cpp"
+        "utility": "cpp",
+        "set": "cpp",
+        "algorithm": "cpp"
     }
 }

CONTRIBUTING

@@ -14,9 +14,7 @@ each source file that you contribute.
 
   PLEASE DO NOT POST GENERAL QUESTIONS that are not about bugs or suspected
   bugs in the Github issues system. We'll be very happy to help you and provide
-  all the support at the Reddit sub:
-
-      http://reddit.com/r/redis
+  all the support in the mailing list.
 
   There is also an active community of Redis users at Stack Overflow:
 
@@ -24,7 +22,12 @@ each source file that you contribute.
 
 # How to provide a patch for a new feature
 
-1. If it is a major feature or a semantical change, please post it as a new submission in r/redis on Reddit at http://reddit.com/r/redis. Try to be passionate about why the feature is needed, make users upvote your proposal to gain traction and so forth. Read feedbacks about the community. But in this first step **please don't write code yet**.
+1. If it is a major feature or a semantical change, please don't start coding
+straight away: if your feature is not a conceptual fit you'll lose a lot of
+time writing the code without any reason. Start by posting in the mailing list
+and creating an issue at Github with the description of, exactly, what you want
+to accomplish and why. Use cases are important for features to be accepted.
+Here you'll see if there is consensus about your idea.
 
 2. If in step 1 you get an acknowledgment from the project leaders, use the
    following procedure to submit a patch:
@@ -35,6 +38,13 @@ each source file that you contribute.
     d. Initiate a pull request on github ( https://help.github.com/articles/creating-a-pull-request/ )
     e. Done :)
 
-For minor fixes just open a pull request on Github.
+3. Keep in mind that we are very overloaded, so issues and PRs sometimes wait
+for a *very* long time. However this is not lack of interest, as the project
+gets more and more users, we find ourselves in a constant need to prioritize
+certain issues/PRs over others. If you think your issue/PR is very important
+try to popularize it, have other users commenting and sharing their point of
+view and so forth. This helps.
+
+4. For minor fixes just open a pull request on Github.
 
 Thanks!

Dockerfile

@@ -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 \
     && apt-get clean
 
 CMD make

README.md

@@ -1,38 +1,48 @@
 ![Current Release](https://img.shields.io/github/release/JohnSully/KeyDB.svg)
 [![Build Status](https://travis-ci.org/JohnSully/KeyDB.svg?branch=unstable)](https://travis-ci.org/JohnSully/KeyDB) [![Join the chat at https://gitter.im/KeyDB/community](https://badges.gitter.im/KeyDB/community.svg)](https://gitter.im/KeyDB/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
+[![StackShare](http://img.shields.io/badge/tech-stack-0690fa.svg?style=flat)](https://stackshare.io/eq-alpha-technology-inc/eq-alpha-technology-inc)
+
+##### Need Help? Check out our extensive [documentation](https://docs.keydb.dev).
 
 What is KeyDB?
 --------------
 
-KeyDB is a high performance fork of Redis focusing on multithreading, memory efficiency, and high throughput.  In addition to multithreading KeyDB also has features only available in Redis Enterprise such as [Active Replication](https://github.com/JohnSully/KeyDB/wiki/KeyDB-(Redis-Fork):-Active-Replica-Support), [FLASH storage](https://github.com/JohnSully/KeyDB/wiki/FLASH-Storage) support, and some not available at all such as direct backup to AWS S3.
+KeyDB is a high performance fork of Redis with a focus on multithreading, memory efficiency, and high throughput.  In addition to multithreading, KeyDB also has features only available in Redis Enterprise such as [Active Replication](https://github.com/JohnSully/KeyDB/wiki/Active-Replication), [FLASH storage](https://github.com/JohnSully/KeyDB/wiki/FLASH-Storage) support, and some not available at all such as direct backup to AWS S3. 
 
-On the same hardware KeyDB can perform twice as many queries per second as Redis, with 60% lower latency.
+KeyDB maintains full compatibility with the Redis protocol, modules, and scripts.  This includes the atomicity gurantees for scripts and transactions.  Because KeyDB keeps in sync with Redis development KeyDB is a superset of Redis functionality, making KeyDB a drop in replacement for existing Redis deployments.
 
-KeyDB has full compatibility with the Redis protocol, modules, and scripts.  This includes full support for transactions, and atomic execution of scripts.  For more information see our architecture section below.
+On the same hardware KeyDB can perform twice as many queries per second as Redis, with 60% lower latency. Active-Replication simplifies hot-spare failover allowing you to easily distribute writes over replicas and use simple TCP based load balancing/failover. KeyDB's higher performance allows you to do more on less hardware which reduces operation costs and complexity.
+
+<img src=https://cdn-images-1.medium.com/max/1400/1*s7mTb7Qb0kxc951mz8bdgA.png width=420 height=300/><img src=https://cdn-images-1.medium.com/max/1400/1*R00A5U4AFGohGOYHMfT6fA.png height=300/>
+
+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 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.
+
+Additional Resources
+--------------------
 
 Try our docker container: https://hub.docker.com/r/eqalpha/keydb
 
 Talk on Gitter: https://gitter.im/KeyDB
 
+Visit our Website: https://keydb.dev
+
+See options for channel partners and support contracts: https://keydb.dev/support.html
+
+Learn with KeyDB’s official documentation site: https://docs.keydb.dev
+
+[Subscribe to the KeyDB mailing list](https://eqalpha.us20.list-manage.com/subscribe/post?u=978f486c2f95589b24591a9cc&id=4ab9220500)
+
 Management GUI: We recommend [FastoNoSQL](https://fastonosql.com/) which has official KeyDB support.
 
-New: Active Replica Support
----------------------------
-
-New! KeyDB now has support for Active Replicas.  This feature greatly simplifies hot-spare failover and allows you to distribute writes over replicas instead of just a single master.  For more information [see the wiki page](https://github.com/JohnSully/KeyDB/wiki/KeyDB-(Redis-Fork):-Active-Replica-Support).
-
-Why fork Redis?
----------------
-
-The Redis maintainers have continually reiterated that they do not plan to support multithreading.  While we have great respect for the redis team, we feel the analysis justifying this decision is incorrect.  In addition we wanted open source implementations of features currently only available in proprietary modules.   We feel a fork is the best way to accelerate development in the areas of most interest to us.
-
-We plan to track the Redis repo closely and hope our projects can learn from each other.
 
 Benchmarking KeyDB
 ------------------
 
-<img src=https://cdn-images-1.medium.com/max/1400/1*s7mTb7Qb0kxc951mz8bdgA.png width=420 height=300/><img src=https://cdn-images-1.medium.com/max/1400/1*R00A5U4AFGohGOYHMfT6fA.png height=300/>
-
 Please note keydb-benchmark and redis-benchmark are currently single threaded and too slow to properly benchmark KeyDB.  We recommend using a redis cluster benchmark tool such as [memtier](https://github.com/RedisLabs/memtier_benchmark).  Please ensure your machine has enough cores for both KeyDB and memteir if testing locally.  KeyDB expects exclusive use of any cores assigned to it.
 
 For more details on how we benchmarked KeyDB along with performance numbers check out our blog post: [Redis Should Be Multithreaded](https://medium.com/@john_63123/redis-should-be-multi-threaded-e28319cab744?source=friends_link&sk=7ce8e9fe3ec8224a4d27ef075d085457)
@@ -55,6 +65,10 @@ If you would like to use the [FLASH backed](https://github.com/JohnSully/KeyDB/w
 
 If you would like KeyDB to dump and load directly to AWS S3 this option specifies the bucket.  Using this option with the traditional RDB options will result in KeyDB backing up twice to both locations.  If both are specified KeyDB will first attempt to load from the local dump file and if that fails load from S3.  This requires the AWS CLI tools to be installed and configured which are used under the hood to transfer the data.
 
+    active-replica yes
+
+If you are using active-active replication set `active-replica` option to “yes”. This will enable both instances to accept reads and writes while remaining synced. [Click here](https://docs.keydb.dev/docs/active-rep/) to see more on active-rep in our docs section. There are also [docker examples]( https://docs.keydb.dev/docs/docker-active-rep/) on docs.
+
 All other configuration options behave as you'd expect.  Your existing configuration files should continue to work unchanged.
 
 Building KeyDB
@@ -64,16 +78,19 @@ KeyDB can be compiled and is tested for use on Linux.  KeyDB currently relies on
 
 Install dependencies:
 
-    % sudo apt install build-essential nasm autotools-dev autoconf libjemalloc-dev tcl tcl-dev uuid-dev
+    % sudo apt install build-essential nasm autotools-dev autoconf libjemalloc-dev tcl tcl-dev uuid-dev libcurl4-openssl-dev
 
 Compiling is as simple as:
 
     % make
 
-You can enable flash support with (Note: autoconf and autotools must be installed):
+You can enable flash support with:
 
     % make MALLOC=memkind
 
+***Note that the following dependencies may be needed: 
+    % sudo apt-get install autoconf autotools-dev libnuma-dev libtool
+
 Fixing build problems with dependencies or cached build options
 ---------
 
@@ -176,7 +193,7 @@ then in another terminal try the following:
     (integer) 2
     keydb>
 
-You can find the list of all the available commands at http://redis.io/commands.
+You can find the list of all the available commands at https://docs.keydb.dev/docs/commands/
 
 Installing KeyDB
 -----------------
@@ -219,23 +236,18 @@ Future work:
 
 Docker Build
 ------------
-
-Run the following commands for a full source download and build:
-
+Build the latest binaries from the github unstable branch within a docker container. Note this is built for Ubuntu 18.04.
+Simply make a directory you would like to have the latest binaries dumped in, then run the following commmand with your updated path:
 ```
-git clone git@github.com:JohnSully/KeyDB.git
-docker run -it --rm -v `pwd`/KeyDB:/build -w /build devopsdood/keydb-builder make
+$ docker run -it --rm -v /path-to-dump-binaries:/keydb_bin eqalpha/keydb-build-bin
 ```
+You should receive the following files: keydb-benchmark,  keydb-check-aof,  keydb-check-rdb,  keydb-cli,  keydb-sentinel,  keydb-server
 
-Then you have fresh binaries built, you can also pass any other options to the make command above after the word make. E.g.
-
-```docker run -it --rm -v `pwd`/KeyDB:/build -w /build devopsdood/keydb-builder make MAllOC=memkind```
-
-The above commands will build you binaries in the src directory. Standard `make install` without Docker command will work after if you wish to install
-
-If you'd prefer you can build the Dockerfile in the repo instead of pulling the above container for use:
-
-`docker build -t KeyDB .`
+If you are looking to enable flash support with the build (make MALLOC=memkind) then use the following command:
+```
+$ docker run -it --rm -v /path-to-dump-binaries:/keydb_bin eqalpha/keydb-build-bin:flash
+```
+Please note that you will need libcurl4-openssl-dev in order to run keydb. With flash version you may need libnuma-dev and libtool installed in order to run the binaries. Keep this in mind especially when running in a container. For a copy of all our Dockerfiles, please see them on [docs]( https://docs.keydb.dev/docs/dockerfiles/).
 
 Code contributions
 -----------------

deps/hiredis/read.c

@@ -31,6 +31,7 @@
 
 #include "fmacros.h"
 #include <string.h>
+#include <strings.h>
 #include <stdlib.h>
 #ifndef _MSC_VER
 #include <unistd.h>

fuzz/rdb/dict.txt

@@ -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"
+

redis.conf

@@ -942,13 +942,7 @@ aof-use-rdb-preamble yes
 lua-time-limit 5000
 
 ################################ REDIS CLUSTER  ###############################
-#
-# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-# WARNING EXPERIMENTAL: Redis Cluster is considered to be stable code, however
-# in order to mark it as "mature" we need to wait for a non trivial percentage
-# of users to deploy it in production.
-# ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
-#
+
 # Normal Redis instances can't be part of a Redis Cluster; only nodes that are
 # started as cluster nodes can. In order to start a Redis instance as a
 # cluster node enable the cluster support uncommenting the following:

runtest-moduleapi

@@ -0,0 +1,16 @@
+#!/bin/sh
+TCL_VERSIONS="8.5 8.6"
+TCLSH=""
+
+for VERSION in $TCL_VERSIONS; do
+	TCL=`which tclsh$VERSION 2>/dev/null` && TCLSH=$TCL
+done
+
+if [ -z $TCLSH ]
+then
+    echo "You need tcl 8.5 or newer in order to run the Redis test"
+    exit 1
+fi
+
+make -C tests/modules && \
+$TCLSH tests/test_helper.tcl --single unit/moduleapi/commandfilter "${@}"

src/IStorage.h

@@ -0,0 +1,14 @@
+#pragma once
+#include <functional>
+
+class IStorage
+{
+public:
+    typedef std::function<void(const char *, size_t, const void *, size_t)> callback;
+
+    virtual void insert(const char *key, size_t cchKey, void *data, size_t cb) = 0;
+    virtual void erase(const char *key, size_t cchKey) = 0;
+    virtual void retrieve(const char *key, size_t cchKey, bool fDelete, callback fn) = 0;
+    virtual size_t clear() = 0;
+    virtual void enumerate(callback fn) = 0;
+};

src/Makefile

@@ -20,8 +20,8 @@ DEPENDENCY_TARGETS=hiredis linenoise lua
 NODEPS:=clean distclean
 
 # Default settings
-STD=-std=c99 -pedantic -DREDIS_STATIC=''
-CXX_STD=-std=c++14 -pedantic -fno-rtti -fno-exceptions -D__STDC_FORMAT_MACROS  
+STD=-std=c11 -pedantic -DREDIS_STATIC=''
+CXX_STD=-std=c++14 -pedantic -fno-rtti -D__STDC_FORMAT_MACROS  
 ifneq (,$(findstring clang,$(CC)))
 ifneq (,$(findstring FreeBSD,$(uname_S)))
   STD+=-Wno-c11-extensions
@@ -45,6 +45,17 @@ endif
 endif
 
 USEASM?=true
+
+ifneq ($(SANITIZE),)
+	CC=clang
+	CXX=clang++
+	CFLAGS+= -fsanitize=$(SANITIZE) -DSANITIZE
+	CXXFLAGS+= -fsanitize=$(SANITIZE) -DSANITIZE
+	LDFLAGS+= -fsanitize=$(SANITIZE)
+	MALLOC=libc
+	USEASM=false
+endif
+
 # Do we use our assembly spinlock? X64 only
 ifeq ($(uname_S),Linux)
 ifeq ($(uname_M),x86_64)
@@ -140,6 +151,7 @@ else
 	# All the other OSes (notably Linux)
 	FINAL_LDFLAGS+= -rdynamic
 	FINAL_LIBS+=-ldl -pthread -lrt -luuid
+	FINAL_CFLAGS += -DMOTD
 endif
 endif
 endif
@@ -197,11 +209,11 @@ endif
 
 REDIS_SERVER_NAME=keydb-server
 REDIS_SENTINEL_NAME=keydb-sentinel
-REDIS_SERVER_OBJ=adlist.o quicklist.o ae.o anet.o dict.o server.o sds.o zmalloc.o lzf_c.o lzf_d.o pqsort.o zipmap.o sha1.o ziplist.o release.o networking.o util.o object.o db.o replication.o rdb.o t_string.o t_list.o t_set.o t_zset.o t_hash.o config.o aof.o pubsub.o multi.o debug.o sort.o intset.o syncio.o cluster.o crc16.o endianconv.o slowlog.o scripting.o bio.o rio.o rand.o memtest.o crc64.o bitops.o sentinel.o notify.o setproctitle.o blocked.o hyperloglog.o latency.o sparkline.o redis-check-rdb.o redis-check-aof.o geo.o lazyfree.o module.o evict.o expire.o geohash.o geohash_helper.o childinfo.o defrag.o siphash.o rax.o t_stream.o listpack.o localtime.o acl.o storage.o rdb-s3.o fastlock.o $(ASM_OBJ)
+REDIS_SERVER_OBJ=adlist.o quicklist.o ae.o anet.o dict.o server.o sds.o zmalloc.o lzf_c.o lzf_d.o pqsort.o zipmap.o sha1.o ziplist.o release.o networking.o util.o object.o db.o replication.o rdb.o t_string.o t_list.o t_set.o t_zset.o t_hash.o config.o aof.o pubsub.o multi.o debug.o sort.o intset.o syncio.o cluster.o crc16.o endianconv.o slowlog.o scripting.o bio.o rio.o rand.o memtest.o crc64.o bitops.o sentinel.o notify.o setproctitle.o blocked.o hyperloglog.o latency.o sparkline.o redis-check-rdb.o redis-check-aof.o geo.o lazyfree.o module.o evict.o expire.o geohash.o geohash_helper.o childinfo.o defrag.o siphash.o rax.o t_stream.o listpack.o localtime.o acl.o storage.o rdb-s3.o fastlock.o new.o tracking.o $(ASM_OBJ)
 REDIS_CLI_NAME=keydb-cli
-REDIS_CLI_OBJ=anet.o adlist.o dict.o redis-cli.o redis-cli-cpphelper.o zmalloc.o release.o anet.o ae.o crc64.o siphash.o crc16.o storage-lite.o fastlock.o $(ASM_OBJ)
+REDIS_CLI_OBJ=anet.o adlist.o dict.o redis-cli.o redis-cli-cpphelper.o zmalloc.o release.o anet.o ae.o crc64.o siphash.o crc16.o storage-lite.o fastlock.o new.o $(ASM_OBJ)
 REDIS_BENCHMARK_NAME=keydb-benchmark
-REDIS_BENCHMARK_OBJ=ae.o anet.o redis-benchmark.o adlist.o dict.o zmalloc.o siphash.o redis-benchmark.o storage-lite.o fastlock.o $(ASM_OBJ)
+REDIS_BENCHMARK_OBJ=ae.o anet.o redis-benchmark.o adlist.o dict.o zmalloc.o siphash.o redis-benchmark.o storage-lite.o fastlock.o new.o $(ASM_OBJ)
 REDIS_CHECK_RDB_NAME=keydb-check-rdb
 REDIS_CHECK_AOF_NAME=keydb-check-aof
 
@@ -264,7 +276,7 @@ $(REDIS_CHECK_AOF_NAME): $(REDIS_SERVER_NAME)
 
 # keydb-cli
 $(REDIS_CLI_NAME): $(REDIS_CLI_OBJ)
-	$(REDIS_LD) -o $@ $^ ../deps/hiredis/libhiredis.a ../deps/linenoise/linenoise.o $(FINAL_LIBS)
+	$(REDIS_LD) -o $@ $^ ../deps/hiredis/libhiredis.a ../deps/linenoise/linenoise.o $(FINAL_LIBS) -lcurl
 
 # keydb-benchmark
 $(REDIS_BENCHMARK_NAME): $(REDIS_BENCHMARK_OBJ)

src/acl.cpp

@@ -295,7 +295,7 @@ int ACLGetCommandBitCoordinates(uint64_t id, uint64_t *word, uint64_t *bit) {
  * Note that this function does not check the ALLCOMMANDS flag of the user
  * but just the lowlevel bitmask.
  *
- * If the bit overflows the user internal represetation, zero is returned
+ * If the bit overflows the user internal representation, zero is returned
  * in order to disallow the execution of the command in such edge case. */
 int ACLGetUserCommandBit(user *u, unsigned long id) {
     uint64_t word, bit;
@@ -311,7 +311,7 @@ int ACLUserCanExecuteFutureCommands(user *u) {
 }
 
 /* Set the specified command bit for the specified user to 'value' (0 or 1).
- * If the bit overflows the user internal represetation, no operation
+ * If the bit overflows the user internal representation, no operation
  * is performed. As a side effect of calling this function with a value of
  * zero, the user flag ALLCOMMANDS is cleared since it is no longer possible
  * to skip the command bit explicit test. */
@@ -350,7 +350,7 @@ int ACLSetUserCommandBitsForCategory(user *u, const char *category, int value) {
 
 /* Return the number of commands allowed (on) and denied (off) for the user 'u'
  * in the subset of commands flagged with the specified category name.
- * If the categoty name is not valid, C_ERR is returend, otherwise C_OK is
+ * If the category name is not valid, C_ERR is returned, otherwise C_OK is
  * returned and on and off are populated by reference. */
 int ACLCountCategoryBitsForUser(user *u, unsigned long *on, unsigned long *off,
                                 const char *category)
@@ -542,6 +542,8 @@ struct redisCommand *ACLLookupCommand(const char *name) {
  * and command ID. */
 void ACLResetSubcommandsForCommand(user *u, unsigned long id) {
     if (u->allowed_subcommands && u->allowed_subcommands[id]) {
+        for (int i = 0; u->allowed_subcommands[id][i]; i++)
+            sdsfree(u->allowed_subcommands[id][i]);
         zfree(u->allowed_subcommands[id]);
         u->allowed_subcommands[id] = NULL;
     }
@@ -624,7 +626,7 @@ void ACLAddAllowedSubcommand(user *u, unsigned long id, const char *sub) {
  *              It is possible to specify multiple patterns.
  * allkeys      Alias for ~*
  * resetkeys    Flush the list of allowed keys patterns.
- * ><password>  Add this passowrd to the list of valid password for the user.
+ * ><password>  Add this password to the list of valid password for the user.
  *              For example >mypass will add "mypass" to the list.
  *              This directive clears the "nopass" flag (see later).
  * <<password>  Remove this password from the list of valid passwords.
@@ -947,9 +949,9 @@ user *ACLGetUserByName(const char *name, size_t namelen) {
     return (user*)myuser;
 }
 
-/* Check if the command ready to be excuted in the client 'c', and already
- * referenced by c->cmd, can be executed by this client according to the
- * ACls associated to the client user c->user.
+/* Check if the command is ready to be executed in the client 'c', already
+ * referenced by c->cmd, and can be executed by this client according to the
+ * ACLs associated to the client user c->user.
  *
  * If the user can execute the command ACL_OK is returned, otherwise
  * ACL_DENIED_CMD or ACL_DENIED_KEY is returned: the first in case the
@@ -1120,7 +1122,7 @@ int ACLLoadConfiguredUsers(void) {
 }
 
 /* This function loads the ACL from the specified filename: every line
- * is validated and shold be either empty or in the format used to specify
+ * is validated and should be either empty or in the format used to specify
  * users in the redis.conf configuration or in the ACL file, that is:
  *
  *  user <username> ... rules ...
@@ -1170,7 +1172,7 @@ sds ACLLoadFromFile(const char *filename) {
      * to the real user mentioned in the ACL line. */
     user *fakeuser = ACLCreateUnlinkedUser();
 
-    /* We do all the loading in a fresh insteance of the Users radix tree,
+    /* We do all the loading in a fresh instance of the Users radix tree,
      * so if there are errors loading the ACL file we can rollback to the
      * old version. */
     rax *old_users = Users;
@@ -1246,7 +1248,7 @@ sds ACLLoadFromFile(const char *filename) {
         }
 
         /* Note that the same rules already applied to the fake user, so
-         * we just assert that everything goess well: it should. */
+         * we just assert that everything goes well: it should. */
         for (j = 2; j < argc; j++)
             serverAssert(ACLSetUser(u,argv[j],sdslen(argv[j])) == C_OK);
 
@@ -1609,7 +1611,7 @@ void addReplyCommandCategories(client *c, struct redisCommand *cmd) {
     setDeferredSetLen(c, flaglen, flagcount);
 }
 
-/* AUTH <passowrd>
+/* AUTH <password>
  * AUTH <username> <password> (Redis >= 6.0 form)
  *
  * When the user is omitted it means that we are trying to authenticate

src/ae.cpp

@@ -191,6 +191,36 @@ void aeProcessCmd(aeEventLoop *eventLoop, int fd, void *, int )
     }
 }
 
+// Unlike write() this is an all or nothing thing.  We will block if a partial write is hit
+ssize_t safe_write(int fd, const void *pv, size_t cb)
+{
+    const char *pcb = (const char*)pv;
+    ssize_t written = 0;
+    do
+    {
+        ssize_t rval = write(fd, pcb, cb);
+        if (rval > 0)
+        {
+            pcb += rval;
+            cb -= rval;
+            written += rval;
+        }
+        else if (errno == EAGAIN)
+        {
+            if (written == 0)
+                break;
+            // if we've already written something then we're committed so keep trying
+        }
+        else
+        {
+            if (rval == 0)
+                return written;
+            return rval;
+        }
+    } while (cb);
+    return written;
+}
+
 int aeCreateRemoteFileEvent(aeEventLoop *eventLoop, int fd, int mask,
         aeFileProc *proc, void *clientData, int fSynchronous)
 {
@@ -199,7 +229,7 @@ int aeCreateRemoteFileEvent(aeEventLoop *eventLoop, int fd, int mask,
 
     int ret = AE_OK;
     
-    aeCommand cmd;
+    aeCommand cmd = {};
     cmd.op = AE_ASYNC_OP::CreateFileEvent;
     cmd.fd = fd;
     cmd.mask = mask;
@@ -212,9 +242,10 @@ int aeCreateRemoteFileEvent(aeEventLoop *eventLoop, int fd, int mask,
     std::unique_lock<std::mutex> ulock(cmd.pctl->mutexcv, std::defer_lock);
     if (fSynchronous)
         cmd.pctl->mutexcv.lock();
-    auto size = write(eventLoop->fdCmdWrite, &cmd, sizeof(cmd));
+    auto size = safe_write(eventLoop->fdCmdWrite, &cmd, sizeof(cmd));
     if (size != sizeof(cmd))
     {
+        AE_ASSERT(size == sizeof(cmd) || size <= 0);
         AE_ASSERT(errno == EAGAIN);
         ret = AE_ERR;
     }
@@ -236,7 +267,7 @@ int aePostFunction(aeEventLoop *eventLoop, aePostFunctionProc *proc, void *arg)
         proc(arg);
         return AE_OK;
     }
-    aeCommand cmd;
+    aeCommand cmd = {};
     cmd.op = AE_ASYNC_OP::PostFunction;
     cmd.proc = proc;
     cmd.clientData = arg;
@@ -253,7 +284,7 @@ int aePostFunction(aeEventLoop *eventLoop, std::function<void()> fn, bool fSynch
         return AE_OK;
     }
 
-    aeCommand cmd;
+    aeCommand cmd = {};
     cmd.op = AE_ASYNC_OP::PostCppFunction;
     cmd.pfn = new (MALLOC_LOCAL) std::function<void()>(fn);
     cmd.pctl = nullptr;
@@ -803,9 +834,9 @@ void aeAcquireLock()
     g_lock.lock();
 }
 
-int aeTryAcquireLock()
+int aeTryAcquireLock(int fWeak)
 {
-    return g_lock.try_lock();
+    return g_lock.try_lock(!!fWeak);
 }
 
 void aeReleaseLock()

src/ae.h

@@ -159,7 +159,7 @@ int aeGetSetSize(aeEventLoop *eventLoop);
 int aeResizeSetSize(aeEventLoop *eventLoop, int setsize);
 
 void aeAcquireLock();
-int aeTryAcquireLock();
+int aeTryAcquireLock(int fWeak);
 void aeReleaseLock();
 int aeThreadOwnsLock();
 

src/aelocker.h

@@ -0,0 +1,74 @@
+#pragma once
+
+class AeLocker
+{
+    bool m_fArmed = false;
+
+public:
+    AeLocker()
+    {
+    }
+
+    void arm(client *c) // if a client is passed, then the client is already locked
+    {
+        if (c != nullptr)
+        {
+            serverAssert(!m_fArmed);
+            serverAssert(c->lock.fOwnLock());
+
+            if (!aeTryAcquireLock(true /*fWeak*/))    // avoid locking the client if we can
+            {
+                bool fOwnClientLock = true;
+                int clientNesting = 1;
+                for (;;)
+                {
+                    if (fOwnClientLock)
+                    {
+                        clientNesting = c->lock.unlock_recursive();
+                        fOwnClientLock = false;
+                    }
+                    aeAcquireLock();
+                    if (!c->lock.try_lock(false))   // ensure a strong try because aeAcquireLock is expensive
+                    {
+                        aeReleaseLock();
+                    }
+                    else
+                    {
+                        break;
+                    }
+                }
+                c->lock.lock_recursive(clientNesting);
+            }
+            
+            m_fArmed = true;
+        }
+        else if (!m_fArmed)
+        {
+            m_fArmed = true;
+            aeAcquireLock();
+        }
+    }
+
+    void disarm()
+    {
+        serverAssert(m_fArmed);
+        m_fArmed = false;
+        aeReleaseLock();
+    }
+
+    bool isArmed() const
+    {
+        return m_fArmed;
+    }
+
+    void release()
+    {
+        m_fArmed = false;
+    }
+
+    ~AeLocker()
+    {
+        if (m_fArmed)
+            aeReleaseLock();
+    }
+};

src/anet.c

@@ -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)

src/anet.h

@@ -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);

src/aof.cpp

@@ -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
@@ -199,6 +197,12 @@ ssize_t aofRewriteBufferWrite(int fd) {
  * AOF file implementation
  * ------------------------------------------------------------------------- */
 
+/* Return true if an AOf fsync is currently already in progress in a
+ * BIO thread. */
+int aofFsyncInProgress(void) {
+    return bioPendingJobsOfType(BIO_AOF_FSYNC) != 0;
+}
+
 /* Starts a background task that performs fsync() against the specified
  * file descriptor (the one of the AOF file) in another thread. */
 void aof_background_fsync(int fd) {
@@ -260,7 +264,7 @@ int startAppendOnly(void) {
             strerror(errno));
         return C_ERR;
     }
-    if (g_pserver->rdb_child_pid != -1) {
+    if (g_pserver->FRdbSaveInProgress()) {
         g_pserver->aof_rewrite_scheduled = 1;
         serverLog(LL_WARNING,"AOF was enabled but there is already a child process saving an RDB file on disk. An AOF background was scheduled to start when possible.");
     } else {
@@ -337,10 +341,24 @@ void flushAppendOnlyFile(int force) {
     int sync_in_progress = 0;
     mstime_t latency;
 
-    if (sdslen(g_pserver->aof_buf) == 0) return;
+    if (sdslen(g_pserver->aof_buf) == 0) {
+        /* Check if we need to do fsync even the aof buffer is empty,
+         * because previously in AOF_FSYNC_EVERYSEC mode, fsync is
+         * called only when aof buffer is not empty, so if users
+         * stop write commands before fsync called in one second,
+         * the data in page cache cannot be flushed in time. */
+        if (g_pserver->aof_fsync == AOF_FSYNC_EVERYSEC &&
+            g_pserver->aof_fsync_offset != g_pserver->aof_current_size &&
+            g_pserver->unixtime > g_pserver->aof_last_fsync &&
+            !(sync_in_progress = aofFsyncInProgress())) {
+            goto try_fsync;
+        } else {
+            return;
+        }
+    }
 
     if (g_pserver->aof_fsync == AOF_FSYNC_EVERYSEC)
-        sync_in_progress = bioPendingJobsOfType(BIO_AOF_FSYNC) != 0;
+        sync_in_progress = aofFsyncInProgress();
 
     if (g_pserver->aof_fsync == AOF_FSYNC_EVERYSEC && !force) {
         /* With this append fsync policy we do background fsyncing.
@@ -379,7 +397,7 @@ void flushAppendOnlyFile(int force) {
      * useful for graphing / monitoring purposes. */
     if (sync_in_progress) {
         latencyAddSampleIfNeeded("aof-write-pending-fsync",latency);
-    } else if (g_pserver->aof_child_pid != -1 || g_pserver->rdb_child_pid != -1) {
+    } else if (g_pserver->aof_child_pid != -1 || g_pserver->FRdbSaveInProgress()) {
         latencyAddSampleIfNeeded("aof-write-active-child",latency);
     } else {
         latencyAddSampleIfNeeded("aof-write-alone",latency);
@@ -472,10 +490,11 @@ void flushAppendOnlyFile(int force) {
         g_pserver->aof_buf = sdsempty();
     }
 
+try_fsync:
     /* Don't fsync if no-appendfsync-on-rewrite is set to yes and there are
      * children doing I/O in the background. */
     if (g_pserver->aof_no_fsync_on_rewrite &&
-        (g_pserver->aof_child_pid != -1 || g_pserver->rdb_child_pid != -1))
+        (g_pserver->aof_child_pid != -1 || g_pserver->FRdbSaveInProgress()))
             return;
 
     /* Perform the fsync if needed. */
@@ -486,10 +505,14 @@ void flushAppendOnlyFile(int force) {
         redis_fsync(g_pserver->aof_fd); /* Let's try to get this data on the disk */
         latencyEndMonitor(latency);
         latencyAddSampleIfNeeded("aof-fsync-always",latency);
+        g_pserver->aof_fsync_offset = g_pserver->aof_current_size;
         g_pserver->aof_last_fsync = g_pserver->unixtime;
     } else if ((g_pserver->aof_fsync == AOF_FSYNC_EVERYSEC &&
                 g_pserver->unixtime > g_pserver->aof_last_fsync)) {
-        if (!sync_in_progress) aof_background_fsync(g_pserver->aof_fd);
+        if (!sync_in_progress) {
+            aof_background_fsync(g_pserver->aof_fd);
+            g_pserver->aof_fsync_offset = g_pserver->aof_current_size;
+        }
         g_pserver->aof_last_fsync = g_pserver->unixtime;
     }
 }
@@ -643,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();
@@ -703,6 +726,7 @@ int loadAppendOnlyFile(char *filename) {
      * operation is received. */
     if (fp && redis_fstat(fileno(fp),&sb) != -1 && sb.st_size == 0) {
         g_pserver->aof_current_size = 0;
+        g_pserver->aof_fsync_offset = g_pserver->aof_current_size;
         fclose(fp);
         return C_ERR;
     }
@@ -726,7 +750,7 @@ int loadAppendOnlyFile(char *filename) {
 
         serverLog(LL_NOTICE,"Reading RDB preamble from AOF file...");
         if (fseek(fp,0,SEEK_SET) == -1) goto readerr;
-        rioInitWithFile(&rdb,fileno(fp));
+        rioInitWithFile(&rdb,fp);
         rdbSaveInfo rsi = RDB_SAVE_INFO_INIT;
         if (rdbLoadRio(&rdb,&rsi,1) != C_OK) {
             serverLog(LL_WARNING,"Error reading the RDB preamble of the AOF file, AOF loading aborted");
@@ -842,6 +866,7 @@ loaded_ok: /* DB loaded, cleanup and return C_OK to the caller. */
     stopLoading();
     aofUpdateCurrentSize();
     g_pserver->aof_rewrite_base_size = g_pserver->aof_current_size;
+    g_pserver->aof_fsync_offset = g_pserver->aof_current_size;
     return C_OK;
 
 readerr: /* Read error. If feof(fp) is true, fall through to unexpected EOF. */
@@ -1275,71 +1300,77 @@ ssize_t aofReadDiffFromParent(void) {
 
 int rewriteAppendOnlyFileRio(rio *aof) {
     dictIterator *di = NULL;
-    dictEntry *de;
     size_t processed = 0;
     int j;
 
     for (j = 0; j < cserver.dbnum; j++) {
         char selectcmd[] = "*2\r\n$6\r\nSELECT\r\n";
         redisDb *db = g_pserver->db+j;
-        dict *d = db->pdict;
-        if (dictSize(d) == 0) continue;
-        di = dictGetSafeIterator(d);
+        if (db->size() == 0) continue;
 
         /* SELECT the new DB */
         if (rioWrite(aof,selectcmd,sizeof(selectcmd)-1) == 0) goto werr;
         if (rioWriteBulkLongLong(aof,j) == 0) goto werr;
 
         /* Iterate this DB writing every entry */
-        while((de = dictNext(di)) != NULL) {
-            sds keystr;
-            robj key, *o;
-            long long expiretime;
+        bool fComplete = db->iterate([&](const char *keystr, robj *o)->bool{
+            robj key;
 
-            keystr = (sds)dictGetKey(de);
-            o = (robj*)dictGetVal(de);
-            initStaticStringObject(key,keystr);
+            initStaticStringObject(key,(sds)keystr);
 
-            expiretime = getExpire(db,&key);
+            expireEntry *pexpire = db->getExpire(&key);
 
             /* Save the key and associated value */
             if (o->type == OBJ_STRING) {
                 /* Emit a SET command */
                 char cmd[]="*3\r\n$3\r\nSET\r\n";
-                if (rioWrite(aof,cmd,sizeof(cmd)-1) == 0) goto werr;
+                if (rioWrite(aof,cmd,sizeof(cmd)-1) == 0) return false;
                 /* Key and value */
-                if (rioWriteBulkObject(aof,&key) == 0) goto werr;
-                if (rioWriteBulkObject(aof,o) == 0) goto werr;
+                if (rioWriteBulkObject(aof,&key) == 0) return false;
+                if (rioWriteBulkObject(aof,o) == 0) return false;
             } else if (o->type == OBJ_LIST) {
-                if (rewriteListObject(aof,&key,o) == 0) goto werr;
+                if (rewriteListObject(aof,&key,o) == 0) return false;
             } else if (o->type == OBJ_SET) {
-                if (rewriteSetObject(aof,&key,o) == 0) goto werr;
+                if (rewriteSetObject(aof,&key,o) == 0) return false;
             } else if (o->type == OBJ_ZSET) {
-                if (rewriteSortedSetObject(aof,&key,o) == 0) goto werr;
+                if (rewriteSortedSetObject(aof,&key,o) == 0) return false;
             } else if (o->type == OBJ_HASH) {
-                if (rewriteHashObject(aof,&key,o) == 0) goto werr;
+                if (rewriteHashObject(aof,&key,o) == 0) return false;
             } else if (o->type == OBJ_STREAM) {
-                if (rewriteStreamObject(aof,&key,o) == 0) goto werr;
+                if (rewriteStreamObject(aof,&key,o) == 0) return false;
             } else if (o->type == OBJ_MODULE) {
-                if (rewriteModuleObject(aof,&key,o) == 0) goto werr;
+                if (rewriteModuleObject(aof,&key,o) == 0) return false;
             } else {
                 serverPanic("Unknown object type");
             }
             /* Save the expire time */
-            if (expiretime != -1) {
-                char cmd[]="*3\r\n$9\r\nPEXPIREAT\r\n";
-                if (rioWrite(aof,cmd,sizeof(cmd)-1) == 0) goto werr;
-                if (rioWriteBulkObject(aof,&key) == 0) goto werr;
-                if (rioWriteBulkLongLong(aof,expiretime) == 0) goto werr;
+            if (pexpire != nullptr) {
+                for (auto &subExpire : *pexpire) {
+                    if (subExpire.subkey() == nullptr)
+                    {
+                        char cmd[]="*3\r\n$9\r\nPEXPIREAT\r\n";
+                        if (rioWrite(aof,cmd,sizeof(cmd)-1) == 0) return false;
+                        if (rioWriteBulkObject(aof,&key) == 0) return false;
+                    }
+                    else
+                    {
+                        char cmd[]="*4\r\n$12\r\nEXPIREMEMBER\r\n";
+                        if (rioWrite(aof,cmd,sizeof(cmd)-1) == 0) return false;
+                        if (rioWriteBulkObject(aof,&key) == 0) return false;
+                        if (rioWrite(aof,subExpire.subkey(),sdslen(subExpire.subkey())) == 0) return false;
+                    }
+                    if (rioWriteBulkLongLong(aof,subExpire.when()) == 0) return false; // common
+                }
             }
             /* Read some diff from the parent process from time to time. */
             if (aof->processed_bytes > processed+AOF_READ_DIFF_INTERVAL_BYTES) {
                 processed = aof->processed_bytes;
                 aofReadDiffFromParent();
             }
-        }
-        dictReleaseIterator(di);
-        di = NULL;
+            return true;
+        });
+        if (!fComplete)
+            goto werr;
     }
     return C_OK;
 
@@ -1373,14 +1404,19 @@ int rewriteAppendOnlyFile(char *filename) {
     }
 
     g_pserver->aof_child_diff = sdsempty();
-    rioInitWithFile(&aof,fileno(fp));
+    rioInitWithFile(&aof,fp);
 
     if (g_pserver->aof_rewrite_incremental_fsync)
         rioSetAutoSync(&aof,REDIS_AUTOSYNC_BYTES);
 
     if (g_pserver->aof_use_rdb_preamble) {
         int error;
-        if (rdbSaveRio(&aof,&error,RDB_SAVE_AOF_PREAMBLE,NULL) == C_ERR) {
+        std::vector<redisDbPersistentData*> vecpdb;
+        for (int idb = 0; idb < cserver.dbnum; ++idb)
+        {
+            vecpdb.push_back(&g_pserver->db[idb]);
+        }
+        if (rdbSaveRio(&aof,vecpdb.data(),&error,RDB_SAVE_AOF_PREAMBLE,NULL) == C_ERR) {
             errno = error;
             goto werr;
         }
@@ -1481,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.
@@ -1519,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);
 }
@@ -1549,7 +1593,7 @@ int rewriteAppendOnlyFileBackground(void) {
     pid_t childpid;
     long long start;
 
-    if (g_pserver->aof_child_pid != -1 || g_pserver->rdb_child_pid != -1) return C_ERR;
+    if (g_pserver->aof_child_pid != -1 || g_pserver->FRdbSaveInProgress()) return C_ERR;
     if (aofCreatePipes() != C_OK) return C_ERR;
     openChildInfoPipe();
     start = ustime();
@@ -1608,7 +1652,7 @@ int rewriteAppendOnlyFileBackground(void) {
 void bgrewriteaofCommand(client *c) {
     if (g_pserver->aof_child_pid != -1) {
         addReplyError(c,"Background append only file rewriting already in progress");
-    } else if (g_pserver->rdb_child_pid != -1) {
+    } else if (g_pserver->FRdbSaveInProgress()) {
         g_pserver->aof_rewrite_scheduled = 1;
         addReplyStatus(c,"Background append only file rewriting scheduled");
     } else if (rewriteAppendOnlyFileBackground() == C_OK) {

src/asciilogo.h

@@ -36,4 +36,7 @@ const char *ascii_logo =
 "                                        Port: %d\n"
 "                                        PID: %ld\n"
 "                                                                     \n"
+"                     Like KeyDB? Star us on GitHub!                  \n"
+"                                                                     \n"
+"                     https://github.com/JohnSully/KeyDB              \n"
 "                                                                     \n\n";

src/bio.cpp

@@ -85,7 +85,7 @@ struct bio_job {
 
 void *bioProcessBackgroundJobs(void *arg);
 void lazyfreeFreeObjectFromBioThread(robj *o);
-void lazyfreeFreeDatabaseFromBioThread(dict *ht1, dict *ht2);
+void lazyfreeFreeDatabaseFromBioThread(dict *ht1, expireset *set);
 void lazyfreeFreeSlotsMapFromBioThread(rax *rt);
 
 /* Make sure we have enough stack to perform all the things we do in the
@@ -196,7 +196,7 @@ void *bioProcessBackgroundJobs(void *arg) {
             if (job->arg1)
                 lazyfreeFreeObjectFromBioThread((robj*)job->arg1);
             else if (job->arg2 && job->arg3)
-                lazyfreeFreeDatabaseFromBioThread((dict*)job->arg2,(dict*)job->arg3);
+                lazyfreeFreeDatabaseFromBioThread((dict*)job->arg2,(expireset*)job->arg3);
             else if (job->arg3)
                 lazyfreeFreeSlotsMapFromBioThread((rax*)job->arg3);
         } else {

src/bitops.cpp

@@ -396,6 +396,8 @@ void printBits(unsigned char *p, unsigned long count) {
 #define BITOP_OR    1
 #define BITOP_XOR   2
 #define BITOP_NOT   3
+#define BITOP_LSHIFT 4
+#define BITOP_RSHIFT 5
 
 #define BITFIELDOP_GET 0
 #define BITFIELDOP_SET 1
@@ -592,7 +594,8 @@ void bitopCommand(client *c) {
     char *opname = szFromObj(c->argv[1]);
     robj *targetkey = c->argv[2];
     robj_roptr o;
-    unsigned long op, j, 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,
@@ -609,6 +612,10 @@ void bitopCommand(client *c) {
         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;
@@ -620,8 +627,25 @@ 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);
@@ -654,94 +678,143 @@ void bitopCommand(client *c) {
         if (j == 0 || len[j] < minlen) minlen = len[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;
+    if (fShiftOp)
+    {
+        long newlen = (long)maxlen + shift/CHAR_BIT;
+        if (shift > 0 && (shift % CHAR_BIT) != 0)
+            newlen++;
 
-        /* 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;
+        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);
 
-            /* 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;
+                // 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);
                 }
-            } 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;
+                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);
                 }
             }
         }
-        #endif
+        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;
 
-        /* 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;
+            /* 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;
+                    }
                 }
             }
-            res[j] = output;
+            #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++) {
@@ -995,12 +1068,18 @@ void bitfieldCommand(client *c) {
         /* Lookup for read is ok if key doesn't exit, but errors
          * if it's not a string. */
         o = lookupKeyRead(c->db,c->argv[1]);
-        if (o != nullptr && checkType(c,o,OBJ_STRING)) return;
+        if (o != nullptr && checkType(c,o,OBJ_STRING)) {
+            zfree(ops);
+            return;
+        }
     } else {
         /* Lookup by making room up to the farest bit reached by
          * this operation. */
         if ((o = lookupStringForBitCommand(c,
-            highest_write_offset)) == nullptr) return;
+            highest_write_offset)) == nullptr) {
+            zfree(ops);
+            return;
+        }
     }
 
     addReplyArrayLen(c,numops);

src/blocked.cpp

@@ -64,6 +64,7 @@
  */
 
 #include "server.h"
+#include <mutex>
 
 int serveClientBlockedOnList(client *receiver, robj *key, robj *dstkey, redisDb *db, robj *value, int where);
 
@@ -180,6 +181,7 @@ void queueClientForReprocessing(client *c) {
  * of operation the client is blocking for. */
 void unblockClient(client *c) {
     serverAssert(GlobalLocksAcquired());
+    serverAssert(c->lock.fOwnLock());
     if (c->btype == BLOCKED_LIST ||
         c->btype == BLOCKED_ZSET ||
         c->btype == BLOCKED_STREAM) {
@@ -219,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. */
@@ -301,6 +303,7 @@ void handleClientsBlockedOnKeys(void) {
                     while(numclients--) {
                         listNode *clientnode = listFirst(clients);
                         client *receiver = (client*)clientnode->value;
+                        std::unique_lock<decltype(client::lock)> lock(receiver->lock);
 
                         if (receiver->btype != BLOCKED_LIST) {
                             /* Put at the tail, so that at the next call

src/cluster.cpp

@@ -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 {
@@ -643,11 +643,11 @@ void clusterAcceptHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
     if (listLength(g_pserver->masters) == 0 && g_pserver->loading) return;
 
     while(max--) {
-        cfd = anetTcpAccept(g_pserver->neterr, fd, cip, sizeof(cip), &cport);
+        cfd = anetTcpAccept(serverTL->neterr, fd, cip, sizeof(cip), &cport);
         if (cfd == ANET_ERR) {
             if (errno != EWOULDBLOCK)
                 serverLog(LL_VERBOSE,
-                    "Error accepting cluster node: %s", g_pserver->neterr);
+                    "Error accepting cluster node: %s", serverTL->neterr);
             return;
         }
         anetNonBlock(NULL,cfd);
@@ -3407,7 +3407,7 @@ void clusterCron(void) {
             mstime_t old_ping_sent;
             clusterLink *link;
 
-            fd = anetTcpNonBlockBindConnect(g_pserver->neterr, node->ip,
+            fd = anetTcpNonBlockBindConnect(serverTL->neterr, node->ip,
                 node->cport, NET_FIRST_BIND_ADDR);
             if (fd == -1) {
                 /* We got a synchronous error from connect before
@@ -3418,7 +3418,7 @@ void clusterCron(void) {
                 if (node->ping_sent == 0) node->ping_sent = mstime();
                 serverLog(LL_DEBUG, "Unable to connect to "
                     "Cluster Node [%s]:%d -> %s", node->ip,
-                    node->cport, g_pserver->neterr);
+                    node->cport, serverTL->neterr);
                 continue;
             }
             link = createClusterLink(node);
@@ -3910,7 +3910,7 @@ int verifyClusterConfigWithData(void) {
 
     /* Make sure we only have keys in DB0. */
     for (j = 1; j < cserver.dbnum; j++) {
-        if (dictSize(g_pserver->db[j].pdict)) return C_ERR;
+        if (g_pserver->db[j].size()) return C_ERR;
     }
 
     /* Check that all the slots we see populated memory have a corresponding
@@ -4286,7 +4286,7 @@ NULL
         clusterReplyMultiBulkSlots(c);
     } else if (!strcasecmp(szFromObj(c->argv[1]),"flushslots") && c->argc == 2) {
         /* CLUSTER FLUSHSLOTS */
-        if (dictSize(g_pserver->db[0].pdict) != 0) {
+        if (g_pserver->db[0].size() != 0) {
             addReplyError(c,"DB must be empty to perform CLUSTER FLUSHSLOTS.");
             return;
         }
@@ -4621,7 +4621,7 @@ NULL
          * slots nor keys to accept to replicate some other node.
          * Slaves can switch to another master without issues. */
         if (nodeIsMaster(myself) &&
-            (myself->numslots != 0 || dictSize(g_pserver->db[0].pdict) != 0)) {
+            (myself->numslots != 0 || g_pserver->db[0].size() != 0)) {
             addReplyError(c,
                 "To set a master the node must be empty and "
                 "without assigned slots.");
@@ -4778,7 +4778,7 @@ NULL
 
         /* Slaves can be reset while containing data, but not master nodes
          * that must be empty. */
-        if (nodeIsMaster(myself) && dictSize(c->db->pdict) != 0) {
+        if (nodeIsMaster(myself) && c->db->size() != 0) {
             addReplyError(c,"CLUSTER RESET can't be called with "
                             "master nodes containing keys");
             return;
@@ -4794,6 +4794,7 @@ NULL
 /* -----------------------------------------------------------------------------
  * DUMP, RESTORE and MIGRATE commands
  * -------------------------------------------------------------------------- */
+ssize_t rdbSaveAuxFieldStrStr(rio *rdb, const char *key, const char *val);
 
 /* Generates a DUMP-format representation of the object 'o', adding it to the
  * io stream pointed by 'rio'. This function can't fail. */
@@ -4806,6 +4807,9 @@ void createDumpPayload(rio *payload, robj_roptr o, robj *key) {
     rioInitWithBuffer(payload,sdsempty());
     serverAssert(rdbSaveObjectType(payload,o));
     serverAssert(rdbSaveObject(payload,o,key));
+    char szT[32];
+    snprintf(szT, 32, "%" PRIu64, o->mvcc_tstamp);
+    serverAssert(rdbSaveAuxFieldStrStr(payload,"mvcc-tstamp", szT) != -1);
 
     /* Write the footer, this is how it looks like:
      * ----------------+---------------------+---------------+
@@ -4941,6 +4945,21 @@ void restoreCommand(client *c) {
         addReplyError(c,"Bad data format");
         return;
     }
+    if (rdbLoadType(&payload) == RDB_OPCODE_AUX)
+    {
+        robj *auxkey, *auxval;
+        if ((auxkey = rdbLoadStringObject(&payload)) == NULL) goto eoferr;
+        if ((auxval = rdbLoadStringObject(&payload)) == NULL) {
+            decrRefCount(auxkey);
+            goto eoferr;
+        }
+        if (strcasecmp(szFromObj(auxkey), "mvcc-tstamp") == 0) {
+            obj->mvcc_tstamp = strtoull(szFromObj(auxval), nullptr, 10);
+        }
+        decrRefCount(auxkey);
+        decrRefCount(auxval);
+    }
+eoferr:
 
     /* Remove the old key if needed. */
     if (replace) dbDelete(c->db,c->argv[1]);
@@ -4949,7 +4968,7 @@ void restoreCommand(client *c) {
     dbAdd(c->db,c->argv[1],obj);
     if (ttl) {
         if (!absttl) ttl+=mstime();
-        setExpire(c,c->db,c->argv[1],ttl);
+        setExpire(c,c->db,c->argv[1],nullptr,ttl);
     }
     objectSetLRUOrLFU(obj,lfu_freq,lru_idle,lru_clock);
     signalModifiedKey(c->db,c->argv[1]);
@@ -5010,15 +5029,15 @@ migrateCachedSocket* migrateGetSocket(client *c, robj *host, robj *port, long ti
     }
 
     /* Create the socket */
-    fd = anetTcpNonBlockConnect(g_pserver->neterr,szFromObj(c->argv[1]),
+    fd = anetTcpNonBlockConnect(serverTL->neterr,szFromObj(c->argv[1]),
                                 atoi(szFromObj(c->argv[2])));
     if (fd == -1) {
         sdsfree(name);
         addReplyErrorFormat(c,"Can't connect to target node: %s",
-            g_pserver->neterr);
+            serverTL->neterr);
         return NULL;
     }
-    anetEnableTcpNoDelay(g_pserver->neterr,fd);
+    anetEnableTcpNoDelay(serverTL->neterr,fd);
 
     /* Check if it connects within the specified timeout. */
     if ((aeWait(fd,AE_WRITABLE,timeout) & AE_WRITABLE) == 0) {
@@ -5194,7 +5213,10 @@ try_again:
     /* Create RESTORE payload and generate the protocol to call the command. */
     for (j = 0; j < num_keys; j++) {
         long long ttl = 0;
-        long long expireat = getExpire(c->db,kv[j]);
+        expireEntry *pexpire = c->db->getExpire(kv[j]);
+        long long expireat = -1;
+        if (pexpire != nullptr)
+            pexpire->FGetPrimaryExpire(&expireat);
 
         if (expireat != -1) {
             ttl = expireat-mstime();

src/compactvector.h

@@ -0,0 +1,161 @@
+#pragma once
+
+#include <type_traits>
+#include <assert.h>
+
+/*************************************************
+ * compactvector - similar to std::vector but optimized for minimal memory
+ *  
+ *  Notable differences:
+ *      - Limited to 2^32 elements
+ *      - Grows linearly not exponentially
+ * 
+ *************************************************/
+
+template<typename T, bool MEMMOVE_SAFE=false>
+class compactvector
+{
+    static_assert(MEMMOVE_SAFE || std::is_trivially_copyable<T>::value, "compactvector requires trivially copyable types");
+    T *m_data = nullptr;
+    unsigned m_celem = 0;
+    unsigned m_max = 0;
+
+public:
+    typedef T* iterator;
+
+    compactvector() noexcept = default;
+    ~compactvector() noexcept
+    {
+        clear();    // call dtors
+        zfree(m_data);
+    }
+
+    compactvector(const compactvector &src)
+    {
+        m_celem = src.m_celem;
+        m_max = src.m_max;
+        m_data = (T*)zmalloc(sizeof(T) * m_max, MALLOC_LOCAL);
+        for (size_t ielem = 0; ielem < m_celem; ++ielem)
+        {
+            new (m_data+ielem) T(src[ielem]);
+        }
+    }
+
+    compactvector(compactvector &&src) noexcept
+    {
+        m_data = src.m_data;
+        m_celem = src.m_celem;
+        m_max = src.m_max;
+        src.m_data = nullptr;
+        src.m_celem = 0;
+        src.m_max = 0;
+    }
+
+    compactvector &operator=(compactvector &&src) noexcept
+    {
+        zfree(m_data);
+        m_data = src.m_data;
+        m_celem = src.m_celem;
+        m_max = src.m_max;
+        src.m_data = nullptr;
+        src.m_celem = 0;
+        src.m_max = 0;
+        return *this;
+    }
+
+    inline T* begin() { return m_data; }
+    inline const T* begin() const { return m_data; }
+
+    inline T* end() { return m_data + m_celem; }
+    inline const T* end() const { return m_data + m_celem; }
+
+    T* insert(T* where, T &val)
+    {
+        assert(where >= m_data);
+        size_t idx = where - m_data;
+        if (m_celem >= m_max)
+        {
+            if (m_max < 2)
+                m_max = 2;
+            else
+                m_max = m_max + 4;
+            
+            m_data = (T*)zrealloc(m_data, sizeof(T) * m_max, MALLOC_LOCAL);
+            m_max = zmalloc_usable(m_data) / sizeof(T);
+        }
+        assert(idx < m_max);
+        where = m_data + idx;
+        memmove(reinterpret_cast<void*>(m_data + idx + 1), reinterpret_cast<const void*>(m_data + idx), (m_celem - idx)*sizeof(T));
+        new(m_data + idx) T(std::move(val));
+        ++m_celem;
+        return where;
+    }
+
+    T &operator[](size_t idx)
+    {
+        assert(idx < m_celem);
+        return m_data[idx];
+    }
+    const T &operator[](size_t idx) const
+    {
+        assert(idx < m_celem);
+        return m_data[idx];
+    }
+
+    T& back() { assert(m_celem > 0); return m_data[m_celem-1]; }
+    const T& back() const { assert(m_celem > 0); return m_data[m_celem-1]; }
+
+    void erase(T* where)
+    {
+        assert(where >= m_data);
+        size_t idx = where - m_data;
+        assert(idx < m_celem);
+        where->~T();
+        memmove(reinterpret_cast<void*>(where), reinterpret_cast<const void*>(where+1), ((m_celem - idx - 1)*sizeof(T)));
+        --m_celem;
+
+        if (m_celem == 0)
+        {
+            zfree(m_data);
+            m_data = nullptr;
+            m_max = 0;
+        }
+    }
+
+    void shrink_to_fit()
+    {
+        if (m_max == m_celem)
+            return;
+        m_data = (T*)zrealloc(m_data, sizeof(T) * m_celem, MALLOC_LOCAL);
+        m_max = m_celem;    // NOTE: We do not get the usable size here, because this could cause us to continually realloc
+    }
+
+    size_t bytes_used() const
+    {
+        return sizeof(this) + (m_max * sizeof(T));
+    }
+
+    void clear()
+    {
+        for (size_t idx = 0; idx < m_celem; ++idx)
+            m_data[idx].~T();
+        zfree(m_data);
+        m_data = nullptr;
+        m_celem = 0;
+        m_max = 0;
+    }
+
+    bool empty() const noexcept
+    {
+        return m_celem == 0;
+    }
+
+    size_t size() const noexcept
+    {
+        return m_celem;
+    }
+
+    T* data() noexcept { return m_data; }
+    const T* data() const noexcept { return m_data; }
+};
+static_assert(sizeof(compactvector<void*>) <= 16, "not compact");

src/config.cpp

@@ -96,10 +96,51 @@ 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 */
 };
 
+/* Configuration values that require no special handling to set, get, load or 
+ * rewrite. */
+typedef struct configYesNo {
+    const char *name; /* The user visible name of this config */
+    const char *alias; /* An alias that can also be used for this config */
+    int *config; /* The pointer to the server config this value is stored in */
+    const int modifiable; /* Can this value be updated by CONFIG SET? */
+    const int default_value; /* The default value of the config on rewrite */
+} configYesNo;
+
+configYesNo configs_yesno[] = {
+    /* Non-Modifiable */
+    {"rdbchecksum",NULL,&g_pserver->rdb_checksum,0,CONFIG_DEFAULT_RDB_CHECKSUM},
+    {"daemonize",NULL,&cserver.daemonize,0,0},
+    {"always-show-logo",NULL,&g_pserver->always_show_logo,0,CONFIG_DEFAULT_ALWAYS_SHOW_LOGO},
+    /* Modifiable */
+    {"protected-mode",NULL,&g_pserver->protected_mode,1,CONFIG_DEFAULT_PROTECTED_MODE},
+    {"rdbcompression",NULL,&g_pserver->rdb_compression,1,CONFIG_DEFAULT_RDB_COMPRESSION},
+    {"activerehashing",NULL,&g_pserver->activerehashing,1,CONFIG_DEFAULT_ACTIVE_REHASHING},
+    {"stop-writes-on-bgsave-error",NULL,&g_pserver->stop_writes_on_bgsave_err,1,CONFIG_DEFAULT_STOP_WRITES_ON_BGSAVE_ERROR},
+    {"dynamic-hz",NULL,&g_pserver->dynamic_hz,1,CONFIG_DEFAULT_DYNAMIC_HZ},
+    {"lazyfree-lazy-eviction",NULL,&g_pserver->lazyfree_lazy_eviction,1,CONFIG_DEFAULT_LAZYFREE_LAZY_EVICTION},
+    {"lazyfree-lazy-expire",NULL,&g_pserver->lazyfree_lazy_expire,1,CONFIG_DEFAULT_LAZYFREE_LAZY_EXPIRE},
+    {"lazyfree-lazy-server-del",NULL,&g_pserver->lazyfree_lazy_server_del,1,CONFIG_DEFAULT_LAZYFREE_LAZY_SERVER_DEL},
+    {"repl-disable-tcp-nodelay",NULL,&g_pserver->repl_disable_tcp_nodelay,1,CONFIG_DEFAULT_REPL_DISABLE_TCP_NODELAY},
+    {"repl-diskless-sync",NULL,&g_pserver->repl_diskless_sync,1,CONFIG_DEFAULT_REPL_DISKLESS_SYNC},
+    {"aof-rewrite-incremental-fsync",NULL,&g_pserver->aof_rewrite_incremental_fsync,1,CONFIG_DEFAULT_AOF_REWRITE_INCREMENTAL_FSYNC},
+    {"no-appendfsync-on-rewrite",NULL,&g_pserver->aof_no_fsync_on_rewrite,1,CONFIG_DEFAULT_AOF_NO_FSYNC_ON_REWRITE},
+    {"cluster-require-full-coverage",NULL,&g_pserver->cluster_require_full_coverage,CLUSTER_DEFAULT_REQUIRE_FULL_COVERAGE},
+    {"rdb-save-incremental-fsync",NULL,&g_pserver->rdb_save_incremental_fsync,1,CONFIG_DEFAULT_RDB_SAVE_INCREMENTAL_FSYNC},
+    {"aof-load-truncated",NULL,&g_pserver->aof_load_truncated,1,CONFIG_DEFAULT_AOF_LOAD_TRUNCATED},
+    {"aof-use-rdb-preamble",NULL,&g_pserver->aof_use_rdb_preamble,1,CONFIG_DEFAULT_AOF_USE_RDB_PREAMBLE},
+    {"cluster-replica-no-failover","cluster-slave-no-failover",&g_pserver->cluster_slave_no_failover,1,CLUSTER_DEFAULT_SLAVE_NO_FAILOVER},
+    {"replica-lazy-flush","slave-lazy-flush",&g_pserver->repl_slave_lazy_flush,1,CONFIG_DEFAULT_SLAVE_LAZY_FLUSH},
+    {"replica-serve-stale-data","slave-serve-stale-data",&g_pserver->repl_serve_stale_data,1,CONFIG_DEFAULT_SLAVE_SERVE_STALE_DATA},
+    {"replica-read-only","slave-read-only",&g_pserver->repl_slave_ro,1,CONFIG_DEFAULT_SLAVE_READ_ONLY},
+    {"replica-ignore-maxmemory","slave-ignore-maxmemory",&g_pserver->repl_slave_ignore_maxmemory,1,CONFIG_DEFAULT_SLAVE_IGNORE_MAXMEMORY},
+    {"multi-master",NULL,&g_pserver->enable_multimaster,false,CONFIG_DEFAULT_ENABLE_MULTIMASTER},
+    {NULL, NULL, 0, 0}
+};
+
 /*-----------------------------------------------------------------------------
  * Enum access functions
  *----------------------------------------------------------------------------*/
@@ -203,6 +244,26 @@ void loadServerConfigFromString(char *config) {
         }
         sdstolower(argv[0]);
 
+        /* Iterate the configs that are standard */
+        int match = 0;
+        for (configYesNo *config = configs_yesno; config->name != NULL; config++) {
+            if ((!strcasecmp(argv[0],config->name) ||
+                (config->alias && !strcasecmp(argv[0],config->alias))) &&
+                (argc == 2)) 
+            {
+                if ((*(config->config) = yesnotoi(argv[1])) == -1) {
+                    err = "argument must be 'yes' or 'no'"; goto loaderr;
+                }
+                match = 1;
+                break;
+            }
+        }
+
+        if (match) {
+            sdsfreesplitres(argv,argc);
+            continue;
+        }
+
         /* Execute config directives */
         if (!strcasecmp(argv[0],"timeout") && argc == 2) {
             cserver.maxidletime = atoi(argv[1]);
@@ -214,10 +275,6 @@ void loadServerConfigFromString(char *config) {
             if (cserver.tcpkeepalive < 0) {
                 err = "Invalid tcp-keepalive value"; goto loaderr;
             }
-        } else if (!strcasecmp(argv[0],"protected-mode") && argc == 2) {
-            if ((g_pserver->protected_mode = yesnotoi(argv[1])) == -1) {
-                err = "argument must be 'yes' or 'no'"; goto loaderr;
-            }
         } else if (!strcasecmp(argv[0],"port") && argc == 2) {
             g_pserver->port = atoi(argv[1]);
             if (g_pserver->port < 0 || g_pserver->port > 65535) {
@@ -288,10 +345,6 @@ void loadServerConfigFromString(char *config) {
         } else if (!strcasecmp(argv[0],"aclfile") && argc == 2) {
             zfree(g_pserver->acl_filename);
             g_pserver->acl_filename = zstrdup(argv[1]);
-        } else if (!strcasecmp(argv[0],"always-show-logo") && argc == 2) {
-            if ((g_pserver->always_show_logo = yesnotoi(argv[1])) == -1) {
-                err = "argument must be 'yes' or 'no'"; goto loaderr;
-            }
         } else if (!strcasecmp(argv[0],"syslog-enabled") && argc == 2) {
             if ((g_pserver->syslog_enabled = yesnotoi(argv[1])) == -1) {
                 err = "argument must be 'yes' or 'no'"; goto loaderr;
@@ -368,14 +421,6 @@ void loadServerConfigFromString(char *config) {
                 err = "repl-timeout must be 1 or greater";
                 goto loaderr;
             }
-        } else if (!strcasecmp(argv[0],"repl-disable-tcp-nodelay") && argc==2) {
-            if ((g_pserver->repl_disable_tcp_nodelay = yesnotoi(argv[1])) == -1) {
-                err = "argument must be 'yes' or 'no'"; goto loaderr;
-            }
-        } else if (!strcasecmp(argv[0],"repl-diskless-sync") && argc==2) {
-            if ((g_pserver->repl_diskless_sync = yesnotoi(argv[1])) == -1) {
-                err = "argument must be 'yes' or 'no'"; goto loaderr;
-            }
         } else if (!strcasecmp(argv[0],"repl-diskless-sync-delay") && argc==2) {
             g_pserver->repl_diskless_sync_delay = atoi(argv[1]);
             if (g_pserver->repl_diskless_sync_delay < 0) {
@@ -403,57 +448,6 @@ void loadServerConfigFromString(char *config) {
             cserver.default_masterauth = argv[1][0] ? zstrdup(argv[1]) : NULL;
             // Loop through all existing master infos and update them (in case this came after the replicaof config)
             updateMasterAuth();
-        } else if ((!strcasecmp(argv[0],"slave-serve-stale-data") ||
-                    !strcasecmp(argv[0],"replica-serve-stale-data"))
-                    && argc == 2)
-        {
-            if ((g_pserver->repl_serve_stale_data = yesnotoi(argv[1])) == -1) {
-                err = "argument must be 'yes' or 'no'"; goto loaderr;
-            }
-        } else if ((!strcasecmp(argv[0],"slave-read-only") ||
-                    !strcasecmp(argv[0],"replica-read-only"))
-                    && argc == 2)
-        {
-            if ((g_pserver->repl_slave_ro = yesnotoi(argv[1])) == -1) {
-                err = "argument must be 'yes' or 'no'"; goto loaderr;
-            }
-        } else if ((!strcasecmp(argv[0],"slave-ignore-maxmemory") ||
-                    !strcasecmp(argv[0],"replica-ignore-maxmemory"))
-                    && argc == 2)
-        {
-            if ((g_pserver->repl_slave_ignore_maxmemory = yesnotoi(argv[1])) == -1) {
-                err = "argument must be 'yes' or 'no'"; goto loaderr;
-            }
-        } else if (!strcasecmp(argv[0],"rdbcompression") && argc == 2) {
-            if ((g_pserver->rdb_compression = yesnotoi(argv[1])) == -1) {
-                err = "argument must be 'yes' or 'no'"; goto loaderr;
-            }
-        } else if (!strcasecmp(argv[0],"rdbchecksum") && argc == 2) {
-            if ((g_pserver->rdb_checksum = yesnotoi(argv[1])) == -1) {
-                err = "argument must be 'yes' or 'no'"; goto loaderr;
-            }
-        } else if (!strcasecmp(argv[0],"activerehashing") && argc == 2) {
-            if ((g_pserver->activerehashing = yesnotoi(argv[1])) == -1) {
-                err = "argument must be 'yes' or 'no'"; goto loaderr;
-            }
-        } else if (!strcasecmp(argv[0],"lazyfree-lazy-eviction") && argc == 2) {
-            if ((g_pserver->lazyfree_lazy_eviction = yesnotoi(argv[1])) == -1) {
-                err = "argument must be 'yes' or 'no'"; goto loaderr;
-            }
-        } else if (!strcasecmp(argv[0],"lazyfree-lazy-expire") && argc == 2) {
-            if ((g_pserver->lazyfree_lazy_expire = yesnotoi(argv[1])) == -1) {
-                err = "argument must be 'yes' or 'no'"; goto loaderr;
-            }
-        } else if (!strcasecmp(argv[0],"lazyfree-lazy-server-del") && argc == 2){
-            if ((g_pserver->lazyfree_lazy_server_del = yesnotoi(argv[1])) == -1) {
-                err = "argument must be 'yes' or 'no'"; goto loaderr;
-            }
-        } else if ((!strcasecmp(argv[0],"slave-lazy-flush") ||
-                    !strcasecmp(argv[0],"replica-lazy-flush")) && argc == 2)
-        {
-            if ((g_pserver->repl_slave_lazy_flush = yesnotoi(argv[1])) == -1) {
-                err = "argument must be 'yes' or 'no'"; goto loaderr;
-            }
         } else if (!strcasecmp(argv[0],"activedefrag") && argc == 2) {
             if ((cserver.active_defrag_enabled = yesnotoi(argv[1])) == -1) {
                 err = "argument must be 'yes' or 'no'"; goto loaderr;
@@ -463,14 +457,6 @@ void loadServerConfigFromString(char *config) {
                 err = "active defrag can't be enabled without proper jemalloc support"; goto loaderr;
 #endif
             }
-        } else if (!strcasecmp(argv[0],"daemonize") && argc == 2) {
-            if ((cserver.daemonize = yesnotoi(argv[1])) == -1) {
-                err = "argument must be 'yes' or 'no'"; goto loaderr;
-            }
-        } else if (!strcasecmp(argv[0],"dynamic-hz") && argc == 2) {
-            if ((g_pserver->dynamic_hz = yesnotoi(argv[1])) == -1) {
-                err = "argument must be 'yes' or 'no'"; goto loaderr;
-            }
         } else if (!strcasecmp(argv[0],"hz") && argc == 2) {
             g_pserver->config_hz = atoi(argv[1]);
             if (g_pserver->config_hz < CONFIG_MIN_HZ) g_pserver->config_hz = CONFIG_MIN_HZ;
@@ -489,11 +475,6 @@ void loadServerConfigFromString(char *config) {
             }
             zfree(g_pserver->aof_filename);
             g_pserver->aof_filename = zstrdup(argv[1]);
-        } else if (!strcasecmp(argv[0],"no-appendfsync-on-rewrite")
-                   && argc == 2) {
-            if ((g_pserver->aof_no_fsync_on_rewrite= yesnotoi(argv[1])) == -1) {
-                err = "argument must be 'yes' or 'no'"; goto loaderr;
-            }
         } else if (!strcasecmp(argv[0],"appendfsync") && argc == 2) {
             g_pserver->aof_fsync = configEnumGetValue(aof_fsync_enum,argv[1]);
             if (g_pserver->aof_fsync == INT_MIN) {
@@ -512,28 +493,6 @@ void loadServerConfigFromString(char *config) {
                    argc == 2)
         {
             g_pserver->aof_rewrite_min_size = memtoll(argv[1],NULL);
-        } else if (!strcasecmp(argv[0],"aof-rewrite-incremental-fsync") &&
-                   argc == 2)
-        {
-            if ((g_pserver->aof_rewrite_incremental_fsync =
-                 yesnotoi(argv[1])) == -1) {
-                err = "argument must be 'yes' or 'no'"; goto loaderr;
-            }
-        } else if (!strcasecmp(argv[0],"rdb-save-incremental-fsync") &&
-                   argc == 2)
-        {
-            if ((g_pserver->rdb_save_incremental_fsync =
-                 yesnotoi(argv[1])) == -1) {
-                err = "argument must be 'yes' or 'no'"; goto loaderr;
-            }
-        } else if (!strcasecmp(argv[0],"aof-load-truncated") && argc == 2) {
-            if ((g_pserver->aof_load_truncated = yesnotoi(argv[1])) == -1) {
-                err = "argument must be 'yes' or 'no'"; goto loaderr;
-            }
-        } else if (!strcasecmp(argv[0],"aof-use-rdb-preamble") && argc == 2) {
-            if ((g_pserver->aof_use_rdb_preamble = yesnotoi(argv[1])) == -1) {
-                err = "argument must be 'yes' or 'no'"; goto loaderr;
-            }
         } else if (!strcasecmp(argv[0],"requirepass") && argc == 2) {
             if (strlen(argv[1]) > CONFIG_AUTHPASS_MAX_LEN) {
                 err = "Password is longer than CONFIG_AUTHPASS_MAX_LEN";
@@ -670,13 +629,6 @@ void loadServerConfigFromString(char *config) {
             {
                 err = "Invalid port"; goto loaderr;
             }
-        } else if (!strcasecmp(argv[0],"cluster-require-full-coverage") &&
-                    argc == 2)
-        {
-            if ((g_pserver->cluster_require_full_coverage = yesnotoi(argv[1])) == -1)
-            {
-                err = "argument must be 'yes' or 'no'"; goto loaderr;
-            }
         } else if (!strcasecmp(argv[0],"cluster-node-timeout") && argc == 2) {
             g_pserver->cluster_node_timeout = strtoll(argv[1],NULL,10);
             if (g_pserver->cluster_node_timeout <= 0) {
@@ -699,15 +651,6 @@ void loadServerConfigFromString(char *config) {
                 err = "cluster replica validity factor must be zero or positive";
                 goto loaderr;
             }
-        } else if ((!strcasecmp(argv[0],"cluster-slave-no-failover") ||
-                    !strcasecmp(argv[0],"cluster-replica-no-failover")) &&
-                   argc == 2)
-        {
-            g_pserver->cluster_slave_no_failover = yesnotoi(argv[1]);
-            if (g_pserver->cluster_slave_no_failover == -1) {
-                err = "argument must be 'yes' or 'no'";
-                goto loaderr;
-            }
         } else if (!strcasecmp(argv[0],"lua-time-limit") && argc == 2) {
             g_pserver->lua_time_limit = strtoll(argv[1],NULL,10);
         } else if (!strcasecmp(argv[0],"lua-replicate-commands") && argc == 2) {
@@ -748,11 +691,6 @@ void loadServerConfigFromString(char *config) {
             cserver.client_obuf_limits[type].hard_limit_bytes = hard;
             cserver.client_obuf_limits[type].soft_limit_bytes = soft;
             cserver.client_obuf_limits[type].soft_limit_seconds = soft_seconds;
-        } else if (!strcasecmp(argv[0],"stop-writes-on-bgsave-error") &&
-                   argc == 2) {
-            if ((g_pserver->stop_writes_on_bgsave_err = yesnotoi(argv[1])) == -1) {
-                err = "argument must be 'yes' or 'no'"; goto loaderr;
-            }
         } else if ((!strcasecmp(argv[0],"slave-priority") ||
                     !strcasecmp(argv[0],"replica-priority")) && argc == 2)
         {
@@ -857,13 +795,13 @@ void loadServerConfigFromString(char *config) {
                 g_pserver->fActiveReplica = CONFIG_DEFAULT_ACTIVE_REPLICA;
                 err = "argument must be 'yes' or 'no'"; goto loaderr;
             }
-        } else if (!strcasecmp(argv[0],"multi-master") && argc == 2){
-            if ((g_pserver->enable_multimaster = yesnotoi(argv[1])) == -1) {
-                err = "argument must be 'yes' or 'no'"; goto loaderr;
-            }
         } else if (!strcasecmp(argv[0], "version-override") && argc == 2) {
             KEYDB_SET_VERSION = zstrdup(argv[1]);
             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;
         }
@@ -972,6 +910,19 @@ void configSetCommand(client *c) {
     serverAssertWithInfo(c,c->argv[3],sdsEncodedObject(c->argv[3]));
     o = c->argv[3];
 
+    /* Iterate the configs that are standard */
+    for (configYesNo *config = configs_yesno; config->name != NULL; config++) {
+        if(config->modifiable && (!strcasecmp(szFromObj(c->argv[2]),config->name) ||
+            (config->alias && !strcasecmp(szFromObj(c->argv[2]),config->alias))))  
+        {
+            int yn = yesnotoi(szFromObj(o));
+            if (yn == -1) goto badfmt;
+            *(config->config) = yn;
+            addReply(c,shared.ok);
+            return;
+        }
+    }
+
     if (0) { /* this starts the config_set macros else-if chain. */
 
     /* Special fields that can't be handled with general macros. */
@@ -1139,40 +1090,6 @@ void configSetCommand(client *c) {
 
     /* Boolean fields.
      * config_set_bool_field(name,var). */
-    } config_set_bool_field(
-      "rdbcompression", g_pserver->rdb_compression) {
-    } config_set_bool_field(
-      "repl-disable-tcp-nodelay",g_pserver->repl_disable_tcp_nodelay) {
-    } config_set_bool_field(
-      "repl-diskless-sync",g_pserver->repl_diskless_sync) {
-    } config_set_bool_field(
-      "cluster-require-full-coverage",g_pserver->cluster_require_full_coverage) {
-    } config_set_bool_field(
-      "cluster-slave-no-failover",g_pserver->cluster_slave_no_failover) {
-    } config_set_bool_field(
-      "cluster-replica-no-failover",g_pserver->cluster_slave_no_failover) {
-    } config_set_bool_field(
-      "aof-rewrite-incremental-fsync",g_pserver->aof_rewrite_incremental_fsync) {
-    } config_set_bool_field(
-      "rdb-save-incremental-fsync",g_pserver->rdb_save_incremental_fsync) {
-    } config_set_bool_field(
-      "aof-load-truncated",g_pserver->aof_load_truncated) {
-    } config_set_bool_field(
-      "aof-use-rdb-preamble",g_pserver->aof_use_rdb_preamble) {
-    } config_set_bool_field(
-      "slave-serve-stale-data",g_pserver->repl_serve_stale_data) {
-    } config_set_bool_field(
-      "replica-serve-stale-data",g_pserver->repl_serve_stale_data) {
-    } config_set_bool_field(
-      "slave-read-only",g_pserver->repl_slave_ro) {
-    } config_set_bool_field(
-      "replica-read-only",g_pserver->repl_slave_ro) {
-    } config_set_bool_field(
-      "slave-ignore-maxmemory",g_pserver->repl_slave_ignore_maxmemory) {
-    } config_set_bool_field(
-      "replica-ignore-maxmemory",g_pserver->repl_slave_ignore_maxmemory) {
-    } config_set_bool_field(
-      "activerehashing",g_pserver->activerehashing) {
     } config_set_bool_field(
       "activedefrag",cserver.active_defrag_enabled) {
 #ifndef HAVE_DEFRAG
@@ -1186,24 +1103,6 @@ void configSetCommand(client *c) {
             return;
         }
 #endif
-    } config_set_bool_field(
-      "protected-mode",g_pserver->protected_mode) {
-    } config_set_bool_field(
-      "stop-writes-on-bgsave-error",g_pserver->stop_writes_on_bgsave_err) {
-    } config_set_bool_field(
-      "lazyfree-lazy-eviction",g_pserver->lazyfree_lazy_eviction) {
-    } config_set_bool_field(
-      "lazyfree-lazy-expire",g_pserver->lazyfree_lazy_expire) {
-    } config_set_bool_field(
-      "lazyfree-lazy-server-del",g_pserver->lazyfree_lazy_server_del) {
-    } config_set_bool_field(
-      "slave-lazy-flush",g_pserver->repl_slave_lazy_flush) {
-    } config_set_bool_field(
-      "replica-lazy-flush",g_pserver->repl_slave_lazy_flush) {
-    } config_set_bool_field(
-      "no-appendfsync-on-rewrite",g_pserver->aof_no_fsync_on_rewrite) {
-    } config_set_bool_field(
-      "dynamic-hz",g_pserver->dynamic_hz) {
 
     /* Numerical fields.
      * config_set_numerical_field(name,var,min,max) */
@@ -1340,8 +1239,6 @@ void configSetCommand(client *c) {
       "loglevel",cserver.verbosity,loglevel_enum) {
     } config_set_enum_field(
       "maxmemory-policy",g_pserver->maxmemory_policy,maxmemory_policy_enum) {
-    } config_set_bool_field(
-       "multi-master", g_pserver->enable_multimaster) {
     } config_set_enum_field(
       "appendfsync",g_pserver->aof_fsync,aof_fsync_enum) {
 
@@ -1494,58 +1391,15 @@ void configGetCommand(client *c) {
     config_get_numerical_field("tcp-keepalive",cserver.tcpkeepalive);
 
     /* Bool (yes/no) values */
-    config_get_bool_field("cluster-require-full-coverage",
-            g_pserver->cluster_require_full_coverage);
-    config_get_bool_field("cluster-slave-no-failover",
-            g_pserver->cluster_slave_no_failover);
-    config_get_bool_field("cluster-replica-no-failover",
-            g_pserver->cluster_slave_no_failover);
-    config_get_bool_field("no-appendfsync-on-rewrite",
-            g_pserver->aof_no_fsync_on_rewrite);
-    config_get_bool_field("slave-serve-stale-data",
-            g_pserver->repl_serve_stale_data);
-    config_get_bool_field("replica-serve-stale-data",
-            g_pserver->repl_serve_stale_data);
-    config_get_bool_field("slave-read-only",
-            g_pserver->repl_slave_ro);
-    config_get_bool_field("replica-read-only",
-            g_pserver->repl_slave_ro);
-    config_get_bool_field("slave-ignore-maxmemory",
-            g_pserver->repl_slave_ignore_maxmemory);
-    config_get_bool_field("replica-ignore-maxmemory",
-            g_pserver->repl_slave_ignore_maxmemory);
-    config_get_bool_field("stop-writes-on-bgsave-error",
-            g_pserver->stop_writes_on_bgsave_err);
-    config_get_bool_field("daemonize", cserver.daemonize);
-    config_get_bool_field("rdbcompression", g_pserver->rdb_compression);
-    config_get_bool_field("rdbchecksum", g_pserver->rdb_checksum);
-    config_get_bool_field("activerehashing", g_pserver->activerehashing);
+    /* Iterate the configs that are standard */
+    for (configYesNo *config = configs_yesno; config->name != NULL; config++) {
+        config_get_bool_field(config->name, *(config->config));
+        if (config->alias) {
+            config_get_bool_field(config->alias, *(config->config));
+        }
+    }
+
     config_get_bool_field("activedefrag", cserver.active_defrag_enabled);
-    config_get_bool_field("protected-mode", g_pserver->protected_mode);
-    config_get_bool_field("repl-disable-tcp-nodelay",
-            g_pserver->repl_disable_tcp_nodelay);
-    config_get_bool_field("repl-diskless-sync",
-            g_pserver->repl_diskless_sync);
-    config_get_bool_field("aof-rewrite-incremental-fsync",
-            g_pserver->aof_rewrite_incremental_fsync);
-    config_get_bool_field("rdb-save-incremental-fsync",
-            g_pserver->rdb_save_incremental_fsync);
-    config_get_bool_field("aof-load-truncated",
-            g_pserver->aof_load_truncated);
-    config_get_bool_field("aof-use-rdb-preamble",
-            g_pserver->aof_use_rdb_preamble);
-    config_get_bool_field("lazyfree-lazy-eviction",
-            g_pserver->lazyfree_lazy_eviction);
-    config_get_bool_field("lazyfree-lazy-expire",
-            g_pserver->lazyfree_lazy_expire);
-    config_get_bool_field("lazyfree-lazy-server-del",
-            g_pserver->lazyfree_lazy_server_del);
-    config_get_bool_field("slave-lazy-flush",
-            g_pserver->repl_slave_lazy_flush);
-    config_get_bool_field("replica-lazy-flush",
-            g_pserver->repl_slave_lazy_flush);
-    config_get_bool_field("dynamic-hz",
-            g_pserver->dynamic_hz);
 
     /* Enum values */
     config_get_enum_field("maxmemory-policy",
@@ -2280,7 +2134,11 @@ int rewriteConfig(char *path) {
     /* Step 2: rewrite every single option, replacing or appending it inside
      * the rewrite state. */
 
-    rewriteConfigYesNoOption(state,"daemonize",cserver.daemonize,0);
+    /* Iterate the configs that are standard */
+    for (configYesNo *config = configs_yesno; config->name != NULL; config++) {
+        rewriteConfigYesNoOption(state,config->name,*(config->config),config->default_value);
+    }
+
     rewriteConfigStringOption(state,"pidfile",cserver.pidfile,CONFIG_DEFAULT_PID_FILE);
     rewriteConfigNumericalOption(state,"port",g_pserver->port,CONFIG_DEFAULT_SERVER_PORT);
     rewriteConfigNumericalOption(state,"cluster-announce-port",g_pserver->cluster_announce_port,CONFIG_DEFAULT_CLUSTER_ANNOUNCE_PORT);
@@ -2301,9 +2159,6 @@ int rewriteConfig(char *path) {
     rewriteConfigSaveOption(state);
     rewriteConfigUserOption(state);
     rewriteConfigNumericalOption(state,"databases",cserver.dbnum,CONFIG_DEFAULT_DBNUM);
-    rewriteConfigYesNoOption(state,"stop-writes-on-bgsave-error",g_pserver->stop_writes_on_bgsave_err,CONFIG_DEFAULT_STOP_WRITES_ON_BGSAVE_ERROR);
-    rewriteConfigYesNoOption(state,"rdbcompression",g_pserver->rdb_compression,CONFIG_DEFAULT_RDB_COMPRESSION);
-    rewriteConfigYesNoOption(state,"rdbchecksum",g_pserver->rdb_checksum,CONFIG_DEFAULT_RDB_CHECKSUM);
     rewriteConfigStringOption(state,"dbfilename",g_pserver->rdb_filename,CONFIG_DEFAULT_RDB_FILENAME);
     rewriteConfigDirOption(state);
     rewriteConfigSlaveofOption(state,"replicaof");
@@ -2311,15 +2166,10 @@ int rewriteConfig(char *path) {
     rewriteConfigStringOption(state,"masteruser",cserver.default_masteruser,NULL);
     rewriteConfigStringOption(state,"masterauth",cserver.default_masterauth,NULL);
     rewriteConfigStringOption(state,"cluster-announce-ip",g_pserver->cluster_announce_ip,NULL);
-    rewriteConfigYesNoOption(state,"replica-serve-stale-data",g_pserver->repl_serve_stale_data,CONFIG_DEFAULT_SLAVE_SERVE_STALE_DATA);
-    rewriteConfigYesNoOption(state,"replica-read-only",g_pserver->repl_slave_ro,CONFIG_DEFAULT_SLAVE_READ_ONLY);
-    rewriteConfigYesNoOption(state,"replica-ignore-maxmemory",g_pserver->repl_slave_ignore_maxmemory,CONFIG_DEFAULT_SLAVE_IGNORE_MAXMEMORY);
     rewriteConfigNumericalOption(state,"repl-ping-replica-period",g_pserver->repl_ping_slave_period,CONFIG_DEFAULT_REPL_PING_SLAVE_PERIOD);
     rewriteConfigNumericalOption(state,"repl-timeout",g_pserver->repl_timeout,CONFIG_DEFAULT_REPL_TIMEOUT);
     rewriteConfigBytesOption(state,"repl-backlog-size",g_pserver->repl_backlog_size,CONFIG_DEFAULT_REPL_BACKLOG_SIZE);
     rewriteConfigBytesOption(state,"repl-backlog-ttl",g_pserver->repl_backlog_time_limit,CONFIG_DEFAULT_REPL_BACKLOG_TIME_LIMIT);
-    rewriteConfigYesNoOption(state,"repl-disable-tcp-nodelay",g_pserver->repl_disable_tcp_nodelay,CONFIG_DEFAULT_REPL_DISABLE_TCP_NODELAY);
-    rewriteConfigYesNoOption(state,"repl-diskless-sync",g_pserver->repl_diskless_sync,CONFIG_DEFAULT_REPL_DISKLESS_SYNC);
     rewriteConfigNumericalOption(state,"repl-diskless-sync-delay",g_pserver->repl_diskless_sync_delay,CONFIG_DEFAULT_REPL_DISKLESS_SYNC_DELAY);
     rewriteConfigNumericalOption(state,"replica-priority",g_pserver->slave_priority,CONFIG_DEFAULT_SLAVE_PRIORITY);
     rewriteConfigNumericalOption(state,"min-replicas-to-write",g_pserver->repl_min_slaves_to_write,CONFIG_DEFAULT_MIN_SLAVES_TO_WRITE);
@@ -2342,14 +2192,11 @@ int rewriteConfig(char *path) {
     rewriteConfigYesNoOption(state,"appendonly",g_pserver->aof_state != AOF_OFF,0);
     rewriteConfigStringOption(state,"appendfilename",g_pserver->aof_filename,CONFIG_DEFAULT_AOF_FILENAME);
     rewriteConfigEnumOption(state,"appendfsync",g_pserver->aof_fsync,aof_fsync_enum,CONFIG_DEFAULT_AOF_FSYNC);
-    rewriteConfigYesNoOption(state,"no-appendfsync-on-rewrite",g_pserver->aof_no_fsync_on_rewrite,CONFIG_DEFAULT_AOF_NO_FSYNC_ON_REWRITE);
     rewriteConfigNumericalOption(state,"auto-aof-rewrite-percentage",g_pserver->aof_rewrite_perc,AOF_REWRITE_PERC);
     rewriteConfigBytesOption(state,"auto-aof-rewrite-min-size",g_pserver->aof_rewrite_min_size,AOF_REWRITE_MIN_SIZE);
     rewriteConfigNumericalOption(state,"lua-time-limit",g_pserver->lua_time_limit,LUA_SCRIPT_TIME_LIMIT);
     rewriteConfigYesNoOption(state,"cluster-enabled",g_pserver->cluster_enabled,0);
     rewriteConfigStringOption(state,"cluster-config-file",g_pserver->cluster_configfile,CONFIG_DEFAULT_CLUSTER_CONFIG_FILE);
-    rewriteConfigYesNoOption(state,"cluster-require-full-coverage",g_pserver->cluster_require_full_coverage,CLUSTER_DEFAULT_REQUIRE_FULL_COVERAGE);
-    rewriteConfigYesNoOption(state,"cluster-replica-no-failover",g_pserver->cluster_slave_no_failover,CLUSTER_DEFAULT_SLAVE_NO_FAILOVER);
     rewriteConfigNumericalOption(state,"cluster-node-timeout",g_pserver->cluster_node_timeout,CLUSTER_DEFAULT_NODE_TIMEOUT);
     rewriteConfigNumericalOption(state,"cluster-migration-barrier",g_pserver->cluster_migration_barrier,CLUSTER_DEFAULT_MIGRATION_BARRIER);
     rewriteConfigNumericalOption(state,"cluster-replica-validity-factor",g_pserver->cluster_slave_validity_factor,CLUSTER_DEFAULT_SLAVE_VALIDITY);
@@ -2367,23 +2214,11 @@ int rewriteConfig(char *path) {
     rewriteConfigNumericalOption(state,"zset-max-ziplist-entries",g_pserver->zset_max_ziplist_entries,OBJ_ZSET_MAX_ZIPLIST_ENTRIES);
     rewriteConfigNumericalOption(state,"zset-max-ziplist-value",g_pserver->zset_max_ziplist_value,OBJ_ZSET_MAX_ZIPLIST_VALUE);
     rewriteConfigNumericalOption(state,"hll-sparse-max-bytes",g_pserver->hll_sparse_max_bytes,CONFIG_DEFAULT_HLL_SPARSE_MAX_BYTES);
-    rewriteConfigYesNoOption(state,"activerehashing",g_pserver->activerehashing,CONFIG_DEFAULT_ACTIVE_REHASHING);
     rewriteConfigYesNoOption(state,"activedefrag",cserver.active_defrag_enabled,CONFIG_DEFAULT_ACTIVE_DEFRAG);
-    rewriteConfigYesNoOption(state,"protected-mode",g_pserver->protected_mode,CONFIG_DEFAULT_PROTECTED_MODE);
     rewriteConfigClientoutputbufferlimitOption(state);
     rewriteConfigNumericalOption(state,"hz",g_pserver->config_hz,CONFIG_DEFAULT_HZ);
-    rewriteConfigYesNoOption(state,"aof-rewrite-incremental-fsync",g_pserver->aof_rewrite_incremental_fsync,CONFIG_DEFAULT_AOF_REWRITE_INCREMENTAL_FSYNC);
-    rewriteConfigYesNoOption(state,"rdb-save-incremental-fsync",g_pserver->rdb_save_incremental_fsync,CONFIG_DEFAULT_RDB_SAVE_INCREMENTAL_FSYNC);
-    rewriteConfigYesNoOption(state,"aof-load-truncated",g_pserver->aof_load_truncated,CONFIG_DEFAULT_AOF_LOAD_TRUNCATED);
-    rewriteConfigYesNoOption(state,"aof-use-rdb-preamble",g_pserver->aof_use_rdb_preamble,CONFIG_DEFAULT_AOF_USE_RDB_PREAMBLE);
     rewriteConfigEnumOption(state,"supervised",cserver.supervised_mode,supervised_mode_enum,SUPERVISED_NONE);
-    rewriteConfigYesNoOption(state,"lazyfree-lazy-eviction",g_pserver->lazyfree_lazy_eviction,CONFIG_DEFAULT_LAZYFREE_LAZY_EVICTION);
-    rewriteConfigYesNoOption(state,"lazyfree-lazy-expire",g_pserver->lazyfree_lazy_expire,CONFIG_DEFAULT_LAZYFREE_LAZY_EXPIRE);
-    rewriteConfigYesNoOption(state,"lazyfree-lazy-server-del",g_pserver->lazyfree_lazy_server_del,CONFIG_DEFAULT_LAZYFREE_LAZY_SERVER_DEL);
-    rewriteConfigYesNoOption(state,"replica-lazy-flush",g_pserver->repl_slave_lazy_flush,CONFIG_DEFAULT_SLAVE_LAZY_FLUSH);
-    rewriteConfigYesNoOption(state,"dynamic-hz",g_pserver->dynamic_hz,CONFIG_DEFAULT_DYNAMIC_HZ);
     rewriteConfigYesNoOption(state,"active-replica",g_pserver->fActiveReplica,CONFIG_DEFAULT_ACTIVE_REPLICA);
-    rewriteConfigYesNoOption(state,"multi-master",g_pserver->enable_multimaster,CONFIG_DEFAULT_ENABLE_MULTIMASTER);
     rewriteConfigStringOption(state, "version-override",KEYDB_SET_VERSION,KEYDB_REAL_VERSION);
 
     /* Rewrite Sentinel config if in Sentinel mode. */

src/debug.cpp

@@ -55,6 +55,8 @@ typedef ucontext_t sigcontext_t;
 #endif
 #endif
 
+bool g_fInCrash = false;
+
 /* ================================= Debugging ============================== */
 
 /* Compute the sha1 of string at 's' with 'len' bytes long.
@@ -124,9 +126,13 @@ void mixStringObjectDigest(unsigned char *digest, robj_roptr o) {
 void xorObjectDigest(redisDb *db, robj_roptr keyobj, unsigned char *digest, robj_roptr o) {
     uint32_t aux = htonl(o->type);
     mixDigest(digest,&aux,sizeof(aux));
-    long long expiretime = getExpire(db,keyobj);
+    expireEntry *pexpire = db->getExpire(keyobj);
+    long long expiretime = -1;
     char buf[128];
 
+    if (pexpire != nullptr)
+        pexpire->FGetPrimaryExpire(&expiretime);
+
     /* Save the key and associated value */
     if (o->type == OBJ_STRING) {
         mixStringObjectDigest(digest,o);
@@ -260,8 +266,6 @@ void xorObjectDigest(redisDb *db, robj_roptr keyobj, unsigned char *digest, robj
  * a different digest. */
 void computeDatasetDigest(unsigned char *final) {
     unsigned char digest[20];
-    dictIterator *di = NULL;
-    dictEntry *de;
     int j;
     uint32_t aux;
 
@@ -270,8 +274,7 @@ void computeDatasetDigest(unsigned char *final) {
     for (j = 0; j < cserver.dbnum; j++) {
         redisDb *db = g_pserver->db+j;
 
-        if (dictSize(db->pdict) == 0) continue;
-        di = dictGetSafeIterator(db->pdict);
+        if (db->size() == 0) continue;
 
         /* hash the DB id, so the same dataset moved in a different
          * DB will lead to a different digest */
@@ -279,24 +282,21 @@ void computeDatasetDigest(unsigned char *final) {
         mixDigest(final,&aux,sizeof(aux));
 
         /* Iterate this DB writing every entry */
-        while((de = dictNext(di)) != NULL) {
-            sds key;
-            robj *keyobj, *o;
+        db->iterate([&](const char *key, robj *o)->bool {
+            robj *keyobj;
 
             memset(digest,0,20); /* This key-val digest */
-            key = (sds)dictGetKey(de);
             keyobj = createStringObject(key,sdslen(key));
 
             mixDigest(digest,key,sdslen(key));
 
-            o = (robj*)dictGetVal(de);
             xorObjectDigest(db,keyobj,digest,o);
 
             /* We can finally xor the key-val digest to the final digest */
             xorDigest(final,digest,20);
             decrRefCount(keyobj);
-        }
-        dictReleaseIterator(di);
+            return true;
+        });
     }
 }
 
@@ -359,7 +359,7 @@ NULL
     } else if (!strcasecmp(szFromObj(c->argv[1]),"reload")) {
         rdbSaveInfo rsi, *rsiptr;
         rsiptr = rdbPopulateSaveInfo(&rsi);
-        if (rdbSave(rsiptr) != C_OK) {
+        if (rdbSave(nullptr, rsiptr) != C_OK) {
             addReply(c,shared.err);
             return;
         }
@@ -388,15 +388,14 @@ NULL
         serverLog(LL_WARNING,"Append Only File loaded by DEBUG LOADAOF");
         addReply(c,shared.ok);
     } else if (!strcasecmp(szFromObj(c->argv[1]),"object") && c->argc == 3) {
-        dictEntry *de;
         robj *val;
         const char *strenc;
 
-        if ((de = dictFind(c->db->pdict,ptrFromObj(c->argv[2]))) == NULL) {
+        val = c->db->find(c->argv[2]);
+        if (val == NULL) {
             addReply(c,shared.nokeyerr);
             return;
         }
-        val = (robj*)dictGetVal(de);
         strenc = strEncoding(val->encoding);
 
         char extra[138] = {0};
@@ -436,20 +435,18 @@ NULL
             "Value at:%p refcount:%d "
             "encoding:%s serializedlength:%zu "
             "lru:%d lru_seconds_idle:%llu%s",
-            (void*)val, val->refcount,
+            (void*)val, static_cast<int>(val->getrefcount(std::memory_order_relaxed)),
             strenc, rdbSavedObjectLen(val),
             val->lru, estimateObjectIdleTime(val)/1000, extra);
     } else if (!strcasecmp(szFromObj(c->argv[1]),"sdslen") && c->argc == 3) {
-        dictEntry *de;
-        robj *val;
-        sds key;
+        auto itr = c->db->find(c->argv[2]);
+        robj *val = itr.val();
+        const char *key = itr.key();
 
-        if ((de = dictFind(c->db->pdict,ptrFromObj(c->argv[2]))) == NULL) {
+        if (val == NULL) {
             addReply(c,shared.nokeyerr);
             return;
         }
-        val = (robj*)dictGetVal(de);
-        key = (sds)dictGetKey(de);
 
         if (val->type != OBJ_STRING || !sdsEncodedObject(val)) {
             addReplyError(c,"Not an sds encoded string.");
@@ -459,16 +456,16 @@ NULL
                 "val_sds_len:%lld, val_sds_avail:%lld, val_zmalloc: %lld",
                 (long long) sdslen(key),
                 (long long) sdsavail(key),
-                (long long) sdsZmallocSize(key),
+                (long long) sdsZmallocSize((sds)key),
                 (long long) sdslen(szFromObj(val)),
                 (long long) sdsavail(szFromObj(val)),
                 (long long) getStringObjectSdsUsedMemory(val));
         }
     } else if (!strcasecmp(szFromObj(c->argv[1]),"ziplist") && c->argc == 3) {
-        robj *o;
+        robj_roptr o;
 
         if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.nokeyerr))
-                == NULL) return;
+                == nullptr) return;
 
         if (o->encoding != OBJ_ENCODING_ZIPLIST) {
             addReplyError(c,"Not an sds encoded string.");
@@ -484,7 +481,7 @@ NULL
 
         if (getLongFromObjectOrReply(c, c->argv[2], &keys, NULL) != C_OK)
             return;
-        dictExpand(c->db->pdict,keys);
+        c->db->expand(keys);
         for (j = 0; j < keys; j++) {
             long valsize = 0;
             snprintf(buf,sizeof(buf),"%s:%lu",
@@ -635,20 +632,20 @@ NULL
         }
 
         stats = sdscatprintf(stats,"[Dictionary HT]\n");
-        dictGetStats(buf,sizeof(buf),g_pserver->db[dbid].pdict);
+        g_pserver->db[dbid].getStats(buf,sizeof(buf));
         stats = sdscat(stats,buf);
 
-        stats = sdscatprintf(stats,"[Expires HT]\n");
-        dictGetStats(buf,sizeof(buf),g_pserver->db[dbid].expires);
-        stats = sdscat(stats,buf);
+        stats = sdscatprintf(stats,"[Expires set]\n");
+        g_pserver->db[dbid].getExpireStats(buf, sizeof(buf));
+        stats = sdscat(stats, buf);
 
         addReplyBulkSds(c,stats);
     } else if (!strcasecmp(szFromObj(c->argv[1]),"htstats-key") && c->argc == 3) {
-        robj *o;
+        robj_roptr o;
         dict *ht = NULL;
 
         if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.nokeyerr))
-                == NULL) return;
+                == nullptr) return;
 
         /* Get the hash table reference from the object, if possible. */
         switch (o->encoding) {
@@ -676,10 +673,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;
@@ -706,7 +705,7 @@ void _serverAssertPrintClientInfo(const client *c) {
 
     bugReportStart();
     serverLog(LL_WARNING,"=== ASSERTION FAILED CLIENT CONTEXT ===");
-    serverLog(LL_WARNING,"client->flags = %d", c->flags);
+    serverLog(LL_WARNING,"client->flags = %llu", static_cast<unsigned long long>(c->flags));
     serverLog(LL_WARNING,"client->fd = %d", c->fd);
     serverLog(LL_WARNING,"client->argc = %d", c->argc);
     for (j=0; j < c->argc; j++) {
@@ -721,14 +720,14 @@ void _serverAssertPrintClientInfo(const client *c) {
             arg = buf;
         }
         serverLog(LL_WARNING,"client->argv[%d] = \"%s\" (refcount: %d)",
-            j, arg, c->argv[j]->refcount);
+            j, arg, static_cast<int>(c->argv[j]->getrefcount(std::memory_order_relaxed)));
     }
 }
 
 void serverLogObjectDebugInfo(robj_roptr o) {
     serverLog(LL_WARNING,"Object type: %d", o->type);
     serverLog(LL_WARNING,"Object encoding: %d", o->encoding);
-    serverLog(LL_WARNING,"Object refcount: %d", o->refcount);
+    serverLog(LL_WARNING,"Object refcount: %d", static_cast<int>(o->getrefcount(std::memory_order_relaxed)));
     if (o->type == OBJ_STRING && sdsEncodedObject(o)) {
         serverLog(LL_WARNING,"Object raw string len: %zu", sdslen(szFromObj(o)));
         if (sdslen(szFromObj(o)) < 4096) {
@@ -1248,12 +1247,10 @@ void logCurrentClient(void) {
      * selected DB, and if so print info about the associated object. */
     if (cc->argc >= 1) {
         robj *val, *key;
-        dictEntry *de;
 
         key = getDecodedObject(cc->argv[1]);
-        de = dictFind(cc->db->pdict, ptrFromObj(key));
-        if (de) {
-            val = (robj*)dictGetVal(de);
+        val = cc->db->find(key);
+        if (val) {
             serverLog(LL_WARNING,"key '%s' found in DB containing the following object:", (char*)ptrFromObj(key));
             serverLogObjectDebugInfo(val);
         }
@@ -1356,6 +1353,7 @@ void dumpX86Calls(void *addr, size_t len) {
 
 void sigsegvHandler(int sig, siginfo_t *info, void *secret) {
     ucontext_t *uc = (ucontext_t*) secret;
+    g_fInCrash = true;
     void *eip = getMcontextEip(uc);
     sds infostring, clients;
     struct sigaction act;

src/defrag.cpp

@@ -47,7 +47,8 @@ extern "C" int je_get_defrag_hint(void* ptr, int *bin_util, int *run_util);
 
 /* forward declarations*/
 void defragDictBucketCallback(void *privdata, dictEntry **bucketref);
-dictEntry* replaceSateliteDictKeyPtrAndOrDefragDictEntry(dict *d, sds oldkey, sds newkey, unsigned int hash, long *defragged);
+dictEntry* replaceSateliteDictKeyPtrAndOrDefragDictEntry(dict *d, sds oldkey, sds newkey, uint64_t hash, long *defragged);
+void replaceSateliteOSetKeyPtr(expireset &set, sds oldkey, sds newkey);
 
 /* Defrag helper for generic allocations.
  *
@@ -102,7 +103,7 @@ sds activeDefragSds(sds sdsptr) {
  * and should NOT be accessed. */
 robj *activeDefragStringOb(robj* ob, long *defragged) {
     robj *ret = NULL;
-    if (ob->refcount!=1)
+    if (ob->getrefcount(std::memory_order_relaxed)!=1)
         return NULL;
 
     /* try to defrag robj (only if not an EMBSTR type (handled below). */
@@ -353,7 +354,7 @@ long activeDefragSdsListAndDict(list *l, dict *d, int dict_val_type) {
         sdsele = (sds)ln->value;
         if ((newsds = activeDefragSds(sdsele))) {
             /* When defragging an sds value, we need to update the dict key */
-            unsigned int hash = dictGetHash(d, sdsele);
+            uint64_t hash = dictGetHash(d, sdsele);
             replaceSateliteDictKeyPtrAndOrDefragDictEntry(d, sdsele, newsds, hash, &defragged);
             ln->value = newsds;
             defragged++;
@@ -390,7 +391,7 @@ long activeDefragSdsListAndDict(list *l, dict *d, int dict_val_type) {
  * moved. Return value is the the dictEntry if found, or NULL if not found.
  * NOTE: this is very ugly code, but it let's us avoid the complication of
  * doing a scan on another dict. */
-dictEntry* replaceSateliteDictKeyPtrAndOrDefragDictEntry(dict *d, sds oldkey, sds newkey, unsigned int hash, long *defragged) {
+dictEntry* replaceSateliteDictKeyPtrAndOrDefragDictEntry(dict *d, sds oldkey, sds newkey, uint64_t hash, long *defragged) {
     dictEntry **deref = dictFindEntryRefByPtrAndHash(d, oldkey, hash);
     if (deref) {
         dictEntry *de = *deref;
@@ -406,6 +407,17 @@ dictEntry* replaceSateliteDictKeyPtrAndOrDefragDictEntry(dict *d, sds oldkey, sd
     return NULL;
 }
 
+void replaceSateliteOSetKeyPtr(expireset &set, sds oldkey, sds newkey) {
+    auto itr = set.find(oldkey);
+    if (itr != set.end())
+    {
+        expireEntry eNew(std::move(*itr));
+        eNew.setKeyUnsafe(newkey);
+        set.erase(itr);
+        set.insert(eNew);
+    }
+}
+
 long activeDefragQuickListNodes(quicklist *ql) {
     quicklistNode *node = ql->head, *newnode;
     long defragged = 0;
@@ -769,16 +781,14 @@ long defragKey(redisDb *db, dictEntry *de) {
     newsds = activeDefragSds(keysds);
     if (newsds)
         defragged++, de->key = newsds;
-    if (dictSize(db->expires)) {
-         /* Dirty code:
-          * I can't search in db->expires for that key after i already released
-          * the pointer it holds it won't be able to do the string compare */
-        uint64_t hash = dictGetHash(db->pdict, de->key);
-        replaceSateliteDictKeyPtrAndOrDefragDictEntry(db->expires, keysds, newsds, hash, &defragged);
+    if (!db->setexpire()->empty()) {
+        replaceSateliteOSetKeyPtr(*const_cast<expireset*>(db->setexpire()), keysds, newsds);
     }
 
     /* Try to defrag robj and / or string value. */
     ob = (robj*)dictGetVal(de);
+    if (ob == nullptr)
+        return defragged;
     if ((newob = activeDefragStringOb(ob, &defragged))) {
         de->v.val = newob;
         ob = newob;
@@ -845,7 +855,7 @@ void defragScanCallback(void *privdata, const dictEntry *de) {
     g_pserver->stat_active_defrag_scanned++;
 }
 
-/* Defrag scan callback for each hash table bicket,
+/* Defrag scan callback for each hash table bucket,
  * used in order to defrag the dictEntry allocations. */
 void defragDictBucketCallback(void *privdata, dictEntry **bucketref) {
     UNUSED(privdata); /* NOTE: this function is also used by both activeDefragCycle and scanLaterHash, etc. don't use privdata */
@@ -894,9 +904,8 @@ long defragOtherGlobals() {
 
 /* returns 0 more work may or may not be needed (see non-zero cursor),
  * and 1 if time is up and more work is needed. */
-int defragLaterItem(dictEntry *de, unsigned long *cursor, long long endtime) {
-    if (de) {
-        robj *ob = (robj*)dictGetVal(de);
+int defragLaterItem(robj *ob, unsigned long *cursor, long long endtime) {
+    if (ob) {
         if (ob->type == OBJ_LIST) {
             g_pserver->stat_active_defrag_hits += scanLaterList(ob);
             *cursor = 0; /* list has no scan, we must finish it in one go */
@@ -951,11 +960,11 @@ int defragLaterStep(redisDb *db, long long endtime) {
         }
 
         /* each time we enter this function we need to fetch the key from the dict again (if it still exists) */
-        dictEntry *de = dictFind(db->pdict, current_key);
+        robj *o = db->find(current_key);
         key_defragged = g_pserver->stat_active_defrag_hits;
         do {
             int quit = 0;
-            if (defragLaterItem(de, &cursor, endtime))
+            if (defragLaterItem(o, &cursor, endtime))
                 quit = 1; /* time is up, we didn't finish all the work */
 
             /* Don't start a new BIG key in this loop, this is because the
@@ -1037,7 +1046,7 @@ void activeDefragCycle(void) {
     mstime_t latency;
     int quit = 0;
 
-    if (g_pserver->aof_child_pid!=-1 || g_pserver->rdb_child_pid!=-1)
+    if (g_pserver->aof_child_pid!=-1 || g_pserver->FRdbSaveInProgress())
         return; /* Defragging memory while there's a fork will just do damage. */
 
     /* Once a second, check if we the fragmentation justfies starting a scan
@@ -1104,7 +1113,8 @@ void activeDefragCycle(void) {
                 break; /* this will exit the function and we'll continue on the next cycle */
             }
 
-            cursor = dictScan(db->pdict, cursor, defragScanCallback, defragDictBucketCallback, db);
+            // we actually look at the objects too but defragScanCallback can handle missing values
+            cursor = dictScan(db->dictUnsafeKeyOnly(), cursor, defragScanCallback, defragDictBucketCallback, db);
 
             /* Once in 16 scan iterations, 512 pointer reallocations. or 64 keys
              * (if we have a lot of pointers in one hash bucket or rehasing),

src/evict.cpp

@@ -78,7 +78,7 @@ unsigned int getLRUClock(void) {
 unsigned int LRU_CLOCK(void) {
     unsigned int lruclock;
     if (1000/g_pserver->hz <= LRU_CLOCK_RESOLUTION) {
-        atomicGet(g_pserver->lruclock,lruclock);
+        lruclock = g_pserver->lruclock;
     } else {
         lruclock = getLRUClock();
     }
@@ -87,7 +87,7 @@ unsigned int LRU_CLOCK(void) {
 
 /* Given an object returns the min number of milliseconds the object was never
  * requested, using an approximated LRU algorithm. */
-unsigned long long estimateObjectIdleTime(robj *o) {
+unsigned long long estimateObjectIdleTime(robj_roptr o) {
     unsigned long long lruclock = LRU_CLOCK();
     if (lruclock >= o->lru) {
         return (lruclock - o->lru) * LRU_CLOCK_RESOLUTION;
@@ -150,6 +150,84 @@ void evictionPoolAlloc(void) {
     EvictionPoolLRU = ep;
 }
 
+void processEvictionCandidate(int dbid, sds key, robj *o, const expireEntry *e, struct evictionPoolEntry *pool)
+{
+    unsigned long long idle;
+
+    /* Calculate the idle time according to the policy. This is called
+        * idle just because the code initially handled LRU, but is in fact
+        * just a score where an higher score means better candidate. */
+    if (g_pserver->maxmemory_policy & MAXMEMORY_FLAG_LRU) {
+        idle = (o != nullptr) ? estimateObjectIdleTime(o) : 0;
+    } else if (g_pserver->maxmemory_policy & MAXMEMORY_FLAG_LFU) {
+        /* When we use an LRU policy, we sort the keys by idle time
+            * so that we expire keys starting from greater idle time.
+            * However when the policy is an LFU one, we have a frequency
+            * estimation, and we want to evict keys with lower frequency
+            * first. So inside the pool we put objects using the inverted
+            * frequency subtracting the actual frequency to the maximum
+            * frequency of 255. */
+        idle = 255-LFUDecrAndReturn(o);
+    } else if (g_pserver->maxmemory_policy == MAXMEMORY_VOLATILE_TTL) {
+        /* In this case the sooner the expire the better. */
+        idle = ULLONG_MAX - e->when();
+    } else {
+        serverPanic("Unknown eviction policy in evictionPoolPopulate()");
+    }
+
+    /* Insert the element inside the pool.
+        * First, find the first empty bucket or the first populated
+        * bucket that has an idle time smaller than our idle time. */
+    int k = 0;
+    while (k < EVPOOL_SIZE &&
+            pool[k].key &&
+            pool[k].idle < idle) k++;
+    if (k == 0 && pool[EVPOOL_SIZE-1].key != NULL) {
+        /* Can't insert if the element is < the worst element we have
+            * and there are no empty buckets. */
+        return;
+    } else if (k < EVPOOL_SIZE && pool[k].key == NULL) {
+        /* Inserting into empty position. No setup needed before insert. */
+    } else {
+        /* Inserting in the middle. Now k points to the first element
+            * greater than the element to insert.  */
+        if (pool[EVPOOL_SIZE-1].key == NULL) {
+            /* Free space on the right? Insert at k shifting
+                * all the elements from k to end to the right. */
+
+            /* Save SDS before overwriting. */
+            sds cached = pool[EVPOOL_SIZE-1].cached;
+            memmove(pool+k+1,pool+k,
+                sizeof(pool[0])*(EVPOOL_SIZE-k-1));
+            pool[k].cached = cached;
+        } else {
+            /* No free space on right? Insert at k-1 */
+            k--;
+            /* Shift all elements on the left of k (included) to the
+                * left, so we discard the element with smaller idle time. */
+            sds cached = pool[0].cached; /* Save SDS before overwriting. */
+            if (pool[0].key != pool[0].cached) sdsfree(pool[0].key);
+            memmove(pool,pool+1,sizeof(pool[0])*k);
+            pool[k].cached = cached;
+        }
+    }
+
+    /* Try to reuse the cached SDS string allocated in the pool entry,
+        * because allocating and deallocating this object is costly
+        * (according to the profiler, not my fantasy. Remember:
+        * premature optimizbla bla bla bla. */
+    int klen = sdslen(key);
+    if (klen > EVPOOL_CACHED_SDS_SIZE) {
+        pool[k].key = sdsdup(key);
+    } else {
+        memcpy(pool[k].cached,key,klen+1);
+        sdssetlen(pool[k].cached,klen);
+        pool[k].key = pool[k].cached;
+    }
+    pool[k].idle = idle;
+    pool[k].dbid = dbid;
+}
+
 /* This is an helper function for freeMemoryIfNeeded(), it is used in order
  * to populate the evictionPool with a few entries every time we want to
  * expire a key. Keys with idle time smaller than one of the current
@@ -159,100 +237,37 @@ void evictionPoolAlloc(void) {
  * idle time are on the left, and keys with the higher idle time on the
  * right. */
 
-void evictionPoolPopulate(int dbid, dict *sampledict, dict *keydict, struct evictionPoolEntry *pool) {
-    int j, k, count;
-    dictEntry **samples = (dictEntry**)alloca(g_pserver->maxmemory_samples * sizeof(dictEntry*));
+struct visitFunctor
+{
+    int dbid;
+    dict *dbdict;
+    struct evictionPoolEntry *pool;
+    int count;
 
-    count = dictGetSomeKeys(sampledict,samples,g_pserver->maxmemory_samples);
-    for (j = 0; j < count; j++) {
-        unsigned long long idle;
-        sds key;
-        robj *o = nullptr;
-        dictEntry *de;
-
-        de = samples[j];
-        key = (sds)dictGetKey(de);
-
-        /* If the dictionary we are sampling from is not the main
-         * dictionary (but the expires one) we need to lookup the key
-         * again in the key dictionary to obtain the value object. */
-        if (g_pserver->maxmemory_policy != MAXMEMORY_VOLATILE_TTL) {
-            if (sampledict != keydict) de = dictFind(keydict, key);
-            o = (robj*)dictGetVal(de);
+    bool operator()(const expireEntry &e)
+    {
+        dictEntry *de = dictFind(dbdict, e.key());
+        processEvictionCandidate(dbid, (sds)dictGetKey(de), (robj*)dictGetVal(de), &e, pool);
+        ++count;
+        return count < g_pserver->maxmemory_samples;
+    }
+};
+void evictionPoolPopulate(int dbid, redisDb *db, expireset *setexpire, struct evictionPoolEntry *pool)
+{
+    if (setexpire != nullptr)
+    {
+        visitFunctor visitor { dbid, db->dictUnsafeKeyOnly(), pool, 0 };
+        setexpire->random_visit(visitor);
+    }
+    else
+    {
+        dictEntry **samples = (dictEntry**)alloca(g_pserver->maxmemory_samples * sizeof(dictEntry*));
+        int count = dictGetSomeKeys(db->dictUnsafeKeyOnly(),samples,g_pserver->maxmemory_samples);
+        for (int j = 0; j < count; j++) {
+            robj *o = (robj*)dictGetVal(samples[j]);
+            serverAssert(o != nullptr); // BUG!!! We have to get the info we need here without permanently rehydrating the obj
+            processEvictionCandidate(dbid, (sds)dictGetKey(samples[j]), o, nullptr, pool);
         }
-
-        /* Calculate the idle time according to the policy. This is called
-         * idle just because the code initially handled LRU, but is in fact
-         * just a score where an higher score means better candidate. */
-        if (g_pserver->maxmemory_policy & MAXMEMORY_FLAG_LRU) {
-            idle = (o != nullptr) ? estimateObjectIdleTime(o) : 0;
-        } else if (g_pserver->maxmemory_policy & MAXMEMORY_FLAG_LFU) {
-            /* When we use an LRU policy, we sort the keys by idle time
-             * so that we expire keys starting from greater idle time.
-             * However when the policy is an LFU one, we have a frequency
-             * estimation, and we want to evict keys with lower frequency
-             * first. So inside the pool we put objects using the inverted
-             * frequency subtracting the actual frequency to the maximum
-             * frequency of 255. */
-            idle = 255-LFUDecrAndReturn(o);
-        } else if (g_pserver->maxmemory_policy == MAXMEMORY_VOLATILE_TTL) {
-            /* In this case the sooner the expire the better. */
-            idle = ULLONG_MAX - (long)dictGetVal(de);
-        } else {
-            serverPanic("Unknown eviction policy in evictionPoolPopulate()");
-        }
-
-        /* Insert the element inside the pool.
-         * First, find the first empty bucket or the first populated
-         * bucket that has an idle time smaller than our idle time. */
-        k = 0;
-        while (k < EVPOOL_SIZE &&
-               pool[k].key &&
-               pool[k].idle < idle) k++;
-        if (k == 0 && pool[EVPOOL_SIZE-1].key != NULL) {
-            /* Can't insert if the element is < the worst element we have
-             * and there are no empty buckets. */
-            continue;
-        } else if (k < EVPOOL_SIZE && pool[k].key == NULL) {
-            /* Inserting into empty position. No setup needed before insert. */
-        } else {
-            /* Inserting in the middle. Now k points to the first element
-             * greater than the element to insert.  */
-            if (pool[EVPOOL_SIZE-1].key == NULL) {
-                /* Free space on the right? Insert at k shifting
-                 * all the elements from k to end to the right. */
-
-                /* Save SDS before overwriting. */
-                sds cached = pool[EVPOOL_SIZE-1].cached;
-                memmove(pool+k+1,pool+k,
-                    sizeof(pool[0])*(EVPOOL_SIZE-k-1));
-                pool[k].cached = cached;
-            } else {
-                /* No free space on right? Insert at k-1 */
-                k--;
-                /* Shift all elements on the left of k (included) to the
-                 * left, so we discard the element with smaller idle time. */
-                sds cached = pool[0].cached; /* Save SDS before overwriting. */
-                if (pool[0].key != pool[0].cached) sdsfree(pool[0].key);
-                memmove(pool,pool+1,sizeof(pool[0])*k);
-                pool[k].cached = cached;
-            }
-        }
-
-        /* Try to reuse the cached SDS string allocated in the pool entry,
-         * because allocating and deallocating this object is costly
-         * (according to the profiler, not my fantasy. Remember:
-         * premature optimizbla bla bla bla. */
-        int klen = sdslen(key);
-        if (klen > EVPOOL_CACHED_SDS_SIZE) {
-            pool[k].key = sdsdup(key);
-        } else {
-            memcpy(pool[k].cached,key,klen+1);
-            sdssetlen(pool[k].cached,klen);
-            pool[k].key = pool[k].cached;
-        }
-        pool[k].idle = idle;
-        pool[k].dbid = dbid;
     }
 }
 
@@ -360,8 +375,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) {
@@ -474,8 +489,6 @@ int freeMemoryIfNeeded(void) {
         sds bestkey = NULL;
         int bestdbid;
         redisDb *db;
-        dict *dict;
-        dictEntry *de;
 
         if (g_pserver->maxmemory_policy & (MAXMEMORY_FLAG_LRU|MAXMEMORY_FLAG_LFU) ||
             g_pserver->maxmemory_policy == MAXMEMORY_VOLATILE_TTL)
@@ -490,10 +503,18 @@ int freeMemoryIfNeeded(void) {
                  * every DB. */
                 for (i = 0; i < cserver.dbnum; i++) {
                     db = g_pserver->db+i;
-                    dict = (g_pserver->maxmemory_policy & MAXMEMORY_FLAG_ALLKEYS) ?
-                            db->pdict : db->expires;
-                    if ((keys = dictSize(dict)) != 0) {
-                        evictionPoolPopulate(i, dict, db->pdict, pool);
+                    if (g_pserver->maxmemory_policy & MAXMEMORY_FLAG_ALLKEYS)
+                    {
+                        if ((keys = db->size()) != 0) {
+                            evictionPoolPopulate(i, db, nullptr, pool);
+                            total_keys += keys;
+                        }
+                    }
+                    else
+                    {
+                        keys = db->expireSize();
+                        if (keys != 0)
+                            evictionPoolPopulate(i, db, db->setexpireUnsafe(), pool);
                         total_keys += keys;
                     }
                 }
@@ -503,14 +524,11 @@ int freeMemoryIfNeeded(void) {
                 for (k = EVPOOL_SIZE-1; k >= 0; k--) {
                     if (pool[k].key == NULL) continue;
                     bestdbid = pool[k].dbid;
+                    sds key = nullptr;
 
-                    if (g_pserver->maxmemory_policy & MAXMEMORY_FLAG_ALLKEYS) {
-                        de = dictFind(g_pserver->db[pool[k].dbid].pdict,
-                            pool[k].key);
-                    } else {
-                        de = dictFind(g_pserver->db[pool[k].dbid].expires,
-                            pool[k].key);
-                    }
+                    auto itr = g_pserver->db[pool[k].dbid].find(pool[k].key);
+                    if (itr != nullptr && (g_pserver->maxmemory_policy & MAXMEMORY_FLAG_ALLKEYS || itr.val()->FExpires()))
+                        key = itr.key();
 
                     /* Remove the entry from the pool. */
                     if (pool[k].key != pool[k].cached)
@@ -520,8 +538,8 @@ int freeMemoryIfNeeded(void) {
 
                     /* If the key exists, is our pick. Otherwise it is
                      * a ghost and we need to try the next element. */
-                    if (de) {
-                        bestkey = (sds)dictGetKey(de);
+                    if (key) {
+                        bestkey = key;
                         break;
                     } else {
                         /* Ghost... Iterate again. */
@@ -540,13 +558,23 @@ int freeMemoryIfNeeded(void) {
             for (i = 0; i < cserver.dbnum; i++) {
                 j = (++next_db) % cserver.dbnum;
                 db = g_pserver->db+j;
-                dict = (g_pserver->maxmemory_policy == MAXMEMORY_ALLKEYS_RANDOM) ?
-                        db->pdict : db->expires;
-                if (dictSize(dict) != 0) {
-                    de = dictGetRandomKey(dict);
-                    bestkey = (sds)dictGetKey(de);
-                    bestdbid = j;
-                    break;
+                if (g_pserver->maxmemory_policy == MAXMEMORY_ALLKEYS_RANDOM)
+                {
+                    if (db->size() != 0) {
+                        auto itr = db->random();
+                        bestkey = itr.key();
+                        bestdbid = j;
+                        break;
+                    }
+                }
+                else
+                {
+                    if (db->expireSize())
+                    {
+                        bestkey = (sds)db->random_expire().key();
+                        bestdbid = j;
+                        break;
+                    }
                 }
             }
         }
@@ -554,16 +582,17 @@ int freeMemoryIfNeeded(void) {
         /* Finally remove the selected key. */
         if (bestkey) {
             db = g_pserver->db+bestdbid;
+
             robj *keyobj = createStringObject(bestkey,sdslen(bestkey));
             propagateExpire(db,keyobj,g_pserver->lazyfree_lazy_eviction);
             /* We compute the amount of memory freed by db*Delete() alone.
-             * It is possible that actually the memory needed to propagate
-             * the DEL in AOF and replication link is greater than the one
-             * we are freeing removing the key, but we can't account for
-             * that otherwise we would never exit the loop.
-             *
-             * AOF and Output buffer memory will be freed eventually so
-             * we only care about memory used by the key space. */
+            * It is possible that actually the memory needed to propagate
+            * the DEL in AOF and replication link is greater than the one
+            * we are freeing removing the key, but we can't account for
+            * that otherwise we would never exit the loop.
+            *
+            * AOF and Output buffer memory will be freed eventually so
+            * we only care about memory used by the key space. */
             delta = (long long) zmalloc_used_memory();
             latencyStartMonitor(eviction_latency);
             if (g_pserver->lazyfree_lazy_eviction)
@@ -582,18 +611,18 @@ int freeMemoryIfNeeded(void) {
             keys_freed++;
 
             /* When the memory to free starts to be big enough, we may
-             * start spending so much time here that is impossible to
-             * deliver data to the slaves fast enough, so we force the
-             * transmission here inside the loop. */
+            * start spending so much time here that is impossible to
+            * deliver data to the slaves fast enough, so we force the
+            * transmission here inside the loop. */
             if (slaves) flushSlavesOutputBuffers();
 
             /* Normally our stop condition is the ability to release
-             * a fixed, pre-computed amount of memory. However when we
-             * are deleting objects in another thread, it's better to
-             * check, from time to time, if we already reached our target
-             * memory, since the "mem_freed" amount is computed only
-             * across the dbAsyncDelete() call, while the thread can
-             * release the memory all the time. */
+            * a fixed, pre-computed amount of memory. However when we
+            * are deleting objects in another thread, it's better to
+            * check, from time to time, if we already reached our target
+            * memory, since the "mem_freed" amount is computed only
+            * across the dbAsyncDelete() call, while the thread can
+            * release the memory all the time. */
             if (g_pserver->lazyfree_lazy_eviction && !(keys_freed % 16)) {
                 if (getMaxmemoryState(NULL,NULL,NULL,NULL) == C_OK) {
                     /* Let's satisfy our stop condition. */

src/expire.cpp

@@ -32,6 +32,21 @@
 
 #include "server.h"
 
+void activeExpireCycleExpireFullKey(redisDb *db, const char *key) {
+    robj *keyobj = createStringObject(key,sdslen(key));
+
+    propagateExpire(db,keyobj,g_pserver->lazyfree_lazy_expire);
+    if (g_pserver->lazyfree_lazy_expire)
+        dbAsyncDelete(db,keyobj);
+    else
+        dbSyncDelete(db,keyobj);
+    notifyKeyspaceEvent(NOTIFY_EXPIRED,
+        "expired",keyobj,db->id);
+    if (g_pserver->tracking_clients) trackingInvalidateKey(keyobj);
+    decrRefCount(keyobj);
+    g_pserver->stat_expiredkeys++;
+}
+
 /*-----------------------------------------------------------------------------
  * Incremental collection of expired keys.
  *
@@ -51,27 +66,148 @@
  *
  * The parameter 'now' is the current time in milliseconds as is passed
  * to the function to avoid too many gettimeofday() syscalls. */
-int activeExpireCycleTryExpire(redisDb *db, dictEntry *de, long long now) {
-    long long t = dictGetSignedIntegerVal(de);
-    if (now > t) {
-        sds key = (sds)dictGetKey(de);
-        robj *keyobj = createStringObject(key,sdslen(key));
+void activeExpireCycleExpire(redisDb *db, expireEntry &e, long long now) {
+    if (!e.FFat())
+    {
+        activeExpireCycleExpireFullKey(db, e.key());
+        return;
+    }
 
-        propagateExpire(db,keyobj,g_pserver->lazyfree_lazy_expire);
-        if (g_pserver->lazyfree_lazy_expire)
-            dbAsyncDelete(db,keyobj);
-        else
-            dbSyncDelete(db,keyobj);
-        notifyKeyspaceEvent(NOTIFY_EXPIRED,
-            "expired",keyobj,db->id);
+    expireEntryFat *pfat = e.pfatentry();
+    robj *val = db->find(e.key());
+    int deleted = 0;
+    while (!pfat->FEmpty())
+    {
+        if (pfat->nextExpireEntry().when > now)
+            break;
+
+        // Is it the full key expiration?
+        if (pfat->nextExpireEntry().spsubkey == nullptr)
+        {
+            activeExpireCycleExpireFullKey(db, e.key());
+            return;
+        }
+
+        switch (val->type)
+        {
+        case OBJ_SET:
+            if (setTypeRemove(val,pfat->nextExpireEntry().spsubkey.get())) {
+                deleted++;
+                if (setTypeSize(val) == 0) {
+                    activeExpireCycleExpireFullKey(db, e.key());
+                    return;
+                }
+            }
+            break;
+        case OBJ_LIST:
+        case OBJ_ZSET:
+        case OBJ_HASH:
+        default:
+            serverAssert(false);
+        }
+        pfat->popfrontExpireEntry();
+    }
+
+    if (deleted)
+    {
+        robj objT;
+        switch (val->type)
+        {
+        case OBJ_SET:
+            initStaticStringObject(objT, (char*)e.key());
+            signalModifiedKey(db,&objT);
+            notifyKeyspaceEvent(NOTIFY_SET,"srem",&objT,db->id);
+            break;
+        }
+    }
+
+    if (pfat->FEmpty())
+    {
+        robj *keyobj = createStringObject(e.key(),sdslen(e.key()));
+        removeExpire(db, keyobj);
         decrRefCount(keyobj);
-        g_pserver->stat_expiredkeys++;
-        return 1;
-    } else {
-        return 0;
     }
 }
 
+int parseUnitString(const char *sz)
+{
+    if (strcasecmp(sz, "s") == 0)
+        return UNIT_SECONDS;
+    if (strcasecmp(sz, "ms") == 0)
+        return UNIT_MILLISECONDS;
+    return -1;
+}
+
+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;
+
+    /* No key, return zero. */
+    robj *val = lookupKeyWriteOrReply(c, key, shared.czero);
+    if (val == nullptr) {
+        return;
+    }
+
+    switch (val->type)
+    {
+    case OBJ_SET:
+        if (!setTypeIsMember(val, szFromObj(subkey))) {
+            addReply(c,shared.czero);
+            return;
+        }
+        break;
+
+    default:
+        addReplyError(c, "object type is unsupported");
+        return;
+    }
+
+    setExpire(c, c->db, key, subkey, when);
+
+    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
@@ -147,7 +283,6 @@ void activeExpireCycle(int type) {
     long total_expired = 0;
 
     for (j = 0; j < dbs_per_call && timelimit_exit == 0; j++) {
-        int expired;
         redisDb *db = g_pserver->db+(current_db % cserver.dbnum);
 
         /* Increment the DB now so we are sure if we run out of time
@@ -155,78 +290,46 @@ void activeExpireCycle(int type) {
          * distribute the time evenly across DBs. */
         current_db++;
 
-        /* Continue to expire if at the end of the cycle more than 25%
-         * of the keys were expired. */
-        do {
-            unsigned long num, slots;
-            long long now, ttl_sum;
-            int ttl_samples;
-            iteration++;
+        long long now;
+        iteration++;
+        now = mstime();
 
-            /* If there is nothing to expire try next DB ASAP. */
-            if ((num = dictSize(db->expires)) == 0) {
-                db->avg_ttl = 0;
-                break;
+        /* If there is nothing to expire try next DB ASAP. */
+        if (db->setexpireUnsafe()->empty())
+        {
+            db->avg_ttl = 0;
+            db->last_expire_set = now;
+            continue;
+        }
+        
+        size_t expired = 0;
+        size_t tried = 0;
+        long long check = ACTIVE_EXPIRE_CYCLE_FAST_DURATION;    // assume a check is roughly 1us.  It isn't but good enough
+        db->expireitr = db->setexpireUnsafe()->enumerate(db->expireitr, now, [&](expireEntry &e) __attribute__((always_inline)) {
+            if (e.when() < now)
+            {
+                activeExpireCycleExpire(db, e, now);
+                ++expired;
             }
-            slots = dictSlots(db->expires);
-            now = mstime();
+            ++tried;
 
-            /* When there are less than 1% filled slots getting random
-             * keys is expensive, so stop here waiting for better times...
-             * The dictionary will be resized asap. */
-            if (num && slots > DICT_HT_INITIAL_SIZE &&
-                (num*100/slots < 1)) break;
-
-            /* The main collection cycle. Sample random keys among keys
-             * with an expire set, checking for expired ones. */
-            expired = 0;
-            ttl_sum = 0;
-            ttl_samples = 0;
-
-            if (num > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP)
-                num = ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP;
-
-            while (num--) {
-                dictEntry *de;
-                long long ttl;
-
-                if ((de = dictGetRandomKey(db->expires)) == NULL) break;
-                ttl = dictGetSignedIntegerVal(de)-now;
-                if (activeExpireCycleTryExpire(db,de,now)) expired++;
-                if (ttl > 0) {
-                    /* We want the average TTL of keys yet not expired. */
-                    ttl_sum += ttl;
-                    ttl_samples++;
-                }
-                total_sampled++;
-            }
-            total_expired += expired;
-
-            /* Update the average TTL stats for this database. */
-            if (ttl_samples) {
-                long long avg_ttl = ttl_sum/ttl_samples;
-
-                /* Do a simple running average with a few samples.
-                 * We just use the current estimate with a weight of 2%
-                 * and the previous estimate with a weight of 98%. */
-                if (db->avg_ttl == 0) db->avg_ttl = avg_ttl;
-                db->avg_ttl = (db->avg_ttl/50)*49 + (avg_ttl/50);
-            }
-
-            /* We can't block forever here even if there are many keys to
-             * expire. So after a given amount of milliseconds return to the
-             * caller waiting for the other active expire cycle. */
-            if ((iteration & 0xf) == 0) { /* check once every 16 iterations. */
+            if ((tried % ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP) == 0)
+            {
+                /* We can't block forever here even if there are many keys to
+                * expire. So after a given amount of milliseconds return to the
+                * caller waiting for the other active expire cycle. */
                 elapsed = ustime()-start;
                 if (elapsed > timelimit) {
                     timelimit_exit = 1;
                     g_pserver->stat_expired_time_cap_reached_count++;
-                    break;
+                    return false;
                 }
+                check = ACTIVE_EXPIRE_CYCLE_FAST_DURATION;
             }
-            /* We don't repeat the cycle if there are less than 25% of keys
-             * found expired in the current DB. */
-        } while (expired > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP/4);
+            return true;
+        }, &check);
+
+        total_expired += expired;
     }
 
     elapsed = ustime()-start;
@@ -248,17 +351,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.
  *
@@ -267,7 +370,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.
@@ -300,20 +403,27 @@ void expireSlaveKeys(void) {
         while(dbids && dbid < cserver.dbnum) {
             if ((dbids & 1) != 0) {
                 redisDb *db = g_pserver->db+dbid;
-                dictEntry *expire = dictFind(db->expires,keyname);
+
+                // the expire is hashed based on the key pointer, so we need the point in the main db
+                auto itrDB = db->find(keyname);
+                auto itrExpire = db->setexpire()->end();
+                if (itrDB != nullptr)
+                    itrExpire = db->setexpireUnsafe()->find(itrDB.key());
                 int expired = 0;
 
-                if (expire &&
-                    activeExpireCycleTryExpire(g_pserver->db+dbid,expire,start))
+                if (itrExpire != db->setexpire()->end())
                 {
-                    expired = 1;
+                    if (itrExpire->when() < start) {
+                        activeExpireCycleExpire(g_pserver->db+dbid,*itrExpire,start);
+                        expired = 1;
+                    }
                 }
 
                 /* If the key was not expired in this DB, we need to set the
                  * corresponding bit in the new bitmap we set as value.
                  * At the end of the loop if the bitmap is zero, it means we
                  * no longer need to keep track of this key. */
-                if (expire && !expired) {
+                if (itrExpire != db->setexpire()->end() && !expired) {
                     noexpire++;
                     new_dbids |= (uint64_t)1 << dbid;
                 }
@@ -323,7 +433,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);
@@ -340,7 +450,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 = {
@@ -382,7 +492,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) {
@@ -420,7 +530,7 @@ 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. */
@@ -440,7 +550,7 @@ void expireGenericCommand(client *c, long long basetime, int unit) {
         addReply(c, shared.cone);
         return;
     } else {
-        setExpire(c,c->db,key,when);
+        setExpire(c,c->db,key,nullptr,when);
         addReply(c,shared.cone);
         signalModifiedKey(c->db,key);
         notifyKeyspaceEvent(NOTIFY_GENERIC,"expire",key,c->db->id);
@@ -471,16 +581,40 @@ void pexpireatCommand(client *c) {
 
 /* Implements TTL and PTTL */
 void ttlGenericCommand(client *c, int output_ms) {
-    long long expire, ttl = -1;
+    long long expire = -1, ttl = -1;
 
     /* If the key does not exist at all, return -2 */
     if (lookupKeyReadWithFlags(c->db,c->argv[1],LOOKUP_NOTOUCH) == nullptr) {
         addReplyLongLong(c,-2);
         return;
     }
+
     /* The key exists. Return -1 if it has no expire, or the actual
-     * TTL value otherwise. */
-    expire = getExpire(c->db,c->argv[1]);
+        * TTL value otherwise. */
+    expireEntry *pexpire = c->db->getExpire(c->argv[1]);
+
+    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();
         if (ttl < 0) ttl = 0;
@@ -505,11 +639,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 (c->db->removeSubkeyExpire(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);

src/fastlock.cpp

@@ -36,6 +36,10 @@
 #include <assert.h>
 #include <pthread.h>
 #include <limits.h>
+#ifdef __linux__
+#include <linux/futex.h>
+#endif
+#include <string.h>
 
 #ifdef __APPLE__
 #include <TargetConditionals.h>
@@ -49,6 +53,11 @@
 #endif
 #endif
 
+#ifndef UNUSED
+#define UNUSED(x) ((void)x)
+#endif
+
+
 /****************************************************
  *
  *      Implementation of a fair spinlock.  To promote fairness we
@@ -56,14 +65,86 @@
  * 
  ****************************************************/
 
+
+#if !defined(__has_feature)
+    #define __has_feature(x) 0
+#endif
+
+#if __has_feature(thread_sanitizer)
+
+    /* Report that a lock has been created at address "lock". */
+    #define ANNOTATE_RWLOCK_CREATE(lock) \
+        AnnotateRWLockCreate(__FILE__, __LINE__, lock)
+
+    /* Report that the lock at address "lock" is about to be destroyed. */
+    #define ANNOTATE_RWLOCK_DESTROY(lock) \
+        AnnotateRWLockDestroy(__FILE__, __LINE__, lock)
+
+    /* Report that the lock at address "lock" has been acquired.
+       is_w=1 for writer lock, is_w=0 for reader lock. */
+    #define ANNOTATE_RWLOCK_ACQUIRED(lock, is_w) \
+        AnnotateRWLockAcquired(__FILE__, __LINE__, lock, is_w)
+
+    /* Report that the lock at address "lock" is about to be released. */
+    #define ANNOTATE_RWLOCK_RELEASED(lock, is_w) \
+      AnnotateRWLockReleased(__FILE__, __LINE__, lock, is_w)
+
+    #if defined(DYNAMIC_ANNOTATIONS_WANT_ATTRIBUTE_WEAK)
+        #if defined(__GNUC__)
+            #define DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK __attribute__((weak))
+        #else
+            /* TODO(glider): for Windows support we may want to change this macro in order
+               to prepend __declspec(selectany) to the annotations' declarations. */
+            #error weak annotations are not supported for your compiler
+        #endif
+    #else
+        #define DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK
+    #endif
+
+    extern "C" {
+    void AnnotateRWLockCreate(
+        const char *file, int line,
+        const volatile void *lock) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
+    void AnnotateRWLockDestroy(
+        const char *file, int line,
+        const volatile void *lock) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
+    void AnnotateRWLockAcquired(
+        const char *file, int line,
+        const volatile void *lock, long is_w) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
+    void AnnotateRWLockReleased(
+        const char *file, int line,
+        const volatile void *lock, long is_w) DYNAMIC_ANNOTATIONS_ATTRIBUTE_WEAK;
+    }
+
+#else
+
+    #define ANNOTATE_RWLOCK_CREATE(lock)
+    #define ANNOTATE_RWLOCK_DESTROY(lock)
+    #define ANNOTATE_RWLOCK_ACQUIRED(lock, is_w)
+    #define ANNOTATE_RWLOCK_RELEASED(lock, is_w)
+
+#endif
+
 static_assert(sizeof(pid_t) <= sizeof(fastlock::m_pidOwner), "fastlock::m_pidOwner not large enough");
 uint64_t g_longwaits = 0;
 
 uint64_t fastlock_getlongwaitcount()
 {
-    return g_longwaits;
+    uint64_t rval;
+    __atomic_load(&g_longwaits, &rval, __ATOMIC_RELAXED);
+    return rval;
 }
 
+#ifndef ASM_SPINLOCK
+#ifdef __linux__
+static int futex(volatile unsigned *uaddr, int futex_op, int val,
+    const struct timespec *timeout, int val3)
+{
+    return syscall(SYS_futex, uaddr, futex_op, val,
+                    timeout, uaddr, val3);
+}
+#endif
+#endif
 
 extern "C" pid_t gettid()
 {
@@ -88,72 +169,129 @@ extern "C" void fastlock_init(struct fastlock *lock)
     lock->m_ticket.m_avail = 0;
     lock->m_depth = 0;
     lock->m_pidOwner = -1;
+    lock->futex = 0;
+    ANNOTATE_RWLOCK_CREATE(lock);
 }
 
 #ifndef ASM_SPINLOCK
 extern "C" void fastlock_lock(struct fastlock *lock)
 {
-    if ((int)__atomic_load_4(&lock->m_pidOwner, __ATOMIC_ACQUIRE) == gettid())
+    int pidOwner;
+    __atomic_load(&lock->m_pidOwner, &pidOwner, __ATOMIC_ACQUIRE);
+    if (pidOwner == gettid())
     {
         ++lock->m_depth;
         return;
     }
 
     unsigned myticket = __atomic_fetch_add(&lock->m_ticket.m_avail, 1, __ATOMIC_RELEASE);
-
+#ifdef __linux__
+    unsigned mask = (1U << (myticket % 32));
+#endif
     int cloops = 0;
-    while (__atomic_load_2(&lock->m_ticket.m_active, __ATOMIC_ACQUIRE) != myticket)
+    ticket ticketT;
+    for (;;)
     {
-        if ((++cloops % 1024*1024) == 0)
-        {
-            sched_yield();
-            ++g_longwaits;
-        }
+        __atomic_load(&lock->m_ticket.u, &ticketT.u, __ATOMIC_ACQUIRE);
+        if ((ticketT.u & 0xffff) == myticket)
+            break;
+
 #if defined(__i386__) || defined(__amd64__)
         __asm__ ("pause");
 #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);
+        }
     }
 
     lock->m_depth = 1;
-    __atomic_store_4(&lock->m_pidOwner, gettid(), __ATOMIC_RELEASE);
+    int tid = gettid();
+    __atomic_store(&lock->m_pidOwner, &tid, __ATOMIC_RELEASE);
+    ANNOTATE_RWLOCK_ACQUIRED(lock, true);
     std::atomic_thread_fence(std::memory_order_acquire);
 }
 
-extern "C" int fastlock_trylock(struct fastlock *lock)
+extern "C" int fastlock_trylock(struct fastlock *lock, int fWeak)
 {
-    if ((int)__atomic_load_4(&lock->m_pidOwner, __ATOMIC_ACQUIRE) == gettid())
+    int tid;
+    __atomic_load(&lock->m_pidOwner, &tid, __ATOMIC_ACQUIRE);
+    if (tid == gettid())
     {
         ++lock->m_depth;
         return true;
     }
 
     // cheap test
-    if (lock->m_ticket.m_active != lock->m_ticket.m_avail)
+    struct ticket ticketT;
+    __atomic_load(&lock->m_ticket.u, &ticketT.u, __ATOMIC_ACQUIRE);
+    if (ticketT.m_active != ticketT.m_avail)
         return false;
 
-    uint16_t active = __atomic_load_2(&lock->m_ticket.m_active, __ATOMIC_RELAXED);
+    uint16_t active = ticketT.m_active;
     uint16_t next = active + 1;
 
-    struct ticket ticket_expect { active, active };
-    struct ticket ticket_setiflocked { active, next };
-    if (__atomic_compare_exchange(&lock->m_ticket, &ticket_expect, &ticket_setiflocked, false /*weak*/, __ATOMIC_ACQUIRE, __ATOMIC_ACQUIRE))
+    struct ticket ticket_expect { { { active, active } } };
+    struct ticket ticket_setiflocked { { { active, next } } };
+    if (__atomic_compare_exchange(&lock->m_ticket, &ticket_expect, &ticket_setiflocked, fWeak /*weak*/, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED))
     {
         lock->m_depth = 1;
-        __atomic_store_4(&lock->m_pidOwner, gettid(), __ATOMIC_RELEASE);
+        tid = gettid();
+        __atomic_store(&lock->m_pidOwner, &tid,  __ATOMIC_RELEASE);
+        ANNOTATE_RWLOCK_ACQUIRED(lock, true);
         return true;
     }
     return false;
 }
 
+#ifdef __linux__
+#define ROL32(v, shift) ((v << shift) | (v >> (32-shift)))
+void unlock_futex(struct fastlock *lock, uint16_t ifutex)
+{
+    unsigned mask = (1U << (ifutex % 32));
+    unsigned futexT;
+    __atomic_load(&lock->futex, &futexT, __ATOMIC_RELAXED);
+    futexT &= mask;
+    
+    if (futexT == 0)
+        return;
+    
+    for (;;)
+    {
+        __atomic_load(&lock->futex, &futexT, __ATOMIC_ACQUIRE);
+        futexT &= mask;
+        if (!futexT)
+            break;
+
+        if (futex(&lock->m_ticket.u, FUTEX_WAKE_BITSET_PRIVATE, INT_MAX, nullptr, mask) == 1)
+            break;
+    }
+}
+#endif
+
 extern "C" void fastlock_unlock(struct fastlock *lock)
 {
     --lock->m_depth;
     if (lock->m_depth == 0)
     {
-        assert((int)__atomic_load_4(&lock->m_pidOwner, __ATOMIC_RELAXED) >= 0);  // unlock after free
-        lock->m_pidOwner = -1;
-        std::atomic_thread_fence(std::memory_order_acquire);
-        __atomic_fetch_add(&lock->m_ticket.m_active, 1, __ATOMIC_ACQ_REL);  // on x86 the atomic is not required here, but ASM handles that case
+        int pidT;
+        __atomic_load(&lock->m_pidOwner, &pidT, __ATOMIC_RELAXED);
+        assert(pidT >= 0);  // unlock after free
+        int t = -1;
+        __atomic_store(&lock->m_pidOwner, &t, __ATOMIC_RELEASE);
+        std::atomic_thread_fence(std::memory_order_release);
+        ANNOTATE_RWLOCK_RELEASED(lock, true);
+        uint16_t activeNew = __atomic_add_fetch(&lock->m_ticket.m_active, 1, __ATOMIC_RELEASE);  // on x86 the atomic is not required here, but ASM handles that case
+#ifdef __linux__
+        unlock_futex(lock, activeNew);
+#else
+		UNUSED(activeNew);
+#endif
     }
 }
 #endif
@@ -164,10 +302,27 @@ extern "C" void fastlock_free(struct fastlock *lock)
     assert((lock->m_ticket.m_active == lock->m_ticket.m_avail)                                        // Asser the lock is unlocked
         || (lock->m_pidOwner == gettid() && (lock->m_ticket.m_active == lock->m_ticket.m_avail-1)));  // OR we own the lock and nobody else is waiting
     lock->m_pidOwner = -2;  // sentinal value indicating free
+    ANNOTATE_RWLOCK_DESTROY(lock);
 }
 
 
 bool fastlock::fOwnLock()
 {
-    return gettid() == m_pidOwner;
+    int tid;
+    __atomic_load(&m_pidOwner, &tid, __ATOMIC_RELAXED);
+    return gettid() == tid;
 }
+
+int fastlock_unlock_recursive(struct fastlock *lock)
+{
+    int rval = lock->m_depth;
+    lock->m_depth = 1;
+    fastlock_unlock(lock);
+    return rval;
+}
+
+void fastlock_lock_recursive(struct fastlock *lock, int nesting)
+{
+    fastlock_lock(lock);
+    lock->m_depth = nesting;
+}

src/fastlock.h

@@ -9,9 +9,11 @@ extern "C" {
 struct fastlock;
 void fastlock_init(struct fastlock *lock);
 void fastlock_lock(struct fastlock *lock);
-int fastlock_trylock(struct fastlock *lock);
+int fastlock_trylock(struct fastlock *lock, int fWeak);
 void fastlock_unlock(struct fastlock *lock);
 void fastlock_free(struct fastlock *lock);
+int fastlock_unlock_recursive(struct fastlock *lock);
+void fastlock_lock_recursive(struct fastlock *lock, int nesting);
 
 uint64_t fastlock_getlongwaitcount();   // this is a global value
 
@@ -20,17 +22,29 @@ uint64_t fastlock_getlongwaitcount();   // this is a global value
 }
 #endif
 
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpedantic"
 struct ticket
 {
-    uint16_t m_active;
-    uint16_t m_avail;
+    union
+    {
+        struct
+        {
+            uint16_t m_active;
+            uint16_t m_avail;
+        };
+        unsigned u;
+    };
 };
+#pragma GCC diagnostic pop
+
 struct fastlock
 {
     volatile struct ticket m_ticket;
 
     volatile int m_pidOwner;
     volatile int m_depth;
+    unsigned futex;
 
 #ifdef __cplusplus
     fastlock()
@@ -43,9 +57,9 @@ struct fastlock
         fastlock_lock(this);
     }
 
-    bool try_lock()
+    bool try_lock(bool fWeak = false)
     {
-        return !!fastlock_trylock(this);
+        return !!fastlock_trylock(this, fWeak);
     }
 
     void unlock()
@@ -53,6 +67,16 @@ struct fastlock
         fastlock_unlock(this);
     }
 
+    int unlock_recursive()
+    {
+        return fastlock_unlock_recursive(this);
+    }
+
+    void lock_recursive(int nesting)
+    {
+        fastlock_lock_recursive(this, nesting);
+    }
+
     bool fOwnLock();   // true if this thread owns the lock, NOTE: not 100% reliable, use for debugging only
 #endif
 };

src/fastlock_x64.asm

@@ -22,7 +22,7 @@ fastlock_lock:
 	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
-	mov rdi, [rsp]          ; get our pointer back
+	pop rdi                 ; get our pointer back
 
 	cmp [rdi+4], esi        ; Is the TID we got back the owner of the lock?
 	je .LLocked             ; Don't spin in that case
@@ -30,11 +30,11 @@ fastlock_lock:
 	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
-	; eax now contains the ticket
-	xor ecx, ecx
+	; ax now contains the ticket
 ALIGN 16
 .LLoop:
-	cmp [rdi], ax           ; is our ticket up?
+	mov edx, [rdi]
+	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)
@@ -44,22 +44,34 @@ ALIGN 16
 	;	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 rsi
 	push rax
-	mov rax, 24             ; sys_sched_yield
-	syscall                 ; give up our timeslice we'll be here a while
-	pop rax
-	pop rsi
+	; 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
-	mov rdi, [rsp]          ; our struct pointer is on the stack already
+	pop rax
+	pop rsi
 	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++
-	add rsp, 8              ; fix stack
 	ret
 
 ALIGN 16
@@ -114,9 +126,32 @@ fastlock_unlock:
 	;	uint16_t avail
 	;	int32_t m_pidOwner
 	;	int32_t m_depth
+	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)
-	inc word [rdi]               ; give up our ticket (note: lock is not required here because the spinlock itself guards this variable)
+	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
+.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
+	syscall
+	cmp eax, 1                   ; did we wake as many as we expected?
+	jnz .LRetryWake
 .LDone:
+	pop r11
 	ret

src/geohash_helper.cpp

@@ -46,13 +46,13 @@
 #define ECCENT (sqrt(1.0 - (RATIO *RATIO)))
 #define COM (0.5 * ECCENT)
 
-/// @brief The usual PI/180 constant
-const double DEG_TO_RAD = 0.017453292519943295769236907684886;
 /// @brief Earth's quatratic mean radius for WGS-84
 const double EARTH_RADIUS_IN_METERS = 6372797.560856;
 
 const double MERCATOR_MAX = 20037726.37;
+#if 0 //unused
 const double MERCATOR_MIN = -20037726.37;
+#endif
 
 static inline double deg_rad(double ang) { return ang * D_R; }
 static inline double rad_deg(double ang) { return ang / D_R; }

src/help.h

@@ -343,6 +343,12 @@ struct commandHelp {
     "Set the expiration for a key as a UNIX timestamp",
     0,
     "1.2.0" },
+    { "EXPIREMEMBER",
+    "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",
@@ -629,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",
@@ -674,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",
@@ -949,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",

src/hyperloglog.cpp

@@ -710,6 +710,7 @@ int hllSparseSet(robj *o, long index, uint8_t count) {
         first += span;
     }
     if (span == 0) return -1; /* Invalid format. */
+    if (p >= end) return -1; /* Invalid format. */
 
     next = HLL_SPARSE_IS_XZERO(p) ? p+2 : p+1;
     if (next >= end) next = NULL;

src/lazyfree.cpp

@@ -51,17 +51,20 @@ size_t lazyfreeGetFreeEffort(robj *obj) {
  * a lazy free list instead of being freed synchronously. The lazy free list
  * will be reclaimed in a different bio.c thread. */
 #define LAZYFREE_THRESHOLD 64
-int dbAsyncDelete(redisDb *db, robj *key) {
-    /* Deleting an entry from the expires dict will not free the sds of
-     * the key, because it is shared with the main dictionary. */
-    if (dictSize(db->expires) > 0) dictDelete(db->expires,ptrFromObj(key));
-
+bool redisDbPersistentData::asyncDelete(robj *key) {
     /* If the value is composed of a few allocations, to free in a lazy way
      * is actually just slower... So under a certain limit we just free
      * the object synchronously. */
-    dictEntry *de = dictUnlink(db->pdict,ptrFromObj(key));
+    dictEntry *de = dictUnlink(m_pdict,ptrFromObj(key));
     if (de) {
         robj *val = (robj*)dictGetVal(de);
+        if (val->FExpires())
+        {
+            /* Deleting an entry from the expires dict will not free the sds of
+             * the key, because it is shared with the main dictionary. */
+            removeExpire(key,dict_iter(de));
+        }
+
         size_t free_effort = lazyfreeGetFreeEffort(val);
 
         /* If releasing the object is too much work, do it in the background
@@ -72,28 +75,32 @@ int dbAsyncDelete(redisDb *db, robj *key) {
          * objects, and then call dbDelete(). In this case we'll fall
          * through and reach the dictFreeUnlinkedEntry() call, that will be
          * equivalent to just calling decrRefCount(). */
-        if (free_effort > LAZYFREE_THRESHOLD && val->refcount == 1) {
+        if (free_effort > LAZYFREE_THRESHOLD && val->getrefcount(std::memory_order_relaxed) == 1) {
             atomicIncr(lazyfree_objects,1);
             bioCreateBackgroundJob(BIO_LAZY_FREE,val,NULL,NULL);
-            dictSetVal(db->pdict,de,NULL);
+            dictSetVal(m_pdict,de,NULL);
         }
     }
 
     /* Release the key-val pair, or just the key if we set the val
      * field to NULL in order to lazy free it later. */
     if (de) {
-        dictFreeUnlinkedEntry(db->pdict,de);
+        dictFreeUnlinkedEntry(m_pdict,de);
         if (g_pserver->cluster_enabled) slotToKeyDel(key);
-        return 1;
+        return true;
     } else {
-        return 0;
+        return false;
     }
 }
 
+int dbAsyncDelete(redisDb *db, robj *key) {
+    return db->asyncDelete(key);
+}
+
 /* Free an object, if the object is huge enough, free it in async way. */
 void freeObjAsync(robj *o) {
     size_t free_effort = lazyfreeGetFreeEffort(o);
-    if (free_effort > LAZYFREE_THRESHOLD && o->refcount == 1) {
+    if (free_effort > LAZYFREE_THRESHOLD && o->getrefcount(std::memory_order_relaxed) == 1) {
         atomicIncr(lazyfree_objects,1);
         bioCreateBackgroundJob(BIO_LAZY_FREE,o,NULL,NULL);
     } else {
@@ -104,12 +111,17 @@ void freeObjAsync(robj *o) {
 /* Empty a Redis DB asynchronously. What the function does actually is to
  * create a new empty set of hash tables and scheduling the old ones for
  * lazy freeing. */
-void emptyDbAsync(redisDb *db) {
-    dict *oldht1 = db->pdict, *oldht2 = db->expires;
-    db->pdict = dictCreate(&dbDictType,NULL);
-    db->expires = dictCreate(&keyptrDictType,NULL);
+void redisDbPersistentData::emptyDbAsync() {
+    dict *oldht1 = m_pdict;
+    auto *set = m_setexpire;
+    m_setexpire = new (MALLOC_LOCAL) expireset();
+    m_pdict = dictCreate(&dbDictType,this);
+    if (m_pstorage != nullptr)
+        m_pstorage->clear();
+    if (m_fTrackingChanges)
+        m_fAllChanged = true;
     atomicIncr(lazyfree_objects,dictSize(oldht1));
-    bioCreateBackgroundJob(BIO_LAZY_FREE,NULL,oldht1,oldht2);
+    bioCreateBackgroundJob(BIO_LAZY_FREE,NULL,oldht1,set);
 }
 
 /* Empty the slots-keys map of Redis CLuster by creating a new empty one
@@ -136,10 +148,10 @@ void lazyfreeFreeObjectFromBioThread(robj *o) {
  * when the database was logically deleted. 'sl' is a skiplist used by
  * Redis Cluster in order to take the hash slots -> keys mapping. This
  * may be NULL if Redis Cluster is disabled. */
-void lazyfreeFreeDatabaseFromBioThread(dict *ht1, dict *ht2) {
+void lazyfreeFreeDatabaseFromBioThread(dict *ht1, expireset *set) {
     size_t numkeys = dictSize(ht1);
     dictRelease(ht1);
-    dictRelease(ht2);
+    delete set;
     atomicDecr(lazyfree_objects,numkeys);
 }
 

src/module.cpp

@@ -32,6 +32,7 @@
 #include <dlfcn.h>
 #include <mutex>
 #include <condition_variable>
+#include <sys/stat.h>
 
 #define REDISMODULE_CORE 1
 #include "redismodule.h"
@@ -565,7 +566,7 @@ void RedisModuleCommandDispatcher(client *c) {
     for (int i = 0; i < c->argc; i++) {
         /* Only do the work if the module took ownership of the object:
          * in that case the refcount is no longer 1. */
-        if (c->argv[i]->refcount > 1)
+        if (c->argv[i]->getrefcount(std::memory_order_relaxed) > 1)
             trimStringObjectIfNeeded(c->argv[i]);
     }
 }
@@ -763,6 +764,7 @@ void RM_SetModuleAttribs(RedisModuleCtx *ctx, const char *name, int ver, int api
     module->usedby = listCreate();
     module->usingMods = listCreate();
     module->filters = listCreate();
+    module->in_call = 0;
     ctx->module = module;
 }
 
@@ -1035,7 +1037,7 @@ int RM_StringCompare(RedisModuleString *a, RedisModuleString *b) {
 /* Return the (possibly modified in encoding) input 'str' object if
  * the string is unshared, otherwise NULL is returned. */
 RedisModuleString *moduleAssertUnsharedString(RedisModuleString *str) {
-    if (str->refcount != 1) {
+    if (str->getrefcount(std::memory_order_relaxed) != 1) {
         serverLog(LL_WARNING,
             "Module attempted to use an in-place string modify operation "
             "with a string referenced multiple times. Please check the code "
@@ -1251,6 +1253,17 @@ int RM_ReplyWithStringBuffer(RedisModuleCtx *ctx, const char *buf, size_t len) {
     return REDISMODULE_OK;
 }
 
+/* Reply with a bulk string, taking in input a C buffer pointer that is
+ * assumed to be null-terminated.
+ *
+ * The function always returns REDISMODULE_OK. */
+int RM_ReplyWithCString(RedisModuleCtx *ctx, const char *buf) {
+    client *c = moduleGetReplyClient(ctx);
+    if (c == NULL) return REDISMODULE_OK;
+    addReplyBulkCString(c,(char*)buf);
+    return REDISMODULE_OK;
+}
+
 /* Reply with a bulk string, taking in input a RedisModuleString object.
  *
  * The function always returns REDISMODULE_OK. */
@@ -1426,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
  *
@@ -1464,6 +1477,9 @@ int RM_GetContextFlags(RedisModuleCtx *ctx) {
     if (g_pserver->cluster_enabled)
         flags |= REDISMODULE_CTX_FLAGS_CLUSTER;
 
+    if (g_pserver->loading)
+        flags |= REDISMODULE_CTX_FLAGS_LOADING;
+
     /* Maxmemory and eviction policy */
     if (g_pserver->maxmemory > 0) {
         flags |= REDISMODULE_CTX_FLAGS_MAXMEMORY;
@@ -1628,7 +1644,11 @@ int RM_UnlinkKey(RedisModuleKey *key) {
  * If no TTL is associated with the key or if the key is empty,
  * REDISMODULE_NO_EXPIRE is returned. */
 mstime_t RM_GetExpire(RedisModuleKey *key) {
-    mstime_t expire = getExpire(key->db,key->key);
+    expireEntry *pexpire = key->db->getExpire(key->key);
+    mstime_t expire = -1;
+    if (pexpire != nullptr)
+        pexpire->FGetPrimaryExpire(&expire);
+    
     if (expire == -1 || key->value == NULL) return -1;
     expire -= mstime();
     return expire >= 0 ? expire : 0;
@@ -1648,7 +1668,7 @@ int RM_SetExpire(RedisModuleKey *key, mstime_t expire) {
         return REDISMODULE_ERR;
     if (expire != REDISMODULE_NO_EXPIRE) {
         expire += mstime();
-        setExpire(key->ctx->client,key->db,key->key,expire);
+        setExpire(key->ctx->client,key->db,key->key,nullptr,expire);
     } else {
         removeExpire(key->db,key->key);
     }
@@ -3786,14 +3806,7 @@ void moduleHandleBlockedClients(int iel) {
          * replies to send to the client in a thread safe context.
          * We need to glue such replies to the client output buffer and
          * free the temporary client we just used for the replies. */
-        if (c) {
-            if (bc->reply_client->bufpos)
-                addReplyProto(c,bc->reply_client->buf,
-                                bc->reply_client->bufpos);
-            if (listLength(bc->reply_client->reply))
-                listJoin(c->reply,bc->reply_client->reply);
-            c->reply_bytes += bc->reply_client->reply_bytes;
-        }
+        if (c) AddReplyFromClient(c, bc->reply_client);
         freeClient(bc->reply_client);
 
         if (c != NULL) {
@@ -3812,7 +3825,7 @@ void moduleHandleBlockedClients(int iel) {
                 AssertCorrectThread(c);
                 
                 fastlock_lock(&g_pserver->rgthreadvar[c->iel].lockPendingWrite);
-                listAddNodeHead(g_pserver->rgthreadvar[c->iel].clients_pending_write,c);
+                g_pserver->rgthreadvar[c->iel].clients_pending_write.push_back(c);
                 fastlock_unlock(&g_pserver->rgthreadvar[c->iel].lockPendingWrite);
             }
         }
@@ -3917,13 +3930,18 @@ RedisModuleCtx *RM_GetThreadSafeContext(RedisModuleBlockedClient *bc) {
      * in order to keep things like the currently selected database and similar
      * things. */
     ctx->client = createClient(-1, IDX_EVENT_LOOP_MAIN);
-    if (bc) selectDb(ctx->client,bc->dbid);
+    if (bc) {
+        selectDb(ctx->client,bc->dbid);
+        ctx->client->id = bc->client->id;
+    }
     return ctx;
 }
 
 /* Release a thread safe context. */
 void RM_FreeThreadSafeContext(RedisModuleCtx *ctx) {
+    moduleAcquireGIL(false /*fServerThread*/);
     moduleFreeContext(ctx);
+    moduleReleaseGIL(false /*fServerThread*/);
     zfree(ctx);
 }
 
@@ -3933,6 +3951,8 @@ void RM_FreeThreadSafeContext(RedisModuleCtx *ctx) {
 void RM_ThreadSafeContextLock(RedisModuleCtx *ctx) {
     UNUSED(ctx);
     moduleAcquireGIL(FALSE /*fServerThread*/);
+    if (serverTL == nullptr)
+        serverTL = &g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN];    // arbitrary module threads get the main thread context
 }
 
 /* Release the server lock after a thread safe API call was executed. */
@@ -4269,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.
  *
@@ -4280,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 */
@@ -4991,6 +5011,12 @@ int RM_UnregisterCommandFilter(RedisModuleCtx *ctx, RedisModuleCommandFilter *fi
     return REDISMODULE_OK;
 }
 
+int moduleHasCommandFilters()
+{
+    // Note: called outside the global lock
+    return listLength(moduleCommandFilters);   
+}
+
 void moduleCallCommandFilters(client *c) {
     if (listLength(moduleCommandFilters) == 0) return;
 
@@ -5155,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;
@@ -5209,6 +5235,15 @@ int moduleLoad(const char *path, void **module_argv, int module_argc) {
     int (*onload)(void *, void **, int);
     void *handle;
     RedisModuleCtx ctx = REDISMODULE_CTX_INIT;
+    
+    struct stat st;
+    if (stat(path, &st) == 0)
+    {   // this check is best effort
+        if (!(st.st_mode & (S_IXUSR  | S_IXGRP | S_IXOTH))) {
+            serverLog(LL_WARNING, "Module %s failed to load: It does not have execute permissions.", path);
+            return C_ERR;
+        }
+    }
 
     handle = dlopen(path,RTLD_NOW|RTLD_LOCAL);
     if (handle == NULL) {

src/modules/Makefile

@@ -13,7 +13,7 @@ endif
 
 .SUFFIXES: .c .so .xo .o
 
-all: helloworld.so hellotype.so helloblock.so testmodule.so hellocluster.so hellotimer.so hellodict.so hellofilter.so
+all: helloworld.so hellotype.so helloblock.so testmodule.so hellocluster.so hellotimer.so hellodict.so
 
 .c.xo:
 	$(CC) -I. $(CFLAGS) $(SHOBJ_CFLAGS) -fPIC -c $< -o $@
@@ -47,11 +47,6 @@ hellodict.xo: ../redismodule.h
 
 hellodict.so: hellodict.xo
 
-hellofilter.xo: ../redismodule.h
-
-hellofilter.so: hellofilter.xo
-	$(LD) -o $@ $< $(SHOBJ_LDFLAGS) $(LIBS) -lc
-
 testmodule.xo: ../redismodule.h
 
 testmodule.so: testmodule.xo

src/modules/hellotimer.c

@@ -40,7 +40,7 @@
 /* Timer callback. */
 void timerHandler(RedisModuleCtx *ctx, void *data) {
     REDISMODULE_NOT_USED(ctx);
-    printf("Fired %s!\n", data);
+    printf("Fired %s!\n", (const char *) data);
     RedisModule_Free(data);
 }
 

src/multi.cpp

@@ -82,7 +82,6 @@ void discardTransaction(client *c) {
 /* Flag the transacation as DIRTY_EXEC so that EXEC will fail.
  * Should be called every time there is an error while queueing a command. */
 void flagTransaction(client *c) {
-    serverAssert(GlobalLocksAcquired());
     if (c->flags & CLIENT_MULTI)
         c->flags |= CLIENT_DIRTY_EXEC;
 }
@@ -143,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). */
@@ -196,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. */
@@ -334,7 +333,7 @@ void touchWatchedKeysOnFlush(int dbid) {
              * key exists, mark the client as dirty, as the key will be
              * removed. */
             if (dbid == -1 || wk->db->id == dbid) {
-                if (dictFind(wk->db->pdict, ptrFromObj(wk->key)) != NULL)
+                if (wk->db->find(wk->key) != NULL)
                     c->flags |= CLIENT_DIRTY_CAS;
             }
         }

src/networking.cpp

@@ -30,71 +30,18 @@
 
 #include "server.h"
 #include "atomicvar.h"
+#include <sys/socket.h>
 #include <sys/uio.h>
 #include <math.h>
 #include <ctype.h>
 #include <vector>
 #include <mutex>
+#include "aelocker.h"
 
 static void setProtocolError(const char *errstr, client *c);
 void addReplyLongLongWithPrefixCore(client *c, long long ll, char prefix, bool fAsync);
 void addReplyBulkCStringCore(client *c, const char *s, bool fAsync);
 
-class AeLocker
-{
-    bool m_fArmed = false;
-
-public:
-    AeLocker()
-    {
-    }
-
-    void arm(client *c) // if a client is passed, then the client is already locked
-    {
-        if (c != nullptr)
-        {
-            serverAssert(!m_fArmed);
-            serverAssert(c->lock.fOwnLock());
-
-            bool fClientLocked = true;
-            while (!aeTryAcquireLock())
-            {
-                if (fClientLocked) c->lock.unlock();
-                fClientLocked = false;
-                aeAcquireLock();
-                if (!c->lock.try_lock())
-                {
-                    aeReleaseLock();
-                }
-                else
-                {
-                    break;
-                }
-            }
-            
-            m_fArmed = true;
-        }
-        else if (!m_fArmed)
-        {
-            m_fArmed = true;
-            aeAcquireLock();
-        }
-    }
-
-    void disarm()
-    {
-        serverAssert(m_fArmed);
-        m_fArmed = false;
-        aeReleaseLock();
-    }
-
-    ~AeLocker()
-    {
-        if (m_fArmed)
-            aeReleaseLock();
-    }
-};
-
 /* Return the size consumed from the allocator, for the specified SDS string,
  * including internal fragmentation. This function is used in order to compute
  * the client output buffer size. */
@@ -167,7 +114,7 @@ client *createClient(int fd, int iel) {
 
     selectDb(c,0);
     uint64_t client_id;
-    atomicGetIncr(g_pserver->next_client_id,client_id,1);
+    client_id = g_pserver->next_client_id.fetch_add(1);
     c->iel = iel;
     fastlock_init(&c->lock);
     c->id = client_id;
@@ -197,6 +144,7 @@ client *createClient(int fd, int iel) {
     c->replstate = REPL_STATE_NONE;
     c->repl_put_online_on_ack = 0;
     c->reploff = 0;
+    c->reploff_skipped = 0;
     c->read_reploff = 0;
     c->repl_ack_off = 0;
     c->repl_ack_time = 0;
@@ -226,6 +174,8 @@ client *createClient(int fd, int iel) {
     c->bufAsync = NULL;
     c->buflenAsync = 0;
     c->bufposAsync = 0;
+    c->client_tracking_redirection = 0;
+    c->casyncOpsPending = 0;
     memset(c->uuid, 0, UUID_BINARY_LEN);
 
     listSetFreeMethod(c->pubsub_patterns,decrRefCountVoid);
@@ -245,7 +195,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 ||
@@ -261,7 +211,7 @@ void clientInstallWriteHandler(client *c) {
          * we'll not be able to write the whole reply at once. */
         c->flags |= CLIENT_PENDING_WRITE;
         std::unique_lock<fastlock> lockf(g_pserver->rgthreadvar[c->iel].lockPendingWrite);
-        listAddNodeHead(g_pserver->rgthreadvar[c->iel].clients_pending_write,c);
+        g_pserver->rgthreadvar[c->iel].clients_pending_write.push_back(c);
     }
 }
 
@@ -289,7 +239,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
@@ -297,7 +247,7 @@ 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(FCorrectThread(c) || fAsync);
     serverAssert(c->fd <= 0 || c->lock.fOwnLock());
 
     if (c->flags & CLIENT_FORCE_REPLY) return C_OK; // FORCE REPLY means we're doing something else with the buffer.
@@ -492,7 +442,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:
@@ -675,7 +625,7 @@ void setDeferredPushLen(client *c, void *node, long length) {
 
 /* Add a double as a bulk reply */
 void addReplyDoubleCore(client *c, double d, bool fAsync) {
-    if (isinf(d)) {
+    if (std::isinf(d)) {
         /* Libc in odd systems (Hi Solaris!) will format infinite in a
          * different way, so better to handle it in an explicit way. */
         if (c->resp == 2) {
@@ -838,8 +788,11 @@ void addReplyNullCore(client *c, bool fAsync) {
     }
 }
 
-void addReplyNull(client *c) {
-    addReplyNullCore(c, false);
+void addReplyNull(client *c, robj_roptr objOldProtocol) {
+    if (c->resp < 3 && objOldProtocol != nullptr)
+        addReply(c, objOldProtocol);
+    else
+        addReplyNullCore(c, false);
 }
 
 void addReplyNullAsync(client *c) {
@@ -931,7 +884,10 @@ void addReplyBulkSdsAsync(client *c, sds s) {
 /* Add a C null term string as bulk reply */
 void addReplyBulkCStringCore(client *c, const char *s, bool fAsync) {
     if (s == NULL) {
-        addReplyNullCore(c,fAsync);
+        if (c->resp < 3)
+            addReplyCore(c,shared.nullbulk, fAsync);
+        else
+            addReplyNullCore(c,fAsync);
     } else {
         addReplyBulkCBufferCore(c,s,strlen(s),fAsync);
     }
@@ -1011,6 +967,19 @@ void addReplySubcommandSyntaxError(client *c) {
     sdsfree(cmd);
 }
 
+/* Append 'src' client output buffers into 'dst' client output buffers. 
+ * This function clears the output buffers of 'src' */
+void AddReplyFromClient(client *dst, client *src) {
+    if (prepareClientToWrite(dst, false) != C_OK)
+        return;
+    addReplyProto(dst,src->buf, src->bufpos);
+    if (listLength(src->reply))
+        listJoin(dst->reply,src->reply);
+    dst->reply_bytes += src->reply_bytes;
+    src->reply_bytes = 0;
+    src->bufpos = 0;
+}
+
 /* Copy 'src' client output buffers into 'dst' client output buffers.
  * The function takes care of freeing the old output buffers of the
  * destination client. */
@@ -1036,7 +1005,6 @@ static void acceptCommonHandler(int fd, int flags, char *ip, int iel) {
         serverLog(LL_WARNING,
             "Error registering fd event for the new client: %s (fd=%d)",
             strerror(errno),fd);
-        close(fd); /* May be already closed, just ignore errors */
         return;
     }
 
@@ -1120,20 +1088,40 @@ void acceptTcpHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
     UNUSED(privdata);
 
     while(max--) {
-        cfd = anetTcpAccept(g_pserver->neterr, fd, cip, sizeof(cip), &cport);
+        cfd = anetTcpAccept(serverTL->neterr, fd, cip, sizeof(cip), &cport);
         if (cfd == ANET_ERR) {
             if (errno != EWOULDBLOCK)
                 serverLog(LL_WARNING,
-                    "Accepting client connection: %s", g_pserver->neterr);
+                    "Accepting client connection: %s", serverTL->neterr);
             return;
         }
         serverLog(LL_VERBOSE,"Accepted %s:%d", cip, cport);
         int ielCur = ielFromEventLoop(el);
 
-        // We always accept on the same thread
-        aeAcquireLock();
-        acceptCommonHandler(cfd,0,cip, ielCur);
-        aeReleaseLock();
+        if (!g_fTestMode)
+        {
+            // We always accept on the same thread
+        LLocalThread:
+            aeAcquireLock();
+            acceptCommonHandler(cfd,0,cip, ielCur);
+            aeReleaseLock();
+        }
+        else
+        {
+            // In test mode we want a good distribution among threads and avoid the main thread
+            //  since the main thread is most likely to work
+            int iel = IDX_EVENT_LOOP_MAIN;
+            while (cserver.cthreads > 1 && iel == IDX_EVENT_LOOP_MAIN)
+                iel = rand() % cserver.cthreads;
+            if (iel == ielFromEventLoop(el))
+                goto LLocalThread;
+            char *szT = (char*)zmalloc(NET_IP_STR_LEN, MALLOC_LOCAL);
+            memcpy(szT, cip, NET_IP_STR_LEN);
+            aePostFunction(g_pserver->rgthreadvar[iel].el, [cfd, iel, szT]{
+                acceptCommonHandler(cfd,0,szT, iel);
+                zfree(szT);
+            });
+        }
     }
 }
 
@@ -1144,18 +1132,28 @@ void acceptUnixHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
     UNUSED(privdata);
 
     while(max--) {
-        cfd = anetUnixAccept(g_pserver->neterr, fd);
+        cfd = anetUnixAccept(serverTL->neterr, fd);
         if (cfd == ANET_ERR) {
             if (errno != EWOULDBLOCK)
                 serverLog(LL_WARNING,
-                    "Accepting client connection: %s", g_pserver->neterr);
+                    "Accepting client connection: %s", serverTL->neterr);
             return;
         }
         int ielCur = ielFromEventLoop(el);
         serverLog(LL_VERBOSE,"Accepted connection to %s", g_pserver->unixsocket);
 
         aeAcquireLock();
-        acceptCommonHandler(cfd,CLIENT_UNIX_SOCKET,NULL, ielCur);
+        int ielTarget = rand() % cserver.cthreads;
+        if (ielTarget == ielCur)
+        {
+            acceptCommonHandler(cfd,CLIENT_UNIX_SOCKET,NULL, ielCur);
+        }
+        else
+        {
+            aePostFunction(g_pserver->rgthreadvar[ielTarget].el, [cfd, ielTarget]{
+                acceptCommonHandler(cfd,CLIENT_UNIX_SOCKET,NULL, ielTarget);
+            });
+        }
         aeReleaseLock();
         
     }
@@ -1216,7 +1214,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) &&
@@ -1236,9 +1234,10 @@ void unlinkClient(client *c) {
     /* Remove from the list of pending writes if needed. */
     if (c->flags & CLIENT_PENDING_WRITE) {
         std::unique_lock<fastlock> lockf(g_pserver->rgthreadvar[c->iel].lockPendingWrite);
-        ln = listSearchKey(g_pserver->rgthreadvar[c->iel].clients_pending_write,c);
-        serverAssert(ln != NULL);
-        listDelNode(g_pserver->rgthreadvar[c->iel].clients_pending_write,ln);
+        auto itr = std::find(g_pserver->rgthreadvar[c->iel].clients_pending_write.begin(),
+            g_pserver->rgthreadvar[c->iel].clients_pending_write.end(), c);
+        serverAssert(itr != g_pserver->rgthreadvar[c->iel].clients_pending_write.end());
+        g_pserver->rgthreadvar[c->iel].clients_pending_write.erase(itr);
         c->flags &= ~CLIENT_PENDING_WRITE;
     }
 
@@ -1266,9 +1265,12 @@ void unlinkClient(client *c) {
         serverAssert(fFound);
         c->fPendingAsyncWrite = FALSE;
     }
+
+    /* Clear the tracking status. */
+    if (c->flags & CLIENT_TRACKING) disableTracking(c);
 }
 
-void freeClient(client *c) {
+bool freeClient(client *c) {
     listNode *ln;
     serverAssert(c->fd == -1 || GlobalLocksAcquired());
     AssertCorrectThread(c);
@@ -1276,9 +1278,9 @@ void freeClient(client *c) {
 
     /* If a client is protected, yet we need to free it right now, make sure
      * to at least use asynchronous freeing. */
-    if (c->flags & CLIENT_PROTECTED) {
+    if (c->flags & CLIENT_PROTECTED || c->casyncOpsPending) {
         freeClientAsync(c);
-        return;
+        return false;
     }
 
     /* If it is our master that's beging disconnected we should make sure
@@ -1293,11 +1295,11 @@ void freeClient(client *c) {
                         CLIENT_BLOCKED)))
         {
             replicationCacheMaster(MasterInfoFromClient(c), c);
-            return;
+            return false;
         }
     }
 
-    /* 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));
@@ -1331,8 +1333,8 @@ void 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);
@@ -1350,7 +1352,7 @@ void 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));
 
@@ -1372,6 +1374,7 @@ void freeClient(client *c) {
     ulock.unlock();
     fastlock_free(&c->lock);
     zfree(c);
+    return true;
 }
 
 /* Schedule a client to free it at a safe time in the serverCron() function.
@@ -1379,28 +1382,42 @@ void freeClient(client *c) {
  * a context where calling freeClient() is not possible, because the client
  * should be valid for the continuation of the flow of the program. */
 void freeClientAsync(client *c) {
-    if (c->flags & CLIENT_CLOSE_ASAP || c->flags & CLIENT_LUA) return;
-    AeLocker lock;
-    lock.arm(nullptr);
+    /* We need to handle concurrent access to the server.clients_to_close list
+     * only in the freeClientAsync() function, since it's the only function that
+     * may access the list while Redis uses I/O threads. All the other accesses
+     * are in the context of the main thread while the other threads are
+     * idle. */
+    if (c->flags & CLIENT_CLOSE_ASAP || c->flags & CLIENT_LUA) return;  // check without the lock first
     std::lock_guard<decltype(c->lock)> clientlock(c->lock);
+    AeLocker lock;
+    lock.arm(c);
+    if (c->flags & CLIENT_CLOSE_ASAP || c->flags & CLIENT_LUA) return;  // race condition after we acquire the lock
     c->flags |= CLIENT_CLOSE_ASAP;    
     listAddNodeTail(g_pserver->clients_to_close,c);
 }
 
 void freeClientsInAsyncFreeQueue(int iel) {
+    serverAssert(GlobalLocksAcquired());
     listIter li;
     listNode *ln;
     listRewind(g_pserver->clients_to_close,&li);
 
-    while((ln = listNext(&li))) {
+    // Store the clients in a temp vector since freeClient will modify this list
+    std::vector<client*> vecclientsFree;
+    while((ln = listNext(&li))) 
+    {
         client *c = (client*)listNodeValue(ln);
-        if (c->iel != iel)
-            continue;   // wrong thread
+        if (c->iel == iel)
+        {
+            vecclientsFree.push_back(c);
+            listDelNode(g_pserver->clients_to_close, ln);
+        }
+    }
 
+    for (client *c : vecclientsFree)
+    {
         c->flags &= ~CLIENT_CLOSE_ASAP;
         freeClient(c);
-        listDelNode(g_pserver->clients_to_close,ln);
-        listRewind(g_pserver->clients_to_close,&li);
     }
 }
 
@@ -1414,7 +1431,12 @@ client *lookupClientByID(uint64_t id) {
 }
 
 /* Write data in output buffers to client. Return C_OK if the client
- * is still valid after the call, C_ERR if it was freed. */
+ * is still valid after the call, C_ERR if it was freed because of some
+ * error.
+ *
+ * This function is called by threads, but always with handler_installed
+ * set to 0. So when handler_installed is set to 0 the function must be
+ * thread safe. */
 int writeToClient(int fd, client *c, int handler_installed) {
     ssize_t nwritten = 0, totwritten = 0;
     clientReplyBlock *o;
@@ -1472,7 +1494,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 ||
@@ -1480,7 +1502,7 @@ int writeToClient(int fd, client *c, int handler_installed) {
             !(c->flags & CLIENT_SLAVE)) break;
     }
     
-    __atomic_fetch_add(&g_pserver->stat_net_output_bytes, totwritten, __ATOMIC_RELAXED);
+    g_pserver->stat_net_output_bytes += totwritten;
     if (nwritten == -1) {
         if (errno == EAGAIN) {
             nwritten = 0;
@@ -1488,15 +1510,7 @@ int writeToClient(int fd, client *c, int handler_installed) {
             serverLog(LL_VERBOSE,
                 "Error writing to client: %s", strerror(errno));
             lock.unlock();
-            if (aeTryAcquireLock())
-            {
-                freeClient(c);
-                aeReleaseLock();
-            }
-            else
-            {
-                freeClientAsync(c);
-            }
+            freeClientAsync(c);
             
             return C_ERR;
         }
@@ -1515,16 +1529,7 @@ 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();
-            if (aeTryAcquireLock())
-            {
-                freeClient(c);
-                aeReleaseLock();
-            }
-            else
-            {
-                lock.unlock();
-                freeClientAsync(c);
-            }
+            freeClientAsync(c);
             return C_ERR;
         }
     }
@@ -1537,7 +1542,14 @@ void sendReplyToClient(aeEventLoop *el, int fd, void *privdata, int mask) {
     client *c = (client*)privdata;
 
     serverAssert(ielFromEventLoop(el) == c->iel);
-    writeToClient(fd,c,1);
+    if (writeToClient(fd,c,1) == C_ERR)
+    {
+        AeLocker ae;
+        c->lock.lock();
+        ae.arm(c);
+        if (c->flags & CLIENT_CLOSE_ASAP)
+            freeClient(c);
+    }
 }
 
 void ProcessPendingAsyncWrites()
@@ -1553,6 +1565,15 @@ void ProcessPendingAsyncWrites()
         std::lock_guard<decltype(c->lock)> lock(c->lock);
 
         serverAssert(c->fPendingAsyncWrite);
+        if (c->flags & (CLIENT_CLOSE_ASAP | CLIENT_CLOSE_AFTER_REPLY))
+        {
+            c->bufposAsync = 0;
+            c->buflenAsync = 0;
+            zfree(c->bufAsync);
+            c->bufAsync = nullptr;
+            c->fPendingAsyncWrite = FALSE;
+            continue;
+        }
 
         // TODO: Append to end of reply block?
 
@@ -1589,8 +1610,36 @@ void ProcessPendingAsyncWrites()
             continue;
 
         asyncCloseClientOnOutputBufferLimitReached(c);
-        if (aeCreateRemoteFileEvent(g_pserver->rgthreadvar[c->iel].el, c->fd, ae_flags, sendReplyToClient, c, FALSE) == AE_ERR)
-            continue;   // We can retry later in the cron
+        if (c->flags & CLIENT_CLOSE_ASAP)
+            continue;   // we will never write this so don't post an op
+        
+        std::atomic_thread_fence(std::memory_order_seq_cst);
+        
+        if (c->casyncOpsPending == 0)
+        {
+            if (FCorrectThread(c))
+            {
+                prepareClientToWrite(c, false); // queue an event
+            }
+            else
+            {
+                // We need to start the write on the client's thread
+                if (aePostFunction(g_pserver->rgthreadvar[c->iel].el, [c]{
+                        // Install a write handler.  Don't do the actual write here since we don't want
+                        //  to duplicate the throttling and safety mechanisms of the normal write code
+                        std::lock_guard<decltype(c->lock)> lock(c->lock);
+                        serverAssert(c->casyncOpsPending > 0);
+                        c->casyncOpsPending--;
+                        aeCreateFileEvent(g_pserver->rgthreadvar[c->iel].el, c->fd, AE_WRITABLE|AE_WRITE_THREADSAFE, sendReplyToClient, c);
+                    }, false) == AE_ERR
+                )
+                {
+                    // Posting the function failed
+                    continue;   // We can retry later in the cron
+                }
+                ++c->casyncOpsPending; // race is handled by the client lock in the lambda
+            }
+        }
     }
 }
 
@@ -1599,56 +1648,64 @@ void ProcessPendingAsyncWrites()
  * need to use a syscall in order to install the writable event handler,
  * get it called, and so forth. */
 int handleClientsWithPendingWrites(int iel) {
-    listIter li;
-    listNode *ln;
-
     std::unique_lock<fastlock> lockf(g_pserver->rgthreadvar[iel].lockPendingWrite);
-    list *list = g_pserver->rgthreadvar[iel].clients_pending_write;
-    int processed = listLength(list);
+    auto &vec = g_pserver->rgthreadvar[iel].clients_pending_write;
+    int processed = (int)vec.size();
     serverAssert(iel == (serverTL - g_pserver->rgthreadvar));
 
-    listRewind(list,&li);
-    while((ln = listNext(&li))) {
-        client *c = (client*)listNodeValue(ln);
-        std::unique_lock<decltype(c->lock)> lock(c->lock);
+    int ae_flags = AE_WRITABLE|AE_WRITE_THREADSAFE;
+    /* For the fsync=always policy, we want that a given FD is never
+        * served for reading and writing in the same event loop iteration,
+        * so that in the middle of receiving the query, and serving it
+        * to the client, we'll call beforeSleep() that will do the
+        * actual fsync of AOF to disk. AE_BARRIER ensures that. */
+    if (g_pserver->aof_state == AOF_ON &&
+        g_pserver->aof_fsync == AOF_FSYNC_ALWAYS)
+    {
+        ae_flags |= AE_BARRIER;
+    }
+
+    while(!vec.empty()) {
+        client *c = vec.back();
+        AssertCorrectThread(c);
 
         c->flags &= ~CLIENT_PENDING_WRITE;
-        listDelNode(list,ln);
-        AssertCorrectThread(c);
+        vec.pop_back();
 
         /* If a client is protected, don't do anything,
          * that may trigger write error or recreate handler. */
         if (c->flags & CLIENT_PROTECTED) continue;
 
+        std::unique_lock<decltype(c->lock)> lock(c->lock);
+
         /* Try to write buffers to the client socket. */
-        if (writeToClient(c->fd,c,0) == C_ERR) {
-            lock.release(); // client is free'd
+        if (writeToClient(c->fd,c,0) == C_ERR) 
+        {
+            if (c->flags & CLIENT_CLOSE_ASAP)
+            {
+                lock.release(); // still locked
+                AeLocker ae;
+                ae.arm(c);
+                if (!freeClient(c))  // writeToClient will only async close, but there's no need to wait
+                    c->lock.unlock();   // if we just got put on the async close list, then we need to remove the lock
+            }
             continue;
         }
 
         /* If after the synchronous writes above we still have data to
          * output to the client, we need to install the writable handler. */
         if (clientHasPendingReplies(c)) {
-            int ae_flags = AE_WRITABLE|AE_WRITE_THREADSAFE;
-            /* For the fsync=always policy, we want that a given FD is never
-             * served for reading and writing in the same event loop iteration,
-             * so that in the middle of receiving the query, and serving it
-             * to the client, we'll call beforeSleep() that will do the
-             * actual fsync of AOF to disk. AE_BARRIER ensures that. */
-            if (g_pserver->aof_state == AOF_ON &&
-                g_pserver->aof_fsync == AOF_FSYNC_ALWAYS)
-            {
-                ae_flags |= AE_BARRIER;
-            }
-            
             if (aeCreateFileEvent(g_pserver->rgthreadvar[c->iel].el, c->fd, ae_flags, sendReplyToClient, c) == AE_ERR)
                 freeClientAsync(c);
         }
     }
 
-    AeLocker locker;
-    locker.arm(nullptr);
-    ProcessPendingAsyncWrites();
+    if (listLength(serverTL->clients_pending_asyncwrite))
+    {
+        AeLocker locker;
+        locker.arm(nullptr);
+        ProcessPendingAsyncWrites();
+    }
 
     return processed;
 }
@@ -1748,7 +1805,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;
@@ -1951,13 +2008,48 @@ int processMultibulkBuffer(client *c) {
     return C_ERR;
 }
 
+/* This function calls processCommand(), but also performs a few sub tasks
+ * that are useful in that context:
+ *
+ * 1. It sets the current client to the client 'c'.
+ * 2. In the case of master clients, the replication offset is updated.
+ * 3. The client is reset unless there are reasons to avoid doing it.
+ *
+ * The function returns C_ERR in case the client was freed as a side effect
+ * of processing the command, otherwise C_OK is returned. */
+int processCommandAndResetClient(client *c, int flags) {
+    int deadclient = 0;
+    serverTL->current_client = c;
+    if (processCommand(c, flags) == C_OK) {
+        if (c->flags & CLIENT_MASTER && !(c->flags & CLIENT_MULTI)) {
+            /* Update the applied replication offset of our master. */
+            c->reploff = c->read_reploff - sdslen(c->querybuf) + c->qb_pos;
+        }
+
+        /* Don't reset the client structure for clients blocked in a
+         * module blocking command, so that the reply callback will
+         * still be able to access the client argv and argc field.
+         * The client will be reset in unblockClientFromModule(). */
+        if (!(c->flags & CLIENT_BLOCKED) ||
+            c->btype != BLOCKED_MODULE)
+        {
+            resetClient(c);
+        }
+    }
+    if (serverTL->current_client == NULL) deadclient = 1;
+    serverTL->current_client = NULL;
+    /* 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;
+}
+
 /* This function is called every time, in the client structure 'c', there is
  * more query buffer to process, because we read more data from the socket
  * or because a client was blocked and later reactivated, so there could be
  * pending query buffer, already representing a full command, to process. */
 void processInputBuffer(client *c, int callFlags) {
     AssertCorrectThread(c);
-    bool fFreed = false;
     
     /* Keep processing while there is something in the input buffer */
     while(c->qb_pos < sdslen(c->querybuf)) {
@@ -1968,7 +2060,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;
@@ -2001,60 +2093,47 @@ void processInputBuffer(client *c, int callFlags) {
         if (c->argc == 0) {
             resetClient(c);
         } else {
-            AeLocker locker;
-            locker.arm(c);
-            serverTL->current_client = c;
-
-            /* Only reset the client when the command was executed. */
-            if (processCommand(c, callFlags) == C_OK) {
-                if (c->flags & CLIENT_MASTER && !(c->flags & CLIENT_MULTI)) {
-                    /* Update the applied replication offset of our master. */
-                    c->reploff = c->read_reploff - sdslen(c->querybuf) + c->qb_pos;
-                }
-
-                /* Don't reset the client structure for clients blocked in a
-                 * module blocking command, so that the reply callback will
-                 * still be able to access the client argv and argc field.
-                 * The client will be reset in unblockClientFromModule(). */
-                if (!(c->flags & CLIENT_BLOCKED) || c->btype != BLOCKED_MODULE)
-                    resetClient(c);
+            /* We are finally ready to execute the command. */
+            if (processCommandAndResetClient(c, callFlags) == C_ERR) {
+                /* If the client is no longer valid, we avoid exiting this
+                 * loop and trimming the client buffer later. So we return
+                 * ASAP in that case. */
+                return;
             }
-            /* freeMemoryIfNeeded may flush slave output buffers. This may
-             * result into a slave, that may be the active client, to be
-             * freed. */
-            if (serverTL->current_client == NULL) {
-                fFreed = true;
-                break;
-            }
-            serverTL->current_client = NULL;
         }
     }
 
     /* Trim to pos */
-    if (!fFreed && c->qb_pos) {
+    if (c->qb_pos) {
         sdsrange(c->querybuf,c->qb_pos,-1);
         c->qb_pos = 0;
     }
 }
 
 /* This is a wrapper for processInputBuffer that also cares about handling
- * the replication forwarding to the sub-slaves, in case the client 'c'
+ * the replication forwarding to the sub-replicas, in case the client 'c'
  * is flagged as master. Usually you want to call this instead of the
  * raw processInputBuffer(). */
 void processInputBufferAndReplicate(client *c) {
     if (!(c->flags & CLIENT_MASTER)) {
         processInputBuffer(c, CMD_CALL_FULL);
     } else {
+        /* If the client is a master we need to compute the difference
+         * between the applied offset before and after processing the buffer,
+         * to understand how much of the replication stream was actually
+         * applied to the master state: this quantity, and its corresponding
+         * part of the replication stream, will be propagated to the
+         * sub-replicas and to the replication backlog. */
         size_t prev_offset = c->reploff;
         processInputBuffer(c, CMD_CALL_FULL);
         size_t applied = c->reploff - prev_offset;
         if (applied) {
             if (!g_pserver->fActiveReplica)
             {
-                aeAcquireLock();
+                AeLocker ae;
+                ae.arm(c);
                 replicationFeedSlavesFromMasterStream(g_pserver->slaves,
                         c->pending_querybuf, applied);
-                aeReleaseLock();
             }
             sdsrange(c->pending_querybuf,applied,-1);
         }
@@ -2104,16 +2183,12 @@ void readQueryFromClient(aeEventLoop *el, int fd, void *privdata, int mask) {
             return;
         } else {
             serverLog(LL_VERBOSE, "Reading from client: %s",strerror(errno));
-            lock.unlock();
-            aelock.arm(nullptr);
-            freeClient(c);
+            freeClientAsync(c);
             return;
         }
     } else if (nread == 0) {
         serverLog(LL_VERBOSE, "Client closed connection");
-        lock.unlock();
-        aelock.arm(nullptr);
-        freeClient(c);
+        freeClientAsync(c);
         return;
     } else if (c->flags & CLIENT_MASTER) {
         /* Append the query buffer to the pending (not applied) buffer
@@ -2133,10 +2208,8 @@ void readQueryFromClient(aeEventLoop *el, int fd, void *privdata, int mask) {
         bytes = sdscatrepr(bytes,c->querybuf,64);
         serverLog(LL_WARNING,"Closing client that reached max query buffer length: %s (qbuf initial bytes: %s)", ci, bytes);
         sdsfree(ci);
-        sdsfree(bytes);
-        lock.unlock();
-        aelock.arm(nullptr);
-        freeClient(c);
+        sdsfree(bytes);       
+        freeClientAsync(c);
         return;
     }
 
@@ -2147,8 +2220,11 @@ void readQueryFromClient(aeEventLoop *el, int fd, void *privdata, int mask) {
      * corresponding part of the replication stream, will be propagated to
      * the sub-slaves and to the replication backlog. */
     processInputBufferAndReplicate(c);
-    aelock.arm(c);
-    ProcessPendingAsyncWrites();
+    if (listLength(serverTL->clients_pending_asyncwrite))
+    {
+        aelock.arm(c);
+        ProcessPendingAsyncWrites();
+    }
 }
 
 void getClientsMaxBuffers(unsigned long *longest_output_list,
@@ -2222,6 +2298,8 @@ sds catClientInfoString(sds s, client *client) {
     if (client->flags & CLIENT_PUBSUB) *p++ = 'P';
     if (client->flags & CLIENT_MULTI) *p++ = 'x';
     if (client->flags & CLIENT_BLOCKED) *p++ = 'b';
+    if (client->flags & CLIENT_TRACKING) *p++ = 't';
+    if (client->flags & CLIENT_TRACKING_BROKEN_REDIR) *p++ = 'R';
     if (client->flags & CLIENT_DIRTY_CAS) *p++ = 'd';
     if (client->flags & CLIENT_CLOSE_AFTER_REPLY) *p++ = 'c';
     if (client->flags & CLIENT_UNBLOCKED) *p++ = 'u';
@@ -2267,6 +2345,7 @@ sds getAllClientsInfoString(int type) {
     listRewind(g_pserver->clients,&li);
     while ((ln = listNext(&li)) != NULL) {
         client = reinterpret_cast<struct client*>(listNodeValue(ln));
+        std::unique_lock<decltype(client->lock)> lock(client->lock);
         if (type != -1 && getClientType(client) != type) continue;
         o = catClientInfoString(o,client);
         o = sdscatlen(o,"\n",1);
@@ -2333,6 +2412,7 @@ void clientCommand(client *c) {
 "reply (on|off|skip)    -- Control the replies sent to the current connection.",
 "setname <name>         -- Assign the name <name> to the current connection.",
 "unblock <clientid> [TIMEOUT|ERROR] -- Unblock the specified blocked client.",
+"tracking (on|off) [REDIRECT <id>] -- Enable client keys tracking for client side caching.",
 NULL
         };
         addReplyHelp(c, help);
@@ -2491,21 +2571,57 @@ NULL
         } else {
             addReply(c,shared.czero);
         }
-    } else if (!strcasecmp((const char*)ptrFromObj(c->argv[1]),"setname") && c->argc == 3) {
+    } else if (!strcasecmp(szFromObj(c->argv[1]),"setname") && c->argc == 3) {
+        /* CLIENT SETNAME */
         if (clientSetNameOrReply(c,c->argv[2]) == C_OK)
             addReply(c,shared.ok);
-    } else if (!strcasecmp((const char*)ptrFromObj(c->argv[1]),"getname") && c->argc == 2) {
+    } else if (!strcasecmp(szFromObj(c->argv[1]),"getname") && c->argc == 2) {
+        /* CLIENT GETNAME */
         if (c->name)
             addReplyBulk(c,c->name);
         else
-            addReplyNull(c);
-    } else if (!strcasecmp((const char*)ptrFromObj(c->argv[1]),"pause") && c->argc == 3) {
+            addReplyNull(c, shared.nullbulk);
+    } else if (!strcasecmp(szFromObj(c->argv[1]),"pause") && c->argc == 3) {
+        /* CLIENT PAUSE */
         long long duration;
 
-        if (getTimeoutFromObjectOrReply(c,c->argv[2],&duration,UNIT_MILLISECONDS)
-                                        != C_OK) return;
+        if (getTimeoutFromObjectOrReply(c,c->argv[2],&duration,
+                UNIT_MILLISECONDS) != C_OK) return;
         pauseClients(duration);
         addReply(c,shared.ok);
+    } else if (!strcasecmp(szFromObj(c->argv[1]),"tracking") &&
+               (c->argc == 3 || c->argc == 5))
+    {
+        /* CLIENT TRACKING (on|off) [REDIRECT <id>] */
+        long long redir = 0;
+
+        /* Parse the redirection option: we'll require the client with
+         * the specified ID to exist right now, even if it is possible
+         * it will get disconnected later. */
+        if (c->argc == 5) {
+            if (strcasecmp(szFromObj(c->argv[3]),"redirect") != 0) {
+                addReply(c,shared.syntaxerr);
+                return;
+            } else {
+                if (getLongLongFromObjectOrReply(c,c->argv[4],&redir,NULL) !=
+                    C_OK) return;
+                if (lookupClientByID(redir) == NULL) {
+                    addReplyError(c,"The client ID you want redirect to "
+                                    "does not exist");
+                    return;
+                }
+            }
+        }
+
+        if (!strcasecmp(szFromObj(c->argv[2]),"on")) {
+            enableTracking(c,redir);
+        } else if (!strcasecmp(szFromObj(c->argv[2]),"off")) {
+            disableTracking(c);
+        } else {
+            addReply(c,shared.syntaxerr);
+            return;
+        }
+        addReply(c,shared.ok);
     } else {
         addReplyErrorFormat(c, "Unknown subcommand or wrong number of arguments for '%s'. Try CLIENT HELP", (char*)ptrFromObj(c->argv[1]));
     }
@@ -2572,7 +2688,9 @@ void helloCommand(client *c) {
 
     if (!g_pserver->sentinel_mode) {
         addReplyBulkCString(c,"role");
-        addReplyBulkCString(c,listLength(g_pserver->masters) ? "replica" : "master");
+        addReplyBulkCString(c,listLength(g_pserver->masters) ? 
+            g_pserver->fActiveReplica ? "active-replica" : "replica" 
+            : "master");
     }
 
     addReplyBulkCString(c,"modules");
@@ -2670,15 +2788,8 @@ void rewriteClientCommandArgument(client *c, int i, robj *newval) {
     }
 }
 
-/* This function returns the number of bytes that Redis is virtually
+/* This function returns the number of bytes that Redis is
  * using to store the reply still not read by the client.
- * It is "virtual" since the reply output list may contain objects that
- * are shared and are not really using additional memory.
- *
- * The function returns the total sum of the length of all the objects
- * stored in the output list, plus the memory used to allocate every
- * list node. The static reply buffer is not taken into account since it
- * is allocated anyway.
  *
  * Note: this function is very fast so can be called as many time as
  * the caller wishes. The main usage of this function currently is
@@ -2799,10 +2910,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
@@ -2811,12 +2922,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);
         }
     }
 }
@@ -2900,3 +3011,4 @@ int processEventsWhileBlocked(int iel) {
     aeAcquireLock();
     return count;
 }
+

src/new.cpp

@@ -0,0 +1,34 @@
+#include <cstddef>  // std::size_t
+#include "server.h"
+#include "new.h"
+
+#ifdef SANITIZE
+void *operator new(size_t size, enum MALLOC_CLASS mclass)
+{
+    (void)mclass;
+    return ::operator new(size);
+}
+
+#else
+[[deprecated]]
+void *operator new(size_t size)
+{
+    return zmalloc(size, MALLOC_LOCAL);
+}
+
+void *operator new(size_t size, enum MALLOC_CLASS mclass) 
+{ 
+    return zmalloc(size, mclass);
+}
+
+void operator delete(void * p) noexcept
+{
+    zfree(p);
+}
+
+void operator delete(void *p, std::size_t) noexcept
+{
+    zfree(p);
+}
+
+#endif

src/new.h

@@ -1,23 +1,12 @@
 #pragma once
 #include <cstddef>  // std::size_t
 
+void *operator new(size_t size, enum MALLOC_CLASS mclass);
+
+#ifndef SANITIZE
 [[deprecated]]
-inline void *operator new(size_t size)
-{
-    return zmalloc(size, MALLOC_LOCAL);
-}
+void *operator new(size_t size);
 
-inline void *operator new(size_t size, enum MALLOC_CLASS mclass) 
-{ 
-    return zmalloc(size, mclass);
-} 
-
-inline void operator delete(void * p)
-{
-    zfree(p);
-}
-
-inline void operator delete(void *p, std::size_t)
-{
-    zfree(p);
-}
+void operator delete(void * p) noexcept;
+void operator delete(void *p, std::size_t) noexcept;
+#endif

src/object.cpp

@@ -39,11 +39,11 @@
 /* ===================== Creation and parsing of objects ==================== */
 
 robj *createObject(int type, void *ptr) {
-    robj *o = (robj*)zmalloc(sizeof(*o), MALLOC_SHARED);
+    robj *o = (robj*)zcalloc(sizeof(*o), MALLOC_SHARED);
     o->type = type;
     o->encoding = OBJ_ENCODING_RAW;
     o->m_ptr = ptr;
-    o->refcount = 1;
+    o->setrefcount(1);
     o->mvcc_tstamp = OBJ_MVCC_INVALID;
 
     /* Set the LRU to the current lruclock (minutes resolution), or
@@ -68,8 +68,9 @@ robj *createObject(int type, void *ptr) {
  *
  */
 robj *makeObjectShared(robj *o) {
-    serverAssert(o->refcount == 1);
-    o->refcount = OBJ_SHARED_REFCOUNT;
+    serverAssert(o->getrefcount(std::memory_order_relaxed) == 1);
+    serverAssert(!o->FExpires());
+    o->setrefcount(OBJ_SHARED_REFCOUNT);
     return o;
 }
 
@@ -86,12 +87,12 @@ robj *createEmbeddedStringObject(const char *ptr, size_t len) {
     size_t allocsize = sizeof(struct sdshdr8)+len+1;
     if (allocsize < sizeof(void*))
         allocsize = sizeof(void*);
-    robj *o = (robj*)zmalloc(sizeof(robj)+allocsize-sizeof(o->m_ptr), MALLOC_SHARED);
+    robj *o = (robj*)zcalloc(sizeof(robj)+allocsize-sizeof(o->m_ptr), MALLOC_SHARED);
     struct sdshdr8 *sh = (sdshdr8*)(&o->m_ptr);
 
     o->type = OBJ_STRING;
     o->encoding = OBJ_ENCODING_EMBSTR;
-    o->refcount = 1;
+    o->setrefcount(1);
     o->mvcc_tstamp = OBJ_MVCC_INVALID;
 
     if (g_pserver->maxmemory_policy & MAXMEMORY_FLAG_LFU) {
@@ -352,11 +353,14 @@ void freeStreamObject(robj_roptr o) {
 }
 
 void incrRefCount(robj_roptr o) {
-    if (o->refcount != OBJ_SHARED_REFCOUNT) o->refcount++;
+    if (o->getrefcount(std::memory_order_relaxed) != OBJ_SHARED_REFCOUNT) o->addref();
 }
 
 void decrRefCount(robj_roptr o) {
-    if (o->refcount == 1) {
+    if (o->getrefcount(std::memory_order_relaxed) == OBJ_SHARED_REFCOUNT)
+        return;
+    unsigned prev = o->release();
+    if (prev == 1) {
         switch(o->type) {
         case OBJ_STRING: freeStringObject(o); break;
         case OBJ_LIST: freeListObject(o); break;
@@ -369,8 +373,7 @@ void decrRefCount(robj_roptr o) {
         }
         zfree(o.unsafe_robjcast());
     } else {
-        if (o->refcount <= 0) serverPanic("decrRefCount against refcount <= 0");
-        if (o->refcount != OBJ_SHARED_REFCOUNT) o->refcount--;
+        if (prev <= 0) serverPanic("decrRefCount against refcount <= 0");
     }
 }
 
@@ -394,7 +397,7 @@ void decrRefCountVoid(const void *o) {
  *    decrRefCount(obj);
  */
 robj *resetRefCount(robj *obj) {
-    obj->refcount = 0;
+    obj->setrefcount(0);
     return obj;
 }
 
@@ -452,7 +455,7 @@ robj *tryObjectEncoding(robj *o) {
     /* It's not safe to encode shared objects: shared objects can be shared
      * everywhere in the "object space" of Redis and may end in places where
      * they are not handled. We handle them only as values in the keyspace. */
-     if (o->refcount > 1) return o;
+     if (o->getrefcount(std::memory_order_relaxed) > 1) return o;
 
     /* Check if we can represent this string as a long integer.
      * Note that we are sure that a string larger than 20 chars is not
@@ -624,7 +627,7 @@ int getDoubleFromObject(const robj *o, double *target) {
                 (size_t)(eptr-(char*)szFromObj(o)) != sdslen(szFromObj(o)) ||
                 (errno == ERANGE &&
                     (value == HUGE_VAL || value == -HUGE_VAL || value == 0)) ||
-                isnan(value))
+                std::isnan(value))
                 return C_ERR;
         } else if (o->encoding == OBJ_ENCODING_INT) {
             value = (long)ptrFromObj(o);
@@ -666,7 +669,7 @@ int getLongDoubleFromObject(robj *o, long double *target) {
                 (size_t)(eptr-(char*)szFromObj(o)) != sdslen(szFromObj(o)) ||
                 (errno == ERANGE &&
                     (value == HUGE_VAL || value == -HUGE_VAL || value == 0)) ||
-                isnan(value))
+                std::isnan(value))
                 return C_ERR;
         } else if (o->encoding == OBJ_ENCODING_INT) {
             value = (long)szFromObj(o);
@@ -786,7 +789,7 @@ size_t streamRadixTreeMemoryUsage(rax *rax) {
  * case of aggregated data types where only "sample_size" elements
  * are checked and averaged to estimate the total size. */
 #define OBJ_COMPUTE_SIZE_DEF_SAMPLES 5 /* Default sample size. */
-size_t objectComputeSize(robj *o, size_t sample_size) {
+size_t objectComputeSize(robj_roptr o, size_t sample_size) {
     sds ele, ele2;
     dict *d;
     dictIterator *di;
@@ -797,7 +800,7 @@ size_t objectComputeSize(robj *o, size_t sample_size) {
         if(o->encoding == OBJ_ENCODING_INT) {
             asize = sizeof(*o);
         } else if(o->encoding == OBJ_ENCODING_RAW) {
-            asize = sdsAllocSize(szFromObj(o))+sizeof(*o);
+            asize = sdsAllocSize((sds)szFromObj(o))+sizeof(*o);
         } else if(o->encoding == OBJ_ENCODING_EMBSTR) {
             asize = sdslen(szFromObj(o))+2+sizeof(*o);
         } else {
@@ -1051,21 +1054,20 @@ struct redisMemOverhead *getMemoryOverheadData(void) {
 
     for (j = 0; j < cserver.dbnum; j++) {
         redisDb *db = g_pserver->db+j;
-        long long keyscount = dictSize(db->pdict);
+        long long keyscount = db->size();
         if (keyscount==0) continue;
 
         mh->total_keys += keyscount;
         mh->db = (decltype(mh->db))zrealloc(mh->db,sizeof(mh->db[0])*(mh->num_dbs+1), MALLOC_LOCAL);
         mh->db[mh->num_dbs].dbid = j;
 
-        mem = dictSize(db->pdict) * sizeof(dictEntry) +
-              dictSlots(db->pdict) * sizeof(dictEntry*) +
-              dictSize(db->pdict) * sizeof(robj);
+        mem = db->size() * sizeof(dictEntry) +
+              db->slots() * sizeof(dictEntry*) +
+              db->size() * sizeof(robj);
         mh->db[mh->num_dbs].overhead_ht_main = mem;
         mem_total+=mem;
 
-        mem = dictSize(db->expires) * sizeof(dictEntry) +
-              dictSlots(db->expires) * sizeof(dictEntry*);
+        mem = db->setexpire()->bytes_used();
         mh->db[mh->num_dbs].overhead_ht_expires = mem;
         mem_total+=mem;
 
@@ -1244,15 +1246,12 @@ void objectSetLRUOrLFU(robj *val, long long lfu_freq, long long lru_idle,
 
 /* This is a helper function for the OBJECT command. We need to lookup keys
  * without any modification of LRU or other parameters. */
-robj *objectCommandLookup(client *c, robj *key) {
-    dictEntry *de;
-
-    if ((de = dictFind(c->db->pdict,ptrFromObj(key))) == NULL) return NULL;
-    return (robj*) dictGetVal(de);
+robj_roptr objectCommandLookup(client *c, robj *key) {
+    return c->db->find(key);
 }
 
-robj *objectCommandLookupOrReply(client *c, robj *key, robj *reply) {
-    robj *o = objectCommandLookup(c,key);
+robj_roptr objectCommandLookupOrReply(client *c, robj *key, robj *reply) {
+    robj_roptr o = objectCommandLookup(c,key);
 
     if (!o) addReply(c, reply);
     return o;
@@ -1261,7 +1260,7 @@ robj *objectCommandLookupOrReply(client *c, robj *key, robj *reply) {
 /* Object command allows to inspect the internals of an Redis Object.
  * Usage: OBJECT <refcount|encoding|idletime|freq> <key> */
 void objectCommand(client *c) {
-    robj *o;
+    robj_roptr o;
 
     if (c->argc == 2 && !strcasecmp(szFromObj(c->argv[1]),"help")) {
         const char *help[] = {
@@ -1274,15 +1273,15 @@ NULL
         addReplyHelp(c, help);
     } else if (!strcasecmp(szFromObj(c->argv[1]),"refcount") && c->argc == 3) {
         if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.null[c->resp]))
-                == NULL) return;
-        addReplyLongLong(c,o->refcount);
+                == nullptr) return;
+        addReplyLongLong(c,o->getrefcount(std::memory_order_relaxed));
     } else if (!strcasecmp(szFromObj(c->argv[1]),"encoding") && c->argc == 3) {
         if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.null[c->resp]))
-                == NULL) return;
+                == nullptr) return;
         addReplyBulkCString(c,strEncoding(o->encoding));
     } else if (!strcasecmp(szFromObj(c->argv[1]),"idletime") && c->argc == 3) {
         if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.null[c->resp]))
-                == NULL) return;
+                == nullptr) return;
         if (g_pserver->maxmemory_policy & MAXMEMORY_FLAG_LFU) {
             addReplyError(c,"An LFU maxmemory policy is selected, idle time not tracked. Please note that when switching between policies at runtime LRU and LFU data will take some time to adjust.");
             return;
@@ -1290,7 +1289,7 @@ NULL
         addReplyLongLong(c,estimateObjectIdleTime(o)/1000);
     } else if (!strcasecmp(szFromObj(c->argv[1]),"freq") && c->argc == 3) {
         if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.null[c->resp]))
-                == NULL) return;
+                == nullptr) return;
         if (!(g_pserver->maxmemory_policy & MAXMEMORY_FLAG_LFU)) {
             addReplyError(c,"An LFU maxmemory policy is not selected, access frequency not tracked. Please note that when switching between policies at runtime LRU and LFU data will take some time to adjust.");
             return;
@@ -1299,7 +1298,11 @@ NULL
          * in case of the key has not been accessed for a long time,
          * because we update the access time only
          * when the key is read or overwritten. */
-        addReplyLongLong(c,LFUDecrAndReturn(o));
+        addReplyLongLong(c,LFUDecrAndReturn(o.unsafe_robjcast()));
+    } else if (!strcasecmp(szFromObj(c->argv[1]), "lastmodified") && c->argc == 3) {
+        if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.null[c->resp]))
+                == nullptr) return;
+        addReplyLongLong(c, (g_pserver->mstime - (o->mvcc_tstamp >> MVCC_MS_SHIFT)) / 1000);
     } else {
         addReplySubcommandSyntaxError(c);
     }
@@ -1321,7 +1324,6 @@ NULL
         };
         addReplyHelp(c, help);
     } else if (!strcasecmp(szFromObj(c->argv[1]),"usage") && c->argc >= 3) {
-        dictEntry *de;
         long long samples = OBJ_COMPUTE_SIZE_DEF_SAMPLES;
         for (int j = 3; j < c->argc; j++) {
             if (!strcasecmp(szFromObj(c->argv[j]),"samples") &&
@@ -1340,12 +1342,14 @@ NULL
                 return;
             }
         }
-        if ((de = dictFind(c->db->pdict,ptrFromObj(c->argv[2]))) == NULL) {
-            addReplyNull(c);
+
+        auto itr = c->db->find(c->argv[2]);
+        if (itr == nullptr) {
+            addReplyNull(c, shared.nullbulk);
             return;
         }
-        size_t usage = objectComputeSize((robj*)dictGetVal(de),samples);
-        usage += sdsAllocSize((sds)dictGetKey(de));
+        size_t usage = objectComputeSize(itr.val(),samples);
+        usage += sdsAllocSize(itr.key());
         usage += sizeof(dictEntry);
         addReplyLongLong(c,usage);
     } else if (!strcasecmp(szFromObj(c->argv[1]),"stats") && c->argc == 2) {
@@ -1474,3 +1478,125 @@ NULL
         addReplyErrorFormat(c, "Unknown subcommand or wrong number of arguments for '%s'. Try MEMORY HELP", (char*)ptrFromObj(c->argv[1]));
     }
 }
+
+void redisObject::SetFExpires(bool fExpire)
+{
+    serverAssert(this->refcount != OBJ_SHARED_REFCOUNT);
+    if (fExpire)
+        this->refcount.fetch_or(1U << 31, std::memory_order_relaxed);
+    else
+        this->refcount.fetch_and(~(1U << 31), std::memory_order_relaxed);
+}
+
+void redisObject::setrefcount(unsigned ref)
+{ 
+    serverAssert(!FExpires());
+    refcount.store(ref, std::memory_order_relaxed); 
+}
+
+sds serializeStoredStringObject(sds str, robj_roptr o)
+{
+    str = sdscatlen(str, &(*o), sizeof(robj));
+    switch (o->encoding)
+    {
+    case OBJ_ENCODING_RAW:
+        str = sdscatsds(str, (sds)szFromObj(o));
+        break;
+
+    case OBJ_ENCODING_INT:
+        break;  //nop
+
+    case OBJ_ENCODING_EMBSTR:
+        size_t cb = zmalloc_size(o.unsafe_robjcast());
+        if (cb > sizeof(robj))
+        {
+            str = sdscatlen(str, o.unsafe_robjcast() + 1, cb - sizeof(robj));
+        }
+        break;
+    }
+        
+    return str;
+}
+
+robj *deserializeStoredStringObject(const char *data, size_t cb)
+{
+    const robj *oT = (const robj*)data;
+    robj *newObject = nullptr;
+    switch (oT->encoding)
+    {
+    case OBJ_ENCODING_INT:
+        serverAssert(cb == sizeof(robj));
+        [[fallthrough]];
+    case OBJ_ENCODING_EMBSTR:
+        newObject = (robj*)zmalloc(cb, MALLOC_LOCAL);
+        memcpy(newObject, data, cb);
+        newObject->setrefcount(1);
+        return newObject;
+
+    case OBJ_ENCODING_RAW:
+        newObject = (robj*)zmalloc(sizeof(robj), MALLOC_SHARED);
+        memcpy(newObject, data, sizeof(robj));
+        newObject->m_ptr = sdsnewlen(SDS_NOINIT,cb-sizeof(robj));
+        memcpy(newObject->m_ptr, data+sizeof(robj), cb-sizeof(robj));
+        newObject->setrefcount(1);
+        return newObject;
+    }
+    serverPanic("Unknown string object encoding from storage");
+    return nullptr;
+}
+
+robj *deserializeStoredObject(const void *data, size_t cb)
+{
+    switch (((char*)data)[0])
+    {
+        case RDB_TYPE_STRING:
+            return deserializeStoredStringObject(((char*)data)+1, cb-1);
+
+        default:
+            rio payload;
+            int type;
+            robj *obj;
+            rioInitWithConstBuffer(&payload,data,cb);
+            if (((type = rdbLoadObjectType(&payload)) == -1) ||
+                ((obj = rdbLoadObject(type,&payload,nullptr, OBJ_MVCC_INVALID)) == nullptr))
+            {
+                serverPanic("Bad data format");
+            }
+            if (rdbLoadType(&payload) == RDB_OPCODE_AUX)
+            {
+                robj *auxkey, *auxval;
+                if ((auxkey = rdbLoadStringObject(&payload)) == NULL) goto eoferr;
+                if ((auxval = rdbLoadStringObject(&payload)) == NULL) {
+                    decrRefCount(auxkey);
+                    goto eoferr;
+                }
+                if (strcasecmp(szFromObj(auxkey), "mvcc-tstamp") == 0) {
+                    obj->mvcc_tstamp = strtoull(szFromObj(auxval), nullptr, 10);
+                }
+                decrRefCount(auxkey);
+                decrRefCount(auxval);
+            }
+        eoferr:
+            return obj;
+    }
+    serverPanic("Unknown object type loading from storage");
+}
+
+sds serializeStoredObject(robj_roptr o)
+{
+    switch (o->type)
+    {
+        case OBJ_STRING:
+        {
+            sds sdsT = sdsnewlen(nullptr, 1);
+            sdsT[0] = RDB_TYPE_STRING;
+            return serializeStoredStringObject(sdsT, o);
+        }
+            
+        default:
+            rio rdb;
+            createDumpPayload(&rdb,o,nullptr);
+            return (sds)rdb.io.buffer.ptr;
+    }
+    serverPanic("Attempting to store unknown object type");
+}

src/pubsub.cpp

@@ -84,7 +84,7 @@ void addReplyPubsubUnsubscribed(client *c, robj *channel) {
     if (channel)
         addReplyBulk(c,channel);
     else
-        addReplyNull(c);
+        addReplyNull(c, shared.nullbulk);
     addReplyLongLong(c,clientSubscriptionsCount(c));
 }
 
@@ -112,7 +112,7 @@ void addReplyPubsubPatUnsubscribed(client *c, robj *pattern) {
     if (pattern)
         addReplyBulk(c,pattern);
     else
-        addReplyNull(c);
+        addReplyNull(c, shared.nullbulk);
     addReplyLongLong(c,clientSubscriptionsCount(c));
 }
 
@@ -143,6 +143,8 @@ int clientSubscriptionsCount(client *c) {
 /* Subscribe a client to a channel. Returns 1 if the operation succeeded, or
  * 0 if the client was already subscribed to that channel. */
 int pubsubSubscribeChannel(client *c, robj *channel) {
+    serverAssert(GlobalLocksAcquired());
+    serverAssert(c->lock.fOwnLock());
     dictEntry *de;
     list *clients = NULL;
     int retval = 0;
@@ -202,6 +204,7 @@ int pubsubUnsubscribeChannel(client *c, robj *channel, int notify) {
 
 /* Subscribe a client to a pattern. Returns 1 if the operation succeeded, or 0 if the client was already subscribed to that pattern. */
 int pubsubSubscribePattern(client *c, robj *pattern) {
+    serverAssert(GlobalLocksAcquired());
     int retval = 0;
 
     if (listSearchKey(c->pubsub_patterns,pattern) == NULL) {
@@ -244,6 +247,7 @@ int pubsubUnsubscribePattern(client *c, robj *pattern, int notify) {
 /* Unsubscribe from all the channels. Return the number of channels the
  * client was subscribed to. */
 int pubsubUnsubscribeAllChannels(client *c, int notify) {
+    serverAssert(GlobalLocksAcquired());
     dictIterator *di = dictGetSafeIterator(c->pubsub_channels);
     dictEntry *de;
     int count = 0;
@@ -262,6 +266,7 @@ int pubsubUnsubscribeAllChannels(client *c, int notify) {
 /* Unsubscribe from all the patterns. Return the number of patterns the
  * client was subscribed from. */
 int pubsubUnsubscribeAllPatterns(client *c, int notify) {
+    serverAssert(GlobalLocksAcquired());
     listNode *ln;
     listIter li;
     int count = 0;
@@ -278,6 +283,7 @@ int pubsubUnsubscribeAllPatterns(client *c, int notify) {
 
 /* Publish a message */
 int pubsubPublishMessage(robj *channel, robj *message) {
+    serverAssert(GlobalLocksAcquired());
     int receivers = 0;
     dictEntry *de;
     listNode *ln;
@@ -293,6 +299,8 @@ int pubsubPublishMessage(robj *channel, robj *message) {
         listRewind(list,&li);
         while ((ln = listNext(&li)) != NULL) {
             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);
             addReplyPubsubMessage(c,channel,message);
             fastlock_unlock(&c->lock);
@@ -311,6 +319,8 @@ int pubsubPublishMessage(robj *channel, robj *message) {
                                 (char*)ptrFromObj(channel),
                                 sdslen(szFromObj(channel)),0))
             {
+                if (pat->pclient->flags & CLIENT_CLOSE_ASAP)
+                    continue;
                 fastlock_lock(&pat->pclient->lock);
                 addReplyPubsubPatMessage(pat->pclient,
                     pat->pattern,channel,message);

src/rax.c

@@ -705,7 +705,7 @@ int raxGenericInsert(rax *rax, unsigned char *s, size_t len, void *data, void **
             nodesize = sizeof(raxNode)+trimmedlen+raxPadding(trimmedlen)+
                        sizeof(raxNode*);
             if (h->iskey && !h->isnull) nodesize += sizeof(void*);
-            trimmed = rax_malloc(nodesize);
+            trimmed = zcalloc(nodesize, MALLOC_LOCAL);//rax_malloc(nodesize);
         }
 
         if (postfixlen) {

src/rdb-s3.cpp

@@ -6,7 +6,7 @@ extern "C" {
 #include <sys/wait.h>
 
 /* Save the DB on disk. Return C_ERR on error, C_OK on success. */
-int rdbSaveS3(char *s3bucket, rdbSaveInfo *rsi)
+int rdbSaveS3(char *s3bucket, redisDbPersistentData **rgpdb, rdbSaveInfo *rsi)
 {
     int status = EXIT_FAILURE;
     int fd[2];
@@ -33,12 +33,19 @@ int rdbSaveS3(char *s3bucket, rdbSaveInfo *rsi)
     else
     {
         close(fd[0]);
-        if (rdbSaveFd(fd[1], rsi) != C_OK)
+        FILE *fp = fdopen(fd[1], "w");
+        if (fp == NULL)
         {
-            close(fd[1]);
+            close (fd[1]);
             return C_ERR;
         }
-        close(fd[1]);
+
+        if (rdbSaveFp(fp, rgpdb, rsi) != C_OK)
+        {
+            fclose(fp);
+            return C_ERR;
+        }
+        fclose(fp);
         waitpid(pid, &status, 0);
     }
     
@@ -59,7 +66,7 @@ int rdbLoadS3Core(int fd, rdbSaveInfo *rsi)
 
     if ((fp = fdopen(fd, "rb")) == NULL) return C_ERR;
     startLoading(fp);
-    rioInitWithFile(&rdb,fileno(fp));
+    rioInitWithFile(&rdb,fp);
     retval = rdbLoadRio(&rdb,rsi,0);
     fclose(fp);
     stopLoading();

src/rdb.h

@@ -136,13 +136,14 @@ 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);
-int rdbSave(rdbSaveInfo *rsi);
-int rdbSaveFile(char *filename, rdbSaveInfo *rsi);
-int rdbSaveFd(int fd, rdbSaveInfo *rsi);
-int rdbSaveS3(char *path, rdbSaveInfo *rsi);
+void rdbRemoveTempFile(int childpid);
+int rdbSave(redisDbPersistentData **rgpdb, rdbSaveInfo *rsi);
+int rdbSaveFile(char *filename, redisDbPersistentData **rgpdb, rdbSaveInfo *rsi);
+int rdbSaveFp(FILE *pf, redisDbPersistentData **rgpdb, rdbSaveInfo *rsi);
+int rdbSaveS3(char *path, redisDbPersistentData **rgpdb, rdbSaveInfo *rsi);
 int rdbLoadS3(char *path, rdbSaveInfo *rsi);
 ssize_t rdbSaveObject(rio *rdb, robj_roptr o, robj *key);
 size_t rdbSavedObjectLen(robj *o);

src/redis-benchmark.cpp

@@ -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;
@@ -258,6 +258,19 @@ static redisConfig *getRedisConfig(const char *ip, int port,
         else fprintf(stderr,"%s: %s\n",hostsocket,err);
         goto fail;
     }
+
+    if(config.auth){
+        void *authReply = NULL;
+        redisAppendCommand(c, "AUTH %s", config.auth);
+        if (REDIS_OK != redisGetReply(c, &authReply)) goto fail;
+        if (reply) freeReplyObject(reply);
+        reply = ((redisReply *) authReply);
+        if (reply->type == REDIS_REPLY_ERROR) {
+            fprintf(stderr, "ERROR: %s\n", reply->str);
+            goto fail;
+        }
+    }
+
     redisAppendCommand(c, "CONFIG GET %s", "save");
     redisAppendCommand(c, "CONFIG GET %s", "appendonly");
     
@@ -1196,7 +1209,7 @@ static int fetchClusterSlotsConfiguration(client c) {
     assert(reply->type == REDIS_REPLY_ARRAY);
     for (i = 0; i < reply->elements; i++) {
         redisReply *r = reply->element[i];
-        assert(r->type = REDIS_REPLY_ARRAY);
+        assert(r->type == REDIS_REPLY_ARRAY);
         assert(r->elements >= 3);
         int from, to, slot;
         from = r->element[0]->integer;
@@ -1298,7 +1311,7 @@ int parseOptions(int argc, const char **argv) {
                 if (*p < '0' || *p > '9') goto invalid;
             }
             config.randomkeys = 1;
-            config.randomkeys_keyspacelen = atoi(argv[++i]);
+            config.randomkeys_keyspacelen = atoi(next);
             if (config.randomkeys_keyspacelen < 0)
                 config.randomkeys_keyspacelen = 0;
         } else if (!strcmp(argv[i],"-q")) {
@@ -1533,7 +1546,10 @@ int main(int argc, const char **argv) {
             if (node->name) printf("%s ", node->name);
             printf("%s:%d\n", node->ip, node->port);
             node->redis_config = getRedisConfig(node->ip, node->port, NULL);
-            if (node->redis_config == NULL) exit(1);
+            if (node->redis_config == NULL) {
+                fprintf(stderr, "WARN: could not fetch node CONFIG %s:%d\n",
+                        node->ip, node->port);
+            }
         }
         printf("\n");
         /* Automatically set thread number to node count if not specified
@@ -1543,7 +1559,8 @@ int main(int argc, const char **argv) {
     } else {
         config.redis_config =
             getRedisConfig(config.hostip, config.hostport, config.hostsocket);
-        if (config.redis_config == NULL) exit(1);
+        if (config.redis_config == NULL)
+            fprintf(stderr, "WARN: could not fetch server CONFIG\n");
     }
 
     if (config.num_threads > 0) {

src/redis-check-aof.cpp

@@ -37,7 +37,7 @@
     snprintf(error, sizeof(error), "0x%16llx: %s", (long long)epos, __buf); \
 }
 
-static char error[1024];
+static char error[1044];
 static off_t epos;
 
 int consumeNewline(char *buf) {

src/redis-check-rdb.cpp

@@ -186,7 +186,7 @@ int redis_check_rdb(const char *rdbfilename, FILE *fp) {
     int closefile = (fp == NULL);
     if (fp == NULL && (fp = fopen(rdbfilename,"r")) == NULL) return 1;
 
-    rioInitWithFile(&rdb,fileno(fp));
+    rioInitWithFile(&rdb,fp);
     rdbstate.rio = &rdb;
     rdb.update_cksum = rdbLoadProgressCallback;
     if (rioRead(&rdb,buf,9) == 0) goto eoferr;

src/redis-cli-cpphelper.cpp

@@ -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
  *

src/redis-cli.c

@@ -45,6 +45,8 @@
 #include <fcntl.h>
 #include <limits.h>
 #include <math.h>
+#include <sys/types.h>
+#include <pwd.h>
 
 #include <hiredis.h>
 #include <sds.h> /* use sds.h from hiredis, so that only one set of sds functions will be present in the binary */
@@ -6532,6 +6534,116 @@ static void intrinsicLatencyMode(void) {
     }
 }
 
+/*------------------------------------------------------------------------------
+ * Message of the day
+ *--------------------------------------------------------------------------- */
+#ifdef MOTD
+#include <curl/curl.h> 
+
+static const char *szMotdCachePath()
+{
+    static sds sdsMotdCachePath = NULL;
+    if (sdsMotdCachePath != NULL)
+        return sdsMotdCachePath;
+
+    struct passwd *pw = getpwuid(getuid());
+    if (pw == NULL)
+        return "";
+    const char *homedir = pw->pw_dir;
+    sdsMotdCachePath = sdsnew(homedir);
+    sdsMotdCachePath = sdscat(sdsMotdCachePath, "/.keydb-cli-motd");
+    return sdsMotdCachePath;
+}
+static size_t motd_write_callback(void *ptr, size_t size, size_t nmemb, sds *str)
+{
+    *str = sdscatlen(*str, ptr, size*nmemb);
+    return (size*nmemb);
+}
+
+static char *fetchMOTDFromCache()
+{
+    struct stat attrib;
+    if (stat(szMotdCachePath(), &attrib) != 0)
+        return NULL;
+    time_t t = attrib.st_mtim.tv_sec;
+    time_t now = time(NULL);
+    if ((now - t) < 14400)
+    {
+        // If our cache was updated no more than 4 hours ago use it instead of fetching the MOTD
+        FILE *pf = fopen(szMotdCachePath(), "rb");
+        if (pf == NULL)
+            return NULL;
+        fseek(pf, 0L, SEEK_END);
+        long cb = ftell(pf);
+        fseek(pf, 0L, SEEK_SET);    // rewind
+        sds str = sdsnewlen(NULL, cb);
+        size_t cbRead = fread(str, 1, cb, pf);
+        fclose(pf);
+        if ((long)cbRead != cb)
+        {
+            sdsfree(str);
+            return NULL;
+        }
+        return str;
+    }
+    return NULL;
+}
+
+static void setMOTDCache(const char *sz)
+{
+    FILE *pf = fopen(szMotdCachePath(), "wb");
+    size_t celem = fwrite(sz, strlen(sz), 1, pf);
+    (void)celem;    // best effort
+    fclose(pf);
+}
+
+static char *fetchMOTD()
+{
+    sds str;
+    CURL *curl;
+    CURLcode res;
+
+    /* First try and get the string from the cache */
+    str = fetchMOTDFromCache();
+    if (str != NULL)
+        return str;
+
+    str = sdsnew("");
+    curl = curl_easy_init();
+    if(curl) {
+        curl_easy_setopt(curl, CURLOPT_URL, "http://api.keydb.dev/motd/motd.txt");
+        curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L); // follow redirects
+        curl_easy_setopt(curl, CURLOPT_TIMEOUT, 2); // take no more than two seconds
+        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, motd_write_callback);
+        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &str);
+
+        /* Perform the request, res will get the return code */ 
+        res = curl_easy_perform(curl);
+        /* Check for errors */ 
+        if(res != CURLE_OK)
+        {
+            sdsfree(str);
+            str = NULL;
+        }
+
+        /* always cleanup */ 
+        curl_easy_cleanup(curl);
+
+        if (str != NULL)
+            setMOTDCache(str);
+    }
+    return str;
+}
+
+#else
+
+static char *fetchMOTD()
+{
+    return NULL;
+}
+
+#endif
+
 /*------------------------------------------------------------------------------
  * Program main()
  *--------------------------------------------------------------------------- */
@@ -6700,6 +6812,15 @@ int main(int argc, char **argv) {
 
     /* Start interactive mode when no command is provided */
     if (argc == 0 && !config.eval) {
+        /* Show the message of the day if we are interactive */
+        if (config.output == OUTPUT_STANDARD) {
+            char *szMotd = fetchMOTD();
+            if (szMotd != NULL) {
+                printf("Message of the day:\n  %s\n", szMotd);
+                sdsfree(szMotd);
+            }
+        }
+
         /* Ignore SIGPIPE in interactive mode to force a reconnect */
         signal(SIGPIPE, SIG_IGN);
 
@@ -6711,6 +6832,7 @@ int main(int argc, char **argv) {
 
     /* Otherwise, we have some arguments to execute */
     if (cliConnect(0) != REDIS_OK) exit(1);
+
     if (config.eval) {
         return evalMode(argc,argv);
     } else {

src/redis-cli.h

@@ -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;
@@ -276,4 +276,5 @@ redisReply *sendScan(unsigned long long *it);
 
 #ifdef __cplusplus
 }
-#endif
+#endif
+

src/redismodule.h

@@ -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)
@@ -91,6 +91,8 @@ extern "C" {
 #define REDISMODULE_CTX_FLAGS_OOM_WARNING (1<<11)
 /* The command was sent over the replication link. */
 #define REDISMODULE_CTX_FLAGS_REPLICATED (1<<12)
+/* Redis is currently loading either from AOF or RDB. */
+#define REDISMODULE_CTX_FLAGS_LOADING (1<<13)
 
 
 #define REDISMODULE_NOTIFY_GENERIC (1<<2)     /* g */
@@ -230,6 +232,7 @@ int REDISMODULE_API_FUNC(RedisModule_ReplyWithSimpleString)(RedisModuleCtx *ctx,
 int REDISMODULE_API_FUNC(RedisModule_ReplyWithArray)(RedisModuleCtx *ctx, long len);
 void REDISMODULE_API_FUNC(RedisModule_ReplySetArrayLength)(RedisModuleCtx *ctx, long len);
 int REDISMODULE_API_FUNC(RedisModule_ReplyWithStringBuffer)(RedisModuleCtx *ctx, const char *buf, size_t len);
+int REDISMODULE_API_FUNC(RedisModule_ReplyWithCString)(RedisModuleCtx *ctx, const char *buf);
 int REDISMODULE_API_FUNC(RedisModule_ReplyWithString)(RedisModuleCtx *ctx, RedisModuleString *str);
 int REDISMODULE_API_FUNC(RedisModule_ReplyWithNull)(RedisModuleCtx *ctx);
 int REDISMODULE_API_FUNC(RedisModule_ReplyWithDouble)(RedisModuleCtx *ctx, double d);
@@ -380,6 +383,7 @@ static int RedisModule_Init(RedisModuleCtx *ctx, const char *name, int ver, int
     REDISMODULE_GET_API(ReplyWithArray);
     REDISMODULE_GET_API(ReplySetArrayLength);
     REDISMODULE_GET_API(ReplyWithStringBuffer);
+    REDISMODULE_GET_API(ReplyWithCString);
     REDISMODULE_GET_API(ReplyWithString);
     REDISMODULE_GET_API(ReplyWithNull);
     REDISMODULE_GET_API(ReplyWithCallReply);

src/rio.cpp

@@ -73,6 +73,14 @@ static size_t rioBufferRead(rio *r, void *buf, size_t len) {
     return 1;
 }
 
+static size_t rioConstBufferRead(rio *r, void *buf, size_t len) {
+     if (r->io.buffer.len-r->io.buffer.pos < (off_t)len)
+        return 0; /* not enough buffer to return len bytes. */
+    memcpy(buf,r->io.buffer.ptr+r->io.buffer.pos,len);
+    r->io.buffer.pos += len;
+    return 1;
+}
+
 /* Returns read/write position in buffer. */
 static off_t rioBufferTell(rio *r) {
     return r->io.buffer.pos;
@@ -97,25 +105,46 @@ static const rio rioBufferIO = {
     { { NULL, 0 } } /* union for io-specific vars */
 };
 
+static const rio rioConstBufferIO = {
+    rioConstBufferRead,
+    nullptr,
+    rioBufferTell,
+    rioBufferFlush,
+    NULL,           /* update_checksum */
+    0,              /* current checksum */
+    0,              /* bytes read or written */
+    0,              /* read/write chunk size */
+    { { NULL, 0 } } /* union for io-specific vars */
+};
+
 void rioInitWithBuffer(rio *r, sds s) {
     *r = rioBufferIO;
     r->io.buffer.ptr = s;
     r->io.buffer.pos = 0;
 }
 
+void rioInitWithConstBuffer(rio *r, const void *buf, size_t cb)
+{
+    *r = rioConstBufferIO;
+    r->io.buffer.ptr = (sds)buf;
+    r->io.buffer.pos = 0;
+    r->io.buffer.len = cb;
+}
+
 /* --------------------- Stdio file pointer implementation ------------------- */
 
 /* Returns 1 or 0 for success/failure. */
 static size_t rioFileWrite(rio *r, const void *buf, size_t len) {
     size_t retval;
 
-    retval = write(r->io.file.fd,buf,len);
+    retval = fwrite(buf,len,1,r->io.file.fp);
     r->io.file.buffered += len;
 
     if (r->io.file.autosync &&
         r->io.file.buffered >= r->io.file.autosync)
     {
-        redis_fsync(r->io.file.fd);
+        fflush(r->io.file.fp);
+        redis_fsync(fileno(r->io.file.fp));
         r->io.file.buffered = 0;
     }
     return retval;
@@ -123,18 +152,18 @@ static size_t rioFileWrite(rio *r, const void *buf, size_t len) {
 
 /* Returns 1 or 0 for success/failure. */
 static size_t rioFileRead(rio *r, void *buf, size_t len) {
-    return read(r->io.file.fd,buf,len);
+    return fread(buf,len,1,r->io.file.fp);
 }
 
 /* Returns read/write position in file. */
 static off_t rioFileTell(rio *r) {
-    return lseek(r->io.file.fd, 0, SEEK_CUR);
+    return ftello(r->io.file.fp);
 }
 
 /* Flushes any buffer to target device if applicable. Returns 1 on success
  * and 0 on failures. */
 static int rioFileFlush(rio *r) {
-    return (fsync(r->io.file.fd) == 0) ? 1 : 0;
+    return (fflush(r->io.file.fp) == 0) ? 1 : 0;
 }
 
 static const rio rioFileIO = {
@@ -149,9 +178,9 @@ static const rio rioFileIO = {
     { { NULL, 0 } } /* union for io-specific vars */
 };
 
-void rioInitWithFile(rio *r, int fd) {
+void rioInitWithFile(rio *r, FILE *fp) {
     *r = rioFileIO;
-    r->io.file.fd = fd;
+    r->io.file.fp = fp;
     r->io.file.buffered = 0;
     r->io.file.autosync = 0;
 }

src/rio.h

@@ -70,10 +70,11 @@ struct _rio {
         struct {
             sds ptr;
             off_t pos;
+            off_t len;  // For const buffers only
         } buffer;
         /* Stdio file pointer target. */
         struct {
-            int fd;
+            FILE *fp;
             off_t buffered; /* Bytes written since last fsync. */
             off_t autosync; /* fsync after 'autosync' bytes written. */
         } file;
@@ -128,8 +129,9 @@ static inline int rioFlush(rio *r) {
     return r->flush(r);
 }
 
-void rioInitWithFile(rio *r, int fd);
+void rioInitWithFile(rio *r, FILE *fp);
 void rioInitWithBuffer(rio *r, sds s);
+void rioInitWithConstBuffer(rio *r, const void *rgch, size_t cch);
 void rioInitWithFdset(rio *r, int *fds, int numfds);
 
 void rioFreeFdset(rio *r);

src/scripting.cpp

@@ -371,7 +371,7 @@ int luaRedisGenericCommand(lua_State *lua, int raise_error) {
     int acl_retval = 0;
     int call_flags = CMD_CALL_SLOWLOG | CMD_CALL_STATS;
     struct redisCommand *cmd;
-    client *c = g_pserver->lua_client;
+    client *c = serverTL->lua_client;
     sds reply;
     
     // Ensure our client is on the right thread
@@ -665,7 +665,7 @@ cleanup:
          * The object must be small, SDS-encoded, and with refcount = 1
          * (we must be the only owner) for us to cache it. */
         if (j < LUA_CMD_OBJCACHE_SIZE &&
-            o->refcount == 1 &&
+            o->getrefcount(std::memory_order_relaxed) == 1 &&
             (o->encoding == OBJ_ENCODING_RAW ||
              o->encoding == OBJ_ENCODING_EMBSTR) &&
             sdslen((sds)ptrFromObj(o)) <= LUA_CMD_OBJCACHE_MAX_LEN)
@@ -966,8 +966,11 @@ void scriptingInit(int setup) {
     lua_State *lua = lua_open();
 
     if (setup) {
-        g_pserver->lua_client = NULL;
-        g_pserver->lua_caller = NULL;
+        for (int iel = 0; iel < cserver.cthreads; ++iel)
+        {
+            g_pserver->rgthreadvar[iel].lua_client = createClient(-1, iel);
+            g_pserver->rgthreadvar[iel].lua_client->flags |= CLIENT_LUA;
+        }
         g_pserver->lua_timedout = 0;
         ldbInit();
     }
@@ -1117,15 +1120,6 @@ void scriptingInit(int setup) {
         lua_pcall(lua,0,0,0);
     }
 
-    /* Create the (non connected) client that we use to execute Redis commands
-     * inside the Lua interpreter.
-     * Note: there is no need to create it again when this function is called
-     * by scriptingReset(). */
-    if (g_pserver->lua_client == NULL) {
-        g_pserver->lua_client = createClient(-1, IDX_EVENT_LOOP_MAIN);
-        g_pserver->lua_client->flags |= CLIENT_LUA;
-    }
-
     /* Lua beginners often don't use "local", this is likely to introduce
      * subtle bugs in their code. To prevent problems we protect accesses
      * to global variables. */
@@ -1272,7 +1266,7 @@ sds luaCreateFunction(client *c, lua_State *lua, robj *body) {
      * so that we can replicate / write in the AOF all the
      * EVALSHA commands as EVAL using the original script. */
     int retval = dictAdd(g_pserver->lua_scripts,sha,body);
-    serverAssertWithInfo(c ? c : g_pserver->lua_client,NULL,retval == DICT_OK);
+    serverAssertWithInfo(c ? c : serverTL->lua_client,NULL,retval == DICT_OK);
     g_pserver->lua_scripts_mem += sdsZmallocSize(sha) + getStringObjectSdsUsedMemory(body);
     incrRefCount(body);
     return sha;
@@ -1393,7 +1387,7 @@ void evalGenericCommand(client *c, int evalsha) {
     luaSetGlobalArray(lua,"ARGV",c->argv+3+numkeys,c->argc-3-numkeys);
 
     /* Select the right DB in the context of the Lua client */
-    selectDb(g_pserver->lua_client,c->db->id);
+    selectDb(serverTL->lua_client,c->db->id);
 
     /* Set a hook in order to be able to stop the script execution if it
      * is running for too much time.
@@ -1485,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) {

src/semiorderedset.h

@@ -0,0 +1,345 @@
+#pragma once
+#include <assert.h>
+#include "compactvector.h"
+
+/****************************************
+ * semiorderedset.h:
+ * 
+ * The ordered set is a hash set that maintains semi-ordering, that is you can iterate in sub-linear time over the set comparing a value.
+ * It has a few other useful properties vs the traditional set:
+ *      1. The key need not be the underlying type, the only requirement is the value type is castable to the key
+ *      2. The key need not have total ordering.  The set will iterate until it finds an exact match with operator== on the value
+ *          This provides additional flexibility on insert allowing us to optimize this case.
+ * 
+ */
+
+extern uint64_t dictGenHashFunction(const void *key, int len);
+
+template<typename T, typename T_KEY = T, bool MEMMOVE_SAFE = false>
+class semiorderedset
+{
+    friend struct setiter;
+    std::vector<compactvector<T, MEMMOVE_SAFE>> m_data;
+    size_t celem = 0;
+    static const size_t bits_min = 8;
+    size_t bits = bits_min;
+    size_t idxRehash = (1ULL << bits_min); 
+    bool fPauseRehash = false;
+
+    constexpr size_t targetElementsPerBucket()
+    {
+        // Aim for roughly 4 cache lines per bucket (determined by imperical testing)
+        //  lower values are faster but use more memory
+        return std::max((64/sizeof(T))*8, (size_t)2);
+    }
+
+public:
+    semiorderedset()
+    {
+        m_data.resize((1ULL << bits));
+    }
+
+    struct setiter
+    {
+        semiorderedset *set;
+        size_t idxPrimary = 0;
+        size_t idxSecondary = 0;
+
+        setiter(semiorderedset *set)
+        {
+            this->set = set;
+        }
+
+        bool operator==(const setiter &other) const
+        {
+            return (idxPrimary == other.idxPrimary) && (idxSecondary == other.idxSecondary);
+        }
+
+        bool operator!=(const setiter &other) const { return !operator==(other); }
+
+        inline T &operator*() { return set->m_data[idxPrimary][idxSecondary]; }
+        inline const T &operator*() const { return set->m_data[idxPrimary][idxSecondary]; }
+
+        inline T *operator->() { return &set->m_data[idxPrimary][idxSecondary]; }
+        inline const T *operator->() const { return &set->m_data[idxPrimary][idxSecondary]; }
+    };
+
+    setiter find(const T_KEY &key)
+    {
+        RehashStep();
+        setiter itr(this);
+        itr.idxPrimary = idxFromObj(key);
+ 
+        for (int hashset = 0; hashset < 2; ++hashset)   // rehashing may only be 1 resize behind, so we check up to two slots
+        {
+            auto &vecBucket = m_data[itr.idxPrimary];
+
+            auto itrFind = std::find(vecBucket.begin(), vecBucket.end(), key);
+            if (itrFind != vecBucket.end())
+            {
+                itr.idxSecondary =  itrFind - vecBucket.begin();
+                return itr;
+            }
+
+            // See if we have to check the older slot
+            size_t mask = (hashmask() >> 1);
+            if (itr.idxPrimary == (itr.idxPrimary & mask))
+                break;  // same bucket we just checked
+            itr.idxPrimary &= mask;
+            if (FRehashedRow(itr.idxPrimary))
+                break;
+        }
+        
+        return end();
+    }
+
+    setiter end() const
+    {
+        setiter itr(const_cast<semiorderedset<T,T_KEY,MEMMOVE_SAFE>*>(this));
+        itr.idxPrimary = m_data.size();
+        return itr;
+    }
+
+    void insert(T &e, bool fRehash = false)
+    {
+        if (!fRehash)
+            RehashStep();
+
+        auto idx = idxFromObj(static_cast<T_KEY>(e));
+        if (!fRehash)
+            ++celem;
+        
+        typename compactvector<T, MEMMOVE_SAFE>::iterator itrInsert;
+        if (!m_data[idx].empty() && !(e < m_data[idx].back()))
+            itrInsert = m_data[idx].end();
+        else
+            itrInsert = std::upper_bound(m_data[idx].begin(), m_data[idx].end(), e);
+        itrInsert = m_data[idx].insert(itrInsert, e);
+
+        if (celem > ((1ULL << bits)*targetElementsPerBucket()))
+            grow();
+    }
+
+    // enumeration starting from the 'itrStart'th key.  Note that the iter is a hint, and need no be valid anymore
+    template<typename T_VISITOR, typename T_MAX>
+    setiter enumerate(const setiter &itrStart, const T_MAX &max, T_VISITOR fn, long long *pccheck)
+    {
+        setiter itr(itrStart);
+
+        if (itrStart.set == this)   // really if this case isn't true its probably a bug
+            itr = itrStart;         // but why crash the program when we can easily fix this?
+        
+        fPauseRehash = true;
+        if (itr.idxPrimary >= m_data.size())
+            itr.idxPrimary = 0;
+        
+        for (size_t ibucket = 0; ibucket < m_data.size(); ++ibucket)
+        {
+            if (!enumerate_bucket(itr, max, fn, pccheck))
+                break;
+            itr.idxSecondary = 0;
+
+            ++itr.idxPrimary;
+            if (itr.idxPrimary >= m_data.size())
+                itr.idxPrimary = 0;
+        }
+        fPauseRehash = false;
+        return itr;
+    }
+
+    // This will "randomly" visit nodes biased towards lower values first
+    template<typename T_VISITOR>
+    size_t random_visit(T_VISITOR &fn)
+    {
+        bool fSawAny = true;
+        size_t visited = 0;
+        size_t basePrimary = rand() % m_data.size();
+        for (size_t idxSecondary = 0; fSawAny; ++idxSecondary)
+        {
+            fSawAny = false;
+            for (size_t idxPrimaryCount = 0; idxPrimaryCount < m_data.size(); ++idxPrimaryCount)
+            {
+                size_t idxPrimary = (basePrimary + idxPrimaryCount) % m_data.size();
+                if (idxSecondary < m_data[idxPrimary].size())
+                {
+                    ++visited;
+                    fSawAny = true;
+                    if (!fn(m_data[idxPrimary][idxSecondary]))
+                        return visited;
+                }
+            }
+        }
+        return visited;
+    }
+
+    const T& random_value() const
+    {
+        assert(!empty());
+        for (;;)
+        {
+            size_t idxPrimary = rand() % m_data.size();
+            if (m_data[idxPrimary].empty())
+                continue;
+
+            return m_data[idxPrimary][rand() % m_data[idxPrimary].size()];
+        }
+    }
+
+    void erase(const setiter &itr)
+    {
+        auto &vecRow = m_data[itr.idxPrimary];
+        vecRow.erase(vecRow.begin() + itr.idxSecondary);
+        --celem;
+        RehashStep();
+    }
+
+    void clear()
+    {
+        m_data = decltype(m_data)();
+        bits = bits_min;
+        m_data.resize(1ULL << bits);
+        idxRehash = m_data.size();
+    }
+    
+    bool empty() const noexcept { return celem == 0; }
+    size_t size() const noexcept { return celem; }
+
+    size_t bytes_used() const
+    {
+        size_t cb = sizeof(this) + (m_data.capacity()-m_data.size())*sizeof(T);
+        for (auto &vec : m_data)
+        {
+            cb += vec.bytes_used();
+        }
+        return cb;
+    }
+
+    #define DICT_STATS_VECTLEN 50
+    size_t getstats(char *buf, size_t bufsize) const
+    {
+        unsigned long i, slots = 0, chainlen, maxchainlen = 0;
+        unsigned long totchainlen = 0;
+        unsigned long clvector[DICT_STATS_VECTLEN] = {0};
+        size_t l = 0;
+
+        if (empty()) {
+            return snprintf(buf,bufsize,
+                "No stats available for empty dictionaries\n");
+        }
+
+        /* Compute stats. */
+        for (auto &vec : m_data) {
+            if (vec.empty()) {
+                clvector[0]++;
+                continue;
+            }
+            slots++;
+            /* For each hash entry on this slot... */
+            chainlen = vec.size();
+            
+            clvector[(chainlen < DICT_STATS_VECTLEN) ? chainlen : (DICT_STATS_VECTLEN-1)]++;
+            if (chainlen > maxchainlen) maxchainlen = chainlen;
+            totchainlen += chainlen;
+        }
+
+        size_t used = m_data.size()-clvector[0];
+        /* Generate human readable stats. */
+        l += snprintf(buf+l,bufsize-l,
+            "semiordered set stats:\n"
+            " table size: %ld\n"
+            " number of slots: %ld\n"
+            " used slots: %ld\n"
+            " max chain length: %ld\n"
+            " avg chain length (counted): %.02f\n"
+            " avg chain length (computed): %.02f\n"
+            " Chain length distribution:\n",
+            size(), used, slots, maxchainlen,
+            (float)totchainlen/slots, (float)size()/m_data.size());
+
+        for (i = 0; i < DICT_STATS_VECTLEN; i++) {
+            if (clvector[i] == 0) continue;
+            if (l >= bufsize) break;
+            l += snprintf(buf+l,bufsize-l,
+                "   %s%ld: %ld (%.02f%%)\n",
+                (i == DICT_STATS_VECTLEN-1)?">= ":"",
+                i, clvector[i], ((float)clvector[i]/m_data.size())*100);
+        }
+
+        /* Unlike snprintf(), teturn the number of characters actually written. */
+        if (bufsize) buf[bufsize-1] = '\0';
+        return strlen(buf);
+    }
+
+private:
+    inline size_t hashmask() const { return (1ULL << bits) - 1; }
+
+    size_t idxFromObj(const T_KEY &key)
+    {
+        size_t v = (size_t)dictGenHashFunction(&key, sizeof(key));
+        return v & hashmask();
+    }
+
+    bool FRehashedRow(size_t idx) const
+    {
+        return (idx >= (m_data.size()/2)) || (idx < idxRehash);
+    }
+
+    void RehashStep()
+    {
+        if (fPauseRehash)
+            return;
+        
+        int steps = 0;
+        for (; idxRehash < (m_data.size()/2); ++idxRehash)
+        {
+            compactvector<T, MEMMOVE_SAFE> vecT;
+            std::swap(m_data[idxRehash], vecT); 
+
+            for (auto &v : vecT)
+                insert(v, true);
+
+            if (++steps > 1024)
+                break;
+        }
+    }
+
+    void grow()
+    {
+        assert(idxRehash >= (m_data.size()/2)); // we should have finished rehashing by the time we need to grow again
+        
+        ++bits;
+        m_data.resize(1ULL << bits);
+        idxRehash = 0;
+        RehashStep();
+    }
+
+    template<typename T_VISITOR, typename T_MAX>
+    inline bool enumerate_bucket(setiter &itr, const T_MAX &max, T_VISITOR &fn, long long *pcheckLimit)
+    {
+        auto &vec = m_data[itr.idxPrimary];
+        for (; itr.idxSecondary < vec.size(); ++itr.idxSecondary)
+        {
+            // Assert we're ordered by T_MAX
+            assert((itr.idxSecondary+1) >= vec.size() 
+                || static_cast<T_MAX>(vec[itr.idxSecondary]) <= static_cast<T_MAX>(vec[itr.idxSecondary+1]));
+
+            (*pcheckLimit)--;
+            if (max < static_cast<T_MAX>(*itr))
+                return *pcheckLimit > 0;
+
+            size_t sizeBefore = vec.size();
+            if (!fn(*itr))
+            {
+                itr.idxSecondary++; // we still visited this node
+                return false;
+            }
+            if (vec.size() != sizeBefore)
+            {
+                assert(vec.size() == (sizeBefore-1));   // they may only remove the element passed to them
+                --itr.idxSecondary;    // they deleted the element
+            }
+        }
+        vec.shrink_to_fit();
+        return *pcheckLimit > 0;
+    }
+};

src/slowlog.cpp

@@ -72,7 +72,7 @@ slowlogEntry *slowlogCreateEntry(client *c, robj **argv, int argc, long long dur
                     (unsigned long)
                     sdslen(szFromObj(argv[j])) - SLOWLOG_ENTRY_MAX_STRING);
                 se->argv[j] = createObject(OBJ_STRING,s);
-            } else if (argv[j]->refcount == OBJ_SHARED_REFCOUNT) {
+            } else if (argv[j]->getrefcount(std::memory_order_relaxed) == OBJ_SHARED_REFCOUNT) {
                 se->argv[j] = argv[j];
             } else {
                 /* Here we need to dupliacate the string objects composing the

src/sort.cpp

@@ -475,7 +475,7 @@ void sortCommand(client *c) {
 
                     vector[j].u.score = strtod(szFromObj(byval),&eptr);
                     if (eptr[0] != '\0' || errno == ERANGE ||
-                        isnan(vector[j].u.score))
+                        std::isnan(vector[j].u.score))
                     {
                         int_conversion_error = 1;
                     }

src/syncio.cpp

@@ -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.

src/t_hash.cpp

@@ -615,7 +615,7 @@ void hincrbyfloatCommand(client *c) {
     }
 
     value += incr;
-    if (isnan(value) || isinf(value)) {
+    if (std::isnan(value) || std::isinf(value)) {
         addReplyError(c,"increment would produce NaN or Infinity");
         return;
     }

src/t_list.cpp

@@ -331,7 +331,7 @@ void lindexCommand(client *c) {
             addReplyBulk(c,value);
             decrRefCount(value);
         } else {
-            addReplyNull(c);
+            addReplyNull(c,shared.nullbulk);
         }
     } else {
         serverPanic("Unknown list encoding");
@@ -414,7 +414,7 @@ void lrangeCommand(client *c) {
     /* Invariant: start >= 0, so this test will be true when end < 0.
      * The range is empty when start > end or start >= length. */
     if (start > end || start >= llen) {
-        addReplyNull(c);
+        addReplyNull(c,shared.emptymultibulk);
         return;
     }
     if (end >= llen) end = llen-1;
@@ -617,7 +617,7 @@ void rpoplpushCommand(client *c) {
  *    the AOF and replication channel.
  *
  * The argument 'where' is LIST_TAIL or LIST_HEAD, and indicates if the
- * 'value' element was popped fron the head (BLPOP) or tail (BRPOP) so that
+ * 'value' element was popped from the head (BLPOP) or tail (BRPOP) so that
  * we can propagate the command properly.
  *
  * The function returns C_OK if we are able to serve the client, otherwise

src/t_set.cpp

@@ -219,9 +219,9 @@ int setTypeRandomElement(robj *setobj, sds *sdsele, int64_t *llele) {
     return setobj->encoding;
 }
 
-int setTypeRandomElement(robj_roptr setobj, const char **sdsele, const int64_t *llele)
+int setTypeRandomElement(robj_roptr setobj, const char **sdsele, int64_t *llele)
 {
-    return setTypeRandomElement(setobj.unsafe_robjcast(), (sds*)sdsele, const_cast<int64_t*>(llele));
+    return setTypeRandomElement(setobj.unsafe_robjcast(), (sds*)sdsele, llele);
 }
 
 unsigned long setTypeSize(robj_roptr subject) {

src/t_stream.cpp

@@ -492,14 +492,14 @@ void streamIteratorStart(streamIterator *si, stream *s, streamID *start, streamI
         streamEncodeID(si->start_key,start);
     } else {
         si->start_key[0] = 0;
-        si->start_key[0] = 0;
+        si->start_key[1] = 0;
     }
 
     if (end) {
         streamEncodeID(si->end_key,end);
     } else {
         si->end_key[0] = UINT64_MAX;
-        si->end_key[0] = UINT64_MAX;
+        si->end_key[1] = UINT64_MAX;
     }
 
     /* Seek the correct node in the radix tree. */
@@ -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;

src/t_string.cpp

@@ -28,7 +28,7 @@
  */
 
 #include "server.h"
-#include <math.h> /* isnan(), isinf() */
+#include <cmath> /* isnan(), isinf() */
 
 /*-----------------------------------------------------------------------------
  * String Commands
@@ -85,7 +85,7 @@ void setGenericCommand(client *c, int flags, robj *key, robj *val, robj *expire,
     }
     setKey(c->db,key,val);
     g_pserver->dirty++;
-    if (expire) setExpire(c,c->db,key,mstime()+milliseconds);
+    if (expire) setExpire(c,c->db,key,nullptr,mstime()+milliseconds);
     notifyKeyspaceEvent(NOTIFY_STRING,"set",key,c->db->id);
     if (expire) notifyKeyspaceEvent(NOTIFY_GENERIC,
         "expire",key,c->db->id);
@@ -353,7 +353,7 @@ void incrDecrCommand(client *c, long long incr) {
     }
     value += incr;
 
-    if (o && o->refcount == 1 && o->encoding == OBJ_ENCODING_INT &&
+    if (o && o->getrefcount(std::memory_order_relaxed) == 1 && o->encoding == OBJ_ENCODING_INT &&
         (value < 0 || value >= OBJ_SHARED_INTEGERS) &&
         value >= LONG_MIN && value <= LONG_MAX)
     {
@@ -408,7 +408,7 @@ void incrbyfloatCommand(client *c) {
         return;
 
     value += incr;
-    if (isnan(value) || isinf(value)) {
+    if (std::isnan(value) || std::isinf(value)) {
         addReplyError(c,"increment would produce NaN or Infinity");
         return;
     }

src/t_zset.cpp

@@ -134,7 +134,7 @@ zskiplistNode *zslInsert(zskiplist *zsl, double score, sds ele) {
     unsigned int rank[ZSKIPLIST_MAXLEVEL];
     int i, level;
 
-    serverAssert(!isnan(score));
+    serverAssert(!std::isnan(score));
     x = zsl->header;
     for (i = zsl->level-1; i >= 0; i--) {
         /* store rank that is crossed to reach the insert position */
@@ -530,11 +530,11 @@ static int zslParseRange(robj *min, robj *max, zrangespec *spec) {
     } else {
         if (((char*)ptrFromObj(min))[0] == '(') {
             spec->min = strtod((char*)ptrFromObj(min)+1,&eptr);
-            if (eptr[0] != '\0' || isnan(spec->min)) return C_ERR;
+            if (eptr[0] != '\0' || std::isnan(spec->min)) return C_ERR;
             spec->minex = 1;
         } else {
             spec->min = strtod((char*)ptrFromObj(min),&eptr);
-            if (eptr[0] != '\0' || isnan(spec->min)) return C_ERR;
+            if (eptr[0] != '\0' || std::isnan(spec->min)) return C_ERR;
         }
     }
     if (max->encoding == OBJ_ENCODING_INT) {
@@ -542,11 +542,11 @@ static int zslParseRange(robj *min, robj *max, zrangespec *spec) {
     } else {
         if (((char*)ptrFromObj(max))[0] == '(') {
             spec->max = strtod((char*)ptrFromObj(max)+1,&eptr);
-            if (eptr[0] != '\0' || isnan(spec->max)) return C_ERR;
+            if (eptr[0] != '\0' || std::isnan(spec->max)) return C_ERR;
             spec->maxex = 1;
         } else {
             spec->max = strtod((char*)ptrFromObj(max),&eptr);
-            if (eptr[0] != '\0' || isnan(spec->max)) return C_ERR;
+            if (eptr[0] != '\0' || std::isnan(spec->max)) return C_ERR;
         }
     }
 
@@ -1320,7 +1320,7 @@ int zsetAdd(robj *zobj, double score, sds ele, int *flags, double *newscore) {
     double curscore;
 
     /* NaN as input is an error regardless of all the other parameters. */
-    if (isnan(score)) {
+    if (std::isnan(score)) {
         *flags = ZADD_NAN;
         return 0;
     }
@@ -1339,7 +1339,7 @@ int zsetAdd(robj *zobj, double score, sds ele, int *flags, double *newscore) {
             /* Prepare the score for the increment if needed. */
             if (incr) {
                 score += curscore;
-                if (isnan(score)) {
+                if (std::isnan(score)) {
                     *flags |= ZADD_NAN;
                     return 0;
                 }
@@ -1385,7 +1385,7 @@ int zsetAdd(robj *zobj, double score, sds ele, int *flags, double *newscore) {
             /* Prepare the score for the increment if needed. */
             if (incr) {
                 score += curscore;
-                if (isnan(score)) {
+                if (std::isnan(score)) {
                     *flags |= ZADD_NAN;
                     return 0;
                 }
@@ -2150,7 +2150,7 @@ inline static void zunionInterAggregate(double *target, double val, int aggregat
         /* The result of adding two doubles is NaN when one variable
          * is +inf and the other is -inf. When these numbers are added,
          * we maintain the convention of the result being 0.0. */
-        if (isnan(*target)) *target = 0.0;
+        if (std::isnan(*target)) *target = 0.0;
     } else if (aggregate == REDIS_AGGR_MIN) {
         *target = val < *target ? val : *target;
     } else if (aggregate == REDIS_AGGR_MAX) {
@@ -2283,7 +2283,7 @@ void zunionInterGenericCommand(client *c, robj *dstkey, int op) {
                 double score, value;
 
                 score = src[0].weight * zval.score;
-                if (isnan(score)) score = 0;
+                if (std::isnan(score)) score = 0;
 
                 for (j = 1; j < setnum; j++) {
                     /* It is not safe to access the zset we are
@@ -2330,7 +2330,7 @@ void zunionInterGenericCommand(client *c, robj *dstkey, int op) {
             while (zuiNext(&src[i],&zval)) {
                 /* Initialize value */
                 score = src[i].weight * zval.score;
-                if (isnan(score)) score = 0;
+                if (std::isnan(score)) score = 0;
 
                 /* Search for this element in the accumulating dictionary. */
                 de = dictAddRaw(accumulator,zuiSdsFromValue(&zval),&existing);
@@ -2439,7 +2439,7 @@ void zrangeGenericCommand(client *c, int reverse) {
     /* Invariant: start >= 0, so this test will be true when end < 0.
      * The range is empty when start > end or start >= length. */
     if (start > end || start >= llen) {
-        addReplyNull(c);
+        addReplyNull(c,shared.emptymultibulk);
         return;
     }
     if (end >= llen) end = llen-1;
@@ -2595,7 +2595,10 @@ void genericZrangebyscoreCommand(client *c, int reverse) {
 
         /* No "first" element in the specified interval. */
         if (eptr == NULL) {
-            addReplyNull(c);
+            if (c->resp < 3)
+                addReply(c, shared.emptyarray);
+            else
+                addReplyNull(c);
             return;
         }
 
@@ -2662,7 +2665,10 @@ void genericZrangebyscoreCommand(client *c, int reverse) {
 
         /* No "first" element in the specified interval. */
         if (ln == NULL) {
-            addReplyNull(c);
+            if (c->resp < 3)
+                addReply(c, shared.emptyarray);
+            else
+                addReplyNull(c);
             return;
         }
 

src/tracking.cpp

@@ -0,0 +1,174 @@
+/* tracking.c - Client side caching: keys tracking and invalidation
+ *
+ * Copyright (c) 2019, Salvatore Sanfilippo <antirez at gmail dot com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *   * Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above copyright
+ *     notice, this list of conditions and the following disclaimer in the
+ *     documentation and/or other materials provided with the distribution.
+ *   * Neither the name of Redis nor the names of its contributors may be used
+ *     to endorse or promote products derived from this software without
+ *     specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "server.h"
+
+/* The tracking table is constituted by 2^24 radix trees (each tree, and the
+ * table itself, are allocated in a lazy way only when needed) tracking
+ * clients that may have certain keys in their local, client side, cache.
+ *
+ * Keys are grouped into 2^24 slots, in a way similar to Redis Cluster hash
+ * slots, however here the function we use is crc64, taking the least
+ * significant 24 bits of the output.
+ *
+ * When a client enables tracking with "CLIENT TRACKING on", each key served to
+ * the client is hashed to one of such slots, and Redis will remember what
+ * client may have keys about such slot. Later, when a key in a given slot is
+ * modified, all the clients that may have local copies of keys in that slot
+ * will receive an invalidation message. There is no distinction of database
+ * number: a single table is used.
+ *
+ * Clients will normally take frequently requested objects in memory, removing
+ * them when invalidation messages are received. A strategy clients may use is
+ * to just cache objects in a dictionary, associating to each cached object
+ * some incremental epoch, or just a timestamp. When invalidation messages are
+ * received clients may store, in a different table, the timestamp (or epoch)
+ * of the invalidation of such given slot: later when accessing objects, the
+ * eviction of stale objects may be performed in a lazy way by checking if the
+ * cached object timestamp is older than the invalidation timestamp for such
+ * objects.
+ *
+ * The output of the 24 bit hash function is very large (more than 16 million
+ * possible slots), so clients that may want to use less resources may only
+ * use the most significant bits instead of the full 24 bits. */
+#define TRACKING_TABLE_SIZE (1<<24)
+rax **TrackingTable = NULL;
+robj *TrackingChannelName;
+
+/* Remove the tracking state from the client 'c'. Note that there is not much
+ * to do for us here, if not to decrement the counter of the clients in
+ * tracking mode, because we just store the ID of the client in the tracking
+ * table, so we'll remove the ID reference in a lazy way. Otherwise when a
+ * client with many entries in the table is removed, it would cost a lot of
+ * time to do the cleanup. */
+void disableTracking(client *c) {
+    if (c->flags & CLIENT_TRACKING) {
+        g_pserver->tracking_clients--;
+        c->flags &= ~(CLIENT_TRACKING|CLIENT_TRACKING_BROKEN_REDIR);
+    }
+}
+
+/* Enable the tracking state for the client 'c', and as a side effect allocates
+ * the tracking table if needed. If the 'redirect_to' argument is non zero, the
+ * invalidation messages for this client will be sent to the client ID
+ * specified by the 'redirect_to' argument. Note that if such client will
+ * eventually get freed, we'll send a message to the original client to
+ * inform it of the condition. Multiple clients can redirect the invalidation
+ * messages to the same client ID. */
+void enableTracking(client *c, uint64_t redirect_to) {
+    if (c->flags & CLIENT_TRACKING) return;
+    c->flags |= CLIENT_TRACKING;
+    c->flags &= ~CLIENT_TRACKING_BROKEN_REDIR;
+    c->client_tracking_redirection = redirect_to;
+    g_pserver->tracking_clients++;
+    if (TrackingTable == NULL) {
+        TrackingTable = (rax**)zcalloc(sizeof(rax*) * TRACKING_TABLE_SIZE, MALLOC_LOCAL);
+        TrackingChannelName = createStringObject("__redis__:invalidate",20);
+    }
+}
+
+/* This function is called after the excution of a readonly command in the
+ * case the client 'c' has keys tracking enabled. It will populate the
+ * tracking ivalidation table according to the keys the user fetched, so that
+ * Redis will know what are the clients that should receive an invalidation
+ * message with certain groups of keys are modified. */
+void trackingRememberKeys(client *c) {
+    int numkeys;
+    int *keys = getKeysFromCommand(c->cmd,c->argv,c->argc,&numkeys);
+    if (keys == NULL) return;
+
+    for(int j = 0; j < numkeys; j++) {
+        int idx = keys[j];
+        sds sdskey = (sds)ptrFromObj(c->argv[idx]);
+        uint64_t hash = crc64(0,
+            (unsigned char*)sdskey,sdslen(sdskey))&(TRACKING_TABLE_SIZE-1);
+        if (TrackingTable[hash] == NULL)
+            TrackingTable[hash] = raxNew();
+        raxTryInsert(TrackingTable[hash],
+            (unsigned char*)&c->id,sizeof(c->id),NULL,NULL);
+    }
+    getKeysFreeResult(keys);
+}
+
+/* This function is called from signalModifiedKey() or other places in Redis
+ * when a key changes value. In the context of keys tracking, our task here is
+ * to send a notification to every client that may have keys about such . */
+void trackingInvalidateKey(robj *keyobj) {
+    sds sdskey = (sds)ptrFromObj(keyobj);
+    uint64_t hash = crc64(0,
+        (unsigned char*)sdskey,sdslen(sdskey))&(TRACKING_TABLE_SIZE-1);
+    if (TrackingTable == NULL || TrackingTable[hash] == NULL) return;
+
+    raxIterator ri;
+    raxStart(&ri,TrackingTable[hash]);
+    raxSeek(&ri,"^",NULL,0);
+    while(raxNext(&ri)) {
+        uint64_t id;
+        memcpy(&id,ri.key,ri.key_len);
+        client *c = lookupClientByID(id);
+        int using_redirection = 0;
+        if (c->client_tracking_redirection) {
+            client *redir = lookupClientByID(c->client_tracking_redirection);
+            if (!redir) {
+                /* We need to signal to the original connection that we
+                 * are unable to send invalidation messages to the redirected
+                 * connection, because the client no longer exist. */
+                if (c->resp > 2) {
+                    addReplyPushLen(c,3);
+                    addReplyBulkCBuffer(c,"tracking-redir-broken",21);
+                    addReplyLongLong(c,c->client_tracking_redirection);
+                }
+                continue;
+            }
+            c = redir;
+            using_redirection = 1;
+        }
+
+        /* Only send such info for clients in RESP version 3 or more. However
+         * if redirection is active, and the connection we redirect to is
+         * in Pub/Sub mode, we can support the feature with RESP 2 as well,
+         * by sending Pub/Sub messages in the __redis__:invalidate channel. */
+        if (c->resp > 2) {
+            addReplyPushLen(c,2);
+            addReplyBulkCBuffer(c,"invalidate",10);
+            addReplyLongLong(c,hash);
+        } else if (using_redirection && c->flags & CLIENT_PUBSUB) {
+            robj *msg = createStringObjectFromLongLong(hash);
+            addReplyPubsubMessage(c,TrackingChannelName,msg);
+            decrRefCount(msg);
+        }
+    }
+    raxStop(&ri);
+
+    /* Free the tracking table: we'll create the radix tree and populate it
+     * again if more keys will be modified in this hash slot. */
+    raxFree(TrackingTable[hash]);
+    TrackingTable[hash] = NULL;
+}

src/version.h

@@ -1,2 +1,3 @@
-#define KEYDB_REAL_VERSION "0.9.2"
-extern const char *KEYDB_SET_VERSION;   // Unlike real version, this can be overriden by the config
+#define KEYDB_REAL_VERSION "0.0.0"
+extern const char *KEYDB_SET_VERSION;   // Unlike real version, this can be overriden by the config
+

src/ziplist.c

@@ -576,7 +576,7 @@ void zipEntry(unsigned char *p, zlentry *e) {
 
 /* Create a new empty ziplist. */
 unsigned char *ziplistNew(void) {
-    unsigned int bytes = ZIPLIST_HEADER_SIZE+1;
+    unsigned int bytes = ZIPLIST_HEADER_SIZE+ZIPLIST_END_SIZE;
     unsigned char *zl = zmalloc(bytes, MALLOC_SHARED);
     ZIPLIST_BYTES(zl) = intrev32ifbe(bytes);
     ZIPLIST_TAIL_OFFSET(zl) = intrev32ifbe(ZIPLIST_HEADER_SIZE);

tests/integration/psync2.tcl

@@ -166,12 +166,15 @@ start_server {} {
         # Pick a random slave
         set slave_id [expr {($master_id+1)%5}]
         set sync_count [status $R($master_id) sync_full]
+        set sync_partial [status $R($master_id) sync_partial_ok]
         catch {
             $R($slave_id) config rewrite
             $R($slave_id) debug restart
         }
+        # note: just waiting for connected_slaves==4 has a race condition since
+        # we might do the check before the master realized that the slave disconnected
         wait_for_condition 50 2000 {
-            [status $R($master_id) connected_slaves] == 4
+            [status $R($master_id) sync_partial_ok] == $sync_partial + 1
         } else {
             fail "Replica not reconnecting"
         }

tests/integration/replication-active.tcl

@@ -0,0 +1,110 @@
+start_server {tags {"active-repl"} overrides {active-replica yes}} {
+    set slave [srv 0 client]
+    set slave_host [srv 0 host]
+    set slave_port [srv 0 port]
+    set slave_log [srv 0 stdout]
+    set slave_pid [s process_id]
+
+    start_server [list overrides [list active-replica yes replicaof [list $slave_host $slave_port]]] {
+        set master [srv 0 client]
+        set master_host [srv 0 host]
+        set master_port [srv 0 port]
+
+        # Use a short replication timeout on the slave, so that if there
+        # are no bugs the timeout is triggered in a reasonable amount
+        # of time.
+        $slave config set repl-timeout 5
+        $master config set repl-timeout 5
+
+        # Start the replication process...
+        $slave slaveof $master_host $master_port
+        #note the master is a replica via the config (see start_server above)
+
+        test {Active replicas report the correct role} {
+            wait_for_condition 50 100 {
+                [string match *active-replica* [$slave role]]
+            } else {
+                fail "Replica0 does not report the correct role"
+            }
+            wait_for_condition 50 100 {
+                [string match *active-replica* [$master role]]
+            } else {
+                fail "Replica1 does not report the correct role"
+            }
+        }
+
+        test {Active replicas propogate} {
+            $master set testkey foo
+            wait_for_condition 50 500 {
+                [string match *foo* [$slave get testkey]]
+            } else {
+                fail "replication failed to propogate"
+            }
+
+            $slave set testkey bar
+            wait_for_condition 50 500 {
+                [string match bar [$master get testkey]]
+            } else {
+                fail "replication failed to propogate in the other direction"
+            }
+        }
+
+        test {Active replicas propogate binary} {
+            $master set binkey "\u0000foo"
+            wait_for_condition 50 500 {
+                [string match *foo* [$slave get binkey]]
+            } else {
+                fail "replication failed to propogate binary data"
+            }
+        }
+
+        test {Active replicas WAIT} {
+            # Test that wait succeeds since replicas should be syncronized
+            $master set testkey foo
+            $slave set testkey2 test
+            assert_equal {1} [$master wait 1 1000] { "value should propogate
+                within 1 second" }
+            assert_equal {1} [$slave wait 1 1000] { "value should propogate
+                within 1 second" }
+
+            # Now setup a situation where wait should fail
+            exec kill -SIGSTOP $slave_pid
+            $master set testkey fee
+            assert_equal {0} [$master wait 1 1000] { "slave shouldn't be
+                synchronized since its stopped" }
+        }
+        # Resume the replica we paused in the prior test
+        exec kill -SIGCONT $slave_pid
+
+        test {Active replica expire propogates} {
+            $master set testkey1 foo
+            wait_for_condition 50 1000 {
+                [string match *foo* [$slave get testkey1]]
+            } else {
+                fail "Replication failed to propogate"
+            }
+            $master pexpire testkey1 200
+            after 1000
+            assert_equal {0} [$master del testkey1] {"master expired"}
+            assert_equal {0} [$slave del testkey1]  {"slave expired"}
+
+            $slave set testkey1 foo px 200
+            after 1000
+            assert_equal {0} [$master del testkey1]
+            assert_equal {0} [$slave del testkey1]
+        }
+
+        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"
+            }
+        }
+    }
+}

tests/integration/replication-psync.tcl

@@ -79,6 +79,32 @@ proc test_psync {descr duration backlog_size backlog_ttl delay cond diskless rec
                 stop_bg_complex_data $load_handle0
                 stop_bg_complex_data $load_handle1
                 stop_bg_complex_data $load_handle2
+
+                # Wait for the slave to reach the "online"
+                # state from the POV of the master.
+                set retry 5000
+                while {$retry} {
+                    set info [$master info]
+                    if {[string match {*slave0:*state=online*} $info]} {
+                        break
+                    } else {
+                        incr retry -1
+                        after 100
+                    }
+                }
+                if {$retry == 0} {
+                    error "assertion:Slave not correctly synchronized"
+                }
+
+                # Wait that slave acknowledge it is online so
+                # we are sure that DBSIZE and DEBUG DIGEST will not
+                # fail because of timing issues. (-LOADING error)
+                wait_for_condition 5000 100 {
+                    [lindex [$slave role] 3] eq {connected}
+                } else {
+                    fail "Slave still not connected after some time"
+                }  
+
                 set retry 10
                 while {$retry && ([$master debug digest] ne [$slave debug digest])}\
                 {

tests/modules/Makefile

@@ -0,0 +1,24 @@
+
+# find the OS
+uname_S := $(shell sh -c 'uname -s 2>/dev/null || echo not')
+
+# Compile flags for linux / osx
+ifeq ($(uname_S),Linux)
+	SHOBJ_CFLAGS ?= -W -Wall -fno-common -g -ggdb -std=c99 -O2
+	SHOBJ_LDFLAGS ?= -shared
+else
+	SHOBJ_CFLAGS ?= -W -Wall -dynamic -fno-common -g -ggdb -std=c99 -O2
+	SHOBJ_LDFLAGS ?= -bundle -undefined dynamic_lookup
+endif
+
+.SUFFIXES: .c .so .xo .o
+
+all: commandfilter.so
+
+.c.xo:
+	$(CC) -I../../src $(CFLAGS) $(SHOBJ_CFLAGS) -fPIC -c $< -o $@
+
+commandfilter.xo: ../../src/redismodule.h
+
+commandfilter.so: commandfilter.xo
+	$(LD) -o $@ $< $(SHOBJ_LDFLAGS) $(LIBS) -lc

tests/modules/commandfilter.c

@@ -1,18 +1,18 @@
 #define REDISMODULE_EXPERIMENTAL_API
-#include "../redismodule.h"
+#include "redismodule.h"
 
 #include <string.h>
 
 static RedisModuleString *log_key_name;
 
-static const char log_command_name[] = "hellofilter.log";
-static const char ping_command_name[] = "hellofilter.ping";
-static const char unregister_command_name[] = "hellofilter.unregister";
+static const char log_command_name[] = "commandfilter.log";
+static const char ping_command_name[] = "commandfilter.ping";
+static const char unregister_command_name[] = "commandfilter.unregister";
 static int in_log_command = 0;
 
 static RedisModuleCommandFilter *filter = NULL;
 
-int HelloFilter_UnregisterCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
+int CommandFilter_UnregisterCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
 {
     (void) argc;
     (void) argv;
@@ -23,7 +23,7 @@ int HelloFilter_UnregisterCommand(RedisModuleCtx *ctx, RedisModuleString **argv,
     return REDISMODULE_OK;
 }
 
-int HelloFilter_PingCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
+int CommandFilter_PingCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
 {
     (void) argc;
     (void) argv;
@@ -39,7 +39,7 @@ int HelloFilter_PingCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int a
     return REDISMODULE_OK;
 }
 
-int HelloFilter_LogCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
+int CommandFilter_LogCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
 {
     RedisModuleString *s = RedisModule_CreateString(ctx, "", 0);
 
@@ -74,9 +74,9 @@ int HelloFilter_LogCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int ar
     return REDISMODULE_OK;
 }
 
-void HelloFilter_CommandFilter(RedisModuleCommandFilterCtx *filter)
+void CommandFilter_CommandFilter(RedisModuleCommandFilterCtx *filter)
 {
-    if (in_log_command) return;  /* don't process our own RM_Call() from HelloFilter_LogCommand() */
+    if (in_log_command) return;  /* don't process our own RM_Call() from CommandFilter_LogCommand() */
 
     /* Fun manipulations:
      * - Remove @delme
@@ -117,7 +117,7 @@ void HelloFilter_CommandFilter(RedisModuleCommandFilterCtx *filter)
 }
 
 int RedisModule_OnLoad(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
-    if (RedisModule_Init(ctx,"hellofilter",1,REDISMODULE_APIVER_1)
+    if (RedisModule_Init(ctx,"commandfilter",1,REDISMODULE_APIVER_1)
             == REDISMODULE_ERR) return REDISMODULE_ERR;
 
     if (argc != 2) {
@@ -130,18 +130,18 @@ int RedisModule_OnLoad(RedisModuleCtx *ctx, RedisModuleString **argv, int argc)
     RedisModule_StringToLongLong(argv[1], &noself);
 
     if (RedisModule_CreateCommand(ctx,log_command_name,
-                HelloFilter_LogCommand,"write deny-oom",1,1,1) == REDISMODULE_ERR)
+                CommandFilter_LogCommand,"write deny-oom",1,1,1) == REDISMODULE_ERR)
             return REDISMODULE_ERR;
 
     if (RedisModule_CreateCommand(ctx,ping_command_name,
-                HelloFilter_PingCommand,"deny-oom",1,1,1) == REDISMODULE_ERR)
+                CommandFilter_PingCommand,"deny-oom",1,1,1) == REDISMODULE_ERR)
             return REDISMODULE_ERR;
 
     if (RedisModule_CreateCommand(ctx,unregister_command_name,
-                HelloFilter_UnregisterCommand,"write deny-oom",1,1,1) == REDISMODULE_ERR)
+                CommandFilter_UnregisterCommand,"write deny-oom",1,1,1) == REDISMODULE_ERR)
             return REDISMODULE_ERR;
 
-    if ((filter = RedisModule_RegisterCommandFilter(ctx, HelloFilter_CommandFilter, 
+    if ((filter = RedisModule_RegisterCommandFilter(ctx, CommandFilter_CommandFilter, 
                     noself ? REDISMODULE_CMDFILTER_NOSELF : 0))
             == NULL) return REDISMODULE_ERR;
 

tests/test_helper.tcl

@@ -35,12 +35,14 @@ set ::all_tests {
     unit/quit
     unit/aofrw
     unit/acl
+    unit/rreplay
     integration/block-repl
     integration/replication
     integration/replication-2
     integration/replication-3
     integration/replication-4
     integration/replication-psync
+    integration/replication-active
     integration/aof
     integration/rdb
     integration/convert-zipmap-hash-on-load
@@ -63,7 +65,6 @@ set ::all_tests {
     unit/lazyfree
     unit/wait
     unit/pendingquerybuf
-    modules/commandfilter
 }
 # Index to the next test to run in the ::all_tests list.
 set ::next_test 0
@@ -504,7 +505,7 @@ for {set j 0} {$j < [llength $argv]} {incr j} {
     } elseif {$opt eq {--only}} {
         lappend ::only_tests $arg
         incr j
-    } elseif {$opt eq {--skiptill}} {
+    } elseif {$opt eq {--skip-till}} {
         set ::skip_till $arg
         incr j
     } elseif {$opt eq {--list-tests}} {

tests/unit/acl.tcl

@@ -108,4 +108,11 @@ start_server {tags {"acl"}} {
         assert_match {*+debug|segfault*} $cmdstr
         assert_match {*+acl*} $cmdstr
     }
+
+    test {ACL #5998 regression: memory leaks adding / removing subcommands} {
+        r AUTH default ""
+        r ACL setuser newuser reset -debug +debug|a +debug|b +debug|c
+        r ACL setuser newuser -debug
+        # The test framework will detect a leak if any.
+    }
 }

tests/unit/bitops.tcl

@@ -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
+    } "\x00abcdefg"
+
+    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

tests/unit/lazyfree.tcl

@@ -2,11 +2,11 @@ start_server {tags {"lazyfree"}} {
     test "UNLINK can reclaim memory in background" {
         set orig_mem [s used_memory]
         set args {}
-        for {set i 0} {$i < 100000} {incr i} {
+        for {set i 0} {$i < 200000} {incr i} {
             lappend args $i
         }
         r sadd myset {*}$args
-        assert {[r scard myset] == 100000}
+        assert {[r scard myset] == 200000}
         set peak_mem [s used_memory]
         assert {[r unlink myset] == 1}
         assert {$peak_mem > $orig_mem+1000000}
@@ -19,14 +19,13 @@ start_server {tags {"lazyfree"}} {
     }
 
     test "FLUSHDB ASYNC can reclaim memory in background" {
-        after 500   # Sometimes Redis is busy with a prior operation
         set orig_mem [s used_memory]
         set args {}
-        for {set i 0} {$i < 100000} {incr i} {
+        for {set i 0} {$i < 200000} {incr i} {
             lappend args $i
         }
         r sadd myset {*}$args
-        assert {[r scard myset] == 100000}
+        assert {[r scard myset] == 200000}
         set peak_mem [s used_memory]
         r flushdb async
         assert {$peak_mem > $orig_mem+1000000}

tests/unit/maxmemory.tcl

@@ -161,7 +161,7 @@ proc test_slave_buffers {test_name cmd_count payload_len limit_memory pipeline}
             }
 
             # make sure master doesn't disconnect slave because of timeout
-            $master config set repl-timeout 300 ;# 5 minutes
+            $master config set repl-timeout 1200 ;# 20 minutes (for valgrind and slow machines)
             $master config set maxmemory-policy allkeys-random
             $master config set client-output-buffer-limit "replica 100000000 100000000 300"
             $master config set repl-backlog-size [expr {10*1024}]
@@ -212,7 +212,8 @@ proc test_slave_buffers {test_name cmd_count payload_len limit_memory pipeline}
 
             assert {[$master dbsize] == 100}
             assert {$slave_buf > 2*1024*1024} ;# some of the data may have been pushed to the OS buffers
-            assert {$delta < 50*1024 && $delta > -50*1024} ;# 1 byte unaccounted for, with 1M commands will consume some 1MB
+            set delta_max [expr {$cmd_count / 2}] ;# 1 byte unaccounted for, with 1M commands will consume some 1MB
+            assert {$delta < $delta_max && $delta > -$delta_max}
 
             $master client kill type slave
             set killed_used [s -1 used_memory]
@@ -221,7 +222,7 @@ proc test_slave_buffers {test_name cmd_count payload_len limit_memory pipeline}
             set killed_used_no_repl [expr {$killed_used - $killed_mem_not_counted_for_evict}]
             set delta_no_repl [expr {$killed_used_no_repl - $used_no_repl}]
             assert {$killed_slave_buf == 0}
-            assert {$delta_no_repl > -50*1024 && $delta_no_repl < 50*1024} ;# 1 byte unaccounted for, with 1M commands will consume some 1MB
+            assert {$delta_no_repl > -$delta_max && $delta_no_repl < $delta_max}
 
         }
         # unfreeze slave process (after the 'test' succeeded or failed, but before we attempt to terminate the server

tests/unit/moduleapi/commandfilter.tcl

@@ -1,4 +1,4 @@
-set testmodule [file normalize src/modules/hellofilter.so]
+set testmodule [file normalize tests/modules/commandfilter.so]
 
 start_server {tags {"modules"}} {
     r module load $testmodule log-key 0
@@ -27,7 +27,7 @@ start_server {tags {"modules"}} {
 
     test {Command Filter applies on RM_Call() commands} {
         r del log-key
-        r hellofilter.ping
+        r commandfilter.ping
         r lrange log-key 0 -1
     } "{ping @log}"
 
@@ -39,13 +39,13 @@ start_server {tags {"modules"}} {
 
     test {Command Filter applies on Lua redis.call() that calls a module} {
         r del log-key
-        r eval "redis.call('hellofilter.ping')" 0
+        r eval "redis.call('commandfilter.ping')" 0
         r lrange log-key 0 -1
     } "{ping @log}"
 
     test {Command Filter is unregistered implicitly on module unload} {
         r del log-key
-        r module unload hellofilter
+        r module unload commandfilter
         r set mykey @log
         r lrange log-key 0 -1
     } {}
@@ -59,14 +59,14 @@ start_server {tags {"modules"}} {
         assert_equal "{set mykey @log}" [r lrange log-key 0 -1]
 
         # Unregister
-        r hellofilter.unregister
+        r commandfilter.unregister
         r del log-key
 
         r set mykey @log
         r lrange log-key 0 -1
     } {}
 
-    r module unload hellofilter
+    r module unload commandfilter
     r module load $testmodule log-key 1
 
     test {Command Filter REDISMODULE_CMDFILTER_NOSELF works as expected} {
@@ -74,10 +74,10 @@ start_server {tags {"modules"}} {
         assert_equal "{set mykey @log}" [r lrange log-key 0 -1]
 
         r del log-key
-        r hellofilter.ping
+        r commandfilter.ping
         assert_equal {} [r lrange log-key 0 -1]
 
-        r eval "redis.call('hellofilter.ping')" 0
+        r eval "redis.call('commandfilter.ping')" 0
         assert_equal {} [r lrange log-key 0 -1]
     }
 

tests/unit/obuf-limits.tcl

@@ -15,7 +15,7 @@ start_server {tags {"obuf-limits"}} {
             if {![regexp {omem=([0-9]+)} $c - omem]} break
             if {$omem > 200000} break
         }
-        assert {$omem >= 90000 && $omem < 200000}
+        assert {$omem >= 70000 && $omem < 200000}
         $rd1 close
     }
 

tests/unit/other.tcl

@@ -1,3 +1,10 @@
+start_server {tags {"other"} overrides {databases 64}} {
+    test {CONF-DATABASES - ensure the databases config option is respected} {
+        r select 63
+        r set testkey {foo}
+    } {OK}
+}
+
 start_server {tags {"other"}} {
     if {$::force_failure} {
         # This is used just for test suite development purposes.

tests/unit/rreplay.tcl

@@ -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
+}

tests/unit/scan.tcl

@@ -53,6 +53,51 @@ start_server {tags {"scan"}} {
         assert_equal 100 [llength $keys]
     }
 
+    test "SCAN TYPE" {
+        r flushdb
+        # populate only creates strings
+        r debug populate 1000
+
+        # Check non-strings are excluded
+        set cur 0
+        set keys {}
+        while 1 {
+            set res [r scan $cur type "list"]
+            set cur [lindex $res 0]
+            set k [lindex $res 1]
+            lappend keys {*}$k
+            if {$cur == 0} break
+        }
+
+        assert_equal 0 [llength $keys] "non-strings excluded"
+
+        # Check strings are included
+        set cur 0
+        set keys {}
+        while 1 {
+            set res [r scan $cur type "string"]
+            set cur [lindex $res 0]
+            set k [lindex $res 1]
+            lappend keys {*}$k
+            if {$cur == 0} break
+        }
+
+        assert_equal 1000 [llength $keys] "strings included"
+
+        # Check all three args work together
+        set cur 0
+        set keys {}
+        while 1 {
+            set res [r scan $cur type "string" match "key:*" count 10]
+            set cur [lindex $res 0]
+            set k [lindex $res 1]
+            lappend keys {*}$k
+            if {$cur == 0} break
+        }
+
+        assert_equal 1000 [llength $keys]
+    }
+
     foreach enc {intset hashtable} {
         test "SSCAN with encoding $enc" {
             # Create the Set