/*@ BSsparse.h - Include fle for the sparse solver package. This is the include file for public use. @*/ /* ****************************************************************** */ /* NOTICE: BlockSolve95 is copyrighted. See the file ../COPYRIGHT */ /* for details. */ /* */ /* Authors: Mark Jones and Paul Plassmann */ /* */ /* Version: 3.0 */ /* */ /* Last Modified: 1/96 */ /* */ /* ****************************************************************** */ #ifndef __BSsparseh #define __BSsparseh /* The following is a global definition of the variable for error handling. */ /* It is statically defined in BScontext.c and initialized to 0 there */ extern int __BSERROR_STATUS; /* include the "system" dependent routines */ #include "BSdepend.h" /* include the special message passing stuff that I wrote */ #include "BMmsg.h" /* the usual system stuff */ #include #include #include /* ****************************************************************** */ /* Definitions of double/single precision stuff */ /* ****************************************************************** */ #if defined(PARCH_cray) || defined(PARCH_t3d) #define dgemm_ SGEMM #define dtrmm_ STRMM #define dcopy_ SCOPY #define daxpy_ SAXPY #define dgemv_ SGEMV #define dtrmv_ STRMV #define dpotrf_ SPOTRF #define dtrtri_ STRTRI #define dlamch_ SLAMCH #define dgetrf_ SGETRF #define dgetri_ SGETRI #define sdot_ SDOT #define sgemm_ SGEMM #define strmm_ STRMM #define scopy_ SCOPY #define saxpy_ SAXPY #define sgemv_ SGEMV #define strmv_ STRMV #define spotrf_ SPOTRF #define strtri_ STRTRI #define slamch_ SLAMCH #define sgetrf_ SGETRF #define sgetri_ SGETRI #elif defined(FORTRANCAPS) #define dgemm_ DGEMM #define dtrmm_ DTRMM #define dcopy_ DCOPY #define daxpy_ DAXPY #define dgemv_ DGEMV #define dtrmv_ DTRMV #define dpotrf_ DPOTRF #define dtrtri_ DTRTRI #define dlamch_ DLAMCH #define dgetrf_ DGETRF #define dgetri_ DGETRI #define sdot_ SDOT #define sgemm_ SGEMM #define strmm_ STRMM #define scopy_ SCOPY #define saxpy_ SAXPY #define sgemv_ SGEMV #define strmv_ STRMV #define spotrf_ SPOTRF #define strtri_ STRTRI #define slamch_ SLAMCH #define sgetrf_ SGETRF #define sgetri_ SGETRI #elif !defined(FORTRANUNDERSCORE) #define dgemm_ dgemm #define dtrmm_ dtrmm #define dcopy_ dcopy #define daxpy_ daxpy #define dgemv_ dgemv #define dtrmv_ dtrmv #define dpotrf_ dpotrf #define dtrtri_ dtrtri #define dlamch_ dlamch #define dgetrf_ dgetrf #define dgetri_ dgetri #define sdot_ sdot #define sgemm_ sgemm #define strmm_ strmm #define scopy_ scopy #define saxpy_ saxpy #define sgemv_ sgemv #define strmv_ strmv #define spotrf_ spotrf #define strtri_ strtri #define slamch_ slamch #define slamch_ slamch #define sgetrf_ sgetrf #define sgetri_ sgetri #endif /* turn on compilation of the double precision version if */ /* BSDOUBLE is defined, otherwise single precision */ #if defined(PARCH_cray) || defined(PARCH_t3d) #else #define BSDOUBLE #endif #if defined(PARCH_t3d) #include #define MY_MPI_FLT MPI_DOUBLE #define FLOAT double #define DLAMCH(a) SLAMCH(_cptofcd((a),1)) #define DGEMM(a,b,c,d,e,f,g,h,i,j,k,l,m) SGEMM(_cptofcd((a),1),_cptofcd((b),1),\ (c),(d),(e),(f),(g),(h),(i),(j),(k),(l),(m)) #define DTRMM(a,b,c,d,e,f,g,h,i,j,k) STRMM(_cptofcd((a),1),_cptofcd((b),1),\ _cptofcd((c),1),_cptofcd((d),1),(e),(f),(g),(h),(i),(j),(k)) #define DCOPY SCOPY #define DAXPY SAXPY #define DGEMV(a,b,c,d,e,f,g,h,i,j,k) SGEMV(_cptofcd((a),1),(b),(c),(d),(e),\ (f),(g),(h),(i),(j),(k)) #define DTRMV(a,b,c,d,e,f,g,h) STRMV(_cptofcd((a),1),\ _cptofcd((b),1),_cptofcd((c),1),(d),(e),(f),(g),(h)) #define DPOTRF(a,b,c,d,e) SPOTRF(_cptofcd((a),1),(b),(c),(d),(e)) #define DTRTRI(a,b,c,d,e,f) STRTRI(_cptofcd((a),1),_cptofcd((b),1),\ (c),(d),(e),(f)) #define GFLSUM GDSUM #define DGETRF SGETRF #define DGETRI SGETRI #elif defined(BSDOUBLE) #define MY_MPI_FLT MPI_DOUBLE #define FLOAT double #define DGEMM dgemm_ #define DTRMM dtrmm_ #define DCOPY dcopy_ #define DAXPY daxpy_ #define DGEMV dgemv_ #define DTRMV dtrmv_ #define DPOTRF dpotrf_ #define DTRTRI dtrtri_ #define DLAMCH dlamch_ #define GFLSUM GDSUM #define DGETRF dgetrf_ #define DGETRI dgetri_ #else #define MY_MPI_FLT MPI_FLOAT #define FLOAT float #define DGEMM sgemm_ #define DTRMM strmm_ #define DCOPY scopy_ #define DAXPY saxpy_ #define DGEMV sgemv_ #define DTRMV strmv_ #define DPOTRF spotrf_ #define DTRTRI strtri_ #define DLAMCH slamch_ #define GFLSUM GFSUM #define DGETRF sgetrf_ #define DGETRI sgetri_ #endif #if defined(__cplusplus) extern "C" { #endif /* note that BLdot cannot be used with COMPLEX because it cannot handle returing a double complex!! */ extern void DCOPY(int*,FLOAT*,int*,FLOAT*,int*); extern void DAXPY(int*,FLOAT*,FLOAT*,int*,FLOAT*,int*); extern void DGETRF(int*,int*,FLOAT*,int*,int*,int*); extern void DGETRI(int*,FLOAT*,int*,int*,FLOAT *,int*,int*); #if defined(PARCH_t3d) extern FLOAT SLAMCH(_fcd); extern void STRMM(_fcd,_fcd,_fcd,_fcd,int*,int*, FLOAT*,FLOAT*,int*,FLOAT*,int*); extern void SPOTRF(_fcd,int*,FLOAT*,int*,int*); extern void STRTRI(_fcd,_fcd,int*,FLOAT*,int*,int*); extern void SGEMV(_fcd,int*,int*,FLOAT*,FLOAT*,int*,FLOAT *,int*, FLOAT*,FLOAT*,int*); extern void STRMV(_fcd,_fcd,_fcd,int*,FLOAT*,int*,FLOAT *,int*); extern void SGEMM(_fcd,_fcd,int*,int*,int*,FLOAT*,FLOAT*,int*, FLOAT *,int*,FLOAT*,FLOAT*,int*); #else extern FLOAT DLAMCH(char*); extern void DTRMM(char*,char*,char*,char*,int*,int*, FLOAT*,FLOAT*,int*,FLOAT*,int*); extern void DPOTRF(char*,int*,FLOAT*,int*,int*); extern void DTRTRI(char*,char*,int*,FLOAT*,int*,int*); extern void DGEMV(char*,int*,int*,FLOAT*,FLOAT*,int*,FLOAT *,int*, FLOAT*,FLOAT*,int*); extern void DTRMV(char*,char*,char*,int*,FLOAT*,int*,FLOAT *,int*); extern void DGEMM(char*,char*,int*,int*,int*,FLOAT*,FLOAT*,int*, FLOAT *,int*,FLOAT*,FLOAT*,int*); #endif #if defined(__cplusplus) } #endif /* include special blas stuff */ #include "BSmy_blas.h" /* ****************************************************************** */ /* End of Definitions */ /* ****************************************************************** */ /* ****************************************************************** */ /* Definitions of misc. constants */ /* ****************************************************************** */ #define MEM_ERROR -25 #define FILE_ERROR -26 #define BB_ERROR -27 #define COLOR1_ERROR -28 #define COLOR2_ERROR -29 #define INODE_ERROR -30 #define MSG_ERROR -30 #define CG_NEG_ERROR -31 #define COLOR_ERROR -32 #define FACTOR_ERROR -33 #define MATRIX_ERROR0 -50 #define MATRIX_ERROR1 -51 #define MATRIX_ERROR2 -52 #define MATRIX_ERROR3 -53 #define MATRIX_ERROR4 -54 #define MATRIX_ERROR5 -55 #define MATRIX_ERROR6 -56 #define MATRIX_ERROR7 -57 #define MATRIX_ERROR8 -58 #define MATRIX_ERROR9 -59 #define MATRIX_ERROR10 -60 #define MATRIX_ERROR11 -61 #define MATRIX_ERROR12 -62 #define MATRIX_ERROR13 -63 #define MATRIX_ERROR14 -64 #define MATRIX_ERROR15 -65 #define MATRIX_ERROR16 -66 #define MATRIX_ERROR17 -67 #define REPERM_ERROR -68 #define SYM_ERROR -69 #define TRI_SOLVE_ERROR -70 #define PAR_SOLVE_ERROR -71 #define SCALING_ERROR -72 #define MLOG_ERROR -73 /* type of coloring */ #define IDO 10 #define SDO 20 /* kinds of preconditioners */ #define PRE_DIAG 0 #define PRE_ICC 1 #define PRE_ILU 2 #define PRE_SSOR 3 #define PRE_BJACOBI 3 /* kinds of iterative methods */ #define CG 100 #define SSOR 200 #define GMRES 300 #define SYMMLQ 400 /* ****************************************************************** */ /* End of section */ /* ****************************************************************** */ /* ****************************************************************** */ /* Definitions of data structures */ /* ****************************************************************** */ /* store a local dense matrix */ typedef struct __BSdense { int size; /* size of the dense matrix */ int local_ind; /* local index of first element of dense matrix */ FLOAT *matrix; /* the matrix itself */ } BSdense; /* shows which inodes belong to each clique */ /* the arrays are one element longer than num_cols for ease of use */ typedef struct __BScl_2_inode { int num_cols; /* number of columns */ int *g_offset; /* global number of beginning of each clique */ int *proc; /* processor who owns clique */ int *inode_index; /* index into inode structure */ BSdense *d_mats; /* array of pointers to dense matrices */ } BScl_2_inode; /* i_node structure keeps several identical rows/cols in place */ /* we are storing on the half of the symmetric matrix, in addition */ /* the diagonal portions are stored with the clique structure */ typedef struct __BSinode { int num_cols; /* number of cols in i_node */ int gcol_num; /* global column number of first row of i_node */ /* global column numbers are consecutive */ int *o_gcol_num; /* original global column number of each row of i_node */ /* original global column numbers are NOT consecutive */ int length; /* the length of each col */ int below_diag; /* a pointer to where row entries below the diag start (ILU only) */ int *row_num; /* the row numbers (we store local, not global #'s */ FLOAT *nz; /* the nz values */ } BSinode; /* list of inodes */ /* the array is one element longer than length for ease of use */ typedef struct __BSinode_list { int length; /* the number of i_nodes */ BSinode *list; /* array of i_nodes */ } BSinode_list; /* permutation of rows/cols of a matrix */ typedef struct __BSpermutation { int length; int *perm; } BSpermutation; /* distribution of a numbering */ /* i.e. how many 0's, how many 1's, etc. */ typedef struct __BSdistribution { int max; int *distribution; } BSdistribution; /* numbering of rows/cols of a matrix */ typedef struct __BSnumbering { int length; int *numbers; } BSnumbering; /* processor information and execution time information */ typedef struct __BSprocinfo { int my_id; /* processor id */ int nprocs; /* number of processors */ MPI_Comm procset; /* set of processors to operate on */ int max_clique_size; /* the maximum clique size to allow */ int max_inode_size; /* the maximum i-node size to allow */ int coloring_type; /* the type of coloring to do */ int error_check; /* if TRUE, then do error checking */ int retain; /* if TRUE, then keep around some extra */ /* information to allow for fast permutation */ /* for a matrix with the same structure */ int print; /* if TRUE, then print reordering information */ int print_log; /* if TRUE, then print logging information when requested */ int single; /* if TRUE, the no cliques or i-nodes are found */ int preconditioner; /* type of preconditioner to be used */ int method; /* iterative method to be used */ int scaling; /* if true, scale linear systems for solution */ int num_rhs; /* number of RHSs to be solved for */ int num_rhs_comm; /* number of RHSs for which the communication */ /* data structure is set up */ int max_iterations; /* the max number of iterations allowed solver */ int guess; /* if TRUE, use x-values as starting vector for solver */ int restart; /* GMRES restart parameter */ FLOAT residual_tol; /* residual error tolerance requested from solver */ } BSprocinfo; /* global/local mapping */ #if defined(__cplusplus) typedef struct __BSmapping { /* not all of these members may be present, some may be NULL */ /* we are trying to define a flexible structure */ void *vlocal2global; /* data for mapping local to global */ /* a function for mapping local to global */ void (*flocal2global)(int,int *,int *,BSprocinfo *,__BSmapping *); void (*free_l2g)(void *); /* a function for free'ing the l2g data */ void *vglobal2local; /* data for mapping global to local */ /* a function mapping global to local */ void (*fglobal2local)(int,int *,int *,BSprocinfo *,__BSmapping *); void (*free_g2l)(void *); /* a function for free'ing the g2l data */ void *vglobal2proc; /* data for mapping global to proc */ /* a function mapping global to proc */ void (*fglobal2proc)(int,int *,int *,BSprocinfo *,__BSmapping *); void (*free_g2p)(void *); /* a function for free'ing the g2p data */ } BSmapping; #else typedef struct __BSmapping { /* not all of these members may be present, some may be NULL */ /* we are trying to define a flexible structure */ void *vlocal2global; /* data for mapping local to global */ void (*flocal2global)(); /* a function for mapping local to global */ void (*free_l2g)(); /* a function for free'ing the l2g data */ void *vglobal2local; /* data for mapping global to local */ void (*fglobal2local)(); /* a function mapping global to local */ void (*free_g2l)(); /* a function for free'ing the g2l data */ void *vglobal2proc; /* data for mapping global to proc */ void (*fglobal2proc)(); /* a function mapping global to proc */ void (*free_g2p)(); /* a function for free'ing the g2p data */ } BSmapping; #endif /* row of a sparse matrix */ typedef struct __BSsprow { int diag_ind; /* index of diagonal in row */ int length; /* num. of nz in row */ int *col; /* col numbers */ FLOAT *nz; /* nz values */ } BSsprow; /* sparse matrix */ typedef struct __BSspmat { int num_rows; /* number of local rows */ int global_num_rows;/* number of global rows */ int symmetric; /* if TRUE, the matrix should be symmetric */ int icc_storage; /* if TRUE, storage scheme used for ICC preconditioner */ /* if FALSE, ILU storage scheme used */ BSmapping *map; /* mapping from local to global, etc */ BSsprow **rows; /* the sparse rows */ } BSspmat; /* offset mapping structure (keep track of who has what row, etc. */ typedef struct __BSoff_map { int length; /* length of the map (number of processors, usually) */ int my_ind; /* my index into the map */ int *proc_id; /* processor id's (sorted by offset) */ int *offset; /* sorted list of offsets */ } BSoff_map; /* information for quickly permuting a matrix with the same structure */ typedef struct __BSreperm { BSpermutation *inode_perm; /* the original inode permutation */ BSdistribution *inode_distr; /* the original inode distribution */ } BSreperm; /* Here is a very important data structure, this is the structure */ /* returned by BSmain_perm. It contains everything needed for */ /* parallel matrix multiply, back solve, etc. It also may or may not */ /* contain the information for quickly permuting a matrix with the */ /* exact same structure again */ /* IMPORTANT: the map pointer is only a copy, do not destroy */ /* if the original is destroyed, we are in trouble */ typedef struct __BSpar_mat { int num_rows; /* number of local rows */ int global_num_rows; /* number of global rows */ int local_nnz; /* number of nonzeroes on this processor */ int local_num_inodes; /* number of i-nodes on this processor */ int global_num_inodes; /* number of global i-nodes */ int local_num_cliques; /* number of cliques on this processor */ int global_num_cliques; /* number of global cliques */ int num_colors; /* number of colors used */ int max_local_row_length; /* max length row on this processor */ int symmetric; /* if TRUE, matrix should be symmetric */ int icc_storage; /* if TRUE, storage scheme used for ICC preconditioner */ /* if FALSE, ILU storage scheme used */ BSpermutation *perm; /* the local permutation of the columns */ BSpermutation *inv_perm; /* the inverse of perm */ BSnumbering *global_row_num; /* the global numbers of the rows */ BSnumbering *color2clique; /* map from colors to cliques */ BScl_2_inode *clique2inode; /* map from cliques to inodes */ BSinode_list *inodes; /* the array of inodes */ FLOAT *diag; /* a copy of the original permuted diagonal */ FLOAT *save_diag; /* a copy of the current (scaled) diagonal */ /* this is useful if we share cliques */ /* it can be NULL (which means the diagonal */ /* is all 1's */ /* can legally be equal to diag */ FLOAT *scale_diag; /* the diagonal the matrix was scaled by */ /* if NULL, then no scaling was done */ /* can legally be equal to diag */ BSmapping *map; /* a POINTER to the original mapping */ BSreperm *reperm; /* information for quick permutation (opt) */ } BSpar_mat; /* data structure used to contain communication information */ typedef struct __BScomm { int num_rhs; /* number of RHSs BScomm set up to solve */ BMcomp_msg *to_msg; /* compiled message structure */ BMcomp_msg *from_msg; /* compiled message structure */ } BScomm; /* ****************************************************************** */ /* End of section */ /* ****************************************************************** */ /* ****************************************************************** */ /* Declarations of my functions */ /* ****************************************************************** */ /* BSsparse functions */ extern BSpar_mat *BSmain_perm(BSprocinfo *,BSspmat *); extern BSoff_map *BSmake_off_map(int,BSprocinfo *,int); extern void BSglob2loc(int,int *,int *,BSprocinfo *,BSmapping *); extern void BSglob2proc(int,int *,int *,BSprocinfo *,BSmapping *); extern void BSloc2glob(int,int *,int *,BSprocinfo *,BSmapping *); extern void BSfree_spmat(BSspmat *); extern void BSfree_easymat(BSspmat *); extern void BSfree_off_map(BSoff_map *); extern void BSfreel2g(void *data); extern void BSfreeg2l(void *data); extern void BSfree_par_mat(BSpar_mat *); extern void BSfree_copy_par_mat(BSpar_mat *); extern void BSmain_reperm(BSprocinfo *,BSspmat *,BSpar_mat *); extern void BSget_diag(BSpar_mat *,FLOAT *,BSprocinfo *); extern void BSscale_diag(BSpar_mat *,FLOAT *,BSprocinfo *); extern BSpar_mat *BScopy_par_mat(BSpar_mat *); extern void BScopy_nz(BSpar_mat *,BSpar_mat *); extern void BSset_diag(BSpar_mat *,FLOAT,BSprocinfo *); extern void BSset_diagv(BSpar_mat *,FLOAT *,BSprocinfo *); extern void BSsetup_block(BSpar_mat *,BScomm *,int,BSprocinfo *); extern BScomm *BSsetup_forward(BSpar_mat *,BSprocinfo *); extern void BSforward(BSpar_mat *,FLOAT *,FLOAT *,BScomm *,BSprocinfo *); extern void BSforward1(BSpar_mat *,FLOAT *,FLOAT *,BScomm *,BSprocinfo *); extern void BSbackward(BSpar_mat *,FLOAT *,FLOAT *,BScomm *, BSprocinfo *); extern void BSbackward1(BSpar_mat *,FLOAT *,FLOAT *,BScomm *, BSprocinfo *); extern void BSb_forward(BSpar_mat *,FLOAT *,FLOAT *,BScomm *,int,BSprocinfo *); extern void BSb_backward(BSpar_mat *,FLOAT *,FLOAT *,BScomm *,int,BSprocinfo *); extern void BSfree_comm(BScomm *); extern void BSfree_comm_data(int *); extern int BSpar_solve(BSpar_mat *,BSpar_mat *,BScomm *,FLOAT *,FLOAT *, FLOAT *,BSprocinfo *); extern int BSpar_sym_solve(int,BSpar_mat *,BSpar_mat *,BScomm *,FLOAT *,FLOAT *, int,FLOAT,int,FLOAT *,int,BSprocinfo *); extern int BSpar_gmres(int,BSpar_mat *,BSpar_mat *,BScomm *,FLOAT *, FLOAT *,int,int,FLOAT,int,FLOAT *,int,BSprocinfo *); extern int BSpar_isolve(BSpar_mat *,BSpar_mat *,BScomm *,BSpar_mat *,BScomm *, FLOAT *,FLOAT *,FLOAT,FLOAT *,BSprocinfo *); extern void BSinv_diag_block(BSpar_mat *,BSprocinfo *); extern int BSinit(int *,char ***); extern int BSfinalize(); extern int BSprint_log(BSprocinfo *); extern void BSfor_solve1(BSpar_mat *,FLOAT *,BScomm *,BSprocinfo *); extern void BSfor_solve(BSpar_mat *,FLOAT *,BScomm *,BSprocinfo *); extern void BSb_for_solve(BSpar_mat *,FLOAT *,BScomm *,int,BSprocinfo *); extern void BSback_solve1(BSpar_mat *,FLOAT *,BScomm *,BSprocinfo *); extern void BSback_solve(BSpar_mat *,FLOAT *,BScomm *,BSprocinfo *); extern void BSb_back_solve(BSpar_mat *,FLOAT *,BScomm *,int,BSprocinfo *); extern int BSfactor(BSpar_mat *,BScomm *,BSprocinfo *); extern BScomm *BSsetup_factor(BSpar_mat *,BSprocinfo *); extern void BStri_solve(BSpar_mat *,BSpar_mat *,BScomm *,FLOAT *,int,int,BSprocinfo *); extern void BStri_mult(BSpar_mat *,BScomm *,BSpar_mat *,BScomm *,FLOAT *,FLOAT *, FLOAT *,FLOAT *,FLOAT,int,BSprocinfo *); extern void BSsave_diag(BSpar_mat *,BSprocinfo *); extern void BSbjacobi(BSpar_mat *,FLOAT *,BScomm *,BSprocinfo *); extern void BSmat_subtract(BSspmat *,BSspmat *,FLOAT); extern BSprocinfo *BScreate_ctx(); extern void BSctx_set_id(BSprocinfo *,int); extern void BSctx_set_np(BSprocinfo *,int); extern void BSctx_set_ps(BSprocinfo *,MPI_Comm); extern void BSctx_set_cs(BSprocinfo *,int); extern void BSctx_set_is(BSprocinfo *,int); extern void BSctx_set_ct(BSprocinfo *,int); extern void BSctx_set_err(BSprocinfo *,int); extern void BSctx_set_rt(BSprocinfo *,int); extern void BSctx_set_pr(BSprocinfo *,int); extern void BSctx_set_print_log(BSprocinfo *,int); extern void BSctx_set_si(BSprocinfo *,int); extern void BSctx_set_sym(BSprocinfo *,int); extern void BSctx_set_max_it(BSprocinfo *,int); extern void BSctx_set_scaling(BSprocinfo *,int); extern void BSctx_set_restart(BSprocinfo *,int); extern void BSctx_set_guess(BSprocinfo *,int); extern void BSctx_set_tol(BSprocinfo *,FLOAT); extern void BSctx_set_num_rhs(BSprocinfo *,int); extern void BSctx_set_bs_comm(BSprocinfo *,int); extern void BSctx_set_pre(BSprocinfo *, int); extern void BSctx_set_method(BSprocinfo *, int); extern void BSctx_print(BSprocinfo *); extern void BSfree_ctx(BSprocinfo *); extern void BSset_mat_symmetric(BSspmat *,int); extern void BSset_mat_icc_storage(BSspmat *,int); extern double BSlocal_flops(); extern double BSglobal_flops(BSprocinfo *); extern int BSlocal_nnz(BSpar_mat *); extern int BSglobal_nnz(BSpar_mat *,BSprocinfo *); extern int BSlocal_num_inodes(BSpar_mat *); extern int BSglobal_num_inodes(BSpar_mat *); extern int BSlocal_num_cliques(BSpar_mat *); extern int BSglobal_num_cliques(BSpar_mat *); extern int BSnum_colors(BSpar_mat *); extern int BSoffset(int,int *,int **,BSprocinfo *); extern BSspmat *BSeasy_A(int,int,int *,int *,FLOAT *,BSprocinfo *); /* ****************************************************************** */ /* End of section */ /* ****************************************************************** */ #endif