This document describes the utility "ADANUC". ADANUC is the database nucleus task.
The following topics are covered:
The nucleus parameters are used to define the Adabas nucleus runtime environment.
The nucleus parameters are set during nucleus startup.
The nucleus parameters provide the following information:
The database to be used;
The setting of various Adabas session parameters, such as the maximum Adabas buffer size and the transaction and user non-activity time limits;
The type and amount of command data to be logged during the Adabas session. These parameters apply to statistical information and not to the logging of database updates on the Adabas data protection log.
This utility is a single-function utility.
If ADANUC terminates with a stop error during nucleus startup, e.g. STP055 or STP997, the reason is probably that there are not enough operating system resources (for example memory) available in order to start the nucleus with the specified parameters. You can prevent the stop error from occurring by reducing the values of some nucleus parameters (for example NT or LBP).
At the start of the first nucleus session after a database has been created or restored, the Adabas nucleus initializes all of the blocks of the WORK container. For a large WORK container this may take a few minutes. The database will only be available after the initialization of the WORK container has finished.
The default values for the nucleus parameters can be used if there are not more than 20 users who perform Adabas calls with relatively small Adabas buffers. The following hints describe conditions under which it may be necessary to use other nucleus parameter values:
If you temporarily have bad response times for Adabas commands (during an Adabas buffer flush), or if you get I/O errors during asynchronous I/Os even though your hardware is OK, consider setting BFIO_PARALLEL_LIMIT.
If Adabas commands with large adabas buffers are performed, e.g. for LOB processing, consider increasing the value for LAB and LBP.
If there are multi-threaded applications performing Adabas calls, consider increasing the NCL parameter.
If the number of parallel Adabas sessions is greater than 20, increase the NU parameter.
If it is important that the autorestart time after a nucleus crash is short, set WRITE_LIMIT to a small positive value, especially if you are using a large buffer pool.
You can run a database in read-only mode by either removing the write
permissions from the Adabas containers or by specifying OPTIONS=READ_ONLY. If
you run the database in read-only mode, the temporary working space on disk is
only created if you specify its location explicitly (environment variables
TEMPLOCn or entries
TEMPORARY_LOCATION in the DBnnn.INI
file). For further information, see Administration,
Temporary Working
Space.
If the previous Adabas session was not terminated normally with SHUTDOWN or CANCEL, Adabas performs an Autorestart: All transactions that were active when the nucleus crashed, are rolled back, and all missing database updates are written to ASSO and DATA. For this purpose, all update operations have been logged on the WORK container. Additionally, all update operations are logged in the NUCPLG file, which is required to recover the current state of the database, if one or more of the database containers has been corrupted, for example, because of a disk failure. In case of a nucleus crash, it is necessary that both logs contain the same information, otherwise the database could contain additional transactions, or transactions could be lost if you perform a restore/recover later. In order to check this, the PLOG file must still be available with the same name when an autorestart is performed. If you have renamed the PLOG file, or moved it to another location, you get the following warning:
%ADANUC-W-PLNOF, Last plog not found, so consistency check is not possible. New backup required.
If you get this warning, your database is still consistent, but if you perform a restore/recover later, it may be that your database then becomes inconsistent. If you create a new backup to be used as a base for restore/recover, the consistency of the restore/recover is guaranteed again.
On UNIX platforms, the IPC resources allocated by the Adabas nucleus
are not removed if the nucleus is not shut down normally with ADAOPR SHUTDOWN
or ADAOPR CANCEL. The nucleus can only be restarted after these resources have
been removed, and for this reason the nucleus executes the command
showipc -k <dbid>. Important: if Adabas was
not installed as recommended by user "sag", group "sag", it is necessary to set
the environment variable SIPUSER and/or SIPGROUP. For further information, see
Administration,
showipc. On
Windows platforms, the operating system automatically removes IPC resources
that are no longer used.
The sequential files NUCPLG and NUCCLG can have multiple extents. For detailed information about sequential files with multiple extents, see Administration, Using Utilities.
| Data Set | Environment Variable/ Logical Name |
Storage Medium | Additional Information |
|---|---|---|---|
| Associator | ASSOx | Disk | |
| Command log | NUCCLG | Disk, Tape | Utilities Manual, ADACLP |
| Data storage | DATAx | Disk | |
| Protection log | NUCPLG | Disk | Utilities Manual, ADAPLP |
| Control statements | stdin/ SYS$INPUT |
Utilities Manual | |
| ADANUC messages | stdout/ SYS$OUTPUT |
Messages and Codes | |
| Work | WORK1 | Disk | |
| CSA dump | ADA_CSA_DUMP | Disk | Adabas CSA dump (see ADAOPR RESPONSE_CHECK) |
| SMP dump | SMP_DUMPFILE | Disk | SMP dump |
| Temporary working space (NUCTMPx, NUCSRTx) |
TEMPLOCx | Disk | Administration Manual (see Temporary Working Space) |
Notes:
The following table shows the checkpoints written by the nucleus:
| Function | Checkpoint written |
|---|---|
| Nucleus startup | SYNC |
| Nucleus termination | SYNC |
The following control parameters are available:
D [NO]AB32BIT D ADABAS_ACCESS = {ALL | GROUP} APU = (n1,n2,n3) D AR_CONFLICT = keyword BFIO_PARALLEL_LIMIT = number D [NO]BI D CLOGBMAX = number [K | M] D CLOGLAYOUT = [5 | 6] M DBID = number D LAB = number [K | M] D LABX = number [K | M] D LBP = number [K | M] D LOGGING = (keyword [,keyword]...) D LPXA = number D LWP = number [K | M] D NCL = number D NISNHQ = number D NT = number D NU = number D OPTIONS = (keyword[,keyword]...) D [NO]PLOG D READ_PARALLEL_LIMITS = (records,blocks,total) D TNAA = number D TNAE = number D TNAX = number D TT = number D UNBUFFERED = ALL | CLEAR | (keyword [, keyword [, keyword]]) USEREXITS = (number[,number]...) D WRITE_LIMIT = number
Note:
This parameter is relevant only for HP-UX.
On HP-UX, you must create a 32-bit shared memory segment if you want access to shared memory from a 32-bit application. For this reason, it is necessary to create the shared memory for the attached buffers required for the communication between client programs and ADANUC as 32-bit shared memory, if you want to perform Adabas calls in 32-bit applications. However, the total size of 32-bit shared memory segments is limited. If you have several databases on a machine, it can happen that starting ADANUC fails with the message LABTB - LAB too big, because no more 32-bit shared memory space is available. If you don’t have 32-bit applications, you can avoid this error by specifying the parameter NOAB32BIT. Then the shared memory for the attached buffers is created as 64-bit shared memory.
The default is AB32BIT, which means that the shared memory is created as 32-bit shared memory segment.
Note:
If you started the nucleus with the parameter NOAB32BIT, and you
nevertheless start a 32-bit application that performs Adabas calls , the
application will get the Adabas response code 148 - Adabas not active.
ADABAS_ACCESS = {ALL | GROUP}
If ADABAS_ACCESS = ALL is specified, all users may perform Adabas calls.
If ADABAS_ACCESS = GROUP is specified, only those users that belong to the group of the user starting Adabas, for example sag, may perform Adabas calls.
The default is ALL.
Please refer to Administration, Database Security Overview, Using the UNIX Group Concept for further information about using the ADABAS_ACCESS parameter.
Note:
This parameter only applies to local Adabas calls in UNIX
environments.
APU = (n1,n2,n3)
This parameter specifies the number and layout of the Adabas Processing Units to be established for an Adabas session.
Adabas Processing Units optimize the parallel execution of Adabas commands, especially in the context of NUMA architectures. An Adabas Processing Unit consists of a logical collection of receiver and worker threads together with a dedicated command queue. The receiver threads pick up incoming user requests and place them into the command queue, while the worker threads process the commands in the command queue.
Each Adabas Processing Unit has exactly one command queue and must have at least one receiver and one worker thread.
Note:
If control parameters NT and APU are both specified, the settings of
parameter NT are ignored. The Adabas nucleus is setup with the settings defined
for APU.
- n1
Specifies the number of Adabas Processing Units that are defined for the Adabas nucleus. The minimum value is 1, the maximum value is 8.
- n2
Specifies the number of worker threads per Adabas Processing Unit. The minimum value is 1, the maximum value is 100/n1. The overall count of worker threads must not exceed 100.
- n3
Specifies the number of receiver threads per Adabas Processing Unit. The minimum value is 1, the maximum value is 100/n1.
APU=(4,4,2)
This defines an Adabas nucleus with 4 Adabas Processing Units, each with 4 worker and 2 receiver threads. This value implies a total of 16 worker threads and 8 receiver threads.
APU=(8,2,1)
This defines an Adabas nucleus with 8 Adabas Processing Units, each with 2 worker threads and 1 receiver thread. This value implies a total of 16 worker threads and 8 receiver threads.
APU=(1,6,2)
This defines an Adabas nucleus with 1 Adabas Processing Unit, each with 6 worker threads and 2 receiver threads. This value implies a total of 6 worker threads and 2 receiver threads. Defining only 1 Adabas Processing Unit results in a runtime environment that is similar to a runtime environment that is defined using the NT parameter only.
AR_CONFLICT = keyword
This parameter specifies the action to be taken if a restart detects that the last system crash was during a buffer flush. The following keywords can be used:
| Keyword | Meaning |
|---|---|
| ABORT | no restart is performed |
| CONTINUE | the system tries to perform a restart |
It is recommended to keep the setting AR_CONFLICT=ABORT. Only if the nucleus does not come up due to an interrupted buffer flush, then temporarily AR_CONFLICT=CONTINUE should be set.
Note:
You should be aware of the possibility of inconsistencies in the
case of a restart with AR_CONFLICT=CONTINUE. Consistency should be checked with
the ADAINV VERIFY function in this case.
The default is ABORT.
BFIO_PARALLEL_LIMIT = number
This parameter is used to limit the number of parallel I/O requests by a buffer flush and to allow earlier processing of concurrent I/Os from other threads. A large buffer flush, for example, can cause the I/O queue to be very busy, and other I/Os (such as buffer pool read I/Os and WORK I/Os) can be enqueued for a long time, slowing down command throughput and possibly causing applications to stall if a buffer flush is active.
If BFIO_PARALLEL_LIMIT is specified, the buffer flush sets up the specified number of I/Os and waits until these have been processed before issuing the next packet. The maximum value for ´number´ is defined by the operating system, for example by the UNIX kernel parameter AIO_LISTIO_MAX. Specifying a value of 0 is equivalent to specifying the maximum value allowed. The default value is 50.
Note:
If the value of BFIO_PARALLEL_LIMIT is too high (or equal to 0),
this can result in an I/O error during asynchronous IO (utility error message:
ADRERR). The reason for this is that the memory available within the operating
system for asynchronous I/O is exhausted. You can imagine that the required
memory is at least the size of the blocks to be written to the database plus
some additional space. The maximum value for BFIO_PARALLEL_LIMIT for which you
can be sure that this ADRERR error will not occur, depends on the operating
system configuration and on the other processes that are active on the same
machine. 50 seems to be a useful value for BFIO_PARALLEL_LIMIT; if the ADRERR
error occurs nevertheless, you should check your operating system
configuration.
adanuc: bfio_parallel_limit = 20
Twenty parallel I/O requests are permitted for a buffer flush.
adanuc: bfio_parallel_limit = 0
The number of parallel buffer flush I/Os is unlimited.
[NO]BI
This option is used to specify whether before images are written to the PLOG (BI) or not (NOBI).
The before images on the PLOG are used during a regenerate in order to verify the data consistency (for example, whether the appropriate PLOG is being used). If NOBI is set, the PLOG is smaller, but the consistency verifications cannot be performed.
The default is BI.
Note that if you specify NOBI, this will reduce the amount of consistency checking possible when using the ADAREC REGENERATE function. See ADAREC for more details.
CLOGBMAX = number[K | M]
This parameter specifies the maximum Adabas buffer length that is logged in the command log. If an Adabas buffer is larger than the value specified, the buffer is truncated in the command log. 0 means that the complete buffers are always logged.
The default is 0 (the complete buffers are logged).
adanuc: clogbmax = 4k
The logging of Adabas buffers is limited to the first 4 kilobytes of each buffer.
CLOGLAYOUT = [5|6]
If you specify CLOGLAYOUT=5, the command log has the same layout as for Adabas Version 5 when command logging is enabled. Since this layout does not support the ACBX interface, only the subset of information that is also available in the old ACB interface is logged for ACBX calls. The command log can be evaluated with the ADACLP utility that already existed in old versions of Adabas.
If you specify CLOGLAYOUT=6, the command log is generated in the new
layout that is supported by Adabas Version 6. For evaluating the command log,
an example program prilogc is provided – for details see
Appendix B.
The default value is 5.
DBID = number
This mandatory parameter selects the database to be used. `number' is in the range from 1 to 255.
adanuc: dbid = 2
Database 2 is used.
LAB = number[K | M]
This parameter specifies the size of the attached buffer area to be used during the Adabas session. The attached buffer area is used for allocating the user buffers during command execution.
Adabas rounds up the given value to the next multiple of 32 kilobytes to allocate the attached buffer area.
The high water mark for this parameter can be displayed using the DISPLAY parameter in ADAOPR.
The minimum value is 1 megabyte, the default value is 1 megabyte, however, if the value specified is less than the value of the NCL parameter in kilobytes, the value for LAB is automatically increased to that value.
Notes:
LABX = number[K | M]
This parameter specifies the size of the attached buffer extension area to be used for LOB processing or for other Adabas calls that use large Adabas buffer areas. While the regular attached buffers remain allocated during the whole Adabas session of the users, the attached buffer extensions are allocated before each Adabas call that requires more than 64 KB of attached buffer space, and they are released again at the end of the call.
The attached buffer extension area was introduced because storing large buffers in the regular attached buffer area requires much more space because of fragmentation.
Adabas rounds up the given value to the next multiple of 32 kilobytes to allocate the attached buffer area.
The high water mark for this parameter can be displayed using the DISPLAY parameter in ADAOPR.
The minimum value is 1 megabyte, the default value is 20 megabytes.
LBP = number[K | M]
This parameter specifies the size in bytes of the Adabas buffer pool during the session.
The high water mark for this parameter can be displayed using the DISPLAY parameter in ADAOPR.
The minimum value is 32 megabytes, the default value is 100 megabytes.
Note:
The actual size of the buffer pool also depends on the NT parameter:
if the size specified for LBP is less than NT * 2M, it is automatically
increased to NT * 2M.
There are the following reasons for using a buffer pool in Adabas:
If the same database block is accessed more than once, physical I/Os for rereading the block can be avoided;
Commands that update the database can be finished before all of the corresponding database blocks have been written to the disk.
If the buffer pool is too small, you have a larger number of I/Os than you would when performing the same database operations with a sufficient buffer pool size. In some cases, it may even occur that Adabas cannot successfully process an Adabas command, in which case the command will get a response code 162 (buffer pool too small).
In particular, if you process LOBs, it is recommended that you increase the size of the buffer pool; it should be possible to put the LOBs into the buffer pool without removing too many other database blocks. On the other hand, the buffer pool should not be too large, since there is no advantage in having buffer pool I/Os replaced by operating system paging I/Os.
You can use the ADAOPR parameter DISPLAY=BP_STATISTICS in order to help you find the optimum size for the buffer pool.
adanuc: lbp=32m
32 megabytes are allocated to the Adabas buffer pool.
LOGGING = (keyword [,keyword]...)
This parameter specifies logging of the buffers as defined in the keyword list.
The following keywords may be specified in the keyword list:
| Keyword | Meaning |
|---|---|
| CB | log Adabas control block |
| FB | log format buffers |
| RB | log record buffers |
| SB | log search buffer |
| VB | log value buffer |
| IB | log ISN buffer |
| ABD | log Adabas buffer descriptions |
| IO | log I/O activity |
| OFF | perform no logging |
Logging parameters may also be specified while a session is executing by using operator commands as described in the section on the utility ADAOPR.
adanuc: logging=(cb)
Command logging is performed for the current Adabas session; all of the Adabas control blocks will be logged.
LPXA = number
This parameter specifies the number of blocks reserved for data protection information on the Adabas WORK in the XA context if OPTIONS=XA is specified. These blocks are used to save protection information for transactions which run in the XA context and are in the pending state (prepared but not yet committed) at nucleus shutdown or for a long time. Each such transaction uses at least one of these blocks. If there are no free blocks in this area, Adabas will heuristically commit such transactions.
The minimum value is 1, and the default value is 10.
LWP = number[K | M]
This parameter specifies the size of the Adabas work pool, which is a work area in memory to be used for the Adabas nucleus session.
The Adabas work pool area is used to store the following:
Descriptor value table (DVT);
WORK I/O areas during command execution.
The high water mark for this parameter can be displayed using the DISPLAY parameter in ADAOPR.
The default value is 16 M, the minimum value is 500 K, the maximum value is 4000 M.
adanuc: lwp=750k
The size of the Adabas work pool is 750 Kbytes.
NCL = number
This parameter specifies the number of client threads locally accessing the database. Normally, the number of client threads is identical to the number of Adabas user sessions = the number of user queue elements, which is limited by the NU parameter.However, in the case of multi-threaded applications, the number of client threads may be larger, since the same Adabas sessions may be accessed by more than one thread. But on the other hand, in the case of application servers where the same process uses different Adabas user sessions for different users, it can happen that the number of client threads is smaller than the number of Adabas user sessions.
The minimum value is 2. The default value is the value for the NU parameter but at least 50. There is no fixed maximum value for this parameter, it is only limited by the IPC resources that are available for the operating system (see Increasing System V Resources (does not apply to AIX) for further information).
Note that Net-Work Version 7 also uses several threads to access the database; please refer to the Net-Work documentation for further details.
Notes:
NISNHQ = number
This parameter specifies the maximum number of records that can be placed into hold at any time by a single user.
If a user attempts to place more records in the hold status than permitted, he will receive a non-zero response code, even though there may still be space in the hold queue.
The high water mark for this parameter can be displayed using the DISPLAY parameter in ADAOPR.
The minimum value is 0 - where 0 means unlimited, the default value is 0 (unlimited).
adanuc: nisnhq=50
The maximum number of records which can be in the hold status for a single user is 50.
NT = number
This parameter specifies the number of threads to be established for the Adabas session.
Each Adabas command is assigned to a thread. A thread is released when the command has been processed.
The high water mark for this parameter can be displayed using the DISPLAY parameter in ADAOPR.
The minimum value is 1, the maximum value 100 and the default value is 6.
Notes:
adanuc: nt=8
Eight threads are established for the session.
NU = number
This parameter specifies the number of user queue elements to be established for the Adabas session.
A user queue element is assigned to each active Adabas user. A user queue element is assigned when the user issues an OP command or when the first Adabas command is issued. A user queue element is released when the user issues a CL command or when the user queue element is deleted on a timeout.
The high water mark for this parameter can be displayed using the DISPLAY parameter in ADAOPR.
The minimum value is 2, the default value is 20, the maximum value is 99999.
adanuc: nu=100
The Adabas user queue consists of 100 elements.
Note:
The NU parameter is used for two different purposes:
the number of user queue entries
the number of communication blocks
For single-threaded applications, the number of required communication blocks is not larger than the number of user queue elements, but for multi-threaded applications you need one communication block for each thread of an application that performs Adabas calls. Therefore the required value of the NU parameter may be much higher than the number of Adabas users.
OPTIONS = (keyword[,keyword]...)
This parameter is used to define the mode(s) in which the nucleus is started.
The following keywords are permitted:
| Keyword | Meaning |
|---|---|
| AUTO_EXPAND |
If AUTO_EXPAND is selected, the database will increase the existing container extents or create a new container extent if there is no free space available for increasing an existing Adabas file or for adding a new Adabas file. See the section Container Files in the Administration section for further information. |
| AUTORESTART_ONLY |
The AUTORESTART_ONLY keyword shuts down the nucleus immediately after its startup sequence has completed. If an autorestart is pending, the autorestart will be performed. No user commands or utility calls will be accepted by the nucleus. |
| FAULT_TOLERANT_AR |
When FAULT_TOLERANT_AR is selected, the nucleus behaviour in the event of an Adabas error during autorestart can be controlled. If an error occurs for a given file, a detailed entry is made in the nucleus log, but the autorestart continues. When the autorestart completes, the DBA can restore and regenerate the file by using ADABCK RESTORE and ADAREC REGENERATE for the affected file. If however the error occurred for the index of a file, it is sufficient to rebuild the file's index by using the REINVERT function of ADAINV. If FAULT_TOLERANT_AR is not selected, Adabas aborts an autorestart if an error is detected, and this can cause the database to be in an inconsistent state. |
| LOCAL_UTILITIES |
If LOCAL_UTILITIES is selected, ADANUC rejects all remote utility calls, i.e. the Adabas utilities cannot be run from a remote node across a network. This setting is recommended if security is important in your operating environment. LOCAL_UTILITIES and UTILITIES_ONLY can be dynamically enabled or disabled without having to shut the database down (see ADAOPR for further information). |
| OPEN_REQUIRED |
If OPEN_REQUIRED is selected, an open (OP) command must be issued as the first command of a user session. This option should be set if lnk_set_adabas_id is used when calling Adabas from application servers, and also when using Net-Work, otherwise in these cases Adabas cannot guarantee transaction integrity following an ADANUC restart. |
| READONLY |
The READONLY option causes ADANUC to run in read-only mode. Refer to the Administration Manual for more details. |
| TRUNCATION |
The TRUNCATION keyword controls the truncation of alphanumeric fields. If TRUNCATION is set, alphanumeric fields are truncated if necessary and response code 0 is returned. If TRUNCATION is not set, response code 55 is returned if truncation occurred. |
| UTILITIES_ONLY |
If UTILITIES_ONLY is selected, all calls other than for utilities will be rejected, giving the DBA exclusive control over all of the files in the database. Note, however, that this restriction only applies to new users; users who were already active when OPTIONS=UTILITIES_ONLY was specified can continue processing normally. If you want exclusive utility control over files or the entire database, use the LOCK function of ADAOPR instead. LOCAL_UTILITIES and UTILITIES_ONLY can be dynamically enabled or disabled without having to shut the database down (see ADAOPR in this manual for further information). |
| XA |
The keyword XA indicates that the server will support distributed transaction processing according to the X/Open XA specification. If the Adabas XA interface is to be used by an application, OPTION=XA must be used. See Administration, XA Support for further information. |
The default is that no option is set.
adanuc: options = utilities_only
All non-utility calls are rejected and the DBA has exclusive control over all database files.
[NO]PLOG
PLOG specifies which protection log is to be switched on.
The database cannot be regenerated if the disk is physically damaged and if there is no protection log. In this case, the database has to be restored using the last database dump. All updates made since this last dump was taken are then lost.
PLOG is the default.
READ_PARALLEL_LIMITS = (records,blocks,total)
For sequential commands, Adabas tries to increase the performance by reading the database blocks required for the following records in advance and in parallel. This lets you take advantage of disk striping, and the sequence of I/Os can be optimized. Significant performance improvements can only be expected when the physical I/O rate is high. A typical case where the READ_PARALLEL_LIMITS parameter can improve the performance is the execution of a batch program in which a complete large file is read, and this file contains a large number of database blocks that are not in the buffer pool when the program is started. However, this prefetching of database blocks can also have a negative impact on the performance:
Checking which blocks are required for the next records requires a certain amount of CPU time, and this is superfluous if all blocks are already in the buffer pool.
If you don’t read the next records of the command sequence, the overhead for reading blocks for this command sequence is superfluous.
If I/Os for too many blocks have been initiated, an I/O required for another command performed in parallel may be delayed significantly.
The READ_PARALLEL_LIMITS parameter lets you control the read-ahead behaviour. You can specify 3 numbers with the following meanings:
- records
The maximum number of records to be processed next in a command sequence, that are checked for blocks that are not yet in the buffer pool. The maximum value that can be specified is 65,535.
- blocks
The maximum number of blocks read in advance for one command sequence. The number specified for blocks must be <= the number specified for records, the maximum value is operating-system dependent.
- total
The maximum total number of blocks read in advance at the same time for the whole database. The number specified for total must be >= the number specified for blocks, the maximum value is operating-system dependent.
The default is (0,0,0), i.e. no read-ahead is performed.
Note:
If the value of the number specified for
total is too high, this can result in an I/O error
during asynchronous IO (utility error message: ADRERR). The reason for this is
that the memory available within the operating system for asynchronous I/O is
exhausted. You can imagine that the required memory is at least the size of the
blocks to be written to the database plus some additional space. The maximum
value for total for which you can be sure that this
ADRERR error will not occur, depends on the operating system configuration and
on the other processes that are active on the same machine.
adanuc: read_parallel_limits = (100,20,50)
When sequential commands are processed, the next up to 100 records of a command sequence are checked for required blocks that are not yet in buffer pool. The search for blocks to be read is stopped when 20 blocks are found, or when the number of blocks found plus the number of blocks currently read by other commands is 50. Then a read I/O for these blocks is initiated.
TNAA = number
This parameter specifies the maximum elapsed time (in seconds) that an access-only user may be active without issuing an Adabas command. This value can be changed dynamically with the ADAOPR utility.
The OP command allows you to override this value. See Command Reference, OP command for details.
See Command Reference, Time Limits for a table with timeout conditions.
Note that the figure you specify for this parameter is only approximate. In any particular instance, the actual amount of time can vary from this value by up to 10 seconds.
The minimum value is 20, the default value is 900 and the maximum value is 2592000.
adanuc: tnaa=180
The non-activity time limit for access-only users is 180 seconds.
TNAE = number
This parameter specifies the maximum elapsed time (in seconds) that an ET logic user may be active without issuing an Adabas command. This value can be changed dynamically with the ADAOPR utility.
The OP command allows you to override this value. See Command Reference, OP command for details.
See Command Reference, Time Limits for a table with timeout conditions.
Note that the figure you specify for this parameter is only approximate. In any particular instance, the actual amount of time can vary from this value by up to 10 seconds.
The minimum value is 20, the default value is 900 and the maximum value is 2592000.
adanuc: tnae=180
The non-activity time limit for ET logic users is 180 seconds.
TNAX = number
This parameter specifies the maximum elapsed time (in seconds) that an exclusive update user who does not use ET logic may be active without issuing an Adabas command. This value can be changed dynamically with the ADAOPR utility.
The OP command allows you to override this value. See Command Reference, OP command for details.
See Command Reference, Time Limits for a table with timeout conditions.
Note that the figure you specify for this parameter is only approximate. In any particular instance, the actual amount of time can vary from this value by up to 10 seconds.
The minimum value is 20, the default value is 900 and the maximum value is 2592000.
adanuc: tnax=180
The non-activity time limit for exclusive update users is 180 seconds.
TT = number
This parameter specifies the maximum elapsed time (in seconds) permitted for a logical transaction issued by an ET logic user. This value can be changed dynamically with the ADAOPR utility.
The OP command allows you to override this value. See Command Reference, OP command for details.
The time measurement for a logical transaction starts when the first command that places a record in hold status is issued, and terminates when an ET, BT, or CL command is issued. Adabas takes the following action when this time limit is exceeded:
All database updates made during the transaction are backed out;
All records held during the transaction are released;
All Command IDs for the user are released;
Response code 9 is returned on the next call issued by the user.
This time limit does not apply to non-ET logic users. The value specified for TT directly influences the required size of the Adabas Work data set.
The high water mark for this parameter can be displayed using the DISPLAY parameter in ADAOPR.
Note that the figure you specify for this parameter is only approximate. In any particular instance, the actual amount of time can vary from this value by up to 10 seconds.
The minimum value is 20, the default value is 300 and the maximum value is 2592000.
adanuc: tt=50
The transaction time limit for ET logic users is 50 seconds.
UNBUFFERED = ALL | CLEAR | (keyword [, keyword [, keyword]])
This parameter is relevant only for UNIX platforms, and if database containers or the protection log are stored in a file system. Usually, write I/Os are buffered by the file system. However, if you specify the O_DSYNC option for the corresponding open call, write I/O operations are performed unbuffered. This may improve the performance, in particular, if specified for WORK and PLOG, as it is required that the corresponding log information is really on disk at the end of a transaction. With the parameter UNBUFFERED, the usage of the O_DSYNC operation may be defined.
Note:
Usage of this parameter only has impact on the performance of
Adabas; which actual setting of the UNBUFFERED parameter results in the best
performance depends on the operating system and the storage system used - the
integrity of the database is guaranteed for all values of the UNBUFFERED
parameter.
The following keywords may be specified in the keyword list:
| Keyword | Meaning |
|---|---|
| DATABASE | ASSO and DATA containers in a file system are opened with the option O_DSYNC. |
| NODATABASE | ASSO and DATA containers in a file system are not opened with the option O_DSYNC. |
| WORK | A WORK container in a file system is opened with the option O_DSYNC. |
| NOWORK | A WORK container in a file system is not opened with the option O_DSYNC. |
| PLOG | A protection log in a file system is opened with the option O_DSYNC. |
| NOPLOG | A protection log in a file system is not opened with the option O_DSYNC. |
The keyword ALL is equivalent to (DATABASE, WORK, PLOG).
The keyword CLEAR is equivalent to (NODATABASE, NOWORK, NOPLOG).
The default is (NODATABASE, WORK, PLOG).
adanuc: unbuffered=(nowork)
O_DSYNC is not used for ASSO and DATA containers because NODATABASE is the default.
O_DSYNC is not used for WORK container because NOWORK has been specified.
O_DSYNC is used for protection logs because PLOG is the default.
USEREXITS = (keyword [,keyword]...)
This parameter, used in conjunction with the user exit facility, specifies one or more user exits. The specified user exit(s) must be loadable at execution time.
The keyword can take the values 1, 2, 4, 11 and 14.
Notes:
See Administration, User Exits and Hyperexits for further information about the user exits available.
WRITE_LIMIT = number
This parameter specifies the percentage of modified database blocks in the buffer pool before an implicit buffer flush is taken. For more information on buffer flushes, refer to Administration, Database Monitoring and Tuning, Buffer Pool Mangement.
Supported values are 1-50; the default value is 50. For compatibility reasons, values of 0 and 51-70 are also allowed - they are equivalent to 50.
Notes:
adanuc: write_limit=10
An implicit buffer flush is taken when the size of modified database blocks is 10% of the buffer pool size.
| Parameter | Use | Min. Value | Max. Value (see note 1) | Default | Dynamic (see note 3) |
|---|---|---|---|---|---|
| [NO]AB32BIT | Attached buffers defined as 32-bit shared memory to enable Adabas access from 32-bit applications (only relevant for HP-UX) | AB32BIT | No | ||
| ADABAS_ACCESS | Restrict user access for making Adabas calls | ALL | No | ||
| APU | Adabas processing units | None | No | ||
| AR_ CONFLICT |
Restart after crash during buffer flush | ABORT | No | ||
| BFIO_PARALLEL_LIMIT | Limit of parallel buffer flush IOs | 0 (see note 4) | None | 50 | Yes |
| [NO]BI | Write before image to PLOG | BI | No | ||
| CLOGBMAX | Length of Adabas buffers logged (only for CLOGLAYOUT=6) | 0 (complete buffers are logged) | 4GB | 4096 | No |
| CLOGLAYOUT | Select layout of CLOG | 5 | 6 | 5 | No |
| DBID | Database | 1 | 255 | None | No |
| LAB | Attached buffer area | 1MB | 2GB | Maximum (1MB, NCL value * 1024) | No |
| LABX | Attached buffer extension area | 1MB | None | 20MB | No |
| LBP | Adabas Buffer Pool Size (see note 2) |
32MB | None | 100MB | No |
| LOGGING | Command Logging | OFF | Yes | ||
| LPXA | XA data protection area size | 1 block | 65535 blocks | 10 blocks if the XA option is set | No |
| LWP | Length of Adabas Work Pool |
500 KB | 4000 MB | 16 MB | No |
| NCL | Number of local client threads | 2 | None | =NU, but at least 50 | No |
| NISNHQ | Maximum Number of ISNs in Hold per User | 0 (see note 4) | None | 0 | Yes |
| NT | Number of Threads | 1 | 100 | 6 | No |
| NU | User Queue Size | 2 users | 99999 users | 20 users | No |
| OPTIONS | Various Options | No option | Some | ||
| [NO]PLOG | Protection Logging | PLOG | No | ||
| READ_PARALLEL_LIMITS | Optimize read-ahead I/O performance | (0,0,0) | Yes | ||
| TNAA | Non-Activity Time Limit (ACC Only Users) |
20 | 2592000 | 900 seconds |
Yes |
| TNAE | Non-Activity Time Limit (ET Logic Users) |
20 | 2592000 | 900 seconds |
Yes |
| TNAX | Non-Activity Time Limit (EXU,EXF Users) |
20 | 2592000 | 900 seconds |
Yes |
| TT | Transaction Time Limit |
20 | 2592000 | 300 seconds |
Yes |
| UNBUFFERED | Setting of the O_DSYNC option (UNIX platforms only) | NODATABASE, WORK, PLOG | No | ||
| USEREXITS | User Exit(s) to be used |
None | No | ||
| WRITE_ LIMIT |
Buffer Pool Modification Limit |
1 (see note 5) | 50 | 50 (see note 5) | Yes |
Notes: