Server

Redis DEBUG subcommand

Redis Server Course	Redis Technical Support	Redis Enterprise Server

DEBUG

레디스 서버 테스트, 디버그 용으로 사용할 수 있는 명령입니다.
redis.io에는 설명이 너무 간단해서, debug 명령을 활용할 수 있도록 정리했습니다.
Subcommand를 클릭하면 해당 설명 섹션으로 넘어갑니다.
이 문서는 5.0.2를 기준으로 작성되었습니다.

help: debug 도움말을 보여준다. 버전 3.2에서 추가
segfault: 서버를 죽인다(crash).
restart: 정상적으로 서버를 종료하고 재시작한다. 버전 3.2에서 추가
crash-and-recover: 비정상적으로 서버를 죽이고 재시작한다. 버전 3.2에서 추가
oom: Out Of Memory로 서버를 죽인다.
assert: Assertion으로 서버를 죽인다.
reload: RDB 저장 후 재로드한다.
loadaof: AOF 저장 후 재로드한다.
populate: SET 명령으로 데이터를 생성한다. 버전 3.0에서 추가
digest: 데이터베이스 비교용 정보를 생성한다.
digest-value: 지정한 키에 대한 digest값을 구한다.
sleep: 서버를 지정한 시간만큼 중지(suspend)시킨다.
set-active-expire: 만료(expire)된 키의 자동 삭제 기능을 활성화/비활성화한다.
lua-always-replicate-commands: 활성화/비활성화한다 버전 3.2에서 추가
error: 에러 메시지 테스트 버전 2.8.8에서 추가
log: 로그를 출력한다. 버전 5.0에서 추가
jemalloc info: 메모리 할당 통계정보를 보여준다. 버전 3.2에서 추가, 4.0에서 memory 명령으로 독립
jemalloc purge: 사용하지 않는 메모리를 해제한다. 버전 3.2에서 추가, 4.0에서 memory 명령으로 독립

Data Structure 관련 명령

structsize: 레디스 핵심 C 구조체 길이(바이트)를 보여준다. 버전 3.2에서 추가
object: 키 정보를 보여준다.
sdslen: SDS 문자열 길이를 보여준다. 버전 2.8.0에서 추가
htstats: 메인 hash table 구조를 볼 수 있다. 버전 3.2에서 추가
htstats-key: 키가 hash table에 저장되어 있을 때 hash table 구조를 볼 수 있다. 버전 5.0에서 추가
ziplist: Data Type이 ziplist 일 때 내부 구조를 자세히 보여준다. 버전 4.0에서 추가

DEBUG HELP

debug 도움말이다.

127.0.0.1:6379> debug help
 1) DEBUG <subcommand> arg arg ... arg. Subcommands:
 2) segfault -- Crash the server with sigsegv.
 3) restart  -- Graceful restart: save config, db, restart.
 4) crash-and-recovery <milliseconds> -- Hard crash and restart after <milliseconds> delay.
 *) oom -- Out Of Memory
 5) assert   -- Crash by assertion failed.
 6) reload   -- Save the RDB on disk and reload it back in memory.
 7) loadaof  -- Flush the AOF buffers on disk and reload the AOF in memory.
 8) object <key> -- Show low level info about key and associated value.
 9) sdslen <key> -- Show low level SDS string info representing key and value.
10) populate <count> [prefix] -- Create <count> string keys named key:<num>. 
    If a prefix is specified is used instead of the 'key' prefix.
11) digest   -- Outputs an hex signature representing the current DB content.
12) sleep <seconds> -- Stop the server for <seconds>. Decimals allowed.
13) set-active-expire (0|1) -- Setting it to 0 disables expiring keys in background when 
    they are not accessed (otherwise the Redis behavior). 
	Setting it to 1 reenables back the default.
14) lua-always-replicate-commands (0|1) -- Setting it to 1 makes Lua replication defaulting 
    to replicating single commands, without the script having to enable effects replication.
15) error <string> -- Return a Redis protocol error with <string> as message. Useful for clients 
    unit tests to simulate Redis errors.
16) structsize -- Return the size of different Redis core C structures.
17) htstats <dbid> -- Return hash table statistics of the specified Redis database.
18) jemalloc info  -- Show internal jemalloc statistics.
19) jemalloc purge -- Force jemalloc to release unused memory.

help에는 4) 번이 crash-and-recovery로 나오는데, 실제 명령은 crash-and-recover로 'y'를 빼야한다.
4) 번 다음에 *) oom은 help에는 없으나, 실제 명령은 사용할 수 있으므로 넣었다.

DEBUG SEGFAULT

Help: Crash the server with sigsegv.
redis.io 설명: performs an invalid memory access that crashes Redis. It is used to simulate bugs during the development.

소스코드: debugCommand() debug.c
if (!strcasecmp(c->argv[1]->ptr,"segfault")) { *((char*)-1) = 'x'; }
debug 명령으로 서버를 crash할 수 있는 subcommand가 4개 있다.
segfault, crash-and-recover, oom, assert 이 중에서 crash-and-recover는 아무 로그도 남기지 않지만, 나머지 3개 subcommand는 버그 리포트를 남긴다.
버그 리포트는 크게 두 부분으로 나눌 수 있는데, 앞 부분은 각 subcommand 마다 다르게 나오고, 이후 부분은 공통이다.

segfault에만 나오는 내용
=== REDIS BUG REPORT START: Cut & paste starting from here === 29609:M 13 May 13:25:12.476 # Redis 3.2.0 crashed by signal: 11 29609:M 13 May 13:25:12.476 # Crashed running the instuction at: 0x45bf40 29609:M 13 May 13:25:12.476 # Accessing address: 0xffffffffffffffff 29609:M 13 May 13:25:12.476 # Failed assertion: <no assertion failed> (<no file>:0)

공통으로 나오는 버그 리포트
------ STACK TRACE ------ EIP: src/redis-server 127.0.0.1:6379(debugCommand+0x1c0)[0x45bf40] Backtrace: src/redis-server 127.0.0.1:6379(logStackTrace+0x29)[0x45ccc9] src/redis-server 127.0.0.1:6379(sigsegvHandler+0xaa)[0x45d1ba] /lib64/libpthread.so.0(+0xf130)[0x7fbe2e0c5130] src/redis-server 127.0.0.1:6379(debugCommand+0x1c0)[0x45bf40] src/redis-server 127.0.0.1:6379(call+0x85)[0x426b95] src/redis-server 127.0.0.1:6379(processCommand+0x367)[0x429ba7] src/redis-server 127.0.0.1:6379(processInputBuffer+0x105)[0x436515] src/redis-server 127.0.0.1:6379(aeProcessEvents+0x218)[0x421338] src/redis-server 127.0.0.1:6379(aeMain+0x2b)[0x4215eb] src/redis-server 127.0.0.1:6379(main+0x40f)[0x41e5df] /lib64/libc.so.6(__libc_start_main+0xf5)[0x7fbe2dd16af5] src/redis-server 127.0.0.1:6379[0x41e865] ------ INFO OUTPUT ------ # Server redis_version:3.2.0 redis_git_sha1:00000000 redis_git_dirty:0 redis_build_id:6987c6e3becc79a5 redis_mode:standalone os:Linux 3.10.0-229.el7.x86_64 x86_64 arch_bits:64 multiplexing_api:epoll gcc_version:4.8.3 process_id:29609 run_id:ef5d42614ae0d7fea5574813cfcfe8febc8b0271 tcp_port:6379 uptime_in_seconds:41 uptime_in_days:0 hz:10 lru_clock:3495720 executable:/root/redis-3.2.0/src/redis-server config_file:/root/redis-3.2.0/6379/redis.conf # Clients connected_clients:1 client_longest_output_list:0 client_biggest_input_buf:0 blocked_clients:0 # Memory used_memory:201205264 used_memory_human:191.88M used_memory_rss:207585280 used_memory_rss_human:197.97M used_memory_peak:201205264 used_memory_peak_human:191.88M total_system_memory:8327958528 total_system_memory_human:7.76G used_memory_lua:37888 used_memory_lua_human:37.00K maxmemory:0 maxmemory_human:0B maxmemory_policy:noeviction mem_fragmentation_ratio:1.03 mem_allocator:jemalloc-4.0.3 # Persistence loading:0 rdb_changes_since_last_save:1000004 rdb_bgsave_in_progress:0 rdb_last_save_time:1463113471 rdb_last_bgsave_status:ok rdb_last_bgsave_time_sec:-1 rdb_current_bgsave_time_sec:-1 aof_enabled:1 aof_rewrite_in_progress:0 aof_rewrite_scheduled:0 aof_last_rewrite_time_sec:-1 aof_current_rewrite_time_sec:-1 aof_last_bgrewrite_status:ok aof_last_write_status:ok aof_current_size:150889045 aof_base_size:150889045 aof_pending_rewrite:0 aof_buffer_length:0 aof_rewrite_buffer_length:0 aof_pending_bio_fsync:0 aof_delayed_fsync:0 # Stats total_connections_received:1 total_commands_processed:0 instantaneous_ops_per_sec:0 total_net_input_bytes:29 total_net_output_bytes:0 instantaneous_input_kbps:0.00 instantaneous_output_kbps:0.00 rejected_connections:0 sync_full:0 sync_partial_ok:0 sync_partial_err:0 expired_keys:0 evicted_keys:0 keyspace_hits:0 keyspace_misses:0 pubsub_channels:0 pubsub_patterns:0 latest_fork_usec:0 migrate_cached_sockets:0 # Replication role:master connected_slaves:0 master_repl_offset:0 repl_backlog_active:0 repl_backlog_size:1048576 repl_backlog_first_byte_offset:0 repl_backlog_histlen:0 # CPU used_cpu_sys:0.18 used_cpu_user:1.09 used_cpu_sys_children:0.00 used_cpu_user_children:0.00 # Commandstats # Cluster cluster_enabled:0 # Keyspace db0:keys=2,expires=0,avg_ttl=0 db9:keys=1000000,expires=0,avg_ttl=0 hash_init_value: 1463726511 ------ CLIENT LIST OUTPUT ------ id=2 addr=127.0.0.1:55482 fd=6 name= age=0 idle=0 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=0 qbuf-free=32768 obl=0 oll=0 omem=0 events=r cmd=debug ------ CURRENT CLIENT INFO ------ id=2 addr=127.0.0.1:55482 fd=6 name= age=0 idle=0 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=0 qbuf-free=32768 obl=0 oll=0 omem=0 events=r cmd=debug argv[0]: 'debug' argv[1]: 'segfault' ------ REGISTERS ------ 29609:M 13 May 13:25:12.477 # RAX:0000000000000000 RBX:00007fbe27342b40 RCX:0000000000000000 RDX:00007fbe2de5aaa0 RDI:00007fbe27227d53 RSI:00000000004e4706 RBP:00007fbe27227d53 RSP:00007fffd22c7cb0 R8 :0000000000000000 R9 :0000000057355728 R10:0000000000000002 R11:0000000000000002 R12:0000000000000002 R13:00007fbe19c6a790 R14:0000000000000000 R15:00000000000f4244 RIP:000000000045bf40 EFL:0000000000010246 CSGSFS:0000000000000033 29609:M 13 May 13:25:12.477 # (00007fffd22c7cbf) -> 0000000000000000 29609:M 13 May 13:25:12.477 # (00007fffd22c7cbe) -> 0000000000000034 29609:M 13 May 13:25:12.477 # (00007fffd22c7cbd) -> 0000000000000004 29609:M 13 May 13:25:12.477 # (00007fffd22c7cbc) -> 0000000000000011 29609:M 13 May 13:25:12.477 # (00007fffd22c7cbb) -> ffff80002dd38281 29609:M 13 May 13:25:12.477 # (00007fffd22c7cba) -> 0000000000000101 29609:M 13 May 13:25:12.477 # (00007fffd22c7cb9) -> 00007fbe2e0af760 29609:M 13 May 13:25:12.477 # (00007fffd22c7cb8) -> 0000000000000001 29609:M 13 May 13:25:12.477 # (00007fffd22c7cb7) -> 0000000000000002 29609:M 13 May 13:25:12.477 # (00007fffd22c7cb6) -> 0000000000000000 29609:M 13 May 13:25:12.477 # (00007fffd22c7cb5) -> 0000000000000001 29609:M 13 May 13:25:12.477 # (00007fffd22c7cb4) -> 0000000000000001 29609:M 13 May 13:25:12.477 # (00007fffd22c7cb3) -> 00007fbe2e7e68b6 29609:M 13 May 13:25:12.477 # (00007fffd22c7cb2) -> 0000000000000002 29609:M 13 May 13:25:12.477 # (00007fffd22c7cb1) -> 0000000000000002 29609:M 13 May 13:25:12.477 # (00007fffd22c7cb0) -> 0010000000000000 ------ FAST MEMORY TEST ------ 29609:M 13 May 13:25:12.477 # Bio thread for job type #0 terminated 29609:M 13 May 13:25:12.478 # Bio thread for job type #1 terminated *** Preparing to test memory region 722000 (114688 bytes) *** Preparing to test memory region 26ba000 (135168 bytes) *** Preparing to test memory region 7fbe19c00000 (205520896 bytes) *** Preparing to test memory region 7fbe261ff000 (8388608 bytes) *** Preparing to test memory region 7fbe26a00000 (8388608 bytes) *** Preparing to test memory region 7fbe27200000 (2097152 bytes) *** Preparing to test memory region 7fbe2da00000 (2097152 bytes) *** Preparing to test memory region 7fbe2e0b1000 (20480 bytes) *** Preparing to test memory region 7fbe2e2ce000 (16384 bytes) *** Preparing to test memory region 7fbe2e9ec000 (16384 bytes) *** Preparing to test memory region 7fbe2e9f7000 (4096 bytes) *** Preparing to test memory region 7fbe2e9f8000 (4096 bytes) *** Preparing to test memory region 7fbe2e9fb000 (4096 bytes) .O.O.O.O.O.O.O.O.O.O.O.O.O Fast memory test PASSED, however your memory can still be broken. Please run a memory test for several hours if possible. === REDIS BUG REPORT END. Make sure to include from START to END. === Please report the crash by opening an issue on github: http://github.com/antirez/redis/issues Suspect RAM error? Use redis-server --test-memory to verify it.

stack trace: 어느 function에서 에러가 났는지 보여준다.
info output: info 명령을 실행했을 때 나오는 정보이다. info 명령에 대한 자세한 내용은 여기를 보세요.
client 정보: client list 정보와 현재 client 정보를 보여준다.
registers: 레지스터 정보를 보여준다.
fast memory test: 정보를 보여준다.

DEBUG RESTART

Help: Graceful restart: save config, db, restart.
버전 3.2.0에서 추가되었다.
config(설정) 정보를 rewrite 하고, RDB, AOF 데이터를 디스크에 쓰고, 서버를 재시작한다. 재시작은 시스템 콜 execvc()를 실행하므로 같은 PID를 이어받는다. 재시작 시 delay는 없다.
debug.c에서 restartServer(flags,delay=0) 실행한다. 이 function은 server.c에 있다.
flags 정보: flags = (RESTART_SERVER_GRACEFULLY|RESTART_SERVER_CONFIG_REWRITE)
다음은 restartServer()에서 수행해는 내용이다.

config 정보를 다시 쓴다. rewriteConfig(server.configfile);
서버를 정리하고 shutdown 한다. prepareForShutdown(SHUTDOWN_NOFLAGS);
- rdb child process가 있으면 kill 하고 tempfile을 지운다.
- AOF rewrite 중(AOF_WAIT_REWRITE)이면 shutdown하지 않는다. 그렇지 않으면(AOF_ON) aof child process를 kill 한다. AOF child process가 있으면서 kill 되는 시간은 rewrite 직전, 직후 아주 짧은 시간이다.
- AOF fsync()를 한다.
- RDB file을 save 한다.
- 데이터를 슬레이브 노드에 flush 한다. flushSlavesOutputBuffers();
- 소켓을 닫는다. closeListeningSockets(1);
서버를 재시작한다. execve(server.executable,server.exec_argv,environ);
소스코드: debugCommand() debug.c

if (!strcasecmp(c->argv[1]->ptr,"restart") || !strcasecmp(c->argv[1]->ptr,"crash-and-recover")) {
	long long delay = 0;
	if (c->argc >= 3) {
		if (getLongLongFromObjectOrReply(c, c->argv[2], &delay, NULL)
			!= C_OK) return;
		if (delay < 0) delay = 0;
	}
	int flags = !strcasecmp(c->argv[1]->ptr,"restart") ?
		(RESTART_SERVER_GRACEFULLY|RESTART_SERVER_CONFIG_REWRITE) :
		 RESTART_SERVER_NONE;
	restartServer(flags,delay);
	addReplyError(c,"failed to restart the server. Check server logs.");
}

DEBUG CRASH-AND-RECOVER <milliseconds>

Help: Hard crash and restart after <milliseconds> delay.
버전 3.2.0에서 추가되었다.
아무 로그도 남기지 않는다. 위에 설명한 restart 처럼 restartServer(flags,delay=ms) 실행하는데, 플래그(flags = RESTART_SERVER_NONE)를 아무것도 하지 않는 것으로 넘긴다. milliseconds 후에 execve()로 재시작한다.

DEBUG OOM

Out Of Memory
debug help에는 나오지 않는다. 소스에서는 아래와 같은 방법으로 OOM을 발생시킨다.
ULONG_MAX 값은 18,446,744,073,709,551,615ULL로 18엑사바이트이다.
kB -> MB -> GB -> TB -> PB(페타) -> EB(엑사) -> ZB(제타) -> YB(요타)

void *ptr = zmalloc(ULONG_MAX); /* Should trigger an out of memory. */

OOM에만 나오는 버그 리포트

=== REDIS BUG REPORT START: Cut & paste starting from here ===
29713:M 13 May 14:29:54.855 # ------------------------------------------------
29713:M 13 May 14:29:54.855 # !!! Software Failure. Press left mouse button to continue
29713:M 13 May 14:29:54.855 # Guru Meditation: "Redis aborting for OUT OF MEMORY" #server.c:3793
29713:M 13 May 14:29:54.855 # (forcing SIGSEGV in order to print the stack trace)
29713:M 13 May 14:29:54.855 # ------------------------------------------------
29713:M 13 May 14:29:54.855 # Redis 3.2.0 crashed by signal: 11
29713:M 13 May 14:29:54.855 # Crashed running the instuction at: 0x45b5da
29713:M 13 May 14:29:54.855 # Accessing address: 0xffffffffffffffff
29713:M 13 May 14:29:54.855 # Failed assertion: <no assertion failed> (<no file>:0)
29609:M 13 May 13:25:12.476 # Failed assertion: <no assertion failed> (<no file>:0)

공통으로 나오는 버그 리포트 중 STACK TRACE 부분

------ STACK TRACE ------
EIP:
src2/redis-server 127.0.0.1:6379(_serverPanic+0x7a)[0x45b5da]

Backtrace:
src2/redis-server 127.0.0.1:6379(logStackTrace+0x29)[0x45ccc9]
src2/redis-server 127.0.0.1:6379(sigsegvHandler+0xaa)[0x45d1ba]
/lib64/libpthread.so.0(+0xf130)[0x7f591fd9f130]
src2/redis-server 127.0.0.1:6379(_serverPanic+0x7a)[0x45b5da]
src2/redis-server 127.0.0.1:6379(redisOutOfMemoryHandler+0x2c)[0x42477c]
src2/redis-server 127.0.0.1:6379(zmalloc+0x69)[0x42d989]
src2/redis-server 127.0.0.1:6379(debugCommand+0x4dc)[0x45c25c]
src2/redis-server 127.0.0.1:6379(call+0x85)[0x426b95]
src2/redis-server 127.0.0.1:6379(processCommand+0x367)[0x429ba7]
src2/redis-server 127.0.0.1:6379(processInputBuffer+0x105)[0x436515]
src2/redis-server 127.0.0.1:6379(aeProcessEvents+0x218)[0x421338]
src2/redis-server 127.0.0.1:6379(aeMain+0x2b)[0x4215eb]
src2/redis-server 127.0.0.1:6379(main+0x40f)[0x41e5df]
/lib64/libc.so.6(__libc_start_main+0xf5)[0x7f591f9f0af5]
src2/redis-server 127.0.0.1:6379[0x41e865]

소스코드: debugCommand() debug.c

if (!strcasecmp(c->argv[1]->ptr,"oom")) {
	void *ptr = zmalloc(ULONG_MAX); /* Should trigger an out of memory. */
	zfree(ptr);
	addReply(c,shared.ok);
}

DEBUG ASSERT

Help: Crash by assertion failed.
debug assert하면 bug report를 남기고 레디스 서버가 죽는다.
debug.c에 있는 소스코드는 아래와 같다.

serverAssertWithInfo(c,c->argv[0],1 == 2);

assert에서는 마지막 인자가 False이면 서버가 죽는데, 1==2는 False이므로 서버가 죽는다.

Assert에만 나오는 버그 리포트

=== REDIS BUG REPORT START: Cut & paste starting from here ===
29853:M 13 May 14:54:39.512 # === ASSERTION FAILED CLIENT CONTEXT ===
29853:M 13 May 14:54:39.512 # client->flags = 0
29853:M 13 May 14:54:39.512 # client->fd = 6
29853:M 13 May 14:54:39.512 # client->argc = 2
29853:M 13 May 14:54:39.512 # client->argv[0] = "debug" (refcount: 1)
29853:M 13 May 14:54:39.512 # client->argv[1] = "assert" (refcount: 1)
29853:M 13 May 14:54:39.512 # === ASSERTION FAILED OBJECT CONTEXT ===
29853:M 13 May 14:54:39.512 # Object type: 0
29853:M 13 May 14:54:39.512 # Object encoding: 8
29853:M 13 May 14:54:39.512 # Object refcount: 1
29853:M 13 May 14:54:39.512 # Object raw string len: 5
29853:M 13 May 14:54:39.512 # Object raw string content: "debug"
29853:M 13 May 14:54:39.512 # === ASSERTION FAILED ===
29853:M 13 May 14:54:39.512 # ==> debug.c:333 '1 == 2' is not true
29853:M 13 May 14:54:39.512 # (forcing SIGSEGV to print the bug report.)
29853:M 13 May 14:54:39.512 # Redis 3.2.0 crashed by signal: 11
29853:M 13 May 14:54:39.512 # Crashed running the instuction at: 0x45b16a
29853:M 13 May 14:54:39.512 # Accessing address: 0xffffffffffffffff
29853:M 13 May 14:54:39.512 # Failed assertion: 1 == 2 (debug.c:333)

공통으로 나오는 버그 리포트 중 STACK TRACE 부분

------ STACK TRACE ------
EIP:
src2/redis-server 127.0.0.1:6379(_serverAssert+0x6a)[0x45b16a]

Backtrace:
src2/redis-server 127.0.0.1:6379(logStackTrace+0x29)[0x45ccc9]
src2/redis-server 127.0.0.1:6379(sigsegvHandler+0xaa)[0x45d1ba]
/lib64/libpthread.so.0(+0xf130)[0x7f488055a130]
src2/redis-server 127.0.0.1:6379(_serverAssert+0x6a)[0x45b16a]
src2/redis-server 127.0.0.1:6379(debugCommand+0xd5e)[0x45cade]
src2/redis-server 127.0.0.1:6379(call+0x85)[0x426b95]
src2/redis-server 127.0.0.1:6379(processCommand+0x367)[0x429ba7]
src2/redis-server 127.0.0.1:6379(processInputBuffer+0x105)[0x436515]
src2/redis-server 127.0.0.1:6379(aeProcessEvents+0x218)[0x421338]
src2/redis-server 127.0.0.1:6379(aeMain+0x2b)[0x4215eb]
src2/redis-server 127.0.0.1:6379(main+0x40f)[0x41e5df]
/lib64/libc.so.6(__libc_start_main+0xf5)[0x7f48801abaf5]
src2/redis-server 127.0.0.1:6379[0x41e865]

소스코드: debugCommand() debug.c

if (!strcasecmp(c->argv[1]->ptr,"assert")) {
	if (c->argc >= 3) c->argv[2] = tryObjectEncoding(c->argv[2]);
	serverAssertWithInfo(c,c->argv[0],1 == 2);
}

DEBUG RELOAD [MERGE] [NOFLUSH] [NOSAVE]

데이터를 RDB 파일에 저장하고, 메모리에 있는 데이터를 지우고, RDB 파일을 다시 읽어들여 메모리에 넣는다. 3개 옵션(MERGE, NOFLUSH, NOSAVE)은 6.0부터 사용 가능합니다.

MERGE: 키가 충돌하면 기존 키를 지우고 로드한 키를 저장한다.
NOFLUSH: 메모리에 있는 데이터를 지우지 않는다.
NOSAVE: 메모리에 있는 데이터를 저장하지 않는다. 새로운 데이터를 로드할 때 사용한다.
소스코드: debugCommand() debug.c

if (!strcasecmp(c->argv[1]->ptr,"reload")) {
    int flush = 1, save = 1; 
    int flags = RDBFLAGS_NONE;

    /* Parse the additional options that modify the RELOAD
     * behavior. */
    for (int j = 2; j < c->argc; j++) {
        char *opt = c->argv[j]->ptr;
        if (!strcasecmp(opt,"MERGE")) {
            flags |= RDBFLAGS_ALLOW_DUP;
        } else if (!strcasecmp(opt,"NOFLUSH")) {
            flush = 0; 
        } else if (!strcasecmp(opt,"NOSAVE")) {
            save = 0; 
        } else {
            addReplyError(c,"DEBUG RELOAD only supports the "
                            "MERGE, NOFLUSH and NOSAVE options.");
            return;
        }    
    }    

    /* The default beahvior is to save the RDB file before loading
     * it back. */
    if (save) {
        rdbSaveInfo rsi, *rsiptr;
        rsiptr = rdbPopulateSaveInfo(&rsi);
        if (rdbSave(server.rdb_filename,rsiptr) != C_OK) {
            addReply(c,shared.err);
            return;
        }    
    }    

    /* The default behavior is to remove the current dataset from
     * memory before loading the RDB file, however when MERGE is
     * used together with NOFLUSH, we are able to merge two datasets. */
    if (flush) emptyDb(-1,EMPTYDB_NO_FLAGS,NULL);

    protectClient(c);
    int ret = rdbLoad(server.rdb_filename,NULL,flags);
    unprotectClient(c);
    if (ret != C_OK) {
        addReplyError(c,"Error trying to load the RDB dump");
        return;
    }
    serverLog(LL_WARNING,"DB reloaded by DEBUG RELOAD");
    addReply(c,shared.ok);
}

DEBUG LOADAOF

Help: Flush the AOF buffers on disk and reload the AOF in memory.
AOF가 OFF 일때도 AppendOnlyFile을 읽어들인다.

AOF가 ON이면 아직 AppendOnlyFile에 쓰이지 않은 데이터를 flush 한다. flushAppendOnlyFile(1)
버전 3.2.0 이전에는 이 부분이 없었다.
메모리에 있는 데이터 삭제한다. emptyDb(NULL)
AppendOnlyFile을 읽어들인다. loadAppendOnlyFile(server.aof_filename)
AOF나 슬레이브 노드에 전파(propagate)되는 것을 막기 위해 다음과 같이 셋팅한다.
server.dirty = 0; /* Prevent AOF/replication */
소스코드: debugCommand() debug.c

if (!strcasecmp(c->argv[1]->ptr,"loadaof")) {
	if (server.aof_state == AOF_ON) flushAppendOnlyFile(1);
	emptyDb(NULL);
	if (loadAppendOnlyFile(server.aof_filename) != C_OK) {
		addReply(c,shared.err);
		return;
	}
	server.dirty = 0; /* Prevent AOF / replication */
	serverLog(LL_WARNING,"Append Only File loaded by DEBUG LOADAOF");
	addReply(c,shared.ok);
}

DEBUG OBJECT

Help: Show low level info about key and associated value.
redis.io 설명: DEBUG OBJECT is a debugging command that should not be used by clients. Check the OBJECT command instead.
Object 명령과 비슷한 정보를 보여주지만, 그것보다 더 자세하다. object 명령에 대한 자세한 내용은 여기를 보세요.

입력된 예로써 각 항목을 설명한다.

127.0.0.1:6379> set key value
OK
127.0.0.1:6379> debug object key
Value at:0x7fd6e1eb70c0 refcount:1 encoding:embstr serializedlength:6 lru:3916170 lru_seconds_idle:23

Value at: 값이 있는 메모리 주소(포인터), 소스코드: (void*)val
refcount: 값의 참조 횟수, 레디스는 메모리를 절약하기 위해서 0~9999까지 숫자는 미리 만들어 놓고 사용한다. 이 숫자들의 초기 refcount는 1이고, 실제 값이 입력되면 2가 된다. 다른 값은 입력되는 시점에 1이 된다. OBJECT refcount 명령은 여기를 참고하세요.
encoding: 데이터의 인코딩 타입이고 종류는 다음과 같다. 클릭하면 자세한 정보가 나옵니다.
int, embstr, raw, ziplist, intset, quicklist, skiplist, hashtable
OBJECT encoding 명령은 여기를 참고하세요.
serializedlength: RDB 파일에 저장할때 값의 길이다. 값 앞에 길이를 저장하는데, 이 길이 바이트까지 포함한 바이트 수이다. 압축되었을 경우는 압축된 길이를 나타낸다. 예에서 6인 이유는, 길이 5를 저장하는 1 바이트, "value" 5 바이트, 합해서 6 바이트입니다.
RDB file format은 여기를 참고하세요.
lru: 키 생성 시 lru(Least Recently Used) time이 들어가고, access마다 변경된다. 이 값으로 idletime을 구하고, 메모리 정책에 따라 삭제될 키를 찾는데 사용된다.
lru_seconds_idle: 마지막 access 한 이후로 지난 시간을 초로 보여준다.
OBJECT idletime 명령은 여기를 참고하세요.

인코딩 타입이 Quicklist일때는 좀 더 자세한 정보를 보여준다.
127.0.0.1:6379> lrange mylist 0 -1
1) "0123456789"
2) "01234567890123456789"
3) "012345678901234567890123456789"
127.0.0.1:6379> debug object mylist
Value at:0x7fd6f56a74a0 refcount:1 encoding:quicklist serializedlength:48 lru:3935360 lru_seconds_idle:10 ql_nodes:1 ql_avg_node:3.00 ql_ziplist_max:-2 ql_compressed:0 ql_uncompressed_size:77
- ql_nodes: quicklist 노드수
- ql_avg_node: 노드당 평균 값(엔트리) 개수, 계산식 = 총 entires(element) 수 / quicklist 노드수
- ql_ziplist_max: ziplist 크기: -1(4kb), -2(8kb) default, -3(16kb), -4(32kb), -5(64kb)
  이것은 redis.conf에 list-max-ziplist-size 파라미터와 관계가 있다.
  다음은 redis.conf에 나와있는 설명이다. # Lists are also encoded in a special way to save a lot of space. # The number of entries allowed per internal list node can be specified # as a fixed maximum size or a maximum number of elements. # For a fixed maximum size, use -5 through -1, meaning: # -5: max size: 64 Kb <-- not recommended for normal workloads # -4: max size: 32 Kb <-- not recommended # -3: max size: 16 Kb <-- probably not recommended # -2: max size: 8 Kb <-- good # -1: max size: 4 Kb <-- good # Positive numbers mean store up to _exactly_ that number of elements # per list node. # The highest performing option is usually -2 (8 Kb size) or -1 (4 Kb size), # but if your use case is unique, adjust the settings as necessary. list-max-ziplist-size -2
- ql_compressed: 압축 여부: 0은 압축하지 않음, 1은 압축
  압축 방식(list-compress-depth)은 아래를 참조하세요.
  1은 head, tail 2개 노드는 압축하지 않고 나머지 노드는 압축한다.
  다음은 redis.conf에 나와있는 설명이다. # Lists may also be compressed. # Compress depth is the number of quicklist ziplist nodes from *each* side of # the list to *exclude* from compression. The head and tail of the list # are always uncompressed for fast push/pop operations. Settings are: # 0: disable all list compression # 1: depth 1 means "don't start compressing until after 1 node into the list, # going from either the head or tail" # So: [head]->node->node->...->node->[tail] # [head], [tail] will always be uncompressed; inner nodes will compress. # 2: [head]->[next]->node->node->...->node->[prev]->[tail] # 2 here means: don't compress head or head->next or tail->prev or tail, # but compress all nodes between them. # 3: [head]->[next]->[next]->node->node->...->node->[prev]->[prev]->[tail] # etc. list-compress-depth 0
- ql_uncompressed_size: 퀵리스트 모든 노드의 압축되지 않는 사이즈(바이트)이다.
  예에서 ql_uncompressed_size:77인것은 값 3개가 10, 20, 30바이트로 합하면 60바이트이고, 각 값마다 prelen, itself len이 각 1바이트씩, 2바이트가 들어가고, 짚리스트 헤더 10바이트, 테일(zlend) 1바이트, 총 77바이트이다. 계산식: 값(66)+길이(6)+헤더(10)+테일(1) = 77바이트.
  serializedlength 48은 77바이트 짚리스트 노드를 RDB 파일에 저장하기 위해서 합축했을때의 크기이다.
소스코드: debugCommand() debug.c

if (!strcasecmp(c->argv[1]->ptr,"object") && c->argc == 3) {
	dictEntry *de;
	robj *val;
	char *strenc;

	if ((de = dictFind(c->db->dict,c->argv[2]->ptr)) == NULL) {
		addReply(c,shared.nokeyerr);
		return;
	}
	val = dictGetVal(de);
	strenc = strEncoding(val->encoding);

	char extra[128] = {0};
	if (val->encoding == OBJ_ENCODING_QUICKLIST) {
		char *nextra = extra;
		int remaining = sizeof(extra);
		quicklist *ql = val->ptr;
		/* Add number of quicklist nodes */
		int used = snprintf(nextra, remaining, " ql_nodes:%u", ql->len);
		nextra += used;
		remaining -= used;
		/* Add average quicklist fill factor */
		double avg = (double)ql->count/ql->len;
		used = snprintf(nextra, remaining, " ql_avg_node:%.2f", avg);
		nextra += used;
		remaining -= used;
		/* Add quicklist fill level / max ziplist size */
		used = snprintf(nextra, remaining, " ql_ziplist_max:%d", ql->fill);
		nextra += used;
		remaining -= used;
		/* Add isCompressed? */
		int compressed = ql->compress != 0;
		used = snprintf(nextra, remaining, " ql_compressed:%d", compressed);
		nextra += used;
		remaining -= used;
		/* Add total uncompressed size */
		unsigned long sz = 0;
		for (quicklistNode *node = ql->head; node; node = node->next) {
			sz += node->sz;
		}
		used = snprintf(nextra, remaining, " ql_uncompressed_size:%lu", sz);
		nextra += used;
		remaining -= used;
	}

	addReplyStatusFormat(c,
		"Value at:%p refcount:%d "
		"encoding:%s serializedlength:%zu "
		"lru:%d lru_seconds_idle:%llu%s",
		(void*)val, val->refcount,
		strenc, rdbSavedObjectLen(val),
		val->lru, estimateObjectIdleTime(val)/1000, extra);
}

DEBUG SDSLEN

Help: Show low level SDS string info representing key and value.
SDS(Simple Dynamic Strings)는 레디스에서 string을 다루는 Library이다. 키와 값의 길이(바이트)와 할당했지만 아직 비어있어 사용 가능한 바이트수를 표시한다. 버전 2.8.0에서 추가되었다.

127.0.0.1:6379> set key value
OK
127.0.0.1:6379> debug sdslen key
key_sds_len:3, key_sds_avail:0, val_sds_len:5, val_sds_avail:0

대상은 데이터 타입이 string이고 문자열(embstr, raw)일때 가능하다. 값이 정수이면 안된다.

key_sds_len: 키에 널('\0') 문자를 제외한 순수 문자열 길이(바이트)
key_sds_avail: 키에 사용 가능한 공간 길이(바이트)
val_sds_len: 값에 널('\0') 문자를 제외한 순수 문자열 길이(바이트)
val_sds_avail: 값에 사용 가능한 공간 길이(바이트), append 명령을 사용해서 큰 값(value)을 입력하면 0이 아닌 값(avail)을 볼 수 있다.
소스코드: debugCommand() debug.c

if (!strcasecmp(c->argv[1]->ptr,"sdslen") && c->argc == 3) {
	dictEntry *de;
	robj *val;
	sds key;

	if ((de = dictFind(c->db->dict,c->argv[2]->ptr)) == NULL) {
		addReply(c,shared.nokeyerr);
		return;
	}
	val = dictGetVal(de);
	key = dictGetKey(de);

	if (val->type != OBJ_STRING || !sdsEncodedObject(val)) {
		addReplyError(c,"Not an sds encoded string.");
	} else {
		addReplyStatusFormat(c,
			"key_sds_len:%lld, key_sds_avail:%lld, "
			"val_sds_len:%lld, val_sds_avail:%lld",
			(long long) sdslen(key),
			(long long) sdsavail(key),
			(long long) sdslen(val->ptr),
			(long long) sdsavail(val->ptr));
	}
}

DEBUG POPULATE

Help: Create string keys named key:. If a prefix is specified is used instead of the 'key' prefix.
테스트용 데이터를 생성할 때 사용된다. 버전 3.0에서 추가되었다.
클러스터에서는 사용하지 말 것. 슬롯을 고려하지 않고 dbAdd() function으로 바로 들어가므로 비정상적인 DB 상황이 된다.

사용법: populate <count> [prefix]
<count>는 입력 횟수로, SET 명령 실행 횟수를 정하는 것이다. 생략할 수 없다.
[prefix]는 키를 정한다. 생략하면 'key'로 시작하는 키가 생성된다. prefix는 키에만 영향을 미친다.
아래는 실제 입력과 결과이다.

debug populate 100 -> key:1 value:1 ~ key:100 value:100
debug populate 100 xxx -> xxx:1 value:1 ~ xxx:100 value:100

소스코드: debugCommand() debug.c

if (!strcasecmp(c->argv[1]->ptr,"populate") && (c->argc == 3 || c->argc == 4)) {
	long keys, j;	/* keys is <count> */
	robj *key, *val;
	char buf[128];

	if (getLongFromObjectOrReply(c, c->argv[2], &keys, NULL) != C_OK)
		return;
	dictExpand(c->db->dict,keys);
	for (j = 0; j < keys; j++) {
		snprintf(buf,sizeof(buf),"%s:%lu",
			(c->argc == 3) ? "key" : (char*)c->argv[3]->ptr, j);
		key = createStringObject(buf,strlen(buf));
		if (lookupKeyWrite(c->db,key) != NULL) {
			decrRefCount(key);
			continue;
		}
		snprintf(buf,sizeof(buf),"value:%lu",j);
		val = createStringObject(buf,strlen(buf));
		dbAdd(c->db,key,val);
		signalModifiedKey(c->db,key);
		decrRefCount(key);
	}
	addReply(c,shared.ok);
}

DEBUG DIGEST

Help: Outputs an hex signature representing the current DB content.
DIGEST는 데이터베이스 전체의 해시 값을 20 바이트로 계산합니다. 이 값으로 두 서버 데이터가 같은지 비교할 수 있습니다. 예를 들어 마스터와 슬레이브 DB 데이터가 같은지 확인할 수 있습니다.
이 명령은 CPU를 많이 사용하고, 명령이 수행되는 동안 다른 명령을 실행할 수 없으므로 사용시 주의가 필요합니다.

실행 예

127.0.0.1:6379> debug digest
c471feae63d93dc4302e0db02c3b2da3d2e35d4f
(3.10s)

소스코드: Main function은 debug.c에 있는 computeDatasetDigest()이다.

if (!strcasecmp(c->argv[1]->ptr,"digest") && c->argc == 2) {
	unsigned char digest[20];
	sds d = sdsempty();
	int j;

	computeDatasetDigest(digest);
	for (j = 0; j < 20; j++)
		d = sdscatprintf(d, "%02x",digest[j]);
	addReplyStatus(c,d);
	sdsfree(d);
}

DEBUG DIGEST-VALUE

Help: Output a hex signature of the values of all the specified keys.
지정한 키의 값에 대한 digest값을 계산한다.

127.0.0.1:5010> debug digest-value key1 key2
1) 8b06d62b6b33e452ce6d722400e8de8505ababb8
2) 638a70cdd3e1ed9b5888f8bf4e86166ce3e7bc4d

DEBUG SLEEP

Help: Stop the server for . Decimals allowed.
지정한 시간(초) 동안 서버의 모든 기능을 멈춘다. 소수점 이하도 입력할 수 있다.
응답 시간(latency) 테스트 등에 사용된다.

실행 예

127.0.0.1:6379> debug sleep 1
OK
(1.00s)
127.0.0.1:6379> debug sleep 5.5
OK
(5.50s)
127.0.0.1:6379> debug sleep 70
OK
(70.00s)

소스코드: debugCommand() debug.c

if (!strcasecmp(c->argv[1]->ptr,"sleep") && c->argc == 3) {
	double dtime = strtod(c->argv[2]->ptr,NULL);
	long long utime = dtime*1000000;
	struct timespec tv;

	tv.tv_sec = utime / 1000000;
	tv.tv_nsec = (utime % 1000000) * 1000;
	nanosleep(&tv, NULL);
	addReply(c,shared.ok);
}

DEBUG SET-ACTIVE-EXPIRE

Help: Setting it to 0 disables expiring keys in background when they are not accessed (otherwise the Redis behavior). Setting it to 1 reenables back the default.

레디스 서버는 디폴트로 1초에 10번(100ms마다) databasesCron()을 실행해서 만료된(expire) 키를 삭제한다. 이 기능을 활성화(1)/비활성화(0) 할 수 있다. 이 기능은 레디스 서버에 당연히 제공되어야 하는 것이므로 redis.conf에 설정할 수 없고, debug 명령으로만 가능하다.
만료된 키를 삭제하는 것은 get 같은 명령을 실행할 때도 expire time을 확인해서 지났으면 삭제한다. 명령 실행 시 만료 키 삭제 기능은 100ms마다 만료된 키를 삭제하지만, 그 사이에 access 했을 때를 대비해서이다. 그리고 이 100ms는 redis.conf에 hz 파라미터로 계산(1000/hz) 하는데, hz를 1로 하면 1초에 한 번씩 수행하게 된다. 그러므로 access 시에 만료된 키를 삭제하는 기능은 필요하다.

실행 예

127.0.0.1:6379> debug set-active-expire 0
OK
127.0.0.1:6379> debug set-active-expire 1
OK

소스코드: debugCommand() debug.c

if (!strcasecmp(c->argv[1]->ptr,"set-active-expire") && c->argc == 3) {
	server.active_expire_enabled = atoi(c->argv[2]->ptr);
	addReply(c,shared.ok);
}

소스코드: databasesCron() server.c

void databasesCron(void) {
    /* Expire keys by random sampling. Not required for slaves
     * as master will synthesize DELs for us. */
    if (server.active_expire_enabled && server.masterhost == NULL)
        activeExpireCycle(ACTIVE_EXPIRE_CYCLE_SLOW);

DEBUG LUA-ALWAYS-REPLICATE-COMMANDS

Help: Setting it to 1 makes Lua replication defaulting to replicating single commands, without the script having to enable effects replication.
버전 3.2.0에서 추가되었다.

실행 예

127.0.0.1:6379> debug lua-always-replicate-commands 0
OK
127.0.0.1:6379> debug lua-always-replicate-commands 1
OK

소스코드: debugCommand() debug.c

if (!strcasecmp(c->argv[1]->ptr,"lua-always-replicate-commands") && c->argc == 3) {
	server.lua_always_replicate_commands = atoi(c->argv[2]->ptr);
	addReply(c,shared.ok);
}

DEBUG ERROR

Help: Return a Redis protocol error with as message. Useful for clients unit tests to simulate Redis errors. 버전 2.8.8에서 추가되었다.

실행 예

127.0.0.1:6379> debug error "This is a error Message."
(error) This is a error Message.

소스코드: debugCommand() debug.c

if (!strcasecmp(c->argv[1]->ptr,"error") && c->argc == 3) {
	sds errstr = sdsnewlen("-",1);

	errstr = sdscatsds(errstr,c->argv[2]->ptr);
	errstr = sdsmapchars(errstr,"\n\r","  ",2); /* no newlines in errors. */
	errstr = sdscatlen(errstr,"\r\n",2);
	addReplySds(c,errstr);
}

DEBUG LOG

Help: write message to the server log.
버전 5.0에서 추가되었다.

실행 예

127.0.0.1:5010> debug log "Log Message"
OK
22837:M 31 Dec 2018 23:17:00.631 # DEBUG LOG: Log Messag

DEBUG STRUCTSIZE

Return the size of different Redis core C structures.
버전 3.2.0에서 추가되었다.
레디스 핵심 C 구조체의 크기(바이트)를 보여준다.

실행 예

127.0.0.1:6379> debug structsize
"bits:64 robj:16 dictentry:24 sdshdr5:1 sdshdr8:3 sdshdr16:5 sdshdr32:9 sdshdr64:17 "

bits:64는 info server 명령의 arch_bits:64 와 같은 데이터이다.
robj:16은 redisObject 구조체이다. 아래는 server.h에 있는 정의이다.

/* The actual Redis Object */
#define LRU_BITS 24
#define LRU_CLOCK_MAX ((1<<LRU_BITS)-1) /* Max value of obj->lru */
#define LRU_CLOCK_RESOLUTION 1000 /* LRU clock resolution in ms */
typedef struct redisObject {
    unsigned type:4;
    unsigned encoding:4;
    unsigned lru:LRU_BITS; /* lru time (relative to server.lruclock) */
    int refcount;	/* 4 bytes */
    void *ptr;		/* 8 bytes */
} robj;

dictentry:24는 dictEntry 구조체이다. 아래는 dict.h에 있는 정의이다.

typedef struct dictEntry {
    void *key;		/* 8 bytes */
    union {
        void *val;
        uint64_t u64;
        int64_t s64;
        double d;
    } v;			/* 8 bytes */
    struct dictEntry *next;	/* 8 bytes */
} dictEntry;

sdshdr5:1 sds header 구조는 버전 3.2.0에서 많이 변경되었다. sds.h에 정의되어 있다.

/* Note: sdshdr5 is never used, we just access the flags byte directly.
 * However is here to document the layout of type 5 SDS strings. */
struct __attribute__ ((__packed__)) sdshdr5 {
    unsigned char flags; /* 3 lsb of type, and 5 msb of string length */
    char buf[];
};

** 구조체의 마지막 멤버인 char buf[]는 크기를 지정하지 않은 멤버로 구조체의 마지막 멤버일 때만 허용된다.
이것을 사용하면 포인터를 사용하지 않고 가변 데이터를 저장할 수 있다.
sizeof 연산자에서 이 배열 크기는 0으로 간주된다.
sdshdr8:3

struct __attribute__ ((__packed__)) sdshdr8 {
    uint8_t len; /* used */
    uint8_t alloc; /* excluding the header and null terminator */
    unsigned char flags; /* 3 lsb of type, 5 unused bits */
    char buf[];
};

sdshdr16:5

struct __attribute__ ((__packed__)) sdshdr16 {
    uint16_t len; /* used */
    uint16_t alloc; /* excluding the header and null terminator */
    unsigned char flags; /* 3 lsb of type, 5 unused bits */
    char buf[];
};

sdshdr32:9

struct __attribute__ ((__packed__)) sdshdr32 {
    uint32_t len; /* used */
    uint32_t alloc; /* excluding the header and null terminator */
    unsigned char flags; /* 3 lsb of type, 5 unused bits */
    char buf[];
};

sdshdr64:17

struct __attribute__ ((__packed__)) sdshdr64 {
    uint64_t len; /* used */
    uint64_t alloc; /* excluding the header and null terminator */
    unsigned char flags; /* 3 lsb of type, 5 unused bits */
    char buf[];
};

버전 3.2.0 이전: sdshdr:8

struct sdshdr {
    unsigned int len;
    unsigned int free;
    char buf[];
};

DEBUG HTSTATS

Help: Return hash table statistics of the specified Redis database.
버전 3.2.0에서 추가되었다.
DB 키 통계정보(Hash table)를 보여준다. Hash table에 대한 설명은 여기를 보세요.

사용법: debug htstats dbid

실행 예

127.0.0.1:6379> debug htstats 0
[Dictionary HT]
Hash table 0 stats (main hash table):
 table size: 262144
 number of elements: 105876
 different slots: 67050
 max chain length: 7
 avg chain length (counted): 1.58
 avg chain length (computed): 1.58
 Chain length distribution:
   0: 195094 (74.42%)
   1: 39129 (14.93%)
   2: 19456 (7.42%)
   3: 6479 (2.47%)
   4: 1617 (0.62%)
   5: 294 (0.11%)
   6: 65 (0.02%)
   7: 10 (0.00%)
Hash table 1 stats (rehashing target):
 table size: 524288
 number of elements: 175986
 different slots: 137807
 max chain length: 6
 avg chain length (counted): 1.28
 avg chain length (computed): 1.28
 Chain length distribution:
   0: 386481 (73.72%)
   1: 105835 (20.19%)
   2: 26539 (5.06%)
   3: 4727 (0.90%)
   4: 641 (0.12%)
   5: 62 (0.01%)
   6: 3 (0.00%)
[Expires HT]
Hash table 0 stats (main hash table):
 table size: 4
 number of elements: 2
 different slots: 2
 max chain length: 1
 avg chain length (counted): 1.00
 avg chain length (computed): 1.00
 Chain length distribution:
   0: 2 (50.00%)
   1: 2 (50.00%)

통계정보는 크게 세 부분으로 구성된다.
- [Dictionary HT] Hash table 0 stats (main hash table): 메인 해시 테이블 정보
- Hash table 1 stats (rehashing target): rehashing 중일때만 나온다.
- [Expires HT] Hash table 0 stats (main hash table): Expire 키가 있을 때만 나온다.
항목 설명
- table size: 262144 : Hash table 크기, 예는 2^18이다.
- number of elements: 105876 : 키 개수이다.
- max chain length: 7 : 해시 값이 충돌해서 최대로 연결된 개수이다. 아래 Chain length distribution의 마지막 숫자와 같다.
- avg chain length (counted): 1.58 : 평균 체인 길이다.
- Chain length distribution:
  0: 195094 (74.42%): 사용되지 않는 slot이다. table size 262144 중 74.42%인 195094개가 미사용중이다.
  1: 39129 (14.93%) 엔트리가 하나만 달려있는 slot 개수이다.
  7: 10 (0.00%) 엔트리가 7개 달려있는 slot 개수이다.
소스코드 #1: debugCommand() debug.c

if (!strcasecmp(c->argv[1]->ptr,"htstats") && c->argc == 3) {
	long dbid;
	sds stats = sdsempty();
	char buf[4096];

	if (getLongFromObjectOrReply(c, c->argv[2], &dbid, NULL) != C_OK)
		return;
	if (dbid < 0 || dbid >= server.dbnum) {
		addReplyError(c,"Out of range database");
		return;
	}

	stats = sdscatprintf(stats,"[Dictionary HT]\n");
	dictGetStats(buf,sizeof(buf),server.db[dbid].dict);
	stats = sdscat(stats,buf);

	stats = sdscatprintf(stats,"[Expires HT]\n");
	dictGetStats(buf,sizeof(buf),server.db[dbid].expires);
	stats = sdscat(stats,buf);

	addReplyBulkSds(c,stats);
}

소스코드 #2: dictGetStats() dict.c

void dictGetStats(char *buf, size_t bufsize, dict *d) {
    size_t l;
    char *orig_buf = buf;
    size_t orig_bufsize = bufsize;

    l = _dictGetStatsHt(buf,bufsize,&d->ht[0],0);
    buf += l;
    bufsize -= l;
    if (dictIsRehashing(d) && bufsize > 0) {
        _dictGetStatsHt(buf,bufsize,&d->ht[1],1);
    }
    /* Make sure there is a NULL term at the end. */
    if (orig_bufsize) orig_buf[orig_bufsize-1] = '\0';
}

소스코드 #3: _dictGetStatsHt() dict.c

#define DICT_STATS_VECTLEN 50
size_t _dictGetStatsHt(char *buf, size_t bufsize, dictht *ht, int tableid) {
    unsigned long i, slots = 0, chainlen, maxchainlen = 0;
    unsigned long totchainlen = 0;
    unsigned long clvector[DICT_STATS_VECTLEN];
    size_t l = 0;

    if (ht->used == 0) {
        return snprintf(buf,bufsize,
            "No stats available for empty dictionaries\n");
    }

    /* Compute stats. */
    for (i = 0; i < DICT_STATS_VECTLEN; i++) clvector[i] = 0;
    for (i = 0; i < ht->size; i++) {
        dictEntry *he;

        if (ht->table[i] == NULL) {
            clvector[0]++;
            continue;
        }
        slots++;
        /* For each hash entry on this slot... */
        chainlen = 0;
        he = ht->table[i];
        while(he) {
            chainlen++;
            he = he->next;
        }
        clvector[(chainlen < DICT_STATS_VECTLEN) ? chainlen : (DICT_STATS_VECTLEN-1)]++;
        if (chainlen > maxchainlen) maxchainlen = chainlen;
        totchainlen += chainlen;
    }

    /* Generate human readable stats. */
    l += snprintf(buf+l,bufsize-l,
        "Hash table %d stats (%s):\n"
        " table size: %ld\n"
        " number of elements: %ld\n"
        " different slots: %ld\n"
        " max chain length: %ld\n"
        " avg chain length (counted): %.02f\n"
        " avg chain length (computed): %.02f\n"
        " Chain length distribution:\n",
        tableid, (tableid == 0) ? "main hash table" : "rehashing target",
        ht->size, ht->used, slots, maxchainlen,
        (float)totchainlen/slots, (float)ht->used/slots);

    for (i = 0; i < DICT_STATS_VECTLEN-1; i++) {
        if (clvector[i] == 0) continue;
        if (l >= bufsize) break;
        l += snprintf(buf+l,bufsize-l,
            "   %s%ld: %ld (%.02f%%)\n",
            (i == DICT_STATS_VECTLEN-1)?">= ":"",
            i, clvector[i], ((float)clvector[i]/ht->size)*100);
    }

    /* Unlike snprintf(), teturn the number of characters actually written. */
    if (bufsize) buf[bufsize-1] = '\0';
    return strlen(buf);
}

DEBUG HTSTATS-KEY

Help: Like htstats but for the hash table stored as key's value..
키가 hash table에 저장되어 있을 때 hash table 정보를 조회합니다.
키의 내부 data type은 object encoding 명령으로 확인할 수 있습니다.
사용법: debug htstats-key key

실행 예

127.0.0.1:5010> sadd myset A B C D E F
(integer) 6
127.0.0.1:5010> debug htstats-key myset
Hash table 0 stats (main hash table):
 table size: 4
 number of elements: 3
 different slots: 2
 max chain length: 2
 avg chain length (counted): 1.50
 avg chain length (computed): 1.50
 Chain length distribution:
   0: 2 (50.00%)
   1: 1 (25.00%)
   2: 1 (25.00%)
Hash table 1 stats (rehashing target):
 table size: 8
 number of elements: 3
 different slots: 2
 max chain length: 2
 avg chain length (counted): 1.50
 avg chain length (computed): 1.50
 Chain length distribution:
   0: 6 (75.00%)
   1: 1 (12.50%)
   2: 1 (12.50%)

DEBUG JEMALLOC INFO

Help: Show internal 버전 3.2.0에서 4.0에서는 memory malloc-stats 이다.
Jemallc()는 레디스에서 미리 정해놓은 단위로 할당함으로써 메모리 할당 속도를 높이고, 메모리 단편화(fragmantation)를 Jason Evans가 레디스 버전 debug jemalloc info ___ Begin jemalloc statistics ___ Version: 4.0.3-0-ge9192e Assertions disabled Run-time option settings: opt.abort: false opt.lg_chunk: 21 opt.dss: "secondary" opt.narenas: 32 opt.lg_dirty_mult: opt.stats_print: false opt.junk: "false" opt.quarantine: 0 opt.redzone: false opt.zero: false opt.tcache: true opt.lg_tcache_max: 15 CPUs: 8 Arenas: 32 Pointer size: 8 Quantum size: 16 Page size: 4096 Min active:dirty Maximum thread-cached size class: 32768 Chunk size: 2097152 (2^21) Allocated: 202613296, Current active ceiling: 203423744 arenas[0]: assigned threads: 1 dss allocation precedence: secondary min active:dirty page ratio: 8:1 dirty pages: 49514:21 small: large: huge: total: active: 202809344 mapped: 209715200 metadata: mapped: bins: size ind 8 0 16 1 32 2 48 3 64 4 80 5 96 6 112 7 128 8 160 9 192 10 224 11 256 12 320 13 --- 448 15 512 16 640 17 768 18 896 19 1024 20 1280 21 --- 1792 23 2048 24 2560 25 3072 26 --- 4096 28 5120 29 --- 8192 32 10240 33 --- large: size ind 16384 36 20480 37 --- 28672 39 32768 40 40960 41 --- 65536 44 81920 45 98304 46 --- 131072 48 --- 262144 52 327680 53 --- 524288 56 --- 1048576 60 --- huge: size ind 2097152 64 --- 4194304 68 --- 8388608 72 --- --- End jemalloc jemalloc statistics.
추가되었다. 4.0에서 debug 명령에서는 제거되었고, memory 명령이 새로 생겼다. 메인으로 사용하고 있는 메모리 할당 알고리즘으로, 줄일 수 있는 이점이 있다.
개발해서 malloc 앞에 JE가 붙었다. 3.2.0에서는 jemalloc 4.0.3이 사용된다.
ebook.com/notes/facebook-engineering/scalable-memory-allocation-using-jemalloc/480222803919" target="_blink" class="redis_link"> 쓴 jemalloc에 대한 글을 보려면 여기를 클릭하세요 cols="90" rows="15" wrap="off" readonly> acf8935e29fc62fddc2701f7942b1cc02c 3 (arenas.lg_dirty_mult: 3) page ratio per arena: 8:1 active: 202809344, metadata: 6521984, resident: 209092608, mapped: 211812352 active:dirty, 0 sweeps, 0 madvises, 0 purged allocated nmalloc ndalloc nrequests 193327664 4044601 2983 10079199 897024 61 51 61 8388608 3 2 3 202613296 4044665 3036 10079263 5111808, allocated: 325888 allocated nmalloc ndalloc nrequests curregs curruns regs pgs util nfills nflushes newruns reruns 10544 2900 1582 1002892 1318 3 512 1 0.858 601 544 5 4 32309088 2019409 91 5018507 2019318 7888 256 1 0.999 20196 6 7889 1 32658752 1020618 32 3042711 1020586 7974 128 1 0.999 10208 5 7974 2 1776 112 75 14271 37 1 256 3 0.144 4 9 1 0 1088 136 119 96 17 1 64 1 0.265 5 9 2 1 720 406 397 402 9 1 256 5 0.035 5 6 2 1 9504 131 32 183 99 1 128 3 0.773 3 5 1 0 0 109 109 3 0 0 256 7 1 3 7 3 0 128000768 1000052 46 1000009 1000006 31251 32 1 0.999 31267 4 31251 0 480 109 106 4 3 1 128 5 0.023 3 6 3 0 768 68 64 1 4 1 64 3 0.062 2 4 2 0 224 106 105 3 1 1 128 7 0.007 2 6 1 0 4352 37 20 22 17 2 16 1 0.531 4 5 4 0 0 68 68 2 0 0 64 5 1 2 6 2 0 28672 64 0 0 64 1 64 7 1 1 0 1 0 0 11 11 4 0 0 8 1 1 2 4 3 0 0 32 32 3 0 0 32 5 1 1 3 1 0 12288 16 0 0 16 1 16 3 1 1 0 1 0 58240 65 0 33 65 3 32 7 0.677 1 0 3 0 2048 11 9 5 2 1 4 1 0.500 2 4 3 1 0 16 16 2 0 0 16 5 1 1 3 1 0 28672 16 0 0 16 1 16 7 1 1 0 1 0 6144 12 9 4 3 2 2 1 0.750 3 4 7 0 0 10 10 2 0 0 8 5 1 1 2 2 0 0 10 10 1 0 0 4 3 1 1 2 3 0 8192 12 10 1 2 2 1 1 1 2 2 12 0 168960 43 10 35 33 9 4 5 0.916 1 2 12 0 16384 12 10 1 2 2 1 2 1 2 2 12 0 0 10 10 2 0 0 2 5 1 1 2 5 0 allocated nmalloc ndalloc nrequests curruns 16384 3 2 3 1 40960 3 1 3 2 28672 1 0 1 1 0 1 1 1 0 40960 42 41 42 1 0 1 1 1 0 81920 2 1 2 1 98304 1 0 1 1 262144 3 1 3 2 0 1 1 1 0 327680 1 0 1 1 0 1 1 1 0 0 1 1 1 0 allocated nmalloc ndalloc nrequests curhchunks 0 1 1 1 0 0 1 1 1 0 8388608 1 0 1 1 statistics ---

small: 16kb 미만
large: 16kb ~ 2mb 미만
huge: 2mb 이상
allocated: 할당된 메모리 바이트 = (nmalloc - ndalloc) * size
예에서는 total 200mb가 할당되었다.
nmalloc: 할당한 횟수
ndalloc: 해제한 횟수
Quantum: time slice라고도 한다.

두산백과 시분할시스템(time sharing system) 설명

DEBUG JEMALLOC PURGE

Force jemalloc to release unused memory.
버전 3.2.0에서 추가되었다. 4.0에서 debug 명령에서는 제거되었고, memory 명령이 새로 생겼다. 4.0에서는 memory purge 이다.
jemalloc가 사용하지 않는 메모리를 해제한다.

소스코드: info, purge 같이 표시 debugCommand() debug.c

if (!strcasecmp(c->argv[1]->ptr,"jemalloc") && c->argc == 3) {
#if defined(USE_JEMALLOC)
	if (!strcasecmp(c->argv[2]->ptr, "info")) {
		sds info = sdsempty();
		je_malloc_stats_print(inputCatSds, &info, NULL);
		addReplyBulkSds(c, info);
	} else if (!strcasecmp(c->argv[2]->ptr, "purge")) {
		char tmp[32];
		unsigned narenas = 0;
		size_t sz = sizeof(unsigned);
		if (!je_mallctl("arenas.narenas", &narenas, &sz, NULL, 0)) {
			sprintf(tmp, "arena.%d.purge", narenas);
			if (!je_mallctl(tmp, NULL, 0, NULL, 0)) {
				addReply(c, shared.ok);
				return;
			}
		}
		addReplyError(c, "Error purging dirty pages");
	} else {
		addReplyErrorFormat(c, "Valid jemalloc debug fields: info, purge");
	}
#else
    addReplyErrorFormat(c, "jemalloc support not available");
#endif
}

DEBUG ZIPLIST key

Show low level info about the ziplist encoding.
Data Type이 ziplist 일 때 내부 구조를 자세히 보여준다.
Ziplist 내부구조 그림과 같이 보면 이해하는데 도움이 됩니다. 127.0.0.1:5010> hset myhash field1 value1 (integer) 1 127.0.0.1:5010> hset myhash field2 value2 (integer) 1 127.0.0.1:5010> debug ziplist myhash Ziplist structure printed on stdout {total bytes 43} {num entries 4} {tail offset 34} { addr 0x7f2b9f40f87a, index 0, offset 10, hdr+entry len: 8, hdr len 2, prevrawlen: 0, prevrawlensize: 1, payload 6 bytes: 00|06|66|69|65|6c|64|31| [str]field1 } { addr 0x7f2b9f40f882, index 1, offset 18, hdr+entry len: 8, hdr len 2, prevrawlen: 8, prevrawlensize: 1, payload 6 bytes: 08|06|76|61|6c|75|65|31| [str]value1 } { addr 0x7f2b9f40f88a, index 2, offset 26, hdr+entry len: 8, hdr len 2, prevrawlen: 8, prevrawlensize: 1, payload 6 bytes: 08|06|66|69|65|6c|64|32| [str]field2 } { addr 0x7f2b9f40f892, index 3, offset 34, hdr+entry len: 8, hdr len 2, prevrawlen: 8, prevrawlensize: 1, payload 6 bytes: 08|06|76|61|6c|75|65|32| [str]value2 } {end}

DEBUG

3.0	3.2	4.0	5.0
assert	assert	assert	assert
digest	digest	digest	digest
error	error	error	error
			log
loadaof	loadaof	loadaof	loadaof
object	object	object	object
oom	oom	oom	oom
populate	populate	populate	populate
reload	reload	reload	reload
sdslen	sdslen	sdslen	sdslen
segfault	segfault	segfault	segfault
set-active-expire	set-active-expire	set-active-expire	set-active-expire
sleep	sleep	sleep	sleep
	crash-and-recover	crash-and-recover	crash-and-recover
	htstats	htstats	htstats
			htstats-key
	jemalloc info
	jemalloc purge
	lua-always-replicate-commands	lua-always-replicate-commands	lua-always-replicate-commands
	restart	restart	restart
	structsize	structsize	structsize
		panic	panic
		ziplist	ziplist
			change-repl-id

명령문

DEBUG subcommand arg1 arg2 ... argN

이 명령은 version 1.0.0 부터 사용할 수 있다.
논리적 처리 소요시간은 subcommand 마다 다르다.

Clients for C

Hiredis

<< INFO	DEBUG	SLOWLOG >>

조회수 :

Email 답글이 올라오면 이메일로 알려드리겠습니다.