This document provides information on how Adabas enables zIIP support.
In general, a z/OS application runs as a dispatchable unit managed using a TCB (task control block). It is said to run "under a TCB" or "in TCB mode". Running an application on a zIIP requires a dispatchable unit managed using an SRB (service request block). SRB code is said to run "under an SRB" or "in SRB mode".
To become eligible for running on a zIIP, an SRB must be assigned to an "enclave" managed by the z/OS Workload Manager (WLM). An enclave is a WLM transaction that can span multiple dispatchable units (TCBs and SRBs) in one or more address spaces and that WLM reports on and manages as a unit. When Adabas for zIIP starts, it creates an enclave consisting of its main TCB and an SRB and configures the SRB to be eligible for running on a zIIP. Generally, Adabas for zIIP runs in SRB mode (eligible for execution on a zIIP) whenever possible and in TCB mode whenever necessary.
The WLM enclave created and used by Adabas for zIIP processing is bound to the Adabas nucleus or utility address space. It is deleted when the Adabas nucleus or utility job step terminates.
When an Adabas nucleus
or utility is started with the ADARUN parameter ZIIP set to YES, the nucleus or utility starts an SRB in
parallel to its main TCB, places the TCB in a wait state, and continues
processing in the SRB. The SRB may run on a zIIP, as directed by the Workload
Manager, and executes the bulk of the Adabas logic.
The SRB cannot perform all operations that the TCB can do, though. Broadly,
there are two categories of operations that Adabas for zIIP cannot perform in
SRB mode:
Certain system services, in particular those that perform input/output operations
Code not owned by Software AG (supplied by the installation or a third party)
Whenever the SRB cannot perform an operation, it may "pass the baton" to the TCB by taking the TCB out of its wait and putting itself into a wait state. The TCB then proceeds at the point where the SRB left off and performs the operation. When the operation has finished, the TCB takes the SRB out of its wait and puts itself into a wait state again. These steps are called "switch to TCB mode" and "switch to SRB mode", respectively.
Adabas for zIIP performs an operation in TCB mode either by switching to TCB mode before and back to SRB mode after the operation or by issuing a request to the TCB to perform the operation in parallel while the SRB continues other processing (see also Parallel Requests below).
As described in TCB/SRB Switches above, Adabas for zIIP may switch to TCB mode to perform an operation that it cannot do in SRB mode, and switch back to SRB mode after the operation. Alternatively, the SRB may issue a request to the TCB to perform the operation in parallel while the SRB continues processing other work. Roughly, the procedure to use parallel requests functions as follows:
The SRB needs to perform an operation that requires TCB mode.
The SRB issues a request to the TCB to perform the operation in parallel and takes the TCB out of its wait state.
If necessary, the SRB puts the current nucleus thread into a wait state.
The SRB looks for other work to do - other threads or new commands.
At the same time, the TCB, coming out of its wait state, processes the parallel request given to it.
When the TCB has finished processing a parallel request, it checks whether the SRB has meanwhile issued another request. If so, it processes that request too, and repeats this step.
When the TCB has processed all parallel requests and the SRB has not requested a switch to TCB mode, the TCB enters a wait state again.
Whether Adabas performs a TCB-mode operation via a mode switch or a parallel request depends on the type of operation. Generally, operations that may occur very frequently are performed via parallel requests. This is more efficient than mode switches if (and only if) the workload given to Adabas is high and allows for sufficient parallelism in its processing. The choice between mode switches and parallel requests is made by Adabas; it cannot be controlled via configuration parameters.