One more iteration on the documentation. Also minor changes to precset.

psblas3-type-indexed
Salvatore Filippone 19 years ago
parent cfe206de5f
commit 2c378361ce

@ -6,8 +6,12 @@ In this chapter are illustrated data structures used for definition of
routines interfaces. This include data structure for sparse matrix,
communication descriptor and preconditioner. These data structures are used for
calling PSBLAS routines in Fortran~90 language and will be used to next
chapters containing these callings. Their definitions are included in
the modules \verb|psb_spmat_type|, \verb|psb_descriptor_type| and \verb|psb_prec_type|.
chapters containing these callings.
All the data types and subroutine interfaces are defined in the module
\verb|psb_sparse_mod|; this will have to be included by every user
subroutine that makes use of the library.
\subsection{Descriptor data structure}

@ -22,7 +22,7 @@ subroutines. In this way, the library can take care of runtime memory
requirements that are quite difficult or even impossible to predict at
implementation or compilation time. The following presentation of the
PSBLAS library follows the general structure of the proposal for
serial Sparse BLAS~\cite{sblas97}, which in its turn is based on the
serial Sparse BLAS~\cite{sblas97,sblas02}, which in its turn is based on the
proposal for BLAS on dense matrices~\cite{BLAS1,BLAS2,BLAS3}.
The applicability of sparse iterative solvers to many different areas
@ -63,7 +63,7 @@ the serial sparse BLAS, so that any extension made to the data
structures of the serial kernels is available to the parallel
version. The overall design and parallelization strategy have been
influenced by the structure of the ScaLAPACK parallel
library~\cite{scalapack}. The layered structure of the PSBLAS library
library. The layered structure of the PSBLAS library
is shown in figure~\ref{fig:psblas} ; lower layers of the library
indicate an encapsulation relationship with upper layers. The ongoing
discussion focuses on the Fortran~95 layer immediately below the
@ -76,7 +76,11 @@ that guarantees a portable and efficient communication layer. The
Message Passing Interface code is encapsulated within the BLACS
layer. However, in some cases, MPI routines are directly used either
to improve efficiency or to implement communication patterns for which
the BLACS package doesn't provide any method.
the BLACS package doesn't provide any method.
We assume that the user program has initialized a BLACS process grid
with one column and as many rows as there are processes; the PSBLAS
initialization routines will take the communication context for this
grid and store internally for further use.
\begin{figure}[h] \begin{center}
\includegraphics[scale=0.45]{figures/psblas}
@ -87,7 +91,6 @@ the BLACS package doesn't provide any method.
The PSBLAS library consists of two classes of subroutines that is, the
{\em computational routines} and the {\em auxiliary routines}. The
computational routine set includes:
\begin{itemize}
\item Sparse matrix by dense matrix product; \item Sparse triangular
systems solution for block diagonal matrices;
@ -177,6 +180,97 @@ fetched from (neighbouring) processes. The descriptor of the index
space is built exactly for the purpose of properly sequencing the
communication steps required to achieve this objective.
A simple application structure will walk through the index space
allocation, matrix/vector creation and linear system solution as
follows:
\begin{enumerate}
\item Initialize parallel environment with \verb|blacs_gridinit|
\item Initialize index space with \verb|psb_cdall|
\item Allocate sparse matrix and dense vectors with \verb|psb_spall|
and \verb|psb_geall|
\item Loop over all local rows, generate matrix and vector entries,
and insert them with \verb|psb_spins| and \verb|psb_geins|
\item Assemble the various entities:
\begin{enumerate}
\item \verb|psb_cdasb|
\item \verb|psb_spasb|
\item \verb|psb_geasb|
\end{enumerate}
\item Choose the preconditioner to be used with \verb|psb_precset| and
build it with \verb|psb_precbld|
\item Call the iterative method of choice, e.g. \verb|psb_bicgstab|
\end{enumerate}
This is the structure of the sample program
\verb|test/pargen/ppde90.f90|.
For a simulation in which the same discretization mesh is used over
multiple time steps, the following structure may be more appropriate:
\begin{enumerate}
\item Initialize parallel environment with \verb|blacs_gridinit|
\item Initialize index space with \verb|psb_cdall|
\item Loop over the topology of the discretization mesh and build the
descriptor with \verb|psb_cdins|
\item Assemble the descriptor with \verb|psb_cdasb|
\item Allocate the sparse matrices and dense vectors with
\verb|psb_spall| and \verb|psb_geall|
\item Loop over the time steps:
\begin{enumerate}
\item If after first time step,
reinitialize the sparse matrix with \verb|psb_sprn|; also zero out
the dense vectors;
\item Loop over the mesh, generate the coefficients and insert/update
them with \verb|psb_spins| and \verb|psb_geins|
\item Assemble with \verb|psb_spasb| and \verb|psb_geasb|
\item Choose and build preconditioner with \verb|psb_precset| and
\verb|psb_precbld|
\item Call the iterative method of choice, e.g. \verb|psb_bicgstab|
\end{enumerate}
\end{enumerate}
The insertion routines will be called as many times as needed; it is
clear that they only need be called on the data that is actually
allocated to the current process, i.e. each process generates its own
data.
In principle there is no specific order in the calls to
\verb|psb_spins|, nor is there a requirement to build a matrix row in
its entirety before calling the routine; this allows the application
programmer to walk through the discretization mesh element by element,
generating the main part of a given matrix row but also contributions
to the rows corresponding to neighbouring elements.
From a functional point of view it is even possible to execute one
call for each nonzero coefficient; however this would have a
substantial computational overhead. It is therefore advisable to pack
a certain amount of data into each call to the insertion routine, say
touching on a few tens of rows; the best performng value would depend
on both the architecture of the computer being used and on the problem
structure.
At the opposite extreme, it would be possible to generate the entire
part of a coefficient matrix residing on a process and pass it in a
single call to \verb|psb_spins|; this, however, would entail a
doubling of memory occupation, and thus would be almost always far
from optimal.
\subsection{Programming model}
The PSBLAS librarary is based on the Single Program Multiple Data
(SPMD) programming model: each process participating in the
computation performs the same actions on a chunk of data. Parallelism
is thus data-driven.
Because of this structure, practically all subroutines \emph{must} be
called simultaneously by all processes participating in the
computation, i.e each subroutine call acts implicitly as a
synchronization point. The exceptions to this rule are:
\begin{itemize}
\item The insertion routines \verb|psb_cdins|, \verb|psb_spins| and
\verb|psb_geins|;
\item The error handling routines.
\end{itemize}
In particular, as per the discussion in the previous section, the
insertion routines may be called a different number of times on each
process, depending on the data distribution chosen by the user.
%%% Local Variables:
%%% mode: latex
%%% TeX-master: "userguide"

@ -2,8 +2,7 @@
\label{sec:methods}
In this chapter we provide routines for preconditioners and iterative
methods. Their
interfaces are defined in the module \verb|psb_methd_mod|
methods.
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

@ -18,38 +18,118 @@ many parameters that is possible to adjust to fit the user's needs:
\subroutine{psb\_precset}{Sets the precodntioner type}
\subroutine{psb\_precset}{Sets the preconditioner type}
\syntax{call psb\_precset}{prec, ptype, iv, rs, rv, ierr}
\syntax{call psb\_precset}{prec, ptype, iv, rs, ierr}
\begin{description}
\item[\bf On Entry]
\item[prec]
Scope: {\bf global} \\
Scope: {\bf local} \\
Type: {\bf required}\\
Specified as: e pronditioner data structure \precdata.
Specified as: a pronditioner data structure \precdata.
\item[ptype] the type of preconditioner.
Scope: {\bf global} \\
Type: {\bf required}\\
Specified as: a string.
Specified as: a character string, see usage notes.
\item[iv] integer parameters for the precondtioner.
Scope: {\bf global} \\
Type: {\bf required}\\
Specified as: an integer array.
Specified as: an integer array, see usage notes.
\item[rs]
Scope: {\bf } \\
Type: {\bf }\\
Specified as: .
\item[rv]
Scope: {\bf } \\
Type: {\bf }\\
Specified as: .
Scope: {\bf global} \\
Type: {\bf optional}\\
Specified as: a long precision real number.
\item[ierr]
Scope: {\bf } \\
Type: {\bf }\\
Specified as: .
Scope: {\bf global} \\
Type: {\bf required}\\
\end{description}
\section*{Usage Notes}
The PSBLAS 2.0 contains a number of preconditioners, ranging from a
simple diagonal scaling to 2-level domain decomposition. These
preconditioners may use the SuperLU or the UMFPACK software, if
installed; see~\cite{SUPERLU,UMFPACK}.
Legal inputs to this subroutine are interpreted depending on the
$ptype$ string as follows\footnote{The string is case-insensitive}:
\begin{description}
\item[NONE] No preconditioning, i.e. the preconditioner is just a copy
operator.
\item[DIAG] Diagonal scaling; each entry of the input vector is
multiplied by the reciprocal of the sum of the absolute values of
the coefficients in the corresponding row of matrix $A$;
\item[ILU] Precondition by the incomplete LU factorization of the
block-diagonal of matrix $A$, where block boundaries are determined
by the data allocation boundaries for each process; requires no
communication. Only $ILU(0)$ is currently implemented.
\item[AS] Additive Schwarz preconditioner (see~\cite{PARA04}); in this
case the user may specify additional flags through the integer
vector \verb|ir| as follows:
\begin{description}
\item[$iv(1)$] Number of overlap levels, an integer $novr>0$, default
$novr=1$.
\item[$iv(2)$] Restriction operator, legal values: \verb|psb_halo_|,
\verb|psb_none_|; default: \verb|psb_halo_|
\item[$iv(3)$] Prolongation operator, legal values: \verb|psb_none_|,
\verb|psb_sum_|, \verb|psb_avg_|, default: \verb|psb_none_|
\item[$iv(4)$] Factorization type, legal values: \verb|f_ilu_n_|,
\verb|f_slu_|, \verb|f_umf_|, default: \verb|f_ilu_n_|.
\end{description}
Note that the default corresponds to a Restricted Additive Schwarz
preconditioner with $ILU(0)$ and 1 level of overlap.
\end{description}
If a multilevel preconditioner is desired, the user should call
\verb|psb_precset| once choosing AS, and a second time specifying
$ptype=ML$ with the following optional parameters in $iv$ (see
also~\cite{APNUM,DD2}):
\begin{description}
\item[$iv(1)$] Type of multilevel correction, legal values: \verb|no_ml_|,
\verb|add_ml_prec_|, \verb|mult_ml_prec_|,
default: \verb|mult_ml_prec_|;
\item[$iv(2)$] Aggregation algorithm, legal values: \verb|loc_aggr_|;
\item[$iv(3)$] Smoother type, legal values: \verb|no_smth_|,
\verb|smth_omg_|, default: \verb|smth_omg_|;
\item[$iv(4)$] Coarse matrix allocation, legal values:
\verb|mat_distr_|, \verb|mat_repl_|, default: \verb|mat_distr_|
\item[$iv(5)$] Smoother position, legal values: \verb|pre_smooth_|,
\verb|post_smooth_|, \verb|smooth_both_|, default:
\verb|post_smooth_|
\item[$iv(6)$] Factorization type (for coarse matrix), legal values: \verb|f_ilu_n_|,
\verb|f_slu_|, \verb|f_umf_|, default: \verb|f_ilu_n_|;
\item[$iv(7)$] Number of Jacobi sweeps for coarse system correction,
default 1.
\item[$rs$] Set the smoother parameter $\omega$ a user defined value;
default: esitimate with the infinity norm of matrix $A$.
\end{description}
The 2-level preconditioners are based on the idea of building a
coarse-space approximation $A_C$ of the matrix $A$; given a set $W_C$
of coarse vertices, with size $n_C$, and a suitable restriction
operator $R_C \in \Re^{n_C \times n}$, $A_C$ is defined as
\[
A_C=R_C A R_C^T .
\]
The prolongator $R_C^T$ is built with the smoothed aggregation technique,
in which we start from a tentative prolongator that simply maps
fine-level entries onto their aggregates $P_C$; if the user chooses
\verb|no_smth_| this is the prolongator used, otherwise it is
multiplied by a smoother \[ S = I - \omega D^{-1} A \], where $D$ is
the diagonal of $A$ and $\omega$ may be imposed by the user or
estimated internally.
The coarse space correction may be added to the fine level solution
\verb|add_ml_prec_|
\[
M_{2L-A}^{-1} = M_{C}^{-1} + M_{1L}^{-1}.
\]
or it can be composed in a multiplicative framework as a pre-smoothed
correction
\[
M_{2L-H1}^{-1} = M_{C}^{-1} + \left( I - M_{C}^{-1}A \right) M_{1L}^{-1},
\]
post-smoothed correction
\[
M_{2L-H2}^{-1} = M_{1L}^{-1} + \left( I - M_{1L}^{-1}A \right) M_{C}^{-1}.
\]
or two-sided.
@ -60,11 +140,11 @@ Specified as: .
\begin{description}
\item[\bf On Entry]
\item[a] the system sparse matrix.
Scope: {\bf global} \\
Scope: {\bf local} \\
Type: {\bf required}\\
Specified as: a sparse matrix data structure \spdata.
\item[desc\_a] the problem communication descriptor.
Scope: {\bf global} \\
Scope: {\bf local} \\
Type: {\bf required}\\
Specified as: a communication descriptor data structure \descdata.
\item[upd]
@ -75,14 +155,14 @@ Specified as: a character.
\begin{description}
\item[\bf On Return]
\item[prec] the precodntioner.\\
Scope: {\bf global} \\
\item[prec] the preconditioner.\\
Scope: {\bf local} \\
Type: {\bf required}\\
Specified as: a precondtioner data structure \precdata\\
\item[info] the return error code.\\
Scope: {\bf local} \\
Scope: {\bf global} \\
Type: {\bf required}\\
Specified as: an integer.\\
Specified as: an integer, upon successful completion $info=0$ \\
\end{description}
@ -95,15 +175,15 @@ Specified as: an integer.\\
\begin{description}
\item[\bf On Entry]
\item[prec] the preconditioner.
Scope: {\bf global} \\
Scope: {\bf local} \\
Type: {\bf required}\\
Specified as: a preconditioner data structure \precdata.
\item[x] the source vector.
Scope: {\bf global} \\
Scope: {\bf local} \\
Type: {\bf require}\\
Specified as: a double precision array.
\item[desc\_a] the problem communication descriptor.
Scope: {\bf global} \\
Scope: {\bf local} \\
Type: {\bf required}\\
Specified as: a communication data structure \descdata.
\item[trans]
@ -119,13 +199,27 @@ Specified as: a double precision array.
\begin{description}
\item[\bf On Return]
\item[y] the destination vector.
Scope: {\bf global} \\
Scope: {\bf local} \\
Type: {\bf required}\\
Specified as: a double precision array.
\item[info] the return error code.\\
Scope: {\bf local} \\
Type: {\bf required}\\
Specified as: an integer.\\
Specified as: an integer, upon successful completion $info=0$ .\\
\end{description}
\subroutine{psb\_prec\_descr}{Prints a description of current preconditioner}
\syntax{call psb\_prec\_descr}{prec}
\begin{description}
\item[\bf On Entry]
\item[prec] the preconditioner.
Scope: {\bf local} \\
Type: {\bf required}\\
Specified as: a preconditioner data structure \precdata.
\end{description}

@ -65,6 +65,11 @@ Type: {\bf required}\\
Specified as: an integer variable.\\
\end{description}
\section*{Notes}
\begin{enumerate}
\item On exit from this routine the descriptor is in the build state
\end{enumerate}
%
%% psb_cdins %%
@ -108,6 +113,11 @@ Scope: {\bf local} \\
Type: {\bf required}\\
Specified as: an integer variable.
\end{description}
\section*{Notes}
\begin{enumerate}
\item This routine may only be called if the descriptor is in the
build state
\end{enumerate}
@ -134,6 +144,11 @@ Type: {\bf required}\\
Specified as: an integer variable.
%\item[arg]
\end{description}
\section*{Notes}
\begin{enumerate}
\item On exit from this routine the descriptor is in the assembled
state.
\end{enumerate}
@ -285,6 +300,12 @@ Scope: {\bf local} \\
Type: {\bf required}\\
Specified as: an integer variable.
\end{description}
\section*{Notes}
\begin{enumerate}
\item On exit from this routine the sparse matrix is in the build
state.
\item The descriptor may be in either the build or assembled state.
\end{enumerate}
@ -342,6 +363,22 @@ Scope: {\bf local} \\
Type: {\bf required}\\
\end{description}
\section*{Notes}
\begin{enumerate}
\item On entry to this routine the descriptor may be in either the
build or assembled state.
\item On entry to this routine the sparse matrix may be in either the
build or update state.
\item If the descriptor is in the build state, then the sparse matrix
ought also be in the buld state; the action of the routine is to
(implicitly) call \verb|psb_cdins| to add entries to the sparsity
pattern;
\item If the descriptor is in the assembled state, then any entries in
the sparse matrix that would generate additional communication
requirements will be ignored;
\item If the matrix is in the update state, any entries in positions
that were not present in the original matrix will be ignored.
\end{enumerate}
%
%% psb_spasb %%
@ -383,6 +420,22 @@ Type: {\bf required}\\
Specified as: an integer variable.
\end{description}
\section*{Notes}
\begin{enumerate}
\item On entry to this routine the descriptor must be in the
assembled state, i.e. \verb|psb_cdasb| must already have been called.
\item The sparse matrix may be in either the build or update state;
\item Duplicate entries are detected and handled in both build and
update state, with the exception of the error action that is only
taken in the build state, i.e. on the first assembly;
\item If the update choice is \verb|psb_upd_perm_|, then subsequent
calls to \verb|psb_spins| to update the matrix must be arranged in
such a way as to produce exactly the same sequence of coefficient
values as encountered at the first assembly;
\item On exit from this routine the matrix is in the assembled state,
and thus is suitable for the computational routines.
\end{enumerate}
%% %
@ -474,7 +527,11 @@ Scope: {\bf local} \\
Type: {\bf required}\\
Specified as: an integer variable.
\end{description}
\section*{Notes}
\begin{enumerate}
\item On exit from this routine the sparse matrix is in the update
state.
\end{enumerate}
%
%% psb_spupdate %%
%
@ -591,7 +648,7 @@ Specified as: a structured data of type \descdata.
Scope: {\bf global}.\\
Type: {\bf optional}.\\
Specified as: integer, possible values: \verb|psb_dupl_ovwrt_|,
\verb|psb_dupl_add_|, \verb|psb_dupl_err_|.
\verb|psb_dupl_add_|.
\end{description}
\begin{description}
@ -607,6 +664,14 @@ Type: {\bf required}\\
Specified as: an integer variable.
\end{description}
\section*{Notes}
\begin{enumerate}
\item Dense vectors/matrices do not have an associated state;
\item Duplicate entries are either overwritten or added, there is no
provision for raising an error condition.
\end{enumerate}
%
%% psb_asb %%
%

@ -91,6 +91,139 @@
\include{methods}
\include{precs}
\include{error}
\clearpage
\begin{thebibliography}{99}
%
\bibitem{BLAS1}
Lawson, C., Hanson, R., Kincaid, D. and Krogh, F.,
Basic {L}inear {A}lgebra {S}ubprograms for {F}ortran usage,
{ACM Trans. Math. Softw.} vol.~{5}, 38--329, 1979.
\bibitem{BLAS2}
Dongarra, J. J., DuCroz, J., Hammarling, S. and Hanson, R.,
An Extended Set of {F}ortran {B}asic {L}inear {A}lgebra {S}ubprograms,
{ACM Trans. Math. Softw.} vol.~{14}, 1--17, 1988.
\bibitem{BLAS3}
Dongarra, J., DuCroz, J., Hammarling, S. and Duff, I.,
A Set of level 3 Basic Linear Algebra Subprograms,
{ACM Trans. Math. Softw.} vol.~{16}, 1--17, 1990.
\bibitem{DOUGLAS}
R.E.~Bank and C.C.~Douglas,
{\em SMMP: Sparse Matrix Multiplication Package},
Advances in Computational Mathematics, 1993, 1, 127-137.
(See also {\tt http://www.mgnet.org/~douglas/ccd-codes.html})
%
\bibitem{PARA04FOREST}
G.~Bella, S.~Filippone, A.~De Maio and M.~Testa,
{\em A Simulation Model for Forest Fires},
in J.~Dongarra, K.~Madsen, J.~Wasniewski, editors,
Proceedings of PARA~04 Workshop on State of the Art
in Scientific Computing, pp.~546--553, Lecture Notes in Computer Science,
Springer, 2005.
%
\bibitem{PARA04}
A.~Buttari, P.~D'Ambra, D.~di Serafino and S.~Filippone,
{\em Extending PSBLAS to Build Parallel Schwarz Preconditioners},
in , J.~Dongarra, K.~Madsen, J.~Wasniewski, editors,
Proceedings of PARA~04 Workshop on State of the Art
in Scientific Computing, pp.~593--602, Lecture Notes in Computer Science,
Springer, 2005.
%
\bibitem{CAI_SAAD}
X.~C.~Cai and Y.~Saad,
{\em Overlapping Domain Decomposition Algorithms for General Sparse Matrices},
Numerical Linear Algebra with Applications, 3(3), pp.~221--237, 1996.
%
\bibitem{CAI_SARKIS}
X.C.~Cai and M.~Sarkis,
{\em A Restricted Additive Schwarz Preconditioner for General Sparse Linear Systems},
SIAM Journal on Scientific Computing, 21(2), pp.~792--797, 1999.
%
\bibitem{CAI_WIDLUND}
X.C.~Cai and O.~B.~Widlund,
{\em Domain Decomposition Algorithms for Indefinite Elliptic Problems},
SIAM Journal on Scientific and Statistical Computing, 13(1), pp.~243--258, 1992.
%
\bibitem{DD1}
T.~Chan and T.~Mathew,
{\em Domain Decomposition Algorithms},
in A.~Iserles, editor, Acta Numerica 1994, pp.~61--143, 1994.
Cambridge University Press.
%
\bibitem{APNUM06}
P.~D'Ambra, D.~di Serafino and S.~Filippone,
On the Development of PSBLAS-based Parallel Two-level Schwarz Preconditioners,
Applied Numerical Mathematics, to appear, 2006.
%
\bibitem{UMFPACK}
T.A.~Davis,
{\em Algorithm 832: UMFPACK - an Unsymmetric-pattern Multifrontal
Method with a Column Pre-ordering Strategy},
ACM Transactions on Mathematical Software, 30, pp.~196--199, 2004.
(See also {\tt http://www.cise.ufl.edu/~davis/})
%
\bibitem{SUPERLU}
J.W.~Demmel, S.C.~Eisenstat, J.R.~Gilbert, X.S.~Li and J.W.H.~Liu,
A supernodal approach to sparse partial pivoting,
SIAM Journal on Matrix Analysis and Applications, 20(3), pp.~720--755, 1999.
%
\bibitem{BLACS}
J.~J.~Dongarra and R.~C.~Whaley,
{\em A User's Guide to the BLACS v.~1.1},
Lapack Working Note 94, Tech.\ Rep.\ UT-CS-95-281, University of
Tennessee, March 1995 (updated May 1997).
%
\bibitem{sblas97}
I.~Duff, M.~Marrone, G.~Radicati and C.~Vittoli,
{\em Level 3 Basic Linear Algebra Subprograms for Sparse Matrices:
a User Level Interface},
ACM Transactions on Mathematical Software, 23(3), pp.~379--401, 1997.
%
\bibitem{sblas02}
I.~Duff, M.~Heroux and R.~Pozo,
{\em An Overview of the Sparse Basic Linear
Algebra Subprograms: the New Standard from the BLAS Technical Forum},
ACM Transactions on Mathematical Software, 28(2), pp.~239--267, 2002.
\bibitem{PSBLAS}
S.~Filippone and M.~Colajanni,
{\em PSBLAS: A Library for Parallel Linear Algebra
Computation on Sparse Matrices},
\newblock
ACM Transactions on Mathematical Software, 26(4), pp.~527--550, 2000.
%
\bibitem{KIVA3PSBLAS}
S.~Filippone, P.~D'Ambra, M.~Colajanni,
{\em Using a Parallel Library of Sparse Linear Algebra in a Fluid Dynamics
Applications Code on Linux Clusters},
in G.~Joubert, A.~Murli, F.~Peters, M.~Vanneschi, editors,
Parallel Computing - Advances \& Current Issues,
pp.~441--448, Imperial College Press, 2002.
%
\bibitem{machiels}
{Machiels, L. and Deville, M.}
{\em Fortran 90: An entry to object-oriented programming for the solution
of partial differential equations.}
{ACM Trans. Math. Softw.} vol.~{23}, 32--49.
\bibitem{metcalf}
{Metcalf, M., Reid, J. and Cohen, M.}
{\em Fortran 95/2003 explained.}
{Oxford University Press}, 2004.
%
\bibitem{DD2}
B.~Smith, P.~Bjorstad and W.~Gropp,
{\em Domain Decomposition: Parallel Multilevel Methods for Elliptic
Partial Differential Equations},
Cambridge University Press, 1996.
%
\bibitem{MPI1}
M.~Snir, S.~Otto, S.~Huss-Lederman, D.~Walker and J.~Dongarra,
{\em MPI: The Complete Reference. Volume 1 - The MPI Core}, second edition,
MIT Press, 1998.
%
\end{thebibliography}
\end{document}
%%% Local Variables:
%%% mode: latex

File diff suppressed because one or more lines are too long

@ -158,7 +158,8 @@ module psb_prec_type
end interface
interface psb_prec_descr
module procedure psb_file_prec_descr, psb_zfile_prec_descr
module procedure psb_out_prec_descr, psb_file_prec_descr, &
& psb_zout_prec_descr, psb_zfile_prec_descr
end interface
interface psb_prec_short_descr
@ -167,6 +168,16 @@ module psb_prec_type
contains
subroutine psb_out_prec_descr(p)
type(psb_dprec_type), intent(in) :: p
call psb_file_prec_descr(6,p)
end subroutine psb_out_prec_descr
subroutine psb_zout_prec_descr(p)
type(psb_zprec_type), intent(in) :: p
call psb_zfile_prec_descr(6,p)
end subroutine psb_zout_prec_descr
subroutine psb_file_prec_descr(iout,p)
integer, intent(in) :: iout
type(psb_dprec_type), intent(in) :: p

@ -179,10 +179,8 @@ subroutine psb_dprecset(p,ptype,iv,rs,rv,info)
if (isz >= 3) p%baseprecv(2)%iprcparm(smth_kind_) = iv(3)
if (isz >= 4) p%baseprecv(2)%iprcparm(coarse_mat_) = iv(4)
if (isz >= 5) p%baseprecv(2)%iprcparm(smth_pos_) = iv(5)
if (isz >= 6) p%baseprecv(2)%iprcparm(glb_smth_) = iv(6)
if (isz >= 7) p%baseprecv(2)%iprcparm(f_type_) = iv(7)
if (isz >= 8) p%baseprecv(2)%iprcparm(jac_sweeps_) = iv(8)
if (isz >= 6) p%baseprecv(2)%iprcparm(f_type_) = iv(6)
if (isz >= 7) p%baseprecv(2)%iprcparm(jac_sweeps_) = iv(7)
end if
if (present(rs)) then

@ -179,9 +179,8 @@ subroutine psb_zprecset(p,ptype,iv,rs,rv,info)
if (isz >= 3) p%baseprecv(2)%iprcparm(smth_kind_) = iv(3)
if (isz >= 4) p%baseprecv(2)%iprcparm(coarse_mat_) = iv(4)
if (isz >= 5) p%baseprecv(2)%iprcparm(smth_pos_) = iv(5)
if (isz >= 6) p%baseprecv(2)%iprcparm(glb_smth_) = iv(6)
if (isz >= 7) p%baseprecv(2)%iprcparm(f_type_) = iv(7)
if (isz >= 8) p%baseprecv(2)%iprcparm(jac_sweeps_) = iv(8)
if (isz >= 6) p%baseprecv(2)%iprcparm(f_type_) = iv(6)
if (isz >= 7) p%baseprecv(2)%iprcparm(jac_sweeps_) = iv(7)
end if

@ -251,11 +251,11 @@ program df_sample
case(7)
call psb_precset(pre,'asm',iv=(/ml,halo_,none_/))
call psb_precset(pre,'ml',&
& iv=(/mult_ml_prec_,loc_aggr_,smth_omg_,mat_distr_,post_smooth_,1,f_ilu_n_,4/))
& iv=(/mult_ml_prec_,loc_aggr_,smth_omg_,mat_distr_,post_smooth_,f_ilu_n_,4/))
case(8)
call psb_precset(pre,'asm',iv=(/ml,halo_,none_/))
call psb_precset(pre,'ml',&
& iv=(/mult_ml_prec_,loc_aggr_,smth_omg_,mat_distr_,post_smooth_,1,f_umf_,4/))
& iv=(/mult_ml_prec_,loc_aggr_,smth_omg_,mat_distr_,post_smooth_,f_umf_,4/))
case default
call psb_precset(pre,'ilu')

@ -173,19 +173,6 @@ program pde90
call psb_precset(pre,'asm',iv=(/novr,halo_,none_/))
case(rash_)
call psb_precset(pre,'asm',iv=(/novr,nohalo_,none_/))
case(ras2lv_)
ptype='asm'
call psb_precset(pre,ptype,iv=(/novr,halo_,none_/))
ptype='ml'
call psb_precset(pre,ptype,&
&iv=(/add_ml_prec_,loc_aggr_,no_smth_,mat_repl_,&
& pre_smooth_/),rs=0.d0)
case(ras2lvm_)
ptype='asm'
call psb_precset(pre,ptype,iv=(/novr,halo_,none_/))
ptype='ml'
call psb_precset(pre,ptype,&
& iv=(/mult_ml_prec_,glb_aggr_,pre_smooth_/),rs=0.d0)
end select
call blacs_barrier(icontxt,'ALL')

Loading…
Cancel
Save