DFT-EFE
 
Loading...
Searching...
No Matches
BlasLapack.h
Go to the documentation of this file.
1/******************************************************************************
2 * Copyright (c) 2021. *
3 * The Regents of the University of Michigan and DFT-EFE developers. *
4 * *
5 * This file is part of the DFT-EFE code. *
6 * *
7 * DFT-EFE is free software: you can redistribute it and/or modify *
8 * it under the terms of the Lesser GNU General Public License as *
9 * published by the Free Software Foundation, either version 3 of *
10 * the License, or (at your option) any later version. *
11 * *
12 * DFT-EFE is distributed in the hope that it will be useful, but *
13 * WITHOUT ANY WARRANTY; without even the implied warranty *
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. *
15 * See the Lesser GNU General Public License for more details. *
16 * *
17 * You should have received a copy of the GNU Lesser General Public *
18 * License at the top level of DFT-EFE distribution. If not, see *
19 * <https://www.gnu.org/licenses/>. *
20 ******************************************************************************/
21
22/*
23 * @author Vishal Subramanian, Avirup Sircar
24 */
25
26#ifndef dftefeBlasWrappers_h
27#define dftefeBlasWrappers_h
28
29#include <linearAlgebra/LinearAlgebraTypes.h>
30#include <utils/ConditionalOStream.h>
31#include <utils/Profiler.h>
32#include "Defaults.h"
33#include <linearAlgebra/BlasAPIWrapper.h>
34
35namespace dftefe
36{
37 namespace linearAlgebra
38 {
39 namespace blasLapack
40 {
41 template <typename ValueType,
42 typename dftefe::utils::MemorySpace memorySpace>
43 real_type<ValueType>
44 asum(size_type n,
45 ValueType const * x,
46 size_type incx,
47 LinAlgOpContext<memorySpace> &context);
48
49 template <typename ValueType,
50 typename dftefe::utils::MemorySpace memorySpace>
51 real_type<ValueType>
52 amax(size_type n,
53 ValueType const * x,
54 size_type incx,
55 LinAlgOpContext<memorySpace> &context);
56
66 template <typename ValueType,
67 typename dftefe::utils::MemorySpace memorySpace>
68 std::vector<double>
69 amaxsMultiVector(const size_type vecSize,
70 const size_type numVec,
71 ValueType const * multiVecData,
72 LinAlgOpContext<memorySpace> &context);
73
74
75 template <typename ValueType1,
76 typename ValueType2,
77 typename dftefe::utils::MemorySpace memorySpace>
78 void
79 axpy(size_type n,
80 scalar_type<ValueType1, ValueType2> alpha,
81 ValueType1 const * x,
82 size_type incx,
83 ValueType2 * y,
84 size_type incy,
85 LinAlgOpContext<memorySpace> & context);
86
87 // i have neglected incx & incy parameters
99 template <typename ValueType1,
100 typename ValueType2,
101 typename dftefe::utils::MemorySpace memorySpace>
102 void
103 reciprocalX(size_type n,
104 const ValueType1 alpha,
105 ValueType2 const * x,
106 scalar_type<ValueType1, ValueType2> *y,
107 LinAlgOpContext<memorySpace> & context);
108
109
117 template <typename ValueType1,
118 typename ValueType2,
119 typename dftefe::utils::MemorySpace memorySpace>
120 void
121 ascale(size_type n,
122 ValueType1 alpha,
123 const ValueType2 * x,
124 scalar_type<ValueType1, ValueType2> *z,
125 LinAlgOpContext<memorySpace> & context);
126
127
135 template <typename ValueType1,
136 typename ValueType2,
137 typename dftefe::utils::MemorySpace memorySpace>
138 void
139 hadamardProduct(size_type n,
140 const ValueType1 * x,
141 const ValueType2 * y,
142 scalar_type<ValueType1, ValueType2> *z,
143 LinAlgOpContext<memorySpace> & context);
144
145 // /*
146 // * @brief Template for performing \f$ blockedOutput_ij = blockedInput_ij * singleVectorInput_i$
147 // * @param[in] size size of the blocked Input array
148 // * @param[in] numComponets no of componets
149 // * @param[in] blockedInput blocked array
150 // * @param[in] singleVectorInput array
151 // * @param[out] blockedOutput blocked array
152 // */
153 // template <typename ValueType1,
154 // typename ValueType2,
155 // typename dftefe::utils::MemorySpace memorySpace>
156 // void
157 // blockedHadamardProduct(const size_type n,
158 // const size_type blockSize,
159 // const ValueType1 * blockedInput,
160 // const ValueType2 * singleVectorInput,
161 // scalar_type<ValueType1, ValueType2> *blockedOutput,
162 // LinAlgOpContext<memorySpace> & context);
163
164
180 template <typename ValueType1,
181 typename ValueType2,
182 typename dftefe::utils::MemorySpace memorySpace>
183 void
184 hadamardProduct(size_type n,
185 const ValueType1 * x,
186 const ValueType2 * y,
187 const ScalarOp & opx,
188 const ScalarOp & opy,
189 scalar_type<ValueType1, ValueType2> *z,
190 LinAlgOpContext<memorySpace> & context);
191
217 template <typename ValueType1,
218 typename ValueType2,
219 dftefe::utils::MemorySpace memorySpace>
220 void
221 scaleStridedVarBatched(const size_type numMats,
222 const Layout layout,
223 const ScalarOp & scalarOpA,
224 const ScalarOp & scalarOpB,
225 const size_type * stridea,
226 const size_type * strideb,
227 const size_type * stridec,
228 const size_type * m,
229 const size_type * n,
230 const size_type * k,
231 const ValueType1 * dA,
232 const ValueType2 * dB,
233 scalar_type<ValueType1, ValueType2> *dC,
234 LinAlgOpContext<memorySpace> & context);
235
258 template <typename ValueType1,
259 typename ValueType2,
260 typename dftefe::utils::MemorySpace memorySpace>
261 void
262 khatriRaoProduct(const Layout layout,
263 size_type sizeI,
264 size_type sizeJ,
265 size_type sizeK,
266 const ValueType1 * A,
267 const ValueType2 * B,
268 scalar_type<ValueType1, ValueType2> *Z,
269 LinAlgOpContext<memorySpace> & context);
270
280 template <typename ValueType1,
281 typename ValueType2,
282 typename dftefe::utils::MemorySpace memorySpace>
283 void
284 axpby(size_type n,
285 scalar_type<ValueType1, ValueType2> alpha,
286 ValueType1 const * x,
287 scalar_type<ValueType1, ValueType2> beta,
288 const ValueType2 * y,
289 scalar_type<ValueType1, ValueType2> *z,
290 LinAlgOpContext<memorySpace> & context);
291
301 template <typename ValueType1,
302 typename ValueType2,
303 typename dftefe::utils::MemorySpace memorySpace>
304 void
305 axpbyBlocked(const size_type n,
306 const size_type blockSize,
307 const scalar_type<ValueType1, ValueType2> alpha1,
308 const scalar_type<ValueType1, ValueType2> *alpha,
309 const ValueType1 * x,
310 const scalar_type<ValueType1, ValueType2> beta1,
311 const scalar_type<ValueType1, ValueType2> *beta,
312 const ValueType2 * y,
313 scalar_type<ValueType1, ValueType2> * z,
314 LinAlgOpContext<memorySpace> & context);
315
316
317 template <typename ValueType1,
318 typename ValueType2,
319 typename dftefe::utils::MemorySpace memorySpace>
320 scalar_type<ValueType1, ValueType2>
321 dot(size_type n,
322 ValueType1 const * x,
323 size_type incx,
324 ValueType2 const * y,
325 size_type incy,
326 LinAlgOpContext<memorySpace> &context);
327
340 template <typename ValueType1,
341 typename ValueType2,
342 typename dftefe::utils::MemorySpace memorySpace>
343 void
344 stridedBlockCopy(const size_type vecSize,
345 const size_type numVec,
346 const size_type srcLeadingDim,
347 const size_type srcBlockStartId,
348 const size_type dstLeadingDim,
349 const size_type dstBlockStartId,
350 const ValueType1 * copyFromVec,
351 ValueType2 * copyToVec,
352 LinAlgOpContext<memorySpace> &context);
353
354 template <typename ValueType1,
355 typename ValueType2,
356 typename dftefe::utils::MemorySpace memorySpace>
357 void
358 copyValueType1ArrToValueType2Arr(const size_type size,
359 const ValueType1 *valueType1Arr,
360 ValueType2 * valueType2Arr,
361 LinAlgOpContext<memorySpace> &context);
362
389 template <typename ValueType1,
390 typename ValueType2,
391 typename dftefe::utils::MemorySpace memorySpace>
392 void
393 varBatchedStridedBlockCopy(const size_type numBatch,
394 const size_type * strideSrc,
395 const size_type * strideDst,
396 const size_type * vecSizeArr,
397 const size_type * numVecArr,
398 const size_type * srcLeadingDimArr,
399 const size_type * srcBlockStartIdArr,
400 const size_type * dstLeadingDimArr,
401 const size_type * dstBlockStartIdArr,
402 const ValueType1 *copyFromVec,
403 ValueType2 * copyToVec,
404 LinAlgOpContext<memorySpace> &context);
405
423 template <typename ValueType1,
424 typename ValueType2,
425 typename dftefe::utils::MemorySpace memorySpace>
426 void
427 dotMultiVector(size_type vecSize,
428 size_type numVec,
429 const ValueType1 * multiVecDataX,
430 const ValueType2 * multiVecDataY,
431 const ScalarOp & opX,
432 const ScalarOp & opY,
433 scalar_type<ValueType1, ValueType2> *multiVecDotProduct,
434 LinAlgOpContext<memorySpace> & context);
435
436
437 template <typename ValueType,
438 typename dftefe::utils::MemorySpace memorySpace>
439 real_type<ValueType>
440 nrm2(size_type n,
441 ValueType const * x,
442 size_type incx,
443 LinAlgOpContext<memorySpace> &context);
444
454 template <typename ValueType,
455 typename dftefe::utils::MemorySpace memorySpace>
456 std::vector<double>
457 nrms2MultiVector(size_type vecSize,
458 size_type numVec,
459 ValueType const * multiVecData,
460 LinAlgOpContext<memorySpace> &context);
461
462 template <typename ValueType1,
463 typename ValueType2,
464 typename dftefe::utils::MemorySpace memorySpace>
465 void
466 gemm(const char & transA,
467 const char & transB,
468 const size_type m,
469 const size_type n,
470 const size_type k,
471 const scalar_type<ValueType1, ValueType2> alpha,
472 ValueType1 const * dA,
473 const size_type ldda,
474 ValueType2 const * dB,
475 const size_type lddb,
476 const scalar_type<ValueType1, ValueType2> beta,
477 scalar_type<ValueType1, ValueType2> * dC,
478 const size_type lddc,
479 LinAlgOpContext<memorySpace> & context);
480
487 template <typename ValueType1,
488 typename ValueType2,
489 typename dftefe::utils::MemorySpace memorySpace>
490 void
491 gemmStridedVarBatched(size_type numMats,
492 const char * transA,
493 const char * transB,
494 const size_type * stridea,
495 const size_type * strideb,
496 const size_type * stridec,
497 const size_type * m,
498 const size_type * n,
499 const size_type * k,
500 scalar_type<ValueType1, ValueType2> alpha,
501 const ValueType1 * dA,
502 const size_type * ldda,
503 const ValueType2 * dB,
504 const size_type * lddb,
505 scalar_type<ValueType1, ValueType2> beta,
506 scalar_type<ValueType1, ValueType2> *dC,
507 const size_type * lddc,
508 LinAlgOpContext<memorySpace> & context);
509
510
514 template <typename ValueType,
515 typename dftefe::utils::MemorySpace memorySpace>
516 LapackError
517 inverse(size_type n, ValueType *A, LinAlgOpContext<memorySpace> &context);
518
522 template <typename ValueType,
523 typename dftefe::utils::MemorySpace memorySpace>
524 LapackError
525 trtri(const char uplo,
526 const char diag,
527 size_type n,
528 ValueType * A,
529 size_type lda,
530 LinAlgOpContext<memorySpace> &context);
531
535 template <typename ValueType,
536 typename dftefe::utils::MemorySpace memorySpace>
537 LapackError
538 potrf(const char uplo,
539 size_type n,
540 ValueType * A,
541 size_type lda,
542 LinAlgOpContext<memorySpace> &context);
543
547 template <typename ValueType,
548 typename dftefe::utils::MemorySpace memorySpace>
549 LapackError
550 steqr(const char jobz,
551 size_type n,
552 real_type<ValueType> * D,
553 real_type<ValueType> * E,
554 ValueType * Z,
555 size_type ldz,
556 LinAlgOpContext<memorySpace> &context);
557
561 template <typename ValueType,
562 typename dftefe::utils::MemorySpace memorySpace>
563 LapackError
564 heevd(const char jobz,
565 const char uplo,
566 size_type n,
567 ValueType * A,
568 size_type lda,
569 real_type<ValueType> * W,
570 LinAlgOpContext<memorySpace> &context);
571
575 template <typename ValueType,
576 typename dftefe::utils::MemorySpace memorySpace>
577 LapackError
578 hegv(size_type itype,
579 const char jobz,
580 const char uplo,
581 size_type n,
582 ValueType * A,
583 size_type lda,
584 ValueType * B,
585 size_type ldb,
586 real_type<ValueType> * W,
587 LinAlgOpContext<memorySpace> &context);
588
593 template <typename ValueType,
594 typename dftefe::utils::MemorySpace memorySpace>
595 LapackError
596 gesv(size_type n,
597 size_type nrhs,
598 ValueType * A,
599 size_type lda,
600 ValueType * B,
601 size_type ldb,
602 LinAlgOpContext<memorySpace> &context);
603
604 } // namespace blasLapack
605 } // namespace linearAlgebra
606} // namespace dftefe
607
608#include "BlasLapack.t.cpp"
609#endif // dftefeBlasWrappers_h
dftefe::linearAlgebra::blasLapack::amax
real_type< ValueType > amax(size_type n, ValueType const *x, size_type incx, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:28
dftefe::linearAlgebra::blasLapack::varBatchedStridedBlockCopy
void varBatchedStridedBlockCopy(const size_type numBatch, const size_type *strideSrc, const size_type *strideDst, const size_type *vecSizeArr, const size_type *numVecArr, const size_type *srcLeadingDimArr, const size_type *srcBlockStartIdArr, const size_type *dstLeadingDimArr, const size_type *dstBlockStartIdArr, const ValueType1 *copyFromVec, ValueType2 *copyToVec, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:343
dftefe::linearAlgebra::blasLapack::gesv
LapackError gesv(size_type n, size_type nrhs, ValueType *A, size_type lda, ValueType *B, size_type ldb, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:638
dftefe::linearAlgebra::blasLapack::dotMultiVector
void dotMultiVector(const size_type vecSize, const size_type numVec, const ValueType1 *multiVecDataX, const ValueType2 *multiVecDataY, const ScalarOp &opX, const ScalarOp &opY, scalar_type< ValueType1, ValueType2 > *multiVecDotProduct, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:261
dftefe::linearAlgebra::blasLapack::hadamardProduct
void hadamardProduct(size_type n, const ValueType1 *x, const ValueType2 *y, scalar_type< ValueType1, ValueType2 > *z, LinAlgOpContext< memorySpace > &context)
Template for performing alpha z_i = x_i * y_i$.
Definition: BlasLapack.t.cpp:106
dftefe::linearAlgebra::blasLapack::axpy
void axpy(size_type n, scalar_type< ValueType1, ValueType2 > alpha, ValueType1 const *x, size_type incx, ValueType2 *y, size_type incy, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:59
dftefe::linearAlgebra::blasLapack::reciprocalX
void reciprocalX(size_type n, const ValueType1 alpha, ValueType2 const *x, scalar_type< ValueType1, ValueType2 > *y, LinAlgOpContext< memorySpace > &context)
Template for computing the multiplicative inverse of all the elements of x, does not check if any ele...
Definition: BlasLapack.t.cpp:78
dftefe::linearAlgebra::blasLapack::stridedBlockCopy
void stridedBlockCopy(const size_type vecSize, const size_type numVec, const size_type srcLeadingDim, const size_type srcBlockStartId, const size_type dstLeadingDim, const size_type dstBlockStartId, const ValueType1 *copyFromVec, ValueType2 *copyToVec, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:311
dftefe::linearAlgebra::blasLapack::khatriRaoProduct
void khatriRaoProduct(const Layout layout, const size_type sizeI, const size_type sizeJ, const size_type sizeK, const ValueType1 *A, const ValueType2 *B, scalar_type< ValueType1, ValueType2 > *Z, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:172
dftefe::linearAlgebra::blasLapack::Layout
Layout
Definition: BlasLapackTypedef.h:161
dftefe::linearAlgebra::blasLapack::gemmStridedVarBatched
void gemmStridedVarBatched(const size_type numMats, const char *transA, const char *transB, const size_type *stridea, const size_type *strideb, const size_type *stridec, const size_type *m, const size_type *n, const size_type *k, const scalar_type< ValueType1, ValueType2 > alpha, const ValueType1 *dA, const size_type *ldda, const ValueType2 *dB, const size_type *lddb, const scalar_type< ValueType1, ValueType2 > beta, scalar_type< ValueType1, ValueType2 > *dC, const size_type *lddc, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:427
dftefe::linearAlgebra::blasLapack::nrm2
real_type< ValueType > nrm2(const size_type n, ValueType const *x, const size_type incx, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:284
dftefe::linearAlgebra::blasLapack::potrf
LapackError potrf(const char uplo, size_type n, ValueType *A, size_type lda, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:524
dftefe::linearAlgebra::blasLapack::nrms2MultiVector
std::vector< double > nrms2MultiVector(const size_type vecSize, const size_type numVec, const ValueType *multiVecData, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:298
dftefe::linearAlgebra::blasLapack::asum
real_type< ValueType > asum(size_type n, ValueType const *x, size_type incx, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:16
dftefe::linearAlgebra::blasLapack::hegv
LapackError hegv(size_type itype, const char jobz, const char uplo, size_type n, ValueType *A, size_type lda, ValueType *B, size_type ldb, real_type< ValueType > *W, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:606
dftefe::linearAlgebra::blasLapack::trtri
LapackError trtri(const char uplo, const char diag, size_type n, ValueType *A, size_type lda, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:497
dftefe::linearAlgebra::blasLapack::copyValueType1ArrToValueType2Arr
void copyValueType1ArrToValueType2Arr(const size_type size, const ValueType1 *valueType1Arr, ValueType2 *valueType2Arr, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:375
dftefe::linearAlgebra::blasLapack::axpby
void axpby(const size_type n, const scalar_type< ValueType1, ValueType2 > alpha, const ValueType1 *x, const scalar_type< ValueType1, ValueType2 > beta, const ValueType2 *y, scalar_type< ValueType1, ValueType2 > *z, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:208
dftefe::linearAlgebra::blasLapack::dot
scalar_type< ValueType1, ValueType2 > dot(const size_type n, ValueType1 const *x, const size_type incx, ValueType2 const *y, const size_type incy, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:244
dftefe::linearAlgebra::blasLapack::scaleStridedVarBatched
void scaleStridedVarBatched(const size_type numMats, const Layout layout, const ScalarOp &scalarOpA, const ScalarOp &scalarOpB, const size_type *stridea, const size_type *strideb, const size_type *stridec, const size_type *m, const size_type *n, const size_type *k, const ValueType1 *dA, const ValueType2 *dB, scalar_type< ValueType1, ValueType2 > *dC, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:136
dftefe::linearAlgebra::blasLapack::ScalarOp
ScalarOp
Definition: BlasLapackTypedef.h:169
dftefe::linearAlgebra::blasLapack::steqr
LapackError steqr(const char jobz, size_type n, real_type< ValueType > *D, real_type< ValueType > *E, ValueType *Z, size_type ldz, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:550
dftefe::linearAlgebra::blasLapack::gemm
void gemm(const char &transA, const char &transB, const size_type m, const size_type n, const size_type k, const scalar_type< ValueType1, ValueType2 > alpha, ValueType1 const *dA, const size_type ldda, ValueType2 const *dB, const size_type lddb, const scalar_type< ValueType1, ValueType2 > beta, scalar_type< ValueType1, ValueType2 > *dC, const size_type lddc, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:391
dftefe::linearAlgebra::blasLapack::axpbyBlocked
void axpbyBlocked(const size_type n, const size_type blockSize, const scalar_type< ValueType1, ValueType2 > alpha1, const scalar_type< ValueType1, ValueType2 > *alpha, const ValueType1 *x, const scalar_type< ValueType1, ValueType2 > beta1, const scalar_type< ValueType1, ValueType2 > *beta, const ValueType2 *y, scalar_type< ValueType1, ValueType2 > *z, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:224
dftefe::linearAlgebra::blasLapack::inverse
LapackError inverse(size_type n, ValueType *A, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:471
dftefe::linearAlgebra::blasLapack::amaxsMultiVector
std::vector< double > amaxsMultiVector(const size_type vecSize, const size_type numVec, ValueType const *multiVecData, LinAlgOpContext< memorySpace > &context)
Template for computing norms of all the numVec vectors in a multi Vector.
Definition: BlasLapack.t.cpp:41
dftefe::linearAlgebra::blasLapack::heevd
LapackError heevd(const char jobz, const char uplo, size_type n, ValueType *A, size_type lda, real_type< ValueType > *W, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:578
dftefe::linearAlgebra::blasLapack::ascale
void ascale(const size_type n, const ValueType1 alpha, const ValueType2 *x, scalar_type< ValueType1, ValueType2 > *z, LinAlgOpContext< memorySpace > &context)
Definition: BlasLapack.t.cpp:92
dftefe::utils::MemorySpace
MemorySpace
Definition: MemorySpaceType.h:37
dftefe
dealii includes
Definition: AtomFieldDataSpherical.cpp:31
dftefe::size_type
std::uint64_t size_type
Definition: TypeConfig.h:9