| Line | Branch | Exec | Source |
|---|---|---|---|
| 1 | /* | ||
| 2 | - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | ||
| 3 | SLEPc - Scalable Library for Eigenvalue Problem Computations | ||
| 4 | Copyright (c) 2002-, Universitat Politecnica de Valencia, Spain | ||
| 5 | |||
| 6 | This file is part of SLEPc. | ||
| 7 | SLEPc is distributed under a 2-clause BSD license (see LICENSE). | ||
| 8 | - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | ||
| 9 | */ | ||
| 10 | |||
| 11 | #pragma once | ||
| 12 | |||
| 13 | #include <slepcbv.h> | ||
| 14 | #include <slepc/private/slepcimpl.h> | ||
| 15 | |||
| 16 | /* SUBMANSEC = BV */ | ||
| 17 | |||
| 18 | SLEPC_EXTERN PetscBool BVRegisterAllCalled; | ||
| 19 | SLEPC_EXTERN PetscErrorCode BVRegisterAll(void); | ||
| 20 | |||
| 21 | SLEPC_EXTERN PetscLogEvent BV_Create,BV_Copy,BV_Mult,BV_MultVec,BV_MultInPlace,BV_Dot,BV_DotVec,BV_Orthogonalize,BV_OrthogonalizeVec,BV_Scale,BV_Norm,BV_NormVec,BV_Normalize,BV_SetRandom,BV_MatMult,BV_MatMultVec,BV_MatProject,BV_SVDAndRank; | ||
| 22 | |||
| 23 | typedef struct _BVOps *BVOps; | ||
| 24 | |||
| 25 | struct _BVOps { | ||
| 26 | PetscErrorCode (*mult)(BV,PetscScalar,PetscScalar,BV,Mat); | ||
| 27 | PetscErrorCode (*multvec)(BV,PetscScalar,PetscScalar,Vec,PetscScalar*); | ||
| 28 | PetscErrorCode (*multinplace)(BV,Mat,PetscInt,PetscInt); | ||
| 29 | PetscErrorCode (*multinplacetrans)(BV,Mat,PetscInt,PetscInt); | ||
| 30 | PetscErrorCode (*dot)(BV,BV,Mat); | ||
| 31 | PetscErrorCode (*dotvec)(BV,Vec,PetscScalar*); | ||
| 32 | PetscErrorCode (*dotvec_local)(BV,Vec,PetscScalar*); | ||
| 33 | PetscErrorCode (*dotvec_begin)(BV,Vec,PetscScalar*); | ||
| 34 | PetscErrorCode (*dotvec_end)(BV,Vec,PetscScalar*); | ||
| 35 | PetscErrorCode (*scale)(BV,PetscInt,PetscScalar); | ||
| 36 | PetscErrorCode (*norm)(BV,PetscInt,NormType,PetscReal*); | ||
| 37 | PetscErrorCode (*norm_local)(BV,PetscInt,NormType,PetscReal*); | ||
| 38 | PetscErrorCode (*norm_begin)(BV,PetscInt,NormType,PetscReal*); | ||
| 39 | PetscErrorCode (*norm_end)(BV,PetscInt,NormType,PetscReal*); | ||
| 40 | PetscErrorCode (*normalize)(BV,PetscScalar*); | ||
| 41 | PetscErrorCode (*matmult)(BV,Mat,BV); | ||
| 42 | PetscErrorCode (*copy)(BV,BV); | ||
| 43 | PetscErrorCode (*copycolumn)(BV,PetscInt,PetscInt); | ||
| 44 | PetscErrorCode (*resize)(BV,PetscInt,PetscBool); | ||
| 45 | PetscErrorCode (*getcolumn)(BV,PetscInt,Vec*); | ||
| 46 | PetscErrorCode (*restorecolumn)(BV,PetscInt,Vec*); | ||
| 47 | PetscErrorCode (*getarray)(BV,PetscScalar**); | ||
| 48 | PetscErrorCode (*restorearray)(BV,PetscScalar**); | ||
| 49 | PetscErrorCode (*getarrayread)(BV,const PetscScalar**); | ||
| 50 | PetscErrorCode (*restorearrayread)(BV,const PetscScalar**); | ||
| 51 | PetscErrorCode (*restoresplit)(BV,BV*,BV*); | ||
| 52 | PetscErrorCode (*restoresplitrows)(BV,IS,IS,BV*,BV*); | ||
| 53 | PetscErrorCode (*gramschmidt)(BV,PetscInt,Vec,PetscBool*,PetscScalar*,PetscScalar*,PetscReal*,PetscReal*); | ||
| 54 | PetscErrorCode (*getmat)(BV,Mat*); | ||
| 55 | PetscErrorCode (*restoremat)(BV,Mat*); | ||
| 56 | PetscErrorCode (*duplicate)(BV,BV); | ||
| 57 | PetscErrorCode (*create)(BV); | ||
| 58 | PetscErrorCode (*setfromoptions)(BV,PetscOptionItems); | ||
| 59 | PetscErrorCode (*view)(BV,PetscViewer); | ||
| 60 | PetscErrorCode (*destroy)(BV); | ||
| 61 | }; | ||
| 62 | |||
| 63 | struct _p_BV { | ||
| 64 | PETSCHEADER(struct _BVOps); | ||
| 65 | /*------------------------- User parameters --------------------------*/ | ||
| 66 | PetscLayout map; /* layout of columns */ | ||
| 67 | VecType vtype; /* vector type */ | ||
| 68 | PetscInt n,N; /* dimensions of vectors (local, global) */ | ||
| 69 | PetscInt m; /* number of vectors */ | ||
| 70 | PetscInt l; /* number of leading columns */ | ||
| 71 | PetscInt k; /* number of active columns */ | ||
| 72 | PetscInt nc; /* number of constraints */ | ||
| 73 | PetscInt ld; /* leading dimension */ | ||
| 74 | BVOrthogType orthog_type; /* the method of vector orthogonalization */ | ||
| 75 | BVOrthogRefineType orthog_ref; /* refinement method */ | ||
| 76 | PetscReal orthog_eta; /* refinement threshold */ | ||
| 77 | BVOrthogBlockType orthog_block; /* the method of block orthogonalization */ | ||
| 78 | Mat matrix; /* inner product matrix */ | ||
| 79 | PetscBool indef; /* matrix is indefinite */ | ||
| 80 | BVMatMultType vmm; /* version of matmult operation */ | ||
| 81 | PetscBool rrandom; /* reproducible random vectors */ | ||
| 82 | PetscReal deftol; /* tolerance for BV_SafeSqrt */ | ||
| 83 | |||
| 84 | /*---------------------- Cached data and workspace -------------------*/ | ||
| 85 | Vec buffer; /* buffer vector used in orthogonalization */ | ||
| 86 | Mat Abuffer; /* auxiliary seqdense matrix that wraps the buffer */ | ||
| 87 | Vec Bx; /* result of matrix times a vector x */ | ||
| 88 | PetscObjectId xid; /* object id of vector x */ | ||
| 89 | PetscObjectState xstate; /* state of vector x */ | ||
| 90 | Vec cv[2]; /* column vectors obtained with BVGetColumn() */ | ||
| 91 | PetscInt ci[2]; /* column indices of obtained vectors */ | ||
| 92 | PetscObjectState st[2]; /* state of obtained vectors */ | ||
| 93 | PetscObjectId id[2]; /* object id of obtained vectors */ | ||
| 94 | PetscScalar *h,*c; /* orthogonalization coefficients */ | ||
| 95 | Vec omega; /* signature matrix values for indefinite case */ | ||
| 96 | PetscBool defersfo; /* deferred call to setfromoptions */ | ||
| 97 | BV cached; /* cached BV to store result of matrix times BV */ | ||
| 98 | PetscObjectState bvstate; /* state of BV when BVApplyMatrixBV() was called */ | ||
| 99 | BV L,R; /* BV objects obtained with BVGetSplit/Rows() */ | ||
| 100 | PetscObjectState lstate,rstate;/* state of L and R when BVGetSplit/Rows() was called */ | ||
| 101 | PetscInt lsplit; /* value of l when BVGetSplit() was called (-1 if BVGetSplitRows()) */ | ||
| 102 | PetscInt issplit; /* !=0 if BV is from split (1=left, 2=right, -1=top, -2=bottom) */ | ||
| 103 | BV splitparent; /* my parent if I am a split BV */ | ||
| 104 | PetscRandom rand; /* random number generator */ | ||
| 105 | Mat Acreate; /* matrix given at BVCreateFromMat() */ | ||
| 106 | Mat Aget; /* matrix returned for BVGetMat() */ | ||
| 107 | PetscBool cuda; /* true if NVIDIA GPU must be used */ | ||
| 108 | PetscBool hip; /* true if AMD GPU must be used */ | ||
| 109 | PetscBool sfocalled; /* setfromoptions has been called */ | ||
| 110 | PetscScalar *work; | ||
| 111 | PetscInt lwork; | ||
| 112 | void *data; | ||
| 113 | }; | ||
| 114 | |||
| 115 | /* | ||
| 116 | BV_SafeSqrt - Computes the square root of a scalar value alpha, which is | ||
| 117 | assumed to be z'*B*z. The result is | ||
| 118 | if definite inner product: res = sqrt(alpha) | ||
| 119 | if indefinite inner product: res = sgn(alpha)*sqrt(abs(alpha)) | ||
| 120 | */ | ||
| 121 | 3160457 | static inline PetscErrorCode BV_SafeSqrt(BV bv,PetscScalar alpha,PetscReal *res) | |
| 122 | { | ||
| 123 | 3160457 | PetscReal absal,realp; | |
| 124 | 3160457 | const char *msg; | |
| 125 | |||
| 126 |
1/2✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
|
3160457 | PetscFunctionBegin; |
| 127 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
|
3160457 | absal = PetscAbsScalar(alpha); |
| 128 | 3160457 | realp = PetscRealPart(alpha); | |
| 129 |
6/8✓ Branch 0 taken 22 times.
✓ Branch 1 taken 32 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 18 times.
✓ Branch 4 taken 4 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 4 times.
|
3160457 | if (PetscUnlikely(absal<PETSC_MACHINE_EPSILON)) PetscCall(PetscInfo(bv,"Zero norm %g, either the vector is zero or a semi-inner product is being used\n",(double)absal)); |
| 130 | #if defined(PETSC_USE_COMPLEX) | ||
| 131 |
3/6✓ Branch 0 taken 11 times.
✓ Branch 1 taken 16 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 11 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
1392103 | PetscCheck(PetscAbsReal(PetscImaginaryPart(alpha))<bv->deftol || PetscAbsReal(PetscImaginaryPart(alpha))/absal<10*bv->deftol,PetscObjectComm((PetscObject)bv),PETSC_ERR_USER_INPUT,"The inner product is not well defined: nonzero imaginary part %g",(double)PetscImaginaryPart(alpha)); |
| 132 | #endif | ||
| 133 |
2/2✓ Branch 0 taken 32 times.
✓ Branch 1 taken 22 times.
|
3160457 | if (PetscUnlikely(bv->indef)) { |
| 134 |
2/2✓ Branch 0 taken 32 times.
✓ Branch 1 taken 32 times.
|
300497 | *res = (realp<0.0)? -PetscSqrtReal(-realp): PetscSqrtReal(realp); |
| 135 | } else { | ||
| 136 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 22 times.
|
2859960 | msg = bv->matrix? "The inner product is not well defined: indefinite matrix %g": "Invalid inner product: %g"; |
| 137 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
2859960 | PetscCheck(realp>-bv->deftol,PetscObjectComm((PetscObject)bv),PETSC_ERR_USER_INPUT,msg,(double)realp); |
| 138 |
1/2✓ Branch 0 taken 22 times.
✗ Branch 1 not taken.
|
2859960 | *res = (realp<0.0)? 0.0: PetscSqrtReal(realp); |
| 139 | } | ||
| 140 |
6/12✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6 times.
✓ Branch 4 taken 6 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 6 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 6 times.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✓ Branch 11 taken 6 times.
|
627426 | PetscFunctionReturn(PETSC_SUCCESS); |
| 141 | } | ||
| 142 | |||
| 143 | /* | ||
| 144 | BV_IPMatMult - Multiply a vector x by the inner-product matrix, cache the | ||
| 145 | result in Bx. | ||
| 146 | */ | ||
| 147 | 876932 | static inline PetscErrorCode BV_IPMatMult(BV bv,Vec x) | |
| 148 | { | ||
| 149 |
1/2✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
|
876932 | PetscFunctionBegin; |
| 150 |
4/4✓ Branch 0 taken 74 times.
✓ Branch 1 taken 74 times.
✓ Branch 2 taken 74 times.
✓ Branch 3 taken 40 times.
|
876932 | if (((PetscObject)x)->id != bv->xid || ((PetscObject)x)->state != bv->xstate) { |
| 151 |
6/8✓ Branch 0 taken 54 times.
✓ Branch 1 taken 74 times.
✓ Branch 2 taken 10 times.
✓ Branch 3 taken 44 times.
✓ Branch 4 taken 10 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 10 times.
|
810248 | if (PetscUnlikely(!bv->Bx)) PetscCall(MatCreateVecs(bv->matrix,&bv->Bx,NULL)); |
| 152 |
4/6✓ Branch 0 taken 14 times.
✓ Branch 1 taken 60 times.
✓ Branch 2 taken 14 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 14 times.
|
810248 | PetscCall(MatMult(bv->matrix,x,bv->Bx)); |
| 153 |
4/6✓ Branch 0 taken 14 times.
✓ Branch 1 taken 60 times.
✓ Branch 2 taken 14 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 14 times.
|
810248 | PetscCall(PetscObjectGetId((PetscObject)x,&bv->xid)); |
| 154 |
4/6✓ Branch 0 taken 18 times.
✓ Branch 1 taken 56 times.
✓ Branch 2 taken 14 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 14 times.
|
810248 | PetscCall(VecGetState(x,&bv->xstate)); |
| 155 | } | ||
| 156 |
6/12✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 14 times.
✓ Branch 4 taken 14 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 14 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 14 times.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✓ Branch 11 taken 14 times.
|
181483 | PetscFunctionReturn(PETSC_SUCCESS); |
| 157 | } | ||
| 158 | |||
| 159 | /* | ||
| 160 | BV_IPMatMultBV - Multiply BV by the inner-product matrix, cache the | ||
| 161 | result internally in bv->cached. | ||
| 162 | */ | ||
| 163 | 3579 | static inline PetscErrorCode BV_IPMatMultBV(BV bv) | |
| 164 | { | ||
| 165 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
3579 | PetscFunctionBegin; |
| 166 |
4/6✓ Branch 0 taken 2 times.
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 2 times.
|
3579 | PetscCall(BVGetCachedBV(bv,&bv->cached)); |
| 167 |
3/6✓ Branch 0 taken 10 times.
✓ Branch 1 taken 10 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 10 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
3579 | if (((PetscObject)bv)->state != bv->bvstate || bv->l != bv->cached->l || bv->k != bv->cached->k) { |
| 168 |
4/6✓ Branch 0 taken 2 times.
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 2 times.
|
3579 | PetscCall(BVSetActiveColumns(bv->cached,bv->l,bv->k)); |
| 169 |
5/8✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 8 times.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 2 times.
|
3579 | if (bv->matrix) PetscCall(BVMatMult(bv,bv->matrix,bv->cached)); |
| 170 | ✗ | else PetscCall(BVCopy(bv,bv->cached)); | |
| 171 | 3579 | bv->bvstate = ((PetscObject)bv)->state; | |
| 172 | } | ||
| 173 |
6/12✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 2 times.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✓ Branch 11 taken 2 times.
|
605 | PetscFunctionReturn(PETSC_SUCCESS); |
| 174 | } | ||
| 175 | |||
| 176 | /* | ||
| 177 | BV_AllocateCoeffs - Allocate orthogonalization coefficients if not done already. | ||
| 178 | */ | ||
| 179 | 462558 | static inline PetscErrorCode BV_AllocateCoeffs(BV bv) | |
| 180 | { | ||
| 181 |
1/2✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
|
462558 | PetscFunctionBegin; |
| 182 |
6/8✓ Branch 0 taken 30 times.
✓ Branch 1 taken 20 times.
✓ Branch 2 taken 6 times.
✓ Branch 3 taken 24 times.
✓ Branch 4 taken 6 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 6 times.
|
462558 | if (!bv->h) PetscCall(PetscMalloc2(bv->nc+bv->m,&bv->h,bv->nc+bv->m,&bv->c)); |
| 183 |
6/12✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6 times.
✓ Branch 4 taken 6 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 6 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 6 times.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✓ Branch 11 taken 6 times.
|
91089 | PetscFunctionReturn(PETSC_SUCCESS); |
| 184 | } | ||
| 185 | |||
| 186 | /* | ||
| 187 | BV_AllocateSignature - Allocate signature coefficients if not done already. | ||
| 188 | */ | ||
| 189 | 2597037 | static inline PetscErrorCode BV_AllocateSignature(BV bv) | |
| 190 | { | ||
| 191 |
1/2✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
|
2597037 | PetscFunctionBegin; |
| 192 |
4/4✓ Branch 0 taken 30 times.
✓ Branch 1 taken 16 times.
✓ Branch 2 taken 30 times.
✓ Branch 3 taken 20 times.
|
2597037 | if (bv->indef && !bv->omega) { |
| 193 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 30 times.
|
874 | if (bv->cuda) { |
| 194 | #if defined(PETSC_HAVE_CUDA) | ||
| 195 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
18 | PetscCall(VecCreateSeqCUDA(PETSC_COMM_SELF,bv->nc+bv->m,&bv->omega)); |
| 196 | #else | ||
| 197 | ✗ | SETERRQ(PetscObjectComm((PetscObject)bv),PETSC_ERR_PLIB,"Something wrong happened"); | |
| 198 | #endif | ||
| 199 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 30 times.
|
856 | } else if (bv->hip) { |
| 200 | #if defined(PETSC_HAVE_HIP) | ||
| 201 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
18 | PetscCall(VecCreateSeqHIP(PETSC_COMM_SELF,bv->nc+bv->m,&bv->omega)); |
| 202 | #else | ||
| 203 | ✗ | SETERRQ(PetscObjectComm((PetscObject)bv),PETSC_ERR_PLIB,"Something wrong happened"); | |
| 204 | #endif | ||
| 205 |
4/6✓ Branch 0 taken 6 times.
✓ Branch 1 taken 24 times.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 6 times.
|
838 | } else PetscCall(VecCreateSeq(PETSC_COMM_SELF,bv->nc+bv->m,&bv->omega)); |
| 206 |
4/6✓ Branch 0 taken 6 times.
✓ Branch 1 taken 24 times.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 6 times.
|
874 | PetscCall(VecSet(bv->omega,1.0)); |
| 207 | } | ||
| 208 |
6/12✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6 times.
✓ Branch 4 taken 6 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 6 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 6 times.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✓ Branch 11 taken 6 times.
|
509061 | PetscFunctionReturn(PETSC_SUCCESS); |
| 209 | } | ||
| 210 | |||
| 211 | /* | ||
| 212 | BV_SetMatrixDiagonal - sets the inner product matrix for BV as a diagonal matrix | ||
| 213 | with the diagonal specified by vector vomega, using the same matrix type as matrix M | ||
| 214 | */ | ||
| 215 | 233 | static inline PetscErrorCode BV_SetMatrixDiagonal(BV bv,Vec vomega,Mat M) | |
| 216 | { | ||
| 217 | 233 | Mat Omega; | |
| 218 | 233 | MatType Mtype; | |
| 219 | |||
| 220 |
1/2✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
|
233 | PetscFunctionBegin; |
| 221 |
4/6✓ Branch 0 taken 6 times.
✓ Branch 1 taken 24 times.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 6 times.
|
233 | PetscCall(MatGetType(M,&Mtype)); |
| 222 |
4/6✓ Branch 0 taken 6 times.
✓ Branch 1 taken 24 times.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 6 times.
|
233 | PetscCall(MatCreate(PetscObjectComm((PetscObject)bv),&Omega)); |
| 223 |
4/6✓ Branch 0 taken 6 times.
✓ Branch 1 taken 24 times.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 6 times.
|
233 | PetscCall(MatSetSizes(Omega,bv->n,bv->n,bv->N,bv->N)); |
| 224 |
4/6✓ Branch 0 taken 6 times.
✓ Branch 1 taken 24 times.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 6 times.
|
233 | PetscCall(MatSetType(Omega,Mtype)); |
| 225 |
4/6✓ Branch 0 taken 6 times.
✓ Branch 1 taken 24 times.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 6 times.
|
233 | PetscCall(MatDiagonalSet(Omega,vomega,INSERT_VALUES)); |
| 226 |
4/6✓ Branch 0 taken 6 times.
✓ Branch 1 taken 24 times.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 6 times.
|
233 | PetscCall(BVSetMatrix(bv,Omega,PETSC_TRUE)); |
| 227 |
4/6✓ Branch 0 taken 6 times.
✓ Branch 1 taken 24 times.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 6 times.
|
233 | PetscCall(MatDestroy(&Omega)); |
| 228 |
6/12✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6 times.
✓ Branch 4 taken 6 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 6 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 6 times.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✓ Branch 11 taken 6 times.
|
57 | PetscFunctionReturn(PETSC_SUCCESS); |
| 229 | } | ||
| 230 | |||
| 231 | /* | ||
| 232 | BVAvailableVec: First (0) or second (1) vector available for | ||
| 233 | getcolumn operation (or -1 if both vectors already fetched). | ||
| 234 | */ | ||
| 235 | #define BVAvailableVec (((bv->ci[0]==-bv->nc-1)? 0: (bv->ci[1]==-bv->nc-1)? 1: -1)) | ||
| 236 | |||
| 237 | /* | ||
| 238 | Macros to test valid BV arguments | ||
| 239 | */ | ||
| 240 | #if !defined(PETSC_USE_DEBUG) | ||
| 241 | |||
| 242 | #define BVCheckSizes(h,arg) do {(void)(h);} while (0) | ||
| 243 | #define BVCheckOp(h,arg,op) do {(void)(h);} while (0) | ||
| 244 | |||
| 245 | #else | ||
| 246 | |||
| 247 | #define BVCheckSizes(h,arg) \ | ||
| 248 | do { \ | ||
| 249 | PetscCheck((h)->m,PetscObjectComm((PetscObject)(h)),PETSC_ERR_ARG_WRONGSTATE,"BV sizes have not been defined: Parameter #%d",arg); \ | ||
| 250 | } while (0) | ||
| 251 | |||
| 252 | #define BVCheckOp(h,arg,op) \ | ||
| 253 | do { \ | ||
| 254 | PetscCheck((h)->ops->op,PetscObjectComm((PetscObject)(h)),PETSC_ERR_SUP,"Operation not implemented in this BV type: Parameter #%d",arg); \ | ||
| 255 | } while (0) | ||
| 256 | |||
| 257 | #endif | ||
| 258 | |||
| 259 | SLEPC_INTERN PetscErrorCode BVView_Vecs(BV,PetscViewer); | ||
| 260 | |||
| 261 | SLEPC_INTERN PetscErrorCode BVAllocateWork_Private(BV,PetscInt); | ||
| 262 | |||
| 263 | SLEPC_INTERN PetscErrorCode BVMult_BLAS_Private(BV,PetscInt,PetscInt,PetscInt,PetscScalar,const PetscScalar*,PetscInt,const PetscScalar*,PetscInt,PetscScalar,PetscScalar*,PetscInt); | ||
| 264 | SLEPC_INTERN PetscErrorCode BVMultVec_BLAS_Private(BV,PetscInt,PetscInt,PetscScalar,const PetscScalar*,PetscInt,const PetscScalar*,PetscScalar,PetscScalar*); | ||
| 265 | SLEPC_INTERN PetscErrorCode BVMultInPlace_BLAS_Private(BV,PetscInt,PetscInt,PetscInt,PetscInt,PetscScalar*,PetscInt,const PetscScalar*,PetscInt,PetscBool); | ||
| 266 | SLEPC_INTERN PetscErrorCode BVMultInPlace_Vecs_Private(BV,PetscInt,PetscInt,PetscInt,Vec*,const PetscScalar*,PetscBool); | ||
| 267 | SLEPC_INTERN PetscErrorCode BVAXPY_BLAS_Private(BV,PetscInt,PetscInt,PetscScalar,const PetscScalar*,PetscInt,PetscScalar,PetscScalar*,PetscInt); | ||
| 268 | SLEPC_INTERN PetscErrorCode BVDot_BLAS_Private(BV,PetscInt,PetscInt,PetscInt,const PetscScalar*,PetscInt,const PetscScalar*,PetscInt,PetscScalar*,PetscInt,PetscBool); | ||
| 269 | SLEPC_INTERN PetscErrorCode BVDotVec_BLAS_Private(BV,PetscInt,PetscInt,const PetscScalar*,PetscInt,const PetscScalar*,PetscScalar*,PetscBool); | ||
| 270 | SLEPC_INTERN PetscErrorCode BVScale_BLAS_Private(BV,PetscInt,PetscScalar*,PetscScalar); | ||
| 271 | SLEPC_INTERN PetscErrorCode BVNorm_LAPACK_Private(BV,PetscInt,PetscInt,const PetscScalar*,PetscInt,NormType,PetscReal*,PetscBool); | ||
| 272 | SLEPC_INTERN PetscErrorCode BVNormalize_LAPACK_Private(BV,PetscInt,PetscInt,const PetscScalar*,PetscInt,PetscScalar*,PetscBool); | ||
| 273 | SLEPC_INTERN PetscErrorCode BVGetMat_Default(BV,Mat*); | ||
| 274 | SLEPC_INTERN PetscErrorCode BVRestoreMat_Default(BV,Mat*); | ||
| 275 | SLEPC_INTERN PetscErrorCode BVMatCholInv_LAPACK_Private(BV,Mat,Mat); | ||
| 276 | SLEPC_INTERN PetscErrorCode BVMatTriInv_LAPACK_Private(BV,Mat,Mat); | ||
| 277 | SLEPC_INTERN PetscErrorCode BVMatSVQB_LAPACK_Private(BV,Mat,Mat); | ||
| 278 | SLEPC_INTERN PetscErrorCode BVOrthogonalize_LAPACK_TSQR(BV,PetscInt,PetscInt,PetscScalar*,PetscInt,PetscScalar*,PetscInt); | ||
| 279 | SLEPC_INTERN PetscErrorCode BVOrthogonalize_LAPACK_TSQR_OnlyR(BV,PetscInt,PetscInt,PetscScalar*,PetscInt,PetscScalar*,PetscInt); | ||
| 280 | |||
| 281 | /* reduction operations used in BVOrthogonalize and BVNormalize */ | ||
| 282 | SLEPC_EXTERN MPI_Op MPIU_TSQR, MPIU_LAPY2; | ||
| 283 | SLEPC_EXTERN void MPIAPI SlepcGivensPacked(void*,void*,PetscMPIInt*,MPI_Datatype*); | ||
| 284 | SLEPC_EXTERN void MPIAPI SlepcPythag(void*,void*,PetscMPIInt*,MPI_Datatype*); | ||
| 285 | |||
| 286 | /* | ||
| 287 | BV_CleanCoefficients_Default - Sets to zero all entries of column j of the bv buffer | ||
| 288 | */ | ||
| 289 | 2545964 | static inline PetscErrorCode BV_CleanCoefficients_Default(BV bv,PetscInt j,PetscScalar *h) | |
| 290 | { | ||
| 291 | 2545964 | PetscScalar *hh=h,*a; | |
| 292 | 2545964 | PetscInt i; | |
| 293 | |||
| 294 |
1/2✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
|
2545964 | PetscFunctionBegin; |
| 295 |
2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 20 times.
|
2545964 | if (!h) { |
| 296 |
4/6✓ Branch 0 taken 2 times.
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 2 times.
|
2086753 | PetscCall(VecGetArray(bv->buffer,&a)); |
| 297 | 2086753 | hh = a + j*(bv->nc+bv->m); | |
| 298 | } | ||
| 299 |
2/2✓ Branch 0 taken 20 times.
✓ Branch 1 taken 20 times.
|
33932719 | for (i=0;i<bv->nc+j;i++) hh[i] = 0.0; |
| 300 |
6/8✓ Branch 0 taken 10 times.
✓ Branch 1 taken 20 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 8 times.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 2 times.
|
2545964 | if (!h) PetscCall(VecRestoreArray(bv->buffer,&a)); |
| 301 |
6/12✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 4 times.
✓ Branch 4 taken 4 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 4 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 4 times.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✓ Branch 11 taken 4 times.
|
508225 | PetscFunctionReturn(PETSC_SUCCESS); |
| 302 | } | ||
| 303 | |||
| 304 | /* | ||
| 305 | BV_AddCoefficients_Default - Add the contents of the scratch (0-th column) of the bv buffer | ||
| 306 | into column j of the bv buffer | ||
| 307 | */ | ||
| 308 | 3953484 | static inline PetscErrorCode BV_AddCoefficients_Default(BV bv,PetscInt j,PetscScalar *h,PetscScalar *c) | |
| 309 | { | ||
| 310 | 3953484 | PetscScalar *hh=h,*cc=c; | |
| 311 | 3953484 | PetscInt i; | |
| 312 | |||
| 313 |
1/2✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
|
3953484 | PetscFunctionBegin; |
| 314 |
2/2✓ Branch 0 taken 20 times.
✓ Branch 1 taken 20 times.
|
3953484 | if (!h) { |
| 315 |
4/6✓ Branch 0 taken 4 times.
✓ Branch 1 taken 16 times.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 4 times.
|
3438492 | PetscCall(VecGetArray(bv->buffer,&cc)); |
| 316 | 3438492 | hh = cc + j*(bv->nc+bv->m); | |
| 317 | } | ||
| 318 |
2/2✓ Branch 0 taken 30 times.
✓ Branch 1 taken 30 times.
|
59653975 | for (i=0;i<bv->nc+j;i++) hh[i] += cc[i]; |
| 319 |
6/8✓ Branch 0 taken 20 times.
✓ Branch 1 taken 20 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 16 times.
✓ Branch 4 taken 4 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 4 times.
|
3953484 | if (!h) PetscCall(VecRestoreArray(bv->buffer,&cc)); |
| 320 |
3/6✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 6 times.
|
3953484 | PetscCall(PetscLogFlops(1.0*(bv->nc+j))); |
| 321 |
6/12✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6 times.
✓ Branch 4 taken 6 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 6 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 6 times.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✓ Branch 11 taken 6 times.
|
3953484 | PetscFunctionReturn(PETSC_SUCCESS); |
| 322 | } | ||
| 323 | |||
| 324 | /* | ||
| 325 | BV_SetValue_Default - Sets value in row j (counted after the constraints) of column k | ||
| 326 | of the coefficients array | ||
| 327 | */ | ||
| 328 | 2942341 | static inline PetscErrorCode BV_SetValue_Default(BV bv,PetscInt j,PetscInt k,PetscScalar *h,PetscScalar value) | |
| 329 | { | ||
| 330 | 2942341 | PetscScalar *hh=h,*a; | |
| 331 | |||
| 332 |
1/2✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
|
2942341 | PetscFunctionBegin; |
| 333 |
2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 30 times.
|
2942341 | if (!h) { |
| 334 |
4/6✓ Branch 0 taken 2 times.
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 2 times.
|
2920321 | PetscCall(VecGetArray(bv->buffer,&a)); |
| 335 | 2920321 | hh = a + k*(bv->nc+bv->m); | |
| 336 | } | ||
| 337 | 2942341 | hh[bv->nc+j] = value; | |
| 338 |
6/8✓ Branch 0 taken 10 times.
✓ Branch 1 taken 30 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 8 times.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 2 times.
|
2942341 | if (!h) PetscCall(VecRestoreArray(bv->buffer,&a)); |
| 339 |
6/12✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6 times.
✓ Branch 4 taken 6 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 6 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 6 times.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✓ Branch 11 taken 6 times.
|
588271 | PetscFunctionReturn(PETSC_SUCCESS); |
| 340 | } | ||
| 341 | |||
| 342 | /* | ||
| 343 | BV_SquareSum_Default - Returns the value h'*h, where h represents the contents of the | ||
| 344 | coefficients array (up to position j) | ||
| 345 | */ | ||
| 346 | 3227863 | static inline PetscErrorCode BV_SquareSum_Default(BV bv,PetscInt j,PetscScalar *h,PetscReal *sum) | |
| 347 | { | ||
| 348 | 3227863 | PetscScalar *hh=h; | |
| 349 | 3227863 | PetscInt i; | |
| 350 | |||
| 351 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
3227863 | PetscFunctionBegin; |
| 352 | 3227863 | *sum = 0.0; | |
| 353 |
5/8✓ Branch 0 taken 10 times.
✓ Branch 1 taken 10 times.
✓ Branch 2 taken 10 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2 times.
✗ Branch 7 not taken.
|
3227863 | if (!h) PetscCall(VecGetArray(bv->buffer,&hh)); |
| 354 |
2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 10 times.
|
43330765 | for (i=0;i<bv->nc+j;i++) *sum += PetscRealPart(hh[i]*PetscConj(hh[i])); |
| 355 |
6/8✓ Branch 0 taken 10 times.
✓ Branch 1 taken 10 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 8 times.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 2 times.
|
3227863 | if (!h) PetscCall(VecRestoreArray(bv->buffer,&hh)); |
| 356 |
3/6✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 2 times.
|
3227863 | PetscCall(PetscLogFlops(2.0*(bv->nc+j))); |
| 357 |
6/12✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 2 times.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✓ Branch 11 taken 2 times.
|
3227863 | PetscFunctionReturn(PETSC_SUCCESS); |
| 358 | } | ||
| 359 | |||
| 360 | /* | ||
| 361 | BV_ApplySignature_Default - Computes the pointwise product h*omega, where h represents | ||
| 362 | the contents of the coefficients array (up to position j) and omega is the signature; | ||
| 363 | if inverse=TRUE then the operation is h/omega | ||
| 364 | */ | ||
| 365 | 604824 | static inline PetscErrorCode BV_ApplySignature_Default(BV bv,PetscInt j,PetscScalar *h,PetscBool inverse) | |
| 366 | { | ||
| 367 | 604824 | PetscScalar *hh=h; | |
| 368 | 604824 | PetscInt i; | |
| 369 | 604824 | const PetscScalar *omega; | |
| 370 | |||
| 371 |
1/2✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
|
604824 | PetscFunctionBegin; |
| 372 |
8/14✓ Branch 0 taken 20 times.
✓ Branch 1 taken 20 times.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 4 times.
✓ Branch 6 taken 4 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 4 times.
✗ Branch 9 not taken.
✓ Branch 10 taken 4 times.
✗ Branch 11 not taken.
✗ Branch 12 not taken.
✓ Branch 13 taken 4 times.
|
604824 | if (PetscUnlikely(!(bv->nc+j))) PetscFunctionReturn(PETSC_SUCCESS); |
| 373 |
6/8✓ Branch 0 taken 10 times.
✓ Branch 1 taken 10 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 8 times.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 2 times.
|
603420 | if (!h) PetscCall(VecGetArray(bv->buffer,&hh)); |
| 374 |
4/6✓ Branch 0 taken 4 times.
✓ Branch 1 taken 16 times.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 4 times.
|
603420 | PetscCall(VecGetArrayRead(bv->omega,&omega)); |
| 375 |
4/4✓ Branch 0 taken 20 times.
✓ Branch 1 taken 20 times.
✓ Branch 2 taken 20 times.
✓ Branch 3 taken 20 times.
|
10821762 | if (inverse) for (i=0;i<bv->nc+j;i++) hh[i] /= PetscRealPart(omega[i]); |
| 376 |
2/2✓ Branch 0 taken 20 times.
✓ Branch 1 taken 20 times.
|
10520052 | else for (i=0;i<bv->nc+j;i++) hh[i] *= PetscRealPart(omega[i]); |
| 377 |
4/6✓ Branch 0 taken 4 times.
✓ Branch 1 taken 16 times.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 4 times.
|
603420 | PetscCall(VecRestoreArrayRead(bv->omega,&omega)); |
| 378 |
6/8✓ Branch 0 taken 10 times.
✓ Branch 1 taken 10 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 8 times.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 2 times.
|
603420 | if (!h) PetscCall(VecRestoreArray(bv->buffer,&hh)); |
| 379 |
3/6✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 4 times.
|
603420 | PetscCall(PetscLogFlops(1.0*(bv->nc+j))); |
| 380 |
6/12✓ Branch 0 taken 4 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 4 times.
✓ Branch 4 taken 4 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 4 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 4 times.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✓ Branch 11 taken 4 times.
|
603420 | PetscFunctionReturn(PETSC_SUCCESS); |
| 381 | } | ||
| 382 | |||
| 383 | /* | ||
| 384 | BV_SquareRoot_Default - Returns the square root of position j (counted after the constraints) | ||
| 385 | of the coefficients array | ||
| 386 | */ | ||
| 387 | 2859971 | static inline PetscErrorCode BV_SquareRoot_Default(BV bv,PetscInt j,PetscScalar *h,PetscReal *beta) | |
| 388 | { | ||
| 389 | 2859971 | PetscScalar *hh=h; | |
| 390 | |||
| 391 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2859971 | PetscFunctionBegin; |
| 392 |
5/8✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 8 times.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 2 times.
|
2859971 | if (!h) PetscCall(VecGetArray(bv->buffer,&hh)); |
| 393 |
4/6✓ Branch 0 taken 2 times.
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 2 times.
|
2859971 | PetscCall(BV_SafeSqrt(bv,hh[bv->nc+j],beta)); |
| 394 |
5/8✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 8 times.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 2 times.
|
2859971 | if (!h) PetscCall(VecRestoreArray(bv->buffer,&hh)); |
| 395 |
6/12✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 2 times.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✓ Branch 11 taken 2 times.
|
571752 | PetscFunctionReturn(PETSC_SUCCESS); |
| 396 | } | ||
| 397 | |||
| 398 | /* | ||
| 399 | BV_StoreCoefficients_Default - Copy the contents of the coefficients array to an array dest | ||
| 400 | provided by the caller (only values from l to j are copied) | ||
| 401 | */ | ||
| 402 | 812123 | static inline PetscErrorCode BV_StoreCoefficients_Default(BV bv,PetscInt j,PetscScalar *h,PetscScalar *dest) | |
| 403 | { | ||
| 404 | 812123 | PetscScalar *hh=h,*a; | |
| 405 | 812123 | PetscInt i; | |
| 406 | |||
| 407 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
812123 | PetscFunctionBegin; |
| 408 |
2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 10 times.
|
812123 | if (!h) { |
| 409 |
4/6✓ Branch 0 taken 2 times.
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 2 times.
|
541876 | PetscCall(VecGetArray(bv->buffer,&a)); |
| 410 | 541876 | hh = a + j*(bv->nc+bv->m); | |
| 411 | } | ||
| 412 |
2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 10 times.
|
12813381 | for (i=bv->l;i<j;i++) dest[i-bv->l] = hh[bv->nc+i]; |
| 413 |
6/8✓ Branch 0 taken 10 times.
✓ Branch 1 taken 10 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 8 times.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 2 times.
|
812123 | if (!h) PetscCall(VecRestoreArray(bv->buffer,&a)); |
| 414 |
6/12✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 2 times.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✓ Branch 11 taken 2 times.
|
161341 | PetscFunctionReturn(PETSC_SUCCESS); |
| 415 | } | ||
| 416 | |||
| 417 | /* | ||
| 418 | BV_GetEigenvector - retrieves k-th eigenvector from basis vectors V. | ||
| 419 | The argument eigi is the imaginary part of the corresponding eigenvalue. | ||
| 420 | */ | ||
| 421 | 117784 | static inline PetscErrorCode BV_GetEigenvector(BV V,PetscInt k,PetscScalar eigi,Vec Vr,Vec Vi) | |
| 422 | { | ||
| 423 |
1/2✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
|
117784 | PetscFunctionBegin; |
| 424 | #if defined(PETSC_USE_COMPLEX) | ||
| 425 | 53393 | (void)eigi; | |
| 426 |
6/8✓ Branch 0 taken 25 times.
✓ Branch 1 taken 10 times.
✓ Branch 2 taken 5 times.
✓ Branch 3 taken 20 times.
✓ Branch 4 taken 5 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 5 times.
|
53393 | if (Vr) PetscCall(BVCopyVec(V,k,Vr)); |
| 427 |
6/8✓ Branch 0 taken 15 times.
✓ Branch 1 taken 25 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 12 times.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 3 times.
|
53393 | if (Vi) PetscCall(VecSet(Vi,0.0)); |
| 428 | #else | ||
| 429 |
2/2✓ Branch 0 taken 15 times.
✓ Branch 1 taken 25 times.
|
64391 | if (eigi > 0.0) { /* first value of conjugate pair */ |
| 430 |
5/8✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 12 times.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 3 times.
|
1219 | if (Vr) PetscCall(BVCopyVec(V,k,Vr)); |
| 431 |
5/8✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 12 times.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 3 times.
|
1219 | if (Vi) PetscCall(BVCopyVec(V,k+1,Vi)); |
| 432 |
2/2✓ Branch 0 taken 15 times.
✓ Branch 1 taken 20 times.
|
63172 | } else if (eigi < 0.0) { /* second value of conjugate pair */ |
| 433 |
5/8✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 12 times.
✓ Branch 4 taken 3 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 3 times.
|
929 | if (Vr) PetscCall(BVCopyVec(V,k-1,Vr)); |
| 434 |
1/2✓ Branch 0 taken 15 times.
✗ Branch 1 not taken.
|
929 | if (Vi) { |
| 435 |
4/6✓ Branch 0 taken 3 times.
✓ Branch 1 taken 12 times.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 3 times.
|
929 | PetscCall(BVCopyVec(V,k,Vi)); |
| 436 |
4/6✓ Branch 0 taken 3 times.
✓ Branch 1 taken 12 times.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 3 times.
|
929 | PetscCall(VecScale(Vi,-1.0)); |
| 437 | } | ||
| 438 | } else { /* real eigenvalue */ | ||
| 439 |
6/8✓ Branch 0 taken 20 times.
✓ Branch 1 taken 15 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 16 times.
✓ Branch 4 taken 4 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 4 times.
|
62243 | if (Vr) PetscCall(BVCopyVec(V,k,Vr)); |
| 440 |
6/8✓ Branch 0 taken 20 times.
✓ Branch 1 taken 15 times.
✓ Branch 2 taken 4 times.
✓ Branch 3 taken 16 times.
✓ Branch 4 taken 4 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 4 times.
|
62243 | if (Vi) PetscCall(VecSet(Vi,0.0)); |
| 441 | } | ||
| 442 | #endif | ||
| 443 |
6/12✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 10 times.
✓ Branch 4 taken 10 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 10 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 10 times.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✓ Branch 11 taken 10 times.
|
21338 | PetscFunctionReturn(PETSC_SUCCESS); |
| 444 | } | ||
| 445 | |||
| 446 | /* | ||
| 447 | BV_OrthogonalizeColumn_Safe - this is intended for cases where we know that | ||
| 448 | the resulting vector is going to be numerically zero, so normalization or | ||
| 449 | iterative refinement may cause problems in parallel (collective operation | ||
| 450 | not being called by all processes) | ||
| 451 | */ | ||
| 452 | 514 | static inline PetscErrorCode BV_OrthogonalizeColumn_Safe(BV bv,PetscInt j,PetscScalar *H,PetscReal *norm,PetscBool *lindep) | |
| 453 | { | ||
| 454 | 514 | BVOrthogRefineType orthog_ref; | |
| 455 | |||
| 456 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
514 | PetscFunctionBegin; |
| 457 |
4/6✓ Branch 0 taken 2 times.
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 2 times.
|
514 | PetscCall(PetscInfo(bv,"Orthogonalizing column %" PetscInt_FMT " without refinement\n",j)); |
| 458 | 514 | orthog_ref = bv->orthog_ref; | |
| 459 | 514 | bv->orthog_ref = BV_ORTHOG_REFINE_NEVER; /* avoid refinement */ | |
| 460 |
4/6✓ Branch 0 taken 2 times.
✓ Branch 1 taken 8 times.
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 2 times.
|
514 | PetscCall(BVOrthogonalizeColumn(bv,j,H,NULL,NULL)); |
| 461 | 514 | bv->orthog_ref = orthog_ref; /* restore refinement setting */ | |
| 462 |
1/2✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
|
514 | if (norm) *norm = 0.0; |
| 463 |
1/2✓ Branch 0 taken 10 times.
✗ Branch 1 not taken.
|
514 | if (lindep) *lindep = PETSC_TRUE; |
| 464 |
6/12✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 2 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 2 times.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✓ Branch 11 taken 2 times.
|
86 | PetscFunctionReturn(PETSC_SUCCESS); |
| 465 | } | ||
| 466 | |||
| 467 | /* | ||
| 468 | BV_SetDefaultLD - set the default value of the leading dimension, based on | ||
| 469 | the local size. | ||
| 470 | */ | ||
| 471 | 149980 | static inline PetscErrorCode BV_SetDefaultLD(BV bv,PetscInt nloc) | |
| 472 | { | ||
| 473 | 149980 | size_t bytes,align; | |
| 474 | |||
| 475 |
1/2✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
|
149980 | PetscFunctionBegin; |
| 476 |
2/2✓ Branch 0 taken 30 times.
✓ Branch 1 taken 30 times.
|
149980 | if (bv->ld) { /* set by user */ |
| 477 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 30 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
126277 | PetscCheck(bv->ld>=nloc,PetscObjectComm((PetscObject)bv),PETSC_ERR_USER_INPUT,"The leading dimension %" PetscInt_FMT " should be larger or equal to the local number of rows %" PetscInt_FMT,bv->ld,nloc); |
| 478 | } else { | ||
| 479 | 23703 | align = PetscMax(PETSC_MEMALIGN,16); /* assume that CUDA requires 16-byte alignment */ | |
| 480 | 23703 | bytes = (nloc*sizeof(PetscScalar) + align - 1) & ~(align - 1); | |
| 481 |
4/6✓ Branch 0 taken 6 times.
✓ Branch 1 taken 24 times.
✓ Branch 2 taken 6 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 6 times.
|
23703 | PetscCall(PetscIntCast(bytes/sizeof(PetscScalar),&bv->ld)); |
| 482 | } | ||
| 483 |
6/12✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 6 times.
✓ Branch 4 taken 6 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 6 times.
✗ Branch 7 not taken.
✓ Branch 8 taken 6 times.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
✓ Branch 11 taken 6 times.
|
28867 | PetscFunctionReturn(PETSC_SUCCESS); |
| 484 | } | ||
| 485 | |||
| 486 | #if defined(PETSC_HAVE_CUDA) | ||
| 487 | /* | ||
| 488 | BV_MatDenseCUDAGetArrayRead - if Q is MATSEQDENSE it will allocate memory on the | ||
| 489 | GPU and copy the contents; otherwise, calls MatDenseCUDAGetArrayRead() | ||
| 490 | */ | ||
| 491 | 4091 | static inline PetscErrorCode BV_MatDenseCUDAGetArrayRead(PETSC_UNUSED BV bv,Mat Q,const PetscScalar **d_q) | |
| 492 | { | ||
| 493 | 4091 | const PetscScalar *q; | |
| 494 | 4091 | PetscInt ldq,mq; | |
| 495 | 4091 | PetscCuBLASInt ldq_=0; | |
| 496 | 4091 | PetscBool matiscuda; | |
| 497 | |||
| 498 | 4091 | PetscFunctionBegin; | |
| 499 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4091 | PetscCall(MatGetSize(Q,NULL,&mq)); |
| 500 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4091 | PetscCall(MatDenseGetLDA(Q,&ldq)); |
| 501 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4091 | PetscCall(PetscCuBLASIntCast(ldq,&ldq_)); |
| 502 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4091 | PetscCall(PetscObjectTypeCompare((PetscObject)Q,MATSEQDENSECUDA,&matiscuda)); |
| 503 |
3/4✓ Branch 0 taken 4 times.
✓ Branch 1 taken 4 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4 times.
|
4091 | if (matiscuda) PetscCall(MatDenseCUDAGetArrayRead(Q,d_q)); |
| 504 | else { | ||
| 505 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4075 | PetscCall(MatDenseGetArrayRead(Q,&q)); |
| 506 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
4075 | PetscCallCUDA(cudaMalloc((void**)d_q,ldq*mq*sizeof(PetscScalar))); |
| 507 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
4075 | PetscCallCUDA(cudaMemcpy((void*)*d_q,q,ldq*mq*sizeof(PetscScalar),cudaMemcpyHostToDevice)); |
| 508 | 4075 | PetscCall(PetscLogCpuToGpu(ldq*mq*sizeof(PetscScalar))); | |
| 509 | } | ||
| 510 | PetscFunctionReturn(PETSC_SUCCESS); | ||
| 511 | } | ||
| 512 | |||
| 513 | /* | ||
| 514 | BV_MatDenseCUDARestoreArrayRead - restores the pointer obtained with BV_MatDenseCUDAGetArrayRead(), | ||
| 515 | freeing the GPU memory in case of MATSEQDENSE | ||
| 516 | */ | ||
| 517 | 4091 | static inline PetscErrorCode BV_MatDenseCUDARestoreArrayRead(PETSC_UNUSED BV bv,Mat Q,const PetscScalar **d_q) | |
| 518 | { | ||
| 519 | 4091 | PetscBool matiscuda; | |
| 520 | |||
| 521 | 4091 | PetscFunctionBegin; | |
| 522 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4091 | PetscCall(PetscObjectTypeCompare((PetscObject)Q,MATSEQDENSECUDA,&matiscuda)); |
| 523 |
3/4✓ Branch 0 taken 4 times.
✓ Branch 1 taken 4 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4 times.
|
4091 | if (matiscuda) PetscCall(MatDenseCUDARestoreArrayRead(Q,d_q)); |
| 524 | else { | ||
| 525 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
|
4075 | PetscCall(MatDenseRestoreArrayRead(Q,NULL)); |
| 526 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 4 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
4075 | PetscCallCUDA(cudaFree((void*)*d_q)); |
| 527 | 4075 | *d_q = NULL; | |
| 528 | } | ||
| 529 | PetscFunctionReturn(PETSC_SUCCESS); | ||
| 530 | } | ||
| 531 | |||
| 532 | SLEPC_INTERN PetscErrorCode BVMult_BLAS_CUDA(BV,PetscInt,PetscInt,PetscInt,PetscScalar,const PetscScalar*,PetscInt,const PetscScalar*,PetscInt,PetscScalar,PetscScalar*,PetscInt); | ||
| 533 | SLEPC_INTERN PetscErrorCode BVMultVec_BLAS_CUDA(BV,PetscInt,PetscInt,PetscScalar,const PetscScalar*,PetscInt,const PetscScalar*,PetscScalar,PetscScalar*); | ||
| 534 | SLEPC_INTERN PetscErrorCode BVMultInPlace_BLAS_CUDA(BV,PetscInt,PetscInt,PetscInt,PetscInt,PetscScalar*,PetscInt,const PetscScalar*,PetscInt,PetscBool); | ||
| 535 | SLEPC_INTERN PetscErrorCode BVAXPY_BLAS_CUDA(BV,PetscInt,PetscInt,PetscScalar,const PetscScalar*,PetscInt,PetscScalar,PetscScalar*,PetscInt); | ||
| 536 | SLEPC_INTERN PetscErrorCode BVDot_BLAS_CUDA(BV,PetscInt,PetscInt,PetscInt,const PetscScalar*,PetscInt,const PetscScalar*,PetscInt,PetscScalar*,PetscInt,PetscBool); | ||
| 537 | SLEPC_INTERN PetscErrorCode BVDotVec_BLAS_CUDA(BV,PetscInt,PetscInt,const PetscScalar*,PetscInt,const PetscScalar*,PetscScalar*,PetscBool); | ||
| 538 | SLEPC_INTERN PetscErrorCode BVScale_BLAS_CUDA(BV,PetscInt,PetscScalar*,PetscScalar); | ||
| 539 | SLEPC_INTERN PetscErrorCode BVNorm_BLAS_CUDA(BV,PetscInt,const PetscScalar*,PetscReal*); | ||
| 540 | SLEPC_INTERN PetscErrorCode BVNormalize_BLAS_CUDA(BV,PetscInt,PetscInt,PetscScalar*,PetscInt,PetscScalar*); | ||
| 541 | |||
| 542 | SLEPC_INTERN PetscErrorCode BV_CleanCoefficients_CUDA(BV,PetscInt,PetscScalar*); | ||
| 543 | SLEPC_INTERN PetscErrorCode BV_AddCoefficients_CUDA(BV,PetscInt,PetscScalar*,PetscScalar*); | ||
| 544 | SLEPC_INTERN PetscErrorCode BV_SetValue_CUDA(BV,PetscInt,PetscInt,PetscScalar*,PetscScalar); | ||
| 545 | SLEPC_INTERN PetscErrorCode BV_SquareSum_CUDA(BV,PetscInt,PetscScalar*,PetscReal*); | ||
| 546 | SLEPC_INTERN PetscErrorCode BV_ApplySignature_CUDA(BV,PetscInt,PetscScalar*,PetscBool); | ||
| 547 | SLEPC_INTERN PetscErrorCode BV_SquareRoot_CUDA(BV,PetscInt,PetscScalar*,PetscReal*); | ||
| 548 | SLEPC_INTERN PetscErrorCode BV_StoreCoefficients_CUDA(BV,PetscInt,PetscScalar*,PetscScalar*); | ||
| 549 | #define BV_CleanCoefficients(a,b,c) ((a)->cuda?BV_CleanCoefficients_CUDA:BV_CleanCoefficients_Default)((a),(b),(c)) | ||
| 550 | #define BV_AddCoefficients(a,b,c,d) ((a)->cuda?BV_AddCoefficients_CUDA:BV_AddCoefficients_Default)((a),(b),(c),(d)) | ||
| 551 | #define BV_SetValue(a,b,c,d,e) ((a)->cuda?BV_SetValue_CUDA:BV_SetValue_Default)((a),(b),(c),(d),(e)) | ||
| 552 | #define BV_SquareSum(a,b,c,d) ((a)->cuda?BV_SquareSum_CUDA:BV_SquareSum_Default)((a),(b),(c),(d)) | ||
| 553 | #define BV_ApplySignature(a,b,c,d) ((a)->cuda?BV_ApplySignature_CUDA:BV_ApplySignature_Default)((a),(b),(c),(d)) | ||
| 554 | #define BV_SquareRoot(a,b,c,d) ((a)->cuda?BV_SquareRoot_CUDA:BV_SquareRoot_Default)((a),(b),(c),(d)) | ||
| 555 | #define BV_StoreCoefficients(a,b,c,d) ((a)->cuda?BV_StoreCoefficients_CUDA:BV_StoreCoefficients_Default)((a),(b),(c),(d)) | ||
| 556 | |||
| 557 | #elif defined(PETSC_HAVE_HIP) | ||
| 558 | #include <petscdevice_cupm.h> | ||
| 559 | /* | ||
| 560 | BV_MatDenseHIPGetArrayRead - if Q is MATSEQDENSE it will allocate memory on the | ||
| 561 | GPU and copy the contents; otherwise, calls MatDenseHIPGetArrayRead() | ||
| 562 | */ | ||
| 563 | static inline PetscErrorCode BV_MatDenseHIPGetArrayRead(PETSC_UNUSED BV bv,Mat Q,const PetscScalar **d_q) | ||
| 564 | { | ||
| 565 | const PetscScalar *q; | ||
| 566 | PetscInt ldq,mq; | ||
| 567 | PetscCuBLASInt ldq_=0; | ||
| 568 | PetscBool matiship; | ||
| 569 | |||
| 570 | PetscFunctionBegin; | ||
| 571 | PetscCall(MatGetSize(Q,NULL,&mq)); | ||
| 572 | PetscCall(MatDenseGetLDA(Q,&ldq)); | ||
| 573 | PetscCall(PetscHipBLASIntCast(ldq,&ldq_)); | ||
| 574 | PetscCall(PetscObjectTypeCompare((PetscObject)Q,MATSEQDENSEHIP,&matiship)); | ||
| 575 | if (matiship) PetscCall(MatDenseHIPGetArrayRead(Q,d_q)); | ||
| 576 | else { | ||
| 577 | PetscCall(MatDenseGetArrayRead(Q,&q)); | ||
| 578 | PetscCallHIP(hipMalloc((void**)d_q,ldq*mq*sizeof(PetscScalar))); | ||
| 579 | PetscCallHIP(hipMemcpy((void*)*d_q,q,ldq*mq*sizeof(PetscScalar),hipMemcpyHostToDevice)); | ||
| 580 | PetscCall(PetscLogCpuToGpu(ldq*mq*sizeof(PetscScalar))); | ||
| 581 | } | ||
| 582 | PetscFunctionReturn(PETSC_SUCCESS); | ||
| 583 | } | ||
| 584 | |||
| 585 | /* | ||
| 586 | BV_MatDenseHIPRestoreArrayRead - restores the pointer obtained with BV_MatDenseHIPGetArrayRead(), | ||
| 587 | freeing the GPU memory in case of MATSEQDENSE | ||
| 588 | */ | ||
| 589 | static inline PetscErrorCode BV_MatDenseHIPRestoreArrayRead(PETSC_UNUSED BV bv,Mat Q,const PetscScalar **d_q) | ||
| 590 | { | ||
| 591 | PetscBool matiship; | ||
| 592 | |||
| 593 | PetscFunctionBegin; | ||
| 594 | PetscCall(PetscObjectTypeCompare((PetscObject)Q,MATSEQDENSEHIP,&matiship)); | ||
| 595 | if (matiship) PetscCall(MatDenseHIPRestoreArrayRead(Q,d_q)); | ||
| 596 | else { | ||
| 597 | PetscCall(MatDenseRestoreArrayRead(Q,NULL)); | ||
| 598 | PetscCallHIP(hipFree((void*)*d_q)); | ||
| 599 | *d_q = NULL; | ||
| 600 | } | ||
| 601 | PetscFunctionReturn(PETSC_SUCCESS); | ||
| 602 | } | ||
| 603 | |||
| 604 | SLEPC_INTERN PetscErrorCode BVMult_BLAS_HIP(BV,PetscInt,PetscInt,PetscInt,PetscScalar,const PetscScalar*,PetscInt,const PetscScalar*,PetscInt,PetscScalar,PetscScalar*,PetscInt); | ||
| 605 | SLEPC_INTERN PetscErrorCode BVMultVec_BLAS_HIP(BV,PetscInt,PetscInt,PetscScalar,const PetscScalar*,PetscInt,const PetscScalar*,PetscScalar,PetscScalar*); | ||
| 606 | SLEPC_INTERN PetscErrorCode BVMultInPlace_BLAS_HIP(BV,PetscInt,PetscInt,PetscInt,PetscInt,PetscScalar*,PetscInt,const PetscScalar*,PetscInt,PetscBool); | ||
| 607 | SLEPC_INTERN PetscErrorCode BVAXPY_BLAS_HIP(BV,PetscInt,PetscInt,PetscScalar,const PetscScalar*,PetscInt,PetscScalar,PetscScalar*,PetscInt); | ||
| 608 | SLEPC_INTERN PetscErrorCode BVDot_BLAS_HIP(BV,PetscInt,PetscInt,PetscInt,const PetscScalar*,PetscInt,const PetscScalar*,PetscInt,PetscScalar*,PetscInt,PetscBool); | ||
| 609 | SLEPC_INTERN PetscErrorCode BVDotVec_BLAS_HIP(BV,PetscInt,PetscInt,const PetscScalar*,PetscInt,const PetscScalar*,PetscScalar*,PetscBool); | ||
| 610 | SLEPC_INTERN PetscErrorCode BVScale_BLAS_HIP(BV,PetscInt,PetscScalar*,PetscScalar); | ||
| 611 | SLEPC_INTERN PetscErrorCode BVNorm_BLAS_HIP(BV,PetscInt,const PetscScalar*,PetscReal*); | ||
| 612 | SLEPC_INTERN PetscErrorCode BVNormalize_BLAS_HIP(BV,PetscInt,PetscInt,PetscScalar*,PetscInt,PetscScalar*); | ||
| 613 | |||
| 614 | SLEPC_INTERN PetscErrorCode BV_CleanCoefficients_HIP(BV,PetscInt,PetscScalar*); | ||
| 615 | SLEPC_INTERN PetscErrorCode BV_AddCoefficients_HIP(BV,PetscInt,PetscScalar*,PetscScalar*); | ||
| 616 | SLEPC_INTERN PetscErrorCode BV_SetValue_HIP(BV,PetscInt,PetscInt,PetscScalar*,PetscScalar); | ||
| 617 | SLEPC_INTERN PetscErrorCode BV_SquareSum_HIP(BV,PetscInt,PetscScalar*,PetscReal*); | ||
| 618 | SLEPC_INTERN PetscErrorCode BV_ApplySignature_HIP(BV,PetscInt,PetscScalar*,PetscBool); | ||
| 619 | SLEPC_INTERN PetscErrorCode BV_SquareRoot_HIP(BV,PetscInt,PetscScalar*,PetscReal*); | ||
| 620 | SLEPC_INTERN PetscErrorCode BV_StoreCoefficients_HIP(BV,PetscInt,PetscScalar*,PetscScalar*); | ||
| 621 | #define BV_CleanCoefficients(a,b,c) ((a)->hip?BV_CleanCoefficients_HIP:BV_CleanCoefficients_Default)((a),(b),(c)) | ||
| 622 | #define BV_AddCoefficients(a,b,c,d) ((a)->hip?BV_AddCoefficients_HIP:BV_AddCoefficients_Default)((a),(b),(c),(d)) | ||
| 623 | #define BV_SetValue(a,b,c,d,e) ((a)->hip?BV_SetValue_HIP:BV_SetValue_Default)((a),(b),(c),(d),(e)) | ||
| 624 | #define BV_SquareSum(a,b,c,d) ((a)->hip?BV_SquareSum_HIP:BV_SquareSum_Default)((a),(b),(c),(d)) | ||
| 625 | #define BV_ApplySignature(a,b,c,d) ((a)->hip?BV_ApplySignature_HIP:BV_ApplySignature_Default)((a),(b),(c),(d)) | ||
| 626 | #define BV_SquareRoot(a,b,c,d) ((a)->hip?BV_SquareRoot_HIP:BV_SquareRoot_Default)((a),(b),(c),(d)) | ||
| 627 | #define BV_StoreCoefficients(a,b,c,d) ((a)->hip?BV_StoreCoefficients_HIP:BV_StoreCoefficients_Default)((a),(b),(c),(d)) | ||
| 628 | |||
| 629 | #else /* CPU */ | ||
| 630 | #define BV_CleanCoefficients(a,b,c) BV_CleanCoefficients_Default((a),(b),(c)) | ||
| 631 | #define BV_AddCoefficients(a,b,c,d) BV_AddCoefficients_Default((a),(b),(c),(d)) | ||
| 632 | #define BV_SetValue(a,b,c,d,e) BV_SetValue_Default((a),(b),(c),(d),(e)) | ||
| 633 | #define BV_SquareSum(a,b,c,d) BV_SquareSum_Default((a),(b),(c),(d)) | ||
| 634 | #define BV_ApplySignature(a,b,c,d) BV_ApplySignature_Default((a),(b),(c),(d)) | ||
| 635 | #define BV_SquareRoot(a,b,c,d) BV_SquareRoot_Default((a),(b),(c),(d)) | ||
| 636 | #define BV_StoreCoefficients(a,b,c,d) BV_StoreCoefficients_Default((a),(b),(c),(d)) | ||
| 637 | #endif /* PETSC_HAVE_CUDA */ | ||
| 638 |