set format

[set jnl_tran_optimum_level=journal-output-method-optimum-level]
[set jnl_arc_terminate_timeout=maximum-waiting-time]
[set max_socket_descriptors=maximum-number-of-file-descriptors-for-
                            sockets]
[set jnl_arc_ipc_buff_size=TCP/IP-send-and-receive-buffer-size]
[set jnl_watch_time=maximum-time-the-journal-service-waits-for-a-communication-response]
[set watch_time=maximum-response-waiting-time]

command format

jnldfsv -r system-journal-service-definition-file-name
        -c checkpoint-dump-service-definition-file-name
         [[,checkpoint-dump-service-definition-file-name]...]

The journal service definition defines the execution environment to use the system journal service and checkpoint dump service. The definition cannot be changed for a system restart.

jnl_tran_optimum_level=journal-output-method-optimum-level~<unsigned integer> ((2-3)) <<2>>

Specify the optimum level for the method of outputting journals that are needed for recovering transactions to be collected in journal files. Consider the mode of applications when using level 3.

2

Optimization per global transaction

Journals are output synchronously in either of the following cases only:

• PJ is output from the root transaction branch within a global transaction.
• PJ and HJ are output from transaction branches at other nodes.

If journals other than the above are output asynchronously, the journal I/O count is reduced at the execution of transactions, resulting in improved performance.

Journals that were not asynchronously output to files when the system restarted after an abnormal termination are output again by the system when the transaction is recovered.

3

Conditional asynchronous journal output

If the transaction in progress does not include any of the following conditions, all the journals are output asynchronously. This eliminates journal I/O operations to enhance the transaction execution performance. If the transaction in progress includes the following conditions, journals are collected at level 2:

• In a global transaction using DAM, any DAM file not using the deferred update function is updated.
• A global transaction extending over more than one node is executed.
• Files are updated in a global transaction using ISAM.
• Files are updated in a global transaction using MCF.

Transaction journals requested to be output asynchronously are output to a journal file at each of the following times:

• When a resource manager (DAM, TAM, or MCF) accessed within a transaction is really updated (at a certain interval).
• When a checkpoint dump is collected.
• When the journal buffer becomes full.

Note that a transaction in which journals were not output to the journal file at system restart from abnormal termination is rolled back. It is rolled back even if the transaction terminated normally (commit completed) before abnormal termination of the system. If a user-processed UAP is executed in expectation for normal return of the commit API of a transaction, mismatch in status between the transaction and user process may occur when the OpenTP1 terminates abnormally during execution of the UAP. With this taken into consideration, do not specify level 3 if roll-back after system restart is a problem.

jnl_arc_terminate_timeout=maximum-waiting-time~<<unsigned integer> ((0-3600)) <<0>> (Unit: seconds)

Specify the maximum waiting time in seconds from the end of journal service to the halt of the archive service. If the archive service that passes the specified time is present, it will be stopped. Also, the journal service will terminate.

If a 0 is specified, the archive service and the journal service will not terminate until the end processing of the archived node to be archived is completed.

max_socket_descriptors=maximum-number-of-file-descriptors-for-sockets~<unsigned integer> ((32-2032))

Specify the maximum number of file descriptors to be used for sockets by the processes under control of OpenTP1^#.

The processes under control of OpenTP1^# exchange the process information with the system servers or user servers through the TCP/IP communication using sockets. Therefore, you must change the maximum number of file descriptors for sockets depending on the number of UAP processes that run concurrently and the number of other nodes to communicate with.

#: OpenTP1 processes other than the MCF services (MCF manager service, MCF communication service, and application startup service). For the MCF services, see the sections on the system service information definition and the system service common information definition.

Use the following formula for calculating the maximum number of file descriptors for sockets:

(Number of UAP processes in the local node^#1 + number of nodes that request a service of the journal service^#2 + number of system service processes^#3)/0.8

: Rounded up to the nearest whole integer.

#1: The number of UAP processes in the local node is the sum of the following values:

• Number of UAP processes in the local OpenTP1
• Number of transactions to be started concurrently from the CUP (value of the parallel_count operand specified in the client service definition)

#2: Add this value only when using the journal archiving facility. This value is the sum of the following values:

• Number of node names specified in the all_node operand for the local OpenTP1
• Number of other nodes that specify the local node name in the all_node operand for the local OpenTP1

#3: The number of system service processes in the local OpenTP1.

If the value specified for this operand is too small, the connection cannot be set with other processes under control of OpenTP1. The process terminates abnormally after outputting the KFCA00307-E error message.

The order of priority of the specified values is 1 > 2.

1. Journal service definition
2. System common definition

If this operand is omitted, the system assumes the value in the system common definition.

jnl_watch_time=maximum-time-the-journal-service-waits-for-a-communication-response ~<unsigned integer> ((0-65535)) <<180>> (Unit: seconds)

Specify the maximum time that the journal service waits from the time it sends a service request until it receives a service response for inter-process communication that uses RPCs. If no response to an RPC is received within the specified time, the RPC returns a timeout error.

If 0 is specified, the journal service continues to wait until a response is received, in which case OpenTP1 might not be able to terminate.

Do not change the setting of this operand unless special tuning is required.

The scope of the jnl_watch_time operand is the following:

• jnlopnfg command
• jnlclsfg command
• jnlchgfg command
• jnlunlfg command
• jnlswpfg command^#
• Time to wait for a response to a swap request when the journal file failed or became full

#:

For the jnlswpfg command, the time specified by the jnl_watch_time operand is doubled.

watch_time=maximum-response-waiting-time~<unsigned integer> ((0-65535)) (Unit: seconds)

Specify the maximum waiting time between sending a service request and receipt of a response when communicating between processes by RPC.

OpenTP1 may suspend termination processing for the length of time specified in this operand. Therefore, if you specify a large value, the termination processing of OpenTP1 may take some time.

If no response is received within the specified time, RPC returns a transmission timeout error.

Specify 0 if the system is to wait for a response. When you specify 0, OpenTP1 may not terminate.

If this operand is omitted, the value specified with the watch_time operand of the system common definition is assumed.

Use the default of the watch_time operand of the system common definition for this operand.

We recommend that you do not change the operand unless special tuning is necessary.

If a value that is much greater or smaller than the default of the watch_time operand of the system common definition is specified, a failure may occur causing OpenTP1 to go down.

jnl_arc_ipc_buff_size=TCP/IP-send-and-receive-buffer-size~<unsigned integer> ((8192-1048576))<<61440>> (units: bytes)

Specify the size of the TCP/IP send-and-receive buffer used by the journal transfer process, which uses the archive facility to transfer journal data to the archive node.

In a high-speed communication environment, you can improve performance by increasing the value of this operand. When you specify the operand, make sure that the value does not exceed the maximum TCP/IP buffer size that can be specified in the OS. Also, note that the value of the operand must be equal to the value of the jnl_arc_ipc_buff_size operand in the global archive journal service definition on the archive node.

Described on the following page.