Preconditioner routines

The base PSBLAS library contains the implementation of some simple preconditioning techniques:

The supporting data type and subroutine interfaces are defined in the module psb_prec_mod. The old interfaces psb_precinit and psb_precbld are still supported for backward compatibility

10.1 init — Initialize a preconditioner

Notes Legal inputs to this subroutine are interpreted depending on the ptype string as follows⁴ :

10.2 Set — set preconditioner parameters

This method sets the parameters defining the subdomain solver when the preconditioner type is BJAC. More precisely, the parameter identified by what is assigned the value contained in val.

`what`	`character(len=*)`.
	The parameter to be set. It can be specified through its name; the string is case-insensitive. See Table 21.
`val`	`integer` or `character(len=*)` or `real(psb_spk_)` or `real(psb_dpk_)`, `intent(in)`.
	The value of the parameter to be set. The list of allowed values and the corresponding data types is given in Table 21. When the value is of type `character(len=*)`, it is also treated as case insensitive.
`info`	`integer, intent(out)`.
	Error code. If no error, 0 is returned. See Section 8 for details.

A number of subdomain solvers can be chosen with this method; a list of the parameters that can be set, along with their allowed and default values, is given in Table-21.


`what`	data type	`val`	default	comments

`’SUB_SOLVE’`	`character(len=*)`	`’ILU’` `’ILUT’` `’INVT’` `’INVK’` `’AINV’`		The local solver to be used with the smoother or one-level preconditioner ILU(p), ILU(p, t), Approximate Inverses INVK(p, q), INVT(p₁, p2, t₁, t₂) and AINV(t); note that approximate inverses are specifically suited for GPUs since they do not employ triangular system solve kernels, see [2].

`’SUB_FILLIN’`	`integer`	Any integer number ≥ 0	0	Fill-in level p of the incomplete LU factorizations.

`’SUB_ILUTHRS’`	`real(kind_parameter)`	Any real number ≥ 0	0	Drop tolerance t in the ILU(p, t) factorization.

`’ILU_ALG’`	`character(len=*)`	`’MILU’`	`’NONE’`	ILU algorithmic variant

`’ILUT_SCALE’`	`character(len=*)`	`’MAXVAL’` `’DIAG’` `’ARSWUM’` `’ARCSUM’` `’ACLSUM’` `’NONE’`	`’NONE’`	ILU scaling strategy

`’INV_FILLIN’`	`integer`	Any integer number ≥ 0	0	Second fill-in level q of the INVK(p, q) approximate inverse.

`’INV_ILUTHRS’`	`real(kind_parameter)`	Any real number ≥ 0	0	Second drop tolerance s in the INVT(t, s) approximate inverse.

`’AINV_ALG’`	`character(len=*)`	`’LLK’` `’SYM-LLK’` `’STAB-LLK’` `’MLK,LMX’`	`’LLK’`	AINV algorithmic strategy.

Table 21: Parameters defining the solver of the BJAC preconditioner.

10.3 build — Builds a preconditioner

The amold, vmold and imold arguments may be employed to interface with special devices, such as GPUs and other accelerators.

10.4 apply — Preconditioner application routine

Notes This method is almost always called by the iterative methods of Sec. 11, and practically never directly by the user.

10.5 descr — Prints a description of current preconditioner

10.6 clone — clone current preconditioner

10.7 free — Free a preconditioner

10.8 allocate_wrk — preconditioner

Notes Preconditioners often need internal work storage during their application at each iteration of a linear solver method: in many situations this can be accomplished by allocating and releasing memory “on the fly”. However, when running on an accelerator through e.g. the CUDA enabled data strutures of Sec. 12.4 and 13, memory allocation and deallocation usually have a much larger overhead, significantly affecting performance. To alleviate this problem we define this method that preallocates internal storage; it is intended to be invoked prior to the iterative solver method, so that the necessary internal work storage is available throughout the iterative method application.

When using GPUs or other specialized devices, the vmold argument is also necessary to ensure the internal work vectors are of the appropriate dynamic type to exploit the accelerator hardware.

10.9 deallocate_wrk — preconditioner

Notes Deallocates preconditioner internal work storage; to be invoked after an iterative solver has completed execution, see the discussion in Sec. 10.8.

10 Preconditioner routines