Amesos Package Browser (Single Doxygen Collection) Development
amesos_paraklete_decl.h
Go to the documentation of this file.
00001 /* ========================================================================== */
00002 /* === Paraklete/paraklete.h ================================================ */
00003 /* ========================================================================== */
00004 
00005 /* Include file for Paraklete library API.
00006  *
00007  * PARAKLETE version 0.3: parallel sparse LU factorization.  Nov 13, 2007
00008  * Copyright (C) 2007, Univ. of Florida.  Author: Timothy A. Davis
00009  * See License.txt for the Version 2.1 of the GNU Lesser General Public License
00010  * http://www.cise.ufl.edu/research/sparse
00011  */
00012 
00013 /* use the UF_long version of CHOLMOD and KLU, where Int is UF_long ("long"
00014  * on all platforms except Windows, where it is int64 but where Paraklete has
00015  * not been ported) */
00016 
00017 /* Include file for user programs that call paraklete_* routines */
00018 
00019 #ifndef AMESOS_PARAKLETE_DECL_H
00020 #define AMESOS_PARAKLETE_DECL_H
00021 
00022 #ifndef DLONG
00023 #define DLONG
00024 #endif
00025 
00026 #include "amesos_cholmod.h"
00027 #include "amesos_cholmod_internal.h"
00028 #include "amesos_btf_decl.h"
00029 #include "amesos_klu_decl.h"
00030 
00031 #ifndef NMPI
00032 #include "mpi.h"
00033 #define MPI(statement) statement
00034 #else
00035 #define MPI(statement)
00036 #endif
00037 
00038 /* all integers are UF_long, or "long" on all but Windows */
00039 #define MPI_Int MPI_LONG
00040 
00041 /* use the long version of KLU and BTF */
00042 #define KLU_analyze amesos_klu_l_analyze
00043 #define KLU_factor amesos_klu_l_factor
00044 #define KLU_solve amesos_klu_l_solve
00045 #define KLU_symbolic klu_l_symbolic
00046 #define KLU_numeric klu_l_numeric
00047 #define KLU_common klu_l_common
00048 #define KLU_free_symbolic amesos_klu_l_free_symbolic
00049 #define KLU_free_numeric amesos_klu_l_free_numeric
00050 #define KLU_defaults amesos_klu_l_defaults
00051 
00052 #define BTF_order amesos_btf_l_order
00053 
00054 #define TAG0 0
00055 
00056 /* turn off debugging */
00057 #ifndef NDEBUG
00058 #define NDEBUG
00059 #endif
00060 
00061 /* To enable debugging, uncomment this line */
00062 /*
00063 #undef NDEBUG
00064 */
00065 
00066 /* ========================================================================== */
00067 /* === paraklete_common ===================================================== */
00068 /* ========================================================================== */
00069 
00070 /* Workspace (for each node) and global parameters */
00071 
00072 typedef struct paraklete_common_struct
00073 {
00074     double tol_diag ;       /* diagonal pivot tolerance (0 to 1)
00075                              * default 0.01 */
00076     double tol_offdiag ;    /* off-diagonal pivot tolerance (0 to 1),
00077                              * default 1.0 */
00078     double growth ;         /* memory reallocation factor, default 2.0 */
00079 
00080     Int status ;            /* PK_OK, PK_SINGULAR, etc, ... (see below) */
00081 
00082 /* the first two error codes match with CHOLMOD error codes: */
00083 #define PK_OK CHOLMOD_OK                        /* status is OK */
00084 #define PK_OUT_OF_MEMORY CHOLMOD_OUT_OF_MEMORY  /* out of memory */
00085 #define PK_TOO_LARGE CHOLMOD_TOO_LARGE          /* Int overflow occurred */
00086 #define PK_SINGULAR (-5)        /* singular */
00087 #define PK_UNKNOWN (-6)         /* not computed or not known */
00088 
00089     Int nproc ;             /* number of processors */
00090     Int myid ;              /* who am I? (in range 0 to nproc-1) */
00091 
00092     Int nleaves ;           /* number of leaves in separator tree.  Should
00093                              * be >= nprocs for parallelism.  Larger value is
00094                              * OK (can affect ordering quality, up or down).
00095                              * Default: nprocs */
00096 
00097     Int dump ;        /* debug print level, for debugging only */
00098     FILE *file ;      /* per-process output file, for debugging only */
00099 
00100     cholmod_common cm ;     /* CHOLMOD workspace for each node */
00101 
00102     KLU_common km ;         /* KLU common */
00103 }
00104 paraklete_common ;
00105 
00106 
00107 /* ========================================================================== */
00108 /* === paraklete_symbolic =================================================== */
00109 /* ========================================================================== */
00110 
00111 /* The LUsymbolic object consists of 3 malloc'd blocks: the LUsymbolic struct
00112  * itself, Mem_n of size 3*n, and Mem_c of size 7*ncomponents+2 */
00113 
00114 typedef struct paraklete_symbolic_struct
00115 {
00116     Int n ;   /* dimension of the matrix to factorize */
00117 
00118     Int ncomponents ; /* final number of components in the separator tree. */
00119     Int ncomp0 ;        /* initial (from cholmod_nested_dissection) */
00120     Int ncomp1 ;        /* after collapsing (from cholmod_collapse_septree) */
00121 
00122     /* ---------------------------------------------------------------------- */
00123     /* size-3n memory space, in Mem_n: */
00124     /* ---------------------------------------------------------------------- */
00125 
00126     Int *Mem_n ;  /* size 3*n (malloc'd block for Cperm, RpermInv,
00127        * Cparent */
00128 
00129     Int *Cperm ;  /* size n.  Symmetric nested-dissection fill-reducing
00130        * ordering of the original matrix.  Cperm [k] = i if
00131        * row/column i of the original matrix becomes row/
00132        * column k of the permuted matrix.  Does not take into
00133        * account numerical pivoting (as returned by
00134        * paraklete_analyze).
00135        * -----------------------------------------------------
00136        * paraklete_reanalyze combines the fill-reducing
00137        * ordering with column permutations arising from column
00138        * pivoting in paraklete_factorize, and stores this
00139        * as Cperm (a copy of LU->Q, from the numeric object).
00140        */
00141 
00142     Int *RpermInv ; /* size n.  The inverse of Rperm, or Cperm if Rperm is
00143        * NULL.  RpermInv [i] = k if Rperm [k] = i. */
00144 
00145     Int *Cparent ;  /* size n, but only entries 0 to ncomponents-1 used.
00146        * Cparent [c] is the parent of node c in the separator
00147        * tree, or EMPTY if c is a root. */
00148 
00149     /* ---------------------------------------------------------------------- */
00150     /* size-(7*ncomponents+2) memory space, in Mem_c: */
00151     /* ---------------------------------------------------------------------- */
00152 
00153     Int *Mem_c ;  /* size 7*ncomponents+2 (malloc'd block for Cstart,
00154        * Child, Childp, Clnz, Cn, Cnz, and Sched) */
00155 
00156     Int *Cstart ; /* size ncomponents+1.  Cstart[c] is the first candidate
00157        * pivot row/column in node c, in the matrix permuted
00158        * with Cperm.  Cstart [c+1]-1 is the last candidate
00159        * pivot row/column in node c. */
00160 
00161     Int *Child ;  /* size ncomponents. */
00162 
00163     Int *Childp ; /* size ncomponents+1.
00164        * Child [Childp [c] ... Childp [c+1]-1] are the
00165        * children of node c.
00166        */
00167 
00168     Int *Cn ;   /* size ncomponents.  Cn [c] is the total dimension of
00169              * node c, including the pivots (Cstart [c] to
00170        * Cstart [c+1]-1), and the sum of the number of pivots
00171        * of all ancestors of node c in the separator tree.  If
00172        * no pivots are lost during numerical factorization,
00173        * Cn [c] is the dimension of the LU factors of node c.
00174        */
00175 
00176     Int *Clnz ;   /* size ncomponents.  Clnz [c] is an estimate of the
00177        * number of nonzeros in the LU factors of node c,
00178        * assuming no numerical pivoting and assuming A+A' is
00179        * factorized. */
00180 
00181     Int *Cnz ;    /* size ncomponents.  Cnz [c] is the number of entries
00182        * in the original matrix A that start in node c. */
00183 
00184     Int *Sched ;  /* size ncomponents.  Sched [c] is the id of the process
00185        * that factorizes node c */
00186 
00187     /* ---------------------------------------------------------------------- */
00188     /* size-n memory space, allocated by itself */
00189     /* ---------------------------------------------------------------------- */
00190 
00191     Int *Rperm ;  /* size n if not NULL.  NULL for output of
00192        * paraklete_analyze (in which case Rperm and the
00193        * initial Cperm are identical).
00194        * -----------------------------------------------------
00195        * For paraklete_reanalyze, this is a copy of LU->P from
00196        * the LU numeric object from paraklete_factorize. */
00197 }
00198 paraklete_symbolic ;
00199 
00200 
00201 /* ========================================================================== */
00202 /* === paraklete_node ======================================================= */
00203 /* ========================================================================== */
00204 
00205 /* LU factorization and Schur complement for one node of the separator tree */
00206 
00207 /* Return pointers to the integer and real parts of column j of a matrix A
00208  * stored with merged row indices and numerical values.
00209  * Assumes sizeof(double) = 2*sizeof(Int).
00210  */
00211 
00212 #define GET_COLUMN(Ap,Anz,Aix,j,Ai,Ax,len) \
00213 { \
00214     Int getp = Ap [j] ; \
00215     len = Anz [j] ; \
00216     Ai = (Int *) (Aix + getp) ; \
00217     Ax = (double *) (Aix + getp + ((len + 1) / 2)) ; \
00218 }
00219 
00220 typedef struct paraklete_node_struct
00221 {
00222 
00223     /* ---------------------------------------------------------------------- */
00224     /* header information */
00225     /* ---------------------------------------------------------------------- */
00226 
00227     /* The header is sent in a single message, from child to parent */
00228 
00229 #define PK_HEADER 8   /* size of header */
00230 
00231     Int header [PK_HEADER] ;  /* contents defined below: */
00232 
00233 #define PK_STATUS header[0] /* status (see Common->status above) */
00234 
00235 #define PK_SN header[1]   /* dimension of the Schur complement */
00236 
00237 #define PK_SNZ header[2]  /* number of nonzeros in S */
00238 
00239 #define PK_NFOUND header[3] /* number of pivots found for this node. */
00240 
00241 #define PK_NLOST header[4]  /* # pivots lost, equal to npiv - nfound */
00242 
00243 #define PK_NN header[5]   /* dimension of the LU factors of this node. */
00244         /* Equal to Cn [c] c if no pivots fail. 
00245          * Failed pivot candidates of the children are
00246          * added to Cn [c] to obtain nn.  */
00247 
00248 #define PK_NPIV header[6] /* number of candidate pivots for this node. */
00249         /* Equal to Cstart [c+1] - Cstart [c] if no
00250          * pivots fail. Failed pivots from the
00251          * children are added to obtain npiv. */
00252 
00253 #define PK_SSIZE header[7]  /* size of the sx array */
00254 
00255     /* ---------------------------------------------------------------------- */
00256     /* local copy of the matrix to factorize for just this node */
00257     /* ---------------------------------------------------------------------- */
00258 
00259     cholmod_sparse *A ; /* dimension Cn [c] */
00260     cholmod_sparse *C ; /* dimension nn, = A + Schur complements of children */
00261 
00262     /* ---------------------------------------------------------------------- */
00263     /* LU factors */
00264     /* ---------------------------------------------------------------------- */
00265 
00266     Int lnz ;   /* number of nonzeros in L */
00267 
00268     Int unz ;   /* number of nonzeros in U */
00269 
00270     Int nlost_in ;  /* sum of # of pivots lost in children */
00271 
00272     Int *llen ;   /* size npiv.  llen [j] is the number of entries in
00273        * column j of L. */
00274 
00275     Int *ulen ;   /* size npiv.  ulen [j] is the number of entries in
00276        * column j of U */
00277 
00278     Int *lp ;   /* size nn. lp [j] is the start of column j of L in the
00279        * ix array. */
00280 
00281     Int *up ;   /* size nn.  up [j] is the start of column j of U in the
00282        * ix array */
00283 
00284     Int *Plocal ; /* size npiv. Plocal [k] = i if local row i is the kth
00285        * row of the LU factors for this node.  Both k and i
00286        * are in the range 0 to npiv-1 */
00287 
00288     Int *Qlocal ; /* size npiv.
00289        * Qlocal [k] = j if local col j is the kth col of the
00290        * LU factors for this node. */
00291 
00292     Int *Pglobal ;  /* size npiv. Pglobal [k] = i if local row i is the kth
00293        * row of the LU factors of A(Cperm,Cperm).
00294        * k is in the range 0 to npiv-1,
00295        * i is in the range 0 to (LU->n)-1 */
00296 
00297     Int *Qglobal ;  /* size npiv. Qglobal [k] = j if local col j is the kth
00298        * col of the LU factors of A(Cperm,Cperm).
00299        * k is in the range 0 to npiv-1,
00300        * j is in the range 0 to (LU->n)-1 */
00301 
00302     Int *Pinv ;   /* size npiv.  The inverse of Plocal.
00303        * Pinv [i] = k if local row i is the kth row of the
00304        * LU factors for this node. */
00305 
00306     Int *Qinv ;   /* size npiv.  The inverse of Qlocal.
00307        * Qinv [j] = k if local col j is the kth col of the
00308        * LU factors for this node. */
00309 
00310     Int lusize ;  /* size of ix array */
00311 
00312     double *ix ;  /* indices and numerical values of the LU factors */
00313 
00314     Int *Lost ;   /* size nchild */
00315     Int *Lostp ;  /* size nchild+1 */
00316     Int nchild ;
00317 
00318     /* To traverse column j of L:
00319      *
00320      *      GET_COLUMN (LUnode->lp, LUnode->llen, LUnode->ix, Li, Lx, len) ;
00321      *      for (p = 0 ; p < len ; p++)
00322      *      {
00323      *    i = Li [p] ;
00324      *    lij = Lx [p] ;
00325      *      }
00326      *
00327      * To traverse column j of U:
00328      *
00329      *      GET_COLUMN (LUnode->up, LUnode->ulen, LUnode->ix, Ui, Ux, len) ;
00330      *      for (p = 0 ; p < len ; p++)
00331      *      {
00332      *    i = Ui [p] ;
00333      *    uij = Ux [p] ;
00334      *      }
00335      */
00336 
00337     Int nrealloc ;
00338     Int noffdiag ;
00339     double umin ;
00340     double umax ;
00341 
00342     /* ---------------------------------------------------------------------- */
00343     /* Schur complement */
00344     /* ---------------------------------------------------------------------- */
00345 
00346     /* The Schur complement has dimension sn = nn-nfound */
00347 
00348     double *sx ;  /* indices and numerical values of Schur complmement */
00349     Int *sp ;   /* size sn.  sp [j] is the start of column j in sx */
00350     Int *slen ;   /* size sn.  sp [j] is the start of column j in sx */
00351 
00352     /* ---------------------------------------------------------------------- */
00353     /* solution to Ly=Pb and Ux=y */
00354     /* ---------------------------------------------------------------------- */
00355 
00356     Int nk ;    /* Cstart [c+1] - Cstart [c], nominal pivots at node */
00357     double *B ;   /* size nk = Cstart [c+1] - Cstart [c] */
00358     double *X ;   /* size nn */
00359 
00360     /* ---------------------------------------------------------------------- */
00361     /* MPI message handling */
00362     /* ---------------------------------------------------------------------- */
00363 
00364     MPI (MPI_Request req ; )
00365     MPI (MPI_Request *Req ; ) /* size nchild */
00366 
00367     /* workspace at this node */
00368     Int *W2 ;     /* size 2*nlost_in */
00369 
00370 } paraklete_node ;
00371 
00372 
00373 /* ========================================================================== */
00374 /* === paraklete_numeric ==================================================== */
00375 /* ========================================================================== */
00376 
00377 /* All nodes share this data structure.  LUnode [0..ncomponents] is an array
00378  * of the LU factorization of each node, and status information about that node.
00379  * If a process owns node c, it uses LUnode [c] to hold permanent parts of the
00380  * global LU factors.  If it does not own node c, it uses LUnode [c] to hold
00381  * information about a child or parent in the separator tree (such as the
00382  * Schur complement from a child node owned by another process.
00383  *
00384  * Some information is shared globally: n, ncomponents, and the global
00385  * permutation (P, Q, Pinv, Qinv).   This structure also contains workspace
00386  * held by process 0 only (W, Ep2, and E).
00387  */
00388 
00389 #define PARAKLETE_MAGIC (-42)
00390 
00391 typedef struct paraklete_numeric_struct
00392 {
00393     Int magic ;     /* always equal to PARAKLETE_MAGIC, and less than zero */
00394     Int n ;
00395     Int ncomponents ;
00396 
00397     Int *P ;      /* size n. row permutation */
00398     Int *Q ;      /* size n. column permutation.  Both P and Q include
00399          * LUsymbolic->Cperm, so that L*U=P*A*Q is the final
00400          * factorization. */
00401 
00402     Int *Pinv ;
00403     Int *Qinv ;
00404 
00405     paraklete_node **LUnode ;     /* size ncomponents.  LUnode [c] is a
00406              * pointer to the LU factorization of
00407              * node c. */
00408 
00409     /* workspace for process 0 only */
00410     double *W ;   /* size n */
00411     Int *Ep2 ;    /* size n+1 */
00412     cholmod_sparse *E ; /* n-by-n, E = A (Cperm, Cperm) */
00413 
00414 } paraklete_numeric ;
00415 
00416 /* ========================================================================== */
00417 /* === paraklete_btf_symbolic =============================================== */
00418 /* ========================================================================== */
00419 
00420 typedef struct paraklete_btf_symbolic_struct
00421 {
00422     Int n ;   /* dimension of A */
00423     Int nblocks ; /* number of diagonal blocks in BTF form */
00424     Int cnz ;   /* # of entries in diagonal blocks of A(p,q) */
00425     Int fnz ;   /* # of entries in off-diagonal blocks of A(p,q) */
00426     Int *Mem_n ;  /* contains Qbtf, Pbinv, and Rbtf */
00427     /* Int *Pbtf ; */ /* BTF row permutation, size n */
00428     Int *Qbtf ;   /* BTF column permutation, size n */
00429     Int *Pbinv ;  /* inverse of Pbtf, size n */
00430     Int *Rbtf ;   /* BTF block boundaries, size n+1 (0..nblocks used) */
00431 
00432     /* symbolic analysis of each diagaonal block (NULL for singletons) */
00433     void **LUsymbolic ; /* array of pointers, size n */
00434       /* only first nblocks entries used */
00435 }
00436 paraklete_btf_symbolic ;
00437 
00438 /* ========================================================================== */
00439 /* === paraklete_btf_numeric ================================================ */
00440 /* ========================================================================== */
00441 
00442 typedef struct paraklete_btf_numeric_struct
00443 {
00444     Int nblocks ;     /* number of diagonal blocks in BTF form */
00445     double *Singleton ;     /* singleton values, size nblocks */
00446 
00447     cholmod_sparse *F ;     /* off-diagonal entries, size n-by-n */
00448 
00449     /* symbolic analysis of each diagaonal block (NULL for singletons) */
00450     void **LUnumeric ;      /* array of pointers, size nblocks */
00451 }
00452 paraklete_btf_numeric ;
00453 
00454 /* ========================================================================== */
00455 
00456 paraklete_btf_symbolic *amesos_paraklete_btf_analyze
00457 (
00458     cholmod_sparse *A,
00459     paraklete_common *Common
00460 ) ;
00461 
00462 paraklete_btf_numeric *amesos_paraklete_btf_factorize
00463 (
00464     cholmod_sparse *A,
00465     paraklete_btf_symbolic *LU_btf_symbolic,
00466     paraklete_common *Common
00467 ) ;
00468 
00469 Int amesos_paraklete_btf_solve
00470 (
00471     paraklete_btf_numeric *LU_btf_numeric,
00472     paraklete_btf_symbolic *LU_btf_symbolic,
00473     double *B,
00474     paraklete_common *Common
00475 ) ;
00476 
00477 void amesos_paraklete_btf_free_symbolic
00478 (
00479     paraklete_btf_symbolic **LU_btf_symbolic_handle,
00480     paraklete_common *Common
00481 ) ;
00482 
00483 void amesos_paraklete_btf_free_numeric
00484 (
00485     paraklete_btf_numeric **LU_btf_numeric_handle,
00486     paraklete_common *Common
00487 ) ;
00488 
00489 paraklete_btf_symbolic *amesos_paraklete_btf_alloc_symbolic
00490 (
00491     Int n,
00492     Int nblocks,
00493     paraklete_common *Common
00494 ) ;
00495 
00496 /* ========================================================================== */
00497 
00498 paraklete_symbolic *amesos_paraklete_analyze
00499 (
00500     cholmod_sparse *A,
00501     paraklete_common *Common
00502 ) ;
00503 
00504 paraklete_numeric *amesos_paraklete_factorize
00505 (
00506     cholmod_sparse *A,
00507     paraklete_symbolic *LUsymbolic,
00508     paraklete_common *Common
00509 ) ;
00510 
00511 Int amesos_paraklete_kernel
00512 (
00513     cholmod_sparse *A,
00514     paraklete_node *LUnode,
00515     paraklete_common *Common
00516 ) ;
00517 
00518 Int amesos_paraklete_factorize_node
00519 (
00520     Int c,
00521     paraklete_numeric *LU,
00522     paraklete_symbolic *LUsymbolic,
00523     paraklete_common *Common
00524 ) ;
00525 
00526 Int amesos_paraklete_solve
00527 (
00528     paraklete_numeric *LU,
00529     paraklete_symbolic *LUsymbolic,
00530     double *B,
00531     paraklete_common *Common
00532 ) ;
00533 
00534 Int amesos_paraklete_lsolve_node
00535 (
00536     Int c,
00537     paraklete_numeric *LU,
00538     paraklete_symbolic *LUsymbolic,
00539     paraklete_common *Common
00540 ) ;
00541 
00542 Int amesos_paraklete_usolve_node
00543 (
00544     Int c,
00545     paraklete_numeric *LU,
00546     paraklete_symbolic *LUsymbolic,
00547     paraklete_common *Common
00548 ) ;
00549 
00550 paraklete_symbolic *amesos_paraklete_alloc_symbolic
00551 (
00552     Int n,
00553     Int ncomponents,
00554     Int do_Rperm,
00555     paraklete_common *Common
00556 ) ;
00557 
00558 void amesos_paraklete_free_symbolic
00559 (
00560     paraklete_symbolic **LUsymbolicHandle,
00561     paraklete_common *Common
00562 ) ;
00563 
00564 void amesos_paraklete_free_numeric
00565 (
00566     paraklete_numeric **LUHandle,
00567     paraklete_common *Common
00568 ) ;
00569 
00570 paraklete_symbolic *amesos_paraklete_reanalyze
00571 (
00572     cholmod_sparse *A,
00573     paraklete_numeric *LU,
00574     paraklete_symbolic *LUsymbolic,
00575     paraklete_common *Common
00576 ) ;
00577 
00578 void amesos_paraklete_start (Int nproc, Int myid, paraklete_common *Common) ;
00579 void amesos_paraklete_finish (paraklete_common *Common) ;
00580 
00581 #define PARAKLETE_ERROR(status,message) \
00582     amesos_paraklete_error (status, __FILE__, __LINE__, message, Common) ;
00583 
00584 void amesos_paraklete_error (Int status, char *filename, Int line, char *message,
00585     paraklete_common *Common) ;
00586 
00587 /* ========================================================================== */
00588 /* === Paraklete version ==================================================== */
00589 /* ========================================================================== */
00590 
00591 #define PARAKLETE_DATE "Nov 27, 2007"
00592 #define PARAKLETE_VERSION_CODE(main,sub) ((main) * 1000 + (sub))
00593 #define PARAKLETE_MAIN_VERSION 0
00594 #define PARAKLETE_SUB_VERSION 3
00595 #define PARAKLETE_VERSION \
00596     PARAKLETE_VERSION_CODE(PARAKLETE_MAIN_VERSION,PARAKLETE_SUB_VERSION)
00597 
00598 /* ========================================================================== */
00599 /* === debugging definitions ================================================ */
00600 /* ========================================================================== */
00601 
00602 #undef DEBUG
00603 #undef ASSERT
00604 #undef PR0
00605 #undef PR1
00606 #undef PR2
00607 #undef PR3
00608 
00609 extern Int my_tries ;
00610 
00611 #ifndef NDEBUG
00612 
00613 #include <assert.h>
00614 #define PR0(params) { (void) fprintf params ; fflush (Common->file) ; }
00615 #define PR1(params) { if (Common->dump >= 1) (void) fprintf params ; fflush (Common->file) ; }
00616 #define PR2(params) { if (Common->dump >= 2) (void) fprintf params ; fflush (Common->file) ; }
00617 #define PR3(params) { if (Common->dump >= 3) (void) fprintf params ; fflush (Common->file) ; }
00618 #define DEBUG(statement) statement
00619 #define ASSERT(expression) (assert (expression))
00620 
00621 #else
00622 
00623 #define PR0(params)
00624 #define PR1(params)
00625 #define PR2(params)
00626 #define PR3(params)
00627 #define DEBUG(statement)
00628 #define ASSERT(expression)
00629 
00630 #endif
00631 
00632 #endif /* AMESOS_PARAKLETE_DECL_H */
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines