Merge branch 'unstable' into RELEASE_5

FINAL_CXXFLAGS should not inherit CFLAGS because they can contain C
specific options unsupported by C++.

REDIS_CXX should point to the C++ compiler rather than C.

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,20 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+** Log Files **
+These should be KeyDB logs, not syslogs or logs from your container manager.  If you are reporting a crash there will be a line in your log stating:
+"=== KEYDB BUG REPORT START: Cut & paste starting from here ==="
+
+Please copy everything after this line.
+
+**To Reproduce**
+Do you know how to reproduce this?  If so please provide repro steps.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.gitignore

@@ -1,6 +1,7 @@
 .*.swp
 core
 *.o
+*.d
 *.log
 dump.rdb
 redis-benchmark
@@ -27,7 +28,7 @@ release.h
 src/transfer.sh
 src/configs
 redis.ds
-src/redis.conf
+src/keydb.conf
 src/nodes.conf
 deps/lua/src/lua
 deps/lua/src/luac

.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

@@ -1,56 +0,0 @@
-{
-    "files.associations": {
-        "zmalloc.h": "c",
-        "stat.h": "c",
-        "array": "cpp",
-        "atomic": "cpp",
-        "*.tcc": "cpp",
-        "cctype": "cpp",
-        "chrono": "cpp",
-        "clocale": "cpp",
-        "cmath": "cpp",
-        "condition_variable": "cpp",
-        "cstdarg": "cpp",
-        "cstddef": "cpp",
-        "cstdint": "cpp",
-        "cstdio": "cpp",
-        "cstdlib": "cpp",
-        "cstring": "cpp",
-        "ctime": "cpp",
-        "cwchar": "cpp",
-        "cwctype": "cpp",
-        "deque": "cpp",
-        "list": "cpp",
-        "unordered_map": "cpp",
-        "vector": "cpp",
-        "exception": "cpp",
-        "fstream": "cpp",
-        "functional": "cpp",
-        "future": "cpp",
-        "initializer_list": "cpp",
-        "iomanip": "cpp",
-        "iosfwd": "cpp",
-        "iostream": "cpp",
-        "istream": "cpp",
-        "limits": "cpp",
-        "memory": "cpp",
-        "mutex": "cpp",
-        "new": "cpp",
-        "numeric": "cpp",
-        "optional": "cpp",
-        "ostream": "cpp",
-        "ratio": "cpp",
-        "scoped_allocator": "cpp",
-        "sstream": "cpp",
-        "stdexcept": "cpp",
-        "streambuf": "cpp",
-        "string_view": "cpp",
-        "system_error": "cpp",
-        "thread": "cpp",
-        "cinttypes": "cpp",
-        "tuple": "cpp",
-        "type_traits": "cpp",
-        "typeinfo": "cpp",
-        "utility": "cpp"
-    }
-}

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 libcurl4-openssl-dev \
     && apt-get clean
 
 CMD make

README.md

@@ -1,38 +1,52 @@
 ![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).
+
+##### Have feedback?  Take our quick survey: https://www.surveymonkey.com/r/Y9XNS93
 
 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 guarantees 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://keydb.dev/assets/img/blog/5x_opspersecVSdatasize.PNG"/>
+
+See the full benchmark results and setup information here: https://docs.keydb.dev/blog/2019/10/07/blog-post/
+
+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 +69,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 +82,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 +197,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 +240,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"
+

keydb.conf

@@ -1,9 +1,9 @@
-# Redis configuration file example.
+# KeyDB configuration file example.
 #
-# Note that in order to read the configuration file, Redis must be
+# Note that in order to read the configuration file, KeyDB must be
 # started with the file path as first argument:
 #
-# ./keydb-server /path/to/redis.conf
+# ./keydb-server /path/to/keydb.conf
 
 # Note on units: when memory size is needed, it is possible to specify
 # it in the usual form of 1k 5GB 4M and so forth:
@@ -20,12 +20,12 @@
 ################################## INCLUDES ###################################
 
 # Include one or more other config files here.  This is useful if you
-# have a standard template that goes to all Redis servers but also need
+# have a standard template that goes to all KeyDB servers but also need
 # to customize a few per-server settings.  Include files can include
 # other files, so use this wisely.
 #
 # Notice option "include" won't be rewritten by command "CONFIG REWRITE"
-# from admin or Redis Sentinel. Since Redis always uses the last processed
+# from admin or KeyDB Sentinel. Since KeyDB always uses the last processed
 # line as value of a configuration directive, you'd better put includes
 # at the beginning of this file to avoid overwriting config change at runtime.
 #
@@ -45,7 +45,7 @@
 
 ################################## NETWORK #####################################
 
-# By default, if no "bind" configuration directive is specified, Redis listens
+# By default, if no "bind" configuration directive is specified, KeyDB listens
 # for connections from all the network interfaces available on the server.
 # It is possible to listen to just one or multiple selected interfaces using
 # the "bind" configuration directive, followed by one or more IP addresses.
@@ -55,11 +55,11 @@
 # bind 192.168.1.100 10.0.0.1
 # bind 127.0.0.1 ::1
 #
-# ~~~ WARNING ~~~ If the computer running Redis is directly exposed to the
+# ~~~ WARNING ~~~ If the computer running KeyDB is directly exposed to the
 # internet, binding to all the interfaces is dangerous and will expose the
 # instance to everybody on the internet. So by default we uncomment the
-# following bind directive, that will force Redis to listen only into
-# the IPv4 loopback interface address (this means Redis will be able to
+# following bind directive, that will force KeyDB to listen only into
+# the IPv4 loopback interface address (this means KeyDB will be able to
 # accept connections only from clients running into the same computer it
 # is running).
 #
@@ -69,7 +69,7 @@
 bind 127.0.0.1
 
 # Protected mode is a layer of security protection, in order to avoid that
-# Redis instances left open on the internet are accessed and exploited.
+# KeyDB instances left open on the internet are accessed and exploited.
 #
 # When protected mode is on and if:
 #
@@ -82,13 +82,13 @@ bind 127.0.0.1
 # sockets.
 #
 # By default protected mode is enabled. You should disable it only if
-# you are sure you want clients from other hosts to connect to Redis
+# you are sure you want clients from other hosts to connect to KeyDB
 # even if no authentication is configured, nor a specific set of interfaces
 # are explicitly listed using the "bind" directive.
 protected-mode yes
 
 # Accept connections on the specified port, default is 6379 (IANA #815344).
-# If port 0 is specified Redis will not listen on a TCP socket.
+# If port 0 is specified KeyDB will not listen on a TCP socket.
 port 6379
 
 # TCP listen() backlog.
@@ -103,10 +103,10 @@ tcp-backlog 511
 # Unix socket.
 #
 # Specify the path for the Unix socket that will be used to listen for
-# incoming connections. There is no default, so Redis will not listen
+# incoming connections. There is no default, so KeyDB will not listen
 # on a unix socket when not specified.
 #
-# unixsocket /tmp/redis.sock
+# unixsocket /tmp/keydb.sock
 # unixsocketperm 700
 
 # Close the connection after a client is idle for N seconds (0 to disable)
@@ -126,19 +126,19 @@ timeout 0
 # On other kernels the period depends on the kernel configuration.
 #
 # A reasonable value for this option is 300 seconds, which is the new
-# Redis default starting with Redis 3.2.1.
+# KeyDB default starting with Redis 3.2.1.
 tcp-keepalive 300
 
 ################################# GENERAL #####################################
 
-# By default Redis does not run as a daemon. Use 'yes' if you need it.
-# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
+# By default KeyDB does not run as a daemon. Use 'yes' if you need it.
+# Note that KeyDB will write a pid file in /var/run/keydb.pid when daemonized.
 daemonize no
 
-# If you run Redis from upstart or systemd, Redis can interact with your
+# If you run KeyDB from upstart or systemd, KeyDB can interact with your
 # supervision tree. Options:
 #   supervised no      - no supervision interaction
-#   supervised upstart - signal upstart by putting Redis into SIGSTOP mode
+#   supervised upstart - signal upstart by putting KeyDB into SIGSTOP mode
 #   supervised systemd - signal systemd by writing READY=1 to $NOTIFY_SOCKET
 #   supervised auto    - detect upstart or systemd method based on
 #                        UPSTART_JOB or NOTIFY_SOCKET environment variables
@@ -146,16 +146,16 @@ daemonize no
 #       They do not enable continuous liveness pings back to your supervisor.
 supervised no
 
-# If a pid file is specified, Redis writes it where specified at startup
+# If a pid file is specified, KeyDB writes it where specified at startup
 # and removes it at exit.
 #
 # When the server runs non daemonized, no pid file is created if none is
 # specified in the configuration. When the server is daemonized, the pid file
-# is used even if not specified, defaulting to "/var/run/redis.pid".
+# is used even if not specified, defaulting to "/var/run/keydb.pid".
 #
-# Creating a pid file is best effort: if Redis is not able to create it
+# Creating a pid file is best effort: if KeyDB is not able to create it
 # nothing bad happens, the server will start and run normally.
-pidfile /var/run/redis_6379.pid
+pidfile /var/run/keydb_6379.pid
 
 # Specify the server verbosity level.
 # This can be one of:
@@ -166,7 +166,7 @@ pidfile /var/run/redis_6379.pid
 loglevel notice
 
 # Specify the log file name. Also the empty string can be used to force
-# Redis to log on the standard output. Note that if you use standard
+# KeyDB to log on the standard output. Note that if you use standard
 # output for logging but daemonize, logs will be sent to /dev/null
 logfile ""
 
@@ -175,7 +175,7 @@ logfile ""
 # syslog-enabled no
 
 # Specify the syslog identity.
-# syslog-ident redis
+# syslog-ident keydb
 
 # Specify the syslog facility. Must be USER or between LOCAL0-LOCAL7.
 # syslog-facility local0
@@ -185,7 +185,7 @@ logfile ""
 # dbid is a number between 0 and 'databases'-1
 databases 16
 
-# By default Redis shows an ASCII art logo only when started to log to the
+# By default KeyDB shows an ASCII art logo only when started to log to the
 # standard output and if the standard output is a TTY. Basically this means
 # that normally a logo is displayed only in interactive sessions.
 #
@@ -219,17 +219,17 @@ save 900 1
 save 300 10
 save 60 10000
 
-# By default Redis will stop accepting writes if RDB snapshots are enabled
+# By default KeyDB will stop accepting writes if RDB snapshots are enabled
 # (at least one save point) and the latest background save failed.
 # This will make the user aware (in a hard way) that data is not persisting
 # on disk properly, otherwise chances are that no one will notice and some
 # disaster will happen.
 #
-# If the background saving process will start working again Redis will
+# If the background saving process will start working again KeyDB will
 # automatically allow writes again.
 #
-# However if you have setup your proper monitoring of the Redis server
-# and persistence, you may want to disable this feature so that Redis will
+# However if you have setup your proper monitoring of the KeyDB server
+# and persistence, you may want to disable this feature so that KeyDB will
 # continue to work as usual even if there are problems with disk,
 # permissions, and so forth.
 stop-writes-on-bgsave-error yes
@@ -264,18 +264,18 @@ dir ./
 
 ################################# REPLICATION #################################
 
-# Master-Replica replication. Use replicaof to make a Redis instance a copy of
-# another Redis server. A few things to understand ASAP about Redis replication.
+# Master-Replica replication. Use replicaof to make a KeyDB instance a copy of
+# another KeyDB server. A few things to understand ASAP about KeyDB replication.
 #
 #   +------------------+      +---------------+
 #   |      Master      | ---> |    Replica    |
 #   | (receive writes) |      |  (exact copy) |
 #   +------------------+      +---------------+
 #
-# 1) Redis replication is asynchronous, but you can configure a master to
+# 1) KeyDB replication is asynchronous, but you can configure a master to
 #    stop accepting writes if it appears to be not connected with at least
 #    a given number of replicas.
-# 2) Redis replicas are able to perform a partial resynchronization with the
+# 2) KeyDB replicas are able to perform a partial resynchronization with the
 #    master if the replication link is lost for a relatively small amount of
 #    time. You may want to configure the replication backlog size (see the next
 #    sections of this file) with a sensible value depending on your needs.
@@ -292,7 +292,7 @@ dir ./
 #
 # masterauth <master-password>
 #
-# However this is not enough if you are using Redis ACLs (for Redis version
+# However this is not enough if you are using KeyDB ACLs (for Redis version
 # 6 or greater), and the default user is not capable of running the PSYNC
 # command and/or other commands needed for replication. In this case it's
 # better to configure a special user to use with replication, and specify the
@@ -345,10 +345,10 @@ replica-read-only yes
 # synchronization". An RDB file is transmitted from the master to the replicas.
 # The transmission can happen in two different ways:
 #
-# 1) Disk-backed: The Redis master creates a new process that writes the RDB
+# 1) Disk-backed: The KeyDB master creates a new process that writes the RDB
 #                 file on disk. Later the file is transferred by the parent
 #                 process to the replicas incrementally.
-# 2) Diskless: The Redis master creates a new process that directly writes the
+# 2) Diskless: The KeyDB master creates a new process that directly writes the
 #              RDB file to replica sockets, without touching the disk at all.
 #
 # With disk-backed replication, while the RDB file is generated, more replicas
@@ -397,7 +397,7 @@ repl-diskless-sync-delay 5
 
 # Disable TCP_NODELAY on the replica socket after SYNC?
 #
-# If you select "yes" Redis will use a smaller number of TCP packets and
+# If you select "yes" KeyDB will use a smaller number of TCP packets and
 # less bandwidth to send data to replicas. But this can add a delay for
 # the data to appear on the replica side, up to 40 milliseconds with
 # Linux kernels using a default configuration.
@@ -436,8 +436,8 @@ repl-disable-tcp-nodelay no
 #
 # repl-backlog-ttl 3600
 
-# The replica priority is an integer number published by Redis in the INFO output.
-# It is used by Redis Sentinel in order to select a replica to promote into a
+# The replica priority is an integer number published by KeyDB in the INFO output.
+# It is used by KeyDB Sentinel in order to select a replica to promote into a
 # master if the master is no longer working correctly.
 #
 # A replica with a low priority number is considered better for promotion, so
@@ -446,7 +446,7 @@ repl-disable-tcp-nodelay no
 #
 # However a special priority of 0 marks the replica as not able to perform the
 # role of master, so a replica with priority of 0 will never be selected by
-# Redis Sentinel for promotion.
+# KeyDB Sentinel for promotion.
 #
 # By default the priority is 100.
 replica-priority 100
@@ -473,10 +473,10 @@ replica-priority 100
 # By default min-replicas-to-write is set to 0 (feature disabled) and
 # min-replicas-max-lag is set to 10.
 
-# A Redis master is able to list the address and port of the attached
+# A KeyDB master is able to list the address and port of the attached
 # replicas in different ways. For example the "INFO replication" section
 # offers this information, which is used, among other tools, by
-# Redis Sentinel in order to discover replica instances.
+# KeyDB Sentinel in order to discover replica instances.
 # Another place where this info is available is in the output of the
 # "ROLE" command of a master.
 #
@@ -504,7 +504,7 @@ replica-priority 100
 
 ################################## SECURITY ###################################
 
-# Warning: since Redis is pretty fast an outside user can try up to
+# Warning: since KeyDB is pretty fast an outside user can try up to
 # 1 million passwords per second against a modern box. This means that you
 # should use very strong passwords, otherwise they will be very easy to break.
 # Note that because the password is really a shared secret between the client
@@ -512,7 +512,7 @@ replica-priority 100
 # can be easily a long string from /dev/urandom or whatever, so by using a
 # long and unguessable password no brute force attack will be possible.
 
-# Redis ACL users are defined in the following format:
+# KeyDB ACL users are defined in the following format:
 #
 #   user <username> ... acl rules ...
 #
@@ -539,7 +539,7 @@ replica-priority 100
 #  +@<category> Allow the execution of all the commands in such category
 #               with valid categories are like @admin, @set, @sortedset, ...
 #               and so forth, see the full list in the server.c file where
-#               the Redis command table is described and defined.
+#               the KeyDB command table is described and defined.
 #               The special category @all means all the commands, but currently
 #               present in the server, and that will be loaded in the future
 #               via modules.
@@ -606,9 +606,9 @@ replica-priority 100
 # ACL file, the server will refuse to start.
 #
 # The format of the external ACL user file is exactly the same as the
-# format that is used inside redis.conf to describe users.
+# format that is used inside keydb.conf to describe users.
 #
-# aclfile /etc/redis/users.acl
+# aclfile /etc/keydb/users.acl
 
 # IMPORTANT NOTE: starting with Redis 6 "requirepass" is just a compatiblity
 # layer on top of the new ACL system. The option effect will be just setting
@@ -646,12 +646,12 @@ replica-priority 100
 ################################### CLIENTS ####################################
 
 # Set the max number of connected clients at the same time. By default
-# this limit is set to 10000 clients, however if the Redis server is not
+# this limit is set to 10000 clients, however if the KeyDB server is not
 # able to configure the process file limit to allow for the specified limit
 # the max number of allowed clients is set to the current file limit
-# minus 32 (as Redis reserves a few file descriptors for internal uses).
+# minus 32 (as KeyDB reserves a few file descriptors for internal uses).
 #
-# Once the limit is reached Redis will close all the new connections sending
+# Once the limit is reached KeyDB will close all the new connections sending
 # an error 'max number of clients reached'.
 #
 # maxclients 10000
@@ -659,15 +659,15 @@ replica-priority 100
 ############################## MEMORY MANAGEMENT ################################
 
 # Set a memory usage limit to the specified amount of bytes.
-# When the memory limit is reached Redis will try to remove keys
+# When the memory limit is reached KeyDB will try to remove keys
 # according to the eviction policy selected (see maxmemory-policy).
 #
-# If Redis can't remove keys according to the policy, or if the policy is
-# set to 'noeviction', Redis will start to reply with errors to commands
+# If KeyDB can't remove keys according to the policy, or if the policy is
+# set to 'noeviction', KeyDB will start to reply with errors to commands
 # that would use more memory, like SET, LPUSH, and so on, and will continue
 # to reply to read-only commands like GET.
 #
-# This option is usually useful when using Redis as an LRU or LFU cache, or to
+# This option is usually useful when using KeyDB as an LRU or LFU cache, or to
 # set a hard memory limit for an instance (using the 'noeviction' policy).
 #
 # WARNING: If you have replicas attached to an instance with maxmemory on,
@@ -683,7 +683,7 @@ replica-priority 100
 #
 # maxmemory <bytes>
 
-# MAXMEMORY POLICY: how Redis will select what to remove when maxmemory
+# MAXMEMORY POLICY: how KeyDB will select what to remove when maxmemory
 # is reached. You can select among five behaviors:
 #
 # volatile-lru -> Evict using approximated LRU among the keys with an expire set.
@@ -701,7 +701,7 @@ replica-priority 100
 # Both LRU, LFU and volatile-ttl are implemented using approximated
 # randomized algorithms.
 #
-# Note: with any of the above policies, Redis will return an error on write
+# Note: with any of the above policies, KeyDB will return an error on write
 #       operations, when there are no suitable keys for eviction.
 #
 #       At the date of writing these commands are: set setnx setex append
@@ -716,7 +716,7 @@ replica-priority 100
 
 # LRU, LFU and minimal TTL algorithms are not precise algorithms but approximated
 # algorithms (in order to save memory), so you can tune it for speed or
-# accuracy. For default Redis will check five keys and pick the one that was
+# accuracy. For default KeyDB will check five keys and pick the one that was
 # used less recently, you can change the sample size using the following
 # configuration directive.
 #
@@ -747,16 +747,16 @@ replica-priority 100
 
 ############################# LAZY FREEING ####################################
 
-# Redis has two primitives to delete keys. One is called DEL and is a blocking
+# KeyDB has two primitives to delete keys. One is called DEL and is a blocking
 # deletion of the object. It means that the server stops processing new commands
 # in order to reclaim all the memory associated with an object in a synchronous
 # way. If the key deleted is associated with a small object, the time needed
 # in order to execute the DEL command is very small and comparable to most other
-# O(1) or O(log_N) commands in Redis. However if the key is associated with an
+# O(1) or O(log_N) commands in KeyDB. However if the key is associated with an
 # aggregated value containing millions of elements, the server can block for
 # a long time (even seconds) in order to complete the operation.
 #
-# For the above reasons Redis also offers non blocking deletion primitives
+# For the above reasons KeyDB also offers non blocking deletion primitives
 # such as UNLINK (non blocking DEL) and the ASYNC option of FLUSHALL and
 # FLUSHDB commands, in order to reclaim memory in background. Those commands
 # are executed in constant time. Another thread will incrementally free the
@@ -764,9 +764,9 @@ replica-priority 100
 #
 # DEL, UNLINK and ASYNC option of FLUSHALL and FLUSHDB are user-controlled.
 # It's up to the design of the application to understand when it is a good
-# idea to use one or the other. However the Redis server sometimes has to
+# idea to use one or the other. However the KeyDB server sometimes has to
 # delete keys or flush the whole database as a side effect of other operations.
-# Specifically Redis deletes objects independently of a user call in the
+# Specifically KeyDB deletes objects independently of a user call in the
 # following scenarios:
 #
 # 1) On eviction, because of the maxmemory and maxmemory policy configurations,
@@ -796,20 +796,20 @@ replica-lazy-flush no
 
 ############################## APPEND ONLY MODE ###############################
 
-# By default Redis asynchronously dumps the dataset on disk. This mode is
-# good enough in many applications, but an issue with the Redis process or
+# By default KeyDB asynchronously dumps the dataset on disk. This mode is
+# good enough in many applications, but an issue with the KeyDB process or
 # a power outage may result into a few minutes of writes lost (depending on
 # the configured save points).
 #
 # The Append Only File is an alternative persistence mode that provides
 # much better durability. For instance using the default data fsync policy
-# (see later in the config file) Redis can lose just one second of writes in a
+# (see later in the config file) KeyDB can lose just one second of writes in a
 # dramatic event like a server power outage, or a single write if something
-# wrong with the Redis process itself happens, but the operating system is
+# wrong with the KeyDB process itself happens, but the operating system is
 # still running correctly.
 #
 # AOF and RDB persistence can be enabled at the same time without problems.
-# If the AOF is enabled on startup Redis will load the AOF, that is the file
+# If the AOF is enabled on startup KeyDB will load the AOF, that is the file
 # with the better durability guarantees.
 #
 # Please check http://redis.io/topics/persistence for more information.
@@ -824,7 +824,7 @@ appendfilename "appendonly.aof"
 # instead of waiting for more data in the output buffer. Some OS will really flush
 # data on disk, some other OS will just try to do it ASAP.
 #
-# Redis supports three different modes:
+# KeyDB supports three different modes:
 #
 # no: don't fsync, just let the OS flush the data when it wants. Faster.
 # always: fsync after every write to the append only log. Slow, Safest.
@@ -850,7 +850,7 @@ appendfsync everysec
 # When the AOF fsync policy is set to always or everysec, and a background
 # saving process (a background save or AOF log background rewriting) is
 # performing a lot of I/O against the disk, in some Linux configurations
-# Redis may block too long on the fsync() call. Note that there is no fix for
+# KeyDB may block too long on the fsync() call. Note that there is no fix for
 # this currently, as even performing fsync in a different thread will block
 # our synchronous write(2) call.
 #
@@ -858,7 +858,7 @@ appendfsync everysec
 # that will prevent fsync() from being called in the main process while a
 # BGSAVE or BGREWRITEAOF is in progress.
 #
-# This means that while another child is saving, the durability of Redis is
+# This means that while another child is saving, the durability of KeyDB is
 # the same as "appendfsync none". In practical terms, this means that it is
 # possible to lose up to 30 seconds of log in the worst scenario (with the
 # default Linux settings).
@@ -869,10 +869,10 @@ appendfsync everysec
 no-appendfsync-on-rewrite no
 
 # Automatic rewrite of the append only file.
-# Redis is able to automatically rewrite the log file implicitly calling
+# KeyDB is able to automatically rewrite the log file implicitly calling
 # BGREWRITEAOF when the AOF log size grows by the specified percentage.
 #
-# This is how it works: Redis remembers the size of the AOF file after the
+# This is how it works: KeyDB remembers the size of the AOF file after the
 # latest rewrite (if no rewrite has happened since the restart, the size of
 # the AOF at startup is used).
 #
@@ -888,19 +888,19 @@ no-appendfsync-on-rewrite no
 auto-aof-rewrite-percentage 100
 auto-aof-rewrite-min-size 64mb
 
-# An AOF file may be found to be truncated at the end during the Redis
+# An AOF file may be found to be truncated at the end during the KeyDB
 # startup process, when the AOF data gets loaded back into memory.
-# This may happen when the system where Redis is running
+# This may happen when the system where KeyDB is running
 # crashes, especially when an ext4 filesystem is mounted without the
-# data=ordered option (however this can't happen when Redis itself
+# data=ordered option (however this can't happen when KeyDB itself
 # crashes or aborts but the operating system still works correctly).
 #
-# Redis can either exit with an error when this happens, or load as much
+# KeyDB can either exit with an error when this happens, or load as much
 # data as possible (the default now) and start if the AOF file is found
 # to be truncated at the end. The following option controls this behavior.
 #
 # If aof-load-truncated is set to yes, a truncated AOF file is loaded and
-# the Redis server starts emitting a log to inform the user of the event.
+# the KeyDB server starts emitting a log to inform the user of the event.
 # Otherwise if the option is set to no, the server aborts with an error
 # and refuses to start. When the option is set to no, the user requires
 # to fix the AOF file using the "keydb-check-aof" utility before to restart
@@ -908,17 +908,17 @@ auto-aof-rewrite-min-size 64mb
 #
 # Note that if the AOF file will be found to be corrupted in the middle
 # the server will still exit with an error. This option only applies when
-# Redis will try to read more data from the AOF file but not enough bytes
+# KeyDB will try to read more data from the AOF file but not enough bytes
 # will be found.
 aof-load-truncated yes
 
-# When rewriting the AOF file, Redis is able to use an RDB preamble in the
+# When rewriting the AOF file, KeyDB is able to use an RDB preamble in the
 # AOF file for faster rewrites and recoveries. When this option is turned
 # on the rewritten AOF file is composed of two different stanzas:
 #
 #   [RDB file][AOF tail]
 #
-# When loading Redis recognizes that the AOF file starts with the "REDIS"
+# When loading KeyDB recognizes that the AOF file starts with the "REDIS"
 # string and loads the prefixed RDB file, and continues loading the AOF
 # tail.
 aof-use-rdb-preamble yes
@@ -927,7 +927,7 @@ aof-use-rdb-preamble yes
 
 # Max execution time of a Lua script in milliseconds.
 #
-# If the maximum execution time is reached Redis will log that a script is
+# If the maximum execution time is reached KeyDB will log that a script is
 # still in execution after the maximum allowed time and will start to
 # reply to queries with an error.
 #
@@ -941,23 +941,17 @@ aof-use-rdb-preamble yes
 # Set it to 0 or a negative value for unlimited execution without warnings.
 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
+################################ KEYDB CLUSTER  ###############################
+
+# Normal KeyDB instances can't be part of a KeyDB Cluster; only nodes that are
+# started as cluster nodes can. In order to start a KeyDB instance as a
 # cluster node enable the cluster support uncommenting the following:
 #
 # cluster-enabled yes
 
 # Every cluster node has a cluster configuration file. This file is not
-# intended to be edited by hand. It is created and updated by Redis nodes.
-# Every Redis Cluster node requires a different cluster configuration file.
+# intended to be edited by hand. It is created and updated by KeyDB nodes.
+# Every KeyDB Cluster node requires a different cluster configuration file.
 # Make sure that instances running in the same system do not have
 # overlapping cluster configuration file names.
 #
@@ -1033,7 +1027,7 @@ lua-time-limit 5000
 #
 # cluster-migration-barrier 1
 
-# By default Redis Cluster nodes stop accepting queries if they detect there
+# By default KeyDB Cluster nodes stop accepting queries if they detect there
 # is at least an hash slot uncovered (no available node is serving it).
 # This way if the cluster is partially down (for example a range of hash slots
 # are no longer covered) all the cluster becomes, eventually, unavailable.
@@ -1061,11 +1055,11 @@ lua-time-limit 5000
 
 ########################## CLUSTER DOCKER/NAT support  ########################
 
-# In certain deployments, Redis Cluster nodes address discovery fails, because
+# In certain deployments, KeyDB Cluster nodes address discovery fails, because
 # addresses are NAT-ted or because ports are forwarded (the typical case is
 # Docker and other containers).
 #
-# In order to make Redis Cluster working in such environments, a static
+# In order to make KeyDB Cluster working in such environments, a static
 # configuration where each node knows its public address is needed. The
 # following two options are used for this scope, and are:
 #
@@ -1078,7 +1072,7 @@ lua-time-limit 5000
 # so that other nodes will be able to correctly map the address of the node
 # publishing the information.
 #
-# If the above options are not used, the normal Redis Cluster auto-detection
+# If the above options are not used, the normal KeyDB Cluster auto-detection
 # will be used instead.
 #
 # Note that when remapped, the bus port may not be at the fixed offset of
@@ -1094,14 +1088,14 @@ lua-time-limit 5000
 
 ################################## SLOW LOG ###################################
 
-# The Redis Slow Log is a system to log queries that exceeded a specified
+# The KeyDB Slow Log is a system to log queries that exceeded a specified
 # execution time. The execution time does not include the I/O operations
 # like talking with the client, sending the reply and so forth,
 # but just the time needed to actually execute the command (this is the only
 # stage of command execution where the thread is blocked and can not serve
 # other requests in the meantime).
 #
-# You can configure the slow log with two parameters: one tells Redis
+# You can configure the slow log with two parameters: one tells KeyDB
 # what is the execution time, in microseconds, to exceed in order for the
 # command to get logged, and the other parameter is the length of the
 # slow log. When a new command is logged the oldest one is removed from the
@@ -1118,9 +1112,9 @@ slowlog-max-len 128
 
 ################################ LATENCY MONITOR ##############################
 
-# The Redis latency monitoring subsystem samples different operations
+# The KeyDB latency monitoring subsystem samples different operations
 # at runtime in order to collect data related to possible sources of
-# latency of a Redis instance.
+# latency of a KeyDB instance.
 #
 # Via the LATENCY command this information is available to the user that can
 # print graphs and obtain reports.
@@ -1139,7 +1133,7 @@ latency-monitor-threshold 0
 
 ############################# EVENT NOTIFICATION ##############################
 
-# Redis can notify Pub/Sub clients about events happening in the key space.
+# KeyDB can notify Pub/Sub clients about events happening in the key space.
 # This feature is documented at http://redis.io/topics/notifications
 #
 # For instance if keyspace events notification is enabled, and a client
@@ -1149,7 +1143,7 @@ latency-monitor-threshold 0
 # PUBLISH __keyspace@0__:foo del
 # PUBLISH __keyevent@0__:del foo
 #
-# It is possible to select the events that Redis will notify among a set
+# It is possible to select the events that KeyDB will notify among a set
 # of classes. Every class is identified by a single character:
 #
 #  K     Keyspace events, published with __keyspace@<db>__ prefix.
@@ -1185,12 +1179,12 @@ notify-keyspace-events ""
 
 ############################### GOPHER SERVER #################################
 
-# Redis contains an implementation of the Gopher protocol, as specified in
+# KeyDB contains an implementation of the Gopher protocol, as specified in
 # the RFC 1436 (https://www.ietf.org/rfc/rfc1436.txt).
 #
 # The Gopher protocol was very popular in the late '90s. It is an alternative 
 # to the web, and the implementation both server and client side is so simple
-# that the Redis server has just 100 lines of code in order to implement this
+# that the KeyDB server has just 100 lines of code in order to implement this
 # support.
 #
 # What do you do with Gopher nowadays? Well Gopher never *really* died, and
@@ -1200,18 +1194,18 @@ notify-keyspace-events ""
 # controlled, and it's cool to create an alternative space for people that
 # want a bit of fresh air.
 #
-# Anyway for the 10nth birthday of the Redis, we gave it the Gopher protocol
+# Anyway for the 10nth birthday of the KeyDB, we gave it the Gopher protocol
 # as a gift.
 #
 # --- HOW IT WORKS? ---
 #
-# The Redis Gopher support uses the inline protocol of Redis, and specifically
+# The KeyDB Gopher support uses the inline protocol of KeyDB, and specifically
 # two kind of inline requests that were anyway illegal: an empty request
-# or any request that starts with "/" (there are no Redis commands starting
+# or any request that starts with "/" (there are no KeyDB commands starting
 # with such a slash). Normal RESP2/RESP3 requests are completely out of the
 # path of the Gopher protocol implementation and are served as usually as well.
 #
-# If you open a connection to Redis when Gopher is enabled and send it
+# If you open a connection to KeyDB when Gopher is enabled and send it
 # a string like "/foo", if there is a key named "/foo" it is served via the
 # Gopher protocol.
 #
@@ -1222,7 +1216,7 @@ notify-keyspace-events ""
 #
 # --- SECURITY WARNING ---
 #
-# If you plan to put Redis on the internet in a publicly accessible address
+# If you plan to put KeyDB on the internet in a publicly accessible address
 # to server Gopher pages MAKE SURE TO SET A PASSWORD to the instance.
 # Once a password is set:
 #
@@ -1316,8 +1310,8 @@ stream-node-max-bytes 4096
 stream-node-max-entries 100
 
 # Active rehashing uses 1 millisecond every 100 milliseconds of CPU time in
-# order to help rehashing the main Redis hash table (the one mapping top-level
-# keys to values). The hash table implementation Redis uses (see dict.c)
+# order to help rehashing the main KeyDB hash table (the one mapping top-level
+# keys to values). The hash table implementation KeyDB uses (see dict.c)
 # performs a lazy rehashing: the more operation you run into a hash table
 # that is rehashing, the more rehashing "steps" are performed, so if the
 # server is idle the rehashing is never complete and some more memory is used
@@ -1328,7 +1322,7 @@ stream-node-max-entries 100
 #
 # If unsure:
 # use "activerehashing no" if you have hard latency requirements and it is
-# not a good thing in your environment that Redis can reply from time to time
+# not a good thing in your environment that KeyDB can reply from time to time
 # to queries with 2 milliseconds delay.
 #
 # use "activerehashing yes" if you don't have such hard requirements but
@@ -1380,21 +1374,21 @@ client-output-buffer-limit pubsub 32mb 8mb 60
 #
 # client-query-buffer-limit 1gb
 
-# In the Redis protocol, bulk requests, that are, elements representing single
+# In the KeyDB protocol, bulk requests, that are, elements representing single
 # strings, are normally limited ot 512 mb. However you can change this limit
 # here.
 #
 # proto-max-bulk-len 512mb
 
-# Redis calls an internal function to perform many background tasks, like
+# KeyDB calls an internal function to perform many background tasks, like
 # closing connections of clients in timeout, purging expired keys that are
 # never requested, and so forth.
 #
-# Not all tasks are performed with the same frequency, but Redis checks for
+# Not all tasks are performed with the same frequency, but KeyDB checks for
 # tasks to perform according to the specified "hz" value.
 #
 # By default "hz" is set to 10. Raising the value will use more CPU when
-# Redis is idle, but at the same time will make Redis more responsive when
+# KeyDB is idle, but at the same time will make KeyDB more responsive when
 # there are many keys expiring at the same time, and timeouts may be
 # handled with more precision.
 #
@@ -1408,7 +1402,7 @@ hz 10
 # avoid too many clients are processed for each background task invocation
 # in order to avoid latency spikes.
 #
-# Since the default HZ value by default is conservatively set to 10, Redis
+# Since the default HZ value by default is conservatively set to 10, KeyDB
 # offers, and enables by default, the ability to use an adaptive HZ value
 # which will temporary raise when there are many connected clients.
 #
@@ -1425,22 +1419,22 @@ dynamic-hz yes
 # big latency spikes.
 aof-rewrite-incremental-fsync yes
 
-# When redis saves RDB file, if the following option is enabled
+# When KeyDB saves RDB file, if the following option is enabled
 # the file will be fsync-ed every 32 MB of data generated. This is useful
 # in order to commit the file to the disk more incrementally and avoid
 # big latency spikes.
 rdb-save-incremental-fsync yes
 
-# Redis LFU eviction (see maxmemory setting) can be tuned. However it is a good
+# KeyDB LFU eviction (see maxmemory setting) can be tuned. However it is a good
 # idea to start with the default settings and only change them after investigating
 # how to improve the performances and how the keys LFU change over time, which
 # is possible to inspect via the OBJECT FREQ command.
 #
-# There are two tunable parameters in the Redis LFU implementation: the
+# There are two tunable parameters in the KeyDB LFU implementation: the
 # counter logarithm factor and the counter decay time. It is important to
 # understand what the two parameters mean before changing them.
 #
-# The LFU counter is just 8 bits per key, it's maximum value is 255, so Redis
+# The LFU counter is just 8 bits per key, it's maximum value is 255, so KeyDB
 # uses a probabilistic increment with logarithmic behavior. Given the value
 # of the old counter, when a key is accessed, the counter is incremented in
 # this way:
@@ -1492,7 +1486,7 @@ rdb-save-incremental-fsync yes
 # What is active defragmentation?
 # -------------------------------
 #
-# Active (online) defragmentation allows a Redis server to compact the
+# Active (online) defragmentation allows a KeyDB server to compact the
 # spaces left between small allocations and deallocations of data in memory,
 # thus allowing to reclaim back memory.
 #
@@ -1504,7 +1498,7 @@ rdb-save-incremental-fsync yes
 # in an "hot" way, while the server is running.
 #
 # Basically when the fragmentation is over a certain level (see the
-# configuration options below) Redis will start to create new copies of the
+# configuration options below) KeyDB will start to create new copies of the
 # values in contiguous memory regions by exploiting certain specific Jemalloc
 # features (in order to understand if an allocation is causing fragmentation
 # and to allocate it in a better place), and at the same time, will release the
@@ -1513,8 +1507,8 @@ rdb-save-incremental-fsync yes
 #
 # Important things to understand:
 #
-# 1. This feature is disabled by default, and only works if you compiled Redis
-#    to use the copy of Jemalloc we ship with the source code of Redis.
+# 1. This feature is disabled by default, and only works if you compiled KeyDB
+#    to use the copy of Jemalloc we ship with the source code of KeyDB.
 #    This is the default with Linux builds.
 #
 # 2. You never need to enable this feature if you don't have fragmentation
@@ -1567,3 +1561,10 @@ server-threads 2
 # replicas will still sync in the normal way and incorrect ordering when
 # bringing up replicas can result in data loss (the first master will win).
 # active-replica yes
+
+# Enable Pro?  KeyDB pro provides support for pro only features
+#   note: you may omit the license key to demo pro features for a limited time
+# enable-pro [License Key]
+
+# Enable FLASH support? (Pro Only)
+# storage-provider flash /path/to/flash/db

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/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,15 @@ endif
 endif
 
 USEASM?=true
+
+ifneq ($(SANITIZE),)
+	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)
@@ -65,12 +74,18 @@ endif
 # To get ARM stack traces if Redis crashes we need a special C flag.
 ifneq (,$(filter aarch64 armv,$(uname_M)))
         CFLAGS+=-funwind-tables
+	CXXFLAGS+=-funwind-tables
 else
 ifneq (,$(findstring armv,$(uname_M)))
         CFLAGS+=-funwind-tables
+	CXXFLAGS+=-funwind-tables
 endif
 endif
 
+ifneq (,$(findstring armv,$(uname_M)))
+	FINAL_LIBS+=-latomic
+endif	
+
 # Backwards compatibility for selecting an allocator
 ifeq ($(USE_TCMALLOC),yes)
 	MALLOC=tcmalloc
@@ -92,22 +107,24 @@ endif
 -include .make-settings
 
 FINAL_CFLAGS=$(STD) $(WARN) $(OPT) $(DEBUG) $(CFLAGS) $(REDIS_CFLAGS)
-FINAL_CXXFLAGS=$(CXX_STD) $(WARN) $(OPT) $(DEBUG) $(CFLAGS) $(CXXFLAGS) $(REDIS_CFLAGS)
+FINAL_CXXFLAGS=$(CXX_STD) $(WARN) $(OPT) $(DEBUG) $(CXXFLAGS) $(REDIS_CFLAGS)
 FINAL_LDFLAGS=$(LDFLAGS) $(REDIS_LDFLAGS) $(DEBUG)
-FINAL_LIBS=-lm
+FINAL_LIBS+=-lm -lcurl
 DEBUG=-g -ggdb
 
 ifeq ($(uname_S),SunOS)
 	# SunOS
         ifneq ($(@@),32bit)
 		CFLAGS+= -m64
+		CXXFLAGS+= -m64
 		LDFLAGS+= -m64
 	endif
 	DEBUG=-g
 	DEBUG_FLAGS=-g
-	export CFLAGS LDFLAGS DEBUG DEBUG_FLAGS
+	export CFLAGS CXXFLAGS LDFLAGS DEBUG DEBUG_FLAGS
 	INSTALL=cp -pf
 	FINAL_CFLAGS+= -D__EXTENSIONS__ -D_XPG6
+	FINAL_CXXFLAGS+= -D__EXTENSIONS__ -D_XPG6
 	FINAL_LIBS+= -ldl -lnsl -lsocket -lresolv -lpthread -lrt
 else
 ifeq ($(uname_S),Darwin)
@@ -124,6 +141,7 @@ ifeq ($(uname_S),OpenBSD)
 	FINAL_LIBS+= -lpthread
 	ifeq ($(USE_BACKTRACE),yes)
 	    FINAL_CFLAGS+= -DUSE_BACKTRACE -I/usr/local/include
+	    FINAL_CXXFLAGS+= -DUSE_BACKTRACE -I/usr/local/include
 	    FINAL_LDFLAGS+= -L/usr/local/lib
 	    FINAL_LIBS+= -lexecinfo
     	endif
@@ -140,6 +158,8 @@ else
 	# All the other OSes (notably Linux)
 	FINAL_LDFLAGS+= -rdynamic
 	FINAL_LIBS+=-ldl -pthread -lrt -luuid
+	FINAL_CFLAGS += -DMOTD
+	FINAL_CXXFLAGS += -DMOTD
 endif
 endif
 endif
@@ -177,8 +197,8 @@ ifeq ($(MALLOC),memkind)
 endif
 
 REDIS_CC=$(QUIET_CC)$(CC) $(FINAL_CFLAGS)
-REDIS_CXX=$(QUIET_CC)$(CC) $(FINAL_CXXFLAGS)
-REDIS_NASM=$(QUIET_CC)nasm -felf64 
+REDIS_CXX=$(QUIET_CC)$(CXX) $(FINAL_CXXFLAGS)
+KEYDB_AS=$(QUIET_CC) as --64 -g
 REDIS_LD=$(QUIET_LINK)$(CXX) $(FINAL_LDFLAGS)
 REDIS_INSTALL=$(QUIET_INSTALL)$(INSTALL)
 
@@ -190,18 +210,18 @@ MAKECOLOR="\033[32;1m"
 ENDCOLOR="\033[0m"
 
 ifndef V
-QUIET_CC = @printf '    %b %b\n' $(CCCOLOR)CC$(ENDCOLOR) $(SRCCOLOR)$@$(ENDCOLOR) 1>&2;
-QUIET_LINK = @printf '    %b %b\n' $(LINKCOLOR)LINK$(ENDCOLOR) $(BINCOLOR)$@$(ENDCOLOR) 1>&2;
-QUIET_INSTALL = @printf '    %b %b\n' $(LINKCOLOR)INSTALL$(ENDCOLOR) $(BINCOLOR)$@$(ENDCOLOR) 1>&2;
+QUIET_CC = @printf '    %b %b\n' $(CCCOLOR)CC$(ENDCOLOR) $(SRCCOLOR)$@$(ENDCOLOR);
+QUIET_LINK = @printf '    %b %b\n' $(LINKCOLOR)LINK$(ENDCOLOR) $(BINCOLOR)$@$(ENDCOLOR);
+QUIET_INSTALL = @printf '    %b %b\n' $(LINKCOLOR)INSTALL$(ENDCOLOR) $(BINCOLOR)$@$(ENDCOLOR);
 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 cron.o motd.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 motd.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
 
@@ -225,10 +245,13 @@ persist-settings: distclean
 	echo OPT=$(OPT) >> .make-settings
 	echo MALLOC=$(MALLOC) >> .make-settings
 	echo CFLAGS=$(CFLAGS) >> .make-settings
+	echo CXXFLAGS=$(CXXFLAGS) >> .make-settings
 	echo LDFLAGS=$(LDFLAGS) >> .make-settings
 	echo REDIS_CFLAGS=$(REDIS_CFLAGS) >> .make-settings
+	echo REDIS_CXXFLAGS=$(REDIS_CXXFLAGS) >> .make-settings
 	echo REDIS_LDFLAGS=$(REDIS_LDFLAGS) >> .make-settings
 	echo PREV_FINAL_CFLAGS=$(FINAL_CFLAGS) >> .make-settings
+	echo PREV_FINAL_CXXFLAGS=$(FINAL_CXXFLAGS) >> .make-settings
 	echo PREV_FINAL_LDFLAGS=$(FINAL_LDFLAGS) >> .make-settings
 	-(cd modules && $(MAKE))
 	-(cd ../deps && $(MAKE) $(DEPENDENCY_TARGETS))
@@ -239,6 +262,8 @@ persist-settings: distclean
 # Clean everything, persist settings and build dependencies if anything changed
 ifneq ($(strip $(PREV_FINAL_CFLAGS)), $(strip $(FINAL_CFLAGS)))
 .make-prerequisites: persist-settings
+else ifneq ($(strip $(PREV_FINAL_CXXFLAGS)), $(strip $(FINAL_CXXFLAGS)))
+.make-prerequisites: persist-settings
 else ifneq ($(strip $(PREV_FINAL_LDFLAGS)), $(strip $(FINAL_LDFLAGS)))
 .make-prerequisites: persist-settings
 else
@@ -273,20 +298,25 @@ $(REDIS_BENCHMARK_NAME): $(REDIS_BENCHMARK_OBJ)
 dict-benchmark: dict.cpp zmalloc.cpp sds.c siphash.c
 	$(REDIS_CC) $(FINAL_CFLAGS) $^ -D DICT_BENCHMARK_MAIN -o $@ $(FINAL_LIBS)
 
+
+DEP = $(REDIS_SERVER_OBJ:%.o=%.d) $(REDIS_CLI_OBJ:%.o=%.d) $(REDIS_BENCHMARK_OBJ:%.o=%.d)
+-include $(DEP)
+
 # Because the jemalloc.h header is generated as a part of the jemalloc build,
 # building it should complete before building any other object. Instead of
 # depending on a single artifact, build all dependencies first.
 %.o: %.c .make-prerequisites
-	$(REDIS_CC) -c $<
+	$(REDIS_CC) -MMD -c $<
 
 %.o: %.cpp .make-prerequisites
-	$(REDIS_CXX) -c $<
+	$(REDIS_CXX) -MMD -c $<
 
 %.o: %.asm .make-prerequisites
-	$(REDIS_NASM) $<
+	$(KEYDB_AS) $< -o $@
 
 clean:
 	rm -rf $(REDIS_SERVER_NAME) $(REDIS_SENTINEL_NAME) $(REDIS_CLI_NAME) $(REDIS_BENCHMARK_NAME) $(REDIS_CHECK_RDB_NAME) $(REDIS_CHECK_AOF_NAME) *.o *.gcda *.gcno *.gcov redis.info lcov-html Makefile.dep dict-benchmark
+	rm -f $(DEP)
 
 .PHONY: clean
 
@@ -324,7 +354,7 @@ bench: $(REDIS_BENCHMARK_NAME)
 	@echo ""
 	@echo "WARNING: if it fails under Linux you probably need to install libc6-dev-i386"
 	@echo ""
-	$(MAKE) CFLAGS="-m32" LDFLAGS="-m32"
+	$(MAKE) CXXFLAGS="-m32" CFLAGS="-m32" LDFLAGS="-m32"
 
 gcov:
 	$(MAKE) REDIS_CFLAGS="-fprofile-arcs -ftest-coverage -DCOVERAGE_TEST" REDIS_LDFLAGS="-fprofile-arcs -ftest-coverage"

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,8 +1122,8 @@ 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
- * users in the redis.conf configuration or in the ACL file, that is:
+ * is validated and should be either empty or in the format used to specify
+ * users in the keydb.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);
 
@@ -1345,17 +1347,17 @@ cleanup:
 
 /* This function is called once the server is already running, modules are
  * loaded, and we are ready to start, in order to load the ACLs either from
- * the pending list of users defined in redis.conf, or from the ACL file.
+ * the pending list of users defined in keydb.conf, or from the ACL file.
  * The function will just exit with an error if the user is trying to mix
  * both the loading methods. */
 void ACLLoadUsersAtStartup(void) {
     if (g_pserver->acl_filename[0] != '\0' && listLength(UsersToLoad) != 0) {
         serverLog(LL_WARNING,
-            "Configuring Redis with users defined in redis.conf and at "
+            "Configuring KeyDB with users defined in keydb.conf and at "
             "the same setting an ACL file path is invalid. This setup "
             "is very likely to lead to configuration errors and security "
             "holes, please define either an ACL file or declare users "
-            "directly in your redis.conf, but not both.");
+            "directly in your keydb.conf, but not both.");
         exit(1);
     }
 
@@ -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

@@ -80,11 +80,11 @@ public:
 mutex_wrapper g_lock;
 
 #else
-fastlock g_lock;
+fastlock g_lock("AE (global)");
 #endif
 thread_local aeEventLoop *g_eventLoopThisThread = NULL;
 
-#define AE_ASSERT(x) if (!(x)) do { fprintf(stderr, "AE_ASSER FAILURE\n"); *((volatile int*)0) = 1; } while(0)
+#define AE_ASSERT(x) if (!(x)) do { fprintf(stderr, "AE_ASSERT FAILURE %s: %d\n", __FILE__, __LINE__); *((volatile int*)1) = 1; } while(0)
 
 /* Include the best multiplexing layer supported by this system.
  * The following should be ordered by performances, descending. */
@@ -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;
@@ -207,20 +237,22 @@ int aeCreateRemoteFileEvent(aeEventLoop *eventLoop, int fd, int mask,
     cmd.clientData = clientData;
     cmd.pctl = nullptr;
     if (fSynchronous)
+    {
         cmd.pctl = new (MALLOC_LOCAL) aeCommandControl();
-
-    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;
     }
     
     if (fSynchronous)
     {
+        std::unique_lock<std::mutex> ulock(cmd.pctl->mutexcv, std::defer_lock);
         cmd.pctl->cv.wait(ulock);
         ret = cmd.pctl->rval;
         delete cmd.pctl;
@@ -236,12 +268,13 @@ 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;
     auto size = write(eventLoop->fdCmdWrite, &cmd, sizeof(cmd));
-    AE_ASSERT(size == sizeof(cmd));
+    if (size != sizeof(cmd))
+        return AE_ERR;
     return AE_OK;
 }
 
@@ -253,20 +286,24 @@ 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;
     if (fSynchronous)
+    {
         cmd.pctl = new (MALLOC_LOCAL) aeCommandControl();
-    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));
+    if (size != sizeof(cmd))
+        return AE_ERR;
     AE_ASSERT(size == sizeof(cmd));
     int ret = AE_OK;
     if (fSynchronous)
     {
+        std::unique_lock<std::mutex> ulock(cmd.pctl->mutexcv, std::defer_lock);
         cmd.pctl->cv.wait(ulock);
         ret = cmd.pctl->rval;
         delete cmd.pctl;
@@ -296,7 +333,7 @@ aeEventLoop *aeCreateEventLoop(int setsize) {
     for (i = 0; i < setsize; i++)
         eventLoop->events[i].mask = AE_NONE;
 
-    fastlock_init(&eventLoop->flock);
+    fastlock_init(&eventLoop->flock, "event loop");
     int rgfd[2];
     if (pipe(rgfd) < 0)
         goto err;
@@ -353,10 +390,18 @@ extern "C" void aeDeleteEventLoop(aeEventLoop *eventLoop) {
     aeApiFree(eventLoop);
     zfree(eventLoop->events);
     zfree(eventLoop->fired);
-    zfree(eventLoop);
     fastlock_free(&eventLoop->flock);
     close(eventLoop->fdCmdRead);
     close(eventLoop->fdCmdWrite);
+
+    auto *te = eventLoop->timeEventHead;
+    while (te)
+    {
+        auto *teNext = te->next;
+        zfree(te);
+        te = teNext;
+    }
+    zfree(eventLoop);
 }
 
 extern "C" void aeStop(aeEventLoop *eventLoop) {
@@ -803,9 +848,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);
@@ -123,6 +124,21 @@ void aofChildWriteDiffData(aeEventLoop *el, int fd, void *privdata, int mask) {
     }
 }
 
+void installAofRewriteEvent()
+{
+    serverTL->fRetrySetAofEvent = false;
+    if (!g_pserver->aof_rewrite_pending) {
+        g_pserver->aof_rewrite_pending = true;
+        int res = aePostFunction(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el, [] {
+            g_pserver->aof_rewrite_pending = false;
+            if (g_pserver->aof_pipe_write_data_to_child >= 0)
+                aeCreateFileEvent(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el, g_pserver->aof_pipe_write_data_to_child, AE_WRITABLE, aofChildWriteDiffData, NULL);
+        });
+        if (res != AE_OK)
+            serverTL->fRetrySetAofEvent = true;
+    }
+}
+
 /* Append data to the AOF rewrite buffer, allocating new blocks if needed. */
 void aofRewriteBufferAppend(unsigned char *s, unsigned long len) {
     listNode *ln = listLast(g_pserver->aof_rewrite_buf_blocks);
@@ -164,10 +180,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);
-    }
+    installAofRewriteEvent();
 }
 
 /* Write the buffer (possibly composed of multiple blocks) into the specified
@@ -199,6 +212,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) {
@@ -337,10 +356,27 @@ void flushAppendOnlyFile(int force) {
     int sync_in_progress = 0;
     mstime_t latency;
 
-    if (sdslen(g_pserver->aof_buf) == 0) return;
+    if (serverTL->fRetrySetAofEvent)
+        installAofRewriteEvent();
+
+    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.
@@ -472,6 +508,7 @@ 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 &&
@@ -486,10 +523,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 +684,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();
@@ -655,7 +696,7 @@ client *createFakeClient(void) {
     c->puser = NULL;
     listSetFreeMethod(c->reply,freeClientReplyValue);
     listSetDupMethod(c->reply,dupClientReplyValue);
-    fastlock_init(&c->lock);
+    fastlock_init(&c->lock, "fake client");
     fastlock_lock(&c->lock);
     initClientMultiState(c);
     return c;
@@ -703,6 +744,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 +768,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 +884,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. */
@@ -1294,13 +1337,12 @@ int rewriteAppendOnlyFileRio(rio *aof) {
         while((de = dictNext(di)) != NULL) {
             sds keystr;
             robj key, *o;
-            long long expiretime;
 
             keystr = (sds)dictGetKey(de);
             o = (robj*)dictGetVal(de);
             initStaticStringObject(key,keystr);
 
-            expiretime = getExpire(db,&key);
+            expireEntry *pexpire = getExpire(db,&key);
 
             /* Save the key and associated value */
             if (o->type == OBJ_STRING) {
@@ -1326,11 +1368,23 @@ int rewriteAppendOnlyFileRio(rio *aof) {
                 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) goto werr;
+                        if (rioWriteBulkObject(aof,&key) == 0) goto werr;
+                    }
+                    else
+                    {
+                        char cmd[]="*4\r\n$12\r\nEXPIREMEMBER\r\n";
+                        if (rioWrite(aof,cmd,sizeof(cmd)-1) == 0) goto werr;
+                        if (rioWriteBulkObject(aof,&key) == 0) goto werr;
+                        if (rioWrite(aof,subExpire.subkey(),sdslen(subExpire.subkey())) == 0) goto werr;
+                    }
+                    if (rioWriteBulkLongLong(aof,subExpire.when()) == 0) goto werr; // common
+                }
             }
             /* Read some diff from the parent process from time to time. */
             if (aof->processed_bytes > processed+AOF_READ_DIFF_INTERVAL_BYTES) {
@@ -1373,7 +1427,7 @@ 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);
@@ -1481,7 +1535,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 +1573,23 @@ 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;
+    int res = aePostFunction(g_pserver->el_alf_pip_read_ack_from_child, [fdAofAckPipe]{
+        aeDeleteFileEventAsync(serverTL->el,fdAofAckPipe,AE_READABLE);
+        close (fdAofAckPipe);
+    });
+    serverAssert(res == AE_OK);
+
+    int fdAofWritePipe = g_pserver->aof_pipe_write_data_to_child;
+    res = aePostFunction(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el, [fdAofWritePipe]{
+        aeDeleteFileEventAsync(serverTL->el,fdAofWritePipe,AE_WRITABLE);
+        close(fdAofWritePipe);
+    });
+    serverAssert(res == AE_OK);
+    g_pserver->aof_pipe_write_data_to_child = -1;
+    
     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);
 }

src/asciilogo.h

@@ -36,4 +36,6 @@ const char *ascii_logo =
 "                                        Port: %d\n"
 "                                        PID: %ld\n"
 "                                                                     \n"
-"                                                                     \n\n";
+"                     %s\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

@@ -295,6 +295,15 @@ int clusterLoadConfig(char *filename) {
     if (clusterGetMaxEpoch() > g_pserver->cluster->currentEpoch) {
         g_pserver->cluster->currentEpoch = clusterGetMaxEpoch();
     }
+
+    if (dictSize(g_pserver->cluster->nodes) > 1 && cserver.thread_min_client_threshold < 100)
+    {
+        // Because we expect the individual load of a client to be much less in a cluster (it will spread over multiple server)
+        //  we can increase the grouping of clients on a single thread within reason
+        cserver.thread_min_client_threshold *= dictSize(g_pserver->cluster->nodes);
+        cserver.thread_min_client_threshold = std::min(cserver.thread_min_client_threshold, 200);
+        serverLog(LL_NOTICE, "Expanding min-clients-per-thread to %d due to cluster", cserver.thread_min_client_threshold);
+    }
     return C_OK;
 
 fmterr:
@@ -499,7 +508,7 @@ void clusterInit(void) {
     }
 
     if (listenToPort(g_pserver->port+CLUSTER_PORT_INCR,
-        g_pserver->cfd,&g_pserver->cfd_count, 0 /*fReusePort*/) == C_ERR)
+        g_pserver->cfd,&g_pserver->cfd_count, 0 /*fReusePort*/, 0 /*fFirstListen*/) == C_ERR)
     {
         exit(1);
     } else {
@@ -617,6 +626,18 @@ clusterLink *createClusterLink(clusterNode *node) {
  * This function will just make sure that the original node associated
  * with this link will have the 'link' field set to NULL. */
 void freeClusterLink(clusterLink *link) {
+    if (ielFromEventLoop(serverTL->el) != IDX_EVENT_LOOP_MAIN)
+    {
+        // we can't perform this operation on this thread, queue it on the main thread
+        if (link->node)
+            link->node->link = NULL;
+        link->node = nullptr;
+        int res = aePostFunction(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el, [link]{
+            freeClusterLink(link);
+        });
+        serverAssert(res == AE_OK);
+        return;
+    }
     if (link->fd != -1) {
         aeDeleteFileEvent(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el, link->fd, AE_READABLE|AE_WRITABLE);
     }
@@ -643,11 +664,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);
@@ -2139,21 +2160,35 @@ void handleLinkIOError(clusterLink *link) {
  * consumed by write(). We don't try to optimize this for speed too much
  * as this is a very low traffic channel. */
 void clusterWriteHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
+    serverAssert(ielFromEventLoop(el) == IDX_EVENT_LOOP_MAIN);
     clusterLink *link = (clusterLink*) privdata;
     ssize_t nwritten;
     UNUSED(el);
     UNUSED(mask);
 
-    nwritten = write(fd, link->sndbuf, sdslen(link->sndbuf));
+    // We're about to release the lock, so the link's sndbuf needs to be owned fully by us
+    //  allocate a new one in case anyone tries to write while we're waiting
+    sds sndbuf = link->sndbuf;
+    link->sndbuf = sdsempty();
+
+    aeReleaseLock();
+    nwritten = write(fd, sndbuf, sdslen(sndbuf));
+    aeAcquireLock();
+
     if (nwritten <= 0) {
         serverLog(LL_DEBUG,"I/O error writing to node link: %s",
             (nwritten == -1) ? strerror(errno) : "short write");
+        sdsfree(sndbuf);
         handleLinkIOError(link);
         return;
     }
-    sdsrange(link->sndbuf,nwritten,-1);
+    sdsrange(sndbuf,nwritten,-1);
+    // Restore our send buffer, ensuring any unsent data is first
+    sndbuf = sdscat(sndbuf, link->sndbuf);
+    sdsfree(link->sndbuf);
+    link->sndbuf = sndbuf;
     if (sdslen(link->sndbuf) == 0)
-        aeDeleteFileEvent(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el, link->fd, AE_WRITABLE);
+        aeDeleteFileEvent(el, link->fd, AE_WRITABLE);
 }
 
 /* Read data. Try to read the first field of the header first to check the
@@ -2228,9 +2263,10 @@ void clusterReadHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
  * the link to be invalidated, so it is safe to call this function
  * from event handlers that will do stuff with the same link later. */
 void clusterSendMessage(clusterLink *link, unsigned char *msg, size_t msglen) {
+    serverAssert(GlobalLocksAcquired());
     if (sdslen(link->sndbuf) == 0 && msglen != 0)
-        aeCreateFileEvent(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el,link->fd,AE_WRITABLE|AE_BARRIER,
-                    clusterWriteHandler,link);
+        aeCreateRemoteFileEvent(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el,link->fd,AE_WRITABLE|AE_BARRIER,
+                    clusterWriteHandler,link,false);
 
     link->sndbuf = sdscatlen(link->sndbuf, msg, msglen);
 
@@ -3284,7 +3320,7 @@ void clusterHandleSlaveMigration(int max_slaves) {
 void resetManualFailover(void) {
     if (g_pserver->cluster->mf_end && clientsArePaused()) {
         g_pserver->clients_pause_end_time = 0;
-        clientsArePaused(); /* Just use the side effect of the function. */
+        unpauseClientsIfNecessary();
     }
     g_pserver->cluster->mf_end = 0; /* No manual failover in progress. */
     g_pserver->cluster->mf_can_start = 0;
@@ -3407,7 +3443,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 +3454,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);
@@ -4154,57 +4190,76 @@ void clusterReplyMultiBulkSlots(client *c) {
     dictIterator *di = dictGetSafeIterator(g_pserver->cluster->nodes);
     while((de = dictNext(di)) != NULL) {
         clusterNode *node = (clusterNode*)dictGetVal(de);
-        int j = 0, start = -1;
+        int start = -1;
 
         /* Skip slaves (that are iterated when producing the output of their
          * master) and  masters not serving any slot. */
         if (!nodeIsMaster(node) || node->numslots == 0) continue;
+        
+        static_assert((CLUSTER_SLOTS % (sizeof(uint32_t)*8)) == 0, "code below assumes the bitfield is a multiple of sizeof(unsinged)");
 
-        for (j = 0; j < CLUSTER_SLOTS; j++) {
-            int bit, i;
-
-            if ((bit = clusterNodeGetSlotBit(node,j)) != 0) {
-                if (start == -1) start = j;
+        for (unsigned iw = 0; iw < (CLUSTER_SLOTS/sizeof(uint32_t)/8); ++iw)
+        {
+            uint32_t wordCur = reinterpret_cast<uint32_t*>(node->slots)[iw];
+            if (iw != ((CLUSTER_SLOTS/sizeof(uint32_t)/8)-1))
+            {
+                if (start == -1 && wordCur == 0)
+                    continue;
+                if (start != -1 && (wordCur+1)==0)
+                    continue;
             }
-            if (start != -1 && (!bit || j == CLUSTER_SLOTS-1)) {
-                int nested_elements = 3; /* slots (2) + master addr (1). */
-                void *nested_replylen = addReplyDeferredLen(c);
 
-                if (bit && j == CLUSTER_SLOTS-1) j++;
-
-                /* If slot exists in output map, add to it's list.
-                 * else, create a new output map for this slot */
-                if (start == j-1) {
-                    addReplyLongLong(c, start); /* only one slot; low==high */
-                    addReplyLongLong(c, start);
-                } else {
-                    addReplyLongLong(c, start); /* low */
-                    addReplyLongLong(c, j-1);   /* high */
+            unsigned ibitStartLoop = iw*sizeof(uint32_t)*8;
+    
+            for (unsigned j = ibitStartLoop; j < (iw+1)*sizeof(uint32_t)*8; j++) {
+                int i;
+                int bit = (int)(wordCur & 1);
+                wordCur >>= 1;
+                if (bit != 0) {
+                    if (start == -1) start = j;
                 }
-                start = -1;
+                if (start != -1 && (!bit || j == CLUSTER_SLOTS-1)) {
+                    int nested_elements = 3; /* slots (2) + master addr (1). */
+                    void *nested_replylen = addReplyDeferredLen(c);
 
-                /* First node reply position is always the master */
-                addReplyArrayLen(c, 3);
-                addReplyBulkCString(c, node->ip);
-                addReplyLongLong(c, node->port);
-                addReplyBulkCBuffer(c, node->name, CLUSTER_NAMELEN);
+                    if (bit && j == CLUSTER_SLOTS-1) j++;
 
-                /* Remaining nodes in reply are replicas for slot range */
-                for (i = 0; i < node->numslaves; i++) {
-                    /* This loop is copy/pasted from clusterGenNodeDescription()
-                     * with modifications for per-slot node aggregation */
-                    if (nodeFailed(node->slaves[i])) continue;
+                    /* If slot exists in output map, add to it's list.
+                    * else, create a new output map for this slot */
+                    if (start == j-1) {
+                        addReplyLongLong(c, start); /* only one slot; low==high */
+                        addReplyLongLong(c, start);
+                    } else {
+                        addReplyLongLong(c, start); /* low */
+                        addReplyLongLong(c, j-1);   /* high */
+                    }
+                    start = -1;
+
+                    /* First node reply position is always the master */
                     addReplyArrayLen(c, 3);
-                    addReplyBulkCString(c, node->slaves[i]->ip);
-                    addReplyLongLong(c, node->slaves[i]->port);
-                    addReplyBulkCBuffer(c, node->slaves[i]->name, CLUSTER_NAMELEN);
-                    nested_elements++;
+                    addReplyBulkCString(c, node->ip);
+                    addReplyLongLong(c, node->port);
+                    addReplyBulkCBuffer(c, node->name, CLUSTER_NAMELEN);
+
+                    /* Remaining nodes in reply are replicas for slot range */
+                    for (i = 0; i < node->numslaves; i++) {
+                        /* This loop is copy/pasted from clusterGenNodeDescription()
+                        * with modifications for per-slot node aggregation */
+                        if (nodeFailed(node->slaves[i])) continue;
+                        addReplyArrayLen(c, 3);
+                        addReplyBulkCString(c, node->slaves[i]->ip);
+                        addReplyLongLong(c, node->slaves[i]->port);
+                        addReplyBulkCBuffer(c, node->slaves[i]->name, CLUSTER_NAMELEN);
+                        nested_elements++;
+                    }
+                    setDeferredArrayLen(c, nested_replylen, nested_elements);
+                    num_masters++;
                 }
-                setDeferredArrayLen(c, nested_replylen, nested_elements);
-                num_masters++;
             }
         }
+        serverAssert(start == -1);
     }
+    
     dictReleaseIterator(di);
     setDeferredArrayLen(c, slot_replylen, num_masters);
 }
@@ -4949,7 +5004,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 +5065,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 +5249,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 = getExpire(c->db,kv[j]);
+        long long expireat = -1;
+        if (pexpire != nullptr)
+            pexpire->FGetPrimaryExpire(&expireat);
 
         if (expireat != -1) {
             ttl = expireat-mstime();

src/compactvector.h

@@ -0,0 +1,153 @@
+#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(compactvector &) noexcept = delete;
+
+    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=(const compactvector&) noexcept = delete;
+    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;
@@ -352,7 +405,7 @@ void loadServerConfigFromString(char *config) {
         } else if ((!strcasecmp(argv[0],"slaveof") ||
                     !strcasecmp(argv[0],"replicaof")) && argc == 3) {
             slaveof_linenum = linenum;
-            replicationAddMaster(sdsnew(argv[1]), atoi(argv[2]));
+            replicationAddMaster(argv[1], atoi(argv[2]));
         } else if ((!strcasecmp(argv[0],"repl-ping-slave-period") ||
                     !strcasecmp(argv[0],"repl-ping-replica-period")) &&
                     argc == 2)
@@ -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,21 @@ 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 if (!strcasecmp(argv[0],"enable-pro")) {
+            cserver.fUsePro = true;
+            break;
+        } else if (!strcasecmp(argv[0],"min-clients-per-thread") && argc == 2) {
+            cserver.thread_min_client_threshold = atoi(argv[1]);
+            if (cserver.thread_min_client_threshold < 0 || cserver.thread_min_client_threshold > 400) {
+                err = "min-thread-client must be between 0 and 400"; goto loaderr;
+            }
         } else {
             err = "Bad directive or wrong number of arguments"; goto loaderr;
         }
@@ -972,6 +918,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 +1098,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 +1111,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 +1247,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 +1399,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",
@@ -1634,8 +1496,15 @@ void configGetCommand(client *c) {
             listIter li;
             listNode *ln;
             listRewind(g_pserver->masters, &li);
+            bool fFirst = true;
             while ((ln = listNext(&li)))
             {
+                if (!fFirst)
+                {
+                    addReplyBulkCString(c,optname);
+                    matches++;
+                }
+                fFirst = false;
                 struct redisMaster *mi = (struct redisMaster*)listNodeValue(ln);
                 snprintf(buf,sizeof(buf),"%s %d",
                     mi->masterhost, mi->masterport);
@@ -1873,7 +1742,7 @@ void rewriteConfigRewriteLine(struct rewriteConfigState *state, const char *opti
 }
 
 /* Write the long long 'bytes' value as a string in a way that is parsable
- * inside redis.conf. If possible uses the GB, MB, KB notation. */
+ * inside keydb.conf. If possible uses the GB, MB, KB notation. */
 int rewriteConfigFormatMemory(char *buf, size_t len, long long bytes) {
     int gb = 1024*1024*1024;
     int mb = 1024*1024;
@@ -2036,7 +1905,7 @@ void rewriteConfigDirOption(struct rewriteConfigState *state) {
 void rewriteConfigSlaveofOption(struct rewriteConfigState *state, const char *option) {
     /* If this is a master, we want all the slaveof config options
     * in the file to be removed. Note that if this is a cluster instance
-    * we don't want a slaveof directive inside redis.conf. */
+    * we don't want a slaveof directive inside keydb.conf. */
     if (g_pserver->cluster_enabled || listLength(g_pserver->masters) == 0) {
         rewriteConfigMarkAsProcessed(state,option);
         return;
@@ -2280,7 +2149,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 +2174,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 +2181,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 +2207,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 +2229,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/cron.cpp

@@ -0,0 +1,135 @@
+#include "server.h"
+#include "cron.h"
+
+void freeCronObject(robj_roptr o)
+{
+    delete reinterpret_cast<const cronjob*>(ptrFromObj(o));
+}
+
+// CRON [name] [single shot] [optional: start] [delay] [script] [numkeys] [key N] [arg N]
+void cronCommand(client *c)
+{
+    int arg_offset = 0;
+    static const int ARG_NAME = 1;
+    static const int ARG_SINGLESHOT = 2;
+    static const int ARG_EXPIRE = 3;
+    #define ARG_SCRIPT (4+arg_offset)
+    #define ARG_NUMKEYS (5+arg_offset)
+    #define ARG_KEYSTART (6+arg_offset)
+
+    bool fSingleShot = false;
+    if (strcasecmp("single", szFromObj(c->argv[ARG_SINGLESHOT])) == 0) {
+        fSingleShot = true;
+    } else {
+        if (strcasecmp("repeat", szFromObj(c->argv[ARG_SINGLESHOT])) != 0) {
+            addReply(c, shared.syntaxerr);
+            return;
+        }
+    }
+
+    long long interval;
+    if (getLongLongFromObjectOrReply(c, c->argv[ARG_EXPIRE], &interval, "missing expire time") != C_OK)
+        return;
+
+    long long base = g_pserver->mstime;
+    if (getLongLongFromObject(c->argv[ARG_EXPIRE+1], &base) == C_OK) {
+        arg_offset++;
+        std::swap(base, interval);
+    }
+
+    if (interval <= 0)
+    {
+        addReplyError(c, "interval must be positive");
+        return;
+    }
+
+    long numkeys = 0;
+    if (c->argc > ARG_NUMKEYS)
+    {
+        if (getLongFromObjectOrReply(c, c->argv[ARG_NUMKEYS], &numkeys, NULL) != C_OK)
+            return;
+        
+        if (c->argc < (6 + numkeys)) {
+            addReplyError(c, "Missing arguments or numkeys is too big");
+        }
+    }
+
+    std::unique_ptr<cronjob> spjob = std::make_unique<cronjob>();
+    spjob->script = sdsstring(sdsdup(szFromObj(c->argv[ARG_SCRIPT])));
+    spjob->interval = (uint64_t)interval;
+    spjob->startTime = (uint64_t)base;
+    spjob->fSingleShot = fSingleShot;
+    spjob->dbNum = c->db - g_pserver->db;
+    for (long i = 0; i < numkeys; ++i)
+        spjob->veckeys.emplace_back(sdsdup(szFromObj(c->argv[ARG_KEYSTART+i])));
+    for (long i = ARG_KEYSTART + numkeys; i < c->argc; ++i)
+        spjob->vecargs.emplace_back(sdsdup(szFromObj(c->argv[i])));
+
+    robj *o = createObject(OBJ_CRON, spjob.release());
+    setKey(c->db, c->argv[ARG_NAME], o);
+    decrRefCount(o);
+    // use an expire to trigger execution.  Note: We use a subkey expire here so legacy clients don't delete it.
+    setExpire(c, c->db, c->argv[ARG_NAME], c->argv[ARG_NAME], base + interval);
+    addReply(c, shared.ok);
+}
+
+void executeCronJobExpireHook(const char *key, robj *o)
+{
+    serverAssert(o->type == OBJ_CRON);
+    cronjob *job = (cronjob*)ptrFromObj(o);
+    
+    client *cFake = createClient(-1, IDX_EVENT_LOOP_MAIN);
+    cFake->lock.lock();
+    cFake->authenticated = 1;
+    cFake->puser = nullptr;
+    selectDb(cFake, job->dbNum);
+    serverAssert(cFake->argc == 0);
+
+    // Setup the args for the EVAL command
+    cFake->argc = 3 + job->veckeys.size() + job->vecargs.size();
+    cFake->argv = (robj**)zmalloc(sizeof(robj*) * cFake->argc, MALLOC_LOCAL);
+    cFake->argv[0] = createStringObject("EVAL", 4);
+    cFake->argv[1] = createStringObject(job->script.get(), job->script.size());
+    cFake->argv[2] = createStringObjectFromLongLong(job->veckeys.size());
+    for (size_t i = 0; i < job->veckeys.size(); ++i)
+        cFake->argv[3+i] = createStringObject(job->veckeys[i].get(), job->veckeys[i].size());
+    for (size_t i = 0; i < job->vecargs.size(); ++i)
+        cFake->argv[3+job->veckeys.size()+i] = createStringObject(job->vecargs[i].get(), job->vecargs[i].size());
+
+    evalCommand(cFake);
+    resetClient(cFake);
+
+    robj *keyobj = createStringObject(key,sdslen(key));
+    int dbId = job->dbNum;
+    if (job->fSingleShot)
+    {
+        dbSyncDelete(cFake->db, keyobj);
+    }
+    else
+    {
+        job->startTime += job->interval;
+        if (job->startTime < (uint64_t)g_pserver->mstime)
+        {
+            // If we are more than one interval in the past then fast forward to
+            //  the first interval still in the future.  If startTime wasn't zero align
+            //  this to the original startTime, if it was zero align to now
+            if (job->startTime == job->interval)
+            {   // startTime was 0
+                job->startTime = g_pserver->mstime + job->interval;
+            }
+            else
+            {
+                auto delta = g_pserver->mstime - job->startTime;
+                auto multiple = (delta / job->interval)+1;
+                job->startTime += job->interval * multiple;
+            }
+        }
+        setExpire(cFake, cFake->db, keyobj, keyobj, job->startTime);
+    }
+
+    notifyKeyspaceEvent(NOTIFY_KEYEVENT, "CRON Executed", keyobj, dbId);
+    decrRefCount(keyobj);
+
+    // o is invalid at this point
+    freeClient(cFake);
+}

src/cron.h

@@ -0,0 +1,16 @@
+#pragma once
+
+struct cronjob
+{
+    sdsstring script;
+    uint64_t interval;
+    uint64_t startTime;
+    std::vector<sdsstring> veckeys;
+    std::vector<sdsstring> vecargs;
+    int dbNum = 0;
+    bool fSingleShot = false;
+};
+
+void freeCronObject(robj_roptr o);
+void executeCronJobExpireHook(const char *key, robj *o);
+void cronCommand(client *c);

src/db.cpp

@@ -30,6 +30,7 @@
 #include "server.h"
 #include "cluster.h"
 #include "atomicvar.h"
+#include "aelocker.h"
 
 #include <signal.h>
 #include <ctype.h>
@@ -39,6 +40,8 @@
  *----------------------------------------------------------------------------*/
 
 int keyIsExpired(redisDb *db, robj *key);
+int expireIfNeeded(redisDb *db, robj *key, robj *o);
+void dbOverwriteCore(redisDb *db, dictEntry *de, robj *key, robj *val, bool fUpdateMvcc, bool fRemoveExpire);
 
 /* Update LFU when an object is accessed.
  * Firstly, decrement the counter if the decrement time is reached.
@@ -49,6 +52,20 @@ void updateLFU(robj *val) {
     val->lru = (LFUGetTimeInMinutes()<<8) | counter;
 }
 
+void updateExpire(redisDb *db, sds key, robj *valOld, robj *valNew)
+{
+    serverAssert(valOld->FExpires());
+    serverAssert(!valNew->FExpires());
+    
+    auto itr = db->setexpire->find(key);
+    serverAssert(itr != db->setexpire->end());
+    
+    valNew->SetFExpires(true);
+    valOld->SetFExpires(false);
+    return;
+}
+
+
 /* Low level key lookup API, not actually called directly from commands
  * implementations that should instead rely on lookupKeyRead(),
  * lookupKeyWrite() and lookupKeyReadWithFlags(). */
@@ -98,7 +115,7 @@ static robj *lookupKey(redisDb *db, robj *key, int flags) {
  *  LOOKUP_NOTOUCH: don't alter the last access time of the key.
  *
  * Note: this function also returns NULL if the key is logically expired
- * but still existing, in case this is a slave, since this API is called only
+ * but still existing, in case this is a replica, since this API is called only
  * for read operations. Even if the key expiry is master-driven, we can
  * correctly report a key is expired on slaves even if the master is lagging
  * expiring our key via DELs in the replication link. */
@@ -116,7 +133,7 @@ robj_roptr lookupKeyReadWithFlags(redisDb *db, robj *key, int flags) {
             return NULL;
         }
 
-        /* However if we are in the context of a slave, expireIfNeeded() will
+        /* However if we are in the context of a replica, expireIfNeeded() will
          * not really try to expire the key, it only returns information
          * about the "logical" status of the key: key expiring is up to the
          * master in order to have a consistent view of master's data set.
@@ -161,7 +178,8 @@ robj_roptr lookupKeyRead(redisDb *db, robj *key) {
  * does not exist in the specified DB. */
 robj *lookupKeyWrite(redisDb *db, robj *key) {
     expireIfNeeded(db,key);
-    return lookupKey(db,key,LOOKUP_UPDATEMVCC);
+    robj *o = lookupKey(db,key,LOOKUP_UPDATEMVCC);
+    return o;
 }
 
 robj_roptr lookupKeyReadOrReply(client *c, robj *key, robj *reply) {
@@ -177,6 +195,7 @@ robj *lookupKeyWriteOrReply(client *c, robj *key, robj *reply) {
 }
 
 int dbAddCore(redisDb *db, robj *key, robj *val) {
+    serverAssert(!val->FExpires());
     sds copy = sdsdup(szFromObj(key));
     int retval = dictAdd(db->pdict, copy, val);
     val->mvcc_tstamp = key->mvcc_tstamp = getMvccTstamp();
@@ -206,15 +225,30 @@ void dbAdd(redisDb *db, robj *key, robj *val)
     serverAssertWithInfo(NULL,key,retval == DICT_OK);
 }
 
-void dbOverwriteCore(redisDb *db, dictEntry *de, robj *val, bool fUpdateMvcc)
+void dbOverwriteCore(redisDb *db, dictEntry *de, robj *key, robj *val, bool fUpdateMvcc, bool fRemoveExpire)
 {
     dictEntry auxentry = *de;
     robj *old = (robj*)dictGetVal(de);
+
+    if (old->FExpires()) {
+        if (fRemoveExpire) {
+            removeExpire(db, key);
+        }
+        else {
+            if (val->getrefcount(std::memory_order_relaxed) == OBJ_SHARED_REFCOUNT)
+                val = dupStringObject(val);
+            updateExpire(db, (sds)dictGetKey(de), old, val);
+        }
+    }
+
     if (g_pserver->maxmemory_policy & MAXMEMORY_FLAG_LFU) {
         val->lru = old->lru;
     }
-    if (fUpdateMvcc)
+    if (fUpdateMvcc) {
+        if (val->getrefcount(std::memory_order_relaxed) == OBJ_SHARED_REFCOUNT)
+            val = dupStringObject(val);
         val->mvcc_tstamp = getMvccTstamp();
+    }
 
     dictSetVal(db->pdict, de, val);
 
@@ -235,7 +269,7 @@ void dbOverwrite(redisDb *db, robj *key, robj *val) {
     dictEntry *de = dictFind(db->pdict,ptrFromObj(key));
 
     serverAssertWithInfo(NULL,key,de != NULL);
-    dbOverwriteCore(db, de, val, true);
+    dbOverwriteCore(db, de, key, val, !!g_pserver->fActiveReplica, false);
 }
 
 /* Insert a key, handling duplicate keys according to fReplace */
@@ -250,7 +284,7 @@ int dbMerge(redisDb *db, robj *key, robj *val, int fReplace)
         robj *old = (robj*)dictGetVal(de);
         if (old->mvcc_tstamp <= val->mvcc_tstamp)
         {
-            dbOverwriteCore(db, de, val, false);
+            dbOverwriteCore(db, de, key, val, false, true);
             return true;
         }
         
@@ -271,13 +305,13 @@ int dbMerge(redisDb *db, robj *key, robj *val, int fReplace)
  *
  * All the new keys in the database should be created via this interface. */
 void setKey(redisDb *db, robj *key, robj *val) {
-    if (lookupKeyWrite(db,key) == NULL) {
+    dictEntry *de = dictFind(db->pdict, ptrFromObj(key));
+    if (de == NULL) {
         dbAdd(db,key,val);
     } else {
-        dbOverwrite(db,key,val);
+        dbOverwriteCore(db,de,key,val,!!g_pserver->fActiveReplica,true);
     }
     incrRefCount(val);
-    removeExpire(db,key);
     signalModifiedKey(db,key);
 }
 
@@ -292,7 +326,7 @@ int dbExists(redisDb *db, robj *key) {
 robj *dbRandomKey(redisDb *db) {
     dictEntry *de;
     int maxtries = 100;
-    int allvolatile = dictSize(db->pdict) == dictSize(db->expires);
+    int allvolatile = dictSize(db->pdict) == db->setexpire->size();
 
     while(1) {
         sds key;
@@ -303,23 +337,30 @@ robj *dbRandomKey(redisDb *db) {
 
         key = (sds)dictGetKey(de);
         keyobj = createStringObject(key,sdslen(key));
-        if (dictFind(db->expires,key)) {
+
+        if (((robj*)dictGetVal(de))->FExpires())
+        {
             if (allvolatile && listLength(g_pserver->masters) && --maxtries == 0) {
                 /* If the DB is composed only of keys with an expire set,
-                 * it could happen that all the keys are already logically
-                 * expired in the slave, so the function cannot stop because
-                 * expireIfNeeded() is false, nor it can stop because
-                 * dictGetRandomKey() returns NULL (there are keys to return).
-                 * To prevent the infinite loop we do some tries, but if there
-                 * are the conditions for an infinite loop, eventually we
-                 * return a key name that may be already expired. */
+                    * it could happen that all the keys are already logically
+                    * expired in the replica, so the function cannot stop because
+                    * expireIfNeeded() is false, nor it can stop because
+                    * dictGetRandomKey() returns NULL (there are keys to return).
+                    * To prevent the infinite loop we do some tries, but if there
+                    * are the conditions for an infinite loop, eventually we
+                    * return a key name that may be already expired. */
                 return keyobj;
             }
-            if (expireIfNeeded(db,keyobj)) {
+        }
+            
+        if (((robj*)dictGetVal(de))->FExpires())
+        {
+             if (expireIfNeeded(db,keyobj)) {
                 decrRefCount(keyobj);
                 continue; /* search for another key. This expired. */
-            }
+             }
         }
+        
         return keyobj;
     }
 }
@@ -328,7 +369,10 @@ robj *dbRandomKey(redisDb *db) {
 int dbSyncDelete(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));
+
+    dictEntry *de = dictFind(db->pdict, szFromObj(key));
+    if (de != nullptr && ((robj*)dictGetVal(de))->FExpires())
+        removeExpireCore(db, key, de);
     if (dictDelete(db->pdict,ptrFromObj(key)) == DICT_OK) {
         if (g_pserver->cluster_enabled) slotToKeyDel(key);
         return 1;
@@ -373,7 +417,7 @@ int dbDelete(redisDb *db, robj *key) {
  */
 robj *dbUnshareStringValue(redisDb *db, robj *key, robj *o) {
     serverAssert(o->type == OBJ_STRING);
-    if (o->refcount != 1 || o->encoding != OBJ_ENCODING_RAW) {
+    if (o->getrefcount(std::memory_order_relaxed) != 1 || o->encoding != OBJ_ENCODING_RAW) {
         robj *decoded = getDecodedObject(o);
         o = createRawStringObject(szFromObj(decoded), sdslen(szFromObj(decoded)));
         decrRefCount(decoded);
@@ -419,7 +463,9 @@ long long emptyDb(int dbnum, int flags, void(callback)(void*)) {
             emptyDbAsync(&g_pserver->db[j]);
         } else {
             dictEmpty(g_pserver->db[j].pdict,callback);
-            dictEmpty(g_pserver->db[j].expires,callback);
+            delete g_pserver->db[j].setexpire;
+            g_pserver->db[j].setexpire = new (MALLOC_LOCAL) expireset();
+            g_pserver->db[j].expireitr = g_pserver->db[j].setexpire->end();
         }
     }
     if (g_pserver->cluster_enabled) {
@@ -451,6 +497,7 @@ int selectDb(client *c, int id) {
 
 void signalModifiedKey(redisDb *db, robj *key) {
     touchWatchedKey(db,key);
+    if (g_pserver->tracking_clients) trackingInvalidateKey(key);
 }
 
 void signalFlushedDb(int dbid) {
@@ -665,7 +712,7 @@ int parseScanCursorOrReply(client *c, robj *o, unsigned long *cursor) {
 }
 
 /* This command implements SCAN, HSCAN and SSCAN commands.
- * If object 'o' is passed, then it must be a Hash or Set object, otherwise
+ * If object 'o' is passed, then it must be a Hash, Set or Zset object, otherwise
  * if 'o' is NULL the command will operate on the dictionary associated with
  * the current database.
  *
@@ -681,6 +728,7 @@ void scanGenericCommand(client *c, robj_roptr o, unsigned long cursor) {
     listNode *node, *nextnode;
     long count = 10;
     sds pat = NULL;
+    sds type = NULL;
     int patlen = 0, use_pattern = 0;
     dict *ht;
 
@@ -717,6 +765,10 @@ void scanGenericCommand(client *c, robj_roptr o, unsigned long cursor) {
             use_pattern = !(pat[0] == '*' && patlen == 1);
 
             i += 2;
+        } else if (!strcasecmp(szFromObj(c->argv[i]), "type") && o == nullptr && j >= 2) {
+            /* SCAN for a particular type only applies to the db dict */
+            type = szFromObj(c->argv[i+1]);
+            i+= 2;
         } else {
             addReply(c,shared.syntaxerr);
             goto cleanup;
@@ -811,6 +863,13 @@ void scanGenericCommand(client *c, robj_roptr o, unsigned long cursor) {
             }
         }
 
+        /* Filter an element if it isn't the type we want. */
+        if (!filter && o == nullptr && type){
+            robj_roptr typecheck = lookupKeyReadWithFlags(c->db, kobj, LOOKUP_NOTOUCH);
+            const char* typeT = getObjectTypeName(typecheck);
+            if (strcasecmp((char*) type, typeT)) filter = 1;
+        }
+
         /* Filter element if it is an expired key. */
         if (!filter && o == nullptr && expireIfNeeded(c->db, kobj)) filter = 1;
 
@@ -867,10 +926,8 @@ void lastsaveCommand(client *c) {
     addReplyLongLong(c,g_pserver->lastsave);
 }
 
-void typeCommand(client *c) {
-    const char *type;
-
-    robj_roptr o = lookupKeyReadWithFlags(c->db,c->argv[1],LOOKUP_NOTOUCH);
+const char* getObjectTypeName(robj_roptr o) {
+    const char* type;
     if (o == nullptr) {
         type = "none";
     } else {
@@ -888,7 +945,12 @@ void typeCommand(client *c) {
         default: type = "unknown"; break;
         }
     }
-    addReplyStatus(c,type);
+    return type;
+}
+
+void typeCommand(client *c) {
+    robj_roptr o = lookupKeyReadWithFlags(c->db,c->argv[1],LOOKUP_NOTOUCH);
+    addReplyStatus(c, getObjectTypeName(o));
 }
 
 void shutdownCommand(client *c) {
@@ -915,13 +977,12 @@ void shutdownCommand(client *c) {
      * Also when in Sentinel mode clear the SAVE flag and force NOSAVE. */
     if (g_pserver->loading || g_pserver->sentinel_mode)
         flags = (flags & ~SHUTDOWN_SAVE) | SHUTDOWN_NOSAVE;
-    if (prepareForShutdown(flags) == C_OK) exit(0);
+    if (prepareForShutdown(flags) == C_OK) throw ShutdownException();
     addReplyError(c,"Errors trying to SHUTDOWN. Check logs.");
 }
 
 void renameGenericCommand(client *c, int nx) {
     robj *o;
-    long long expire;
     int samekey = 0;
 
     /* When source and dest key is the same, no operation is performed,
@@ -937,7 +998,15 @@ void renameGenericCommand(client *c, int nx) {
     }
 
     incrRefCount(o);
-    expire = getExpire(c->db,c->argv[1]);
+
+    std::unique_ptr<expireEntry> spexpire;
+
+    {   // scope pexpireOld since it will be invalid soon
+    expireEntry *pexpireOld = getExpire(c->db,c->argv[1]);
+    if (pexpireOld != nullptr)
+        spexpire = std::make_unique<expireEntry>(std::move(*pexpireOld));
+    }
+
     if (lookupKeyWrite(c->db,c->argv[2]) != NULL) {
         if (nx) {
             decrRefCount(o);
@@ -948,9 +1017,10 @@ void renameGenericCommand(client *c, int nx) {
          * with the same name. */
         dbDelete(c->db,c->argv[2]);
     }
-    dbAdd(c->db,c->argv[2],o);
-    if (expire != -1) setExpire(c,c->db,c->argv[2],expire);
     dbDelete(c->db,c->argv[1]);
+    dbAdd(c->db,c->argv[2],o);
+    if (spexpire != nullptr) 
+        setExpire(c,c->db,c->argv[2],std::move(*spexpire));
     signalModifiedKey(c->db,c->argv[1]);
     signalModifiedKey(c->db,c->argv[2]);
     notifyKeyspaceEvent(NOTIFY_GENERIC,"rename_from",
@@ -973,7 +1043,7 @@ void moveCommand(client *c) {
     robj *o;
     redisDb *src, *dst;
     int srcid;
-    long long dbid, expire;
+    long long dbid;
 
     if (g_pserver->cluster_enabled) {
         addReplyError(c,"MOVE is not allowed in cluster mode");
@@ -1007,7 +1077,19 @@ void moveCommand(client *c) {
         addReply(c,shared.czero);
         return;
     }
-    expire = getExpire(c->db,c->argv[1]);
+
+    std::unique_ptr<expireEntry> spexpire;
+    {   // scope pexpireOld
+    expireEntry *pexpireOld = getExpire(c->db,c->argv[1]);
+    if (pexpireOld != nullptr)
+        spexpire = std::make_unique<expireEntry>(std::move(*pexpireOld));
+    }
+    if (o->FExpires())
+        removeExpire(c->db,c->argv[1]);
+    serverAssert(!o->FExpires());
+    incrRefCount(o);
+    dbDelete(src,c->argv[1]);
+    g_pserver->dirty++;
 
     /* Return zero if the key already exists in the target DB */
     if (lookupKeyWrite(dst,c->argv[1]) != NULL) {
@@ -1015,12 +1097,8 @@ void moveCommand(client *c) {
         return;
     }
     dbAdd(dst,c->argv[1],o);
-    if (expire != -1) setExpire(c,dst,c->argv[1],expire);
-    incrRefCount(o);
+    if (spexpire != nullptr) setExpire(c,dst,c->argv[1],std::move(*spexpire));
 
-    /* OK! key moved, free the entry in the source DB */
-    dbDelete(src,c->argv[1]);
-    g_pserver->dirty++;
     addReply(c,shared.cone);
 }
 
@@ -1054,19 +1132,24 @@ int dbSwapDatabases(int id1, int id2) {
     if (id1 < 0 || id1 >= cserver.dbnum ||
         id2 < 0 || id2 >= cserver.dbnum) return C_ERR;
     if (id1 == id2) return C_OK;
-    redisDb aux = g_pserver->db[id1];
+    redisDb aux; 
+    memcpy(&aux, &g_pserver->db[id1], sizeof(redisDb));
     redisDb *db1 = &g_pserver->db[id1], *db2 = &g_pserver->db[id2];
 
     /* Swap hash tables. Note that we don't swap blocking_keys,
      * ready_keys and watched_keys, since we want clients to
      * remain in the same DB they were. */
     db1->pdict = db2->pdict;
-    db1->expires = db2->expires;
+    db1->setexpire = db2->setexpire;
+    db1->expireitr = db2->expireitr;
     db1->avg_ttl = db2->avg_ttl;
+    db1->last_expire_set = db2->last_expire_set;
 
     db2->pdict = aux.pdict;
-    db2->expires = aux.expires;
+    db2->setexpire = aux.setexpire;
+    db2->expireitr = aux.expireitr;
     db2->avg_ttl = aux.avg_ttl;
+    db2->last_expire_set = aux.last_expire_set;
 
     /* Now we need to handle clients blocked on lists: as an effect
      * of swapping the two DBs, a client that was waiting for list
@@ -1114,46 +1197,169 @@ void swapdbCommand(client *c) {
 /*-----------------------------------------------------------------------------
  * Expires API
  *----------------------------------------------------------------------------*/
-
 int removeExpire(redisDb *db, robj *key) {
+    dictEntry *de = dictFind(db->pdict,ptrFromObj(key));
+    return removeExpireCore(db, key, de);
+}
+int removeExpireCore(redisDb *db, robj *key, dictEntry *de) {
     /* An expire may only be removed if there is a corresponding entry in the
      * main dict. Otherwise, the key will never be freed. */
-    serverAssertWithInfo(NULL,key,dictFind(db->pdict,ptrFromObj(key)) != NULL);
-    return dictDelete(db->expires,ptrFromObj(key)) == DICT_OK;
+    serverAssertWithInfo(NULL,key,de != NULL);
+
+    robj *val = (robj*)dictGetVal(de);
+    if (!val->FExpires())
+        return 0;
+
+    auto itr = db->setexpire->find((sds)dictGetKey(de));
+    serverAssert(itr != db->setexpire->end());
+    serverAssert(itr->key() == (sds)dictGetKey(de));
+    db->setexpire->erase(itr);
+    val->SetFExpires(false);
+    return 1;
+}
+
+int removeSubkeyExpire(redisDb *db, robj *key, robj *subkey) {
+    dictEntry *de = dictFind(db->pdict,ptrFromObj(key));
+    serverAssertWithInfo(NULL,key,de != NULL);
+    
+    robj *val = (robj*)dictGetVal(de);
+    if (!val->FExpires())
+        return 0;
+    
+    auto itr = db->setexpire->find((sds)dictGetKey(de));
+    serverAssert(itr != db->setexpire->end());
+    serverAssert(itr->key() == (sds)dictGetKey(de));
+    if (!itr->FFat())
+        return 0;
+
+    int found = 0;
+    for (auto subitr : *itr)
+    {
+        if (subitr.subkey() == nullptr)
+            continue;
+        if (sdscmp((sds)subitr.subkey(), szFromObj(subkey)) == 0)
+        {
+            itr->erase(subitr);
+            found = 1;
+            break;
+        }
+    }
+
+    if (itr->pfatentry()->size() == 0)
+        removeExpireCore(db, key, de);
+
+    return found;
 }
 
 /* Set an expire to the specified key. If the expire is set in the context
  * of an user calling a command 'c' is the client, otherwise 'c' is set
  * to NULL. The 'when' parameter is the absolute unix time in milliseconds
  * after which the key will no longer be considered valid. */
-void setExpire(client *c, redisDb *db, robj *key, long long when) {
-    dictEntry *kde, *de;
+void setExpire(client *c, redisDb *db, robj *key, robj *subkey, long long when) {
+    dictEntry *kde;
+
     serverAssert(GlobalLocksAcquired());
 
     /* Reuse the sds from the main dict in the expire dict */
     kde = dictFind(db->pdict,ptrFromObj(key));
     serverAssertWithInfo(NULL,key,kde != NULL);
-    de = dictAddOrFind(db->expires,dictGetKey(kde));
-    dictSetSignedIntegerVal(de,when);
+
+    if (((robj*)dictGetVal(kde))->getrefcount(std::memory_order_relaxed) == OBJ_SHARED_REFCOUNT)
+    {
+        // shared objects cannot have the expire bit set, create a real object
+        dictSetVal(db->pdict, kde, dupStringObject((robj*)dictGetVal(kde)));
+    }
+
+    /* Update TTL stats (exponential moving average) */
+    /*  Note: We never have to update this on expiry since we reduce it by the current elapsed time here */
+    long long now = g_pserver->mstime;
+    db->avg_ttl -= (now - db->last_expire_set); // reduce the TTL by the time that has elapsed
+    if (db->setexpire->empty())
+        db->avg_ttl = 0;
+    else
+        db->avg_ttl -= db->avg_ttl / db->setexpire->size(); // slide one entry out the window
+    if (db->avg_ttl < 0)
+        db->avg_ttl = 0;    // TTLs are never negative
+    db->avg_ttl += (double)(when-now) / (db->setexpire->size()+1);    // add the new entry
+    db->last_expire_set = now;
+
+    /* Update the expire set */
+    const char *szSubKey = (subkey != nullptr) ? szFromObj(subkey) : nullptr;
+    if (((robj*)dictGetVal(kde))->FExpires()) {
+        auto itr = db->setexpire->find((sds)dictGetKey(kde));
+        serverAssert(itr != db->setexpire->end());
+        expireEntry eNew(std::move(*itr));
+        eNew.update(szSubKey, when);
+        db->setexpire->erase(itr);
+        db->setexpire->insert(eNew);
+    }
+    else
+    {
+        expireEntry e((sds)dictGetKey(kde), szSubKey, when);
+        ((robj*)dictGetVal(kde))->SetFExpires(true);
+        db->setexpire->insert(e);
+    }
 
     int writable_slave = listLength(g_pserver->masters) && g_pserver->repl_slave_ro == 0;
     if (c && writable_slave && !(c->flags & CLIENT_MASTER))
         rememberSlaveKeyWithExpire(db,key);
 }
 
-/* Return the expire time of the specified key, or -1 if no expire
+redisDb::~redisDb()
+{
+    dictRelease(watched_keys);
+    dictRelease(ready_keys);
+    dictRelease(blocking_keys);
+    listRelease(defrag_later);
+}
+
+void setExpire(client *c, redisDb *db, robj *key, expireEntry &&e)
+{
+    dictEntry *kde;
+
+    serverAssert(GlobalLocksAcquired());
+
+    /* Reuse the sds from the main dict in the expire dict */
+    kde = dictFind(db->pdict,ptrFromObj(key));
+    serverAssertWithInfo(NULL,key,kde != NULL);
+
+    if (((robj*)dictGetVal(kde))->getrefcount(std::memory_order_relaxed) == OBJ_SHARED_REFCOUNT)
+    {
+        // shared objects cannot have the expire bit set, create a real object
+        dictSetVal(db->pdict, kde, dupStringObject((robj*)dictGetVal(kde)));
+    }
+
+    if (((robj*)dictGetVal(kde))->FExpires())
+        removeExpire(db, key);
+
+    e.setKeyUnsafe((sds)dictGetKey(kde));
+    db->setexpire->insert(e);
+    ((robj*)dictGetVal(kde))->SetFExpires(true);
+
+
+    int writable_slave = listLength(g_pserver->masters) && g_pserver->repl_slave_ro == 0;
+    if (c && writable_slave && !(c->flags & CLIENT_MASTER))
+        rememberSlaveKeyWithExpire(db,key);
+}
+
+/* Return the expire time of the specified key, or null if no expire
  * is associated with this key (i.e. the key is non volatile) */
-long long getExpire(redisDb *db, robj_roptr key) {
+expireEntry *getExpire(redisDb *db, robj_roptr key) {
     dictEntry *de;
 
     /* No expire? return ASAP */
-    if (dictSize(db->expires) == 0 ||
-       (de = dictFind(db->expires,ptrFromObj(key))) == NULL) return -1;
+    if (db->setexpire->size() == 0)
+        return nullptr;
 
-    /* The entry was found in the expire dict, this means it should also
-     * be present in the main dict (safety check). */
-    serverAssertWithInfo(NULL,key,dictFind(db->pdict,ptrFromObj(key)) != NULL);
-    return dictGetSignedIntegerVal(de);
+    de = dictFind(db->pdict, ptrFromObj(key));
+    if (de == NULL)
+        return nullptr;
+    robj *obj = (robj*)dictGetVal(de);
+    if (!obj->FExpires())
+        return nullptr;
+
+    auto itr = db->setexpire->find((sds)dictGetKey(de));
+    return itr.operator->();
 }
 
 /* Propagate expires into slaves and the AOF file.
@@ -1161,7 +1367,7 @@ long long getExpire(redisDb *db, robj_roptr key) {
  * to all the slaves and the AOF file if enabled.
  *
  * This way the key expiry is centralized in one place, and since both
- * AOF and the master->slave link guarantee operation ordering, everything
+ * AOF and the master->replica link guarantee operation ordering, everything
  * will be consistent even if we allow write operations against expiring
  * keys. */
 void propagateExpire(redisDb *db, robj *key, int lazy) {
@@ -1175,21 +1381,36 @@ void propagateExpire(redisDb *db, robj *key, int lazy) {
 
     if (g_pserver->aof_state != AOF_OFF)
         feedAppendOnlyFile(cserver.delCommand,db->id,argv,2);
-    replicationFeedSlaves(g_pserver->slaves,db->id,argv,2);
+    // Active replicas do their own expiries, do not propogate
+    if (!g_pserver->fActiveReplica)
+        replicationFeedSlaves(g_pserver->slaves,db->id,argv,2);
 
     decrRefCount(argv[0]);
     decrRefCount(argv[1]);
 }
 
-/* Check if the key is expired. */
+/* Check if the key is expired. Note, this does not check subexpires */
 int keyIsExpired(redisDb *db, robj *key) {
-    mstime_t when = getExpire(db,key);
+    expireEntry *pexpire = getExpire(db,key);
 
-    if (when < 0) return 0; /* No expire for this key */
+    if (pexpire == nullptr) return 0; /* No expire for this key */
 
     /* Don't expire anything while loading. It will be done later. */
     if (g_pserver->loading) return 0;
 
+    long long when = -1;
+    for (auto &exp : *pexpire)
+    {
+        if (exp.subkey() == nullptr)
+        {
+            when = exp.when();
+            break;
+        }
+    }
+
+    if (when == -1)
+        return 0;
+
     /* If we are in the context of a Lua script, we pretend that time is
      * blocked to when the Lua script started. This way a key can expire
      * only the first time it is accessed and not in the middle of the
@@ -1206,10 +1427,10 @@ int keyIsExpired(redisDb *db, robj *key) {
  * is via lookupKey*() family of functions.
  *
  * The behavior of the function depends on the replication role of the
- * instance, because slave instances do not expire keys, they wait
+ * instance, because replica instances do not expire keys, they wait
  * for DELs from the master for consistency matters. However even
  * slaves will try to have a coherent return value for the function,
- * so that read commands executed in the slave side will be able to
+ * so that read commands executed in the replica side will be able to
  * behave like if the key is expired even if still present (because the
  * master has yet to propagate the DEL).
  *
@@ -1222,15 +1443,15 @@ int keyIsExpired(redisDb *db, robj *key) {
 int expireIfNeeded(redisDb *db, robj *key) {
     if (!keyIsExpired(db,key)) return 0;
 
-    /* If we are running in the context of a slave, instead of
+    /* If we are running in the context of a replica, instead of
      * evicting the expired key from the database, we return ASAP:
-     * the slave key expiration is controlled by the master that will
+     * the replica key expiration is controlled by the master that will
      * send us synthesized DEL operations for expired keys.
      *
      * Still we try to return the right information to the caller,
      * that is, 0 if we think the key should be still valid, 1 if
      * we think the key is expired at this time. */
-    if (listLength(g_pserver->masters)) return 1;
+    if (listLength(g_pserver->masters) && !g_pserver->fActiveReplica) return 1;
 
     /* Delete the key */
     g_pserver->stat_expiredkeys++;

src/debug.cpp

@@ -55,6 +55,8 @@ typedef ucontext_t sigcontext_t;
 #endif
 #endif
 
+int 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 = getExpire(db,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);
@@ -436,7 +442,7 @@ 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) {
@@ -638,9 +644,9 @@ NULL
         dictGetStats(buf,sizeof(buf),g_pserver->db[dbid].pdict);
         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].setexpire->getstats(buf, sizeof(buf));
+        stats = sdscat(stats, buf);
 
         addReplyBulkSds(c,stats);
     } else if (!strcasecmp(szFromObj(c->argv[1]),"htstats-key") && c->argc == 3) {
@@ -676,10 +682,30 @@ 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 == 3) {
+        c->flags |= CLIENT_MASTER | CLIENT_MASTER_FORCE_REPLY;
+        if (!strcasecmp(szFromObj(c->argv[2]), "yes"))
+        {
+            redisMaster *mi = (redisMaster*)zcalloc(sizeof(redisMaster), MALLOC_LOCAL);
+            mi->master = c;
+            listAddNodeHead(g_pserver->masters, mi);
+        }
+        else if (strcasecmp(szFromObj(c->argv[2]), "flagonly")) // if we didn't set flagonly assume its an unset
+        {
+            serverAssert(c->flags & CLIENT_MASTER);
+            if (listLength(g_pserver->masters))
+            {
+                redisMaster *mi = (redisMaster*)listNodeValue(listFirst(g_pserver->masters));
+                serverAssert(mi->master == c);
+                listDelNode(g_pserver->masters, listFirst(g_pserver->masters));
+                zfree(mi);
+            }
+            c->flags &= ~(CLIENT_MASTER | CLIENT_MASTER_FORCE_REPLY);
+        }
+        addReply(c, shared.ok);
     } else {
         addReplySubcommandSyntaxError(c);
         return;
@@ -706,7 +732,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 +747,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) {
@@ -1356,6 +1382,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);
+bool 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,20 @@ dictEntry* replaceSateliteDictKeyPtrAndOrDefragDictEntry(dict *d, sds oldkey, sd
     return NULL;
 }
 
+bool 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);
+        serverAssert(set.find(newkey) != set.end());
+        return true;
+    }
+    return false;
+}
+
 long activeDefragQuickListNodes(quicklist *ql) {
     quicklistNode *node = ql->head, *newnode;
     long defragged = 0;
@@ -765,20 +780,22 @@ long defragKey(redisDb *db, dictEntry *de) {
     long defragged = 0;
     sds newsds;
 
+    ob = (robj*)dictGetVal(de);
+
     /* Try to defrag the key name. */
     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()) {
+            bool fReplaced = replaceSateliteOSetKeyPtr(*db->setexpire, keysds, newsds);
+            serverAssert(fReplaced == ob->FExpires());
+        } else {
+            serverAssert(!ob->FExpires());
+        }
     }
 
     /* Try to defrag robj and / or string value. */
-    ob = (robj*)dictGetVal(de);
     if ((newob = activeDefragStringOb(ob, &defragged))) {
         de->v.val = newob;
         ob = newob;
@@ -831,6 +848,7 @@ long defragKey(redisDb *db, dictEntry *de) {
     } else {
         serverPanic("Unknown object type");
     }
+
     return defragged;
 }
 

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();
     }
@@ -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,36 @@ 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, dict *dbdict, expireset *setexpire, struct evictionPoolEntry *pool)
+{
+    if (setexpire != nullptr)
+    {
+        visitFunctor visitor { dbid, dbdict, pool, 0 };
+        setexpire->random_visit(visitor);
+    }
+    else
+    {
+        dictEntry **samples = (dictEntry**)alloca(g_pserver->maxmemory_samples * sizeof(dictEntry*));
+        int count = dictGetSomeKeys(dbdict,samples,g_pserver->maxmemory_samples);
+        for (int j = 0; j < count; j++) {
+            robj *o = (robj*)dictGetVal(samples[j]);
+            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 +374,8 @@ size_t freeMemoryGetNotCountedMemory(void) {
 
         listRewind(g_pserver->slaves,&li);
         while((ln = listNext(&li))) {
-            client *slave = (client*)listNodeValue(ln);
-            overhead += getClientOutputBufferMemoryUsage(slave);
+            client *replica = (client*)listNodeValue(ln);
+            overhead += getClientOutputBufferMemoryUsage(replica);
         }
     }
     if (g_pserver->aof_state != AOF_OFF) {
@@ -474,8 +488,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 +502,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 = dictSize(db->pdict)) != 0) {
+                            evictionPoolPopulate(i, db->pdict, nullptr, pool);
+                            total_keys += keys;
+                        }
+                    }
+                    else
+                    {
+                        keys = db->setexpire->size();
+                        if (keys != 0)
+                            evictionPoolPopulate(i, db->pdict, db->setexpire, pool);
                         total_keys += keys;
                     }
                 }
@@ -503,14 +523,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);
-                    }
+                    dictEntry *de = dictFind(g_pserver->db[pool[k].dbid].pdict,pool[k].key);
+                    if (de != nullptr && (g_pserver->maxmemory_policy & MAXMEMORY_FLAG_ALLKEYS || ((robj*)dictGetVal(de))->FExpires()))
+                        key = (sds)dictGetKey(de);
 
                     /* Remove the entry from the pool. */
                     if (pool[k].key != pool[k].cached)
@@ -520,8 +537,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 +557,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 (dictSize(db->pdict) != 0) {
+                        dictEntry *de = dictGetRandomKey(db->pdict);
+                        bestkey = (sds)dictGetKey(de);
+                        bestdbid = j;
+                        break;
+                    }
+                }
+                else
+                {
+                    if (!db->setexpire->empty())
+                    {
+                        bestkey = (sds)db->setexpire->random_value().key();
+                        bestdbid = j;
+                        break;
+                    }
                 }
             }
         }

src/expire.cpp

@@ -31,6 +31,22 @@
  */
 
 #include "server.h"
+#include "cron.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 +67,196 @@
  *
  * 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();
+    dictEntry *de = dictFind(db->pdict, e.key());
+    robj *val = (robj*)dictGetVal(de);
+    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_HASH:
+            if (hashTypeDelete(val,(sds)pfat->nextExpireEntry().spsubkey.get())) {
+                deleted++;
+                if (hashTypeLength(val) == 0) {
+                    activeExpireCycleExpireFullKey(db, e.key());
+                    return;
+                }
+            }
+            break;
+
+        case OBJ_ZSET:
+            if (zsetDel(val,(sds)pfat->nextExpireEntry().spsubkey.get())) {
+                deleted++;
+                if (zsetLength(val) == 0) {
+                    activeExpireCycleExpireFullKey(db, e.key());
+                    return;
+                }
+            }
+            break;
+
+        case OBJ_CRON:
+            executeCronJobExpireHook(e.key(), val);
+            return;
+
+        case OBJ_LIST:
+        default:
+            serverAssert(false);
+        }
+        pfat->popfrontExpireEntry();
+    }
+
+    if (deleted)
+    {
+        if (!pfat->FEmpty())
+        {
+            // We need to resort the expire entry since it may no longer be in the correct position
+            auto itr = db->setexpire->find(e.key());
+            expireEntry eT = std::move(e);
+            db->setexpire->erase(itr);
+            db->setexpire->insert(eT);
+        }
+
+        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 == NULL) {
+        return;
+    }
+
+    double dblT;
+    switch (val->type)
+    {
+    case OBJ_SET:
+        if (!setTypeIsMember(val, szFromObj(subkey))) {
+            addReply(c,shared.czero);
+            return;
+        }
+        break;
+
+    case OBJ_HASH:
+        if (!hashTypeExists(val, szFromObj(subkey))) {
+            addReply(c,shared.czero);
+            return;
+        }
+        break;
+
+    case OBJ_ZSET:
+        if (zsetScore(val, szFromObj(subkey), &dblT) == C_ERR) {
+            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 +332,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 +339,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->setexpire->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->setexpire->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 +400,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 +419,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 +452,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
+                dictEntry *deMain = dictFind(db->pdict, keyname);
+                auto itr = db->setexpire->end();
+                if (deMain != nullptr)
+                    itr = db->setexpire->find((sds)dictGetKey(deMain));
                 int expired = 0;
 
-                if (expire &&
-                    activeExpireCycleTryExpire(g_pserver->db+dbid,expire,start))
+                if (itr != db->setexpire->end())
                 {
-                    expired = 1;
+                    if (itr->when() < start) {
+                        activeExpireCycleExpire(g_pserver->db+dbid,*itr,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 (itr != db->setexpire->end() && !expired) {
                     noexpire++;
                     new_dbids |= (uint64_t)1 << dbid;
                 }
@@ -323,7 +482,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 +499,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 +541,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,11 +579,11 @@ void expireGenericCommand(client *c, long long basetime, int unit) {
 
     /* EXPIRE with negative TTL, or EXPIREAT with a timestamp into the past
      * should never be executed as a DEL when load the AOF or in the context
-     * of a slave instance.
+     * of a replica instance.
      *
      * Instead we take the other branch of the IF statement setting an expire
      * (possibly in the past) and wait for an explicit DEL from the master. */
-    if (when <= mstime() && !g_pserver->loading && !listLength(g_pserver->masters)) {
+    if (when <= mstime() && !g_pserver->loading && (!listLength(g_pserver->masters) || g_pserver->fActiveReplica)) {
         robj *aux;
 
         int deleted = g_pserver->lazyfree_lazy_expire ? dbAsyncDelete(c->db,key) :
@@ -440,7 +599,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 +630,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 = getExpire(c->db,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 +688,22 @@ void pttlCommand(client *c) {
 /* PERSIST key */
 void persistCommand(client *c) {
     if (lookupKeyWrite(c->db,c->argv[1])) {
-        if (removeExpire(c->db,c->argv[1])) {
-            addReply(c,shared.cone);
-            g_pserver->dirty++;
+        if (c->argc == 2) {
+            if (removeExpire(c->db,c->argv[1])) {
+                addReply(c,shared.cone);
+                g_pserver->dirty++;
+            } else {
+                addReply(c,shared.czero);
+            }
+        } else if (c->argc == 3) {
+            if (removeSubkeyExpire(c->db, c->argv[1], c->argv[2])) {
+                addReply(c,shared.cone);
+                g_pserver->dirty++;
+            } else {
+                addReply(c,shared.czero);
+            }
         } else {
-            addReply(c,shared.czero);
+            addReplyError(c, "Invalid arguments");
         }
     } else {
         addReply(c,shared.czero);

src/fastlock.cpp

@@ -27,6 +27,7 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
+#include "fmacros.h"
 #include "fastlock.h"
 #include <unistd.h>
 #include <sys/syscall.h>
@@ -36,6 +37,14 @@
 #include <assert.h>
 #include <pthread.h>
 #include <limits.h>
+#include <map>
+#ifdef __linux__
+#include <linux/futex.h>
+#endif
+#include <string.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include "config.h"
 
 #ifdef __APPLE__
 #include <TargetConditionals.h>
@@ -49,6 +58,17 @@
 #endif
 #endif
 
+#ifndef UNUSED
+#define UNUSED(x) ((void)x)
+#endif
+
+#ifdef HAVE_BACKTRACE
+#include <ucontext.h>
+__attribute__((weak)) void logStackTrace(ucontext_t *) {}
+#endif
+
+extern int g_fInCrash;
+
 /****************************************************
  *
  *      Implementation of a fair spinlock.  To promote fairness we
@@ -56,14 +76,85 @@
  * 
  ****************************************************/
 
-static_assert(sizeof(pid_t) <= sizeof(fastlock::m_pidOwner), "fastlock::m_pidOwner not large enough");
-uint64_t g_longwaits = 0;
 
-uint64_t fastlock_getlongwaitcount()
+#if !defined(__has_feature)
+    #define __has_feature(x) 0
+#endif
+
+#ifdef __linux__
+extern "C" void unlock_futex(struct fastlock *lock, uint16_t ifutex);
+#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
+
+#pragma weak _serverPanic
+extern "C"  __attribute__((weak)) void _serverPanic(const char * /*file*/, int /*line*/, const char * /*msg*/, ...)
 {
-    return g_longwaits;
+    *((char*)-1) = 'x';
 }
 
+#pragma weak serverLog
+__attribute__((weak)) void serverLog(int , const char *fmt, ...)
+{
+    va_list args;
+    va_start(args, fmt);
+    vprintf(fmt, args);
+    va_end(args);
+    printf("\n");
+}
 
 extern "C" pid_t gettid()
 {
@@ -82,64 +173,215 @@ extern "C" pid_t gettid()
     return pidCache;
 }
 
-extern "C" void fastlock_init(struct fastlock *lock)
+void printTrace()
+{
+#ifdef HAVE_BACKTRACE
+    serverLog(3 /*LL_WARNING*/, "printing backtrace for thread %d", gettid());
+    ucontext_t ctxt;
+    getcontext(&ctxt);
+    logStackTrace(&ctxt);
+#endif
+}
+
+
+#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
+
+class DeadlockDetector
+{
+    std::map<pid_t, fastlock *> m_mapwait;
+    fastlock m_lock { "deadlock detector" };
+public:
+    void registerwait(fastlock *lock, pid_t thispid)
+    {
+        static volatile bool fInDeadlock = false;
+
+        if (lock == &m_lock || g_fInCrash)
+            return;
+        fastlock_lock(&m_lock);
+        
+        if (fInDeadlock)
+        {
+            printTrace();
+            fastlock_unlock(&m_lock);
+            return;
+        }
+
+        m_mapwait.insert(std::make_pair(thispid, lock));
+
+        // Detect cycles
+        pid_t pidCheck = thispid;
+        size_t cchecks = 0;
+        for (;;)
+        {
+            auto itr = m_mapwait.find(pidCheck);
+            if (itr == m_mapwait.end())
+                break;
+            pidCheck = itr->second->m_pidOwner;
+            if (pidCheck == thispid)
+            {
+                // Deadlock detected, printout some debugging info and crash
+                serverLog(3 /*LL_WARNING*/, "\n\n");
+                serverLog(3 /*LL_WARNING*/, "!!! ERROR: Deadlock detected !!!");
+                pidCheck = thispid;
+                for (;;)
+                {
+                    auto itr = m_mapwait.find(pidCheck);
+                    serverLog(3 /* LL_WARNING */, "\t%d: (%p) %s", pidCheck, itr->second, itr->second->szName);
+                    pidCheck = itr->second->m_pidOwner;
+                    if (pidCheck == thispid)
+                        break;
+                }
+                // Wake All sleeping threads so they can print their callstacks
+#ifdef HAVE_BACKTRACE
+#ifdef __linux__
+                int mask = -1;
+                fInDeadlock = true;
+                fastlock_unlock(&m_lock);
+                futex(&lock->m_ticket.u, FUTEX_WAKE_BITSET_PRIVATE, INT_MAX, nullptr, mask);
+                futex(&itr->second->m_ticket.u, FUTEX_WAKE_BITSET_PRIVATE, INT_MAX, nullptr, mask);
+                sleep(2);
+                fastlock_lock(&m_lock);
+                printTrace();
+#endif
+#endif
+                serverLog(3 /*LL_WARNING*/, "!!! KeyDB Will Now Crash !!!");
+                _serverPanic(__FILE__, __LINE__, "Deadlock detected");
+            }
+
+            if (cchecks > m_mapwait.size())
+                break;  // There is a cycle but we're not in it
+            ++cchecks;
+        }
+        fastlock_unlock(&m_lock);
+    }
+
+    void clearwait(fastlock *lock, pid_t thispid)
+    {
+        if (lock == &m_lock || g_fInCrash)
+            return;
+        fastlock_lock(&m_lock);
+        m_mapwait.erase(thispid);
+        fastlock_unlock(&m_lock);
+    }
+};
+
+DeadlockDetector g_dlock;
+
+static_assert(sizeof(pid_t) <= sizeof(fastlock::m_pidOwner), "fastlock::m_pidOwner not large enough");
+uint64_t g_longwaits = 0;
+
+extern "C" void fastlock_panic(struct fastlock *lock)
+{
+    _serverPanic(__FILE__, __LINE__, "fastlock lock/unlock mismatch for: %s", lock->szName);
+}
+
+uint64_t fastlock_getlongwaitcount()
+{
+    uint64_t rval;
+    __atomic_load(&g_longwaits, &rval, __ATOMIC_RELAXED);
+    return rval;
+}
+
+extern "C" void fastlock_sleep(fastlock *lock, pid_t pid, unsigned wake, unsigned mask)
+{
+#ifdef __linux__
+    g_dlock.registerwait(lock, pid);
+    __atomic_fetch_or(&lock->futex, mask, __ATOMIC_ACQUIRE);
+    futex(&lock->m_ticket.u, FUTEX_WAIT_BITSET_PRIVATE, wake, nullptr, mask);
+    __atomic_fetch_and(&lock->futex, ~mask, __ATOMIC_RELEASE);
+    g_dlock.clearwait(lock, pid);
+#endif
+    __atomic_fetch_add(&g_longwaits, 1, __ATOMIC_RELAXED);
+}
+
+extern "C" void fastlock_init(struct fastlock *lock, const char *name)
 {
     lock->m_ticket.m_active = 0;
     lock->m_ticket.m_avail = 0;
     lock->m_depth = 0;
     lock->m_pidOwner = -1;
+    lock->futex = 0;
+    int cch = strlen(name);
+    cch = std::min<int>(cch, sizeof(lock->szName)-1);
+    memcpy(lock->szName, name, cch);
+    lock->szName[cch] = '\0';
+    ANNOTATE_RWLOCK_CREATE(lock);
 }
 
 #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;
     }
 
+    int tid = gettid();
     unsigned myticket = __atomic_fetch_add(&lock->m_ticket.m_avail, 1, __ATOMIC_RELEASE);
+    unsigned mask = (1U << (myticket % 32));
+    unsigned cloops = 0;
+    ticket ticketT;
 
-    int cloops = 0;
-    while (__atomic_load_2(&lock->m_ticket.m_active, __ATOMIC_ACQUIRE) != myticket)
+    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");
+        __asm__ __volatile__ ("pause");
+#elif defined(__aarch64__)
+        __asm__ __volatile__ ("yield");
 #endif
+        if ((++cloops % 0x100000) == 0)
+        {
+            fastlock_sleep(lock, tid, ticketT.u, mask);
+        }
     }
 
     lock->m_depth = 1;
-    __atomic_store_4(&lock->m_pidOwner, gettid(), __ATOMIC_RELEASE);
+    __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.u, &ticket_expect.u, &ticket_setiflocked.u, 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;
@@ -150,10 +392,39 @@ 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
+
+#ifdef __linux__
+#define ROL32(v, shift) ((v << shift) | (v >> (32-shift)))
+extern "C" void unlock_futex(struct fastlock *lock, uint16_t ifutex)
+{
+    unsigned mask = (1U << (ifutex % 32));
+    unsigned futexT;
+    
+    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
@@ -164,10 +435,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

@@ -1,5 +1,6 @@
 #pragma once
 #include <inttypes.h>
+#include <stddef.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -7,11 +8,13 @@ extern "C" {
 
 /* Begin C API */
 struct fastlock;
-void fastlock_init(struct fastlock *lock);
+void fastlock_init(struct fastlock *lock, const char *name);
 void fastlock_lock(struct fastlock *lock);
-int fastlock_trylock(struct fastlock *lock);
+int 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,39 +23,65 @@ 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;
+    char szName[56];
+    /* Volatile data on seperate cache line */
+    volatile struct ticket m_ticket;
+    unsigned futex;
+    char padding[56];   // ensure ticket and futex are on their own independent cache line
 
 #ifdef __cplusplus
-    fastlock()
+    fastlock(const char *name)
     {
-        fastlock_init(this);
+        fastlock_init(this, name);
     }
 
-    void lock()
+    inline void lock()
     {
         fastlock_lock(this);
     }
 
-    bool try_lock()
+    inline bool try_lock(bool fWeak = false)
     {
-        return !!fastlock_trylock(this);
+        return !!fastlock_trylock(this, fWeak);
     }
 
-    void unlock()
+    inline void unlock()
     {
         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
 };
+
+static_assert(offsetof(struct fastlock, m_ticket) == 64, "ensure padding is correct");

src/fastlock_x64.asm

@@ -1,122 +1,152 @@
-section .text
+.intel_syntax noprefix
+.text
 
-extern gettid
-extern sched_yield
-extern g_longwaits
+.extern gettid
+.extern fastlock_sleep
 
-;	This is the first use of assembly in this codebase, a valid question is WHY?
-;	The spinlock we implement here is performance critical, and simply put GCC
-;	emits awful code.  The original C code is left in fastlock.cpp for reference
-;	and x-plat.
+#	This is the first use of assembly in this codebase, a valid question is WHY?
+#	The spinlock we implement here is performance critical, and simply put GCC
+#	emits awful code.  The original C code is left in fastlock.cpp for reference
+#	and x-plat.
 
-ALIGN 16
-global fastlock_lock
+.ALIGN 16
+.global fastlock_lock
+.type   fastlock_lock,@function
 fastlock_lock:
-	; RDI points to the struct:
-	;	uint16_t active
-	;	uint16_t avail
-	;	int32_t m_pidOwner
-	;	int32_t m_depth
+	.cfi_startproc
+	.cfi_def_cfa rsp, 8
+	# RDI points to the struct:
+	#	int32_t m_pidOwner
+	#	int32_t m_depth
+	# [rdi+64] ...
+	#	uint16_t active
+	#	uint16_t avail
 	
-	; First get our TID and put it in ecx
-	push rdi                ; we need our struct pointer (also balance the stack for the call)
-	call gettid             ; get our thread ID (TLS is nasty in ASM so don't bother inlining)
-	mov esi, eax            ; back it up in esi
-	mov rdi, [rsp]          ; get our pointer back
+	# First get our TID and put it in ecx
+	push rdi                # we need our struct pointer (also balance the stack for the call)
+	.cfi_adjust_cfa_offset 8
+	call gettid             # get our thread ID (TLS is nasty in ASM so don't bother inlining)
+	mov esi, eax            # back it up in esi
+	pop rdi                 # get our pointer back
+	.cfi_adjust_cfa_offset -8
 
-	cmp [rdi+4], esi        ; Is the TID we got back the owner of the lock?
-	je .LLocked             ; Don't spin in that case
+	cmp [rdi], esi          # Is the TID we got back the owner of the lock?
+	je .LLocked             # Don't spin in that case
 
-	xor eax, eax            ; eliminate partial register dependency
-	inc eax                 ; we want to add one
-	lock xadd [rdi+2], ax   ; do the xadd, ax contains the value before the addition
-	; eax now contains the ticket
+	xor eax, eax            # eliminate partial register dependency
+	inc eax                 # we want to add one
+	lock xadd [rdi+66], ax  # do the xadd, ax contains the value before the addition
+	# ax now contains the ticket
+	# OK Start the wait loop
 	xor ecx, ecx
-ALIGN 16
+.ALIGN 16
 .LLoop:
-	cmp [rdi], ax           ; is our ticket up?
-	je .LLocked             ; leave the loop
+	mov edx, [rdi+64]
+	cmp dx, ax              # is our ticket up?
+	je .LLocked             # leave the loop
 	pause
-	add ecx, 1000h          ; Have we been waiting a long time? (oflow if we have)
-	                        ;	1000h is set so we overflow on the 1024*1024'th iteration (like the C code)
-	jnc .LLoop              ; If so, give up our timeslice to someone who's doing real work
-	; Like the compiler, you're probably thinking: "Hey! I should take these pushs out of the loop"
-	;	But the compiler doesn't know that we rarely hit this, and when we do we know the lock is
-	;	taking a long time to be released anyways.  We optimize for the common case of short
-	;	lock intervals.  That's why we're using a spinlock in the first place
+	add ecx, 0x1000         # Have we been waiting a long time? (oflow if we have)
+	                        #	1000h is set so we overflow on the 1024*1024'th iteration (like the C code)
+	jnc .LLoop              # If so, give up our timeslice to someone who's doing real work
+	# Like the compiler, you're probably thinking: "Hey! I should take these pushs out of the loop"
+	#	But the compiler doesn't know that we rarely hit this, and when we do we know the lock is
+	#	taking a long time to be released anyways.  We optimize for the common case of short
+	#	lock intervals.  That's why we're using a spinlock in the first place
+	# If we get here we're going to sleep in the kernel with a futex
+	push rdi
 	push rsi
 	push rax
-	mov rax, 24             ; sys_sched_yield
-	syscall                 ; give up our timeslice we'll be here a while
+	.cfi_adjust_cfa_offset 24
+	# Setup the syscall args
+
+                            # rdi ARG1 futex (already in rdi)
+	                        # rsi ARG2 tid (already in esi)
+                            # rdx ARG3 ticketT.u (already in edx)
+	bts ecx, eax            # rcx ARG4 mask
+	call fastlock_sleep
+	# cleanup and continue
 	pop rax
 	pop rsi
-	mov rcx, g_longwaits
-	inc qword [rcx]         ; increment our long wait counter
-	mov rdi, [rsp]          ; our struct pointer is on the stack already
-	xor ecx, ecx            ; Reset our loop counter
-	jmp .LLoop              ; Get back in the game
-ALIGN 16
+	pop rdi
+	.cfi_adjust_cfa_offset -24
+	xor ecx, ecx            # Reset our loop counter
+	jmp .LLoop              # Get back in the game
+.ALIGN 16
 .LLocked:
-	mov [rdi+4], esi        ; lock->m_pidOwner = gettid()
-	inc dword [rdi+8]       ; lock->m_depth++
-	add rsp, 8              ; fix stack
+	mov [rdi], esi          # lock->m_pidOwner = gettid()
+	inc dword ptr [rdi+4]   # lock->m_depth++
 	ret
+.cfi_endproc
 
-ALIGN 16
-global fastlock_trylock
+.ALIGN 16
+.global fastlock_trylock
+.type   fastlock_trylock,@function
 fastlock_trylock:
-	; RDI points to the struct:
-	;	uint16_t active
-	;	uint16_t avail
-	;	int32_t m_pidOwner
-	;	int32_t m_depth
+	# RDI points to the struct:
+	#	int32_t m_pidOwner
+	#	int32_t m_depth
+	# [rdi+64] ...
+	#	uint16_t active
+	#	uint16_t avail
 	
-	; First get our TID and put it in ecx
-	push rdi                ; we need our struct pointer (also balance the stack for the call)
-	call gettid             ; get our thread ID (TLS is nasty in ASM so don't bother inlining)
-	mov esi, eax            ; back it up in esi
-	pop rdi                 ; get our pointer back
+	# First get our TID and put it in ecx
+	push rdi                # we need our struct pointer (also balance the stack for the call)
+	call gettid             # get our thread ID (TLS is nasty in ASM so don't bother inlining)
+	mov esi, eax            # back it up in esi
+	pop rdi                 # get our pointer back
 
-	cmp [rdi+4], esi        ; Is the TID we got back the owner of the lock?
-	je .LRecursive          ; Don't spin in that case
+	cmp [rdi], esi          # Is the TID we got back the owner of the lock?
+	je .LRecursive          # Don't spin in that case
 
-	mov eax, [rdi]          ; get both active and avail counters
-	mov ecx, eax            ; duplicate in ecx
-	ror ecx, 16             ; swap upper and lower 16-bits
-	cmp eax, ecx            ; are the upper and lower 16-bits the same?
-	jnz .LAlreadyLocked     ;	If not return failure
+	mov eax, [rdi+64]       # get both active and avail counters
+	mov ecx, eax            # duplicate in ecx
+	ror ecx, 16             # swap upper and lower 16-bits
+	cmp eax, ecx            # are the upper and lower 16-bits the same?
+	jnz .LAlreadyLocked     #	If not return failure
 
-	; at this point we know eax+ecx have [avail][active] and they are both the same
-	add ecx, 10000h         ; increment avail, ecx is now our wanted value
-	lock cmpxchg [rdi], ecx ;	If rdi still contains the value in eax, put in ecx (inc avail)
-	jnz .LAlreadyLocked     ; If Z is not set then someone locked it while we were preparing
+	# at this point we know eax+ecx have [avail][active] and they are both the same
+	add ecx, 0x10000            # increment avail, ecx is now our wanted value
+	lock cmpxchg [rdi+64], ecx  #	If rdi still contains the value in eax, put in ecx (inc avail)
+	jnz .LAlreadyLocked         # If Z is not set then someone locked it while we were preparing
 	xor eax, eax
-	inc eax                 ; return SUCCESS! (eax=1)
-	mov [rdi+4], esi        ; lock->m_pidOwner = gettid()
-	mov dword [rdi+8], eax  ; lock->m_depth = 1
+	inc eax                     # return SUCCESS! (eax=1)
+	mov [rdi], esi              # lock->m_pidOwner = gettid()
+	mov dword ptr [rdi+4], eax  # lock->m_depth = 1
 	ret
-ALIGN 16
+.ALIGN 16
 .LRecursive:
 	xor eax, eax
-	inc eax                 ; return SUCCESS! (eax=1)
-	inc dword [rdi+8]       ; lock->m_depth++
+	inc eax                 # return SUCCESS! (eax=1)
+	inc dword ptr [rdi+4]   # lock->m_depth++
 	ret
-ALIGN 16
+.ALIGN 16
 .LAlreadyLocked:
-	xor eax, eax            ; return 0;
+	xor eax, eax            # return 0
 	ret
 
-ALIGN 16
-global fastlock_unlock
+.ALIGN 16
+.global fastlock_unlock
+.type   fastlock_unlock,@function
 fastlock_unlock:
-	; RDI points to the struct:
-	;	uint16_t active
-	;	uint16_t avail
-	;	int32_t m_pidOwner
-	;	int32_t m_depth
-	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)
+	# RDI points to the struct:
+	#	int32_t m_pidOwner
+	#	int32_t m_depth
+	# [rdi+64] ...
+	#	uint16_t active
+	#	uint16_t avail
+	sub dword ptr [rdi+4], 1     # decrement m_depth, don't use dec because it partially writes the flag register and we don't know its state
+	jnz .LDone                   # if depth is non-zero this is a recursive unlock, and we still hold it
+	mov dword ptr [rdi], -1      # pidOwner = -1 (we don't own it anymore)
+	mov esi, [rdi+64]            # get current active (this one)
+	inc esi                      # bump it to the next thread
+	mov word ptr [rdi+64], si    # give up our ticket (note: lock is not required here because the spinlock itself guards this variable)
+	mfence                       # sync other threads
+	# At this point the lock is removed, however we must wake up any pending futexs
+	mov edx, [rdi+64+4]          # load the futex mask
+	bt edx, esi                  # is the next thread waiting on a futex?
+	jc unlock_futex              # unlock the futex if necessary
+	ret                          # if not we're done.
+.ALIGN 16
 .LDone:
+	js fastlock_panic            # panic if we made m_depth negative
 	ret

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",
@@ -1162,7 +1168,13 @@ struct commandHelp {
     "destination numkeys key [key ...] [WEIGHTS weight] [AGGREGATE SUM|MIN|MAX]",
     "Add multiple sorted sets and store the resulting sorted set in a new key",
     4,
-    "2.0.0" }
+    "2.0.0" },
+    { "KEYDB.CRON",
+    "name [single/repeat] [optional: start] delay script numkeys [key N] [arg N]",
+    "Run a specified script after start + delay, optionally repeating every delay interval.  The job may be cancelled by deleting the key associated with the job (name parameter)",
+    10,
+    "6.5.2"
+    }
 };
 
 #endif

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

@@ -52,16 +52,19 @@ size_t lazyfreeGetFreeEffort(robj *obj) {
  * 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));
-
     /* 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));
     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. */
+            removeExpireCore(db,key,de);
+        }
+
         size_t free_effort = lazyfreeGetFreeEffort(val);
 
         /* If releasing the object is too much work, do it in the background
@@ -72,7 +75,7 @@ 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);
@@ -93,7 +96,7 @@ int dbAsyncDelete(redisDb *db, robj *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 {
@@ -105,11 +108,13 @@ void freeObjAsync(robj *o) {
  * 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;
+    dict *oldht1 = db->pdict;
+    auto *set = db->setexpire;
+    db->setexpire = new (MALLOC_LOCAL) expireset();
+    db->expireitr = db->setexpire->end();
     db->pdict = dictCreate(&dbDictType,NULL);
-    db->expires = dictCreate(&keyptrDictType,NULL);
     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 +141,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 = getExpire(key->db,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. */
@@ -4023,7 +4043,7 @@ int moduleGILAcquiredByModule(void) {
  * used to send anything to the client, and has the db number where the event
  * occurred as its selected db number.
  *
- * Notice that it is not necessary to enable notifications in redis.conf for
+ * Notice that it is not necessary to enable notifications in keydb.conf for
  * module notifications to work.
  *
  * Warning: the notification callbacks are performed in a synchronous manner,
@@ -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/motd.cpp

@@ -0,0 +1,132 @@
+#include "sds.h"
+#include <cstring>
+#include <unistd.h>
+#include <sys/types.h>
+#include <pwd.h>
+#include <sys/stat.h>
+#include "motd.h"
+
+/*------------------------------------------------------------------------------
+ * 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, motd_cache_file);
+    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");
+    if (pf == NULL)
+        return;
+    size_t celem = fwrite(sz, strlen(sz), 1, pf);
+    (void)celem;    // best effort
+    fclose(pf);
+}
+
+extern "C" char *fetchMOTD(int cache)
+{
+    sds str;
+    CURL *curl;
+    CURLcode res;
+
+    /* First try and get the string from the cache */
+    if (cache) {
+        str = fetchMOTDFromCache();
+        if (str != NULL)
+            return str;
+    }
+
+    str = sdsnew("");
+    curl = curl_easy_init();
+    if(curl) {
+        curl_easy_setopt(curl, CURLOPT_URL, motd_url);
+        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;
+        }
+        else
+        {
+            long response_code;
+            curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+            if ((response_code / 100) != 2)
+            {
+                // An error code not in the 200s implies an error
+                sdsfree(str);
+                str = NULL;
+            }
+        }
+
+        /* always cleanup */ 
+        curl_easy_cleanup(curl);
+
+        if (str != NULL && cache)
+            setMOTDCache(str);
+    }
+    return str;
+}
+
+#else
+
+extern "C" char *fetchMOTD(int /* cache */)
+{
+    return NULL;
+}
+
+#endif

src/motd.h

@@ -0,0 +1,14 @@
+#pragma once
+
+extern const char *motd_url;
+extern const char *motd_cache_file;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+    
+char *fetchMOTD(int fCache);
+
+#ifdef __cplusplus
+}
+#endif

src/multi.cpp

@@ -28,6 +28,7 @@
  */
 
 #include "server.h"
+bool FInReplicaReplay();
 
 /* ================================ MULTI/EXEC ============================== */
 
@@ -82,7 +83,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 +143,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). */
@@ -173,12 +173,15 @@ void execCommand(client *c) {
          * This way we'll deliver the MULTI/..../EXEC block as a whole and
          * both the AOF and the replication link will have the same consistency
          * and atomicity guarantees. */
-        if (!must_propagate && !(c->cmd->flags & (CMD_READONLY|CMD_ADMIN))) {
+        if (!must_propagate && !(c->cmd->flags & (CMD_READONLY|CMD_ADMIN)) && !(FInReplicaReplay())) {
             execCommandPropagateMulti(c);
             must_propagate = 1;
         }
 
-        call(c,g_pserver->loading ? CMD_CALL_NONE : CMD_CALL_FULL);
+        int flags = g_pserver->loading ? CMD_CALL_NONE : CMD_CALL_FULL;
+        if (FInReplicaReplay())
+            flags &= ~CMD_CALL_PROPAGATE;
+        call(c,flags);
 
         /* Commands may alter argc/argv, restore mstate. */
         c->mstate.commands[j].argc = c->argc;
@@ -196,7 +199,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. */

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

@@ -29,6 +29,7 @@
  */
 
 #include "server.h"
+#include "cron.h"
 #include <math.h>
 #include <ctype.h>
 
@@ -39,11 +40,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 +69,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 +88,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 +354,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;
@@ -365,12 +370,12 @@ void decrRefCount(robj_roptr o) {
         case OBJ_HASH: freeHashObject(o); break;
         case OBJ_MODULE: freeModuleObject(o); break;
         case OBJ_STREAM: freeStreamObject(o); break;
+        case OBJ_CRON: freeCronObject(o); break;
         default: serverPanic("Unknown object type"); break;
         }
         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 +399,7 @@ void decrRefCountVoid(const void *o) {
  *    decrRefCount(obj);
  */
 robj *resetRefCount(robj *obj) {
-    obj->refcount = 0;
+    obj->setrefcount(0);
     return obj;
 }
 
@@ -452,7 +457,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 +629,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 +671,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);
@@ -711,6 +716,34 @@ int getLongLongFromObject(robj *o, long long *target) {
     return C_OK;
 }
 
+int getUnsignedLongLongFromObject(robj *o, uint64_t *target) {
+    uint64_t value;
+
+    if (o == NULL) {
+        value = 0;
+    } else {
+        serverAssertWithInfo(NULL,o,o->type == OBJ_STRING);
+        if (sdsEncodedObject(o)) {
+            char *pchEnd = nullptr;
+            errno = 0;
+            value = strtoull(szFromObj(o), &pchEnd, 10);
+            if (value == 0) {
+                // potential error
+                if (errno != 0)
+                    return C_ERR;
+                if (pchEnd == szFromObj(o))
+                    return C_ERR;
+            }
+        } else if (o->encoding == OBJ_ENCODING_INT) {
+            value = (long)ptrFromObj(o);
+        } else {
+            serverPanic("Unknown string encoding");
+        }
+    }
+    if (target) *target = value;
+    return C_OK;
+}
+
 int getLongLongFromObjectOrReply(client *c, robj *o, long long *target, const char *msg) {
     long long value;
     if (getLongLongFromObject(o, &value) != C_OK) {
@@ -1064,8 +1097,7 @@ struct redisMemOverhead *getMemoryOverheadData(void) {
         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;
 
@@ -1275,7 +1307,7 @@ NULL
     } 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);
+        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;
@@ -1300,6 +1332,10 @@ NULL
          * because we update the access time only
          * when the key is read or overwritten. */
         addReplyLongLong(c,LFUDecrAndReturn(o));
+    } else if (!strcasecmp(szFromObj(c->argv[1]), "lastmodified") && c->argc == 3) {
+        if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.null[c->resp]))
+                == NULL) return;
+        addReplyLongLong(c, (g_pserver->mstime - (o->mvcc_tstamp >> MVCC_MS_SHIFT)) / 1000);
     } else {
         addReplySubcommandSyntaxError(c);
     }
@@ -1341,7 +1377,7 @@ NULL
             }
         }
         if ((de = dictFind(c->db->pdict,ptrFromObj(c->argv[2]))) == NULL) {
-            addReplyNull(c);
+            addReplyNull(c, shared.nullbulk);
             return;
         }
         size_t usage = objectComputeSize((robj*)dictGetVal(de),samples);
@@ -1474,3 +1510,18 @@ 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); 
+}

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,9 +299,13 @@ int pubsubPublishMessage(robj *channel, robj *message) {
         listRewind(list,&li);
         while ((ln = listNext(&li)) != NULL) {
             client *c = reinterpret_cast<client*>(ln->value);
-            fastlock_lock(&c->lock);
+            if (c->flags & CLIENT_CLOSE_ASAP)   // avoid blocking if the write will be ignored
+                continue;
+            if (FCorrectThread(c))
+                fastlock_lock(&c->lock);
             addReplyPubsubMessage(c,channel,message);
-            fastlock_unlock(&c->lock);
+            if (FCorrectThread(c))
+                fastlock_unlock(&c->lock);
             receivers++;
         }
     }
@@ -311,10 +321,14 @@ int pubsubPublishMessage(robj *channel, robj *message) {
                                 (char*)ptrFromObj(channel),
                                 sdslen(szFromObj(channel)),0))
             {
-                fastlock_lock(&pat->pclient->lock);
+                if (pat->pclient->flags & CLIENT_CLOSE_ASAP)
+                    continue;
+                if (FCorrectThread(pat->pclient))
+                    fastlock_lock(&pat->pclient->lock);
                 addReplyPubsubPatMessage(pat->pclient,
                     pat->pattern,channel,message);
-                fastlock_unlock(&pat->pclient->lock);
+                if (FCorrectThread(pat->pclient))
+                    fastlock_unlock(&pat->pclient->lock);
                 receivers++;
             }
         }

src/rdb-s3.cpp

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

@@ -33,6 +33,7 @@
 #include "endianconv.h"
 #include "stream.h"
 #include "storage.h"
+#include "cron.h"
 
 #include <math.h>
 #include <sys/types.h>
@@ -278,8 +279,8 @@ void *rdbLoadIntegerObject(rio *rdb, int enctype, int flags, size_t *lenptr) {
         v = enc[0]|(enc[1]<<8)|(enc[2]<<16)|(enc[3]<<24);
         val = (int32_t)v;
     } else {
-        val = 0; /* anti-warning */
         rdbExitReportCorruptRDB("Unknown RDB integer encoding type %d",enctype);
+        return nullptr; /* Never reached. */
     }
     if (plain || sds) {
         char buf[LONG_STR_SIZE], *p;
@@ -382,8 +383,7 @@ void *rdbLoadLzfStringObject(rio *rdb, int flags, size_t *lenptr) {
     /* Load the compressed representation and uncompress it to target. */
     if (rioRead(rdb,c,clen) == 0) goto err;
     if (lzf_decompress(c,clen,val,len) == 0) {
-        if (rdbCheckMode) rdbCheckSetError("Invalid LZF compressed string");
-        goto err;
+        rdbExitReportCorruptRDB("Invalid LZF compressed string");
     }
     zfree(c);
 
@@ -497,6 +497,7 @@ void *rdbGenericLoadStringObject(rio *rdb, int flags, size_t *lenptr) {
             return rdbLoadLzfStringObject(rdb,flags,lenptr);
         default:
             rdbExitReportCorruptRDB("Unknown RDB string encoding type %d",len);
+            return nullptr; /* Never reached. */
         }
     }
 
@@ -523,6 +524,11 @@ void *rdbGenericLoadStringObject(rio *rdb, int flags, size_t *lenptr) {
     }
 }
 
+sdsstring rdbLoadString(rio *rdb){
+    sds str = (sds)rdbGenericLoadStringObject(rdb,RDB_LOAD_SDS,NULL);
+    return sdsstring(str);
+}
+
 robj *rdbLoadStringObject(rio *rdb) {
     return (robj*)rdbGenericLoadStringObject(rdb,RDB_LOAD_NONE,NULL);
 }
@@ -543,10 +549,10 @@ int rdbSaveDoubleValue(rio *rdb, double val) {
     unsigned char buf[128];
     int len;
 
-    if (isnan(val)) {
+    if (std::isnan(val)) {
         buf[0] = 253;
         len = 1;
-    } else if (!isfinite(val)) {
+    } else if (!std::isfinite(val)) {
         len = 1;
         buf[0] = (val < 0) ? 255 : 254;
     } else {
@@ -657,6 +663,8 @@ int rdbSaveObjectType(rio *rdb, robj_roptr o) {
         return rdbSaveType(rdb,RDB_TYPE_STREAM_LISTPACKS);
     case OBJ_MODULE:
         return rdbSaveType(rdb,RDB_TYPE_MODULE_2);
+    case OBJ_CRON:
+        return rdbSaveType(rdb,RDB_TYPE_CRON);
     default:
         serverPanic("Unknown object type");
     }
@@ -986,6 +994,17 @@ ssize_t rdbSaveObject(rio *rdb, robj_roptr o, robj *key) {
             zfree(io.ctx);
         }
         return io.error ? -1 : (ssize_t)io.bytes;
+    } else if (o->type == OBJ_CRON) {
+        cronjob *job = (cronjob*)ptrFromObj(o);
+        rdbSaveRawString(rdb, (const unsigned char*)job->script.get(), job->script.size());
+        rdbSaveMillisecondTime(rdb, job->startTime);
+        rdbSaveMillisecondTime(rdb, job->interval);
+        rdbSaveLen(rdb, job->veckeys.size());
+        for (auto &key : job->veckeys)
+            rdbSaveRawString(rdb, (const unsigned char*)key.get(), key.size());
+        rdbSaveLen(rdb, job->vecargs.size());
+        for (auto &arg : job->vecargs)
+            rdbSaveRawString(rdb, (const unsigned char*)arg.get(), arg.size());
     } else {
         serverPanic("Unknown object type");
     }
@@ -1031,12 +1050,13 @@ size_t rdbSavedObjectLen(robj *o) {
  * On error -1 is returned.
  * On success if the key was actually saved 1 is returned, otherwise 0
  * is returned (the key was already expired). */
-int rdbSaveKeyValuePair(rio *rdb, robj *key, robj *val, long long expiretime) {
+int rdbSaveKeyValuePair(rio *rdb, robj *key, robj *val, expireEntry *pexpire) {
     int savelru = g_pserver->maxmemory_policy & MAXMEMORY_FLAG_LRU;
     int savelfu = g_pserver->maxmemory_policy & MAXMEMORY_FLAG_LFU;
 
     /* Save the expire time */
-    if (expiretime != -1) {
+    long long expiretime = -1;
+    if (pexpire != nullptr && pexpire->FGetPrimaryExpire(&expiretime)) {
         if (rdbSaveType(rdb,RDB_OPCODE_EXPIRETIME_MS) == -1) return -1;
         if (rdbSaveMillisecondTime(rdb,expiretime) == -1) return -1;
     }
@@ -1061,14 +1081,29 @@ int rdbSaveKeyValuePair(rio *rdb, robj *key, robj *val, long long expiretime) {
         if (rdbWriteRaw(rdb,buf,1) == -1) return -1;
     }
 
-    char szMvcc[32];
-    snprintf(szMvcc, 32, "%" PRIu64, val->mvcc_tstamp);
-    if (rdbSaveAuxFieldStrStr(rdb,"mvcc-tstamp", szMvcc) == -1) return -1;
+    char szT[32];
+    snprintf(szT, 32, "%" PRIu64, val->mvcc_tstamp);
+    if (rdbSaveAuxFieldStrStr(rdb,"mvcc-tstamp", szT) == -1) return -1;
 
     /* Save type, key, value */
     if (rdbSaveObjectType(rdb,val) == -1) return -1;
     if (rdbSaveStringObject(rdb,key) == -1) return -1;
     if (rdbSaveObject(rdb,val,key) == -1) return -1;
+
+    /* Save expire entry after as it will apply to the previously loaded key */
+    /*  This is because we update the expire datastructure directly without buffering */
+    if (pexpire != nullptr)
+    {
+        for (auto itr : *pexpire)
+        {
+            if (itr.subkey() == nullptr)
+                continue;   // already saved
+            snprintf(szT, 32, "%lld", itr.when());
+            rdbSaveAuxFieldStrStr(rdb,"keydb-subexpire-key",itr.subkey());
+            rdbSaveAuxFieldStrStr(rdb,"keydb-subexpire-when",szT);
+        }
+    }
+
     return 1;
 }
 
@@ -1096,6 +1131,28 @@ int rdbSaveInfoAuxFields(rio *rdb, int flags, rdbSaveInfo *rsi) {
     return 1;
 }
 
+int saveKey(rio *rdb, redisDb *db, int flags, size_t *processed, const char *keystr, robj *o)
+{    
+    robj key;
+
+    initStaticStringObject(key,(char*)keystr);
+    expireEntry *pexpire = getExpire(db, &key);
+
+    if (rdbSaveKeyValuePair(rdb,&key,o,pexpire) == -1)
+        return 0;
+
+    /* When this RDB is produced as part of an AOF rewrite, move
+        * accumulated diff from parent to child while rewriting in
+        * order to have a smaller final write. */
+    if (flags & RDB_SAVE_AOF_PREAMBLE &&
+        rdb->processed_bytes > *processed+AOF_READ_DIFF_INTERVAL_BYTES)
+    {
+        *processed = rdb->processed_bytes;
+        aofReadDiffFromParent();
+    }
+    return 1;
+}
+
 /* Produces a dump of the database in RDB format sending it to the specified
  * Redis I/O channel. On success C_OK is returned, otherwise C_ERR
  * is returned and part of the output, or all the output, can be
@@ -1134,31 +1191,24 @@ int rdbSaveRio(rio *rdb, int *error, int flags, rdbSaveInfo *rsi) {
          * these sizes are just hints to resize the hash tables. */
         uint64_t db_size, expires_size;
         db_size = dictSize(db->pdict);
-        expires_size = dictSize(db->expires);
+        expires_size = db->setexpire->size();
         if (rdbSaveType(rdb,RDB_OPCODE_RESIZEDB) == -1) goto werr;
         if (rdbSaveLen(rdb,db_size) == -1) goto werr;
         if (rdbSaveLen(rdb,expires_size) == -1) goto werr;
-
+        
         /* Iterate this DB writing every entry */
+        size_t ckeysExpired = 0;
         while((de = dictNext(di)) != NULL) {
             sds keystr = (sds)dictGetKey(de);
-            robj key, *o = (robj*)dictGetVal(de);
-            long long expire;
+            robj *o = (robj*)dictGetVal(de);
 
-            initStaticStringObject(key,keystr);
-            expire = getExpire(db,&key);
-            if (rdbSaveKeyValuePair(rdb,&key,o,expire) == -1) goto werr;
-
-            /* When this RDB is produced as part of an AOF rewrite, move
-             * accumulated diff from parent to child while rewriting in
-             * order to have a smaller final write. */
-            if (flags & RDB_SAVE_AOF_PREAMBLE &&
-                rdb->processed_bytes > processed+AOF_READ_DIFF_INTERVAL_BYTES)
-            {
-                processed = rdb->processed_bytes;
-                aofReadDiffFromParent();
-            }
+            if (o->FExpires())
+                ++ckeysExpired;
+            
+            if (!saveKey(rdb, db, flags, &processed, keystr, o))
+                goto werr;
         }
+        serverAssert(ckeysExpired == db->setexpire->size());
         dictReleaseIterator(di);
         di = NULL; /* So that we don't release it again on error. */
     }
@@ -1220,12 +1270,12 @@ werr: /* Write error. */
     return C_ERR;
 }
 
-int rdbSaveFd(int fd, rdbSaveInfo *rsi)
+int rdbSaveFp(FILE *fp, rdbSaveInfo *rsi)
 {
     int error = 0;
     rio rdb;
 
-    rioInitWithFile(&rdb,fd);
+    rioInitWithFile(&rdb,fp);
 
     if (g_pserver->rdb_save_incremental_fsync)
         rioSetAutoSync(&rdb,REDIS_AUTOSYNC_BYTES);
@@ -1267,7 +1317,7 @@ int rdbSaveFile(char *filename, rdbSaveInfo *rsi) {
         return C_ERR;
     }
 
-    if (rdbSaveFd(fileno(fp), rsi) == C_ERR){
+    if (rdbSaveFp(fp, rsi) == C_ERR){
         goto werr;
     }
 
@@ -1495,9 +1545,15 @@ robj *rdbLoadObject(int rdbtype, rio *rdb, robj *key, uint64_t mvcc_tstamp) {
                 == NULL) return NULL;
 
             if (rdbtype == RDB_TYPE_ZSET_2) {
-                if (rdbLoadBinaryDoubleValue(rdb,&score) == -1) return NULL;
+                if (rdbLoadBinaryDoubleValue(rdb,&score) == -1) {
+                    sdsfree(sdsele);
+                    return NULL;
+                }
             } else {
-                if (rdbLoadDoubleValue(rdb,&score) == -1) return NULL;
+                if (rdbLoadDoubleValue(rdb,&score) == -1) {
+                    sdsfree(sdsele);
+                    return NULL;
+                }
             }
 
             /* Don't care about integer-encoded strings. */
@@ -1817,11 +1873,24 @@ robj *rdbLoadObject(int rdbtype, rio *rdb, robj *key, uint64_t mvcc_tstamp) {
             exit(1);
         }
         o = createModuleObject(mt,ptr);
+    } else if (rdbtype == RDB_TYPE_CRON) {
+        std::unique_ptr<cronjob> spjob = std::make_unique<cronjob>();
+        spjob->script = rdbLoadString(rdb);
+        spjob->startTime = rdbLoadMillisecondTime(rdb,RDB_VERSION);
+        spjob->interval = rdbLoadMillisecondTime(rdb,RDB_VERSION);
+        auto ckeys = rdbLoadLen(rdb,NULL);
+        for (uint64_t i = 0; i < ckeys; ++i)
+            spjob->veckeys.push_back(rdbLoadString(rdb));
+        auto cargs = rdbLoadLen(rdb,NULL);
+        for (uint64_t i = 0; i < cargs; ++i)
+            spjob->vecargs.push_back(rdbLoadString(rdb));
+        o = createObject(OBJ_CRON, spjob.release());
     } else {
         rdbExitReportCorruptRDB("Unknown RDB encoding type %d",rdbtype);
     }
 
     o->mvcc_tstamp = mvcc_tstamp;
+    serverAssert(!o->FExpires());
     return o;
 }
 
@@ -1887,9 +1956,11 @@ int rdbLoadRio(rio *rdb, rdbSaveInfo *rsi, int loading_aof) {
     redisDb *db = g_pserver->db+0;
     char buf[1024];
     /* Key-specific attributes, set by opcodes before the key type. */
-    long long lru_idle = -1, lfu_freq = -1, expiretime = -1, now = mstime();
+    long long lru_idle = -1, lfu_freq = -1, expiretime = -1, now;
     long long lru_clock = 0;
     uint64_t mvcc_tstamp = OBJ_MVCC_INVALID;
+    robj *subexpireKey = nullptr;
+    robj *key = nullptr;
 
     rdb->update_cksum = rdbLoadProgressCallback;
     rdb->max_processing_chunk = g_pserver->loading_process_events_interval_bytes;
@@ -1909,9 +1980,9 @@ int rdbLoadRio(rio *rdb, rdbSaveInfo *rsi, int loading_aof) {
 
     now = mstime();
     lru_clock = LRU_CLOCK();
-
+    
     while(1) {
-        robj *key, *val;
+        robj *val;
 
         /* Read type. */
         if ((type = rdbLoadType(rdb)) == -1) goto eoferr;
@@ -1965,7 +2036,6 @@ int rdbLoadRio(rio *rdb, rdbSaveInfo *rsi, int loading_aof) {
             if ((expires_size = rdbLoadLen(rdb,NULL)) == RDB_LENERR)
                 goto eoferr;
             dictExpand(db->pdict,db_size);
-            dictExpand(db->expires,expires_size);
             continue; /* Read next opcode. */
         } else if (type == RDB_OPCODE_AUX) {
             /* AUX: generic string-string fields. Use to add state to RDB
@@ -2020,6 +2090,18 @@ int rdbLoadRio(rio *rdb, rdbSaveInfo *rsi, int loading_aof) {
             } else if (!strcasecmp(szFromObj(auxkey),"mvcc-tstamp")) {
                 static_assert(sizeof(unsigned long long) == sizeof(uint64_t), "Ensure long long is 64-bits");
                 mvcc_tstamp = strtoull(szFromObj(auxval), nullptr, 10);
+            } else if (!strcasecmp(szFromObj(auxkey), "keydb-subexpire-key")) {
+                subexpireKey = auxval;
+                incrRefCount(subexpireKey);
+            } else if (!strcasecmp(szFromObj(auxkey), "keydb-subexpire-when")) {
+                if (key == nullptr || subexpireKey == nullptr) {
+                    serverLog(LL_WARNING, "Corrupt subexpire entry in RDB skipping. key: %s subkey: %s", key != nullptr ? szFromObj(key) : "(null)", subexpireKey != nullptr ? szFromObj(subexpireKey) : "(null)");
+                }
+                else {
+                    setExpire(NULL, db, key, subexpireKey, strtoll(szFromObj(auxval), nullptr, 10));
+                    decrRefCount(subexpireKey);
+                    subexpireKey = nullptr;
+                }
             } else {
                 /* We ignore fields we don't understand, as by AUX field
                  * contract. */
@@ -2061,37 +2143,49 @@ int rdbLoadRio(rio *rdb, rdbSaveInfo *rsi, int loading_aof) {
         }
 
         /* Read key */
+        if (key != nullptr)
+        {
+            decrRefCount(key);
+            key = nullptr;
+        }
+
         if ((key = rdbLoadStringObject(rdb)) == NULL) goto eoferr;
         /* Read value */
         if ((val = rdbLoadObject(type,rdb,key, mvcc_tstamp)) == NULL) goto eoferr;
+        bool fStaleMvccKey = val->mvcc_tstamp < rsi->mvccMinThreshold;
         /* Check if the key already expired. This function is used when loading
          * an RDB file from disk, either at startup, or when an RDB was
          * received from the master. In the latter case, the master is
          * responsible for key expiry. If we would expire keys here, the
-         * snapshot taken by the master may not be reflected on the slave. */
-        if (listLength(g_pserver->masters) == 0 && !loading_aof && expiretime != -1 && expiretime < now) {
+         * snapshot taken by the master may not be reflected on the replica. */
+        bool fExpiredKey = (listLength(g_pserver->masters) == 0 || g_pserver->fActiveReplica) && !loading_aof && expiretime != -1 && expiretime < now;
+        if (fStaleMvccKey || fExpiredKey) {
+            if (fStaleMvccKey && !fExpiredKey && rsi->mi != nullptr && rsi->mi->staleKeyMap != nullptr && lookupKeyRead(db, key) == nullptr) {
+                // We have a key that we've already deleted and is not back in our database.
+                //  We'll need to inform the sending master of the delete if it is also a replica of us
+                rsi->mi->staleKeyMap->operator[](db - g_pserver->db).push_back(key);
+            }
             decrRefCount(key);
+            key = nullptr;
             decrRefCount(val);
+            val = nullptr;
         } else {
             /* Add the new object in the hash table */
-            int fInserted = dbMerge(db, key, val, rsi->fForceSetKey);
+            int fInserted = dbMerge(db, key, val, rsi->fForceSetKey);   // Note: dbMerge will incrRef
 
             if (fInserted)
             {
                 /* Set the expire time if needed */
-                if (expiretime != -1) setExpire(NULL,db,key,expiretime);
+                if (expiretime != -1)
+                    setExpire(NULL,db,key,nullptr,expiretime);
 
                 /* Set usage information (for eviction). */
                 objectSetLRUOrLFU(val,lfu_freq,lru_idle,lru_clock);
-
-                /* Decrement the key refcount since dbMerge() will take its
-                * own reference. */
-                decrRefCount(key);
             }
             else
             {
-                decrRefCount(key);
                 decrRefCount(val);
+                val = nullptr;
             }
         }
 
@@ -2101,6 +2195,20 @@ int rdbLoadRio(rio *rdb, rdbSaveInfo *rsi, int loading_aof) {
         lfu_freq = -1;
         lru_idle = -1;
     }
+
+    if (key != nullptr)
+    {
+        decrRefCount(key);
+        key = nullptr;
+    }
+
+    if (subexpireKey != nullptr)
+    {
+        serverLog(LL_WARNING, "Corrupt subexpire entry in RDB.");
+        decrRefCount(subexpireKey);
+        subexpireKey = nullptr;
+    }
+    
     /* Verify the checksum if RDB version is >= 5 */
     if (rdbver >= 5) {
         uint64_t cksum, expected = rdb->cksum;
@@ -2119,12 +2227,22 @@ int rdbLoadRio(rio *rdb, rdbSaveInfo *rsi, int loading_aof) {
     return C_OK;
 
 eoferr: /* unexpected end of file is handled here with a fatal exit */
+    if (key != nullptr)
+    {
+        decrRefCount(key);
+        key = nullptr;
+    }
+    if (subexpireKey != nullptr)
+    {
+        decrRefCount(subexpireKey);
+        subexpireKey = nullptr;
+    }
+
     serverLog(LL_WARNING,"Short read or OOM loading DB. Unrecoverable error, aborting now.");
     rdbExitReportCorruptRDB("Unexpected EOF reading RDB file");
     return C_ERR; /* Just to avoid warning */
 }
 
-int rdbLoadFile(char *filename, rdbSaveInfo *rsi);
 int rdbLoad(rdbSaveInfo *rsi)
 {
     int err = C_ERR;
@@ -2144,14 +2262,14 @@ int rdbLoad(rdbSaveInfo *rsi)
  *
  * If you pass an 'rsi' structure initialied with RDB_SAVE_OPTION_INIT, the
  * loading code will fiil the information fields in the structure. */
-int rdbLoadFile(char *filename, rdbSaveInfo *rsi) {
+int rdbLoadFile(const char *filename, rdbSaveInfo *rsi) {
     FILE *fp;
     rio rdb;
     int retval;
 
     if ((fp = fopen(filename,"r")) == NULL) return C_ERR;
     startLoading(fp);
-    rioInitWithFile(&rdb,fileno(fp));
+    rioInitWithFile(&rdb,fp);
     retval = rdbLoadRio(&rdb,rsi,0);
     fclose(fp);
     stopLoading();
@@ -2213,7 +2331,7 @@ void backgroundSaveDoneHandlerSocket(int exitcode, int bysignal) {
     g_pserver->rdb_child_type = RDB_CHILD_TYPE_NONE;
     g_pserver->rdb_save_time_start = -1;
 
-    /* If the child returns an OK exit code, read the set of slave client
+    /* If the child returns an OK exit code, read the set of replica client
      * IDs and the associated status code. We'll terminate all the slaves
      * in error state.
      *
@@ -2252,35 +2370,35 @@ void backgroundSaveDoneHandlerSocket(int exitcode, int bysignal) {
 
     listRewind(g_pserver->slaves,&li);
     while((ln = listNext(&li))) {
-        client *slave = (client*)ln->value;
+        client *replica = (client*)ln->value;
 
-        if (slave->replstate == SLAVE_STATE_WAIT_BGSAVE_END) {
+        if (replica->replstate == SLAVE_STATE_WAIT_BGSAVE_END) {
             uint64_t j;
             int errorcode = 0;
 
-            /* Search for the slave ID in the reply. In order for a slave to
+            /* Search for the replica ID in the reply. In order for a replica to
              * continue the replication process, we need to find it in the list,
              * and it must have an error code set to 0 (which means success). */
             for (j = 0; j < ok_slaves[0]; j++) {
-                if (slave->id == ok_slaves[2*j+1]) {
+                if (replica->id == ok_slaves[2*j+1]) {
                     errorcode = ok_slaves[2*j+2];
                     break; /* Found in slaves list. */
                 }
             }
             if (j == ok_slaves[0] || errorcode != 0) {
                 serverLog(LL_WARNING,
-                "Closing slave %s: child->slave RDB transfer failed: %s",
-                    replicationGetSlaveName(slave),
+                "Closing replica %s: child->replica RDB transfer failed: %s",
+                    replicationGetSlaveName(replica),
                     (errorcode == 0) ? "RDB transfer child aborted"
                                      : strerror(errorcode));
-                freeClient(slave);
+                freeClient(replica);
             } else {
                 serverLog(LL_WARNING,
                 "Slave %s correctly received the streamed RDB file.",
-                    replicationGetSlaveName(slave));
+                    replicationGetSlaveName(replica));
                 /* Restore the socket as non-blocking. */
-                anetNonBlock(NULL,slave->fd);
-                anetSendTimeout(NULL,slave->fd,0);
+                anetNonBlock(NULL,replica->fd);
+                anetSendTimeout(NULL,replica->fd,0);
             }
         }
     }
@@ -2347,17 +2465,17 @@ int rdbSaveToSlavesSockets(rdbSaveInfo *rsi) {
 
     listRewind(g_pserver->slaves,&li);
     while((ln = listNext(&li))) {
-        client *slave = (client*)ln->value;
+        client *replica = (client*)ln->value;
 
-        if (slave->replstate == SLAVE_STATE_WAIT_BGSAVE_START) {
-            clientids[numfds] = slave->id;
-            fds[numfds++] = slave->fd;
-            replicationSetupSlaveForFullResync(slave,getPsyncInitialOffset());
+        if (replica->replstate == SLAVE_STATE_WAIT_BGSAVE_START) {
+            clientids[numfds] = replica->id;
+            fds[numfds++] = replica->fd;
+            replicationSetupSlaveForFullResync(replica,getPsyncInitialOffset());
             /* Put the socket in blocking mode to simplify RDB transfer.
              * We'll restore it when the children returns (since duped socket
              * will share the O_NONBLOCK attribute with the parent). */
-            anetBlock(NULL,slave->fd);
-            anetSendTimeout(NULL,slave->fd,g_pserver->repl_timeout*1000);
+            anetBlock(NULL,replica->fd);
+            anetSendTimeout(NULL,replica->fd,g_pserver->repl_timeout*1000);
         }
     }
 
@@ -2391,19 +2509,19 @@ int rdbSaveToSlavesSockets(rdbSaveInfo *rsi) {
             g_pserver->child_info_data.cow_size = private_dirty;
             sendChildInfo(CHILD_INFO_TYPE_RDB);
 
-            /* If we are returning OK, at least one slave was served
+            /* If we are returning OK, at least one replica was served
              * with the RDB file as expected, so we need to send a report
              * to the parent via the pipe. The format of the message is:
              *
-             * <len> <slave[0].id> <slave[0].error> ...
+             * <len> <replica[0].id> <replica[0].error> ...
              *
-             * len, slave IDs, and slave errors, are all uint64_t integers,
+             * len, replica IDs, and replica errors, are all uint64_t integers,
              * so basically the reply is composed of 64 bits for the len field
              * plus 2 additional 64 bit integers for each entry, for a total
              * of 'len' entries.
              *
-             * The 'id' represents the slave's client ID, so that the master
-             * can match the report with a specific slave, and 'error' is
+             * The 'id' represents the replica's client ID, so that the master
+             * can match the report with a specific replica, and 'error' is
              * set to 0 if the replication process terminated with a success
              * or the error code if an error occurred. */
             void *msg = zmalloc(sizeof(uint64_t)*(1+2*numfds), MALLOC_LOCAL);
@@ -2444,12 +2562,12 @@ int rdbSaveToSlavesSockets(rdbSaveInfo *rsi) {
              * replicationSetupSlaveForFullResync() turned it into BGSAVE_END */
             listRewind(g_pserver->slaves,&li);
             while((ln = listNext(&li))) {
-                client *slave = (client*)ln->value;
+                client *replica = (client*)ln->value;
                 int j;
 
                 for (j = 0; j < numfds; j++) {
-                    if (slave->id == clientids[j]) {
-                        slave->replstate = SLAVE_STATE_WAIT_BGSAVE_START;
+                    if (replica->id == clientids[j]) {
+                        replica->replstate = SLAVE_STATE_WAIT_BGSAVE_START;
                         break;
                     }
                 }
@@ -2543,17 +2661,17 @@ rdbSaveInfo *rdbPopulateSaveInfo(rdbSaveInfo *rsi) {
     /* If the instance is a master, we can populate the replication info
      * only when repl_backlog is not NULL. If the repl_backlog is NULL,
      * it means that the instance isn't in any replication chains. In this
-     * scenario the replication info is useless, because when a slave
+     * scenario the replication info is useless, because when a replica
      * connects to us, the NULL repl_backlog will trigger a full
      * synchronization, at the same time we will use a new replid and clear
      * replid2. */
-    if (!listLength(g_pserver->masters) && g_pserver->repl_backlog) {
-        /* Note that when g_pserver->slaveseldb is -1, it means that this master
+    if (g_pserver->fActiveReplica || (!listLength(g_pserver->masters) && g_pserver->repl_backlog)) {
+        /* Note that when g_pserver->replicaseldb is -1, it means that this master
          * didn't apply any write commands after a full synchronization.
-         * So we can let repl_stream_db be 0, this allows a restarted slave
+         * So we can let repl_stream_db be 0, this allows a restarted replica
          * to reload replication ID/offset, it's safe because the next write
          * command must generate a SELECT statement. */
-        rsi->repl_stream_db = g_pserver->slaveseldb == -1 ? 0 : g_pserver->slaveseldb;
+        rsi->repl_stream_db = g_pserver->replicaseldb == -1 ? 0 : g_pserver->replicaseldb;
         return rsi;
     }
 
@@ -2564,7 +2682,7 @@ rdbSaveInfo *rdbPopulateSaveInfo(rdbSaveInfo *rsi) {
     }
     struct redisMaster *miFirst = (redisMaster*)(listLength(g_pserver->masters) ? listNodeValue(listFirst(g_pserver->masters)) : NULL);
 
-    /* If the instance is a slave we need a connected master
+    /* If the instance is a replica we need a connected master
      * in order to fetch the currently selected DB. */
     if (miFirst && miFirst->master) {
         rsi->repl_stream_db = miFirst->master->db->id;
@@ -2572,7 +2690,7 @@ rdbSaveInfo *rdbPopulateSaveInfo(rdbSaveInfo *rsi) {
     }
 
     /* If we have a cached master we can use it in order to populate the
-     * replication selected DB info inside the RDB file: the slave can
+     * replication selected DB info inside the RDB file: the replica can
      * increment the master_repl_offset only from data arriving from the
      * master, so if we are disconnected the offset in the cached master
      * is valid. */

src/rdb.h

@@ -91,10 +91,13 @@
 #define RDB_TYPE_HASH_ZIPLIST  13
 #define RDB_TYPE_LIST_QUICKLIST 14
 #define RDB_TYPE_STREAM_LISTPACKS 15
+
+/* KeyDB Specific Object Types */
+#define RDB_TYPE_CRON 64
 /* NOTE: WHEN ADDING NEW RDB TYPE, UPDATE rdbIsObjectType() BELOW */
 
 /* Test if a type is an object type. */
-#define rdbIsObjectType(t) ((t >= 0 && t <= 7) || (t >= 9 && t <= 15))
+#define rdbIsObjectType(t) ((t >= 0 && t <= 7) || (t >= 9 && t <= 15) || (t == RDB_TYPE_CRON))
 
 /* Special RDB opcodes (saved/loaded with rdbSaveType/rdbLoadType). */
 #define RDB_OPCODE_MODULE_AUX 247   /* Module auxiliary data. */
@@ -136,12 +139,13 @@ 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 rdbSaveFp(FILE *pf, rdbSaveInfo *rsi);
 int rdbSaveS3(char *path, rdbSaveInfo *rsi);
 int rdbLoadS3(char *path, rdbSaveInfo *rsi);
 ssize_t rdbSaveObject(rio *rdb, robj_roptr o, robj *key);

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;
@@ -173,6 +173,8 @@ typedef struct redisConfig {
     sds appendonly;
 } redisConfig;
 
+int g_fInCrash = false;
+
 /* Prototypes */
 static void writeHandler(aeEventLoop *el, int fd, void *privdata, int mask);
 static void createMissingClients(client c);
@@ -258,6 +260,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 +1211,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 +1313,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 +1548,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 +1561,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 */
@@ -55,6 +57,7 @@
 #include "anet.h"
 #include "ae.h"
 #include "storage.h"
+#include "motd.h"
 
 #include "redis-cli.h"
 
@@ -88,6 +91,11 @@ int spectrum_palette_mono[] = {0,233,234,235,237,239,241,243,245,247,249,251,253
 int *spectrum_palette;
 int spectrum_palette_size;
 
+int g_fInCrash = 0;
+
+const char *motd_url = "http://api.keydb.dev/motd/motd_cli.txt";
+const char *motd_cache_file = "/.keydb-cli-motd";
+
 /*------------------------------------------------------------------------------
  * Utility functions
  *--------------------------------------------------------------------------- */
@@ -6700,6 +6708,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(1 /* cache */);
+            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 +6728,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

@@ -109,13 +109,14 @@ void rioInitWithBuffer(rio *r, sds s) {
 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 +124,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 +150,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

@@ -73,7 +73,7 @@ struct _rio {
         } 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,7 +128,7 @@ 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 rioInitWithFdset(rio *r, int *fds, int numfds);
 

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/sds.c

@@ -53,11 +53,18 @@ static inline int sdsHdrSize(char type) {
             return sizeof(struct sdshdr32);
         case SDS_TYPE_64:
             return sizeof(struct sdshdr64);
+        case SDS_TYPE_REFCOUNTED:
+            return sizeof(struct sdshdrrefcount);
     }
     return 0;
 }
 
-static inline char sdsReqType(size_t string_size) {
+static inline char sdsReqType(ssize_t string_size) {
+    if (string_size < 0){
+        string_size = -string_size;
+        if (string_size < 1<<16)
+            return SDS_TYPE_REFCOUNTED;
+    }
     if (string_size < 1<<5)
         return SDS_TYPE_5;
     if (string_size < 1<<8)
@@ -86,10 +93,12 @@ static inline char sdsReqType(size_t string_size) {
  * You can print the string with printf() as there is an implicit \0 at the
  * end of the string. However the string is binary safe and can contain
  * \0 characters in the middle, as the length is stored in the sds header. */
-sds sdsnewlen(const void *init, size_t initlen) {
+sds sdsnewlen(const void *init, ssize_t initlen) {
     void *sh;
     sds s;
     char type = sdsReqType(initlen);
+    if (initlen < 0)
+        initlen = -initlen;
     /* Empty strings are usually created in order to append. Use type 8
      * since type 5 is not good at this. */
     if (type == SDS_TYPE_5 && initlen == 0) type = SDS_TYPE_8;
@@ -137,6 +146,13 @@ sds sdsnewlen(const void *init, size_t initlen) {
             *fp = type;
             break;
         }
+        case SDS_TYPE_REFCOUNTED: {
+            SDS_HDR_VAR_REFCOUNTED(s);
+            sh->len = initlen;
+            sh->refcount = 1;
+            *fp = type;
+            break;
+        }
     }
     if (initlen && init)
         memcpy(s, init, initlen);
@@ -161,9 +177,25 @@ sds sdsdup(const char *s) {
     return sdsnewlen(s, sdslen(s));
 }
 
+sds sdsdupshared(const char *s) {
+    unsigned char flags = s[-1];
+    if ((flags & SDS_TYPE_MASK) != SDS_TYPE_REFCOUNTED)
+        return sdsnewlen(s, -sdslen(s));
+    SDS_HDR_VAR_REFCOUNTED(s);
+    __atomic_fetch_add(&sh->refcount, 1, __ATOMIC_RELAXED);
+    return (sds)s;
+}
+
 /* Free an sds string. No operation is performed if 's' is NULL. */
 void sdsfree(const char *s) {
     if (s == NULL) return;
+    unsigned char flags = s[-1];
+    if ((flags & SDS_TYPE_MASK) == SDS_TYPE_REFCOUNTED)
+    {
+        SDS_HDR_VAR_REFCOUNTED(s);
+        if (__atomic_fetch_sub(&sh->refcount, 1, __ATOMIC_RELAXED) > 1)
+            return;
+    }
     s_free((char*)s-sdsHdrSize(s[-1]));
 }
 
@@ -368,6 +400,11 @@ void sdsIncrLen(sds s, ssize_t incr) {
             len = (sh->len += incr);
             break;
         }
+        case SDS_TYPE_REFCOUNTED: {
+            SDS_HDR_VAR_REFCOUNTED(s);
+            len = (sh->len += incr);
+            break;
+        }
         default: len = 0; /* Just to avoid compilation warnings. */
     }
     s[len] = '\0';
@@ -787,7 +824,7 @@ void sdstoupper(sds s) {
  * If two strings share exactly the same prefix, but one of the two has
  * additional characters, the longer string is considered to be greater than
  * the smaller one. */
-int sdscmp(const sds s1, const sds s2) {
+int sdscmp(const char *s1, const char *s2) {
     size_t l1, l2, minlen;
     int cmp;
 

src/sds.h

@@ -91,15 +91,27 @@ struct __attribute__ ((__packed__)) sdshdr64 {
 #endif
 };
 
+struct __attribute__ ((__packed__)) sdshdrrefcount {
+    uint64_t len; /* used */
+    uint16_t refcount;
+    unsigned char flags; /* 3 lsb of type, 5 unused bits */
+#ifndef __cplusplus
+    char buf[];
+#endif
+};
+
 #define SDS_TYPE_5  0
 #define SDS_TYPE_8  1
 #define SDS_TYPE_16 2
 #define SDS_TYPE_32 3
 #define SDS_TYPE_64 4
+#define SDS_TYPE_REFCOUNTED 5
 #define SDS_TYPE_MASK 7
 #define SDS_TYPE_BITS 3
 #define SDS_HDR_VAR(T,s) struct sdshdr##T *sh = (struct sdshdr##T *)(((void*)((s)-(sizeof(struct sdshdr##T)))));
+#define SDS_HDR_VAR_REFCOUNTED(s) struct sdshdrrefcount *sh = (struct sdshdrrefcount *)(((void*)((s)-(sizeof(struct sdshdrrefcount)))));
 #define SDS_HDR(T,s) ((struct sdshdr##T *)((s)-(sizeof(struct sdshdr##T))))
+#define SDS_HDR_REFCOUNTED(s) ((struct sdshdrrefcount *)((s)-(sizeof(struct sdshdrrefcount))))
 #define SDS_TYPE_5_LEN(f) ((f)>>SDS_TYPE_BITS)
 
 static inline size_t sdslen(const char *s) {
@@ -121,6 +133,8 @@ static inline size_t sdslen(const char *s) {
                 return SDS_HDR(32,s)->len;
             case SDS_TYPE_64:
                 return SDS_HDR(64,s)->len;
+            case SDS_TYPE_REFCOUNTED:
+                return SDS_HDR_REFCOUNTED(s)->len;
         }
     }
     return 0;
@@ -148,6 +162,9 @@ static inline size_t sdsavail(const char * s) {
             SDS_HDR_VAR(64,s);
             return sh->alloc - sh->len;
         }
+        case SDS_TYPE_REFCOUNTED: {
+            return 0;   // immutable
+        }
     }
     return 0;
 }
@@ -173,6 +190,9 @@ static inline void sdssetlen(sds s, size_t newlen) {
         case SDS_TYPE_64:
             SDS_HDR(64,s)->len = newlen;
             break;
+        case SDS_TYPE_REFCOUNTED:
+            SDS_HDR_REFCOUNTED(s)->len = newlen;
+            break;
     }
 }
 
@@ -198,6 +218,9 @@ static inline void sdsinclen(sds s, size_t inc) {
         case SDS_TYPE_64:
             SDS_HDR(64,s)->len += inc;
             break;
+        case SDS_TYPE_REFCOUNTED:
+            SDS_HDR_REFCOUNTED(s)->len += inc;
+            break;
     }
 }
 
@@ -215,6 +238,8 @@ static inline size_t sdsalloc(const sds s) {
             return SDS_HDR(32,s)->alloc;
         case SDS_TYPE_64:
             return SDS_HDR(64,s)->alloc;
+        case SDS_TYPE_REFCOUNTED:
+            return SDS_HDR_REFCOUNTED(s)->len;
     }
     return 0;
 }
@@ -237,13 +262,22 @@ static inline void sdssetalloc(sds s, size_t newlen) {
         case SDS_TYPE_64:
             SDS_HDR(64,s)->alloc = newlen;
             break;
+        case SDS_TYPE_REFCOUNTED:
+            break;
     }
 }
 
-sds sdsnewlen(const void *init, size_t initlen);
+static inline int sdsisshared(const char *s)
+{
+    unsigned char flags = s[-1];
+    return ((flags & SDS_TYPE_MASK) == SDS_TYPE_REFCOUNTED);
+}
+
+sds sdsnewlen(const void *init, ssize_t initlen);
 sds sdsnew(const char *init);
 sds sdsempty(void);
 sds sdsdup(const char *s);
+sds sdsdupshared(const char *s);
 void sdsfree(const char *s);
 sds sdsgrowzero(sds s, size_t len);
 sds sdscatlen(sds s, const void *t, size_t len);
@@ -265,7 +299,7 @@ sds sdstrim(sds s, const char *cset);
 void sdsrange(sds s, ssize_t start, ssize_t end);
 void sdsupdatelen(sds s);
 void sdsclear(sds s);
-int sdscmp(const sds s1, const sds s2);
+int sdscmp(const char *s1, const char *s2);
 sds *sdssplitlen(const char *s, ssize_t len, const char *sep, int seplen, int *count);
 void sdsfreesplitres(sds *tokens, int count);
 void sdstolower(sds s);
@@ -298,6 +332,120 @@ int sdsTest(int argc, char *argv[]);
 
 #ifdef __cplusplus
 }
+
+class sdsview
+{
+protected:
+    sds m_str = nullptr;
+
+    sdsview() = default;    // Not allowed to create a sdsview directly with a nullptr
+public:
+    sdsview(sds str)
+        : m_str(str)
+    {}
+
+    sdsview(const char *str)
+        : m_str((sds)str)
+    {}
+
+    bool operator<(const sdsview &other) const
+    {
+        return sdscmp(m_str, other.m_str) < 0;
+    }
+
+    bool operator==(const sdsview &other) const
+    {
+        return sdscmp(m_str, other.m_str) == 0;
+    }
+
+    bool operator==(const char *other) const
+    {
+        return sdscmp(m_str, other) == 0;
+    }
+
+    char operator[](size_t idx) const
+    {
+        return m_str[idx];
+    }
+
+    size_t size() const
+    {
+        return sdslen(m_str);
+    }
+
+    const char *get() const { return m_str; }
+
+    explicit operator const char*() const { return m_str; }
+};
+
+class sdsstring : public sdsview
+{
+public:
+    sdsstring() = default;
+    explicit sdsstring(sds str)
+        : sdsview(str)
+    {}
+
+    sdsstring(const sdsstring &other)
+        : sdsview(sdsdup(other.m_str))
+    {}
+
+    sdsstring(sdsstring &&other)
+        : sdsview(other.m_str)
+    {
+        other.m_str = nullptr;
+    }
+
+    sdsstring &operator=(const sdsstring &other)
+    {
+        sdsfree(m_str);
+        m_str = sdsdup(other.m_str);
+        return *this;
+    }
+
+    sdsstring &operator=(sds other)
+    {
+        sdsfree(m_str);
+        m_str = sdsdup(other);
+        return *this;
+    }
+
+    ~sdsstring()
+    {
+        sdsfree(m_str);
+    }
+};
+
+class sdsimmutablestring : public sdsstring
+{
+public:
+    sdsimmutablestring() = default;
+    explicit sdsimmutablestring(sds str)
+        : sdsstring(str)
+    {}
+
+    explicit sdsimmutablestring(const char *str)
+        : sdsstring((sds)str)
+    {}
+
+    sdsimmutablestring(const sdsimmutablestring &other)
+        : sdsstring(sdsdupshared(other.m_str))
+    {}
+
+    sdsimmutablestring(sdsimmutablestring &&other)
+        : sdsstring(other.m_str)
+    {
+        other.m_str = nullptr;
+    }
+
+    auto &operator=(const sdsimmutablestring &other)
+    {
+        sdsfree(m_str);
+        m_str = sdsdupshared(other.m_str);
+        return *this;
+    }
+};
+
 #endif
 
 #endif

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()
+    {
+        setiter itr(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/server.h

@@ -40,6 +40,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <cmath>
 #include <string.h>
 #include <time.h>
 #include <limits.h>
@@ -49,6 +50,12 @@
 #include <pthread.h>
 #include <syslog.h>
 #include <netinet/in.h>
+#include <atomic>
+#include <vector>
+#include <algorithm>
+#include <memory>
+#include <map>
+#include <string>
 #ifdef __cplusplus
 extern "C" {
 #include <lua.h>
@@ -77,6 +84,7 @@ typedef long long mstime_t; /* millisecond time type. */
                            N-elements flat arrays */
 #include "rax.h"     /* Radix tree */
 #include "uuid.h"
+#include "semiorderedset.h"
 
 /* Following includes allow test functions to be called from Redis main() */
 #include "zipmap.h"
@@ -84,6 +92,8 @@ typedef long long mstime_t; /* millisecond time type. */
 #include "endianconv.h"
 #include "crc64.h"
 
+extern int g_fTestMode;
+
 struct redisObject;
 class robj_roptr
 {
@@ -136,6 +146,87 @@ public:
     }
 };
 
+void decrRefCount(robj_roptr o);
+void incrRefCount(robj_roptr o);
+class robj_sharedptr
+{
+    redisObject *m_ptr;
+
+public:
+    robj_sharedptr()
+        : m_ptr(nullptr)
+        {}
+    robj_sharedptr(redisObject *ptr)
+        : m_ptr(ptr)
+        {
+            incrRefCount(ptr);
+        }
+    ~robj_sharedptr()
+    {
+        if (m_ptr)
+            decrRefCount(m_ptr);
+    }
+    robj_sharedptr(const robj_sharedptr& other)
+    {
+        m_ptr = other.m_ptr;
+        incrRefCount(m_ptr);
+    }
+
+    robj_sharedptr(robj_sharedptr&& other)
+    {
+        m_ptr = other.m_ptr;
+        other.m_ptr = nullptr;
+    }
+
+    robj_sharedptr &operator=(const robj_sharedptr& other)
+    {
+        if (m_ptr)
+            decrRefCount(m_ptr);
+        m_ptr = other.m_ptr;
+        incrRefCount(m_ptr);
+        return *this;
+    }
+    robj_sharedptr &operator=(redisObject *ptr)
+    {
+        if (m_ptr)
+            decrRefCount(m_ptr);
+        m_ptr = ptr;
+        incrRefCount(m_ptr);
+        return *this;
+    }
+
+    bool operator==(const robj_sharedptr &other) const
+    {
+        return m_ptr == other.m_ptr;
+    }
+
+    bool operator!=(const robj_sharedptr &other) const
+    {
+        return m_ptr != other.m_ptr;
+    }
+
+    redisObject* operator->() const
+    {
+        return m_ptr;
+    }
+
+    bool operator!() const
+    {
+        return !m_ptr;
+    }
+
+    operator bool() const{
+        return !!m_ptr;
+    }
+
+    operator redisObject *()
+    {
+        return (redisObject*)m_ptr;
+    }
+
+    redisObject *get() { return m_ptr; }
+};
+
 /* Error codes */
 #define C_OK                    0
 #define C_ERR                   -1
@@ -174,7 +265,7 @@ public:
 #define CONFIG_DEFAULT_REPL_BACKLOG_TIME_LIMIT (60*60)  /* 1 hour */
 #define CONFIG_REPL_BACKLOG_MIN_SIZE (1024*16)          /* 16k */
 #define CONFIG_BGSAVE_RETRY_DELAY 5 /* Wait a few secs before trying again. */
-#define CONFIG_DEFAULT_PID_FILE "/var/run/redis.pid"
+#define CONFIG_DEFAULT_PID_FILE "/var/run/keydb.pid"
 #define CONFIG_DEFAULT_SYSLOG_IDENT "redis"
 #define CONFIG_DEFAULT_CLUSTER_CONFIG_FILE "nodes.conf"
 #define CONFIG_DEFAULT_CLUSTER_ANNOUNCE_IP NULL         /* Auto detect. */
@@ -237,7 +328,7 @@ public:
 #define CONFIG_DEFAULT_ACTIVE_REPLICA 0
 #define CONFIG_DEFAULT_ENABLE_MULTIMASTER 0
 
-#define ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP 20 /* Loopkups per loop. */
+#define ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP 64 /* Loopkups per loop. */
 #define ACTIVE_EXPIRE_CYCLE_FAST_DURATION 1000 /* Microseconds */
 #define ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC 25 /* CPU max % for keys collection */
 #define ACTIVE_EXPIRE_CYCLE_SLOW 0
@@ -321,9 +412,9 @@ public:
 #define AOF_WAIT_REWRITE 2    /* AOF waits rewrite to start appending */
 
 /* Client flags */
-#define CLIENT_SLAVE (1<<0)   /* This client is a slave server */
-#define CLIENT_MASTER (1<<1)  /* This client is a master server */
-#define CLIENT_MONITOR (1<<2) /* This client is a slave monitor, see MONITOR */
+#define CLIENT_SLAVE (1<<0)   /* This client is a repliaca */
+#define CLIENT_MASTER (1<<1)  /* This client is a master */
+#define CLIENT_MONITOR (1<<2) /* This client is a replica monitor, see MONITOR */
 #define CLIENT_MULTI (1<<3)   /* This client is in a MULTI context */
 #define CLIENT_BLOCKED (1<<4) /* The client is waiting in a blocking operation */
 #define CLIENT_DIRTY_CAS (1<<5) /* Watched keys modified. EXEC will fail. */
@@ -353,7 +444,17 @@ public:
 #define CLIENT_LUA_DEBUG_SYNC (1<<26)  /* EVAL debugging without fork() */
 #define CLIENT_MODULE (1<<27) /* Non connected client used by some module. */
 #define CLIENT_PROTECTED (1<<28) /* Client should not be freed for now. */
-#define CLIENT_FORCE_REPLY (1<<29) /* Should addReply be forced to write the text? */
+#define CLIENT_PENDING_READ (1<<29) /* The client has pending reads and was put
+                                       in the list of clients we can read
+                                       from. */
+#define CLIENT_PENDING_COMMAND (1<<30) /* Used in threaded I/O to signal after
+                                          we return single threaded that the
+                                          client has already pending commands
+                                          to be executed. */
+#define CLIENT_TRACKING (1<<31) /* Client enabled keys tracking in order to
+                                   perform client side caching. */
+#define CLIENT_TRACKING_BROKEN_REDIR (1ULL<<32) /* Target client is invalid. */
+#define CLIENT_FORCE_REPLY (1ULL<<33) /* Should addReply be forced to write the text? */
 
 /* Client block type (btype field in client structure)
  * if CLIENT_BLOCKED flag is set. */
@@ -377,7 +478,7 @@ public:
 #define CLIENT_TYPE_MASTER 3 /* Master. */
 #define CLIENT_TYPE_OBUF_COUNT 3 /* Number of clients to expose to output
                                     buffer configuration. Just the first
-                                    three: normal, slave, pubsub. */
+                                    three: normal, replica, pubsub. */
 
 /* Slave replication state. Used in g_pserver->repl_state for slaves to remember
  * what to do next. */
@@ -403,20 +504,21 @@ public:
 #define REPL_STATE_CONNECTED 17 /* Connected to master */
 
 /* State of slaves from the POV of the master. Used in client->replstate.
- * In SEND_BULK and ONLINE state the slave receives new updates
+ * In SEND_BULK and ONLINE state the replica receives new updates
  * in its output queue. In the WAIT_BGSAVE states instead the server is waiting
  * to start the next background saving in order to send updates to it. */
 #define SLAVE_STATE_WAIT_BGSAVE_START 6 /* We need to produce a new RDB file. */
 #define SLAVE_STATE_WAIT_BGSAVE_END 7 /* Waiting RDB file creation to finish. */
-#define SLAVE_STATE_SEND_BULK 8 /* Sending RDB file to slave. */
+#define SLAVE_STATE_SEND_BULK 8 /* Sending RDB file to replica. */
 #define SLAVE_STATE_ONLINE 9 /* RDB file transmitted, sending just updates. */
 
 /* Slave capabilities. */
 #define SLAVE_CAPA_NONE 0
 #define SLAVE_CAPA_EOF (1<<0)    /* Can parse the RDB EOF streaming format. */
 #define SLAVE_CAPA_PSYNC2 (1<<1) /* Supports PSYNC2 protocol. */
+#define SLAVE_CAPA_ACTIVE_EXPIRE (1<<2) /* Will the slave perform its own expirations? (Don't send delete) */
 
-/* Synchronous read timeout - slave side */
+/* Synchronous read timeout - replica side */
 #define CONFIG_REPL_SYNCIO_TIMEOUT 5
 
 /* List related stuff */
@@ -525,7 +627,7 @@ public:
 /* RDB active child save type. */
 #define RDB_CHILD_TYPE_NONE 0
 #define RDB_CHILD_TYPE_DISK 1     /* RDB is written to disk. */
-#define RDB_CHILD_TYPE_SOCKET 2   /* RDB is written to slave socket. */
+#define RDB_CHILD_TYPE_SOCKET 2   /* RDB is written to replica socket. */
 
 /* Keyspace changes notification classes. Every class is associated with a
  * character for configuration purposes. */
@@ -582,6 +684,8 @@ public:
  * encoding version. */
 #define OBJ_MODULE 5    /* Module object. */
 #define OBJ_STREAM 6    /* Stream object. */
+#define OBJ_CRON 7      /* CRON job */
+
 
 /* Extract encver / signature from a module type ID. */
 #define REDISMODULE_TYPE_ENCVER_BITS 10
@@ -701,19 +805,32 @@ typedef struct RedisModuleDigest {
 #define LRU_CLOCK_MAX ((1<<LRU_BITS)-1) /* Max value of obj->lru */
 #define LRU_CLOCK_RESOLUTION 1000 /* LRU clock resolution in ms */
 
-#define OBJ_SHARED_REFCOUNT INT_MAX
+#define OBJ_SHARED_REFCOUNT (0x7FFFFFFF) 
 #define OBJ_MVCC_INVALID (0xFFFFFFFFFFFFFFFFULL)
+
+#define MVCC_MS_SHIFT 20
+
 typedef struct redisObject {
     unsigned type:4;
     unsigned encoding:4;
     unsigned lru:LRU_BITS; /* LRU time (relative to global lru_clock) or
                             * LFU data (least significant 8 bits frequency
                             * and most significant 16 bits access time). */
-    mutable int refcount;
+private:
+    mutable std::atomic<unsigned> refcount {0};
+public:
     uint64_t mvcc_tstamp;
     void *m_ptr;
-} robj;
 
+    inline bool FExpires() const { return refcount.load(std::memory_order_relaxed) >> 31; }
+    void SetFExpires(bool fExpires);
+
+    void setrefcount(unsigned ref);
+    unsigned getrefcount(std::memory_order order) const { return (refcount.load(order) & ~(1U << 31)); }
+    void addref() const { refcount.fetch_add(1, std::memory_order_acq_rel); }
+    unsigned release() const { return refcount.fetch_sub(1, std::memory_order_acq_rel) & ~(1U << 31); }
+} robj;
+static_assert(sizeof(redisObject) == 24, "object size is critical, don't increase");
 
 __attribute__((always_inline)) inline const void *ptrFromObj(robj_roptr &o)
 {
@@ -739,12 +856,254 @@ __attribute__((always_inline)) inline char *szFromObj(const robj *o)
     return (char*)ptrFromObj(o);
 }
 
+class expireEntryFat
+{
+    friend class expireEntry;
+public:
+    struct subexpireEntry
+    {
+        long long when;
+        std::unique_ptr<const char, void(*)(const char*)> spsubkey;
+
+        subexpireEntry(long long when, const char *subkey)
+            : when(when), spsubkey(subkey, sdsfree)
+        {}
+
+        bool operator<(long long when) const noexcept { return this->when < when; }
+        bool operator<(const subexpireEntry &se) { return this->when < se.when; }
+    };
+
+private:
+    sds m_keyPrimary;
+    std::vector<subexpireEntry> m_vecexpireEntries;  // Note a NULL for the sds portion means the expire is for the primary key
+
+public:
+    expireEntryFat(sds keyPrimary)
+        : m_keyPrimary(keyPrimary)
+        {}
+    long long when() const noexcept { return m_vecexpireEntries.front().when; }
+    const char *key() const noexcept { return m_keyPrimary; }
+
+    bool operator<(long long when) const noexcept { return this->when() <  when; }
+
+    void expireSubKey(const char *szSubkey, long long when)
+    {
+        // First check if the subkey already has an expiration
+        for (auto &entry : m_vecexpireEntries)
+        {
+            if (szSubkey != nullptr)
+            {
+                // if this is a subkey expiry then its not a match if the expireEntry is either for the
+                //  primary key or a different subkey
+                if (entry.spsubkey == nullptr || sdscmp((sds)entry.spsubkey.get(), (sds)szSubkey) != 0)
+                    continue;
+            }
+            else
+            {
+                if (entry.spsubkey != nullptr)
+                    continue;
+            }
+            m_vecexpireEntries.erase(m_vecexpireEntries.begin() + (&entry - m_vecexpireEntries.data()));
+            break;
+        }
+        auto itrInsert = std::lower_bound(m_vecexpireEntries.begin(), m_vecexpireEntries.end(), when);
+        const char *subkey = (szSubkey) ? sdsdup(szSubkey) : nullptr;
+        m_vecexpireEntries.emplace(itrInsert, when, subkey);
+    }
+
+    bool FEmpty() const noexcept { return m_vecexpireEntries.empty(); }
+    const subexpireEntry &nextExpireEntry() const noexcept { return m_vecexpireEntries.front(); }
+    void popfrontExpireEntry() { m_vecexpireEntries.erase(m_vecexpireEntries.begin()); }
+    const subexpireEntry &operator[](size_t idx) { return m_vecexpireEntries[idx]; }
+    size_t size() const noexcept { return m_vecexpireEntries.size(); }
+};
+
+class expireEntry {
+    union
+    {
+        sds m_key;
+        expireEntryFat *m_pfatentry;
+    } u;
+    long long m_when;   // LLONG_MIN means this is a fat entry and we should use the pointer
+
+public:
+    class iter
+    {
+        friend class expireEntry;
+        expireEntry *m_pentry = nullptr;
+        size_t m_idx = 0;
+
+    public:
+        iter(expireEntry *pentry, size_t idx)
+            : m_pentry(pentry), m_idx(idx)
+        {}
+
+        iter &operator++() { ++m_idx; return *this; }
+        
+        const char *subkey() const
+        {
+            if (m_pentry->FFat())
+                return (*m_pentry->pfatentry())[m_idx].spsubkey.get();
+            return nullptr;
+        }
+        long long when() const
+        {
+            if (m_pentry->FFat())
+                return (*m_pentry->pfatentry())[m_idx].when;
+            return m_pentry->when();
+        }
+
+        bool operator!=(const iter &other)
+        {
+            return m_idx != other.m_idx;
+        }
+
+        const iter &operator*() const { return *this; }
+    };
+
+    expireEntry(sds key, const char *subkey, long long when)
+    {
+        if (subkey != nullptr)
+        {
+            m_when = LLONG_MIN;
+            u.m_pfatentry = new (MALLOC_LOCAL) expireEntryFat(key);
+            u.m_pfatentry->expireSubKey(subkey, when);
+        }
+        else
+        {
+            u.m_key = key;
+            m_when = when;
+        }
+    }
+
+    expireEntry(expireEntryFat *pfatentry)
+    {
+        u.m_pfatentry = pfatentry;
+        m_when = LLONG_MIN;
+    }
+
+    expireEntry(expireEntry &&e)
+    {
+        u.m_key = e.u.m_key;
+        m_when = e.m_when;
+        e.u.m_key = (char*)key();  // we do this so it can still be found in the set
+        e.m_when = 0;
+    }
+
+    ~expireEntry()
+    {
+        if (FFat())
+            delete u.m_pfatentry;
+    }
+
+    void setKeyUnsafe(sds key)
+    {
+        if (FFat())
+            u.m_pfatentry->m_keyPrimary = key;
+        else
+            u.m_key = key;
+    }
+
+    inline bool FFat() const noexcept { return m_when == LLONG_MIN; }
+    expireEntryFat *pfatentry() { assert(FFat()); return u.m_pfatentry; }
+
+
+    bool operator==(const char *key) const noexcept
+    { 
+        return this->key() == key; 
+    }
+
+    bool operator<(const expireEntry &e) const noexcept
+    { 
+        return when() < e.when(); 
+    }
+    bool operator<(long long when) const noexcept
+    { 
+        return this->when() < when;
+    }
+
+    const char *key() const noexcept
+    { 
+        if (FFat())
+            return u.m_pfatentry->key();
+        return u.m_key;
+    }
+    long long when() const noexcept
+    { 
+        if (FFat())
+            return u.m_pfatentry->when();
+        return m_when; 
+    }
+
+    void update(const char *subkey, long long when)
+    {
+        if (!FFat())
+        {
+            if (subkey == nullptr)
+            {
+                m_when = when;
+                return;
+            }
+            else
+            {
+                // we have to upgrade to a fat entry
+                long long whenT = m_when;
+                sds keyPrimary = u.m_key;
+                m_when = LLONG_MIN;
+                u.m_pfatentry = new (MALLOC_LOCAL) expireEntryFat(keyPrimary);
+                u.m_pfatentry->expireSubKey(nullptr, whenT);
+                // at this point we're fat so fall through
+            }
+        }
+        u.m_pfatentry->expireSubKey(subkey, when);
+    }
+    
+    iter begin() { return iter(this, 0); }
+    iter end()
+    {
+        if (FFat())
+            return iter(this, u.m_pfatentry->size());
+        return iter(this, 1);
+    }
+    
+    void erase(iter &itr)
+    {
+        if (!FFat())
+            throw -1;   // assert
+        pfatentry()->m_vecexpireEntries.erase(
+            pfatentry()->m_vecexpireEntries.begin() + itr.m_idx);
+    }
+
+    bool FGetPrimaryExpire(long long *pwhen)
+    {
+        *pwhen = -1;
+        for (auto itr : *this)
+        {
+            if (itr.subkey() == nullptr)
+            {
+                *pwhen = itr.when();
+                return true;
+            }
+        }
+        return false;
+    }
+
+    explicit operator const char*() const noexcept { return key(); }
+    explicit operator long long() const noexcept { return when(); }
+};
+typedef semiorderedset<expireEntry, const char *, true /*expireEntry can be memmoved*/> expireset;
+
+/* The a string name for an object's type as listed above
+ * Native types are checked against the OBJ_STRING, OBJ_LIST, OBJ_* defines,
+ * and Module types have their registered name returned. */
+const char *getObjectTypeName(robj_roptr o);
+
 /* Macro used to initialize a Redis object allocated on the stack.
  * Note that this macro is taken near the structure definition to make sure
  * we'll update it when the structure is changed, to avoid bugs like
  * bug #85 introduced exactly in this way. */
 #define initStaticStringObject(_var,_ptr) do { \
-    _var.refcount = 1; \
+    _var.setrefcount(1); \
     _var.type = OBJ_STRING; \
     _var.encoding = OBJ_ENCODING_RAW; \
     _var.m_ptr = _ptr; \
@@ -769,16 +1128,25 @@ typedef struct clientReplyBlock {
 /* Redis database representation. There are multiple databases identified
  * by integers from 0 (the default database) up to the max configured
  * database. The database number is the 'id' field in the structure. */
-typedef struct redisDb {
+struct redisDb {
+    redisDb() 
+        : expireitr(nullptr)
+    {};
+    
+    ~redisDb();
+
     dict *pdict;                 /* The keyspace for this DB */
-    dict *expires;              /* Timeout of keys with a timeout set */
+    expireset *setexpire;
+    expireset::setiter expireitr;
+
     dict *blocking_keys;        /* Keys with clients waiting for data (BLPOP)*/
     dict *ready_keys;           /* Blocked keys that received a PUSH */
     dict *watched_keys;         /* WATCHED keys for MULTI/EXEC CAS */
     int id;                     /* Database ID */
-    long long avg_ttl;          /* Average TTL, just for stats */
+    long long last_expire_set;  /* when the last expire was set */
+    double avg_ttl;             /* Average TTL, just for stats */
     list *defrag_later;         /* List of key names to attempt to defrag one by one, gradually. */
-} redisDb;
+};
 
 /* Client MULTI/EXEC state */
 typedef struct multiCmd {
@@ -917,21 +1285,23 @@ typedef struct client {
     time_t ctime;           /* Client creation time. */
     time_t lastinteraction; /* Time of the last interaction, used for timeout */
     time_t obuf_soft_limit_reached_time;
-    int flags;              /* Client flags: CLIENT_* macros. */
+    std::atomic<uint64_t> flags;              /* Client flags: CLIENT_* macros. */
+    int casyncOpsPending;
     int fPendingAsyncWrite; /* NOTE: Not a flag because it is written to outside of the client lock (locked by the global lock instead) */
     int authenticated;      /* Needed when the default user requires auth. */
-    int replstate;          /* Replication state if this is a slave. */
-    int repl_put_online_on_ack; /* Install slave write handler on ACK. */
+    int replstate;          /* Replication state if this is a replica. */
+    int repl_put_online_on_ack; /* Install replica write handler on ACK. */
     int repldbfd;           /* Replication DB file descriptor. */
     off_t repldboff;        /* Replication DB file offset. */
     off_t repldbsize;       /* Replication DB file size. */
     sds replpreamble;       /* Replication DB preamble. */
     long long read_reploff; /* Read replication offset if this is a master. */
     long long reploff;      /* Applied replication offset if this is a master. */
-    long long repl_ack_off; /* Replication ack offset, if this is a slave. */
-    long long repl_ack_time;/* Replication ack time, if this is a slave. */
+    long long reploff_skipped;  /* Repl backlog we did not send to this client */
+    long long repl_ack_off; /* Replication ack offset, if this is a replica. */
+    long long repl_ack_time;/* Replication ack time, if this is a replica. */
     long long psync_initial_offset; /* FULLRESYNC reply offset other slaves
-                                       copying this slave output buffer
+                                       copying this replica output buffer
                                        should use. */
     char replid[CONFIG_RUN_ID_SIZE+1]; /* Master replication ID (if master). */
     int slave_listening_port; /* As configured with: SLAVECONF listening-port */
@@ -952,6 +1322,11 @@ typedef struct client {
     /* UUIDs are transient and lost when the server is shut down */
     unsigned char uuid[UUID_BINARY_LEN];
 
+    /* If this client is in tracking mode and this field is non zero,
+     * invalidation messages for keys fetched by this client will be send to
+     * the specified client ID. */
+    uint64_t client_tracking_redirection;
+
     /* Response buffer */
     int bufpos;
     char buf[PROTO_REPLY_CHUNK_BYTES];
@@ -963,6 +1338,7 @@ typedef struct client {
 
     int iel; /* the event loop index we're registered with */
     struct fastlock lock;
+    int master_error;
 } client;
 
 struct saveparam {
@@ -977,7 +1353,7 @@ struct moduleLoadQueueEntry {
 };
 
 struct sharedObjectsStruct {
-    robj *crlf, *ok, *err, *emptybulk, *czero, *cone, *pong, *space,
+    robj *crlf, *ok, *err, *emptybulk, *emptymultibulk, *nullbulk, *czero, *cone, *pong, *space,
     *colon, *queued, *null[4], *nullarray[4],
     *emptyarray, *wrongtypeerr, *nokeyerr, *syntaxerr, *sameobjecterr,
     *outofrangeerr, *noscripterr, *loadingerr, *slowscripterr, *bgsaveerr,
@@ -1104,9 +1480,11 @@ typedef struct rdbSaveInfo {
     char repl_id[CONFIG_RUN_ID_SIZE+1];     /* Replication ID. */
     long long repl_offset;                  /* Replication offset. */
     int fForceSetKey;
+    uint64_t mvccMinThreshold;
+    struct redisMaster *mi;
 } rdbSaveInfo;
 
-#define RDB_SAVE_INFO_INIT {-1,0,"000000000000000000000000000000",-1, TRUE}
+#define RDB_SAVE_INFO_INIT {-1,0,"000000000000000000000000000000",-1, TRUE, 0, nullptr}
 
 struct malloc_stats {
     size_t zmalloc_used;
@@ -1140,7 +1518,8 @@ struct redisServerThreadVars {
     aeEventLoop *el;
     int ipfd[CONFIG_BINDADDR_MAX]; /* TCP socket file descriptors */
     int ipfd_count;             /* Used slots in ipfd[] */
-    list *clients_pending_write; /* There is to write or install handler. */
+    int clients_paused;         /* True if clients are currently paused */
+    std::vector<client*> clients_pending_write; /* There is to write or install handler. */
     list *unblocked_clients;     /* list of clients to unblock before next loop NOT THREADSAFE */
     list *clients_pending_asyncwrite;
     int cclients;
@@ -1148,7 +1527,11 @@ struct redisServerThreadVars {
     int module_blocked_pipe[2]; /* Pipe used to awake the event loop if a
                                 client blocked on a module command needs
                                 to be processed. */
-    struct fastlock lockPendingWrite;
+    client *lua_client = nullptr;   /* The "fake client" to query Redis from Lua */
+    struct fastlock lockPendingWrite { "thread pending write" };
+    char neterr[ANET_ERR_LEN];   /* Error buffer for anet.c */
+    long unsigned commandsExecuted = 0;
+    bool fRetrySetAofEvent = false;
 };
 
 struct redisMaster {
@@ -1156,7 +1539,7 @@ struct redisMaster {
     char *masterauth;               /* AUTH with this password with master */
     char *masterhost;               /* Hostname of master */
     int masterport;                 /* Port of master */
-    client *cached_master; /* Cached master to be reused for PSYNC. */
+    client *cached_master;          /* Cached master to be reused for PSYNC. */
     client *master;
     /* The following two fields is where we store master PSYNC replid/offset
      * while the PSYNC is in progress. At the end we'll copy the fields into
@@ -1164,7 +1547,7 @@ struct redisMaster {
     char master_replid[CONFIG_RUN_ID_SIZE+1];  /* Master PSYNC runid. */
     long long master_initial_offset;           /* Master PSYNC offset. */
 
-    int repl_state;          /* Replication status if the instance is a slave */
+    int repl_state;          /* Replication status if the instance is a replica */
     off_t repl_transfer_size; /* Size of RDB to read from master during sync. */
     off_t repl_transfer_read; /* Amount of RDB read from master during sync. */
     off_t repl_transfer_last_fsync_off; /* Offset when we fsync-ed last time. */
@@ -1176,6 +1559,9 @@ struct redisMaster {
 
     unsigned char master_uuid[UUID_BINARY_LEN];  /* Used during sync with master, this is our master's UUID */
                                                 /* After we've connected with our master use the UUID in g_pserver->master */
+    uint64_t mvccLastSync;
+    /* During a handshake the server may have stale keys, we track these here to share once a reciprocal connection is made */
+    std::map<int, std::vector<robj_sharedptr>> *staleKeyMap;
 };
 
 // Const vars are not changed after worker threads are launched
@@ -1200,7 +1586,7 @@ struct redisServerConst {
     /* Configuration */
     char *default_masteruser;               /* AUTH with this user and masterauth with master */
     char *default_masterauth;               /* AUTH with this password with master */
-    int verbosity;                  /* Loglevel in redis.conf */
+    int verbosity;                  /* Loglevel in keydb.conf */
     int maxidletime;                /* Client timeout in seconds */
     int tcpkeepalive;               /* Set SO_KEEPALIVE if non-zero. */
     int active_defrag_enabled;
@@ -1221,6 +1607,8 @@ struct redisServerConst {
     size_t system_memory_size;  /* Total memory in system as reported by OS */
 
     unsigned char uuid[UUID_BINARY_LEN];         /* This server's UUID - populated on boot */
+    bool fUsePro = false;
+    int thread_min_client_threshold = 50;
 };
 
 struct redisServer {
@@ -1229,14 +1617,14 @@ struct redisServer {
     int config_hz;              /* Configured HZ value. May be different than
                                    the actual 'hz' field value if dynamic-hz
                                    is enabled. */
-    int hz;                     /* serverCron() calls frequency in hertz */
+    std::atomic<int> hz;                     /* serverCron() calls frequency in hertz */
     redisDb *db;
     dict *commands;             /* Command table */
     dict *orig_commands;        /* Command table before command renaming. */
 
     struct redisServerThreadVars rgthreadvar[MAX_EVENT_LOOPS];
 
-    unsigned int lruclock;      /* Clock for LRU eviction */
+    std::atomic<unsigned int> lruclock;      /* Clock for LRU eviction */
     int shutdown_asap;          /* SHUTDOWN needed ASAP */
     int activerehashing;        /* Incremental rehash in serverCron() */
     int active_defrag_running;  /* Active defragmentation running (holds current scan aggressiveness) */
@@ -1264,11 +1652,9 @@ struct redisServer {
     list *clients_to_close;     /* Clients to close asynchronously */
     list *slaves, *monitors;    /* List of slaves and MONITORs */
     rax *clients_index;         /* Active clients dictionary by client ID. */
-    int clients_paused;         /* True if clients are currently paused */
     mstime_t clients_pause_end_time; /* Time when we undo clients_paused */
-    char neterr[ANET_ERR_LEN];   /* Error buffer for anet.c */
     dict *migrate_cached_sockets;/* MIGRATE cached sockets */
-    uint64_t next_client_id;    /* Next client unique ID. Incremental. */
+    std::atomic<uint64_t> next_client_id; /* Next client unique ID. Incremental. */
     int protected_mode;         /* Don't accept external connections. */
     /* RDB / AOF loading information */
     int loading;                /* We are loading data from disk if true */
@@ -1305,8 +1691,8 @@ struct redisServer {
     long long slowlog_log_slower_than; /* SLOWLOG time limit (to get logged) */
     unsigned long slowlog_max_len;     /* SLOWLOG max number of items logged */
     struct malloc_stats cron_malloc_stats; /* sampled in serverCron(). */
-    long long stat_net_input_bytes; /* Bytes read from network. */
-    long long stat_net_output_bytes; /* Bytes written to network. */
+    std::atomic<long long> stat_net_input_bytes; /* Bytes read from network. */
+    std::atomic<long long> stat_net_output_bytes; /* Bytes written to network. */
     size_t stat_rdb_cow_bytes;      /* Copy on write bytes during RDB saving. */
     size_t stat_aof_cow_bytes;      /* Copy on write bytes during AOF rewrite. */
     /* The following two are used to track instantaneous metrics, like
@@ -1317,7 +1703,6 @@ struct redisServer {
         long long samples[STATS_METRIC_SAMPLES];
         int idx;
     } inst_metric[STATS_METRIC_COUNT];
-    
     /* AOF persistence */
     int aof_state;                  /* AOF_(ON|OFF|WAIT_REWRITE) */
     int aof_fsync;                  /* Kind of fsync() policy */
@@ -1327,6 +1712,7 @@ struct redisServer {
     off_t aof_rewrite_min_size;     /* the AOF file is at least N bytes. */
     off_t aof_rewrite_base_size;    /* AOF size on latest startup or rewrite. */
     off_t aof_current_size;         /* AOF current size. */
+    off_t aof_fsync_offset;         /* AOF offset which is already synced to disk. */
     int aof_rewrite_scheduled;      /* Rewrite once BGSAVE terminates. */
     pid_t aof_child_pid;            /* PID if rewriting process */
     list *aof_rewrite_buf_blocks;   /* Hold changes during an AOF rewrite. */
@@ -1356,6 +1742,7 @@ struct redisServer {
     int aof_stop_sending_diff;     /* If true stop sending accumulated diffs
                                       to child process. */
     sds aof_child_diff;             /* AOF diff accumulator child side. */
+    int aof_rewrite_pending = 0;    /* is a call to aofChildWriteDiffData already queued? */
     /* RDB persistence */
     long long dirty;                /* Changes to DB from the last save */
     long long dirty_before_bgsave;  /* Used to restore dirty on failed BGSAVE */
@@ -1375,7 +1762,7 @@ struct redisServer {
     int lastbgsave_status;          /* C_OK or C_ERR */
     int stop_writes_on_bgsave_err;  /* Don't allow writes if can't BGSAVE */
     int rdb_pipe_write_result_to_parent; /* RDB pipes used to return the state */
-    int rdb_pipe_read_result_from_child; /* of each slave in diskless SYNC. */
+    int rdb_pipe_read_result_from_child; /* of each replica in diskless SYNC. */
     /* Pipe and data structures for child -> parent info sharing. */
     int child_info_pipe[2];         /* Pipe used to write the child_info_data. */
     struct {
@@ -1395,8 +1782,8 @@ struct redisServer {
     char replid2[CONFIG_RUN_ID_SIZE+1]; /* replid inherited from master*/
     long long master_repl_offset;   /* My current replication offset */
     long long second_replid_offset; /* Accept offsets up to this for replid2. */
-    int slaveseldb;                 /* Last SELECTed DB in replication output */
-    int repl_ping_slave_period;     /* Master pings the slave every N seconds */
+    int replicaseldb;                 /* Last SELECTed DB in replication output */
+    int repl_ping_slave_period;     /* Master pings the replica every N seconds */
     char *repl_backlog;             /* Replication backlog for partial syncs */
     long long repl_backlog_size;    /* Backlog circular buffer size */
     long long repl_backlog_histlen; /* Backlog actual data length */
@@ -1413,7 +1800,7 @@ struct redisServer {
     int repl_good_slaves_count;     /* Number of slaves with lag <= max_lag. */
     int repl_diskless_sync;         /* Send RDB to slaves sockets directly. */
     int repl_diskless_sync_delay;   /* Delay to start a diskless repl BGSAVE. */
-    /* Replication (slave) */
+    /* Replication (replica) */
     list *masters;
     int enable_multimaster; 
     int repl_timeout;               /* Timeout after N seconds of master idle */
@@ -1445,13 +1832,15 @@ struct redisServer {
     unsigned int blocked_clients;   /* # of clients executing a blocking cmd.*/
     unsigned int blocked_clients_by_type[BLOCKED_NUM];
     list *ready_keys;        /* List of readyList structures for BLPOP & co */
+    /* Client side caching. */
+    unsigned int tracking_clients;  /* # of clients with tracking enabled.*/
     /* Sort parameters - qsort_r() is only available under BSD so we
      * have to take this state global, in order to pass it to sortCompare() */
     int sort_desc;
     int sort_alpha;
     int sort_bypattern;
     int sort_store;
-    /* Zip structure config, see redis.conf for more information  */
+    /* Zip structure config, see keydb.conf for more information  */
     size_t hash_max_ziplist_entries;
     size_t hash_max_ziplist_value;
     size_t set_max_intset_entries;
@@ -1464,10 +1853,10 @@ struct redisServer {
     int list_max_ziplist_size;
     int list_compress_depth;
     /* time cache */
-    time_t unixtime;    /* Unix time sampled every cron cycle. */
-    time_t timezone;    /* Cached timezone. As set by tzset(). */
-    int daylight_active;    /* Currently in daylight saving time. */
-    long long mstime;   /* Like 'unixtime' but with milliseconds resolution. */
+    std::atomic<time_t> unixtime;    /* Unix time sampled every cron cycle. */
+    time_t timezone;            /* Cached timezone. As set by tzset(). */
+    int daylight_active;        /* Currently in daylight saving time. */
+    long long mstime;           /* 'unixtime' with milliseconds resolution. */
     /* Pubsub */
     dict *pubsub_channels;  /* Map channels to list of subscribed clients */
     list *pubsub_patterns;  /* A list of pubsub_patterns */
@@ -1482,7 +1871,7 @@ struct redisServer {
     int cluster_slave_validity_factor; /* Slave max data age for failover. */
     int cluster_require_full_coverage; /* If true, put the cluster down if
                                           there is at least an uncovered slot.*/
-    int cluster_slave_no_failover;  /* Prevent slave from starting a failover
+    int cluster_slave_no_failover;  /* Prevent replica from starting a failover
                                        if the master is in failure state. */
     char *cluster_announce_ip;  /* IP address to announce on cluster bus. */
     int cluster_announce_port;     /* base port to announce on cluster bus. */
@@ -1493,8 +1882,7 @@ struct redisServer {
                                       REDISMODULE_CLUSTER_FLAG_*. */
     /* Scripting */
     lua_State *lua; /* The Lua interpreter. We use just one for all clients */
-    client *lua_client;   /* The "fake client" to query Redis from Lua */
-    client *lua_caller;   /* The client running EVAL right now, or NULL */
+    client *lua_caller = nullptr;   /* The client running EVAL right now, or NULL */
     dict *lua_scripts;         /* A dictionary of SHA1 -> Lua scripts */
     unsigned long long lua_scripts_mem;  /* Cached scripts' memory + oh */
     mstime_t lua_time_limit;  /* Script timeout in milliseconds */
@@ -1526,20 +1914,15 @@ struct redisServer {
     int bug_report_start; /* True if bug report header was already logged. */
     int watchdog_period;  /* Software watchdog period in ms. 0 = off */
 
-    /* Mutexes used to protect atomic variables when atomic builtins are
-     * not available. */
-    pthread_mutex_t lruclock_mutex;
-    pthread_mutex_t next_client_id_mutex;
-    pthread_mutex_t unixtime_mutex;
-
     int fActiveReplica;                          /* Can this replica also be a master? */
 
-    struct fastlock flock;
-
     // Format:
     //  Lower 20 bits: a counter incrementing for each command executed in the same millisecond
     //  Upper 44 bits: mstime (least significant 44-bits) enough for ~500 years before rollover from date of addition
     uint64_t mvcc_tstamp;
+
+    /* System hardware info */
+    size_t system_memory_size;  /* Total memory in system as reported by OS */
 };
 
 typedef struct pubsubPattern {
@@ -1673,6 +2056,7 @@ void moduleAcquireGIL(int fServerThread);
 void moduleReleaseGIL(int fServerThread);
 void moduleNotifyKeyspaceEvent(int type, const char *event, robj *key, int dbid);
 void moduleCallCommandFilters(client *c);
+int moduleHasCommandFilters();
 
 /* Utils */
 long long ustime(void);
@@ -1687,7 +2071,7 @@ void redisSetProcTitle(const char *title);
 /* networking.c -- Networking and Client related operations */
 client *createClient(int fd, int iel);
 void closeTimedoutClients(void);
-void freeClient(client *c);
+bool freeClient(client *c);
 void freeClientAsync(client *c);
 void resetClient(client *c);
 void sendReplyToClient(aeEventLoop *el, int fd, void *privdata, int mask);
@@ -1703,12 +2087,13 @@ void acceptHandler(aeEventLoop *el, int fd, void *privdata, int mask);
 void acceptTcpHandler(aeEventLoop *el, int fd, void *privdata, int mask);
 void acceptUnixHandler(aeEventLoop *el, int fd, void *privdata, int mask);
 void readQueryFromClient(aeEventLoop *el, int fd, void *privdata, int mask);
-void addReplyNull(client *c);
+void addReplyNull(client *c, robj_roptr objOldProtocol = nullptr);
 void addReplyNullArray(client *c);
 void addReplyBool(client *c, int b);
 void addReplyVerbatim(client *c, const char *s, size_t len, const char *ext);
 void addReplyProto(client *c, const char *s, size_t len);
 void addReplyBulk(client *c, robj_roptr obj);
+void AddReplyFromClient(client *c, client *src);
 void addReplyBulkCString(client *c, const char *s);
 void addReplyBulkCBuffer(client *c, const void *p, size_t len);
 void addReplyBulkLongLong(client *c, long long ll);
@@ -1753,9 +2138,10 @@ const char *getClientTypeName(int cclass);
 void flushSlavesOutputBuffers(void);
 void disconnectSlaves(void);
 void disconnectSlavesExcept(unsigned char *uuid);
-int listenToPort(int port, int *fds, int *count, int fReusePort);
+int listenToPort(int port, int *fds, int *count, int fReusePort, int fFirstListen);
 void pauseClients(mstime_t duration);
 int clientsArePaused(void);
+void unpauseClientsIfNecessary();
 int processEventsWhileBlocked(int iel);
 int handleClientsWithPendingWrites(int iel);
 int clientHasPendingReplies(client *c);
@@ -1783,6 +2169,7 @@ void addReplyPushLenAsync(client *c, long length);
 void addReplyLongLongAsync(client *c, long long ll);
 
 void ProcessPendingAsyncWrites(void);
+client *lookupClientByID(uint64_t id);
 
 #ifdef __GNUC__
 void addReplyErrorFormat(client *c, const char *fmt, ...)
@@ -1794,6 +2181,12 @@ void addReplyErrorFormat(client *c, const char *fmt, ...);
 void addReplyStatusFormat(client *c, const char *fmt, ...);
 #endif
 
+/* Client side caching (tracking mode) */
+void enableTracking(client *c, uint64_t redirect_to);
+void disableTracking(client *c);
+void trackingRememberKeys(client *c);
+void trackingInvalidateKey(robj *keyobj);
+
 /* List data type */
 void listTypeTryConversion(robj *subject, robj *value);
 void listTypePush(robj *subject, robj *value, int where);
@@ -1861,6 +2254,7 @@ int getLongLongFromObjectOrReply(client *c, robj *o, long long *target, const ch
 int getDoubleFromObjectOrReply(client *c, robj *o, double *target, const char *msg);
 int getDoubleFromObject(const robj *o, double *target);
 int getLongLongFromObject(robj *o, long long *target);
+int getUnsignedLongLongFromObject(robj *o, uint64_t *target);
 int getLongDoubleFromObject(robj *o, long double *target);
 int getLongDoubleFromObjectOrReply(client *c, robj *o, long double *target, const char *msg);
 const char *strEncoding(int encoding);
@@ -1900,9 +2294,10 @@ void replicationSendNewlineToMaster(struct redisMaster *mi);
 long long replicationGetSlaveOffset(struct redisMaster *mi);
 char *replicationGetSlaveName(client *c);
 long long getPsyncInitialOffset(void);
-int replicationSetupSlaveForFullResync(client *slave, long long offset);
+int replicationSetupSlaveForFullResync(client *replica, long long offset);
 void changeReplicationId(void);
 void clearReplicationId2(void);
+void mergeReplicationId(const char *);
 void chopReplicationBacklog(void);
 void replicationCacheMasterUsingMyself(struct redisMaster *mi);
 void feedReplicationBacklog(const void *ptr, size_t len);
@@ -2121,6 +2516,7 @@ int pubsubUnsubscribeAllPatterns(client *c, int notify);
 void freePubsubPattern(const void *p);
 int listMatchPubsubPattern(void *a, void *b);
 int pubsubPublishMessage(robj *channel, robj *message);
+void addReplyPubsubMessage(client *c, robj *channel, robj *msg);
 
 /* Keyspace events notification */
 void notifyKeyspaceEvent(int type, const char *event, robj *key, int dbid);
@@ -2137,10 +2533,13 @@ int rewriteConfig(char *path);
 
 /* db.c -- Keyspace access API */
 int removeExpire(redisDb *db, robj *key);
+int removeExpireCore(redisDb *db, robj *key, dictEntry *de);
+int removeSubkeyExpire(redisDb *db, robj *key, robj *subkey);
 void propagateExpire(redisDb *db, robj *key, int lazy);
 int expireIfNeeded(redisDb *db, robj *key);
-long long getExpire(redisDb *db, robj_roptr key);
-void setExpire(client *c, redisDb *db, robj *key, long long when);
+expireEntry *getExpire(redisDb *db, robj_roptr key);
+void setExpire(client *c, redisDb *db, robj *key, robj *subkey, long long when);
+void setExpire(client *c, redisDb *db, robj *key, expireEntry &&entry);
 robj_roptr lookupKeyRead(redisDb *db, robj *key);
 robj *lookupKeyWrite(redisDb *db, robj *key);
 robj_roptr lookupKeyReadOrReply(client *c, robj *key, robj *reply);
@@ -2335,6 +2734,8 @@ void mgetCommand(client *c);
 void monitorCommand(client *c);
 void expireCommand(client *c);
 void expireatCommand(client *c);
+void expireMemberCommand(client *c);
+void expireMemberAtCommand(client *c);
 void pexpireCommand(client *c);
 void pexpireatCommand(client *c);
 void getsetCommand(client *c);
@@ -2466,7 +2867,7 @@ struct redisMaster *MasterInfoFromClient(client *c);
 uint64_t getMvccTstamp();
 void incrementMvccTstamp();
 
-#if defined(__GNUC__) && !defined(NO_DEPRECATE_FREE)
+#if __GNUC__ >= 7 && !defined(NO_DEPRECATE_FREE)
  [[deprecated]]
 void *calloc(size_t count, size_t size);
  [[deprecated]]
@@ -2495,9 +2896,10 @@ void xorDigest(unsigned char *digest, const void *ptr, size_t len);
 int populateCommandTableParseFlags(struct redisCommand *c, const char *strflags);
 
 int moduleGILAcquiredByModule(void);
+extern int g_fInCrash;
 static inline int GlobalLocksAcquired(void)  // Used in asserts to verify all global locks are correctly acquired for a server-thread to operate
 {
-    return aeThreadOwnsLock() || moduleGILAcquiredByModule();
+    return aeThreadOwnsLock() || moduleGILAcquiredByModule() || g_fInCrash;
 }
 
 inline int ielFromEventLoop(const aeEventLoop *eventLoop)
@@ -2520,6 +2922,9 @@ inline int FCorrectThread(client *c)
 }
 #define AssertCorrectThread(c) serverAssert(FCorrectThread(c))
 
+class ShutdownException
+{};
+
 #define redisDebug(fmt, ...) \
     printf("DEBUG %s:%d > " fmt "\n", __FILE__, __LINE__, __VA_ARGS__)
 #define redisDebugMark() \

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_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 "5.3.3"
+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/cluster/run.tcl

@@ -14,6 +14,8 @@ proc main {} {
     spawn_instance redis $::redis_base_port $::instances_count {
         "cluster-enabled yes"
         "appendonly yes"
+	"testmode yes"
+	"server-threads 3"
     }
     run_tests
     cleanup

tests/integration/logging.tcl

@@ -6,7 +6,7 @@ if {$system_name eq {linux} || $system_name eq {darwin}} {
         test "Server is able to generate a stack trace on selected systems" {
             r config set watchdog-period 200
             r debug sleep 1
-            set pattern "*debugCommand*"
+            set pattern "*watchdogSignalHandler*"
             set retry 10
             while {$retry} {
                 set result [exec tail -100 < [srv 0 stdout]]

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,149 @@
+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]
+    	set master_pid [s process_id]
+
+        # Use a short replication timeout on the slave, so that if there
+        # are no bugs the timeout is triggered in a reasonable amount
+        # 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 propogate transaction} {
+            $master set testkey 0
+            $master multi
+            $master incr testkey
+            $master incr testkey
+            after 5000
+            $master get testkey
+            $master exec
+            assert_equal 2 [$master get testkey]
+            after 500
+            wait_for_condition 50 500 {
+                [string match "2" [$slave get testkey]]
+            } else {
+                fail "Transaction failed to replicate"
+            }
+            $master flushall
+        }
+
+        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 expire propogates when source is down} {
+            $slave flushall
+	    $slave set testkey2 foo
+            $slave set testkey1 foo
+            wait_for_condition 50 1000 {
+                [string match *foo* [$master get testkey1]]
+            } else {
+                fail "Replication failed to propogate"
+            }
+            $slave expire testkey1 2
+	    assert_equal {1} [$slave wait 1 500] { "value should propogate
+		                    within 0.5 seconds" }
+	    exec kill -SIGSTOP $slave_pid
+            after 3000
+	    # Ensure testkey1 is gone.  Note, we can't do this directly as the normal commands lie to us
+	    # about what is actually in the dict.  The only way to know is with a count from info
+            assert_equal {1} [expr [string first {keys=1} [$master info keyspace]] >= 0]  {"slave expired"}
+	}
+	exec kill -SIGCONT $slave_pid
+
+        test {Active replica different databases} {
+            $master select 3
+            $master set testkey abcd
+            $master select 2
+            $master del testkey
+            $slave select 3
+            wait_for_condition 50 1000 {
+                [string match abcd [$slave get testkey]]
+            } else {
+                fail "Replication failed to propogate DB 3"
+            }
+        }
+    }
+}

tests/integration/replication-multimaster.tcl

@@ -0,0 +1,74 @@
+foreach topology {mesh ring} {
+start_server {tags {"multi-master"} overrides {hz 500 active-replica yes multi-master yes}} {
+start_server {overrides {hz 500 active-replica yes multi-master yes}} {
+start_server {overrides {hz 500 active-replica yes multi-master yes}} {
+start_server {overrides {hz 500 active-replica yes multi-master yes}} {
+
+    for {set j 0} {$j < 4} {incr j} {
+        set R($j) [srv [expr 0-$j] client]
+        set R_host($j) [srv [expr 0-$j] host]
+        set R_port($j) [srv [expr 0-$j] port]
+    }
+
+    # Initialize as mesh
+    if [string equal $topology "mesh"] {
+    for {set j 0} {$j < 4} {incr j} {
+        for {set k 0} {$k < 4} {incr k} {
+            if $j!=$k {
+                $R($j) replicaof $R_host($k) $R_port($k)
+                after 100
+            }
+        }
+    }}
+    #Else Ring
+    if [string equal $topology "ring"] {
+        $R(0) replicaof $R_host(3) $R_port(3)
+        after 100
+        $R(1) replicaof $R_host(0) $R_port(0)
+        after 100
+        $R(2) replicaof $R_host(1) $R_port(1)
+        after 100
+        $R(3) replicaof $R_host(2) $R_port(2)
+    }
+
+    after 2000
+
+    test "$topology replicates to all nodes" {
+        $R(0) set testkey foo
+        after 500
+        assert_equal foo [$R(1) get testkey] "replicates to 1"
+        assert_equal foo [$R(2) get testkey] "replicates to 2"
+    }
+
+    test "$topology replicates only once" {
+        $R(0) set testkey 1
+        after 500
+        $R(1) incr testkey
+        after 500
+        $R(2) incr testkey
+        after 500
+        assert_equal 3 [$R(0) get testkey]
+        assert_equal 3 [$R(1) get testkey]
+        assert_equal 3 [$R(2) get testkey]
+        assert_equal 3 [$R(3) get testkey]
+    }
+
+    test "$topology transaction replicates only once" {
+        for {set j 0} {$j < 1000} {incr j} {
+            $R(0) set testkey 1
+            $R(0) multi
+            $R(0) incr testkey
+            $R(0) incr testkey
+            $R(0) exec
+            after 1
+            assert_equal 3 [$R(0) get testkey] "node 0"
+            assert_equal 3 [$R(1) get testkey] "node 1"
+            assert_equal 3 [$R(2) get testkey] "node 2"
+            assert_equal 3 [$R(3) get testkey] "node 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/integration/replication.tcl

@@ -309,3 +309,5 @@ start_server {tags {"repl"}} {
         }
     }
 }
+
+

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,17 @@ set ::all_tests {
     unit/quit
     unit/aofrw
     unit/acl
+    unit/rreplay
+    unit/cron
+    unit/replication
     integration/block-repl
     integration/replication
     integration/replication-2
     integration/replication-3
     integration/replication-4
     integration/replication-psync
+    integration/replication-active
+    integration/replication-multimaster
     integration/aof
     integration/rdb
     integration/convert-zipmap-hash-on-load
@@ -63,7 +68,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 +508,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}} {