Remove performance zapping test code

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,20 +0,0 @@
----
-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

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

.vscode/settings.json

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

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 libcurl4-openssl-dev libjemalloc-dev tcl tcl-dev uuid-dev libcurl4-openssl-dev \
+        build-essential nasm autotools-dev autoconf libcurl4-openssl-dev libjemalloc-dev tcl tcl-dev uuid-dev \
     && apt-get clean
 
 CMD make

README.md

@@ -4,20 +4,16 @@
 
 ##### 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 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. 
 
-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 maintains full compatibility with the Redis protocol, modules, and scripts.  This includes the atomicity gurantees for scripts and transactions.  Because KeyDB keeps in sync with Redis development KeyDB is a superset of Redis functionality, making KeyDB a drop in replacement for existing Redis deployments.
 
 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/
+<img src=https://cdn-images-1.medium.com/max/1400/1*s7mTb7Qb0kxc951mz8bdgA.png width=420 height=300/><img src=https://cdn-images-1.medium.com/max/1400/1*R00A5U4AFGohGOYHMfT6fA.png height=300/>
 
 Why fork Redis?
 ---------------

redis.conf

@@ -1,9 +1,9 @@
-# KeyDB configuration file example.
+# Redis configuration file example.
 #
-# Note that in order to read the configuration file, KeyDB must be
+# Note that in order to read the configuration file, Redis must be
 # started with the file path as first argument:
 #
-# ./keydb-server /path/to/keydb.conf
+# ./keydb-server /path/to/redis.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 KeyDB servers but also need
+# have a standard template that goes to all Redis 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 KeyDB Sentinel. Since KeyDB always uses the last processed
+# from admin or Redis Sentinel. Since Redis 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, KeyDB listens
+# By default, if no "bind" configuration directive is specified, Redis 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 KeyDB is directly exposed to the
+# ~~~ WARNING ~~~ If the computer running Redis 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 KeyDB to listen only into
-# the IPv4 loopback interface address (this means KeyDB will be able to
+# following bind directive, that will force Redis to listen only into
+# the IPv4 loopback interface address (this means Redis 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
-# KeyDB instances left open on the internet are accessed and exploited.
+# Redis 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 KeyDB
+# you are sure you want clients from other hosts to connect to Redis
 # 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 KeyDB will not listen on a TCP socket.
+# If port 0 is specified Redis 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 KeyDB will not listen
+# incoming connections. There is no default, so Redis will not listen
 # on a unix socket when not specified.
 #
-# unixsocket /tmp/keydb.sock
+# unixsocket /tmp/redis.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
-# KeyDB default starting with Redis 3.2.1.
+# Redis default starting with Redis 3.2.1.
 tcp-keepalive 300
 
 ################################# GENERAL #####################################
 
-# 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.
+# 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.
 daemonize no
 
-# If you run KeyDB from upstart or systemd, KeyDB can interact with your
+# If you run Redis from upstart or systemd, Redis can interact with your
 # supervision tree. Options:
 #   supervised no      - no supervision interaction
-#   supervised upstart - signal upstart by putting KeyDB into SIGSTOP mode
+#   supervised upstart - signal upstart by putting Redis 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, KeyDB writes it where specified at startup
+# If a pid file is specified, Redis 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/keydb.pid".
+# is used even if not specified, defaulting to "/var/run/redis.pid".
 #
-# Creating a pid file is best effort: if KeyDB is not able to create it
+# Creating a pid file is best effort: if Redis is not able to create it
 # nothing bad happens, the server will start and run normally.
-pidfile /var/run/keydb_6379.pid
+pidfile /var/run/redis_6379.pid
 
 # Specify the server verbosity level.
 # This can be one of:
@@ -166,7 +166,7 @@ pidfile /var/run/keydb_6379.pid
 loglevel notice
 
 # Specify the log file name. Also the empty string can be used to force
-# KeyDB to log on the standard output. Note that if you use standard
+# Redis 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 keydb
+# syslog-ident redis
 
 # 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 KeyDB shows an ASCII art logo only when started to log to the
+# By default Redis 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 KeyDB will stop accepting writes if RDB snapshots are enabled
+# By default Redis 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 KeyDB will
+# If the background saving process will start working again Redis will
 # automatically allow writes again.
 #
-# 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
+# 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
 # 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 KeyDB instance a copy of
-# another KeyDB server. A few things to understand ASAP about KeyDB 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    |
 #   | (receive writes) |      |  (exact copy) |
 #   +------------------+      +---------------+
 #
-# 1) KeyDB replication is asynchronous, but you can configure a master to
+# 1) Redis 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) KeyDB replicas are able to perform a partial resynchronization with the
+# 2) Redis 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 KeyDB ACLs (for Redis version
+# However this is not enough if you are using Redis 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 KeyDB master creates a new process that writes the RDB
+# 1) Disk-backed: The Redis 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 KeyDB master creates a new process that directly writes the
+# 2) Diskless: The Redis 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" KeyDB will use a smaller number of TCP packets and
+# If you select "yes" Redis 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 KeyDB in the INFO output.
-# It is used by KeyDB Sentinel in order to select a replica to promote into a
+# 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
 # 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
-# KeyDB Sentinel for promotion.
+# Redis 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 KeyDB master is able to list the address and port of the attached
+# A Redis 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
-# KeyDB Sentinel in order to discover replica instances.
+# Redis 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 KeyDB is pretty fast an outside user can try up to
+# Warning: since Redis 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.
 
-# KeyDB ACL users are defined in the following format:
+# Redis 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 KeyDB command table is described and defined.
+#               the Redis 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 keydb.conf to describe users.
+# format that is used inside redis.conf to describe users.
 #
-# aclfile /etc/keydb/users.acl
+# aclfile /etc/redis/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 KeyDB server is not
+# this limit is set to 10000 clients, however if the Redis 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 KeyDB reserves a few file descriptors for internal uses).
+# minus 32 (as Redis reserves a few file descriptors for internal uses).
 #
-# Once the limit is reached KeyDB will close all the new connections sending
+# Once the limit is reached Redis 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 KeyDB will try to remove keys
+# When the memory limit is reached Redis will try to remove keys
 # according to the eviction policy selected (see maxmemory-policy).
 #
-# 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
+# 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
 # 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 KeyDB as an LRU or LFU cache, or to
+# This option is usually useful when using Redis 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 KeyDB will select what to remove when maxmemory
+# MAXMEMORY POLICY: how Redis 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, KeyDB will return an error on write
+# Note: with any of the above policies, Redis 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 KeyDB will check five keys and pick the one that was
+# accuracy. For default Redis 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 ####################################
 
-# KeyDB has two primitives to delete keys. One is called DEL and is a blocking
+# Redis 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 KeyDB. However if the key is associated with an
+# O(1) or O(log_N) commands in Redis. 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 KeyDB also offers non blocking deletion primitives
+# For the above reasons Redis 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 KeyDB server sometimes has to
+# idea to use one or the other. However the Redis server sometimes has to
 # delete keys or flush the whole database as a side effect of other operations.
-# Specifically KeyDB deletes objects independently of a user call in the
+# Specifically Redis 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 KeyDB asynchronously dumps the dataset on disk. This mode is
-# good enough in many applications, but an issue with the KeyDB process or
+# 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
 # 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) KeyDB can lose just one second of writes in a
+# (see later in the config file) Redis 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 KeyDB process itself happens, but the operating system is
+# wrong with the Redis 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 KeyDB will load the AOF, that is the file
+# If the AOF is enabled on startup Redis 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.
 #
-# KeyDB supports three different modes:
+# Redis 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
-# KeyDB may block too long on the fsync() call. Note that there is no fix for
+# Redis 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 KeyDB is
+# This means that while another child is saving, the durability of Redis 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.
-# KeyDB is able to automatically rewrite the log file implicitly calling
+# Redis 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: KeyDB remembers the size of the AOF file after the
+# This is how it works: Redis 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 KeyDB
+# An AOF file may be found to be truncated at the end during the Redis
 # startup process, when the AOF data gets loaded back into memory.
-# This may happen when the system where KeyDB is running
+# This may happen when the system where Redis is running
 # crashes, especially when an ext4 filesystem is mounted without the
-# data=ordered option (however this can't happen when KeyDB itself
+# data=ordered option (however this can't happen when Redis itself
 # crashes or aborts but the operating system still works correctly).
 #
-# KeyDB can either exit with an error when this happens, or load as much
+# Redis 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 KeyDB server starts emitting a log to inform the user of the event.
+# the Redis 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
-# KeyDB will try to read more data from the AOF file but not enough bytes
+# Redis 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, KeyDB is able to use an RDB preamble in the
+# When rewriting the AOF file, Redis 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 KeyDB recognizes that the AOF file starts with the "REDIS"
+# When loading Redis 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 KeyDB will log that a script is
+# If the maximum execution time is reached Redis 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,17 +941,17 @@ aof-use-rdb-preamble yes
 # Set it to 0 or a negative value for unlimited execution without warnings.
 lua-time-limit 5000
 
-################################ KEYDB CLUSTER  ###############################
+################################ REDIS 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
+# Normal Redis instances can't be part of a Redis Cluster; only nodes that are
+# started as cluster nodes can. In order to start a Redis instance as a
 # cluster node enable the cluster support uncommenting the following:
 #
 # 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 KeyDB nodes.
-# Every KeyDB Cluster node requires a different cluster configuration file.
+# intended to be edited by hand. It is created and updated by Redis nodes.
+# Every Redis 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.
 #
@@ -1027,7 +1027,7 @@ lua-time-limit 5000
 #
 # cluster-migration-barrier 1
 
-# By default KeyDB Cluster nodes stop accepting queries if they detect there
+# By default Redis 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.
@@ -1055,11 +1055,11 @@ lua-time-limit 5000
 
 ########################## CLUSTER DOCKER/NAT support  ########################
 
-# In certain deployments, KeyDB Cluster nodes address discovery fails, because
+# In certain deployments, Redis 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 KeyDB Cluster working in such environments, a static
+# In order to make Redis 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:
 #
@@ -1072,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 KeyDB Cluster auto-detection
+# If the above options are not used, the normal Redis Cluster auto-detection
 # will be used instead.
 #
 # Note that when remapped, the bus port may not be at the fixed offset of
@@ -1088,14 +1088,14 @@ lua-time-limit 5000
 
 ################################## SLOW LOG ###################################
 
-# The KeyDB Slow Log is a system to log queries that exceeded a specified
+# The Redis 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 KeyDB
+# You can configure the slow log with two parameters: one tells Redis
 # 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
@@ -1112,9 +1112,9 @@ slowlog-max-len 128
 
 ################################ LATENCY MONITOR ##############################
 
-# The KeyDB latency monitoring subsystem samples different operations
+# The Redis latency monitoring subsystem samples different operations
 # at runtime in order to collect data related to possible sources of
-# latency of a KeyDB instance.
+# latency of a Redis instance.
 #
 # Via the LATENCY command this information is available to the user that can
 # print graphs and obtain reports.
@@ -1133,7 +1133,7 @@ latency-monitor-threshold 0
 
 ############################# EVENT NOTIFICATION ##############################
 
-# KeyDB can notify Pub/Sub clients about events happening in the key space.
+# Redis 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
@@ -1143,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 KeyDB will notify among a set
+# It is possible to select the events that Redis will notify among a set
 # of classes. Every class is identified by a single character:
 #
 #  K     Keyspace events, published with __keyspace@<db>__ prefix.
@@ -1179,12 +1179,12 @@ notify-keyspace-events ""
 
 ############################### GOPHER SERVER #################################
 
-# KeyDB contains an implementation of the Gopher protocol, as specified in
+# Redis 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 KeyDB server has just 100 lines of code in order to implement this
+# that the Redis 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
@@ -1194,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 KeyDB, we gave it the Gopher protocol
+# Anyway for the 10nth birthday of the Redis, we gave it the Gopher protocol
 # as a gift.
 #
 # --- HOW IT WORKS? ---
 #
-# The KeyDB Gopher support uses the inline protocol of KeyDB, and specifically
+# The Redis Gopher support uses the inline protocol of Redis, and specifically
 # two kind of inline requests that were anyway illegal: an empty request
-# or any request that starts with "/" (there are no KeyDB commands starting
+# or any request that starts with "/" (there are no Redis 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 KeyDB when Gopher is enabled and send it
+# If you open a connection to Redis 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.
 #
@@ -1216,7 +1216,7 @@ notify-keyspace-events ""
 #
 # --- SECURITY WARNING ---
 #
-# If you plan to put KeyDB on the internet in a publicly accessible address
+# If you plan to put Redis 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:
 #
@@ -1310,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 KeyDB hash table (the one mapping top-level
-# keys to values). The hash table implementation KeyDB uses (see dict.c)
+# 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)
 # 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
@@ -1322,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 KeyDB can reply from time to time
+# not a good thing in your environment that Redis can reply from time to time
 # to queries with 2 milliseconds delay.
 #
 # use "activerehashing yes" if you don't have such hard requirements but
@@ -1374,21 +1374,21 @@ client-output-buffer-limit pubsub 32mb 8mb 60
 #
 # client-query-buffer-limit 1gb
 
-# In the KeyDB protocol, bulk requests, that are, elements representing single
+# In the Redis 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
 
-# KeyDB calls an internal function to perform many background tasks, like
+# Redis 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 KeyDB checks for
+# Not all tasks are performed with the same frequency, but Redis 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
-# KeyDB is idle, but at the same time will make KeyDB more responsive when
+# Redis is idle, but at the same time will make Redis more responsive when
 # there are many keys expiring at the same time, and timeouts may be
 # handled with more precision.
 #
@@ -1402,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, KeyDB
+# Since the default HZ value by default is conservatively set to 10, Redis
 # offers, and enables by default, the ability to use an adaptive HZ value
 # which will temporary raise when there are many connected clients.
 #
@@ -1419,22 +1419,22 @@ dynamic-hz yes
 # big latency spikes.
 aof-rewrite-incremental-fsync yes
 
-# When KeyDB saves RDB file, if the following option is enabled
+# When redis 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
 
-# KeyDB LFU eviction (see maxmemory setting) can be tuned. However it is a good
+# Redis 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 KeyDB LFU implementation: the
+# There are two tunable parameters in the Redis 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 KeyDB
+# The LFU counter is just 8 bits per key, it's maximum value is 255, so Redis
 # 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:
@@ -1486,7 +1486,7 @@ rdb-save-incremental-fsync yes
 # What is active defragmentation?
 # -------------------------------
 #
-# Active (online) defragmentation allows a KeyDB server to compact the
+# Active (online) defragmentation allows a Redis server to compact the
 # spaces left between small allocations and deallocations of data in memory,
 # thus allowing to reclaim back memory.
 #
@@ -1498,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) KeyDB will start to create new copies of the
+# configuration options below) Redis 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
@@ -1507,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 KeyDB
-#    to use the copy of Jemalloc we ship with the source code of KeyDB.
+# 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.
 #    This is the default with Linux builds.
 #
 # 2. You never need to enable this feature if you don't have fragmentation
@@ -1561,10 +1561,3 @@ 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

src/IStorage.h

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

src/Makefile

@@ -47,6 +47,8 @@ endif
 USEASM?=true
 
 ifneq ($(SANITIZE),)
+	CC=clang
+	CXX=clang++
 	CFLAGS+= -fsanitize=$(SANITIZE) -DSANITIZE
 	CXXFLAGS+= -fsanitize=$(SANITIZE) -DSANITIZE
 	LDFLAGS+= -fsanitize=$(SANITIZE)
@@ -74,18 +76,12 @@ 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
@@ -107,24 +103,22 @@ endif
 -include .make-settings
 
 FINAL_CFLAGS=$(STD) $(WARN) $(OPT) $(DEBUG) $(CFLAGS) $(REDIS_CFLAGS)
-FINAL_CXXFLAGS=$(CXX_STD) $(WARN) $(OPT) $(DEBUG) $(CXXFLAGS) $(REDIS_CFLAGS)
+FINAL_CXXFLAGS=$(CXX_STD) $(WARN) $(OPT) $(DEBUG) $(CFLAGS) $(CXXFLAGS) $(REDIS_CFLAGS)
 FINAL_LDFLAGS=$(LDFLAGS) $(REDIS_LDFLAGS) $(DEBUG)
-FINAL_LIBS+=-lm -lcurl
+FINAL_LIBS=-lm
 DEBUG=-g -ggdb
 
 ifeq ($(uname_S),SunOS)
 	# SunOS
         ifneq ($(@@),32bit)
 		CFLAGS+= -m64
-		CXXFLAGS+= -m64
 		LDFLAGS+= -m64
 	endif
 	DEBUG=-g
 	DEBUG_FLAGS=-g
-	export CFLAGS CXXFLAGS LDFLAGS DEBUG DEBUG_FLAGS
+	export CFLAGS 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)
@@ -141,7 +135,6 @@ 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
@@ -159,7 +152,6 @@ else
 	FINAL_LDFLAGS+= -rdynamic
 	FINAL_LIBS+=-ldl -pthread -lrt -luuid
 	FINAL_CFLAGS += -DMOTD
-	FINAL_CXXFLAGS += -DMOTD
 endif
 endif
 endif
@@ -197,8 +189,8 @@ ifeq ($(MALLOC),memkind)
 endif
 
 REDIS_CC=$(QUIET_CC)$(CC) $(FINAL_CFLAGS)
-REDIS_CXX=$(QUIET_CC)$(CXX) $(FINAL_CXXFLAGS)
-KEYDB_AS=$(QUIET_CC) as --64 -g
+REDIS_CXX=$(QUIET_CC)$(CC) $(FINAL_CXXFLAGS)
+REDIS_NASM=$(QUIET_CC)nasm -felf64 
 REDIS_LD=$(QUIET_LINK)$(CXX) $(FINAL_LDFLAGS)
 REDIS_INSTALL=$(QUIET_INSTALL)$(INSTALL)
 
@@ -210,16 +202,16 @@ MAKECOLOR="\033[32;1m"
 ENDCOLOR="\033[0m"
 
 ifndef V
-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);
+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;
 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 new.o tracking.o cron.o motd.o $(ASM_OBJ)
+REDIS_SERVER_OBJ=adlist.o quicklist.o ae.o anet.o dict.o server.o sds.o zmalloc.o lzf_c.o lzf_d.o pqsort.o zipmap.o sha1.o ziplist.o release.o networking.o util.o object.o db.o replication.o rdb.o t_string.o t_list.o t_set.o t_zset.o t_hash.o config.o aof.o pubsub.o multi.o debug.o sort.o intset.o syncio.o cluster.o crc16.o endianconv.o slowlog.o scripting.o bio.o rio.o rand.o memtest.o crc64.o bitops.o sentinel.o notify.o setproctitle.o blocked.o hyperloglog.o latency.o sparkline.o redis-check-rdb.o redis-check-aof.o geo.o lazyfree.o module.o evict.o expire.o geohash.o geohash_helper.o childinfo.o defrag.o siphash.o rax.o t_stream.o listpack.o localtime.o acl.o storage.o rdb-s3.o fastlock.o new.o tracking.o $(ASM_OBJ)
 REDIS_CLI_NAME=keydb-cli
-REDIS_CLI_OBJ=anet.o adlist.o dict.o redis-cli.o redis-cli-cpphelper.o zmalloc.o release.o anet.o ae.o crc64.o siphash.o crc16.o storage-lite.o fastlock.o new.o motd.o $(ASM_OBJ)
+REDIS_CLI_OBJ=anet.o adlist.o dict.o redis-cli.o redis-cli-cpphelper.o zmalloc.o release.o anet.o ae.o crc64.o siphash.o crc16.o storage-lite.o fastlock.o new.o $(ASM_OBJ)
 REDIS_BENCHMARK_NAME=keydb-benchmark
 REDIS_BENCHMARK_OBJ=ae.o anet.o redis-benchmark.o adlist.o dict.o zmalloc.o siphash.o redis-benchmark.o storage-lite.o fastlock.o new.o $(ASM_OBJ)
 REDIS_CHECK_RDB_NAME=keydb-check-rdb
@@ -245,13 +237,10 @@ 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))
@@ -262,8 +251,6 @@ 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
@@ -289,7 +276,7 @@ $(REDIS_CHECK_AOF_NAME): $(REDIS_SERVER_NAME)
 
 # keydb-cli
 $(REDIS_CLI_NAME): $(REDIS_CLI_OBJ)
-	$(REDIS_LD) -o $@ $^ ../deps/hiredis/libhiredis.a ../deps/linenoise/linenoise.o $(FINAL_LIBS)
+	$(REDIS_LD) -o $@ $^ ../deps/hiredis/libhiredis.a ../deps/linenoise/linenoise.o $(FINAL_LIBS) -lcurl
 
 # keydb-benchmark
 $(REDIS_BENCHMARK_NAME): $(REDIS_BENCHMARK_OBJ)
@@ -298,25 +285,20 @@ $(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) -MMD -c $<
+	$(REDIS_CC) -c $<
 
 %.o: %.cpp .make-prerequisites
-	$(REDIS_CXX) -MMD -c $<
+	$(REDIS_CXX) -c $<
 
 %.o: %.asm .make-prerequisites
-	$(KEYDB_AS) $< -o $@
+	$(REDIS_NASM) $<
 
 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
 
@@ -354,7 +336,7 @@ bench: $(REDIS_BENCHMARK_NAME)
 	@echo ""
 	@echo "WARNING: if it fails under Linux you probably need to install libc6-dev-i386"
 	@echo ""
-	$(MAKE) CXXFLAGS="-m32" CFLAGS="-m32" LDFLAGS="-m32"
+	$(MAKE) CFLAGS="-m32" LDFLAGS="-m32"
 
 gcov:
 	$(MAKE) REDIS_CFLAGS="-fprofile-arcs -ftest-coverage -DCOVERAGE_TEST" REDIS_LDFLAGS="-fprofile-arcs -ftest-coverage"

src/acl.cpp

@@ -1123,7 +1123,7 @@ int ACLLoadConfiguredUsers(void) {
 
 /* This function loads the ACL from the specified filename: every line
  * 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:
+ * users in the redis.conf configuration or in the ACL file, that is:
  *
  *  user <username> ... rules ...
  *
@@ -1347,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 keydb.conf, or from the ACL file.
+ * the pending list of users defined in redis.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 KeyDB with users defined in keydb.conf and at "
+            "Configuring Redis with users defined in redis.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 keydb.conf, but not both.");
+            "directly in your redis.conf, but not both.");
         exit(1);
     }
 

src/ae.cpp

@@ -80,11 +80,11 @@ public:
 mutex_wrapper g_lock;
 
 #else
-fastlock g_lock("AE (global)");
+fastlock g_lock;
 #endif
 thread_local aeEventLoop *g_eventLoopThisThread = NULL;
 
-#define AE_ASSERT(x) if (!(x)) do { fprintf(stderr, "AE_ASSERT FAILURE %s: %d\n", __FILE__, __LINE__); *((volatile int*)1) = 1; } while(0)
+#define AE_ASSERT(x) if (!(x)) do { fprintf(stderr, "AE_ASSER FAILURE\n"); *((volatile int*)0) = 1; } while(0)
 
 /* Include the best multiplexing layer supported by this system.
  * The following should be ordered by performances, descending. */
@@ -237,11 +237,11 @@ int aeCreateRemoteFileEvent(aeEventLoop *eventLoop, int fd, int mask,
     cmd.clientData = clientData;
     cmd.pctl = nullptr;
     if (fSynchronous)
-    {
         cmd.pctl = new (MALLOC_LOCAL) aeCommandControl();
-        cmd.pctl->mutexcv.lock();
-    }
 
+    std::unique_lock<std::mutex> ulock(cmd.pctl->mutexcv, std::defer_lock);
+    if (fSynchronous)
+        cmd.pctl->mutexcv.lock();
     auto size = safe_write(eventLoop->fdCmdWrite, &cmd, sizeof(cmd));
     if (size != sizeof(cmd))
     {
@@ -252,7 +252,6 @@ int aeCreateRemoteFileEvent(aeEventLoop *eventLoop, int fd, int mask,
     
     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;
@@ -273,8 +272,7 @@ int aePostFunction(aeEventLoop *eventLoop, aePostFunctionProc *proc, void *arg)
     cmd.proc = proc;
     cmd.clientData = arg;
     auto size = write(eventLoop->fdCmdWrite, &cmd, sizeof(cmd));
-    if (size != sizeof(cmd))
-        return AE_ERR;
+    AE_ASSERT(size == sizeof(cmd));
     return AE_OK;
 }
 
@@ -291,19 +289,15 @@ int aePostFunction(aeEventLoop *eventLoop, std::function<void()> fn, bool fSynch
     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;
@@ -333,7 +327,7 @@ aeEventLoop *aeCreateEventLoop(int setsize) {
     for (i = 0; i < setsize; i++)
         eventLoop->events[i].mask = AE_NONE;
 
-    fastlock_init(&eventLoop->flock, "event loop");
+    fastlock_init(&eventLoop->flock);
     int rgfd[2];
     if (pipe(rgfd) < 0)
         goto err;
@@ -390,18 +384,10 @@ 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) {

src/aof.cpp

@@ -124,21 +124,6 @@ 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);
@@ -180,7 +165,7 @@ void aofRewriteBufferAppend(unsigned char *s, unsigned long len) {
 
     /* Install a file event to send data to the rewrite child if there is
      * not one already. */
-    installAofRewriteEvent();
+    aeCreateRemoteFileEvent(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el, g_pserver->aof_pipe_write_data_to_child, AE_WRITABLE, aofChildWriteDiffData, NULL, FALSE);
 }
 
 /* Write the buffer (possibly composed of multiple blocks) into the specified
@@ -279,7 +264,7 @@ int startAppendOnly(void) {
             strerror(errno));
         return C_ERR;
     }
-    if (g_pserver->rdb_child_pid != -1) {
+    if (g_pserver->FRdbSaveInProgress()) {
         g_pserver->aof_rewrite_scheduled = 1;
         serverLog(LL_WARNING,"AOF was enabled but there is already a child process saving an RDB file on disk. An AOF background was scheduled to start when possible.");
     } else {
@@ -356,9 +341,6 @@ void flushAppendOnlyFile(int force) {
     int sync_in_progress = 0;
     mstime_t latency;
 
-    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
@@ -415,7 +397,7 @@ void flushAppendOnlyFile(int force) {
      * useful for graphing / monitoring purposes. */
     if (sync_in_progress) {
         latencyAddSampleIfNeeded("aof-write-pending-fsync",latency);
-    } else if (g_pserver->aof_child_pid != -1 || g_pserver->rdb_child_pid != -1) {
+    } else if (g_pserver->aof_child_pid != -1 || g_pserver->FRdbSaveInProgress()) {
         latencyAddSampleIfNeeded("aof-write-active-child",latency);
     } else {
         latencyAddSampleIfNeeded("aof-write-alone",latency);
@@ -512,7 +494,7 @@ try_fsync:
     /* Don't fsync if no-appendfsync-on-rewrite is set to yes and there are
      * children doing I/O in the background. */
     if (g_pserver->aof_no_fsync_on_rewrite &&
-        (g_pserver->aof_child_pid != -1 || g_pserver->rdb_child_pid != -1))
+        (g_pserver->aof_child_pid != -1 || g_pserver->FRdbSaveInProgress()))
             return;
 
     /* Perform the fsync if needed. */
@@ -696,7 +678,7 @@ client *createFakeClient(void) {
     c->puser = NULL;
     listSetFreeMethod(c->reply,freeClientReplyValue);
     listSetDupMethod(c->reply,dupClientReplyValue);
-    fastlock_init(&c->lock, "fake client");
+    fastlock_init(&c->lock);
     fastlock_lock(&c->lock);
     initClientMultiState(c);
     return c;
@@ -1318,52 +1300,46 @@ ssize_t aofReadDiffFromParent(void) {
 
 int rewriteAppendOnlyFileRio(rio *aof) {
     dictIterator *di = NULL;
-    dictEntry *de;
     size_t processed = 0;
     int j;
 
     for (j = 0; j < cserver.dbnum; j++) {
         char selectcmd[] = "*2\r\n$6\r\nSELECT\r\n";
         redisDb *db = g_pserver->db+j;
-        dict *d = db->pdict;
-        if (dictSize(d) == 0) continue;
-        di = dictGetSafeIterator(d);
+        if (db->size() == 0) continue;
 
         /* SELECT the new DB */
         if (rioWrite(aof,selectcmd,sizeof(selectcmd)-1) == 0) goto werr;
         if (rioWriteBulkLongLong(aof,j) == 0) goto werr;
 
         /* Iterate this DB writing every entry */
-        while((de = dictNext(di)) != NULL) {
-            sds keystr;
-            robj key, *o;
+        bool fComplete = db->iterate([&](const char *keystr, robj *o)->bool{
+            robj key;
 
-            keystr = (sds)dictGetKey(de);
-            o = (robj*)dictGetVal(de);
-            initStaticStringObject(key,keystr);
+            initStaticStringObject(key,(sds)keystr);
 
-            expireEntry *pexpire = getExpire(db,&key);
+            expireEntry *pexpire = db->getExpire(&key);
 
             /* Save the key and associated value */
             if (o->type == OBJ_STRING) {
                 /* Emit a SET command */
                 char cmd[]="*3\r\n$3\r\nSET\r\n";
-                if (rioWrite(aof,cmd,sizeof(cmd)-1) == 0) goto werr;
+                if (rioWrite(aof,cmd,sizeof(cmd)-1) == 0) return false;
                 /* Key and value */
-                if (rioWriteBulkObject(aof,&key) == 0) goto werr;
-                if (rioWriteBulkObject(aof,o) == 0) goto werr;
+                if (rioWriteBulkObject(aof,&key) == 0) return false;
+                if (rioWriteBulkObject(aof,o) == 0) return false;
             } else if (o->type == OBJ_LIST) {
-                if (rewriteListObject(aof,&key,o) == 0) goto werr;
+                if (rewriteListObject(aof,&key,o) == 0) return false;
             } else if (o->type == OBJ_SET) {
-                if (rewriteSetObject(aof,&key,o) == 0) goto werr;
+                if (rewriteSetObject(aof,&key,o) == 0) return false;
             } else if (o->type == OBJ_ZSET) {
-                if (rewriteSortedSetObject(aof,&key,o) == 0) goto werr;
+                if (rewriteSortedSetObject(aof,&key,o) == 0) return false;
             } else if (o->type == OBJ_HASH) {
-                if (rewriteHashObject(aof,&key,o) == 0) goto werr;
+                if (rewriteHashObject(aof,&key,o) == 0) return false;
             } else if (o->type == OBJ_STREAM) {
-                if (rewriteStreamObject(aof,&key,o) == 0) goto werr;
+                if (rewriteStreamObject(aof,&key,o) == 0) return false;
             } else if (o->type == OBJ_MODULE) {
-                if (rewriteModuleObject(aof,&key,o) == 0) goto werr;
+                if (rewriteModuleObject(aof,&key,o) == 0) return false;
             } else {
                 serverPanic("Unknown object type");
             }
@@ -1373,17 +1349,17 @@ int rewriteAppendOnlyFileRio(rio *aof) {
                     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;
+                        if (rioWrite(aof,cmd,sizeof(cmd)-1) == 0) return false;
+                        if (rioWriteBulkObject(aof,&key) == 0) return false;
                     }
                     else
                     {
                         char cmd[]="*4\r\n$12\r\nEXPIREMEMBER\r\n";
-                        if (rioWrite(aof,cmd,sizeof(cmd)-1) == 0) goto werr;
-                        if (rioWriteBulkObject(aof,&key) == 0) goto werr;
-                        if (rioWrite(aof,subExpire.subkey(),sdslen(subExpire.subkey())) == 0) goto werr;
+                        if (rioWrite(aof,cmd,sizeof(cmd)-1) == 0) return false;
+                        if (rioWriteBulkObject(aof,&key) == 0) return false;
+                        if (rioWrite(aof,subExpire.subkey(),sdslen(subExpire.subkey())) == 0) return false;
                     }
-                    if (rioWriteBulkLongLong(aof,subExpire.when()) == 0) goto werr; // common
+                    if (rioWriteBulkLongLong(aof,subExpire.when()) == 0) return false; // common
                 }
             }
             /* Read some diff from the parent process from time to time. */
@@ -1391,9 +1367,10 @@ int rewriteAppendOnlyFileRio(rio *aof) {
                 processed = aof->processed_bytes;
                 aofReadDiffFromParent();
             }
-        }
-        dictReleaseIterator(di);
-        di = NULL;
+            return true;
+        });
+        if (!fComplete)
+            goto werr;
     }
     return C_OK;
 
@@ -1434,7 +1411,12 @@ int rewriteAppendOnlyFile(char *filename) {
 
     if (g_pserver->aof_use_rdb_preamble) {
         int error;
-        if (rdbSaveRio(&aof,&error,RDB_SAVE_AOF_PREAMBLE,NULL) == C_ERR) {
+        std::vector<redisDbPersistentData*> vecpdb;
+        for (int idb = 0; idb < cserver.dbnum; ++idb)
+        {
+            vecpdb.push_back(&g_pserver->db[idb]);
+        }
+        if (rdbSaveRio(&aof,vecpdb.data(),&error,RDB_SAVE_AOF_PREAMBLE,NULL) == C_ERR) {
             errno = error;
             goto werr;
         }
@@ -1574,19 +1556,16 @@ error:
 
 void aofClosePipes(void) {
     int fdAofAckPipe = g_pserver->aof_pipe_read_ack_from_child;
-    int res = aePostFunction(g_pserver->el_alf_pip_read_ack_from_child, [fdAofAckPipe]{
+    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]{
+    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);
@@ -1614,7 +1593,7 @@ int rewriteAppendOnlyFileBackground(void) {
     pid_t childpid;
     long long start;
 
-    if (g_pserver->aof_child_pid != -1 || g_pserver->rdb_child_pid != -1) return C_ERR;
+    if (g_pserver->aof_child_pid != -1 || g_pserver->FRdbSaveInProgress()) return C_ERR;
     if (aofCreatePipes() != C_OK) return C_ERR;
     openChildInfoPipe();
     start = ustime();
@@ -1673,7 +1652,7 @@ int rewriteAppendOnlyFileBackground(void) {
 void bgrewriteaofCommand(client *c) {
     if (g_pserver->aof_child_pid != -1) {
         addReplyError(c,"Background append only file rewriting already in progress");
-    } else if (g_pserver->rdb_child_pid != -1) {
+    } else if (g_pserver->FRdbSaveInProgress()) {
         g_pserver->aof_rewrite_scheduled = 1;
         addReplyStatus(c,"Background append only file rewriting scheduled");
     } else if (rewriteAppendOnlyFileBackground() == C_OK) {

src/asciilogo.h

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

src/cluster.cpp

@@ -295,15 +295,6 @@ 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:
@@ -626,18 +617,6 @@ 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);
     }
@@ -2160,35 +2139,21 @@ 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);
 
-    // 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();
-
+    nwritten = write(fd, link->sndbuf, sdslen(link->sndbuf));
     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(sndbuf,nwritten,-1);
-    // Restore our send buffer, ensuring any unsent data is first
-    sndbuf = sdscat(sndbuf, link->sndbuf);
-    sdsfree(link->sndbuf);
-    link->sndbuf = sndbuf;
+    sdsrange(link->sndbuf,nwritten,-1);
     if (sdslen(link->sndbuf) == 0)
-        aeDeleteFileEvent(el, link->fd, AE_WRITABLE);
+        aeDeleteFileEvent(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el, link->fd, AE_WRITABLE);
 }
 
 /* Read data. Try to read the first field of the header first to check the
@@ -2263,10 +2228,9 @@ 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)
-        aeCreateRemoteFileEvent(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el,link->fd,AE_WRITABLE|AE_BARRIER,
-                    clusterWriteHandler,link,false);
+        aeCreateFileEvent(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el,link->fd,AE_WRITABLE|AE_BARRIER,
+                    clusterWriteHandler,link);
 
     link->sndbuf = sdscatlen(link->sndbuf, msg, msglen);
 
@@ -3320,7 +3284,7 @@ void clusterHandleSlaveMigration(int max_slaves) {
 void resetManualFailover(void) {
     if (g_pserver->cluster->mf_end && clientsArePaused()) {
         g_pserver->clients_pause_end_time = 0;
-        unpauseClientsIfNecessary();
+        clientsArePaused(); /* Just use the side effect of the function. */
     }
     g_pserver->cluster->mf_end = 0; /* No manual failover in progress. */
     g_pserver->cluster->mf_can_start = 0;
@@ -3946,7 +3910,7 @@ int verifyClusterConfigWithData(void) {
 
     /* Make sure we only have keys in DB0. */
     for (j = 1; j < cserver.dbnum; j++) {
-        if (dictSize(g_pserver->db[j].pdict)) return C_ERR;
+        if (g_pserver->db[j].size()) return C_ERR;
     }
 
     /* Check that all the slots we see populated memory have a corresponding
@@ -4190,76 +4154,57 @@ void clusterReplyMultiBulkSlots(client *c) {
     dictIterator *di = dictGetSafeIterator(g_pserver->cluster->nodes);
     while((de = dictNext(di)) != NULL) {
         clusterNode *node = (clusterNode*)dictGetVal(de);
-        int start = -1;
+        int j = 0, 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 (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;
+        for (j = 0; j < CLUSTER_SLOTS; j++) {
+            int bit, i;
+
+            if ((bit = clusterNodeGetSlotBit(node,j)) != 0) {
+                if (start == -1) start = j;
             }
+            if (start != -1 && (!bit || j == CLUSTER_SLOTS-1)) {
+                int nested_elements = 3; /* slots (2) + master addr (1). */
+                void *nested_replylen = addReplyDeferredLen(c);
 
-            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;
+                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 */
                 }
-                if (start != -1 && (!bit || j == CLUSTER_SLOTS-1)) {
-                    int nested_elements = 3; /* slots (2) + master addr (1). */
-                    void *nested_replylen = addReplyDeferredLen(c);
+                start = -1;
 
-                    if (bit && j == CLUSTER_SLOTS-1) j++;
+                /* 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 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 */
+                /* 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->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++;
+                    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++;
             }
         }
-        serverAssert(start == -1);
     }
-    
     dictReleaseIterator(di);
     setDeferredArrayLen(c, slot_replylen, num_masters);
 }
@@ -4341,7 +4286,7 @@ NULL
         clusterReplyMultiBulkSlots(c);
     } else if (!strcasecmp(szFromObj(c->argv[1]),"flushslots") && c->argc == 2) {
         /* CLUSTER FLUSHSLOTS */
-        if (dictSize(g_pserver->db[0].pdict) != 0) {
+        if (g_pserver->db[0].size() != 0) {
             addReplyError(c,"DB must be empty to perform CLUSTER FLUSHSLOTS.");
             return;
         }
@@ -4676,7 +4621,7 @@ NULL
          * slots nor keys to accept to replicate some other node.
          * Slaves can switch to another master without issues. */
         if (nodeIsMaster(myself) &&
-            (myself->numslots != 0 || dictSize(g_pserver->db[0].pdict) != 0)) {
+            (myself->numslots != 0 || g_pserver->db[0].size() != 0)) {
             addReplyError(c,
                 "To set a master the node must be empty and "
                 "without assigned slots.");
@@ -4833,7 +4778,7 @@ NULL
 
         /* Slaves can be reset while containing data, but not master nodes
          * that must be empty. */
-        if (nodeIsMaster(myself) && dictSize(c->db->pdict) != 0) {
+        if (nodeIsMaster(myself) && c->db->size() != 0) {
             addReplyError(c,"CLUSTER RESET can't be called with "
                             "master nodes containing keys");
             return;
@@ -4849,6 +4794,7 @@ NULL
 /* -----------------------------------------------------------------------------
  * DUMP, RESTORE and MIGRATE commands
  * -------------------------------------------------------------------------- */
+ssize_t rdbSaveAuxFieldStrStr(rio *rdb, const char *key, const char *val);
 
 /* Generates a DUMP-format representation of the object 'o', adding it to the
  * io stream pointed by 'rio'. This function can't fail. */
@@ -4861,6 +4807,9 @@ void createDumpPayload(rio *payload, robj_roptr o, robj *key) {
     rioInitWithBuffer(payload,sdsempty());
     serverAssert(rdbSaveObjectType(payload,o));
     serverAssert(rdbSaveObject(payload,o,key));
+    char szT[32];
+    snprintf(szT, 32, "%" PRIu64, o->mvcc_tstamp);
+    serverAssert(rdbSaveAuxFieldStrStr(payload,"mvcc-tstamp", szT) != -1);
 
     /* Write the footer, this is how it looks like:
      * ----------------+---------------------+---------------+
@@ -4996,6 +4945,21 @@ void restoreCommand(client *c) {
         addReplyError(c,"Bad data format");
         return;
     }
+    if (rdbLoadType(&payload) == RDB_OPCODE_AUX)
+    {
+        robj *auxkey, *auxval;
+        if ((auxkey = rdbLoadStringObject(&payload)) == NULL) goto eoferr;
+        if ((auxval = rdbLoadStringObject(&payload)) == NULL) {
+            decrRefCount(auxkey);
+            goto eoferr;
+        }
+        if (strcasecmp(szFromObj(auxkey), "mvcc-tstamp") == 0) {
+            obj->mvcc_tstamp = strtoull(szFromObj(auxval), nullptr, 10);
+        }
+        decrRefCount(auxkey);
+        decrRefCount(auxval);
+    }
+eoferr:
 
     /* Remove the old key if needed. */
     if (replace) dbDelete(c->db,c->argv[1]);
@@ -5249,7 +5213,7 @@ try_again:
     /* Create RESTORE payload and generate the protocol to call the command. */
     for (j = 0; j < num_keys; j++) {
         long long ttl = 0;
-        expireEntry *pexpire = getExpire(c->db,kv[j]);
+        expireEntry *pexpire = c->db->getExpire(kv[j]);
         long long expireat = -1;
         if (pexpire != nullptr)
             pexpire->FGetPrimaryExpire(&expireat);

src/compactvector.h

@@ -30,7 +30,16 @@ public:
         zfree(m_data);
     }
 
-    compactvector(compactvector &) noexcept = delete;
+    compactvector(const compactvector &src)
+    {
+        m_celem = src.m_celem;
+        m_max = src.m_max;
+        m_data = (T*)zmalloc(sizeof(T) * m_max, MALLOC_LOCAL);
+        for (size_t ielem = 0; ielem < m_celem; ++ielem)
+        {
+            new (m_data+ielem) T(src[ielem]);
+        }
+    }
 
     compactvector(compactvector &&src) noexcept
     {
@@ -42,7 +51,6 @@ public:
         src.m_max = 0;
     }
 
-    compactvector &operator=(const compactvector&) noexcept = delete;
     compactvector &operator=(compactvector &&src) noexcept
     {
         zfree(m_data);

src/config.cpp

@@ -405,7 +405,7 @@ void loadServerConfigFromString(char *config) {
         } else if ((!strcasecmp(argv[0],"slaveof") ||
                     !strcasecmp(argv[0],"replicaof")) && argc == 3) {
             slaveof_linenum = linenum;
-            replicationAddMaster(argv[1], atoi(argv[2]));
+            replicationAddMaster(sdsnew(argv[1]), atoi(argv[2]));
         } else if ((!strcasecmp(argv[0],"repl-ping-slave-period") ||
                     !strcasecmp(argv[0],"repl-ping-replica-period")) &&
                     argc == 2)
@@ -802,14 +802,6 @@ void loadServerConfigFromString(char *config) {
             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;
         }
@@ -1496,15 +1488,8 @@ 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);
@@ -1742,7 +1727,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 keydb.conf. If possible uses the GB, MB, KB notation. */
+ * inside redis.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;
@@ -1905,7 +1890,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 keydb.conf. */
+    * we don't want a slaveof directive inside redis.conf. */
     if (g_pserver->cluster_enabled || listLength(g_pserver->masters) == 0) {
         rewriteConfigMarkAsProcessed(state,option);
         return;

src/cron.cpp

@@ -1,135 +0,0 @@
-#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

@@ -1,16 +0,0 @@
-#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

@@ -41,7 +41,6 @@
 
 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.
@@ -57,8 +56,7 @@ 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());
+    serverAssert(db->FKeyExpires((const char*)key));
     
     valNew->SetFExpires(true);
     valOld->SetFExpires(false);
@@ -70,14 +68,13 @@ void updateExpire(redisDb *db, sds key, robj *valOld, robj *valNew)
  * implementations that should instead rely on lookupKeyRead(),
  * lookupKeyWrite() and lookupKeyReadWithFlags(). */
 static robj *lookupKey(redisDb *db, robj *key, int flags) {
-    dictEntry *de = dictFind(db->pdict,ptrFromObj(key));
-    if (de) {
-        robj *val = (robj*)dictGetVal(de);
-
+    auto itr = db->find(key);
+    if (itr) {
+        robj *val = itr.val();
         /* Update the access time for the ageing algorithm.
          * Don't do it if we have a saving child, as this will trigger
          * a copy on write madness. */
-        if (g_pserver->rdb_child_pid == -1 &&
+        if (!g_pserver->FRdbSaveInProgress() &&
             g_pserver->aof_child_pid == -1 &&
             !(flags & LOOKUP_NOTOUCH))
         {
@@ -90,6 +87,7 @@ static robj *lookupKey(redisDb *db, robj *key, int flags) {
 
         if (flags & LOOKUP_UPDATEMVCC) {
             val->mvcc_tstamp = getMvccTstamp();
+            db->trackkey(key);
         }
         return val;
     } else {
@@ -177,8 +175,9 @@ robj_roptr lookupKeyRead(redisDb *db, robj *key) {
  * Returns the linked value object if the key exists or NULL if the key
  * does not exist in the specified DB. */
 robj *lookupKeyWrite(redisDb *db, robj *key) {
-    expireIfNeeded(db,key);
     robj *o = lookupKey(db,key,LOOKUP_UPDATEMVCC);
+    if (expireIfNeeded(db,key))
+        o = NULL;
     return o;
 }
 
@@ -194,13 +193,14 @@ robj *lookupKeyWriteOrReply(client *c, robj *key, robj *reply) {
     return o;
 }
 
-int dbAddCore(redisDb *db, robj *key, robj *val) {
+bool 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();
+    bool fInserted = db->insert(copy, val);
+    if (g_pserver->fActiveReplica)
+        val->mvcc_tstamp = key->mvcc_tstamp = getMvccTstamp();
 
-    if (retval == DICT_OK)
+    if (fInserted)
     {
         if (val->type == OBJ_LIST ||
             val->type == OBJ_ZSET)
@@ -212,7 +212,7 @@ int dbAddCore(redisDb *db, robj *key, robj *val) {
         sdsfree(copy);
     }
 
-    return retval;
+    return fInserted;
 }
 
 /* Add the key to the DB. It's up to the caller to increment the reference
@@ -221,23 +221,22 @@ int dbAddCore(redisDb *db, robj *key, robj *val) {
  * The program is aborted if the key already exists. */
 void dbAdd(redisDb *db, robj *key, robj *val)
 {
-    int retval = dbAddCore(db, key, val);
-    serverAssertWithInfo(NULL,key,retval == DICT_OK);
+    bool fInserted = dbAddCore(db, key, val);
+    serverAssertWithInfo(NULL,key,fInserted);
 }
 
-void dbOverwriteCore(redisDb *db, dictEntry *de, robj *key, robj *val, bool fUpdateMvcc, bool fRemoveExpire)
+void redisDb::dbOverwriteCore(redisDb::iter itr, robj *key, robj *val, bool fUpdateMvcc, bool fRemoveExpire)
 {
-    dictEntry auxentry = *de;
-    robj *old = (robj*)dictGetVal(de);
+    robj *old = itr.val();
 
     if (old->FExpires()) {
         if (fRemoveExpire) {
-            removeExpire(db, key);
+            ::removeExpire(this, key);
         }
         else {
             if (val->getrefcount(std::memory_order_relaxed) == OBJ_SHARED_REFCOUNT)
                 val = dupStringObject(val);
-            updateExpire(db, (sds)dictGetKey(de), old, val);
+            ::updateExpire(this, itr.key(), old, val);
         }
     }
 
@@ -250,14 +249,12 @@ void dbOverwriteCore(redisDb *db, dictEntry *de, robj *key, robj *val, bool fUpd
         val->mvcc_tstamp = getMvccTstamp();
     }
 
-    dictSetVal(db->pdict, de, val);
+    if (g_pserver->lazyfree_lazy_server_del)
+        freeObjAsync(itr.val());
+    else
+        decrRefCount(itr.val());
 
-    if (g_pserver->lazyfree_lazy_server_del) {
-        freeObjAsync(old);
-        dictSetVal(db->pdict, &auxentry, NULL);
-    }
-
-    dictFreeVal(db->pdict, &auxentry);
+    updateValue(itr, val);
 }
 
 /* Overwrite an existing key with a new value. Incrementing the reference
@@ -266,10 +263,10 @@ void dbOverwriteCore(redisDb *db, dictEntry *de, robj *key, robj *val, bool fUpd
  *
  * The program is aborted if the key was not already present. */
 void dbOverwrite(redisDb *db, robj *key, robj *val) {
-    dictEntry *de = dictFind(db->pdict,ptrFromObj(key));
+    auto itr = db->find(key);
 
-    serverAssertWithInfo(NULL,key,de != NULL);
-    dbOverwriteCore(db, de, key, val, !!g_pserver->fActiveReplica, false);
+    serverAssertWithInfo(NULL,key,itr != nullptr);
+    db->dbOverwriteCore(itr, key, val, !!g_pserver->fActiveReplica, false);
 }
 
 /* Insert a key, handling duplicate keys according to fReplace */
@@ -277,14 +274,14 @@ int dbMerge(redisDb *db, robj *key, robj *val, int fReplace)
 {
     if (fReplace)
     {
-        dictEntry *de = dictFind(db->pdict, ptrFromObj(key));
-        if (de == nullptr)
-            return (dbAddCore(db, key, val) == DICT_OK);
+        auto itr = db->find(key);
+        if (itr == nullptr)
+            return (dbAddCore(db, key, val) == true);
 
-        robj *old = (robj*)dictGetVal(de);
+        robj *old = itr.val();
         if (old->mvcc_tstamp <= val->mvcc_tstamp)
         {
-            dbOverwriteCore(db, de, key, val, false, true);
+            db->dbOverwriteCore(itr, key, val, false, true);
             return true;
         }
         
@@ -292,7 +289,7 @@ int dbMerge(redisDb *db, robj *key, robj *val, int fReplace)
     }
     else
     {
-        return (dbAddCore(db, key, val) == DICT_OK);
+        return (dbAddCore(db, key, val) == true);
     }
 }
 
@@ -305,18 +302,18 @@ 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) {
-    dictEntry *de = dictFind(db->pdict, ptrFromObj(key));
-    if (de == NULL) {
+    auto itr = db->find(key);
+    if (itr == NULL) {
         dbAdd(db,key,val);
     } else {
-        dbOverwriteCore(db,de,key,val,!!g_pserver->fActiveReplica,true);
+        db->dbOverwriteCore(itr,key,val,!!g_pserver->fActiveReplica,true);
     }
     incrRefCount(val);
     signalModifiedKey(db,key);
 }
 
 int dbExists(redisDb *db, robj *key) {
-    return dictFind(db->pdict,ptrFromObj(key)) != NULL;
+    return (db->find(key) != nullptr);
 }
 
 /* Return a random key, in form of a Redis object.
@@ -324,21 +321,20 @@ int dbExists(redisDb *db, robj *key) {
  *
  * The function makes sure to return keys not already expired. */
 robj *dbRandomKey(redisDb *db) {
-    dictEntry *de;
     int maxtries = 100;
-    int allvolatile = dictSize(db->pdict) == db->setexpire->size();
+    bool allvolatile = db->expireSize() == db->size();
 
     while(1) {
         sds key;
         robj *keyobj;
 
-        de = dictGetRandomKey(db->pdict);
-        if (de == NULL) return NULL;
+        auto itr = db->random();
+        if (itr == nullptr) return NULL;
 
-        key = (sds)dictGetKey(de);
+        key = itr.key();
         keyobj = createStringObject(key,sdslen(key));
 
-        if (((robj*)dictGetVal(de))->FExpires())
+        if (itr.val()->FExpires())
         {
             if (allvolatile && listLength(g_pserver->masters) && --maxtries == 0) {
                 /* If the DB is composed only of keys with an expire set,
@@ -353,7 +349,7 @@ robj *dbRandomKey(redisDb *db) {
             }
         }
             
-        if (((robj*)dictGetVal(de))->FExpires())
+        if (itr.val()->FExpires())
         {
              if (expireIfNeeded(db,keyobj)) {
                 decrRefCount(keyobj);
@@ -365,15 +361,16 @@ robj *dbRandomKey(redisDb *db) {
     }
 }
 
-/* Delete a key, value, and associated expiration entry if any, from the DB */
-int dbSyncDelete(redisDb *db, robj *key) {
+bool redisDbPersistentData::syncDelete(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. */
 
-    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) {
+    auto itr = find(szFromObj(key));
+    trackkey(szFromObj(key));
+    if (itr != nullptr && itr.val()->FExpires())
+        removeExpire(key, itr);
+    if (dictDelete(m_pdict,ptrFromObj(key)) == DICT_OK) {
         if (g_pserver->cluster_enabled) slotToKeyDel(key);
         return 1;
     } else {
@@ -381,6 +378,11 @@ int dbSyncDelete(redisDb *db, robj *key) {
     }
 }
 
+/* Delete a key, value, and associated expiration entry if any, from the DB */
+int dbSyncDelete(redisDb *db, robj *key) {
+    return db->syncDelete(key);
+}
+
 /* This is a wrapper whose behavior depends on the Redis lazy free
  * configuration. Deletes the key synchronously or asynchronously. */
 int dbDelete(redisDb *db, robj *key) {
@@ -426,7 +428,7 @@ robj *dbUnshareStringValue(redisDb *db, robj *key, robj *o) {
     return o;
 }
 
-/* Remove all keys from all the databases in a Redis g_pserver->
+/* Remove all keys from all the databases in a Redis DB
  * If callback is given the function is called from time to time to
  * signal that work is in progress.
  *
@@ -458,15 +460,7 @@ long long emptyDb(int dbnum, int flags, void(callback)(void*)) {
     }
 
     for (int j = startdb; j <= enddb; j++) {
-        removed += dictSize(g_pserver->db[j].pdict);
-        if (async) {
-            emptyDbAsync(&g_pserver->db[j]);
-        } else {
-            dictEmpty(g_pserver->db[j].pdict,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();
-        }
+        removed += g_pserver->db[j].clear(!!async, callback); 
     }
     if (g_pserver->cluster_enabled) {
         if (async) {
@@ -552,14 +546,14 @@ void flushallCommand(client *c) {
     signalFlushedDb(-1);
     g_pserver->dirty += emptyDb(-1,flags,NULL);
     addReply(c,shared.ok);
-    if (g_pserver->rdb_child_pid != -1) killRDBChild();
+    if (g_pserver->FRdbSaveInProgress()) killRDBChild();
     if (g_pserver->saveparamslen > 0) {
         /* Normally rdbSave() will reset dirty, but we don't want this here
          * as otherwise FLUSHALL will not be replicated nor put into the AOF. */
         int saved_dirty = g_pserver->dirty;
         rdbSaveInfo rsi, *rsiptr;
         rsiptr = rdbPopulateSaveInfo(&rsi);
-        rdbSave(rsiptr);
+        rdbSave(nullptr, rsiptr);
         g_pserver->dirty = saved_dirty;
     }
     g_pserver->dirty++;
@@ -634,18 +628,35 @@ void randomkeyCommand(client *c) {
     decrRefCount(key);
 }
 
+
+bool redisDbPersistentData::iterate(std::function<bool(const char*, robj*)> fn)
+{
+    dictIterator *di = dictGetSafeIterator(m_pdict);
+    dictEntry *de = nullptr;
+    bool fResult = true;
+    while((de = dictNext(di)) != nullptr)
+    {
+        ensure(de);
+        if (!fn((const char*)dictGetKey(de), (robj*)dictGetVal(de)))
+        {
+            fResult = false;
+            break;
+        }
+    }
+    dictReleaseIterator(di);
+    return fResult;
+}
+
 void keysCommand(client *c) {
-    dictIterator *di;
-    dictEntry *de;
     sds pattern = szFromObj(c->argv[1]);
     int plen = sdslen(pattern), allkeys;
     unsigned long numkeys = 0;
     void *replylen = addReplyDeferredLen(c);
 
-    di = dictGetSafeIterator(c->db->pdict);
+    aeReleaseLock();
+
     allkeys = (pattern[0] == '*' && pattern[1] == '\0');
-    while((de = dictNext(di)) != NULL) {
-        sds key = (sds)dictGetKey(de);
+    c->db->iterate([&](const char *key, robj *)->bool {
         robj *keyobj;
 
         if (allkeys || stringmatchlen(pattern,plen,key,sdslen(key),0)) {
@@ -656,9 +667,15 @@ void keysCommand(client *c) {
             }
             decrRefCount(keyobj);
         }
-    }
-    dictReleaseIterator(di);
+        return true;
+    });
     setDeferredArrayLen(c,replylen,numkeys);
+    
+    fastlock_unlock(&c->db->lock);  // we must release the DB lock before acquiring the AE lock to prevent deadlocks
+    AeLocker lock;
+    lock.arm(c);
+    fastlock_lock(&c->db->lock);    // we still need the DB lock
+    lock.release();
 }
 
 /* This callback is used by scanGenericCommand in order to collect elements
@@ -786,7 +803,7 @@ void scanGenericCommand(client *c, robj_roptr o, unsigned long cursor) {
     /* Handle the case of a hash table. */
     ht = NULL;
     if (o == nullptr) {
-        ht = c->db->pdict;
+        ht = c->db->dictUnsafeKeyOnly();
     } else if (o->type == OBJ_SET && o->encoding == OBJ_ENCODING_HT) {
         ht = (dict*)ptrFromObj(o);
     } else if (o->type == OBJ_HASH && o->encoding == OBJ_ENCODING_HT) {
@@ -919,7 +936,7 @@ void scanCommand(client *c) {
 }
 
 void dbsizeCommand(client *c) {
-    addReplyLongLong(c,dictSize(c->db->pdict));
+    addReplyLongLong(c,c->db->size());
 }
 
 void lastsaveCommand(client *c) {
@@ -977,7 +994,7 @@ 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) throw ShutdownException();
+    if (prepareForShutdown(flags) == C_OK) exit(0);
     addReplyError(c,"Errors trying to SHUTDOWN. Check logs.");
 }
 
@@ -1002,7 +1019,7 @@ void renameGenericCommand(client *c, int nx) {
     std::unique_ptr<expireEntry> spexpire;
 
     {   // scope pexpireOld since it will be invalid soon
-    expireEntry *pexpireOld = getExpire(c->db,c->argv[1]);
+    expireEntry *pexpireOld = c->db->getExpire(c->argv[1]);
     if (pexpireOld != nullptr)
         spexpire = std::make_unique<expireEntry>(std::move(*pexpireOld));
     }
@@ -1080,7 +1097,7 @@ void moveCommand(client *c) {
 
     std::unique_ptr<expireEntry> spexpire;
     {   // scope pexpireOld
-    expireEntry *pexpireOld = getExpire(c->db,c->argv[1]);
+    expireEntry *pexpireOld = c->db->getExpire(c->argv[1]);
     if (pexpireOld != nullptr)
         spexpire = std::make_unique<expireEntry>(std::move(*pexpireOld));
     }
@@ -1139,17 +1156,14 @@ int dbSwapDatabases(int id1, int 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->setexpire = db2->setexpire;
-    db1->expireitr = db2->expireitr;
+    redisDbPersistentData::swap(db1, db2);
     db1->avg_ttl = db2->avg_ttl;
     db1->last_expire_set = db2->last_expire_set;
+    db1->expireitr = db2->expireitr;
 
-    db2->pdict = aux.pdict;
-    db2->setexpire = aux.setexpire;
-    db2->expireitr = aux.expireitr;
     db2->avg_ttl = aux.avg_ttl;
     db2->last_expire_set = aux.last_expire_set;
+    db2->expireitr = aux.expireitr;
 
     /* Now we need to handle clients blocked on lists: as an effect
      * of swapping the two DBs, a client that was waiting for list
@@ -1198,37 +1212,38 @@ void swapdbCommand(client *c) {
  * Expires API
  *----------------------------------------------------------------------------*/
 int removeExpire(redisDb *db, robj *key) {
-    dictEntry *de = dictFind(db->pdict,ptrFromObj(key));
-    return removeExpireCore(db, key, de);
+    auto itr = db->find(key);
+    return db->removeExpire(key, itr);
 }
-int removeExpireCore(redisDb *db, robj *key, dictEntry *de) {
+int redisDbPersistentData::removeExpire(robj *key, dict_iter itr) {
     /* 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,de != NULL);
+    serverAssertWithInfo(NULL,key,itr != nullptr);
 
-    robj *val = (robj*)dictGetVal(de);
+    robj *val = itr.val();
     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);
+    trackkey(key);
+    auto itrExpire = m_setexpire->find(itr.key());
+    serverAssert(itrExpire != m_setexpire->end());
+    serverAssert(itrExpire->key() == itr.key());
+    m_setexpire->erase(itrExpire);
     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);
+int redisDbPersistentData::removeSubkeyExpire(robj *key, robj *subkey) {
+    auto de = find(szFromObj(key));
+    serverAssertWithInfo(NULL,key,de != nullptr);
     
-    robj *val = (robj*)dictGetVal(de);
+    robj *val = de.val();
     if (!val->FExpires())
         return 0;
     
-    auto itr = db->setexpire->find((sds)dictGetKey(de));
-    serverAssert(itr != db->setexpire->end());
-    serverAssert(itr->key() == (sds)dictGetKey(de));
+    auto itr = m_setexpire->find(de.key());
+    serverAssert(itr != m_setexpire->end());
+    serverAssert(itr->key() == de.key());
     if (!itr->FFat())
         return 0;
 
@@ -1246,7 +1261,7 @@ int removeSubkeyExpire(redisDb *db, robj *key, robj *subkey) {
     }
 
     if (itr->pfatentry()->size() == 0)
-        removeExpireCore(db, key, de);
+        this->removeExpire(key, de);
 
     return found;
 }
@@ -1256,85 +1271,49 @@ int removeSubkeyExpire(redisDb *db, robj *key, robj *subkey) {
  * 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, 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);
-
-    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())
+    if (db->expireSize() == 0)
         db->avg_ttl = 0;
     else
-        db->avg_ttl -= db->avg_ttl / db->setexpire->size(); // slide one entry out the window
+        db->avg_ttl -= db->avg_ttl / db->expireSize(); // 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->avg_ttl += (double)(when-now) / (db->expireSize()+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);
-    }
+    db->setExpire(key, subkey, when);
 
     int writable_slave = listLength(g_pserver->masters) && g_pserver->repl_slave_ro == 0;
     if (c && writable_slave && !(c->flags & CLIENT_MASTER))
         rememberSlaveKeyWithExpire(db,key);
 }
 
-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));
+    auto kde = db->find(key);
     serverAssertWithInfo(NULL,key,kde != NULL);
 
-    if (((robj*)dictGetVal(kde))->getrefcount(std::memory_order_relaxed) == OBJ_SHARED_REFCOUNT)
+    if (kde.val()->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)));
+        db->updateValue(kde, dupStringObject(kde.val()));
     }
 
-    if (((robj*)dictGetVal(kde))->FExpires())
+    if (kde.val()->FExpires())
         removeExpire(db, key);
 
-    e.setKeyUnsafe((sds)dictGetKey(kde));
-    db->setexpire->insert(e);
-    ((robj*)dictGetVal(kde))->SetFExpires(true);
+    e.setKeyUnsafe(kde.key());
+    db->setExpire(std::move(e));
+    kde.val()->SetFExpires(true);
 
 
     int writable_slave = listLength(g_pserver->masters) && g_pserver->repl_slave_ro == 0;
@@ -1344,22 +1323,19 @@ void setExpire(client *c, redisDb *db, robj *key, expireEntry &&e)
 
 /* 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) */
-expireEntry *getExpire(redisDb *db, robj_roptr key) {
-    dictEntry *de;
-
+expireEntry *redisDbPersistentData::getExpire(robj_roptr key) {
     /* No expire? return ASAP */
-    if (db->setexpire->size() == 0)
+    if (expireSize() == 0)
         return nullptr;
 
-    de = dictFind(db->pdict, ptrFromObj(key));
-    if (de == NULL)
+    auto itr = find(szFromObj(key));
+    if (itr == nullptr)
         return nullptr;
-    robj *obj = (robj*)dictGetVal(de);
-    if (!obj->FExpires())
+    if (!itr.val()->FExpires())
         return nullptr;
 
-    auto itr = db->setexpire->find((sds)dictGetKey(de));
-    return itr.operator->();
+    auto itrExpire = findExpire(itr.key());
+    return itrExpire.operator->();
 }
 
 /* Propagate expires into slaves and the AOF file.
@@ -1381,9 +1357,7 @@ void propagateExpire(redisDb *db, robj *key, int lazy) {
 
     if (g_pserver->aof_state != AOF_OFF)
         feedAppendOnlyFile(cserver.delCommand,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);
+    replicationFeedSlaves(g_pserver->slaves,db->id,argv,2);
 
     decrRefCount(argv[0]);
     decrRefCount(argv[1]);
@@ -1391,7 +1365,7 @@ void propagateExpire(redisDb *db, robj *key, int lazy) {
 
 /* Check if the key is expired. Note, this does not check subexpires */
 int keyIsExpired(redisDb *db, robj *key) {
-    expireEntry *pexpire = getExpire(db,key);
+    expireEntry *pexpire = db->getExpire(key);
 
     if (pexpire == nullptr) return 0; /* No expire for this key */
 
@@ -1451,7 +1425,7 @@ int expireIfNeeded(redisDb *db, robj *key) {
      * 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) && !g_pserver->fActiveReplica) return 1;
+    if (listLength(g_pserver->masters)) return 1;
 
     /* Delete the key */
     g_pserver->stat_expiredkeys++;
@@ -1823,3 +1797,304 @@ unsigned int delKeysInSlot(unsigned int hashslot) {
 unsigned int countKeysInSlot(unsigned int hashslot) {
     return g_pserver->cluster->slots_keys_count[hashslot];
 }
+
+void redisDbPersistentData::initialize()
+{
+    m_pdict = dictCreate(&dbDictType,this);
+    m_setexpire = new(MALLOC_LOCAL) expireset();
+    m_fAllChanged = false;
+    m_fTrackingChanges = 0;
+}
+
+void redisDb::initialize(int id)
+{
+    redisDbPersistentData::initialize();
+    this->expireitr = setexpire()->end();
+    this->blocking_keys = dictCreate(&keylistDictType,NULL);
+    this->ready_keys = dictCreate(&objectKeyPointerValueDictType,NULL);
+    this->watched_keys = dictCreate(&keylistDictType,NULL);
+    this->id = id;
+    this->avg_ttl = 0;
+    this->last_expire_set = 0;
+    this->defrag_later = listCreate();
+}
+
+bool redisDbPersistentData::insert(char *key, robj *o)
+{
+    int res = dictAdd(m_pdict, key, o);
+    if (res == DICT_OK)
+        trackkey(key);
+    return (res == DICT_OK);
+}
+
+void redisDbPersistentData::tryResize()
+{
+    if (htNeedsResize(m_pdict))
+        dictResize(m_pdict);
+}
+
+size_t redisDb::clear(bool fAsync, void(callback)(void*))
+{
+    size_t removed = size();
+    if (fAsync) {
+        redisDbPersistentData::emptyDbAsync();
+    } else {
+        redisDbPersistentData::clear(callback);
+    }
+    expireitr = setexpire()->end();
+    return removed;
+}
+
+void redisDbPersistentData::clear(void(callback)(void*))
+{
+    dictEmpty(m_pdict,callback);
+    if (m_fTrackingChanges)
+        m_fAllChanged = true;
+    delete m_setexpire;
+    m_setexpire = new (MALLOC_LOCAL) expireset();
+    if (m_pstorage != nullptr)
+        m_pstorage->clear();
+}
+
+/* static */ void redisDbPersistentData::swap(redisDbPersistentData *db1, redisDbPersistentData *db2)
+{
+    redisDbPersistentData aux = *db1;
+    db1->m_pdict = db2->m_pdict;
+    db1->m_fTrackingChanges = db2->m_fTrackingChanges;
+    db1->m_fAllChanged = db2->m_fAllChanged;
+    db1->m_setexpire = db2->m_setexpire;
+    db1->m_pstorage = db2->m_pstorage;
+    db1->m_spdbSnapshot = db2->m_spdbSnapshot;
+
+    db2->m_pdict = aux.m_pdict;
+    db2->m_fTrackingChanges = aux.m_fTrackingChanges;
+    db2->m_fAllChanged = aux.m_fAllChanged;
+    db2->m_setexpire = aux.m_setexpire;
+    db2->m_pstorage = aux.m_pstorage;
+    db2->m_spdbSnapshot = aux.m_spdbSnapshot;
+
+    db1->m_pdict->privdata = static_cast<redisDbPersistentData*>(db1);
+    db2->m_pdict->privdata = static_cast<redisDbPersistentData*>(db2);
+}
+
+void redisDbPersistentData::setExpire(robj *key, robj *subkey, long long when)
+{
+    /* Reuse the sds from the main dict in the expire dict */
+    dictEntry *kde = dictFind(m_pdict,ptrFromObj(key));
+    serverAssertWithInfo(NULL,key,kde != NULL);
+    trackkey(key);
+
+    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(m_pdict, kde, dupStringObject((robj*)dictGetVal(kde)));
+    }
+
+    const char *szSubKey = (subkey != nullptr) ? szFromObj(subkey) : nullptr;
+    if (((robj*)dictGetVal(kde))->FExpires()) {
+        auto itr = m_setexpire->find((sds)dictGetKey(kde));
+        serverAssert(itr != m_setexpire->end());
+        expireEntry eNew(std::move(*itr));
+        eNew.update(szSubKey, when);
+        m_setexpire->erase(itr);
+        m_setexpire->insert(eNew);
+    }
+    else
+    {
+        expireEntry e((sds)dictGetKey(kde), szSubKey, when);
+        ((robj*)dictGetVal(kde))->SetFExpires(true);
+        m_setexpire->insert(e);
+    }
+}
+
+void redisDbPersistentData::setExpire(expireEntry &&e)
+{
+    trackkey(e.key());
+    m_setexpire->insert(e);
+}
+
+bool redisDb::FKeyExpires(const char *key)
+{
+    return setexpireUnsafe()->find(key) != setexpire()->end();
+}
+
+void redisDbPersistentData::updateValue(dict_iter itr, robj *val)
+{
+    trackkey(itr.key());
+    dictSetVal(m_pdict, itr.de, val);
+}
+
+void redisDbPersistentData::ensure(const char *key)
+{
+    dictEntry *de = dictFind(m_pdict, key);
+    ensure(de);
+}
+
+void redisDbPersistentData::ensure(dictEntry *de)
+{
+    if (de != nullptr && dictGetVal(de) == nullptr)
+    {
+        if (m_spdbSnapshot != nullptr)
+        {
+            auto itr = m_spdbSnapshot->find((const char*)dictGetKey(de));
+            serverAssert(itr != m_spdbSnapshot->end());
+            if (itr.val()->getrefcount(std::memory_order_relaxed) == OBJ_SHARED_REFCOUNT)
+            {
+                dictSetVal(m_pdict, de, itr.val());
+            }
+            else
+            {
+                sds strT = serializeStoredObject(itr.val());
+                robj *objNew = deserializeStoredObject(strT, sdslen(strT));
+                sdsfree(strT);
+                dictSetVal(m_pdict, de, objNew);
+                serverAssert(objNew->getrefcount(std::memory_order_relaxed) == 1);
+                serverAssert(objNew->mvcc_tstamp == itr.val()->mvcc_tstamp);
+            }
+        }
+        else
+        {
+            serverAssert(m_pstorage != nullptr);
+            sds key = (sds)dictGetKey(de);
+            m_pstorage->retrieve(key, sdslen(key), true, [&](const char *, size_t, const void *data, size_t cb){
+                robj *o = deserializeStoredObject(data, cb);
+                serverAssert(o != nullptr);
+                dictSetVal(m_pdict, de, o);
+            });
+        }
+    }
+}
+
+void redisDbPersistentData::storeKey(const char *szKey, size_t cchKey, robj *o)
+{
+    sds temp = serializeStoredObject(o);
+    m_pstorage->insert(szKey, cchKey, temp, sdslen(temp));
+    sdsfree(temp);
+}
+
+void redisDbPersistentData::storeDatabase()
+{
+    dictIterator *di = dictGetIterator(m_pdict);
+    dictEntry *de;
+    while ((de = dictNext(di)) != NULL) {
+        sds key = (sds)dictGetKey(de);
+        robj *o = (robj*)dictGetVal(de);
+        storeKey(key, sdslen(key), o);
+    }
+    dictReleaseIterator(di);
+}
+
+void redisDbPersistentData::processChanges()
+{
+    --m_fTrackingChanges;
+    serverAssert(m_fTrackingChanges >= 0);
+
+    if (m_pstorage != nullptr)
+    {
+        if (m_fTrackingChanges == 0)
+        {
+            if (m_fAllChanged)
+            {
+                m_pstorage->clear();
+                storeDatabase();
+            }
+            else
+            {
+                for (auto &str : m_setchanged)
+                {
+                    sds sdsKey = sdsnewlen(str.data(), str.size());
+                    robj *o = find(sdsKey);
+                    if (o != nullptr)
+                    {
+                        storeKey(str.data(), str.size(), o);
+                    }
+                    else
+                    {
+                        m_pstorage->erase(str.data(), str.size());
+                    }
+                    sdsfree(sdsKey);
+                }
+            }
+        }
+    }
+    m_setchanged.clear();
+}
+
+std::shared_ptr<redisDbPersistentData> redisDbPersistentData::createSnapshot()
+{
+    serverAssert(GlobalLocksAcquired());
+    serverAssert(m_spdbSnapshot == nullptr);
+    auto spdb = std::make_shared<redisDbPersistentData>();
+    spdb->m_pdict = dictCreate(&dbDictType,spdb.get());
+    spdb->m_fAllChanged = false;
+    spdb->m_fTrackingChanges = 0;
+    spdb->m_pdict->rehashidx = m_pdict->rehashidx;
+    spdb->m_pdict->iterators++; // fake an iterator so it doesn't rehash
+    if (m_setexpire != nullptr)
+        spdb->m_setexpire = new (MALLOC_LOCAL) expireset(*m_setexpire);
+
+    for (unsigned iht = 0; iht < 2; ++iht)
+    {
+        spdb->m_pdict->ht[iht] = m_pdict->ht[iht];
+        if (m_pdict->ht[iht].size)
+            m_pdict->ht[iht].table = (dictEntry**)zcalloc(m_pdict->ht[iht].size*sizeof(dictEntry*), MALLOC_SHARED);
+        else
+            m_pdict->ht[iht].table = nullptr;
+
+        for (size_t idx = 0; idx < m_pdict->ht[iht].size; ++idx)
+        {
+            const dictEntry *deSrc = spdb->m_pdict->ht[iht].table[idx];
+            dictEntry **pdeDst = &m_pdict->ht[iht].table[idx];
+            while (deSrc != nullptr)
+            {
+                *pdeDst = (dictEntry*)zmalloc(sizeof(dictEntry), MALLOC_SHARED);
+                (*pdeDst)->key = deSrc->key;
+                (*pdeDst)->v.val = nullptr;
+                (*pdeDst)->next = nullptr;
+                pdeDst = &(*pdeDst)->next;
+                deSrc = deSrc->next;
+            }
+        }
+    }
+    
+    m_spdbSnapshot = std::move(spdb);
+    return m_spdbSnapshot;
+}
+
+void redisDbPersistentData::endSnapshot(const redisDbPersistentData *psnapshot)
+{
+    serverAssert(GlobalLocksAcquired());
+    serverAssert(m_spdbSnapshot.get() == psnapshot);
+
+    dictIterator *di = dictGetIterator(m_pdict);
+    dictEntry *de;
+    while ((de = dictNext(di)) != NULL)
+    {
+        dictEntry *deSnapshot = dictFind(m_spdbSnapshot->m_pdict, dictGetKey(de));
+        if (dictGetVal(de) == nullptr)
+        {
+            if (deSnapshot != nullptr)
+            {
+                de->v.val = deSnapshot->v.val;
+                deSnapshot->v.val = nullptr;
+            }
+        }
+        if (deSnapshot && (dictGetKey(deSnapshot) == dictGetKey(de)))
+        {
+            // The key is owned by the parent snapshot, so we modify the DB key dtor
+            //  to ensure the key is not free'd during the delete
+            m_spdbSnapshot->m_pdict->type = &dbSnapshotDictType;
+            dictDelete(m_spdbSnapshot->m_pdict, dictGetKey(de));
+            m_spdbSnapshot->m_pdict->type = &dbDictType;
+        }
+    }
+    dictReleaseIterator(di);
+    m_spdbSnapshot->m_pdict->iterators--;
+    m_spdbSnapshot = nullptr;
+}
+
+redisDbPersistentData::~redisDbPersistentData()
+{
+    dictRelease(m_pdict);
+    delete m_setexpire;
+}

src/debug.cpp

@@ -55,7 +55,7 @@ typedef ucontext_t sigcontext_t;
 #endif
 #endif
 
-int g_fInCrash = false;
+bool g_fInCrash = false;
 
 /* ================================= Debugging ============================== */
 
@@ -126,7 +126,7 @@ 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));
-    expireEntry *pexpire = getExpire(db,keyobj);
+    expireEntry *pexpire = db->getExpire(keyobj);
     long long expiretime = -1;
     char buf[128];
 
@@ -266,8 +266,6 @@ void xorObjectDigest(redisDb *db, robj_roptr keyobj, unsigned char *digest, robj
  * a different digest. */
 void computeDatasetDigest(unsigned char *final) {
     unsigned char digest[20];
-    dictIterator *di = NULL;
-    dictEntry *de;
     int j;
     uint32_t aux;
 
@@ -276,8 +274,7 @@ void computeDatasetDigest(unsigned char *final) {
     for (j = 0; j < cserver.dbnum; j++) {
         redisDb *db = g_pserver->db+j;
 
-        if (dictSize(db->pdict) == 0) continue;
-        di = dictGetSafeIterator(db->pdict);
+        if (db->size() == 0) continue;
 
         /* hash the DB id, so the same dataset moved in a different
          * DB will lead to a different digest */
@@ -285,24 +282,21 @@ void computeDatasetDigest(unsigned char *final) {
         mixDigest(final,&aux,sizeof(aux));
 
         /* Iterate this DB writing every entry */
-        while((de = dictNext(di)) != NULL) {
-            sds key;
-            robj *keyobj, *o;
+        db->iterate([&](const char *key, robj *o)->bool {
+            robj *keyobj;
 
             memset(digest,0,20); /* This key-val digest */
-            key = (sds)dictGetKey(de);
             keyobj = createStringObject(key,sdslen(key));
 
             mixDigest(digest,key,sdslen(key));
 
-            o = (robj*)dictGetVal(de);
             xorObjectDigest(db,keyobj,digest,o);
 
             /* We can finally xor the key-val digest to the final digest */
             xorDigest(final,digest,20);
             decrRefCount(keyobj);
-        }
-        dictReleaseIterator(di);
+            return true;
+        });
     }
 }
 
@@ -365,7 +359,7 @@ NULL
     } else if (!strcasecmp(szFromObj(c->argv[1]),"reload")) {
         rdbSaveInfo rsi, *rsiptr;
         rsiptr = rdbPopulateSaveInfo(&rsi);
-        if (rdbSave(rsiptr) != C_OK) {
+        if (rdbSave(nullptr, rsiptr) != C_OK) {
             addReply(c,shared.err);
             return;
         }
@@ -394,15 +388,14 @@ NULL
         serverLog(LL_WARNING,"Append Only File loaded by DEBUG LOADAOF");
         addReply(c,shared.ok);
     } else if (!strcasecmp(szFromObj(c->argv[1]),"object") && c->argc == 3) {
-        dictEntry *de;
         robj *val;
         const char *strenc;
 
-        if ((de = dictFind(c->db->pdict,ptrFromObj(c->argv[2]))) == NULL) {
+        val = c->db->find(c->argv[2]);
+        if (val == NULL) {
             addReply(c,shared.nokeyerr);
             return;
         }
-        val = (robj*)dictGetVal(de);
         strenc = strEncoding(val->encoding);
 
         char extra[138] = {0};
@@ -446,16 +439,14 @@ NULL
             strenc, rdbSavedObjectLen(val),
             val->lru, estimateObjectIdleTime(val)/1000, extra);
     } else if (!strcasecmp(szFromObj(c->argv[1]),"sdslen") && c->argc == 3) {
-        dictEntry *de;
-        robj *val;
-        sds key;
+        auto itr = c->db->find(c->argv[2]);
+        robj *val = itr.val();
+        const char *key = itr.key();
 
-        if ((de = dictFind(c->db->pdict,ptrFromObj(c->argv[2]))) == NULL) {
+        if (val == NULL) {
             addReply(c,shared.nokeyerr);
             return;
         }
-        val = (robj*)dictGetVal(de);
-        key = (sds)dictGetKey(de);
 
         if (val->type != OBJ_STRING || !sdsEncodedObject(val)) {
             addReplyError(c,"Not an sds encoded string.");
@@ -465,16 +456,16 @@ NULL
                 "val_sds_len:%lld, val_sds_avail:%lld, val_zmalloc: %lld",
                 (long long) sdslen(key),
                 (long long) sdsavail(key),
-                (long long) sdsZmallocSize(key),
+                (long long) sdsZmallocSize((sds)key),
                 (long long) sdslen(szFromObj(val)),
                 (long long) sdsavail(szFromObj(val)),
                 (long long) getStringObjectSdsUsedMemory(val));
         }
     } else if (!strcasecmp(szFromObj(c->argv[1]),"ziplist") && c->argc == 3) {
-        robj *o;
+        robj_roptr o;
 
         if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.nokeyerr))
-                == NULL) return;
+                == nullptr) return;
 
         if (o->encoding != OBJ_ENCODING_ZIPLIST) {
             addReplyError(c,"Not an sds encoded string.");
@@ -490,7 +481,7 @@ NULL
 
         if (getLongFromObjectOrReply(c, c->argv[2], &keys, NULL) != C_OK)
             return;
-        dictExpand(c->db->pdict,keys);
+        c->db->expand(keys);
         for (j = 0; j < keys; j++) {
             long valsize = 0;
             snprintf(buf,sizeof(buf),"%s:%lu",
@@ -641,20 +632,20 @@ NULL
         }
 
         stats = sdscatprintf(stats,"[Dictionary HT]\n");
-        dictGetStats(buf,sizeof(buf),g_pserver->db[dbid].pdict);
+        g_pserver->db[dbid].getStats(buf,sizeof(buf));
         stats = sdscat(stats,buf);
 
         stats = sdscatprintf(stats,"[Expires set]\n");
-        g_pserver->db[dbid].setexpire->getstats(buf, sizeof(buf));
+        g_pserver->db[dbid].getExpireStats(buf, sizeof(buf));
         stats = sdscat(stats, buf);
 
         addReplyBulkSds(c,stats);
     } else if (!strcasecmp(szFromObj(c->argv[1]),"htstats-key") && c->argc == 3) {
-        robj *o;
+        robj_roptr o;
         dict *ht = NULL;
 
         if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.nokeyerr))
-                == NULL) return;
+                == nullptr) return;
 
         /* Get the hash table reference from the object, if possible. */
         switch (o->encoding) {
@@ -685,26 +676,8 @@ NULL
     } 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) {
+    } else if (!strcasecmp(szFromObj(c->argv[1]), "force-master") && c->argc == 2) {
         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);
@@ -1274,12 +1247,10 @@ void logCurrentClient(void) {
      * selected DB, and if so print info about the associated object. */
     if (cc->argc >= 1) {
         robj *val, *key;
-        dictEntry *de;
 
         key = getDecodedObject(cc->argv[1]);
-        de = dictFind(cc->db->pdict, ptrFromObj(key));
-        if (de) {
-            val = (robj*)dictGetVal(de);
+        val = cc->db->find(key);
+        if (val) {
             serverLog(LL_WARNING,"key '%s' found in DB containing the following object:", (char*)ptrFromObj(key));
             serverLogObjectDebugInfo(val);
         }

src/defrag.cpp

@@ -48,7 +48,7 @@ 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, uint64_t hash, long *defragged);
-bool replaceSateliteOSetKeyPtr(expireset &set, sds oldkey, sds newkey);
+void replaceSateliteOSetKeyPtr(expireset &set, sds oldkey, sds newkey);
 
 /* Defrag helper for generic allocations.
  *
@@ -407,7 +407,7 @@ dictEntry* replaceSateliteDictKeyPtrAndOrDefragDictEntry(dict *d, sds oldkey, sd
     return NULL;
 }
 
-bool replaceSateliteOSetKeyPtr(expireset &set, sds oldkey, sds newkey) {
+void replaceSateliteOSetKeyPtr(expireset &set, sds oldkey, sds newkey) {
     auto itr = set.find(oldkey);
     if (itr != set.end())
     {
@@ -415,10 +415,7 @@ bool replaceSateliteOSetKeyPtr(expireset &set, sds oldkey, sds newkey) {
         eNew.setKeyUnsafe(newkey);
         set.erase(itr);
         set.insert(eNew);
-        serverAssert(set.find(newkey) != set.end());
-        return true;
     }
-    return false;
 }
 
 long activeDefragQuickListNodes(quicklist *ql) {
@@ -780,22 +777,18 @@ 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 (!db->setexpire->empty()) {
-            bool fReplaced = replaceSateliteOSetKeyPtr(*db->setexpire, keysds, newsds);
-            serverAssert(fReplaced == ob->FExpires());
-        } else {
-            serverAssert(!ob->FExpires());
-        }
+    if (!db->setexpire()->empty()) {
+        replaceSateliteOSetKeyPtr(*const_cast<expireset*>(db->setexpire()), keysds, newsds);
     }
 
     /* Try to defrag robj and / or string value. */
+    ob = (robj*)dictGetVal(de);
+    if (ob == nullptr)
+        return defragged;
     if ((newob = activeDefragStringOb(ob, &defragged))) {
         de->v.val = newob;
         ob = newob;
@@ -848,7 +841,6 @@ long defragKey(redisDb *db, dictEntry *de) {
     } else {
         serverPanic("Unknown object type");
     }
-
     return defragged;
 }
 
@@ -863,7 +855,7 @@ void defragScanCallback(void *privdata, const dictEntry *de) {
     g_pserver->stat_active_defrag_scanned++;
 }
 
-/* Defrag scan callback for each hash table bicket,
+/* Defrag scan callback for each hash table bucket,
  * used in order to defrag the dictEntry allocations. */
 void defragDictBucketCallback(void *privdata, dictEntry **bucketref) {
     UNUSED(privdata); /* NOTE: this function is also used by both activeDefragCycle and scanLaterHash, etc. don't use privdata */
@@ -912,9 +904,8 @@ long defragOtherGlobals() {
 
 /* returns 0 more work may or may not be needed (see non-zero cursor),
  * and 1 if time is up and more work is needed. */
-int defragLaterItem(dictEntry *de, unsigned long *cursor, long long endtime) {
-    if (de) {
-        robj *ob = (robj*)dictGetVal(de);
+int defragLaterItem(robj *ob, unsigned long *cursor, long long endtime) {
+    if (ob) {
         if (ob->type == OBJ_LIST) {
             g_pserver->stat_active_defrag_hits += scanLaterList(ob);
             *cursor = 0; /* list has no scan, we must finish it in one go */
@@ -969,11 +960,11 @@ int defragLaterStep(redisDb *db, long long endtime) {
         }
 
         /* each time we enter this function we need to fetch the key from the dict again (if it still exists) */
-        dictEntry *de = dictFind(db->pdict, current_key);
+        robj *o = db->find(current_key);
         key_defragged = g_pserver->stat_active_defrag_hits;
         do {
             int quit = 0;
-            if (defragLaterItem(de, &cursor, endtime))
+            if (defragLaterItem(o, &cursor, endtime))
                 quit = 1; /* time is up, we didn't finish all the work */
 
             /* Don't start a new BIG key in this loop, this is because the
@@ -1055,7 +1046,7 @@ void activeDefragCycle(void) {
     mstime_t latency;
     int quit = 0;
 
-    if (g_pserver->aof_child_pid!=-1 || g_pserver->rdb_child_pid!=-1)
+    if (g_pserver->aof_child_pid!=-1 || g_pserver->FRdbSaveInProgress())
         return; /* Defragging memory while there's a fork will just do damage. */
 
     /* Once a second, check if we the fragmentation justfies starting a scan
@@ -1122,7 +1113,8 @@ void activeDefragCycle(void) {
                 break; /* this will exit the function and we'll continue on the next cycle */
             }
 
-            cursor = dictScan(db->pdict, cursor, defragScanCallback, defragDictBucketCallback, db);
+            // we actually look at the objects too but defragScanCallback can handle missing values
+            cursor = dictScan(db->dictUnsafeKeyOnly(), cursor, defragScanCallback, defragDictBucketCallback, db);
 
             /* Once in 16 scan iterations, 512 pointer reallocations. or 64 keys
              * (if we have a lot of pointers in one hash bucket or rehasing),

src/evict.cpp

@@ -87,7 +87,7 @@ unsigned int LRU_CLOCK(void) {
 
 /* Given an object returns the min number of milliseconds the object was never
  * requested, using an approximated LRU algorithm. */
-unsigned long long estimateObjectIdleTime(robj *o) {
+unsigned long long estimateObjectIdleTime(robj_roptr o) {
     unsigned long long lruclock = LRU_CLOCK();
     if (lruclock >= o->lru) {
         return (lruclock - o->lru) * LRU_CLOCK_RESOLUTION;
@@ -252,19 +252,20 @@ struct visitFunctor
         return count < g_pserver->maxmemory_samples;
     }
 };
-void evictionPoolPopulate(int dbid, dict *dbdict, expireset *setexpire, struct evictionPoolEntry *pool)
+void evictionPoolPopulate(int dbid, redisDb *db, expireset *setexpire, struct evictionPoolEntry *pool)
 {
     if (setexpire != nullptr)
     {
-        visitFunctor visitor { dbid, dbdict, pool, 0 };
+        visitFunctor visitor { dbid, db->dictUnsafeKeyOnly(), pool, 0 };
         setexpire->random_visit(visitor);
     }
     else
     {
         dictEntry **samples = (dictEntry**)alloca(g_pserver->maxmemory_samples * sizeof(dictEntry*));
-        int count = dictGetSomeKeys(dbdict,samples,g_pserver->maxmemory_samples);
+        int count = dictGetSomeKeys(db->dictUnsafeKeyOnly(),samples,g_pserver->maxmemory_samples);
         for (int j = 0; j < count; j++) {
             robj *o = (robj*)dictGetVal(samples[j]);
+            serverAssert(o != nullptr); // BUG!!! We have to get the info we need here without permanently rehydrating the obj
             processEvictionCandidate(dbid, (sds)dictGetKey(samples[j]), o, nullptr, pool);
         }
     }
@@ -504,16 +505,16 @@ int freeMemoryIfNeeded(void) {
                     db = g_pserver->db+i;
                     if (g_pserver->maxmemory_policy & MAXMEMORY_FLAG_ALLKEYS)
                     {
-                        if ((keys = dictSize(db->pdict)) != 0) {
-                            evictionPoolPopulate(i, db->pdict, nullptr, pool);
+                        if ((keys = db->size()) != 0) {
+                            evictionPoolPopulate(i, db, nullptr, pool);
                             total_keys += keys;
                         }
                     }
                     else
                     {
-                        keys = db->setexpire->size();
+                        keys = db->expireSize();
                         if (keys != 0)
-                            evictionPoolPopulate(i, db->pdict, db->setexpire, pool);
+                            evictionPoolPopulate(i, db, db->setexpireUnsafe(), pool);
                         total_keys += keys;
                     }
                 }
@@ -525,9 +526,9 @@ int freeMemoryIfNeeded(void) {
                     bestdbid = pool[k].dbid;
                     sds key = nullptr;
 
-                    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);
+                    auto itr = g_pserver->db[pool[k].dbid].find(pool[k].key);
+                    if (itr != nullptr && (g_pserver->maxmemory_policy & MAXMEMORY_FLAG_ALLKEYS || itr.val()->FExpires()))
+                        key = itr.key();
 
                     /* Remove the entry from the pool. */
                     if (pool[k].key != pool[k].cached)
@@ -559,18 +560,18 @@ int freeMemoryIfNeeded(void) {
                 db = g_pserver->db+j;
                 if (g_pserver->maxmemory_policy == MAXMEMORY_ALLKEYS_RANDOM)
                 {
-                    if (dictSize(db->pdict) != 0) {
-                        dictEntry *de = dictGetRandomKey(db->pdict);
-                        bestkey = (sds)dictGetKey(de);
+                    if (db->size() != 0) {
+                        auto itr = db->random();
+                        bestkey = itr.key();
                         bestdbid = j;
                         break;
                     }
                 }
                 else
                 {
-                    if (!db->setexpire->empty())
+                    if (db->expireSize())
                     {
-                        bestkey = (sds)db->setexpire->random_value().key();
+                        bestkey = (sds)db->random_expire().key();
                         bestdbid = j;
                         break;
                     }
@@ -581,16 +582,17 @@ int freeMemoryIfNeeded(void) {
         /* Finally remove the selected key. */
         if (bestkey) {
             db = g_pserver->db+bestdbid;
+
             robj *keyobj = createStringObject(bestkey,sdslen(bestkey));
             propagateExpire(db,keyobj,g_pserver->lazyfree_lazy_eviction);
             /* We compute the amount of memory freed by db*Delete() alone.
-             * It is possible that actually the memory needed to propagate
-             * the DEL in AOF and replication link is greater than the one
-             * we are freeing removing the key, but we can't account for
-             * that otherwise we would never exit the loop.
-             *
-             * AOF and Output buffer memory will be freed eventually so
-             * we only care about memory used by the key space. */
+            * It is possible that actually the memory needed to propagate
+            * the DEL in AOF and replication link is greater than the one
+            * we are freeing removing the key, but we can't account for
+            * that otherwise we would never exit the loop.
+            *
+            * AOF and Output buffer memory will be freed eventually so
+            * we only care about memory used by the key space. */
             delta = (long long) zmalloc_used_memory();
             latencyStartMonitor(eviction_latency);
             if (g_pserver->lazyfree_lazy_eviction)
@@ -609,18 +611,18 @@ int freeMemoryIfNeeded(void) {
             keys_freed++;
 
             /* When the memory to free starts to be big enough, we may
-             * start spending so much time here that is impossible to
-             * deliver data to the slaves fast enough, so we force the
-             * transmission here inside the loop. */
+            * start spending so much time here that is impossible to
+            * deliver data to the slaves fast enough, so we force the
+            * transmission here inside the loop. */
             if (slaves) flushSlavesOutputBuffers();
 
             /* Normally our stop condition is the ability to release
-             * a fixed, pre-computed amount of memory. However when we
-             * are deleting objects in another thread, it's better to
-             * check, from time to time, if we already reached our target
-             * memory, since the "mem_freed" amount is computed only
-             * across the dbAsyncDelete() call, while the thread can
-             * release the memory all the time. */
+            * a fixed, pre-computed amount of memory. However when we
+            * are deleting objects in another thread, it's better to
+            * check, from time to time, if we already reached our target
+            * memory, since the "mem_freed" amount is computed only
+            * across the dbAsyncDelete() call, while the thread can
+            * release the memory all the time. */
             if (g_pserver->lazyfree_lazy_eviction && !(keys_freed % 16)) {
                 if (getMaxmemoryState(NULL,NULL,NULL,NULL) == C_OK) {
                     /* Let's satisfy our stop condition. */

src/expire.cpp

@@ -31,7 +31,6 @@
  */
 
 #include "server.h"
-#include "cron.h"
 
 void activeExpireCycleExpireFullKey(redisDb *db, const char *key) {
     robj *keyobj = createStringObject(key,sdslen(key));
@@ -75,8 +74,7 @@ void activeExpireCycleExpire(redisDb *db, expireEntry &e, long long now) {
     }
 
     expireEntryFat *pfat = e.pfatentry();
-    dictEntry *de = dictFind(db->pdict, e.key());
-    robj *val = (robj*)dictGetVal(de);
+    robj *val = db->find(e.key());
     int deleted = 0;
     while (!pfat->FEmpty())
     {
@@ -101,32 +99,9 @@ void activeExpireCycleExpire(redisDb *db, expireEntry &e, long long now) {
                 }
             }
             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:
+        case OBJ_ZSET:
+        case OBJ_HASH:
         default:
             serverAssert(false);
         }
@@ -135,15 +110,6 @@ void activeExpireCycleExpire(redisDb *db, expireEntry &e, long long now) {
 
     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)
         {
@@ -190,11 +156,10 @@ void expireMemberCore(client *c, robj *key, robj *subkey, long long basetime, lo
 
     /* No key, return zero. */
     robj *val = lookupKeyWriteOrReply(c, key, shared.czero);
-    if (val == NULL) {
+    if (val == nullptr) {
         return;
     }
 
-    double dblT;
     switch (val->type)
     {
     case OBJ_SET:
@@ -204,20 +169,6 @@ void expireMemberCore(client *c, robj *key, robj *subkey, long long basetime, lo
         }
         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;
@@ -344,7 +295,7 @@ void activeExpireCycle(int type) {
         now = mstime();
 
         /* If there is nothing to expire try next DB ASAP. */
-        if (db->setexpire->empty())
+        if (db->setexpireUnsafe()->empty())
         {
             db->avg_ttl = 0;
             db->last_expire_set = now;
@@ -354,7 +305,7 @@ void activeExpireCycle(int type) {
         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)) {
+        db->expireitr = db->setexpireUnsafe()->enumerate(db->expireitr, now, [&](expireEntry &e) __attribute__((always_inline)) {
             if (e.when() < now)
             {
                 activeExpireCycleExpire(db, e, now);
@@ -454,16 +405,16 @@ void expireSlaveKeys(void) {
                 redisDb *db = g_pserver->db+dbid;
 
                 // 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));
+                auto itrDB = db->find(keyname);
+                auto itrExpire = db->setexpire()->end();
+                if (itrDB != nullptr)
+                    itrExpire = db->setexpireUnsafe()->find(itrDB.key());
                 int expired = 0;
 
-                if (itr != db->setexpire->end())
+                if (itrExpire != db->setexpire()->end())
                 {
-                    if (itr->when() < start) {
-                        activeExpireCycleExpire(g_pserver->db+dbid,*itr,start);
+                    if (itrExpire->when() < start) {
+                        activeExpireCycleExpire(g_pserver->db+dbid,*itrExpire,start);
                         expired = 1;
                     }
                 }
@@ -472,7 +423,7 @@ void expireSlaveKeys(void) {
                  * 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 (itr != db->setexpire->end() && !expired) {
+                if (itrExpire != db->setexpire()->end() && !expired) {
                     noexpire++;
                     new_dbids |= (uint64_t)1 << dbid;
                 }
@@ -583,7 +534,7 @@ void expireGenericCommand(client *c, long long basetime, int unit) {
      *
      * 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) || g_pserver->fActiveReplica)) {
+    if (when <= mstime() && !g_pserver->loading && !listLength(g_pserver->masters)) {
         robj *aux;
 
         int deleted = g_pserver->lazyfree_lazy_expire ? dbAsyncDelete(c->db,key) :
@@ -640,7 +591,7 @@ void ttlGenericCommand(client *c, int output_ms) {
 
     /* The key exists. Return -1 if it has no expire, or the actual
         * TTL value otherwise. */
-    expireEntry *pexpire = getExpire(c->db,c->argv[1]);
+    expireEntry *pexpire = c->db->getExpire(c->argv[1]);
 
     if (c->argc == 2) {
         // primary expire    
@@ -696,7 +647,7 @@ void persistCommand(client *c) {
                 addReply(c,shared.czero);
             }
         } else if (c->argc == 3) {
-            if (removeSubkeyExpire(c->db, c->argv[1], c->argv[2])) {
+            if (c->db->removeSubkeyExpire(c->argv[1], c->argv[2])) {
                 addReply(c,shared.cone);
                 g_pserver->dirty++;
             } else {

src/fastlock.cpp

@@ -27,7 +27,6 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#include "fmacros.h"
 #include "fastlock.h"
 #include <unistd.h>
 #include <sys/syscall.h>
@@ -37,14 +36,10 @@
 #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>
@@ -62,12 +57,6 @@
 #define UNUSED(x) ((void)x)
 #endif
 
-#ifdef HAVE_BACKTRACE
-#include <ucontext.h>
-__attribute__((weak)) void logStackTrace(ucontext_t *) {}
-#endif
-
-extern int g_fInCrash;
 
 /****************************************************
  *
@@ -81,10 +70,6 @@ extern int g_fInCrash;
     #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". */
@@ -140,21 +125,26 @@ extern "C" void unlock_futex(struct fastlock *lock, uint16_t ifutex);
 
 #endif
 
-#pragma weak _serverPanic
-extern "C"  __attribute__((weak)) void _serverPanic(const char * /*file*/, int /*line*/, const char * /*msg*/, ...)
+static_assert(sizeof(pid_t) <= sizeof(fastlock::m_pidOwner), "fastlock::m_pidOwner not large enough");
+uint64_t g_longwaits = 0;
+
+uint64_t fastlock_getlongwaitcount()
 {
-    *((char*)-1) = 'x';
+    uint64_t rval;
+    __atomic_load(&g_longwaits, &rval, __ATOMIC_RELAXED);
+    return rval;
 }
 
-#pragma weak serverLog
-__attribute__((weak)) void serverLog(int , const char *fmt, ...)
+#ifndef ASM_SPINLOCK
+#ifdef __linux__
+static int futex(volatile unsigned *uaddr, int futex_op, int val,
+    const struct timespec *timeout, int val3)
 {
-    va_list args;
-    va_start(args, fmt);
-    vprintf(fmt, args);
-    va_end(args);
-    printf("\n");
+    return syscall(SYS_futex, uaddr, futex_op, val,
+                    timeout, uaddr, val3);
 }
+#endif
+#endif
 
 extern "C" pid_t gettid()
 {
@@ -173,145 +163,13 @@ extern "C" pid_t gettid()
     return pidCache;
 }
 
-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)
+extern "C" void fastlock_init(struct fastlock *lock)
 {
     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);
 }
 
@@ -326,12 +184,12 @@ extern "C" void fastlock_lock(struct fastlock *lock)
         return;
     }
 
-    int tid = gettid();
     unsigned myticket = __atomic_fetch_add(&lock->m_ticket.m_avail, 1, __ATOMIC_RELEASE);
+#ifdef __linux__
     unsigned mask = (1U << (myticket % 32));
-    unsigned cloops = 0;
+#endif
+    int cloops = 0;
     ticket ticketT;
-
     for (;;)
     {
         __atomic_load(&lock->m_ticket.u, &ticketT.u, __ATOMIC_ACQUIRE);
@@ -339,17 +197,21 @@ extern "C" void fastlock_lock(struct fastlock *lock)
             break;
 
 #if defined(__i386__) || defined(__amd64__)
-        __asm__ __volatile__ ("pause");
-#elif defined(__aarch64__)
-        __asm__ __volatile__ ("yield");
+        __asm__ ("pause");
 #endif
-        if ((++cloops % 0x100000) == 0)
+        if ((++cloops % 1024*1024) == 0)
         {
-            fastlock_sleep(lock, tid, ticketT.u, mask);
+#ifdef __linux__
+            __atomic_fetch_or(&lock->futex, mask, __ATOMIC_ACQUIRE);
+            futex(&lock->m_ticket.u, FUTEX_WAIT_BITSET_PRIVATE, ticketT.u, nullptr, mask);
+            __atomic_fetch_and(&lock->futex, ~mask, __ATOMIC_RELEASE);
+#endif
+            __atomic_fetch_add(&g_longwaits, 1, __ATOMIC_RELAXED);
         }
     }
 
     lock->m_depth = 1;
+    int tid = gettid();
     __atomic_store(&lock->m_pidOwner, &tid, __ATOMIC_RELEASE);
     ANNOTATE_RWLOCK_ACQUIRED(lock, true);
     std::atomic_thread_fence(std::memory_order_acquire);
@@ -376,7 +238,7 @@ extern "C" int fastlock_trylock(struct fastlock *lock, int fWeak)
 
     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))
+    if (__atomic_compare_exchange(&lock->m_ticket, &ticket_expect, &ticket_setiflocked, fWeak /*weak*/, __ATOMIC_ACQUIRE, __ATOMIC_RELAXED))
     {
         lock->m_depth = 1;
         tid = gettid();
@@ -387,6 +249,31 @@ extern "C" int fastlock_trylock(struct fastlock *lock, int fWeak)
     return false;
 }
 
+#ifdef __linux__
+#define ROL32(v, shift) ((v << shift) | (v >> (32-shift)))
+void unlock_futex(struct fastlock *lock, uint16_t ifutex)
+{
+    unsigned mask = (1U << (ifutex % 32));
+    unsigned futexT;
+    __atomic_load(&lock->futex, &futexT, __ATOMIC_RELAXED);
+    futexT &= mask;
+    
+    if (futexT == 0)
+        return;
+    
+    for (;;)
+    {
+        __atomic_load(&lock->futex, &futexT, __ATOMIC_ACQUIRE);
+        futexT &= mask;
+        if (!futexT)
+            break;
+
+        if (futex(&lock->m_ticket.u, FUTEX_WAKE_BITSET_PRIVATE, INT_MAX, nullptr, mask) == 1)
+            break;
+    }
+}
+#endif
+
 extern "C" void fastlock_unlock(struct fastlock *lock)
 {
     --lock->m_depth;
@@ -409,26 +296,6 @@ extern "C" void fastlock_unlock(struct fastlock *lock)
 }
 #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
-
 extern "C" void fastlock_free(struct fastlock *lock)
 {
     // NOP
@@ -458,4 +325,4 @@ void fastlock_lock_recursive(struct fastlock *lock, int nesting)
 {
     fastlock_lock(lock);
     lock->m_depth = nesting;
-}
+}

src/fastlock.h

@@ -1,6 +1,5 @@
 #pragma once
 #include <inttypes.h>
-#include <stddef.h>
 
 #ifdef __cplusplus
 extern "C" {
@@ -8,7 +7,7 @@ extern "C" {
 
 /* Begin C API */
 struct fastlock;
-void fastlock_init(struct fastlock *lock, const char *name);
+void fastlock_init(struct fastlock *lock);
 void fastlock_lock(struct fastlock *lock);
 int fastlock_trylock(struct fastlock *lock, int fWeak);
 void fastlock_unlock(struct fastlock *lock);
@@ -41,31 +40,29 @@ struct ticket
 
 struct fastlock
 {
+    volatile struct ticket m_ticket;
+
     volatile int m_pidOwner;
     volatile int m_depth;
-    char szName[56];
-    /* Volatile data on seperate cache line */
-    volatile struct ticket m_ticket;
     unsigned futex;
-    char padding[56];   // ensure ticket and futex are on their own independent cache line
 
 #ifdef __cplusplus
-    fastlock(const char *name)
+    fastlock()
     {
-        fastlock_init(this, name);
+        fastlock_init(this);
     }
 
-    inline void lock()
+    void lock()
     {
         fastlock_lock(this);
     }
 
-    inline bool try_lock(bool fWeak = false)
+    bool try_lock(bool fWeak = false)
     {
         return !!fastlock_trylock(this, fWeak);
     }
 
-    inline void unlock()
+    void unlock()
     {
         fastlock_unlock(this);
     }
@@ -83,5 +80,3 @@ struct fastlock
     bool fOwnLock();   // true if this thread owns the lock, NOTE: not 100% reliable, use for debugging only
 #endif
 };
-
-static_assert(offsetof(struct fastlock, m_ticket) == 64, "ensure padding is correct");

src/fastlock_x64.asm

@@ -1,152 +1,157 @@
-.intel_syntax noprefix
-.text
+section .text
 
-.extern gettid
-.extern fastlock_sleep
+extern gettid
+extern sched_yield
+extern g_longwaits
 
-#	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
-.type   fastlock_lock,@function
+ALIGN 16
+global fastlock_lock
 fastlock_lock:
-	.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
+	; RDI points to the struct:
+	;	uint16_t active
+	;	uint16_t avail
+	;	int32_t m_pidOwner
+	;	int32_t m_depth
 	
-	# 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
+	; 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], esi          # Is the TID we got back the owner of the lock?
-	je .LLocked             # Don't spin in that case
+	cmp [rdi+4], 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+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
+	xor eax, eax            ; eliminate partial register dependency
+	inc eax                 ; we want to add one
+	lock xadd [rdi+2], ax   ; do the xadd, ax contains the value before the addition
+	; ax now contains the ticket
+ALIGN 16
 .LLoop:
-	mov edx, [rdi+64]
-	cmp dx, ax              # is our ticket up?
-	je .LLocked             # leave the loop
+	mov edx, [rdi]
+	cmp dx, ax              ; is our ticket up?
+	je .LLocked             ; leave the loop
 	pause
-	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
+	add ecx, 1000h          ; Have we been waiting a long time? (oflow if we have)
+	                        ;	1000h is set so we overflow on the 1024*1024'th iteration (like the C code)
+	jnc .LLoop              ; If so, give up our timeslice to someone who's doing real work
+	; Like the compiler, you're probably thinking: "Hey! I should take these pushs out of the loop"
+	;	But the compiler doesn't know that we rarely hit this, and when we do we know the lock is
+	;	taking a long time to be released anyways.  We optimize for the common case of short
+	;	lock intervals.  That's why we're using a spinlock in the first place
+	; If we get here we're going to sleep in the kernel with a futex
 	push rsi
 	push rax
-	.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
+	; Setup the syscall args
+                            ; rdi ARG1 futex (already in rdi)
+	mov esi, (9 | 128)      ; rsi ARG2 FUTEX_WAIT_BITSET_PRIVATE
+                            ; rdx ARG3 ticketT.u (already in edx)
+	xor r10d, r10d          ; r10 ARG4 NULL
+	mov r8, rdi	            ; r8 ARG5 dup rdi
+	xor r9d, r9d
+	bts r9d, eax            ; r9 ARG6 mask
+	mov eax, 202            ; sys_futex
+	; Do the syscall
+	lock or [rdi+12], r9d   ; inform the unlocking thread we're waiting
+	syscall	                ; wait for the futex
+	not r9d	                ; convert our flag into a mask of bits not to touch
+	lock and [rdi+12], r9d  ; clear the flag in the futex control mask
+	; cleanup and continue
+	mov rcx, g_longwaits
+	inc qword [rcx]         ; increment our long wait counter
 	pop rax
 	pop rsi
-	pop rdi
-	.cfi_adjust_cfa_offset -24
-	xor ecx, ecx            # Reset our loop counter
-	jmp .LLoop              # Get back in the game
-.ALIGN 16
+	xor ecx, ecx            ; Reset our loop counter
+	jmp .LLoop              ; Get back in the game
+ALIGN 16
 .LLocked:
-	mov [rdi], esi          # lock->m_pidOwner = gettid()
-	inc dword ptr [rdi+4]   # lock->m_depth++
+	mov [rdi+4], esi        ; lock->m_pidOwner = gettid()
+	inc dword [rdi+8]       ; lock->m_depth++
 	ret
-.cfi_endproc
 
-.ALIGN 16
-.global fastlock_trylock
-.type   fastlock_trylock,@function
+ALIGN 16
+global fastlock_trylock
 fastlock_trylock:
-	# RDI points to the struct:
-	#	int32_t m_pidOwner
-	#	int32_t m_depth
-	# [rdi+64] ...
-	#	uint16_t active
-	#	uint16_t avail
+	; RDI points to the struct:
+	;	uint16_t active
+	;	uint16_t avail
+	;	int32_t m_pidOwner
+	;	int32_t m_depth
 	
-	# 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], esi          # Is the TID we got back the owner of the lock?
-	je .LRecursive          # Don't spin in that case
+	cmp [rdi+4], esi        ; Is the TID we got back the owner of the lock?
+	je .LRecursive          ; Don't spin in that case
 
-	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
+	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
 
-	# 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
+	; 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
 	xor eax, eax
-	inc eax                     # return SUCCESS! (eax=1)
-	mov [rdi], esi              # lock->m_pidOwner = gettid()
-	mov dword ptr [rdi+4], eax  # lock->m_depth = 1
+	inc eax                 ; return SUCCESS! (eax=1)
+	mov [rdi+4], esi        ; lock->m_pidOwner = gettid()
+	mov dword [rdi+8], eax  ; lock->m_depth = 1
 	ret
-.ALIGN 16
+ALIGN 16
 .LRecursive:
 	xor eax, eax
-	inc eax                 # return SUCCESS! (eax=1)
-	inc dword ptr [rdi+4]   # lock->m_depth++
+	inc eax                 ; return SUCCESS! (eax=1)
+	inc dword [rdi+8]       ; 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
-.type   fastlock_unlock,@function
+ALIGN 16
+global fastlock_unlock
 fastlock_unlock:
-	# 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
+	; RDI points to the struct:
+	;	uint16_t active
+	;	uint16_t avail
+	;	int32_t m_pidOwner
+	;	int32_t m_depth
+	push r11
+	sub dword [rdi+8], 1         ; decrement m_depth, don't use dec because it partially writes the flag register and we don't know its state
+	jnz .LDone                   ; if depth is non-zero this is a recursive unlock, and we still hold it
+	mov dword [rdi+4], -1        ; pidOwner = -1 (we don't own it anymore)
+	mov ecx, [rdi]               ; get current active (this one)
+	inc ecx                      ; bump it to the next thread
+	mov [rdi], cx                ; give up our ticket (note: lock is not required here because the spinlock itself guards this variable)
+	; At this point the lock is removed, however we must wake up any pending futexs
+	mov r9d, 1                   ; eax is the bitmask for 2 threads
+	rol r9d, cl                  ; place the mask in the right spot for the next 2 threads
+ALIGN 16
+.LRetryWake:
+	mov r11d, [rdi+12]           ; load the futex mask
+	and r11d, r9d                ; are any threads waiting on a futex?
+	jz .LDone                    ; if not we're done.
+	; we have to wake the futexs
+                                 ; rdi ARG1 futex (already in rdi)
+	mov esi, (10 | 128)          ; rsi ARG2 FUTEX_WAKE_BITSET_PRIVATE
+	mov edx, 0x7fffffff          ; rdx ARG3 INT_MAX (number of threads to wake)
+	xor r10d, r10d               ; r10 ARG4 NULL
+	mov r8, rdi                  ; r8 ARG5 dup rdi
+                                 ; r9 ARG6 mask (already set above)
+	mov eax, 202                 ; sys_futex
+	syscall
+	cmp eax, 1                   ; did we wake as many as we expected?
+	jnz .LRetryWake
 .LDone:
-	js fastlock_panic            # panic if we made m_depth negative
+	pop r11
 	ret

src/geohash_helper.cpp

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

src/help.h

@@ -1168,13 +1168,7 @@ 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" },
-    { "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"
-    }
+    "2.0.0" }
 };
 
 #endif

src/lazyfree.cpp

@@ -51,18 +51,18 @@ size_t lazyfreeGetFreeEffort(robj *obj) {
  * a lazy free list instead of being freed synchronously. The lazy free list
  * will be reclaimed in a different bio.c thread. */
 #define LAZYFREE_THRESHOLD 64
-int dbAsyncDelete(redisDb *db, robj *key) {
+bool redisDbPersistentData::asyncDelete(robj *key) {
     /* If the value is composed of a few allocations, to free in a lazy way
      * is actually just slower... So under a certain limit we just free
      * the object synchronously. */
-    dictEntry *de = dictUnlink(db->pdict,ptrFromObj(key));
+    dictEntry *de = dictUnlink(m_pdict,ptrFromObj(key));
     if (de) {
         robj *val = (robj*)dictGetVal(de);
         if (val->FExpires())
         {
             /* Deleting an entry from the expires dict will not free the sds of
              * the key, because it is shared with the main dictionary. */
-            removeExpireCore(db,key,de);
+            removeExpire(key,dict_iter(de));
         }
 
         size_t free_effort = lazyfreeGetFreeEffort(val);
@@ -78,21 +78,25 @@ int dbAsyncDelete(redisDb *db, robj *key) {
         if (free_effort > LAZYFREE_THRESHOLD && val->getrefcount(std::memory_order_relaxed) == 1) {
             atomicIncr(lazyfree_objects,1);
             bioCreateBackgroundJob(BIO_LAZY_FREE,val,NULL,NULL);
-            dictSetVal(db->pdict,de,NULL);
+            dictSetVal(m_pdict,de,NULL);
         }
     }
 
     /* Release the key-val pair, or just the key if we set the val
      * field to NULL in order to lazy free it later. */
     if (de) {
-        dictFreeUnlinkedEntry(db->pdict,de);
+        dictFreeUnlinkedEntry(m_pdict,de);
         if (g_pserver->cluster_enabled) slotToKeyDel(key);
-        return 1;
+        return true;
     } else {
-        return 0;
+        return false;
     }
 }
 
+int dbAsyncDelete(redisDb *db, robj *key) {
+    return db->asyncDelete(key);
+}
+
 /* Free an object, if the object is huge enough, free it in async way. */
 void freeObjAsync(robj *o) {
     size_t free_effort = lazyfreeGetFreeEffort(o);
@@ -107,12 +111,15 @@ void freeObjAsync(robj *o) {
 /* Empty a Redis DB asynchronously. What the function does actually is to
  * create a new empty set of hash tables and scheduling the old ones for
  * lazy freeing. */
-void emptyDbAsync(redisDb *db) {
-    dict *oldht1 = db->pdict;
-    auto *set = db->setexpire;
-    db->setexpire = new (MALLOC_LOCAL) expireset();
-    db->expireitr = db->setexpire->end();
-    db->pdict = dictCreate(&dbDictType,NULL);
+void redisDbPersistentData::emptyDbAsync() {
+    dict *oldht1 = m_pdict;
+    auto *set = m_setexpire;
+    m_setexpire = new (MALLOC_LOCAL) expireset();
+    m_pdict = dictCreate(&dbDictType,this);
+    if (m_pstorage != nullptr)
+        m_pstorage->clear();
+    if (m_fTrackingChanges)
+        m_fAllChanged = true;
     atomicIncr(lazyfree_objects,dictSize(oldht1));
     bioCreateBackgroundJob(BIO_LAZY_FREE,NULL,oldht1,set);
 }

src/module.cpp

@@ -1644,7 +1644,7 @@ 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) {
-    expireEntry *pexpire = getExpire(key->db,key->key);
+    expireEntry *pexpire = key->db->getExpire(key->key);
     mstime_t expire = -1;
     if (pexpire != nullptr)
         pexpire->FGetPrimaryExpire(&expire);
@@ -4043,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 keydb.conf for
+ * Notice that it is not necessary to enable notifications in redis.conf for
  * module notifications to work.
  *
  * Warning: the notification callbacks are performed in a synchronous manner,

src/motd.cpp

@@ -1,132 +0,0 @@
-#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

@@ -1,14 +0,0 @@
-#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,7 +28,6 @@
  */
 
 #include "server.h"
-bool FInReplicaReplay();
 
 /* ================================ MULTI/EXEC ============================== */
 
@@ -173,15 +172,12 @@ 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)) && !(FInReplicaReplay())) {
+        if (!must_propagate && !(c->cmd->flags & (CMD_READONLY|CMD_ADMIN))) {
             execCommandPropagateMulti(c);
             must_propagate = 1;
         }
 
-        int flags = g_pserver->loading ? CMD_CALL_NONE : CMD_CALL_FULL;
-        if (FInReplicaReplay())
-            flags &= ~CMD_CALL_PROPAGATE;
-        call(c,flags);
+        call(c,g_pserver->loading ? CMD_CALL_NONE : CMD_CALL_FULL);
 
         /* Commands may alter argc/argv, restore mstate. */
         c->mstate.commands[j].argc = c->argc;
@@ -337,7 +333,7 @@ void touchWatchedKeysOnFlush(int dbid) {
              * key exists, mark the client as dirty, as the key will be
              * removed. */
             if (dbid == -1 || wk->db->id == dbid) {
-                if (dictFind(wk->db->pdict, ptrFromObj(wk->key)) != NULL)
+                if (wk->db->find(wk->key) != NULL)
                     c->flags |= CLIENT_DIRTY_CAS;
             }
         }

src/networking.cpp

@@ -99,7 +99,6 @@ client *createClient(int fd, int iel) {
      * in the context of a client. When commands are executed in other
      * contexts (for instance a Lua script) we need a non connected client. */
     if (fd != -1) {
-        serverAssert(iel == (serverTL - g_pserver->rgthreadvar));
         anetNonBlock(NULL,fd);
         anetEnableTcpNoDelay(NULL,fd);
         if (cserver.tcpkeepalive)
@@ -117,7 +116,7 @@ client *createClient(int fd, int iel) {
     uint64_t client_id;
     client_id = g_pserver->next_client_id.fetch_add(1);
     c->iel = iel;
-    fastlock_init(&c->lock, "client");
+    fastlock_init(&c->lock);
     c->id = client_id;
     c->resp = 2;
     c->fd = fd;
@@ -177,7 +176,6 @@ client *createClient(int fd, int iel) {
     c->bufposAsync = 0;
     c->client_tracking_redirection = 0;
     c->casyncOpsPending = 0;
-    c->master_error = 0;
     memset(c->uuid, 0, UUID_BINARY_LEN);
 
     listSetFreeMethod(c->pubsub_patterns,decrRefCountVoid);
@@ -250,11 +248,7 @@ void clientInstallAsyncWriteHandler(client *c) {
 int prepareClientToWrite(client *c, bool fAsync) {
     fAsync = fAsync && !FCorrectThread(c);  // Not async if we're on the right thread
     serverAssert(FCorrectThread(c) || fAsync);
-	if (FCorrectThread(c)) {
-		serverAssert(c->fd <= 0 || c->lock.fOwnLock());
-	} else {
-		serverAssert(GlobalLocksAcquired());
-	}
+    serverAssert(c->fd <= 0 || c->lock.fOwnLock());
 
     if (c->flags & CLIENT_FORCE_REPLY) return C_OK; // FORCE REPLY means we're doing something else with the buffer.
                                                 // do not install a write handler
@@ -433,34 +427,6 @@ void addReplyProtoAsync(client *c, const char *s, size_t len) {
     addReplyProtoCore(c, s, len, true);
 }
 
-std::string escapeString(sds str)
-{
-    std::string newstr;
-    size_t len = sdslen(str);
-    for (size_t ich = 0; ich < len; ++ich)
-    {
-        char ch = str[ich];
-        switch (ch)
-        {
-        case '\n':
-            newstr += "\\n";
-            break;
-
-        case '\t':
-            newstr += "\\t";
-            break;
-
-        case '\r':
-            newstr += "\\r";
-            break;
-        
-        default:
-            newstr += ch;
-        }
-    }
-    return newstr;
-}
-
 /* Low level function called by the addReplyError...() functions.
  * It emits the protocol for a Redis error, in the form:
  *
@@ -493,12 +459,6 @@ void addReplyErrorLengthCore(client *c, const char *s, size_t len, bool fAsync)
         serverLog(LL_WARNING,"== CRITICAL == This %s is sending an error "
                              "to its %s: '%s' after processing the command "
                              "'%s'", from, to, s, cmdname);
-
-        if (c->querybuf && sdslen(c->querybuf)) {
-            std::string str = escapeString(c->querybuf);
-            printf("\tquerybuf: %s\n", str.c_str());
-        }
-        c->master_error = 1;
     }
 }
 
@@ -1038,27 +998,6 @@ int clientHasPendingReplies(client *c) {
     return (c->bufpos || listLength(c->reply)) && !(c->flags & CLIENT_CLOSE_ASAP);
 }
 
-static std::atomic<int> rgacceptsInFlight[MAX_EVENT_LOOPS];
-int chooseBestThreadForAccept()
-{
-    int ielMinLoad = 0;
-    int cclientsMin = INT_MAX;
-    for (int iel = 0; iel < cserver.cthreads; ++iel)
-    {
-        int cclientsThread;
-        atomicGet(g_pserver->rgthreadvar[iel].cclients, cclientsThread);
-        cclientsThread += rgacceptsInFlight[iel].load(std::memory_order_relaxed);
-        if (cclientsThread < cserver.thread_min_client_threshold)
-            return iel;
-        if (cclientsThread < cclientsMin)
-        {
-            cclientsMin = cclientsThread;
-            ielMinLoad = iel;
-        }
-    }
-    return ielMinLoad;
-}
-
 #define MAX_ACCEPTS_PER_CALL 1000
 static void acceptCommonHandler(int fd, int flags, char *ip, int iel) {
     client *c;
@@ -1161,25 +1100,7 @@ void acceptTcpHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
 
         if (!g_fTestMode)
         {
-            {
-            int ielTarget = chooseBestThreadForAccept();
-            rgacceptsInFlight[ielTarget].fetch_add(1, std::memory_order_relaxed);
-            if (ielTarget != ielCur)
-            {
-                char *szT = (char*)zmalloc(NET_IP_STR_LEN, MALLOC_LOCAL);
-                memcpy(szT, cip, NET_IP_STR_LEN);
-                int res = aePostFunction(g_pserver->rgthreadvar[ielTarget].el, [cfd, ielTarget, szT]{
-                    acceptCommonHandler(cfd,0,szT, ielTarget);
-                    rgacceptsInFlight[ielTarget].fetch_sub(1, std::memory_order_relaxed);
-                    zfree(szT);
-                });
-
-                if (res == AE_OK)
-                    continue;
-            }
-            rgacceptsInFlight[ielTarget].fetch_sub(1, std::memory_order_relaxed);
-            }
-
+            // We always accept on the same thread
         LLocalThread:
             aeAcquireLock();
             acceptCommonHandler(cfd,0,cip, ielCur);
@@ -1196,15 +1117,10 @@ void acceptTcpHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
                 goto LLocalThread;
             char *szT = (char*)zmalloc(NET_IP_STR_LEN, MALLOC_LOCAL);
             memcpy(szT, cip, NET_IP_STR_LEN);
-            int res = aePostFunction(g_pserver->rgthreadvar[iel].el, [cfd, iel, szT]{
+            aePostFunction(g_pserver->rgthreadvar[iel].el, [cfd, iel, szT]{
                 acceptCommonHandler(cfd,0,szT, iel);
                 zfree(szT);
             });
-            if (res != AE_OK)
-            {
-                zfree(szT);
-                goto LLocalThread;
-            }
         }
     }
 }
@@ -1230,16 +1146,13 @@ void acceptUnixHandler(aeEventLoop *el, int fd, void *privdata, int mask) {
         int ielTarget = rand() % cserver.cthreads;
         if (ielTarget == ielCur)
         {
-        LLocalThread:
             acceptCommonHandler(cfd,CLIENT_UNIX_SOCKET,NULL, ielCur);
         }
         else
         {
-            int res = aePostFunction(g_pserver->rgthreadvar[ielTarget].el, [cfd, ielTarget]{
+            aePostFunction(g_pserver->rgthreadvar[ielTarget].el, [cfd, ielTarget]{
                 acceptCommonHandler(cfd,CLIENT_UNIX_SOCKET,NULL, ielTarget);
             });
-            if (res != AE_OK)
-                goto LLocalThread;
         }
         aeReleaseLock();
         
@@ -1596,6 +1509,7 @@ int writeToClient(int fd, client *c, int handler_installed) {
         } else {
             serverLog(LL_VERBOSE,
                 "Error writing to client: %s", strerror(errno));
+            lock.unlock();
             freeClientAsync(c);
             
             return C_ERR;
@@ -1614,6 +1528,7 @@ int writeToClient(int fd, client *c, int handler_installed) {
 
         /* Close connection after entire reply has been sent. */
         if (c->flags & CLIENT_CLOSE_AFTER_REPLY) {
+            lock.unlock();
             freeClientAsync(c);
             return C_ERR;
         }
@@ -1633,10 +1548,7 @@ void sendReplyToClient(aeEventLoop *el, int fd, void *privdata, int mask) {
         c->lock.lock();
         ae.arm(c);
         if (c->flags & CLIENT_CLOSE_ASAP)
-        {
-            if (!freeClient(c))
-                c->lock.unlock();
-        }
+            freeClient(c);
     }
 }
 
@@ -2607,17 +2519,9 @@ NULL
                 close_this_client = 1;
             } else {
                 if (FCorrectThread(client))
-                {
                     freeClient(client);
-                }
                 else
-                {
-                    int iel = client->iel;
                     freeClientAsync(client);
-                    aePostFunction(g_pserver->rgthreadvar[client->iel].el, [iel] {  // note: failure is OK
-                        freeClientsInAsyncFreeQueue(iel);
-                    });
-                }
             }
             killed++;
         }
@@ -3046,48 +2950,38 @@ void flushSlavesOutputBuffers(void) {
  * than the time left for the previous pause, no change is made to the
  * left duration. */
 void pauseClients(mstime_t end) {
-    serverAssert(GlobalLocksAcquired());
-    if (!serverTL->clients_paused || end > g_pserver->clients_pause_end_time)
+    if (!g_pserver->clients_paused || end > g_pserver->clients_pause_end_time)
         g_pserver->clients_pause_end_time = end;
-    
-    for (int iel = 0; iel < cserver.cthreads; ++iel)
-    {
-        g_pserver->rgthreadvar[iel].clients_paused = true;
-    }
+    g_pserver->clients_paused = 1;
 }
 
 /* Return non-zero if clients are currently paused. As a side effect the
  * function checks if the pause time was reached and clear it. */
 int clientsArePaused(void) {
-    return serverTL->clients_paused;
-}
-
-void unpauseClientsIfNecessary()
-{
-    serverAssert(GlobalLocksAcquired());
-    if (serverTL->clients_paused &&
+    if (g_pserver->clients_paused &&
         g_pserver->clients_pause_end_time < g_pserver->mstime)
     {
+        aeAcquireLock();
         listNode *ln;
         listIter li;
         client *c;
 
-        serverTL->clients_paused = 0;
+        g_pserver->clients_paused = 0;
 
         /* Put all the clients in the unblocked clients queue in order to
          * force the re-processing of the input buffer if any. */
         listRewind(g_pserver->clients,&li);
         while ((ln = listNext(&li)) != NULL) {
             c = (client*)listNodeValue(ln);
-            if (!FCorrectThread(c))
-                continue;
 
             /* Don't touch slaves and blocked clients.
              * The latter pending requests will be processed when unblocked. */
             if (c->flags & (CLIENT_SLAVE|CLIENT_BLOCKED)) continue;
             queueClientForReprocessing(c);
         }
+        aeReleaseLock();
     }
+    return g_pserver->clients_paused;
 }
 
 /* This function is called by Redis in order to process a few events from
@@ -3103,55 +2997,18 @@ void unpauseClientsIfNecessary()
  *
  * The function returns the total number of events processed. */
 int processEventsWhileBlocked(int iel) {
-    serverAssert(GlobalLocksAcquired());
     int iterations = 4; /* See the function top-comment. */
     int count = 0;
 
-    std::vector<client*> vecclients;
-    listIter li;
-    listNode *ln;
-    listRewind(g_pserver->clients, &li);
-
-    // All client locks must be acquired *after* the global lock is reacquired to prevent deadlocks
-    //  so unlock here, and save them for reacquisition later
-    while ((ln = listNext(&li)) != nullptr)
-    {
-        client *c = (client*)listNodeValue(ln);
-        if (c->lock.fOwnLock()) {
-            serverAssert(c->flags & CLIENT_PROTECTED);  // If the client is not protected we have no gurantee they won't be free'd in the event loop
-            c->lock.unlock();
-            vecclients.push_back(c);
-        }
-    }
-    
-
     aeReleaseLock();
-    try
-    {
-        while (iterations--) {
-            int events = 0;
-            events += aeProcessEvents(g_pserver->rgthreadvar[iel].el, AE_FILE_EVENTS|AE_DONT_WAIT);
-            events += handleClientsWithPendingWrites(iel);
-            if (!events) break;
-            count += events;
-        }
+    while (iterations--) {
+        int events = 0;
+        events += aeProcessEvents(g_pserver->rgthreadvar[iel].el, AE_FILE_EVENTS|AE_DONT_WAIT);
+        events += handleClientsWithPendingWrites(iel);
+        if (!events) break;
+        count += events;
     }
-    catch (...)
-    {
-        // Caller expects us to be locked so fix and rethrow
-        AeLocker locker;
-        locker.arm(nullptr);
-        locker.release();
-        for (client *c : vecclients)
-            c->lock.lock();
-        throw;
-    }
-    
-    AeLocker locker;
-    locker.arm(nullptr);
-    locker.release();
-    for (client *c : vecclients)
-        c->lock.lock();
+    aeAcquireLock();
     return count;
 }
 

src/object.cpp

@@ -29,7 +29,6 @@
  */
 
 #include "server.h"
-#include "cron.h"
 #include <math.h>
 #include <ctype.h>
 
@@ -370,7 +369,6 @@ 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());
@@ -716,34 +714,6 @@ 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) {
@@ -819,7 +789,7 @@ size_t streamRadixTreeMemoryUsage(rax *rax) {
  * case of aggregated data types where only "sample_size" elements
  * are checked and averaged to estimate the total size. */
 #define OBJ_COMPUTE_SIZE_DEF_SAMPLES 5 /* Default sample size. */
-size_t objectComputeSize(robj *o, size_t sample_size) {
+size_t objectComputeSize(robj_roptr o, size_t sample_size) {
     sds ele, ele2;
     dict *d;
     dictIterator *di;
@@ -830,7 +800,7 @@ size_t objectComputeSize(robj *o, size_t sample_size) {
         if(o->encoding == OBJ_ENCODING_INT) {
             asize = sizeof(*o);
         } else if(o->encoding == OBJ_ENCODING_RAW) {
-            asize = sdsAllocSize(szFromObj(o))+sizeof(*o);
+            asize = sdsAllocSize((sds)szFromObj(o))+sizeof(*o);
         } else if(o->encoding == OBJ_ENCODING_EMBSTR) {
             asize = sdslen(szFromObj(o))+2+sizeof(*o);
         } else {
@@ -1084,20 +1054,20 @@ struct redisMemOverhead *getMemoryOverheadData(void) {
 
     for (j = 0; j < cserver.dbnum; j++) {
         redisDb *db = g_pserver->db+j;
-        long long keyscount = dictSize(db->pdict);
+        long long keyscount = db->size();
         if (keyscount==0) continue;
 
         mh->total_keys += keyscount;
         mh->db = (decltype(mh->db))zrealloc(mh->db,sizeof(mh->db[0])*(mh->num_dbs+1), MALLOC_LOCAL);
         mh->db[mh->num_dbs].dbid = j;
 
-        mem = dictSize(db->pdict) * sizeof(dictEntry) +
-              dictSlots(db->pdict) * sizeof(dictEntry*) +
-              dictSize(db->pdict) * sizeof(robj);
+        mem = db->size() * sizeof(dictEntry) +
+              db->slots() * sizeof(dictEntry*) +
+              db->size() * sizeof(robj);
         mh->db[mh->num_dbs].overhead_ht_main = mem;
         mem_total+=mem;
 
-        mem = db->setexpire->bytes_used();
+        mem = db->setexpire()->bytes_used();
         mh->db[mh->num_dbs].overhead_ht_expires = mem;
         mem_total+=mem;
 
@@ -1276,15 +1246,12 @@ void objectSetLRUOrLFU(robj *val, long long lfu_freq, long long lru_idle,
 
 /* This is a helper function for the OBJECT command. We need to lookup keys
  * without any modification of LRU or other parameters. */
-robj *objectCommandLookup(client *c, robj *key) {
-    dictEntry *de;
-
-    if ((de = dictFind(c->db->pdict,ptrFromObj(key))) == NULL) return NULL;
-    return (robj*) dictGetVal(de);
+robj_roptr objectCommandLookup(client *c, robj *key) {
+    return c->db->find(key);
 }
 
-robj *objectCommandLookupOrReply(client *c, robj *key, robj *reply) {
-    robj *o = objectCommandLookup(c,key);
+robj_roptr objectCommandLookupOrReply(client *c, robj *key, robj *reply) {
+    robj_roptr o = objectCommandLookup(c,key);
 
     if (!o) addReply(c, reply);
     return o;
@@ -1293,7 +1260,7 @@ robj *objectCommandLookupOrReply(client *c, robj *key, robj *reply) {
 /* Object command allows to inspect the internals of an Redis Object.
  * Usage: OBJECT <refcount|encoding|idletime|freq> <key> */
 void objectCommand(client *c) {
-    robj *o;
+    robj_roptr o;
 
     if (c->argc == 2 && !strcasecmp(szFromObj(c->argv[1]),"help")) {
         const char *help[] = {
@@ -1306,15 +1273,15 @@ NULL
         addReplyHelp(c, help);
     } else if (!strcasecmp(szFromObj(c->argv[1]),"refcount") && c->argc == 3) {
         if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.null[c->resp]))
-                == NULL) return;
+                == nullptr) return;
         addReplyLongLong(c,o->getrefcount(std::memory_order_relaxed));
     } else if (!strcasecmp(szFromObj(c->argv[1]),"encoding") && c->argc == 3) {
         if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.null[c->resp]))
-                == NULL) return;
+                == nullptr) return;
         addReplyBulkCString(c,strEncoding(o->encoding));
     } else if (!strcasecmp(szFromObj(c->argv[1]),"idletime") && c->argc == 3) {
         if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.null[c->resp]))
-                == NULL) return;
+                == nullptr) return;
         if (g_pserver->maxmemory_policy & MAXMEMORY_FLAG_LFU) {
             addReplyError(c,"An LFU maxmemory policy is selected, idle time not tracked. Please note that when switching between policies at runtime LRU and LFU data will take some time to adjust.");
             return;
@@ -1322,7 +1289,7 @@ NULL
         addReplyLongLong(c,estimateObjectIdleTime(o)/1000);
     } else if (!strcasecmp(szFromObj(c->argv[1]),"freq") && c->argc == 3) {
         if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.null[c->resp]))
-                == NULL) return;
+                == nullptr) return;
         if (!(g_pserver->maxmemory_policy & MAXMEMORY_FLAG_LFU)) {
             addReplyError(c,"An LFU maxmemory policy is not selected, access frequency not tracked. Please note that when switching between policies at runtime LRU and LFU data will take some time to adjust.");
             return;
@@ -1331,10 +1298,10 @@ NULL
          * in case of the key has not been accessed for a long time,
          * because we update the access time only
          * when the key is read or overwritten. */
-        addReplyLongLong(c,LFUDecrAndReturn(o));
+        addReplyLongLong(c,LFUDecrAndReturn(o.unsafe_robjcast()));
     } else if (!strcasecmp(szFromObj(c->argv[1]), "lastmodified") && c->argc == 3) {
         if ((o = objectCommandLookupOrReply(c,c->argv[2],shared.null[c->resp]))
-                == NULL) return;
+                == nullptr) return;
         addReplyLongLong(c, (g_pserver->mstime - (o->mvcc_tstamp >> MVCC_MS_SHIFT)) / 1000);
     } else {
         addReplySubcommandSyntaxError(c);
@@ -1357,7 +1324,6 @@ NULL
         };
         addReplyHelp(c, help);
     } else if (!strcasecmp(szFromObj(c->argv[1]),"usage") && c->argc >= 3) {
-        dictEntry *de;
         long long samples = OBJ_COMPUTE_SIZE_DEF_SAMPLES;
         for (int j = 3; j < c->argc; j++) {
             if (!strcasecmp(szFromObj(c->argv[j]),"samples") &&
@@ -1376,12 +1342,14 @@ NULL
                 return;
             }
         }
-        if ((de = dictFind(c->db->pdict,ptrFromObj(c->argv[2]))) == NULL) {
+
+        auto itr = c->db->find(c->argv[2]);
+        if (itr == nullptr) {
             addReplyNull(c, shared.nullbulk);
             return;
         }
-        size_t usage = objectComputeSize((robj*)dictGetVal(de),samples);
-        usage += sdsAllocSize((sds)dictGetKey(de));
+        size_t usage = objectComputeSize(itr.val(),samples);
+        usage += sdsAllocSize(itr.key());
         usage += sizeof(dictEntry);
         addReplyLongLong(c,usage);
     } else if (!strcasecmp(szFromObj(c->argv[1]),"stats") && c->argc == 2) {
@@ -1525,3 +1493,110 @@ void redisObject::setrefcount(unsigned ref)
     serverAssert(!FExpires());
     refcount.store(ref, std::memory_order_relaxed); 
 }
+
+sds serializeStoredStringObject(sds str, robj_roptr o)
+{
+    str = sdscatlen(str, &(*o), sizeof(robj));
+    switch (o->encoding)
+    {
+    case OBJ_ENCODING_RAW:
+        str = sdscatsds(str, (sds)szFromObj(o));
+        break;
+
+    case OBJ_ENCODING_INT:
+        break;  //nop
+
+    case OBJ_ENCODING_EMBSTR:
+        size_t cb = zmalloc_size(o.unsafe_robjcast());
+        if (cb > sizeof(robj))
+        {
+            str = sdscatlen(str, o.unsafe_robjcast() + 1, cb - sizeof(robj));
+        }
+        break;
+    }
+        
+    return str;
+}
+
+robj *deserializeStoredStringObject(const char *data, size_t cb)
+{
+    const robj *oT = (const robj*)data;
+    robj *newObject = nullptr;
+    switch (oT->encoding)
+    {
+    case OBJ_ENCODING_INT:
+        serverAssert(cb == sizeof(robj));
+        [[fallthrough]];
+    case OBJ_ENCODING_EMBSTR:
+        newObject = (robj*)zmalloc(cb, MALLOC_LOCAL);
+        memcpy(newObject, data, cb);
+        newObject->setrefcount(1);
+        return newObject;
+
+    case OBJ_ENCODING_RAW:
+        newObject = (robj*)zmalloc(sizeof(robj), MALLOC_SHARED);
+        memcpy(newObject, data, sizeof(robj));
+        newObject->m_ptr = sdsnewlen(SDS_NOINIT,cb-sizeof(robj));
+        memcpy(newObject->m_ptr, data+sizeof(robj), cb-sizeof(robj));
+        newObject->setrefcount(1);
+        return newObject;
+    }
+    serverPanic("Unknown string object encoding from storage");
+    return nullptr;
+}
+
+robj *deserializeStoredObject(const void *data, size_t cb)
+{
+    switch (((char*)data)[0])
+    {
+        case RDB_TYPE_STRING:
+            return deserializeStoredStringObject(((char*)data)+1, cb-1);
+
+        default:
+            rio payload;
+            int type;
+            robj *obj;
+            rioInitWithConstBuffer(&payload,data,cb);
+            if (((type = rdbLoadObjectType(&payload)) == -1) ||
+                ((obj = rdbLoadObject(type,&payload,nullptr, OBJ_MVCC_INVALID)) == nullptr))
+            {
+                serverPanic("Bad data format");
+            }
+            if (rdbLoadType(&payload) == RDB_OPCODE_AUX)
+            {
+                robj *auxkey, *auxval;
+                if ((auxkey = rdbLoadStringObject(&payload)) == NULL) goto eoferr;
+                if ((auxval = rdbLoadStringObject(&payload)) == NULL) {
+                    decrRefCount(auxkey);
+                    goto eoferr;
+                }
+                if (strcasecmp(szFromObj(auxkey), "mvcc-tstamp") == 0) {
+                    obj->mvcc_tstamp = strtoull(szFromObj(auxval), nullptr, 10);
+                }
+                decrRefCount(auxkey);
+                decrRefCount(auxval);
+            }
+        eoferr:
+            return obj;
+    }
+    serverPanic("Unknown object type loading from storage");
+}
+
+sds serializeStoredObject(robj_roptr o)
+{
+    switch (o->type)
+    {
+        case OBJ_STRING:
+        {
+            sds sdsT = sdsnewlen(nullptr, 1);
+            sdsT[0] = RDB_TYPE_STRING;
+            return serializeStoredStringObject(sdsT, o);
+        }
+            
+        default:
+            rio rdb;
+            createDumpPayload(&rdb,o,nullptr);
+            return (sds)rdb.io.buffer.ptr;
+    }
+    serverPanic("Attempting to store unknown object type");
+}

src/pubsub.cpp

@@ -301,11 +301,9 @@ int pubsubPublishMessage(robj *channel, robj *message) {
             client *c = reinterpret_cast<client*>(ln->value);
             if (c->flags & CLIENT_CLOSE_ASAP)   // avoid blocking if the write will be ignored
                 continue;
-            if (FCorrectThread(c))
-                fastlock_lock(&c->lock);
+            fastlock_lock(&c->lock);
             addReplyPubsubMessage(c,channel,message);
-            if (FCorrectThread(c))
-                fastlock_unlock(&c->lock);
+            fastlock_unlock(&c->lock);
             receivers++;
         }
     }
@@ -323,12 +321,10 @@ int pubsubPublishMessage(robj *channel, robj *message) {
             {
                 if (pat->pclient->flags & CLIENT_CLOSE_ASAP)
                     continue;
-                if (FCorrectThread(pat->pclient))
-                    fastlock_lock(&pat->pclient->lock);
+                fastlock_lock(&pat->pclient->lock);
                 addReplyPubsubPatMessage(pat->pclient,
                     pat->pattern,channel,message);
-                if (FCorrectThread(pat->pclient))
-                    fastlock_unlock(&pat->pclient->lock);
+                fastlock_unlock(&pat->pclient->lock);
                 receivers++;
             }
         }

src/rax.c

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

src/rdb-s3.cpp

@@ -6,7 +6,7 @@ extern "C" {
 #include <sys/wait.h>
 
 /* Save the DB on disk. Return C_ERR on error, C_OK on success. */
-int rdbSaveS3(char *s3bucket, rdbSaveInfo *rsi)
+int rdbSaveS3(char *s3bucket, redisDbPersistentData **rgpdb, rdbSaveInfo *rsi)
 {
     int status = EXIT_FAILURE;
     int fd[2];
@@ -40,7 +40,7 @@ int rdbSaveS3(char *s3bucket, rdbSaveInfo *rsi)
             return C_ERR;
         }
 
-        if (rdbSaveFp(fp, rsi) != C_OK)
+        if (rdbSaveFp(fp, rgpdb, rsi) != C_OK)
         {
             fclose(fp);
             return C_ERR;

src/rdb.cpp

@@ -33,7 +33,6 @@
 #include "endianconv.h"
 #include "stream.h"
 #include "storage.h"
-#include "cron.h"
 
 #include <math.h>
 #include <sys/types.h>
@@ -43,6 +42,9 @@
 #include <arpa/inet.h>
 #include <sys/stat.h>
 #include <sys/param.h>
+#include <thread>
+#include <future>
+#include "aelocker.h"
 
 #define rdbExitReportCorruptRDB(...) rdbCheckThenExit(__LINE__,__VA_ARGS__)
 
@@ -524,11 +526,6 @@ 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);
 }
@@ -663,8 +660,6 @@ 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");
     }
@@ -994,17 +989,6 @@ 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");
     }
@@ -1122,21 +1106,21 @@ int rdbSaveInfoAuxFields(rio *rdb, int flags, rdbSaveInfo *rsi) {
     if (rsi) {
         if (rdbSaveAuxFieldStrInt(rdb,"repl-stream-db",rsi->repl_stream_db)
             == -1) return -1;
-        if (rdbSaveAuxFieldStrStr(rdb,"repl-id",g_pserver->replid)
+        if (rdbSaveAuxFieldStrStr(rdb,"repl-id",rsi->repl_id)
             == -1) return -1;
-        if (rdbSaveAuxFieldStrInt(rdb,"repl-offset",g_pserver->master_repl_offset)
+        if (rdbSaveAuxFieldStrInt(rdb,"repl-offset",rsi->master_repl_offset)
             == -1) return -1;
     }
     if (rdbSaveAuxFieldStrInt(rdb,"aof-preamble",aof_preamble) == -1) return -1;
     return 1;
 }
 
-int saveKey(rio *rdb, redisDb *db, int flags, size_t *processed, const char *keystr, robj *o)
+int saveKey(rio *rdb, redisDbPersistentData *db, int flags, size_t *processed, const char *keystr, robj *o)
 {    
     robj key;
 
     initStaticStringObject(key,(char*)keystr);
-    expireEntry *pexpire = getExpire(db, &key);
+    expireEntry *pexpire = db->getExpire(&key);
 
     if (rdbSaveKeyValuePair(rdb,&key,o,pexpire) == -1)
         return 0;
@@ -1161,9 +1145,9 @@ int saveKey(rio *rdb, redisDb *db, int flags, size_t *processed, const char *key
  * When the function returns C_ERR and if 'error' is not NULL, the
  * integer pointed by 'error' is set to the value of errno just after the I/O
  * error. */
-int rdbSaveRio(rio *rdb, int *error, int flags, rdbSaveInfo *rsi) {
-    dictIterator *di = NULL;
+int rdbSaveRio(rio *rdb, redisDbPersistentData **rgpdb, int *error, int flags, rdbSaveInfo *rsi) {
     dictEntry *de;
+    dictIterator *di = NULL;
     char magic[10];
     int j;
     uint64_t cksum;
@@ -1173,13 +1157,12 @@ int rdbSaveRio(rio *rdb, int *error, int flags, rdbSaveInfo *rsi) {
         rdb->update_cksum = rioGenericUpdateChecksum;
     snprintf(magic,sizeof(magic),"REDIS%04d",RDB_VERSION);
     if (rdbWriteRaw(rdb,magic,9) == -1) goto werr;
+    
     if (rdbSaveInfoAuxFields(rdb,flags,rsi) == -1) goto werr;
 
     for (j = 0; j < cserver.dbnum; j++) {
-        redisDb *db = g_pserver->db+j;
-        dict *d = db->pdict;
-        if (dictSize(d) == 0) continue;
-        di = dictGetSafeIterator(d);
+        redisDbPersistentData *db = rgpdb[j];
+        if (db->size() == 0) continue;
 
         /* Write the SELECT DB opcode */
         if (rdbSaveType(rdb,RDB_OPCODE_SELECTDB) == -1) goto werr;
@@ -1190,43 +1173,47 @@ int rdbSaveRio(rio *rdb, int *error, int flags, rdbSaveInfo *rsi) {
          * However this does not limit the actual size of the DB to load since
          * these sizes are just hints to resize the hash tables. */
         uint64_t db_size, expires_size;
-        db_size = dictSize(db->pdict);
-        expires_size = db->setexpire->size();
+        db_size = db->size();
+        expires_size = db->expireSize();
         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 *o = (robj*)dictGetVal(de);
-
+        bool fSavedAll = db->iterate([&](const char *keystr, robj *o)->bool {
             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. */
+                return false;
+            return !g_pserver->rdbThreadVars.fRdbThreadCancel;
+        });
+        if (!fSavedAll)
+            goto werr;
+        serverAssert(ckeysExpired == db->expireSize());
     }
 
     /* If we are storing the replication information on disk, persist
      * the script cache as well: on successful PSYNC after a restart, we need
      * to be able to process any EVALSHA inside the replication backlog the
      * master will send us. */
+    {
+    AeLocker lock;
+    lock.arm(nullptr);
     if (rsi && dictSize(g_pserver->lua_scripts)) {
         di = dictGetIterator(g_pserver->lua_scripts);
         while((de = dictNext(di)) != NULL) {
             robj *body = (robj*)dictGetVal(de);
             if (rdbSaveAuxField(rdb,"lua",3,szFromObj(body),sdslen(szFromObj(body))) == -1)
                 goto werr;
+            if (g_pserver->rdbThreadVars.fRdbThreadCancel)
+                goto werr;
         }
         dictReleaseIterator(di);
         di = NULL; /* So that we don't release it again on error. */
     }
+    }   // AeLocker end scope
 
     /* EOF opcode */
     if (rdbSaveType(rdb,RDB_OPCODE_EOF) == -1) goto werr;
@@ -1252,7 +1239,7 @@ werr:
  * While the suffix is the 40 bytes hex string we announced in the prefix.
  * This way processes receiving the payload can understand when it ends
  * without doing any processing of the content. */
-int rdbSaveRioWithEOFMark(rio *rdb, int *error, rdbSaveInfo *rsi) {
+int rdbSaveRioWithEOFMark(rio *rdb, redisDbPersistentData **rgpdb, int *error, rdbSaveInfo *rsi) {
     char eofmark[RDB_EOF_MARK_SIZE];
 
     getRandomHexChars(eofmark,RDB_EOF_MARK_SIZE);
@@ -1260,7 +1247,7 @@ int rdbSaveRioWithEOFMark(rio *rdb, int *error, rdbSaveInfo *rsi) {
     if (rioWrite(rdb,"$EOF:",5) == 0) goto werr;
     if (rioWrite(rdb,eofmark,RDB_EOF_MARK_SIZE) == 0) goto werr;
     if (rioWrite(rdb,"\r\n",2) == 0) goto werr;
-    if (rdbSaveRio(rdb,error,RDB_SAVE_NONE,rsi) == C_ERR) goto werr;
+    if (rdbSaveRio(rdb,rgpdb,error,RDB_SAVE_NONE,rsi) == C_ERR) goto werr;
     if (rioWrite(rdb,eofmark,RDB_EOF_MARK_SIZE) == 0) goto werr;
     return C_OK;
 
@@ -1270,7 +1257,7 @@ werr: /* Write error. */
     return C_ERR;
 }
 
-int rdbSaveFp(FILE *fp, rdbSaveInfo *rsi)
+int rdbSaveFp(FILE *fp, redisDbPersistentData **rgpdb, rdbSaveInfo *rsi)
 {
     int error = 0;
     rio rdb;
@@ -1280,31 +1267,41 @@ int rdbSaveFp(FILE *fp, rdbSaveInfo *rsi)
     if (g_pserver->rdb_save_incremental_fsync)
         rioSetAutoSync(&rdb,REDIS_AUTOSYNC_BYTES);
 
-    if (rdbSaveRio(&rdb,&error,RDB_SAVE_NONE,rsi) == C_ERR) {
+    if (rdbSaveRio(&rdb,rgpdb,&error,RDB_SAVE_NONE,rsi) == C_ERR) {
         errno = error;
         return C_ERR;
     }
     return C_OK;
 }
 
-int rdbSave(rdbSaveInfo *rsi)
+int rdbSave(redisDbPersistentData **rgpdb, rdbSaveInfo *rsi)
 {
+    std::vector<redisDbPersistentData*> vecdb;
+    if (rgpdb == nullptr)
+    {
+        for (int idb = 0; idb < cserver.dbnum; ++idb)
+        {
+            vecdb.push_back(&g_pserver->db[idb]);
+        }
+        rgpdb = vecdb.data();
+    }
+
     int err = C_OK;
     if (g_pserver->rdb_filename != NULL)
-        err = rdbSaveFile(g_pserver->rdb_filename, rsi);
+        err = rdbSaveFile(g_pserver->rdb_filename, rgpdb, rsi);
 
     if (err == C_OK && g_pserver->rdb_s3bucketpath != NULL)
-        err = rdbSaveS3(g_pserver->rdb_s3bucketpath, rsi);
+        err = rdbSaveS3(g_pserver->rdb_s3bucketpath, rgpdb, rsi);
     return err;
 }
 
 /* Save the DB on disk. Return C_ERR on error, C_OK on success. */
-int rdbSaveFile(char *filename, rdbSaveInfo *rsi) {
+int rdbSaveFile(char *filename, redisDbPersistentData **rgpdb, rdbSaveInfo *rsi) {
     char tmpfile[256];
     char cwd[MAXPATHLEN]; /* Current working dir path for error messages. */
     FILE *fp;
 
-    snprintf(tmpfile,256,"temp-%d.rdb", (int) getpid());
+    snprintf(tmpfile,256,"temp-%d.rdb", g_pserver->rdbThreadVars.tmpfileNum);
     fp = fopen(tmpfile,"w");
     if (!fp) {
         char *cwdp = getcwd(cwd,MAXPATHLEN);
@@ -1317,7 +1314,7 @@ int rdbSaveFile(char *filename, rdbSaveInfo *rsi) {
         return C_ERR;
     }
 
-    if (rdbSaveFp(fp, rsi) == C_ERR){
+    if (rdbSaveFp(fp, rgpdb, rsi) == C_ERR){
         goto werr;
     }
 
@@ -1342,9 +1339,12 @@ int rdbSaveFile(char *filename, rdbSaveInfo *rsi) {
     }
 
     serverLog(LL_NOTICE,"DB saved on disk");
-    g_pserver->dirty = 0;
-    g_pserver->lastsave = time(NULL);
-    g_pserver->lastbgsave_status = C_OK;
+    if (serverTL != nullptr)
+    {
+        g_pserver->dirty = 0;
+        g_pserver->lastsave = time(NULL);
+        g_pserver->lastbgsave_status = C_OK;
+    }
     return C_OK;
 
 werr:
@@ -1354,63 +1354,99 @@ werr:
     return C_ERR;
 }
 
+struct rdbSaveThreadArgs
+{
+    rdbSaveInfo rsi;
+    redisDbPersistentData *rgpdb[1];    // NOTE: Variable Length
+};
+
+void *rdbSaveThread(void *vargs)
+{
+    rdbSaveThreadArgs *args = reinterpret_cast<rdbSaveThreadArgs*>(vargs);
+    serverAssert(serverTL == nullptr);
+    int retval = rdbSave(args->rgpdb, &args->rsi);
+    if (retval == C_OK) {
+        size_t private_dirty = zmalloc_get_private_dirty(-1);
+
+        if (private_dirty) {
+            serverLog(LL_NOTICE,
+                "RDB: %zu MB of memory used by copy-on-write",
+                private_dirty/(1024*1024));
+        }
+
+        g_pserver->child_info_data.cow_size = private_dirty;
+        sendChildInfo(CHILD_INFO_TYPE_RDB);
+    }
+
+    aeAcquireLock();
+    for (int idb = 0; idb < cserver.dbnum; ++idb)
+        g_pserver->db[idb].endSnapshot(args->rgpdb[idb]);
+    aeReleaseLock();
+    zfree(args);
+    return (retval == C_OK) ? (void*)0 : (void*)1;
+}
+
+int launchRdbSaveThread(pthread_t &child, rdbSaveInfo *rsi)
+{
+    rdbSaveThreadArgs *args = (rdbSaveThreadArgs*)zmalloc(sizeof(rdbSaveThreadArgs) + ((cserver.dbnum-1)*sizeof(redisDbPersistentData*)), MALLOC_LOCAL);
+    rdbSaveInfo rsiT = RDB_SAVE_INFO_INIT;
+    if (rsi == nullptr)
+        rsi = &rsiT;
+    memcpy(&args->rsi, rsi, sizeof(rdbSaveInfo));
+    memcpy(&args->rsi.repl_id, g_pserver->replid, sizeof(g_pserver->replid));
+    args->rsi.master_repl_offset = g_pserver->master_repl_offset;
+        
+    for (int idb = 0; idb < cserver.dbnum; ++idb)
+        args->rgpdb[idb] = g_pserver->db[idb].createSnapshot().get();
+
+    g_pserver->rdbThreadVars.tmpfileNum++;
+    g_pserver->rdbThreadVars.fRdbThreadCancel = false;
+    if (pthread_create(&child, NULL, rdbSaveThread, args)) {
+        for (int idb = 0; idb < cserver.dbnum; ++idb)
+            g_pserver->db[idb].endSnapshot(args->rgpdb[idb]);
+        zfree(args);
+        return C_ERR;
+    }
+    return C_OK;
+}
+
 int rdbSaveBackground(rdbSaveInfo *rsi) {
-    pid_t childpid;
+    pthread_t child;
     long long start;
 
-    if (g_pserver->aof_child_pid != -1 || g_pserver->rdb_child_pid != -1) return C_ERR;
+    if (g_pserver->aof_child_pid != -1 || g_pserver->FRdbSaveInProgress()) return C_ERR;
 
     g_pserver->dirty_before_bgsave = g_pserver->dirty;
     g_pserver->lastbgsave_try = time(NULL);
     openChildInfoPipe();
 
     start = ustime();
-    if ((childpid = fork()) == 0) {
-        int retval;
 
-        /* Child */
-        closeListeningSockets(0);
-        redisSetProcTitle("keydb-rdb-bgsave");
-        retval = rdbSave(rsi);
-        if (retval == C_OK) {
-            size_t private_dirty = zmalloc_get_private_dirty(-1);
-
-            if (private_dirty) {
-                serverLog(LL_NOTICE,
-                    "RDB: %zu MB of memory used by copy-on-write",
-                    private_dirty/(1024*1024));
-            }
-
-            g_pserver->child_info_data.cow_size = private_dirty;
-            sendChildInfo(CHILD_INFO_TYPE_RDB);
-        }
-        exitFromChild((retval == C_OK) ? 0 : 1);
-    } else {
-        /* Parent */
-        g_pserver->stat_fork_time = ustime()-start;
-        g_pserver->stat_fork_rate = (double) zmalloc_used_memory() * 1000000 / g_pserver->stat_fork_time / (1024*1024*1024); /* GB per second. */
-        latencyAddSampleIfNeeded("fork",g_pserver->stat_fork_time/1000);
-        if (childpid == -1) {
-            closeChildInfoPipe();
-            g_pserver->lastbgsave_status = C_ERR;
-            serverLog(LL_WARNING,"Can't save in background: fork: %s",
-                strerror(errno));
-            return C_ERR;
-        }
-        serverLog(LL_NOTICE,"Background saving started by pid %d",childpid);
-        g_pserver->rdb_save_time_start = time(NULL);
-        g_pserver->rdb_child_pid = childpid;
-        g_pserver->rdb_child_type = RDB_CHILD_TYPE_DISK;
-        updateDictResizePolicy();
-        return C_OK;
+    
+    g_pserver->stat_fork_time = ustime()-start;
+    g_pserver->stat_fork_rate = (double) zmalloc_used_memory() * 1000000 / g_pserver->stat_fork_time / (1024*1024*1024); /* GB per second. */
+    latencyAddSampleIfNeeded("fork",g_pserver->stat_fork_time/1000);
+    if (launchRdbSaveThread(child, rsi) != C_OK) {
+        closeChildInfoPipe();
+        g_pserver->lastbgsave_status = C_ERR;
+        serverLog(LL_WARNING,"Can't save in background: fork: %s",
+            strerror(errno));
+        return C_ERR;
     }
-    return C_OK; /* unreached */
+    serverLog(LL_NOTICE,"Background saving started");
+    g_pserver->rdb_save_time_start = time(NULL);
+    g_pserver->rdbThreadVars.fRdbThreadActive = true;
+    g_pserver->rdbThreadVars.rdb_child_thread = child;
+    g_pserver->rdb_child_type = RDB_CHILD_TYPE_DISK;
+    updateDictResizePolicy();
+
+    return C_OK;
 }
 
-void rdbRemoveTempFile(pid_t childpid) {
+void rdbRemoveTempFile(int tmpfileNum) {
     char tmpfile[256];
 
-    snprintf(tmpfile,sizeof(tmpfile),"temp-%d.rdb", (int) childpid);
+    snprintf(tmpfile,sizeof(tmpfile),"temp-%d.rdb", tmpfileNum);
     unlink(tmpfile);
 }
 
@@ -1545,15 +1581,9 @@ 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) {
-                    sdsfree(sdsele);
-                    return NULL;
-                }
+                if (rdbLoadBinaryDoubleValue(rdb,&score) == -1) return NULL;
             } else {
-                if (rdbLoadDoubleValue(rdb,&score) == -1) {
-                    sdsfree(sdsele);
-                    return NULL;
-                }
+                if (rdbLoadDoubleValue(rdb,&score) == -1) return NULL;
             }
 
             /* Don't care about integer-encoded strings. */
@@ -1873,18 +1903,6 @@ 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);
     }
@@ -1956,7 +1974,7 @@ 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;
+    long long lru_idle = -1, lfu_freq = -1, expiretime = -1, now = mstime();
     long long lru_clock = 0;
     uint64_t mvcc_tstamp = OBJ_MVCC_INVALID;
     robj *subexpireKey = nullptr;
@@ -2035,7 +2053,7 @@ int rdbLoadRio(rio *rdb, rdbSaveInfo *rsi, int loading_aof) {
                 goto eoferr;
             if ((expires_size = rdbLoadLen(rdb,NULL)) == RDB_LENERR)
                 goto eoferr;
-            dictExpand(db->pdict,db_size);
+            db->expand(db_size);
             continue; /* Read next opcode. */
         } else if (type == RDB_OPCODE_AUX) {
             /* AUX: generic string-string fields. Use to add state to RDB
@@ -2095,7 +2113,7 @@ int rdbLoadRio(rio *rdb, rdbSaveInfo *rsi, int loading_aof) {
                 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)");
+                    serverLog(LL_WARNING, "Corrupt subexpire entry in RDB skipping.");
                 }
                 else {
                     setExpire(NULL, db, key, subexpireKey, strtoll(szFromObj(auxval), nullptr, 10));
@@ -2152,19 +2170,12 @@ int rdbLoadRio(rio *rdb, rdbSaveInfo *rsi, int loading_aof) {
         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 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);
-            }
+        if (listLength(g_pserver->masters) == 0 && !loading_aof && expiretime != -1 && expiretime < now) {
             decrRefCount(key);
             key = nullptr;
             decrRefCount(val);
@@ -2197,10 +2208,7 @@ int rdbLoadRio(rio *rdb, rdbSaveInfo *rsi, int loading_aof) {
     }
 
     if (key != nullptr)
-    {
         decrRefCount(key);
-        key = nullptr;
-    }
 
     if (subexpireKey != nullptr)
     {
@@ -2227,17 +2235,6 @@ 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 */
@@ -2294,7 +2291,7 @@ void backgroundSaveDoneHandlerDisk(int exitcode, int bysignal) {
         serverLog(LL_WARNING,
             "Background saving terminated by signal %d", bysignal);
         latencyStartMonitor(latency);
-        rdbRemoveTempFile(g_pserver->rdb_child_pid);
+        rdbRemoveTempFile(g_pserver->rdbThreadVars.tmpfileNum);
         latencyEndMonitor(latency);
         latencyAddSampleIfNeeded("rdb-unlink-temp-file",latency);
         /* SIGUSR1 is whitelisted, so we have a way to kill a child without
@@ -2302,7 +2299,7 @@ void backgroundSaveDoneHandlerDisk(int exitcode, int bysignal) {
         if (bysignal != SIGUSR1)
             g_pserver->lastbgsave_status = C_ERR;
     }
-    g_pserver->rdb_child_pid = -1;
+    g_pserver->rdbThreadVars.fRdbThreadActive = false;
     g_pserver->rdb_child_type = RDB_CHILD_TYPE_NONE;
     g_pserver->rdb_save_time_last = time(NULL)-g_pserver->rdb_save_time_start;
     g_pserver->rdb_save_time_start = -1;
@@ -2327,7 +2324,7 @@ void backgroundSaveDoneHandlerSocket(int exitcode, int bysignal) {
         serverLog(LL_WARNING,
             "Background transfer terminated by signal %d", bysignal);
     }
-    g_pserver->rdb_child_pid = -1;
+    g_pserver->rdbThreadVars.fRdbThreadActive = false;
     g_pserver->rdb_child_type = RDB_CHILD_TYPE_NONE;
     g_pserver->rdb_save_time_start = -1;
 
@@ -2426,26 +2423,114 @@ void backgroundSaveDoneHandler(int exitcode, int bysignal) {
  * the child did not exit for an error, but because we wanted), and performs
  * the cleanup needed. */
 void killRDBChild(void) {
-    kill(g_pserver->rdb_child_pid,SIGUSR1);
-    rdbRemoveTempFile(g_pserver->rdb_child_pid);
+    g_pserver->rdbThreadVars.fRdbThreadCancel = true;
+    void *rval;
+    pthread_join(g_pserver->rdbThreadVars.rdb_child_thread,&rval);
+    g_pserver->rdbThreadVars.fRdbThreadActive = false;
+    g_pserver->rdbThreadVars.fRdbThreadCancel = false;
+    rdbRemoveTempFile(g_pserver->rdbThreadVars.tmpfileNum);
     closeChildInfoPipe();
     updateDictResizePolicy();
 }
 
+struct rdbSaveSocketThreadArgs
+{
+    rdbSaveInfo rsi;
+    int *fds;
+    int numfds;
+    uint64_t *clientids;
+    redisDbPersistentData *rgpdb[1];
+};
+void *rdbSaveToSlavesSocketsThread(void *vargs)
+{
+    /* Child */
+    serverAssert(serverTL == nullptr);
+    rdbSaveSocketThreadArgs *args = (rdbSaveSocketThreadArgs*)vargs;
+    int retval;
+    rio slave_sockets;
+
+    rioInitWithFdset(&slave_sockets,args->fds,args->numfds);
+    zfree(args->fds);
+    args->fds = nullptr;
+
+    retval = rdbSaveRioWithEOFMark(&slave_sockets,args->rgpdb,NULL,&args->rsi);
+    if (retval == C_OK && rioFlush(&slave_sockets) == 0)
+        retval = C_ERR;
+
+    if (retval == C_OK) {
+        size_t private_dirty = zmalloc_get_private_dirty(-1);
+
+        if (private_dirty) {
+            serverLog(LL_NOTICE,
+                "RDB: %zu MB of memory used by copy-on-write",
+                private_dirty/(1024*1024));
+        }
+
+        g_pserver->child_info_data.cow_size = private_dirty;
+        sendChildInfo(CHILD_INFO_TYPE_RDB);
+
+        /* 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> <replica[0].id> <replica[0].error> ...
+            *
+            * 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 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*args->numfds), MALLOC_LOCAL);
+        uint64_t *len = (uint64_t*)msg;
+        uint64_t *ids = len+1;
+        int j, msglen;
+
+        *len = args->numfds;
+        for (j = 0; j < args->numfds; j++) {
+            *ids++ = args->clientids[j];
+            *ids++ = slave_sockets.io.fdset.state[j];
+        }
+
+        /* Write the message to the parent. If we have no good slaves or
+            * we are unable to transfer the message to the parent, we exit
+            * with an error so that the parent will abort the replication
+            * process with all the childre that were waiting. */
+        msglen = sizeof(uint64_t)*(1+2*args->numfds);
+        if (*len == 0 ||
+            write(g_pserver->rdb_pipe_write_result_to_parent,msg,msglen)
+            != msglen)
+        {
+            retval = C_ERR;
+        }
+        zfree(msg);
+    }
+    aeAcquireLock();
+    for (int idb = 0; idb < cserver.dbnum; ++idb)
+        g_pserver->db[idb].endSnapshot(args->rgpdb[idb]);
+    aeReleaseLock();
+    zfree(args->clientids);
+    zfree(args);
+    rioFreeFdset(&slave_sockets);
+
+    return (retval == C_OK) ? (void*)0 : (void*)1;
+}
+
 /* Spawn an RDB child that writes the RDB to the sockets of the slaves
  * that are currently in SLAVE_STATE_WAIT_BGSAVE_START state. */
 int rdbSaveToSlavesSockets(rdbSaveInfo *rsi) {
     serverAssert(GlobalLocksAcquired());
-    int *fds;
-    uint64_t *clientids;
-    int numfds;
     listNode *ln;
     listIter li;
-    pid_t childpid;
+    pthread_t child;
     long long start;
     int pipefds[2];
+    rdbSaveSocketThreadArgs *args = nullptr;
 
-    if (g_pserver->aof_child_pid != -1 || g_pserver->rdb_child_pid != -1) return C_ERR;
+    if (g_pserver->aof_child_pid != -1 || g_pserver->FRdbSaveInProgress()) return C_ERR;
 
     /* Before to fork, create a pipe that will be used in order to
      * send back to the parent the IDs of the slaves that successfully
@@ -2454,22 +2539,27 @@ int rdbSaveToSlavesSockets(rdbSaveInfo *rsi) {
     g_pserver->rdb_pipe_read_result_from_child = pipefds[0];
     g_pserver->rdb_pipe_write_result_to_parent = pipefds[1];
 
+    args = (rdbSaveSocketThreadArgs*)zmalloc(sizeof(rdbSaveSocketThreadArgs) + sizeof(redisDbPersistentData*)*(cserver.dbnum-1), MALLOC_LOCAL);
+
     /* Collect the file descriptors of the slaves we want to transfer
      * the RDB to, which are i WAIT_BGSAVE_START state. */
-    fds = (int*)zmalloc(sizeof(int)*listLength(g_pserver->slaves), MALLOC_LOCAL);
+    args->fds = (int*)zmalloc(sizeof(int)*listLength(g_pserver->slaves), MALLOC_LOCAL);
     /* We also allocate an array of corresponding client IDs. This will
      * be useful for the child process in order to build the report
      * (sent via unix pipe) that will be sent to the parent. */
-    clientids = (uint64_t*)zmalloc(sizeof(uint64_t)*listLength(g_pserver->slaves), MALLOC_LOCAL);
-    numfds = 0;
+    args->clientids = (uint64_t*)zmalloc(sizeof(uint64_t)*listLength(g_pserver->slaves), MALLOC_LOCAL);
+    args->numfds = 0;
+    memcpy(&args->rsi, rsi, sizeof(rdbSaveInfo));
+    memcpy(&args->rsi.repl_id, g_pserver->replid, sizeof(g_pserver->replid));
+    args->rsi.master_repl_offset = g_pserver->master_repl_offset;
 
     listRewind(g_pserver->slaves,&li);
     while((ln = listNext(&li))) {
         client *replica = (client*)ln->value;
 
         if (replica->replstate == SLAVE_STATE_WAIT_BGSAVE_START) {
-            clientids[numfds] = replica->id;
-            fds[numfds++] = replica->fd;
+            args->clientids[args->numfds] = replica->id;
+            args->fds[args->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
@@ -2482,126 +2572,63 @@ int rdbSaveToSlavesSockets(rdbSaveInfo *rsi) {
     /* Create the child process. */
     openChildInfoPipe();
     start = ustime();
-    if ((childpid = fork()) == 0) {
-        /* Child */
-        int retval;
-        rio slave_sockets;
 
-        rioInitWithFdset(&slave_sockets,fds,numfds);
-        zfree(fds);
+    for (int idb = 0; idb < cserver.dbnum; ++idb)
+        args->rgpdb[idb] = g_pserver->db[idb].createSnapshot().get();
 
-        closeListeningSockets(0);
-        redisSetProcTitle("keydb-rdb-to-slaves");
+    g_pserver->rdbThreadVars.tmpfileNum++;
+    g_pserver->rdbThreadVars.fRdbThreadCancel = false;
+    if (pthread_create(&child, nullptr, rdbSaveToSlavesSocketsThread, args)) {
+        serverLog(LL_WARNING,"Can't save in background: fork: %s",
+            strerror(errno));
 
-        retval = rdbSaveRioWithEOFMark(&slave_sockets,NULL,rsi);
-        if (retval == C_OK && rioFlush(&slave_sockets) == 0)
-            retval = C_ERR;
+        /* Undo the state change. The caller will perform cleanup on
+            * all the slaves in BGSAVE_START state, but an early call to
+            * replicationSetupSlaveForFullResync() turned it into BGSAVE_END */
+        listRewind(g_pserver->slaves,&li);
+        while((ln = listNext(&li))) {
+            client *replica = (client*)ln->value;
+            int j;
 
-        if (retval == C_OK) {
-            size_t private_dirty = zmalloc_get_private_dirty(-1);
-
-            if (private_dirty) {
-                serverLog(LL_NOTICE,
-                    "RDB: %zu MB of memory used by copy-on-write",
-                    private_dirty/(1024*1024));
-            }
-
-            g_pserver->child_info_data.cow_size = private_dirty;
-            sendChildInfo(CHILD_INFO_TYPE_RDB);
-
-            /* 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> <replica[0].id> <replica[0].error> ...
-             *
-             * 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 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);
-            uint64_t *len = (uint64_t*)msg;
-            uint64_t *ids = len+1;
-            int j, msglen;
-
-            *len = numfds;
-            for (j = 0; j < numfds; j++) {
-                *ids++ = clientids[j];
-                *ids++ = slave_sockets.io.fdset.state[j];
-            }
-
-            /* Write the message to the parent. If we have no good slaves or
-             * we are unable to transfer the message to the parent, we exit
-             * with an error so that the parent will abort the replication
-             * process with all the childre that were waiting. */
-            msglen = sizeof(uint64_t)*(1+2*numfds);
-            if (*len == 0 ||
-                write(g_pserver->rdb_pipe_write_result_to_parent,msg,msglen)
-                != msglen)
-            {
-                retval = C_ERR;
-            }
-            zfree(msg);
-        }
-        zfree(clientids);
-        rioFreeFdset(&slave_sockets);
-        exitFromChild((retval == C_OK) ? 0 : 1);
-    } else {
-        /* Parent */
-        if (childpid == -1) {
-            serverLog(LL_WARNING,"Can't save in background: fork: %s",
-                strerror(errno));
-
-            /* Undo the state change. The caller will perform cleanup on
-             * all the slaves in BGSAVE_START state, but an early call to
-             * replicationSetupSlaveForFullResync() turned it into BGSAVE_END */
-            listRewind(g_pserver->slaves,&li);
-            while((ln = listNext(&li))) {
-                client *replica = (client*)ln->value;
-                int j;
-
-                for (j = 0; j < numfds; j++) {
-                    if (replica->id == clientids[j]) {
-                        replica->replstate = SLAVE_STATE_WAIT_BGSAVE_START;
-                        break;
-                    }
+            for (j = 0; j < args->numfds; j++) {
+                if (replica->id == args->clientids[j]) {
+                    replica->replstate = SLAVE_STATE_WAIT_BGSAVE_START;
+                    break;
                 }
             }
-            close(pipefds[0]);
-            close(pipefds[1]);
-            closeChildInfoPipe();
-        } else {
-            g_pserver->stat_fork_time = ustime()-start;
-            g_pserver->stat_fork_rate = (double) zmalloc_used_memory() * 1000000 / g_pserver->stat_fork_time / (1024*1024*1024); /* GB per second. */
-            latencyAddSampleIfNeeded("fork",g_pserver->stat_fork_time/1000);
-
-            serverLog(LL_NOTICE,"Background RDB transfer started by pid %d",
-                childpid);
-            g_pserver->rdb_save_time_start = time(NULL);
-            g_pserver->rdb_child_pid = childpid;
-            g_pserver->rdb_child_type = RDB_CHILD_TYPE_SOCKET;
-            updateDictResizePolicy();
         }
-        zfree(clientids);
-        zfree(fds);
-        return (childpid == -1) ? C_ERR : C_OK;
+        close(pipefds[0]);
+        close(pipefds[1]);
+        closeChildInfoPipe();
+        for (int idb = 0; idb < cserver.dbnum; ++idb)
+            g_pserver->db[idb].endSnapshot(args->rgpdb[idb]);
+        zfree(args->clientids);
+        zfree(args->fds);
+        zfree(args);
+        return C_ERR;
     }
+
+    g_pserver->stat_fork_time = ustime()-start;
+    g_pserver->stat_fork_rate = (double) zmalloc_used_memory() * 1000000 / g_pserver->stat_fork_time / (1024*1024*1024); /* GB per second. */
+    latencyAddSampleIfNeeded("fork",g_pserver->stat_fork_time/1000);
+
+    serverLog(LL_NOTICE,"Background RDB transfer started");
+    g_pserver->rdb_save_time_start = time(NULL);
+    g_pserver->rdbThreadVars.rdb_child_thread = child;
+    g_pserver->rdbThreadVars.fRdbThreadActive = true;
+    g_pserver->rdb_child_type = RDB_CHILD_TYPE_SOCKET;
+    updateDictResizePolicy();
     return C_OK; /* Unreached. */
 }
 
 void saveCommand(client *c) {
-    if (g_pserver->rdb_child_pid != -1) {
+    if (g_pserver->FRdbSaveInProgress()) {
         addReplyError(c,"Background save already in progress");
         return;
     }
     rdbSaveInfo rsi, *rsiptr;
     rsiptr = rdbPopulateSaveInfo(&rsi);
-    if (rdbSave(rsiptr) == C_OK) {
+    if (rdbSave(nullptr, rsiptr) == C_OK) {
         addReply(c,shared.ok);
     } else {
         addReply(c,shared.err);
@@ -2626,7 +2653,7 @@ void bgsaveCommand(client *c) {
     rdbSaveInfo rsi, *rsiptr;
     rsiptr = rdbPopulateSaveInfo(&rsi);
 
-    if (g_pserver->rdb_child_pid != -1) {
+    if (g_pserver->FRdbSaveInProgress()) {
         addReplyError(c,"Background save already in progress");
     } else if (g_pserver->aof_child_pid != -1) {
         if (schedule) {
@@ -2658,6 +2685,9 @@ rdbSaveInfo *rdbPopulateSaveInfo(rdbSaveInfo *rsi) {
     rdbSaveInfo rsi_init = RDB_SAVE_INFO_INIT;
     *rsi = rsi_init;
 
+    memcpy(rsi->repl_id, g_pserver->replid, sizeof(g_pserver->replid));
+    rsi->master_repl_offset = g_pserver->master_repl_offset;
+
     /* 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

src/rdb.h

@@ -91,13 +91,10 @@
 #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) || (t == RDB_TYPE_CRON))
+#define rdbIsObjectType(t) ((t >= 0 && t <= 7) || (t >= 9 && t <= 15))
 
 /* Special RDB opcodes (saved/loaded with rdbSaveType/rdbLoadType). */
 #define RDB_OPCODE_MODULE_AUX 247   /* Module auxiliary data. */
@@ -142,11 +139,11 @@ 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 rdbSaveFp(FILE *pf, rdbSaveInfo *rsi);
-int rdbSaveS3(char *path, rdbSaveInfo *rsi);
+void rdbRemoveTempFile(int childpid);
+int rdbSave(redisDbPersistentData **rgpdb, rdbSaveInfo *rsi);
+int rdbSaveFile(char *filename, redisDbPersistentData **rgpdb, rdbSaveInfo *rsi);
+int rdbSaveFp(FILE *pf, redisDbPersistentData **rgpdb, rdbSaveInfo *rsi);
+int rdbSaveS3(char *path, redisDbPersistentData **rgpdb, rdbSaveInfo *rsi);
 int rdbLoadS3(char *path, rdbSaveInfo *rsi);
 ssize_t rdbSaveObject(rio *rdb, robj_roptr o, robj *key);
 size_t rdbSavedObjectLen(robj *o);

src/redis-benchmark.cpp

@@ -173,8 +173,6 @@ 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);

src/redis-cli.c

@@ -57,7 +57,6 @@
 #include "anet.h"
 #include "ae.h"
 #include "storage.h"
-#include "motd.h"
 
 #include "redis-cli.h"
 
@@ -91,11 +90,6 @@ 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
  *--------------------------------------------------------------------------- */
@@ -6540,6 +6534,116 @@ static void intrinsicLatencyMode(void) {
     }
 }
 
+/*------------------------------------------------------------------------------
+ * Message of the day
+ *--------------------------------------------------------------------------- */
+#ifdef MOTD
+#include <curl/curl.h> 
+
+static const char *szMotdCachePath()
+{
+    static sds sdsMotdCachePath = NULL;
+    if (sdsMotdCachePath != NULL)
+        return sdsMotdCachePath;
+
+    struct passwd *pw = getpwuid(getuid());
+    if (pw == NULL)
+        return "";
+    const char *homedir = pw->pw_dir;
+    sdsMotdCachePath = sdsnew(homedir);
+    sdsMotdCachePath = sdscat(sdsMotdCachePath, "/.keydb-cli-motd");
+    return sdsMotdCachePath;
+}
+static size_t motd_write_callback(void *ptr, size_t size, size_t nmemb, sds *str)
+{
+    *str = sdscatlen(*str, ptr, size*nmemb);
+    return (size*nmemb);
+}
+
+static char *fetchMOTDFromCache()
+{
+    struct stat attrib;
+    if (stat(szMotdCachePath(), &attrib) != 0)
+        return NULL;
+    time_t t = attrib.st_mtim.tv_sec;
+    time_t now = time(NULL);
+    if ((now - t) < 14400)
+    {
+        // If our cache was updated no more than 4 hours ago use it instead of fetching the MOTD
+        FILE *pf = fopen(szMotdCachePath(), "rb");
+        if (pf == NULL)
+            return NULL;
+        fseek(pf, 0L, SEEK_END);
+        long cb = ftell(pf);
+        fseek(pf, 0L, SEEK_SET);    // rewind
+        sds str = sdsnewlen(NULL, cb);
+        size_t cbRead = fread(str, 1, cb, pf);
+        fclose(pf);
+        if ((long)cbRead != cb)
+        {
+            sdsfree(str);
+            return NULL;
+        }
+        return str;
+    }
+    return NULL;
+}
+
+static void setMOTDCache(const char *sz)
+{
+    FILE *pf = fopen(szMotdCachePath(), "wb");
+    size_t celem = fwrite(sz, strlen(sz), 1, pf);
+    (void)celem;    // best effort
+    fclose(pf);
+}
+
+static char *fetchMOTD()
+{
+    sds str;
+    CURL *curl;
+    CURLcode res;
+
+    /* First try and get the string from the cache */
+    str = fetchMOTDFromCache();
+    if (str != NULL)
+        return str;
+
+    str = sdsnew("");
+    curl = curl_easy_init();
+    if(curl) {
+        curl_easy_setopt(curl, CURLOPT_URL, "http://api.keydb.dev/motd/motd.txt");
+        curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L); // follow redirects
+        curl_easy_setopt(curl, CURLOPT_TIMEOUT, 2); // take no more than two seconds
+        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, motd_write_callback);
+        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &str);
+
+        /* Perform the request, res will get the return code */ 
+        res = curl_easy_perform(curl);
+        /* Check for errors */ 
+        if(res != CURLE_OK)
+        {
+            sdsfree(str);
+            str = NULL;
+        }
+
+        /* always cleanup */ 
+        curl_easy_cleanup(curl);
+
+        if (str != NULL)
+            setMOTDCache(str);
+    }
+    return str;
+}
+
+#else
+
+static char *fetchMOTD()
+{
+    return NULL;
+}
+
+#endif
+
 /*------------------------------------------------------------------------------
  * Program main()
  *--------------------------------------------------------------------------- */
@@ -6710,7 +6814,7 @@ int main(int argc, char **argv) {
     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 */);
+            char *szMotd = fetchMOTD();
             if (szMotd != NULL) {
                 printf("Message of the day:\n  %s\n", szMotd);
                 sdsfree(szMotd);

src/replication.cpp

@@ -42,15 +42,12 @@
 #include <algorithm>
 #include <uuid/uuid.h>
 #include <chrono>
-#include <unordered_map>
-#include <string>
 
 void replicationDiscardCachedMaster(redisMaster *mi);
 void replicationResurrectCachedMaster(redisMaster *mi, int newfd);
 void replicationSendAck(redisMaster *mi);
 void putSlaveOnline(client *replica);
 int cancelReplicationHandshake(redisMaster *mi);
-static void propagateMasterStaleKeys();
 
 /* --------------------------- Utility functions ---------------------------- */
 
@@ -132,23 +129,6 @@ static bool FAnyDisconnectedMasters()
     return false;
 }
 
-client *replicaFromMaster(redisMaster *mi)
-{
-    if (mi->master == nullptr)
-        return nullptr;
-
-    listIter liReplica;
-    listNode *lnReplica;
-    listRewind(g_pserver->slaves, &liReplica);
-    while ((lnReplica = listNext(&liReplica)) != nullptr)
-    {
-        client *replica = (client*)listNodeValue(lnReplica);
-        if (FSameHost(mi->master, replica))
-            return replica;
-    }
-    return nullptr;
-}
-
 /* ---------------------------------- MASTER -------------------------------- */
 
 void createReplicationBacklog(void) {
@@ -278,7 +258,7 @@ void replicationFeedSlave(client *replica, int dictid, robj **argv, int argc, bo
         if (g_pserver->repl_backlog && fSendRaw) feedReplicationBacklogWithObject(selectcmd);
 
         /* Send it to slaves */
-        addReplyAsync(replica,selectcmd);
+        addReply(replica,selectcmd);
 
         if (dictid < 0 || dictid >= PROTO_SHARED_SELECT_CMDS)
             decrRefCount(selectcmd);
@@ -290,12 +270,12 @@ void replicationFeedSlave(client *replica, int dictid, robj **argv, int argc, bo
      * or are already in sync with the master. */
 
     /* Add the multi bulk length. */
-    addReplyArrayLenAsync(replica,argc);
+    addReplyArrayLen(replica,argc);
 
     /* Finally any additional argument that was not stored inside the
         * static buffer if any (from j to argc). */
     for (int j = 0; j < argc; j++)
-        addReplyBulkAsync(replica,argv[j]);
+        addReplyBulk(replica,argv[j]);
 }
 
 /* Propagate write commands to slaves, and populate the replication backlog
@@ -345,21 +325,12 @@ void replicationFeedSlaves(list *slaves, int dictid, robj **argv, int argc) {
     char uuid[40] = {'\0'};
     uuid_unparse(cserver.uuid, uuid);
     char proto[1024];
-    int cchProto = snprintf(proto, sizeof(proto), "*5\r\n$7\r\nRREPLAY\r\n$%d\r\n%s\r\n$%lld\r\n", (int)strlen(uuid), uuid, cchbuf);
+    int cchProto = snprintf(proto, sizeof(proto), "*4\r\n$7\r\nRREPLAY\r\n$%d\r\n%s\r\n$%lld\r\n", (int)strlen(uuid), uuid, cchbuf);
     cchProto = std::min((int)sizeof(proto), cchProto);
     long long master_repl_offset_start = g_pserver->master_repl_offset;
     
     char szDbNum[128];
-    int cchDictIdNum = snprintf(szDbNum, sizeof(szDbNum), "%d", dictid);
-    int cchDbNum = snprintf(szDbNum, sizeof(szDbNum), "$%d\r\n%d\r\n", cchDictIdNum, dictid);
-    cchDbNum = std::min<int>(cchDbNum, sizeof(szDbNum)); // snprintf is tricky like that
-
-    char szMvcc[128];
-    incrementMvccTstamp();
-    uint64_t mvccTstamp = getMvccTstamp();
-    int cchMvccNum = snprintf(szMvcc, sizeof(szMvcc), "%" PRIu64, mvccTstamp);
-    int cchMvcc = snprintf(szMvcc, sizeof(szMvcc), "$%d\r\n%" PRIu64 "\r\n", cchMvccNum, mvccTstamp);
-    cchMvcc = std::min<int>(cchMvcc, sizeof(szMvcc));    // tricky snprintf
+    int cchDbNum = snprintf(szDbNum, sizeof(szDbNum), "$%d\r\n%d\r\n", (dictid/10)+1, dictid);
 
     /* Write the command to the replication backlog if any. */
     if (g_pserver->repl_backlog) 
@@ -403,7 +374,6 @@ void replicationFeedSlaves(list *slaves, int dictid, robj **argv, int argc) {
             const char *crlf = "\r\n";
             feedReplicationBacklog(crlf, 2);
             feedReplicationBacklog(szDbNum, cchDbNum);
-            feedReplicationBacklog(szMvcc, cchMvcc);
         }
     }
 
@@ -414,11 +384,7 @@ void replicationFeedSlaves(list *slaves, int dictid, robj **argv, int argc) {
 
         /* Don't feed slaves that are still waiting for BGSAVE to start */
         if (replica->replstate == SLAVE_STATE_WAIT_BGSAVE_START) continue;
-        if (replica->flags & CLIENT_CLOSE_ASAP) continue;
-        std::unique_lock<decltype(replica->lock)> lock(replica->lock, std::defer_lock);
-		// When writing to clients on other threads the global lock is sufficient provided we only use AddReply*Async()
-		if (FCorrectThread(replica))
-			lock.lock();
+        std::unique_lock<decltype(replica->lock)> lock(replica->lock);
         if (serverTL->current_client && FSameHost(serverTL->current_client, replica))
         {
             replica->reploff_skipped += g_pserver->master_repl_offset - master_repl_offset_start;
@@ -435,12 +401,10 @@ void replicationFeedSlaves(list *slaves, int dictid, robj **argv, int argc) {
             clientReplyBlock* reply = (clientReplyBlock*)listNodeValue(lnReply);
             addReplyProtoAsync(replica, reply->buf(), reply->used);
         }
-
         if (!fSendRaw)
         {
             addReplyAsync(replica,shared.crlf);
             addReplyProtoAsync(replica, szDbNum, cchDbNum);
-            addReplyProtoAsync(replica, szMvcc, cchMvcc);
         }
     }
 
@@ -469,9 +433,7 @@ void replicationFeedSlavesFromMasterStream(list *slaves, char *buf, size_t bufle
 
     while((ln = listNext(&li))) {
         client *replica = (client*)ln->value;
-        std::unique_lock<decltype(replica->lock)> ulock(replica->lock, std::defer_lock);
-		if (FCorrectThread(replica))
-			ulock.lock();
+        std::lock_guard<decltype(replica->lock)> ulock(replica->lock);
         if (FMasterHost(replica))
             continue;   // Active Active case, don't feed back
 
@@ -520,10 +482,7 @@ void replicationFeedMonitors(client *c, list *monitors, int dictid, robj **argv,
     listRewind(monitors,&li);
     while((ln = listNext(&li))) {
         client *monitor = (client*)ln->value;
-		std::unique_lock<decltype(monitor->lock)> lock(monitor->lock, std::defer_lock);
-		// When writing to clients on other threads the global lock is sufficient provided we only use AddReply*Async()
-		if (FCorrectThread(c))
-			lock.lock();
+        std::lock_guard<decltype(monitor->lock)> lock(monitor->lock);
         addReplyAsync(monitor,cmdobj);
     }
     decrRefCount(cmdobj);
@@ -701,7 +660,6 @@ int masterTryPartialResynchronization(client *c) {
     c->repl_ack_time = g_pserver->unixtime;
     c->repl_put_online_on_ack = 0;
     listAddNodeTail(g_pserver->slaves,c);
-
     /* We can't use the connection buffers since they are used to accumulate
      * new commands at this stage. But we are sure the socket send buffer is
      * empty so this write will never fail actually. */
@@ -900,7 +858,7 @@ void syncCommand(client *c) {
     }
 
     /* CASE 1: BGSAVE is in progress, with disk target. */
-    if (g_pserver->rdb_child_pid != -1 &&
+    if (g_pserver->FRdbSaveInProgress() &&
         g_pserver->rdb_child_type == RDB_CHILD_TYPE_DISK)
     {
         /* Ok a background save is in progress. Let's check if it is a good
@@ -931,7 +889,7 @@ void syncCommand(client *c) {
         }
 
     /* CASE 2: BGSAVE is in progress, with socket target. */
-    } else if (g_pserver->rdb_child_pid != -1 &&
+    } else if (g_pserver->FRdbSaveInProgress() &&
                g_pserver->rdb_child_type == RDB_CHILD_TYPE_SOCKET)
     {
         /* There is an RDB child process but it is writing directly to
@@ -1035,8 +993,6 @@ void replconfCommand(client *c) {
                 c->slave_capa |= SLAVE_CAPA_EOF;
             else if (!strcasecmp((const char*)ptrFromObj(c->argv[j+1]),"psync2"))
                 c->slave_capa |= SLAVE_CAPA_PSYNC2;
-            else if (!strcasecmp((const char*)ptrFromObj(c->argv[j+1]), "activeExpire"))
-                c->slave_capa |= SLAVE_CAPA_ACTIVE_EXPIRE;
         } else if (!strcasecmp((const char*)ptrFromObj(c->argv[j]),"ack")) {
             /* REPLCONF ACK is used by replica to inform the master the amount
              * of replication stream that it processed so far. It is an
@@ -1106,14 +1062,6 @@ void putSlaveOnline(client *replica) {
     refreshGoodSlavesCount();
     serverLog(LL_NOTICE,"Synchronization with replica %s succeeded",
         replicationGetSlaveName(replica));
-    
-    if (!(replica->slave_capa & SLAVE_CAPA_ACTIVE_EXPIRE) && g_pserver->fActiveReplica)
-    {
-        serverLog(LL_WARNING, "Warning: replica %s does not support active expiration.  This client may not correctly process key expirations."
-            "\n\tThis is OK if you are in the process of an active upgrade.", replicationGetSlaveName(replica));
-        serverLog(LL_WARNING, "Connections between active replicas and traditional replicas is deprecated.  This will be refused in future versions."
-            "\n\tPlease fix your replica topology");
-    }
 }
 
 void sendBulkToSlave(aeEventLoop *el, int fd, void *privdata, int mask) {
@@ -1257,21 +1205,7 @@ void updateSlavesWaitingBgsave(int bgsaveerr, int type)
                 }
                 else
                 {
-                    aePostFunction(g_pserver->rgthreadvar[replica->iel].el, [replica] {
-                        // Because the client could have been closed while the lambda waited to run we need to
-			            // verify the replica is still connected
-                        listIter li;
-                        listNode *ln;
-                        listRewind(g_pserver->slaves,&li);
-                        bool fFound = false;
-                        while ((ln = listNext(&li))) {
-                            if (listNodeValue(ln) == replica) {
-                                fFound = true;
-                                break;
-                            }
-                        }
-                        if (!fFound)
-                            return;
+                    aePostFunction(g_pserver->rgthreadvar[replica->iel].el, [replica]{
                         aeDeleteFileEvent(g_pserver->rgthreadvar[replica->iel].el,replica->fd,AE_WRITABLE);
                         if (aeCreateFileEvent(g_pserver->rgthreadvar[replica->iel].el, replica->fd, AE_WRITABLE, sendBulkToSlave, replica) == AE_ERR) {
                             freeClient(replica);
@@ -1576,13 +1510,12 @@ void readSyncBulkPayload(aeEventLoop *el, int fd, void *privdata, int mask) {
         int aof_is_enabled = g_pserver->aof_state != AOF_OFF;
 
         /* Ensure background save doesn't overwrite synced data */
-        if (g_pserver->rdb_child_pid != -1) {
+        if (g_pserver->FRdbSaveInProgress()) {
             serverLog(LL_NOTICE,
                 "Replica is about to load the RDB file received from the "
                 "master, but there is a pending RDB child running. "
-                "Killing process %ld and removing its temp file to avoid "
-                "any race",
-                    (long) g_pserver->rdb_child_pid);
+                "Cancelling RDB the save and removing its temp file to avoid "
+                "any race");
             killRDBChild();
         }
 
@@ -1619,15 +1552,6 @@ void readSyncBulkPayload(aeEventLoop *el, int fd, void *privdata, int mask) {
         aeDeleteFileEvent(el,mi->repl_transfer_s,AE_READABLE);
         serverLog(LL_NOTICE, "MASTER <-> REPLICA sync: Loading DB in memory");
         rdbSaveInfo rsi = RDB_SAVE_INFO_INIT;
-        if (g_pserver->fActiveReplica)
-        {
-            rsi.mvccMinThreshold = mi->mvccLastSync;
-            if (mi->staleKeyMap != nullptr)
-                mi->staleKeyMap->clear();
-            else
-                mi->staleKeyMap = new (MALLOC_LOCAL) std::map<int, std::vector<robj_sharedptr>>();
-            rsi.mi = mi;
-        }
         if (rdbLoadFile(rdb_filename, &rsi) != C_OK) {
             serverLog(LL_WARNING,"Failed trying to load the MASTER synchronization DB from disk");
             cancelReplicationHandshake(mi);
@@ -2146,16 +2070,8 @@ void syncWithMaster(aeEventLoop *el, int fd, void *privdata, int mask) {
      *
      * The master will ignore capabilities it does not understand. */
     if (mi->repl_state == REPL_STATE_SEND_CAPA) {
-        if (g_pserver->fActiveReplica)
-        {
-            err = sendSynchronousCommand(mi, SYNC_CMD_WRITE,fd,"REPLCONF",
-                    "capa","eof","capa","psync2","capa","activeExpire",NULL);
-        }
-        else
-        {
-            err = sendSynchronousCommand(mi, SYNC_CMD_WRITE,fd,"REPLCONF",
-                    "capa","eof","capa","psync2",NULL);
-        }
+        err = sendSynchronousCommand(mi, SYNC_CMD_WRITE,fd,"REPLCONF",
+                "capa","eof","capa","psync2",NULL);
         if (err) goto write_error;
         sdsfree(err);
         mi->repl_state = REPL_STATE_RECEIVE_CAPA;
@@ -2302,8 +2218,7 @@ int connectWithMaster(redisMaster *mi) {
     fd = anetTcpNonBlockBestEffortBindConnect(NULL,
         mi->masterhost,mi->masterport,NET_FIRST_BIND_ADDR);
     if (fd == -1) {
-        int sev = g_pserver->enable_multimaster ? LL_NOTICE : LL_WARNING;   // with multimaster its not unheard of to intentiallionall have downed masters
-        serverLog(sev,"Unable to connect to MASTER: %s",
+        serverLog(LL_WARNING,"Unable to connect to MASTER: %s",
             strerror(errno));
         return C_ERR;
     }
@@ -2329,11 +2244,10 @@ int connectWithMaster(redisMaster *mi) {
 void undoConnectWithMaster(redisMaster *mi) {
     int fd = mi->repl_transfer_s;
 
-    int res = aePostFunction(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el, [fd]{
+    aePostFunction(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el, [fd]{
         aeDeleteFileEvent(g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN].el,fd,AE_READABLE|AE_WRITABLE);
         close(fd);
     });
-    serverAssert(res == AE_OK);
     mi->repl_transfer_s = -1;
 }
 
@@ -2425,7 +2339,6 @@ void freeMasterInfo(redisMaster *mi)
 {
     zfree(mi->masterauth);
     zfree(mi->masteruser);
-    delete mi->staleKeyMap;
     zfree(mi);
 }
 
@@ -3062,12 +2975,12 @@ void replicationCron(void) {
         if (mi->masterhost && mi->repl_state == REPL_STATE_TRANSFER &&
             (time(NULL)-mi->repl_transfer_lastio) > g_pserver->repl_timeout)
         {
-            serverLog(LL_WARNING,"Timeout receiving bulk data from MASTER... If the problem persists try to set the 'repl-timeout' parameter in keydb.conf to a larger value.");
+            serverLog(LL_WARNING,"Timeout receiving bulk data from MASTER... If the problem persists try to set the 'repl-timeout' parameter in redis.conf to a larger value.");
             cancelReplicationHandshake(mi);
         }
 
         /* Timed out master when we are an already connected replica? */
-        if (mi->masterhost && mi->master && mi->repl_state == REPL_STATE_CONNECTED &&
+        if (mi->masterhost && mi->repl_state == REPL_STATE_CONNECTED &&
             (time(NULL)-mi->master->lastinteraction) > g_pserver->repl_timeout)
         {
             serverLog(LL_WARNING,"MASTER timeout: no data nor PING received...");
@@ -3229,7 +3142,7 @@ void replicationCron(void) {
     * In case of diskless replication, we make sure to wait the specified
     * number of seconds (according to configuration) so that other slaves
     * have the time to arrive before we start streaming. */
-    if (g_pserver->rdb_child_pid == -1 && g_pserver->aof_child_pid == -1) {
+    if (!g_pserver->FRdbSaveInProgress() && g_pserver->aof_child_pid == -1) {
         time_t idle, max_idle = 0;
         int slaves_waiting = 0;
         int mincapa = -1;
@@ -3259,8 +3172,6 @@ void replicationCron(void) {
         }
     }
 
-    propagateMasterStaleKeys();
-
     /* Refresh the number of slaves with lag <= min-slaves-max-lag. */
     refreshGoodSlavesCount();
     replication_cron_loops++; /* Incremented with frequency 1 HZ. */
@@ -3349,40 +3260,16 @@ public:
         return m_cnesting == 1;
     }
 
-    redisMaster *getMi(client *c)
-    {
-        if (m_mi == nullptr)
-            m_mi = MasterInfoFromClient(c);
-        return m_mi;
-    }
-
-    int nesting() const { return m_cnesting; }
-
 private:
     int m_cnesting = 0;
     bool m_fCancelled = false;
-    redisMaster *m_mi = nullptr;
 };
 
-static thread_local std::unique_ptr<ReplicaNestState> s_pstate;
-
-bool FInReplicaReplay()
-{
-    return s_pstate != nullptr && s_pstate->nesting() > 0;
-}
-
-struct RemoteMasterState
-{
-    uint64_t mvcc = 0;
-    client *cFake = nullptr;
-};
-
-static std::unordered_map<std::string, RemoteMasterState> g_mapremote;
-
 void replicaReplayCommand(client *c)
 {
+    static thread_local ReplicaNestState *s_pstate = nullptr;
     if (s_pstate == nullptr)
-        s_pstate = std::make_unique<ReplicaNestState>();
+        s_pstate = new (MALLOC_LOCAL) ReplicaNestState;
 
     // the replay command contains two arguments: 
     //  1: The UUID of the source
@@ -3404,10 +3291,9 @@ void replicaReplayCommand(client *c)
         return;
     }
 
-    std::string uuid;
-    uuid.resize(UUID_BINARY_LEN);
+    unsigned char uuid[UUID_BINARY_LEN];
     if (c->argv[1]->type != OBJ_STRING || sdslen((sds)ptrFromObj(c->argv[1])) != 36 
-        || uuid_parse((sds)ptrFromObj(c->argv[1]), (unsigned char*)uuid.data()) != 0)
+        || uuid_parse((sds)ptrFromObj(c->argv[1]), uuid) != 0)
     {
         addReplyError(c, "Expected UUID arg1");
         s_pstate->Cancel();
@@ -3432,18 +3318,7 @@ void replicaReplayCommand(client *c)
         }
     }
 
-    uint64_t mvcc = 0;
-    if (c->argc >= 5)
-    {
-        if (getUnsignedLongLongFromObject(c->argv[4], &mvcc) != C_OK)
-        {
-            addReplyError(c, "Invalid MVCC Timestamp");
-            s_pstate->Cancel();
-            return;
-        }
-    }
-
-    if (FSameUuidNoNil((unsigned char*)uuid.data(), cserver.uuid))
+    if (FSameUuidNoNil(uuid, cserver.uuid))
     {
         addReply(c, shared.ok);
         s_pstate->Cancel();
@@ -3453,51 +3328,28 @@ void replicaReplayCommand(client *c)
     if (!s_pstate->FPush())
         return;
 
-    RemoteMasterState &remoteState = g_mapremote[uuid];
-    if (remoteState.cFake == nullptr)
-        remoteState.cFake = createClient(-1, c->iel);
-    else
-        remoteState.cFake->iel = c->iel;
-
-    client *cFake = remoteState.cFake;
-
-    if (mvcc != 0 && remoteState.mvcc >= mvcc)
-    {
-        s_pstate->Cancel();
-        s_pstate->Pop();
-        return;
-    }
-
     // OK We've recieved a command lets execute
     client *current_clientSave = serverTL->current_client;
+    client *cFake = createClient(-1, c->iel);
     cFake->lock.lock();
     cFake->authenticated = c->authenticated;
     cFake->puser = c->puser;
     cFake->querybuf = sdscatsds(cFake->querybuf,(sds)ptrFromObj(c->argv[2]));
     selectDb(cFake, c->db->id);
     auto ccmdPrev = serverTL->commandsExecuted;
-    cFake->flags |= CLIENT_MASTER | CLIENT_PREVENT_REPL_PROP;
     processInputBuffer(cFake, (CMD_CALL_FULL & (~CMD_CALL_PROPAGATE)));
-    cFake->flags &= ~(CLIENT_MASTER | CLIENT_PREVENT_REPL_PROP);
     bool fExec = ccmdPrev != serverTL->commandsExecuted;
     cFake->lock.unlock();
-    if (cFake->master_error)
-    {
-        addReplyError(c, "Error in rreplay command, please check logs.");
-    }
-    if (fExec || cFake->flags & CLIENT_MULTI)
+    if (fExec)
     {
         addReply(c, shared.ok);
         selectDb(c, cFake->db->id);
-        if (mvcc > remoteState.mvcc)
-            remoteState.mvcc = mvcc;
     }
     else
     {
-        serverLog(LL_WARNING, "Command didn't execute: %s", cFake->buf);
         addReplyError(c, "command did not execute");
     }
-    serverAssert(sdslen(cFake->querybuf) == 0);
+    freeClient(cFake);
     serverTL->current_client = current_clientSave;
 
     // call() will not propogate this for us, so we do so here
@@ -3525,44 +3377,4 @@ void updateMasterAuth()
         if (cserver.default_masteruser)
             mi->masteruser = zstrdup(cserver.default_masteruser);
     }
-}
-
-static void propagateMasterStaleKeys()
-{
-    listIter li;
-    listNode *ln;
-    listRewind(g_pserver->masters, &li);
-    robj *rgobj[2];
-
-    rgobj[0] = createEmbeddedStringObject("DEL", 3);
-
-    while ((ln = listNext(&li)) != nullptr)
-    {
-        redisMaster *mi = (redisMaster*)listNodeValue(ln);
-        if (mi->staleKeyMap != nullptr)
-        {
-            if (mi->master != nullptr)
-            {
-                for (auto &pair : *mi->staleKeyMap)
-                {
-                    if (pair.second.empty())
-                        continue;
-                    
-                    client *replica = replicaFromMaster(mi);
-                    if (replica == nullptr)
-                        continue;
-
-                    for (auto &spkey : pair.second)
-                    {
-                        rgobj[1] = spkey.get();
-                        replicationFeedSlave(replica, pair.first, rgobj, 2, false);
-                    }
-                }
-                delete mi->staleKeyMap;
-                mi->staleKeyMap = nullptr;
-            }
-        }
-    }
-
-    decrRefCount(rgobj[0]);
-}
+}

src/rio.cpp

@@ -73,6 +73,14 @@ static size_t rioBufferRead(rio *r, void *buf, size_t len) {
     return 1;
 }
 
+static size_t rioConstBufferRead(rio *r, void *buf, size_t len) {
+     if (r->io.buffer.len-r->io.buffer.pos < (off_t)len)
+        return 0; /* not enough buffer to return len bytes. */
+    memcpy(buf,r->io.buffer.ptr+r->io.buffer.pos,len);
+    r->io.buffer.pos += len;
+    return 1;
+}
+
 /* Returns read/write position in buffer. */
 static off_t rioBufferTell(rio *r) {
     return r->io.buffer.pos;
@@ -97,12 +105,32 @@ static const rio rioBufferIO = {
     { { NULL, 0 } } /* union for io-specific vars */
 };
 
+static const rio rioConstBufferIO = {
+    rioConstBufferRead,
+    nullptr,
+    rioBufferTell,
+    rioBufferFlush,
+    NULL,           /* update_checksum */
+    0,              /* current checksum */
+    0,              /* bytes read or written */
+    0,              /* read/write chunk size */
+    { { NULL, 0 } } /* union for io-specific vars */
+};
+
 void rioInitWithBuffer(rio *r, sds s) {
     *r = rioBufferIO;
     r->io.buffer.ptr = s;
     r->io.buffer.pos = 0;
 }
 
+void rioInitWithConstBuffer(rio *r, const void *buf, size_t cb)
+{
+    *r = rioConstBufferIO;
+    r->io.buffer.ptr = (sds)buf;
+    r->io.buffer.pos = 0;
+    r->io.buffer.len = cb;
+}
+
 /* --------------------- Stdio file pointer implementation ------------------- */
 
 /* Returns 1 or 0 for success/failure. */

src/rio.h

@@ -70,6 +70,7 @@ struct _rio {
         struct {
             sds ptr;
             off_t pos;
+            off_t len;  // For const buffers only
         } buffer;
         /* Stdio file pointer target. */
         struct {
@@ -130,6 +131,7 @@ static inline int rioFlush(rio *r) {
 
 void rioInitWithFile(rio *r, FILE *fp);
 void rioInitWithBuffer(rio *r, sds s);
+void rioInitWithConstBuffer(rio *r, const void *rgch, size_t cch);
 void rioInitWithFdset(rio *r, int *fds, int numfds);
 
 void rioFreeFdset(rio *r);

src/sds.c

@@ -53,18 +53,11 @@ 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(ssize_t string_size) {
-    if (string_size < 0){
-        string_size = -string_size;
-        if (string_size < 1<<16)
-            return SDS_TYPE_REFCOUNTED;
-    }
+static inline char sdsReqType(size_t string_size) {
     if (string_size < 1<<5)
         return SDS_TYPE_5;
     if (string_size < 1<<8)
@@ -93,12 +86,10 @@ static inline char sdsReqType(ssize_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, ssize_t initlen) {
+sds sdsnewlen(const void *init, size_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;
@@ -146,13 +137,6 @@ sds sdsnewlen(const void *init, ssize_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);
@@ -177,25 +161,9 @@ 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]));
 }
 
@@ -400,11 +368,6 @@ 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';
@@ -824,7 +787,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 char *s1, const char *s2) {
+int sdscmp(const sds s1, const sds s2) {
     size_t l1, l2, minlen;
     int cmp;
 

src/sds.h

@@ -91,27 +91,15 @@ 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) {
@@ -133,8 +121,6 @@ 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;
@@ -162,9 +148,6 @@ 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;
 }
@@ -190,9 +173,6 @@ 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;
     }
 }
 
@@ -218,9 +198,6 @@ 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;
     }
 }
 
@@ -238,8 +215,6 @@ 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;
 }
@@ -262,22 +237,13 @@ 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;
     }
 }
 
-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 sdsnewlen(const void *init, size_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);
@@ -299,7 +265,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 char *s1, const char *s2);
+int sdscmp(const sds s1, const sds 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);
@@ -332,120 +298,6 @@ 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

@@ -93,9 +93,9 @@ public:
         return end();
     }
 
-    setiter end()
+    setiter end() const
     {
-        setiter itr(this);
+        setiter itr(const_cast<semiorderedset<T,T_KEY,MEMMOVE_SAFE>*>(this));
         itr.idxPrimary = m_data.size();
         return itr;
     }

src/server.cpp

@@ -35,7 +35,6 @@
 #include "latency.h"
 #include "atomicvar.h"
 #include "storage.h"
-#include "cron.h"
 #include <thread>
 #include <time.h>
 #include <signal.h>
@@ -62,11 +61,8 @@
 #include <uuid/uuid.h>
 #include <mutex>
 #include "aelocker.h"
-#include "motd.h"
 
 int g_fTestMode = false;
-const char *motd_url = "http://api.keydb.dev/motd/motd_server.txt";
-const char *motd_cache_file = "/.keydb-server-motd";
 
 /* Our shared "common" objects */
 
@@ -1027,11 +1023,7 @@ struct redisCommand redisCommandTable[] = {
 
     {"rreplay",replicaReplayCommand,-3,
      "read-only fast noprop",
-     0,NULL,0,0,0,0,0,0},
-
-    {"keydb.cron",cronCommand,-5,
-     "write use-memory",
-     0,NULL,1,1,1,0,0,0},
+     0,NULL,0,0,0,0,0,0}
 };
 
 /*============================ Utility functions ============================ */
@@ -1039,7 +1031,6 @@ struct redisCommand redisCommandTable[] = {
 /* We use a private localtime implementation which is fork-safe. The logging
  * function of Redis may be called from other threads. */
 extern "C" void nolocks_localtime(struct tm *tmp, time_t t, time_t tz, int dst);
-extern "C" pid_t gettid();
 
 /* Low level logging. To use only for very big messages, otherwise
  * serverLog() is to prefer. */
@@ -1077,8 +1068,8 @@ void serverLogRaw(int level, const char *msg) {
         } else {
             role_char = (listLength(g_pserver->masters) ? 'S':'M'); /* Slave or Master. */
         }
-        fprintf(fp,"%d:%d:%c %s %c %s\n",
-            (int)getpid(),(int)gettid(),role_char, buf,c[level],msg);
+        fprintf(fp,"%d:%c %s %c %s\n",
+            (int)getpid(),role_char, buf,c[level],msg);
     }
     fflush(fp);
 
@@ -1188,6 +1179,21 @@ int dictSdsKeyCompare(void *privdata, const void *key1,
     return memcmp(key1, key2, l1) == 0;
 }
 
+void dictSdsNOPDestructor(void *, void *) {}
+
+void dictDbKeyDestructor(void *privdata, void *key)
+{
+    redisDbPersistentData *owner = (redisDbPersistentData*)privdata;
+    serverAssert(owner != nullptr);
+    if (owner->m_spdbSnapshot != nullptr)
+    {
+        dictEntry *deSnapshot = dictFind(owner->m_spdbSnapshot->m_pdict, key);
+        if (deSnapshot && (key == dictGetKey(deSnapshot)))
+            return; // don't free, it's now owned by the snapshot
+    }
+    sdsfree((sds)key);
+}
+
 /* A case insensitive version used for the command lookup table and other
  * places where case insensitive non binary-safe comparison is needed. */
 int dictSdsKeyCaseCompare(void *privdata, const void *key1,
@@ -1323,10 +1329,19 @@ dictType dbDictType = {
     NULL,                       /* key dup */
     NULL,                       /* val dup */
     dictSdsKeyCompare,          /* key compare */
-    dictSdsDestructor,          /* key destructor */
+    dictDbKeyDestructor,          /* key destructor */
     dictObjectDestructor   /* val destructor */
 };
 
+dictType dbSnapshotDictType = {
+    dictSdsHash,
+    NULL,
+    NULL,
+    dictSdsKeyCompare,
+    dictSdsNOPDestructor,
+    dictObjectDestructor,
+};
+
 /* g_pserver->lua_scripts sha (as sds string) -> scripts (as robj) cache. */
 dictType shaScriptObjectDictType = {
     dictSdsCaseHash,            /* hash function */
@@ -1448,8 +1463,7 @@ int htNeedsResize(dict *dict) {
 /* If the percentage of used slots in the HT reaches HASHTABLE_MIN_FILL
  * we resize the hash table to save memory */
 void tryResizeHashTables(int dbid) {
-    if (htNeedsResize(g_pserver->db[dbid].pdict))
-        dictResize(g_pserver->db[dbid].pdict);
+    g_pserver->db[dbid].tryResize();
 }
 
 /* Our hash table implementation performs rehashing incrementally while
@@ -1459,10 +1473,10 @@ void tryResizeHashTables(int dbid) {
  *
  * The function returns 1 if some rehashing was performed, otherwise 0
  * is returned. */
-int incrementallyRehash(int dbid) {
+int redisDbPersistentData::incrementallyRehash() {
     /* Keys dictionary */
-    if (dictIsRehashing(g_pserver->db[dbid].pdict)) {
-        dictRehashMilliseconds(g_pserver->db[dbid].pdict,1);
+    if (dictIsRehashing(m_pdict)) {
+        dictRehashMilliseconds(m_pdict,1);
         return 1; /* already used our millisecond for this loop... */
     }
     return 0;
@@ -1475,7 +1489,7 @@ int incrementallyRehash(int dbid) {
  * for dict.c to resize the hash tables accordingly to the fact we have o not
  * running childs. */
 void updateDictResizePolicy(void) {
-    if (g_pserver->rdb_child_pid == -1 && g_pserver->aof_child_pid == -1)
+    if (!g_pserver->FRdbSaveInProgress() && g_pserver->aof_child_pid == -1)
         dictEnableResize();
     else
         dictDisableResize();
@@ -1694,16 +1708,13 @@ void clientsCron(int iel) {
             /* The following functions do different service checks on the client.
             * The protocol is that they return non-zero if the client was
             * terminated. */
-            if (clientsCronHandleTimeout(c,now)) continue;  // Client free'd so don't release the lock
+            if (clientsCronHandleTimeout(c,now)) goto LContinue;
             if (clientsCronResizeQueryBuffer(c)) goto LContinue;
             if (clientsCronTrackExpansiveClients(c)) goto LContinue;
         LContinue:
             fastlock_unlock(&c->lock);
         }        
     }
-
-    /* Free any pending clients */
-    freeClientsInAsyncFreeQueue(iel);
 }
 
 /* This function handles 'background' operations we are required to do
@@ -1712,9 +1723,9 @@ void clientsCron(int iel) {
 void databasesCron(void) {
     /* Expire keys by random sampling. Not required for slaves
      * as master will synthesize DELs for us. */
-    if (g_pserver->active_expire_enabled && (listLength(g_pserver->masters) == 0 || g_pserver->fActiveReplica)) {
+    if (g_pserver->active_expire_enabled && listLength(g_pserver->masters) == 0) {
         activeExpireCycle(ACTIVE_EXPIRE_CYCLE_SLOW);
-    } else if (listLength(g_pserver->masters) && !g_pserver->fActiveReplica) {
+    } else if (listLength(g_pserver->masters)) {
         expireSlaveKeys();
     }
 
@@ -1725,7 +1736,7 @@ void databasesCron(void) {
     /* Perform hash tables rehashing if needed, but only if there are no
      * other processes saving the DB on disk. Otherwise rehashing is bad
      * as will cause a lot of copy-on-write of memory pages. */
-    if (g_pserver->rdb_child_pid == -1 && g_pserver->aof_child_pid == -1) {
+    if (!g_pserver->FRdbSaveInProgress() && g_pserver->aof_child_pid == -1) {
         /* We use global counters so if we stop the computation at a given
          * DB we'll be able to start from the successive in the next
          * cron loop iteration. */
@@ -1746,7 +1757,7 @@ void databasesCron(void) {
         /* Rehash */
         if (g_pserver->activerehashing) {
             for (j = 0; j < dbs_per_call; j++) {
-                int work_done = incrementallyRehash(rehash_db);
+                int work_done = g_pserver->db[rehash_db].incrementallyRehash();
                 if (work_done) {
                     /* If the function did some work, stop here, we'll do
                      * more at the next cron loop. */
@@ -1824,9 +1835,6 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
     /* Update the time cache. */
     updateCachedTime();
 
-    /* Unpause clients if enough time has elapsed */
-    unpauseClientsIfNecessary();
-
     g_pserver->hz = g_pserver->config_hz;
     /* Adapt the g_pserver->hz value to the number of configured clients. If we have
      * many clients, we want to call serverCron() with an higher frequency. */
@@ -1834,7 +1842,7 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
         while (listLength(g_pserver->clients) / g_pserver->hz >
                MAX_CLIENTS_PER_CLOCK_TICK)
         {
-            g_pserver->hz += g_pserver->hz; // *= 2
+            g_pserver->hz *= 2;
             if (g_pserver->hz > CONFIG_MAX_HZ) {
                 g_pserver->hz = CONFIG_MAX_HZ;
                 break;
@@ -1898,7 +1906,7 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
     /* We received a SIGTERM, shutting down here in a safe way, as it is
      * not ok doing so inside the signal handler. */
     if (g_pserver->shutdown_asap) {
-        if (prepareForShutdown(SHUTDOWN_NOFLAGS) == C_OK) throw ShutdownException();
+        if (prepareForShutdown(SHUTDOWN_NOFLAGS) == C_OK) exit(0);
         serverLog(LL_WARNING,"SIGTERM received but errors trying to shut down the server, check the logs for more information");
         g_pserver->shutdown_asap = 0;
     }
@@ -1908,9 +1916,9 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
         for (j = 0; j < cserver.dbnum; j++) {
             long long size, used, vkeys;
 
-            size = dictSlots(g_pserver->db[j].pdict);
-            used = dictSize(g_pserver->db[j].pdict);
-            vkeys = g_pserver->db[j].setexpire->size();
+            size = g_pserver->db[j].slots();
+            used = g_pserver->db[j].size();
+            vkeys = g_pserver->db[j].expireSize();
             if (used || vkeys) {
                 serverLog(LL_VERBOSE,"DB %d: %lld keys (%lld volatile) in %lld slots HT.",j,used,vkeys,size);
                 /* dictPrintStats(g_pserver->dict); */
@@ -1937,20 +1945,37 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
 
     /* Start a scheduled AOF rewrite if this was requested by the user while
      * a BGSAVE was in progress. */
-    if (g_pserver->rdb_child_pid == -1 && g_pserver->aof_child_pid == -1 &&
+    if (!g_pserver->FRdbSaveInProgress() && g_pserver->aof_child_pid == -1 &&
         g_pserver->aof_rewrite_scheduled)
     {
         rewriteAppendOnlyFileBackground();
     }
 
     /* Check if a background saving or AOF rewrite in progress terminated. */
-    if (g_pserver->rdb_child_pid != -1 || g_pserver->aof_child_pid != -1 ||
+    if (g_pserver->FRdbSaveInProgress() || g_pserver->aof_child_pid != -1 ||
         ldbPendingChildren())
     {
         int statloc;
         pid_t pid;
 
-        if ((pid = wait3(&statloc,WNOHANG,NULL)) != 0) {
+        if (g_pserver->FRdbSaveInProgress())
+        {
+            void *rval = nullptr;
+            if (pthread_tryjoin_np(g_pserver->rdbThreadVars.rdb_child_thread, &rval))
+            {
+                if (errno != EBUSY && errno != EAGAIN)
+                    serverLog(LL_WARNING, "Error joining the background RDB save thread: %s\n", strerror(errno));
+            }
+            else
+            {
+                int exitcode = (int)reinterpret_cast<ptrdiff_t>(rval);
+                backgroundSaveDoneHandler(exitcode,0);
+                if (exitcode == 0) receiveChildInfo();
+                updateDictResizePolicy();
+                closeChildInfoPipe();
+            }
+        }
+        else if ((pid = wait3(&statloc,WNOHANG,NULL)) != 0) {
             int exitcode = WEXITSTATUS(statloc);
             int bysignal = 0;
 
@@ -1958,13 +1983,9 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
 
             if (pid == -1) {
                 serverLog(LL_WARNING,"wait3() returned an error: %s. "
-                    "rdb_child_pid = %d, aof_child_pid = %d",
+                    "aof_child_pid = %d",
                     strerror(errno),
-                    (int) g_pserver->rdb_child_pid,
                     (int) g_pserver->aof_child_pid);
-            } else if (pid == g_pserver->rdb_child_pid) {
-                backgroundSaveDoneHandler(exitcode,bysignal);
-                if (!bysignal && exitcode == 0) receiveChildInfo();
             } else if (pid == g_pserver->aof_child_pid) {
                 backgroundRewriteDoneHandler(exitcode,bysignal);
                 if (!bysignal && exitcode == 0) receiveChildInfo();
@@ -2005,7 +2026,7 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
 
         /* Trigger an AOF rewrite if needed. */
         if (g_pserver->aof_state == AOF_ON &&
-            g_pserver->rdb_child_pid == -1 &&
+            !g_pserver->FRdbSaveInProgress() &&
             g_pserver->aof_child_pid == -1 &&
             g_pserver->aof_rewrite_perc &&
             g_pserver->aof_current_size > g_pserver->aof_rewrite_min_size)
@@ -2034,6 +2055,9 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
             flushAppendOnlyFile(0);
     }
 
+    /* Clear the paused clients flag if needed. */
+    clientsArePaused(); /* Don't check return value, just use the side effect.*/
+
     /* Replication cron function -- used to reconnect to master,
      * detect transfer failures, start background RDB transfers and so forth. */
     run_with_period(1000) replicationCron();
@@ -2058,7 +2082,7 @@ int serverCron(struct aeEventLoop *eventLoop, long long id, void *clientData) {
      * Note: this code must be after the replicationCron() call above so
      * make sure when refactoring this file to keep this order. This is useful
      * because we want to give priority to RDB savings for replication. */
-    if (g_pserver->rdb_child_pid == -1 && g_pserver->aof_child_pid == -1 &&
+    if (!g_pserver->FRdbSaveInProgress() && g_pserver->aof_child_pid == -1 &&
         g_pserver->rdb_bgsave_scheduled &&
         (g_pserver->unixtime-g_pserver->lastbgsave_try > CONFIG_BGSAVE_RETRY_DELAY ||
          g_pserver->lastbgsave_status == C_OK))
@@ -2090,9 +2114,6 @@ int serverCronLite(struct aeEventLoop *eventLoop, long long id, void *clientData
     {
         processUnblockedClients(iel);
     }
-
-    /* Unpause clients if enough time has elapsed */
-    unpauseClientsIfNecessary();
     
     ProcessPendingAsyncWrites();    // A bug but leave for now, events should clean up after themselves
     clientsCron(iel);
@@ -2114,7 +2135,7 @@ void beforeSleep(struct aeEventLoop *eventLoop) {
 
     /* Run a fast expire cycle (the called function will return
      * ASAP if a fast cycle is not needed). */
-    if (g_pserver->active_expire_enabled && (listLength(g_pserver->masters) == 0 || g_pserver->fActiveReplica))
+    if (g_pserver->active_expire_enabled && listLength(g_pserver->masters) == 0)
         activeExpireCycle(ACTIVE_EXPIRE_CYCLE_FAST);
 
     /* Send all the slaves an ACK request if at least one client blocked
@@ -2328,7 +2349,6 @@ void initMasterInfo(redisMaster *master)
 
     master->repl_state = REPL_STATE_NONE;
     master->repl_down_since = 0; /* Never connected, repl is down since EVER. */
-    master->mvccLastSync = 0;
 }
 
 void initServerConfig(void) {
@@ -2496,7 +2516,7 @@ void initServerConfig(void) {
 
     /* Command table -- we initiialize it here as it is part of the
      * initial configuration, since command names may be changed via
-     * keydb.conf using the rename-command directive. */
+     * redis.conf using the rename-command directive. */
     g_pserver->commands = dictCreate(&commandTableDictType,NULL);
     g_pserver->orig_commands = dictCreate(&commandTableDictType,NULL);
     populateCommandTable();
@@ -2532,7 +2552,7 @@ void initServerConfig(void) {
     /* By default we want scripts to be always replicated by effects
      * (single commands executed by the script), and not by sending the
      * script to the replica / AOF. This is the new way starting from
-     * Redis 5. However it is possible to revert it via keydb.conf. */
+     * Redis 5. However it is possible to revert it via redis.conf. */
     g_pserver->lua_always_replicate_commands = 1;
 
     /* Multithreading */
@@ -2887,8 +2907,6 @@ static void initServerThread(struct redisServerThreadVars *pvar, int fMain)
     pvar->cclients = 0;
     pvar->el = aeCreateEventLoop(g_pserver->maxclients+CONFIG_FDSET_INCR);
     pvar->current_client = nullptr;
-    pvar->clients_paused = 0;
-    pvar->fRetrySetAofEvent = false;
     if (pvar->el == NULL) {
         serverLog(LL_WARNING,
             "Failed creating the event loop. Error message: '%s'",
@@ -2896,7 +2914,7 @@ static void initServerThread(struct redisServerThreadVars *pvar, int fMain)
         exit(1);
     }
 
-    fastlock_init(&pvar->lockPendingWrite, "lockPendingWrite");
+    fastlock_init(&pvar->lockPendingWrite);
 
     if (!fMain)
     {
@@ -2943,21 +2961,14 @@ void initServer(void) {
     signal(SIGPIPE, SIG_IGN);
     setupSignalHandlers();
 
+    fastlock_init(&g_pserver->flock);
+
     g_pserver->db = (redisDb*)zmalloc(sizeof(redisDb)*cserver.dbnum, MALLOC_LOCAL);
 
     /* Create the Redis databases, and initialize other internal state. */
     for (int j = 0; j < cserver.dbnum; j++) {
         new (&g_pserver->db[j]) redisDb;
-        g_pserver->db[j].pdict = dictCreate(&dbDictType,NULL);
-        g_pserver->db[j].setexpire = new(MALLOC_LOCAL) expireset();
-        g_pserver->db[j].expireitr = g_pserver->db[j].setexpire->end();
-        g_pserver->db[j].blocking_keys = dictCreate(&keylistDictType,NULL);
-        g_pserver->db[j].ready_keys = dictCreate(&objectKeyPointerValueDictType,NULL);
-        g_pserver->db[j].watched_keys = dictCreate(&keylistDictType,NULL);
-        g_pserver->db[j].id = j;
-        g_pserver->db[j].avg_ttl = 0;
-        g_pserver->db[j].last_expire_set = 0;
-        g_pserver->db[j].defrag_later = listCreate();
+        g_pserver->db[j].initialize(j);
     }
 
     /* Fixup Master Client Database */
@@ -2985,6 +2996,7 @@ void initServer(void) {
     g_pserver->ready_keys = listCreate();
     g_pserver->clients_waiting_acks = listCreate();
     g_pserver->get_ack_from_slaves = 0;
+    g_pserver->clients_paused = 0;
     cserver.system_memory_size = zmalloc_get_memory_size();
 
     createSharedObjects();
@@ -2996,7 +3008,7 @@ void initServer(void) {
     listSetFreeMethod(g_pserver->pubsub_patterns,freePubsubPattern);
     listSetMatchMethod(g_pserver->pubsub_patterns,listMatchPubsubPattern);
     g_pserver->cronloops = 0;
-    g_pserver->rdb_child_pid = -1;
+    g_pserver->rdbThreadVars.fRdbThreadActive = false;
     g_pserver->aof_child_pid = -1;
     g_pserver->rdb_child_type = RDB_CHILD_TYPE_NONE;
     g_pserver->rdb_bgsave_scheduled = 0;
@@ -3149,7 +3161,7 @@ void populateCommandTable(void) {
         c->id = ACLGetCommandID(c->name); /* Assign the ID used for ACL. */
         retval1 = dictAdd(g_pserver->commands, sdsnew(c->name), c);
         /* Populate an additional dictionary that will be unaffected
-         * by rename-command statements in keydb.conf. */
+         * by rename-command statements in redis.conf. */
         retval2 = dictAdd(g_pserver->orig_commands, sdsnew(c->name), c);
         serverAssert(retval1 == DICT_OK && retval2 == DICT_OK);
     }
@@ -3224,7 +3236,7 @@ struct redisCommand *lookupCommandByCString(const char *s) {
 
 /* Lookup the command in the current table, if not found also check in
  * the original table containing the original command names unaffected by
- * keydb.conf rename-command statement.
+ * redis.conf rename-command statement.
  *
  * This is used by functions rewriting the argument vector such as
  * rewriteClientCommandVector() in order to set client->cmd pointer
@@ -3593,12 +3605,12 @@ int processCommand(client *c, int callFlags) {
             return C_OK;
         }
     }
+
+    incrementMvccTstamp();
     
     if (!locker.isArmed())
         locker.arm(c);
 
-    incrementMvccTstamp();
-
     /* Handle the maxmemory directive.
      *
      * Note that we do not want to reclaim memory if we are here re-entering
@@ -3682,8 +3694,7 @@ int processCommand(client *c, int callFlags) {
      * link with master. */
     if (FBrokenLinkToMaster() &&
         g_pserver->repl_serve_stale_data == 0 &&
-        !(c->cmd->flags & CMD_STALE)
-        && !(g_pserver->fActiveReplica && c->cmd->proc == syncCommand))
+        !(c->cmd->flags & CMD_STALE))
     {
         flagTransaction(c);
         addReply(c, shared.masterdownerr);
@@ -3722,7 +3733,12 @@ int processCommand(client *c, int callFlags) {
         queueMultiCommand(c);
         addReply(c,shared.queued);
     } else {
+        std::unique_lock<decltype(c->db->lock)> ulock(c->db->lock);
+        for (int idb = 0; idb < cserver.dbnum; ++idb)
+            g_pserver->db[idb].trackChanges();
         call(c,callFlags);
+        for (int idb = 0; idb < cserver.dbnum; ++idb)
+            g_pserver->db[idb].processChanges();
         c->woff = g_pserver->master_repl_offset;
         if (listLength(g_pserver->ready_keys))
             handleClientsBlockedOnKeys();
@@ -3763,7 +3779,7 @@ int prepareForShutdown(int flags) {
     /* Kill the saving child if there is a background saving in progress.
        We want to avoid race conditions, for instance our saving child may
        overwrite the synchronous saving did by SHUTDOWN. */
-    if (g_pserver->rdb_child_pid != -1) {
+    if (g_pserver->FRdbSaveInProgress()) {
         serverLog(LL_WARNING,"There is a child saving an .rdb. Killing it!");
         killRDBChild();
     }
@@ -3794,7 +3810,7 @@ int prepareForShutdown(int flags) {
         /* Snapshotting. Perform a SYNC SAVE and exit */
         rdbSaveInfo rsi, *rsiptr;
         rsiptr = rdbPopulateSaveInfo(&rsi);
-        if (rdbSave(rsiptr) != C_OK) {
+        if (rdbSave(nullptr, rsiptr) != C_OK) {
             /* Ooops.. error saving! The best we can do is to continue
              * operating. Note that if there was a background saving process,
              * in the next cron() Redis will be notified that the background
@@ -3817,17 +3833,8 @@ int prepareForShutdown(int flags) {
 
     /* Close the listening sockets. Apparently this allows faster restarts. */
     closeListeningSockets(1);
-
-    for (int iel = 0; iel < cserver.cthreads; ++iel)
-    {
-        aePostFunction(g_pserver->rgthreadvar[iel].el, [iel]{
-            g_pserver->rgthreadvar[iel].el->stop = 1;
-        });
-    }
-
     serverLog(LL_WARNING,"%s is now ready to exit, bye bye...",
         g_pserver->sentinel_mode ? "Sentinel" : "KeyDB");
-
     return C_OK;
 }
 
@@ -4115,7 +4122,7 @@ sds genRedisInfoString(const char *section) {
             g_pserver->port,
             (intmax_t)uptime,
             (intmax_t)(uptime/(3600*24)),
-            g_pserver->hz.load(),
+            g_pserver->hz,
             g_pserver->config_hz,
             (unsigned long) lruclock,
             cserver.executable ? cserver.executable : "",
@@ -4286,12 +4293,12 @@ sds genRedisInfoString(const char *section) {
             "aof_last_cow_size:%zu\r\n",
             g_pserver->loading,
             g_pserver->dirty,
-            g_pserver->rdb_child_pid != -1,
+            g_pserver->FRdbSaveInProgress(),
             (intmax_t)g_pserver->lastsave,
             (g_pserver->lastbgsave_status == C_OK) ? "ok" : "err",
             (intmax_t)g_pserver->rdb_save_time_last,
-            (intmax_t)((g_pserver->rdb_child_pid == -1) ?
-                -1 : time(NULL)-g_pserver->rdb_save_time_start),
+            (intmax_t)(g_pserver->FRdbSaveInProgress() ?
+                time(NULL)-g_pserver->rdb_save_time_start : -1),
             g_pserver->stat_rdb_cow_bytes,
             g_pserver->aof_state != AOF_OFF,
             g_pserver->aof_child_pid != -1,
@@ -4607,8 +4614,8 @@ sds genRedisInfoString(const char *section) {
         for (j = 0; j < cserver.dbnum; j++) {
             long long keys, vkeys;
 
-            keys = dictSize(g_pserver->db[j].pdict);
-            vkeys = g_pserver->db[j].setexpire->size();
+            keys = g_pserver->db[j].size();
+            vkeys = g_pserver->db[j].expireSize();
 
             // Adjust TTL by the current time
             g_pserver->db[j].avg_ttl -= (g_pserver->mstime - g_pserver->db[j].last_expire_set);
@@ -4704,7 +4711,7 @@ void daemonize(void) {
 }
 
 void version(void) {
-    printf("KeyDB server v=%s sha=%s:%d malloc=%s bits=%d build=%llx\n",
+    printf("Redis server v=%s sha=%s:%d malloc=%s bits=%d build=%llx\n",
         KEYDB_REAL_VERSION,
         redisGitSHA1(),
         atoi(redisGitDirty()) > 0,
@@ -4715,7 +4722,7 @@ void version(void) {
 }
 
 void usage(void) {
-    fprintf(stderr,"Usage: ./keydb-server [/path/to/keydb.conf] [options]\n");
+    fprintf(stderr,"Usage: ./keydb-server [/path/to/redis.conf] [options]\n");
     fprintf(stderr,"       ./keydb-server - (read config from stdin)\n");
     fprintf(stderr,"       ./keydb-server -v or --version\n");
     fprintf(stderr,"       ./keydb-server -h or --help\n");
@@ -4725,7 +4732,7 @@ void usage(void) {
     fprintf(stderr,"       ./keydb-server /etc/redis/6379.conf\n");
     fprintf(stderr,"       ./keydb-server --port 7777\n");
     fprintf(stderr,"       ./keydb-server --port 7777 --replicaof 127.0.0.1 8888\n");
-    fprintf(stderr,"       ./keydb-server /etc/mykeydb.conf --loglevel verbose\n\n");
+    fprintf(stderr,"       ./keydb-server /etc/myredis.conf --loglevel verbose\n\n");
     fprintf(stderr,"Sentinel mode:\n");
     fprintf(stderr,"       ./keydb-server /etc/sentinel.conf --sentinel\n");
     exit(1);
@@ -4742,7 +4749,7 @@ void redisAsciiArt(void) {
 
     /* Show the ASCII logo if: log file is stdout AND stdout is a
      * tty AND syslog logging is disabled. Also show logo if the user
-     * forced us to do so via keydb.conf. */
+     * forced us to do so via redis.conf. */
     int show_logo = ((!g_pserver->syslog_enabled &&
                       g_pserver->logfile[0] == '\0' &&
                       isatty(fileno(stdout))) ||
@@ -4754,18 +4761,14 @@ void redisAsciiArt(void) {
             mode, g_pserver->port
         );
     } else {
-        sds motd = fetchMOTD(true);
         snprintf(buf,1024*16,ascii_logo,
             KEYDB_REAL_VERSION,
             redisGitSHA1(),
             strtol(redisGitDirty(),NULL,10) > 0,
             (sizeof(long) == 8) ? "64" : "32",
             mode, g_pserver->port,
-            (long) getpid(),
-            motd ? motd : ""
+            (long) getpid()
         );
-        if (motd)
-            sdsfree(motd);
         serverLogRaw(LL_NOTICE|LL_RAW,buf);
     }
     zfree(buf);
@@ -4791,7 +4794,7 @@ static void sigShutdownHandler(int sig) {
      * on disk. */
     if (g_pserver->shutdown_asap && sig == SIGINT) {
         serverLogFromHandler(LL_WARNING, "You insist... exiting now.");
-        rdbRemoveTempFile(getpid());
+        rdbRemoveTempFile(g_pserver->rdbThreadVars.tmpfileNum);
         exit(1); /* Exit with an error since this was not a clean shutdown. */
     } else if (g_pserver->loading) {
         serverLogFromHandler(LL_WARNING, "Received shutdown signal during loading, exiting now.");
@@ -5019,15 +5022,14 @@ void incrementMvccTstamp()
     msPrev >>= MVCC_MS_SHIFT;  // convert to milliseconds
 
     long long mst;
-    __atomic_load(&g_pserver->mstime, &mst, __ATOMIC_ACQUIRE);
+    __atomic_load(&g_pserver->mstime, &mst, __ATOMIC_RELAXED);
     if (msPrev >= (uint64_t)mst)  // we can be greater if the count overflows
     {
-        __atomic_fetch_add(&g_pserver->mvcc_tstamp, 1, __ATOMIC_RELEASE);
+        atomicIncr(g_pserver->mvcc_tstamp, 1);
     }
     else
     {
-        uint64_t val = ((uint64_t)g_pserver->mstime) << MVCC_MS_SHIFT;
-        __atomic_store(&g_pserver->mvcc_tstamp, &val, __ATOMIC_RELEASE);
+        atomicSet(g_pserver->mvcc_tstamp, ((uint64_t)g_pserver->mstime) << MVCC_MS_SHIFT);
     }
 }
 
@@ -5038,7 +5040,7 @@ void OnTerminate()
         The easiest way to achieve that is to acutally segfault, so we assert
         here.
     */
-    serverPanic("std::teminate() called");
+    serverAssert(false);
 }
 
 void *workerThreadMain(void *parg)
@@ -5052,34 +5054,11 @@ void *workerThreadMain(void *parg)
     aeEventLoop *el = g_pserver->rgthreadvar[iel].el;
     aeSetBeforeSleepProc(el, isMainThread ? beforeSleep : beforeSleepLite, isMainThread ? 0 : AE_SLEEP_THREADSAFE);
     aeSetAfterSleepProc(el, afterSleep, AE_SLEEP_THREADSAFE);
-    try
-    {
-        aeMain(el);
-    }
-    catch (ShutdownException)
-    {
-    }
-    serverAssert(!GlobalLocksAcquired());
+    aeMain(el);
     aeDeleteEventLoop(el);
-
     return NULL;
 }
 
-static void validateConfiguration()
-{
-    if (cserver.cthreads > (int)std::thread::hardware_concurrency()) {
-        serverLog(LL_WARNING, "WARNING: server-threads is greater than this machine's core count.  Truncating to %u threads", std::thread::hardware_concurrency());
-        cserver.cthreads = (int)std::thread::hardware_concurrency();
-        cserver.cthreads = std::max(cserver.cthreads, 1);	// in case of any weird sign overflows
-    }
-
-    if (g_pserver->enable_multimaster && !g_pserver->fActiveReplica) {
-        serverLog(LL_WARNING, "ERROR: Multi Master requires active replication to be enabled.");
-        serverLog(LL_WARNING, "\tKeyDB will now exit.  Please update your configuration file.");
-        exit(EXIT_FAILURE);
-    }
-}
-
 int main(int argc, char **argv) {
     struct timeval tv;
     int j;
@@ -5131,6 +5110,10 @@ int main(int argc, char **argv) {
     dictSetHashFunctionSeed((uint8_t*)hashseed);
     g_pserver->sentinel_mode = checkForSentinelMode(argc,argv);
     initServerConfig();
+    for (int iel = 0; iel < MAX_EVENT_LOOPS; ++iel)
+    {
+        initServerThread(g_pserver->rgthreadvar+iel, iel == IDX_EVENT_LOOP_MAIN);
+    }
     serverTL = &g_pserver->rgthreadvar[IDX_EVENT_LOOP_MAIN];
     aeAcquireLock();    // We own the lock on boot
 
@@ -5227,15 +5210,6 @@ int main(int argc, char **argv) {
         sdsfree(options);
     }
 
-    if (cserver.fUsePro) {
-        const char *keydb_pro_dir = getenv("KEYDB_PRO_DIRECTORY");
-        sds path = sdsnew(keydb_pro_dir);
-        path = sdscat(path, "keydb-pro-server");
-        execv(path, argv);
-        perror("Failed launch the pro binary");
-        exit(EXIT_FAILURE);
-    }
-
     serverLog(LL_WARNING, "oO0OoO0OoO0Oo KeyDB is starting oO0OoO0OoO0Oo");
     serverLog(LL_WARNING,
         "KeyDB version=%s, bits=%d, commit=%s, modified=%d, pid=%d, just started",
@@ -5251,16 +5225,16 @@ int main(int argc, char **argv) {
         serverLog(LL_WARNING, "Configuration loaded");
     }
 
-    validateConfiguration();
+    if (cserver.cthreads > (int)std::thread::hardware_concurrency()) {
+        serverLog(LL_WARNING, "WARNING: server-threads is greater than this machine's core count.  Truncating to %u threads", std::thread::hardware_concurrency());
+	cserver.cthreads = (int)std::thread::hardware_concurrency();
+	cserver.cthreads = std::max(cserver.cthreads, 1);	// in case of any weird sign overflows
+    }
 
     cserver.supervised = redisIsSupervised(cserver.supervised_mode);
     int background = cserver.daemonize && !cserver.supervised;
     if (background) daemonize();
 
-    for (int iel = 0; iel < MAX_EVENT_LOOPS; ++iel)
-    {
-        initServerThread(g_pserver->rgthreadvar+iel, iel == IDX_EVENT_LOOP_MAIN);
-    }
     initServer();
     initNetworking(cserver.cthreads > 1 /* fReusePort */);
 
@@ -5361,9 +5335,7 @@ int main(int argc, char **argv) {
     /* The main thread sleeps until all the workers are done.
         this is so that all worker threads are orthogonal in their startup/shutdown */
     void *pvRet;
-    for (int iel = 0; iel < cserver.cthreads; ++iel)
-        pthread_join(rgthread[iel], &pvRet);
-
+    pthread_join(rgthread[IDX_EVENT_LOOP_MAIN], &pvRet);
     return 0;
 }
 

src/server.h

@@ -42,6 +42,7 @@
 #include <stdlib.h>
 #include <cmath>
 #include <string.h>
+#include <string>
 #include <time.h>
 #include <limits.h>
 #include <unistd.h>
@@ -54,8 +55,7 @@
 #include <vector>
 #include <algorithm>
 #include <memory>
-#include <map>
-#include <string>
+#include <set>
 #ifdef __cplusplus
 extern "C" {
 #include <lua.h>
@@ -91,6 +91,7 @@ typedef long long mstime_t; /* millisecond time type. */
 #include "sha1.h"
 #include "endianconv.h"
 #include "crc64.h"
+#include "IStorage.h"
 
 extern int g_fTestMode;
 
@@ -131,6 +132,11 @@ public:
         return m_ptr;
     }
 
+    const redisObject& operator*() const
+    {
+        return *m_ptr;
+    }
+
     bool operator!() const
     {
         return !m_ptr;
@@ -146,87 +152,6 @@ 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
@@ -265,7 +190,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/keydb.pid"
+#define CONFIG_DEFAULT_PID_FILE "/var/run/redis.pid"
 #define CONFIG_DEFAULT_SYSLOG_IDENT "redis"
 #define CONFIG_DEFAULT_CLUSTER_CONFIG_FILE "nodes.conf"
 #define CONFIG_DEFAULT_CLUSTER_ANNOUNCE_IP NULL         /* Auto detect. */
@@ -516,7 +441,6 @@ public:
 #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 - replica side */
 #define CONFIG_REPL_SYNCIO_TIMEOUT 5
@@ -684,8 +608,6 @@ 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
@@ -869,6 +791,16 @@ public:
             : when(when), spsubkey(subkey, sdsfree)
         {}
 
+        subexpireEntry(const subexpireEntry &e)
+            : when(e.when), spsubkey(nullptr, sdsfree)
+        {
+            if (e.spsubkey)
+                spsubkey = std::unique_ptr<const char, void(*)(const char*)>((const char*)sdsdup((sds)e.spsubkey.get()), sdsfree);
+        }
+
+        subexpireEntry(subexpireEntry &&e) = default;
+        subexpireEntry& operator=(subexpireEntry &&e) = default;
+
         bool operator<(long long when) const noexcept { return this->when < when; }
         bool operator<(const subexpireEntry &se) { return this->when < se.when; }
     };
@@ -881,6 +813,10 @@ public:
     expireEntryFat(sds keyPrimary)
         : m_keyPrimary(keyPrimary)
         {}
+        
+    expireEntryFat(const expireEntryFat &e) = default;
+    expireEntryFat(expireEntryFat &&e) = default;
+
     long long when() const noexcept { return m_vecexpireEntries.front().when; }
     const char *key() const noexcept { return m_keyPrimary; }
 
@@ -982,6 +918,14 @@ public:
         m_when = LLONG_MIN;
     }
 
+    expireEntry(const expireEntry &e)
+    {
+        u.m_key = e.u.m_key;
+        m_when = e.m_when;
+        if (e.FFat())
+            u.m_pfatentry = new (MALLOC_LOCAL) expireEntryFat(*e.u.m_pfatentry);
+    }
+
     expireEntry(expireEntry &&e)
     {
         u.m_key = e.u.m_key;
@@ -1125,20 +1069,183 @@ typedef struct clientReplyBlock {
 #endif
 } clientReplyBlock;
 
+struct dictEntry;
+class dict_const_iter
+{
+    friend struct redisDb;
+    friend class redisDbPersistentData;
+protected:
+    dictEntry *de;
+public:
+    explicit dict_const_iter(dictEntry *de)
+        : de(de)
+    {}
+
+    const char *key() const { return de ? (const char*)dictGetKey(de) : nullptr; }
+    robj_roptr val() const { return de ? (robj*)dictGetVal(de) : nullptr; }
+    const robj* operator->() const { return de ? (robj*)dictGetVal(de) : nullptr; }
+    operator robj_roptr() const { return de ? (robj*)dictGetVal(de) : nullptr; }
+
+    bool operator==(std::nullptr_t) const { return de == nullptr; }
+    bool operator!=(std::nullptr_t) const { return de != nullptr; }
+    bool operator==(const dict_const_iter &other) { return de == other.de; }
+};
+class dict_iter : public dict_const_iter
+{
+public:
+    explicit dict_iter(dictEntry *de)
+        : dict_const_iter(de)
+    {}
+    sds key() { return de ? (sds)dictGetKey(de) : nullptr; }
+    robj *val() { return de ? (robj*)dictGetVal(de) : nullptr; }
+    robj *operator->() { return de ? (robj*)dictGetVal(de) : nullptr; }
+    operator robj*() const { return de ? (robj*)dictGetVal(de) : nullptr; }
+};
+
+class redisDbPersistentData
+{
+    friend void dictDbKeyDestructor(void *privdata, void *key);
+public:
+    ~redisDbPersistentData();
+
+    static void swap(redisDbPersistentData *db1, redisDbPersistentData *db2);
+
+    size_t slots() const { return dictSlots(m_pdict); }
+    size_t size() const { return dictSize(m_pdict); }
+    void expand(uint64_t slots) { dictExpand(m_pdict, slots); }
+    
+    void trackkey(robj_roptr o)
+    {
+        trackkey(szFromObj(o));
+    }
+
+    void trackkey(const char *key)
+    {
+        if (m_fTrackingChanges && !m_fAllChanged)
+            m_setchanged.insert(std::string(key, sdslen(key)));
+    }
+
+    dict_iter find(const char *key) 
+    {
+        dictEntry *de = dictFind(m_pdict, key);
+        ensure(de);
+        return dict_iter(de);
+    }
+
+    dict_iter find(robj_roptr key)
+    {
+        return find(szFromObj(key));
+    }
+
+    dict_iter random()
+    {
+        dictEntry *de = dictGetRandomKey(m_pdict);
+        ensure(de);
+        return dict_iter(de);
+    }
+
+    const expireEntry &random_expire()
+    {
+        return m_setexpire->random_value();
+    }
+
+    auto findExpire(const char *key)
+    {
+        return m_setexpire->find(key);
+    }
+
+    dict_iter end()  { return dict_iter(nullptr); }
+    dict_const_iter end() const { return dict_const_iter(nullptr); }
+
+    void getStats(char *buf, size_t bufsize) { dictGetStats(buf, bufsize, m_pdict); }
+    void getExpireStats(char *buf, size_t bufsize) { m_setexpire->getstats(buf, bufsize); }
+
+    bool insert(char *k, robj *o);
+    void tryResize();
+    int incrementallyRehash();
+    void updateValue(dict_iter itr, robj *val);
+    bool syncDelete(robj *key);
+    bool asyncDelete(robj *key);
+    size_t expireSize() const { return m_setexpire->size(); }
+    int removeExpire(robj *key, dict_iter itr);
+    int removeSubkeyExpire(robj *key, robj *subkey);
+    void clear(void(callback)(void*));
+    void emptyDbAsync();
+    bool iterate(std::function<bool(const char*, robj*)> fn);
+    void setExpire(robj *key, robj *subkey, long long when);
+    void setExpire(expireEntry &&e);
+    expireEntry *getExpire(robj_roptr key);
+    void initialize();
+
+    void trackChanges() { m_fTrackingChanges++; }
+    void processChanges();
+
+    // This should only be used if you look at the key, we do not fixup
+    //  objects stored elsewhere
+    dict *dictUnsafeKeyOnly() { return m_pdict; }   
+
+    expireset *setexpireUnsafe() { return m_setexpire; }
+    const expireset *setexpire() { return m_setexpire; }
+
+    std::shared_ptr<redisDbPersistentData> createSnapshot();
+    void endSnapshot(const redisDbPersistentData *psnapshot);
+
+private:
+    void ensure(const char *key);
+    void ensure(dictEntry *de);
+    void storeDatabase();
+    void storeKey(const char *key, size_t cchKey, robj *o);
+
+    // Keyspace
+    dict *m_pdict = nullptr;                 /* The keyspace for this DB */
+    int m_fTrackingChanges = 0;     // Note: Stack based
+    bool m_fAllChanged = false;
+    std::set<std::string> m_setchanged;
+    IStorage *m_pstorage = nullptr;
+
+    // Expire
+    expireset *m_setexpire = nullptr;
+
+    std::shared_ptr<redisDbPersistentData> m_spdbSnapshot;
+};
+
 /* 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. */
-struct redisDb {
-    redisDb() 
+typedef struct redisDb : public redisDbPersistentData 
+{
+    // Legacy C API, Do not add more
+    friend void tryResizeHashTables(int);
+    friend int dbSyncDelete(redisDb *db, robj *key);
+    friend int dbAsyncDelete(redisDb *db, robj *key);
+    friend long long emptyDb(int dbnum, int flags, void(callback)(void*));
+    friend void scanGenericCommand(struct client *c, robj_roptr o, unsigned long cursor);
+    friend int dbSwapDatabases(int id1, int id2);
+    friend int removeExpire(redisDb *db, robj *key);
+    friend void setExpire(struct client *c, redisDb *db, robj *key, robj *subkey, long long when);
+    friend void setExpire(client *c, redisDb *db, robj *key, expireEntry &&e);
+    friend void evictionPoolPopulate(int dbid, redisDb *db, expireset *setexpire, struct evictionPoolEntry *pool);
+    friend void activeDefragCycle(void);
+    friend int freeMemoryIfNeeded(void);
+    friend void activeExpireCycle(int);
+    friend void expireSlaveKeys(void);
+
+    typedef ::dict_const_iter const_iter;
+    typedef ::dict_iter iter;
+
+    redisDb()
         : expireitr(nullptr)
-    {};
-    
-    ~redisDb();
+    {}
+    void initialize(int id);
 
-    dict *pdict;                 /* The keyspace for this DB */
-    expireset *setexpire;
+    void dbOverwriteCore(redisDb::iter itr, robj *key, robj *val, bool fUpdateMvcc, bool fRemoveExpire);
+
+
+    bool FKeyExpires(const char *key);
+    size_t clear(bool fAsync, void(callback)(void*));
+
+public:
     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 */
@@ -1146,7 +1253,9 @@ struct redisDb {
     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. */
-};
+
+    fastlock lock;
+} redisDb;
 
 /* Client MULTI/EXEC state */
 typedef struct multiCmd {
@@ -1338,7 +1447,6 @@ typedef struct client {
 
     int iel; /* the event loop index we're registered with */
     struct fastlock lock;
-    int master_error;
 } client;
 
 struct saveparam {
@@ -1480,11 +1588,12 @@ 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;
+
+    /* Used In Save */
+    long long master_repl_offset;
 } rdbSaveInfo;
 
-#define RDB_SAVE_INFO_INIT {-1,0,"000000000000000000000000000000",-1, TRUE, 0, nullptr}
+#define RDB_SAVE_INFO_INIT {-1,0,"000000000000000000000000000000",-1, TRUE}
 
 struct malloc_stats {
     size_t zmalloc_used;
@@ -1518,7 +1627,6 @@ struct redisServerThreadVars {
     aeEventLoop *el;
     int ipfd[CONFIG_BINDADDR_MAX]; /* TCP socket file descriptors */
     int ipfd_count;             /* Used slots in ipfd[] */
-    int clients_paused;         /* True if clients are currently paused */
     std::vector<client*> clients_pending_write; /* There is to write or install handler. */
     list *unblocked_clients;     /* list of clients to unblock before next loop NOT THREADSAFE */
     list *clients_pending_asyncwrite;
@@ -1528,10 +1636,9 @@ struct redisServerThreadVars {
                                 client blocked on a module command needs
                                 to be processed. */
     client *lua_client = nullptr;   /* The "fake client" to query Redis from Lua */
-    struct fastlock lockPendingWrite { "thread pending write" };
+    struct fastlock lockPendingWrite;
     char neterr[ANET_ERR_LEN];   /* Error buffer for anet.c */
     long unsigned commandsExecuted = 0;
-    bool fRetrySetAofEvent = false;
 };
 
 struct redisMaster {
@@ -1559,9 +1666,6 @@ 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
@@ -1586,7 +1690,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 keydb.conf */
+    int verbosity;                  /* Loglevel in redis.conf */
     int maxidletime;                /* Client timeout in seconds */
     int tcpkeepalive;               /* Set SO_KEEPALIVE if non-zero. */
     int active_defrag_enabled;
@@ -1607,8 +1711,6 @@ 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 {
@@ -1617,7 +1719,7 @@ struct redisServer {
     int config_hz;              /* Configured HZ value. May be different than
                                    the actual 'hz' field value if dynamic-hz
                                    is enabled. */
-    std::atomic<int> hz;                     /* serverCron() calls frequency in hertz */
+    int hz;                     /* serverCron() calls frequency in hertz */
     redisDb *db;
     dict *commands;             /* Command table */
     dict *orig_commands;        /* Command table before command renaming. */
@@ -1652,6 +1754,7 @@ struct redisServer {
     list *clients_to_close;     /* Clients to close asynchronously */
     list *slaves, *monitors;    /* List of slaves and MONITORs */
     rax *clients_index;         /* Active clients dictionary by client ID. */
+    int clients_paused;         /* True if clients are currently paused */
     mstime_t clients_pause_end_time; /* Time when we undo clients_paused */
     dict *migrate_cached_sockets;/* MIGRATE cached sockets */
     std::atomic<uint64_t> next_client_id; /* Next client unique ID. Incremental. */
@@ -1742,11 +1845,16 @@ 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 */
-    pid_t rdb_child_pid;            /* PID of RDB saving child */
+    struct _rdbThreadVars
+    {
+        bool fRdbThreadActive = false;
+        volatile bool fRdbThreadCancel = false;
+        pthread_t rdb_child_thread;     /* PID of RDB saving child */
+        int tmpfileNum = 0;
+    } rdbThreadVars;
     struct saveparam *saveparams;   /* Save points array for RDB */
     int saveparamslen;              /* Number of saving points */
     char *rdb_filename;             /* Name of RDB file */
@@ -1840,7 +1948,7 @@ struct redisServer {
     int sort_alpha;
     int sort_bypattern;
     int sort_store;
-    /* Zip structure config, see keydb.conf for more information  */
+    /* Zip structure config, see redis.conf for more information  */
     size_t hash_max_ziplist_entries;
     size_t hash_max_ziplist_value;
     size_t set_max_intset_entries;
@@ -1916,6 +2024,8 @@ struct redisServer {
 
     int fActiveReplica;                          /* Can this replica also be a master? */
 
+    struct fastlock flock;
+
     // Format:
     //  Lower 20 bits: a counter incrementing for each command executed in the same millisecond
     //  Upper 44 bits: mstime (least significant 44-bits) enough for ~500 years before rollover from date of addition
@@ -1923,6 +2033,8 @@ struct redisServer {
 
     /* System hardware info */
     size_t system_memory_size;  /* Total memory in system as reported by OS */
+
+    bool FRdbSaveInProgress() const { return rdbThreadVars.fRdbThreadActive; }
 };
 
 typedef struct pubsubPattern {
@@ -2028,9 +2140,11 @@ extern dictType zsetDictType;
 extern dictType clusterNodesDictType;
 extern dictType clusterNodesBlackListDictType;
 extern dictType dbDictType;
+extern dictType dbSnapshotDictType;
 extern dictType shaScriptObjectDictType;
 extern double R_Zero, R_PosInf, R_NegInf, R_Nan;
 extern dictType hashDictType;
+extern dictType keylistDictType;
 extern dictType replScriptCacheDictType;
 extern dictType keyptrDictType;
 extern dictType modulesDictType;
@@ -2141,7 +2255,6 @@ void disconnectSlavesExcept(unsigned char *uuid);
 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);
@@ -2254,15 +2367,18 @@ 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);
 int compareStringObjects(robj *a, robj *b);
 int collateStringObjects(robj *a, robj *b);
 int equalStringObjects(robj *a, robj *b);
-unsigned long long estimateObjectIdleTime(robj *o);
+unsigned long long estimateObjectIdleTime(robj_roptr o);
 void trimStringObjectIfNeeded(robj *o);
+
+robj *deserializeStoredObject(const void *data, size_t cb);
+sds serializeStoredObject(robj_roptr o);
+
 #define sdsEncodedObject(objptr) (objptr->encoding == OBJ_ENCODING_RAW || objptr->encoding == OBJ_ENCODING_EMBSTR)
 
 /* Synchronous I/O with timeout */
@@ -2315,7 +2431,7 @@ int writeCommandsDeniedByDiskError(void);
 
 /* RDB persistence */
 #include "rdb.h"
-int rdbSaveRio(rio *rdb, int *error, int flags, rdbSaveInfo *rsi);
+int rdbSaveRio(rio *rdb, redisDbPersistentData **rgpdb, int *error, int flags, rdbSaveInfo *rsi);
 void killRDBChild(void);
 
 /* AOF persistence */
@@ -2533,11 +2649,9 @@ int rewriteConfig(char *path);
 
 /* db.c -- Keyspace access API */
 int removeExpire(redisDb *db, robj *key);
-int removeExpireCore(redisDb *db, robj *key, dictEntry *de);
 int removeSubkeyExpire(redisDb *db, robj *key, robj *subkey);
 void propagateExpire(redisDb *db, robj *key, int lazy);
 int expireIfNeeded(redisDb *db, robj *key);
-expireEntry *getExpire(redisDb *db, robj_roptr key);
 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);
@@ -2545,8 +2659,8 @@ robj *lookupKeyWrite(redisDb *db, robj *key);
 robj_roptr lookupKeyReadOrReply(client *c, robj *key, robj *reply);
 robj *lookupKeyWriteOrReply(client *c, robj *key, robj *reply);
 robj_roptr lookupKeyReadWithFlags(redisDb *db, robj *key, int flags);
-robj *objectCommandLookup(client *c, robj *key);
-robj *objectCommandLookupOrReply(client *c, robj *key, robj *reply);
+robj_roptr objectCommandLookup(client *c, robj *key);
+robj_roptr objectCommandLookupOrReply(client *c, robj *key, robj *reply);
 void objectSetLRUOrLFU(robj *val, long long lfu_freq, long long lru_idle,
                        long long lru_clock);
 #define LOOKUP_NONE 0
@@ -2579,7 +2693,6 @@ void slotToKeyAdd(robj *key);
 void slotToKeyDel(robj *key);
 void slotToKeyFlush(void);
 int dbAsyncDelete(redisDb *db, robj *key);
-void emptyDbAsync(redisDb *db);
 void slotToKeyFlushAsync(void);
 size_t lazyfreeGetPendingObjectsCount(void);
 void freeObjAsync(robj *o);
@@ -2603,6 +2716,7 @@ void clusterPropagatePublish(robj *channel, robj *message);
 void migrateCloseTimedoutSockets(void);
 void clusterBeforeSleep(void);
 int clusterSendModuleMessageToTarget(const char *target, uint64_t module_id, uint8_t type, unsigned char *payload, uint32_t len);
+void createDumpPayload(rio *payload, robj_roptr o, robj *key);
 
 /* Sentinel */
 void initSentinelConfig(void);
@@ -2896,7 +3010,7 @@ 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;
+extern bool g_fInCrash;
 static inline int GlobalLocksAcquired(void)  // Used in asserts to verify all global locks are correctly acquired for a server-thread to operate
 {
     return aeThreadOwnsLock() || moduleGILAcquiredByModule() || g_fInCrash;
@@ -2922,9 +3036,6 @@ 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/t_set.cpp

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

src/version.h

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

tests/cluster/run.tcl

@@ -14,8 +14,6 @@ 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 "*watchdogSignalHandler*"
+            set pattern "*debugCommand*"
             set retry 10
             while {$retry} {
                 set result [exec tail -100 < [srv 0 stdout]]

tests/integration/replication-active.tcl

@@ -9,7 +9,6 @@ start_server {tags {"active-repl"} overrides {active-replica yes}} {
         set master [srv 0 client]
         set master_host [srv 0 host]
         set master_port [srv 0 port]
-    	set master_pid [s process_id]
 
         # Use a short replication timeout on the slave, so that if there
         # are no bugs the timeout is triggered in a reasonable amount
@@ -59,24 +58,6 @@ start_server {tags {"active-repl"} overrides {active-replica yes}} {
             }
         }
 
-        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
@@ -113,26 +94,6 @@ start_server {tags {"active-repl"} overrides {active-replica yes}} {
             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

tests/integration/replication-multimaster.tcl

@@ -1,74 +0,0 @@
-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.tcl

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

tests/test_helper.tcl

@@ -36,8 +36,6 @@ set ::all_tests {
     unit/aofrw
     unit/acl
     unit/rreplay
-    unit/cron
-    unit/replication
     integration/block-repl
     integration/replication
     integration/replication-2
@@ -45,7 +43,6 @@ set ::all_tests {
     integration/replication-4
     integration/replication-psync
     integration/replication-active
-    integration/replication-multimaster
     integration/aof
     integration/rdb
     integration/convert-zipmap-hash-on-load

tests/unit/bitops.tcl

@@ -238,7 +238,7 @@ start_server {tags {"bitops"}} {
         r set a "abcdefg"
         r bitop lshift x a 8
         r get x
-    } "\000abcdefg"
+    } "\x00abcdefg"
 
     test {BITOP lshift char} {
         r set a "\xAA"

tests/unit/cron.tcl

@@ -1,47 +0,0 @@
-start_server {tags {"CRON"}} {
-    test {keydb.cron singleshot past tense} {
-        r flushall
-        r keydb.cron testjob single 0 1 {redis.call("incr", "testkey")} 1 testkey
-        after 300
-        assert_equal 1 [r get testkey]
-        assert_equal 0 [r exists testjob]
-    }
-
-    test {keydb.cron repeat past tense next exec is in the future} {
-        r flushall
-        r keydb.cron testjob repeat 0 1000000 {redis.call("incr", "testkey")} 1 testkey
-        after 300
-        assert_equal 1 [r get testkey]
-        assert_equal 1 [r exists testjob]
-        r del testjob
-    }
-
-    test {keydb.cron repeat works} {
-        r flushall
-        r keydb.cron testjob repeat 0 600 {redis.call("incr","testkey")}
-        after 1000
-        assert_equal 2 [r get testkey]
-    }
-
-    test {keydb.cron overwrite works} {
-        r flushall
-        r keydb.cron testjob single 500 {redis.call("set","testkey","a")} 1 testkey
-        r keydb.cron testjob single 500 {redis.call("set","anotherkey","b")} 1 anotherkey
-        after 1000
-        assert_equal 0 [r exists testkey]
-        assert_equal b [r get anotherkey]
-    }
-
-    test {keydb.cron delete key stops job} {
-        r flushall
-        r keydb.cron testjob single 500 {redis.call("set","testkey","a")}
-        r del testjob
-        after 1000
-        assert_equal 0 [r exists testkey]
-    }
-
-    test {keydb.cron zero interval rejected} {
-        catch {r keydb.cron testjob single 0 0 {redis.call("incr","testkey")} 1 testkey} e
-        assert_match {ERR*} $e
-    }
-}

tests/unit/expire.tcl

@@ -219,46 +219,4 @@ start_server {tags {"expire"}} {
         set ttl [r ttl foo]
         assert {$ttl <= 98 && $ttl > 90}
     }
-
-    test {EXPIREMEMBER works (set)} {
-        r flushall
-        r sadd testkey foo bar baz
-        r expiremember testkey foo 1
-        after 1500
-        assert_equal {2} [r scard testkey]
-    }
-
-    test {EXPIREMEMBER works (hash)} {
-        r flushall
-        r hset testkey foo bar
-        r expiremember testkey foo 1
-        after 1500
-        r exists testkey
-    } {0}
-
-    test {EXPIREMEMBER works (zset)} {
-        r flushall
-        r zadd testkey 1 foo
-        r zadd testkey 2 bar
-        assert_equal {2} [r zcard testkey]
-        r expiremember testkey foo 1
-        after 1500
-        assert_equal {1} [r zcard testkey]
-    }
-
-    test {TTL for subkey expires works} {
-        r flushall
-        r sadd testkey foo bar baz
-        r expiremember testkey foo 10000
-        assert [expr [r ttl testkey foo] > 0]
-    }
-
-    test {Roundtrip for subkey expires works} {
-        r flushall
-        r sadd testkey foo bar baz
-        r expiremember testkey foo 10000
-        r save
-        r debug reload
-        assert [expr [r ttl testkey foo] > 0]
-    }
 }

tests/unit/replication.tcl

@@ -1,12 +0,0 @@
-
-start_server {tags {"repl"}} {
-        test "incr of expired key on replica doesn't cause a crash" {
-            r debug force-master yes
-            r set testkey 1
-            r pexpire testkey 1
-            after 500
-            r incr testkey
-            r incr testkey
-            r debug force-master no
-        }
-}

tests/unit/rreplay.tcl

@@ -1,7 +1,7 @@
-start_server {tags {"rreplay"} overrides {active-replica yes}} {
+start_server {tags {"rreplay"}} {
 
     test {RREPLAY use current db} {
-        r debug force-master yes
+        r debug force-master
         r select 4
         r set dbnum invalid
         r rreplay "f4d5b2b5-4f07-4ee5-a4f2-5dc98507dfce" "*3\r\n\$3\r\nSET\r\n\$5\r\ndbnum\r\n\$4\r\nfour\r\n"
@@ -10,7 +10,7 @@ start_server {tags {"rreplay"} overrides {active-replica yes}} {
     reconnect
 
     test {RREPLAY db different} {
-        r debug force-master yes
+        r debug force-master
         r select 4
         r set testkey four
         r rreplay "f4d5b2b5-4f07-4ee5-a4f2-5dc98507dfce" "*3\r\n\$3\r\nSET\r\n\$7\r\ntestkey\r\n\$4\r\nbebe\r\n" 2

utils/install_server.sh

@@ -156,7 +156,7 @@ mkdir -p "$REDIS_DATA_DIR" || die "Could not create redis data directory"
 
 #render the templates
 TMP_FILE="/tmp/${REDIS_PORT}.conf"
-DEFAULT_CONFIG="${SCRIPTPATH}/../keydb.conf"
+DEFAULT_CONFIG="${SCRIPTPATH}/../redis.conf"
 INIT_TPL_FILE="${SCRIPTPATH}/redis_init_script.tpl"
 INIT_SCRIPT_DEST="/etc/init.d/redis_${REDIS_PORT}"
 PIDFILE="/var/run/redis_${REDIS_PORT}.pid"