| async_parser |
Enables Replication Server
to asynchronously parse commands from the RepAgent.Setting async_parser on sets: - Asynchronous parser on – exec_prs_num_threads to 2
- ASCII packing on – ascii_pack_ibq on
- Inbound direct command replication on –
cmd_direct_replicate
on
- Outbound
direct command replication on – dist_cmd_direct_replicate on
Default: off
Note:
Ensure that smp_enable on, and that the Replication
Server host machine can support additional threads for the
parsing before you configure the asynchronous parser.
You
must set the Replication Server site version to 1571 or
later before you can set ascii_pack_ibq on. If the site version is
earlier than 1571, setting async_parser on only sets exec_prs_num_threads,
cmd_direct_replicate, and dist_cmd_direct_replicate.
|
| ascii_pack_ibq |
Reduces the stable queue space consumed by packed
commands in the inbound queue by using ASCII packing.
Default: off
Note: You must enable the asynchronous parser for
Replication Server to benefit from ASCII packing in the inbound
queue.
You
must set the Replication Server site version to 1571 or later before
you set ascii_pack_ibq
on.
|
|
batch
|
The default, “on,” allows command batches to a
replicate database.
Default: on
|
|
cmd_direct_replicate
|
Set cmd_direct_replicate on for the Executor thread to
send parsed data directly to the Distributor thread along with
binary or ascii data. When required, the Distributor thread can
retrieve and process data directly from parsed data, and improve
replication performance by saving time otherwise spent parsing data
again.
Default: off
|
| dist_cmd_direct_replicate |
Set dist_cmd_direct_replicate on to allow the DIST module
to send internal parsed data through an in-memory cache.
Default: on
If you set dist_cmd_direct_replicate off, DIST module sends the
data to DSI through outbound queue.
|
|
db_packet_size
|
The maximum size of a network packet. During database
communication, the network packet value must be within the range
accepted by the database.
Maximum: 16384 bytes
Default: 512-byte network packet for all Adaptive
Server databases
|
|
disk_affinity
|
Specifies an allocation hint for assigning the next
partition. Enter the logical name of the partition to which the next
segment should be allocated when the current partition is full.
Values are “partition_name” and
“off.”
Default: off
|
|
dist_sqt_max_cache_size
|
The maximum Stable Queue Transaction (SQT) cache size
for the inbound queue in bytes. The default, 0, means the current
setting of the sqt_max_cache_size
parameter is used as the maximum cache size for the connection.
Default: 0
For 32-bit Replication Server: -
Minimum – 0
-
Maximum – 2,147,483,647
For 64-bit Replication Server: -
Minimum – 0
-
Maximum – 2,251,799,813,685,247
|
|
dsi_cdb_max_size
|
Maximum net-change database size that
Replication Server can generate for HVAR or RTL. in megabytes. -
Default – 1024
-
Minimum – 0
-
Maximum – 2,147,483,647
In HVAR, Replication Server uses dsi_cdb_max_size as a threshold to: - Detect large transactions that are then
replicated using the continuous replication mode.
- Stop grouping small compilable transactions
into a group requiring a net-change database that is larger
than dsi_cdb_max_size.
In RTL, Replication Server uses dsi_cdb_max_size to flush large
transaction groups incrementally using full incremental
compilation.
|
|
dsi_cmd_batch_size
|
The maximum number of bytes that Replication Server
places into a command batch.
Default: 8192 bytes
|
|
dsi_cmd_prefetch
|
Allows DSI to pre-build the next batch of commands
while waiting for the response from data server, and therefore
improves DSI efficiency. If you also tune your data server to
enhance performance, it is likely that you will gain an additional
performance increase when you use this feature.
Default: off
When you set dsi_compile_enable to ‘on’, Replication Server
ignores what you set for dsi_cmd_prefetch.
License: Separately licensed under the Advanced
Services Option.
|
|
dsi_commit_check_locks_intrvl
|
The number of milliseconds (ms) the DSI executor
thread waits between executions of the rs_dsi_check_thread_lock function string. Used with
parallel DSI.
Default: 1000 ms (1 second)
Minimum: 0
Maximum: 86,400,000 ms (24 hours)
|
|
dsi_commit_check_locks_max
|
The maximum number of times the DSI executor thread
executes the rs_dsi_check_thread_lock function string before
rolling back and retrying a transaction. Used with parallel DSI.
Default: 400
Minimum: 1
Maximum: 1,000,000
|
|
dsi_commit_control
|
Specifies whether commit control processing is
handled internally by Replication Server using internal tables (on)
or externally using the rs_threads
system table (off). Used with parallel DSI.
Default: on
|
|
dsi_incremental_parsing
|
Set to on to enable incremental parsing by the DSI Scheduler thread
when you enable high volume adaptive replication (HVAR), real-time
loading (RTL), or DSI bulk copy-in. Attention: If you set
the dsi_incremental_parsing parameter to on,
the parameter takes effect only if either
dsi_compile_enable or
dsi_bulk_copy is set to on. Otherwise,
Replication Server ignores what you set for
dsi_incremental_parsing.
Default: on
The primary and replicate Replication Servers must be version
15.7.1
SP100 or later to support incremental parsing.
Use dsi_incremental_parsing with:
Connection-level settings override server-level settings. See Incremental Parsing , High Volume Adaptive
Replication to Adaptive Server, and DSI Bulk
Copy-in in the Replication Server Administration
Guide Volume 2.
See Real-Time Loading Solution in the Replication
Server Heterogeneous Guide
|
|
dsi_isolation_level
|
Specifies the isolation level for transactions. ANSI
standard and Adaptive Server supported values are: -
0 – ensures that data written by one
transaction represents the actual data.
-
1 – prevents dirty reads and ensures
that data written by one transaction represents the
actual data.
-
2 – prevents nonrepeatable reads and
dirty reads, and ensures that data written by one
transaction represents the actual data.
-
3 – prevents phantom rows, nonrepeatable
reads, and dirty reads, and ensures that data written by
one transaction represents the actual data.
Through the use of custom function strings,
Replication Server can support any isolation level the replicate
data server may use. Support is not limited to the ANSI standard
only.
Default: the current transaction isolation level for
the target data server
|
|
dsi_large_xact_size
|
The number of commands allowed in a transaction before the
transaction is considered to be large.
Default: 100
Minimum: 4
Maximum: 2,147,483,647
Replication Server ignores dsi_large_xact_size
when you turn on
dsi_compile_enable.
|
|
dsi_max_cmds_in_batch
|
Defines the maximum number of source commands whose
output commands can be batched.
You
must suspend and resume the connection for any change in the
parameter to take effect.
Range: 1 – 1000
Default: 100
|
|
dsi_max_xacts_in_group
|
Specifies the maximum number of transactions in a
group. Larger numbers may improve data latency at the replicate
database. Range of values: 1 – 1000.
Default: 20
This parameter is ignored when dsi_compile_enable is turned on.
|
|
dsi_num_large_xact_threads
|
The number of parallel DSI threads to be reserved
for use with large transactions. The maximum value is one less than
the value of dsi_num_threads.
Default: 0
|
|
dsi_num_threads
|
The number of parallel DSI threads to be used. The
maximum value is 255.
Default: 1
|
|
dsi_partitioning_rule
|
Specifies the partitioning rules (one or more) the
DSI uses to partition transactions among available parallel DSI
threads. Values are origin,
origin_sessid, time, user, name, and
none.
Default: none
This
parameter is ignored when dsi_compile_enable is turned on.
|
|
dsi_serialization_method
|
Specifies the method used to determine when a
transaction can start, while still maintaining consistency. In all
cases, commit order is preserved.
These methods are ordered from most to least amount
of parallelism. Greater parallelism can lead to more contention
between parallel transactions as they are applied to the replicate
database. To reduce contention, use the dsi_partitioning_rule option.
-
no_wait – specifies that a transaction
can start as soon as it is ready—without regard to the
state of other transactions.
Note: You can only set dsi_serialization_method
to no_wait if
dsi_commit_control
is set to “on”.
-
wait_for_start – specifies that a
transaction can start as soon as the transaction
scheduled to commit immediately before it has started.
-
wait_for_commit (default) – specifies
that a transaction cannot start until the transaction
scheduled to commit immediately preceding it is ready to
commit.
-
wait_after_commit – specifies that a
transaction cannot start until the transaction scheduled
to commit immediately preceding it has committed
completely.
These options are retained only for backward
compatibility with older versions of Replication Server:
Note: The isolation_level_3 value is no longer supported as a
serialization method but it is the same as setting dsi_serialization_method to wait_for_start and dsi_isolation_level to 3.
Default: wait_for_commit
|
|
dsi_sqt_max_cache_size
|
Maximum SQT (Stable Queue Transaction) interface
cache size for the outbound queue in bytes. The default, 0, means
the current setting of the sqt_max_cache_size parameter is used as the maximum
cache size for the connection.
Default: 0
For 32-bit Replication Server: - Minimum – 0
- Maximum – 2GB (2,147,483,648 bytes)
For 64-bit Replication Server: - Minimum – 0
- Maximum – 2 petabytes
(2,251,799,813,685,247 bytes)
|
|
dsi_xact_group_size
|
The maximum number of bytes, including stable queue
overhead, to place into one grouped transaction. A grouped
transaction is a set of transactions that the DSI applies as a
single transaction. A value of –1 means no grouping.
Sybase recommends that you set dsi_xact_group_size to the maximum
value and use dsi_max_xacts_in_group to control the number of
transactions in a group. Note:
Obsolete for Replication Server version 15.0
and later. Retained for compatibility with older Replication
Servers.
Maximum: 2,147,483,647
Default: 65,536 bytes
This
parameter is ignored when dsi_compile_enable is turned on.
|
|
exec_cmds_per_timeslice
|
Specifies the number of LTL commands an LTI or
RepAgent executor thread can process before yielding the CPU. By
increasing this value, you allow the RepAgent executor thread to
control CPU resources for longer periods of time, which may improve
throughput from RepAgent to Replication Server.
Set this parameter at the connection level using
alter connection.
Default: 2,147,483,647
Minimum: 1
Maximum: 2,147,483,647
|
|
exec_max_cache_size
|
Specifies the amount of memory to allocate for the
Executor command cache.
Default: 1,048,576 bytes
For 32-bit Replication Server: -
Minimum – 0
-
Maximum – 2,147,483,647
For 64-bit Replication Server: -
Minimum – 0
-
Maximum – 2,251,799,813,685,247
|
|
exec_nrm_request_limit
|
Specifies the amount of memory available for
messages from a primary database waiting to be normalized.
Set nrm_thread
to ‘on’ with configure replication
server before you use exec_nrm_request_limit.
Minimum: 16,384 bytes
Maximum: 2,147,483,647 bytes
Default for:
-
32-bit – 1,048,576 bytes (1MB)
-
64-bit – 8,388,608 bytes (8MB)
After you change the configuration for exec_nrm_request_limit, suspend and
resume the Replication Agent.
License: Separately licensed under the Advanced
Services Option.
|
| exec_prs_num_threads |
Enables the Asynchronous Parser feature by starting
multiple parser threads for a specific connection from the primary
database and specifies the number of asynchronous parser threads for
the connection.
Default: 0
Minimum: 0 to disable asynchronous parser.
Maximum: 20
Note:
Ensure that smp_enable is on, and that the Replication Server
host machine can support additional threads for the parsing
before you configure the asynchronous parser
|
|
exec_sqm_write_request_limit
|
Specifies the amount of memory available for
messages waiting to be written to an inbound queue.
Default: 1MB Minimum: 16KB Maximum: 2GB
|
|
md_sqm_write_request_limit
|
Specifies the amount of memory available to the
Distributor for messages waiting to be written to the outbound
queue.
Note:
In Replication Server 12.1, md_sqm_write_request_limit
replaces md_source_memory_pool. md_source_memory_pool is retained for
compatibility with older Replication Servers.
Default: 1MB
Minimum: 16K
Maximum: 2GB
|
|
parallel_dsi
|
Provides a shorthand method for configuring parallel DSI threads.
Setting parallel_dsi to on
automatically sets:
-
dsi_num_threads to 5
-
dsi_num_large_xact_threads to 2
-
dsi_serialization_method to
wait_for_commit
-
dsi_sqt_max_cache_size to 1 million
bytes on 32-bit platforms and 20 million bytes on 64-bit
platforms.
Setting parallel_dsi to off
resets these parallel DSI parameters to their default values.
You can set parallel_dsi to on
and then set individual parallel DSI configuration parameters to
fine-tune your configuration.
Default: off
|
|
sqm_async_seg_delete
|
Set sqm_async_seg_delete to on to enable a dedicated
daemon for deleting segments.
Default: on
|
|
sqm_cmd_cache_size
|
The maximum size, in bytes, of parsed data that
Replication Server can store in the SQM command cache.
32-bit Replication Server: - Default – 1,048,576
- Minimum – 0, which disables SQM command caching
- Maximum – 2,147,483,647
64-bit Replication Server: - Default – 20,971,520
- Minimum – 0
- Maximum – 2,251,799,813,685,247
Replication Server ignores any value you set for
sqm_cmd_cache_size if
cmd_direct_replicate or
sqm_cache_enable is off.
|
|
sqm_max_cmd_in_block
|
Specifies, in each SQM block, the maximum number of
entries with which the parsed data can associate.
Default: 320
Minimum: 0
Maximum: 4096
Set the value of sqm_max_cmd_in_block to the number of entries in the
SQM block. Depending on the data profile, each block has a different
number of entries because the block size is fixed, and the message
size is unpredictable. If you set a value that is too large, there
is memory waste. If you set a value that is too small, replication
performance is compromised.
Replication Server ignores any value you set for
sqm_max_cmd_in_block if
cmd_direct_replicate or
sqm_cache_enable is off.
|
|
use_batch_markers
|
If use_batch_markers is set to on, the function strings rs_batch_start and rs_batch_end will be executed.
Note: This parameter will only need to be
set to on for replicate data
servers that require additional SQL translation to be sent at the
beginning and end of a batch of commands that are not contained in
the rs_begin and rs_commit function strings.
Default: off
|