COMPASS  5.0.0
End-to-end AO simulation tool using GPU acceleration
carma_cusolver.h
Go to the documentation of this file.
1 // -----------------------------------------------------------------------------
2 // This file is part of COMPASS <https://anr-compass.github.io/compass/>
3 //
4 // Copyright (C) 2011-2019 COMPASS Team <https://github.com/ANR-COMPASS>
5 // All rights reserved.
6 // Distributed under GNU - LGPL
7 //
8 // COMPASS is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser
9 // General Public License as published by the Free Software Foundation, either version 3 of the License,
10 // or any later version.
11 //
12 // COMPASS: End-to-end AO simulation tool using GPU acceleration
13 // The COMPASS platform was designed to meet the need of high-performance for the simulation of AO systems.
14 //
15 // The final product includes a software package for simulating all the critical subcomponents of AO,
16 // particularly in the context of the ELT and a real-time core based on several control approaches,
17 // with performances consistent with its integration into an instrument. Taking advantage of the specific
18 // hardware architecture of the GPU, the COMPASS tool allows to achieve adequate execution speeds to
19 // conduct large simulation campaigns called to the ELT.
20 //
21 // The COMPASS platform can be used to carry a wide variety of simulations to both testspecific components
22 // of AO of the E-ELT (such as wavefront analysis device with a pyramid or elongated Laser star), and
23 // various systems configurations such as multi-conjugate AO.
24 //
25 // COMPASS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the
26 // implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
27 // See the GNU Lesser General Public License for more details.
28 //
29 // You should have received a copy of the GNU Lesser General Public License along with COMPASS.
30 // If not, see <https://www.gnu.org/licenses/lgpl-3.0.txt>.
31 // -----------------------------------------------------------------------------
32 
40 
41 #ifndef _CARMA_CUSOLVER_H_
42 #define _CARMA_CUSOLVER_H_
43 
44 #include <carma_host_obj.h>
45 #include <carma_obj.h>
46 #include <carma_sparse_obj.h>
47 #include <cusolverDn.h>
48 
49 template <class T>
50 int carma_syevd(cusolverEigMode_t jobz, CarmaObj<T> *mat,
51  CarmaObj<T> *eigenvals);
52 // template <class T, int method>
53 // int carma_syevd(char jobz, CarmaObj<T> *mat, CarmaHostObj<T> *eigenvals);
54 // template <class T>
55 // int carma_syevd_m(long ngpu, char jobz, long N, T *mat, T *eigenvals);
56 // template <class T>
57 // int carma_syevd_m(long ngpu, char jobz, CarmaHostObj<T> *mat,
58 // CarmaHostObj<T> *eigenvals);
59 // template <class T>
60 // int carma_syevd_m(long ngpu, char jobz, CarmaHostObj<T> *mat,
61 // CarmaHostObj<T> *eigenvals, CarmaHostObj<T> *U);
62 // template <class T>
63 // int carma_getri(CarmaObj<T> *d_iA);
64 // template <class T>
65 // int carma_potri(CarmaObj<T> *d_iA);
66 // template <class T>
67 // int carma_potri_m(long num_gpus, CarmaHostObj<T> *h_A, CarmaObj<T> *d_iA);
68 
69 // MAGMA functions (direct access)
70 template <class T>
71 int carma_syevd(cusolverEigMode_t jobz, long N, T *mat, T *eigenvals);
72 // template <class T>
73 // int carma_potri_m(long num_gpus, long N, T *h_A, T *d_iA);
74 
75 // template <class T_data>
76 // int carma_svd_cpu(CarmaHostObj<T_data> *imat,
77 // CarmaHostObj<T_data> *eigenvals,
78 // CarmaHostObj<T_data> *mod2act,
79 // CarmaHostObj<T_data> *mes2mod);
80 // template <class T>
81 // int carma_getri_cpu(CarmaHostObj<T> *h_A);
82 // template <class T>
83 // int carma_potri_cpu(CarmaHostObj<T> *h_A);
84 // template <class T>
85 // int carma_syevd_cpu(char jobz, CarmaHostObj<T> *h_A,
86 // CarmaHostObj<T> *eigenvals);
87 
88 // // MAGMA functions (direct access)
89 // // template <class T>
90 // // int carma_svd_cpu(long N, long M, T *imat, T *eigenvals, T *mod2act,
91 // // T *mes2mod);
92 // template <class T>
93 // int carma_getri_cpu(long N, T *h_A);
94 // template <class T>
95 // int carma_potri_cpu(long N, T *h_A);
96 // template <class T>
97 // int carma_syevd_cpu(char jobz, long N, T *h_A, T *eigenvals);
98 // template <class T>
99 // int carma_axpy_cpu(long N, T alpha, T *h_X, long incX, T *h_Y, long incY);
100 // template <class T>
101 // int carma_gemm_cpu(char transa, char transb, long m, long n, long k, T alpha,
102 // T *A, long lda, T *B, long ldb, T beta, T *C, long ldc);
103 
104 // template <class T_data>
105 // int carma_cusolver_csr2ell(CarmaSparseObj<T_data> *dA);
106 
107 // template <class T_data>
108 // int carma_cusolver_spmv(T_data alpha, CarmaSparseObj<T_data> *dA,
109 // CarmaObj<T_data> *dx, T_data beta, CarmaObj<T_data>
110 // *dy);
111 
112 // template <class T_data>
113 // int carma_sparse_free(CarmaSparseObj<T_data> *dA);
114 
115 #endif // _CARMA_CUSOLVER_H_
carma_syevd
int carma_syevd(cusolverEigMode_t jobz, CarmaObj< T > *mat, CarmaObj< T > *eigenvals)
CarmaObj< T >
carma_obj.h
carma_sparse_obj.h
carma_host_obj.h