mirror of
https://github.com/redis/redis.git
synced 2026-01-10 09:28:01 -05:00
9b63e99d05
Hash field expiration is managed with two levels of data structures. 1. At the DB level, an ebuckets structure maintains the set of all hashes that contain fields with expiration. 2. At the per-hash level, an ebuckets structure tracks fields with expiration. This pull request refactors the 1st level to operate per slot instead, and introduces a new API called estore (expiration store). Its design aligns closely with the existing kvstore API, ensuring consistency and simplifying usage. The terminology at that level has been updated from “HFE” or “hexpire” to “subexpiry”, reflecting a broader scope that can later support other data types.
564 lines
18 KiB
Makefile
564 lines
18 KiB
Makefile
# Redis Makefile
|
|
# Copyright (c) 2011-Present, Redis Ltd.
|
|
# All rights reserved.
|
|
#
|
|
# Licensed under your choice of (a) the Redis Source Available License 2.0
|
|
# (RSALv2); or (b) the Server Side Public License v1 (SSPLv1); or (c) the
|
|
# GNU Affero General Public License v3 (AGPLv3).
|
|
#
|
|
# 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')
|
|
CLANG := $(findstring clang,$(shell sh -c '$(CC) --version | head -1'))
|
|
|
|
# Optimization flags. To override, the OPTIMIZATION variable can be passed, but
|
|
# some automatic defaults are added to it. To specify optimization flags
|
|
# explicitly without any defaults added, pass the OPT variable instead.
|
|
OPTIMIZATION?=-O3
|
|
ifeq ($(OPTIMIZATION),-O3)
|
|
ifeq (clang,$(CLANG))
|
|
OPTIMIZATION+=-flto
|
|
else
|
|
OPTIMIZATION+=-flto=auto
|
|
endif
|
|
endif
|
|
ifneq ($(OPTIMIZATION),-O0)
|
|
OPTIMIZATION+=-fno-omit-frame-pointer
|
|
endif
|
|
DEPENDENCY_TARGETS=hiredis linenoise lua hdr_histogram fpconv fast_float
|
|
NODEPS:=clean distclean
|
|
|
|
# Default settings
|
|
STD=-pedantic -DREDIS_STATIC=''
|
|
|
|
# Use -Wno-c11-extensions on clang, either where explicitly used or on
|
|
# platforms we can assume it's being used.
|
|
ifeq (clang,$(CLANG))
|
|
STD+=-Wno-c11-extensions
|
|
else
|
|
ifneq (,$(findstring FreeBSD,$(uname_S)))
|
|
STD+=-Wno-c11-extensions
|
|
endif
|
|
endif
|
|
WARN=-Wall -W -Wno-missing-field-initializers -Werror=deprecated-declarations -Wstrict-prototypes
|
|
OPT=$(OPTIMIZATION)
|
|
|
|
SKIP_VEC_SETS?=no
|
|
# Detect if the compiler supports C11 _Atomic.
|
|
# NUMBER_SIGN_CHAR is a workaround to support both GNU Make 4.3 and older versions.
|
|
NUMBER_SIGN_CHAR := \#
|
|
C11_ATOMIC := $(shell sh -c 'echo "$(NUMBER_SIGN_CHAR)include <stdatomic.h>" > foo.c; \
|
|
$(CC) -std=gnu11 -c foo.c -o foo.o > /dev/null 2>&1; \
|
|
if [ -f foo.o ]; then echo "yes"; rm foo.o; fi; rm foo.c')
|
|
ifeq ($(C11_ATOMIC),yes)
|
|
STD+=-std=gnu11
|
|
else
|
|
SKIP_VEC_SETS=yes
|
|
STD+=-std=c99
|
|
endif
|
|
|
|
PREFIX?=/usr/local
|
|
INSTALL_BIN=$(PREFIX)/bin
|
|
INSTALL=install
|
|
PKG_CONFIG?=pkg-config
|
|
|
|
ifndef PYTHON
|
|
PYTHON := $(shell which python3 || which python)
|
|
endif
|
|
|
|
# Default allocator defaults to Jemalloc on Linux and libc otherwise
|
|
MALLOC=libc
|
|
ifeq ($(uname_S),Linux)
|
|
MALLOC=jemalloc
|
|
endif
|
|
|
|
# To get ARM stack traces if Redis crashes we need a special C flag.
|
|
ifneq (,$(filter aarch64 armv%,$(uname_M)))
|
|
CFLAGS+=-funwind-tables
|
|
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
|
|
|
|
ifdef SANITIZER
|
|
ifeq ($(SANITIZER),address)
|
|
MALLOC=libc
|
|
CFLAGS+=-fsanitize=address -fno-sanitize-recover=all -fno-omit-frame-pointer
|
|
LDFLAGS+=-fsanitize=address
|
|
else
|
|
ifeq ($(SANITIZER),undefined)
|
|
MALLOC=libc
|
|
CFLAGS+=-fsanitize=undefined -fno-sanitize-recover=all -fno-omit-frame-pointer
|
|
LDFLAGS+=-fsanitize=undefined
|
|
else
|
|
ifeq ($(SANITIZER),thread)
|
|
CFLAGS+=-fsanitize=thread -fno-sanitize-recover=all -fno-omit-frame-pointer
|
|
LDFLAGS+=-fsanitize=thread
|
|
else
|
|
ifeq ($(SANITIZER),memory)
|
|
ifeq (clang, $(CLANG))
|
|
export CXX:=clang
|
|
export LD:=clang
|
|
MALLOC=libc # MSan provides its own allocator so make sure not to use jemalloc as they clash
|
|
CFLAGS+=-fsanitize=memory -fsanitize-memory-track-origins=2 -fno-sanitize-recover=all -fno-omit-frame-pointer
|
|
LDFLAGS+=-fsanitize=memory
|
|
else
|
|
$(error "MemorySanitizer needs to be compiled and linked with clang. Please use CC=clang")
|
|
endif
|
|
else
|
|
$(error "unknown sanitizer=${SANITIZER}")
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
# Special case of forcing defrag to run even though we have no Jemlloc support
|
|
ifeq ($(DEBUG_DEFRAG), force)
|
|
CFLAGS +=-DDEBUG_DEFRAG_FORCE
|
|
else ifeq ($(DEBUG_DEFRAG), fully)
|
|
CFLAGS +=-DDEBUG_DEFRAG_FORCE -DDEBUG_DEFRAG_FULLY
|
|
endif
|
|
|
|
# Override default settings if possible
|
|
-include .make-settings
|
|
|
|
FINAL_CFLAGS=$(STD) $(WARN) $(OPT) $(DEBUG) $(CFLAGS) $(REDIS_CFLAGS)
|
|
FINAL_LDFLAGS=$(LDFLAGS) $(OPT) $(REDIS_LDFLAGS) $(DEBUG)
|
|
FINAL_LIBS=-lm -lstdc++
|
|
DEBUG=-g -ggdb
|
|
|
|
# Linux ARM32 needs -latomic at linking time
|
|
ifneq (,$(findstring armv,$(uname_M)))
|
|
FINAL_LIBS+=-latomic
|
|
endif
|
|
|
|
ifeq ($(uname_S),SunOS)
|
|
# SunOS
|
|
ifeq ($(findstring -m32,$(FINAL_CFLAGS)),)
|
|
CFLAGS+=-m64
|
|
endif
|
|
ifeq ($(findstring -m32,$(FINAL_LDFLAGS)),)
|
|
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
|
|
ifeq ($(USE_BACKTRACE),yes)
|
|
FINAL_CFLAGS+= -DUSE_BACKTRACE
|
|
endif
|
|
else
|
|
ifeq ($(uname_S),Darwin)
|
|
# Darwin
|
|
FINAL_LIBS+= -ldl
|
|
# Homebrew's OpenSSL is not linked to /usr/local to avoid
|
|
# conflicts with the system's LibreSSL installation so it
|
|
# must be referenced explicitly during build.
|
|
ifeq ($(uname_M),arm64)
|
|
# Homebrew arm64 uses /opt/homebrew as HOMEBREW_PREFIX
|
|
OPENSSL_PREFIX?=/opt/homebrew/opt/openssl
|
|
else
|
|
# Homebrew x86/ppc uses /usr/local as HOMEBREW_PREFIX
|
|
OPENSSL_PREFIX?=/usr/local/opt/openssl
|
|
endif
|
|
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),NetBSD)
|
|
# NetBSD
|
|
FINAL_LIBS+= -lpthread
|
|
ifeq ($(USE_BACKTRACE),yes)
|
|
FINAL_CFLAGS+= -DUSE_BACKTRACE -I/usr/pkg/include
|
|
FINAL_LDFLAGS+= -L/usr/pkg/lib
|
|
FINAL_LIBS+= -lexecinfo
|
|
endif
|
|
else
|
|
ifeq ($(uname_S),FreeBSD)
|
|
# FreeBSD
|
|
FINAL_LIBS+= -lpthread -lexecinfo
|
|
else
|
|
ifeq ($(uname_S),DragonFly)
|
|
# DragonFly
|
|
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
|
|
ifeq ($(uname_S),Haiku)
|
|
# Haiku
|
|
FINAL_CFLAGS+= -DBSD_SOURCE
|
|
FINAL_LDFLAGS+= -lbsd -lnetwork
|
|
FINAL_LIBS+= -lpthread
|
|
else
|
|
# All the other OSes (notably Linux)
|
|
FINAL_LDFLAGS+= -rdynamic
|
|
FINAL_LIBS+=-ldl -pthread -lrt
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
ifdef OPENSSL_PREFIX
|
|
OPENSSL_CFLAGS=-I$(OPENSSL_PREFIX)/include
|
|
OPENSSL_LDFLAGS=-L$(OPENSSL_PREFIX)/lib
|
|
# Also export OPENSSL_PREFIX so it ends up in deps sub-Makefiles
|
|
export OPENSSL_PREFIX
|
|
endif
|
|
|
|
# Include paths to dependencies
|
|
FINAL_CFLAGS+= -I../deps/hiredis -I../deps/linenoise -I../deps/lua/src -I../deps/hdr_histogram -I../deps/fpconv -I../deps/fast_float
|
|
|
|
# Determine systemd support and/or build preference (defaulting to auto-detection)
|
|
BUILD_WITH_SYSTEMD=no
|
|
LIBSYSTEMD_LIBS=-lsystemd
|
|
|
|
# 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
|
|
LIBSYSTEMD_LIBS=$(shell $(PKG_CONFIG) --libs libsystemd)
|
|
endif
|
|
endif
|
|
|
|
# If 'USE_SYSTEMD' is set to "yes" use pkg-config if available or fall back to
|
|
# default -lsystemd.
|
|
ifeq ($(USE_SYSTEMD),yes)
|
|
BUILD_WITH_SYSTEMD=yes
|
|
endif
|
|
|
|
ifeq ($(BUILD_WITH_SYSTEMD),yes)
|
|
FINAL_LIBS+=$(LIBSYSTEMD_LIBS)
|
|
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
|
|
|
|
# LIBSSL & LIBCRYPTO
|
|
LIBSSL_LIBS=
|
|
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_LIBS=
|
|
LIBCRYPTO_PKGCONFIG := $(shell $(PKG_CONFIG) --exists libcrypto && echo $$?)
|
|
ifeq ($(LIBCRYPTO_PKGCONFIG),0)
|
|
LIBCRYPTO_LIBS=$(shell $(PKG_CONFIG) --libs libcrypto)
|
|
else
|
|
LIBCRYPTO_LIBS=-lcrypto
|
|
endif
|
|
|
|
BUILD_NO:=0
|
|
BUILD_YES:=1
|
|
BUILD_MODULE:=2
|
|
ifeq ($(BUILD_TLS),yes)
|
|
FINAL_CFLAGS+=-DUSE_OPENSSL=$(BUILD_YES) $(OPENSSL_CFLAGS) -DBUILD_TLS_MODULE=$(BUILD_NO)
|
|
FINAL_LDFLAGS+=$(OPENSSL_LDFLAGS)
|
|
FINAL_LIBS += ../deps/hiredis/libhiredis_ssl.a $(LIBSSL_LIBS) $(LIBCRYPTO_LIBS)
|
|
endif
|
|
|
|
TLS_MODULE=
|
|
TLS_MODULE_NAME:=redis-tls$(PROG_SUFFIX).so
|
|
TLS_MODULE_CFLAGS:=$(FINAL_CFLAGS)
|
|
ifeq ($(BUILD_TLS),module)
|
|
FINAL_CFLAGS+=-DUSE_OPENSSL=$(BUILD_MODULE) $(OPENSSL_CFLAGS)
|
|
TLS_CLIENT_LIBS = ../deps/hiredis/libhiredis_ssl.a $(LIBSSL_LIBS) $(LIBCRYPTO_LIBS)
|
|
TLS_MODULE=$(TLS_MODULE_NAME)
|
|
TLS_MODULE_CFLAGS+=-DUSE_OPENSSL=$(BUILD_MODULE) $(OPENSSL_CFLAGS) -DBUILD_TLS_MODULE=$(BUILD_MODULE)
|
|
endif
|
|
|
|
ifneq ($(SKIP_VEC_SETS),yes)
|
|
vpath %.c ../modules/vector-sets
|
|
REDIS_VEC_SETS_OBJ=hnsw.o vset.o vset_config.o
|
|
FINAL_CFLAGS+=-DINCLUDE_VEC_SETS=1
|
|
endif
|
|
|
|
ifndef V
|
|
define MAKE_INSTALL
|
|
@printf ' %b %b\n' $(LINKCOLOR)INSTALL$(ENDCOLOR) $(BINCOLOR)$(1)$(ENDCOLOR) 1>&2
|
|
@$(INSTALL) $(1) $(2)
|
|
endef
|
|
else
|
|
define MAKE_INSTALL
|
|
$(INSTALL) $(1) $(2)
|
|
endef
|
|
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_GEN = @printf ' %b %b\n' $(CCCOLOR)GEN$(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
|
|
|
|
ifneq (, $(findstring LOG_REQ_RES, $(REDIS_CFLAGS)))
|
|
COMMANDS_DEF_FILENAME=commands_with_reply_schema
|
|
GEN_COMMANDS_FLAGS=--with-reply-schema
|
|
else
|
|
COMMANDS_DEF_FILENAME=commands
|
|
GEN_COMMANDS_FLAGS=
|
|
endif
|
|
|
|
REDIS_SERVER_NAME=redis-server$(PROG_SUFFIX)
|
|
REDIS_SENTINEL_NAME=redis-sentinel$(PROG_SUFFIX)
|
|
REDIS_SERVER_OBJ=threads_mngr.o memory_prefetch.o adlist.o quicklist.o ae.o anet.o dict.o ebuckets.o eventnotifier.o iothread.o mstr.o kvstore.o fwtree.o estore.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 cluster_legacy.o cluster_slot_stats.o crc16.o endianconv.o slowlog.o eval.o bio.o rio.o rand.o memtest.o syscheck.o crcspeed.o crccombine.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 lolwut8.o acl.o tracking.o socket.o tls.o sha256.o timeout.o setcpuaffinity.o monotonic.o mt19937-64.o resp_parser.o call_reply.o script_lua.o script.o functions.o function_lua.o commands.o strl.o connection.o unix.o logreqres.o
|
|
REDIS_CLI_NAME=redis-cli$(PROG_SUFFIX)
|
|
REDIS_CLI_OBJ=anet.o adlist.o dict.o redis-cli.o zmalloc.o release.o ae.o redisassert.o crcspeed.o crccombine.o crc64.o siphash.o crc16.o monotonic.o cli_common.o mt19937-64.o strl.o cli_commands.o
|
|
REDIS_BENCHMARK_NAME=redis-benchmark$(PROG_SUFFIX)
|
|
REDIS_BENCHMARK_OBJ=ae.o anet.o redis-benchmark.o adlist.o dict.o zmalloc.o redisassert.o release.o crcspeed.o crccombine.o crc64.o siphash.o crc16.o monotonic.o cli_common.o mt19937-64.o strl.o
|
|
REDIS_CHECK_RDB_NAME=redis-check-rdb$(PROG_SUFFIX)
|
|
REDIS_CHECK_AOF_NAME=redis-check-aof$(PROG_SUFFIX)
|
|
ALL_SOURCES=$(sort $(patsubst %.o,%.c,$(REDIS_SERVER_OBJ) $(REDIS_VEC_SETS_OBJ) $(REDIS_CLI_OBJ) $(REDIS_BENCHMARK_OBJ)))
|
|
|
|
all: $(REDIS_SERVER_NAME) $(REDIS_SENTINEL_NAME) $(REDIS_CLI_NAME) $(REDIS_BENCHMARK_NAME) $(REDIS_CHECK_RDB_NAME) $(REDIS_CHECK_AOF_NAME) $(TLS_MODULE) module_tests
|
|
@echo ""
|
|
@echo "Hint: It's a good idea to run 'make test' ;)"
|
|
@echo ""
|
|
|
|
Makefile.dep:
|
|
-$(REDIS_CC) -MM $(ALL_SOURCES) > Makefile.dep 2> /dev/null || true
|
|
|
|
ifeq (0, $(words $(findstring $(MAKECMDGOALS), $(NODEPS))))
|
|
-include Makefile.dep
|
|
endif
|
|
|
|
.PHONY: all
|
|
|
|
module_tests: $(REDIS_SERVER_NAME)
|
|
$(MAKE) -C ../tests/modules
|
|
|
|
.PHONY: module_tests
|
|
|
|
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_VEC_SETS_OBJ)
|
|
$(REDIS_LD) -o $@ $^ ../deps/hiredis/libhiredis.a ../deps/lua/src/liblua.a ../deps/hdr_histogram/libhdrhistogram.a ../deps/fpconv/libfpconv.a ../deps/fast_float/libfast_float.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-tls.so
|
|
$(TLS_MODULE_NAME): $(REDIS_SERVER_NAME)
|
|
$(QUIET_CC)$(CC) -o $@ tls.c -shared -fPIC $(TLS_MODULE_CFLAGS) $(TLS_CLIENT_LIBS)
|
|
|
|
# redis-cli
|
|
$(REDIS_CLI_NAME): $(REDIS_CLI_OBJ)
|
|
$(REDIS_LD) -o $@ $^ ../deps/hiredis/libhiredis.a ../deps/linenoise/linenoise.o ../deps/hdr_histogram/libhdrhistogram.a $(FINAL_LIBS) $(TLS_CLIENT_LIBS)
|
|
|
|
# redis-benchmark
|
|
$(REDIS_BENCHMARK_NAME): $(REDIS_BENCHMARK_OBJ)
|
|
$(REDIS_LD) -o $@ $^ ../deps/hiredis/libhiredis.a ../deps/hdr_histogram/libhdrhistogram.a $(FINAL_LIBS) $(TLS_CLIENT_LIBS)
|
|
|
|
DEP = $(REDIS_SERVER_OBJ:%.o=%.d) $(REDIS_VEC_SETS_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 $<
|
|
|
|
# The following files are checked in and don't normally need to be rebuilt. They
|
|
# are built only if python is available and their prereqs are modified.
|
|
ifneq (,$(PYTHON))
|
|
$(COMMANDS_DEF_FILENAME).def: commands/*.json ../utils/generate-command-code.py
|
|
$(QUIET_GEN)$(PYTHON) ../utils/generate-command-code.py $(GEN_COMMANDS_FLAGS)
|
|
|
|
fmtargs.h: ../utils/generate-fmtargs.py
|
|
$(QUITE_GEN)sed '/Everything below this line/,$$d' $@ > $@.tmp
|
|
$(QUITE_GEN)$(PYTHON) ../utils/generate-fmtargs.py >> $@.tmp
|
|
$(QUITE_GEN)mv $@.tmp $@
|
|
endif
|
|
|
|
commands.c: $(COMMANDS_DEF_FILENAME).def
|
|
|
|
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 *.so
|
|
rm -f $(DEP)
|
|
-(cd ../tests/modules && $(MAKE) clean)
|
|
|
|
.PHONY: clean
|
|
|
|
distclean: clean
|
|
-(cd ../deps && $(MAKE) distclean)
|
|
-(cd modules && $(MAKE) clean)
|
|
-(cd ../tests/modules && $(MAKE) clean)
|
|
-(rm -f .make-*)
|
|
|
|
.PHONY: distclean
|
|
|
|
test: $(REDIS_SERVER_NAME) $(REDIS_CHECK_AOF_NAME) $(REDIS_CLI_NAME) $(REDIS_BENCHMARK_NAME) module_tests
|
|
@(cd ..; ./runtest)
|
|
|
|
test-modules: $(REDIS_SERVER_NAME)
|
|
@(cd ..; ./runtest-moduleapi)
|
|
|
|
test-sentinel: $(REDIS_SENTINEL_NAME) $(REDIS_CLI_NAME)
|
|
@(cd ..; ./runtest-sentinel)
|
|
|
|
test-cluster: $(REDIS_SERVER_NAME) $(REDIS_CLI_NAME)
|
|
@(cd ..; ./runtest-cluster)
|
|
|
|
check: test
|
|
|
|
lcov:
|
|
@lcov --version
|
|
$(MAKE) gcov
|
|
@(set -e; cd ..; ./runtest)
|
|
@geninfo -o redis.info .
|
|
@genhtml --legend -o lcov-html redis.info
|
|
|
|
.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" SKIP_VEC_SETS="yes"
|
|
|
|
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"
|
|
|
|
install: all
|
|
@mkdir -p $(INSTALL_BIN)
|
|
$(call MAKE_INSTALL,$(REDIS_SERVER_NAME),$(INSTALL_BIN))
|
|
$(call MAKE_INSTALL,$(REDIS_BENCHMARK_NAME),$(INSTALL_BIN))
|
|
$(call MAKE_INSTALL,$(REDIS_CLI_NAME),$(INSTALL_BIN))
|
|
@ln -sf $(REDIS_SERVER_NAME) $(INSTALL_BIN)/$(REDIS_CHECK_RDB_NAME)
|
|
@ln -sf $(REDIS_SERVER_NAME) $(INSTALL_BIN)/$(REDIS_CHECK_AOF_NAME)
|
|
@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)}
|