98 lines
4.4 KiB
Text
98 lines
4.4 KiB
Text
# #ddev-generated
|
|
################################ THREADED I/O #################################
|
|
|
|
# Redis is mostly single threaded, however there are certain threaded
|
|
# operations such as UNLINK, slow I/O accesses and other things that are
|
|
# performed on side threads.
|
|
#
|
|
# Now it is also possible to handle Redis clients socket reads and writes
|
|
# in different I/O threads. Since especially writing is so slow, normally
|
|
# Redis users use pipelining in order to speed up the Redis performances per
|
|
# core, and spawn multiple instances in order to scale more. Using I/O
|
|
# threads it is possible to easily speedup two times Redis without resorting
|
|
# to pipelining nor sharding of the instance.
|
|
#
|
|
# By default threading is disabled, we suggest enabling it only in machines
|
|
# that have at least 4 or more cores, leaving at least one spare core.
|
|
# Using more than 8 threads is unlikely to help much. We also recommend using
|
|
# threaded I/O only if you actually have performance problems, with Redis
|
|
# instances being able to use a quite big percentage of CPU time, otherwise
|
|
# there is no point in using this feature.
|
|
#
|
|
# So for instance if you have a four cores boxes, try to use 2 or 3 I/O
|
|
# threads, if you have a 8 cores, try to use 6 threads. In order to
|
|
# enable I/O threads use the following configuration directive:
|
|
#
|
|
io-threads 1
|
|
|
|
#
|
|
# Setting io-threads to 1 will just use the main thread as usual.
|
|
# When I/O threads are enabled, we only use threads for writes, that is
|
|
# to thread the write(2) syscall and transfer the client buffers to the
|
|
# socket. However it is also possible to enable threading of reads and
|
|
# protocol parsing using the following configuration directive, by setting
|
|
# it to yes:
|
|
#
|
|
io-threads-do-reads no
|
|
|
|
#
|
|
# Usually threading reads doesn't help much.
|
|
#
|
|
# NOTE 1: This configuration directive cannot be changed at runtime via
|
|
# CONFIG SET. Aso this feature currently does not work when SSL is
|
|
# enabled.
|
|
#
|
|
# NOTE 2: If you want to test the Redis speedup using redis-benchmark, make
|
|
# sure you also run the benchmark itself in threaded mode, using the
|
|
# --threads option to match the number of Redis threads, otherwise you'll not
|
|
# be able to notice the improvements.
|
|
|
|
############################ KERNEL OOM CONTROL ##############################
|
|
|
|
# On Linux, it is possible to hint the kernel OOM killer on what processes
|
|
# should be killed first when out of memory.
|
|
#
|
|
# Enabling this feature makes Redis actively control the oom_score_adj value
|
|
# for all its processes, depending on their role. The default scores will
|
|
# attempt to have background child processes killed before all others, and
|
|
# replicas killed before masters.
|
|
|
|
oom-score-adj no
|
|
|
|
# When oom-score-adj is used, this directive controls the specific values used
|
|
# for master, replica and background child processes. Values range -1000 to
|
|
# 1000 (higher means more likely to be killed).
|
|
#
|
|
# Unprivileged processes (not root, and without CAP_SYS_RESOURCE capabilities)
|
|
# can freely increase their value, but not decrease it below its initial
|
|
# settings.
|
|
#
|
|
# Values are used relative to the initial value of oom_score_adj when the server
|
|
# starts. Because typically the initial value is 0, they will often match the
|
|
# absolute values.
|
|
|
|
oom-score-adj-values 0 200 800
|
|
|
|
################################## SLOW LOG ###################################
|
|
|
|
# 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 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
|
|
# queue of logged commands.
|
|
|
|
# The following time is expressed in microseconds, so 1000000 is equivalent
|
|
# to one second. Note that a negative number disables the slow log, while
|
|
# a value of zero forces the logging of every command.
|
|
slowlog-log-slower-than 10000
|
|
|
|
# There is no limit to this length. Just be aware that it will consume memory.
|
|
# You can reclaim memory used by the slow log with SLOWLOG RESET.
|
|
slowlog-max-len 128
|