Find useful information of config.ini - rDSN

To find the latest explanation for each item in config file, you should run "config-dump" in "dsn cli", which will print out all default config and one single-line explanation for each config. (To find more useful commands, run "help".)
One sample (not necessarily the latest)
[apps..default]
; arguments for the app instances
arguments = 

; count of app instances for this type (ports are automatically calculated accordingly to avoid confliction)
count = 1

; delay seconds for when the apps should be started
delay_seconds = 0

; path of a dynamic library which implement this app role, and register itself upon loaded
dmodule = 

; network channel configuration, e.g., dsn::tools::asio_network_provider,65536
network.client.RPC_CHANNEL_TCP = dsn::tools::sim_network_provider, 65536

; network channel configuration, e.g., dsn::tools::asio_network_provider,65536
network.client.RPC_CHANNEL_UDP = dsn::tools::sim_network_provider, 65536

; network channel configuration, e.g., NET_HDR_DSN, dsn::tools::asio_network_provider,65536
network.server.0.RPC_CHANNEL_TCP = NET_HDR_DSN, dsn::tools::sim_network_provider, 65536

; thread pools need to be started
pools = 

; RPC server listening ports needed for this app
ports = 

; whether to run the app instances or not
run = true

; app type name, as given when registering by dsn_register_app_role
type = 


[apps.client]
; arguments for the app instances
arguments = localhost 8101

; 
bench = queue-test

; 
concurrency = 100000000

; count of app instances for this type (ports are automatically calculated accordingly to avoid confliction)
count = 1

; delay seconds for when the apps should be started
delay_seconds = 0

; path of a dynamic library which implement this app role, and register itself upon loaded
dmodule = 

; 
echo2 = true

; 
message_size = 1

; 
name = client

; thread pools need to be started
pools = THREAD_POOL_DEFAULT

; RPC server listening ports needed for this app
ports = 

; 
queue-test-local = true

; whether to run the app instances or not
run = true

; app type name, as given when registering by dsn_register_app_role
type = client


[apps.server]
; arguments for the app instances
arguments = 

; count of app instances for this type (ports are automatically calculated accordingly to avoid confliction)
count = 1

; delay seconds for when the apps should be started
delay_seconds = 0

; path of a dynamic library which implement this app role, and register itself upon loaded
dmodule = 

; 
name = server

; thread pools need to be started
pools = THREAD_POOL_DEFAULT

; RPC server listening ports needed for this app
ports = 8101,8103

; whether to run the app instances or not
run = true

; app type name, as given when registering by dsn_register_app_role
type = server


[components.simple_perf_counter]
; period (seconds) the system computes the percentiles of the counters
counter_computation_interval_seconds = 30


[core]
; aio aspect providers, usually for tooling purpose
aio_aspects = 

; asynchonous file system provider
aio_factory_name = 

; whether to enable local command line interface (cli)
cli_local = true

; whether to enable remote command line interface (using dsn.cli)
cli_remote = true

; where to put the core dump files
coredump_dir = ./coredump

; how many disk engines? IOE_PER_NODE, or IOE_PER_QUEUE
disk_io_mode = 

; environment aspect providers, usually for tooling purpose
env_aspects = 

; environment provider
env_factory_name = 

; io thread count, only for IOE_PER_NODE; for IOE_PER_QUEUE, task workers are served as io threads
io_worker_count = 2

; recursive lock aspect providers, usually for tooling purpose
lock_aspects = 

; recursive exclusive lock provider
lock_factory_name = 

; non-recurisve lock aspect providers, usually for tooling purpose
lock_nr_aspects = 

; non-recurisve exclusive lock provider
lock_nr_factory_name = 

; logging provider
logging_factory_name = 

; logs with level below this will not be logged
logging_start_level = LOG_LEVEL_INFORMATION

; memory management provider
memory_factory_name = 

; network aspect providers, usually for tooling purpose
network_aspects = 

; nfs provider
nfs_factory_name = 

; how many nfs engines? IOE_PER_NODE, or IOE_PER_QUEUE
nfs_io_mode = 

; whether to pause at startup time for easier debugging
pause_on_start = false

; peformance counter provider
perf_counter_factory_name = 

; how many rpc engines? IOE_PER_NODE, or IOE_PER_QUEUE
rpc_io_mode = 

; non-recursive rwlock aspect providers, usually for tooling purpose
rwlock_nr_aspects = 

; non-recurisve rwlock provider
rwlock_nr_factory_name = 

; semaphore aspect providers, usually for tooling purpose
semaphore_aspects = 

; semaphore provider
semaphore_factory_name = 

; whether to start nfs
start_nfs = false

; timer service aspect providers, usually for tooling purpose
timer_aspects = 

; timer service provider
timer_factory_name = 

; how many disk timer services? IOE_PER_NODE, or IOE_PER_QUEUE
timer_io_mode = 

; thread number for timer service for core itself
timer_service_worker_count = 1

; use what tool to run this process, e.g., native or simulator
tool = nativerun

; use what toollets, e.g., tracer, profiler, fault_injector
toollets = tracer, profiler

; memory management provider for tools
tools_memory_factory_name = 


[network]
; 
io_service_worker_count = 8

; whether crc is enabled for network messages
message_crc_required = false


[task..default]
; whether the task can be executed inlined with the caller task
allow_inline = false

; whether to collect how many time this kind of tasks invoke each of other kinds tasks
collect_call_count = true

; whether the rpc task can be executed in network threads directly
fast_execution_in_network_thread = false

; group rpc mode: GRPC_TO_LEADER, GRPC_TO_ALL, GRPC_TO_ANY
grpc_mode = 

; whether to profile this kind of task
is_profile = true

; whether to trace tasks by default
is_trace = true

; thread pool to execute the task
pool_code = 

; task priority
priority = 

; what kind of network channel for this kind of rpc calls
rpc_call_channel = RPC_CHANNEL_TCP

; what kind of header format for this kind of rpc calls
rpc_call_header_format = 

; 
rpc_message_header_format = dsn

; what is the default timeout (ms) for this kind of rpc calls
rpc_timeout_milliseconds = 5000


[task.LPC_AIO_BATCH_WRITE]
; whether the task can be executed inlined with the caller task
allow_inline = false

; whether to collect how many time this kind of tasks invoke each of other kinds tasks
collect_call_count = true

; whether the rpc task can be executed in network threads directly
fast_execution_in_network_thread = false

; group rpc mode: GRPC_TO_LEADER, GRPC_TO_ALL, GRPC_TO_ANY
grpc_mode = 

; whether to profile this kind of task
is_profile = true

; whether to trace this kind of task
is_trace = true

; thread pool to execute the task
pool_code = 

; task priority
priority = 

; what kind of network channel for this kind of rpc calls
rpc_call_channel = 

; what kind of header format for this kind of rpc calls
rpc_call_header_format = 

; what is the default timeout (ms) for this kind of rpc calls
rpc_timeout_milliseconds = 5000

; whether to trace when an aio task is called
tracer::on_aio_call = true

; whether to trace when an aio task is enqueued
tracer::on_aio_enqueue = true

; whether to trace when a rpc is made
tracer::on_rpc_call = true

; whether to trace when reply a rpc request
tracer::on_rpc_reply = true

; whether to trace when a rpc request task is enqueued
tracer::on_rpc_request_enqueue = true

; whetehr to trace when a rpc response task is enqueued
tracer::on_rpc_response_enqueue = true

; whether to trace when a task begins
tracer::on_task_begin = true

; whether to trace when a task ends
tracer::on_task_end = true

; whether to trace when a timer or async task is enqueued
tracer::on_task_enqueue = true


[task.LPC_AIO_IMMEDIATE_CALLBACK]
; 
allow_inline = false

; 
is_profile = false

; 
is_trace = false


[task.LPC_CONTROL_SERVICE_APP]
; whether the task can be executed inlined with the caller task
allow_inline = false

; whether to collect how many time this kind of tasks invoke each of other kinds tasks
collect_call_count = true

; whether the rpc task can be executed in network threads directly
fast_execution_in_network_thread = false

; group rpc mode: GRPC_TO_LEADER, GRPC_TO_ALL, GRPC_TO_ANY
grpc_mode = 

; whether to profile this kind of task
is_profile = true

; whether to trace this kind of task
is_trace = true

; thread pool to execute the task
pool_code = 

; task priority
priority = 

; what kind of network channel for this kind of rpc calls
rpc_call_channel = 

; what kind of header format for this kind of rpc calls
rpc_call_header_format = 

; what is the default timeout (ms) for this kind of rpc calls
rpc_timeout_milliseconds = 5000

; whether to trace when an aio task is called
tracer::on_aio_call = true

; whether to trace when an aio task is enqueued
tracer::on_aio_enqueue = true

; whether to trace when a rpc is made
tracer::on_rpc_call = true

; whether to trace when reply a rpc request
tracer::on_rpc_reply = true

; whether to trace when a rpc request task is enqueued
tracer::on_rpc_request_enqueue = true

; whetehr to trace when a rpc response task is enqueued
tracer::on_rpc_response_enqueue = true

; whether to trace when a task begins
tracer::on_task_begin = true

; whether to trace when a task ends
tracer::on_task_end = true

; whether to trace when a timer or async task is enqueued
tracer::on_task_enqueue = true


[task.LPC_ECHO_TIMER]
; 
pool_code = THREAD_POOL_DEFAULT


[task.LPC_ECHO_TIMER1]
; whether the task can be executed inlined with the caller task
allow_inline = false

; whether to collect how many time this kind of tasks invoke each of other kinds tasks
collect_call_count = true

; whether the rpc task can be executed in network threads directly
fast_execution_in_network_thread = false

; group rpc mode: GRPC_TO_LEADER, GRPC_TO_ALL, GRPC_TO_ANY
grpc_mode = 

; whether to profile this kind of task
is_profile = true

; whether to trace this kind of task
is_trace = true

; thread pool to execute the task
pool_code = 

; task priority
priority = 

; what kind of network channel for this kind of rpc calls
rpc_call_channel = 

; what kind of header format for this kind of rpc calls
rpc_call_header_format = 

; what is the default timeout (ms) for this kind of rpc calls
rpc_timeout_milliseconds = 5000

; whether to trace when an aio task is called
tracer::on_aio_call = true

; whether to trace when an aio task is enqueued
tracer::on_aio_enqueue = true

; whether to trace when a rpc is made
tracer::on_rpc_call = true

; whether to trace when reply a rpc request
tracer::on_rpc_reply = true

; whether to trace when a rpc request task is enqueued
tracer::on_rpc_request_enqueue = true

; whetehr to trace when a rpc response task is enqueued
tracer::on_rpc_response_enqueue = true

; whether to trace when a task begins
tracer::on_task_begin = true

; whether to trace when a task ends
tracer::on_task_end = true

; whether to trace when a timer or async task is enqueued
tracer::on_task_enqueue = true


[task.LPC_ECHO_TIMER2]
; whether the task can be executed inlined with the caller task
allow_inline = false

; whether to collect how many time this kind of tasks invoke each of other kinds tasks
collect_call_count = true

; whether the rpc task can be executed in network threads directly
fast_execution_in_network_thread = false

; group rpc mode: GRPC_TO_LEADER, GRPC_TO_ALL, GRPC_TO_ANY
grpc_mode = 

; whether to profile this kind of task
is_profile = true

; whether to trace this kind of task
is_trace = true

; thread pool to execute the task
pool_code = 

; task priority
priority = 

; what kind of network channel for this kind of rpc calls
rpc_call_channel = 

; what kind of header format for this kind of rpc calls
rpc_call_header_format = 

; what is the default timeout (ms) for this kind of rpc calls
rpc_timeout_milliseconds = 5000

; whether to trace when an aio task is called
tracer::on_aio_call = true

; whether to trace when an aio task is enqueued
tracer::on_aio_enqueue = true

; whether to trace when a rpc is made
tracer::on_rpc_call = true

; whether to trace when reply a rpc request
tracer::on_rpc_reply = true

; whether to trace when a rpc request task is enqueued
tracer::on_rpc_request_enqueue = true

; whetehr to trace when a rpc response task is enqueued
tracer::on_rpc_response_enqueue = true

; whether to trace when a task begins
tracer::on_task_begin = true

; whether to trace when a task ends
tracer::on_task_end = true

; whether to trace when a timer or async task is enqueued
tracer::on_task_enqueue = true


[task.LPC_NATIVE_AIO_REDIRECT]
; whether the task can be executed inlined with the caller task
allow_inline = false

; whether to collect how many time this kind of tasks invoke each of other kinds tasks
collect_call_count = true

; whether the rpc task can be executed in network threads directly
fast_execution_in_network_thread = false

; group rpc mode: GRPC_TO_LEADER, GRPC_TO_ALL, GRPC_TO_ANY
grpc_mode = 

; whether to profile this kind of task
is_profile = true

; whether to trace this kind of task
is_trace = true

; thread pool to execute the task
pool_code = 

; task priority
priority = 

; what kind of network channel for this kind of rpc calls
rpc_call_channel = 

; what kind of header format for this kind of rpc calls
rpc_call_header_format = 

; what is the default timeout (ms) for this kind of rpc calls
rpc_timeout_milliseconds = 5000

; whether to trace when an aio task is called
tracer::on_aio_call = true

; whether to trace when an aio task is enqueued
tracer::on_aio_enqueue = true

; whether to trace when a rpc is made
tracer::on_rpc_call = true

; whether to trace when reply a rpc request
tracer::on_rpc_reply = true

; whether to trace when a rpc request task is enqueued
tracer::on_rpc_request_enqueue = true

; whetehr to trace when a rpc response task is enqueued
tracer::on_rpc_response_enqueue = true

; whether to trace when a task begins
tracer::on_task_begin = true

; whether to trace when a task ends
tracer::on_task_end = true

; whether to trace when a timer or async task is enqueued
tracer::on_task_enqueue = true


[task.LPC_NFS_COPY_FILE]
; whether the task can be executed inlined with the caller task
allow_inline = false

; whether to collect how many time this kind of tasks invoke each of other kinds tasks
collect_call_count = true

; whether the rpc task can be executed in network threads directly
fast_execution_in_network_thread = false

; group rpc mode: GRPC_TO_LEADER, GRPC_TO_ALL, GRPC_TO_ANY
grpc_mode = 

; whether to profile this kind of task
is_profile = true

; whether to trace this kind of task
is_trace = true

; thread pool to execute the task
pool_code = 

; task priority
priority = 

; what kind of network channel for this kind of rpc calls
rpc_call_channel = 

; what kind of header format for this kind of rpc calls
rpc_call_header_format = 

; what is the default timeout (ms) for this kind of rpc calls
rpc_timeout_milliseconds = 5000

; whether to trace when an aio task is called
tracer::on_aio_call = true

; whether to trace when an aio task is enqueued
tracer::on_aio_enqueue = true

; whether to trace when a rpc is made
tracer::on_rpc_call = true

; whether to trace when reply a rpc request
tracer::on_rpc_reply = true

; whether to trace when a rpc request task is enqueued
tracer::on_rpc_request_enqueue = true

; whetehr to trace when a rpc response task is enqueued
tracer::on_rpc_response_enqueue = true

; whether to trace when a task begins
tracer::on_task_begin = true

; whether to trace when a task ends
tracer::on_task_end = true

; whether to trace when a timer or async task is enqueued
tracer::on_task_enqueue = true


[task.LPC_NFS_FILE_CLOSE_TIMER]
; whether the task can be executed inlined with the caller task
allow_inline = false

; whether to collect how many time this kind of tasks invoke each of other kinds tasks
collect_call_count = true

; whether the rpc task can be executed in network threads directly
fast_execution_in_network_thread = false

; group rpc mode: GRPC_TO_LEADER, GRPC_TO_ALL, GRPC_TO_ANY
grpc_mode = 

; whether to profile this kind of task
is_profile = true

; whether to trace this kind of task
is_trace = true

; thread pool to execute the task
pool_code = 

; task priority
priority = 

; what kind of network channel for this kind of rpc calls
rpc_call_channel = 

; what kind of header format for this kind of rpc calls
rpc_call_header_format = 

; what is the default timeout (ms) for this kind of rpc calls
rpc_timeout_milliseconds = 5000

; whether to trace when an aio task is called
tracer::on_aio_call = true

; whether to trace when an aio task is enqueued
tracer::on_aio_enqueue = true

; whether to trace when a rpc is made
tracer::on_rpc_call = true

; whether to trace when reply a rpc request
tracer::on_rpc_reply = true

; whether to trace when a rpc request task is enqueued
tracer::on_rpc_request_enqueue = true

; whetehr to trace when a rpc response task is enqueued
tracer::on_rpc_response_enqueue = true

; whether to trace when a task begins
tracer::on_task_begin = true

; whether to trace when a task ends
tracer::on_task_end = true

; whether to trace when a timer or async task is enqueued
tracer::on_task_enqueue = true


[task.LPC_NFS_READ]
; whether the task can be executed inlined with the caller task
allow_inline = false

; whether to collect how many time this kind of tasks invoke each of other kinds tasks
collect_call_count = true

; whether the rpc task can be executed in network threads directly
fast_execution_in_network_thread = false

; group rpc mode: GRPC_TO_LEADER, GRPC_TO_ALL, GRPC_TO_ANY
grpc_mode = 

; whether to profile this kind of task
is_profile = true

; whether to trace this kind of task
is_trace = true

; thread pool to execute the task
pool_code = 

; task priority
priority = 

; what kind of network channel for this kind of rpc calls
rpc_call_channel = 

; what kind of header format for this kind of rpc calls
rpc_call_header_format = 

; what is the default timeout (ms) for this kind of rpc calls
rpc_timeout_milliseconds = 5000

; whether to trace when an aio task is called
tracer::on_aio_call = true

; whether to trace when an aio task is enqueued
tracer::on_aio_enqueue = true

; whether to trace when a rpc is made
tracer::on_rpc_call = true

; whether to trace when reply a rpc request
tracer::on_rpc_reply = true

; whether to trace when a rpc request task is enqueued
tracer::on_rpc_request_enqueue = true

; whetehr to trace when a rpc response task is enqueued
tracer::on_rpc_response_enqueue = true

; whether to trace when a task begins
tracer::on_task_begin = true

; whether to trace when a task ends
tracer::on_task_end = true

; whether to trace when a timer or async task is enqueued
tracer::on_task_enqueue = true


[task.LPC_NFS_REQUEST_TIMER]
; whether the task can be executed inlined with the caller task
allow_inline = false

; whether to collect how many time this kind of tasks invoke each of other kinds tasks
collect_call_count = true

; whether the rpc task can be executed in network threads directly
fast_execution_in_network_thread = false

; group rpc mode: GRPC_TO_LEADER, GRPC_TO_ALL, GRPC_TO_ANY
grpc_mode = 

; whether to profile this kind of task
is_profile = true

; whether to trace this kind of task
is_trace = true

; thread pool to execute the task
pool_code = 

; task priority
priority = 

; what kind of network channel for this kind of rpc calls
rpc_call_channel = 

; what kind of header format for this kind of rpc calls
rpc_call_header_format = 

; what is the default timeout (ms) for this kind of rpc calls
rpc_timeout_milliseconds = 5000

; whether to trace when an aio task is called
tracer::on_aio_call = true

; whether to trace when an aio task is enqueued
tracer::on_aio_enqueue = true

; whether to trace when a rpc is made
tracer::on_rpc_call = true

; whether to trace when reply a rpc request
tracer::on_rpc_reply = true

; whether to trace when a rpc request task is enqueued
tracer::on_rpc_request_enqueue = true

; whetehr to trace when a rpc response task is enqueued
tracer::on_rpc_response_enqueue = true

; whether to trace when a task begins
tracer::on_task_begin = true

; whether to trace when a task ends
tracer::on_task_end = true

; whether to trace when a timer or async task is enqueued
tracer::on_task_enqueue = true


[task.LPC_NFS_WRITE]
; whether the task can be executed inlined with the caller task
allow_inline = false

; whether to collect how many time this kind of tasks invoke each of other kinds tasks
collect_call_count = true

; whether the rpc task can be executed in network threads directly
fast_execution_in_network_thread = false

; group rpc mode: GRPC_TO_LEADER, GRPC_TO_ALL, GRPC_TO_ANY
grpc_mode = 

; whether to profile this kind of task
is_profile = true

; whether to trace this kind of task
is_trace = true

; thread pool to execute the task
pool_code = 

; task priority
priority = 

; what kind of network channel for this kind of rpc calls
rpc_call_channel = 

; what kind of header format for this kind of rpc calls
rpc_call_header_format = 

; what is the default timeout (ms) for this kind of rpc calls
rpc_timeout_milliseconds = 5000

; whether to trace when an aio task is called
tracer::on_aio_call = true

; whether to trace when an aio task is enqueued
tracer::on_aio_enqueue = true

; whether to trace when a rpc is made
tracer::on_rpc_call = true

; whether to trace when reply a rpc request
tracer::on_rpc_reply = true

; whether to trace when a rpc request task is enqueued
tracer::on_rpc_request_enqueue = true

; whetehr to trace when a rpc response task is enqueued
tracer::on_rpc_response_enqueue = true

; whether to trace when a task begins
tracer::on_task_begin = true

; whether to trace when a task ends
tracer::on_task_end = true

; whether to trace when a timer or async task is enqueued
tracer::on_task_enqueue = true


[task.LPC_RPC_TIMEOUT]
; whether the task can be executed inlined with the caller task
allow_inline = false

; whether to collect how many time this kind of tasks invoke each of other kinds tasks
collect_call_count = true

; whether the rpc task can be executed in network threads directly
fast_execution_in_network_thread = false

; group rpc mode: GRPC_TO_LEADER, GRPC_TO_ALL, GRPC_TO_ANY
grpc_mode = 

; whether to profile this kind of task
is_profile = false

; whether to trace this kind of task
is_trace = false

; thread pool to execute the task
pool_code = 

; task priority
priority = 

; what kind of network channel for this kind of rpc calls
rpc_call_channel = 

; what kind of header format for this kind of rpc calls
rpc_call_header_format = 

; what is the default timeout (ms) for this kind of rpc calls
rpc_timeout_milliseconds = 5000


[task.RPC_DSN_CLI_CALL]
; whether the task can be executed inlined with the caller task
allow_inline = false

; whether to collect how many time this kind of tasks invoke each of other kinds tasks
collect_call_count = true

; whether the rpc task can be executed in network threads directly
fast_execution_in_network_thread = false

; group rpc mode: GRPC_TO_LEADER, GRPC_TO_ALL, GRPC_TO_ANY
grpc_mode = 

; whether to profile this kind of task
is_profile = true

; whether to trace this kind of task
is_trace = true

; thread pool to execute the task
pool_code = 

; task priority
priority = 

; what kind of network channel for this kind of rpc calls
rpc_call_channel = 

; what kind of header format for this kind of rpc calls
rpc_call_header_format = 

; what is the default timeout (ms) for this kind of rpc calls
rpc_timeout_milliseconds = 5000

; whether to trace when an aio task is called
tracer::on_aio_call = true

; whether to trace when an aio task is enqueued
tracer::on_aio_enqueue = true

; whether to trace when a rpc is made
tracer::on_rpc_call = true

; whether to trace when reply a rpc request
tracer::on_rpc_reply = true

; whether to trace when a rpc request task is enqueued
tracer::on_rpc_request_enqueue = true

; whetehr to trace when a rpc response task is enqueued
tracer::on_rpc_response_enqueue = true

; whether to trace when a task begins
tracer::on_task_begin = true

; whether to trace when a task ends
tracer::on_task_end = true

; whether to trace when a timer or async task is enqueued
tracer::on_task_enqueue = true


[task.RPC_DSN_CLI_CALL_ACK]
; whether the task can be executed inlined with the caller task
allow_inline = false

; whether to collect how many time this kind of tasks invoke each of other kinds tasks
collect_call_count = true

; whether the rpc task can be executed in network threads directly
fast_execution_in_network_thread = false

; group rpc mode: GRPC_TO_LEADER, GRPC_TO_ALL, GRPC_TO_ANY
grpc_mode = 

; whether to profile this kind of task
is_profile = true

; whether to trace this kind of task
is_trace = true

; thread pool to execute the task
pool_code = 

; task priority
priority = 

; what kind of network channel for this kind of rpc calls
rpc_call_channel = 

; what kind of header format for this kind of rpc calls
rpc_call_header_format = 

; what is the default timeout (ms) for this kind of rpc calls
rpc_timeout_milliseconds = 5000

; whether to trace when an aio task is called
tracer::on_aio_call = true

; whether to trace when an aio task is enqueued
tracer::on_aio_enqueue = true

; whether to trace when a rpc is made
tracer::on_rpc_call = true

; whether to trace when reply a rpc request
tracer::on_rpc_reply = true

; whether to trace when a rpc request task is enqueued
tracer::on_rpc_request_enqueue = true

; whetehr to trace when a rpc response task is enqueued
tracer::on_rpc_response_enqueue = true

; whether to trace when a task begins
tracer::on_task_begin = true

; whether to trace when a task ends
tracer::on_task_end = true

; whether to trace when a timer or async task is enqueued
tracer::on_task_enqueue = true


[task.RPC_ECHO]
; whether the task can be executed inlined with the caller task
allow_inline = false

; whether to collect how many time this kind of tasks invoke each of other kinds tasks
collect_call_count = true

; whether the rpc task can be executed in network threads directly
fast_execution_in_network_thread = false

; group rpc mode: GRPC_TO_LEADER, GRPC_TO_ALL, GRPC_TO_ANY
grpc_mode = 

; whether to profile this kind of task
is_profile = true

; whether to trace this kind of task
is_trace = true

; thread pool to execute the task
pool_code = 

; task priority
priority = 

; what kind of network channel for this kind of rpc calls
rpc_call_channel = 

; what kind of header format for this kind of rpc calls
rpc_call_header_format = 

; what is the default timeout (ms) for this kind of rpc calls
rpc_timeout_milliseconds = 5000

; whether to trace when an aio task is called
tracer::on_aio_call = true

; whether to trace when an aio task is enqueued
tracer::on_aio_enqueue = true

; whether to trace when a rpc is made
tracer::on_rpc_call = true

; whether to trace when reply a rpc request
tracer::on_rpc_reply = true

; whether to trace when a rpc request task is enqueued
tracer::on_rpc_request_enqueue = true

; whetehr to trace when a rpc response task is enqueued
tracer::on_rpc_response_enqueue = true

; whether to trace when a task begins
tracer::on_task_begin = true

; whether to trace when a task ends
tracer::on_task_end = true

; whether to trace when a timer or async task is enqueued
tracer::on_task_enqueue = true


[task.RPC_ECHO_ACK]
; whether the task can be executed inlined with the caller task
allow_inline = false

; whether to collect how many time this kind of tasks invoke each of other kinds tasks
collect_call_count = true

; whether the rpc task can be executed in network threads directly
fast_execution_in_network_thread = false

; group rpc mode: GRPC_TO_LEADER, GRPC_TO_ALL, GRPC_TO_ANY
grpc_mode = 

; whether to profile this kind of task
is_profile = true

; whether to trace this kind of task
is_trace = true

; thread pool to execute the task
pool_code = 

; task priority
priority = 

; what kind of network channel for this kind of rpc calls
rpc_call_channel = 

; what kind of header format for this kind of rpc calls
rpc_call_header_format = 

; what is the default timeout (ms) for this kind of rpc calls
rpc_timeout_milliseconds = 5000

; whether to trace when an aio task is called
tracer::on_aio_call = true

; whether to trace when an aio task is enqueued
tracer::on_aio_enqueue = true

; whether to trace when a rpc is made
tracer::on_rpc_call = true

; whether to trace when reply a rpc request
tracer::on_rpc_reply = true

; whether to trace when a rpc request task is enqueued
tracer::on_rpc_request_enqueue = true

; whetehr to trace when a rpc response task is enqueued
tracer::on_rpc_response_enqueue = true

; whether to trace when a task begins
tracer::on_task_begin = true

; whether to trace when a task ends
tracer::on_task_end = true

; whether to trace when a timer or async task is enqueued
tracer::on_task_enqueue = true


[task.RPC_NFS_COPY]
; whether the task can be executed inlined with the caller task
allow_inline = false

; whether to collect how many time this kind of tasks invoke each of other kinds tasks
collect_call_count = true

; whether the rpc task can be executed in network threads directly
fast_execution_in_network_thread = false

; group rpc mode: GRPC_TO_LEADER, GRPC_TO_ALL, GRPC_TO_ANY
grpc_mode = 

; whether to profile this kind of task
is_profile = true

; whether to trace this kind of task
is_trace = true

; thread pool to execute the task
pool_code = 

; task priority
priority = 

; what kind of network channel for this kind of rpc calls
rpc_call_channel = 

; what kind of header format for this kind of rpc calls
rpc_call_header_format = 

; what is the default timeout (ms) for this kind of rpc calls
rpc_timeout_milliseconds = 5000

; whether to trace when an aio task is called
tracer::on_aio_call = true

; whether to trace when an aio task is enqueued
tracer::on_aio_enqueue = true

; whether to trace when a rpc is made
tracer::on_rpc_call = true

; whether to trace when reply a rpc request
tracer::on_rpc_reply = true

; whether to trace when a rpc request task is enqueued
tracer::on_rpc_request_enqueue = true

; whetehr to trace when a rpc response task is enqueued
tracer::on_rpc_response_enqueue = true

; whether to trace when a task begins
tracer::on_task_begin = true

; whether to trace when a task ends
tracer::on_task_end = true

; whether to trace when a timer or async task is enqueued
tracer::on_task_enqueue = true


[task.RPC_NFS_COPY_ACK]
; whether the task can be executed inlined with the caller task
allow_inline = false

; whether to collect how many time this kind of tasks invoke each of other kinds tasks
collect_call_count = true

; whether the rpc task can be executed in network threads directly
fast_execution_in_network_thread = false

; group rpc mode: GRPC_TO_LEADER, GRPC_TO_ALL, GRPC_TO_ANY
grpc_mode = 

; whether to profile this kind of task
is_profile = true

; whether to trace this kind of task
is_trace = true

; thread pool to execute the task
pool_code = 

; task priority
priority = 

; what kind of network channel for this kind of rpc calls
rpc_call_channel = 

; what kind of header format for this kind of rpc calls
rpc_call_header_format = 

; what is the default timeout (ms) for this kind of rpc calls
rpc_timeout_milliseconds = 5000

; whether to trace when an aio task is called
tracer::on_aio_call = true

; whether to trace when an aio task is enqueued
tracer::on_aio_enqueue = true

; whether to trace when a rpc is made
tracer::on_rpc_call = true

; whether to trace when reply a rpc request
tracer::on_rpc_reply = true

; whether to trace when a rpc request task is enqueued
tracer::on_rpc_request_enqueue = true

; whetehr to trace when a rpc response task is enqueued
tracer::on_rpc_response_enqueue = true

; whether to trace when a task begins
tracer::on_task_begin = true

; whether to trace when a task ends
tracer::on_task_end = true

; whether to trace when a timer or async task is enqueued
tracer::on_task_enqueue = true


[task.RPC_NFS_GET_FILE_SIZE]
; whether the task can be executed inlined with the caller task
allow_inline = false

; whether to collect how many time this kind of tasks invoke each of other kinds tasks
collect_call_count = true

; whether the rpc task can be executed in network threads directly
fast_execution_in_network_thread = false

; group rpc mode: GRPC_TO_LEADER, GRPC_TO_ALL, GRPC_TO_ANY
grpc_mode = 

; whether to profile this kind of task
is_profile = true

; whether to trace this kind of task
is_trace = true

; thread pool to execute the task
pool_code = 

; task priority
priority = 

; what kind of network channel for this kind of rpc calls
rpc_call_channel = 

; what kind of header format for this kind of rpc calls
rpc_call_header_format = 

; what is the default timeout (ms) for this kind of rpc calls
rpc_timeout_milliseconds = 5000

; whether to trace when an aio task is called
tracer::on_aio_call = true

; whether to trace when an aio task is enqueued
tracer::on_aio_enqueue = true

; whether to trace when a rpc is made
tracer::on_rpc_call = true

; whether to trace when reply a rpc request
tracer::on_rpc_reply = true

; whether to trace when a rpc request task is enqueued
tracer::on_rpc_request_enqueue = true

; whetehr to trace when a rpc response task is enqueued
tracer::on_rpc_response_enqueue = true

; whether to trace when a task begins
tracer::on_task_begin = true

; whether to trace when a task ends
tracer::on_task_end = true

; whether to trace when a timer or async task is enqueued
tracer::on_task_enqueue = true


[task.RPC_NFS_GET_FILE_SIZE_ACK]
; whether the task can be executed inlined with the caller task
allow_inline = false

; whether to collect how many time this kind of tasks invoke each of other kinds tasks
collect_call_count = true

; whether the rpc task can be executed in network threads directly
fast_execution_in_network_thread = false

; group rpc mode: GRPC_TO_LEADER, GRPC_TO_ALL, GRPC_TO_ANY
grpc_mode = 

; whether to profile this kind of task
is_profile = true

; whether to trace this kind of task
is_trace = true

; thread pool to execute the task
pool_code = 

; task priority
priority = 

; what kind of network channel for this kind of rpc calls
rpc_call_channel = 

; what kind of header format for this kind of rpc calls
rpc_call_header_format = 

; what is the default timeout (ms) for this kind of rpc calls
rpc_timeout_milliseconds = 5000

; whether to trace when an aio task is called
tracer::on_aio_call = true

; whether to trace when an aio task is enqueued
tracer::on_aio_enqueue = true

; whether to trace when a rpc is made
tracer::on_rpc_call = true

; whether to trace when reply a rpc request
tracer::on_rpc_reply = true

; whether to trace when a rpc request task is enqueued
tracer::on_rpc_request_enqueue = true

; whetehr to trace when a rpc response task is enqueued
tracer::on_rpc_response_enqueue = true

; whether to trace when a task begins
tracer::on_task_begin = true

; whether to trace when a task ends
tracer::on_task_end = true

; whether to trace when a timer or async task is enqueued
tracer::on_task_enqueue = true


[threadpool..default]
; arguments for the cusotmized admission controller
admission_controller_arguments = 

; customized admission controller for the task queues
admission_controller_factory_name = 

; maximum (each) task queue length for this pool
max_input_queue_length = 4294967295

; thread pool name
name = THREAD_POOL_INVALID

; whethe the threads share a single queue(partitioned=false) or not; the latter is usually for workload hash partitioning for avoiding locking
partitioned = false

; task queue aspects names, usually for tooling purpose
queue_aspects = 

; task queue provider name
queue_factory_name = dsn::tools::hpc_task_queue

; what CPU cores are assigned to this pool, 0 for all
worker_affinity_mask = 0

; Tas aspects names, usually for tooling purpose
worker_aspects = 

; thread/worker count
worker_count = 2

; task worker provider name
worker_factory_name = 

; thread priority
worker_priority = 

; whether the threads share all assigned cores
worker_share_core = true


[threadpool.THREAD_POOL_DEFAULT]
; arguments for the cusotmized admission controller
admission_controller_arguments = 

; customized admission controller for the task queues
admission_controller_factory_name = 

; maximum (each) task queue length for this pool
max_input_queue_length = 4294967295

; thread pool name
name = default

; whethe the threads share a single queue(partitioned=false) or not; the latter is usually for workload hash partitioning for avoiding locking
partitioned = true

; task queue aspects names, usually for tooling purpose
queue_aspects = 

; task queue provider name
queue_factory_name = dsn::tools::hpc_task_queue

; what CPU cores are assigned to this pool, 0 for all
worker_affinity_mask = 0

; Tas aspects names, usually for tooling purpose
worker_aspects = 

; thread/worker count
worker_count = 1

; task worker provider name
worker_factory_name = 

; thread priority
worker_priority = THREAD_xPRIORITY_NORMAL

; whether the threads share all assigned cores
worker_share_core = true


[threadpool.THREAD_POOL_INVALID]
; arguments for the cusotmized admission controller
admission_controller_arguments = 

; customized admission controller for the task queues
admission_controller_factory_name = 

; maximum (each) task queue length for this pool
max_input_queue_length = 4294967295

; thread pool name
name = 

; whethe the threads share a single queue(partitioned=false) or not; the latter is usually for workload hash partitioning for avoiding locking
partitioned = false

; task queue aspects names, usually for tooling purpose
queue_aspects = 

; task queue provider name
queue_factory_name = dsn::tools::hpc_task_queue

; what CPU cores are assigned to this pool, 0 for all
worker_affinity_mask = 0

; Tas aspects names, usually for tooling purpose
worker_aspects = 

; thread/worker count
worker_count = 2

; task worker provider name
worker_factory_name = 

; thread priority
worker_priority = 

; whether the threads share all assigned cores
worker_share_core = true


[tools.simple_logger]
; whether to flush immediately
fast_flush = false

; whether to use short header (excluding file/function etc.)
short_header = true


[tools.simulator]
; max message delay (us)
max_message_delay_microseconds = 0

; min message delay (us)
min_message_delay_microseconds = 0

; 
random_seed = 2756568580

; 
use_given_random_seed = true
Content