mirror of
https://github.com/redis/redis.git
synced 2026-04-21 03:01:35 -04:00
445a4b669a
Redis 6.0 introduces I/O threads, it is so cool and efficient, we use C11 _Atomic to establish inter-thread synchronization without mutex. But the compiler that must supports C11 _Atomic can compile redis code, that brings a lot of inconvenience since some common platforms can't support by default such as CentOS7, so we want to implement redis atomic type to make it more portable. We have implemented our atomic variable for redis that only has 'relaxed' operations in src/atomicvar.h, so we implement some operations with 'sequentially-consistent', just like the default behavior of C11 _Atomic that can establish inter-thread synchronization. And we replace all uses of C11 _Atomic with redis atomic variable. Our implementation of redis atomic variable uses C11 _Atomic, __atomic or __sync macros if available, it supports most common platforms, and we will detect automatically which feature we use. In Makefile we use a dummy file to detect if the compiler supports C11 _Atomic. Now for gcc, we can compile redis code theoretically if your gcc version is not less than 4.1.2(starts to support __sync_xxx operations). Otherwise, we remove use mutex fallback to implement redis atomic variable for performance and test. You will get compiling errors if your compiler doesn't support all features of above. For cover redis atomic variable tests, we add other CI jobs that build redis on CentOS6 and CentOS7 and workflow daily jobs that run the tests on them. For them, we just install gcc by default in order to cover different compiler versions, gcc is 4.4.7 by default installation on CentOS6 and 4.8.5 on CentOS7. We restore the feature that we can test redis with Helgrind to find data race errors. But you need install Valgrind in the default path configuration firstly before running your tests, since we use macros in helgrind.h to tell Helgrind inter-thread happens-before relationship explicitly for avoiding false positives. Please open an issue on github if you find data race errors relate to this commit. Unrelated: - Fix redefinition of typedef 'RedisModuleUserChangedFunc' For some old version compilers, they will report errors or warnings, if we re-define function type.
396 lines
12 KiB
Makefile
396 lines
12 KiB
Makefile
# Redis Makefile
|
|
# Copyright (C) 2009 Salvatore Sanfilippo <antirez at gmail dot com>
|
|
# This file is released under the BSD license, see the COPYING file
|
|
#
|
|
# The Makefile composes the final FINAL_CFLAGS and FINAL_LDFLAGS using
|
|
# what is needed for Redis plus the standard CFLAGS and LDFLAGS passed.
|
|
# However when building the dependencies (Jemalloc, Lua, Hiredis, ...)
|
|
# CFLAGS and LDFLAGS are propagated to the dependencies, so to pass
|
|
# flags only to be used when compiling / linking Redis itself REDIS_CFLAGS
|
|
# and REDIS_LDFLAGS are used instead (this is the case of 'make gcov').
|
|
#
|
|
# Dependencies are stored in the Makefile.dep file. To rebuild this file
|
|
# Just use 'make dep', but this is only needed by developers.
|
|
|
|
release_hdr := $(shell sh -c './mkreleasehdr.sh')
|
|
uname_S := $(shell sh -c 'uname -s 2>/dev/null || echo not')
|
|
uname_M := $(shell sh -c 'uname -m 2>/dev/null || echo not')
|
|
OPTIMIZATION?=-O2
|
|
DEPENDENCY_TARGETS=hiredis linenoise lua hdr_histogram
|
|
NODEPS:=clean distclean
|
|
|
|
# Default settings
|
|
STD=-pedantic -DREDIS_STATIC=''
|
|
ifneq (,$(findstring clang,$(CC)))
|
|
ifneq (,$(findstring FreeBSD,$(uname_S)))
|
|
STD+=-Wno-c11-extensions
|
|
endif
|
|
endif
|
|
WARN=-Wall -W -Wno-missing-field-initializers
|
|
OPT=$(OPTIMIZATION)
|
|
|
|
# Detect if the compiler supports C11 _Atomic
|
|
C11_ATOMIC := $(shell sh -c 'echo "\#include <stdatomic.h>" > foo.c; \
|
|
$(CC) -std=c11 -c foo.c -o foo.o &> /dev/null; \
|
|
if [ -f foo.o ]; then echo "yes"; rm foo.o; fi; rm foo.c')
|
|
ifeq ($(C11_ATOMIC),yes)
|
|
STD+=-std=c11
|
|
else
|
|
STD+=-std=c99
|
|
endif
|
|
|
|
PREFIX?=/usr/local
|
|
INSTALL_BIN=$(PREFIX)/bin
|
|
INSTALL=install
|
|
PKG_CONFIG?=pkg-config
|
|
|
|
# Default allocator defaults to Jemalloc if it's not an ARM
|
|
MALLOC=libc
|
|
ifneq ($(uname_M),armv6l)
|
|
ifneq ($(uname_M),armv7l)
|
|
ifeq ($(uname_S),Linux)
|
|
MALLOC=jemalloc
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
# To get ARM stack traces if Redis crashes we need a special C flag.
|
|
ifneq (,$(filter aarch64 armv,$(uname_M)))
|
|
CFLAGS+=-funwind-tables
|
|
else
|
|
ifneq (,$(findstring armv,$(uname_M)))
|
|
CFLAGS+=-funwind-tables
|
|
endif
|
|
endif
|
|
|
|
# Backwards compatibility for selecting an allocator
|
|
ifeq ($(USE_TCMALLOC),yes)
|
|
MALLOC=tcmalloc
|
|
endif
|
|
|
|
ifeq ($(USE_TCMALLOC_MINIMAL),yes)
|
|
MALLOC=tcmalloc_minimal
|
|
endif
|
|
|
|
ifeq ($(USE_JEMALLOC),yes)
|
|
MALLOC=jemalloc
|
|
endif
|
|
|
|
ifeq ($(USE_JEMALLOC),no)
|
|
MALLOC=libc
|
|
endif
|
|
|
|
# Override default settings if possible
|
|
-include .make-settings
|
|
|
|
FINAL_CFLAGS=$(STD) $(WARN) $(OPT) $(DEBUG) $(CFLAGS) $(REDIS_CFLAGS)
|
|
FINAL_LDFLAGS=$(LDFLAGS) $(REDIS_LDFLAGS) $(DEBUG)
|
|
FINAL_LIBS=-lm
|
|
DEBUG=-g -ggdb
|
|
|
|
# Linux ARM needs -latomic at linking time
|
|
ifneq (,$(filter aarch64 armv,$(uname_M)))
|
|
FINAL_LIBS+=-latomic
|
|
else
|
|
ifneq (,$(findstring armv,$(uname_M)))
|
|
FINAL_LIBS+=-latomic
|
|
endif
|
|
endif
|
|
|
|
ifeq ($(uname_S),SunOS)
|
|
# SunOS
|
|
ifneq ($(@@),32bit)
|
|
CFLAGS+= -m64
|
|
LDFLAGS+= -m64
|
|
endif
|
|
DEBUG=-g
|
|
DEBUG_FLAGS=-g
|
|
export CFLAGS LDFLAGS DEBUG DEBUG_FLAGS
|
|
INSTALL=cp -pf
|
|
FINAL_CFLAGS+= -D__EXTENSIONS__ -D_XPG6
|
|
FINAL_LIBS+= -ldl -lnsl -lsocket -lresolv -lpthread -lrt
|
|
else
|
|
ifeq ($(uname_S),Darwin)
|
|
# Darwin
|
|
FINAL_LIBS+= -ldl
|
|
OPENSSL_CFLAGS=-I/usr/local/opt/openssl/include
|
|
OPENSSL_LDFLAGS=-L/usr/local/opt/openssl/lib
|
|
else
|
|
ifeq ($(uname_S),AIX)
|
|
# AIX
|
|
FINAL_LDFLAGS+= -Wl,-bexpall
|
|
FINAL_LIBS+=-ldl -pthread -lcrypt -lbsd
|
|
else
|
|
ifeq ($(uname_S),OpenBSD)
|
|
# OpenBSD
|
|
FINAL_LIBS+= -lpthread
|
|
ifeq ($(USE_BACKTRACE),yes)
|
|
FINAL_CFLAGS+= -DUSE_BACKTRACE -I/usr/local/include
|
|
FINAL_LDFLAGS+= -L/usr/local/lib
|
|
FINAL_LIBS+= -lexecinfo
|
|
endif
|
|
|
|
else
|
|
ifeq ($(uname_S),FreeBSD)
|
|
# FreeBSD
|
|
FINAL_LIBS+= -lpthread -lexecinfo
|
|
else
|
|
ifeq ($(uname_S),DragonFly)
|
|
# FreeBSD
|
|
FINAL_LIBS+= -lpthread -lexecinfo
|
|
else
|
|
ifeq ($(uname_S),OpenBSD)
|
|
# OpenBSD
|
|
FINAL_LIBS+= -lpthread -lexecinfo
|
|
else
|
|
ifeq ($(uname_S),NetBSD)
|
|
# NetBSD
|
|
FINAL_LIBS+= -lpthread -lexecinfo
|
|
else
|
|
# All the other OSes (notably Linux)
|
|
FINAL_LDFLAGS+= -rdynamic
|
|
FINAL_LIBS+=-ldl -pthread -lrt
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
# Include paths to dependencies
|
|
FINAL_CFLAGS+= -I../deps/hiredis -I../deps/linenoise -I../deps/lua/src -I../deps/hdr_histogram
|
|
|
|
# Determine systemd support and/or build preference (defaulting to auto-detection)
|
|
BUILD_WITH_SYSTEMD=no
|
|
# If 'USE_SYSTEMD' in the environment is neither "no" nor "yes", try to
|
|
# auto-detect libsystemd's presence and link accordingly.
|
|
ifneq ($(USE_SYSTEMD),no)
|
|
LIBSYSTEMD_PKGCONFIG := $(shell $(PKG_CONFIG) --exists libsystemd && echo $$?)
|
|
# If libsystemd cannot be detected, continue building without support for it
|
|
# (unless a later check tells us otherwise)
|
|
ifeq ($(LIBSYSTEMD_PKGCONFIG),0)
|
|
BUILD_WITH_SYSTEMD=yes
|
|
endif
|
|
endif
|
|
ifeq ($(USE_SYSTEMD),yes)
|
|
ifneq ($(LIBSYSTEMD_PKGCONFIG),0)
|
|
$(error USE_SYSTEMD is set to "$(USE_SYSTEMD)", but $(PKG_CONFIG) cannot find libsystemd)
|
|
endif
|
|
# Force building with libsystemd
|
|
BUILD_WITH_SYSTEMD=yes
|
|
endif
|
|
ifeq ($(BUILD_WITH_SYSTEMD),yes)
|
|
FINAL_LIBS+=$(shell $(PKG_CONFIG) --libs libsystemd)
|
|
FINAL_CFLAGS+= -DHAVE_LIBSYSTEMD
|
|
endif
|
|
|
|
ifeq ($(MALLOC),tcmalloc)
|
|
FINAL_CFLAGS+= -DUSE_TCMALLOC
|
|
FINAL_LIBS+= -ltcmalloc
|
|
endif
|
|
|
|
ifeq ($(MALLOC),tcmalloc_minimal)
|
|
FINAL_CFLAGS+= -DUSE_TCMALLOC
|
|
FINAL_LIBS+= -ltcmalloc_minimal
|
|
endif
|
|
|
|
ifeq ($(MALLOC),jemalloc)
|
|
DEPENDENCY_TARGETS+= jemalloc
|
|
FINAL_CFLAGS+= -DUSE_JEMALLOC -I../deps/jemalloc/include
|
|
FINAL_LIBS := ../deps/jemalloc/lib/libjemalloc.a $(FINAL_LIBS)
|
|
endif
|
|
|
|
ifeq ($(BUILD_TLS),yes)
|
|
FINAL_CFLAGS+=-DUSE_OPENSSL $(OPENSSL_CFLAGS)
|
|
FINAL_LDFLAGS+=$(OPENSSL_LDFLAGS)
|
|
LIBSSL_PKGCONFIG := $(shell $(PKG_CONFIG) --exists libssl && echo $$?)
|
|
ifeq ($(LIBSSL_PKGCONFIG),0)
|
|
LIBSSL_LIBS=$(shell $(PKG_CONFIG) --libs libssl)
|
|
else
|
|
LIBSSL_LIBS=-lssl
|
|
endif
|
|
LIBCRYPTO_PKGCONFIG := $(shell $(PKG_CONFIG) --exists libcrypto && echo $$?)
|
|
ifeq ($(LIBCRYPTO_PKGCONFIG),0)
|
|
LIBCRYPTO_LIBS=$(shell $(PKG_CONFIG) --libs libcrypto)
|
|
else
|
|
LIBCRYPTO_LIBS=-lcrypto
|
|
endif
|
|
FINAL_LIBS += ../deps/hiredis/libhiredis_ssl.a $(LIBSSL_LIBS) $(LIBCRYPTO_LIBS)
|
|
endif
|
|
|
|
REDIS_CC=$(QUIET_CC)$(CC) $(FINAL_CFLAGS)
|
|
REDIS_LD=$(QUIET_LINK)$(CC) $(FINAL_LDFLAGS)
|
|
REDIS_INSTALL=$(QUIET_INSTALL)$(INSTALL)
|
|
|
|
CCCOLOR="\033[34m"
|
|
LINKCOLOR="\033[34;1m"
|
|
SRCCOLOR="\033[33m"
|
|
BINCOLOR="\033[37;1m"
|
|
MAKECOLOR="\033[32;1m"
|
|
ENDCOLOR="\033[0m"
|
|
|
|
ifndef V
|
|
QUIET_CC = @printf ' %b %b\n' $(CCCOLOR)CC$(ENDCOLOR) $(SRCCOLOR)$@$(ENDCOLOR) 1>&2;
|
|
QUIET_LINK = @printf ' %b %b\n' $(LINKCOLOR)LINK$(ENDCOLOR) $(BINCOLOR)$@$(ENDCOLOR) 1>&2;
|
|
QUIET_INSTALL = @printf ' %b %b\n' $(LINKCOLOR)INSTALL$(ENDCOLOR) $(BINCOLOR)$@$(ENDCOLOR) 1>&2;
|
|
endif
|
|
|
|
REDIS_SERVER_NAME=redis-server
|
|
REDIS_SENTINEL_NAME=redis-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 crcspeed.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 lolwut.o lolwut5.o lolwut6.o acl.o gopher.o tracking.o connection.o tls.o sha256.o timeout.o setcpuaffinity.o monotonic.o
|
|
REDIS_CLI_NAME=redis-cli
|
|
REDIS_CLI_OBJ=anet.o adlist.o dict.o redis-cli.o zmalloc.o release.o ae.o crcspeed.o crc64.o siphash.o crc16.o monotonic.o
|
|
REDIS_BENCHMARK_NAME=redis-benchmark
|
|
REDIS_BENCHMARK_OBJ=ae.o anet.o redis-benchmark.o adlist.o dict.o zmalloc.o siphash.o monotonic.o
|
|
REDIS_CHECK_RDB_NAME=redis-check-rdb
|
|
REDIS_CHECK_AOF_NAME=redis-check-aof
|
|
|
|
all: $(REDIS_SERVER_NAME) $(REDIS_SENTINEL_NAME) $(REDIS_CLI_NAME) $(REDIS_BENCHMARK_NAME) $(REDIS_CHECK_RDB_NAME) $(REDIS_CHECK_AOF_NAME)
|
|
@echo ""
|
|
@echo "Hint: It's a good idea to run 'make test' ;)"
|
|
@echo ""
|
|
|
|
Makefile.dep:
|
|
-$(REDIS_CC) -MM *.c > Makefile.dep 2> /dev/null || true
|
|
|
|
ifeq (0, $(words $(findstring $(MAKECMDGOALS), $(NODEPS))))
|
|
-include Makefile.dep
|
|
endif
|
|
|
|
.PHONY: all
|
|
|
|
persist-settings: distclean
|
|
echo STD=$(STD) >> .make-settings
|
|
echo WARN=$(WARN) >> .make-settings
|
|
echo OPT=$(OPT) >> .make-settings
|
|
echo MALLOC=$(MALLOC) >> .make-settings
|
|
echo BUILD_TLS=$(BUILD_TLS) >> .make-settings
|
|
echo USE_SYSTEMD=$(USE_SYSTEMD) >> .make-settings
|
|
echo CFLAGS=$(CFLAGS) >> .make-settings
|
|
echo LDFLAGS=$(LDFLAGS) >> .make-settings
|
|
echo REDIS_CFLAGS=$(REDIS_CFLAGS) >> .make-settings
|
|
echo REDIS_LDFLAGS=$(REDIS_LDFLAGS) >> .make-settings
|
|
echo PREV_FINAL_CFLAGS=$(FINAL_CFLAGS) >> .make-settings
|
|
echo PREV_FINAL_LDFLAGS=$(FINAL_LDFLAGS) >> .make-settings
|
|
-(cd ../deps && $(MAKE) $(DEPENDENCY_TARGETS))
|
|
|
|
.PHONY: persist-settings
|
|
|
|
# Prerequisites target
|
|
.make-prerequisites:
|
|
@touch $@
|
|
|
|
# Clean everything, persist settings and build dependencies if anything changed
|
|
ifneq ($(strip $(PREV_FINAL_CFLAGS)), $(strip $(FINAL_CFLAGS)))
|
|
.make-prerequisites: persist-settings
|
|
endif
|
|
|
|
ifneq ($(strip $(PREV_FINAL_LDFLAGS)), $(strip $(FINAL_LDFLAGS)))
|
|
.make-prerequisites: persist-settings
|
|
endif
|
|
|
|
# redis-server
|
|
$(REDIS_SERVER_NAME): $(REDIS_SERVER_OBJ)
|
|
$(REDIS_LD) -o $@ $^ ../deps/hiredis/libhiredis.a ../deps/lua/src/liblua.a $(FINAL_LIBS)
|
|
|
|
# redis-sentinel
|
|
$(REDIS_SENTINEL_NAME): $(REDIS_SERVER_NAME)
|
|
$(REDIS_INSTALL) $(REDIS_SERVER_NAME) $(REDIS_SENTINEL_NAME)
|
|
|
|
# redis-check-rdb
|
|
$(REDIS_CHECK_RDB_NAME): $(REDIS_SERVER_NAME)
|
|
$(REDIS_INSTALL) $(REDIS_SERVER_NAME) $(REDIS_CHECK_RDB_NAME)
|
|
|
|
# redis-check-aof
|
|
$(REDIS_CHECK_AOF_NAME): $(REDIS_SERVER_NAME)
|
|
$(REDIS_INSTALL) $(REDIS_SERVER_NAME) $(REDIS_CHECK_AOF_NAME)
|
|
|
|
# redis-cli
|
|
$(REDIS_CLI_NAME): $(REDIS_CLI_OBJ)
|
|
$(REDIS_LD) -o $@ $^ ../deps/hiredis/libhiredis.a ../deps/linenoise/linenoise.o $(FINAL_LIBS)
|
|
|
|
# redis-benchmark
|
|
$(REDIS_BENCHMARK_NAME): $(REDIS_BENCHMARK_OBJ)
|
|
$(REDIS_LD) -o $@ $^ ../deps/hiredis/libhiredis.a ../deps/hdr_histogram/hdr_histogram.o $(FINAL_LIBS)
|
|
|
|
dict-benchmark: dict.c zmalloc.c 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 -o $@ -c $<
|
|
|
|
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
|
|
|
|
distclean: clean
|
|
-(cd ../deps && $(MAKE) distclean)
|
|
-(rm -f .make-*)
|
|
|
|
.PHONY: distclean
|
|
|
|
test: $(REDIS_SERVER_NAME) $(REDIS_CHECK_AOF_NAME) $(REDIS_CLI_NAME) $(REDIS_BENCHMARK_NAME)
|
|
@(cd ..; ./runtest)
|
|
|
|
test-sentinel: $(REDIS_SENTINEL_NAME) $(REDIS_CLI_NAME)
|
|
@(cd ..; ./runtest-sentinel)
|
|
|
|
check: test
|
|
|
|
lcov:
|
|
$(MAKE) gcov
|
|
@(set -e; cd ..; ./runtest --clients 1)
|
|
@geninfo -o redis.info .
|
|
@genhtml --legend -o lcov-html redis.info
|
|
|
|
test-sds: sds.c sds.h
|
|
$(REDIS_CC) sds.c zmalloc.c -DSDS_TEST_MAIN $(FINAL_LIBS) -o /tmp/sds_test
|
|
/tmp/sds_test
|
|
|
|
.PHONY: lcov
|
|
|
|
bench: $(REDIS_BENCHMARK_NAME)
|
|
./$(REDIS_BENCHMARK_NAME)
|
|
|
|
32bit:
|
|
@echo ""
|
|
@echo "WARNING: if it fails under Linux you probably need to install libc6-dev-i386"
|
|
@echo ""
|
|
$(MAKE) CFLAGS="-m32" LDFLAGS="-m32"
|
|
|
|
gcov:
|
|
$(MAKE) REDIS_CFLAGS="-fprofile-arcs -ftest-coverage -DCOVERAGE_TEST" REDIS_LDFLAGS="-fprofile-arcs -ftest-coverage"
|
|
|
|
noopt:
|
|
$(MAKE) OPTIMIZATION="-O0"
|
|
|
|
valgrind:
|
|
$(MAKE) OPTIMIZATION="-O0" MALLOC="libc"
|
|
|
|
helgrind:
|
|
$(MAKE) OPTIMIZATION="-O0" MALLOC="libc" CFLAGS="-D__ATOMIC_VAR_FORCE_SYNC_MACROS" REDIS_CFLAGS="-I/usr/local/include" REDIS_LDFLAGS="-L/usr/local/lib"
|
|
|
|
src/help.h:
|
|
@../utils/generate-command-help.rb > help.h
|
|
|
|
install: all
|
|
@mkdir -p $(INSTALL_BIN)
|
|
$(REDIS_INSTALL) $(REDIS_SERVER_NAME) $(INSTALL_BIN)
|
|
$(REDIS_INSTALL) $(REDIS_BENCHMARK_NAME) $(INSTALL_BIN)
|
|
$(REDIS_INSTALL) $(REDIS_CLI_NAME) $(INSTALL_BIN)
|
|
$(REDIS_INSTALL) $(REDIS_CHECK_RDB_NAME) $(INSTALL_BIN)
|
|
$(REDIS_INSTALL) $(REDIS_CHECK_AOF_NAME) $(INSTALL_BIN)
|
|
@ln -sf $(REDIS_SERVER_NAME) $(INSTALL_BIN)/$(REDIS_SENTINEL_NAME)
|
|
|
|
uninstall:
|
|
rm -f $(INSTALL_BIN)/{$(REDIS_SERVER_NAME),$(REDIS_BENCHMARK_NAME),$(REDIS_CLI_NAME),$(REDIS_CHECK_RDB_NAME),$(REDIS_CHECK_AOF_NAME),$(REDIS_SENTINEL_NAME)}
|