The FairCom DB Server Configuration File gives the Administrator much more control over the operation of the FairCom DB Server than covered so far. The following detailed list of additional keywords is provided with explanations and default values for each. For completeness, all configuration options supported by the FairCom DB Server are included in this manual. The keywords in this section are listed in alphabetical order.
Note: The options listed in this section require in-depth knowledge of the operating system and hardware configurations of the specific computing environment the FairCom DB process is operating in and, as such, are intended for the appropriate personnel as required. We assume the FairCom DB Administrator will coordinate with the application developer and other members of their operations team as needed.
Overrides the default number of hash bins for each user.
Specifies the spin count for FairCom DB critical sections on Windows.
Sets the thread stack size in kilobytes on Unix/Linux (non-Windows) systems.
Sets the time interval between calls to the aggregating functions.
Controls performance optimizations for tables supporting HOT ALTER TABLE.
Specifies the sleep time for a thread synchronization object on Solaris systems (latch). Requires a custom build.
Specifies the spin count for a thread synchronization object on Solaris systems (latch). Requires a custom build.
Specifies the number of hash bins available to the lock hash algorithm.
Sets the maximum number of lock hash bins.
Sets the average number of locks in each hash bin.
Sets the fraction of the hash bins to be reorganized.
Sets the number of seconds a user thread waits for the internal threads to close the file before retrying.
Specifies the maximum number of file handles to store keys that do not fit in memory.
Specifies the value in kilobytes that can be used for storing key values in memory.
Sets the maximum transaction isolation level at which SQL clients can operate.
The MAX_STORE keyword limits the per-connection amount of temporary disk space available for SQL query execution.
Reuses empty index nodes after the specified number of seconds.
Specifies how deep (the number of nodes) to inspect the delete node queue for previously deleted index nodes before adding already existing deleted nodes to the queue.
Sets the time limit in seconds that a data cache page can remain dirty before it is written to the file system cache.
Sets the time limit in seconds that an index buffer can remain dirty before it is written to the file system cache.
Estimates the distinct key count for a partitioned index file instead of calculating the exact distinct key count by summing the distinct key counts for each partition of that index.
Specifies the number of hash bins available to the preimage hash algorithm.
Sets the fraction of hash bins to be reorganized.
Enables a feature to perform a checkpoint file system flush without blocking all of the mutexes.
Limit the time the server will wait before failing a ctQUIET() call.
Deprecated as of FairCom DB V9.3. See LOCAL_DIRECTORY (LOCAL_DIRECTORY, LOCAL_DIRECTORY).
OEM-specific abilities to change the number of sessions under program control. Not for general use.
Can be used to limit JVM memory.
Enables logic to prepare more resultset rows than requested by the client.
Disables internal thread synchronization (add work/remove work) logic in early V9 server lines. Consult with the FairCom engineering team.
Enable or disable SQL to add the changeid field to new tables.
Deletes the MRT host (physical file) when performing drop table from SQL of the last MRT defined on the table.
Marks a section in the server configuration file ctsrvr.cfg to configure the LATTE sorting subsystem for FairCom DB SQL.
Specifies the number of seconds between log flushes. FairCom does NOT recommend the use of this option.
Reduces FairCom DB Server CPU activity level in non-preemptive environments, thus controlling when to put itself to sleep and when to wake up.
Sets the time limit in seconds that a data cache page can remain dirty before it is written to the file system cache.
Sets the time limit in seconds that an index buffer can remain dirty before it is written to the file system cache.
Specifies the microsecond duration of 64 consecutive yield calls. See the full explanation under UDEFER_THRESHOLD_USEC.
Specifies in microseconds the value below which yield calls are used.
Specifies the number of times to retry an ISAM add or update operation that fails with error VLEN_ERR. This option is disabled at compile-time by default.
CONTEXT_HASH
CONTEXT_HASH <# of hash bins>
To speed the search for location of ISAM contexts, a simple hashing scheme is used. The number of hash bins defaults to six (6) for each user. If a large number of contexts are to be maintained, then this default can be overridden with this keyword.
Refer to the OpenISAMContext(), SelectISAMContext(), and CloseISAMContext() API calls for detailed information about this feature.
Default: 6
CRITICAL_SECTION_SPIN
CRITICAL_SECTION_SPIN <spin_limit>
Specify the spin count for FairCom DB critical sections on Windows. Only Windows versions supporting the CriticalSectionAndSpinCount() function (0x403 or greater) have this feature enabled.
This configuration option includes Unix/Linux systems. If the value is 1000, we try up to 1000 calls to pthread_mutex_trylock() before making the blocking pthread_mutex_lock() call. In a file open/close mutex contention test on a Linux system, a significant speedup was observed when using this option.
Default: The Windows default is 1000, the Unix/Linux default is 0.
DH_THREAD_STACK_SZ_KB
DH_THREAD_STACK_SZ_KB=<size>
DH_THREAD_STACK_SZ_KB sets the thread stack size in kilobytes on Unix/Linux (non-Windows) systems. Each operating system defaults to its own stack size. The system administrator should determine this value from the OS documentation should the value be required.
The default thread stack size for the FairCom DB ISAM server on Unix systems is now 64 KB. The default thread stack size for FairCom DB SQL is 1.5 MB on SCO Unix and 1 MB on other Unix systems. The default thread stack size is 1 MB for both FairCom DB SQL and FairCom DB ISAM Servers on Windows systems.
At server startup, FairCom DB logs the following message to CTSTATUS.FCS, to identify the thread stack size that the server is using on Unix systems.
Set thread stack size to <stack_size>
Note: This keyword only applies to FairCom DB Servers on non-Windows (Unix/Linux) systems.
DIST_COUNT_SEC
DIST_COUNT_SEC <seconds>
Sets the time interval between calls to the aggregating functions.
An internal FairCom DB thread, is launched at server startup (if any of the distributed counter features have been enabled). It periodically calls these aggregating functions.
Default: 30 seconds.
FLEXREC_OPTMIZE
FLEXREC_OPTMIZE <YES/NO>
Controls performance optimizations for tables supporting HOT ALTER TABLE.
Default: YES
LATCH_SLEEP
LATCH_SLEEP <latch_sleep_time_in_microseconds>
Support for a thread synchronization object on Solaris systems, the latch, can be used as an alternative to a mutex.
See Also
Note: Latch support is not enabled by default and requires a custom build. Please contact your nearest FairCom office for current availability.
LATCH_SPIN
LATCH_SPIN <latch_spin_count>
Support for a thread synchronization object on Solaris systems, the latch, can be used as an alternative to a mutex.
A latch is implemented using the atomic processor instructions atomic_swap_8() (which performs an atomic 'test-and-set' operation) and atomic_and_8() (which performs an atomic bitwise AND of the specified two values). set_latch() calls atomic_swap_8() and checks the return value, which is the original value of the latch. If the original value of the latch was zero, this indicates that the thread successfully set the value to one (i.e., acquired the latch). Otherwise, another thread acquired the latch, so the thread retries the operation up to the number of times specified for the latch spin count. If the thread exhausts its spin count without acquiring the latch, the thread sleeps for the number of microseconds specified for the latch sleep time and then retries the operation.
See Also
Note: Latch support is not enabled by default and requires a custom build. Please contact your nearest FairCom office for current availability.
LOCK_HASH
LOCK_HASH <Number of Hash Bins>
The number of hash bins available to the lock hash algorithm. A lock table exists holding all lock entries for each user. To search this table a hash algorithm is employed. The LOCK_HASH value specifies the number of 8-byte hash bins available for use by this algorithm. This value should only be increased with careful consideration. There is a marginally decreasing return for increasing values.
Default: 16
The following keywords are closely related to the lock hash bin strategy and are listed here for convenience.
LOCK_HASH_MAX <maximum number of lock hash bins>
Default: 131072
LOCK_HASH_LOADFAC <avg locks per bin>
Default: 8
LOCK_HASH_REHASHFAC <fraction of hash bins reorganized>
Default: 4 (denominator - one fourth at a time)
Note: Dynamic hashing is recommended for lock table entries held before commit. This results in more efficient searching of intermediate lock table contents. Dynamic hashing automatically adjusts to changing conditions of transaction and lock data.
LOCK_HASH_MAX
Sets the maximum number of lock hash bins:
LOCK_HASH_MAX <maximum number of lock hash bins>
Default: 131072
See also:
LOCK_HASH_LOADFAC
Sets the average number of locks in each hash bin:
LOCK_HASH_LOADFAC <avg locks per bin>
Default: 8
See also:
LOCK_HASH_REHASHFAC
Sets the fraction of the hash bins to be reorganized. The number you enter will be the denominator of a fraction with a numerator of 1 (e.g., setting this keyword to 4 results in a fraction of 1/4, so one fourth of the hash bins are reorganized.
LOCK_HASH_REHASHFAC <fraction of hash bins reorganized>
Default: 4 (denominator - one fourth at a time)
See also:
MAX_FILE_WAIT_SECS
MAX_FILE_WAIT_SECS <seconds> | -1 | 0
To control delete node and space reclamation threads' access to files, c-tree Server automatically detects when a file open fails due to the internal threads having the file open and it signals the threads to close the file. It then tries to open the file again.
This keyword sets the number of seconds a user thread waits for the internal threads to close the file before retrying.
A value of 0 (the default) sets no limit on the wait loop.
A setting of -1 disables this feature.
The maximum value is 86400. Specifying a greater value sets the limit to 86400 seconds.
This keyword allows an application to avoid error 12 with sysiocod -8 when trying to open c-tree files in exclusive mode.
Default: 0
MAX_HANDLES
MAX_HANDLES
MAX_HANDLES can improve the performance of a rebuild.
The rebuild function does a scan on the data file. At the end of the scan the number of records (max key values) is known. An output buffer is used to write sorted key values to disk when needed, that is, when all keys can't fit into data buffers. Data buffers contain unsorted key values put there the data file is scanned. When all data buffers or the pointer area are full, the logic sorts the pointers in the buffer by key value and then writes all data in data buffers to disk. Output is done in output buffer sized chunks to sort work files, which are c-tree data files.
Based on the actual number of keys (number of records) and key size + pntr size the fraction of key values that can stored in the given memory (MAX_K_TO_USE) is known. If the memory is large enough then just that amount of memory is needed. If the memory is not large enough then the # of file handles needed to store the values on disk is computed, limited by the MAX_HANDLES value.
Default: 255
See Also
MAX_K_TO_USE
MAX_K_TO_USE
MAX_K_TO_USE can improve the performance of a rebuild. The value is specified in kilobytes (KB) with no scaling factor (such as KB, MB, GB, etc.). A scaling factor is ignored if specified; therefore specifying "4 GB" is the same as "4" and is interpreted as 4 KB. (The SORT_MEMORY keyword supports scaling factors.)
The rebuild function does a scan on the data file. At the end of the scan the number of records (max key values) is known. An output buffer is used to write sorted key values to disk when needed, that is, when all keys can't fit into data buffers. Data buffers contain unsorted key values put there while the data file is scanned. When all data buffers or the pointer area are full, the logic sorts the pointers in the buffer by key value and then writes all data in data buffers to disk. Output is done in output buffer sized chunks to sort work files, which are c-tree data files.
Based on the actual number of keys (number of records) and key size + pntr size the fraction of key values that can stored in the given memory (MAX_K_TO_USE) is known. If the memory is large enough then just that amount of memory is needed. If the memory is not large enough then the number of file handles needed to store the values on disk is computed, limited by the MAX_HANDLES value.
If both SORT_MEMORY and MAX_K_TO_USE are specified in ctsrvr.cfg, only the one that is specified last in the configuration file takes effect.
Default: 10000 (10 MB)
See Also
MAX_SQL_ISOLATION_LEVEL
Sets the maximum transaction isolation level at which SQL clients can operate. The supported values are:
MAX_SQL_ISOLATION_LEVEL 1 ; Support READ_COMMITTED only
MAX_SQL_ISOLATION_LEVEL 2 ; Support READ_COMMITTED and REPEATABLE_READ. (default server setting)
MAX_SQL_ISOLATION_LEVEL 3 ; Support READ_COMMITTED, REPEATABLE_READ, and SERIALIZABLE.
If a SQL client requests an isolation level that exceeds the maximum SQL isolation level specifed in the server configuration file, the SQL client operates at the maximum SQL isolation level rather than its requested isolation level.
MAX_STORE
The MAX_STORE keyword limits the per-connection amount of temporary disk space available for SQL query execution. Default is 512 GB. Max is 128 TB. Minimum is 2 GB.
SUBSYSTEM SQL LATTE {
MAX_STORE <limit>
}
<limit> equals the size in the units specified (e.g., 512 GB = 512 Gigabytes; 128TB = 128 Terrabytes).
For example, the following sets the limit to 1 TB:
SUBSYSTEM SQL LATTE {
MAX_STORE 1000 GB
}
Note: Setting this value too small could cause some SQL queries to fail with LT_ERR_STOREFULL (-16306)
This setting can be changed at runtime using ctadmn.
MAX_WORKERS
MAX_WORKERS
MAX_WORKERS can set a limit on the maximum allowed number of worker threads.
Manually adjusting the number of threads like this can improve performance. Increasing threads can boost parallelism and data throughput. Reducing threads is advisable when too many concurrent threads cause excessive lock contention within index caches.
Maximum value: 2048
NOTE: When not using MQTT, the maximum worker thread limit is 256.
NODE_DELAY
NODE_DELAY <seconds>
Reuses empty index nodes after NODE_DELAY seconds. This allows the FairCom DB Server to finish active searches in the index tree before removing the empty node.
Default: 300
NODEQ_SEARCH
NODEQ SEARCH <nodes>
Inspects the delete node queue <nodes> deep for previously deleted index nodes before adding already existing deleted nodes to the queue.
Default: 50
In server implementations, an emptied index node is not directly deleted from the b-tree. Instead, an entry is placed in a queue read by the special administrative delete-node-thread. Before writing to the queue, a check is made to see if the node is already on the queue. For systems that generate many empty nodes, it can be more efficient to inspect the queue to a deeper level.
PARTITION_ESTIMATE_LIMIT
PARTITION_ESTIMATE_LIMIT <limit>
This keyword estimates the distinct key count for a partitioned index file instead of calculating the exact distinct key count by summing the distinct key counts for each partition of that index. This behavior can significantly reduce the time necessary to calculate the distinct key count for a partitioned index (at the cost of a larger uncertainty in the estimate).
Default sampling behavior is to only sample three active partitions unless PARTITION_ESTIMATE_LIMIT sets this limit to a value greater than three. The partitions sampled are the first and last partitions that ordinarily would have been used, and one or more in the "middle" of the remaining active partitions. At this time no attempt is made to spread out the sampled middle partitions over the range of available middle partitions.
With a negative value, the behavior resorts to summing the distinct key counts for each active partition.
PREIMAGE_HASH
PREIMAGE_HASH <number of hash bins>
The number of hash bins available to the preimage hash algorithm. During a transaction, a preimage space is used to hold intermediate results pending an abort or a commit. To search this area, a hashing algorithm is employed. The PREIMAGE_HASH value specifies the number of four-byte bins available per user for use by this algorithm. This value should be increased only if a large volume of updates and/or additions per transaction (e.g., several thousand) is anticipated.
Default: 128
The following keywords are closely related to the lock hash bin strategy and are enumerated here for convenience.
PREIMAGE_HASH_MAX <maximum number of lock hash bins>
Default: 131072
PREIMAGE_HASH_LOADFAC <avg locks per bin>
Default: 8
PREIMAGE_HASH_REHASHFAC <fraction of hash bins reorganized>
Default: 4 (denominator - one fourth at a time)
Note: Dynamic hashing is now used for transaction entries held before commit. This results in more efficient searching of intermediate transaction contents. Dynamic hashing automatically adjusts to changing conditions of transaction and lock data.
PREIMAGE_HASH_REHASHFAC
Sets the fraction of hash bins to be reorganized. The number you enter will be the denominator of a fraction with a numerator of 1 (e.g., setting this keyword to 4 results in a fraction of 1/4, so one fourth of the hash bins are reorganized.
PREIMAGE_HASH_REHASHFAC <fraction of hash bins reorganized>
Default: 4 (denominator - one fourth at a time)
PRESYNC_THRESHOLD
PRESYNC_THRESHOLD <active user count>
Background: When a transaction is committed, the transaction log must be flushed to disk to ensure the log contains the ability to undo or redo the transaction. The server does not, however, flush all the transaction related data and index file images to disk. The c-tree cache pages holding the disk images are aged and eventually forced to disk, otherwise transaction logs of arbitrary age would be required to make good any transaction that was committed but not entirely flushed to disk. The aging of cache pages occurs as part of the checkpoint, and consists of issuing an OS write operation. If the OS write is not guaranteed to synchronously flush the image to disk, then a call must also be made to flush the system cache pages (as opposed to the c-tree cache pages) to disk. When a data or index disk image for a transaction is committed but not yet flushed to disk, the transaction is placed on a data or index vulnerable transaction list. When the image is flushed to disk, the transaction is removed from the list. A feature can be enabled to perform the checkpoint file system flush without blocking all of the mutexes.
Specifying <active user count> greater than or equal to zero enables this feature. An active user count less than zero turns off this feature. The default for the threshold is set to -1 which turns off the new feature. [By active user count we mean the number of users actually making requests to the server. An idle user, or a user in between requests, will not count toward the active user count.]
Pending further testing, it is suggested that the PRESYNC_THRESHOLD be set somewhere in the range of 2 to 6.
QUIET_MAX_WAIT
QUIET_MAX_WAIT <seconds>
When ctQUIET() is unable to block internal activity due to some long running action, it will eventually give up and fail with error 843 after a fixed number of internal attempts. During this interval, all new database activity is blocked. This keyword allows controlling this server wide limit with an additional time based limit. This wait begins AFTER any transaction timeout specified by the ctQUIET() API call.
Default = 60 seconds. (Minimum = 5 seconds).
SERVER_DIRECTORY
SERVER_DIRECTORY <path>
See LOCAL_DIRECTORY (LOCAL_DIRECTORY, LOCAL_DIRECTORY)
Note: This configuration option has been deprecated as of FairCom DB V9.3 and later. LOCAL_DIRECTORY (LOCAL_DIRECTORY, LOCAL_DIRECTORY) is now the preferred keyword to allow the server to store data and files in an alternative location.
To avoid potential problems with the use of this option, it has been disabled. When this option is specified in ctsrvr.cfg, the c-tree Server fails to start and displays the following message:
The SERVER_DIRECTORY option is no longer supported.
Use the LOCAL_DIRECTORY option instead.
The message is logged to CTSTATUS.FCS. On Unix systems it is also written to standard output and on Windows systems it is displayed in a dialog box when the c-tree Server is not running as a Windows service.
Relocating Transaction Logs
Use these configuration keywords to relocate transaction logs if this has been the purpose of using this keyword in the past:
These configuration options can include an environment variable name that will be substituted with its value when the configuration file is read.
Legacy Notes
The SERVER_DIRECTORY option was one of two mutually exclusive ways to supply the name of a directory path the FairCom DB Server used when processing all files not having absolute names (i.e., absolute names include a specific volume or drive reference as part of the name). For example, d:\fairserv\data\ (the trailing slash was required). The other option, LOCAL_DIRECTORY (LOCAL_DIRECTORY, LOCAL_DIRECTORY), is now the preferred keyword to allow the server to store data and files in an alternative location.
If a SERVER_DIRECTORY name was defined in the configuration script, the name was attached to the beginning of any file name that was not absolute. If no SERVER_DIRECTORY or LOCAL_DIRECTORY name was supplied, all database and system files were stored relative to the FairCom DB Server working directory. SERVER_DIRECTORY and LOCAL_DIRECTORY cannot be used together. SERVER_DIRECTORY did not affect the location of the FairCom DB Server Status log, the transaction log files, or the start files.
Note: The SERVER_DIRECTORY, unlike LOCAL_DIRECTORY, became part of the file name. The name entered into the transaction log included the SERVER_DIRECTORY.
Default: Server working directory
See Also
SESSCHG_ENABLE
SESSCHG_ENABLE
This option pertains to OEM-specific abilities to change the number of sessions under program control. The internal variable, ct_mxu1, which controls memory allocations and for loops was not properly handled when SESSVAL() and SESSINC() were used. This fix sets ct_mxu1 to the activation limit when SESSCHG_ENABLE YES is added to the server configuration file. If this entry is not in the configuration file, then calls to SESSVAL() and SESSINC() will return NSUP_ERR (454, not supported).
Note: SESSCHG_ENABLE should not be considered for general use.
SETENV
Sets an environment variable within the server process. This keyword is mainly used to configure the Java environment or SQL behavior.
SETENV DH_JVM_OPTION_STRINGS=-Xms100m -Xmx300m
Limits JVM memory.
SETENV DH_DO_AHEAD
Enables logic to prepare more resultset rows than requested by the client so that, on subsequent requests, they are already available.
SETENV DH_DO_AHEAD=Y
Default: N
SKIP_CTADDWORK
SKIP_CTADDWORK <YES | NO>
Disables internal thread synchronization (add work/remove work) logic in early V9 server lines.
Note: Only consider this option after consultation with the FairCom engineering team.
SQL_OPTION AUTO_CHANGEID
Starting with version 12.6.1, FairCom products, the ctsrvr.cfg file contains the SQL_OPTION AUTO_CHANGEID setting. This setting automatically causes SQL to add a changeid field to all new tables. This behavior matches the JSON DB API. The changeid field enables you to use optimistic locking in SQL.
When you do not want SQL to add the changeid field to new tables, remove the SQL_OPTION AUTO_CHANGEID setting from the ctsrvr.cfg file.
SQL_OPTION DEL_MRT_HOST
Deletes the MRT host (physical file) when performing drop table from SQL of the last MRT defined on the table. (MRT is short for "Multi-Record Type Table, or "Multi-Schema Table")
SUBSYSTEM SQL LATTE
SUBSYSTEM SQL LATTE
Marks a section in the server configuration file ctsrvr.cfg to configure the LATTE sorting subsystem for FairCom DB SQL.
Configuration options are available in the server configuration file ctsrvr.cfg to configure the LATTE sorting subsystem for FairCom DB SQL. This subsystem is indicated as: SUBSYSTEM SQL LATTE. Keywords that affect this subsystem must be enclosed in curly braces as shown in the example below:
SUBSYSTEM SQL LATTE
{
SQL LATTE KEYWORD
}
This subsystem accepts the following keywords:
- MAX_MEMORY - Maximum advisable memory per environment. Default: 64M
- CACHE_BLK - Default number of blocks in the temporary cache of a table. Default: 8
- MAX_STORE - The maximum number of swap files (128M each) LATTE can create. This setting can be 65535 at max. Default: 128
- NONE - This option is used in conjunction with the tamper-proof settings file (.set). When specified, the entire SUBSYSTEM SQL LATTE cannot be overridden in the ctsrvr.cfg file.
Example
Notice that any keywords listed above must be in a section of the configuration file labeled SUBSYSTEM SQL LATTE and enclosed in curly braces. For example, include the following to set the maximum advisable memory per environment to 64MB:
SUBSYSTEM SQL LATTE
{
MAX_MEMORY 64M
}
SYNC_DELAY
SYNC_DELAY <seconds>
Specifies the number of seconds between log flushes.
Note: FairCom does NOT recommend the use of this option since it may cause problems with our automatic recovery.
TASKER_SLEEP
TASKER_SLEEP <milliseconds | 0 | -1>
Reduces FairCom DB Server CPU activity level in non-preemptive environments, where the FairCom DB Server performs its own task switching, thus controlling when to put itself to sleep and when to wake up. The value of TASKER_SLEEP controls whether the FairCom DB Server puts itself to sleep and, if it does, when it will wake itself up. Setting this keyword to other than default will diminish the FairCom DB Server performance. This keyword is generally only required in older Unix environments. (SCO Unix, QNX, Apple A/UX, Interactive Unix and Motorola 88 OPEN.)
Valid values are:
| Value | Explanation |
|---|---|
| -1 | Never sleep. |
| 0 | Relinquish control of the CPU if another process is ready to run; otherwise, resume processing |
| > 0 | Sleep for that amount of time (in milliseconds). |
Default: 0
UDEFER_64YIELD_USEC
UDEFER_64YIELD_USEC <defer>
where <defer> is the microsecond duration of 64 consecutive yield calls. See the full explanation under UDEFER_THRESHOLD_USEC.
See Also
UDEFER_THRESHOLD_USEC
UDEFER_THRESHOLD_USEC
An internal defer routine takes a microsecond sleep argument. However, not all systems provide a useful implementation of a microsecond or nanosecond sleep routine. The UDEFER_THRESHOLD_USEC and UDEFER_64YIELD_USEC configuration options force this routine to make multiple calls to defer(0), which causes a thread yield, to generate shorter (more accurate) sleep intervals.
UDEFER_THRESHOLD_USEC <usec value below which yield calls used>
UDEFER_64YIELD_USEC <usec duration of 64 consecutive yield calls>
Even if the microsecond sleep has provisions for consecutive yields, it will not take effect unless both the DEFER_THRESHOLD_USEC and UDEFER_64YIELD_USEC appear with non-zero values.
See Also
VLEN_ERR_RETRY_LIMIT
VLEN_ERR_RETRY_LIMIT <limit>
VLEN_ERR_RETRY_LIMIT is used to set a number of times to retry an ISAM add or update operation that fails with error VLEN_ERR. Under normal operation, a VLEN_ERR error (148, WRTVREC() cannot fit record at recbyt) is unexpected.
Note: This option is disabled at compile-time by default.