diff --git a/master/add_8h_source.html b/master/add_8h_source.html index 8c304045cf..5414c34594 100644 --- a/master/add_8h_source.html +++ b/master/add_8h_source.html @@ -95,30 +95,32 @@
12
13#ifdef DLAF_WITH_GPU
14
-
15#include <blas.hh>
-
16#include <whip.hpp>
-
17
-
18#include <dlaf/gpu/blas/api.h>
-
19#include <dlaf/types.h>
-
20
-
21namespace dlaf::gpulapack {
+
15#include <complex>
+
16
+
17#include <blas.hh>
+
18#include <whip.hpp>
+
19
+
20#include <dlaf/gpu/blas/api.h>
+
21#include <dlaf/types.h>
22
-
23template <class T>
-
24void add(const blas::Uplo uplo, const SizeType m, const SizeType n, const T& alpha, const T* a,
-
25 const SizeType lda, T* b, const SizeType ldb, const whip::stream_t stream);
-
26
-
27#define DLAF_CUBLAS_ADD_ETI(kword, Type) \
-
28 kword template void add(const blas::Uplo uplo, const SizeType m, const SizeType n, const Type& alpha, \
-
29 const Type* a, const SizeType lda, Type* b, const SizeType ldb, \
-
30 const whip::stream_t stream)
-
31
-
32DLAF_CUBLAS_ADD_ETI(extern, float);
-
33DLAF_CUBLAS_ADD_ETI(extern, double);
-
34DLAF_CUBLAS_ADD_ETI(extern, std::complex<float>);
-
35DLAF_CUBLAS_ADD_ETI(extern, std::complex<double>);
-
36}
-
37
-
38#endif
+
23namespace dlaf::gpulapack {
+
24
+
25template <class T>
+
26void add(const blas::Uplo uplo, const SizeType m, const SizeType n, const T& alpha, const T* a,
+
27 const SizeType lda, T* b, const SizeType ldb, const whip::stream_t stream);
+
28
+
29#define DLAF_CUBLAS_ADD_ETI(kword, Type) \
+
30 kword template void add(const blas::Uplo uplo, const SizeType m, const SizeType n, const Type& alpha, \
+
31 const Type* a, const SizeType lda, Type* b, const SizeType ldb, \
+
32 const whip::stream_t stream)
+
33
+
34DLAF_CUBLAS_ADD_ETI(extern, float);
+
35DLAF_CUBLAS_ADD_ETI(extern, double);
+
36DLAF_CUBLAS_ADD_ETI(extern, std::complex<float>);
+
37DLAF_CUBLAS_ADD_ETI(extern, std::complex<double>);
+
38}
+
39
+
40#endif
dlaf::tile::add
void add(T alpha, const matrix::Tile< const T, D > &tile_b, const matrix::Tile< T, D > &tile_a)
types.h
diff --git a/master/auxiliary_2norm_2api_8h_source.html b/master/auxiliary_2norm_2api_8h_source.html index a17aac42cc..fe05c235f4 100644 --- a/master/auxiliary_2norm_2api_8h_source.html +++ b/master/auxiliary_2norm_2api_8h_source.html @@ -92,41 +92,43 @@
9//
10#pragma once
11
-
12#include <pika/execution.hpp>
+
12#include <complex>
13
-
14#include <dlaf/communication/communicator_grid.h>
-
15#include <dlaf/matrix/matrix.h>
-
16#include <dlaf/types.h>
-
17
-
18namespace dlaf::auxiliary::internal {
+
14#include <pika/execution.hpp>
+
15
+
16#include <dlaf/communication/communicator_grid.h>
+
17#include <dlaf/matrix/matrix.h>
+
18#include <dlaf/types.h>
19
-
20template <Backend backend, Device device, class T>
-
21struct Norm {};
-
22
-
23template <class T>
-
-
24struct Norm<Backend::MC, Device::CPU, T> {
-
25 static pika::execution::experimental::unique_any_sender<dlaf::BaseType<T>> max_L(
-
26 comm::CommunicatorGrid& comm_grid, comm::Index2D rank, Matrix<const T, Device::CPU>& matrix);
-
27
-
28 static pika::execution::experimental::unique_any_sender<dlaf::BaseType<T>> max_G(
-
29 comm::CommunicatorGrid& comm_grid, comm::Index2D rank, Matrix<const T, Device::CPU>& matrix);
-
30};
+
20namespace dlaf::auxiliary::internal {
+
21
+
22template <Backend backend, Device device, class T>
+
23struct Norm {};
+
24
+
25template <class T>
+
+
26struct Norm<Backend::MC, Device::CPU, T> {
+
27 static pika::execution::experimental::unique_any_sender<dlaf::BaseType<T>> max_L(
+
28 comm::CommunicatorGrid& comm_grid, comm::Index2D rank, Matrix<const T, Device::CPU>& matrix);
+
29
+
30 static pika::execution::experimental::unique_any_sender<dlaf::BaseType<T>> max_G(
+
31 comm::CommunicatorGrid& comm_grid, comm::Index2D rank, Matrix<const T, Device::CPU>& matrix);
+
32};
-
31
-
32// ETI
-
33#define DLAF_NORM_ETI(KWORD, DATATYPE) KWORD template struct Norm<Backend::MC, Device::CPU, DATATYPE>;
-
34
-
35DLAF_NORM_ETI(extern, float)
-
36DLAF_NORM_ETI(extern, double)
-
37DLAF_NORM_ETI(extern, std::complex<float>)
-
38DLAF_NORM_ETI(extern, std::complex<double>)
-
39}
+
33
+
34// ETI
+
35#define DLAF_NORM_ETI(KWORD, DATATYPE) KWORD template struct Norm<Backend::MC, Device::CPU, DATATYPE>;
+
36
+
37DLAF_NORM_ETI(extern, float)
+
38DLAF_NORM_ETI(extern, double)
+
39DLAF_NORM_ETI(extern, std::complex<float>)
+
40DLAF_NORM_ETI(extern, std::complex<double>)
+
41}
dlaf::comm::CommunicatorGrid
Definition communicator_grid.h:37
dlaf::common::Index2D< IndexT_MPI, TAG_MPI >
communicator_grid.h
matrix.h
-
dlaf::auxiliary::internal::Norm
Definition api.h:21
+
dlaf::auxiliary::internal::Norm
Definition api.h:23
types.h
diff --git a/master/auxiliary_2norm_2mc_8h_source.html b/master/auxiliary_2norm_2mc_8h_source.html index 1176b6a80c..8dea521cc3 100644 --- a/master/auxiliary_2norm_2mc_8h_source.html +++ b/master/auxiliary_2norm_2mc_8h_source.html @@ -249,7 +249,7 @@
dlaf::comm::Communicator::rank
IndexT_MPI rank() const noexcept
Return the rank of the current process in the Communicator.
dlaf::common::Index2D< IndexT_MPI, TAG_MPI >
dlaf::internal::Policy
Definition policy.h:24
-
dlaf::matrix::Matrix
Definition matrix.h:61
+
dlaf::matrix::Matrix
Definition matrix.h:62
dlaf::common::make_data
auto make_data(Data &&data) noexcept
Definition data.h:78
distribution.h
reduce.h
@@ -263,8 +263,8 @@
reduce.h
types.h
util_matrix.h
-
dlaf::matrix::square_blocksize
bool square_blocksize(const MatrixLike &m) noexcept
Returns true if the matrix block size is square.
Definition util_matrix.h:48
-
dlaf::matrix::square_size
bool square_size(const MatrixLike &m) noexcept
Returns true if the matrix is square.
Definition util_matrix.h:42
+
dlaf::matrix::square_blocksize
bool square_blocksize(const MatrixLike &m) noexcept
Returns true if the matrix block size is square.
Definition util_matrix.h:49
+
dlaf::matrix::square_size
bool square_size(const MatrixLike &m) noexcept
Returns true if the matrix is square.
Definition util_matrix.h:43
vector.h
diff --git a/master/band__to__tridiag_8h_source.html b/master/band__to__tridiag_8h_source.html index 79f2b0ff62..989a08f097 100644 --- a/master/band__to__tridiag_8h_source.html +++ b/master/band__to__tridiag_8h_source.html @@ -166,8 +166,8 @@
dlaf::common::Size2D< IndexT_MPI, TAG_MPI >
communicator_grid.h
matrix.h
-
dlaf::eigensolver::internal::BandToTridiag
Definition api.h:37
-
dlaf::eigensolver::internal::TridiagResult
Definition api.h:19
+
dlaf::eigensolver::internal::BandToTridiag
Definition api.h:39
+
dlaf::eigensolver::internal::TridiagResult
Definition api.h:21
types.h
util_matrix.h
diff --git a/master/blas_2tile_8h_source.html b/master/blas_2tile_8h_source.html index 24944242af..c47abaf45e 100644 --- a/master/blas_2tile_8h_source.html +++ b/master/blas_2tile_8h_source.html @@ -413,7 +413,7 @@
DLAF_MAKE_CALLABLE_OBJECT
#define DLAF_MAKE_CALLABLE_OBJECT(fname)
Definition callable_object.h:29
dlaf::common::internal::SingleThreadedBlasScope
Definition single_threaded_blas.h:20
dlaf::internal::Policy
Definition policy.h:24
-
dlaf::matrix::Tile
Definition tile.h:332
+
dlaf::matrix::Tile
Definition tile.h:333
copy_tile.h
gpublas.h
tile.h
diff --git a/master/broadcast__panel_8h_source.html b/master/broadcast__panel_8h_source.html index 579337e6a2..67600e7b0f 100644 --- a/master/broadcast__panel_8h_source.html +++ b/master/broadcast__panel_8h_source.html @@ -261,8 +261,8 @@
dlaf::comm::broadcast
void broadcast(comm::IndexT_MPI rank_root, matrix::Panel< axis, T, D, storage > &panel, comm::CommunicatorPipeline< coord_to_communicator_type(orthogonal(axis))> &serial_comm)
Definition broadcast_panel.h:61
dlaf::comm::CommunicatorPipeline
Definition communicator_pipeline.h:41
dlaf::common::Index2D< SizeType, matrix::LocalTile_TAG >
-
dlaf::matrix::Matrix
Definition matrix.h:61
-
dlaf::matrix::Matrix::readwrite
ReadWriteSenderType readwrite(const LocalTileIndex &index) noexcept
Definition matrix.h:153
+
dlaf::matrix::Matrix
Definition matrix.h:62
+
dlaf::matrix::Matrix::readwrite
ReadWriteSenderType readwrite(const LocalTileIndex &index) noexcept
Definition matrix.h:154
index.h
dlaf::comm::IndexT_MPI
int IndexT_MPI
Type used for indexes in MPI API.
Definition index.h:20
communicator_pipeline.h
diff --git a/master/bt__band__to__tridiag_8h_source.html b/master/bt__band__to__tridiag_8h_source.html index a31375af1a..b4e3349813 100644 --- a/master/bt__band__to__tridiag_8h_source.html +++ b/master/bt__band__to__tridiag_8h_source.html @@ -147,11 +147,11 @@
133}
dlaf::eigensolver::internal::bt_band_to_tridiagonal
void bt_band_to_tridiagonal(const SizeType band_size, MatrixRef< T, D > &mat_e, matrix::Matrix< const T, Device::CPU > &mat_hh)
Definition bt_band_to_tridiag.h:60
dlaf::comm::CommunicatorGrid
Definition communicator_grid.h:37
-
dlaf::matrix::Matrix
Definition matrix.h:61
-
dlaf::matrix::internal::MatrixRef
Definition matrix_ref.h:171
+
dlaf::matrix::Matrix
Definition matrix.h:62
+
dlaf::matrix::internal::MatrixRef
Definition matrix_ref.h:172
matrix.h
matrix_ref.h
-
dlaf::eigensolver::internal::BackTransformationT2B
Definition api.h:23
+
dlaf::eigensolver::internal::BackTransformationT2B
Definition api.h:25
types.h
util_matrix.h
diff --git a/master/bt__reduction__to__band_8h_source.html b/master/bt__reduction__to__band_8h_source.html index 21473bb54d..59a23e30cc 100644 --- a/master/bt__reduction__to__band_8h_source.html +++ b/master/bt__reduction__to__band_8h_source.html @@ -156,11 +156,11 @@
108}
dlaf::eigensolver::internal::bt_reduction_to_band
void bt_reduction_to_band(const SizeType b, MatrixRef< T, device > &mat_c, Matrix< const T, device > &mat_v, Matrix< const T, Device::CPU > &mat_taus)
Definition bt_reduction_to_band.h:45
dlaf::comm::CommunicatorGrid
Definition communicator_grid.h:37
-
dlaf::matrix::internal::MatrixRef
Definition matrix_ref.h:171
+
dlaf::matrix::internal::MatrixRef
Definition matrix_ref.h:172
communicator_grid.h
matrix.h
matrix_ref.h
-
dlaf::eigensolver::internal::BackTransformationReductionToBand
Definition api.h:21
+
dlaf::eigensolver::internal::BackTransformationReductionToBand
Definition api.h:23
types.h
util_matrix.h
diff --git a/master/copy_8h_source.html b/master/copy_8h_source.html index 4991d71879..28ac979d55 100644 --- a/master/copy_8h_source.html +++ b/master/copy_8h_source.html @@ -283,9 +283,9 @@
dlaf::common::Index2D< SizeType, matrix::LocalTile_TAG >
dlaf::common::Size2D< SizeType, matrix::LocalTile_TAG >
dlaf::internal::Policy
Definition policy.h:24
-
dlaf::matrix::Matrix
Definition matrix.h:61
-
dlaf::matrix::Matrix::retiledSubPipeline
Matrix retiledSubPipeline(const LocalTileSize &tiles_per_block) noexcept
Definition matrix.h:184
-
dlaf::matrix::Matrix::readwrite
ReadWriteSenderType readwrite(const LocalTileIndex &index) noexcept
Definition matrix.h:153
+
dlaf::matrix::Matrix
Definition matrix.h:62
+
dlaf::matrix::Matrix::retiledSubPipeline
Matrix retiledSubPipeline(const LocalTileSize &tiles_per_block) noexcept
Definition matrix.h:185
+
dlaf::matrix::Matrix::readwrite
ReadWriteSenderType readwrite(const LocalTileIndex &index) noexcept
Definition matrix.h:154
dlaf::comm::IndexT_MPI
int IndexT_MPI
Type used for indexes in MPI API.
Definition index.h:20
communicator.h
copy_tile.h
@@ -301,10 +301,10 @@
dlaf::to_int
auto to_int(const T unsigned_value)
Definition types.h:248
util_math.h
util_matrix.h
-
dlaf::matrix::equal_process_grid
bool equal_process_grid(const MatrixLike< const T, D > &m, const comm::CommunicatorGrid &g) noexcept
Returns true if the matrix is distributed on the communication grid.
Definition util_matrix.h:78
-
dlaf::matrix::single_tile_per_block
bool single_tile_per_block(const MatrixLike &m) noexcept
Returns true if the matrix has a single tile per block.
Definition util_matrix.h:54
-
dlaf::matrix::local_matrix
bool local_matrix(const MatrixLike< const T, D > &m) noexcept
Returns true if the matrix is local to a process.
Definition util_matrix.h:72
-
dlaf::matrix::equal_size
bool equal_size(const MatrixLikeA &lhs, const MatrixLikeB &rhs) noexcept
Returns true if matrices have equal sizes.
Definition util_matrix.h:60
+
dlaf::matrix::equal_process_grid
bool equal_process_grid(const MatrixLike< const T, D > &m, const comm::CommunicatorGrid &g) noexcept
Returns true if the matrix is distributed on the communication grid.
Definition util_matrix.h:79
+
dlaf::matrix::single_tile_per_block
bool single_tile_per_block(const MatrixLike &m) noexcept
Returns true if the matrix has a single tile per block.
Definition util_matrix.h:55
+
dlaf::matrix::local_matrix
bool local_matrix(const MatrixLike< const T, D > &m) noexcept
Returns true if the matrix is local to a process.
Definition util_matrix.h:73
+
dlaf::matrix::equal_size
bool equal_size(const MatrixLikeA &lhs, const MatrixLikeB &rhs) noexcept
Returns true if matrices have equal sizes.
Definition util_matrix.h:61
diff --git a/master/copy__tile_8h_source.html b/master/copy__tile_8h_source.html index 39b97df93b..42328b8821 100644 --- a/master/copy__tile_8h_source.html +++ b/master/copy__tile_8h_source.html @@ -296,8 +296,8 @@
208}
callable_object.h
DLAF_MAKE_CALLABLE_OBJECT
#define DLAF_MAKE_CALLABLE_OBJECT(fname)
Definition callable_object.h:29
-
dlaf::matrix::Matrix
Definition matrix.h:61
-
dlaf::memory::MemoryView
Definition memory_view.h:32
+
dlaf::matrix::Matrix
Definition matrix.h:62
+
dlaf::memory::MemoryView
Definition memory_view.h:33
dlaf::matrix::DuplicateNoCopy
Definition copy_tile.h:199
diff --git a/master/distribution_8h_source.html b/master/distribution_8h_source.html index dd3138013e..cc129c8ecb 100644 --- a/master/distribution_8h_source.html +++ b/master/distribution_8h_source.html @@ -924,7 +924,7 @@
dlaf::matrix::Distribution::rank_global_tile
comm::Index2D rank_global_tile(const GlobalTileIndex &global_tile) const noexcept
Definition distribution.h:310
dlaf::matrix::Distribution::tile_element_index
TileElementIndex tile_element_index(const GlobalElementIndex &global_element) const noexcept
Definition distribution.h:335
dlaf::matrix::Distribution::next_local_tile_from_global_element
SizeType next_local_tile_from_global_element(SizeType global_element) const noexcept
Definition distribution.h:494
-
dlaf::matrix::Matrix
Definition matrix.h:61
+
dlaf::matrix::Matrix
Definition matrix.h:62
communicator_grid.h
dlaf::matrix::internal::distribution::tile_element_offset_from_sub_distribution
TileElementIndex tile_element_offset_from_sub_distribution(const Distribution &distribution, const GlobalElementIndex &sub_offset, const Distribution &sub_distribution, const GlobalTileIndex &sub_index) noexcept
Definition distribution_extensions.h:198
dlaf::matrix::internal::distribution::global_tile_linear_index
SizeType global_tile_linear_index(const Distribution &dist, GlobalElementIndex i_gl) noexcept
Returns a global linear column-major index of the tile that contains ij.
Definition distribution_extensions.h:231
diff --git a/master/distribution__extensions_8h_source.html b/master/distribution__extensions_8h_source.html index 20c10921ca..7e32843158 100644 --- a/master/distribution__extensions_8h_source.html +++ b/master/distribution__extensions_8h_source.html @@ -335,7 +335,7 @@
dlaf::matrix::Distribution
Definition distribution.h:111
-
dlaf::matrix::Matrix
Definition matrix.h:61
+
dlaf::matrix::Matrix
Definition matrix.h:62
dlaf::comm::IndexT_MPI
int IndexT_MPI
Type used for indexes in MPI API.
Definition index.h:20
diff --git a/master/dlaf_2eigensolver_2eigensolver_8h_source.html b/master/dlaf_2eigensolver_2eigensolver_8h_source.html index 9f2f821b14..9979037dcc 100644 --- a/master/dlaf_2eigensolver_2eigensolver_8h_source.html +++ b/master/dlaf_2eigensolver_2eigensolver_8h_source.html @@ -232,12 +232,12 @@
dlaf::comm::CommunicatorGrid
Definition communicator_grid.h:37
dlaf::comm::CommunicatorGrid::size
Size2D size() const noexcept
Return the number of rows in the grid.
Definition communicator_grid.h:79
-
dlaf::matrix::Matrix
Definition matrix.h:61
+
dlaf::matrix::Matrix
Definition matrix.h:62
communicator_grid.h
dlaf::hermitian_eigensolver
void hermitian_eigensolver(blas::Uplo uplo, Matrix< T, D > &mat, Matrix< BaseType< T >, D > &eigenvalues, Matrix< T, D > &eigenvectors, const SizeType eigenvalues_index_begin, const SizeType eigenvalues_index_end)
Definition eigensolver.h:33
-
dlaf::EigensolverResult
Definition api.h:22
- +
dlaf::EigensolverResult
Definition api.h:24
+
util_matrix.h
diff --git a/master/eigensolver_2band__to__tridiag_2api_8h_source.html b/master/eigensolver_2band__to__tridiag_2api_8h_source.html index 65243b84d2..089832322c 100644 --- a/master/eigensolver_2band__to__tridiag_2api_8h_source.html +++ b/master/eigensolver_2band__to__tridiag_2api_8h_source.html @@ -93,65 +93,67 @@
10
11#pragma once
12
-
13#include <dlaf/matrix/matrix.h>
-
14#include <dlaf/types.h>
-
15
-
16namespace dlaf::eigensolver::internal {
+
13#include <complex>
+
14
+
15#include <dlaf/matrix/matrix.h>
+
16#include <dlaf/types.h>
17
-
18template <class T, Device D>
-
-
19struct TridiagResult {
-
20 Matrix<BaseType<T>, D> tridiagonal;
-
21 Matrix<T, D> hh_reflectors;
-
22};
+
18namespace dlaf::eigensolver::internal {
+
19
+
20template <class T, Device D>
+
+
21struct TridiagResult {
+
22 Matrix<BaseType<T>, D> tridiagonal;
+
23 Matrix<T, D> hh_reflectors;
+
24};
-
23
-
24template <class T>
-
25SizeType nrSweeps(SizeType size) noexcept {
-
26 // Complex needs an extra sweep to have a real tridiagonal matrix.
-
27 return isComplex_v<T> ? size - 1 : size - 2;
-
28}
-
29
-
30inline SizeType nrStepsForSweep(SizeType sweep, SizeType size, SizeType band) noexcept {
-
31 // Sweep size-2 should be handled differently
-
32 // as it is executed only for complex types (see nrSweeps)
-
33 return sweep == size - 2 ? 1 : util::ceilDiv(size - sweep - 2, band);
-
34}
-
35
-
36template <Backend B, Device D, class T>
-
37struct BandToTridiag;
-
38
-
39template <Device D, class T>
-
-
40struct BandToTridiag<Backend::MC, D, T> {
-
41 static TridiagResult<T, Device::CPU> call_L(const SizeType b, Matrix<const T, D>& mat_a) noexcept;
-
42 static TridiagResult<T, Device::CPU> call_L(comm::CommunicatorGrid& grid, const SizeType b,
-
43 Matrix<const T, D>& mat_a) noexcept;
-
44};
+
25
+
26template <class T>
+
27SizeType nrSweeps(SizeType size) noexcept {
+
28 // Complex needs an extra sweep to have a real tridiagonal matrix.
+
29 return isComplex_v<T> ? size - 1 : size - 2;
+
30}
+
31
+
32inline SizeType nrStepsForSweep(SizeType sweep, SizeType size, SizeType band) noexcept {
+
33 // Sweep size-2 should be handled differently
+
34 // as it is executed only for complex types (see nrSweeps)
+
35 return sweep == size - 2 ? 1 : util::ceilDiv(size - sweep - 2, band);
+
36}
+
37
+
38template <Backend B, Device D, class T>
+
39struct BandToTridiag;
+
40
+
41template <Device D, class T>
+
+
42struct BandToTridiag<Backend::MC, D, T> {
+
43 static TridiagResult<T, Device::CPU> call_L(const SizeType b, Matrix<const T, D>& mat_a) noexcept;
+
44 static TridiagResult<T, Device::CPU> call_L(comm::CommunicatorGrid& grid, const SizeType b,
+
45 Matrix<const T, D>& mat_a) noexcept;
+
46};
-
45
-
46// ETI
-
47#define DLAF_EIGENSOLVER_B2T_ETI(KWORD, BACKEND, DEVICE, DATATYPE) \
-
48 KWORD template struct BandToTridiag<BACKEND, DEVICE, DATATYPE>;
-
49#define DLAF_EIGENSOLVER_B2T_DISTR_ETI(KWORD, BACKEND, DEVICE, DATATYPE) \
-
50 KWORD template struct BandToTridiagDistr<BACKEND, DEVICE, DATATYPE>;
-
51
-
52DLAF_EIGENSOLVER_B2T_ETI(extern, Backend::MC, Device::CPU, float)
-
53DLAF_EIGENSOLVER_B2T_ETI(extern, Backend::MC, Device::CPU, double)
-
54DLAF_EIGENSOLVER_B2T_ETI(extern, Backend::MC, Device::CPU, std::complex<float>)
-
55DLAF_EIGENSOLVER_B2T_ETI(extern, Backend::MC, Device::CPU, std::complex<double>)
-
56
-
57#ifdef DLAF_WITH_GPU
-
58DLAF_EIGENSOLVER_B2T_ETI(extern, Backend::MC, Device::GPU, float)
-
59DLAF_EIGENSOLVER_B2T_ETI(extern, Backend::MC, Device::GPU, double)
-
60DLAF_EIGENSOLVER_B2T_ETI(extern, Backend::MC, Device::GPU, std::complex<float>)
-
61DLAF_EIGENSOLVER_B2T_ETI(extern, Backend::MC, Device::GPU, std::complex<double>)
-
62#endif
-
63}
+
47
+
48// ETI
+
49#define DLAF_EIGENSOLVER_B2T_ETI(KWORD, BACKEND, DEVICE, DATATYPE) \
+
50 KWORD template struct BandToTridiag<BACKEND, DEVICE, DATATYPE>;
+
51#define DLAF_EIGENSOLVER_B2T_DISTR_ETI(KWORD, BACKEND, DEVICE, DATATYPE) \
+
52 KWORD template struct BandToTridiagDistr<BACKEND, DEVICE, DATATYPE>;
+
53
+
54DLAF_EIGENSOLVER_B2T_ETI(extern, Backend::MC, Device::CPU, float)
+
55DLAF_EIGENSOLVER_B2T_ETI(extern, Backend::MC, Device::CPU, double)
+
56DLAF_EIGENSOLVER_B2T_ETI(extern, Backend::MC, Device::CPU, std::complex<float>)
+
57DLAF_EIGENSOLVER_B2T_ETI(extern, Backend::MC, Device::CPU, std::complex<double>)
+
58
+
59#ifdef DLAF_WITH_GPU
+
60DLAF_EIGENSOLVER_B2T_ETI(extern, Backend::MC, Device::GPU, float)
+
61DLAF_EIGENSOLVER_B2T_ETI(extern, Backend::MC, Device::GPU, double)
+
62DLAF_EIGENSOLVER_B2T_ETI(extern, Backend::MC, Device::GPU, std::complex<float>)
+
63DLAF_EIGENSOLVER_B2T_ETI(extern, Backend::MC, Device::GPU, std::complex<double>)
+
64#endif
+
65}
dlaf::comm::CommunicatorGrid
Definition communicator_grid.h:37
- - + +
diff --git a/master/eigensolver_2band__to__tridiag_2mc_8h_source.html b/master/eigensolver_2band__to__tridiag_2mc_8h_source.html index 09992d2c8d..fd82dac049 100644 --- a/master/eigensolver_2band__to__tridiag_2mc_8h_source.html +++ b/master/eigensolver_2band__to__tridiag_2mc_8h_source.html @@ -1663,8 +1663,8 @@
dlaf::internal::Policy
Definition policy.h:24
dlaf::matrix::Distribution
Definition distribution.h:111
-
dlaf::matrix::Matrix
Definition matrix.h:61
-
dlaf::memory::MemoryView
Definition memory_view.h:32
+
dlaf::matrix::Matrix
Definition matrix.h:62
+
dlaf::memory::MemoryView
Definition memory_view.h:33
dlaf::comm::IndexT_MPI
int IndexT_MPI
Type used for indexes in MPI API.
Definition index.h:20
@@ -1676,7 +1676,7 @@ -
dlaf::matrix::splitTile
ReadOnlyTileSender< T, D > splitTile(ReadOnlyTileSender< T, D > tile, const SubTileSpec &spec)
Definition tile.h:510
+
dlaf::matrix::splitTile
ReadOnlyTileSender< T, D > splitTile(ReadOnlyTileSender< T, D > tile, const SubTileSpec &spec)
Definition tile.h:511
memory_view.h
@@ -1685,8 +1685,8 @@
single_threaded_blas.h
dlaf::comm::mpi_datatype
Mapper between language types and basic MPI_Datatype.
Definition datatypes.h:24
dlaf::common::internal::vector
Definition vector.h:27
- - + +
dlaf::to_sizet
auto to_sizet(const T signed_value)
Definition types.h:266
diff --git a/master/eigensolver_2bt__band__to__tridiag_2api_8h_source.html b/master/eigensolver_2bt__band__to__tridiag_2api_8h_source.html index ff87398e02..346cf225fe 100644 --- a/master/eigensolver_2bt__band__to__tridiag_2api_8h_source.html +++ b/master/eigensolver_2bt__band__to__tridiag_2api_8h_source.html @@ -93,47 +93,49 @@
10
11#pragma once
12
-
13#include <dlaf/communication/communicator_grid.h>
-
14#include <dlaf/matrix/matrix.h>
-
15#include <dlaf/matrix/matrix_ref.h>
-
16#include <dlaf/types.h>
-
17
-
18namespace dlaf::eigensolver::internal {
+
13#include <complex>
+
14
+
15#include <dlaf/communication/communicator_grid.h>
+
16#include <dlaf/matrix/matrix.h>
+
17#include <dlaf/matrix/matrix_ref.h>
+
18#include <dlaf/types.h>
19
-
20using matrix::internal::MatrixRef;
+
20namespace dlaf::eigensolver::internal {
21
-
22template <Backend B, Device D, class T>
-
-
23struct BackTransformationT2B {
-
24 static void call(const SizeType band_size, MatrixRef<T, D>& mat_e,
-
25 Matrix<const T, Device::CPU>& mat_hh);
-
26 static void call(comm::CommunicatorGrid& grid, const SizeType band_size, MatrixRef<T, D>& mat_e,
+
22using matrix::internal::MatrixRef;
+
23
+
24template <Backend B, Device D, class T>
+
+
25struct BackTransformationT2B {
+
26 static void call(const SizeType band_size, MatrixRef<T, D>& mat_e,
27 Matrix<const T, Device::CPU>& mat_hh);
-
28};
+
28 static void call(comm::CommunicatorGrid& grid, const SizeType band_size, MatrixRef<T, D>& mat_e,
+
29 Matrix<const T, Device::CPU>& mat_hh);
+
30};
-
29
-
30// ETI
-
31#define DLAF_EIGENSOLVER_BT_BAND_TO_TRIDIAGONAL_ETI(KWORD, BACKEND, DEVICE, T) \
-
32 KWORD template struct BackTransformationT2B<BACKEND, DEVICE, T>;
-
33
-
34DLAF_EIGENSOLVER_BT_BAND_TO_TRIDIAGONAL_ETI(extern, Backend::MC, Device::CPU, float)
-
35DLAF_EIGENSOLVER_BT_BAND_TO_TRIDIAGONAL_ETI(extern, Backend::MC, Device::CPU, double)
-
36DLAF_EIGENSOLVER_BT_BAND_TO_TRIDIAGONAL_ETI(extern, Backend::MC, Device::CPU, std::complex<float>)
-
37DLAF_EIGENSOLVER_BT_BAND_TO_TRIDIAGONAL_ETI(extern, Backend::MC, Device::CPU, std::complex<double>)
-
38
-
39#ifdef DLAF_WITH_GPU
-
40DLAF_EIGENSOLVER_BT_BAND_TO_TRIDIAGONAL_ETI(extern, Backend::GPU, Device::GPU, float)
-
41DLAF_EIGENSOLVER_BT_BAND_TO_TRIDIAGONAL_ETI(extern, Backend::GPU, Device::GPU, double)
-
42DLAF_EIGENSOLVER_BT_BAND_TO_TRIDIAGONAL_ETI(extern, Backend::GPU, Device::GPU, std::complex<float>)
-
43DLAF_EIGENSOLVER_BT_BAND_TO_TRIDIAGONAL_ETI(extern, Backend::GPU, Device::GPU, std::complex<double>)
-
44#endif
-
45}
+
31
+
32// ETI
+
33#define DLAF_EIGENSOLVER_BT_BAND_TO_TRIDIAGONAL_ETI(KWORD, BACKEND, DEVICE, T) \
+
34 KWORD template struct BackTransformationT2B<BACKEND, DEVICE, T>;
+
35
+
36DLAF_EIGENSOLVER_BT_BAND_TO_TRIDIAGONAL_ETI(extern, Backend::MC, Device::CPU, float)
+
37DLAF_EIGENSOLVER_BT_BAND_TO_TRIDIAGONAL_ETI(extern, Backend::MC, Device::CPU, double)
+
38DLAF_EIGENSOLVER_BT_BAND_TO_TRIDIAGONAL_ETI(extern, Backend::MC, Device::CPU, std::complex<float>)
+
39DLAF_EIGENSOLVER_BT_BAND_TO_TRIDIAGONAL_ETI(extern, Backend::MC, Device::CPU, std::complex<double>)
+
40
+
41#ifdef DLAF_WITH_GPU
+
42DLAF_EIGENSOLVER_BT_BAND_TO_TRIDIAGONAL_ETI(extern, Backend::GPU, Device::GPU, float)
+
43DLAF_EIGENSOLVER_BT_BAND_TO_TRIDIAGONAL_ETI(extern, Backend::GPU, Device::GPU, double)
+
44DLAF_EIGENSOLVER_BT_BAND_TO_TRIDIAGONAL_ETI(extern, Backend::GPU, Device::GPU, std::complex<float>)
+
45DLAF_EIGENSOLVER_BT_BAND_TO_TRIDIAGONAL_ETI(extern, Backend::GPU, Device::GPU, std::complex<double>)
+
46#endif
+
47}
dlaf::comm::CommunicatorGrid
Definition communicator_grid.h:37
-
dlaf::matrix::internal::MatrixRef
Definition matrix_ref.h:171
+
dlaf::matrix::internal::MatrixRef
Definition matrix_ref.h:172
communicator_grid.h
matrix_ref.h
- +
diff --git a/master/eigensolver_2bt__band__to__tridiag_2impl_8h_source.html b/master/eigensolver_2bt__band__to__tridiag_2impl_8h_source.html index b0652e2386..7021c46cc1 100644 --- a/master/eigensolver_2bt__band__to__tridiag_2impl_8h_source.html +++ b/master/eigensolver_2bt__band__to__tridiag_2impl_8h_source.html @@ -1123,10 +1123,10 @@
dlaf::common::internal::SingleThreadedBlasScope
Definition single_threaded_blas.h:20
dlaf::internal::Policy
Definition policy.h:24
dlaf::matrix::Distribution
Definition distribution.h:111
-
dlaf::matrix::Matrix
Definition matrix.h:61
-
dlaf::matrix::Matrix::readwrite
ReadWriteSenderType readwrite(const LocalTileIndex &index) noexcept
Definition matrix.h:153
-
dlaf::matrix::internal::MatrixRef
Definition matrix_ref.h:171
-
dlaf::matrix::internal::MatrixRef::retiledSubPipeline
Matrix< T, D > retiledSubPipeline(const LocalTileSize &tiles_per_block) noexcept
Definition matrix_ref.h:212
+
dlaf::matrix::Matrix
Definition matrix.h:62
+
dlaf::matrix::Matrix::readwrite
ReadWriteSenderType readwrite(const LocalTileIndex &index) noexcept
Definition matrix.h:154
+
dlaf::matrix::internal::MatrixRef
Definition matrix_ref.h:172
+
dlaf::matrix::internal::MatrixRef::retiledSubPipeline
Matrix< T, D > retiledSubPipeline(const LocalTileSize &tiles_per_block) noexcept
Definition matrix_ref.h:213
dlaf::comm::IndexT_MPI
int IndexT_MPI
Type used for indexes in MPI API.
Definition index.h:20
@@ -1137,7 +1137,7 @@ -
dlaf::matrix::splitTile
ReadOnlyTileSender< T, D > splitTile(ReadOnlyTileSender< T, D > tile, const SubTileSpec &spec)
Definition tile.h:510
+
dlaf::matrix::splitTile
ReadOnlyTileSender< T, D > splitTile(ReadOnlyTileSender< T, D > tile, const SubTileSpec &spec)
Definition tile.h:511
p2p_allsum.h
@@ -1146,14 +1146,14 @@
round_robin.h
single_threaded_blas.h
- +
dlaf::eigensolver::internal::bt_tridiag::ApplyHHToDoubleTileRow
Definition impl.h:261
dlaf::eigensolver::internal::bt_tridiag::ApplyHHToSingleTileRow
Definition impl.h:176
dlaf::eigensolver::internal::bt_tridiag::DistIndexing
Definition impl.h:448
dlaf::eigensolver::internal::bt_tridiag::HHManager
Definition impl.h:503
dlaf::eigensolver::internal::bt_tridiag::TileAccessHelper
Definition impl.h:324
dlaf::matrix::Panel
Definition panel.h:589
-
dlaf::matrix::SubTileSpec
Contains the information to create a subtile.
Definition tile.h:112
+
dlaf::matrix::SubTileSpec
Contains the information to create a subtile.
Definition tile.h:113
dlaf::to_sizet
auto to_sizet(const T signed_value)
Definition types.h:266
diff --git a/master/eigensolver_2bt__reduction__to__band_2api_8h_source.html b/master/eigensolver_2bt__reduction__to__band_2api_8h_source.html index 96569002a7..153ee0a39c 100644 --- a/master/eigensolver_2bt__reduction__to__band_2api_8h_source.html +++ b/master/eigensolver_2bt__reduction__to__band_2api_8h_source.html @@ -92,46 +92,48 @@
9//
10#pragma once
11
-
12#include <dlaf/matrix/matrix.h>
-
13#include <dlaf/matrix/matrix_ref.h>
-
14#include <dlaf/types.h>
-
15
-
16namespace dlaf::eigensolver::internal {
+
12#include <complex>
+
13
+
14#include <dlaf/matrix/matrix.h>
+
15#include <dlaf/matrix/matrix_ref.h>
+
16#include <dlaf/types.h>
17
-
18using matrix::internal::MatrixRef;
+
18namespace dlaf::eigensolver::internal {
19
-
20template <Backend backend, Device device, class T>
-
-
21struct BackTransformationReductionToBand {
-
22 static void call(SizeType b, MatrixRef<T, device>& mat_c, Matrix<const T, device>& mat_v,
-
23 Matrix<const T, Device::CPU>& mat_taus);
-
24
-
25 static void call(comm::CommunicatorGrid& grid, const SizeType b, MatrixRef<T, device>& mat_c,
-
26 Matrix<const T, device>& mat_v, Matrix<const T, Device::CPU>& mat_taus);
-
27};
+
20using matrix::internal::MatrixRef;
+
21
+
22template <Backend backend, Device device, class T>
+
+
23struct BackTransformationReductionToBand {
+
24 static void call(SizeType b, MatrixRef<T, device>& mat_c, Matrix<const T, device>& mat_v,
+
25 Matrix<const T, Device::CPU>& mat_taus);
+
26
+
27 static void call(comm::CommunicatorGrid& grid, const SizeType b, MatrixRef<T, device>& mat_c,
+
28 Matrix<const T, device>& mat_v, Matrix<const T, Device::CPU>& mat_taus);
+
29};
-
28
-
29// ETI
-
30#define DLAF_EIGENSOLVER_BT_REDUCTION_TO_BAND_ETI(KWORD, BACKEND, DEVICE, DATATYPE) \
-
31 KWORD template struct BackTransformationReductionToBand<BACKEND, DEVICE, DATATYPE>;
-
32
-
33DLAF_EIGENSOLVER_BT_REDUCTION_TO_BAND_ETI(extern, Backend::MC, Device::CPU, float)
-
34DLAF_EIGENSOLVER_BT_REDUCTION_TO_BAND_ETI(extern, Backend::MC, Device::CPU, double)
-
35DLAF_EIGENSOLVER_BT_REDUCTION_TO_BAND_ETI(extern, Backend::MC, Device::CPU, std::complex<float>)
-
36DLAF_EIGENSOLVER_BT_REDUCTION_TO_BAND_ETI(extern, Backend::MC, Device::CPU, std::complex<double>)
-
37
-
38#ifdef DLAF_WITH_GPU
-
39DLAF_EIGENSOLVER_BT_REDUCTION_TO_BAND_ETI(extern, Backend::GPU, Device::GPU, float)
-
40DLAF_EIGENSOLVER_BT_REDUCTION_TO_BAND_ETI(extern, Backend::GPU, Device::GPU, double)
-
41DLAF_EIGENSOLVER_BT_REDUCTION_TO_BAND_ETI(extern, Backend::GPU, Device::GPU, std::complex<float>)
-
42DLAF_EIGENSOLVER_BT_REDUCTION_TO_BAND_ETI(extern, Backend::GPU, Device::GPU, std::complex<double>)
-
43#endif
-
44}
+
30
+
31// ETI
+
32#define DLAF_EIGENSOLVER_BT_REDUCTION_TO_BAND_ETI(KWORD, BACKEND, DEVICE, DATATYPE) \
+
33 KWORD template struct BackTransformationReductionToBand<BACKEND, DEVICE, DATATYPE>;
+
34
+
35DLAF_EIGENSOLVER_BT_REDUCTION_TO_BAND_ETI(extern, Backend::MC, Device::CPU, float)
+
36DLAF_EIGENSOLVER_BT_REDUCTION_TO_BAND_ETI(extern, Backend::MC, Device::CPU, double)
+
37DLAF_EIGENSOLVER_BT_REDUCTION_TO_BAND_ETI(extern, Backend::MC, Device::CPU, std::complex<float>)
+
38DLAF_EIGENSOLVER_BT_REDUCTION_TO_BAND_ETI(extern, Backend::MC, Device::CPU, std::complex<double>)
+
39
+
40#ifdef DLAF_WITH_GPU
+
41DLAF_EIGENSOLVER_BT_REDUCTION_TO_BAND_ETI(extern, Backend::GPU, Device::GPU, float)
+
42DLAF_EIGENSOLVER_BT_REDUCTION_TO_BAND_ETI(extern, Backend::GPU, Device::GPU, double)
+
43DLAF_EIGENSOLVER_BT_REDUCTION_TO_BAND_ETI(extern, Backend::GPU, Device::GPU, std::complex<float>)
+
44DLAF_EIGENSOLVER_BT_REDUCTION_TO_BAND_ETI(extern, Backend::GPU, Device::GPU, std::complex<double>)
+
45#endif
+
46}
dlaf::comm::CommunicatorGrid
Definition communicator_grid.h:37
-
dlaf::matrix::internal::MatrixRef
Definition matrix_ref.h:171
+
dlaf::matrix::internal::MatrixRef
Definition matrix_ref.h:172
matrix_ref.h
- +
diff --git a/master/eigensolver_2bt__reduction__to__band_2impl_8h_source.html b/master/eigensolver_2bt__reduction__to__band_2impl_8h_source.html index 47d310d4ee..3a0f145f97 100644 --- a/master/eigensolver_2bt__reduction__to__band_2impl_8h_source.html +++ b/master/eigensolver_2bt__reduction__to__band_2impl_8h_source.html @@ -462,8 +462,8 @@
dlaf::common::internal::SingleThreadedBlasScope
Definition single_threaded_blas.h:20
dlaf::internal::Policy
Definition policy.h:24
dlaf::matrix::Distribution
Definition distribution.h:111
-
dlaf::matrix::Matrix
Definition matrix.h:61
-
dlaf::matrix::Matrix::readwrite
ReadWriteSenderType readwrite(const LocalTileIndex &index) noexcept
Definition matrix.h:153
+
dlaf::matrix::Matrix
Definition matrix.h:62
+
dlaf::matrix::Matrix::readwrite
ReadWriteSenderType readwrite(const LocalTileIndex &index) noexcept
Definition matrix.h:154
communicator_grid.h
@@ -474,7 +474,7 @@
dlaf::comm::schedule_all_reduce_in_place
dlaf::matrix::ReadWriteTileSender< T, D > schedule_all_reduce_in_place(pika::execution::experimental::unique_any_sender< CommunicatorPipelineExclusiveWrapper > pcomm, MPI_Op reduce_op, dlaf::matrix::ReadWriteTileSender< T, D > tile)
layout_info.h
-
dlaf::matrix::splitTile
ReadOnlyTileSender< T, D > splitTile(ReadOnlyTileSender< T, D > tile, const SubTileSpec &spec)
Definition tile.h:510
+
dlaf::matrix::splitTile
ReadOnlyTileSender< T, D > splitTile(ReadOnlyTileSender< T, D > tile, const SubTileSpec &spec)
Definition tile.h:511
matrix_ref.h
diff --git a/master/eigensolver_2eigensolver_2api_8h_source.html b/master/eigensolver_2eigensolver_2api_8h_source.html index f195d3e18f..694542f46b 100644 --- a/master/eigensolver_2eigensolver_2api_8h_source.html +++ b/master/eigensolver_2eigensolver_2api_8h_source.html @@ -93,59 +93,61 @@
10
11#pragma once
12
-
13#include <dlaf/blas/tile.h>
-
14#include <dlaf/common/vector.h>
-
15#include <dlaf/communication/communicator_grid.h>
-
16#include <dlaf/matrix/matrix.h>
-
17#include <dlaf/types.h>
-
18
-
19namespace dlaf {
+
13#include <complex>
+
14
+
15#include <dlaf/blas/tile.h>
+
16#include <dlaf/common/vector.h>
+
17#include <dlaf/communication/communicator_grid.h>
+
18#include <dlaf/matrix/matrix.h>
+
19#include <dlaf/types.h>
20
-
21template <class T, Device D>
-
-
22struct EigensolverResult {
-
23 Matrix<BaseType<T>, D> eigenvalues;
-
24 Matrix<T, D> eigenvectors;
-
25};
+
21namespace dlaf {
+
22
+
23template <class T, Device D>
+
+
24struct EigensolverResult {
+
25 Matrix<BaseType<T>, D> eigenvalues;
+
26 Matrix<T, D> eigenvectors;
+
27};
-
26
-
27namespace eigensolver::internal {
28
-
29template <Backend B, Device D, class T>
-
-
30struct Eigensolver {
-
31 static void call(blas::Uplo uplo, Matrix<T, D>& mat_a, Matrix<BaseType<T>, D>& evals,
-
32 Matrix<T, D>& mat_e, const SizeType eigenvalues_index_begin,
-
33 const SizeType eigenvalues_index_end);
-
34 static void call(comm::CommunicatorGrid& grid, blas::Uplo uplo, Matrix<T, D>& mat_a,
-
35 Matrix<BaseType<T>, D>& evals, Matrix<T, D>& mat_e,
-
36 const SizeType eigenvalues_index_begin, const SizeType eigenvalues_index_end);
-
37};
+
29namespace eigensolver::internal {
+
30
+
31template <Backend B, Device D, class T>
+
+
32struct Eigensolver {
+
33 static void call(blas::Uplo uplo, Matrix<T, D>& mat_a, Matrix<BaseType<T>, D>& evals,
+
34 Matrix<T, D>& mat_e, const SizeType eigenvalues_index_begin,
+
35 const SizeType eigenvalues_index_end);
+
36 static void call(comm::CommunicatorGrid& grid, blas::Uplo uplo, Matrix<T, D>& mat_a,
+
37 Matrix<BaseType<T>, D>& evals, Matrix<T, D>& mat_e,
+
38 const SizeType eigenvalues_index_begin, const SizeType eigenvalues_index_end);
+
39};
-
38
-
39// ETI
-
40#define DLAF_EIGENSOLVER_ETI(KWORD, BACKEND, DEVICE, DATATYPE) \
-
41 KWORD template struct Eigensolver<BACKEND, DEVICE, DATATYPE>;
-
42
-
43DLAF_EIGENSOLVER_ETI(extern, Backend::MC, Device::CPU, float)
-
44DLAF_EIGENSOLVER_ETI(extern, Backend::MC, Device::CPU, double)
-
45DLAF_EIGENSOLVER_ETI(extern, Backend::MC, Device::CPU, std::complex<float>)
-
46DLAF_EIGENSOLVER_ETI(extern, Backend::MC, Device::CPU, std::complex<double>)
-
47
-
48#ifdef DLAF_WITH_GPU
-
49DLAF_EIGENSOLVER_ETI(extern, Backend::GPU, Device::GPU, float)
-
50DLAF_EIGENSOLVER_ETI(extern, Backend::GPU, Device::GPU, double)
-
51DLAF_EIGENSOLVER_ETI(extern, Backend::GPU, Device::GPU, std::complex<float>)
-
52DLAF_EIGENSOLVER_ETI(extern, Backend::GPU, Device::GPU, std::complex<double>)
-
53#endif
-
54}
-
55}
+
40
+
41// ETI
+
42#define DLAF_EIGENSOLVER_ETI(KWORD, BACKEND, DEVICE, DATATYPE) \
+
43 KWORD template struct Eigensolver<BACKEND, DEVICE, DATATYPE>;
+
44
+
45DLAF_EIGENSOLVER_ETI(extern, Backend::MC, Device::CPU, float)
+
46DLAF_EIGENSOLVER_ETI(extern, Backend::MC, Device::CPU, double)
+
47DLAF_EIGENSOLVER_ETI(extern, Backend::MC, Device::CPU, std::complex<float>)
+
48DLAF_EIGENSOLVER_ETI(extern, Backend::MC, Device::CPU, std::complex<double>)
+
49
+
50#ifdef DLAF_WITH_GPU
+
51DLAF_EIGENSOLVER_ETI(extern, Backend::GPU, Device::GPU, float)
+
52DLAF_EIGENSOLVER_ETI(extern, Backend::GPU, Device::GPU, double)
+
53DLAF_EIGENSOLVER_ETI(extern, Backend::GPU, Device::GPU, std::complex<float>)
+
54DLAF_EIGENSOLVER_ETI(extern, Backend::GPU, Device::GPU, std::complex<double>)
+
55#endif
+
56}
+
57}
dlaf::comm::CommunicatorGrid
Definition communicator_grid.h:37
communicator_grid.h
-
dlaf::EigensolverResult
Definition api.h:22
- +
dlaf::EigensolverResult
Definition api.h:24
+
diff --git a/master/eigensolver_2gen__eigensolver_2api_8h_source.html b/master/eigensolver_2gen__eigensolver_2api_8h_source.html index 0d430d5ac7..7be8cc575f 100644 --- a/master/eigensolver_2gen__eigensolver_2api_8h_source.html +++ b/master/eigensolver_2gen__eigensolver_2api_8h_source.html @@ -92,50 +92,52 @@
9//
10#pragma once
11
-
12#include <dlaf/communication/communicator_grid.h>
-
13#include <dlaf/eigensolver/eigensolver/api.h>
-
14#include <dlaf/matrix/matrix.h>
-
15#include <dlaf/types.h>
-
16
-
17namespace dlaf::eigensolver::internal {
+
12#include <complex>
+
13
+
14#include <dlaf/communication/communicator_grid.h>
+
15#include <dlaf/eigensolver/eigensolver/api.h>
+
16#include <dlaf/matrix/matrix.h>
+
17#include <dlaf/types.h>
18
-
19enum class Factorization { do_factorization, already_factorized };
+
19namespace dlaf::eigensolver::internal {
20
-
21template <Backend backend, Device device, class T>
-
-
22struct GenEigensolver {
-
23 static void call(blas::Uplo uplo, Matrix<T, device>& mat_a, Matrix<T, device>& mat_b,
-
24 Matrix<BaseType<T>, device>& eigenvalues, Matrix<T, device>& eigenvectors,
-
25 const Factorization factorization, const SizeType eigenvalues_index_begin,
-
26 const SizeType eigenvalues_index_end);
-
27 static void call(comm::CommunicatorGrid& grid, blas::Uplo uplo, Matrix<T, device>& mat_a,
-
28 Matrix<T, device>& mat_b, Matrix<BaseType<T>, device>& eigenvalues,
-
29 Matrix<T, device>& eigenvectors, const Factorization factorization,
-
30 const SizeType eigenvalues_index_begin, const SizeType eigenvalues_index_end);
-
31};
+
21enum class Factorization { do_factorization, already_factorized };
+
22
+
23template <Backend backend, Device device, class T>
+
+
24struct GenEigensolver {
+
25 static void call(blas::Uplo uplo, Matrix<T, device>& mat_a, Matrix<T, device>& mat_b,
+
26 Matrix<BaseType<T>, device>& eigenvalues, Matrix<T, device>& eigenvectors,
+
27 const Factorization factorization, const SizeType eigenvalues_index_begin,
+
28 const SizeType eigenvalues_index_end);
+
29 static void call(comm::CommunicatorGrid& grid, blas::Uplo uplo, Matrix<T, device>& mat_a,
+
30 Matrix<T, device>& mat_b, Matrix<BaseType<T>, device>& eigenvalues,
+
31 Matrix<T, device>& eigenvectors, const Factorization factorization,
+
32 const SizeType eigenvalues_index_begin, const SizeType eigenvalues_index_end);
+
33};
-
32
-
33// ETI
-
34#define DLAF_EIGENSOLVER_GEN_ETI(KWORD, BACKEND, DEVICE, DATATYPE) \
-
35 KWORD template struct GenEigensolver<BACKEND, DEVICE, DATATYPE>;
-
36
-
37DLAF_EIGENSOLVER_GEN_ETI(extern, Backend::MC, Device::CPU, float)
-
38DLAF_EIGENSOLVER_GEN_ETI(extern, Backend::MC, Device::CPU, double)
-
39DLAF_EIGENSOLVER_GEN_ETI(extern, Backend::MC, Device::CPU, std::complex<float>)
-
40DLAF_EIGENSOLVER_GEN_ETI(extern, Backend::MC, Device::CPU, std::complex<double>)
-
41
-
42#ifdef DLAF_WITH_GPU
-
43DLAF_EIGENSOLVER_GEN_ETI(extern, Backend::GPU, Device::GPU, float)
-
44DLAF_EIGENSOLVER_GEN_ETI(extern, Backend::GPU, Device::GPU, double)
-
45DLAF_EIGENSOLVER_GEN_ETI(extern, Backend::GPU, Device::GPU, std::complex<float>)
-
46DLAF_EIGENSOLVER_GEN_ETI(extern, Backend::GPU, Device::GPU, std::complex<double>)
-
47#endif
-
48
-
49}
+
34
+
35// ETI
+
36#define DLAF_EIGENSOLVER_GEN_ETI(KWORD, BACKEND, DEVICE, DATATYPE) \
+
37 KWORD template struct GenEigensolver<BACKEND, DEVICE, DATATYPE>;
+
38
+
39DLAF_EIGENSOLVER_GEN_ETI(extern, Backend::MC, Device::CPU, float)
+
40DLAF_EIGENSOLVER_GEN_ETI(extern, Backend::MC, Device::CPU, double)
+
41DLAF_EIGENSOLVER_GEN_ETI(extern, Backend::MC, Device::CPU, std::complex<float>)
+
42DLAF_EIGENSOLVER_GEN_ETI(extern, Backend::MC, Device::CPU, std::complex<double>)
+
43
+
44#ifdef DLAF_WITH_GPU
+
45DLAF_EIGENSOLVER_GEN_ETI(extern, Backend::GPU, Device::GPU, float)
+
46DLAF_EIGENSOLVER_GEN_ETI(extern, Backend::GPU, Device::GPU, double)
+
47DLAF_EIGENSOLVER_GEN_ETI(extern, Backend::GPU, Device::GPU, std::complex<float>)
+
48DLAF_EIGENSOLVER_GEN_ETI(extern, Backend::GPU, Device::GPU, std::complex<double>)
+
49#endif
+
50
+
51}
dlaf::comm::CommunicatorGrid
Definition communicator_grid.h:37
communicator_grid.h
- +
diff --git a/master/eigensolver_2gen__eigensolver_8h_source.html b/master/eigensolver_2gen__eigensolver_8h_source.html index 4f7e19b0bd..0f2d0972a1 100644 --- a/master/eigensolver_2gen__eigensolver_8h_source.html +++ b/master/eigensolver_2gen__eigensolver_8h_source.html @@ -435,7 +435,7 @@
dlaf::comm::CommunicatorGrid::size
Size2D size() const noexcept
Return the number of rows in the grid.
Definition communicator_grid.h:79
dlaf::hermitian_generalized_eigensolver_factorized
void hermitian_generalized_eigensolver_factorized(blas::Uplo uplo, Matrix< T, D > &mat_a, Matrix< T, D > &mat_b, Matrix< BaseType< T >, D > &eigenvalues, Matrix< T, D > &eigenvectors, const SizeType eigenvalues_index_begin, const SizeType eigenvalues_index_end)
Generalized Eigensolver.
Definition gen_eigensolver.h:293
-
dlaf::EigensolverResult
Definition api.h:22
+
dlaf::EigensolverResult
Definition api.h:24
util_matrix.h
diff --git a/master/eigensolver_2gen__to__std_2api_8h_source.html b/master/eigensolver_2gen__to__std_2api_8h_source.html index 169b493825..2e5cce597f 100644 --- a/master/eigensolver_2gen__to__std_2api_8h_source.html +++ b/master/eigensolver_2gen__to__std_2api_8h_source.html @@ -92,40 +92,42 @@
9//
10#pragma once
11
-
12#include <dlaf/matrix/matrix.h>
-
13#include <dlaf/types.h>
-
14
-
15namespace dlaf::eigensolver::internal {
+
12#include <complex>
+
13
+
14#include <dlaf/matrix/matrix.h>
+
15#include <dlaf/types.h>
16
-
17template <Backend backend, Device device, class T>
-
-
18struct GenToStd {
-
19 static void call_L(Matrix<T, device>& mat_a, Matrix<T, device>& mat_l);
-
20 static void call_L(comm::CommunicatorGrid& grid, Matrix<T, device>& mat_a, Matrix<T, device>& mat_l);
-
21 static void call_U(Matrix<T, device>& mat_a, Matrix<T, device>& mat_u);
-
22 static void call_U(comm::CommunicatorGrid& grid, Matrix<T, device>& mat_a, Matrix<T, device>& mat_u);
-
23};
+
17namespace dlaf::eigensolver::internal {
+
18
+
19template <Backend backend, Device device, class T>
+
+
20struct GenToStd {
+
21 static void call_L(Matrix<T, device>& mat_a, Matrix<T, device>& mat_l);
+
22 static void call_L(comm::CommunicatorGrid& grid, Matrix<T, device>& mat_a, Matrix<T, device>& mat_l);
+
23 static void call_U(Matrix<T, device>& mat_a, Matrix<T, device>& mat_u);
+
24 static void call_U(comm::CommunicatorGrid& grid, Matrix<T, device>& mat_a, Matrix<T, device>& mat_u);
+
25};
-
24
-
25// ETI
-
26#define DLAF_GENTOSTD_ETI(KWORD, BACKEND, DEVICE, DATATYPE) \
-
27 KWORD template struct GenToStd<BACKEND, DEVICE, DATATYPE>;
-
28
-
29DLAF_GENTOSTD_ETI(extern, Backend::MC, Device::CPU, float)
-
30DLAF_GENTOSTD_ETI(extern, Backend::MC, Device::CPU, double)
-
31DLAF_GENTOSTD_ETI(extern, Backend::MC, Device::CPU, std::complex<float>)
-
32DLAF_GENTOSTD_ETI(extern, Backend::MC, Device::CPU, std::complex<double>)
-
33
-
34#ifdef DLAF_WITH_GPU
-
35DLAF_GENTOSTD_ETI(extern, Backend::GPU, Device::GPU, float)
-
36DLAF_GENTOSTD_ETI(extern, Backend::GPU, Device::GPU, double)
-
37DLAF_GENTOSTD_ETI(extern, Backend::GPU, Device::GPU, std::complex<float>)
-
38DLAF_GENTOSTD_ETI(extern, Backend::GPU, Device::GPU, std::complex<double>)
-
39#endif
-
40}
+
26
+
27// ETI
+
28#define DLAF_GENTOSTD_ETI(KWORD, BACKEND, DEVICE, DATATYPE) \
+
29 KWORD template struct GenToStd<BACKEND, DEVICE, DATATYPE>;
+
30
+
31DLAF_GENTOSTD_ETI(extern, Backend::MC, Device::CPU, float)
+
32DLAF_GENTOSTD_ETI(extern, Backend::MC, Device::CPU, double)
+
33DLAF_GENTOSTD_ETI(extern, Backend::MC, Device::CPU, std::complex<float>)
+
34DLAF_GENTOSTD_ETI(extern, Backend::MC, Device::CPU, std::complex<double>)
+
35
+
36#ifdef DLAF_WITH_GPU
+
37DLAF_GENTOSTD_ETI(extern, Backend::GPU, Device::GPU, float)
+
38DLAF_GENTOSTD_ETI(extern, Backend::GPU, Device::GPU, double)
+
39DLAF_GENTOSTD_ETI(extern, Backend::GPU, Device::GPU, std::complex<float>)
+
40DLAF_GENTOSTD_ETI(extern, Backend::GPU, Device::GPU, std::complex<double>)
+
41#endif
+
42}
dlaf::comm::CommunicatorGrid
Definition communicator_grid.h:37
- +
diff --git a/master/eigensolver_2reduction__to__band_2api_8h_source.html b/master/eigensolver_2reduction__to__band_2api_8h_source.html index a6a26f4e74..ca606abbdc 100644 --- a/master/eigensolver_2reduction__to__band_2api_8h_source.html +++ b/master/eigensolver_2reduction__to__band_2api_8h_source.html @@ -93,41 +93,43 @@
10
11#pragma once
12
-
13#include <pika/execution.hpp>
+
13#include <complex>
14
-
15#include <dlaf/matrix/matrix.h>
-
16#include <dlaf/types.h>
-
17
-
18namespace dlaf::eigensolver::internal {
+
15#include <pika/execution.hpp>
+
16
+
17#include <dlaf/matrix/matrix.h>
+
18#include <dlaf/types.h>
19
-
20template <Backend B, Device D, class T>
-
-
21struct ReductionToBand {
-
22 static Matrix<T, Device::CPU> call(Matrix<T, D>& mat_a, const SizeType band_size);
-
23 static Matrix<T, Device::CPU> call(comm::CommunicatorGrid& grid, Matrix<T, D>& mat_a,
-
24 const SizeType band_size);
-
25};
+
20namespace dlaf::eigensolver::internal {
+
21
+
22template <Backend B, Device D, class T>
+
+
23struct ReductionToBand {
+
24 static Matrix<T, Device::CPU> call(Matrix<T, D>& mat_a, const SizeType band_size);
+
25 static Matrix<T, Device::CPU> call(comm::CommunicatorGrid& grid, Matrix<T, D>& mat_a,
+
26 const SizeType band_size);
+
27};
-
26
-
27// ETI
-
28#define DLAF_EIGENSOLVER_REDUCTION_TO_BAND_ETI(KWORD, BACKEND, DEVICE, DATATYPE) \
-
29 KWORD template struct ReductionToBand<BACKEND, DEVICE, DATATYPE>;
-
30
-
31DLAF_EIGENSOLVER_REDUCTION_TO_BAND_ETI(extern, Backend::MC, Device::CPU, float)
-
32DLAF_EIGENSOLVER_REDUCTION_TO_BAND_ETI(extern, Backend::MC, Device::CPU, double)
-
33DLAF_EIGENSOLVER_REDUCTION_TO_BAND_ETI(extern, Backend::MC, Device::CPU, std::complex<float>)
-
34DLAF_EIGENSOLVER_REDUCTION_TO_BAND_ETI(extern, Backend::MC, Device::CPU, std::complex<double>)
-
35
-
36#ifdef DLAF_WITH_GPU
-
37DLAF_EIGENSOLVER_REDUCTION_TO_BAND_ETI(extern, Backend::GPU, Device::GPU, float)
-
38DLAF_EIGENSOLVER_REDUCTION_TO_BAND_ETI(extern, Backend::GPU, Device::GPU, double)
-
39DLAF_EIGENSOLVER_REDUCTION_TO_BAND_ETI(extern, Backend::GPU, Device::GPU, std::complex<float>)
-
40DLAF_EIGENSOLVER_REDUCTION_TO_BAND_ETI(extern, Backend::GPU, Device::GPU, std::complex<double>)
-
41#endif
-
42}
+
28
+
29// ETI
+
30#define DLAF_EIGENSOLVER_REDUCTION_TO_BAND_ETI(KWORD, BACKEND, DEVICE, DATATYPE) \
+
31 KWORD template struct ReductionToBand<BACKEND, DEVICE, DATATYPE>;
+
32
+
33DLAF_EIGENSOLVER_REDUCTION_TO_BAND_ETI(extern, Backend::MC, Device::CPU, float)
+
34DLAF_EIGENSOLVER_REDUCTION_TO_BAND_ETI(extern, Backend::MC, Device::CPU, double)
+
35DLAF_EIGENSOLVER_REDUCTION_TO_BAND_ETI(extern, Backend::MC, Device::CPU, std::complex<float>)
+
36DLAF_EIGENSOLVER_REDUCTION_TO_BAND_ETI(extern, Backend::MC, Device::CPU, std::complex<double>)
+
37
+
38#ifdef DLAF_WITH_GPU
+
39DLAF_EIGENSOLVER_REDUCTION_TO_BAND_ETI(extern, Backend::GPU, Device::GPU, float)
+
40DLAF_EIGENSOLVER_REDUCTION_TO_BAND_ETI(extern, Backend::GPU, Device::GPU, double)
+
41DLAF_EIGENSOLVER_REDUCTION_TO_BAND_ETI(extern, Backend::GPU, Device::GPU, std::complex<float>)
+
42DLAF_EIGENSOLVER_REDUCTION_TO_BAND_ETI(extern, Backend::GPU, Device::GPU, std::complex<double>)
+
43#endif
+
44}
dlaf::comm::CommunicatorGrid
Definition communicator_grid.h:37
- +
diff --git a/master/eigensolver_2reduction__to__band_2impl_8h_source.html b/master/eigensolver_2reduction__to__band_2impl_8h_source.html index 8a2fa30187..a9a2e039ba 100644 --- a/master/eigensolver_2reduction__to__band_2impl_8h_source.html +++ b/master/eigensolver_2reduction__to__band_2impl_8h_source.html @@ -1566,8 +1566,8 @@
dlaf::internal::Policy
Definition policy.h:24
dlaf::matrix::Distribution
Definition distribution.h:111
-
dlaf::matrix::Matrix
Definition matrix.h:61
-
dlaf::matrix::Matrix::readwrite
ReadWriteSenderType readwrite(const LocalTileIndex &index) noexcept
Definition matrix.h:153
+
dlaf::matrix::Matrix
Definition matrix.h:62
+
dlaf::matrix::Matrix::readwrite
ReadWriteSenderType readwrite(const LocalTileIndex &index) noexcept
Definition matrix.h:154
dlaf::comm::IndexT_MPI
int IndexT_MPI
Type used for indexes in MPI API.
Definition index.h:20
@@ -1584,7 +1584,7 @@ -
dlaf::matrix::splitTile
ReadOnlyTileSender< T, D > splitTile(ReadOnlyTileSender< T, D > tile, const SubTileSpec &spec)
Definition tile.h:510
+
dlaf::matrix::splitTile
ReadOnlyTileSender< T, D > splitTile(ReadOnlyTileSender< T, D > tile, const SubTileSpec &spec)
Definition tile.h:511
@@ -1593,7 +1593,7 @@
round_robin.h
single_threaded_blas.h
- +
dlaf::matrix::Panel
Definition panel.h:589
dlaf::matrix::SubPanelView
Definition views.h:132
diff --git a/master/eigensolver_2tridiag__solver_2api_8h_source.html b/master/eigensolver_2tridiag__solver_2api_8h_source.html index d90d2e1486..9ffc43264d 100644 --- a/master/eigensolver_2tridiag__solver_2api_8h_source.html +++ b/master/eigensolver_2tridiag__solver_2api_8h_source.html @@ -92,40 +92,42 @@
9//
10#pragma once
11
-
12#include <dlaf/matrix/matrix.h>
-
13#include <dlaf/types.h>
-
14
-
15namespace dlaf::eigensolver::internal {
+
12#include <complex>
+
13
+
14#include <dlaf/matrix/matrix.h>
+
15#include <dlaf/types.h>
16
-
17template <Backend backend, Device device, class T>
-
-
18struct TridiagSolver {
-
19 static void call(Matrix<T, Device::CPU>& tridiag, Matrix<T, device>& evals, Matrix<T, device>& evecs);
-
20 static void call(Matrix<T, Device::CPU>& tridiag, Matrix<T, device>& evals,
-
21 Matrix<std::complex<T>, device>& evecs);
-
22 static void call(comm::CommunicatorGrid& grid, Matrix<T, Device::CPU>& tridiag,
-
23 Matrix<T, device>& evals, Matrix<T, device>& evecs);
+
17namespace dlaf::eigensolver::internal {
+
18
+
19template <Backend backend, Device device, class T>
+
+
20struct TridiagSolver {
+
21 static void call(Matrix<T, Device::CPU>& tridiag, Matrix<T, device>& evals, Matrix<T, device>& evecs);
+
22 static void call(Matrix<T, Device::CPU>& tridiag, Matrix<T, device>& evals,
+
23 Matrix<std::complex<T>, device>& evecs);
24 static void call(comm::CommunicatorGrid& grid, Matrix<T, Device::CPU>& tridiag,
-
25 Matrix<T, device>& evals, Matrix<std::complex<T>, device>& evecs);
-
26};
+
25 Matrix<T, device>& evals, Matrix<T, device>& evecs);
+
26 static void call(comm::CommunicatorGrid& grid, Matrix<T, Device::CPU>& tridiag,
+
27 Matrix<T, device>& evals, Matrix<std::complex<T>, device>& evecs);
+
28};
-
27
-
28// ETI
-
29#define DLAF_TRIDIAGONAL_EIGENSOLVER_ETI(KWORD, BACKEND, DEVICE, DATATYPE) \
-
30 KWORD template struct TridiagSolver<BACKEND, DEVICE, DATATYPE>;
-
31
-
32DLAF_TRIDIAGONAL_EIGENSOLVER_ETI(extern, Backend::MC, Device::CPU, float)
-
33DLAF_TRIDIAGONAL_EIGENSOLVER_ETI(extern, Backend::MC, Device::CPU, double)
-
34
-
35#ifdef DLAF_WITH_GPU
-
36DLAF_TRIDIAGONAL_EIGENSOLVER_ETI(extern, Backend::GPU, Device::GPU, float)
-
37DLAF_TRIDIAGONAL_EIGENSOLVER_ETI(extern, Backend::GPU, Device::GPU, double)
-
38#endif
-
39
-
40}
+
29
+
30// ETI
+
31#define DLAF_TRIDIAGONAL_EIGENSOLVER_ETI(KWORD, BACKEND, DEVICE, DATATYPE) \
+
32 KWORD template struct TridiagSolver<BACKEND, DEVICE, DATATYPE>;
+
33
+
34DLAF_TRIDIAGONAL_EIGENSOLVER_ETI(extern, Backend::MC, Device::CPU, float)
+
35DLAF_TRIDIAGONAL_EIGENSOLVER_ETI(extern, Backend::MC, Device::CPU, double)
+
36
+
37#ifdef DLAF_WITH_GPU
+
38DLAF_TRIDIAGONAL_EIGENSOLVER_ETI(extern, Backend::GPU, Device::GPU, float)
+
39DLAF_TRIDIAGONAL_EIGENSOLVER_ETI(extern, Backend::GPU, Device::GPU, double)
+
40#endif
+
41
+
42}
dlaf::comm::CommunicatorGrid
Definition communicator_grid.h:37
- +
diff --git a/master/eigensolver_2tridiag__solver_2gpu_2kernels_8h_source.html b/master/eigensolver_2tridiag__solver_2gpu_2kernels_8h_source.html index f80a8e9521..be5445e54d 100644 --- a/master/eigensolver_2tridiag__solver_2gpu_2kernels_8h_source.html +++ b/master/eigensolver_2tridiag__solver_2gpu_2kernels_8h_source.html @@ -95,52 +95,54 @@
12
13#ifdef DLAF_WITH_GPU
14
-
15#include <whip.hpp>
+
15#include <complex>
16
-
17#include <dlaf/eigensolver/tridiag_solver/coltype.h>
-
18#include <dlaf/gpu/lapack/api.h>
-
19#include <dlaf/types.h>
-
20
-
21namespace dlaf::eigensolver::internal::gpu {
+
17#include <whip.hpp>
+
18
+
19#include <dlaf/eigensolver/tridiag_solver/coltype.h>
+
20#include <dlaf/gpu/lapack/api.h>
+
21#include <dlaf/types.h>
22
-
23template <class T>
-
24void castToComplex(const SizeType m, const SizeType n, const T* in, const SizeType ld_in,
-
25 std::complex<T>* out, const SizeType ld_out, whip::stream_t stream);
-
26
-
27#define DLAF_GPU_CAST_TO_COMPLEX_ETI(kword, Type) \
-
28 kword template void castToComplex(const SizeType m, const SizeType n, const Type* in, \
-
29 const SizeType ld_in, std::complex<Type>* out, \
-
30 const SizeType ld_out, whip::stream_t stream)
-
31
-
32DLAF_GPU_CAST_TO_COMPLEX_ETI(extern, float);
-
33DLAF_GPU_CAST_TO_COMPLEX_ETI(extern, double);
-
34
-
35template <class T>
-
36void assembleRank1UpdateVectorTile(bool is_top_tile, T rho, const SizeType m, const SizeType n,
-
37 const T* evecs, const SizeType ld_evecs, T* rank1,
-
38 whip::stream_t stream);
-
39
-
40#define DLAF_GPU_ASSEMBLE_RANK1_UPDATE_VECTOR_TILE_ETI(kword, Type) \
-
41 kword template void assembleRank1UpdateVectorTile(bool is_top_tile, Type rho, const SizeType m, \
-
42 const SizeType n, const Type* evecs, \
-
43 const SizeType ld_evecs, Type* rank1, \
-
44 whip::stream_t stream)
-
45
-
46DLAF_GPU_ASSEMBLE_RANK1_UPDATE_VECTOR_TILE_ETI(extern, float);
-
47DLAF_GPU_ASSEMBLE_RANK1_UPDATE_VECTOR_TILE_ETI(extern, double);
-
48
-
49template <class T>
-
50void givensRotationOnDevice(SizeType len, T* x, T* y, T c, T s, whip::stream_t stream);
-
51
-
52#define DLAF_GIVENS_ROT_ETI(kword, Type) \
-
53 kword template void givensRotationOnDevice(SizeType len, Type* x, Type* y, Type c, Type s, \
-
54 whip::stream_t stream)
-
55
-
56DLAF_GIVENS_ROT_ETI(extern, float);
-
57DLAF_GIVENS_ROT_ETI(extern, double);
-
58
-
59}
-
60#endif
+
23namespace dlaf::eigensolver::internal::gpu {
+
24
+
25template <class T>
+
26void castToComplex(const SizeType m, const SizeType n, const T* in, const SizeType ld_in,
+
27 std::complex<T>* out, const SizeType ld_out, whip::stream_t stream);
+
28
+
29#define DLAF_GPU_CAST_TO_COMPLEX_ETI(kword, Type) \
+
30 kword template void castToComplex(const SizeType m, const SizeType n, const Type* in, \
+
31 const SizeType ld_in, std::complex<Type>* out, \
+
32 const SizeType ld_out, whip::stream_t stream)
+
33
+
34DLAF_GPU_CAST_TO_COMPLEX_ETI(extern, float);
+
35DLAF_GPU_CAST_TO_COMPLEX_ETI(extern, double);
+
36
+
37template <class T>
+
38void assembleRank1UpdateVectorTile(bool is_top_tile, T rho, const SizeType m, const SizeType n,
+
39 const T* evecs, const SizeType ld_evecs, T* rank1,
+
40 whip::stream_t stream);
+
41
+
42#define DLAF_GPU_ASSEMBLE_RANK1_UPDATE_VECTOR_TILE_ETI(kword, Type) \
+
43 kword template void assembleRank1UpdateVectorTile(bool is_top_tile, Type rho, const SizeType m, \
+
44 const SizeType n, const Type* evecs, \
+
45 const SizeType ld_evecs, Type* rank1, \
+
46 whip::stream_t stream)
+
47
+
48DLAF_GPU_ASSEMBLE_RANK1_UPDATE_VECTOR_TILE_ETI(extern, float);
+
49DLAF_GPU_ASSEMBLE_RANK1_UPDATE_VECTOR_TILE_ETI(extern, double);
+
50
+
51template <class T>
+
52void givensRotationOnDevice(SizeType len, T* x, T* y, T c, T s, whip::stream_t stream);
+
53
+
54#define DLAF_GIVENS_ROT_ETI(kword, Type) \
+
55 kword template void givensRotationOnDevice(SizeType len, Type* x, Type* y, Type c, Type s, \
+
56 whip::stream_t stream)
+
57
+
58DLAF_GIVENS_ROT_ETI(extern, float);
+
59DLAF_GIVENS_ROT_ETI(extern, double);
+
60
+
61}
+
62#endif
diff --git a/master/eigensolver_2tridiag__solver_2impl_8h_source.html b/master/eigensolver_2tridiag__solver_2impl_8h_source.html index dc7509acc6..c661a2eed7 100644 --- a/master/eigensolver_2tridiag__solver_2impl_8h_source.html +++ b/master/eigensolver_2tridiag__solver_2impl_8h_source.html @@ -94,489 +94,490 @@
11
12#include <algorithm>
13#include <atomic>
-
14#include <sstream>
-
15#include <tuple>
-
16#include <utility>
-
17#include <vector>
-
18
-
19#include <pika/execution.hpp>
-
20#include <pika/thread.hpp>
-
21
-
22#ifdef DLAF_WITH_GPU
-
23#include <whip.hpp>
-
24#endif
-
25
-
26#include <dlaf/common/callable_object.h>
-
27#include <dlaf/communication/communicator_grid.h>
-
28#include <dlaf/communication/communicator_pipeline.h>
-
29#include <dlaf/communication/index.h>
-
30#include <dlaf/eigensolver/tridiag_solver/api.h>
-
31#include <dlaf/eigensolver/tridiag_solver/kernels_async.h>
-
32#include <dlaf/eigensolver/tridiag_solver/merge.h>
-
33#include <dlaf/lapack/tile.h>
-
34#include <dlaf/matrix/copy_tile.h>
-
35#include <dlaf/matrix/hdf5.h>
-
36#include <dlaf/permutations/general.h>
-
37#include <dlaf/permutations/general/impl.h>
-
38#include <dlaf/sender/make_sender_algorithm_overloads.h>
-
39#include <dlaf/sender/policy.h>
-
40#include <dlaf/types.h>
-
41
-
42namespace dlaf::eigensolver::internal {
-
43
-
44// Splits [i_begin, i_end) in the middle and waits for all splits on [i_begin, i_split] and [i_split,
-
45// i_end) before saving the triad <i_begin, i_split, i_end> into `indices`.
-
46//
-
47// The recursive calls span a binary tree which is traversed in depth first left-right-root order. That
-
48// is also the order of triads in `indices`.
-
49//
-
50inline void splitIntervalInTheMiddleRecursively(
-
51 const SizeType i_begin, const SizeType i_end,
-
52 std::vector<std::tuple<SizeType, SizeType, SizeType>>& indices) {
-
53 if (i_begin + 1 == i_end)
-
54 return;
-
55 const SizeType i_split = util::ceilDiv<SizeType>(i_begin + i_end, 2);
-
56 splitIntervalInTheMiddleRecursively(i_begin, i_split, indices);
-
57 splitIntervalInTheMiddleRecursively(i_split, i_end, indices);
-
58 indices.emplace_back(i_begin, i_split, i_end);
-
59}
-
60
-
61// Generates an array of triad indices. Each triad is composed of begin <= middle < end indices and
-
62// represents two intervals [begin, middle] and [middle + 1, end]. The two intervals are the subproblems
-
63// that have to be merged to arrive at [begin, end].
-
64//
-
65// Note: the intervals are all closed!
-
66//
-
67inline std::vector<std::tuple<SizeType, SizeType, SizeType>> generateSubproblemIndices(const SizeType n) {
-
68 if (n == 0)
-
69 return {};
-
70
-
71 std::vector<std::tuple<SizeType, SizeType, SizeType>> indices;
-
72 indices.reserve(to_sizet(n));
-
73 splitIntervalInTheMiddleRecursively(0, n, indices);
-
74 return indices;
-
75}
-
76
-
77template <class T>
-
78auto cuppensDecomposition(Matrix<T, Device::CPU>& tridiag) {
-
79 namespace ex = pika::execution::experimental;
-
80 using sender_type = decltype(ex::split(
-
81 ex::ensure_started(cuppensDecompAsync<T>(tridiag.readwrite(std::declval<LocalTileIndex>()),
-
82 tridiag.readwrite(std::declval<LocalTileIndex>())))));
-
83 using vector_type = std::vector<sender_type>;
-
84
-
85 if (tridiag.nrTiles().rows() == 0)
-
86 return vector_type{};
-
87
-
88 const SizeType i_end = tridiag.nrTiles().rows();
-
89 vector_type offdiag_vals;
-
90 offdiag_vals.reserve(to_sizet(i_end - 1));
-
91
-
92 for (SizeType i_split = 1; i_split < i_end; ++i_split) {
-
93 offdiag_vals.push_back(ex::split(
-
94 ex::ensure_started(cuppensDecompAsync<T>(tridiag.readwrite(LocalTileIndex(i_split - 1, 0)),
-
95 tridiag.readwrite(LocalTileIndex(i_split, 0))))));
-
96 }
-
97 return offdiag_vals;
-
98}
-
99
-
100// Solve leaf eigensystem with stedc
-
101template <class T>
-
102void solveLeaf(Matrix<T, Device::CPU>& tridiag, Matrix<T, Device::CPU>& evecs) {
-
103 const SizeType ntiles = tridiag.distribution().nrTiles().rows();
-
104 for (SizeType i = 0; i < ntiles; ++i) {
-
105 stedcAsync(tridiag.readwrite(LocalTileIndex(i, 0)), evecs.readwrite(LocalTileIndex(i, i)));
-
106 }
-
107}
-
108
-
109#ifdef DLAF_WITH_GPU
-
110template <class T>
-
111void solveLeaf(Matrix<T, Device::CPU>& tridiag, Matrix<T, Device::GPU>& evecs,
-
112 Matrix<T, Device::CPU>& h_evecs) {
-
113 namespace ex = pika::execution::experimental;
-
114 using matrix::copy;
-
115 using pika::execution::thread_stacksize;
-
116 const auto cp_policy =
-
117 dlaf::internal::Policy<matrix::internal::CopyBackend_v<Device::GPU, Device::CPU>>{
-
118 thread_stacksize::nostack};
-
119
-
120 const SizeType ntiles = tridiag.distribution().nrTiles().rows();
-
121 for (SizeType i = 0; i < ntiles; ++i) {
-
122 const auto id_tr = LocalTileIndex(i, 0);
-
123 const auto id_ev = LocalTileIndex(i, i);
-
124
-
125 stedcAsync(tridiag.readwrite(id_tr), h_evecs.readwrite(id_ev));
-
126 ex::start_detached(ex::when_all(h_evecs.read(id_ev), evecs.readwrite(id_ev)) | copy(cp_policy));
-
127 }
-
128}
-
129#endif
-
130
-
131// Copy the first column of @p tridiag (n x 2) into the column matrix @p evals (n x 1).
-
132template <class T, Device D>
-
133void offloadDiagonal(Matrix<const T, Device::CPU>& tridiag, Matrix<T, D>& evals) {
-
134 for (SizeType i = 0; i < evals.distribution().nrTiles().rows(); ++i) {
-
135 copyDiagonalFromCompactTridiagonalAsync<D>(tridiag.read(GlobalTileIndex(i, 0)),
-
136 evals.readwrite(GlobalTileIndex(i, 0)));
-
137 }
-
138}
-
139
-
140// Notation:
-
141//
-
142// nb - the block/tile size of all matrices and vectors
-
143// n1 - the size of the top subproblem
-
144// n2 - the size of the bottom subproblem
-
145// Q1 - (n1 x n1) the orthogonal matrix of the top subproblem
-
146// Q2 - (n2 x n2) the orthogonal matrix of the bottom subproblem
-
147// n := n1 + n2, the size of the merged problem
-
148//
-
149// ┌───┬───┐
-
150// │Q1 │ │
-
151// Q := ├───┼───┤ , (n x n) orthogonal matrix composed of the top and bottom subproblems
-
152// │ │Q2 │
-
153// └───┴───┘
-
154// D := diag(Q), (n x 1) the diagonal of Q
-
155// z := (n x 1) rank 1 update vector
-
156// rho := rank 1 update scaling factor
-
157// D + rho*z*z^T := rank 1 update problem
-
158// U := (n x n) matrix of eigenvectors of the rank 1 update problem:
-
159//
-
160// k := the size of the deflated rank 1 update problem (k <= n)
-
161// D' := (k x 1), deflated D
-
162// z' := (k x 1), deflated z
-
163// D' + rho*z'*z'^T := deflated rank 1 update problem
-
164// U' := (k x k) matrix of eigenvectors of the deflated rank 1 update problem
-
165//
-
166// l1 := number of columns of the top subproblem after deflation, l1 <= n1
-
167// l2 := number of columns of the bottom subproblem after deflation, l2 <= n2
-
168// Q1' := (n1 x l1) the non-deflated part of Q1 (l1 <= n1)
-
169// Q2' := (n2 x l2) the non-deflated part of Q2 (l2 <= n2)
-
170// Qd := (n-k x n) the deflated parts of Q1 and Q2
-
171// U1' := (l1 x k) is the first l1 rows of U'
-
172// U2' := (l2 x k) is the last l2 rows of U'
-
173// I := (n-k x n-k) identity matrix
-
174// P := (n x n) permutation matrix used to bring Q and U into multiplication form
-
175//
-
176// Q-U multiplication form to arrive at the eigenvectors of the merged problem:
-
177//
-
178// ┌────────┬──────┬────┐ ┌───────────────┬────┐ ┌───────────────┬────┐
-
179// │ │ │ │ │ │ │ │ │ │
-
180// │ Q1' │ │ │ │ │ │ │ Q1'xU1' │ │
-
181// │ │ │ │ │ U1' │ │ │ │ │
-
182// │ │ │ │ │ ──────┤ │ │ │ │
-
183// ├──────┬─┴──────┤ Qd │ ├─────── │ │ ├───────────────┤ Qd │
-
184// │ │ │ │ X │ U2' │ │ = │ │ │
-
185// │ │ │ │ │ │ │ │ Q2'xU2' │ │
-
186// │ │ Q2' │ │ ├───────────────┼────┤ │ │ │
-
187// │ │ │ │ │ │ I │ │ │ │
-
188// │ │ │ │ │ │ │ │ │ │
-
189// └──────┴────────┴────┘ └───────────────┴────┘ └───────────────┴────┘
-
190//
-
191// Note:
-
192// 1. U1' and U2' may overlap (in practice they almost always do)
-
193// 2. The overlap between U1' and U2' matches the number of shared columns between Q1' and Q2'
-
194// 3. The overlap region is due to deflation via Givens rotations of a column vector from Q1 with a
-
195// column vector of Q2.
-
196//
-
197template <Backend B, Device D, class T>
-
198void TridiagSolver<B, D, T>::call(Matrix<T, Device::CPU>& tridiag, Matrix<T, D>& evals,
-
199 Matrix<T, D>& evecs) {
-
200 using pika::execution::thread_priority;
-
201
-
202 // Quick return for empty matrix
-
203 if (evecs.size().isEmpty())
-
204 return;
-
205
-
206 // If the matrix is composed by a single tile simply call stedc.
-
207 if (evecs.nrTiles().linear_size() == 1) {
-
208 if constexpr (D == Device::CPU) {
-
209 solveLeaf(tridiag, evecs);
-
210 }
-
211 else {
-
212 Matrix<T, Device::CPU> h_evecs{evecs.distribution()};
-
213 solveLeaf(tridiag, evecs, h_evecs);
-
214 }
-
215 offloadDiagonal(tridiag, evals);
-
216 return;
-
217 }
-
218
-
219 // Auxiliary matrix used for the D&C algorithm
-
220 const matrix::Distribution& distr = evecs.distribution();
-
221 const LocalElementSize vec_size(distr.size().rows(), 1);
-
222 const TileElementSize vec_tile_size(distr.blockSize().rows(), 1);
-
223 WorkSpace<T, D> ws{Matrix<T, D>(distr), // e0
-
224 Matrix<T, D>(distr), // e1
-
225 evecs, // e2
-
226 evals, // d1
-
227 Matrix<T, D>(vec_size, vec_tile_size), // z0
-
228 Matrix<T, D>(vec_size, vec_tile_size), // z1
-
229 Matrix<SizeType, D>(vec_size, vec_tile_size), // i2
-
230 Matrix<SizeType, D>(vec_size, vec_tile_size), // i5
-
231 Matrix<SizeType, D>(vec_size, vec_tile_size), // i5b
-
232 Matrix<SizeType, D>(vec_size, vec_tile_size)}; // i6
-
233
-
234 WorkSpaceHost<T> ws_h{Matrix<T, Device::CPU>(vec_size, vec_tile_size), // d0
-
235 Matrix<ColType, Device::CPU>(vec_size, vec_tile_size), // c
-
236 Matrix<SizeType, Device::CPU>(vec_size, vec_tile_size), // i1
-
237 Matrix<SizeType, Device::CPU>(vec_size, vec_tile_size), // i3
-
238 Matrix<SizeType, Device::CPU>(vec_size, vec_tile_size)}; // i4
-
239
-
240 // Mirror workspace on host memory for CPU-only kernels
-
241 WorkSpaceHostMirror<T, D> ws_hm{initMirrorMatrix(ws.e2), initMirrorMatrix(ws.d1),
-
242 initMirrorMatrix(ws.z0), initMirrorMatrix(ws.z1),
-
243 initMirrorMatrix(ws.i2), initMirrorMatrix(ws.i5)};
-
244
-
245 // Set `ws.e0` to `zero` (needed for Given's rotation to make sure no random values are picked up)
-
246 matrix::util::set0<B, T, D>(thread_priority::normal, ws.e0);
-
247
-
248 // Cuppen's decomposition
-
249 auto offdiag_vals = cuppensDecomposition(tridiag);
-
250
-
251 // Solve with stedc for each tile of `tridiag` (nb x 2) and save eigenvectors in diagonal tiles of
-
252 // `evecs` (nb x nb)
-
253 if constexpr (D == Device::CPU) {
-
254 solveLeaf(tridiag, ws.e0);
-
255 }
-
256 else {
-
257 solveLeaf(tridiag, ws.e0, ws_hm.e2);
-
258 }
-
259
-
260 // Offload the diagonal from `tridiag` to `d0`
-
261 offloadDiagonal(tridiag, ws_h.d0);
-
262
-
263 // Each triad represents two subproblems to be merged
-
264 for (auto [i_begin, i_split, i_end] : generateSubproblemIndices(distr.nrTiles().rows())) {
-
265 mergeSubproblems<B>(i_begin, i_split, i_end, offdiag_vals[to_sizet(i_split - 1)], ws, ws_h, ws_hm);
-
266 }
-
267
-
268 const SizeType n = evecs.nrTiles().rows();
-
269 copy(ws_hm.i2, ws.i2);
-
270
-
271 // Note: ws_hm.d1 is the mirror of ws.d1 which is evals
-
272 applyIndex(0, n, ws_hm.i2, ws_h.d0, ws_hm.d1);
-
273 copy(ws_hm.d1, evals);
-
274
-
275 dlaf::permutations::permute<B, D, T, Coord::Col>(0, n, ws.i2, ws.e0, evecs);
-
276}
-
277
-
278// Overload which provides the eigenvector matrix as complex values where the imaginery part is set to zero.
-
279template <Backend B, Device D, class T>
-
280void TridiagSolver<B, D, T>::call(Matrix<T, Device::CPU>& tridiag, Matrix<T, D>& evals,
-
281 Matrix<std::complex<T>, D>& evecs) {
-
282 Matrix<T, D> real_evecs(evecs.distribution());
-
283 TridiagSolver<B, D, T>::call(tridiag, evals, real_evecs);
-
284
-
285 // Convert real to complex numbers
-
286 const matrix::Distribution& dist = evecs.distribution();
-
287 for (auto tile_wrt_local : iterate_range2d(dist.localNrTiles())) {
-
288 castToComplexAsync<D>(real_evecs.read(tile_wrt_local), evecs.readwrite(tile_wrt_local));
-
289 }
-
290}
-
291
-
292// Solve for each tile of the local matrix @p tridiag (n x 2) with `stedc()` and save the result in the
-
293// corresponding diagonal tile of the distribtued matrix @p evecs (n x n)
-
294//
-
295// @p tridiag is a local matrix of size (n x 2)
-
296// @p evecs is a distributed matrix of size (n x n)
-
297//
-
298template <class T>
-
299void solveDistLeaf(comm::CommunicatorPipeline<comm::CommunicatorType::Full>& full_task_chain,
-
300 Matrix<T, Device::CPU>& tridiag, Matrix<T, Device::CPU>& evecs) {
-
301 const matrix::Distribution& dist = evecs.distribution();
-
302 namespace ex = pika::execution::experimental;
-
303
-
304 const comm::Index2D this_rank = dist.rankIndex();
-
305 const SizeType ntiles = dist.nrTiles().rows();
-
306 for (SizeType i = 0; i < ntiles; ++i) {
-
307 const GlobalTileIndex ii_tile(i, i);
-
308 const comm::Index2D ii_rank = dist.rankGlobalTile(ii_tile);
-
309 const GlobalTileIndex id_tr(i, 0);
-
310 if (ii_rank == this_rank) {
-
311 stedcAsync(tridiag.readwrite(id_tr), evecs.readwrite(ii_tile));
-
312 if (full_task_chain.size() > 1) {
-
313 ex::start_detached(comm::schedule_bcast_send(full_task_chain.exclusive(), tridiag.read(id_tr)));
-
314 }
-
315 }
-
316 else {
-
317 const comm::IndexT_MPI root_rank = full_task_chain.rank_full_communicator(ii_rank);
-
318 ex::start_detached(comm::schedule_bcast_recv(full_task_chain.exclusive(), root_rank,
-
319 tridiag.readwrite(id_tr)));
-
320 }
-
321 }
-
322}
-
323
-
324#ifdef DLAF_WITH_GPU
-
325template <class T>
-
326void solveDistLeaf(comm::CommunicatorPipeline<comm::CommunicatorType::Full>& full_task_chain,
-
327 Matrix<T, Device::CPU>& tridiag, Matrix<T, Device::GPU>& evecs,
-
328 Matrix<T, Device::CPU>& h_evecs) {
-
329 const matrix::Distribution& dist = evecs.distribution();
-
330 namespace ex = pika::execution::experimental;
-
331 using matrix::copy;
-
332 using pika::execution::thread_stacksize;
-
333 const auto cp_policy =
-
334 dlaf::internal::Policy<matrix::internal::CopyBackend_v<Device::GPU, Device::CPU>>{
-
335 thread_stacksize::nostack};
-
336
-
337 const comm::Index2D this_rank = dist.rankIndex();
-
338 const SizeType ntiles = dist.nrTiles().rows();
-
339 for (SizeType i = 0; i < ntiles; ++i) {
-
340 const GlobalTileIndex ii_tile(i, i);
-
341 const comm::Index2D ii_rank = dist.rankGlobalTile(ii_tile);
-
342 const GlobalTileIndex id_tr(i, 0);
-
343 if (ii_rank == this_rank) {
-
344 stedcAsync(tridiag.readwrite(id_tr), h_evecs.readwrite(ii_tile));
-
345 ex::start_detached(ex::when_all(h_evecs.read(ii_tile), evecs.readwrite(ii_tile)) |
-
346 copy(cp_policy));
-
347 if (full_task_chain.size() > 1) {
-
348 ex::start_detached(comm::schedule_bcast_send(full_task_chain.exclusive(), tridiag.read(id_tr)));
-
349 }
-
350 }
-
351 else {
-
352 const comm::IndexT_MPI root_rank = full_task_chain.rank_full_communicator(ii_rank);
-
353 ex::start_detached(comm::schedule_bcast_recv(full_task_chain.exclusive(), root_rank,
-
354 tridiag.readwrite(id_tr)));
-
355 }
-
356 }
-
357}
-
358#endif
-
359
-
360// Distributed tridiagonal eigensolver
-
361//
-
362template <Backend B, Device D, class T>
-
363void TridiagSolver<B, D, T>::call(comm::CommunicatorGrid& grid, Matrix<T, Device::CPU>& tridiag,
-
364 Matrix<T, D>& evals, Matrix<T, D>& evecs) {
-
365 using pika::execution::thread_priority;
-
366
-
367 auto full_task_chain = grid.full_communicator_pipeline();
-
368
-
369 // Quick return for empty matrix
-
370 if (evecs.size().isEmpty())
-
371 return;
-
372
-
373#ifdef DLAF_WITH_HDF5
-
374 static std::atomic<size_t> num_tridiag_solver_calls = 0;
-
375 std::stringstream fname;
-
376 fname << "tridiag_solver-"
-
377 << matrix::internal::TypeToString_v<T> << std::to_string(num_tridiag_solver_calls) << ".h5";
-
378 std::optional<matrix::internal::FileHDF5> file;
-
379
-
380 if (getTuneParameters().debug_dump_tridiag_solver_data) {
-
381 file = matrix::internal::FileHDF5(grid.fullCommunicator(), fname.str());
-
382 file->write(tridiag, "/input");
-
383 }
-
384#endif
-
385
-
386 // If the matrix is composed by a single tile simply call stedc.
-
387 if (evecs.nrTiles().linear_size() == 1) {
-
388 if constexpr (D == Device::CPU) {
-
389 solveDistLeaf(full_task_chain, tridiag, evecs);
-
390 }
-
391 else {
-
392 Matrix<T, Device::CPU> h_evecs{evecs.distribution()};
-
393 solveDistLeaf(full_task_chain, tridiag, evecs, h_evecs);
-
394 }
-
395 offloadDiagonal(tridiag, evals);
-
396 return;
-
397 }
-
398
-
399 // Auxiliary matrix used for the D&C algorithm
-
400 const matrix::Distribution& dist_evecs = evecs.distribution();
-
401 const matrix::Distribution& dist_evals = evals.distribution();
-
402 const matrix::Distribution dist_local({dist_evecs.local_size().cols(), 1}, dist_evecs.tile_size());
-
403
-
404 WorkSpace<T, D> ws{Matrix<T, D>(dist_evecs), // e0
-
405 Matrix<T, D>(dist_evecs), // e1
-
406 evecs, // e2
-
407 evals, // d1
-
408 Matrix<T, D>(dist_evals), // z0
-
409 Matrix<T, D>(dist_evals), // z1
-
410 Matrix<SizeType, D>(dist_evals), // i2
-
411 Matrix<SizeType, D>(dist_evals), // i5
-
412 Matrix<SizeType, D>(dist_local), // i5b
-
413 Matrix<SizeType, D>(dist_evals)}; // i6
-
414
-
415 WorkSpaceHost<T> ws_h{Matrix<T, Device::CPU>(dist_evals), // d0
-
416 Matrix<ColType, Device::CPU>(dist_evals), // c
-
417 Matrix<SizeType, Device::CPU>(dist_evals), // i1
-
418 Matrix<SizeType, Device::CPU>(dist_evals), // i3
-
419 Matrix<SizeType, Device::CPU>(dist_evals)}; // i4
-
420
-
421 // Mirror workspace on host memory for CPU-only kernels
-
422 DistWorkSpaceHostMirror<T, D> ws_hm{initMirrorMatrix(ws.e0), initMirrorMatrix(ws.e2),
-
423 initMirrorMatrix(ws.d1), initMirrorMatrix(ws.z0),
-
424 initMirrorMatrix(ws.z1), initMirrorMatrix(ws.i2),
-
425 initMirrorMatrix(ws.i5), initMirrorMatrix(ws.i5b),
-
426 initMirrorMatrix(ws.i6)};
-
427
-
428 // Set `ws.e0` to `zero` (needed for Given's rotation to make sure no random values are picked up)
-
429 matrix::util::set0<B, T, D>(thread_priority::normal, ws.e0);
-
430
-
431 // Cuppen's decomposition
-
432 auto offdiag_vals = cuppensDecomposition(tridiag);
-
433
-
434 auto row_task_chain = grid.row_communicator_pipeline();
-
435 auto col_task_chain = grid.col_communicator_pipeline();
-
436
-
437 // Solve with stedc for each tile of `tridiag` (nb x 2) and save eigenvectors in diagonal tiles of
-
438 // `evecs` (nb x nb)
-
439 if constexpr (D == Device::CPU) {
-
440 solveDistLeaf(full_task_chain, tridiag, ws.e0);
-
441 }
-
442 else {
-
443 solveDistLeaf(full_task_chain, tridiag, ws.e0, ws_hm.e0);
-
444 }
-
445
-
446 // Offload the diagonal from `tridiag` to `evals`
-
447 offloadDiagonal(tridiag, ws_h.d0);
-
448
-
449 // Each triad represents two subproblems to be merged
-
450 SizeType nrtiles = dist_evecs.nrTiles().rows();
-
451 for (auto [i_begin, i_split, i_end] : generateSubproblemIndices(nrtiles)) {
-
452 mergeDistSubproblems<B>(full_task_chain, row_task_chain, col_task_chain, i_begin, i_split, i_end,
-
453 offdiag_vals[to_sizet(i_split - 1)], ws, ws_h, ws_hm);
-
454 }
-
455
-
456 const SizeType n = evecs.nrTiles().rows();
-
457 copy(ws.e0, ws_hm.e0);
-
458
-
459 // Note: ws_hm.d1 is the mirror of ws.d1 which is evals
-
460 applyIndex(0, n, ws_h.i1, ws_h.d0, ws_hm.d1);
-
461 copy(ws_hm.d1, evals);
-
462
-
463 // Note: ws_hm.e2 is the mirror of ws.e2 which is evecs
-
464 dlaf::permutations::permute<Backend::MC, Device::CPU, T, Coord::Col>(row_task_chain, 0, n, ws_h.i1,
-
465 ws_hm.e0, ws_hm.e2);
-
466 copy(ws_hm.e2, evecs);
-
467
-
468#ifdef DLAF_WITH_HDF5
-
469 if (getTuneParameters().debug_dump_tridiag_solver_data) {
-
470 file->write(evecs, "/evecs");
-
471 file->write(evals, "/evals");
-
472 }
-
473
-
474 num_tridiag_solver_calls++;
-
475#endif
-
476}
-
477
-
478// \overload TridiagSolver<B, D, T>::call()
-
479//
-
480// This overload of the distributed tridiagonal version of the algorithm provides the eigenvector matrix
-
481// as complex values where the imaginery part is set to zero.
-
482//
-
483template <Backend B, Device D, class T>
-
484void TridiagSolver<B, D, T>::call(comm::CommunicatorGrid& grid, Matrix<T, Device::CPU>& tridiag,
-
485 Matrix<T, D>& evals, Matrix<std::complex<T>, D>& evecs) {
-
486 Matrix<T, D> real_evecs(evecs.distribution());
-
487 TridiagSolver<B, D, T>::call(grid, tridiag, evals, real_evecs);
-
488
-
489 // Convert real to complex numbers
-
490 const matrix::Distribution& dist = evecs.distribution();
-
491 for (auto tile_wrt_local : iterate_range2d(dist.localNrTiles())) {
-
492 castToComplexAsync<D>(real_evecs.read(tile_wrt_local), evecs.readwrite(tile_wrt_local));
-
493 }
-
494}
-
495
-
496}
+
14#include <complex>
+
15#include <sstream>
+
16#include <tuple>
+
17#include <utility>
+
18#include <vector>
+
19
+
20#include <pika/execution.hpp>
+
21#include <pika/thread.hpp>
+
22
+
23#ifdef DLAF_WITH_GPU
+
24#include <whip.hpp>
+
25#endif
+
26
+
27#include <dlaf/common/callable_object.h>
+
28#include <dlaf/communication/communicator_grid.h>
+
29#include <dlaf/communication/communicator_pipeline.h>
+
30#include <dlaf/communication/index.h>
+
31#include <dlaf/eigensolver/tridiag_solver/api.h>
+
32#include <dlaf/eigensolver/tridiag_solver/kernels_async.h>
+
33#include <dlaf/eigensolver/tridiag_solver/merge.h>
+
34#include <dlaf/lapack/tile.h>
+
35#include <dlaf/matrix/copy_tile.h>
+
36#include <dlaf/matrix/hdf5.h>
+
37#include <dlaf/permutations/general.h>
+
38#include <dlaf/permutations/general/impl.h>
+
39#include <dlaf/sender/make_sender_algorithm_overloads.h>
+
40#include <dlaf/sender/policy.h>
+
41#include <dlaf/types.h>
+
42
+
43namespace dlaf::eigensolver::internal {
+
44
+
45// Splits [i_begin, i_end) in the middle and waits for all splits on [i_begin, i_split] and [i_split,
+
46// i_end) before saving the triad <i_begin, i_split, i_end> into `indices`.
+
47//
+
48// The recursive calls span a binary tree which is traversed in depth first left-right-root order. That
+
49// is also the order of triads in `indices`.
+
50//
+
51inline void splitIntervalInTheMiddleRecursively(
+
52 const SizeType i_begin, const SizeType i_end,
+
53 std::vector<std::tuple<SizeType, SizeType, SizeType>>& indices) {
+
54 if (i_begin + 1 == i_end)
+
55 return;
+
56 const SizeType i_split = util::ceilDiv<SizeType>(i_begin + i_end, 2);
+
57 splitIntervalInTheMiddleRecursively(i_begin, i_split, indices);
+
58 splitIntervalInTheMiddleRecursively(i_split, i_end, indices);
+
59 indices.emplace_back(i_begin, i_split, i_end);
+
60}
+
61
+
62// Generates an array of triad indices. Each triad is composed of begin <= middle < end indices and
+
63// represents two intervals [begin, middle] and [middle + 1, end]. The two intervals are the subproblems
+
64// that have to be merged to arrive at [begin, end].
+
65//
+
66// Note: the intervals are all closed!
+
67//
+
68inline std::vector<std::tuple<SizeType, SizeType, SizeType>> generateSubproblemIndices(const SizeType n) {
+
69 if (n == 0)
+
70 return {};
+
71
+
72 std::vector<std::tuple<SizeType, SizeType, SizeType>> indices;
+
73 indices.reserve(to_sizet(n));
+
74 splitIntervalInTheMiddleRecursively(0, n, indices);
+
75 return indices;
+
76}
+
77
+
78template <class T>
+
79auto cuppensDecomposition(Matrix<T, Device::CPU>& tridiag) {
+
80 namespace ex = pika::execution::experimental;
+
81 using sender_type = decltype(ex::split(
+
82 ex::ensure_started(cuppensDecompAsync<T>(tridiag.readwrite(std::declval<LocalTileIndex>()),
+
83 tridiag.readwrite(std::declval<LocalTileIndex>())))));
+
84 using vector_type = std::vector<sender_type>;
+
85
+
86 if (tridiag.nrTiles().rows() == 0)
+
87 return vector_type{};
+
88
+
89 const SizeType i_end = tridiag.nrTiles().rows();
+
90 vector_type offdiag_vals;
+
91 offdiag_vals.reserve(to_sizet(i_end - 1));
+
92
+
93 for (SizeType i_split = 1; i_split < i_end; ++i_split) {
+
94 offdiag_vals.push_back(ex::split(
+
95 ex::ensure_started(cuppensDecompAsync<T>(tridiag.readwrite(LocalTileIndex(i_split - 1, 0)),
+
96 tridiag.readwrite(LocalTileIndex(i_split, 0))))));
+
97 }
+
98 return offdiag_vals;
+
99}
+
100
+
101// Solve leaf eigensystem with stedc
+
102template <class T>
+
103void solveLeaf(Matrix<T, Device::CPU>& tridiag, Matrix<T, Device::CPU>& evecs) {
+
104 const SizeType ntiles = tridiag.distribution().nrTiles().rows();
+
105 for (SizeType i = 0; i < ntiles; ++i) {
+
106 stedcAsync(tridiag.readwrite(LocalTileIndex(i, 0)), evecs.readwrite(LocalTileIndex(i, i)));
+
107 }
+
108}
+
109
+
110#ifdef DLAF_WITH_GPU
+
111template <class T>
+
112void solveLeaf(Matrix<T, Device::CPU>& tridiag, Matrix<T, Device::GPU>& evecs,
+
113 Matrix<T, Device::CPU>& h_evecs) {
+
114 namespace ex = pika::execution::experimental;
+
115 using matrix::copy;
+
116 using pika::execution::thread_stacksize;
+
117 const auto cp_policy =
+
118 dlaf::internal::Policy<matrix::internal::CopyBackend_v<Device::GPU, Device::CPU>>{
+
119 thread_stacksize::nostack};
+
120
+
121 const SizeType ntiles = tridiag.distribution().nrTiles().rows();
+
122 for (SizeType i = 0; i < ntiles; ++i) {
+
123 const auto id_tr = LocalTileIndex(i, 0);
+
124 const auto id_ev = LocalTileIndex(i, i);
+
125
+
126 stedcAsync(tridiag.readwrite(id_tr), h_evecs.readwrite(id_ev));
+
127 ex::start_detached(ex::when_all(h_evecs.read(id_ev), evecs.readwrite(id_ev)) | copy(cp_policy));
+
128 }
+
129}
+
130#endif
+
131
+
132// Copy the first column of @p tridiag (n x 2) into the column matrix @p evals (n x 1).
+
133template <class T, Device D>
+
134void offloadDiagonal(Matrix<const T, Device::CPU>& tridiag, Matrix<T, D>& evals) {
+
135 for (SizeType i = 0; i < evals.distribution().nrTiles().rows(); ++i) {
+
136 copyDiagonalFromCompactTridiagonalAsync<D>(tridiag.read(GlobalTileIndex(i, 0)),
+
137 evals.readwrite(GlobalTileIndex(i, 0)));
+
138 }
+
139}
+
140
+
141// Notation:
+
142//
+
143// nb - the block/tile size of all matrices and vectors
+
144// n1 - the size of the top subproblem
+
145// n2 - the size of the bottom subproblem
+
146// Q1 - (n1 x n1) the orthogonal matrix of the top subproblem
+
147// Q2 - (n2 x n2) the orthogonal matrix of the bottom subproblem
+
148// n := n1 + n2, the size of the merged problem
+
149//
+
150// ┌───┬───┐
+
151// │Q1 │ │
+
152// Q := ├───┼───┤ , (n x n) orthogonal matrix composed of the top and bottom subproblems
+
153// │ │Q2 │
+
154// └───┴───┘
+
155// D := diag(Q), (n x 1) the diagonal of Q
+
156// z := (n x 1) rank 1 update vector
+
157// rho := rank 1 update scaling factor
+
158// D + rho*z*z^T := rank 1 update problem
+
159// U := (n x n) matrix of eigenvectors of the rank 1 update problem:
+
160//
+
161// k := the size of the deflated rank 1 update problem (k <= n)
+
162// D' := (k x 1), deflated D
+
163// z' := (k x 1), deflated z
+
164// D' + rho*z'*z'^T := deflated rank 1 update problem
+
165// U' := (k x k) matrix of eigenvectors of the deflated rank 1 update problem
+
166//
+
167// l1 := number of columns of the top subproblem after deflation, l1 <= n1
+
168// l2 := number of columns of the bottom subproblem after deflation, l2 <= n2
+
169// Q1' := (n1 x l1) the non-deflated part of Q1 (l1 <= n1)
+
170// Q2' := (n2 x l2) the non-deflated part of Q2 (l2 <= n2)
+
171// Qd := (n-k x n) the deflated parts of Q1 and Q2
+
172// U1' := (l1 x k) is the first l1 rows of U'
+
173// U2' := (l2 x k) is the last l2 rows of U'
+
174// I := (n-k x n-k) identity matrix
+
175// P := (n x n) permutation matrix used to bring Q and U into multiplication form
+
176//
+
177// Q-U multiplication form to arrive at the eigenvectors of the merged problem:
+
178//
+
179// ┌────────┬──────┬────┐ ┌───────────────┬────┐ ┌───────────────┬────┐
+
180// │ │ │ │ │ │ │ │ │ │
+
181// │ Q1' │ │ │ │ │ │ │ Q1'xU1' │ │
+
182// │ │ │ │ │ U1' │ │ │ │ │
+
183// │ │ │ │ │ ──────┤ │ │ │ │
+
184// ├──────┬─┴──────┤ Qd │ ├─────── │ │ ├───────────────┤ Qd │
+
185// │ │ │ │ X │ U2' │ │ = │ │ │
+
186// │ │ │ │ │ │ │ │ Q2'xU2' │ │
+
187// │ │ Q2' │ │ ├───────────────┼────┤ │ │ │
+
188// │ │ │ │ │ │ I │ │ │ │
+
189// │ │ │ │ │ │ │ │ │ │
+
190// └──────┴────────┴────┘ └───────────────┴────┘ └───────────────┴────┘
+
191//
+
192// Note:
+
193// 1. U1' and U2' may overlap (in practice they almost always do)
+
194// 2. The overlap between U1' and U2' matches the number of shared columns between Q1' and Q2'
+
195// 3. The overlap region is due to deflation via Givens rotations of a column vector from Q1 with a
+
196// column vector of Q2.
+
197//
+
198template <Backend B, Device D, class T>
+
199void TridiagSolver<B, D, T>::call(Matrix<T, Device::CPU>& tridiag, Matrix<T, D>& evals,
+
200 Matrix<T, D>& evecs) {
+
201 using pika::execution::thread_priority;
+
202
+
203 // Quick return for empty matrix
+
204 if (evecs.size().isEmpty())
+
205 return;
+
206
+
207 // If the matrix is composed by a single tile simply call stedc.
+
208 if (evecs.nrTiles().linear_size() == 1) {
+
209 if constexpr (D == Device::CPU) {
+
210 solveLeaf(tridiag, evecs);
+
211 }
+
212 else {
+
213 Matrix<T, Device::CPU> h_evecs{evecs.distribution()};
+
214 solveLeaf(tridiag, evecs, h_evecs);
+
215 }
+
216 offloadDiagonal(tridiag, evals);
+
217 return;
+
218 }
+
219
+
220 // Auxiliary matrix used for the D&C algorithm
+
221 const matrix::Distribution& distr = evecs.distribution();
+
222 const LocalElementSize vec_size(distr.size().rows(), 1);
+
223 const TileElementSize vec_tile_size(distr.blockSize().rows(), 1);
+
224 WorkSpace<T, D> ws{Matrix<T, D>(distr), // e0
+
225 Matrix<T, D>(distr), // e1
+
226 evecs, // e2
+
227 evals, // d1
+
228 Matrix<T, D>(vec_size, vec_tile_size), // z0
+
229 Matrix<T, D>(vec_size, vec_tile_size), // z1
+
230 Matrix<SizeType, D>(vec_size, vec_tile_size), // i2
+
231 Matrix<SizeType, D>(vec_size, vec_tile_size), // i5
+
232 Matrix<SizeType, D>(vec_size, vec_tile_size), // i5b
+
233 Matrix<SizeType, D>(vec_size, vec_tile_size)}; // i6
+
234
+
235 WorkSpaceHost<T> ws_h{Matrix<T, Device::CPU>(vec_size, vec_tile_size), // d0
+
236 Matrix<ColType, Device::CPU>(vec_size, vec_tile_size), // c
+
237 Matrix<SizeType, Device::CPU>(vec_size, vec_tile_size), // i1
+
238 Matrix<SizeType, Device::CPU>(vec_size, vec_tile_size), // i3
+
239 Matrix<SizeType, Device::CPU>(vec_size, vec_tile_size)}; // i4
+
240
+
241 // Mirror workspace on host memory for CPU-only kernels
+
242 WorkSpaceHostMirror<T, D> ws_hm{initMirrorMatrix(ws.e2), initMirrorMatrix(ws.d1),
+
243 initMirrorMatrix(ws.z0), initMirrorMatrix(ws.z1),
+
244 initMirrorMatrix(ws.i2), initMirrorMatrix(ws.i5)};
+
245
+
246 // Set `ws.e0` to `zero` (needed for Given's rotation to make sure no random values are picked up)
+
247 matrix::util::set0<B, T, D>(thread_priority::normal, ws.e0);
+
248
+
249 // Cuppen's decomposition
+
250 auto offdiag_vals = cuppensDecomposition(tridiag);
+
251
+
252 // Solve with stedc for each tile of `tridiag` (nb x 2) and save eigenvectors in diagonal tiles of
+
253 // `evecs` (nb x nb)
+
254 if constexpr (D == Device::CPU) {
+
255 solveLeaf(tridiag, ws.e0);
+
256 }
+
257 else {
+
258 solveLeaf(tridiag, ws.e0, ws_hm.e2);
+
259 }
+
260
+
261 // Offload the diagonal from `tridiag` to `d0`
+
262 offloadDiagonal(tridiag, ws_h.d0);
+
263
+
264 // Each triad represents two subproblems to be merged
+
265 for (auto [i_begin, i_split, i_end] : generateSubproblemIndices(distr.nrTiles().rows())) {
+
266 mergeSubproblems<B>(i_begin, i_split, i_end, offdiag_vals[to_sizet(i_split - 1)], ws, ws_h, ws_hm);
+
267 }
+
268
+
269 const SizeType n = evecs.nrTiles().rows();
+
270 copy(ws_hm.i2, ws.i2);
+
271
+
272 // Note: ws_hm.d1 is the mirror of ws.d1 which is evals
+
273 applyIndex(0, n, ws_hm.i2, ws_h.d0, ws_hm.d1);
+
274 copy(ws_hm.d1, evals);
+
275
+
276 dlaf::permutations::permute<B, D, T, Coord::Col>(0, n, ws.i2, ws.e0, evecs);
+
277}
+
278
+
279// Overload which provides the eigenvector matrix as complex values where the imaginery part is set to zero.
+
280template <Backend B, Device D, class T>
+
281void TridiagSolver<B, D, T>::call(Matrix<T, Device::CPU>& tridiag, Matrix<T, D>& evals,
+
282 Matrix<std::complex<T>, D>& evecs) {
+
283 Matrix<T, D> real_evecs(evecs.distribution());
+
284 TridiagSolver<B, D, T>::call(tridiag, evals, real_evecs);
+
285
+
286 // Convert real to complex numbers
+
287 const matrix::Distribution& dist = evecs.distribution();
+
288 for (auto tile_wrt_local : iterate_range2d(dist.localNrTiles())) {
+
289 castToComplexAsync<D>(real_evecs.read(tile_wrt_local), evecs.readwrite(tile_wrt_local));
+
290 }
+
291}
+
292
+
293// Solve for each tile of the local matrix @p tridiag (n x 2) with `stedc()` and save the result in the
+
294// corresponding diagonal tile of the distribtued matrix @p evecs (n x n)
+
295//
+
296// @p tridiag is a local matrix of size (n x 2)
+
297// @p evecs is a distributed matrix of size (n x n)
+
298//
+
299template <class T>
+
300void solveDistLeaf(comm::CommunicatorPipeline<comm::CommunicatorType::Full>& full_task_chain,
+
301 Matrix<T, Device::CPU>& tridiag, Matrix<T, Device::CPU>& evecs) {
+
302 const matrix::Distribution& dist = evecs.distribution();
+
303 namespace ex = pika::execution::experimental;
+
304
+
305 const comm::Index2D this_rank = dist.rankIndex();
+
306 const SizeType ntiles = dist.nrTiles().rows();
+
307 for (SizeType i = 0; i < ntiles; ++i) {
+
308 const GlobalTileIndex ii_tile(i, i);
+
309 const comm::Index2D ii_rank = dist.rankGlobalTile(ii_tile);
+
310 const GlobalTileIndex id_tr(i, 0);
+
311 if (ii_rank == this_rank) {
+
312 stedcAsync(tridiag.readwrite(id_tr), evecs.readwrite(ii_tile));
+
313 if (full_task_chain.size() > 1) {
+
314 ex::start_detached(comm::schedule_bcast_send(full_task_chain.exclusive(), tridiag.read(id_tr)));
+
315 }
+
316 }
+
317 else {
+
318 const comm::IndexT_MPI root_rank = full_task_chain.rank_full_communicator(ii_rank);
+
319 ex::start_detached(comm::schedule_bcast_recv(full_task_chain.exclusive(), root_rank,
+
320 tridiag.readwrite(id_tr)));
+
321 }
+
322 }
+
323}
+
324
+
325#ifdef DLAF_WITH_GPU
+
326template <class T>
+
327void solveDistLeaf(comm::CommunicatorPipeline<comm::CommunicatorType::Full>& full_task_chain,
+
328 Matrix<T, Device::CPU>& tridiag, Matrix<T, Device::GPU>& evecs,
+
329 Matrix<T, Device::CPU>& h_evecs) {
+
330 const matrix::Distribution& dist = evecs.distribution();
+
331 namespace ex = pika::execution::experimental;
+
332 using matrix::copy;
+
333 using pika::execution::thread_stacksize;
+
334 const auto cp_policy =
+
335 dlaf::internal::Policy<matrix::internal::CopyBackend_v<Device::GPU, Device::CPU>>{
+
336 thread_stacksize::nostack};
+
337
+
338 const comm::Index2D this_rank = dist.rankIndex();
+
339 const SizeType ntiles = dist.nrTiles().rows();
+
340 for (SizeType i = 0; i < ntiles; ++i) {
+
341 const GlobalTileIndex ii_tile(i, i);
+
342 const comm::Index2D ii_rank = dist.rankGlobalTile(ii_tile);
+
343 const GlobalTileIndex id_tr(i, 0);
+
344 if (ii_rank == this_rank) {
+
345 stedcAsync(tridiag.readwrite(id_tr), h_evecs.readwrite(ii_tile));
+
346 ex::start_detached(ex::when_all(h_evecs.read(ii_tile), evecs.readwrite(ii_tile)) |
+
347 copy(cp_policy));
+
348 if (full_task_chain.size() > 1) {
+
349 ex::start_detached(comm::schedule_bcast_send(full_task_chain.exclusive(), tridiag.read(id_tr)));
+
350 }
+
351 }
+
352 else {
+
353 const comm::IndexT_MPI root_rank = full_task_chain.rank_full_communicator(ii_rank);
+
354 ex::start_detached(comm::schedule_bcast_recv(full_task_chain.exclusive(), root_rank,
+
355 tridiag.readwrite(id_tr)));
+
356 }
+
357 }
+
358}
+
359#endif
+
360
+
361// Distributed tridiagonal eigensolver
+
362//
+
363template <Backend B, Device D, class T>
+
364void TridiagSolver<B, D, T>::call(comm::CommunicatorGrid& grid, Matrix<T, Device::CPU>& tridiag,
+
365 Matrix<T, D>& evals, Matrix<T, D>& evecs) {
+
366 using pika::execution::thread_priority;
+
367
+
368 auto full_task_chain = grid.full_communicator_pipeline();
+
369
+
370 // Quick return for empty matrix
+
371 if (evecs.size().isEmpty())
+
372 return;
+
373
+
374#ifdef DLAF_WITH_HDF5
+
375 static std::atomic<size_t> num_tridiag_solver_calls = 0;
+
376 std::stringstream fname;
+
377 fname << "tridiag_solver-"
+
378 << matrix::internal::TypeToString_v<T> << std::to_string(num_tridiag_solver_calls) << ".h5";
+
379 std::optional<matrix::internal::FileHDF5> file;
+
380
+
381 if (getTuneParameters().debug_dump_tridiag_solver_data) {
+
382 file = matrix::internal::FileHDF5(grid.fullCommunicator(), fname.str());
+
383 file->write(tridiag, "/input");
+
384 }
+
385#endif
+
386
+
387 // If the matrix is composed by a single tile simply call stedc.
+
388 if (evecs.nrTiles().linear_size() == 1) {
+
389 if constexpr (D == Device::CPU) {
+
390 solveDistLeaf(full_task_chain, tridiag, evecs);
+
391 }
+
392 else {
+
393 Matrix<T, Device::CPU> h_evecs{evecs.distribution()};
+
394 solveDistLeaf(full_task_chain, tridiag, evecs, h_evecs);
+
395 }
+
396 offloadDiagonal(tridiag, evals);
+
397 return;
+
398 }
+
399
+
400 // Auxiliary matrix used for the D&C algorithm
+
401 const matrix::Distribution& dist_evecs = evecs.distribution();
+
402 const matrix::Distribution& dist_evals = evals.distribution();
+
403 const matrix::Distribution dist_local({dist_evecs.local_size().cols(), 1}, dist_evecs.tile_size());
+
404
+
405 WorkSpace<T, D> ws{Matrix<T, D>(dist_evecs), // e0
+
406 Matrix<T, D>(dist_evecs), // e1
+
407 evecs, // e2
+
408 evals, // d1
+
409 Matrix<T, D>(dist_evals), // z0
+
410 Matrix<T, D>(dist_evals), // z1
+
411 Matrix<SizeType, D>(dist_evals), // i2
+
412 Matrix<SizeType, D>(dist_evals), // i5
+
413 Matrix<SizeType, D>(dist_local), // i5b
+
414 Matrix<SizeType, D>(dist_evals)}; // i6
+
415
+
416 WorkSpaceHost<T> ws_h{Matrix<T, Device::CPU>(dist_evals), // d0
+
417 Matrix<ColType, Device::CPU>(dist_evals), // c
+
418 Matrix<SizeType, Device::CPU>(dist_evals), // i1
+
419 Matrix<SizeType, Device::CPU>(dist_evals), // i3
+
420 Matrix<SizeType, Device::CPU>(dist_evals)}; // i4
+
421
+
422 // Mirror workspace on host memory for CPU-only kernels
+
423 DistWorkSpaceHostMirror<T, D> ws_hm{initMirrorMatrix(ws.e0), initMirrorMatrix(ws.e2),
+
424 initMirrorMatrix(ws.d1), initMirrorMatrix(ws.z0),
+
425 initMirrorMatrix(ws.z1), initMirrorMatrix(ws.i2),
+
426 initMirrorMatrix(ws.i5), initMirrorMatrix(ws.i5b),
+
427 initMirrorMatrix(ws.i6)};
+
428
+
429 // Set `ws.e0` to `zero` (needed for Given's rotation to make sure no random values are picked up)
+
430 matrix::util::set0<B, T, D>(thread_priority::normal, ws.e0);
+
431
+
432 // Cuppen's decomposition
+
433 auto offdiag_vals = cuppensDecomposition(tridiag);
+
434
+
435 auto row_task_chain = grid.row_communicator_pipeline();
+
436 auto col_task_chain = grid.col_communicator_pipeline();
+
437
+
438 // Solve with stedc for each tile of `tridiag` (nb x 2) and save eigenvectors in diagonal tiles of
+
439 // `evecs` (nb x nb)
+
440 if constexpr (D == Device::CPU) {
+
441 solveDistLeaf(full_task_chain, tridiag, ws.e0);
+
442 }
+
443 else {
+
444 solveDistLeaf(full_task_chain, tridiag, ws.e0, ws_hm.e0);
+
445 }
+
446
+
447 // Offload the diagonal from `tridiag` to `evals`
+
448 offloadDiagonal(tridiag, ws_h.d0);
+
449
+
450 // Each triad represents two subproblems to be merged
+
451 SizeType nrtiles = dist_evecs.nrTiles().rows();
+
452 for (auto [i_begin, i_split, i_end] : generateSubproblemIndices(nrtiles)) {
+
453 mergeDistSubproblems<B>(full_task_chain, row_task_chain, col_task_chain, i_begin, i_split, i_end,
+
454 offdiag_vals[to_sizet(i_split - 1)], ws, ws_h, ws_hm);
+
455 }
+
456
+
457 const SizeType n = evecs.nrTiles().rows();
+
458 copy(ws.e0, ws_hm.e0);
+
459
+
460 // Note: ws_hm.d1 is the mirror of ws.d1 which is evals
+
461 applyIndex(0, n, ws_h.i1, ws_h.d0, ws_hm.d1);
+
462 copy(ws_hm.d1, evals);
+
463
+
464 // Note: ws_hm.e2 is the mirror of ws.e2 which is evecs
+
465 dlaf::permutations::permute<Backend::MC, Device::CPU, T, Coord::Col>(row_task_chain, 0, n, ws_h.i1,
+
466 ws_hm.e0, ws_hm.e2);
+
467 copy(ws_hm.e2, evecs);
+
468
+
469#ifdef DLAF_WITH_HDF5
+
470 if (getTuneParameters().debug_dump_tridiag_solver_data) {
+
471 file->write(evecs, "/evecs");
+
472 file->write(evals, "/evals");
+
473 }
+
474
+
475 num_tridiag_solver_calls++;
+
476#endif
+
477}
+
478
+
479// \overload TridiagSolver<B, D, T>::call()
+
480//
+
481// This overload of the distributed tridiagonal version of the algorithm provides the eigenvector matrix
+
482// as complex values where the imaginery part is set to zero.
+
483//
+
484template <Backend B, Device D, class T>
+
485void TridiagSolver<B, D, T>::call(comm::CommunicatorGrid& grid, Matrix<T, Device::CPU>& tridiag,
+
486 Matrix<T, D>& evals, Matrix<std::complex<T>, D>& evecs) {
+
487 Matrix<T, D> real_evecs(evecs.distribution());
+
488 TridiagSolver<B, D, T>::call(grid, tridiag, evals, real_evecs);
+
489
+
490 // Convert real to complex numbers
+
491 const matrix::Distribution& dist = evecs.distribution();
+
492 for (auto tile_wrt_local : iterate_range2d(dist.localNrTiles())) {
+
493 castToComplexAsync<D>(real_evecs.read(tile_wrt_local), evecs.readwrite(tile_wrt_local));
+
494 }
+
495}
+
496
+
497}
callable_object.h
dlaf::internal::Policy
Definition policy.h:24
diff --git a/master/eigensolver_2tridiag__solver_2kernels_8h_source.html b/master/eigensolver_2tridiag__solver_2kernels_8h_source.html index e0e17179b3..f9e1d5ba3b 100644 --- a/master/eigensolver_2tridiag__solver_2kernels_8h_source.html +++ b/master/eigensolver_2tridiag__solver_2kernels_8h_source.html @@ -93,134 +93,136 @@
10
11#pragma once
12
-
13#include <dlaf/common/callable_object.h>
-
14#include <dlaf/eigensolver/tridiag_solver/coltype.h>
-
15#include <dlaf/lapack/tile.h>
-
16#include <dlaf/matrix/copy_tile.h>
-
17#include <dlaf/matrix/tile.h>
-
18#include <dlaf/types.h>
-
19
-
20#ifdef DLAF_WITH_GPU
-
21#include <whip.hpp>
-
22
-
23#include <dlaf/eigensolver/tridiag_solver/gpu/kernels.h>
-
24#include <dlaf/gpu/lapack/api.h>
-
25#endif
-
26
-
27namespace dlaf::eigensolver::internal {
+
13#include <complex>
+
14
+
15#include <dlaf/common/callable_object.h>
+
16#include <dlaf/eigensolver/tridiag_solver/coltype.h>
+
17#include <dlaf/lapack/tile.h>
+
18#include <dlaf/matrix/copy_tile.h>
+
19#include <dlaf/matrix/tile.h>
+
20#include <dlaf/types.h>
+
21
+
22#ifdef DLAF_WITH_GPU
+
23#include <whip.hpp>
+
24
+
25#include <dlaf/eigensolver/tridiag_solver/gpu/kernels.h>
+
26#include <dlaf/gpu/lapack/api.h>
+
27#endif
28
-
29template <class T>
-
30void castToComplex(const matrix::Tile<const T, Device::CPU>& in,
-
31 const matrix::Tile<std::complex<T>, Device::CPU>& out) {
-
32 DLAF_ASSERT_HEAVY(in.size() == out.size(), in.size(), out.size());
-
33 for (auto el_idx : iterate_range2d(out.size())) {
-
34 out(el_idx) = std::complex<T>(in(el_idx), 0);
-
35 }
-
36}
-
37
-
38#ifdef DLAF_WITH_GPU
-
39template <class T>
-
40void castToComplex(const matrix::Tile<const T, Device::GPU>& in,
-
41 const matrix::Tile<std::complex<T>, Device::GPU>& out, whip::stream_t stream) {
-
42 DLAF_ASSERT_HEAVY(in.size() == out.size(), in.size(), out.size());
-
43 const SizeType m = in.size().rows();
-
44 const SizeType n = in.size().cols();
-
45 gpu::castToComplex(m, n, in.ptr(), in.ld(), out.ptr(), out.ld(), stream);
-
46}
-
47#endif
-
48
-
49DLAF_MAKE_CALLABLE_OBJECT(castToComplex);
+
29namespace dlaf::eigensolver::internal {
+
30
+
31template <class T>
+
32void castToComplex(const matrix::Tile<const T, Device::CPU>& in,
+
33 const matrix::Tile<std::complex<T>, Device::CPU>& out) {
+
34 DLAF_ASSERT_HEAVY(in.size() == out.size(), in.size(), out.size());
+
35 for (auto el_idx : iterate_range2d(out.size())) {
+
36 out(el_idx) = std::complex<T>(in(el_idx), 0);
+
37 }
+
38}
+
39
+
40#ifdef DLAF_WITH_GPU
+
41template <class T>
+
42void castToComplex(const matrix::Tile<const T, Device::GPU>& in,
+
43 const matrix::Tile<std::complex<T>, Device::GPU>& out, whip::stream_t stream) {
+
44 DLAF_ASSERT_HEAVY(in.size() == out.size(), in.size(), out.size());
+
45 const SizeType m = in.size().rows();
+
46 const SizeType n = in.size().cols();
+
47 gpu::castToComplex(m, n, in.ptr(), in.ld(), out.ptr(), out.ld(), stream);
+
48}
+
49#endif
50
-
51// Cuppen's decomposition
-
52//
-
53// Substracts the offdiagonal element at the split from the top and bottom diagonal elements and
-
54// returns the offdiagonal element. The split is between the last row of the top tile and the first
-
55// row of the bottom tile.
-
56//
-
57template <class T>
-
58T cuppensDecomp(const matrix::Tile<T, Device::CPU>& top, const matrix::Tile<T, Device::CPU>& bottom) {
-
59 TileElementIndex offdiag_idx{top.size().rows() - 1, 1};
-
60 TileElementIndex top_idx{top.size().rows() - 1, 0};
-
61 TileElementIndex bottom_idx{0, 0};
-
62 const T offdiag_val = top(offdiag_idx);
-
63
-
64 // Refence: Lapack working notes: LAWN 69, Serial Cuppen algorithm, Chapter 3
-
65 //
-
66 top(top_idx) -= std::abs(offdiag_val);
-
67 bottom(bottom_idx) -= std::abs(offdiag_val);
-
68 return offdiag_val;
-
69}
-
70
-
71DLAF_MAKE_CALLABLE_OBJECT(cuppensDecomp);
+
51DLAF_MAKE_CALLABLE_OBJECT(castToComplex);
+
52
+
53// Cuppen's decomposition
+
54//
+
55// Substracts the offdiagonal element at the split from the top and bottom diagonal elements and
+
56// returns the offdiagonal element. The split is between the last row of the top tile and the first
+
57// row of the bottom tile.
+
58//
+
59template <class T>
+
60T cuppensDecomp(const matrix::Tile<T, Device::CPU>& top, const matrix::Tile<T, Device::CPU>& bottom) {
+
61 TileElementIndex offdiag_idx{top.size().rows() - 1, 1};
+
62 TileElementIndex top_idx{top.size().rows() - 1, 0};
+
63 TileElementIndex bottom_idx{0, 0};
+
64 const T offdiag_val = top(offdiag_idx);
+
65
+
66 // Refence: Lapack working notes: LAWN 69, Serial Cuppen algorithm, Chapter 3
+
67 //
+
68 top(top_idx) -= std::abs(offdiag_val);
+
69 bottom(bottom_idx) -= std::abs(offdiag_val);
+
70 return offdiag_val;
+
71}
72
-
73template <class T>
-
74void copyDiagonalFromCompactTridiagonal(const matrix::Tile<const T, Device::CPU>& tridiag_tile,
-
75 const matrix::Tile<T, Device::CPU>& diag_tile) {
-
76 const SizeType m = tridiag_tile.size().rows();
-
77 DLAF_ASSERT_HEAVY(m == diag_tile.size().rows(), m, diag_tile.size().rows());
-
78 for (SizeType i = 0; i < m; ++i) {
-
79 diag_tile(TileElementIndex(i, 0)) = tridiag_tile(TileElementIndex(i, 0));
-
80 }
-
81}
-
82
-
83#ifdef DLAF_WITH_GPU
-
84template <class T>
-
85void copyDiagonalFromCompactTridiagonal(const matrix::Tile<const T, Device::CPU>& tridiag_tile,
-
86 const matrix::Tile<T, Device::GPU>& diag_tile,
-
87 whip::stream_t stream) {
-
88 const SizeType m = tridiag_tile.size().rows();
-
89 DLAF_ASSERT_HEAVY(m == diag_tile.size().rows(), m, diag_tile.size().rows());
-
90
-
91 whip::memcpy_async(diag_tile.ptr(), tridiag_tile.ptr(), sizeof(T) * to_sizet(m), whip::memcpy_default,
-
92 stream);
-
93}
-
94#endif
-
95
-
96DLAF_MAKE_CALLABLE_OBJECT(copyDiagonalFromCompactTridiagonal);
+
73DLAF_MAKE_CALLABLE_OBJECT(cuppensDecomp);
+
74
+
75template <class T>
+
76void copyDiagonalFromCompactTridiagonal(const matrix::Tile<const T, Device::CPU>& tridiag_tile,
+
77 const matrix::Tile<T, Device::CPU>& diag_tile) {
+
78 const SizeType m = tridiag_tile.size().rows();
+
79 DLAF_ASSERT_HEAVY(m == diag_tile.size().rows(), m, diag_tile.size().rows());
+
80 for (SizeType i = 0; i < m; ++i) {
+
81 diag_tile(TileElementIndex(i, 0)) = tridiag_tile(TileElementIndex(i, 0));
+
82 }
+
83}
+
84
+
85#ifdef DLAF_WITH_GPU
+
86template <class T>
+
87void copyDiagonalFromCompactTridiagonal(const matrix::Tile<const T, Device::CPU>& tridiag_tile,
+
88 const matrix::Tile<T, Device::GPU>& diag_tile,
+
89 whip::stream_t stream) {
+
90 const SizeType m = tridiag_tile.size().rows();
+
91 DLAF_ASSERT_HEAVY(m == diag_tile.size().rows(), m, diag_tile.size().rows());
+
92
+
93 whip::memcpy_async(diag_tile.ptr(), tridiag_tile.ptr(), sizeof(T) * to_sizet(m), whip::memcpy_default,
+
94 stream);
+
95}
+
96#endif
97
-
98template <class T>
-
99void assembleRank1UpdateVectorTile(bool is_top_tile, T rho,
-
100 const matrix::Tile<const T, Device::CPU>& evecs_tile,
-
101 const matrix::Tile<T, Device::CPU>& rank1_tile) {
-
102 const SizeType m = evecs_tile.size().rows();
-
103 const SizeType n = evecs_tile.size().cols();
-
104 DLAF_ASSERT_HEAVY(n == rank1_tile.size().rows(), n, rank1_tile.size().rows());
-
105
-
106 // Copy the bottom row of the top tile or the top row of the bottom tile
-
107 SizeType row = (is_top_tile) ? m - 1 : 0;
-
108
-
109 // Negate the last row of the top eigenvector subproblem matrix (Q1) if rho < 0
-
110 //
-
111 // lapack 3.10.0, dlaed2.f, line 280 and 281
-
112 int sign = (is_top_tile && rho < 0) ? -1 : 1;
-
113
-
114 for (SizeType i = 0; i < n; ++i) {
-
115 rank1_tile(TileElementIndex(i, 0)) = sign * evecs_tile(TileElementIndex(row, i)) / T(std::sqrt(2));
-
116 }
-
117}
-
118
-
119#ifdef DLAF_WITH_GPU
+
98DLAF_MAKE_CALLABLE_OBJECT(copyDiagonalFromCompactTridiagonal);
+
99
+
100template <class T>
+
101void assembleRank1UpdateVectorTile(bool is_top_tile, T rho,
+
102 const matrix::Tile<const T, Device::CPU>& evecs_tile,
+
103 const matrix::Tile<T, Device::CPU>& rank1_tile) {
+
104 const SizeType m = evecs_tile.size().rows();
+
105 const SizeType n = evecs_tile.size().cols();
+
106 DLAF_ASSERT_HEAVY(n == rank1_tile.size().rows(), n, rank1_tile.size().rows());
+
107
+
108 // Copy the bottom row of the top tile or the top row of the bottom tile
+
109 SizeType row = (is_top_tile) ? m - 1 : 0;
+
110
+
111 // Negate the last row of the top eigenvector subproblem matrix (Q1) if rho < 0
+
112 //
+
113 // lapack 3.10.0, dlaed2.f, line 280 and 281
+
114 int sign = (is_top_tile && rho < 0) ? -1 : 1;
+
115
+
116 for (SizeType i = 0; i < n; ++i) {
+
117 rank1_tile(TileElementIndex(i, 0)) = sign * evecs_tile(TileElementIndex(row, i)) / T(std::sqrt(2));
+
118 }
+
119}
120
-
121template <class T>
-
122void assembleRank1UpdateVectorTile(bool is_top_tile, T rho,
-
123 const matrix::Tile<const T, Device::GPU>& evecs_tile,
-
124 const matrix::Tile<T, Device::GPU>& rank1_tile,
-
125 whip::stream_t stream) {
-
126 const SizeType m = evecs_tile.size().rows();
-
127 const SizeType n = evecs_tile.size().cols();
-
128 DLAF_ASSERT_HEAVY(n == rank1_tile.size().rows(), n, rank1_tile.size().rows());
-
129
-
130 gpu::assembleRank1UpdateVectorTile(is_top_tile, rho, m, n, evecs_tile.ptr(), evecs_tile.ld(),
-
131 rank1_tile.ptr(), stream);
-
132}
-
133#endif
-
134
-
135DLAF_MAKE_CALLABLE_OBJECT(assembleRank1UpdateVectorTile);
+
121#ifdef DLAF_WITH_GPU
+
122
+
123template <class T>
+
124void assembleRank1UpdateVectorTile(bool is_top_tile, T rho,
+
125 const matrix::Tile<const T, Device::GPU>& evecs_tile,
+
126 const matrix::Tile<T, Device::GPU>& rank1_tile,
+
127 whip::stream_t stream) {
+
128 const SizeType m = evecs_tile.size().rows();
+
129 const SizeType n = evecs_tile.size().cols();
+
130 DLAF_ASSERT_HEAVY(n == rank1_tile.size().rows(), n, rank1_tile.size().rows());
+
131
+
132 gpu::assembleRank1UpdateVectorTile(is_top_tile, rho, m, n, evecs_tile.ptr(), evecs_tile.ld(),
+
133 rank1_tile.ptr(), stream);
+
134}
+
135#endif
136
-
137#ifdef DLAF_WITH_GPU
-
138using gpu::givensRotationOnDevice;
-
139#endif
-
140}
+
137DLAF_MAKE_CALLABLE_OBJECT(assembleRank1UpdateVectorTile);
+
138
+
139#ifdef DLAF_WITH_GPU
+
140using gpu::givensRotationOnDevice;
+
141#endif
+
142}
callable_object.h
DLAF_MAKE_CALLABLE_OBJECT
#define DLAF_MAKE_CALLABLE_OBJECT(fname)
Definition callable_object.h:29
copy_tile.h
diff --git a/master/factorization_2cholesky_2api_8h_source.html b/master/factorization_2cholesky_2api_8h_source.html index d355318037..93e19117fc 100644 --- a/master/factorization_2cholesky_2api_8h_source.html +++ b/master/factorization_2cholesky_2api_8h_source.html @@ -92,39 +92,41 @@
9//
10#pragma once
11
-
12#include <dlaf/matrix/matrix.h>
-
13#include <dlaf/types.h>
-
14
-
15namespace dlaf::factorization::internal {
-
16template <Backend backend, Device device, class T>
-
-
17struct Cholesky {
-
18 static void call_L(Matrix<T, device>& mat_a);
-
19 static void call_U(Matrix<T, device>& mat_a);
-
20 static void call_L(comm::CommunicatorGrid& grid, Matrix<T, device>& mat_a);
-
21 static void call_U(comm::CommunicatorGrid& grid, Matrix<T, device>& mat_a);
-
22};
+
12#include <complex>
+
13
+
14#include <dlaf/matrix/matrix.h>
+
15#include <dlaf/types.h>
+
16
+
17namespace dlaf::factorization::internal {
+
18template <Backend backend, Device device, class T>
+
+
19struct Cholesky {
+
20 static void call_L(Matrix<T, device>& mat_a);
+
21 static void call_U(Matrix<T, device>& mat_a);
+
22 static void call_L(comm::CommunicatorGrid& grid, Matrix<T, device>& mat_a);
+
23 static void call_U(comm::CommunicatorGrid& grid, Matrix<T, device>& mat_a);
+
24};
-
23
-
24// ETI
-
25#define DLAF_FACTORIZATION_CHOLESKY_ETI(KWORD, BACKEND, DEVICE, DATATYPE) \
-
26 KWORD template struct Cholesky<BACKEND, DEVICE, DATATYPE>;
-
27
-
28DLAF_FACTORIZATION_CHOLESKY_ETI(extern, Backend::MC, Device::CPU, float)
-
29DLAF_FACTORIZATION_CHOLESKY_ETI(extern, Backend::MC, Device::CPU, double)
-
30DLAF_FACTORIZATION_CHOLESKY_ETI(extern, Backend::MC, Device::CPU, std::complex<float>)
-
31DLAF_FACTORIZATION_CHOLESKY_ETI(extern, Backend::MC, Device::CPU, std::complex<double>)
-
32
-
33#ifdef DLAF_WITH_GPU
-
34DLAF_FACTORIZATION_CHOLESKY_ETI(extern, Backend::GPU, Device::GPU, float)
-
35DLAF_FACTORIZATION_CHOLESKY_ETI(extern, Backend::GPU, Device::GPU, double)
-
36DLAF_FACTORIZATION_CHOLESKY_ETI(extern, Backend::GPU, Device::GPU, std::complex<float>)
-
37DLAF_FACTORIZATION_CHOLESKY_ETI(extern, Backend::GPU, Device::GPU, std::complex<double>)
-
38#endif
-
39}
+
25
+
26// ETI
+
27#define DLAF_FACTORIZATION_CHOLESKY_ETI(KWORD, BACKEND, DEVICE, DATATYPE) \
+
28 KWORD template struct Cholesky<BACKEND, DEVICE, DATATYPE>;
+
29
+
30DLAF_FACTORIZATION_CHOLESKY_ETI(extern, Backend::MC, Device::CPU, float)
+
31DLAF_FACTORIZATION_CHOLESKY_ETI(extern, Backend::MC, Device::CPU, double)
+
32DLAF_FACTORIZATION_CHOLESKY_ETI(extern, Backend::MC, Device::CPU, std::complex<float>)
+
33DLAF_FACTORIZATION_CHOLESKY_ETI(extern, Backend::MC, Device::CPU, std::complex<double>)
+
34
+
35#ifdef DLAF_WITH_GPU
+
36DLAF_FACTORIZATION_CHOLESKY_ETI(extern, Backend::GPU, Device::GPU, float)
+
37DLAF_FACTORIZATION_CHOLESKY_ETI(extern, Backend::GPU, Device::GPU, double)
+
38DLAF_FACTORIZATION_CHOLESKY_ETI(extern, Backend::GPU, Device::GPU, std::complex<float>)
+
39DLAF_FACTORIZATION_CHOLESKY_ETI(extern, Backend::GPU, Device::GPU, std::complex<double>)
+
40#endif
+
41}
dlaf::comm::CommunicatorGrid
Definition communicator_grid.h:37
- +
diff --git a/master/factorization_2cholesky_8h_source.html b/master/factorization_2cholesky_8h_source.html index 0b40cef07d..e6899bd8e6 100644 --- a/master/factorization_2cholesky_8h_source.html +++ b/master/factorization_2cholesky_8h_source.html @@ -139,7 +139,7 @@
communicator_grid.h
dlaf::cholesky_factorization
void cholesky_factorization(blas::Uplo uplo, Matrix< T, device > &mat_a)
Definition cholesky.h:40
- +
util_matrix.h
diff --git a/master/factorization_2qr_2api_8h_source.html b/master/factorization_2qr_2api_8h_source.html index 81ef419999..6b8b8a0fec 100644 --- a/master/factorization_2qr_2api_8h_source.html +++ b/master/factorization_2qr_2api_8h_source.html @@ -93,57 +93,59 @@
10
11#pragma once
12
-
13#include <pika/execution.hpp>
+
13#include <complex>
14
-
15#include <dlaf/communication/communicator_pipeline.h>
-
16#include <dlaf/matrix/panel.h>
-
17#include <dlaf/matrix/tile.h>
-
18#include <dlaf/matrix/views.h>
-
19#include <dlaf/types.h>
-
20
-
21namespace dlaf::factorization::internal {
+
15#include <pika/execution.hpp>
+
16
+
17#include <dlaf/communication/communicator_pipeline.h>
+
18#include <dlaf/matrix/panel.h>
+
19#include <dlaf/matrix/tile.h>
+
20#include <dlaf/matrix/views.h>
+
21#include <dlaf/types.h>
22
-
23template <Backend backend, Device device, class T>
-
24struct QR {};
-
25
-
26template <Backend backend, Device device, class T>
-
-
27struct QR_Tfactor {
-
52 static void call(matrix::Panel<Coord::Col, T, device>& panel_view,
-
53 matrix::ReadOnlyTileSender<T, Device::CPU> taus,
-
54 matrix::ReadWriteTileSender<T, device> t);
-
55
-
81 static void call(matrix::Panel<Coord::Col, T, device>& hh_panel,
-
82 matrix::ReadOnlyTileSender<T, Device::CPU> taus,
-
83 matrix::ReadWriteTileSender<T, device> t,
-
84 comm::CommunicatorPipeline<comm::CommunicatorType::Col>& mpi_col_task_chain);
-
85};
+
23namespace dlaf::factorization::internal {
+
24
+
25template <Backend backend, Device device, class T>
+
26struct QR {};
+
27
+
28template <Backend backend, Device device, class T>
+ -
86
-
87// ETI
-
88#define DLAF_FACTORIZATION_QR_TFACTOR_ETI(KWORD, BACKEND, DEVICE, DATATYPE) \
-
89 KWORD template struct QR_Tfactor<BACKEND, DEVICE, DATATYPE>;
-
90
-
91DLAF_FACTORIZATION_QR_TFACTOR_ETI(extern, Backend::MC, Device::CPU, float)
-
92DLAF_FACTORIZATION_QR_TFACTOR_ETI(extern, Backend::MC, Device::CPU, double)
-
93DLAF_FACTORIZATION_QR_TFACTOR_ETI(extern, Backend::MC, Device::CPU, std::complex<float>)
-
94DLAF_FACTORIZATION_QR_TFACTOR_ETI(extern, Backend::MC, Device::CPU, std::complex<double>)
-
95
-
96#ifdef DLAF_WITH_GPU
-
97DLAF_FACTORIZATION_QR_TFACTOR_ETI(extern, Backend::GPU, Device::GPU, float)
-
98DLAF_FACTORIZATION_QR_TFACTOR_ETI(extern, Backend::GPU, Device::GPU, double)
-
99DLAF_FACTORIZATION_QR_TFACTOR_ETI(extern, Backend::GPU, Device::GPU, std::complex<float>)
-
100DLAF_FACTORIZATION_QR_TFACTOR_ETI(extern, Backend::GPU, Device::GPU, std::complex<double>)
-
101#endif
-
102}
+
88
+
89// ETI
+
90#define DLAF_FACTORIZATION_QR_TFACTOR_ETI(KWORD, BACKEND, DEVICE, DATATYPE) \
+
91 KWORD template struct QR_Tfactor<BACKEND, DEVICE, DATATYPE>;
+
92
+
93DLAF_FACTORIZATION_QR_TFACTOR_ETI(extern, Backend::MC, Device::CPU, float)
+
94DLAF_FACTORIZATION_QR_TFACTOR_ETI(extern, Backend::MC, Device::CPU, double)
+
95DLAF_FACTORIZATION_QR_TFACTOR_ETI(extern, Backend::MC, Device::CPU, std::complex<float>)
+
96DLAF_FACTORIZATION_QR_TFACTOR_ETI(extern, Backend::MC, Device::CPU, std::complex<double>)
+
97
+
98#ifdef DLAF_WITH_GPU
+
99DLAF_FACTORIZATION_QR_TFACTOR_ETI(extern, Backend::GPU, Device::GPU, float)
+
100DLAF_FACTORIZATION_QR_TFACTOR_ETI(extern, Backend::GPU, Device::GPU, double)
+
101DLAF_FACTORIZATION_QR_TFACTOR_ETI(extern, Backend::GPU, Device::GPU, std::complex<float>)
+
102DLAF_FACTORIZATION_QR_TFACTOR_ETI(extern, Backend::GPU, Device::GPU, std::complex<double>)
+
103#endif
+
104}
dlaf::comm::CommunicatorPipeline
Definition communicator_pipeline.h:41
-
dlaf::matrix::Matrix
Definition matrix.h:61
+
dlaf::matrix::Matrix
Definition matrix.h:62
communicator_pipeline.h
-
dlaf::factorization::internal::QR_Tfactor
Definition api.h:27
+
dlaf::factorization::internal::QR_Tfactor
Definition api.h:29
dlaf::factorization::internal::QR_Tfactor::call
static void call(matrix::Panel< Coord::Col, T, device > &panel_view, matrix::ReadOnlyTileSender< T, Device::CPU > taus, matrix::ReadWriteTileSender< T, device > t)
Definition t_factor_impl.h:248
- +
diff --git a/master/gen__to__std_8h_source.html b/master/gen__to__std_8h_source.html index ac767edc60..7ecb3d30ad 100644 --- a/master/gen__to__std_8h_source.html +++ b/master/gen__to__std_8h_source.html @@ -165,7 +165,7 @@
communicator_grid.h
dlaf::eigensolver::internal::generalized_to_standard
void generalized_to_standard(blas::Uplo uplo, Matrix< T, device > &mat_a, Matrix< T, device > &mat_b)
Definition gen_to_std.h:50
- +
util_matrix.h
diff --git a/master/gpublas_8h.html b/master/gpublas_8h.html index 620d9e1337..446c9e9bec 100644 --- a/master/gpublas_8h.html +++ b/master/gpublas_8h.html @@ -79,7 +79,8 @@
gpublas.h File Reference
-
#include <cstddef>
+
#include <complex>
+#include <cstddef>
#include <utility>
#include <whip.hpp>
#include <dlaf/gpu/blas/api.h>
diff --git a/master/gpublas_8h_source.html b/master/gpublas_8h_source.html index 42128c0ac5..caa66ea435 100644 --- a/master/gpublas_8h_source.html +++ b/master/gpublas_8h_source.html @@ -94,139 +94,140 @@
11
14
15#ifdef DLAF_WITH_GPU
-
16#include <cstddef>
-
17#include <utility>
-
18
-
19#include <whip.hpp>
-
20
-
21#include <dlaf/gpu/blas/api.h>
-
22#include <dlaf/gpu/blas/error.h>
-
23#include <dlaf/util_cublas.h>
-
24
-
25#ifdef DLAF_WITH_HIP
-
26
-
27#include <pika/async_cuda/detail/cuda_event_callback.hpp>
-
28
-
29#include <dlaf/memory/memory_view.h>
-
30
-
31#define DLAF_GET_ROCBLAS_WORKSPACE(f) \
-
32 [&]() { \
-
33 std::size_t workspace_size; \
-
34 DLAF_GPUBLAS_CHECK_ERROR( \
-
35 rocblas_start_device_memory_size_query(static_cast<rocblas_handle>(handle))); \
-
36 DLAF_ROCBLAS_WORKSPACE_CHECK_ERROR(rocblas_##f(handle, std::forward<Args>(args)...)); \
-
37 DLAF_GPUBLAS_CHECK_ERROR(rocblas_stop_device_memory_size_query(static_cast<rocblas_handle>(handle), \
-
38 &workspace_size)); \
-
39 return ::dlaf::memory::MemoryView<std::byte, Device::GPU>(to_int(workspace_size)); \
-
40 }();
-
41
-
42namespace dlaf::tile::internal {
-
43inline void extendROCBlasWorkspace(cublasHandle_t handle,
-
44 ::dlaf::memory::MemoryView<std::byte, Device::GPU>&& workspace) {
-
45 whip::stream_t stream;
-
46 DLAF_GPUBLAS_CHECK_ERROR(cublasGetStream(handle, &stream));
-
47 auto f = [workspace = std::move(workspace)](whip::error_t status) { whip::check_error(status); };
-
48 pika::cuda::experimental::detail::add_event_callback(std::move(f), stream);
-
49}
+
16#include <complex>
+
17#include <cstddef>
+
18#include <utility>
+
19
+
20#include <whip.hpp>
+
21
+
22#include <dlaf/gpu/blas/api.h>
+
23#include <dlaf/gpu/blas/error.h>
+
24#include <dlaf/util_cublas.h>
+
25
+
26#ifdef DLAF_WITH_HIP
+
27
+
28#include <pika/async_cuda/detail/cuda_event_callback.hpp>
+
29
+
30#include <dlaf/memory/memory_view.h>
+
31
+
32#define DLAF_GET_ROCBLAS_WORKSPACE(f) \
+
33 [&]() { \
+
34 std::size_t workspace_size; \
+
35 DLAF_GPUBLAS_CHECK_ERROR( \
+
36 rocblas_start_device_memory_size_query(static_cast<rocblas_handle>(handle))); \
+
37 DLAF_ROCBLAS_WORKSPACE_CHECK_ERROR(rocblas_##f(handle, std::forward<Args>(args)...)); \
+
38 DLAF_GPUBLAS_CHECK_ERROR(rocblas_stop_device_memory_size_query(static_cast<rocblas_handle>(handle), \
+
39 &workspace_size)); \
+
40 return ::dlaf::memory::MemoryView<std::byte, Device::GPU>(to_int(workspace_size)); \
+
41 }();
+
42
+
43namespace dlaf::tile::internal {
+
44inline void extendROCBlasWorkspace(cublasHandle_t handle,
+
45 ::dlaf::memory::MemoryView<std::byte, Device::GPU>&& workspace) {
+
46 whip::stream_t stream;
+
47 DLAF_GPUBLAS_CHECK_ERROR(cublasGetStream(handle, &stream));
+
48 auto f = [workspace = std::move(workspace)](whip::error_t status) { whip::check_error(status); };
+
49 pika::cuda::experimental::detail::add_event_callback(std::move(f), stream);
50}
-
51
-
52#define DLAF_DEFINE_GPUBLAS_OP(Name, Type, f) \
-
53 template <> \
-
54 struct Name<Type> { \
-
55 template <typename... Args> \
-
56 static void call(cublasHandle_t handle, Args&&... args) { \
-
57 auto workspace = DLAF_GET_ROCBLAS_WORKSPACE(f); \
-
58 DLAF_GPUBLAS_CHECK_ERROR(rocblas_set_workspace(static_cast<rocblas_handle>(handle), workspace(), \
-
59 to_sizet(workspace.size()))); \
-
60 DLAF_GPUBLAS_CHECK_ERROR(rocblas_##f(handle, std::forward<Args>(args)...)); \
-
61 DLAF_GPUBLAS_CHECK_ERROR(rocblas_set_workspace(static_cast<rocblas_handle>(handle), nullptr, 0)); \
-
62 ::dlaf::tile::internal::extendROCBlasWorkspace(handle, std::move(workspace)); \
-
63 } \
-
64 }
-
65
-
66#elif defined(DLAF_WITH_CUDA)
-
67
-
68#define DLAF_DEFINE_GPUBLAS_OP(Name, Type, f) \
-
69 template <> \
-
70 struct Name<Type> { \
-
71 template <typename... Args> \
-
72 static void call(Args&&... args) { \
-
73 DLAF_GPUBLAS_CHECK_ERROR(cublas##f##_v2(std::forward<Args>(args)...)); \
-
74 } \
-
75 }
-
76
-
77#endif
-
78
-
79#define DLAF_DECLARE_GPUBLAS_OP(Name) \
-
80 template <typename T> \
-
81 struct Name
-
82
-
83#ifdef DLAF_WITH_HIP
-
84#define DLAF_MAKE_GPUBLAS_OP(Name, f) \
-
85 DLAF_DECLARE_GPUBLAS_OP(Name); \
-
86 DLAF_DEFINE_GPUBLAS_OP(Name, float, s##f); \
-
87 DLAF_DEFINE_GPUBLAS_OP(Name, double, d##f); \
-
88 DLAF_DEFINE_GPUBLAS_OP(Name, std::complex<float>, c##f); \
-
89 DLAF_DEFINE_GPUBLAS_OP(Name, std::complex<double>, z##f)
-
90
-
91#define DLAF_MAKE_GPUBLAS_SYHE_OP(Name, f) \
-
92 DLAF_DECLARE_GPUBLAS_OP(Name); \
-
93 DLAF_DEFINE_GPUBLAS_OP(Name, float, ssy##f); \
-
94 DLAF_DEFINE_GPUBLAS_OP(Name, double, dsy##f); \
-
95 DLAF_DEFINE_GPUBLAS_OP(Name, std::complex<float>, che##f); \
-
96 DLAF_DEFINE_GPUBLAS_OP(Name, std::complex<double>, zhe##f)
-
97
-
98#elif defined(DLAF_WITH_CUDA)
-
99#define DLAF_MAKE_GPUBLAS_OP(Name, f) \
-
100 DLAF_DECLARE_GPUBLAS_OP(Name); \
-
101 DLAF_DEFINE_GPUBLAS_OP(Name, float, S##f); \
-
102 DLAF_DEFINE_GPUBLAS_OP(Name, double, D##f); \
-
103 DLAF_DEFINE_GPUBLAS_OP(Name, std::complex<float>, C##f); \
-
104 DLAF_DEFINE_GPUBLAS_OP(Name, std::complex<double>, Z##f)
-
105
-
106#define DLAF_MAKE_GPUBLAS_SYHE_OP(Name, f) \
-
107 DLAF_DECLARE_GPUBLAS_OP(Name); \
-
108 DLAF_DEFINE_GPUBLAS_OP(Name, float, Ssy##f); \
-
109 DLAF_DEFINE_GPUBLAS_OP(Name, double, Dsy##f); \
-
110 DLAF_DEFINE_GPUBLAS_OP(Name, std::complex<float>, Che##f); \
-
111 DLAF_DEFINE_GPUBLAS_OP(Name, std::complex<double>, Zhe##f)
-
112#endif
-
113
-
114namespace dlaf::gpublas::internal {
-
115
-
116// Level 1
-
117DLAF_MAKE_GPUBLAS_OP(Axpy, axpy);
-
118
-
119// Level 2
-
120DLAF_MAKE_GPUBLAS_OP(Gemv, gemv);
-
121
-
122DLAF_MAKE_GPUBLAS_OP(Trmv, trmv);
-
123
-
124// Level 3
-
125DLAF_MAKE_GPUBLAS_OP(Gemm, gemm);
-
126
-
127DLAF_MAKE_GPUBLAS_SYHE_OP(Hemm, mm);
-
128
-
129DLAF_MAKE_GPUBLAS_SYHE_OP(Her2k, r2k);
-
130
-
131DLAF_MAKE_GPUBLAS_SYHE_OP(Herk, rk);
-
132
-
133#if defined(DLAF_WITH_CUDA)
-
134DLAF_MAKE_GPUBLAS_OP(Trmm, trmm);
-
135#elif defined(DLAF_WITH_HIP)
-
136
-
137#if ROCBLAS_VERSION_MAJOR >= 3 && defined(ROCBLAS_V3)
-
138DLAF_MAKE_GPUBLAS_OP(Trmm, trmm);
-
139#else
-
140DLAF_MAKE_GPUBLAS_OP(Trmm, trmm_outofplace);
-
141#endif
-
142
-
143#endif
-
144
-
145DLAF_MAKE_GPUBLAS_OP(Trsm, trsm);
-
146}
-
147#endif
-
dlaf::memory::MemoryView
Definition memory_view.h:32
+
51}
+
52
+
53#define DLAF_DEFINE_GPUBLAS_OP(Name, Type, f) \
+
54 template <> \
+
55 struct Name<Type> { \
+
56 template <typename... Args> \
+
57 static void call(cublasHandle_t handle, Args&&... args) { \
+
58 auto workspace = DLAF_GET_ROCBLAS_WORKSPACE(f); \
+
59 DLAF_GPUBLAS_CHECK_ERROR(rocblas_set_workspace(static_cast<rocblas_handle>(handle), workspace(), \
+
60 to_sizet(workspace.size()))); \
+
61 DLAF_GPUBLAS_CHECK_ERROR(rocblas_##f(handle, std::forward<Args>(args)...)); \
+
62 DLAF_GPUBLAS_CHECK_ERROR(rocblas_set_workspace(static_cast<rocblas_handle>(handle), nullptr, 0)); \
+
63 ::dlaf::tile::internal::extendROCBlasWorkspace(handle, std::move(workspace)); \
+
64 } \
+
65 }
+
66
+
67#elif defined(DLAF_WITH_CUDA)
+
68
+
69#define DLAF_DEFINE_GPUBLAS_OP(Name, Type, f) \
+
70 template <> \
+
71 struct Name<Type> { \
+
72 template <typename... Args> \
+
73 static void call(Args&&... args) { \
+
74 DLAF_GPUBLAS_CHECK_ERROR(cublas##f##_v2(std::forward<Args>(args)...)); \
+
75 } \
+
76 }
+
77
+
78#endif
+
79
+
80#define DLAF_DECLARE_GPUBLAS_OP(Name) \
+
81 template <typename T> \
+
82 struct Name
+
83
+
84#ifdef DLAF_WITH_HIP
+
85#define DLAF_MAKE_GPUBLAS_OP(Name, f) \
+
86 DLAF_DECLARE_GPUBLAS_OP(Name); \
+
87 DLAF_DEFINE_GPUBLAS_OP(Name, float, s##f); \
+
88 DLAF_DEFINE_GPUBLAS_OP(Name, double, d##f); \
+
89 DLAF_DEFINE_GPUBLAS_OP(Name, std::complex<float>, c##f); \
+
90 DLAF_DEFINE_GPUBLAS_OP(Name, std::complex<double>, z##f)
+
91
+
92#define DLAF_MAKE_GPUBLAS_SYHE_OP(Name, f) \
+
93 DLAF_DECLARE_GPUBLAS_OP(Name); \
+
94 DLAF_DEFINE_GPUBLAS_OP(Name, float, ssy##f); \
+
95 DLAF_DEFINE_GPUBLAS_OP(Name, double, dsy##f); \
+
96 DLAF_DEFINE_GPUBLAS_OP(Name, std::complex<float>, che##f); \
+
97 DLAF_DEFINE_GPUBLAS_OP(Name, std::complex<double>, zhe##f)
+
98
+
99#elif defined(DLAF_WITH_CUDA)
+
100#define DLAF_MAKE_GPUBLAS_OP(Name, f) \
+
101 DLAF_DECLARE_GPUBLAS_OP(Name); \
+
102 DLAF_DEFINE_GPUBLAS_OP(Name, float, S##f); \
+
103 DLAF_DEFINE_GPUBLAS_OP(Name, double, D##f); \
+
104 DLAF_DEFINE_GPUBLAS_OP(Name, std::complex<float>, C##f); \
+
105 DLAF_DEFINE_GPUBLAS_OP(Name, std::complex<double>, Z##f)
+
106
+
107#define DLAF_MAKE_GPUBLAS_SYHE_OP(Name, f) \
+
108 DLAF_DECLARE_GPUBLAS_OP(Name); \
+
109 DLAF_DEFINE_GPUBLAS_OP(Name, float, Ssy##f); \
+
110 DLAF_DEFINE_GPUBLAS_OP(Name, double, Dsy##f); \
+
111 DLAF_DEFINE_GPUBLAS_OP(Name, std::complex<float>, Che##f); \
+
112 DLAF_DEFINE_GPUBLAS_OP(Name, std::complex<double>, Zhe##f)
+
113#endif
+
114
+
115namespace dlaf::gpublas::internal {
+
116
+
117// Level 1
+
118DLAF_MAKE_GPUBLAS_OP(Axpy, axpy);
+
119
+
120// Level 2
+
121DLAF_MAKE_GPUBLAS_OP(Gemv, gemv);
+
122
+
123DLAF_MAKE_GPUBLAS_OP(Trmv, trmv);
+
124
+
125// Level 3
+
126DLAF_MAKE_GPUBLAS_OP(Gemm, gemm);
+
127
+
128DLAF_MAKE_GPUBLAS_SYHE_OP(Hemm, mm);
+
129
+
130DLAF_MAKE_GPUBLAS_SYHE_OP(Her2k, r2k);
+
131
+
132DLAF_MAKE_GPUBLAS_SYHE_OP(Herk, rk);
+
133
+
134#if defined(DLAF_WITH_CUDA)
+
135DLAF_MAKE_GPUBLAS_OP(Trmm, trmm);
+
136#elif defined(DLAF_WITH_HIP)
+
137
+
138#if ROCBLAS_VERSION_MAJOR >= 3 && defined(ROCBLAS_V3)
+
139DLAF_MAKE_GPUBLAS_OP(Trmm, trmm);
+
140#else
+
141DLAF_MAKE_GPUBLAS_OP(Trmm, trmm_outofplace);
+
142#endif
+
143
+
144#endif
+
145
+
146DLAF_MAKE_GPUBLAS_OP(Trsm, trsm);
+
147}
+
148#endif
+
dlaf::memory::MemoryView
Definition memory_view.h:33
memory_view.h
diff --git a/master/hermitian_8h_source.html b/master/hermitian_8h_source.html index 780c1c1bf6..d21b6ec0ec 100644 --- a/master/hermitian_8h_source.html +++ b/master/hermitian_8h_source.html @@ -193,10 +193,10 @@
162
163}
dlaf::comm::CommunicatorGrid
Definition communicator_grid.h:37
-
dlaf::matrix::internal::MatrixRef
Definition matrix_ref.h:171
+
dlaf::matrix::internal::MatrixRef
Definition matrix_ref.h:172
communicator_grid.h
- +
util_matrix.h
diff --git a/master/internal_2p2p_8h_source.html b/master/internal_2p2p_8h_source.html index cf2b4c9f09..3b562de91d 100644 --- a/master/internal_2p2p_8h_source.html +++ b/master/internal_2p2p_8h_source.html @@ -193,7 +193,7 @@
111}
callable_object.h
DLAF_MAKE_CALLABLE_OBJECT
#define DLAF_MAKE_CALLABLE_OBJECT(fname)
Definition callable_object.h:29
-
dlaf::matrix::Matrix
Definition matrix.h:61
+
dlaf::matrix::Matrix
Definition matrix.h:62
diff --git a/master/kernels_2all__reduce_8h.html b/master/kernels_2all__reduce_8h.html index 212276b009..bdc73ee1b6 100644 --- a/master/kernels_2all__reduce_8h.html +++ b/master/kernels_2all__reduce_8h.html @@ -155,7 +155,7 @@

pika::execution::experimental::unique_any_sender<CommunicatorPipelineExclusiveWrapper> pcomm, \
MPI_Op reduce_op, dlaf::matrix::ReadOnlyTileSender<Type, Device> tile_in, \
dlaf::matrix::ReadWriteTileSender<Type, Device> tile_out)
-
dlaf::matrix::Matrix
Definition matrix.h:61
+
dlaf::matrix::Matrix
Definition matrix.h:62
diff --git a/master/kernels_2all__reduce_8h_source.html b/master/kernels_2all__reduce_8h_source.html index ea352562b9..1333a4ca01 100644 --- a/master/kernels_2all__reduce_8h_source.html +++ b/master/kernels_2all__reduce_8h_source.html @@ -136,7 +136,7 @@
65DLAF_EXPAND_ETI_SDCZ_DEVICE(DLAF_SCHEDULE_ALL_REDUCE_IN_PLACE_ETI, extern);
66DLAF_SCHEDULE_ALL_REDUCE_IN_PLACE_ETI(extern, int, Device::CPU);
67}
-
dlaf::matrix::Matrix
Definition matrix.h:61
+
dlaf::matrix::Matrix
Definition matrix.h:62
communicator_pipeline.h
diff --git a/master/kernels_2broadcast_8h.html b/master/kernels_2broadcast_8h.html index f7be4a5a50..6f4baeb81d 100644 --- a/master/kernels_2broadcast_8h.html +++ b/master/kernels_2broadcast_8h.html @@ -169,7 +169,7 @@

kword template dlaf::matrix::ReadWriteTileSender<Type, Device> schedule_bcast_recv( \
pika::execution::experimental::unique_any_sender<Comm> pcomm, comm::IndexT_MPI root_rank, \
dlaf::matrix::ReadWriteTileSender<Type, Device> tile)
-
dlaf::matrix::Matrix
Definition matrix.h:61
+
dlaf::matrix::Matrix
Definition matrix.h:62
diff --git a/master/kernels_2broadcast_8h_source.html b/master/kernels_2broadcast_8h_source.html index 3b37f20d6e..d8d2df9401 100644 --- a/master/kernels_2broadcast_8h_source.html +++ b/master/kernels_2broadcast_8h_source.html @@ -151,7 +151,7 @@
79// clang-format on
80}
callable_object.h
-
dlaf::matrix::Matrix
Definition matrix.h:61
+
dlaf::matrix::Matrix
Definition matrix.h:62
dlaf::comm::IndexT_MPI
int IndexT_MPI
Type used for indexes in MPI API.
Definition index.h:20
communicator_pipeline.h
diff --git a/master/kernels_2internal_2all__reduce_8h_source.html b/master/kernels_2internal_2all__reduce_8h_source.html index 7a4eb20667..4ff56ba33d 100644 --- a/master/kernels_2internal_2all__reduce_8h_source.html +++ b/master/kernels_2internal_2all__reduce_8h_source.html @@ -238,7 +238,7 @@
155}
callable_object.h
DLAF_MAKE_CALLABLE_OBJECT
#define DLAF_MAKE_CALLABLE_OBJECT(fname)
Definition callable_object.h:29
-
dlaf::matrix::Matrix
Definition matrix.h:61
+
dlaf::matrix::Matrix
Definition matrix.h:62
communicator_pipeline.h
diff --git a/master/kernels_2internal_2broadcast_8h_source.html b/master/kernels_2internal_2broadcast_8h_source.html index 905feb94f2..6a27c11963 100644 --- a/master/kernels_2internal_2broadcast_8h_source.html +++ b/master/kernels_2internal_2broadcast_8h_source.html @@ -203,7 +203,7 @@
120}
callable_object.h
DLAF_MAKE_CALLABLE_OBJECT
#define DLAF_MAKE_CALLABLE_OBJECT(fname)
Definition callable_object.h:29
-
dlaf::matrix::Matrix
Definition matrix.h:61
+
dlaf::matrix::Matrix
Definition matrix.h:62
diff --git a/master/kernels_2internal_2reduce_8h_source.html b/master/kernels_2internal_2reduce_8h_source.html index 9833be4a22..050e101e15 100644 --- a/master/kernels_2internal_2reduce_8h_source.html +++ b/master/kernels_2internal_2reduce_8h_source.html @@ -212,7 +212,7 @@
129}
130}
DLAF_MAKE_CALLABLE_OBJECT
#define DLAF_MAKE_CALLABLE_OBJECT(fname)
Definition callable_object.h:29
-
dlaf::matrix::Matrix
Definition matrix.h:61
+
dlaf::matrix::Matrix
Definition matrix.h:62
communicator_pipeline.h
diff --git a/master/kernels_2reduce_8h.html b/master/kernels_2reduce_8h.html index e18e2c34df..829df5f89b 100644 --- a/master/kernels_2reduce_8h.html +++ b/master/kernels_2reduce_8h.html @@ -155,7 +155,7 @@

kword template dlaf::matrix::ReadWriteTileSender<Type, Device> schedule_reduce_recv_in_place( \
pika::execution::experimental::unique_any_sender<CommunicatorPipelineExclusiveWrapper> pcomm, \
MPI_Op reduce_op, dlaf::matrix::ReadWriteTileSender<Type, Device> tile)
-
dlaf::matrix::Matrix
Definition matrix.h:61
+
dlaf::matrix::Matrix
Definition matrix.h:62
diff --git a/master/kernels_2reduce_8h_source.html b/master/kernels_2reduce_8h_source.html index cd3f7ea88e..79d06757b3 100644 --- a/master/kernels_2reduce_8h_source.html +++ b/master/kernels_2reduce_8h_source.html @@ -136,7 +136,7 @@
64DLAF_EXPAND_ETI_SDCZ_DEVICE(DLAF_SCHEDULE_REDUCE_SEND_ETI, extern);
65DLAF_SCHEDULE_REDUCE_SEND_ETI(extern, int, Device::CPU);
66}
-
dlaf::matrix::Matrix
Definition matrix.h:61
+
dlaf::matrix::Matrix
Definition matrix.h:62
dlaf::comm::IndexT_MPI
int IndexT_MPI
Type used for indexes in MPI API.
Definition index.h:20
diff --git a/master/lacpy_8h_source.html b/master/lacpy_8h_source.html index f787f91643..58b5b94acc 100644 --- a/master/lacpy_8h_source.html +++ b/master/lacpy_8h_source.html @@ -95,30 +95,32 @@
12
13#ifdef DLAF_WITH_GPU
14
-
15#include <blas.hh>
-
16#include <whip.hpp>
-
17
-
18#include <dlaf/gpu/blas/api.h>
-
19#include <dlaf/types.h>
-
20
-
21namespace dlaf::gpulapack {
+
15#include <complex>
+
16
+
17#include <blas.hh>
+
18#include <whip.hpp>
+
19
+
20#include <dlaf/gpu/blas/api.h>
+
21#include <dlaf/types.h>
22
-
23template <class T>
-
24void lacpy(const blas::Uplo uplo, const SizeType m, const SizeType n, const T* a, const SizeType lda,
-
25 T* b, const SizeType ldb, const whip::stream_t stream);
-
26
-
27#define DLAF_CUBLAS_LACPY_ETI(kword, Type) \
-
28 kword template void lacpy(const blas::Uplo uplo, const SizeType m, const SizeType n, const Type* a, \
-
29 const SizeType lda, Type* b, const SizeType ldb, \
-
30 const whip::stream_t stream)
-
31
-
32DLAF_CUBLAS_LACPY_ETI(extern, float);
-
33DLAF_CUBLAS_LACPY_ETI(extern, double);
-
34DLAF_CUBLAS_LACPY_ETI(extern, std::complex<float>);
-
35DLAF_CUBLAS_LACPY_ETI(extern, std::complex<double>);
-
36}
-
37
-
38#endif
+
23namespace dlaf::gpulapack {
+
24
+
25template <class T>
+
26void lacpy(const blas::Uplo uplo, const SizeType m, const SizeType n, const T* a, const SizeType lda,
+
27 T* b, const SizeType ldb, const whip::stream_t stream);
+
28
+
29#define DLAF_CUBLAS_LACPY_ETI(kword, Type) \
+
30 kword template void lacpy(const blas::Uplo uplo, const SizeType m, const SizeType n, const Type* a, \
+
31 const SizeType lda, Type* b, const SizeType ldb, \
+
32 const whip::stream_t stream)
+
33
+
34DLAF_CUBLAS_LACPY_ETI(extern, float);
+
35DLAF_CUBLAS_LACPY_ETI(extern, double);
+
36DLAF_CUBLAS_LACPY_ETI(extern, std::complex<float>);
+
37DLAF_CUBLAS_LACPY_ETI(extern, std::complex<double>);
+
38}
+
39
+
40#endif
diff --git a/master/lapack_2tile_8h.html b/master/lapack_2tile_8h.html index 881cebbf07..a822abd3f1 100644 --- a/master/lapack_2tile_8h.html +++ b/master/lapack_2tile_8h.html @@ -78,7 +78,8 @@
tile.h File Reference
-
#include <cstddef>
+
#include <complex>
+#include <cstddef>
#include <utility>
#include <lapack.hh>
#include <dlaf/common/assert.h>
diff --git a/master/lapack_2tile_8h_source.html b/master/lapack_2tile_8h_source.html index a4dc3334eb..e190b9542d 100644 --- a/master/lapack_2tile_8h_source.html +++ b/master/lapack_2tile_8h_source.html @@ -94,504 +94,505 @@
11#pragma once
12
14
-
15#include <cstddef>
-
16#include <utility>
-
17
-
18#include <lapack.hh>
-
19// LAPACKPP includes complex.h which defines the macro I.
-
20// This breaks pika.
-
21#ifdef I
-
22#undef I
-
23#endif
-
24
-
25#include <dlaf/common/assert.h>
-
26#include <dlaf/common/callable_object.h>
-
27#include <dlaf/common/single_threaded_blas.h>
-
28#include <dlaf/lapack/enum_output.h>
-
29#include <dlaf/matrix/index.h>
-
30#include <dlaf/matrix/tile.h>
-
31#include <dlaf/sender/make_sender_algorithm_overloads.h>
-
32#include <dlaf/sender/policy.h>
-
33#include <dlaf/sender/transform.h>
-
34#include <dlaf/types.h>
-
35#include <dlaf/util_lapack.h>
-
36#include <dlaf/util_tile.h>
-
37
-
38#ifdef DLAF_WITH_GPU
-
39#include <whip.hpp>
-
40
-
41#include <pika/cuda.hpp>
-
42
-
43#include <dlaf/gpu/lapack/api.h>
-
44#include <dlaf/gpu/lapack/assert_info.h>
-
45#include <dlaf/gpu/lapack/error.h>
-
46#include <dlaf/lapack/gpu/laset.h>
-
47#include <dlaf/util_cublas.h>
-
48#endif
-
49// hegst functions get exposed in rocSOLVER
-
50#ifdef DLAF_WITH_CUDA
-
51#include <dlaf/gpu/cusolver/hegst.h>
-
52#elif defined(DLAF_WITH_HIP)
-
53#include <dlaf/gpu/blas/error.h>
-
54#include <dlaf/util_rocblas.h>
-
55#endif
-
56
-
57namespace dlaf::tile {
-
58using matrix::Tile;
-
59
-
60// See LAPACK documentation for more details.
-
61
-
67template <class T>
-
-
68void lacpy(const Tile<const T, Device::CPU>& a, const Tile<T, Device::CPU>& b) {
-
69 DLAF_ASSERT_MODERATE(a.size() == b.size(), a, b);
-
70
-
71 const SizeType m = a.size().rows();
-
72 const SizeType n = a.size().cols();
-
73
-
74 common::internal::SingleThreadedBlasScope single;
-
75 lapack::lacpy(blas::Uplo::General, m, n, a.ptr(), a.ld(), b.ptr(), b.ld());
-
76}
+
15#include <complex>
+
16#include <cstddef>
+
17#include <utility>
+
18
+
19#include <lapack.hh>
+
20// LAPACKPP includes complex.h which defines the macro I.
+
21// This breaks pika.
+
22#ifdef I
+
23#undef I
+
24#endif
+
25
+
26#include <dlaf/common/assert.h>
+
27#include <dlaf/common/callable_object.h>
+
28#include <dlaf/common/single_threaded_blas.h>
+
29#include <dlaf/lapack/enum_output.h>
+
30#include <dlaf/matrix/index.h>
+
31#include <dlaf/matrix/tile.h>
+
32#include <dlaf/sender/make_sender_algorithm_overloads.h>
+
33#include <dlaf/sender/policy.h>
+
34#include <dlaf/sender/transform.h>
+
35#include <dlaf/types.h>
+
36#include <dlaf/util_lapack.h>
+
37#include <dlaf/util_tile.h>
+
38
+
39#ifdef DLAF_WITH_GPU
+
40#include <whip.hpp>
+
41
+
42#include <pika/cuda.hpp>
+
43
+
44#include <dlaf/gpu/lapack/api.h>
+
45#include <dlaf/gpu/lapack/assert_info.h>
+
46#include <dlaf/gpu/lapack/error.h>
+
47#include <dlaf/lapack/gpu/laset.h>
+
48#include <dlaf/util_cublas.h>
+
49#endif
+
50// hegst functions get exposed in rocSOLVER
+
51#ifdef DLAF_WITH_CUDA
+
52#include <dlaf/gpu/cusolver/hegst.h>
+
53#elif defined(DLAF_WITH_HIP)
+
54#include <dlaf/gpu/blas/error.h>
+
55#include <dlaf/util_rocblas.h>
+
56#endif
+
57
+
58namespace dlaf::tile {
+
59using matrix::Tile;
+
60
+
61// See LAPACK documentation for more details.
+
62
+
68template <class T>
+
+
69void lacpy(const Tile<const T, Device::CPU>& a, const Tile<T, Device::CPU>& b) {
+
70 DLAF_ASSERT_MODERATE(a.size() == b.size(), a, b);
+
71
+
72 const SizeType m = a.size().rows();
+
73 const SizeType n = a.size().cols();
+
74
+
75 common::internal::SingleThreadedBlasScope single;
+
76 lapack::lacpy(blas::Uplo::General, m, n, a.ptr(), a.ld(), b.ptr(), b.ld());
+
77}
-
77
-
83template <class T>
-
-
84void lacpy(TileElementSize region, TileElementIndex in_idx, const Tile<const T, Device::CPU>& in,
-
85 TileElementIndex out_idx, const Tile<T, Device::CPU>& out) {
-
86 DLAF_ASSERT_MODERATE(in_idx.isIn(in.size() - region + TileElementSize(1, 1)),
-
87 "Region goes out of bounds for `in`!", region, in_idx, in);
-
88 DLAF_ASSERT_MODERATE(out_idx.isIn(out.size() - region + TileElementSize(1, 1)),
-
89 "Region goes out of bounds for `out`!", region, out_idx, out);
-
90
-
91 common::internal::SingleThreadedBlasScope single;
-
92 lapack::lacpy(blas::Uplo::General, region.rows(), region.cols(), in.ptr(in_idx), in.ld(),
-
93 out.ptr(out_idx), out.ld());
-
94}
+
78
+
84template <class T>
+
+
85void lacpy(TileElementSize region, TileElementIndex in_idx, const Tile<const T, Device::CPU>& in,
+
86 TileElementIndex out_idx, const Tile<T, Device::CPU>& out) {
+
87 DLAF_ASSERT_MODERATE(in_idx.isIn(in.size() - region + TileElementSize(1, 1)),
+
88 "Region goes out of bounds for `in`!", region, in_idx, in);
+
89 DLAF_ASSERT_MODERATE(out_idx.isIn(out.size() - region + TileElementSize(1, 1)),
+
90 "Region goes out of bounds for `out`!", region, out_idx, out);
+
91
+
92 common::internal::SingleThreadedBlasScope single;
+
93 lapack::lacpy(blas::Uplo::General, region.rows(), region.cols(), in.ptr(in_idx), in.ld(),
+
94 out.ptr(out_idx), out.ld());
+
95}
-
95
-
96#ifdef DLAF_DOXYGEN
-
97
-
104template <Backend B, class T, Device D>
-
105dlaf::BaseType<T> lange(const dlaf::internal::Policy<B>& p, const lapack::Norm norm,
-
106 const Tile<T, D>& a);
-
107
-
112template <Backend B, typename Sender,
-
113 typename = std::enable_if_t<pika::execution::experimental::is_sender_v<Sender>>>
-
114dlaf::BaseType<T> lange(const dlaf::internal::Policy<B>& p, Sender&& s);
-
115
-
120template <Backend B>
-
121dlaf::BaseType<T> lange(const dlaf::internal::Policy<B>& p);
-
122
-
132template <Backend B, class T, Device D>
-
133dlaf::BaseType<T> lantr(const dlaf::internal::Policy<B>& p, const lapack::Norm norm,
-
134 const blas::Uplo uplo, const blas::Diag diag, const Tile<T, D>& a);
-
135
-
140template <Backend B, typename Sender,
-
141 typename = std::enable_if_t<pika::execution::experimental::is_sender_v<Sender>>>
-
142dlaf::BaseType<T> lantr(const dlaf::internal::Policy<B>& p, Sender&& s);
-
143
-
148template <Backend B>
-
149dlaf::BaseType<T> lantr(const dlaf::internal::Policy<B>& p);
-
150
-
154template <Backend B, class T, Device D>
-
155void laset(const dlaf::internal::Policy<B>& p, const blas::Uplo uplo, T alpha, T beta,
-
156 const Tile<T, D>& tile);
-
157
-
162template <Backend B, typename Sender,
-
163 typename = std::enable_if_t<pika::execution::experimental::is_sender_v<Sender>>>
-
164void laset(const dlaf::internal::Policy<B>& p, Sender&& s);
-
165
-
170template <Backend B>
-
171void laset(const dlaf::internal::Policy<B>& p);
-
172
-
176template <Backend B, class T, Device D>
-
177void set0(const dlaf::internal::Policy<B>& p, const Tile<T, D>& tile);
-
178
-
183template <Backend B, typename Sender,
-
184 typename = std::enable_if_t<pika::execution::experimental::is_sender_v<Sender>>>
-
185void set0(const dlaf::internal::Policy<B>& p, Sender&& s);
-
186
-
191template <Backend B>
-
192void set0(const dlaf::internal::Policy<B>& p);
-
193
-
208template <Backend B, class T, Device D>
-
209void hegst(const dlaf::internal::Policy<B>&, const int itype, const blas::Uplo uplo, const Tile<T, D>& a,
-
210 const Tile<T, D>& b);
-
211
-
216template <Backend B, typename Sender,
-
217 typename = std::enable_if_t<pika::execution::experimental::is_sender_v<Sender>>>
-
218auto hegst(const dlaf::internal::Policy<B>& p, Sender&& s);
-
219
-
224template <Backend B>
-
225auto hegst(const dlaf::internal::Policy<B>& p);
-
226
-
233template <Backend B, class T, Device D>
-
234auto potrfInfo(const dlaf::internal::Policy<B>&, const blas::Uplo uplo, const Tile<T, D>& a);
-
235
-
240template <Backend B, typename Sender,
-
241 typename = std::enable_if_t<pika::execution::experimental::is_sender_v<Sender>>>
-
242auto potrfInfo(const dlaf::internal::Policy<B>& p, Sender&& s);
-
243
-
248template <Backend B>
-
249auto potrfInfo(const dlaf::internal::Policy<B>& p);
-
250
-
258template <Backend B, class T, Device D>
-
259void potrf(const dlaf::internal::Policy<B>& p, const blas::Uplo uplo, const Tile<T, D>& a);
-
260
-
265template <Backend B, typename Sender,
-
266 typename = std::enable_if_t<pika::execution::experimental::is_sender_v<Sender>>>
-
267auto potrf(const dlaf::internal::Policy<B>& p, Sender&& s);
-
268
-
273template <Backend B>
-
274auto potrf(const dlaf::internal::Policy<B>& p);
-
275
-
287template <Backend B, class T, Device D>
-
288void stedc(const dlaf::internal::Policy<B>& p, const Tile<T, D>& tridiag, const Tile<T, D>& evecs);
-
289
-
294template <Backend B, typename Sender,
-
295 typename = std::enable_if_t<hpx::execution::experimental::is_sender_v<Sender>>>
-
296auto stedc(const dlaf::internal::Policy<B>& p, Sender&& s);
-
297
-
302template <Backend B>
-
303auto stedc(const dlaf::internal::Policy<B>& p);
-
304
-
305#else
-
306
-
307namespace internal {
-
308
-
309template <class T>
-
310dlaf::BaseType<T> lange(const lapack::Norm norm, const Tile<T, Device::CPU>& a) noexcept {
-
311 common::internal::SingleThreadedBlasScope single;
-
312 return lapack::lange(norm, a.size().rows(), a.size().cols(), a.ptr(), a.ld());
-
313}
-
314
-
315template <class T>
-
316dlaf::BaseType<T> lantr(const lapack::Norm norm, const blas::Uplo uplo, const blas::Diag diag,
-
317 const Tile<T, Device::CPU>& a) noexcept {
-
318 switch (uplo) {
-
319 case blas::Uplo::Lower:
-
320 DLAF_ASSERT(a.size().rows() >= a.size().cols(), a);
-
321 break;
-
322 case blas::Uplo::Upper:
-
323 DLAF_ASSERT(a.size().rows() <= a.size().cols(), a);
-
324 break;
-
325 case blas::Uplo::General:
-
326 DLAF_ASSERT(blas::Uplo::General == uplo, uplo);
-
327 break;
-
328 }
-
329 common::internal::SingleThreadedBlasScope single;
-
330 return lapack::lantr(norm, uplo, diag, a.size().rows(), a.size().cols(), a.ptr(), a.ld());
-
331}
-
332
-
333template <class T>
-
334void laset(const blas::Uplo uplo, T alpha, T beta, const Tile<T, Device::CPU>& tile) {
-
335 const SizeType m = tile.size().rows();
-
336 const SizeType n = tile.size().cols();
-
337
-
338 common::internal::SingleThreadedBlasScope single;
-
339 lapack::laset(uplo, m, n, alpha, beta, tile.ptr(), tile.ld());
-
340}
-
341
-
342template <class T>
-
343void set0(const Tile<T, Device::CPU>& tile) {
-
344 tile::internal::laset(blas::Uplo::General, static_cast<T>(0.0), static_cast<T>(0.0), tile);
-
345}
-
346
-
347template <class T>
-
348void hegst(const int itype, const blas::Uplo uplo, const Tile<T, Device::CPU>& a,
-
349 const Tile<T, Device::CPU>& b) {
-
350 DLAF_ASSERT(square_size(a), a);
-
351 DLAF_ASSERT(square_size(b), b);
-
352 DLAF_ASSERT(a.size() == b.size(), a, b);
-
353 DLAF_ASSERT(itype >= 1 && itype <= 3, itype);
-
354
-
355 common::internal::SingleThreadedBlasScope single;
-
356 [[maybe_unused]] auto info =
-
357 lapack::hegst(itype, uplo, a.size().cols(), a.ptr(), a.ld(), b.ptr(), b.ld());
-
358
-
359 DLAF_ASSERT(info == 0, info);
-
360}
-
361
-
362template <class T>
-
363long long potrfInfo(const blas::Uplo uplo, const Tile<T, Device::CPU>& a) {
-
364 DLAF_ASSERT(square_size(a), a);
-
365
-
366 common::internal::SingleThreadedBlasScope single;
-
367 auto info = lapack::potrf(uplo, a.size().rows(), a.ptr(), a.ld());
-
368 DLAF_ASSERT_HEAVY(info >= 0, info);
-
369
-
370 return info;
-
371}
-
372
-
373template <class T>
-
374void potrf(const blas::Uplo uplo, const Tile<T, Device::CPU>& a) noexcept {
-
375 [[maybe_unused]] auto info = potrfInfo(uplo, a);
-
376
-
377 DLAF_ASSERT(info == 0, info);
-
378}
-
379
-
380template <class T>
-
381void stedc(const Tile<T, Device::CPU>& tridiag, const Tile<T, Device::CPU>& evecs) {
-
382 DLAF_ASSERT(square_size(evecs), evecs);
-
383 DLAF_ASSERT(tridiag.size().rows() == evecs.size().rows(), tridiag, evecs);
-
384 DLAF_ASSERT(tridiag.size().cols() == 2, tridiag);
-
385
-
386 // In lapackpp see `util.hh` and `job_comp2char()` and `enum class Job`
-
387 // Note that `lapack::Job::Vec` corresponds to `compz=I` in the LAPACK
-
388
-
389 // compz, n, D, E, Z, ldz
-
390 common::internal::SingleThreadedBlasScope single;
-
391 lapack::stedc(lapack::Job::Vec, evecs.size().rows(), tridiag.ptr(),
-
392 tridiag.ptr(TileElementIndex(0, 1)), evecs.ptr(), evecs.ld());
-
393}
-
394
-
395template <class T>
-
396void scaleCol(T alpha, SizeType col, const Tile<T, Device::CPU>& tile) {
-
397 DLAF_ASSERT(col >= 0, col);
-
398 DLAF_ASSERT(tile.size().cols() > col, tile, col);
-
399 common::internal::SingleThreadedBlasScope single;
-
400 blas::scal(tile.size().rows(), alpha, tile.ptr(TileElementIndex(0, col)), 1);
-
401}
-
402
-
403#ifdef DLAF_WITH_GPU
-
404namespace internal {
-
405#define DLAF_DECLARE_GPULAPACK_OP(Name) \
-
406 template <typename T> \
-
407 struct Cusolver##Name
-
408
-
409DLAF_DECLARE_GPULAPACK_OP(Hegst);
-
410DLAF_DECLARE_GPULAPACK_OP(Potrf);
-
411
-
412#ifdef DLAF_WITH_CUDA
-
413
-
414#define DLAF_DEFINE_CUSOLVER_OP_BUFFER(Name, Type, f) \
-
415 template <> \
-
416 struct Cusolver##Name<Type> { \
-
417 template <typename... Args> \
-
418 static void call(Args&&... args) { \
-
419 DLAF_GPULAPACK_CHECK_ERROR(cusolverDn##f(std::forward<Args>(args)...)); \
-
420 } \
-
421 template <typename... Args> \
-
422 static void callBufferSize(Args&&... args) { \
-
423 DLAF_GPULAPACK_CHECK_ERROR(cusolverDn##f##_bufferSize(std::forward<Args>(args)...)); \
-
424 } \
-
425 }
-
426
-
427DLAF_DEFINE_CUSOLVER_OP_BUFFER(Hegst, float, Ssygst);
-
428DLAF_DEFINE_CUSOLVER_OP_BUFFER(Hegst, double, Dsygst);
-
429DLAF_DEFINE_CUSOLVER_OP_BUFFER(Hegst, std::complex<float>, Chegst);
-
430DLAF_DEFINE_CUSOLVER_OP_BUFFER(Hegst, std::complex<double>, Zhegst);
-
431
-
432DLAF_DEFINE_CUSOLVER_OP_BUFFER(Potrf, float, Spotrf);
-
433DLAF_DEFINE_CUSOLVER_OP_BUFFER(Potrf, double, Dpotrf);
-
434DLAF_DEFINE_CUSOLVER_OP_BUFFER(Potrf, std::complex<float>, Cpotrf);
-
435DLAF_DEFINE_CUSOLVER_OP_BUFFER(Potrf, std::complex<double>, Zpotrf);
-
436
-
437#elif defined(DLAF_WITH_HIP)
-
438
-
439#define DLAF_GET_ROCSOLVER_WORKSPACE(f) \
-
440 [&]() { \
-
441 std::size_t workspace_size; \
-
442 DLAF_GPULAPACK_CHECK_ERROR( \
-
443 rocblas_start_device_memory_size_query(static_cast<rocblas_handle>(handle))); \
-
444 DLAF_GPULAPACK_CHECK_ERROR(rocsolver_##f(handle, std::forward<Args>(args)...)); \
-
445 DLAF_GPULAPACK_CHECK_ERROR( \
-
446 rocblas_stop_device_memory_size_query(static_cast<rocblas_handle>(handle), &workspace_size)); \
-
447 return ::dlaf::memory::MemoryView<std::byte, Device::GPU>(to_int(workspace_size)); \
-
448 }();
-
449
-
450inline void extendROCSolverWorkspace(cusolverDnHandle_t handle,
-
451 ::dlaf::memory::MemoryView<std::byte, Device::GPU>&& workspace) {
-
452 whip::stream_t stream;
-
453 DLAF_GPUBLAS_CHECK_ERROR(cublasGetStream(handle, &stream));
-
454 auto f = [workspace = std::move(workspace)](whip::error_t status) { whip::check_error(status); };
-
455 pika::cuda::experimental::detail::add_event_callback(std::move(f), stream);
-
456}
-
457
-
458#define DLAF_DEFINE_CUSOLVER_OP_BUFFER(Name, Type, f) \
-
459 template <> \
-
460 struct Cusolver##Name<Type> { \
-
461 template <typename... Args> \
-
462 static void call(cusolverDnHandle_t handle, Args&&... args) { \
-
463 auto workspace = DLAF_GET_ROCSOLVER_WORKSPACE(f); \
-
464 DLAF_GPULAPACK_CHECK_ERROR(rocblas_set_workspace(handle, workspace(), \
-
465 to_sizet(workspace.size()))); \
-
466 DLAF_GPULAPACK_CHECK_ERROR(rocsolver_##f(handle, std::forward<Args>(args)...)); \
-
467 DLAF_GPULAPACK_CHECK_ERROR(rocblas_set_workspace(handle, nullptr, 0)); \
-
468 extendROCSolverWorkspace(handle, std::move(workspace)); \
-
469 } \
-
470 }
-
471
-
472DLAF_DEFINE_CUSOLVER_OP_BUFFER(Hegst, float, ssygst);
-
473DLAF_DEFINE_CUSOLVER_OP_BUFFER(Hegst, double, dsygst);
-
474DLAF_DEFINE_CUSOLVER_OP_BUFFER(Hegst, std::complex<float>, chegst);
-
475DLAF_DEFINE_CUSOLVER_OP_BUFFER(Hegst, std::complex<double>, zhegst);
-
476
-
477DLAF_DEFINE_CUSOLVER_OP_BUFFER(Potrf, float, spotrf);
-
478DLAF_DEFINE_CUSOLVER_OP_BUFFER(Potrf, double, dpotrf);
-
479DLAF_DEFINE_CUSOLVER_OP_BUFFER(Potrf, std::complex<float>, cpotrf);
-
480DLAF_DEFINE_CUSOLVER_OP_BUFFER(Potrf, std::complex<double>, zpotrf);
-
481
-
482#endif
-
483}
-
484
-
485namespace internal {
-
486template <class T>
-
487class CusolverInfo {
-
488#ifdef DLAF_WITH_CUDA
-
489 memory::MemoryView<T, Device::GPU> workspace_;
-
490#endif
-
491 memory::MemoryView<int, Device::GPU> info_;
-
492
-
493public:
-
494#ifdef DLAF_WITH_CUDA
-
495 CusolverInfo(int workspace_size) : workspace_(workspace_size), info_(1) {}
-
496#endif
-
497 CusolverInfo() : info_(1) {}
-
498
-
499#ifdef DLAF_WITH_CUDA
-
500 T* workspace() {
-
501 return workspace_();
-
502 }
-
503#endif
-
504 int* info() {
-
505 return info_();
-
506 }
-
507};
-
508
-
509template <class F, class T>
-
510void assertExtendInfo(F assertFunc, cusolverDnHandle_t handle, CusolverInfo<T>&& info) {
-
511 whip::stream_t stream;
-
512 DLAF_GPULAPACK_CHECK_ERROR(cusolverDnGetStream(handle, &stream));
-
513 assertFunc(stream, info.info());
-
514 // Extend info scope to the end of the kernel execution
-
515 auto extend_info = [info = std::move(info)](whip::error_t status) { whip::check_error(status); };
-
516 pika::cuda::experimental::detail::add_event_callback(std::move(extend_info), stream);
-
517}
+
96
+
97#ifdef DLAF_DOXYGEN
+
98
+
105template <Backend B, class T, Device D>
+
106dlaf::BaseType<T> lange(const dlaf::internal::Policy<B>& p, const lapack::Norm norm,
+
107 const Tile<T, D>& a);
+
108
+
113template <Backend B, typename Sender,
+
114 typename = std::enable_if_t<pika::execution::experimental::is_sender_v<Sender>>>
+
115dlaf::BaseType<T> lange(const dlaf::internal::Policy<B>& p, Sender&& s);
+
116
+
121template <Backend B>
+
122dlaf::BaseType<T> lange(const dlaf::internal::Policy<B>& p);
+
123
+
133template <Backend B, class T, Device D>
+
134dlaf::BaseType<T> lantr(const dlaf::internal::Policy<B>& p, const lapack::Norm norm,
+
135 const blas::Uplo uplo, const blas::Diag diag, const Tile<T, D>& a);
+
136
+
141template <Backend B, typename Sender,
+
142 typename = std::enable_if_t<pika::execution::experimental::is_sender_v<Sender>>>
+
143dlaf::BaseType<T> lantr(const dlaf::internal::Policy<B>& p, Sender&& s);
+
144
+
149template <Backend B>
+
150dlaf::BaseType<T> lantr(const dlaf::internal::Policy<B>& p);
+
151
+
155template <Backend B, class T, Device D>
+
156void laset(const dlaf::internal::Policy<B>& p, const blas::Uplo uplo, T alpha, T beta,
+
157 const Tile<T, D>& tile);
+
158
+
163template <Backend B, typename Sender,
+
164 typename = std::enable_if_t<pika::execution::experimental::is_sender_v<Sender>>>
+
165void laset(const dlaf::internal::Policy<B>& p, Sender&& s);
+
166
+
171template <Backend B>
+
172void laset(const dlaf::internal::Policy<B>& p);
+
173
+
177template <Backend B, class T, Device D>
+
178void set0(const dlaf::internal::Policy<B>& p, const Tile<T, D>& tile);
+
179
+
184template <Backend B, typename Sender,
+
185 typename = std::enable_if_t<pika::execution::experimental::is_sender_v<Sender>>>
+
186void set0(const dlaf::internal::Policy<B>& p, Sender&& s);
+
187
+
192template <Backend B>
+
193void set0(const dlaf::internal::Policy<B>& p);
+
194
+
209template <Backend B, class T, Device D>
+
210void hegst(const dlaf::internal::Policy<B>&, const int itype, const blas::Uplo uplo, const Tile<T, D>& a,
+
211 const Tile<T, D>& b);
+
212
+
217template <Backend B, typename Sender,
+
218 typename = std::enable_if_t<pika::execution::experimental::is_sender_v<Sender>>>
+
219auto hegst(const dlaf::internal::Policy<B>& p, Sender&& s);
+
220
+
225template <Backend B>
+
226auto hegst(const dlaf::internal::Policy<B>& p);
+
227
+
234template <Backend B, class T, Device D>
+
235auto potrfInfo(const dlaf::internal::Policy<B>&, const blas::Uplo uplo, const Tile<T, D>& a);
+
236
+
241template <Backend B, typename Sender,
+
242 typename = std::enable_if_t<pika::execution::experimental::is_sender_v<Sender>>>
+
243auto potrfInfo(const dlaf::internal::Policy<B>& p, Sender&& s);
+
244
+
249template <Backend B>
+
250auto potrfInfo(const dlaf::internal::Policy<B>& p);
+
251
+
259template <Backend B, class T, Device D>
+
260void potrf(const dlaf::internal::Policy<B>& p, const blas::Uplo uplo, const Tile<T, D>& a);
+
261
+
266template <Backend B, typename Sender,
+
267 typename = std::enable_if_t<pika::execution::experimental::is_sender_v<Sender>>>
+
268auto potrf(const dlaf::internal::Policy<B>& p, Sender&& s);
+
269
+
274template <Backend B>
+
275auto potrf(const dlaf::internal::Policy<B>& p);
+
276
+
288template <Backend B, class T, Device D>
+
289void stedc(const dlaf::internal::Policy<B>& p, const Tile<T, D>& tridiag, const Tile<T, D>& evecs);
+
290
+
295template <Backend B, typename Sender,
+
296 typename = std::enable_if_t<hpx::execution::experimental::is_sender_v<Sender>>>
+
297auto stedc(const dlaf::internal::Policy<B>& p, Sender&& s);
+
298
+
303template <Backend B>
+
304auto stedc(const dlaf::internal::Policy<B>& p);
+
305
+
306#else
+
307
+
308namespace internal {
+
309
+
310template <class T>
+
311dlaf::BaseType<T> lange(const lapack::Norm norm, const Tile<T, Device::CPU>& a) noexcept {
+
312 common::internal::SingleThreadedBlasScope single;
+
313 return lapack::lange(norm, a.size().rows(), a.size().cols(), a.ptr(), a.ld());
+
314}
+
315
+
316template <class T>
+
317dlaf::BaseType<T> lantr(const lapack::Norm norm, const blas::Uplo uplo, const blas::Diag diag,
+
318 const Tile<T, Device::CPU>& a) noexcept {
+
319 switch (uplo) {
+
320 case blas::Uplo::Lower:
+
321 DLAF_ASSERT(a.size().rows() >= a.size().cols(), a);
+
322 break;
+
323 case blas::Uplo::Upper:
+
324 DLAF_ASSERT(a.size().rows() <= a.size().cols(), a);
+
325 break;
+
326 case blas::Uplo::General:
+
327 DLAF_ASSERT(blas::Uplo::General == uplo, uplo);
+
328 break;
+
329 }
+
330 common::internal::SingleThreadedBlasScope single;
+
331 return lapack::lantr(norm, uplo, diag, a.size().rows(), a.size().cols(), a.ptr(), a.ld());
+
332}
+
333
+
334template <class T>
+
335void laset(const blas::Uplo uplo, T alpha, T beta, const Tile<T, Device::CPU>& tile) {
+
336 const SizeType m = tile.size().rows();
+
337 const SizeType n = tile.size().cols();
+
338
+
339 common::internal::SingleThreadedBlasScope single;
+
340 lapack::laset(uplo, m, n, alpha, beta, tile.ptr(), tile.ld());
+
341}
+
342
+
343template <class T>
+
344void set0(const Tile<T, Device::CPU>& tile) {
+
345 tile::internal::laset(blas::Uplo::General, static_cast<T>(0.0), static_cast<T>(0.0), tile);
+
346}
+
347
+
348template <class T>
+
349void hegst(const int itype, const blas::Uplo uplo, const Tile<T, Device::CPU>& a,
+
350 const Tile<T, Device::CPU>& b) {
+
351 DLAF_ASSERT(square_size(a), a);
+
352 DLAF_ASSERT(square_size(b), b);
+
353 DLAF_ASSERT(a.size() == b.size(), a, b);
+
354 DLAF_ASSERT(itype >= 1 && itype <= 3, itype);
+
355
+
356 common::internal::SingleThreadedBlasScope single;
+
357 [[maybe_unused]] auto info =
+
358 lapack::hegst(itype, uplo, a.size().cols(), a.ptr(), a.ld(), b.ptr(), b.ld());
+
359
+
360 DLAF_ASSERT(info == 0, info);
+
361}
+
362
+
363template <class T>
+
364long long potrfInfo(const blas::Uplo uplo, const Tile<T, Device::CPU>& a) {
+
365 DLAF_ASSERT(square_size(a), a);
+
366
+
367 common::internal::SingleThreadedBlasScope single;
+
368 auto info = lapack::potrf(uplo, a.size().rows(), a.ptr(), a.ld());
+
369 DLAF_ASSERT_HEAVY(info >= 0, info);
+
370
+
371 return info;
+
372}
+
373
+
374template <class T>
+
375void potrf(const blas::Uplo uplo, const Tile<T, Device::CPU>& a) noexcept {
+
376 [[maybe_unused]] auto info = potrfInfo(uplo, a);
+
377
+
378 DLAF_ASSERT(info == 0, info);
+
379}
+
380
+
381template <class T>
+
382void stedc(const Tile<T, Device::CPU>& tridiag, const Tile<T, Device::CPU>& evecs) {
+
383 DLAF_ASSERT(square_size(evecs), evecs);
+
384 DLAF_ASSERT(tridiag.size().rows() == evecs.size().rows(), tridiag, evecs);
+
385 DLAF_ASSERT(tridiag.size().cols() == 2, tridiag);
+
386
+
387 // In lapackpp see `util.hh` and `job_comp2char()` and `enum class Job`
+
388 // Note that `lapack::Job::Vec` corresponds to `compz=I` in the LAPACK
+
389
+
390 // compz, n, D, E, Z, ldz
+
391 common::internal::SingleThreadedBlasScope single;
+
392 lapack::stedc(lapack::Job::Vec, evecs.size().rows(), tridiag.ptr(),
+
393 tridiag.ptr(TileElementIndex(0, 1)), evecs.ptr(), evecs.ld());
+
394}
+
395
+
396template <class T>
+
397void scaleCol(T alpha, SizeType col, const Tile<T, Device::CPU>& tile) {
+
398 DLAF_ASSERT(col >= 0, col);
+
399 DLAF_ASSERT(tile.size().cols() > col, tile, col);
+
400 common::internal::SingleThreadedBlasScope single;
+
401 blas::scal(tile.size().rows(), alpha, tile.ptr(TileElementIndex(0, col)), 1);
+
402}
+
403
+
404#ifdef DLAF_WITH_GPU
+
405namespace internal {
+
406#define DLAF_DECLARE_GPULAPACK_OP(Name) \
+
407 template <typename T> \
+
408 struct Cusolver##Name
+
409
+
410DLAF_DECLARE_GPULAPACK_OP(Hegst);
+
411DLAF_DECLARE_GPULAPACK_OP(Potrf);
+
412
+
413#ifdef DLAF_WITH_CUDA
+
414
+
415#define DLAF_DEFINE_CUSOLVER_OP_BUFFER(Name, Type, f) \
+
416 template <> \
+
417 struct Cusolver##Name<Type> { \
+
418 template <typename... Args> \
+
419 static void call(Args&&... args) { \
+
420 DLAF_GPULAPACK_CHECK_ERROR(cusolverDn##f(std::forward<Args>(args)...)); \
+
421 } \
+
422 template <typename... Args> \
+
423 static void callBufferSize(Args&&... args) { \
+
424 DLAF_GPULAPACK_CHECK_ERROR(cusolverDn##f##_bufferSize(std::forward<Args>(args)...)); \
+
425 } \
+
426 }
+
427
+
428DLAF_DEFINE_CUSOLVER_OP_BUFFER(Hegst, float, Ssygst);
+
429DLAF_DEFINE_CUSOLVER_OP_BUFFER(Hegst, double, Dsygst);
+
430DLAF_DEFINE_CUSOLVER_OP_BUFFER(Hegst, std::complex<float>, Chegst);
+
431DLAF_DEFINE_CUSOLVER_OP_BUFFER(Hegst, std::complex<double>, Zhegst);
+
432
+
433DLAF_DEFINE_CUSOLVER_OP_BUFFER(Potrf, float, Spotrf);
+
434DLAF_DEFINE_CUSOLVER_OP_BUFFER(Potrf, double, Dpotrf);
+
435DLAF_DEFINE_CUSOLVER_OP_BUFFER(Potrf, std::complex<float>, Cpotrf);
+
436DLAF_DEFINE_CUSOLVER_OP_BUFFER(Potrf, std::complex<double>, Zpotrf);
+
437
+
438#elif defined(DLAF_WITH_HIP)
+
439
+
440#define DLAF_GET_ROCSOLVER_WORKSPACE(f) \
+
441 [&]() { \
+
442 std::size_t workspace_size; \
+
443 DLAF_GPULAPACK_CHECK_ERROR( \
+
444 rocblas_start_device_memory_size_query(static_cast<rocblas_handle>(handle))); \
+
445 DLAF_GPULAPACK_CHECK_ERROR(rocsolver_##f(handle, std::forward<Args>(args)...)); \
+
446 DLAF_GPULAPACK_CHECK_ERROR( \
+
447 rocblas_stop_device_memory_size_query(static_cast<rocblas_handle>(handle), &workspace_size)); \
+
448 return ::dlaf::memory::MemoryView<std::byte, Device::GPU>(to_int(workspace_size)); \
+
449 }();
+
450
+
451inline void extendROCSolverWorkspace(cusolverDnHandle_t handle,
+
452 ::dlaf::memory::MemoryView<std::byte, Device::GPU>&& workspace) {
+
453 whip::stream_t stream;
+
454 DLAF_GPUBLAS_CHECK_ERROR(cublasGetStream(handle, &stream));
+
455 auto f = [workspace = std::move(workspace)](whip::error_t status) { whip::check_error(status); };
+
456 pika::cuda::experimental::detail::add_event_callback(std::move(f), stream);
+
457}
+
458
+
459#define DLAF_DEFINE_CUSOLVER_OP_BUFFER(Name, Type, f) \
+
460 template <> \
+
461 struct Cusolver##Name<Type> { \
+
462 template <typename... Args> \
+
463 static void call(cusolverDnHandle_t handle, Args&&... args) { \
+
464 auto workspace = DLAF_GET_ROCSOLVER_WORKSPACE(f); \
+
465 DLAF_GPULAPACK_CHECK_ERROR(rocblas_set_workspace(handle, workspace(), \
+
466 to_sizet(workspace.size()))); \
+
467 DLAF_GPULAPACK_CHECK_ERROR(rocsolver_##f(handle, std::forward<Args>(args)...)); \
+
468 DLAF_GPULAPACK_CHECK_ERROR(rocblas_set_workspace(handle, nullptr, 0)); \
+
469 extendROCSolverWorkspace(handle, std::move(workspace)); \
+
470 } \
+
471 }
+
472
+
473DLAF_DEFINE_CUSOLVER_OP_BUFFER(Hegst, float, ssygst);
+
474DLAF_DEFINE_CUSOLVER_OP_BUFFER(Hegst, double, dsygst);
+
475DLAF_DEFINE_CUSOLVER_OP_BUFFER(Hegst, std::complex<float>, chegst);
+
476DLAF_DEFINE_CUSOLVER_OP_BUFFER(Hegst, std::complex<double>, zhegst);
+
477
+
478DLAF_DEFINE_CUSOLVER_OP_BUFFER(Potrf, float, spotrf);
+
479DLAF_DEFINE_CUSOLVER_OP_BUFFER(Potrf, double, dpotrf);
+
480DLAF_DEFINE_CUSOLVER_OP_BUFFER(Potrf, std::complex<float>, cpotrf);
+
481DLAF_DEFINE_CUSOLVER_OP_BUFFER(Potrf, std::complex<double>, zpotrf);
+
482
+
483#endif
+
484}
+
485
+
486namespace internal {
+
487template <class T>
+
488class CusolverInfo {
+
489#ifdef DLAF_WITH_CUDA
+
490 memory::MemoryView<T, Device::GPU> workspace_;
+
491#endif
+
492 memory::MemoryView<int, Device::GPU> info_;
+
493
+
494public:
+
495#ifdef DLAF_WITH_CUDA
+
496 CusolverInfo(int workspace_size) : workspace_(workspace_size), info_(1) {}
+
497#endif
+
498 CusolverInfo() : info_(1) {}
+
499
+
500#ifdef DLAF_WITH_CUDA
+
501 T* workspace() {
+
502 return workspace_();
+
503 }
+
504#endif
+
505 int* info() {
+
506 return info_();
+
507 }
+
508};
+
509
+
510template <class F, class T>
+
511void assertExtendInfo(F assertFunc, cusolverDnHandle_t handle, CusolverInfo<T>&& info) {
+
512 whip::stream_t stream;
+
513 DLAF_GPULAPACK_CHECK_ERROR(cusolverDnGetStream(handle, &stream));
+
514 assertFunc(stream, info.info());
+
515 // Extend info scope to the end of the kernel execution
+
516 auto extend_info = [info = std::move(info)](whip::error_t status) { whip::check_error(status); };
+
517 pika::cuda::experimental::detail::add_event_callback(std::move(extend_info), stream);
518}
-
519
-
520template <class T>
-
521dlaf::BaseType<T> lange(cusolverDnHandle_t handle, const lapack::Norm norm,
-
522 const Tile<T, Device::GPU>& a) {
-
523 DLAF_STATIC_UNIMPLEMENTED(T);
-
524 dlaf::internal::silenceUnusedWarningFor(handle, norm, a);
-
525}
-
526
-
527template <class T>
-
528dlaf::BaseType<T> lantr(cusolverDnHandle_t handle, const lapack::Norm norm, const blas::Uplo uplo,
-
529 const blas::Diag diag, const Tile<T, Device::GPU>& a) {
-
530 DLAF_STATIC_UNIMPLEMENTED(T);
-
531 dlaf::internal::silenceUnusedWarningFor(handle, norm, uplo, diag, a);
-
532}
-
533
-
534template <class T>
-
535void laset(const blas::Uplo uplo, T alpha, T beta, const Tile<T, Device::GPU>& tile,
-
536 whip::stream_t stream) {
-
537 const SizeType m = tile.size().rows();
-
538 const SizeType n = tile.size().cols();
-
539
-
540 gpulapack::laset(uplo, m, n, alpha, beta, tile.ptr(), tile.ld(), stream);
-
541}
-
542
-
543template <class T>
-
544void set0(const Tile<T, Device::GPU>& tile, whip::stream_t stream) {
-
545 whip::memset_2d_async(tile.ptr(), sizeof(T) * to_sizet(tile.ld()), 0,
-
546 sizeof(T) * to_sizet(tile.size().rows()), to_sizet(tile.size().cols()), stream);
-
547}
-
548
-
549template <class T>
-
550void hegst(cusolverDnHandle_t handle, const int itype, const blas::Uplo uplo,
-
551 const matrix::Tile<T, Device::GPU>& a, const matrix::Tile<T, Device::GPU>& b) {
-
552 DLAF_ASSERT(square_size(a), a);
-
553 DLAF_ASSERT(square_size(b), b);
-
554 DLAF_ASSERT(a.size() == b.size(), a, b);
-
555 const auto n = a.size().rows();
-
556
-
557#ifdef DLAF_WITH_CUDA
-
558 int workspace_size;
-
559 internal::CusolverHegst<T>::callBufferSize(handle, itype, util::blasToCublas(uplo), to_int(n),
-
560 util::blasToCublasCast(a.ptr()), to_int(a.ld()),
-
561 util::blasToCublasCast(b.ptr()), to_int(b.ld()),
-
562 &workspace_size);
-
563 internal::CusolverInfo<T> info{std::max(1, workspace_size)};
-
564 internal::CusolverHegst<T>::call(handle, itype, util::blasToCublas(uplo), to_int(n),
-
565 util::blasToCublasCast(a.ptr()), to_int(a.ld()),
-
566 util::blasToCublasCast(b.ptr()), to_int(b.ld()),
-
567 util::blasToCublasCast(info.workspace()), info.info());
-
568
-
569 assertExtendInfo(dlaf::gpulapack::internal::assertInfoHegst, handle, std::move(info));
-
570#elif defined(DLAF_WITH_HIP)
-
571 internal::CusolverHegst<T>::call(handle, util::blasToRocblas(itype), util::blasToRocblas(uplo),
-
572 to_int(n), util::blasToRocblasCast(a.ptr()), to_int(a.ld()),
-
573 util::blasToRocblasCast(b.ptr()), to_int(b.ld()));
-
574#endif
-
575}
-
576
-
577template <class T>
-
578internal::CusolverInfo<T> potrfInfo(cusolverDnHandle_t handle, const blas::Uplo uplo,
-
579 const matrix::Tile<T, Device::GPU>& a) {
-
580 DLAF_ASSERT(square_size(a), a);
-
581 const auto n = a.size().rows();
-
582
-
583#ifdef DLAF_WITH_CUDA
-
584 int workspace_size;
-
585 internal::CusolverPotrf<T>::callBufferSize(handle, util::blasToCublas(uplo), to_int(n),
-
586 util::blasToCublasCast(a.ptr()), to_int(a.ld()),
-
587 &workspace_size);
-
588 internal::CusolverInfo<T> info{workspace_size};
-
589 internal::CusolverPotrf<T>::call(handle, util::blasToCublas(uplo), to_int(n),
-
590 util::blasToCublasCast(a.ptr()), to_int(a.ld()),
-
591 util::blasToCublasCast(info.workspace()), workspace_size,
-
592 info.info());
-
593#elif defined(DLAF_WITH_HIP)
-
594 internal::CusolverInfo<T> info{};
-
595 internal::CusolverPotrf<T>::call(handle, util::blasToRocblas(uplo), to_int(n),
-
596 util::blasToRocblasCast(a.ptr()), to_int(a.ld()), info.info());
-
597#endif
-
598
-
599 return info;
-
600}
-
601
-
602template <class T>
-
603void potrf(cusolverDnHandle_t handle, const blas::Uplo uplo, const matrix::Tile<T, Device::GPU>& a) {
-
604 auto info = potrfInfo(handle, uplo, a);
-
605 assertExtendInfo(dlaf::gpulapack::internal::assertInfoPotrf, handle, std::move(info));
-
606}
-
607
-
608#endif
-
609
-
610DLAF_MAKE_CALLABLE_OBJECT(lange);
-
611DLAF_MAKE_CALLABLE_OBJECT(lantr);
-
612DLAF_MAKE_CALLABLE_OBJECT(laset);
-
613DLAF_MAKE_CALLABLE_OBJECT(set0);
-
614DLAF_MAKE_CALLABLE_OBJECT(hegst);
-
615DLAF_MAKE_CALLABLE_OBJECT(potrf);
-
616DLAF_MAKE_CALLABLE_OBJECT(potrfInfo);
-
617DLAF_MAKE_CALLABLE_OBJECT(stedc);
-
618DLAF_MAKE_CALLABLE_OBJECT(scaleCol);
-
619}
-
620
-
621DLAF_MAKE_SENDER_ALGORITHM_OVERLOADS(::dlaf::internal::TransformDispatchType::Lapack, lange,
-
622 internal::lange_o)
-
623DLAF_MAKE_SENDER_ALGORITHM_OVERLOADS(::dlaf::internal::TransformDispatchType::Lapack, lantr,
-
624 internal::lantr_o)
-
625DLAF_MAKE_SENDER_ALGORITHM_OVERLOADS(::dlaf::internal::TransformDispatchType::Plain, laset,
-
626 internal::laset_o)
-
627DLAF_MAKE_SENDER_ALGORITHM_OVERLOADS(::dlaf::internal::TransformDispatchType::Plain, set0,
-
628 internal::set0_o)
-
629DLAF_MAKE_SENDER_ALGORITHM_OVERLOADS(::dlaf::internal::TransformDispatchType::Lapack, hegst,
-
630 internal::hegst_o)
-
631DLAF_MAKE_SENDER_ALGORITHM_OVERLOADS(::dlaf::internal::TransformDispatchType::Lapack, potrf,
-
632 internal::potrf_o)
-
633DLAF_MAKE_SENDER_ALGORITHM_OVERLOADS(::dlaf::internal::TransformDispatchType::Lapack, potrfInfo,
-
634 internal::potrfInfo_o)
-
635DLAF_MAKE_SENDER_ALGORITHM_OVERLOADS(::dlaf::internal::TransformDispatchType::Lapack, stedc,
-
636 internal::stedc_o)
-
637DLAF_MAKE_SENDER_ALGORITHM_OVERLOADS(::dlaf::internal::TransformDispatchType::Lapack, scaleCol,
-
638 internal::scaleCol_o)
-
639
-
640#endif
-
641}
+
519}
+
520
+
521template <class T>
+
522dlaf::BaseType<T> lange(cusolverDnHandle_t handle, const lapack::Norm norm,
+
523 const Tile<T, Device::GPU>& a) {
+
524 DLAF_STATIC_UNIMPLEMENTED(T);
+
525 dlaf::internal::silenceUnusedWarningFor(handle, norm, a);
+
526}
+
527
+
528template <class T>
+
529dlaf::BaseType<T> lantr(cusolverDnHandle_t handle, const lapack::Norm norm, const blas::Uplo uplo,
+
530 const blas::Diag diag, const Tile<T, Device::GPU>& a) {
+
531 DLAF_STATIC_UNIMPLEMENTED(T);
+
532 dlaf::internal::silenceUnusedWarningFor(handle, norm, uplo, diag, a);
+
533}
+
534
+
535template <class T>
+
536void laset(const blas::Uplo uplo, T alpha, T beta, const Tile<T, Device::GPU>& tile,
+
537 whip::stream_t stream) {
+
538 const SizeType m = tile.size().rows();
+
539 const SizeType n = tile.size().cols();
+
540
+
541 gpulapack::laset(uplo, m, n, alpha, beta, tile.ptr(), tile.ld(), stream);
+
542}
+
543
+
544template <class T>
+
545void set0(const Tile<T, Device::GPU>& tile, whip::stream_t stream) {
+
546 whip::memset_2d_async(tile.ptr(), sizeof(T) * to_sizet(tile.ld()), 0,
+
547 sizeof(T) * to_sizet(tile.size().rows()), to_sizet(tile.size().cols()), stream);
+
548}
+
549
+
550template <class T>
+
551void hegst(cusolverDnHandle_t handle, const int itype, const blas::Uplo uplo,
+
552 const matrix::Tile<T, Device::GPU>& a, const matrix::Tile<T, Device::GPU>& b) {
+
553 DLAF_ASSERT(square_size(a), a);
+
554 DLAF_ASSERT(square_size(b), b);
+
555 DLAF_ASSERT(a.size() == b.size(), a, b);
+
556 const auto n = a.size().rows();
+
557
+
558#ifdef DLAF_WITH_CUDA
+
559 int workspace_size;
+
560 internal::CusolverHegst<T>::callBufferSize(handle, itype, util::blasToCublas(uplo), to_int(n),
+
561 util::blasToCublasCast(a.ptr()), to_int(a.ld()),
+
562 util::blasToCublasCast(b.ptr()), to_int(b.ld()),
+
563 &workspace_size);
+
564 internal::CusolverInfo<T> info{std::max(1, workspace_size)};
+
565 internal::CusolverHegst<T>::call(handle, itype, util::blasToCublas(uplo), to_int(n),
+
566 util::blasToCublasCast(a.ptr()), to_int(a.ld()),
+
567 util::blasToCublasCast(b.ptr()), to_int(b.ld()),
+
568 util::blasToCublasCast(info.workspace()), info.info());
+
569
+
570 assertExtendInfo(dlaf::gpulapack::internal::assertInfoHegst, handle, std::move(info));
+
571#elif defined(DLAF_WITH_HIP)
+
572 internal::CusolverHegst<T>::call(handle, util::blasToRocblas(itype), util::blasToRocblas(uplo),
+
573 to_int(n), util::blasToRocblasCast(a.ptr()), to_int(a.ld()),
+
574 util::blasToRocblasCast(b.ptr()), to_int(b.ld()));
+
575#endif
+
576}
+
577
+
578template <class T>
+
579internal::CusolverInfo<T> potrfInfo(cusolverDnHandle_t handle, const blas::Uplo uplo,
+
580 const matrix::Tile<T, Device::GPU>& a) {
+
581 DLAF_ASSERT(square_size(a), a);
+
582 const auto n = a.size().rows();
+
583
+
584#ifdef DLAF_WITH_CUDA
+
585 int workspace_size;
+
586 internal::CusolverPotrf<T>::callBufferSize(handle, util::blasToCublas(uplo), to_int(n),
+
587 util::blasToCublasCast(a.ptr()), to_int(a.ld()),
+
588 &workspace_size);
+
589 internal::CusolverInfo<T> info{workspace_size};
+
590 internal::CusolverPotrf<T>::call(handle, util::blasToCublas(uplo), to_int(n),
+
591 util::blasToCublasCast(a.ptr()), to_int(a.ld()),
+
592 util::blasToCublasCast(info.workspace()), workspace_size,
+
593 info.info());
+
594#elif defined(DLAF_WITH_HIP)
+
595 internal::CusolverInfo<T> info{};
+
596 internal::CusolverPotrf<T>::call(handle, util::blasToRocblas(uplo), to_int(n),
+
597 util::blasToRocblasCast(a.ptr()), to_int(a.ld()), info.info());
+
598#endif
+
599
+
600 return info;
+
601}
+
602
+
603template <class T>
+
604void potrf(cusolverDnHandle_t handle, const blas::Uplo uplo, const matrix::Tile<T, Device::GPU>& a) {
+
605 auto info = potrfInfo(handle, uplo, a);
+
606 assertExtendInfo(dlaf::gpulapack::internal::assertInfoPotrf, handle, std::move(info));
+
607}
+
608
+
609#endif
+
610
+
611DLAF_MAKE_CALLABLE_OBJECT(lange);
+
612DLAF_MAKE_CALLABLE_OBJECT(lantr);
+
613DLAF_MAKE_CALLABLE_OBJECT(laset);
+
614DLAF_MAKE_CALLABLE_OBJECT(set0);
+
615DLAF_MAKE_CALLABLE_OBJECT(hegst);
+
616DLAF_MAKE_CALLABLE_OBJECT(potrf);
+
617DLAF_MAKE_CALLABLE_OBJECT(potrfInfo);
+
618DLAF_MAKE_CALLABLE_OBJECT(stedc);
+
619DLAF_MAKE_CALLABLE_OBJECT(scaleCol);
+
620}
+
621
+
622DLAF_MAKE_SENDER_ALGORITHM_OVERLOADS(::dlaf::internal::TransformDispatchType::Lapack, lange,
+
623 internal::lange_o)
+
624DLAF_MAKE_SENDER_ALGORITHM_OVERLOADS(::dlaf::internal::TransformDispatchType::Lapack, lantr,
+
625 internal::lantr_o)
+
626DLAF_MAKE_SENDER_ALGORITHM_OVERLOADS(::dlaf::internal::TransformDispatchType::Plain, laset,
+
627 internal::laset_o)
+
628DLAF_MAKE_SENDER_ALGORITHM_OVERLOADS(::dlaf::internal::TransformDispatchType::Plain, set0,
+
629 internal::set0_o)
+
630DLAF_MAKE_SENDER_ALGORITHM_OVERLOADS(::dlaf::internal::TransformDispatchType::Lapack, hegst,
+
631 internal::hegst_o)
+
632DLAF_MAKE_SENDER_ALGORITHM_OVERLOADS(::dlaf::internal::TransformDispatchType::Lapack, potrf,
+
633 internal::potrf_o)
+
634DLAF_MAKE_SENDER_ALGORITHM_OVERLOADS(::dlaf::internal::TransformDispatchType::Lapack, potrfInfo,
+
635 internal::potrfInfo_o)
+
636DLAF_MAKE_SENDER_ALGORITHM_OVERLOADS(::dlaf::internal::TransformDispatchType::Lapack, stedc,
+
637 internal::stedc_o)
+
638DLAF_MAKE_SENDER_ALGORITHM_OVERLOADS(::dlaf::internal::TransformDispatchType::Lapack, scaleCol,
+
639 internal::scaleCol_o)
+
640
+
641#endif
+
642}
callable_object.h
DLAF_MAKE_CALLABLE_OBJECT
#define DLAF_MAKE_CALLABLE_OBJECT(fname)
Definition callable_object.h:29
@@ -599,9 +600,9 @@
dlaf::common::internal::SingleThreadedBlasScope
Definition single_threaded_blas.h:20
dlaf::internal::Policy
Definition policy.h:24
-
dlaf::matrix::Tile
Definition tile.h:332
-
dlaf::matrix::Tile::ptr
T * ptr() const noexcept
Returns the base pointer.
Definition tile.h:381
-
dlaf::memory::MemoryView
Definition memory_view.h:32
+
dlaf::matrix::Tile
Definition tile.h:333
+
dlaf::matrix::Tile::ptr
T * ptr() const noexcept
Returns the base pointer.
Definition tile.h:382
+
dlaf::memory::MemoryView
Definition memory_view.h:33
dlaf::tile::stedc
void stedc(const dlaf::internal::Policy< B > &p, const Tile< T, D > &tridiag, const Tile< T, D > &evecs)
dlaf::tile::lantr
dlaf::BaseType< T > lantr(const dlaf::internal::Policy< B > &p, const lapack::Norm norm, const blas::Uplo uplo, const blas::Diag diag, const Tile< T, D > &a)
dlaf::tile::potrfInfo
auto potrfInfo(const dlaf::internal::Policy< B > &, const blas::Uplo uplo, const Tile< T, D > &a)
@@ -617,7 +618,7 @@
dlaf::to_int
auto to_int(const T unsigned_value)
Definition types.h:248
util_lapack.h
lapack::laset
void laset(blas::Uplo uplo, int64_t m, int64_t n, T alpha, T beta, T *a, int64_t lda)
Overload of laset with blas::Uplo instead of lapack::MatrixType.
Definition util_lapack.h:43
-
dlaf::matrix::square_size
bool square_size(const MatrixLike &m) noexcept
Returns true if the matrix is square.
Definition util_matrix.h:42
+
dlaf::matrix::square_size
bool square_size(const MatrixLike &m) noexcept
Returns true if the matrix is square.
Definition util_matrix.h:43
util_tile.h
diff --git a/master/larft_8h_source.html b/master/larft_8h_source.html index bf7e585559..f7d60206d1 100644 --- a/master/larft_8h_source.html +++ b/master/larft_8h_source.html @@ -95,43 +95,45 @@
12
13#ifdef DLAF_WITH_GPU
14
-
15#include <blas.hh>
-
16#include <whip.hpp>
-
17
-
18#include <dlaf/gpu/blas/api.h>
-
19#include <dlaf/types.h>
-
20
-
21namespace dlaf::gpulapack {
+
15#include <complex>
+
16
+
17#include <blas.hh>
+
18#include <whip.hpp>
+
19
+
20#include <dlaf/gpu/blas/api.h>
+
21#include <dlaf/types.h>
22
-
23template <class T>
-
24void larft_gemv0(cublasHandle_t handle, const SizeType m, SizeType k, const T* v, const SizeType ldv,
-
25 const T* tau, T* t, const SizeType ldt);
-
26
-
27template <class T>
-
28void larft_gemv1_notau(cublasHandle_t handle, const SizeType m, const SizeType k, const T* v,
-
29 const SizeType ldv, T* t, const SizeType ldt);
-
30
-
31template <class T>
-
32void larft_gemv1_fixtau(const SizeType k, const T* tau, const SizeType inctau, T* t, const SizeType ldt,
-
33 whip::stream_t stream);
-
34
-
35#define DLAF_CUBLAS_LARFT_GEMV_ETI(kword, Type) \
-
36 kword template void larft_gemv0(cublasHandle_t handle, const SizeType n, SizeType k, const Type* v, \
-
37 const SizeType ldv, const Type* tau, Type* t, const SizeType ldt); \
-
38 kword template void larft_gemv1_notau(cublasHandle_t handle, const SizeType m, const SizeType k, \
-
39 const Type* v, const SizeType ldv, Type* t, \
-
40 const SizeType ldt); \
-
41 kword template void larft_gemv1_fixtau(const SizeType k, const Type* tau, const SizeType inctau, \
-
42 Type* t, const SizeType ldt, whip::stream_t stream)
-
43
-
44DLAF_CUBLAS_LARFT_GEMV_ETI(extern, float);
-
45DLAF_CUBLAS_LARFT_GEMV_ETI(extern, double);
-
46DLAF_CUBLAS_LARFT_GEMV_ETI(extern, std::complex<float>);
-
47DLAF_CUBLAS_LARFT_GEMV_ETI(extern, std::complex<double>);
-
48
-
49}
+
23namespace dlaf::gpulapack {
+
24
+
25template <class T>
+
26void larft_gemv0(cublasHandle_t handle, const SizeType m, SizeType k, const T* v, const SizeType ldv,
+
27 const T* tau, T* t, const SizeType ldt);
+
28
+
29template <class T>
+
30void larft_gemv1_notau(cublasHandle_t handle, const SizeType m, const SizeType k, const T* v,
+
31 const SizeType ldv, T* t, const SizeType ldt);
+
32
+
33template <class T>
+
34void larft_gemv1_fixtau(const SizeType k, const T* tau, const SizeType inctau, T* t, const SizeType ldt,
+
35 whip::stream_t stream);
+
36
+
37#define DLAF_CUBLAS_LARFT_GEMV_ETI(kword, Type) \
+
38 kword template void larft_gemv0(cublasHandle_t handle, const SizeType n, SizeType k, const Type* v, \
+
39 const SizeType ldv, const Type* tau, Type* t, const SizeType ldt); \
+
40 kword template void larft_gemv1_notau(cublasHandle_t handle, const SizeType m, const SizeType k, \
+
41 const Type* v, const SizeType ldv, Type* t, \
+
42 const SizeType ldt); \
+
43 kword template void larft_gemv1_fixtau(const SizeType k, const Type* tau, const SizeType inctau, \
+
44 Type* t, const SizeType ldt, whip::stream_t stream)
+
45
+
46DLAF_CUBLAS_LARFT_GEMV_ETI(extern, float);
+
47DLAF_CUBLAS_LARFT_GEMV_ETI(extern, double);
+
48DLAF_CUBLAS_LARFT_GEMV_ETI(extern, std::complex<float>);
+
49DLAF_CUBLAS_LARFT_GEMV_ETI(extern, std::complex<double>);
50
-
51#endif
+
51}
+
52
+
53#endif
diff --git a/master/laset_8h_source.html b/master/laset_8h_source.html index 1ef412a41e..f74136cbe1 100644 --- a/master/laset_8h_source.html +++ b/master/laset_8h_source.html @@ -95,29 +95,31 @@
12
13#ifdef DLAF_WITH_GPU
14
-
15#include <blas.hh>
-
16#include <whip.hpp>
-
17
-
18#include <dlaf/gpu/blas/api.h>
-
19#include <dlaf/types.h>
-
20
-
21namespace dlaf::gpulapack {
+
15#include <complex>
+
16
+
17#include <blas.hh>
+
18#include <whip.hpp>
+
19
+
20#include <dlaf/gpu/blas/api.h>
+
21#include <dlaf/types.h>
22
-
23template <class T>
-
24void laset(blas::Uplo uplo, SizeType m, SizeType n, T alpha, T beta, T* a, SizeType lda,
-
25 whip::stream_t stream);
-
26
-
27#define DLAF_CUBLAS_LASET_ETI(kword, Type) \
-
28 kword template void laset(blas::Uplo uplo, SizeType m, SizeType n, Type alpha, Type beta, Type* a, \
-
29 SizeType lda, whip::stream_t stream)
-
30
-
31DLAF_CUBLAS_LASET_ETI(extern, float);
-
32DLAF_CUBLAS_LASET_ETI(extern, double);
-
33DLAF_CUBLAS_LASET_ETI(extern, std::complex<float>);
-
34DLAF_CUBLAS_LASET_ETI(extern, std::complex<double>);
-
35}
-
36
-
37#endif
+
23namespace dlaf::gpulapack {
+
24
+
25template <class T>
+
26void laset(blas::Uplo uplo, SizeType m, SizeType n, T alpha, T beta, T* a, SizeType lda,
+
27 whip::stream_t stream);
+
28
+
29#define DLAF_CUBLAS_LASET_ETI(kword, Type) \
+
30 kword template void laset(blas::Uplo uplo, SizeType m, SizeType n, Type alpha, Type beta, Type* a, \
+
31 SizeType lda, whip::stream_t stream)
+
32
+
33DLAF_CUBLAS_LASET_ETI(extern, float);
+
34DLAF_CUBLAS_LASET_ETI(extern, double);
+
35DLAF_CUBLAS_LASET_ETI(extern, std::complex<float>);
+
36DLAF_CUBLAS_LASET_ETI(extern, std::complex<double>);
+
37}
+
38
+
39#endif
diff --git a/master/layout__info_8h_source.html b/master/layout__info_8h_source.html index 14291a6820..adb4a90cd8 100644 --- a/master/layout__info_8h_source.html +++ b/master/layout__info_8h_source.html @@ -227,7 +227,7 @@
dlaf::matrix::LayoutInfo::minTileMemSize
SizeType minTileMemSize(const TileElementSize &tile_size) const noexcept
dlaf::matrix::LayoutInfo::tileOffset
SizeType tileOffset(const LocalTileIndex &index) const noexcept
Definition layout_info.h:67
dlaf::matrix::LayoutInfo::minMemSize
SizeType minMemSize() const noexcept
Returns the minimum number of elements that are needed to fit a matrix with the given layout.
-
dlaf::matrix::Matrix
Definition matrix.h:61
+
dlaf::matrix::Matrix
Definition matrix.h:62
dlaf::matrix::tileLayout
LayoutInfo tileLayout(const LocalElementSize &size, const TileElementSize &block_size, SizeType ld_tile, SizeType tiles_per_col)
Returns LayoutInfo for a local matrix which use the tile layout (Advanced interface).
Definition layout_info.h:135
dlaf::matrix::colMajorLayout
LayoutInfo colMajorLayout(const LocalElementSize &size, const TileElementSize &block_size, SizeType ld)
Returns LayoutInfo for a local column major matrix.
Definition layout_info.h:125
diff --git a/master/matrix_2tile_8h.html b/master/matrix_2tile_8h.html index 4e46fecc17..781db9e8f1 100644 --- a/master/matrix_2tile_8h.html +++ b/master/matrix_2tile_8h.html @@ -81,7 +81,8 @@
tile.h File Reference
-
#include <exception>
+
#include <complex>
+#include <exception>
#include <memory>
#include <ostream>
#include <tuple>
diff --git a/master/matrix_2tile_8h_source.html b/master/matrix_2tile_8h_source.html index abdb6b885f..fd7a403939 100644 --- a/master/matrix_2tile_8h_source.html +++ b/master/matrix_2tile_8h_source.html @@ -94,627 +94,628 @@
11#pragma once
12
14
-
15#include <exception>
-
16#include <memory>
-
17#include <ostream>
-
18#include <tuple>
-
19#include <type_traits>
-
20#include <utility>
-
21#include <vector>
-
22
-
23#include <pika/async_rw_mutex.hpp>
-
24#include <pika/execution.hpp>
-
25#include <pika/functional.hpp>
-
26
-
27#include <dlaf/common/data_descriptor.h>
-
28#include <dlaf/matrix/index.h>
-
29#include <dlaf/memory/memory_view.h>
-
30#include <dlaf/sender/when_all_lift.h>
-
31#include <dlaf/types.h>
-
32#include <dlaf/util_math.h>
-
33
-
34namespace dlaf::matrix {
-
35namespace internal {
-
36
-
37template <class T, Device D>
-
-
38class TileData {
-
39public:
-
40 TileData() = default;
-
41
-
42 TileData(const TileElementSize& size, memory::MemoryView<T, D> memory_view, SizeType ld) noexcept
-
43 : size_(size), memory_view_(std::move(memory_view)), ld_(ld) {
-
44 DLAF_ASSERT(size_.isValid(), size_);
-
45 DLAF_ASSERT(ld_ >= std::max<SizeType>(1, size_.rows()), ld, size_.rows());
-
46 DLAF_ASSERT(size_.isEmpty() || linearSize(size_, ld_) <= memory_view_.size(), size_, ld_,
-
47 memory_view_.size());
-
48 }
-
49
-
50 TileData(const TileData& rhs) = delete;
-
51
-
52 TileData(TileData&& rhs) noexcept
-
53 : size_(rhs.size_), memory_view_(std::move(rhs.memory_view_)), ld_(rhs.ld_) {
-
54 rhs.setDefaultSize();
-
55 }
-
56
-
57 TileData& operator=(const TileData&) = delete;
-
58
-
59 TileData& operator=(TileData&& rhs) {
-
60 size_ = rhs.size_;
-
61 memory_view_ = std::move(rhs.memory_view_);
-
62 ld_ = rhs.ld_;
-
63 rhs.setDefaultSize();
-
64
-
65 return *this;
-
66 }
-
67
-
68 const auto& memoryView() const noexcept {
-
69 return memory_view_;
-
70 }
-
71
-
72 T* ptr() const noexcept {
-
73 return memory_view_();
-
74 }
-
75
-
76 T* ptr(const TileElementIndex& index) const noexcept {
-
77 return memory_view_(linearIndex(index));
-
78 }
-
79
-
80 const TileElementSize& size() const noexcept {
-
81 return size_;
-
82 }
-
83 SizeType ld() const noexcept {
-
84 return ld_;
-
85 }
-
86
-
87 SizeType linearIndex(const TileElementIndex& index) const noexcept {
-
88 DLAF_ASSERT_HEAVY(index.isIn(size_), index, size_);
-
89 return index.row() + ld_ * index.col();
-
90 }
-
91
-
92 static SizeType linearSize(const TileElementSize& size, SizeType ld) noexcept {
-
93 if (size.isEmpty())
-
94 return 0;
-
95 return size.rows() + ld * (size.cols() - 1);
-
96 }
-
97
-
98private:
-
100 void setDefaultSize() noexcept {
-
101 size_ = {0, 0};
-
102 ld_ = 1;
-
103 }
-
104
-
105 TileElementSize size_{0, 0};
-
106 memory::MemoryView<T, D> memory_view_{};
-
107 SizeType ld_{1};
-
108};
+
15#include <complex>
+
16#include <exception>
+
17#include <memory>
+
18#include <ostream>
+
19#include <tuple>
+
20#include <type_traits>
+
21#include <utility>
+
22#include <vector>
+
23
+
24#include <pika/async_rw_mutex.hpp>
+
25#include <pika/execution.hpp>
+
26#include <pika/functional.hpp>
+
27
+
28#include <dlaf/common/data_descriptor.h>
+
29#include <dlaf/matrix/index.h>
+
30#include <dlaf/memory/memory_view.h>
+
31#include <dlaf/sender/when_all_lift.h>
+
32#include <dlaf/types.h>
+
33#include <dlaf/util_math.h>
+
34
+
35namespace dlaf::matrix {
+
36namespace internal {
+
37
+
38template <class T, Device D>
+
+
39class TileData {
+
40public:
+
41 TileData() = default;
+
42
+
43 TileData(const TileElementSize& size, memory::MemoryView<T, D> memory_view, SizeType ld) noexcept
+
44 : size_(size), memory_view_(std::move(memory_view)), ld_(ld) {
+
45 DLAF_ASSERT(size_.isValid(), size_);
+
46 DLAF_ASSERT(ld_ >= std::max<SizeType>(1, size_.rows()), ld, size_.rows());
+
47 DLAF_ASSERT(size_.isEmpty() || linearSize(size_, ld_) <= memory_view_.size(), size_, ld_,
+
48 memory_view_.size());
+
49 }
+
50
+
51 TileData(const TileData& rhs) = delete;
+
52
+
53 TileData(TileData&& rhs) noexcept
+
54 : size_(rhs.size_), memory_view_(std::move(rhs.memory_view_)), ld_(rhs.ld_) {
+
55 rhs.setDefaultSize();
+
56 }
+
57
+
58 TileData& operator=(const TileData&) = delete;
+
59
+
60 TileData& operator=(TileData&& rhs) {
+
61 size_ = rhs.size_;
+
62 memory_view_ = std::move(rhs.memory_view_);
+
63 ld_ = rhs.ld_;
+
64 rhs.setDefaultSize();
+
65
+
66 return *this;
+
67 }
+
68
+
69 const auto& memoryView() const noexcept {
+
70 return memory_view_;
+
71 }
+
72
+
73 T* ptr() const noexcept {
+
74 return memory_view_();
+
75 }
+
76
+
77 T* ptr(const TileElementIndex& index) const noexcept {
+
78 return memory_view_(linearIndex(index));
+
79 }
+
80
+
81 const TileElementSize& size() const noexcept {
+
82 return size_;
+
83 }
+
84 SizeType ld() const noexcept {
+
85 return ld_;
+
86 }
+
87
+
88 SizeType linearIndex(const TileElementIndex& index) const noexcept {
+
89 DLAF_ASSERT_HEAVY(index.isIn(size_), index, size_);
+
90 return index.row() + ld_ * index.col();
+
91 }
+
92
+
93 static SizeType linearSize(const TileElementSize& size, SizeType ld) noexcept {
+
94 if (size.isEmpty())
+
95 return 0;
+
96 return size.rows() + ld * (size.cols() - 1);
+
97 }
+
98
+
99private:
+
101 void setDefaultSize() noexcept {
+
102 size_ = {0, 0};
+
103 ld_ = 1;
+
104 }
+
105
+
106 TileElementSize size_{0, 0};
+
107 memory::MemoryView<T, D> memory_view_{};
+
108 SizeType ld_{1};
+
109};
-
109}
-
110
-
-
112struct SubTileSpec {
-
113 TileElementIndex origin;
-
114 TileElementSize size;
-
115};
+
110}
+
111
+
+
113struct SubTileSpec {
+
114 TileElementIndex origin;
+
115 TileElementSize size;
+
116};
-
116
-
117namespace internal {
-
118inline bool subTileSpecsOverlap(const SubTileSpec& spec1, const SubTileSpec& spec2) {
-
119 // no overlap if either of the sizes is empty.
-
120 if (spec1.size.isEmpty() || spec2.size.isEmpty()) {
-
121 return false;
-
122 }
-
123
-
124 const auto& start1 = spec1.origin;
-
125 const auto end1 = start1 + spec1.size;
-
126 const auto& start2 = spec2.origin;
-
127 const auto end2 = start2 + spec2.size;
-
128
-
129 // no overlap if rows do not overlap.
-
130 if (end1.row() <= start2.row() || end2.row() <= start1.row()) {
-
131 return false;
-
132 }
-
133 // no overlap if cols do not overlap.
-
134 if (end1.col() <= start2.col() || end2.col() <= start1.col()) {
-
135 return false;
-
136 }
-
137
-
138 return true;
-
139}
+
117
+
118namespace internal {
+
119inline bool subTileSpecsOverlap(const SubTileSpec& spec1, const SubTileSpec& spec2) {
+
120 // no overlap if either of the sizes is empty.
+
121 if (spec1.size.isEmpty() || spec2.size.isEmpty()) {
+
122 return false;
+
123 }
+
124
+
125 const auto& start1 = spec1.origin;
+
126 const auto end1 = start1 + spec1.size;
+
127 const auto& start2 = spec2.origin;
+
128 const auto end2 = start2 + spec2.size;
+
129
+
130 // no overlap if rows do not overlap.
+
131 if (end1.row() <= start2.row() || end2.row() <= start1.row()) {
+
132 return false;
+
133 }
+
134 // no overlap if cols do not overlap.
+
135 if (end1.col() <= start2.col() || end2.col() <= start1.col()) {
+
136 return false;
+
137 }
+
138
+
139 return true;
140}
-
141
-
142// forward declarations
-
143template <class T, Device D>
-
144class Tile;
-
145
-
146template <class T, Device D>
-
147class Tile<const T, D>;
-
148
-
149namespace internal {
-
150template <class T, Device D>
-
151using TileAsyncRwMutex =
-
152 pika::execution::experimental::async_rw_mutex<Tile<T, D>, const Tile<const T, D>>;
-
153
-
154template <class T, Device D>
-
155using TileAsyncRwMutexReadWriteWrapper = pika::execution::experimental::async_rw_mutex_access_wrapper<
-
156 Tile<T, D>, const Tile<const T, D>,
-
157 pika::execution::experimental::async_rw_mutex_access_type::readwrite>;
-
158
-
159template <class T, Device D>
-
160using TileAsyncRwMutexReadOnlyWrapper = pika::execution::experimental::async_rw_mutex_access_wrapper<
-
161 Tile<T, D>, const Tile<const T, D>, pika::execution::experimental::async_rw_mutex_access_type::read>;
-
162}
-
163
-
164template <class T, Device D>
-
165using ReadWriteTileSender = pika::execution::experimental::unique_any_sender<Tile<T, D>>;
-
166
-
167template <class T, Device D>
-
168using ReadOnlyTileSender =
-
169 pika::execution::experimental::any_sender<internal::TileAsyncRwMutexReadOnlyWrapper<T, D>>;
-
170
-
171namespace internal {
-
172template <class T, Device D>
-
173Tile<T, D> createSubTileAsyncRwMutex(internal::TileAsyncRwMutexReadOnlyWrapper<T, D> tile_wrapper,
-
174 const SubTileSpec& spec);
-
175
-
176template <class T, Device D>
-
177Tile<T, D> createTileAsyncRwMutex(internal::TileAsyncRwMutexReadWriteWrapper<T, D> tile_wrapper);
-
178
-
179template <class T, Device D>
-
180Tile<T, D> createSubTileAsyncRwMutex(internal::TileAsyncRwMutexReadWriteWrapper<T, D> tile_wrapper,
-
181 const SubTileSpec& spec);
-
182
-
183template <class T, Device D>
-
184Tile<T, D> createSubTileAsyncRwMutex(Tile<T, D> tile, const SubTileSpec& spec);
-
185
-
186template <class T, Device D>
-
187Tile<T, D> prepareDisjointTile(Tile<T, D>&& tile);
-
188
-
189template <class T, Device D>
-
190Tile<T, D> createDisjointSubTile(const Tile<T, D>& tile, const SubTileSpec& spec);
-
191}
-
192
-
203template <class T, Device D>
-
-
204class Tile<const T, D> {
-
205public:
-
206 using TileType = Tile<T, D>;
-
207 using ConstTileType = Tile<const T, D>;
-
208 using TileDataType = internal::TileData<T, D>;
-
209
-
210 friend TileType;
-
211 using ElementType = T;
-
212 static constexpr Device device = D;
-
213
-
215 Tile() = default;
-
216
-
-
223 Tile(const TileElementSize& size, memory::MemoryView<ElementType, D>&& memory_view,
-
224 SizeType ld) noexcept
-
225 : data_(size, std::move(memory_view), ld) {}
+
141}
+
142
+
143// forward declarations
+
144template <class T, Device D>
+
145class Tile;
+
146
+
147template <class T, Device D>
+
148class Tile<const T, D>;
+
149
+
150namespace internal {
+
151template <class T, Device D>
+
152using TileAsyncRwMutex =
+
153 pika::execution::experimental::async_rw_mutex<Tile<T, D>, const Tile<const T, D>>;
+
154
+
155template <class T, Device D>
+
156using TileAsyncRwMutexReadWriteWrapper = pika::execution::experimental::async_rw_mutex_access_wrapper<
+
157 Tile<T, D>, const Tile<const T, D>,
+
158 pika::execution::experimental::async_rw_mutex_access_type::readwrite>;
+
159
+
160template <class T, Device D>
+
161using TileAsyncRwMutexReadOnlyWrapper = pika::execution::experimental::async_rw_mutex_access_wrapper<
+
162 Tile<T, D>, const Tile<const T, D>, pika::execution::experimental::async_rw_mutex_access_type::read>;
+
163}
+
164
+
165template <class T, Device D>
+
166using ReadWriteTileSender = pika::execution::experimental::unique_any_sender<Tile<T, D>>;
+
167
+
168template <class T, Device D>
+
169using ReadOnlyTileSender =
+
170 pika::execution::experimental::any_sender<internal::TileAsyncRwMutexReadOnlyWrapper<T, D>>;
+
171
+
172namespace internal {
+
173template <class T, Device D>
+
174Tile<T, D> createSubTileAsyncRwMutex(internal::TileAsyncRwMutexReadOnlyWrapper<T, D> tile_wrapper,
+
175 const SubTileSpec& spec);
+
176
+
177template <class T, Device D>
+
178Tile<T, D> createTileAsyncRwMutex(internal::TileAsyncRwMutexReadWriteWrapper<T, D> tile_wrapper);
+
179
+
180template <class T, Device D>
+
181Tile<T, D> createSubTileAsyncRwMutex(internal::TileAsyncRwMutexReadWriteWrapper<T, D> tile_wrapper,
+
182 const SubTileSpec& spec);
+
183
+
184template <class T, Device D>
+
185Tile<T, D> createSubTileAsyncRwMutex(Tile<T, D> tile, const SubTileSpec& spec);
+
186
+
187template <class T, Device D>
+
188Tile<T, D> prepareDisjointTile(Tile<T, D>&& tile);
+
189
+
190template <class T, Device D>
+
191Tile<T, D> createDisjointSubTile(const Tile<T, D>& tile, const SubTileSpec& spec);
+
192}
+
193
+
204template <class T, Device D>
+
+
205class Tile<const T, D> {
+
206public:
+
207 using TileType = Tile<T, D>;
+
208 using ConstTileType = Tile<const T, D>;
+
209 using TileDataType = internal::TileData<T, D>;
+
210
+
211 friend TileType;
+
212 using ElementType = T;
+
213 static constexpr Device device = D;
+
214
+
216 Tile() = default;
+
217
+
+
224 Tile(const TileElementSize& size, memory::MemoryView<ElementType, D>&& memory_view,
+
225 SizeType ld) noexcept
+
226 : data_(size, std::move(memory_view), ld) {}
-
226
-
227 Tile(TileDataType&& data) noexcept : data_(std::move(data)) {}
-
228
-
229 Tile(const Tile&) = delete;
-
230
-
231 Tile(Tile&& rhs) noexcept : data_(std::move(rhs.data_)), dep_tracker_(std::move(rhs.dep_tracker_)) {
-
232 rhs.dep_tracker_ = std::monostate();
-
233 }
-
234
-
238 ~Tile() = default;
-
239
-
240 Tile& operator=(const Tile&) = delete;
-
241
-
242 Tile& operator=(Tile&& rhs) noexcept {
-
243 data_ = std::move(rhs.data_);
-
244 dep_tracker_ = std::move(rhs.dep_tracker_);
-
245 rhs.dep_tracker_ = std::monostate();
-
246
-
247 return *this;
-
248 }
-
249
-
-
254 const T& operator()(const TileElementIndex& index) const noexcept {
-
255 return *ptr(index);
-
256 }
+
227
+
228 Tile(TileDataType&& data) noexcept : data_(std::move(data)) {}
+
229
+
230 Tile(const Tile&) = delete;
+
231
+
232 Tile(Tile&& rhs) noexcept : data_(std::move(rhs.data_)), dep_tracker_(std::move(rhs.dep_tracker_)) {
+
233 rhs.dep_tracker_ = std::monostate();
+
234 }
+
235
+
239 ~Tile() = default;
+
240
+
241 Tile& operator=(const Tile&) = delete;
+
242
+
243 Tile& operator=(Tile&& rhs) noexcept {
+
244 data_ = std::move(rhs.data_);
+
245 dep_tracker_ = std::move(rhs.dep_tracker_);
+
246 rhs.dep_tracker_ = std::monostate();
+
247
+
248 return *this;
+
249 }
+
250
+
+
255 const T& operator()(const TileElementIndex& index) const noexcept {
+
256 return *ptr(index);
+
257 }
-
257
-
-
259 const T* ptr() const noexcept {
-
260 return data_.ptr();
-
261 }
+
258
+
+
260 const T* ptr() const noexcept {
+
261 return data_.ptr();
+
262 }
-
262
-
-
267 const T* ptr(const TileElementIndex& index) const noexcept {
-
268 return data_.ptr(index);
-
269 }
+
263
+
+
268 const T* ptr(const TileElementIndex& index) const noexcept {
+
269 return data_.ptr(index);
+
270 }
-
270
-
-
272 const TileElementSize& size() const noexcept {
-
273 return data_.size();
-
274 }
+
271
+
+
273 const TileElementSize& size() const noexcept {
+
274 return data_.size();
+
275 }
-
-
276 SizeType ld() const noexcept {
-
277 return data_.ld();
-
278 }
+
+
277 SizeType ld() const noexcept {
+
278 return data_.ld();
+
279 }
-
279
-
280 bool is_contiguous() const noexcept {
-
281 return data_.ld() == data_.size().rows();
-
282 }
-
283
-
-
286 Tile subTileReference(const SubTileSpec& spec) const noexcept {
-
287 return Tile(*this, spec);
-
288 }
+
280
+
281 bool is_contiguous() const noexcept {
+
282 return data_.ld() == data_.size().rows();
+
283 }
+
284
+
+
287 Tile subTileReference(const SubTileSpec& spec) const noexcept {
+
288 return Tile(*this, spec);
+
289 }
-
289
-
-
291 friend std::ostream& operator<<(std::ostream& out, const Tile& tile) {
-
292 return out << "size=" << tile.size() << ", ld=" << tile.ld();
-
293 }
+
290
+
+
292 friend std::ostream& operator<<(std::ostream& out, const Tile& tile) {
+
293 return out << "size=" << tile.size() << ", ld=" << tile.ld();
+
294 }
-
294
-
295private:
-
296 static memory::MemoryView<T, D> createMemoryViewForSubtile(const Tile<const T, D>& tile,
-
297 const SubTileSpec& spec) {
-
298 DLAF_ASSERT(spec.origin.isValid(), spec.origin);
-
299 DLAF_ASSERT(spec.origin.isInOrOn(tile.size()), spec.origin, tile.size());
-
300 DLAF_ASSERT(spec.size.isValid(), spec.size);
-
301 DLAF_ASSERT((spec.origin + spec.size).isInOrOn(tile.size()), spec.origin, spec.size, tile.size());
-
302
-
303 return memory::MemoryView<T, D>(tile.data_.memoryView(),
-
304 spec.size.isEmpty() ? 0 : tile.data_.linearIndex(spec.origin),
-
305 tile.data_.linearSize(spec.size, tile.ld()));
-
306 }
-
307
-
308 Tile(const TileElementSize& size, const memory::MemoryView<ElementType, D>& memory_view,
-
309 SizeType ld) noexcept
-
310 : data_(size, memory_view, ld) {}
-
311
-
312 // Creates an untracked subtile.
-
313 // Dependencies are not influenced by the new created object therefore race-conditions
-
314 // might happen if used improperly.
-
315 Tile(const Tile& tile, const SubTileSpec& spec) noexcept
-
316 : Tile(spec.size, Tile::createMemoryViewForSubtile(tile, spec), tile.ld()) {}
-
317
-
318 TileDataType data_{};
-
319 std::variant<
-
320 // No dependency
-
321 std::monostate,
-
322 // Read-only access
-
323 internal::TileAsyncRwMutexReadOnlyWrapper<T, D>,
-
324 // Read-write access
-
325 internal::TileAsyncRwMutexReadWriteWrapper<T, D>,
-
326 // Disjoint read-write access
-
327 std::shared_ptr<internal::TileAsyncRwMutexReadWriteWrapper<T, D>>>
-
328 dep_tracker_{};
-
329};
+
295
+
296private:
+
297 static memory::MemoryView<T, D> createMemoryViewForSubtile(const Tile<const T, D>& tile,
+
298 const SubTileSpec& spec) {
+
299 DLAF_ASSERT(spec.origin.isValid(), spec.origin);
+
300 DLAF_ASSERT(spec.origin.isInOrOn(tile.size()), spec.origin, tile.size());
+
301 DLAF_ASSERT(spec.size.isValid(), spec.size);
+
302 DLAF_ASSERT((spec.origin + spec.size).isInOrOn(tile.size()), spec.origin, spec.size, tile.size());
+
303
+
304 return memory::MemoryView<T, D>(tile.data_.memoryView(),
+
305 spec.size.isEmpty() ? 0 : tile.data_.linearIndex(spec.origin),
+
306 tile.data_.linearSize(spec.size, tile.ld()));
+
307 }
+
308
+
309 Tile(const TileElementSize& size, const memory::MemoryView<ElementType, D>& memory_view,
+
310 SizeType ld) noexcept
+
311 : data_(size, memory_view, ld) {}
+
312
+
313 // Creates an untracked subtile.
+
314 // Dependencies are not influenced by the new created object therefore race-conditions
+
315 // might happen if used improperly.
+
316 Tile(const Tile& tile, const SubTileSpec& spec) noexcept
+
317 : Tile(spec.size, Tile::createMemoryViewForSubtile(tile, spec), tile.ld()) {}
+
318
+
319 TileDataType data_{};
+
320 std::variant<
+
321 // No dependency
+
322 std::monostate,
+
323 // Read-only access
+
324 internal::TileAsyncRwMutexReadOnlyWrapper<T, D>,
+
325 // Read-write access
+
326 internal::TileAsyncRwMutexReadWriteWrapper<T, D>,
+
327 // Disjoint read-write access
+
328 std::shared_ptr<internal::TileAsyncRwMutexReadWriteWrapper<T, D>>>
+
329 dep_tracker_{};
+
330};
-
330
-
331template <class T, Device D>
-
-
332class Tile : public Tile<const T, D> {
-
333public:
-
334 using TileType = Tile<T, D>;
-
335 using ConstTileType = Tile<const T, D>;
-
336 using TileDataType = internal::TileData<T, D>;
-
337
-
338 friend ConstTileType;
-
339 friend Tile<T, D> internal::createSubTileAsyncRwMutex<>(
-
340 internal::TileAsyncRwMutexReadOnlyWrapper<T, D> tile_wrapper, const SubTileSpec& spec);
-
341 friend Tile<T, D> internal::createTileAsyncRwMutex<>(
-
342 internal::TileAsyncRwMutexReadWriteWrapper<T, D> tile_wrapper);
-
343 friend Tile<T, D> internal::createSubTileAsyncRwMutex<>(
-
344 internal::TileAsyncRwMutexReadWriteWrapper<T, D> tile_wrapper, const SubTileSpec& spec);
-
345 friend Tile<T, D> internal::createSubTileAsyncRwMutex<>(Tile<T, D> tile, const SubTileSpec& spec);
-
346 friend Tile<T, D> internal::prepareDisjointTile<>(Tile<T, D>&& tile);
-
347 friend Tile<T, D> internal::createDisjointSubTile<>(const Tile<T, D>& tile, const SubTileSpec& spec);
-
348
-
349 using ElementType = T;
-
350
-
352 Tile() = default;
-
353
-
-
360 Tile(const TileElementSize& size, memory::MemoryView<ElementType, D>&& memory_view,
-
361 SizeType ld) noexcept
-
362 : Tile<const T, D>(size, std::move(memory_view), ld) {}
+
331
+
332template <class T, Device D>
+
+
333class Tile : public Tile<const T, D> {
+
334public:
+
335 using TileType = Tile<T, D>;
+
336 using ConstTileType = Tile<const T, D>;
+
337 using TileDataType = internal::TileData<T, D>;
+
338
+
339 friend ConstTileType;
+
340 friend Tile<T, D> internal::createSubTileAsyncRwMutex<>(
+
341 internal::TileAsyncRwMutexReadOnlyWrapper<T, D> tile_wrapper, const SubTileSpec& spec);
+
342 friend Tile<T, D> internal::createTileAsyncRwMutex<>(
+
343 internal::TileAsyncRwMutexReadWriteWrapper<T, D> tile_wrapper);
+
344 friend Tile<T, D> internal::createSubTileAsyncRwMutex<>(
+
345 internal::TileAsyncRwMutexReadWriteWrapper<T, D> tile_wrapper, const SubTileSpec& spec);
+
346 friend Tile<T, D> internal::createSubTileAsyncRwMutex<>(Tile<T, D> tile, const SubTileSpec& spec);
+
347 friend Tile<T, D> internal::prepareDisjointTile<>(Tile<T, D>&& tile);
+
348 friend Tile<T, D> internal::createDisjointSubTile<>(const Tile<T, D>& tile, const SubTileSpec& spec);
+
349
+
350 using ElementType = T;
+
351
+
353 Tile() = default;
+
354
+
+
361 Tile(const TileElementSize& size, memory::MemoryView<ElementType, D>&& memory_view,
+
362 SizeType ld) noexcept
+
363 : Tile<const T, D>(size, std::move(memory_view), ld) {}
-
363
-
364 Tile(TileDataType&& data) noexcept : ConstTileType(std::move(data)) {}
-
365
-
366 Tile(const Tile&) = delete;
-
367 Tile(Tile&& rhs) = default;
-
368
-
369 Tile& operator=(const Tile&) = delete;
-
370 Tile& operator=(Tile&&) = default;
-
371
-
-
376 T& operator()(const TileElementIndex& index) const noexcept {
-
377 return *ptr(index);
-
378 }
+
364
+
365 Tile(TileDataType&& data) noexcept : ConstTileType(std::move(data)) {}
+
366
+
367 Tile(const Tile&) = delete;
+
368 Tile(Tile&& rhs) = default;
+
369
+
370 Tile& operator=(const Tile&) = delete;
+
371 Tile& operator=(Tile&&) = default;
+
372
+
+
377 T& operator()(const TileElementIndex& index) const noexcept {
+
378 return *ptr(index);
+
379 }
-
379
-
-
381 T* ptr() const noexcept {
-
382 return data_.ptr();
-
383 }
+
380
+
+
382 T* ptr() const noexcept {
+
383 return data_.ptr();
+
384 }
-
384
-
-
389 T* ptr(const TileElementIndex& index) const noexcept {
-
390 return data_.ptr(index);
-
391 }
+
385
+
+
390 T* ptr(const TileElementIndex& index) const noexcept {
+
391 return data_.ptr(index);
+
392 }
-
392
-
-
395 Tile subTileReference(const SubTileSpec& spec) const noexcept {
-
396 return Tile(*this, spec);
-
397 }
+
393
+
+
396 Tile subTileReference(const SubTileSpec& spec) const noexcept {
+
397 return Tile(*this, spec);
+
398 }
-
398
-
399private:
-
400 Tile(const Tile& tile, const SubTileSpec& spec) noexcept : Tile<const T, D>(tile, spec) {}
-
401
-
402 Tile(internal::TileAsyncRwMutexReadOnlyWrapper<T, D> tile_wrapper, const SubTileSpec& spec)
-
403 : Tile<const T, D>(tile_wrapper.get(), spec) {
-
404 dep_tracker_ = std::move(tile_wrapper);
-
405 }
-
406
-
407 Tile(internal::TileAsyncRwMutexReadWriteWrapper<T, D> tile_wrapper)
-
408 : ConstTileType(tile_wrapper.get().size(), tile_wrapper.get().data_.memoryView(),
-
409 tile_wrapper.get().ld()) {
-
410 dep_tracker_ = std::move(tile_wrapper);
-
411 }
-
412
-
413 Tile(internal::TileAsyncRwMutexReadWriteWrapper<T, D> tile_wrapper, const SubTileSpec& spec)
-
414 : ConstTileType(tile_wrapper.get(), spec) {
-
415 dep_tracker_ = std::move(tile_wrapper);
-
416 }
-
417
-
418 Tile(Tile&& tile, const SubTileSpec& spec) : ConstTileType(tile, spec) {
-
419 dep_tracker_ = std::move(tile.dep_tracker_);
-
420 }
-
421
-
422 void prepareDisjointTile() {
-
423 // We only expect read-write tiles for disjoint access. That means that the
-
424 // dependency tracker holds anything but a read-only wrapper.
-
425 DLAF_ASSERT((!std::holds_alternative<internal::TileAsyncRwMutexReadOnlyWrapper<T, D>>(dep_tracker_)),
-
426 "");
-
427
-
428 // If a tile is untracked (std::monostate), or already a disjoint subtile
-
429 // (std::shared_ptr<internal::TileAsyncRwMutexReadWriteWrapper<T, D>) we don't do
-
430 // anything. If a tile is in read-write mode we upgrade it to allow shared,
-
431 // but disjoint, access.
-
432 if (std::holds_alternative<internal::TileAsyncRwMutexReadWriteWrapper<T, D>>(dep_tracker_)) {
-
433 dep_tracker_ = std::make_shared<internal::TileAsyncRwMutexReadWriteWrapper<T, D>>(
-
434 std::get<internal::TileAsyncRwMutexReadWriteWrapper<T, D>>(std::move(dep_tracker_)));
-
435 }
-
436 }
-
437
-
438 Tile createDisjointSubTile(const SubTileSpec& spec) const& {
-
439 // We only expect read-write tiles for disjoint access. They should be
-
440 // either untracked or disjoint tracked read-write access.
-
441 DLAF_ASSERT((!std::holds_alternative<internal::TileAsyncRwMutexReadOnlyWrapper<T, D>>(dep_tracker_)),
-
442 "");
-
443 DLAF_ASSERT(
-
444 (!std::holds_alternative<internal::TileAsyncRwMutexReadWriteWrapper<T, D>>(dep_tracker_)), "");
-
445
-
446 Tile subtile(spec.size, ConstTileType::createMemoryViewForSubtile(*this, spec), this->ld());
-
447 // Not all possible states of the dependency tracker are copyable. This
-
448 // means that we can't copy the variant as a whole, but only copy the states
-
449 // that are copyable, if they are active.
-
450 if (std::holds_alternative<std::shared_ptr<internal::TileAsyncRwMutexReadWriteWrapper<T, D>>>(
-
451 dep_tracker_)) {
-
452 subtile.dep_tracker_ =
-
453 std::get<std::shared_ptr<internal::TileAsyncRwMutexReadWriteWrapper<T, D>>>(dep_tracker_);
-
454 }
-
455
-
456 return subtile;
-
457 }
-
458
-
459 using ConstTileType::data_;
-
460 using ConstTileType::dep_tracker_;
-
461};
+
399
+
400private:
+
401 Tile(const Tile& tile, const SubTileSpec& spec) noexcept : Tile<const T, D>(tile, spec) {}
+
402
+
403 Tile(internal::TileAsyncRwMutexReadOnlyWrapper<T, D> tile_wrapper, const SubTileSpec& spec)
+
404 : Tile<const T, D>(tile_wrapper.get(), spec) {
+
405 dep_tracker_ = std::move(tile_wrapper);
+
406 }
+
407
+
408 Tile(internal::TileAsyncRwMutexReadWriteWrapper<T, D> tile_wrapper)
+
409 : ConstTileType(tile_wrapper.get().size(), tile_wrapper.get().data_.memoryView(),
+
410 tile_wrapper.get().ld()) {
+
411 dep_tracker_ = std::move(tile_wrapper);
+
412 }
+
413
+
414 Tile(internal::TileAsyncRwMutexReadWriteWrapper<T, D> tile_wrapper, const SubTileSpec& spec)
+
415 : ConstTileType(tile_wrapper.get(), spec) {
+
416 dep_tracker_ = std::move(tile_wrapper);
+
417 }
+
418
+
419 Tile(Tile&& tile, const SubTileSpec& spec) : ConstTileType(tile, spec) {
+
420 dep_tracker_ = std::move(tile.dep_tracker_);
+
421 }
+
422
+
423 void prepareDisjointTile() {
+
424 // We only expect read-write tiles for disjoint access. That means that the
+
425 // dependency tracker holds anything but a read-only wrapper.
+
426 DLAF_ASSERT((!std::holds_alternative<internal::TileAsyncRwMutexReadOnlyWrapper<T, D>>(dep_tracker_)),
+
427 "");
+
428
+
429 // If a tile is untracked (std::monostate), or already a disjoint subtile
+
430 // (std::shared_ptr<internal::TileAsyncRwMutexReadWriteWrapper<T, D>) we don't do
+
431 // anything. If a tile is in read-write mode we upgrade it to allow shared,
+
432 // but disjoint, access.
+
433 if (std::holds_alternative<internal::TileAsyncRwMutexReadWriteWrapper<T, D>>(dep_tracker_)) {
+
434 dep_tracker_ = std::make_shared<internal::TileAsyncRwMutexReadWriteWrapper<T, D>>(
+
435 std::get<internal::TileAsyncRwMutexReadWriteWrapper<T, D>>(std::move(dep_tracker_)));
+
436 }
+
437 }
+
438
+
439 Tile createDisjointSubTile(const SubTileSpec& spec) const& {
+
440 // We only expect read-write tiles for disjoint access. They should be
+
441 // either untracked or disjoint tracked read-write access.
+
442 DLAF_ASSERT((!std::holds_alternative<internal::TileAsyncRwMutexReadOnlyWrapper<T, D>>(dep_tracker_)),
+
443 "");
+
444 DLAF_ASSERT(
+
445 (!std::holds_alternative<internal::TileAsyncRwMutexReadWriteWrapper<T, D>>(dep_tracker_)), "");
+
446
+
447 Tile subtile(spec.size, ConstTileType::createMemoryViewForSubtile(*this, spec), this->ld());
+
448 // Not all possible states of the dependency tracker are copyable. This
+
449 // means that we can't copy the variant as a whole, but only copy the states
+
450 // that are copyable, if they are active.
+
451 if (std::holds_alternative<std::shared_ptr<internal::TileAsyncRwMutexReadWriteWrapper<T, D>>>(
+
452 dep_tracker_)) {
+
453 subtile.dep_tracker_ =
+
454 std::get<std::shared_ptr<internal::TileAsyncRwMutexReadWriteWrapper<T, D>>>(dep_tracker_);
+
455 }
+
456
+
457 return subtile;
+
458 }
+
459
+
460 using ConstTileType::data_;
+
461 using ConstTileType::dep_tracker_;
+
462};
-
462
-
464template <class T, Device D>
-
-
465auto create_data(const Tile<T, D>& tile) {
-
466 return common::DataDescriptor<T>(tile.ptr({0, 0}), tile.size().cols(), tile.size().rows(), tile.ld());
-
467}
+
463
+
465template <class T, Device D>
+
+
466auto create_data(const Tile<T, D>& tile) {
+
467 return common::DataDescriptor<T>(tile.ptr({0, 0}), tile.size().cols(), tile.size().rows(), tile.ld());
+
468}
-
468
-
469namespace internal {
-
470template <class T, Device D>
-
471Tile<T, D> createSubTileAsyncRwMutex(internal::TileAsyncRwMutexReadOnlyWrapper<T, D> tile_wrapper,
-
472 const SubTileSpec& spec) {
-
473 return {std::move(tile_wrapper), spec};
-
474}
-
475
-
476template <class T, Device D>
-
477Tile<T, D> createTileAsyncRwMutex(internal::TileAsyncRwMutexReadWriteWrapper<T, D> tile_wrapper) {
-
478 return {std::move(tile_wrapper)};
-
479}
-
480
-
481template <class T, Device D>
-
482Tile<T, D> createSubTileAsyncRwMutex(internal::TileAsyncRwMutexReadWriteWrapper<T, D> tile_wrapper,
-
483 const SubTileSpec& spec) {
-
484 return {std::move(tile_wrapper), spec};
-
485}
-
486
-
487template <class T, Device D>
-
488Tile<T, D> createSubTileAsyncRwMutex(Tile<T, D> tile, const SubTileSpec& spec) {
-
489 return {std::move(tile), spec};
-
490}
-
491
-
492template <class T, Device D>
-
493Tile<T, D> prepareDisjointTile(Tile<T, D>&& tile) {
-
494 tile.prepareDisjointTile();
-
495 return std::move(tile);
-
496}
-
497
-
498template <class T, Device D>
-
499Tile<T, D> createDisjointSubTile(const Tile<T, D>& tile, const SubTileSpec& spec) {
-
500 return tile.createDisjointSubTile(spec);
-
501}
+
469
+
470namespace internal {
+
471template <class T, Device D>
+
472Tile<T, D> createSubTileAsyncRwMutex(internal::TileAsyncRwMutexReadOnlyWrapper<T, D> tile_wrapper,
+
473 const SubTileSpec& spec) {
+
474 return {std::move(tile_wrapper), spec};
+
475}
+
476
+
477template <class T, Device D>
+
478Tile<T, D> createTileAsyncRwMutex(internal::TileAsyncRwMutexReadWriteWrapper<T, D> tile_wrapper) {
+
479 return {std::move(tile_wrapper)};
+
480}
+
481
+
482template <class T, Device D>
+
483Tile<T, D> createSubTileAsyncRwMutex(internal::TileAsyncRwMutexReadWriteWrapper<T, D> tile_wrapper,
+
484 const SubTileSpec& spec) {
+
485 return {std::move(tile_wrapper), spec};
+
486}
+
487
+
488template <class T, Device D>
+
489Tile<T, D> createSubTileAsyncRwMutex(Tile<T, D> tile, const SubTileSpec& spec) {
+
490 return {std::move(tile), spec};
+
491}
+
492
+
493template <class T, Device D>
+
494Tile<T, D> prepareDisjointTile(Tile<T, D>&& tile) {
+
495 tile.prepareDisjointTile();
+
496 return std::move(tile);
+
497}
+
498
+
499template <class T, Device D>
+
500Tile<T, D> createDisjointSubTile(const Tile<T, D>& tile, const SubTileSpec& spec) {
+
501 return tile.createDisjointSubTile(spec);
502}
-
503
-
509template <class T, Device D>
-
-
510ReadOnlyTileSender<T, D> splitTile(ReadOnlyTileSender<T, D> tile, const SubTileSpec& spec) {
-
511 return std::move(tile) |
-
512 pika::execution::experimental::let_value(
-
513 [spec](internal::TileAsyncRwMutexReadOnlyWrapper<T, D>& tile_wrapper) {
-
514 internal::TileAsyncRwMutex<T, D> tile_manager{
-
515 internal::createSubTileAsyncRwMutex<T, D>(std::move(tile_wrapper), spec)};
-
516 return tile_manager.read();
-
517 }) |
-
518 pika::execution::experimental::split();
-
519}
+
503}
+
504
+
510template <class T, Device D>
+
+
511ReadOnlyTileSender<T, D> splitTile(ReadOnlyTileSender<T, D> tile, const SubTileSpec& spec) {
+
512 return std::move(tile) |
+
513 pika::execution::experimental::let_value(
+
514 [spec](internal::TileAsyncRwMutexReadOnlyWrapper<T, D>& tile_wrapper) {
+
515 internal::TileAsyncRwMutex<T, D> tile_manager{
+
516 internal::createSubTileAsyncRwMutex<T, D>(std::move(tile_wrapper), spec)};
+
517 return tile_manager.read();
+
518 }) |
+
519 pika::execution::experimental::split();
+
520}
-
520
-
526template <class T, Device D>
-
-
527ReadOnlyTileSender<T, D> shareReadWriteTile(ReadWriteTileSender<T, D>&& tile) {
-
528 return std::move(tile) | pika::execution::experimental::let_value([](Tile<T, D>& tile) {
-
529 internal::TileAsyncRwMutex<T, D> tile_manager{std::move(tile)};
-
530 return tile_manager.read();
-
531 }) |
-
532 pika::execution::experimental::split();
-
533}
+
521
+
527template <class T, Device D>
+
+
528ReadOnlyTileSender<T, D> shareReadWriteTile(ReadWriteTileSender<T, D>&& tile) {
+
529 return std::move(tile) | pika::execution::experimental::let_value([](Tile<T, D>& tile) {
+
530 internal::TileAsyncRwMutex<T, D> tile_manager{std::move(tile)};
+
531 return tile_manager.read();
+
532 }) |
+
533 pika::execution::experimental::split();
+
534}
-
534
-
540template <class T, Device D>
-
-
541std::vector<ReadOnlyTileSender<T, D>> splitTile(ReadOnlyTileSender<T, D> tile,
-
542 const std::vector<SubTileSpec>& specs) {
-
543 std::vector<ReadOnlyTileSender<T, D>> senders;
-
544 senders.reserve(specs.size());
-
545
-
546 for (const auto& spec : specs) {
-
547 senders.push_back(splitTile(tile, spec));
-
548 }
-
549
-
550 return senders;
-
551}
+
535
+
541template <class T, Device D>
+
+
542std::vector<ReadOnlyTileSender<T, D>> splitTile(ReadOnlyTileSender<T, D> tile,
+
543 const std::vector<SubTileSpec>& specs) {
+
544 std::vector<ReadOnlyTileSender<T, D>> senders;
+
545 senders.reserve(specs.size());
+
546
+
547 for (const auto& spec : specs) {
+
548 senders.push_back(splitTile(tile, spec));
+
549 }
+
550
+
551 return senders;
+
552}
-
552
-
558template <class T, Device D>
-
-
559ReadWriteTileSender<T, D> splitTile(ReadWriteTileSender<T, D>&& tile, const SubTileSpec& spec) {
-
560 return std::move(tile) | pika::execution::experimental::then([spec](Tile<T, D> tile) {
-
561 return internal::createSubTileAsyncRwMutex<T, D>(std::move(tile), spec);
-
562 });
-
563}
+
553
+
559template <class T, Device D>
+
+
560ReadWriteTileSender<T, D> splitTile(ReadWriteTileSender<T, D>&& tile, const SubTileSpec& spec) {
+
561 return std::move(tile) | pika::execution::experimental::then([spec](Tile<T, D> tile) {
+
562 return internal::createSubTileAsyncRwMutex<T, D>(std::move(tile), spec);
+
563 });
+
564}
-
564
-
572template <class T, Device D>
-
-
573std::vector<ReadWriteTileSender<T, D>> splitTileDisjoint(ReadWriteTileSender<T, D>&& tile,
-
574 const std::vector<SubTileSpec>& specs) {
-
575 // If there are no specs we still consume the tile by starting it.
-
576 if (specs.empty()) {
-
577 pika::execution::experimental::start_detached(std::move(tile));
-
578 return {};
-
579 }
-
580
-
581 // If there is only one spec we can avoid calling execution::split on the
-
582 // input tile (and thus avoid a heap allocation) and directly call the
-
583 // single-spec splitTile instead.
-
584 if (specs.size() == 1) {
-
585 auto subtiles = std::vector<ReadWriteTileSender<T, D>>();
-
586 subtiles.push_back(splitTile(std::move(tile), specs[0]));
-
587 return subtiles;
-
588 }
-
589
-
590#ifdef DLAF_ASSERT_MODERATE_ENABLE
-
591 for (auto it1 = specs.cbegin(); it1 < specs.cend(); ++it1) {
-
592 for (auto it2 = specs.cbegin(); it2 < it1; ++it2) {
-
593 DLAF_ASSERT_MODERATE(!internal::subTileSpecsOverlap(*it1, *it2), it1->origin, it1->size,
-
594 it2->origin, it2->size);
-
595 }
-
596 }
-
597#endif
-
598
-
599 std::vector<ReadWriteTileSender<T, D>> senders;
-
600 senders.reserve(specs.size());
-
601
-
602 // We first need mutable access to extract a dependency manager, if one exists
-
603 auto prepared_tile = std::move(tile) |
-
604 pika::execution::experimental::then(&internal::prepareDisjointTile<T, D>) |
-
605 pika::execution::experimental::split();
-
606
-
607 for (const auto& spec : specs) {
-
608 // Once the tile has been prepared for disjoint access, we can then actually
-
609 // extract the subtiles
-
610 auto disjoint_tile =
-
611 prepared_tile | pika::execution::experimental::then([spec](const Tile<T, D>& tile) {
-
612 return internal::createDisjointSubTile(tile, spec);
-
613 });
-
614 senders.push_back(std::move(disjoint_tile));
-
615 }
-
616
-
617 return senders;
-
618}
+
565
+
573template <class T, Device D>
+
+
574std::vector<ReadWriteTileSender<T, D>> splitTileDisjoint(ReadWriteTileSender<T, D>&& tile,
+
575 const std::vector<SubTileSpec>& specs) {
+
576 // If there are no specs we still consume the tile by starting it.
+
577 if (specs.empty()) {
+
578 pika::execution::experimental::start_detached(std::move(tile));
+
579 return {};
+
580 }
+
581
+
582 // If there is only one spec we can avoid calling execution::split on the
+
583 // input tile (and thus avoid a heap allocation) and directly call the
+
584 // single-spec splitTile instead.
+
585 if (specs.size() == 1) {
+
586 auto subtiles = std::vector<ReadWriteTileSender<T, D>>();
+
587 subtiles.push_back(splitTile(std::move(tile), specs[0]));
+
588 return subtiles;
+
589 }
+
590
+
591#ifdef DLAF_ASSERT_MODERATE_ENABLE
+
592 for (auto it1 = specs.cbegin(); it1 < specs.cend(); ++it1) {
+
593 for (auto it2 = specs.cbegin(); it2 < it1; ++it2) {
+
594 DLAF_ASSERT_MODERATE(!internal::subTileSpecsOverlap(*it1, *it2), it1->origin, it1->size,
+
595 it2->origin, it2->size);
+
596 }
+
597 }
+
598#endif
+
599
+
600 std::vector<ReadWriteTileSender<T, D>> senders;
+
601 senders.reserve(specs.size());
+
602
+
603 // We first need mutable access to extract a dependency manager, if one exists
+
604 auto prepared_tile = std::move(tile) |
+
605 pika::execution::experimental::then(&internal::prepareDisjointTile<T, D>) |
+
606 pika::execution::experimental::split();
+
607
+
608 for (const auto& spec : specs) {
+
609 // Once the tile has been prepared for disjoint access, we can then actually
+
610 // extract the subtiles
+
611 auto disjoint_tile =
+
612 prepared_tile | pika::execution::experimental::then([spec](const Tile<T, D>& tile) {
+
613 return internal::createDisjointSubTile(tile, spec);
+
614 });
+
615 senders.push_back(std::move(disjoint_tile));
+
616 }
+
617
+
618 return senders;
+
619}
-
619
-
620// ETI
-
621
-
622#define DLAF_TILE_ETI(KWORD, DATATYPE, DEVICE) \
-
623 KWORD template class Tile<DATATYPE, DEVICE>; \
-
624 KWORD template class Tile<const DATATYPE, DEVICE>;
-
625
-
626DLAF_TILE_ETI(extern, float, Device::CPU)
-
627DLAF_TILE_ETI(extern, double, Device::CPU)
-
628DLAF_TILE_ETI(extern, std::complex<float>, Device::CPU)
-
629DLAF_TILE_ETI(extern, std::complex<double>, Device::CPU)
-
630
-
631#if defined(DLAF_WITH_GPU)
-
632DLAF_TILE_ETI(extern, float, Device::GPU)
-
633DLAF_TILE_ETI(extern, double, Device::GPU)
-
634DLAF_TILE_ETI(extern, std::complex<float>, Device::GPU)
-
635DLAF_TILE_ETI(extern, std::complex<double>, Device::GPU)
-
636#endif
-
637}
+
620
+
621// ETI
+
622
+
623#define DLAF_TILE_ETI(KWORD, DATATYPE, DEVICE) \
+
624 KWORD template class Tile<DATATYPE, DEVICE>; \
+
625 KWORD template class Tile<const DATATYPE, DEVICE>;
+
626
+
627DLAF_TILE_ETI(extern, float, Device::CPU)
+
628DLAF_TILE_ETI(extern, double, Device::CPU)
+
629DLAF_TILE_ETI(extern, std::complex<float>, Device::CPU)
+
630DLAF_TILE_ETI(extern, std::complex<double>, Device::CPU)
+
631
+
632#if defined(DLAF_WITH_GPU)
+
633DLAF_TILE_ETI(extern, float, Device::GPU)
+
634DLAF_TILE_ETI(extern, double, Device::GPU)
+
635DLAF_TILE_ETI(extern, std::complex<float>, Device::GPU)
+
636DLAF_TILE_ETI(extern, std::complex<double>, Device::GPU)
+
637#endif
+
638}
dlaf::common::Index2D::isIn
bool isIn(const Size2D< IndexT, Tag > &boundary) const noexcept
Definition index2d.h:214
dlaf::common::Size2D::isEmpty
bool isEmpty() const noexcept
Definition index2d.h:160
dlaf::common::internal::basic_coords::isValid
bool isValid() const noexcept
Definition index2d.h:102
-
dlaf::matrix::Matrix
Definition matrix.h:61
- +
dlaf::matrix::Matrix
Definition matrix.h:62
+
dlaf::matrix::Tile< const T, D >::Tile
Tile()=default
Constructs an empty Tile.
-
dlaf::matrix::Tile< const T, D >::ld
SizeType ld() const noexcept
Returns the leading dimension.
Definition tile.h:276
-
dlaf::matrix::Tile< const T, D >::subTileReference
Tile subTileReference(const SubTileSpec &spec) const noexcept
Definition tile.h:286
+
dlaf::matrix::Tile< const T, D >::ld
SizeType ld() const noexcept
Returns the leading dimension.
Definition tile.h:277
+
dlaf::matrix::Tile< const T, D >::subTileReference
Tile subTileReference(const SubTileSpec &spec) const noexcept
Definition tile.h:287
-
dlaf::matrix::Tile< const T, D >::Tile
Tile(const TileElementSize &size, memory::MemoryView< ElementType, D > &&memory_view, SizeType ld) noexcept
Definition tile.h:223
-
dlaf::matrix::Tile< const T, D >::operator()
const T & operator()(const TileElementIndex &index) const noexcept
Definition tile.h:254
-
dlaf::matrix::Tile< const T, D >::ptr
const T * ptr(const TileElementIndex &index) const noexcept
Definition tile.h:267
-
dlaf::matrix::Tile< const T, D >::size
const TileElementSize & size() const noexcept
Returns the size of the Tile.
Definition tile.h:272
-
dlaf::matrix::Tile< const T, D >::ptr
const T * ptr() const noexcept
Returns the base pointer.
Definition tile.h:259
-
dlaf::matrix::Tile< const T, D >::operator<<
friend std::ostream & operator<<(std::ostream &out, const Tile &tile)
Prints information about the tile.
Definition tile.h:291
-
dlaf::matrix::Tile
Definition tile.h:332
-
dlaf::matrix::Tile::operator()
T & operator()(const TileElementIndex &index) const noexcept
Definition tile.h:376
-
dlaf::matrix::Tile::Tile
Tile(const TileElementSize &size, memory::MemoryView< ElementType, D > &&memory_view, SizeType ld) noexcept
Definition tile.h:360
-
dlaf::matrix::Tile::subTileReference
Tile subTileReference(const SubTileSpec &spec) const noexcept
Definition tile.h:395
-
dlaf::matrix::Tile::ptr
T * ptr(const TileElementIndex &index) const noexcept
Definition tile.h:389
-
dlaf::matrix::Tile::ptr
T * ptr() const noexcept
Returns the base pointer.
Definition tile.h:381
+
dlaf::matrix::Tile< const T, D >::Tile
Tile(const TileElementSize &size, memory::MemoryView< ElementType, D > &&memory_view, SizeType ld) noexcept
Definition tile.h:224
+
dlaf::matrix::Tile< const T, D >::operator()
const T & operator()(const TileElementIndex &index) const noexcept
Definition tile.h:255
+
dlaf::matrix::Tile< const T, D >::ptr
const T * ptr(const TileElementIndex &index) const noexcept
Definition tile.h:268
+
dlaf::matrix::Tile< const T, D >::size
const TileElementSize & size() const noexcept
Returns the size of the Tile.
Definition tile.h:273
+
dlaf::matrix::Tile< const T, D >::ptr
const T * ptr() const noexcept
Returns the base pointer.
Definition tile.h:260
+
dlaf::matrix::Tile< const T, D >::operator<<
friend std::ostream & operator<<(std::ostream &out, const Tile &tile)
Prints information about the tile.
Definition tile.h:292
+
dlaf::matrix::Tile
Definition tile.h:333
+
dlaf::matrix::Tile::operator()
T & operator()(const TileElementIndex &index) const noexcept
Definition tile.h:377
+
dlaf::matrix::Tile::Tile
Tile(const TileElementSize &size, memory::MemoryView< ElementType, D > &&memory_view, SizeType ld) noexcept
Definition tile.h:361
+
dlaf::matrix::Tile::subTileReference
Tile subTileReference(const SubTileSpec &spec) const noexcept
Definition tile.h:396
+
dlaf::matrix::Tile::ptr
T * ptr(const TileElementIndex &index) const noexcept
Definition tile.h:390
+
dlaf::matrix::Tile::ptr
T * ptr() const noexcept
Returns the base pointer.
Definition tile.h:382
dlaf::matrix::Tile::Tile
Tile()=default
Constructs an empty Tile.
- -
dlaf::memory::MemoryView
Definition memory_view.h:32
+ +
dlaf::memory::MemoryView
Definition memory_view.h:33
data_descriptor.h
-
dlaf::matrix::splitTile
ReadOnlyTileSender< T, D > splitTile(ReadOnlyTileSender< T, D > tile, const SubTileSpec &spec)
Definition tile.h:510
-
dlaf::matrix::splitTileDisjoint
std::vector< ReadWriteTileSender< T, D > > splitTileDisjoint(ReadWriteTileSender< T, D > &&tile, const std::vector< SubTileSpec > &specs)
Definition tile.h:573
-
dlaf::matrix::shareReadWriteTile
ReadOnlyTileSender< T, D > shareReadWriteTile(ReadWriteTileSender< T, D > &&tile)
Definition tile.h:527
+
dlaf::matrix::splitTile
ReadOnlyTileSender< T, D > splitTile(ReadOnlyTileSender< T, D > tile, const SubTileSpec &spec)
Definition tile.h:511
+
dlaf::matrix::splitTileDisjoint
std::vector< ReadWriteTileSender< T, D > > splitTileDisjoint(ReadWriteTileSender< T, D > &&tile, const std::vector< SubTileSpec > &specs)
Definition tile.h:574
+
dlaf::matrix::shareReadWriteTile
ReadOnlyTileSender< T, D > shareReadWriteTile(ReadWriteTileSender< T, D > &&tile)
Definition tile.h:528
memory_view.h
dlaf::common::DataDescriptor
Definition data_descriptor.h:35
-
dlaf::matrix::SubTileSpec
Contains the information to create a subtile.
Definition tile.h:112
+
dlaf::matrix::SubTileSpec
Contains the information to create a subtile.
Definition tile.h:113
util_math.h
diff --git a/master/matrix_8h.html b/master/matrix_8h.html index bb95460b45..f932616c87 100644 --- a/master/matrix_8h.html +++ b/master/matrix_8h.html @@ -80,7 +80,8 @@
matrix.h File Reference
-
#include <cstddef>
+
#include <complex>
+#include <cstddef>
#include <exception>
#include <utility>
#include <vector>
diff --git a/master/matrix_8h_source.html b/master/matrix_8h_source.html index 4578c07771..8d59f11b14 100644 --- a/master/matrix_8h_source.html +++ b/master/matrix_8h_source.html @@ -94,424 +94,425 @@
11#pragma once
12
14
-
15#include <cstddef>
-
16#include <exception>
-
17#include <utility>
-
18#include <vector>
-
19
-
20#include <pika/execution.hpp>
-
21
-
22#include <dlaf/common/range2d.h>
-
23#include <dlaf/common/vector.h>
-
24#include <dlaf/communication/communicator_grid.h>
-
25#include <dlaf/matrix/distribution.h>
-
26#include <dlaf/matrix/internal/tile_pipeline.h>
-
27#include <dlaf/matrix/layout_info.h>
-
28#include <dlaf/matrix/matrix_base.h>
-
29#include <dlaf/matrix/tile.h>
-
30#include <dlaf/types.h>
-
31
-
32namespace dlaf {
-
33namespace matrix {
-
34
-
35namespace internal {
-
36
-
37template <class T, Device D>
-
38class MatrixRef;
-
39
-
43template <class Func>
-
-
44auto selectGeneric(Func&& f, common::IterableRange2D<SizeType, LocalTile_TAG> range) {
-
45 using RetT = decltype(f(LocalTileIndex{}));
-
46
-
47 std::vector<RetT> tiles;
-
48 tiles.reserve(to_sizet(std::distance(range.begin(), range.end())));
-
49 std::transform(range.begin(), range.end(), std::back_inserter(tiles),
-
50 [&](auto idx) { return f(idx); });
-
51 return tiles;
-
52}
-
+
15#include <complex>
+
16#include <cstddef>
+
17#include <exception>
+
18#include <utility>
+
19#include <vector>
+
20
+
21#include <pika/execution.hpp>
+
22
+
23#include <dlaf/common/range2d.h>
+
24#include <dlaf/common/vector.h>
+
25#include <dlaf/communication/communicator_grid.h>
+
26#include <dlaf/matrix/distribution.h>
+
27#include <dlaf/matrix/internal/tile_pipeline.h>
+
28#include <dlaf/matrix/layout_info.h>
+
29#include <dlaf/matrix/matrix_base.h>
+
30#include <dlaf/matrix/tile.h>
+
31#include <dlaf/types.h>
+
32
+
33namespace dlaf {
+
34namespace matrix {
+
35
+
36namespace internal {
+
37
+
38template <class T, Device D>
+
39class MatrixRef;
+
40
+
44template <class Func>
+
+
45auto selectGeneric(Func&& f, common::IterableRange2D<SizeType, LocalTile_TAG> range) {
+
46 using RetT = decltype(f(LocalTileIndex{}));
+
47
+
48 std::vector<RetT> tiles;
+
49 tiles.reserve(to_sizet(std::distance(range.begin(), range.end())));
+
50 std::transform(range.begin(), range.end(), std::back_inserter(tiles),
+
51 [&](auto idx) { return f(idx); });
+
52 return tiles;
53}
-
54
-
60template <class T, Device D>
-
-
61class Matrix : public Matrix<const T, D> {
-
62public:
-
63 static constexpr Device device = D;
-
64
-
65 using ElementType = T;
-
66 using TileType = Tile<ElementType, D>;
-
67 using ConstTileType = Tile<const ElementType, D>;
-
68 using TileDataType = internal::TileData<const ElementType, D>;
-
69 using ReadWriteSenderType = ReadWriteTileSender<ElementType, D>;
-
70 friend Matrix<const ElementType, D>;
-
71 friend internal::MatrixRef<ElementType, D>;
-
72
-
-
77 Matrix(const LocalElementSize& size, const TileElementSize& tile_size)
-
78 : Matrix<T, D>(Distribution(size, tile_size)) {}
-
79
-
-
85 Matrix(const GlobalElementSize& size, const TileElementSize& tile_size,
-
86 const comm::CommunicatorGrid& comm)
-
87 : Matrix<T, D>(Distribution(size, tile_size, comm.size(), comm.rank(), {0, 0})) {}
+
54}
+
55
+
61template <class T, Device D>
+
+
62class Matrix : public Matrix<const T, D> {
+
63public:
+
64 static constexpr Device device = D;
+
65
+
66 using ElementType = T;
+
67 using TileType = Tile<ElementType, D>;
+
68 using ConstTileType = Tile<const ElementType, D>;
+
69 using TileDataType = internal::TileData<const ElementType, D>;
+
70 using ReadWriteSenderType = ReadWriteTileSender<ElementType, D>;
+
71 friend Matrix<const ElementType, D>;
+
72 friend internal::MatrixRef<ElementType, D>;
+
73
+
+
78 Matrix(const LocalElementSize& size, const TileElementSize& tile_size)
+
79 : Matrix<T, D>(Distribution(size, tile_size)) {}
+
+
80
+
+
86 Matrix(const GlobalElementSize& size, const TileElementSize& tile_size,
+
87 const comm::CommunicatorGrid& comm)
+
88 : Matrix<T, D>(Distribution(size, tile_size, comm.size(), comm.rank(), {0, 0})) {}
-
88
-
-
90 Matrix(Distribution distribution) : Matrix<const T, D>(std::move(distribution)) {
-
91 const SizeType alignment = 64;
-
92 const SizeType ld = std::max<SizeType>(
-
93 1, util::ceilDiv(this->distribution().local_size().rows(), alignment) * alignment);
-
94
-
95 auto layout = colMajorLayout(this->distribution().local_size(), this->tile_size(), ld);
-
96
-
97 SizeType memory_size = layout.minMemSize();
-
98 memory::MemoryView<ElementType, D> mem(memory_size);
-
99
-
100 setUpTiles(mem, layout);
-
101 }
+
89
+
+
91 Matrix(Distribution distribution) : Matrix<const T, D>(std::move(distribution)) {
+
92 const SizeType alignment = 64;
+
93 const SizeType ld = std::max<SizeType>(
+
94 1, util::ceilDiv(this->distribution().local_size().rows(), alignment) * alignment);
+
95
+
96 auto layout = colMajorLayout(this->distribution().local_size(), this->tile_size(), ld);
+
97
+
98 SizeType memory_size = layout.minMemSize();
+
99 memory::MemoryView<ElementType, D> mem(memory_size);
+
100
+
101 setUpTiles(mem, layout);
+
102 }
-
102
-
-
110 Matrix(Distribution distribution, const LayoutInfo& layout)
-
111 : Matrix<const T, D>(std::move(distribution)) {
-
112 DLAF_ASSERT(this->distribution().local_size() == layout.size(),
-
113 "Size of distribution does not match layout size!", distribution.local_size(),
-
114 layout.size());
-
115 DLAF_ASSERT(this->distribution().tile_size() == layout.blockSize(), distribution.tile_size(),
-
116 layout.blockSize());
-
117
-
118 memory::MemoryView<ElementType, D> mem(layout.minMemSize());
-
119
-
120 setUpTiles(mem, layout);
-
121 }
+
103
+
+
111 Matrix(Distribution distribution, const LayoutInfo& layout)
+
112 : Matrix<const T, D>(std::move(distribution)) {
+
113 DLAF_ASSERT(this->distribution().local_size() == layout.size(),
+
114 "Size of distribution does not match layout size!", distribution.local_size(),
+
115 layout.size());
+
116 DLAF_ASSERT(this->distribution().tile_size() == layout.blockSize(), distribution.tile_size(),
+
117 layout.blockSize());
+
118
+
119 memory::MemoryView<ElementType, D> mem(layout.minMemSize());
+
120
+
121 setUpTiles(mem, layout);
+
122 }
-
122
-
130 Matrix(const LayoutInfo& layout, ElementType* ptr) noexcept : Matrix<const T, D>(layout, ptr) {}
-
131
-
-
141 Matrix(Distribution distribution, const LayoutInfo& layout, ElementType* ptr) noexcept
-
142 : Matrix<const T, D>(std::move(distribution), layout, ptr) {}
+
123
+
131 Matrix(const LayoutInfo& layout, ElementType* ptr) noexcept : Matrix<const T, D>(layout, ptr) {}
+
132
+
+
142 Matrix(Distribution distribution, const LayoutInfo& layout, ElementType* ptr) noexcept
+
143 : Matrix<const T, D>(std::move(distribution), layout, ptr) {}
-
143
-
144 Matrix(const Matrix& rhs) = delete;
-
145 Matrix(Matrix&& rhs) = default;
-
146
-
147 Matrix& operator=(const Matrix& rhs) = delete;
-
148 Matrix& operator=(Matrix&& rhs) = default;
-
149
-
-
153 ReadWriteSenderType readwrite(const LocalTileIndex& index) noexcept {
-
154 return tile_managers_[tileLinearIndex(index)].readwrite();
-
155 }
+
144
+
145 Matrix(const Matrix& rhs) = delete;
+
146 Matrix(Matrix&& rhs) = default;
+
147
+
148 Matrix& operator=(const Matrix& rhs) = delete;
+
149 Matrix& operator=(Matrix&& rhs) = default;
+
150
+
+
154 ReadWriteSenderType readwrite(const LocalTileIndex& index) noexcept {
+
155 return tile_managers_[tileLinearIndex(index)].readwrite();
+
156 }
-
156
-
-
161 ReadWriteSenderType readwrite(const GlobalTileIndex& index) noexcept {
-
162 return readwrite(this->distribution().local_tile_index(index));
-
163 }
+
157
+
+
162 ReadWriteSenderType readwrite(const GlobalTileIndex& index) noexcept {
+
163 return readwrite(this->distribution().local_tile_index(index));
+
164 }
-
164
-
-
171 Matrix subPipeline() noexcept {
-
172 return Matrix(*this, SubPipelineTag{});
-
173 }
+
165
+
+
172 Matrix subPipeline() noexcept {
+
173 return Matrix(*this, SubPipelineTag{});
+
174 }
-
174
-
-
184 Matrix retiledSubPipeline(const LocalTileSize& tiles_per_block) noexcept {
-
185 return Matrix(*this, tiles_per_block);
-
186 }
+
175
+
+
185 Matrix retiledSubPipeline(const LocalTileSize& tiles_per_block) noexcept {
+
186 return Matrix(*this, tiles_per_block);
+
187 }
-
187
-
188protected:
-
189 using Matrix<const T, D>::tileLinearIndex;
-
190
-
191private:
-
192 using typename Matrix<const T, D>::SubPipelineTag;
-
193 Matrix(Matrix& mat, const SubPipelineTag tag) noexcept : Matrix<const T, D>(mat, tag) {}
-
194
-
195 template <template <class, Device> class MatrixLike>
-
196 Matrix(MatrixLike<const T, D>& mat, const LocalTileSize& tiles_per_block) noexcept
-
197 : Matrix<const T, D>(mat, tiles_per_block) {}
-
198
-
199 using Matrix<const T, D>::setUpTiles;
-
200 using Matrix<const T, D>::tile_managers_;
-
201};
+
188
+
189protected:
+
190 using Matrix<const T, D>::tileLinearIndex;
+
191
+
192private:
+
193 using typename Matrix<const T, D>::SubPipelineTag;
+
194 Matrix(Matrix& mat, const SubPipelineTag tag) noexcept : Matrix<const T, D>(mat, tag) {}
+
195
+
196 template <template <class, Device> class MatrixLike>
+
197 Matrix(MatrixLike<const T, D>& mat, const LocalTileSize& tiles_per_block) noexcept
+
198 : Matrix<const T, D>(mat, tiles_per_block) {}
+
199
+
200 using Matrix<const T, D>::setUpTiles;
+
201 using Matrix<const T, D>::tile_managers_;
+
202};
-
202
-
203template <class T, Device D>
-
-
204class Matrix<const T, D> : public internal::MatrixBase {
-
205public:
-
206 static constexpr Device device = D;
-
207
-
208 using ElementType = T;
-
209 using TileType = Tile<ElementType, D>;
-
210 using ConstTileType = Tile<const ElementType, D>;
-
211 using TileDataType = internal::TileData<ElementType, D>;
-
212 using ReadOnlySenderType = ReadOnlyTileSender<ElementType, D>;
-
213 using ReadWriteSenderType = ReadWriteTileSender<ElementType, D>;
-
214 friend internal::MatrixRef<const ElementType, D>;
-
215
-
216 Matrix(const LayoutInfo& layout, ElementType* ptr) noexcept
-
217 : MatrixBase({layout.size(), layout.blockSize()}) {
-
218 memory::MemoryView<ElementType, D> mem(ptr, layout.minMemSize());
-
219 setUpTiles(mem, layout);
-
220 }
-
221
-
222 Matrix(const LayoutInfo& layout, const ElementType* ptr) noexcept
-
223 : Matrix(layout, const_cast<ElementType*>(ptr)) {}
-
224
-
225 Matrix(Distribution distribution, const LayoutInfo& layout, ElementType* ptr) noexcept
-
226 : MatrixBase(std::move(distribution)) {
-
227 DLAF_ASSERT(this->distribution().local_size() == layout.size(), distribution.local_size(),
-
228 layout.size());
-
229 DLAF_ASSERT(this->distribution().tile_size() == layout.blockSize(), distribution.tile_size(),
-
230 layout.blockSize());
-
231
-
232 memory::MemoryView<ElementType, D> mem(ptr, layout.minMemSize());
-
233 setUpTiles(mem, layout);
-
234 }
-
235
-
236 Matrix(Distribution distribution, const LayoutInfo& layout, const ElementType* ptr) noexcept
-
237 : Matrix(std::move(distribution), layout, const_cast<ElementType*>(ptr)) {}
-
238
-
239 Matrix(const Matrix& rhs) = delete;
-
240 Matrix(Matrix&& rhs) = default;
-
241
-
242 Matrix& operator=(const Matrix& rhs) = delete;
-
243 Matrix& operator=(Matrix&& rhs) = default;
-
244
-
-
248 ReadOnlySenderType read(const LocalTileIndex& index) noexcept {
-
249 return tile_managers_[tileLinearIndex(index)].read();
-
250 }
+
203
+
204template <class T, Device D>
+
+
205class Matrix<const T, D> : public internal::MatrixBase {
+
206public:
+
207 static constexpr Device device = D;
+
208
+
209 using ElementType = T;
+
210 using TileType = Tile<ElementType, D>;
+
211 using ConstTileType = Tile<const ElementType, D>;
+
212 using TileDataType = internal::TileData<ElementType, D>;
+
213 using ReadOnlySenderType = ReadOnlyTileSender<ElementType, D>;
+
214 using ReadWriteSenderType = ReadWriteTileSender<ElementType, D>;
+
215 friend internal::MatrixRef<const ElementType, D>;
+
216
+
217 Matrix(const LayoutInfo& layout, ElementType* ptr) noexcept
+
218 : MatrixBase({layout.size(), layout.blockSize()}) {
+
219 memory::MemoryView<ElementType, D> mem(ptr, layout.minMemSize());
+
220 setUpTiles(mem, layout);
+
221 }
+
222
+
223 Matrix(const LayoutInfo& layout, const ElementType* ptr) noexcept
+
224 : Matrix(layout, const_cast<ElementType*>(ptr)) {}
+
225
+
226 Matrix(Distribution distribution, const LayoutInfo& layout, ElementType* ptr) noexcept
+
227 : MatrixBase(std::move(distribution)) {
+
228 DLAF_ASSERT(this->distribution().local_size() == layout.size(), distribution.local_size(),
+
229 layout.size());
+
230 DLAF_ASSERT(this->distribution().tile_size() == layout.blockSize(), distribution.tile_size(),
+
231 layout.blockSize());
+
232
+
233 memory::MemoryView<ElementType, D> mem(ptr, layout.minMemSize());
+
234 setUpTiles(mem, layout);
+
235 }
+
236
+
237 Matrix(Distribution distribution, const LayoutInfo& layout, const ElementType* ptr) noexcept
+
238 : Matrix(std::move(distribution), layout, const_cast<ElementType*>(ptr)) {}
+
239
+
240 Matrix(const Matrix& rhs) = delete;
+
241 Matrix(Matrix&& rhs) = default;
+
242
+
243 Matrix& operator=(const Matrix& rhs) = delete;
+
244 Matrix& operator=(Matrix&& rhs) = default;
+
245
+
+
249 ReadOnlySenderType read(const LocalTileIndex& index) noexcept {
+
250 return tile_managers_[tileLinearIndex(index)].read();
+
251 }
-
251
-
-
256 ReadOnlySenderType read(const GlobalTileIndex& index) {
-
257 return read(distribution().local_tile_index(index));
-
258 }
+
252
+
+
257 ReadOnlySenderType read(const GlobalTileIndex& index) {
+
258 return read(distribution().local_tile_index(index));
+
259 }
-
259
-
264 void waitLocalTiles() noexcept;
-
265
-
-
272 Matrix subPipelineConst() {
-
273 return Matrix(*this, SubPipelineTag{});
-
274 }
+
260
+
265 void waitLocalTiles() noexcept;
+
266
+
+
273 Matrix subPipelineConst() {
+
274 return Matrix(*this, SubPipelineTag{});
+
275 }
-
275
-
-
285 Matrix retiledSubPipelineConst(const LocalTileSize& tiles_per_block) {
-
286 return Matrix(*this, tiles_per_block);
-
287 }
+
276
+
+
286 Matrix retiledSubPipelineConst(const LocalTileSize& tiles_per_block) {
+
287 return Matrix(*this, tiles_per_block);
+
288 }
-
288
-
-
293 void done(const LocalTileIndex& index) noexcept {
-
294 const auto i = tileLinearIndex(index);
-
295 tile_managers_[i].reset();
-
296 }
+
289
+
+
294 void done(const LocalTileIndex& index) noexcept {
+
295 const auto i = tileLinearIndex(index);
+
296 tile_managers_[i].reset();
+
297 }
-
297
-
-
302 void done(const GlobalTileIndex& index) noexcept {
-
303 done(distribution().local_tile_index(index));
-
304 }
+
298
+
+
303 void done(const GlobalTileIndex& index) noexcept {
+
304 done(distribution().local_tile_index(index));
+
305 }
-
305
-
306protected:
-
307 Matrix(Distribution distribution) : internal::MatrixBase{std::move(distribution)} {
-
308 DLAF_ASSERT((distribution.offset() == GlobalElementIndex{0, 0}), "not supported",
-
309 distribution.offset());
-
310 }
-
311
-
312 struct SubPipelineTag {};
-
313 Matrix(Matrix& mat, const SubPipelineTag) noexcept : MatrixBase(mat.distribution()) {
-
314 setUpSubPipelines(mat);
-
315 }
-
316
-
317 template <template <class, Device> class MatrixLike>
-
318 Matrix(MatrixLike<const T, D>& mat, const LocalTileSize& tiles_per_block) noexcept
-
319 : MatrixBase(mat.distribution(), tiles_per_block) {
-
320 setUpRetiledSubPipelines(mat, tiles_per_block);
-
321 }
-
322
-
323 void setUpTiles(const memory::MemoryView<ElementType, D>& mem, const LayoutInfo& layout) noexcept;
-
324 void setUpSubPipelines(Matrix<const T, D>&) noexcept;
-
325
-
326 template <template <class, Device> class MatrixLike>
-
327 void setUpRetiledSubPipelines(MatrixLike<const T, D>& mat,
-
328 const LocalTileSize& tiles_per_block) noexcept;
-
329
-
330 std::vector<internal::TilePipeline<T, D>> tile_managers_;
-
331
-
332private:
-
333 ReadWriteSenderType readwrite(const LocalTileIndex& index) noexcept {
-
334 return tile_managers_[tileLinearIndex(index)].readwrite();
-
335 }
-
336
-
337 ReadWriteSenderType readwrite(const GlobalTileIndex& index) noexcept {
-
338 return readwrite(this->distribution().local_tile_index(index));
-
339 }
-
340};
+
306
+
307protected:
+
308 Matrix(Distribution distribution) : internal::MatrixBase{std::move(distribution)} {
+
309 DLAF_ASSERT((distribution.offset() == GlobalElementIndex{0, 0}), "not supported",
+
310 distribution.offset());
+
311 }
+
312
+
313 struct SubPipelineTag {};
+
314 Matrix(Matrix& mat, const SubPipelineTag) noexcept : MatrixBase(mat.distribution()) {
+
315 setUpSubPipelines(mat);
+
316 }
+
317
+
318 template <template <class, Device> class MatrixLike>
+
319 Matrix(MatrixLike<const T, D>& mat, const LocalTileSize& tiles_per_block) noexcept
+
320 : MatrixBase(mat.distribution(), tiles_per_block) {
+
321 setUpRetiledSubPipelines(mat, tiles_per_block);
+
322 }
+
323
+
324 void setUpTiles(const memory::MemoryView<ElementType, D>& mem, const LayoutInfo& layout) noexcept;
+
325 void setUpSubPipelines(Matrix<const T, D>&) noexcept;
+
326
+
327 template <template <class, Device> class MatrixLike>
+
328 void setUpRetiledSubPipelines(MatrixLike<const T, D>& mat,
+
329 const LocalTileSize& tiles_per_block) noexcept;
+
330
+
331 std::vector<internal::TilePipeline<T, D>> tile_managers_;
+
332
+
333private:
+
334 ReadWriteSenderType readwrite(const LocalTileIndex& index) noexcept {
+
335 return tile_managers_[tileLinearIndex(index)].readwrite();
+
336 }
+
337
+
338 ReadWriteSenderType readwrite(const GlobalTileIndex& index) noexcept {
+
339 return readwrite(this->distribution().local_tile_index(index));
+
340 }
+
341};
-
341
-
342template <class T, Device D>
-
343void Matrix<const T, D>::waitLocalTiles() noexcept {
-
344 // Note:
-
345 // Using a readwrite access to the tile ensures that the access is exclusive and not shared
-
346 // among multiple tasks.
-
347
-
348 const auto range_local = common::iterate_range2d(distribution().local_nr_tiles());
-
349
-
350 auto s = pika::execution::experimental::when_all_vector(internal::selectGeneric(
-
351 [this](const LocalTileIndex& index) {
-
352 return this->tile_managers_[tileLinearIndex(index)].readwrite();
-
353 },
-
354 range_local)) |
-
355 pika::execution::experimental::drop_value();
-
356 pika::this_thread::experimental::sync_wait(std::move(s));
-
357}
-
358
-
359template <class T, Device D>
-
360void Matrix<const T, D>::setUpTiles(const memory::MemoryView<ElementType, D>& mem,
-
361 const LayoutInfo& layout) noexcept {
-
362 const auto& nr_tiles = layout.nrTiles();
-
363
-
364 DLAF_ASSERT(tile_managers_.empty(), "");
-
365 tile_managers_.reserve(to_sizet(nr_tiles.linear_size()));
-
366
-
367 using MemView = memory::MemoryView<T, D>;
-
368
-
369 for (SizeType j = 0; j < nr_tiles.cols(); ++j) {
-
370 for (SizeType i = 0; i < nr_tiles.rows(); ++i) {
-
371 LocalTileIndex ind(i, j);
-
372 TileElementSize tile_size = layout.tileSize(ind);
-
373 tile_managers_.emplace_back(
-
374 TileDataType(tile_size, MemView(mem, layout.tileOffset(ind), layout.minTileMemSize(tile_size)),
-
375 layout.ldTile()));
-
376 }
-
377 }
-
378}
-
379
-
380template <class T, Device D>
-
381void Matrix<const T, D>::setUpSubPipelines(Matrix<const T, D>& mat) noexcept {
-
382 namespace ex = pika::execution::experimental;
-
383
-
384 // TODO: Optimize read-after-read. This is currently forced to access the base
-
385 // matrix in readwrite mode so that we can move the tile into the
-
386 // sub-pipeline. This is semantically not required and should eventually be
-
387 // optimized.
-
388 tile_managers_.reserve(mat.tile_managers_.size());
-
389 for (auto& tm : mat.tile_managers_) {
-
390 tile_managers_.emplace_back(Tile<T, D>());
-
391 auto s = ex::when_all(tile_managers_.back().readwrite_with_wrapper(), tm.readwrite()) |
-
392 ex::then([](internal::TileAsyncRwMutexReadWriteWrapper<T, D> empty_tile_wrapper,
-
393 Tile<T, D> tile) { empty_tile_wrapper.get() = std::move(tile); });
-
394 ex::start_detached(std::move(s));
-
395 }
-
396}
-
397
-
398template <class T, Device D>
-
399template <template <class, Device> class MatrixLike>
-
400void Matrix<const T, D>::setUpRetiledSubPipelines(MatrixLike<const T, D>& mat,
-
401 const LocalTileSize& tiles_per_block) noexcept {
-
402 DLAF_ASSERT(mat.blockSize() == mat.tile_size(), mat.blockSize(), mat.tile_size());
-
403
-
404 using common::internal::vector;
-
405 namespace ex = pika::execution::experimental;
-
406
-
407 const auto n = to_sizet(distribution().local_nr_tiles().linear_size());
-
408 tile_managers_.reserve(n);
-
409 for (std::size_t i = 0; i < n; ++i) {
-
410 tile_managers_.emplace_back(Tile<T, D>());
-
411 }
-
412
-
413 const auto tile_size = distribution().tile_size();
-
414 vector<SubTileSpec> specs;
-
415 vector<LocalTileIndex> indices;
-
416 specs.reserve(tiles_per_block.linear_size());
-
417 indices.reserve(tiles_per_block.linear_size());
-
418
-
419 // TODO: Optimize read-after-read. This is currently forced to access the base matrix in readwrite
-
420 // mode so that we can move the tile into the sub-pipeline. This is semantically not required and
-
421 // should eventually be optimized.
-
422 for (const auto& orig_tile_index : common::iterate_range2d(mat.distribution().local_nr_tiles())) {
-
423 const auto original_tile_size = mat.tileSize(mat.distribution().global_tile_index(orig_tile_index));
-
424
-
425 for (SizeType j = 0; j < original_tile_size.cols(); j += tile_size.cols())
-
426 for (SizeType i = 0; i < original_tile_size.rows(); i += tile_size.rows()) {
-
427 indices.emplace_back(
-
428 LocalTileIndex{orig_tile_index.row() * tiles_per_block.rows() + i / tile_size.rows(),
-
429 orig_tile_index.col() * tiles_per_block.cols() + j / tile_size.cols()});
-
430 specs.emplace_back(SubTileSpec{{i, j},
-
431 tileSize(distribution().global_tile_index(indices.back()))});
-
432 }
-
433
-
434 auto sub_tiles = splitTileDisjoint(mat.readwrite(orig_tile_index), specs);
-
435
-
436 DLAF_ASSERT_HEAVY(specs.size() == indices.size(), specs.size(), indices.size());
-
437 for (SizeType j = 0; j < specs.size(); ++j) {
-
438 const auto i = tileLinearIndex(indices[j]);
-
439
-
440 // Move subtile to be managed by the tile manager of RetiledMatrix. We
-
441 // use readwrite_with_wrapper to get access to the original tile managed
-
442 // by the underlying async_rw_mutex.
-
443 auto s =
-
444 ex::when_all(tile_managers_[i].readwrite_with_wrapper(), std::move(sub_tiles[to_sizet(j)])) |
-
445 ex::then([](internal::TileAsyncRwMutexReadWriteWrapper<T, D> empty_tile_wrapper,
-
446 Tile<T, D> sub_tile) { empty_tile_wrapper.get() = std::move(sub_tile); });
-
447 ex::start_detached(std::move(s));
-
448 }
-
449
-
450 specs.clear();
-
451 indices.clear();
-
452 }
-
453}
-
454
-
458template <class MatrixLike>
-
-
459auto selectRead(MatrixLike& matrix, common::IterableRange2D<SizeType, LocalTile_TAG> range) {
-
460 return internal::selectGeneric([&](auto index) { return matrix.read(index); }, range);
-
461}
+
342
+
343template <class T, Device D>
+
344void Matrix<const T, D>::waitLocalTiles() noexcept {
+
345 // Note:
+
346 // Using a readwrite access to the tile ensures that the access is exclusive and not shared
+
347 // among multiple tasks.
+
348
+
349 const auto range_local = common::iterate_range2d(distribution().local_nr_tiles());
+
350
+
351 auto s = pika::execution::experimental::when_all_vector(internal::selectGeneric(
+
352 [this](const LocalTileIndex& index) {
+
353 return this->tile_managers_[tileLinearIndex(index)].readwrite();
+
354 },
+
355 range_local)) |
+
356 pika::execution::experimental::drop_value();
+
357 pika::this_thread::experimental::sync_wait(std::move(s));
+
358}
+
359
+
360template <class T, Device D>
+
361void Matrix<const T, D>::setUpTiles(const memory::MemoryView<ElementType, D>& mem,
+
362 const LayoutInfo& layout) noexcept {
+
363 const auto& nr_tiles = layout.nrTiles();
+
364
+
365 DLAF_ASSERT(tile_managers_.empty(), "");
+
366 tile_managers_.reserve(to_sizet(nr_tiles.linear_size()));
+
367
+
368 using MemView = memory::MemoryView<T, D>;
+
369
+
370 for (SizeType j = 0; j < nr_tiles.cols(); ++j) {
+
371 for (SizeType i = 0; i < nr_tiles.rows(); ++i) {
+
372 LocalTileIndex ind(i, j);
+
373 TileElementSize tile_size = layout.tileSize(ind);
+
374 tile_managers_.emplace_back(
+
375 TileDataType(tile_size, MemView(mem, layout.tileOffset(ind), layout.minTileMemSize(tile_size)),
+
376 layout.ldTile()));
+
377 }
+
378 }
+
379}
+
380
+
381template <class T, Device D>
+
382void Matrix<const T, D>::setUpSubPipelines(Matrix<const T, D>& mat) noexcept {
+
383 namespace ex = pika::execution::experimental;
+
384
+
385 // TODO: Optimize read-after-read. This is currently forced to access the base
+
386 // matrix in readwrite mode so that we can move the tile into the
+
387 // sub-pipeline. This is semantically not required and should eventually be
+
388 // optimized.
+
389 tile_managers_.reserve(mat.tile_managers_.size());
+
390 for (auto& tm : mat.tile_managers_) {
+
391 tile_managers_.emplace_back(Tile<T, D>());
+
392 auto s = ex::when_all(tile_managers_.back().readwrite_with_wrapper(), tm.readwrite()) |
+
393 ex::then([](internal::TileAsyncRwMutexReadWriteWrapper<T, D> empty_tile_wrapper,
+
394 Tile<T, D> tile) { empty_tile_wrapper.get() = std::move(tile); });
+
395 ex::start_detached(std::move(s));
+
396 }
+
397}
+
398
+
399template <class T, Device D>
+
400template <template <class, Device> class MatrixLike>
+
401void Matrix<const T, D>::setUpRetiledSubPipelines(MatrixLike<const T, D>& mat,
+
402 const LocalTileSize& tiles_per_block) noexcept {
+
403 DLAF_ASSERT(mat.blockSize() == mat.tile_size(), mat.blockSize(), mat.tile_size());
+
404
+
405 using common::internal::vector;
+
406 namespace ex = pika::execution::experimental;
+
407
+
408 const auto n = to_sizet(distribution().local_nr_tiles().linear_size());
+
409 tile_managers_.reserve(n);
+
410 for (std::size_t i = 0; i < n; ++i) {
+
411 tile_managers_.emplace_back(Tile<T, D>());
+
412 }
+
413
+
414 const auto tile_size = distribution().tile_size();
+
415 vector<SubTileSpec> specs;
+
416 vector<LocalTileIndex> indices;
+
417 specs.reserve(tiles_per_block.linear_size());
+
418 indices.reserve(tiles_per_block.linear_size());
+
419
+
420 // TODO: Optimize read-after-read. This is currently forced to access the base matrix in readwrite
+
421 // mode so that we can move the tile into the sub-pipeline. This is semantically not required and
+
422 // should eventually be optimized.
+
423 for (const auto& orig_tile_index : common::iterate_range2d(mat.distribution().local_nr_tiles())) {
+
424 const auto original_tile_size = mat.tileSize(mat.distribution().global_tile_index(orig_tile_index));
+
425
+
426 for (SizeType j = 0; j < original_tile_size.cols(); j += tile_size.cols())
+
427 for (SizeType i = 0; i < original_tile_size.rows(); i += tile_size.rows()) {
+
428 indices.emplace_back(
+
429 LocalTileIndex{orig_tile_index.row() * tiles_per_block.rows() + i / tile_size.rows(),
+
430 orig_tile_index.col() * tiles_per_block.cols() + j / tile_size.cols()});
+
431 specs.emplace_back(SubTileSpec{{i, j},
+
432 tileSize(distribution().global_tile_index(indices.back()))});
+
433 }
+
434
+
435 auto sub_tiles = splitTileDisjoint(mat.readwrite(orig_tile_index), specs);
+
436
+
437 DLAF_ASSERT_HEAVY(specs.size() == indices.size(), specs.size(), indices.size());
+
438 for (SizeType j = 0; j < specs.size(); ++j) {
+
439 const auto i = tileLinearIndex(indices[j]);
+
440
+
441 // Move subtile to be managed by the tile manager of RetiledMatrix. We
+
442 // use readwrite_with_wrapper to get access to the original tile managed
+
443 // by the underlying async_rw_mutex.
+
444 auto s =
+
445 ex::when_all(tile_managers_[i].readwrite_with_wrapper(), std::move(sub_tiles[to_sizet(j)])) |
+
446 ex::then([](internal::TileAsyncRwMutexReadWriteWrapper<T, D> empty_tile_wrapper,
+
447 Tile<T, D> sub_tile) { empty_tile_wrapper.get() = std::move(sub_tile); });
+
448 ex::start_detached(std::move(s));
+
449 }
+
450
+
451 specs.clear();
+
452 indices.clear();
+
453 }
+
454}
+
455
+
459template <class MatrixLike>
+
+
460auto selectRead(MatrixLike& matrix, common::IterableRange2D<SizeType, LocalTile_TAG> range) {
+
461 return internal::selectGeneric([&](auto index) { return matrix.read(index); }, range);
+
462}
-
462
-
466template <class MatrixLike>
-
-
467auto select(MatrixLike& matrix, common::IterableRange2D<SizeType, LocalTile_TAG> range) {
-
468 return internal::selectGeneric([&](auto index) { return matrix.readwrite(index); }, range);
-
469}
+
463
+
467template <class MatrixLike>
+
+
468auto select(MatrixLike& matrix, common::IterableRange2D<SizeType, LocalTile_TAG> range) {
+
469 return internal::selectGeneric([&](auto index) { return matrix.readwrite(index); }, range);
+
470}
-
470
-
471// ETI
-
472
-
473#define DLAF_MATRIX_ETI(KWORD, DATATYPE, DEVICE) \
-
474 KWORD template class Matrix<DATATYPE, DEVICE>; \
-
475 KWORD template class Matrix<const DATATYPE, DEVICE>;
-
476
-
477DLAF_MATRIX_ETI(extern, float, Device::CPU)
-
478DLAF_MATRIX_ETI(extern, double, Device::CPU)
-
479DLAF_MATRIX_ETI(extern, std::complex<float>, Device::CPU)
-
480DLAF_MATRIX_ETI(extern, std::complex<double>, Device::CPU)
-
481
-
482#if defined(DLAF_WITH_GPU)
-
483DLAF_MATRIX_ETI(extern, float, Device::GPU)
-
484DLAF_MATRIX_ETI(extern, double, Device::GPU)
-
485DLAF_MATRIX_ETI(extern, std::complex<float>, Device::GPU)
-
486DLAF_MATRIX_ETI(extern, std::complex<double>, Device::GPU)
-
487#endif
-
488}
-
489#ifndef DLAF_DOXYGEN
-
490// Note: Doxygen doesn't deal correctly with template specialized inheritance,
-
491// and this line makes it run infinitely
-
492
-
494using matrix::Matrix;
-
495#endif
-
496}
+
471
+
472// ETI
+
473
+
474#define DLAF_MATRIX_ETI(KWORD, DATATYPE, DEVICE) \
+
475 KWORD template class Matrix<DATATYPE, DEVICE>; \
+
476 KWORD template class Matrix<const DATATYPE, DEVICE>;
+
477
+
478DLAF_MATRIX_ETI(extern, float, Device::CPU)
+
479DLAF_MATRIX_ETI(extern, double, Device::CPU)
+
480DLAF_MATRIX_ETI(extern, std::complex<float>, Device::CPU)
+
481DLAF_MATRIX_ETI(extern, std::complex<double>, Device::CPU)
+
482
+
483#if defined(DLAF_WITH_GPU)
+
484DLAF_MATRIX_ETI(extern, float, Device::GPU)
+
485DLAF_MATRIX_ETI(extern, double, Device::GPU)
+
486DLAF_MATRIX_ETI(extern, std::complex<float>, Device::GPU)
+
487DLAF_MATRIX_ETI(extern, std::complex<double>, Device::GPU)
+
488#endif
+
489}
+
490#ifndef DLAF_DOXYGEN
+
491// Note: Doxygen doesn't deal correctly with template specialized inheritance,
+
492// and this line makes it run infinitely
+
493
+
495using matrix::Matrix;
+
496#endif
+
497}
dlaf::comm::CommunicatorGrid
Definition communicator_grid.h:37
dlaf::common::IterableRange2D
An Iterable representing a 2D range.
Definition range2d.h:170
@@ -521,36 +522,36 @@
dlaf::matrix::LayoutInfo::tileSize
TileElementSize tileSize(const LocalTileIndex &index) const noexcept
Definition layout_info.h:75
dlaf::matrix::LayoutInfo::minTileMemSize
SizeType minTileMemSize(const LocalTileIndex &index) const noexcept
Definition layout_info.h:87
dlaf::matrix::LayoutInfo::tileOffset
SizeType tileOffset(const LocalTileIndex &index) const noexcept
Definition layout_info.h:67
-
dlaf::matrix::Matrix< const T, D >::read
ReadOnlySenderType read(const GlobalTileIndex &index)
Definition matrix.h:256
-
dlaf::matrix::Matrix< const T, D >::retiledSubPipelineConst
Matrix retiledSubPipelineConst(const LocalTileSize &tiles_per_block)
Definition matrix.h:285
-
dlaf::matrix::Matrix< const T, D >::done
void done(const LocalTileIndex &index) noexcept
Definition matrix.h:293
-
dlaf::matrix::Matrix< const T, D >::read
ReadOnlySenderType read(const LocalTileIndex &index) noexcept
Definition matrix.h:248
+
dlaf::matrix::Matrix< const T, D >::read
ReadOnlySenderType read(const GlobalTileIndex &index)
Definition matrix.h:257
+
dlaf::matrix::Matrix< const T, D >::retiledSubPipelineConst
Matrix retiledSubPipelineConst(const LocalTileSize &tiles_per_block)
Definition matrix.h:286
+
dlaf::matrix::Matrix< const T, D >::done
void done(const LocalTileIndex &index) noexcept
Definition matrix.h:294
+
dlaf::matrix::Matrix< const T, D >::read
ReadOnlySenderType read(const LocalTileIndex &index) noexcept
Definition matrix.h:249
-
dlaf::matrix::Matrix< const T, D >::done
void done(const GlobalTileIndex &index) noexcept
Definition matrix.h:302
-
dlaf::matrix::Matrix
Definition matrix.h:61
-
dlaf::matrix::Matrix::retiledSubPipeline
Matrix retiledSubPipeline(const LocalTileSize &tiles_per_block) noexcept
Definition matrix.h:184
-
dlaf::matrix::Matrix::Matrix
Matrix(const LocalElementSize &size, const TileElementSize &tile_size)
Definition matrix.h:77
-
dlaf::matrix::Matrix::subPipeline
Matrix subPipeline() noexcept
Definition matrix.h:171
-
dlaf::matrix::Matrix::Matrix
Matrix(const LayoutInfo &layout, ElementType *ptr) noexcept
Definition matrix.h:130
-
dlaf::matrix::Matrix::Matrix
Matrix(Distribution distribution, const LayoutInfo &layout, ElementType *ptr) noexcept
Definition matrix.h:141
-
dlaf::matrix::Matrix::Matrix
Matrix(Distribution distribution)
Create a matrix distributed according to the distribution distribution.
Definition matrix.h:90
-
dlaf::matrix::Matrix::Matrix
Matrix(Distribution distribution, const LayoutInfo &layout)
Definition matrix.h:110
-
dlaf::matrix::Matrix::Matrix
Matrix(const GlobalElementSize &size, const TileElementSize &tile_size, const comm::CommunicatorGrid &comm)
Definition matrix.h:85
-
dlaf::matrix::Matrix::readwrite
ReadWriteSenderType readwrite(const LocalTileIndex &index) noexcept
Definition matrix.h:153
-
dlaf::matrix::Matrix::readwrite
ReadWriteSenderType readwrite(const GlobalTileIndex &index) noexcept
Definition matrix.h:161
+
dlaf::matrix::Matrix< const T, D >::done
void done(const GlobalTileIndex &index) noexcept
Definition matrix.h:303
+
dlaf::matrix::Matrix
Definition matrix.h:62
+
dlaf::matrix::Matrix::retiledSubPipeline
Matrix retiledSubPipeline(const LocalTileSize &tiles_per_block) noexcept
Definition matrix.h:185
+
dlaf::matrix::Matrix::Matrix
Matrix(const LocalElementSize &size, const TileElementSize &tile_size)
Definition matrix.h:78
+
dlaf::matrix::Matrix::subPipeline
Matrix subPipeline() noexcept
Definition matrix.h:172
+
dlaf::matrix::Matrix::Matrix
Matrix(const LayoutInfo &layout, ElementType *ptr) noexcept
Definition matrix.h:131
+
dlaf::matrix::Matrix::Matrix
Matrix(Distribution distribution, const LayoutInfo &layout, ElementType *ptr) noexcept
Definition matrix.h:142
+
dlaf::matrix::Matrix::Matrix
Matrix(Distribution distribution)
Create a matrix distributed according to the distribution distribution.
Definition matrix.h:91
+
dlaf::matrix::Matrix::Matrix
Matrix(Distribution distribution, const LayoutInfo &layout)
Definition matrix.h:111
+
dlaf::matrix::Matrix::Matrix
Matrix(const GlobalElementSize &size, const TileElementSize &tile_size, const comm::CommunicatorGrid &comm)
Definition matrix.h:86
+
dlaf::matrix::Matrix::readwrite
ReadWriteSenderType readwrite(const LocalTileIndex &index) noexcept
Definition matrix.h:154
+
dlaf::matrix::Matrix::readwrite
ReadWriteSenderType readwrite(const GlobalTileIndex &index) noexcept
Definition matrix.h:162
dlaf::matrix::internal::MatrixBase
Definition matrix_base.h:34
-
dlaf::matrix::internal::MatrixRef
Definition matrix_ref.h:171
- -
dlaf::memory::MemoryView
Definition memory_view.h:32
+
dlaf::matrix::internal::MatrixRef
Definition matrix_ref.h:172
+ +
dlaf::memory::MemoryView
Definition memory_view.h:33
communicator_grid.h
layout_info.h
dlaf::matrix::colMajorLayout
LayoutInfo colMajorLayout(const LocalElementSize &size, const TileElementSize &block_size, SizeType ld)
Returns LayoutInfo for a local column major matrix.
Definition layout_info.h:125
-
dlaf::matrix::splitTileDisjoint
std::vector< ReadWriteTileSender< T, D > > splitTileDisjoint(ReadWriteTileSender< T, D > &&tile, const std::vector< SubTileSpec > &specs)
Definition tile.h:573
-
dlaf::matrix::selectRead
auto selectRead(MatrixLike &matrix, common::IterableRange2D< SizeType, LocalTile_TAG > range)
Definition matrix.h:459
-
dlaf::matrix::select
auto select(MatrixLike &matrix, common::IterableRange2D< SizeType, LocalTile_TAG > range)
Definition matrix.h:467
-
dlaf::matrix::internal::selectGeneric
auto selectGeneric(Func &&f, common::IterableRange2D< SizeType, LocalTile_TAG > range)
Definition matrix.h:44
+
dlaf::matrix::splitTileDisjoint
std::vector< ReadWriteTileSender< T, D > > splitTileDisjoint(ReadWriteTileSender< T, D > &&tile, const std::vector< SubTileSpec > &specs)
Definition tile.h:574
+
dlaf::matrix::selectRead
auto selectRead(MatrixLike &matrix, common::IterableRange2D< SizeType, LocalTile_TAG > range)
Definition matrix.h:460
+
dlaf::matrix::select
auto select(MatrixLike &matrix, common::IterableRange2D< SizeType, LocalTile_TAG > range)
Definition matrix.h:468
+
dlaf::matrix::internal::selectGeneric
auto selectGeneric(Func &&f, common::IterableRange2D< SizeType, LocalTile_TAG > range)
Definition matrix.h:45
matrix_base.h
dlaf::common::iterate_range2d
IterableRange2D< IndexT, Tag > iterate_range2d(Index2D< IndexT, Tag > begin_idx, Index2D< IndexT, Tag > end_idx) noexcept
Definition range2d.h:247
diff --git a/master/matrix__base_8h_source.html b/master/matrix__base_8h_source.html index 7aab026265..aee069b3aa 100644 --- a/master/matrix__base_8h_source.html +++ b/master/matrix__base_8h_source.html @@ -286,7 +286,7 @@
dlaf::matrix::Distribution::tile_size_of
TileElementSize tile_size_of(const GlobalTileIndex &index) const noexcept
Definition distribution.h:345
dlaf::matrix::Distribution::local_nr_tiles
const LocalTileSize & local_nr_tiles() const noexcept
Returns the number of tiles stored locally (2D size).
Definition distribution.h:241
dlaf::matrix::Distribution::rank_global_tile
comm::Index2D rank_global_tile(const GlobalTileIndex &global_tile) const noexcept
Definition distribution.h:310
-
dlaf::matrix::Matrix
Definition matrix.h:61
+
dlaf::matrix::Matrix
Definition matrix.h:62
dlaf::matrix::internal::MatrixBase
Definition matrix_base.h:34
dlaf::matrix::internal::MatrixBase::rank_index
const comm::Index2D & rank_index() const noexcept
Returns the id associated to the matrix of this rank.
Definition matrix_base.h:75
dlaf::matrix::internal::MatrixBase::source_rank_index
const comm::Index2D & source_rank_index() const noexcept
Returns the 2D rank index of the process that stores the top-left tile of the matrix.
Definition matrix_base.h:80
diff --git a/master/matrix__mirror_8h.html b/master/matrix__mirror_8h.html index 6fa2e1309a..9592f53cad 100644 --- a/master/matrix__mirror_8h.html +++ b/master/matrix__mirror_8h.html @@ -79,7 +79,8 @@
matrix_mirror.h File Reference
-
#include <exception>
+
#include <complex>
+#include <exception>
#include <vector>
#include <dlaf/matrix/copy.h>
#include <dlaf/matrix/matrix.h>
diff --git a/master/matrix__mirror_8h_source.html b/master/matrix__mirror_8h_source.html index f735fca988..297c3165f3 100644 --- a/master/matrix__mirror_8h_source.html +++ b/master/matrix__mirror_8h_source.html @@ -94,196 +94,197 @@
11#pragma once
12
14
-
15#include <exception>
-
16#include <vector>
-
17
-
18#include <dlaf/matrix/copy.h>
-
19#include <dlaf/matrix/matrix.h>
-
20#include <dlaf/matrix/matrix_base.h>
-
21#include <dlaf/types.h>
-
22
-
23namespace dlaf {
-
24namespace matrix {
-
25
-
32template <class T, Device Target, Device Source>
-
33class MatrixMirror;
-
34
-
40template <class T, Device SourceTarget>
-
-
41class MatrixMirror<const T, SourceTarget, SourceTarget> {
-
42protected:
-
43 Matrix<const T, SourceTarget>& mat_source;
-
44
-
45public:
-
47 MatrixMirror(Matrix<const T, SourceTarget>& mat_source) : mat_source(mat_source) {}
-
48
-
-
50 Matrix<const T, SourceTarget>& get() {
-
51 return mat_source;
-
52 }
+
15#include <complex>
+
16#include <exception>
+
17#include <vector>
+
18
+
19#include <dlaf/matrix/copy.h>
+
20#include <dlaf/matrix/matrix.h>
+
21#include <dlaf/matrix/matrix_base.h>
+
22#include <dlaf/types.h>
+
23
+
24namespace dlaf {
+
25namespace matrix {
+
26
+
33template <class T, Device Target, Device Source>
+
34class MatrixMirror;
+
35
+
41template <class T, Device SourceTarget>
+
+
42class MatrixMirror<const T, SourceTarget, SourceTarget> {
+
43protected:
+
44 Matrix<const T, SourceTarget>& mat_source;
+
45
+
46public:
+
48 MatrixMirror(Matrix<const T, SourceTarget>& mat_source) : mat_source(mat_source) {}
+
49
+
+
51 Matrix<const T, SourceTarget>& get() {
+
52 return mat_source;
+
53 }
-
53
-
-
55 Matrix<const T, SourceTarget>& getSource() {
-
56 return mat_source;
-
57 }
+
54
+
+
56 Matrix<const T, SourceTarget>& getSource() {
+
57 return mat_source;
+
58 }
-
58};
+
59};
-
59
-
66template <class T, Device SourceTarget>
-
-
67class MatrixMirror<T, SourceTarget, SourceTarget>
-
68 : public MatrixMirror<const T, SourceTarget, SourceTarget> {
-
69 using base_type = MatrixMirror<const T, SourceTarget, SourceTarget>;
-
70 Matrix<T, SourceTarget>& mat_source;
-
71
-
72public:
-
74 MatrixMirror(Matrix<T, SourceTarget>& mat_source) : base_type(mat_source), mat_source(mat_source) {}
-
75
-
-
77 Matrix<T, SourceTarget>& get() {
-
78 return mat_source;
-
79 }
+
60
+
67template <class T, Device SourceTarget>
+
+
68class MatrixMirror<T, SourceTarget, SourceTarget>
+
69 : public MatrixMirror<const T, SourceTarget, SourceTarget> {
+
70 using base_type = MatrixMirror<const T, SourceTarget, SourceTarget>;
+
71 Matrix<T, SourceTarget>& mat_source;
+
72
+
73public:
+
75 MatrixMirror(Matrix<T, SourceTarget>& mat_source) : base_type(mat_source), mat_source(mat_source) {}
+
76
+
+
78 Matrix<T, SourceTarget>& get() {
+
79 return mat_source;
+
80 }
-
80
-
-
82 Matrix<T, SourceTarget>& getSource() {
-
83 return mat_source;
-
84 }
+
81
+
+
83 Matrix<T, SourceTarget>& getSource() {
+
84 return mat_source;
+
85 }
-
85
-
88 void copySourceToTarget() {}
-
89
-
92 void copyTargetToSource() {}
-
93};
+
86
+
89 void copySourceToTarget() {}
+
90
+
93 void copyTargetToSource() {}
+
94};
-
94
-
101template <class T, Device Target, Device Source>
-
-
102class MatrixMirror<const T, Target, Source> {
-
103protected:
-
104 Matrix<T, Target> mat_target;
-
105 Matrix<const T, Source>& mat_source;
-
106
-
107public:
-
-
110 MatrixMirror(Matrix<const T, Source>& mat_source)
-
111 : mat_target(mat_source.distribution()), mat_source(mat_source) {
-
112 copy(mat_source, mat_target);
-
113 }
+
95
+
102template <class T, Device Target, Device Source>
+
+
103class MatrixMirror<const T, Target, Source> {
+
104protected:
+
105 Matrix<T, Target> mat_target;
+
106 Matrix<const T, Source>& mat_source;
+
107
+
108public:
+
+
111 MatrixMirror(Matrix<const T, Source>& mat_source)
+
112 : mat_target(mat_source.distribution()), mat_source(mat_source) {
+
113 copy(mat_source, mat_target);
+
114 }
-
114
-
116 virtual ~MatrixMirror() = default;
-
117
-
-
119 Matrix<const T, Target>& get() {
-
120 return mat_target;
-
121 }
+
115
+
117 virtual ~MatrixMirror() = default;
+
118
+
+
120 Matrix<const T, Target>& get() {
+
121 return mat_target;
+
122 }
-
122
-
-
124 Matrix<const T, Source>& getSource() {
-
125 return mat_source;
-
126 }
+
123
+
+
125 Matrix<const T, Source>& getSource() {
+
126 return mat_source;
+
127 }
-
127};
+
128};
-
128
-
137template <class T, Device Target, Device Source>
-
-
138class MatrixMirror : public MatrixMirror<const T, Target, Source> {
-
139 using base_type = MatrixMirror<const T, Target, Source>;
-
140 using base_type::mat_target;
-
141 Matrix<T, Source>& mat_source;
-
142
-
143public:
-
146 MatrixMirror(Matrix<T, Source>& mat_source) : base_type(mat_source), mat_source(mat_source) {}
-
147
-
-
150 ~MatrixMirror() {
-
151 copyTargetToSource();
-
152 }
+
129
+
138template <class T, Device Target, Device Source>
+
+
139class MatrixMirror : public MatrixMirror<const T, Target, Source> {
+
140 using base_type = MatrixMirror<const T, Target, Source>;
+
141 using base_type::mat_target;
+
142 Matrix<T, Source>& mat_source;
+
143
+
144public:
+
147 MatrixMirror(Matrix<T, Source>& mat_source) : base_type(mat_source), mat_source(mat_source) {}
+
148
+
+
151 ~MatrixMirror() {
+
152 copyTargetToSource();
+
153 }
-
153
-
-
155 Matrix<T, Target>& get() {
-
156 return mat_target;
-
157 }
+
154
+
+
156 Matrix<T, Target>& get() {
+
157 return mat_target;
+
158 }
-
158
-
-
160 Matrix<T, Source>& getSource() {
-
161 return mat_source;
-
162 }
+
159
+
+
161 Matrix<T, Source>& getSource() {
+
162 return mat_source;
+
163 }
-
163
-
-
165 void copySourceToTarget() {
-
166 copy(mat_source, mat_target);
-
167 }
+
164
+
+
166 void copySourceToTarget() {
+
167 copy(mat_source, mat_target);
+
168 }
-
168
-
-
170 void copyTargetToSource() {
-
171 copy(mat_target, mat_source);
-
172 }
+
169
+
+
171 void copyTargetToSource() {
+
172 copy(mat_target, mat_source);
+
173 }
-
173};
+
174};
-
174
-
175// ETI
-
176
-
177#define DLAF_MATRIX_MIRROR_ETI(KWORD, DATATYPE, TARGETDEVICE, SOURCEDEVICE) \
-
178 KWORD template class MatrixMirror<DATATYPE, TARGETDEVICE, SOURCEDEVICE>; \
-
179 KWORD template class MatrixMirror<const DATATYPE, TARGETDEVICE, SOURCEDEVICE>;
-
180
-
181DLAF_MATRIX_MIRROR_ETI(extern, float, Device::CPU, Device::CPU)
-
182DLAF_MATRIX_MIRROR_ETI(extern, double, Device::CPU, Device::CPU)
-
183DLAF_MATRIX_MIRROR_ETI(extern, std::complex<float>, Device::CPU, Device::CPU)
-
184DLAF_MATRIX_MIRROR_ETI(extern, std::complex<double>, Device::CPU, Device::CPU)
-
185
-
186#ifdef DLAF_WITH_GPU
-
187DLAF_MATRIX_MIRROR_ETI(extern, float, Device::CPU, Device::GPU)
-
188DLAF_MATRIX_MIRROR_ETI(extern, double, Device::CPU, Device::GPU)
-
189DLAF_MATRIX_MIRROR_ETI(extern, std::complex<float>, Device::CPU, Device::GPU)
-
190DLAF_MATRIX_MIRROR_ETI(extern, std::complex<double>, Device::CPU, Device::GPU)
-
191
-
192DLAF_MATRIX_MIRROR_ETI(extern, float, Device::GPU, Device::CPU)
-
193DLAF_MATRIX_MIRROR_ETI(extern, double, Device::GPU, Device::CPU)
-
194DLAF_MATRIX_MIRROR_ETI(extern, std::complex<float>, Device::GPU, Device::CPU)
-
195DLAF_MATRIX_MIRROR_ETI(extern, std::complex<double>, Device::GPU, Device::CPU)
-
196
-
197DLAF_MATRIX_MIRROR_ETI(extern, float, Device::GPU, Device::GPU)
-
198DLAF_MATRIX_MIRROR_ETI(extern, double, Device::GPU, Device::GPU)
-
199DLAF_MATRIX_MIRROR_ETI(extern, std::complex<float>, Device::GPU, Device::GPU)
-
200DLAF_MATRIX_MIRROR_ETI(extern, std::complex<double>, Device::GPU, Device::GPU)
-
201#endif
-
202
-
203}
+
175
+
176// ETI
+
177
+
178#define DLAF_MATRIX_MIRROR_ETI(KWORD, DATATYPE, TARGETDEVICE, SOURCEDEVICE) \
+
179 KWORD template class MatrixMirror<DATATYPE, TARGETDEVICE, SOURCEDEVICE>; \
+
180 KWORD template class MatrixMirror<const DATATYPE, TARGETDEVICE, SOURCEDEVICE>;
+
181
+
182DLAF_MATRIX_MIRROR_ETI(extern, float, Device::CPU, Device::CPU)
+
183DLAF_MATRIX_MIRROR_ETI(extern, double, Device::CPU, Device::CPU)
+
184DLAF_MATRIX_MIRROR_ETI(extern, std::complex<float>, Device::CPU, Device::CPU)
+
185DLAF_MATRIX_MIRROR_ETI(extern, std::complex<double>, Device::CPU, Device::CPU)
+
186
+
187#ifdef DLAF_WITH_GPU
+
188DLAF_MATRIX_MIRROR_ETI(extern, float, Device::CPU, Device::GPU)
+
189DLAF_MATRIX_MIRROR_ETI(extern, double, Device::CPU, Device::GPU)
+
190DLAF_MATRIX_MIRROR_ETI(extern, std::complex<float>, Device::CPU, Device::GPU)
+
191DLAF_MATRIX_MIRROR_ETI(extern, std::complex<double>, Device::CPU, Device::GPU)
+
192
+
193DLAF_MATRIX_MIRROR_ETI(extern, float, Device::GPU, Device::CPU)
+
194DLAF_MATRIX_MIRROR_ETI(extern, double, Device::GPU, Device::CPU)
+
195DLAF_MATRIX_MIRROR_ETI(extern, std::complex<float>, Device::GPU, Device::CPU)
+
196DLAF_MATRIX_MIRROR_ETI(extern, std::complex<double>, Device::GPU, Device::CPU)
+
197
+
198DLAF_MATRIX_MIRROR_ETI(extern, float, Device::GPU, Device::GPU)
+
199DLAF_MATRIX_MIRROR_ETI(extern, double, Device::GPU, Device::GPU)
+
200DLAF_MATRIX_MIRROR_ETI(extern, std::complex<float>, Device::GPU, Device::GPU)
+
201DLAF_MATRIX_MIRROR_ETI(extern, std::complex<double>, Device::GPU, Device::GPU)
+
202#endif
+
203
204}
-
dlaf::matrix::Matrix
Definition matrix.h:61
-
dlaf::matrix::MatrixMirror< T, SourceTarget, SourceTarget >::copyTargetToSource
void copyTargetToSource()
Definition matrix_mirror.h:92
-
dlaf::matrix::MatrixMirror< T, SourceTarget, SourceTarget >::get
Matrix< T, SourceTarget > & get()
Return a reference to the mirror matrix on the target device.
Definition matrix_mirror.h:77
-
dlaf::matrix::MatrixMirror< T, SourceTarget, SourceTarget >::MatrixMirror
MatrixMirror(Matrix< T, SourceTarget > &mat_source)
Create a mirror of the source matrix mat_source.
Definition matrix_mirror.h:74
-
dlaf::matrix::MatrixMirror< T, SourceTarget, SourceTarget >::copySourceToTarget
void copySourceToTarget()
Definition matrix_mirror.h:88
-
dlaf::matrix::MatrixMirror< T, SourceTarget, SourceTarget >::getSource
Matrix< T, SourceTarget > & getSource()
Return a reference to the source matrix.
Definition matrix_mirror.h:82
- -
dlaf::matrix::MatrixMirror< const T, SourceTarget, SourceTarget >::getSource
Matrix< const T, SourceTarget > & getSource()
Return a reference to the source matrix.
Definition matrix_mirror.h:55
-
dlaf::matrix::MatrixMirror< const T, SourceTarget, SourceTarget >::MatrixMirror
MatrixMirror(Matrix< const T, SourceTarget > &mat_source)
Create a matrix mirror of the source matrix mat_source.
Definition matrix_mirror.h:47
-
dlaf::matrix::MatrixMirror< const T, SourceTarget, SourceTarget >::get
Matrix< const T, SourceTarget > & get()
Return a reference to the mirror matrix on the target device.
Definition matrix_mirror.h:50
- +
205}
+
dlaf::matrix::Matrix
Definition matrix.h:62
+
dlaf::matrix::MatrixMirror< T, SourceTarget, SourceTarget >::copyTargetToSource
void copyTargetToSource()
Definition matrix_mirror.h:93
+
dlaf::matrix::MatrixMirror< T, SourceTarget, SourceTarget >::get
Matrix< T, SourceTarget > & get()
Return a reference to the mirror matrix on the target device.
Definition matrix_mirror.h:78
+
dlaf::matrix::MatrixMirror< T, SourceTarget, SourceTarget >::MatrixMirror
MatrixMirror(Matrix< T, SourceTarget > &mat_source)
Create a mirror of the source matrix mat_source.
Definition matrix_mirror.h:75
+
dlaf::matrix::MatrixMirror< T, SourceTarget, SourceTarget >::copySourceToTarget
void copySourceToTarget()
Definition matrix_mirror.h:89
+
dlaf::matrix::MatrixMirror< T, SourceTarget, SourceTarget >::getSource
Matrix< T, SourceTarget > & getSource()
Return a reference to the source matrix.
Definition matrix_mirror.h:83
+ +
dlaf::matrix::MatrixMirror< const T, SourceTarget, SourceTarget >::getSource
Matrix< const T, SourceTarget > & getSource()
Return a reference to the source matrix.
Definition matrix_mirror.h:56
+
dlaf::matrix::MatrixMirror< const T, SourceTarget, SourceTarget >::MatrixMirror
MatrixMirror(Matrix< const T, SourceTarget > &mat_source)
Create a matrix mirror of the source matrix mat_source.
Definition matrix_mirror.h:48
+
dlaf::matrix::MatrixMirror< const T, SourceTarget, SourceTarget >::get
Matrix< const T, SourceTarget > & get()
Return a reference to the mirror matrix on the target device.
Definition matrix_mirror.h:51
+
dlaf::matrix::MatrixMirror< const T, Target, Source >::~MatrixMirror
virtual ~MatrixMirror()=default
Release the target matrix.
-
dlaf::matrix::MatrixMirror< const T, Target, Source >::getSource
Matrix< const T, Source > & getSource()
Return a reference to the source matrix.
Definition matrix_mirror.h:124
-
dlaf::matrix::MatrixMirror< const T, Target, Source >::get
Matrix< const T, Target > & get()
Return a reference to the mirror matrix on the target device.
Definition matrix_mirror.h:119
-
dlaf::matrix::MatrixMirror< const T, Target, Source >::MatrixMirror
MatrixMirror(Matrix< const T, Source > &mat_source)
Definition matrix_mirror.h:110
-
dlaf::matrix::MatrixMirror
Definition matrix_mirror.h:138
-
dlaf::matrix::MatrixMirror::get
Matrix< T, Target > & get()
Return a reference to the mirror matrix on the target device.
Definition matrix_mirror.h:155
-
dlaf::matrix::MatrixMirror::MatrixMirror
MatrixMirror(Matrix< T, Source > &mat_source)
Definition matrix_mirror.h:146
-
dlaf::matrix::MatrixMirror::getSource
Matrix< T, Source > & getSource()
Return a reference to the source matrix.
Definition matrix_mirror.h:160
-
dlaf::matrix::MatrixMirror::copyTargetToSource
void copyTargetToSource()
Copies the target to the source matrix.
Definition matrix_mirror.h:170
-
dlaf::matrix::MatrixMirror::~MatrixMirror
~MatrixMirror()
Definition matrix_mirror.h:150
-
dlaf::matrix::MatrixMirror::copySourceToTarget
void copySourceToTarget()
Copies the source to the target matrix.
Definition matrix_mirror.h:165
+
dlaf::matrix::MatrixMirror< const T, Target, Source >::getSource
Matrix< const T, Source > & getSource()
Return a reference to the source matrix.
Definition matrix_mirror.h:125
+
dlaf::matrix::MatrixMirror< const T, Target, Source >::get
Matrix< const T, Target > & get()
Return a reference to the mirror matrix on the target device.
Definition matrix_mirror.h:120
+
dlaf::matrix::MatrixMirror< const T, Target, Source >::MatrixMirror
MatrixMirror(Matrix< const T, Source > &mat_source)
Definition matrix_mirror.h:111
+
dlaf::matrix::MatrixMirror
Definition matrix_mirror.h:139
+
dlaf::matrix::MatrixMirror::get
Matrix< T, Target > & get()
Return a reference to the mirror matrix on the target device.
Definition matrix_mirror.h:156
+
dlaf::matrix::MatrixMirror::MatrixMirror
MatrixMirror(Matrix< T, Source > &mat_source)
Definition matrix_mirror.h:147
+
dlaf::matrix::MatrixMirror::getSource
Matrix< T, Source > & getSource()
Return a reference to the source matrix.
Definition matrix_mirror.h:161
+
dlaf::matrix::MatrixMirror::copyTargetToSource
void copyTargetToSource()
Copies the target to the source matrix.
Definition matrix_mirror.h:171
+
dlaf::matrix::MatrixMirror::~MatrixMirror
~MatrixMirror()
Definition matrix_mirror.h:151
+
dlaf::matrix::MatrixMirror::copySourceToTarget
void copySourceToTarget()
Copies the source to the target matrix.
Definition matrix_mirror.h:166
matrix_base.h
diff --git a/master/matrix__ref_8h.html b/master/matrix__ref_8h.html index 8c3b0be95f..209a9d6e80 100644 --- a/master/matrix__ref_8h.html +++ b/master/matrix__ref_8h.html @@ -80,7 +80,8 @@
matrix_ref.h File Reference
-
#include <utility>
+
#include <complex>
+#include <utility>
#include <dlaf/matrix/distribution.h>
#include <dlaf/matrix/matrix.h>
#include <dlaf/matrix/matrix_base.h>
diff --git a/master/matrix__ref_8h_source.html b/master/matrix__ref_8h_source.html index 997b44c362..105689e16d 100644 --- a/master/matrix__ref_8h_source.html +++ b/master/matrix__ref_8h_source.html @@ -94,253 +94,254 @@
11#pragma once
12
14
-
15#include <utility>
-
16
-
17#include <dlaf/matrix/distribution.h>
-
18#include <dlaf/matrix/matrix.h>
-
19#include <dlaf/matrix/matrix_base.h>
-
20#include <dlaf/matrix/tile.h>
-
21#include <dlaf/types.h>
-
22
-
23namespace dlaf::matrix::internal {
-
24
-
26using SubMatrixSpec = SubDistributionSpec;
-
27
-
34template <class T, Device D>
-
35class MatrixRef;
-
36
-
37template <class T, Device D>
-
-
38class MatrixRef<const T, D> : public internal::MatrixBase {
-
39public:
-
40 static constexpr Device device = D;
-
41
-
42 using ElementType = T;
-
43 using TileType = Tile<ElementType, D>;
-
44 using ConstTileType = Tile<const ElementType, D>;
-
45 using TileDataType = internal::TileData<ElementType, D>;
-
46 using ReadOnlySenderType = ReadOnlyTileSender<T, D>;
-
47 using ReadWriteSenderType = ReadWriteTileSender<ElementType, D>;
-
48 friend class Matrix<const ElementType, D>;
-
49
-
-
57 MatrixRef(Matrix<const T, D>& mat, const SubMatrixSpec& spec)
-
58 : internal::MatrixBase(Distribution(mat.distribution(), spec)), mat_const_(mat),
-
59 origin_(spec.origin) {}
+
15#include <complex>
+
16#include <utility>
+
17
+
18#include <dlaf/matrix/distribution.h>
+
19#include <dlaf/matrix/matrix.h>
+
20#include <dlaf/matrix/matrix_base.h>
+
21#include <dlaf/matrix/tile.h>
+
22#include <dlaf/types.h>
+
23
+
24namespace dlaf::matrix::internal {
+
25
+
27using SubMatrixSpec = SubDistributionSpec;
+
28
+
35template <class T, Device D>
+
36class MatrixRef;
+
37
+
38template <class T, Device D>
+
+
39class MatrixRef<const T, D> : public internal::MatrixBase {
+
40public:
+
41 static constexpr Device device = D;
+
42
+
43 using ElementType = T;
+
44 using TileType = Tile<ElementType, D>;
+
45 using ConstTileType = Tile<const ElementType, D>;
+
46 using TileDataType = internal::TileData<ElementType, D>;
+
47 using ReadOnlySenderType = ReadOnlyTileSender<T, D>;
+
48 using ReadWriteSenderType = ReadWriteTileSender<ElementType, D>;
+
49 friend class Matrix<const ElementType, D>;
+
50
+
+
58 MatrixRef(Matrix<const T, D>& mat, const SubMatrixSpec& spec)
+
59 : internal::MatrixBase(Distribution(mat.distribution(), spec)), mat_const_(mat),
+
60 origin_(spec.origin) {}
-
60
-
64 MatrixRef(Matrix<const T, D>& mat) : MatrixRef<const T, D>(mat, {{0, 0}, mat.distribution().size()}) {}
-
65
-
66 MatrixRef() = delete;
-
67 MatrixRef(MatrixRef&&) = delete;
-
68 MatrixRef(const MatrixRef&) = delete;
-
69 MatrixRef& operator=(MatrixRef&&) = delete;
-
70 MatrixRef& operator=(const MatrixRef&) = delete;
-
71
-
-
82 Matrix<const T, D> retiledSubPipelineConst(const LocalTileSize& tiles_per_block) {
-
83 DLAF_ASSERT(origin_.row() == 0 && origin_.col() == 0, origin_);
-
84 return Matrix<const T, D>(*this, tiles_per_block);
-
85 }
+
61
+
65 MatrixRef(Matrix<const T, D>& mat) : MatrixRef<const T, D>(mat, {{0, 0}, mat.distribution().size()}) {}
+
66
+
67 MatrixRef() = delete;
+
68 MatrixRef(MatrixRef&&) = delete;
+
69 MatrixRef(const MatrixRef&) = delete;
+
70 MatrixRef& operator=(MatrixRef&&) = delete;
+
71 MatrixRef& operator=(const MatrixRef&) = delete;
+
72
+
+
83 Matrix<const T, D> retiledSubPipelineConst(const LocalTileSize& tiles_per_block) {
+
84 DLAF_ASSERT(origin_.row() == 0 && origin_.col() == 0, origin_);
+
85 return Matrix<const T, D>(*this, tiles_per_block);
+
86 }
-
86
-
-
90 ReadOnlySenderType read(const LocalTileIndex& index) noexcept {
-
91 // Note: this forwards to the overload with GlobalTileIndex which will
-
92 // handle taking a subtile if needed
-
93 return read(distribution().globalTileIndex(index));
-
94 }
+
87
+
+
91 ReadOnlySenderType read(const LocalTileIndex& index) noexcept {
+
92 // Note: this forwards to the overload with GlobalTileIndex which will
+
93 // handle taking a subtile if needed
+
94 return read(distribution().globalTileIndex(index));
+
95 }
-
95
-
-
100 ReadOnlySenderType read(const GlobalTileIndex& index) {
-
101 DLAF_ASSERT(index.isIn(distribution().nrTiles()), index, distribution().nrTiles());
-
102
-
103 const auto parent_index(
-
104 mat_const_.distribution().globalTileIndexFromSubDistribution(origin_, distribution(), index));
-
105 auto tile_sender = mat_const_.read(parent_index);
-
106
-
107 const auto parent_dist = mat_const_.distribution();
-
108 const auto parent_tile_size = parent_dist.tileSize(parent_index);
-
109 const auto tile_size = tileSize(index);
-
110
-
111 // If the corresponding tile in the parent distribution is exactly the same
-
112 // size as the tile in the sub-distribution, we don't need to take a subtile
-
113 // and can return the tile sender directly. This avoids unnecessary wrapping.
-
114 if (parent_tile_size == tile_size) {
-
115 return tile_sender;
-
116 }
-
117
-
118 // Otherwise we have to extract a subtile from the tile in the parent
-
119 // distribution.
-
120 const auto ij_tile =
-
121 parent_dist.tileElementOffsetFromSubDistribution(origin_, distribution(), index);
-
122 return splitTile(std::move(tile_sender), SubTileSpec{ij_tile, tile_size});
-
123 }
+
96
+
+
101 ReadOnlySenderType read(const GlobalTileIndex& index) {
+
102 DLAF_ASSERT(index.isIn(distribution().nrTiles()), index, distribution().nrTiles());
+
103
+
104 const auto parent_index(
+
105 mat_const_.distribution().globalTileIndexFromSubDistribution(origin_, distribution(), index));
+
106 auto tile_sender = mat_const_.read(parent_index);
+
107
+
108 const auto parent_dist = mat_const_.distribution();
+
109 const auto parent_tile_size = parent_dist.tileSize(parent_index);
+
110 const auto tile_size = tileSize(index);
+
111
+
112 // If the corresponding tile in the parent distribution is exactly the same
+
113 // size as the tile in the sub-distribution, we don't need to take a subtile
+
114 // and can return the tile sender directly. This avoids unnecessary wrapping.
+
115 if (parent_tile_size == tile_size) {
+
116 return tile_sender;
+
117 }
+
118
+
119 // Otherwise we have to extract a subtile from the tile in the parent
+
120 // distribution.
+
121 const auto ij_tile =
+
122 parent_dist.tileElementOffsetFromSubDistribution(origin_, distribution(), index);
+
123 return splitTile(std::move(tile_sender), SubTileSpec{ij_tile, tile_size});
+
124 }
-
124
-
125private:
-
126 Matrix<const T, D>& mat_const_;
-
127
-
128protected:
-
129 GlobalElementIndex origin_;
-
130
-
-
134 ReadWriteSenderType readwrite(const LocalTileIndex& index) noexcept {
-
135 // Note: this forwards to the overload with GlobalTileIndex which will
-
136 // handle taking a subtile if needed
-
137 return readwrite(this->distribution().globalTileIndex(index));
-
138 }
+
125
+
126private:
+
127 Matrix<const T, D>& mat_const_;
+
128
+
129protected:
+
130 GlobalElementIndex origin_;
+
131
+
+
135 ReadWriteSenderType readwrite(const LocalTileIndex& index) noexcept {
+
136 // Note: this forwards to the overload with GlobalTileIndex which will
+
137 // handle taking a subtile if needed
+
138 return readwrite(this->distribution().globalTileIndex(index));
+
139 }
-
139
-
-
144 ReadWriteSenderType readwrite(const GlobalTileIndex& index) {
-
145 DLAF_ASSERT(index.isIn(this->distribution().nrTiles()), index, this->distribution().nrTiles());
-
146
-
147 const auto parent_index(mat_const_.distribution().globalTileIndexFromSubDistribution(
-
148 origin_, this->distribution(), index));
-
149 auto tile_sender = mat_const_.readwrite(parent_index);
-
150
-
151 const auto parent_dist = mat_const_.distribution();
-
152 const auto parent_tile_size = parent_dist.tileSize(parent_index);
-
153 const auto tile_size = this->tileSize(index);
-
154
-
155 // If the corresponding tile in the parent distribution is exactly the same
-
156 // size as the tile in the sub-distribution, we don't need to take a subtile
-
157 // and can return the tile sender directly. This avoids unnecessary wrapping.
-
158 if (parent_tile_size == tile_size) {
-
159 return tile_sender;
-
160 }
-
161
-
162 // Otherwise we have to extract a subtile from the tile in the parent
-
163 // distribution.
-
164 const auto ij_tile =
-
165 parent_dist.tileElementOffsetFromSubDistribution(origin_, this->distribution(), index);
-
166 return splitTile(std::move(tile_sender), SubTileSpec{ij_tile, tile_size});
-
167 }
+
140
+
+
145 ReadWriteSenderType readwrite(const GlobalTileIndex& index) {
+
146 DLAF_ASSERT(index.isIn(this->distribution().nrTiles()), index, this->distribution().nrTiles());
+
147
+
148 const auto parent_index(mat_const_.distribution().globalTileIndexFromSubDistribution(
+
149 origin_, this->distribution(), index));
+
150 auto tile_sender = mat_const_.readwrite(parent_index);
+
151
+
152 const auto parent_dist = mat_const_.distribution();
+
153 const auto parent_tile_size = parent_dist.tileSize(parent_index);
+
154 const auto tile_size = this->tileSize(index);
+
155
+
156 // If the corresponding tile in the parent distribution is exactly the same
+
157 // size as the tile in the sub-distribution, we don't need to take a subtile
+
158 // and can return the tile sender directly. This avoids unnecessary wrapping.
+
159 if (parent_tile_size == tile_size) {
+
160 return tile_sender;
+
161 }
+
162
+
163 // Otherwise we have to extract a subtile from the tile in the parent
+
164 // distribution.
+
165 const auto ij_tile =
+
166 parent_dist.tileElementOffsetFromSubDistribution(origin_, this->distribution(), index);
+
167 return splitTile(std::move(tile_sender), SubTileSpec{ij_tile, tile_size});
+
168 }
-
168};
+
169};
-
169
-
170template <class T, Device D>
-
-
171class MatrixRef : public MatrixRef<const T, D> {
-
172public:
-
173 static constexpr Device device = D;
-
174
-
175 using ElementType = T;
-
176 using TileType = Tile<ElementType, D>;
-
177 using ConstTileType = Tile<const ElementType, D>;
-
178 using TileDataType = internal::TileData<ElementType, D>;
-
179 using ReadWriteSenderType = ReadWriteTileSender<T, D>;
-
180
-
-
188 MatrixRef(Matrix<T, D>& mat, const SubMatrixSpec& spec)
-
189 : MatrixRef<const T, D>(mat, spec), mat_(mat) {}
+
170
+
171template <class T, Device D>
+
+
172class MatrixRef : public MatrixRef<const T, D> {
+
173public:
+
174 static constexpr Device device = D;
+
175
+
176 using ElementType = T;
+
177 using TileType = Tile<ElementType, D>;
+
178 using ConstTileType = Tile<const ElementType, D>;
+
179 using TileDataType = internal::TileData<ElementType, D>;
+
180 using ReadWriteSenderType = ReadWriteTileSender<T, D>;
+
181
+
+
189 MatrixRef(Matrix<T, D>& mat, const SubMatrixSpec& spec)
+
190 : MatrixRef<const T, D>(mat, spec), mat_(mat) {}
-
190
-
194 MatrixRef(Matrix<T, D>& mat) : MatrixRef<const T, D>(mat), mat_(mat) {}
-
195
-
196 MatrixRef() = delete;
-
197 MatrixRef(MatrixRef&&) = delete;
-
198 MatrixRef(const MatrixRef&) = delete;
-
199 MatrixRef& operator=(MatrixRef&&) = delete;
-
200 MatrixRef& operator=(const MatrixRef&) = delete;
-
201
-
-
212 Matrix<T, D> retiledSubPipeline(const LocalTileSize& tiles_per_block) noexcept {
-
213 DLAF_ASSERT(origin_.row() == 0 && origin_.col() == 0, origin_);
-
214 return Matrix<T, D>(*this, tiles_per_block);
-
215 }
+
191
+
195 MatrixRef(Matrix<T, D>& mat) : MatrixRef<const T, D>(mat), mat_(mat) {}
+
196
+
197 MatrixRef() = delete;
+
198 MatrixRef(MatrixRef&&) = delete;
+
199 MatrixRef(const MatrixRef&) = delete;
+
200 MatrixRef& operator=(MatrixRef&&) = delete;
+
201 MatrixRef& operator=(const MatrixRef&) = delete;
+
202
+
+
213 Matrix<T, D> retiledSubPipeline(const LocalTileSize& tiles_per_block) noexcept {
+
214 DLAF_ASSERT(origin_.row() == 0 && origin_.col() == 0, origin_);
+
215 return Matrix<T, D>(*this, tiles_per_block);
+
216 }
-
216
-
-
220 ReadWriteSenderType readwrite(const LocalTileIndex& index) noexcept {
-
221 // Note: this forwards to the overload with GlobalTileIndex which will
-
222 // handle taking a subtile if needed
-
223 return readwrite(this->distribution().globalTileIndex(index));
-
224 }
+
217
+
+
221 ReadWriteSenderType readwrite(const LocalTileIndex& index) noexcept {
+
222 // Note: this forwards to the overload with GlobalTileIndex which will
+
223 // handle taking a subtile if needed
+
224 return readwrite(this->distribution().globalTileIndex(index));
+
225 }
-
225
-
-
230 ReadWriteSenderType readwrite(const GlobalTileIndex& index) {
-
231 DLAF_ASSERT(index.isIn(this->distribution().nrTiles()), index, this->distribution().nrTiles());
-
232
-
233 const auto parent_index(
-
234 mat_.distribution().globalTileIndexFromSubDistribution(origin_, this->distribution(), index));
-
235 auto tile_sender = mat_.readwrite(parent_index);
-
236
-
237 const auto parent_dist = mat_.distribution();
-
238 const auto parent_tile_size = parent_dist.tileSize(parent_index);
-
239 const auto tile_size = this->tileSize(index);
-
240
-
241 // If the corresponding tile in the parent distribution is exactly the same
-
242 // size as the tile in the sub-distribution, we don't need to take a subtile
-
243 // and can return the tile sender directly. This avoids unnecessary wrapping.
-
244 if (parent_tile_size == tile_size) {
-
245 return tile_sender;
-
246 }
-
247
-
248 // Otherwise we have to extract a subtile from the tile in the parent
-
249 // distribution.
-
250 const auto ij_tile =
-
251 parent_dist.tileElementOffsetFromSubDistribution(origin_, this->distribution(), index);
-
252 return splitTile(std::move(tile_sender), SubTileSpec{ij_tile, tile_size});
-
253 }
+
226
+
+
231 ReadWriteSenderType readwrite(const GlobalTileIndex& index) {
+
232 DLAF_ASSERT(index.isIn(this->distribution().nrTiles()), index, this->distribution().nrTiles());
+
233
+
234 const auto parent_index(
+
235 mat_.distribution().globalTileIndexFromSubDistribution(origin_, this->distribution(), index));
+
236 auto tile_sender = mat_.readwrite(parent_index);
+
237
+
238 const auto parent_dist = mat_.distribution();
+
239 const auto parent_tile_size = parent_dist.tileSize(parent_index);
+
240 const auto tile_size = this->tileSize(index);
+
241
+
242 // If the corresponding tile in the parent distribution is exactly the same
+
243 // size as the tile in the sub-distribution, we don't need to take a subtile
+
244 // and can return the tile sender directly. This avoids unnecessary wrapping.
+
245 if (parent_tile_size == tile_size) {
+
246 return tile_sender;
+
247 }
+
248
+
249 // Otherwise we have to extract a subtile from the tile in the parent
+
250 // distribution.
+
251 const auto ij_tile =
+
252 parent_dist.tileElementOffsetFromSubDistribution(origin_, this->distribution(), index);
+
253 return splitTile(std::move(tile_sender), SubTileSpec{ij_tile, tile_size});
+
254 }
-
254
-
255private:
-
256 Matrix<T, D>& mat_;
-
257 using MatrixRef<const T, D>::origin_;
-
258};
+
255
+
256private:
+
257 Matrix<T, D>& mat_;
+
258 using MatrixRef<const T, D>::origin_;
+
259};
-
259
-
260// ETI
-
261
-
262#define DLAF_MATRIX_REF_ETI(KWORD, DATATYPE, DEVICE) \
-
263 KWORD template class MatrixRef<DATATYPE, DEVICE>; \
-
264 KWORD template class MatrixRef<const DATATYPE, DEVICE>;
-
265
-
266DLAF_MATRIX_REF_ETI(extern, float, Device::CPU)
-
267DLAF_MATRIX_REF_ETI(extern, double, Device::CPU)
-
268DLAF_MATRIX_REF_ETI(extern, std::complex<float>, Device::CPU)
-
269DLAF_MATRIX_REF_ETI(extern, std::complex<double>, Device::CPU)
-
270
-
271#if defined(DLAF_WITH_GPU)
-
272DLAF_MATRIX_REF_ETI(extern, float, Device::GPU)
-
273DLAF_MATRIX_REF_ETI(extern, double, Device::GPU)
-
274DLAF_MATRIX_REF_ETI(extern, std::complex<float>, Device::GPU)
-
275DLAF_MATRIX_REF_ETI(extern, std::complex<double>, Device::GPU)
-
276#endif
-
277}
+
260
+
261// ETI
+
262
+
263#define DLAF_MATRIX_REF_ETI(KWORD, DATATYPE, DEVICE) \
+
264 KWORD template class MatrixRef<DATATYPE, DEVICE>; \
+
265 KWORD template class MatrixRef<const DATATYPE, DEVICE>;
+
266
+
267DLAF_MATRIX_REF_ETI(extern, float, Device::CPU)
+
268DLAF_MATRIX_REF_ETI(extern, double, Device::CPU)
+
269DLAF_MATRIX_REF_ETI(extern, std::complex<float>, Device::CPU)
+
270DLAF_MATRIX_REF_ETI(extern, std::complex<double>, Device::CPU)
+
271
+
272#if defined(DLAF_WITH_GPU)
+
273DLAF_MATRIX_REF_ETI(extern, float, Device::GPU)
+
274DLAF_MATRIX_REF_ETI(extern, double, Device::GPU)
+
275DLAF_MATRIX_REF_ETI(extern, std::complex<float>, Device::GPU)
+
276DLAF_MATRIX_REF_ETI(extern, std::complex<double>, Device::GPU)
+
277#endif
+
278}
dlaf::common::Index2D::isIn
bool isIn(const Size2D< IndexT, Tag > &boundary) const noexcept
Definition index2d.h:214
dlaf::matrix::Distribution
Definition distribution.h:111
-
dlaf::matrix::Matrix
Definition matrix.h:61
-
dlaf::matrix::Matrix::readwrite
ReadWriteSenderType readwrite(const LocalTileIndex &index) noexcept
Definition matrix.h:153
+
dlaf::matrix::Matrix
Definition matrix.h:62
+
dlaf::matrix::Matrix::readwrite
ReadWriteSenderType readwrite(const LocalTileIndex &index) noexcept
Definition matrix.h:154
dlaf::matrix::internal::MatrixBase
Definition matrix_base.h:34
-
dlaf::matrix::internal::MatrixRef< const T, D >::retiledSubPipelineConst
Matrix< const T, D > retiledSubPipelineConst(const LocalTileSize &tiles_per_block)
Definition matrix_ref.h:82
-
dlaf::matrix::internal::MatrixRef< const T, D >::MatrixRef
MatrixRef(Matrix< const T, D > &mat, const SubMatrixSpec &spec)
Definition matrix_ref.h:57
-
dlaf::matrix::internal::MatrixRef< const T, D >::read
ReadOnlySenderType read(const LocalTileIndex &index) noexcept
Definition matrix_ref.h:90
-
dlaf::matrix::internal::MatrixRef< const T, D >::readwrite
ReadWriteSenderType readwrite(const LocalTileIndex &index) noexcept
Definition matrix_ref.h:134
-
dlaf::matrix::internal::MatrixRef< const T, D >::read
ReadOnlySenderType read(const GlobalTileIndex &index)
Definition matrix_ref.h:100
-
dlaf::matrix::internal::MatrixRef< const T, D >::MatrixRef
MatrixRef(Matrix< const T, D > &mat)
Definition matrix_ref.h:64
-
dlaf::matrix::internal::MatrixRef< const T, D >::readwrite
ReadWriteSenderType readwrite(const GlobalTileIndex &index)
Definition matrix_ref.h:144
-
dlaf::matrix::internal::MatrixRef
Definition matrix_ref.h:171
-
dlaf::matrix::internal::MatrixRef::MatrixRef
MatrixRef(Matrix< T, D > &mat, const SubMatrixSpec &spec)
Definition matrix_ref.h:188
-
dlaf::matrix::internal::MatrixRef::retiledSubPipeline
Matrix< T, D > retiledSubPipeline(const LocalTileSize &tiles_per_block) noexcept
Definition matrix_ref.h:212
-
dlaf::matrix::internal::MatrixRef::readwrite
ReadWriteSenderType readwrite(const LocalTileIndex &index) noexcept
Definition matrix_ref.h:220
-
dlaf::matrix::internal::MatrixRef::readwrite
ReadWriteSenderType readwrite(const GlobalTileIndex &index)
Definition matrix_ref.h:230
-
dlaf::matrix::internal::MatrixRef::MatrixRef
MatrixRef(Matrix< T, D > &mat)
Definition matrix_ref.h:194
- +
dlaf::matrix::internal::MatrixRef< const T, D >::retiledSubPipelineConst
Matrix< const T, D > retiledSubPipelineConst(const LocalTileSize &tiles_per_block)
Definition matrix_ref.h:83
+
dlaf::matrix::internal::MatrixRef< const T, D >::MatrixRef
MatrixRef(Matrix< const T, D > &mat, const SubMatrixSpec &spec)
Definition matrix_ref.h:58
+
dlaf::matrix::internal::MatrixRef< const T, D >::read
ReadOnlySenderType read(const LocalTileIndex &index) noexcept
Definition matrix_ref.h:91
+
dlaf::matrix::internal::MatrixRef< const T, D >::readwrite
ReadWriteSenderType readwrite(const LocalTileIndex &index) noexcept
Definition matrix_ref.h:135
+
dlaf::matrix::internal::MatrixRef< const T, D >::read
ReadOnlySenderType read(const GlobalTileIndex &index)
Definition matrix_ref.h:101
+
dlaf::matrix::internal::MatrixRef< const T, D >::MatrixRef
MatrixRef(Matrix< const T, D > &mat)
Definition matrix_ref.h:65
+
dlaf::matrix::internal::MatrixRef< const T, D >::readwrite
ReadWriteSenderType readwrite(const GlobalTileIndex &index)
Definition matrix_ref.h:145
+
dlaf::matrix::internal::MatrixRef
Definition matrix_ref.h:172
+
dlaf::matrix::internal::MatrixRef::MatrixRef
MatrixRef(Matrix< T, D > &mat, const SubMatrixSpec &spec)
Definition matrix_ref.h:189
+
dlaf::matrix::internal::MatrixRef::retiledSubPipeline
Matrix< T, D > retiledSubPipeline(const LocalTileSize &tiles_per_block) noexcept
Definition matrix_ref.h:213
+
dlaf::matrix::internal::MatrixRef::readwrite
ReadWriteSenderType readwrite(const LocalTileIndex &index) noexcept
Definition matrix_ref.h:221
+
dlaf::matrix::internal::MatrixRef::readwrite
ReadWriteSenderType readwrite(const GlobalTileIndex &index)
Definition matrix_ref.h:231
+
dlaf::matrix::internal::MatrixRef::MatrixRef
MatrixRef(Matrix< T, D > &mat)
Definition matrix_ref.h:195
+ -
dlaf::matrix::splitTile
ReadOnlyTileSender< T, D > splitTile(ReadOnlyTileSender< T, D > tile, const SubTileSpec &spec)
Definition tile.h:510
+
dlaf::matrix::splitTile
ReadOnlyTileSender< T, D > splitTile(ReadOnlyTileSender< T, D > tile, const SubTileSpec &spec)
Definition tile.h:511
matrix_base.h
dlaf::matrix::SubDistributionSpec
Contains information to create a sub-distribution.
Definition distribution.h:60
-
dlaf::matrix::SubTileSpec
Contains the information to create a subtile.
Definition tile.h:112
+
dlaf::matrix::SubTileSpec
Contains the information to create a subtile.
Definition tile.h:113
diff --git a/master/memory__view_8h.html b/master/memory__view_8h.html index b112a99728..7642db2c2d 100644 --- a/master/memory__view_8h.html +++ b/master/memory__view_8h.html @@ -79,7 +79,8 @@
memory_view.h File Reference
-
#include <cstdlib>
+
#include <complex>
+#include <cstdlib>
#include <memory>
#include <utility>
#include <dlaf/common/assert.h>
diff --git a/master/memory__view_8h_source.html b/master/memory__view_8h_source.html index 2a698b3952..4a094c9ae4 100644 --- a/master/memory__view_8h_source.html +++ b/master/memory__view_8h_source.html @@ -94,161 +94,162 @@
11#pragma once
12
14
-
15#include <cstdlib>
-
16#include <memory>
-
17#include <utility>
-
18
-
19#include <dlaf/common/assert.h>
-
20#include <dlaf/memory/memory_chunk.h>
-
21#include <dlaf/types.h>
-
22
-
23namespace dlaf {
-
24namespace memory {
-
25
-
31template <class T, Device D>
-
-
32class MemoryView {
-
33public:
-
34 using ElementType = std::remove_const_t<T>;
-
35 friend MemoryView<const ElementType, D>;
-
36
-
38 MemoryView() : memory_(), offset_(0), size_(0) {}
-
39
-
45 template <class U = T, class = typename std::enable_if_t<!std::is_const_v<U> && std::is_same_v<T, U>>>
-
-
46 explicit MemoryView(SizeType size)
-
47 : memory_(size > 0 ? std::make_shared<MemoryChunk<ElementType, D>>(size) : nullptr), offset_(0),
-
48 size_(size) {
-
49 DLAF_ASSERT(size >= 0, size);
-
50 }
+
15#include <complex>
+
16#include <cstdlib>
+
17#include <memory>
+
18#include <utility>
+
19
+
20#include <dlaf/common/assert.h>
+
21#include <dlaf/memory/memory_chunk.h>
+
22#include <dlaf/types.h>
+
23
+
24namespace dlaf {
+
25namespace memory {
+
26
+
32template <class T, Device D>
+
+
33class MemoryView {
+
34public:
+
35 using ElementType = std::remove_const_t<T>;
+
36 friend MemoryView<const ElementType, D>;
+
37
+
39 MemoryView() : memory_(), offset_(0), size_(0) {}
+
40
+
46 template <class U = T, class = typename std::enable_if_t<!std::is_const_v<U> && std::is_same_v<T, U>>>
+
+
47 explicit MemoryView(SizeType size)
+
48 : memory_(size > 0 ? std::make_shared<MemoryChunk<ElementType, D>>(size) : nullptr), offset_(0),
+
49 size_(size) {
+
50 DLAF_ASSERT(size >= 0, size);
+
51 }
-
51
-
-
57 MemoryView(T* ptr, SizeType size)
-
58 : memory_(ptr ? std::make_shared<MemoryChunk<ElementType, D>>(const_cast<ElementType*>(ptr), size)
-
59 : nullptr),
-
60 offset_(0), size_(size) {
-
61 DLAF_ASSERT(size >= 0, size);
-
62 }
+
52
+
+
58 MemoryView(T* ptr, SizeType size)
+
59 : memory_(ptr ? std::make_shared<MemoryChunk<ElementType, D>>(const_cast<ElementType*>(ptr), size)
+
60 : nullptr),
+
61 offset_(0), size_(size) {
+
62 DLAF_ASSERT(size >= 0, size);
+
63 }
-
63
-
64 MemoryView(const MemoryView&) = default;
-
65 template <class U = T, class = typename std::enable_if_t<std::is_const_v<U> && std::is_same_v<T, U>>>
-
66 MemoryView(const MemoryView<ElementType, D>& rhs)
-
67 : memory_(rhs.memory_), offset_(rhs.offset_), size_(rhs.size_) {}
-
68
-
69 MemoryView(MemoryView&& rhs) noexcept
-
70 : memory_(std::move(rhs.memory_)), offset_(rhs.offset_), size_(rhs.size_) {
-
71 rhs.size_ = 0;
-
72 rhs.offset_ = 0;
-
73 }
-
74
-
75 template <class U = T, class = typename std::enable_if_t<std::is_const_v<U> && std::is_same_v<T, U>>>
-
76 MemoryView(MemoryView<ElementType, D>&& rhs) noexcept
-
77 : memory_(std::move(rhs.memory_)), offset_(rhs.offset_), size_(rhs.size_) {
-
78 rhs.size_ = 0;
-
79 rhs.offset_ = 0;
-
80 }
-
81
-
-
88 MemoryView(const MemoryView& memory_view, SizeType offset, SizeType size)
-
89 : memory_(size > 0 ? memory_view.memory_ : nullptr),
-
90 offset_(size > 0 ? offset + memory_view.offset_ : 0), size_(size) {
-
91 DLAF_ASSERT(offset + size <= memory_view.size_, offset + size, memory_view.size_);
-
92 }
+
64
+
65 MemoryView(const MemoryView&) = default;
+
66 template <class U = T, class = typename std::enable_if_t<std::is_const_v<U> && std::is_same_v<T, U>>>
+
67 MemoryView(const MemoryView<ElementType, D>& rhs)
+
68 : memory_(rhs.memory_), offset_(rhs.offset_), size_(rhs.size_) {}
+
69
+
70 MemoryView(MemoryView&& rhs) noexcept
+
71 : memory_(std::move(rhs.memory_)), offset_(rhs.offset_), size_(rhs.size_) {
+
72 rhs.size_ = 0;
+
73 rhs.offset_ = 0;
+
74 }
+
75
+
76 template <class U = T, class = typename std::enable_if_t<std::is_const_v<U> && std::is_same_v<T, U>>>
+
77 MemoryView(MemoryView<ElementType, D>&& rhs) noexcept
+
78 : memory_(std::move(rhs.memory_)), offset_(rhs.offset_), size_(rhs.size_) {
+
79 rhs.size_ = 0;
+
80 rhs.offset_ = 0;
+
81 }
+
82
+
+
89 MemoryView(const MemoryView& memory_view, SizeType offset, SizeType size)
+
90 : memory_(size > 0 ? memory_view.memory_ : nullptr),
+
91 offset_(size > 0 ? offset + memory_view.offset_ : 0), size_(size) {
+
92 DLAF_ASSERT(offset + size <= memory_view.size_, offset + size, memory_view.size_);
+
93 }
-
93 template <class U = T, class = typename std::enable_if_t<std::is_const_v<U> && std::is_same_v<T, U>>>
-
94 MemoryView(const MemoryView<ElementType, D>& memory_view, SizeType offset, SizeType size)
-
95 : memory_(size > 0 ? memory_view.memory_ : nullptr),
-
96 offset_(size > 0 ? offset + memory_view.offset_ : 0), size_(size) {
-
97 DLAF_ASSERT(offset + size <= memory_view.size_, offset + size, memory_view.size_);
-
98 }
-
99
-
100 MemoryView& operator=(const MemoryView&) = default;
-
101 template <class U = T, class = typename std::enable_if_t<std::is_const_v<U> && std::is_same_v<T, U>>>
-
102 MemoryView& operator=(const MemoryView<ElementType, D>& rhs) {
-
103 memory_ = rhs.memory_;
-
104 offset_ = rhs.offset_;
-
105 size_ = rhs.size_;
-
106
-
107 return *this;
-
108 }
-
109
-
110 MemoryView& operator=(MemoryView&& rhs) {
-
111 memory_ = std::move(rhs.memory_);
-
112 offset_ = rhs.offset_;
-
113 size_ = rhs.size_;
-
114
-
115 rhs.size_ = 0;
-
116 rhs.offset_ = 0;
-
117
-
118 return *this;
-
119 }
-
120 template <class U = T, class = typename std::enable_if_t<std::is_const_v<U> && std::is_same_v<T, U>>>
-
121 MemoryView& operator=(MemoryView<ElementType, D>&& rhs) {
-
122 memory_ = std::move(rhs.memory_);
-
123 offset_ = rhs.offset_;
-
124 size_ = rhs.size_;
-
125
-
126 rhs.size_ = 0;
-
127 rhs.offset_ = 0;
-
128
-
129 return *this;
-
130 }
-
131
-
-
136 T* operator()(SizeType index) const {
-
137 DLAF_ASSERT_HEAVY(index < size_, index, size_);
-
138 return memory_->operator()(offset_ + index);
-
139 }
+
94 template <class U = T, class = typename std::enable_if_t<std::is_const_v<U> && std::is_same_v<T, U>>>
+
95 MemoryView(const MemoryView<ElementType, D>& memory_view, SizeType offset, SizeType size)
+
96 : memory_(size > 0 ? memory_view.memory_ : nullptr),
+
97 offset_(size > 0 ? offset + memory_view.offset_ : 0), size_(size) {
+
98 DLAF_ASSERT(offset + size <= memory_view.size_, offset + size, memory_view.size_);
+
99 }
+
100
+
101 MemoryView& operator=(const MemoryView&) = default;
+
102 template <class U = T, class = typename std::enable_if_t<std::is_const_v<U> && std::is_same_v<T, U>>>
+
103 MemoryView& operator=(const MemoryView<ElementType, D>& rhs) {
+
104 memory_ = rhs.memory_;
+
105 offset_ = rhs.offset_;
+
106 size_ = rhs.size_;
+
107
+
108 return *this;
+
109 }
+
110
+
111 MemoryView& operator=(MemoryView&& rhs) {
+
112 memory_ = std::move(rhs.memory_);
+
113 offset_ = rhs.offset_;
+
114 size_ = rhs.size_;
+
115
+
116 rhs.size_ = 0;
+
117 rhs.offset_ = 0;
+
118
+
119 return *this;
+
120 }
+
121 template <class U = T, class = typename std::enable_if_t<std::is_const_v<U> && std::is_same_v<T, U>>>
+
122 MemoryView& operator=(MemoryView<ElementType, D>&& rhs) {
+
123 memory_ = std::move(rhs.memory_);
+
124 offset_ = rhs.offset_;
+
125 size_ = rhs.size_;
+
126
+
127 rhs.size_ = 0;
+
128 rhs.offset_ = 0;
+
129
+
130 return *this;
+
131 }
+
132
+
+
137 T* operator()(SizeType index) const {
+
138 DLAF_ASSERT_HEAVY(index < size_, index, size_);
+
139 return memory_->operator()(offset_ + index);
+
140 }
-
140
-
-
143 T* operator()() const {
-
144 return size_ == 0 ? nullptr : memory_->operator()(offset_);
-
145 }
+
141
+
+
144 T* operator()() const {
+
145 return size_ == 0 ? nullptr : memory_->operator()(offset_);
+
146 }
-
146
-
-
148 SizeType size() const {
-
149 return size_;
-
150 }
+
147
+
+
149 SizeType size() const {
+
150 return size_;
+
151 }
-
151
-
152private:
-
153 std::shared_ptr<MemoryChunk<ElementType, D>> memory_;
-
154 SizeType offset_;
-
155 SizeType size_;
-
156};
+
152
+
153private:
+
154 std::shared_ptr<MemoryChunk<ElementType, D>> memory_;
+
155 SizeType offset_;
+
156 SizeType size_;
+
157};
-
157
-
158// ETI
-
159
-
160#define DLAF_MEMVIEW_ETI(KWORD, DATATYPE, DEVICE) KWORD template class MemoryView<DATATYPE, DEVICE>;
-
161
-
162DLAF_MEMVIEW_ETI(extern, float, Device::CPU)
-
163DLAF_MEMVIEW_ETI(extern, double, Device::CPU)
-
164DLAF_MEMVIEW_ETI(extern, std::complex<float>, Device::CPU)
-
165DLAF_MEMVIEW_ETI(extern, std::complex<double>, Device::CPU)
-
166
-
167#ifdef DLAF_WITH_GPU
-
168DLAF_MEMVIEW_ETI(extern, float, Device::GPU)
-
169DLAF_MEMVIEW_ETI(extern, double, Device::GPU)
-
170DLAF_MEMVIEW_ETI(extern, std::complex<float>, Device::GPU)
-
171DLAF_MEMVIEW_ETI(extern, std::complex<double>, Device::GPU)
-
172#endif
-
173
-
174}
+
158
+
159// ETI
+
160
+
161#define DLAF_MEMVIEW_ETI(KWORD, DATATYPE, DEVICE) KWORD template class MemoryView<DATATYPE, DEVICE>;
+
162
+
163DLAF_MEMVIEW_ETI(extern, float, Device::CPU)
+
164DLAF_MEMVIEW_ETI(extern, double, Device::CPU)
+
165DLAF_MEMVIEW_ETI(extern, std::complex<float>, Device::CPU)
+
166DLAF_MEMVIEW_ETI(extern, std::complex<double>, Device::CPU)
+
167
+
168#ifdef DLAF_WITH_GPU
+
169DLAF_MEMVIEW_ETI(extern, float, Device::GPU)
+
170DLAF_MEMVIEW_ETI(extern, double, Device::GPU)
+
171DLAF_MEMVIEW_ETI(extern, std::complex<float>, Device::GPU)
+
172DLAF_MEMVIEW_ETI(extern, std::complex<double>, Device::GPU)
+
173#endif
+
174
175}
+
176}
dlaf::memory::MemoryChunk
The class MemoryChunk represents a layer of abstraction over the underlying device memory.
Definition memory_chunk.h:46
-
dlaf::memory::MemoryView
Definition memory_view.h:32
-
dlaf::memory::MemoryView::MemoryView
MemoryView(SizeType size)
Definition memory_view.h:46
-
dlaf::memory::MemoryView::MemoryView
MemoryView(T *ptr, SizeType size)
Definition memory_view.h:57
-
dlaf::memory::MemoryView::size
SizeType size() const
Returns the number of elements accessible from the MemoryView.
Definition memory_view.h:148
-
dlaf::memory::MemoryView::MemoryView
MemoryView(const MemoryView &memory_view, SizeType offset, SizeType size)
Definition memory_view.h:88
-
dlaf::memory::MemoryView::MemoryView
MemoryView()
Creates a MemoryView of size 0.
Definition memory_view.h:38
-
dlaf::memory::MemoryView::operator()
T * operator()(SizeType index) const
Definition memory_view.h:136
-
dlaf::memory::MemoryView::operator()
T * operator()() const
Definition memory_view.h:143
+
dlaf::memory::MemoryView
Definition memory_view.h:33
+
dlaf::memory::MemoryView::MemoryView
MemoryView(SizeType size)
Definition memory_view.h:47
+
dlaf::memory::MemoryView::MemoryView
MemoryView(T *ptr, SizeType size)
Definition memory_view.h:58
+
dlaf::memory::MemoryView::size
SizeType size() const
Returns the number of elements accessible from the MemoryView.
Definition memory_view.h:149
+
dlaf::memory::MemoryView::MemoryView
MemoryView(const MemoryView &memory_view, SizeType offset, SizeType size)
Definition memory_view.h:89
+
dlaf::memory::MemoryView::MemoryView
MemoryView()
Creates a MemoryView of size 0.
Definition memory_view.h:39
+
dlaf::memory::MemoryView::operator()
T * operator()(SizeType index) const
Definition memory_view.h:137
+
dlaf::memory::MemoryView::operator()
T * operator()() const
Definition memory_view.h:144
memory_chunk.h
diff --git a/master/merge_8h_source.html b/master/merge_8h_source.html index f61b58fe59..5282411613 100644 --- a/master/merge_8h_source.html +++ b/master/merge_8h_source.html @@ -2052,7 +2052,7 @@ -
dlaf::matrix::select
auto select(MatrixLike &matrix, common::IterableRange2D< SizeType, LocalTile_TAG > range)
Definition matrix.h:467
+
dlaf::matrix::select
auto select(MatrixLike &matrix, common::IterableRange2D< SizeType, LocalTile_TAG > range)
Definition matrix.h:468
matrix_ref.h
memory_view.h
diff --git a/master/multiplication_2general_2api_8h_source.html b/master/multiplication_2general_2api_8h_source.html index 9fad41bd38..85791bb792 100644 --- a/master/multiplication_2general_2api_8h_source.html +++ b/master/multiplication_2general_2api_8h_source.html @@ -93,52 +93,54 @@
10
11#pragma once
12
-
13#include <blas.hh>
+
13#include <complex>
14
-
15#include <dlaf/common/index2d.h>
-
16#include <dlaf/communication/communicator_pipeline.h>
-
17#include <dlaf/matrix/matrix.h>
-
18#include <dlaf/matrix/matrix_ref.h>
-
19#include <dlaf/types.h>
-
20
-
21namespace dlaf::multiplication::internal {
-
22using dlaf::matrix::internal::MatrixRef;
-
23
-
24template <Backend B, Device D, class T>
-
-
25struct General {
-
26 static void callNN(const T alpha, MatrixRef<const T, D>& mat_a, MatrixRef<const T, D>& mat_b,
-
27 const T beta, MatrixRef<T, D>& mat_c);
-
28 static void callNN(comm::CommunicatorPipeline<comm::CommunicatorType::Row>& row_task_chain,
-
29 comm::CommunicatorPipeline<comm::CommunicatorType::Col>& col_task_chain,
-
30 const T alpha, MatrixRef<const T, D>& mat_a, MatrixRef<const T, D>& mat_b,
-
31 const T beta, MatrixRef<T, D>& mat_c);
-
32};
+
15#include <blas.hh>
+
16
+
17#include <dlaf/common/index2d.h>
+
18#include <dlaf/communication/communicator_pipeline.h>
+
19#include <dlaf/matrix/matrix.h>
+
20#include <dlaf/matrix/matrix_ref.h>
+
21#include <dlaf/types.h>
+
22
+
23namespace dlaf::multiplication::internal {
+
24using dlaf::matrix::internal::MatrixRef;
+
25
+
26template <Backend B, Device D, class T>
+
+
27struct General {
+
28 static void callNN(const T alpha, MatrixRef<const T, D>& mat_a, MatrixRef<const T, D>& mat_b,
+
29 const T beta, MatrixRef<T, D>& mat_c);
+
30 static void callNN(comm::CommunicatorPipeline<comm::CommunicatorType::Row>& row_task_chain,
+
31 comm::CommunicatorPipeline<comm::CommunicatorType::Col>& col_task_chain,
+
32 const T alpha, MatrixRef<const T, D>& mat_a, MatrixRef<const T, D>& mat_b,
+
33 const T beta, MatrixRef<T, D>& mat_c);
+
34};
-
33
-
34#define DLAF_MULTIPLICATION_GENERAL_ETI(KWORD, BACKEND, DEVICE, DATATYPE) \
-
35 KWORD template struct General<BACKEND, DEVICE, DATATYPE>;
-
36
-
37DLAF_MULTIPLICATION_GENERAL_ETI(extern, Backend::MC, Device::CPU, float)
-
38DLAF_MULTIPLICATION_GENERAL_ETI(extern, Backend::MC, Device::CPU, double)
-
39DLAF_MULTIPLICATION_GENERAL_ETI(extern, Backend::MC, Device::CPU, std::complex<float>)
-
40DLAF_MULTIPLICATION_GENERAL_ETI(extern, Backend::MC, Device::CPU, std::complex<double>)
-
41
-
42#ifdef DLAF_WITH_GPU
-
43DLAF_MULTIPLICATION_GENERAL_ETI(extern, Backend::GPU, Device::GPU, float)
-
44DLAF_MULTIPLICATION_GENERAL_ETI(extern, Backend::GPU, Device::GPU, double)
-
45DLAF_MULTIPLICATION_GENERAL_ETI(extern, Backend::GPU, Device::GPU, std::complex<float>)
-
46DLAF_MULTIPLICATION_GENERAL_ETI(extern, Backend::GPU, Device::GPU, std::complex<double>)
-
47#endif
-
48
-
49}
+
35
+
36#define DLAF_MULTIPLICATION_GENERAL_ETI(KWORD, BACKEND, DEVICE, DATATYPE) \
+
37 KWORD template struct General<BACKEND, DEVICE, DATATYPE>;
+
38
+
39DLAF_MULTIPLICATION_GENERAL_ETI(extern, Backend::MC, Device::CPU, float)
+
40DLAF_MULTIPLICATION_GENERAL_ETI(extern, Backend::MC, Device::CPU, double)
+
41DLAF_MULTIPLICATION_GENERAL_ETI(extern, Backend::MC, Device::CPU, std::complex<float>)
+
42DLAF_MULTIPLICATION_GENERAL_ETI(extern, Backend::MC, Device::CPU, std::complex<double>)
+
43
+
44#ifdef DLAF_WITH_GPU
+
45DLAF_MULTIPLICATION_GENERAL_ETI(extern, Backend::GPU, Device::GPU, float)
+
46DLAF_MULTIPLICATION_GENERAL_ETI(extern, Backend::GPU, Device::GPU, double)
+
47DLAF_MULTIPLICATION_GENERAL_ETI(extern, Backend::GPU, Device::GPU, std::complex<float>)
+
48DLAF_MULTIPLICATION_GENERAL_ETI(extern, Backend::GPU, Device::GPU, std::complex<double>)
+
49#endif
+
50
+
51}
dlaf::comm::CommunicatorPipeline
Definition communicator_pipeline.h:41
-
dlaf::matrix::internal::MatrixRef
Definition matrix_ref.h:171
+
dlaf::matrix::internal::MatrixRef
Definition matrix_ref.h:172
communicator_pipeline.h
matrix_ref.h
- +
diff --git a/master/multiplication_2general_8h_source.html b/master/multiplication_2general_8h_source.html index e694ad2e82..33dbe4b304 100644 --- a/master/multiplication_2general_8h_source.html +++ b/master/multiplication_2general_8h_source.html @@ -147,7 +147,7 @@
97}
dlaf::comm::CommunicatorPipeline
Definition communicator_pipeline.h:41
-
dlaf::matrix::internal::MatrixRef
Definition matrix_ref.h:171
+
dlaf::matrix::internal::MatrixRef
Definition matrix_ref.h:172
communicator_grid.h
communicator_pipeline.h
@@ -155,7 +155,7 @@
matrix_ref.h
dlaf::multiplication::internal::generalMatrix
void generalMatrix(const blas::Op opA, const blas::Op opB, const T alpha, MatrixRef< const T, D > &mat_a, MatrixRef< const T, D > &mat_b, const T beta, MatrixRef< T, D > &mat_c)
Definition general.h:52
- +
util_matrix.h
diff --git a/master/multiplication_2hermitian_2api_8h_source.html b/master/multiplication_2hermitian_2api_8h_source.html index 1427fac87a..77e029024e 100644 --- a/master/multiplication_2hermitian_2api_8h_source.html +++ b/master/multiplication_2hermitian_2api_8h_source.html @@ -92,46 +92,48 @@
9//
10#pragma once
11
-
12#include <dlaf/matrix/matrix.h>
-
13#include <dlaf/matrix/matrix_ref.h>
-
14#include <dlaf/types.h>
-
15
-
16namespace dlaf::multiplication::internal {
+
12#include <complex>
+
13
+
14#include <dlaf/matrix/matrix.h>
+
15#include <dlaf/matrix/matrix_ref.h>
+
16#include <dlaf/types.h>
17
-
18using matrix::internal::MatrixRef;
+
18namespace dlaf::multiplication::internal {
19
-
20template <Backend B, Device D, class T>
-
-
21struct Hermitian {
-
22 static void call_LL(const T alpha, Matrix<const T, D>& mat_a, Matrix<const T, D>& mat_b, const T beta,
-
23 Matrix<T, D>& mat_c);
-
24
-
25 static void call_LL(comm::CommunicatorGrid& grid, const T alpha, Matrix<const T, D>& mat_a,
-
26 MatrixRef<const T, D>& mat_b, const T beta, Matrix<T, D>& mat_c);
-
27};
+
20using matrix::internal::MatrixRef;
+
21
+
22template <Backend B, Device D, class T>
+
+
23struct Hermitian {
+
24 static void call_LL(const T alpha, Matrix<const T, D>& mat_a, Matrix<const T, D>& mat_b, const T beta,
+
25 Matrix<T, D>& mat_c);
+
26
+
27 static void call_LL(comm::CommunicatorGrid& grid, const T alpha, Matrix<const T, D>& mat_a,
+
28 MatrixRef<const T, D>& mat_b, const T beta, Matrix<T, D>& mat_c);
+
29};
-
28
-
29// ETI
-
30#define DLAF_MULTIPLICATION_HERMITIAN_ETI(KWORD, BACKEND, DEVICE, DATATYPE) \
-
31 KWORD template struct Hermitian<BACKEND, DEVICE, DATATYPE>;
-
32
-
33DLAF_MULTIPLICATION_HERMITIAN_ETI(extern, Backend::MC, Device::CPU, float)
-
34DLAF_MULTIPLICATION_HERMITIAN_ETI(extern, Backend::MC, Device::CPU, double)
-
35DLAF_MULTIPLICATION_HERMITIAN_ETI(extern, Backend::MC, Device::CPU, std::complex<float>)
-
36DLAF_MULTIPLICATION_HERMITIAN_ETI(extern, Backend::MC, Device::CPU, std::complex<double>)
-
37
-
38#ifdef DLAF_WITH_GPU
-
39DLAF_MULTIPLICATION_HERMITIAN_ETI(extern, Backend::GPU, Device::GPU, float)
-
40DLAF_MULTIPLICATION_HERMITIAN_ETI(extern, Backend::GPU, Device::GPU, double)
-
41DLAF_MULTIPLICATION_HERMITIAN_ETI(extern, Backend::GPU, Device::GPU, std::complex<float>)
-
42DLAF_MULTIPLICATION_HERMITIAN_ETI(extern, Backend::GPU, Device::GPU, std::complex<double>)
-
43#endif
-
44}
+
30
+
31// ETI
+
32#define DLAF_MULTIPLICATION_HERMITIAN_ETI(KWORD, BACKEND, DEVICE, DATATYPE) \
+
33 KWORD template struct Hermitian<BACKEND, DEVICE, DATATYPE>;
+
34
+
35DLAF_MULTIPLICATION_HERMITIAN_ETI(extern, Backend::MC, Device::CPU, float)
+
36DLAF_MULTIPLICATION_HERMITIAN_ETI(extern, Backend::MC, Device::CPU, double)
+
37DLAF_MULTIPLICATION_HERMITIAN_ETI(extern, Backend::MC, Device::CPU, std::complex<float>)
+
38DLAF_MULTIPLICATION_HERMITIAN_ETI(extern, Backend::MC, Device::CPU, std::complex<double>)
+
39
+
40#ifdef DLAF_WITH_GPU
+
41DLAF_MULTIPLICATION_HERMITIAN_ETI(extern, Backend::GPU, Device::GPU, float)
+
42DLAF_MULTIPLICATION_HERMITIAN_ETI(extern, Backend::GPU, Device::GPU, double)
+
43DLAF_MULTIPLICATION_HERMITIAN_ETI(extern, Backend::GPU, Device::GPU, std::complex<float>)
+
44DLAF_MULTIPLICATION_HERMITIAN_ETI(extern, Backend::GPU, Device::GPU, std::complex<double>)
+
45#endif
+
46}
dlaf::comm::CommunicatorGrid
Definition communicator_grid.h:37
-
dlaf::matrix::internal::MatrixRef
Definition matrix_ref.h:171
+
dlaf::matrix::internal::MatrixRef
Definition matrix_ref.h:172
matrix_ref.h
- +
diff --git a/master/multiplication_2triangular_2api_8h_source.html b/master/multiplication_2triangular_2api_8h_source.html index ef64ed9fc7..11616f0380 100644 --- a/master/multiplication_2triangular_2api_8h_source.html +++ b/master/multiplication_2triangular_2api_8h_source.html @@ -92,61 +92,63 @@
9//
10#pragma once
11
-
12#include <blas.hh>
+
12#include <complex>
13
-
14#include <dlaf/matrix/matrix.h>
-
15#include <dlaf/types.h>
-
16
-
17namespace dlaf::multiplication::internal {
-
18template <Backend backend, Device device, class T>
-
-
19struct Triangular {
-
20 static void call_LLN(blas::Diag diag, T alpha, Matrix<const T, device>& mat_a,
-
21 Matrix<T, device>& mat_b);
-
22 static void call_LLT(blas::Op op, blas::Diag diag, T alpha, Matrix<const T, device>& mat_a,
+
14#include <blas.hh>
+
15
+
16#include <dlaf/matrix/matrix.h>
+
17#include <dlaf/types.h>
+
18
+
19namespace dlaf::multiplication::internal {
+
20template <Backend backend, Device device, class T>
+
+
21struct Triangular {
+
22 static void call_LLN(blas::Diag diag, T alpha, Matrix<const T, device>& mat_a,
23 Matrix<T, device>& mat_b);
-
24 static void call_LUN(blas::Diag diag, T alpha, Matrix<const T, device>& mat_a,
+
24 static void call_LLT(blas::Op op, blas::Diag diag, T alpha, Matrix<const T, device>& mat_a,
25 Matrix<T, device>& mat_b);
-
26 static void call_LUT(blas::Op op, blas::Diag diag, T alpha, Matrix<const T, device>& mat_a,
+
26 static void call_LUN(blas::Diag diag, T alpha, Matrix<const T, device>& mat_a,
27 Matrix<T, device>& mat_b);
-
28 static void call_RLN(blas::Diag diag, T alpha, Matrix<const T, device>& mat_a,
+
28 static void call_LUT(blas::Op op, blas::Diag diag, T alpha, Matrix<const T, device>& mat_a,
29 Matrix<T, device>& mat_b);
-
30 static void call_RLT(blas::Op op, blas::Diag diag, T alpha, Matrix<const T, device>& mat_a,
+
30 static void call_RLN(blas::Diag diag, T alpha, Matrix<const T, device>& mat_a,
31 Matrix<T, device>& mat_b);
-
32 static void call_RUN(blas::Diag diag, T alpha, Matrix<const T, device>& mat_a,
+
32 static void call_RLT(blas::Op op, blas::Diag diag, T alpha, Matrix<const T, device>& mat_a,
33 Matrix<T, device>& mat_b);
-
34 static void call_RUT(blas::Op op, blas::Diag diag, T alpha, Matrix<const T, device>& mat_a,
+
34 static void call_RUN(blas::Diag diag, T alpha, Matrix<const T, device>& mat_a,
35 Matrix<T, device>& mat_b);
-
36 static void call_LLN(comm::CommunicatorGrid& grid, blas::Diag diag, T alpha,
-
37 Matrix<const T, device>& mat_a, Matrix<T, device>& mat_b);
-
38 static void call_LUN(comm::CommunicatorGrid& grid, blas::Diag diag, T alpha,
+
36 static void call_RUT(blas::Op op, blas::Diag diag, T alpha, Matrix<const T, device>& mat_a,
+
37 Matrix<T, device>& mat_b);
+
38 static void call_LLN(comm::CommunicatorGrid& grid, blas::Diag diag, T alpha,
39 Matrix<const T, device>& mat_a, Matrix<T, device>& mat_b);
-
40 static void call_RLN(comm::CommunicatorGrid& grid, blas::Diag diag, T alpha,
+
40 static void call_LUN(comm::CommunicatorGrid& grid, blas::Diag diag, T alpha,
41 Matrix<const T, device>& mat_a, Matrix<T, device>& mat_b);
-
42 static void call_RUN(comm::CommunicatorGrid& grid, blas::Diag diag, T alpha,
+
42 static void call_RLN(comm::CommunicatorGrid& grid, blas::Diag diag, T alpha,
43 Matrix<const T, device>& mat_a, Matrix<T, device>& mat_b);
-
44};
+
44 static void call_RUN(comm::CommunicatorGrid& grid, blas::Diag diag, T alpha,
+
45 Matrix<const T, device>& mat_a, Matrix<T, device>& mat_b);
+
46};
-
45
-
46// ETI
-
47#define DLAF_MULTIPLICATION_TRIANGULAR_ETI(KWORD, BACKEND, DEVICE, DATATYPE) \
-
48 KWORD template struct Triangular<BACKEND, DEVICE, DATATYPE>;
-
49
-
50DLAF_MULTIPLICATION_TRIANGULAR_ETI(extern, Backend::MC, Device::CPU, float)
-
51DLAF_MULTIPLICATION_TRIANGULAR_ETI(extern, Backend::MC, Device::CPU, double)
-
52DLAF_MULTIPLICATION_TRIANGULAR_ETI(extern, Backend::MC, Device::CPU, std::complex<float>)
-
53DLAF_MULTIPLICATION_TRIANGULAR_ETI(extern, Backend::MC, Device::CPU, std::complex<double>)
-
54
-
55#ifdef DLAF_WITH_GPU
-
56DLAF_MULTIPLICATION_TRIANGULAR_ETI(extern, Backend::GPU, Device::GPU, float)
-
57DLAF_MULTIPLICATION_TRIANGULAR_ETI(extern, Backend::GPU, Device::GPU, double)
-
58DLAF_MULTIPLICATION_TRIANGULAR_ETI(extern, Backend::GPU, Device::GPU, std::complex<float>)
-
59DLAF_MULTIPLICATION_TRIANGULAR_ETI(extern, Backend::GPU, Device::GPU, std::complex<double>)
-
60#endif
-
61}
+
47
+
48// ETI
+
49#define DLAF_MULTIPLICATION_TRIANGULAR_ETI(KWORD, BACKEND, DEVICE, DATATYPE) \
+
50 KWORD template struct Triangular<BACKEND, DEVICE, DATATYPE>;
+
51
+
52DLAF_MULTIPLICATION_TRIANGULAR_ETI(extern, Backend::MC, Device::CPU, float)
+
53DLAF_MULTIPLICATION_TRIANGULAR_ETI(extern, Backend::MC, Device::CPU, double)
+
54DLAF_MULTIPLICATION_TRIANGULAR_ETI(extern, Backend::MC, Device::CPU, std::complex<float>)
+
55DLAF_MULTIPLICATION_TRIANGULAR_ETI(extern, Backend::MC, Device::CPU, std::complex<double>)
+
56
+
57#ifdef DLAF_WITH_GPU
+
58DLAF_MULTIPLICATION_TRIANGULAR_ETI(extern, Backend::GPU, Device::GPU, float)
+
59DLAF_MULTIPLICATION_TRIANGULAR_ETI(extern, Backend::GPU, Device::GPU, double)
+
60DLAF_MULTIPLICATION_TRIANGULAR_ETI(extern, Backend::GPU, Device::GPU, std::complex<float>)
+
61DLAF_MULTIPLICATION_TRIANGULAR_ETI(extern, Backend::GPU, Device::GPU, std::complex<double>)
+
62#endif
+
63}
dlaf::comm::CommunicatorGrid
Definition communicator_grid.h:37
- +
diff --git a/master/multiplication_2triangular_8h_source.html b/master/multiplication_2triangular_8h_source.html index d2bd29bb5e..43fd0edba9 100644 --- a/master/multiplication_2triangular_8h_source.html +++ b/master/multiplication_2triangular_8h_source.html @@ -228,7 +228,7 @@
communicator_grid.h
dlaf::triangular_multiplication
void triangular_multiplication(blas::Side side, blas::Uplo uplo, blas::Op op, blas::Diag diag, T alpha, Matrix< const T, device > &mat_a, Matrix< T, device > &mat_b)
Definition triangular.h:48
- +
util_matrix.h
diff --git a/master/norm_8h_source.html b/master/norm_8h_source.html index edfa2b84a5..7e59c4dafa 100644 --- a/master/norm_8h_source.html +++ b/master/norm_8h_source.html @@ -141,7 +141,7 @@
dlaf::auxiliary::max_norm
pika::execution::experimental::unique_any_sender< dlaf::BaseType< T > > max_norm(comm::CommunicatorGrid &grid, comm::Index2D rank, blas::Uplo uplo, Matrix< const T, device > &A)
Definition norm.h:36
- +
util_matrix.h
diff --git a/master/p2p_8h.html b/master/p2p_8h.html index b94140fbe5..83d8146b5f 100644 --- a/master/p2p_8h.html +++ b/master/p2p_8h.html @@ -173,7 +173,7 @@

kword template dlaf::matrix::ReadWriteTileSender<Type, Device> schedule_recv( \
CommSender pcomm, IndexT_MPI source, IndexT_MPI tag, \
dlaf::matrix::ReadWriteTileSender<Type, Device> tile)
-
dlaf::matrix::Matrix
Definition matrix.h:61
+
dlaf::matrix::Matrix
Definition matrix.h:62

diff --git a/master/p2p_8h_source.html b/master/p2p_8h_source.html index 868ae41b4d..b215f49911 100644 --- a/master/p2p_8h_source.html +++ b/master/p2p_8h_source.html @@ -139,7 +139,7 @@
57DLAF_EXPAND_ETI_SDCZ_DEVICE_VA_ARGS(DLAF_SCHEDULE_RECV_ETI, extern, CommunicatorPipelineExclusiveSender);
58// clang-format on
59}
-
dlaf::matrix::Matrix
Definition matrix.h:61
+
dlaf::matrix::Matrix
Definition matrix.h:62
communicator_pipeline.h
diff --git a/master/panel_8h_source.html b/master/panel_8h_source.html index f07df4ce20..0f0ed2ce0e 100644 --- a/master/panel_8h_source.html +++ b/master/panel_8h_source.html @@ -655,8 +655,8 @@
dlaf::common::internal::basic_coords::transpose
void transpose() noexcept
Swaps row and column index/size.
Definition index2d.h:107
dlaf::matrix::Distribution
Definition distribution.h:111
-
dlaf::matrix::Matrix
Definition matrix.h:61
- +
dlaf::matrix::Matrix
Definition matrix.h:62
+
communicator_grid.h
@@ -665,7 +665,7 @@
dlaf::matrix::tileLayout
LayoutInfo tileLayout(const LocalElementSize &size, const TileElementSize &block_size, SizeType ld_tile, SizeType tiles_per_col)
Returns LayoutInfo for a local matrix which use the tile layout (Advanced interface).
Definition layout_info.h:135
-
dlaf::matrix::splitTile
ReadOnlyTileSender< T, D > splitTile(ReadOnlyTileSender< T, D > tile, const SubTileSpec &spec)
Definition tile.h:510
+
dlaf::matrix::splitTile
ReadOnlyTileSender< T, D > splitTile(ReadOnlyTileSender< T, D > tile, const SubTileSpec &spec)
Definition tile.h:511
matrix_base.h
matrix_ref.h
diff --git a/master/perms_8h_source.html b/master/perms_8h_source.html index 9fff03cd26..a52196e166 100644 --- a/master/perms_8h_source.html +++ b/master/perms_8h_source.html @@ -95,52 +95,53 @@
12
13#ifdef DLAF_WITH_GPU
14
-
15#include <vector>
-
16
-
17#include <whip.hpp>
-
18
-
19#include <dlaf/matrix/index.h>
-
20#include <dlaf/types.h>
-
21
-
22namespace dlaf::permutations::internal {
-
23
-
-
24struct MatrixLayout {
-
25 SizeType nb; // square tile size
-
26 SizeType ld; // tile leading dimension
-
27 SizeType row_offset; // tile offset to first element of tile on the next row
-
28 SizeType col_offset; // tile offset to first element of tile on the next column
-
29};
+
15#include <complex>
+
16#include <vector>
+
17
+
18#include <whip.hpp>
+
19
+
20#include <dlaf/matrix/index.h>
+
21#include <dlaf/types.h>
+
22
+
23namespace dlaf::permutations::internal {
+
24
+
+
25struct MatrixLayout {
+
26 SizeType nb; // square tile size
+
27 SizeType ld; // tile leading dimension
+
28 SizeType row_offset; // tile offset to first element of tile on the next row
+
29 SizeType col_offset; // tile offset to first element of tile on the next column
+
30};
-
30
-
31template <class T, Coord coord>
-
32void applyPermutationsOnDevice(GlobalElementIndex out_begin, GlobalElementSize sz, SizeType in_offset,
-
33 const SizeType* perms, MatrixLayout in_layout, const T* in,
-
34 MatrixLayout out_layout, T* out, whip::stream_t stream);
-
35
-
36#define DLAF_CUDA_PERMUTE_ON_DEVICE(kword, Type, Coord) \
-
37 kword template void applyPermutationsOnDevice<Type, Coord>( \
-
38 GlobalElementIndex out_begin, GlobalElementSize sz, SizeType in_offset, const SizeType* perms, \
-
39 MatrixLayout in_layout, const Type* in, MatrixLayout out_layout, Type* out, \
-
40 whip::stream_t stream)
-
41
-
42DLAF_CUDA_PERMUTE_ON_DEVICE(extern, float, Coord::Col);
-
43DLAF_CUDA_PERMUTE_ON_DEVICE(extern, double, Coord::Col);
-
44DLAF_CUDA_PERMUTE_ON_DEVICE(extern, std::complex<float>, Coord::Col);
-
45DLAF_CUDA_PERMUTE_ON_DEVICE(extern, std::complex<double>, Coord::Col);
-
46
-
47DLAF_CUDA_PERMUTE_ON_DEVICE(extern, float, Coord::Row);
-
48DLAF_CUDA_PERMUTE_ON_DEVICE(extern, double, Coord::Row);
-
49DLAF_CUDA_PERMUTE_ON_DEVICE(extern, std::complex<float>, Coord::Row);
-
50DLAF_CUDA_PERMUTE_ON_DEVICE(extern, std::complex<double>, Coord::Row);
-
51
-
52}
-
53
-
54#endif
+
31
+
32template <class T, Coord coord>
+
33void applyPermutationsOnDevice(GlobalElementIndex out_begin, GlobalElementSize sz, SizeType in_offset,
+
34 const SizeType* perms, MatrixLayout in_layout, const T* in,
+
35 MatrixLayout out_layout, T* out, whip::stream_t stream);
+
36
+
37#define DLAF_CUDA_PERMUTE_ON_DEVICE(kword, Type, Coord) \
+
38 kword template void applyPermutationsOnDevice<Type, Coord>( \
+
39 GlobalElementIndex out_begin, GlobalElementSize sz, SizeType in_offset, const SizeType* perms, \
+
40 MatrixLayout in_layout, const Type* in, MatrixLayout out_layout, Type* out, \
+
41 whip::stream_t stream)
+
42
+
43DLAF_CUDA_PERMUTE_ON_DEVICE(extern, float, Coord::Col);
+
44DLAF_CUDA_PERMUTE_ON_DEVICE(extern, double, Coord::Col);
+
45DLAF_CUDA_PERMUTE_ON_DEVICE(extern, std::complex<float>, Coord::Col);
+
46DLAF_CUDA_PERMUTE_ON_DEVICE(extern, std::complex<double>, Coord::Col);
+
47
+
48DLAF_CUDA_PERMUTE_ON_DEVICE(extern, float, Coord::Row);
+
49DLAF_CUDA_PERMUTE_ON_DEVICE(extern, double, Coord::Row);
+
50DLAF_CUDA_PERMUTE_ON_DEVICE(extern, std::complex<float>, Coord::Row);
+
51DLAF_CUDA_PERMUTE_ON_DEVICE(extern, std::complex<double>, Coord::Row);
+
52
+
53}
+
54
+
55#endif
- +
diff --git a/master/permutations_2general_2impl_8h_source.html b/master/permutations_2general_2impl_8h_source.html index b9bbce95aa..aa4a06b860 100644 --- a/master/permutations_2general_2impl_8h_source.html +++ b/master/permutations_2general_2impl_8h_source.html @@ -751,7 +751,7 @@
dlaf::internal::Policy
Definition policy.h:24
dlaf::matrix::Distribution
Definition distribution.h:111
dlaf::matrix::LayoutInfo
Definition layout_info.h:26
-
dlaf::matrix::Matrix
Definition matrix.h:61
+
dlaf::matrix::Matrix
Definition matrix.h:62
dlaf::comm::IndexT_MPI
int IndexT_MPI
Type used for indexes in MPI API.
Definition index.h:20
diff --git a/master/print__csv_8h_source.html b/master/print__csv_8h_source.html index b39d46628a..e0966512f2 100644 --- a/master/print__csv_8h_source.html +++ b/master/print__csv_8h_source.html @@ -161,7 +161,7 @@
79}
80}
-
dlaf::matrix::Matrix
Definition matrix.h:61
+
dlaf::matrix::Matrix
Definition matrix.h:62
@@ -170,7 +170,7 @@
dlaf::format::csv
Definition print_csv.h:29
util_matrix.h
-
dlaf::matrix::local_matrix
bool local_matrix(const MatrixLike< const T, D > &m) noexcept
Returns true if the matrix is local to a process.
Definition util_matrix.h:72
+
dlaf::matrix::local_matrix
bool local_matrix(const MatrixLike< const T, D > &m) noexcept
Returns true if the matrix is local to a process.
Definition util_matrix.h:73
diff --git a/master/print__gpu_8h_source.html b/master/print__gpu_8h_source.html index dd92c8616a..b6856f8e89 100644 --- a/master/print__gpu_8h_source.html +++ b/master/print__gpu_8h_source.html @@ -140,8 +140,8 @@
65
66}
67#endif
-
dlaf::matrix::Matrix
Definition matrix.h:61
-
dlaf::memory::MemoryView
Definition memory_view.h:32
+
dlaf::matrix::Matrix
Definition matrix.h:62
+
dlaf::memory::MemoryView
Definition memory_view.h:33
copy_tile.h
dlaf::matrix::print
void print(format::csv, const Tile< const T, Device::CPU > &tile, std::ostream &os=std::cout)
Print a tile in csv format to standard output.
Definition print_csv.h:36
diff --git a/master/print__numpy_8h.html b/master/print__numpy_8h.html index c890b70751..5419ccd3db 100644 --- a/master/print__numpy_8h.html +++ b/master/print__numpy_8h.html @@ -79,7 +79,8 @@
print_numpy.h File Reference
-
#include <iostream>
+
#include <complex>
+#include <iostream>
#include <sstream>
#include <string>
#include <dlaf/common/index2d.h>
diff --git a/master/print__numpy_8h_source.html b/master/print__numpy_8h_source.html index bfe9b22113..2daaa5958e 100644 --- a/master/print__numpy_8h_source.html +++ b/master/print__numpy_8h_source.html @@ -94,125 +94,126 @@
11#pragma once
12
14
-
15#include <iostream>
-
16#include <sstream>
-
17#include <string>
-
18
-
19#include <dlaf/common/index2d.h>
-
20#include <dlaf/common/range2d.h>
-
21#include <dlaf/matrix/matrix.h>
-
22#include <dlaf/matrix/tile.h>
-
23#include <dlaf/types.h>
-
24
-
25namespace dlaf {
-
26
-
27namespace format {
-
28struct numpy {};
-
29}
-
30
-
31namespace matrix {
-
32
-
33namespace internal {
-
34
-
35// For reference see https://numpy.org/doc/stable/user/basics.types.html
-
36// Moreover, considering the small number of digits in the output,
-
37// just single-precision types are used.
-
38template <class T>
-
-
39struct numpy_datatype {
-
40 static constexpr auto typestring = "single";
-
41};
+
15#include <complex>
+
16#include <iostream>
+
17#include <sstream>
+
18#include <string>
+
19
+
20#include <dlaf/common/index2d.h>
+
21#include <dlaf/common/range2d.h>
+
22#include <dlaf/matrix/matrix.h>
+
23#include <dlaf/matrix/tile.h>
+
24#include <dlaf/types.h>
+
25
+
26namespace dlaf {
+
27
+
28namespace format {
+
29struct numpy {};
+
30}
+
31
+
32namespace matrix {
+
33
+
34namespace internal {
+
35
+
36// For reference see https://numpy.org/doc/stable/user/basics.types.html
+
37// Moreover, considering the small number of digits in the output,
+
38// just single-precision types are used.
+
39template <class T>
+
+
40struct numpy_datatype {
+
41 static constexpr auto typestring = "single";
+
42};
-
42
-
43template <class T>
-
-
44struct numpy_datatype<std::complex<T>> {
-
45 static constexpr auto typestring = "csingle";
-
46};
+
43
+
44template <class T>
+
+
45struct numpy_datatype<std::complex<T>> {
+
46 static constexpr auto typestring = "csingle";
+
47};
-
47
-
48template <class T>
-
49std::string numpy_value(const T& value) {
-
50 std::ostringstream os;
-
51 if (std::isnan(value))
-
52 os << "np.nan";
-
53 else
-
54 os << value;
-
55 return os.str();
-
56}
-
57
-
58template <class T>
-
59std::string numpy_value(const std::complex<T>& value) {
-
60 std::ostringstream os;
-
61 const auto imag = std::imag(value);
-
62 const auto sign = (imag < 0) ? '-' : '+';
-
63 os << std::real(value) << sign << std::abs(imag) << "j";
-
64 return os.str();
-
65}
+
48
+
49template <class T>
+
50std::string numpy_value(const T& value) {
+
51 std::ostringstream os;
+
52 if (std::isnan(value))
+
53 os << "np.nan";
+
54 else
+
55 os << value;
+
56 return os.str();
+
57}
+
58
+
59template <class T>
+
60std::string numpy_value(const std::complex<T>& value) {
+
61 std::ostringstream os;
+
62 const auto imag = std::imag(value);
+
63 const auto sign = (imag < 0) ? '-' : '+';
+
64 os << std::real(value) << sign << std::abs(imag) << "j";
+
65 return os.str();
66}
-
67
-
69template <class T>
-
-
70void print(format::numpy, const Tile<const T, Device::CPU>& tile, std::ostream& os = std::cout) {
-
71 os << "np.array([";
-
72
-
73 // Note:
-
74 // iterate_range2d loops over indices in column-major order, while python default
-
75 // order is row-major.
-
76 // For this reason, values are printed in a column-major order, and reordering is deferred
-
77 // to python by tranposing the resulting array (and shaping it accordingly)
-
78 for (const auto& index : iterate_range2d(tile.size()))
-
79 os << internal::numpy_value(tile(index)) << ",";
-
80
-
81 os << "]"
-
82 << ", dtype=np." << internal::numpy_datatype<T>::typestring << ")"
-
83 << ".reshape" << transposed(tile.size()) << ".T\n";
-
84}
+
67}
+
68
+
70template <class T>
+
+
71void print(format::numpy, const Tile<const T, Device::CPU>& tile, std::ostream& os = std::cout) {
+
72 os << "np.array([";
+
73
+
74 // Note:
+
75 // iterate_range2d loops over indices in column-major order, while python default
+
76 // order is row-major.
+
77 // For this reason, values are printed in a column-major order, and reordering is deferred
+
78 // to python by tranposing the resulting array (and shaping it accordingly)
+
79 for (const auto& index : iterate_range2d(tile.size()))
+
80 os << internal::numpy_value(tile(index)) << ",";
+
81
+
82 os << "]"
+
83 << ", dtype=np." << internal::numpy_datatype<T>::typestring << ")"
+
84 << ".reshape" << transposed(tile.size()) << ".T\n";
+
85}
-
85
-
86template <class T, Device D, template <class, Device> class MatrixLikeT>
-
87void print(format::numpy, std::string sym, MatrixLikeT<const T, D>& matrix,
-
88 std::ostream& os = std::cout) {
-
89 using common::iterate_range2d;
-
90
-
91 const auto& distribution = matrix.distribution();
-
92
-
93 os << sym << " = np.zeros(" << distribution.size() << ", dtype=np."
-
94 << internal::numpy_datatype<T>::typestring << ")\n";
-
95
-
96 const LocalTileSize local_tiles = distribution.localNrTiles();
-
97
-
98 auto getTileTopLeft = [&distribution](const LocalTileIndex& local) -> GlobalElementIndex {
-
99 return {
-
100 distribution.template globalElementFromLocalTileAndTileElement<Coord::Row>(local.row(), 0),
-
101 distribution.template globalElementFromLocalTileAndTileElement<Coord::Col>(local.col(), 0),
-
102 };
-
103 };
-
104
-
105 for (const auto& ij_local : iterate_range2d(local_tiles)) {
-
106 const auto tile = pika::this_thread::experimental::sync_wait(matrix.read(ij_local));
-
107
-
108 const auto tl = getTileTopLeft(ij_local);
-
109 const auto br = tl + GlobalElementSize{tile.get().size().rows(), tile.get().size().cols()};
-
110
-
111 os << sym << "[" << tl.row() << ":" << br.row() << "," << tl.col() << ":" << br.col() << "] = ";
-
112 print(format::numpy{}, tile.get(), os);
-
113 }
-
114}
+
86
+
87template <class T, Device D, template <class, Device> class MatrixLikeT>
+
88void print(format::numpy, std::string sym, MatrixLikeT<const T, D>& matrix,
+
89 std::ostream& os = std::cout) {
+
90 using common::iterate_range2d;
+
91
+
92 const auto& distribution = matrix.distribution();
+
93
+
94 os << sym << " = np.zeros(" << distribution.size() << ", dtype=np."
+
95 << internal::numpy_datatype<T>::typestring << ")\n";
+
96
+
97 const LocalTileSize local_tiles = distribution.localNrTiles();
+
98
+
99 auto getTileTopLeft = [&distribution](const LocalTileIndex& local) -> GlobalElementIndex {
+
100 return {
+
101 distribution.template globalElementFromLocalTileAndTileElement<Coord::Row>(local.row(), 0),
+
102 distribution.template globalElementFromLocalTileAndTileElement<Coord::Col>(local.col(), 0),
+
103 };
+
104 };
+
105
+
106 for (const auto& ij_local : iterate_range2d(local_tiles)) {
+
107 const auto tile = pika::this_thread::experimental::sync_wait(matrix.read(ij_local));
+
108
+
109 const auto tl = getTileTopLeft(ij_local);
+
110 const auto br = tl + GlobalElementSize{tile.get().size().rows(), tile.get().size().cols()};
+
111
+
112 os << sym << "[" << tl.row() << ":" << br.row() << "," << tl.col() << ":" << br.col() << "] = ";
+
113 print(format::numpy{}, tile.get(), os);
+
114 }
115}
116}
+
117}
dlaf::common::internal::basic_coords::get
IndexT get() const noexcept
Return a copy of the row or the col index as specified by rc.
Definition index2d.h:87
-
dlaf::matrix::Matrix
Definition matrix.h:61
+
dlaf::matrix::Matrix
Definition matrix.h:62
dlaf::matrix::print
void print(format::csv, const Tile< const T, Device::CPU > &tile, std::ostream &os=std::cout)
Print a tile in csv format to standard output.
Definition print_csv.h:36
dlaf::common::iterate_range2d
IterableRange2D< IndexT, Tag > iterate_range2d(Index2D< IndexT, Tag > begin_idx, Index2D< IndexT, Tag > end_idx) noexcept
Definition range2d.h:247
-
dlaf::format::numpy
Definition print_numpy.h:28
-
dlaf::matrix::internal::numpy_datatype
Definition print_numpy.h:39
+
dlaf::format::numpy
Definition print_numpy.h:29
+
dlaf::matrix::internal::numpy_datatype
Definition print_numpy.h:40
diff --git a/master/qr_8h_source.html b/master/qr_8h_source.html index 5e77fda7c9..24c25e8b9a 100644 --- a/master/qr_8h_source.html +++ b/master/qr_8h_source.html @@ -122,7 +122,7 @@
57
58}
dlaf::comm::CommunicatorPipeline
Definition communicator_pipeline.h:41
-
dlaf::matrix::Matrix
Definition matrix.h:61
+
dlaf::matrix::Matrix
Definition matrix.h:62
communicator_pipeline.h
diff --git a/master/reduction__to__band_8h_source.html b/master/reduction__to__band_8h_source.html index 92c07b3283..1acd0142af 100644 --- a/master/reduction__to__band_8h_source.html +++ b/master/reduction__to__band_8h_source.html @@ -141,7 +141,7 @@
communicator_grid.h
dlaf::eigensolver::internal::reduction_to_band
Matrix< T, Device::CPU > reduction_to_band(Matrix< T, D > &mat_a, const SizeType band_size)
Definition reduction_to_band.h:41
- +
util_matrix.h
diff --git a/master/rot_8h_source.html b/master/rot_8h_source.html index 287c9d01d9..8845ad2c65 100644 --- a/master/rot_8h_source.html +++ b/master/rot_8h_source.html @@ -481,7 +481,7 @@ -
dlaf::matrix::select
auto select(MatrixLike &matrix, common::IterableRange2D< SizeType, LocalTile_TAG > range)
Definition matrix.h:467
+
dlaf::matrix::select
auto select(MatrixLike &matrix, common::IterableRange2D< SizeType, LocalTile_TAG > range)
Definition matrix.h:468
memory_view.h
diff --git a/master/solver_2triangular_2api_8h_source.html b/master/solver_2triangular_2api_8h_source.html index c7fc6ce13c..1427c19f8a 100644 --- a/master/solver_2triangular_2api_8h_source.html +++ b/master/solver_2triangular_2api_8h_source.html @@ -92,75 +92,77 @@
9//
10#pragma once
11
-
12#include <blas.hh>
+
12#include <complex>
13
-
14#include <dlaf/matrix/matrix.h>
-
15#include <dlaf/matrix/matrix_ref.h>
-
16#include <dlaf/types.h>
-
17
-
18namespace dlaf::solver::internal {
+
14#include <blas.hh>
+
15
+
16#include <dlaf/matrix/matrix.h>
+
17#include <dlaf/matrix/matrix_ref.h>
+
18#include <dlaf/types.h>
19
-
20using matrix::internal::MatrixRef;
+
20namespace dlaf::solver::internal {
21
-
22template <Backend backend, Device device, class T>
-
-
23struct Triangular {
-
24 static void call_LLN(blas::Diag diag, T alpha, Matrix<const T, device>& mat_a,
-
25 MatrixRef<T, device>& mat_b);
-
26 static void call_LLT(blas::Op op, blas::Diag diag, T alpha, Matrix<const T, device>& mat_a,
+
22using matrix::internal::MatrixRef;
+
23
+
24template <Backend backend, Device device, class T>
+
+
25struct Triangular {
+
26 static void call_LLN(blas::Diag diag, T alpha, Matrix<const T, device>& mat_a,
27 MatrixRef<T, device>& mat_b);
-
28 static void call_LUN(blas::Diag diag, T alpha, Matrix<const T, device>& mat_a,
+
28 static void call_LLT(blas::Op op, blas::Diag diag, T alpha, Matrix<const T, device>& mat_a,
29 MatrixRef<T, device>& mat_b);
-
30 static void call_LUT(blas::Op op, blas::Diag diag, T alpha, Matrix<const T, device>& mat_a,
+
30 static void call_LUN(blas::Diag diag, T alpha, Matrix<const T, device>& mat_a,
31 MatrixRef<T, device>& mat_b);
-
32 static void call_RLN(blas::Diag diag, T alpha, Matrix<const T, device>& mat_a,
+
32 static void call_LUT(blas::Op op, blas::Diag diag, T alpha, Matrix<const T, device>& mat_a,
33 MatrixRef<T, device>& mat_b);
-
34 static void call_RLT(blas::Op op, blas::Diag diag, T alpha, Matrix<const T, device>& mat_a,
+
34 static void call_RLN(blas::Diag diag, T alpha, Matrix<const T, device>& mat_a,
35 MatrixRef<T, device>& mat_b);
-
36 static void call_RUN(blas::Diag diag, T alpha, Matrix<const T, device>& mat_a,
+
36 static void call_RLT(blas::Op op, blas::Diag diag, T alpha, Matrix<const T, device>& mat_a,
37 MatrixRef<T, device>& mat_b);
-
38 static void call_RUT(blas::Op op, blas::Diag diag, T alpha, Matrix<const T, device>& mat_a,
+
38 static void call_RUN(blas::Diag diag, T alpha, Matrix<const T, device>& mat_a,
39 MatrixRef<T, device>& mat_b);
-
40 static void call_LLN(comm::CommunicatorGrid& grid, blas::Diag diag, T alpha,
-
41 Matrix<const T, device>& mat_a, MatrixRef<T, device>& mat_b);
-
42 static void call_LLT(comm::CommunicatorGrid& grid, blas::Op op, blas::Diag diag, T alpha,
+
40 static void call_RUT(blas::Op op, blas::Diag diag, T alpha, Matrix<const T, device>& mat_a,
+
41 MatrixRef<T, device>& mat_b);
+
42 static void call_LLN(comm::CommunicatorGrid& grid, blas::Diag diag, T alpha,
43 Matrix<const T, device>& mat_a, MatrixRef<T, device>& mat_b);
-
44 static void call_LUN(comm::CommunicatorGrid& grid, blas::Diag diag, T alpha,
+
44 static void call_LLT(comm::CommunicatorGrid& grid, blas::Op op, blas::Diag diag, T alpha,
45 Matrix<const T, device>& mat_a, MatrixRef<T, device>& mat_b);
-
46 static void call_LUT(comm::CommunicatorGrid& grid, blas::Op op, blas::Diag diag, T alpha,
+
46 static void call_LUN(comm::CommunicatorGrid& grid, blas::Diag diag, T alpha,
47 Matrix<const T, device>& mat_a, MatrixRef<T, device>& mat_b);
-
48 static void call_RLN(comm::CommunicatorGrid& grid, blas::Diag diag, T alpha,
+
48 static void call_LUT(comm::CommunicatorGrid& grid, blas::Op op, blas::Diag diag, T alpha,
49 Matrix<const T, device>& mat_a, MatrixRef<T, device>& mat_b);
-
50 static void call_RLT(comm::CommunicatorGrid& grid, blas::Op op, blas::Diag diag, T alpha,
+
50 static void call_RLN(comm::CommunicatorGrid& grid, blas::Diag diag, T alpha,
51 Matrix<const T, device>& mat_a, MatrixRef<T, device>& mat_b);
-
52 static void call_RUN(comm::CommunicatorGrid& grid, blas::Diag diag, T alpha,
+
52 static void call_RLT(comm::CommunicatorGrid& grid, blas::Op op, blas::Diag diag, T alpha,
53 Matrix<const T, device>& mat_a, MatrixRef<T, device>& mat_b);
-
54 static void call_RUT(comm::CommunicatorGrid& grid, blas::Op op, blas::Diag diag, T alpha,
+
54 static void call_RUN(comm::CommunicatorGrid& grid, blas::Diag diag, T alpha,
55 Matrix<const T, device>& mat_a, MatrixRef<T, device>& mat_b);
-
56};
+
56 static void call_RUT(comm::CommunicatorGrid& grid, blas::Op op, blas::Diag diag, T alpha,
+
57 Matrix<const T, device>& mat_a, MatrixRef<T, device>& mat_b);
+
58};
-
57
-
58// ETI
-
59#define DLAF_SOLVER_TRIANGULAR_ETI(KWORD, BACKEND, DEVICE, DATATYPE) \
-
60 KWORD template struct Triangular<BACKEND, DEVICE, DATATYPE>;
-
61
-
62DLAF_SOLVER_TRIANGULAR_ETI(extern, Backend::MC, Device::CPU, float)
-
63DLAF_SOLVER_TRIANGULAR_ETI(extern, Backend::MC, Device::CPU, double)
-
64DLAF_SOLVER_TRIANGULAR_ETI(extern, Backend::MC, Device::CPU, std::complex<float>)
-
65DLAF_SOLVER_TRIANGULAR_ETI(extern, Backend::MC, Device::CPU, std::complex<double>)
-
66
-
67#ifdef DLAF_WITH_GPU
-
68DLAF_SOLVER_TRIANGULAR_ETI(extern, Backend::GPU, Device::GPU, float)
-
69DLAF_SOLVER_TRIANGULAR_ETI(extern, Backend::GPU, Device::GPU, double)
-
70DLAF_SOLVER_TRIANGULAR_ETI(extern, Backend::GPU, Device::GPU, std::complex<float>)
-
71DLAF_SOLVER_TRIANGULAR_ETI(extern, Backend::GPU, Device::GPU, std::complex<double>)
-
72#endif
-
73}
+
59
+
60// ETI
+
61#define DLAF_SOLVER_TRIANGULAR_ETI(KWORD, BACKEND, DEVICE, DATATYPE) \
+
62 KWORD template struct Triangular<BACKEND, DEVICE, DATATYPE>;
+
63
+
64DLAF_SOLVER_TRIANGULAR_ETI(extern, Backend::MC, Device::CPU, float)
+
65DLAF_SOLVER_TRIANGULAR_ETI(extern, Backend::MC, Device::CPU, double)
+
66DLAF_SOLVER_TRIANGULAR_ETI(extern, Backend::MC, Device::CPU, std::complex<float>)
+
67DLAF_SOLVER_TRIANGULAR_ETI(extern, Backend::MC, Device::CPU, std::complex<double>)
+
68
+
69#ifdef DLAF_WITH_GPU
+
70DLAF_SOLVER_TRIANGULAR_ETI(extern, Backend::GPU, Device::GPU, float)
+
71DLAF_SOLVER_TRIANGULAR_ETI(extern, Backend::GPU, Device::GPU, double)
+
72DLAF_SOLVER_TRIANGULAR_ETI(extern, Backend::GPU, Device::GPU, std::complex<float>)
+
73DLAF_SOLVER_TRIANGULAR_ETI(extern, Backend::GPU, Device::GPU, std::complex<double>)
+
74#endif
+
75}
dlaf::comm::CommunicatorGrid
Definition communicator_grid.h:37
-
dlaf::matrix::internal::MatrixRef
Definition matrix_ref.h:171
+
dlaf::matrix::internal::MatrixRef
Definition matrix_ref.h:172
matrix_ref.h
- +
diff --git a/master/solver_2triangular_8h_source.html b/master/solver_2triangular_8h_source.html index bdfc2192b0..2facde6bbf 100644 --- a/master/solver_2triangular_8h_source.html +++ b/master/solver_2triangular_8h_source.html @@ -237,7 +237,7 @@
199
200}
dlaf::comm::CommunicatorGrid
Definition communicator_grid.h:37
-
dlaf::matrix::internal::MatrixRef
Definition matrix_ref.h:171
+
dlaf::matrix::internal::MatrixRef
Definition matrix_ref.h:172
communicator_grid.h
matrix_base.h
diff --git a/master/t__factor__impl_8h_source.html b/master/t__factor__impl_8h_source.html index afe31626ec..ba16bdcf63 100644 --- a/master/t__factor__impl_8h_source.html +++ b/master/t__factor__impl_8h_source.html @@ -441,7 +441,7 @@
dlaf::common::internal::SingleThreadedBlasScope
Definition single_threaded_blas.h:20
-
dlaf::matrix::Matrix
Definition matrix.h:61
+
dlaf::matrix::Matrix
Definition matrix.h:62
communicator_pipeline.h
diff --git a/master/tile__extensions_8h_source.html b/master/tile__extensions_8h_source.html index 8c74eb8ce1..7cb41e172c 100644 --- a/master/tile__extensions_8h_source.html +++ b/master/tile__extensions_8h_source.html @@ -200,7 +200,7 @@
DLAF_MAKE_CALLABLE_OBJECT
#define DLAF_MAKE_CALLABLE_OBJECT(fname)
Definition callable_object.h:29
dlaf::common::internal::SingleThreadedBlasScope
Definition single_threaded_blas.h:20
dlaf::internal::Policy
Definition policy.h:24
-
dlaf::matrix::Matrix
Definition matrix.h:61
+
dlaf::matrix::Matrix
Definition matrix.h:62
single_threaded_blas.h
dlaf::tile::add
void add(T alpha, const matrix::Tile< const T, D > &tile_b, const matrix::Tile< T, D > &tile_a)
diff --git a/master/tile__pipeline_8h_source.html b/master/tile__pipeline_8h_source.html index 1b3011be54..2f106c9513 100644 --- a/master/tile__pipeline_8h_source.html +++ b/master/tile__pipeline_8h_source.html @@ -147,7 +147,7 @@
81};
82}
-
dlaf::matrix::Matrix
Definition matrix.h:61
+
dlaf::matrix::Matrix
Definition matrix.h:62
dlaf::matrix::internal::TilePipeline
Definition tile_pipeline.h:20
dlaf::matrix::internal::TilePipeline::readwrite_with_wrapper
auto readwrite_with_wrapper()
Definition tile_pipeline.h:60
dlaf::matrix::internal::TilePipeline::valid
bool valid() const noexcept
Definition tile_pipeline.h:68
diff --git a/master/tridiag__solver_8h_source.html b/master/tridiag__solver_8h_source.html index ed8b048b7b..7bd152c1bb 100644 --- a/master/tridiag__solver_8h_source.html +++ b/master/tridiag__solver_8h_source.html @@ -170,7 +170,7 @@
dlaf::comm::CommunicatorGrid
Definition communicator_grid.h:37
communicator_grid.h
- +
dlaf::eigensolver::internal::tridiagonal_eigensolver
void tridiagonal_eigensolver(Matrix< BaseType< T >, Device::CPU > &tridiag, Matrix< BaseType< T >, device > &evals, Matrix< T, device > &evecs)
Definition tridiag_solver.h:45
util_matrix.h
diff --git a/master/util__blas_8h_source.html b/master/util__blas_8h_source.html index 24b59374a7..0d299286cc 100644 --- a/master/util__blas_8h_source.html +++ b/master/util__blas_8h_source.html @@ -269,7 +269,7 @@
175}
176}
177}
-
dlaf::matrix::Matrix
Definition matrix.h:61
+
dlaf::matrix::Matrix
Definition matrix.h:62
dlaf::tile::internal::gemmSizes
Definition util_blas.h:26
dlaf::tile::internal::hemmSizes
Definition util_blas.h:66
diff --git a/master/util__matrix_8h.html b/master/util__matrix_8h.html index ee1b9b6dc8..d6fd3e8670 100644 --- a/master/util__matrix_8h.html +++ b/master/util__matrix_8h.html @@ -81,6 +81,7 @@
#include <cmath>
+#include <complex>
#include <cstddef>
#include <optional>
#include <random>
diff --git a/master/util__matrix_8h_source.html b/master/util__matrix_8h_source.html index ef2d38e627..532751844a 100644 --- a/master/util__matrix_8h_source.html +++ b/master/util__matrix_8h_source.html @@ -93,497 +93,498 @@
10#pragma once
11
12#include <cmath>
-
13#include <cstddef>
-
14#include <optional>
-
15#include <random>
-
16#include <utility>
-
17
-
18#ifndef M_PI
-
19constexpr double M_PI = 3.141592;
-
20#endif
-
21
-
22#include <blas.hh>
-
23
-
24#include <pika/execution.hpp>
-
25
-
26#include <dlaf/blas/enum_output.h>
-
27#include <dlaf/common/assert.h>
-
28#include <dlaf/common/index2d.h>
-
29#include <dlaf/common/range2d.h>
-
30#include <dlaf/lapack/tile.h>
-
31#include <dlaf/matrix/matrix.h>
-
32#include <dlaf/matrix/panel.h>
-
33#include <dlaf/sender/transform.h>
-
34#include <dlaf/types.h>
-
35
-
37
-
38namespace dlaf::matrix {
-
39
-
41template <class MatrixLike>
-
-
42bool square_size(const MatrixLike& m) noexcept {
-
43 return m.size().rows() == m.size().cols();
-
44}
-
-
45
-
47template <class MatrixLike>
-
-
48bool square_blocksize(const MatrixLike& m) noexcept {
-
49 return m.block_size().rows() == m.block_size().cols();
-
50}
-
-
51
-
53template <class MatrixLike>
-
-
54bool single_tile_per_block(const MatrixLike& m) noexcept {
-
55 return m.block_size() == m.tile_size();
-
56}
-
-
57
-
59template <class MatrixLikeA, class MatrixLikeB>
-
-
60bool equal_size(const MatrixLikeA& lhs, const MatrixLikeB& rhs) noexcept {
-
61 return lhs.size() == rhs.size();
-
62}
-
-
63
-
65template <class T, Device D1, Device D2>
-
-
66bool equal_blocksize(const Matrix<const T, D1>& lhs, Matrix<const T, D2>& rhs) noexcept {
-
67 return lhs.block_size() == rhs.block_size();
-
68}
-
-
69
-
71template <template <class, Device> class MatrixLike, class T, Device D>
-
-
72bool local_matrix(const MatrixLike<const T, D>& m) noexcept {
-
73 return m.commGridSize() == comm::Size2D(1, 1);
-
74}
-
-
75
-
77template <template <class, Device> class MatrixLike, class T, Device D>
-
-
78bool equal_process_grid(const MatrixLike<const T, D>& m, const comm::CommunicatorGrid& g) noexcept {
-
79 return m.commGridSize() == g.size() && m.rankIndex() == g.rank();
-
80}
-
-
81
-
83template <template <class, Device> class MatrixLike, class T, Device D, comm::CommunicatorType CT>
-
-
84bool equal_process_grid(const MatrixLike<const T, D>& m,
-
85 const comm::CommunicatorPipeline<CT>& p) noexcept {
-
86 return m.commGridSize() == p.size_2d() && m.rankIndex() == p.rank_2d();
-
87}
-
-
88
-
90template <comm::CommunicatorType CT1, comm::CommunicatorType CT2>
-
-
91bool equal_process_grid(const comm::CommunicatorPipeline<CT1>& p1,
-
92 const comm::CommunicatorPipeline<CT2>& p2) noexcept {
-
93 return p1.size_2d() == p2.size_2d() && p1.rank_2d() == p2.rank_2d();
-
94}
-
-
95
-
97template <template <class, Device> class MatrixLikeA, template <class, Device> class MatrixLikeB,
-
98 class T, Device D1, Device D2>
-
-
99bool same_process_grid(const MatrixLikeA<const T, D1>& a, const MatrixLikeB<const T, D2>& b) noexcept {
-
100 return a.commGridSize() == b.commGridSize() && a.rankIndex() == b.rankIndex();
-
101}
-
-
102
-
104template <class T, Device D1, Device D2>
-
-
105bool equal_distributions(const Matrix<const T, D1>& lhs, const Matrix<const T, D2>& rhs) noexcept {
-
106 return lhs.distribution() == rhs.distribution();
-
107}
-
-
108
-
110template <class IndexT, class Tag>
-
-
111bool multipliable_sizes(common::Size2D<IndexT, Tag> a, common::Size2D<IndexT, Tag> b,
-
112 common::Size2D<IndexT, Tag> c, const blas::Op opA, const blas::Op opB) noexcept {
-
113 if (opA != blas::Op::NoTrans)
-
114 a.transpose();
-
115 if (opB != blas::Op::NoTrans)
-
116 b.transpose();
-
117
-
118 return a.rows() == c.rows() && a.cols() == b.rows() && b.cols() == c.cols();
-
119}
-
-
120
-
122template <template <class, Device> class MatrixLikeA, template <class, Device> class MatrixLikeB,
-
123 template <class, Device> class MatrixLikeC, class T, Device D>
-
-
124bool multipliable(const MatrixLikeA<const T, D>& a, const MatrixLikeB<const T, D>& b,
-
125 const MatrixLikeC<const T, D>& c, const blas::Op opA, const blas::Op opB) noexcept {
-
126 const bool isSizeOk = multipliable_sizes(a.size(), b.size(), c.size(), opA, opB);
-
127
-
128 if (a.size().isEmpty() || c.size().isEmpty())
-
129 return isSizeOk;
-
130
-
131 const bool allSameGrid = same_process_grid(a, b) && same_process_grid(b, c);
-
132 const bool isTileSizeOk = multipliable_sizes(a.tile_size(), b.tile_size(), c.tile_size(), opA, opB);
-
133 const bool isOffsetOk = multipliable_sizes(a.tile_size_of({0, 0}), b.tile_size_of({0, 0}),
-
134 c.tile_size_of({0, 0}), opA, opB);
-
135
-
136 if (local_matrix(c))
-
137 return allSameGrid && isSizeOk && isTileSizeOk && isOffsetOk;
-
138
-
139 // TODO distributed (fix offset)
-
140 return allSameGrid && isSizeOk && isTileSizeOk && isOffsetOk;
-
141}
-
-
142
-
143namespace util {
-
144namespace internal {
-
145
-
147template <class T>
-
-
148class getter_random {
-
149 static_assert(std::is_same_v<T, float> || std::is_same_v<T, double>,
-
150 "T is not compatible with random generator used.");
-
151
-
152public:
-
153 getter_random() : random_engine_(std::minstd_rand::default_seed) {}
-
154 getter_random(SizeType seed) : random_engine_(static_cast<std::size_t>(seed)) {
-
155 DLAF_ASSERT(seed >= 0, "");
-
156 }
-
157
-
158 T operator()() {
-
159 return random_sampler_(random_engine_);
-
160 }
-
161
-
162private:
-
163 std::mt19937_64 random_engine_;
-
164 std::uniform_real_distribution<T> random_sampler_{-1, 1};
-
165};
-
-
166
-
168template <class T>
-
-
169class getter_random<std::complex<T>> : private getter_random<T> {
-
170public:
-
171 using getter_random<T>::getter_random;
-
172
-
173 std::complex<T> operator()() {
-
174 return std::polar<T>(std::abs(getter_random<T>::operator()()),
-
175 static_cast<T>(M_PI) * getter_random<T>::operator()());
-
176 }
-
177};
-
-
178
-
179}
-
180
-
183template <Backend backend, class T, Device D>
-
-
184void set0(pika::execution::thread_priority priority, LocalTileIndex begin, LocalTileSize sz,
-
185 Matrix<T, D>& matrix) {
-
186 using dlaf::internal::Policy;
-
187 using pika::execution::thread_stacksize;
-
188 using pika::execution::experimental::start_detached;
-
189
-
190 for (const auto& ij_lc : iterate_range2d(begin, sz))
-
191 start_detached(matrix.readwrite(ij_lc) |
-
192 tile::set0(Policy<backend>(priority, thread_stacksize::nostack)));
-
193}
-
-
194
-
199template <Backend backend, class T, Device D>
-
200void set0(pika::execution::thread_priority priority, Matrix<T, D>& matrix) {
-
201 set0<backend>(priority, LocalTileIndex(0, 0), matrix.distribution().local_nr_tiles(), matrix);
-
202}
-
203
-
205template <Backend backend, class T, Coord axis, Device D, StoreTransposed storage>
-
-
206void set0(pika::execution::thread_priority priority, Panel<axis, T, D, storage>& panel) {
-
207 using dlaf::internal::Policy;
-
208 using pika::execution::thread_stacksize;
-
209 using pika::execution::experimental::start_detached;
-
210
-
211 for (const auto& ij_lc : panel.iteratorLocal())
-
212 start_detached(panel.readwrite(ij_lc) |
-
213 tile::set0(Policy<backend>(priority, thread_stacksize::nostack)));
-
214}
-
-
215
-
222template <class T, class ElementGetter>
-
-
223void set(Matrix<T, Device::CPU>& matrix, ElementGetter el_f) {
-
224 using pika::execution::thread_stacksize;
-
225
-
226 const Distribution& dist = matrix.distribution();
-
227 for (auto ij_lc : iterate_range2d(dist.local_nr_tiles())) {
-
228 GlobalTileIndex ij = dist.global_tile_index(ij_lc);
-
229 auto tile_origin = dist.global_element_index(ij, {0, 0});
-
230
-
231 using TileType = typename std::decay_t<decltype(matrix)>::TileType;
-
232 auto set_f = [tile_origin, el_f = el_f](const TileType& tile) {
-
233 for (auto ij_el_tl : iterate_range2d(tile.size())) {
-
234 GlobalElementIndex ij_el_gl(tile_origin.row() + ij_el_tl.row(),
-
235 tile_origin.col() + ij_el_tl.col());
-
236 tile(ij_el_tl) = el_f(ij_el_gl);
-
237 }
-
238 };
-
239
-
240 dlaf::internal::transformDetach(dlaf::internal::Policy<Backend::MC>(thread_stacksize::nostack),
-
241 std::move(set_f), matrix.readwrite(ij_lc));
-
242 }
-
243}
-
-
244
-
254template <class T, class ElementGetter>
-
-
255void set(Matrix<T, Device::CPU>& matrix, ElementGetter el_f, const blas::Op op) {
-
256 auto el_op_f = [op, el_f](const GlobalElementIndex& index) -> T {
-
257 using blas::Op;
-
258 switch (op) {
-
259 case Op::NoTrans:
-
260 return el_f(index);
-
261 case Op::Trans:
-
262 return el_f(transposed(index));
-
263 case Op::ConjTrans:
-
264 return dlaf::conj(el_f(transposed(index)));
-
265 default:
-
266 DLAF_UNIMPLEMENTED(op);
-
267 return T{};
-
268 }
-
269 };
-
270
-
271 set(matrix, el_op_f);
-
272}
-
-
273
-
277template <class T>
-
-
278void set_identity(Matrix<T, Device::CPU>& matrix) {
-
279 set(matrix, [](const GlobalElementIndex& ij_lc) {
-
280 if (ij_lc.row() == ij_lc.col())
-
281 return T{1};
-
282 return T{0};
-
283 });
-
284}
-
-
285
-
296template <class T>
-
-
297void set_random(Matrix<T, Device::CPU>& matrix) {
-
298 using pika::execution::thread_stacksize;
-
299
-
300 const Distribution& dist = matrix.distribution();
-
301 for (auto ij_lc : iterate_range2d(dist.local_nr_tiles())) {
-
302 GlobalTileIndex ij = dist.global_tile_index(ij_lc);
-
303 auto tile_origin = dist.global_element_index(ij, {0, 0});
-
304 auto seed = tile_origin.col() + tile_origin.row() * matrix.size().cols();
-
305
-
306 using TileType = typename std::decay_t<decltype(matrix)>::TileType;
-
307 auto rnd_f = [seed](TileType&& tile) {
-
308 internal::getter_random<T> random_value(seed);
-
309 for (auto ij_el_tl : iterate_range2d(tile.size())) {
-
310 tile(ij_el_tl) = random_value();
-
311 }
-
312 };
-
313
-
314 dlaf::internal::transformDetach(dlaf::internal::Policy<Backend::MC>(thread_stacksize::nostack),
-
315 std::move(rnd_f), matrix.readwrite(ij_lc));
-
316 }
-
317}
-
-
318
-
319namespace internal {
-
320
-
321template <class T>
-
322void set_diagonal_tile(const Tile<T, Device::CPU>& tile, internal::getter_random<T>& random_value,
-
323 SizeType offset_value) {
-
324 // DIAGONAL
-
325 // for diagonal tiles get just lower matrix values and set value for both
-
326 // straight and transposed indices
-
327 for (SizeType j = 0; j < tile.size().cols(); ++j) {
-
328 for (SizeType i = 0; i < j; ++i) {
-
329 auto value = random_value();
-
330
-
331 tile(TileElementIndex{i, j}) = value;
-
332 tile(TileElementIndex{j, i}) = dlaf::conj(value);
-
333 }
-
334 tile(TileElementIndex{j, j}) = std::real(random_value()) + offset_value;
-
335 }
-
336}
-
337
-
338template <class T>
-
339void set_lower_and_upper_tile(const Tile<T, Device::CPU>& tile, internal::getter_random<T>& random_value,
-
340 TileElementSize full_tile_size, GlobalTileIndex ij,
-
341 dlaf::matrix::Distribution dist,
-
342 std::optional<SizeType> band_size = std::nullopt) {
-
343 auto is_off_band = [](GlobalElementIndex ij_lc, std::optional<SizeType> band_size) {
-
344 return band_size ? ij_lc.col() < ij_lc.row() - *band_size || ij_lc.col() > ij_lc.row() + *band_size
-
345 : false;
-
346 };
-
347
-
348 // LOWER or UPPER (except DIAGONAL)
-
349 // random values are requested in the same order for both original and transposed
-
350 for (SizeType j = 0; j < full_tile_size.cols(); ++j) {
-
351 for (SizeType i = 0; i < full_tile_size.rows(); ++i) {
-
352 auto value = random_value();
-
353
-
354 // but they are set row-wise in the original tile and col-wise in the
-
355 // transposed one
-
356 if (ij.row() > ij.col()) { // LOWER
-
357 TileElementIndex index{i, j};
-
358 if (index.isIn(tile.size())) {
-
359 auto ij_lc = dist.globalElementIndex(ij, index);
-
360 if (is_off_band(ij_lc, band_size))
-
361 tile(index) = T(0);
-
362 else
-
363 tile(index) = value;
-
364 }
-
365 }
-
366 else { // UPPER
-
367 TileElementIndex index{j, i};
-
368 if (index.isIn(tile.size())) {
-
369 auto ij_lc = dist.globalElementIndex(ij, index);
-
370 if (is_off_band(ij_lc, band_size))
-
371 tile(index) = T(0);
-
372 else
-
373 tile(index) = dlaf::conj(value);
-
374 }
-
375 }
-
376 }
-
377 }
-
378}
-
379
-
396template <class T>
-
-
397void set_random_hermitian_with_offset(Matrix<T, Device::CPU>& matrix, const SizeType offset_value,
-
398 std::optional<SizeType> band_size = std::nullopt) {
-
399 using pika::execution::thread_stacksize;
-
400
-
401 // note:
-
402 // By assuming square blocksizes, it is easier to locate elements. In fact:
-
403 // - Elements on the diagonal are stored in the diagonal of the diagonal tiles
-
404 // - Tiles under the diagonal store elements of the lower triangular matrix
-
405 // - Tiles over the diagonal store elements of the upper triangular matrix
-
406
-
407 const Distribution& dist = matrix.distribution();
-
408
-
409 DLAF_ASSERT(square_size(matrix), matrix);
-
410 DLAF_ASSERT(square_blocksize(matrix), matrix);
-
411
-
412 auto full_tile_size = matrix.block_size();
-
413
-
414 for (auto ij_lc : iterate_range2d(dist.local_nr_tiles())) {
-
415 GlobalTileIndex ij = dist.global_tile_index(ij_lc);
-
416
-
417 auto tile_origin = dist.global_element_index(ij, {0, 0});
-
418
-
419 // compute the same seed for original and "transposed" tiles, so transposed ones will know the
-
420 // values of the original one without the need of accessing real values (nor communication in case
-
421 // of distributed matrices)
-
422 SizeType seed;
-
423 if (ij.row() >= ij.col()) // LOWER or DIAGONAL
-
424 seed = tile_origin.col() + tile_origin.row() * matrix.size().cols();
-
425 else
-
426 seed = tile_origin.row() + tile_origin.col() * matrix.size().rows();
-
427
-
428 using TileType = typename std::decay_t<decltype(matrix)>::TileType;
-
429 auto set_hp_f = [=](const TileType& tile) {
-
430 internal::getter_random<T> random_value(seed);
-
431 if (ij.row() == ij.col())
-
432 internal::set_diagonal_tile(tile, random_value, offset_value);
-
433 else
-
434 internal::set_lower_and_upper_tile(tile, random_value, full_tile_size, ij, dist, band_size);
-
435 };
-
436
-
437 dlaf::internal::transformDetach(dlaf::internal::Policy<Backend::MC>(thread_stacksize::nostack),
-
438 std::move(set_hp_f), matrix.readwrite(ij_lc));
-
439 }
-
440}
-
-
441
-
451template <class T, Device D>
-
452dlaf::matrix::internal::SubMatrixSpec sub_matrix_spec_slice_cols(const Matrix<T, D>& matrix,
-
453 SizeType col_begin, SizeType col_end) {
-
454 DLAF_ASSERT(col_begin >= 0, col_begin);
-
455 DLAF_ASSERT(col_begin <= col_end, col_begin, col_end);
-
456 DLAF_ASSERT(col_end <= matrix.size().cols(), col_end, matrix.size().cols());
-
457 return dlaf::matrix::internal::SubMatrixSpec({{0, col_begin},
-
458 {matrix.size().rows(), col_end - col_begin}});
-
459}
-
460
-
461}
-
462
-
476template <class T>
-
-
477void set_random_hermitian(Matrix<T, Device::CPU>& matrix) {
-
478 internal::set_random_hermitian_with_offset(matrix, 0);
-
479}
-
-
480
-
494template <class T>
-
-
495void set_random_hermitian_banded(Matrix<T, Device::CPU>& matrix, const SizeType band_size) {
-
496 internal::set_random_hermitian_with_offset(matrix, 0, band_size);
-
497}
-
-
498
-
515template <class T>
-
-
516void set_random_hermitian_positive_definite(Matrix<T, Device::CPU>& matrix) {
-
517 internal::set_random_hermitian_with_offset(matrix, 2 * matrix.size().rows());
-
518}
-
-
519
-
536template <class T>
-
-
537void set_random_non_zero_diagonal(Matrix<T, Device::CPU>& matrix) {
-
538 using pika::execution::thread_stacksize;
-
539
-
540 // note:
-
541 // By assuming square blocksizes, it is easier to locate elements. In fact:
-
542 // - Elements on the diagonal are stored in the diagonal of the diagonal tiles
-
543 // - Tiles under the diagonal store elements of the lower triangular matrix
-
544 // - Tiles over the diagonal store elements of the upper triangular matrix
-
545
-
546 const Distribution& dist = matrix.distribution();
-
547
-
548 DLAF_ASSERT(square_size(matrix), matrix);
-
549 DLAF_ASSERT(square_blocksize(matrix), matrix);
-
550
-
551 for (auto ij_lc : iterate_range2d(dist.local_nr_tiles())) {
-
552 GlobalTileIndex ij = dist.global_tile_index(ij_lc);
-
553
-
554 const SizeType seed = ij.col() + ij.row() * matrix.size().cols();
-
555 const BaseType<T> lower_limit = static_cast<BaseType<T>>(0.1);
-
556
-
557 using TileType = typename std::decay_t<decltype(matrix)>::TileType;
-
558 auto set_hp_f = [=](const TileType& tile) {
-
559 internal::getter_random<T> random_value(seed);
-
560 if (ij.row() == ij.col()) {
-
561 for (auto ij_el_tl : iterate_range2d(tile.size())) {
-
562 auto value = random_value();
-
563 if (ij_el_tl.row() == ij_el_tl.col() && std::abs(value) < lower_limit) {
-
564 if (value == T{0})
-
565 tile(ij_el_tl) = lower_limit;
-
566 else
-
567 tile(ij_el_tl) = lower_limit * value / std::abs(value);
-
568 }
-
569 else
-
570 tile(ij_el_tl) = value;
-
571 }
-
572 }
-
573 else
-
574 for (auto ij_el_tl : iterate_range2d(tile.size())) {
-
575 tile(ij_el_tl) = random_value();
-
576 }
-
577 };
-
578
-
579 dlaf::internal::transformDetach(dlaf::internal::Policy<Backend::MC>(thread_stacksize::nostack),
-
580 std::move(set_hp_f), matrix.readwrite(ij_lc));
-
581 }
-
582}
-
-
583
-
584}
+
13#include <complex>
+
14#include <cstddef>
+
15#include <optional>
+
16#include <random>
+
17#include <utility>
+
18
+
19#ifndef M_PI
+
20constexpr double M_PI = 3.141592;
+
21#endif
+
22
+
23#include <blas.hh>
+
24
+
25#include <pika/execution.hpp>
+
26
+
27#include <dlaf/blas/enum_output.h>
+
28#include <dlaf/common/assert.h>
+
29#include <dlaf/common/index2d.h>
+
30#include <dlaf/common/range2d.h>
+
31#include <dlaf/lapack/tile.h>
+
32#include <dlaf/matrix/matrix.h>
+
33#include <dlaf/matrix/panel.h>
+
34#include <dlaf/sender/transform.h>
+
35#include <dlaf/types.h>
+
36
+
38
+
39namespace dlaf::matrix {
+
40
+
42template <class MatrixLike>
+
+
43bool square_size(const MatrixLike& m) noexcept {
+
44 return m.size().rows() == m.size().cols();
+
45}
+
+
46
+
48template <class MatrixLike>
+
+
49bool square_blocksize(const MatrixLike& m) noexcept {
+
50 return m.block_size().rows() == m.block_size().cols();
+
51}
+
+
52
+
54template <class MatrixLike>
+
+
55bool single_tile_per_block(const MatrixLike& m) noexcept {
+
56 return m.block_size() == m.tile_size();
+
57}
+
+
58
+
60template <class MatrixLikeA, class MatrixLikeB>
+
+
61bool equal_size(const MatrixLikeA& lhs, const MatrixLikeB& rhs) noexcept {
+
62 return lhs.size() == rhs.size();
+
63}
+
+
64
+
66template <class T, Device D1, Device D2>
+
+
67bool equal_blocksize(const Matrix<const T, D1>& lhs, Matrix<const T, D2>& rhs) noexcept {
+
68 return lhs.block_size() == rhs.block_size();
+
69}
+
+
70
+
72template <template <class, Device> class MatrixLike, class T, Device D>
+
+
73bool local_matrix(const MatrixLike<const T, D>& m) noexcept {
+
74 return m.commGridSize() == comm::Size2D(1, 1);
+
75}
+
+
76
+
78template <template <class, Device> class MatrixLike, class T, Device D>
+
+
79bool equal_process_grid(const MatrixLike<const T, D>& m, const comm::CommunicatorGrid& g) noexcept {
+
80 return m.commGridSize() == g.size() && m.rankIndex() == g.rank();
+
81}
+
+
82
+
84template <template <class, Device> class MatrixLike, class T, Device D, comm::CommunicatorType CT>
+
+
85bool equal_process_grid(const MatrixLike<const T, D>& m,
+
86 const comm::CommunicatorPipeline<CT>& p) noexcept {
+
87 return m.commGridSize() == p.size_2d() && m.rankIndex() == p.rank_2d();
+
88}
+
+
89
+
91template <comm::CommunicatorType CT1, comm::CommunicatorType CT2>
+
+
92bool equal_process_grid(const comm::CommunicatorPipeline<CT1>& p1,
+
93 const comm::CommunicatorPipeline<CT2>& p2) noexcept {
+
94 return p1.size_2d() == p2.size_2d() && p1.rank_2d() == p2.rank_2d();
+
95}
+
+
96
+
98template <template <class, Device> class MatrixLikeA, template <class, Device> class MatrixLikeB,
+
99 class T, Device D1, Device D2>
+
+
100bool same_process_grid(const MatrixLikeA<const T, D1>& a, const MatrixLikeB<const T, D2>& b) noexcept {
+
101 return a.commGridSize() == b.commGridSize() && a.rankIndex() == b.rankIndex();
+
102}
+
+
103
+
105template <class T, Device D1, Device D2>
+
+
106bool equal_distributions(const Matrix<const T, D1>& lhs, const Matrix<const T, D2>& rhs) noexcept {
+
107 return lhs.distribution() == rhs.distribution();
+
108}
+
+
109
+
111template <class IndexT, class Tag>
+
+
112bool multipliable_sizes(common::Size2D<IndexT, Tag> a, common::Size2D<IndexT, Tag> b,
+
113 common::Size2D<IndexT, Tag> c, const blas::Op opA, const blas::Op opB) noexcept {
+
114 if (opA != blas::Op::NoTrans)
+
115 a.transpose();
+
116 if (opB != blas::Op::NoTrans)
+
117 b.transpose();
+
118
+
119 return a.rows() == c.rows() && a.cols() == b.rows() && b.cols() == c.cols();
+
120}
+
+
121
+
123template <template <class, Device> class MatrixLikeA, template <class, Device> class MatrixLikeB,
+
124 template <class, Device> class MatrixLikeC, class T, Device D>
+
+
125bool multipliable(const MatrixLikeA<const T, D>& a, const MatrixLikeB<const T, D>& b,
+
126 const MatrixLikeC<const T, D>& c, const blas::Op opA, const blas::Op opB) noexcept {
+
127 const bool isSizeOk = multipliable_sizes(a.size(), b.size(), c.size(), opA, opB);
+
128
+
129 if (a.size().isEmpty() || c.size().isEmpty())
+
130 return isSizeOk;
+
131
+
132 const bool allSameGrid = same_process_grid(a, b) && same_process_grid(b, c);
+
133 const bool isTileSizeOk = multipliable_sizes(a.tile_size(), b.tile_size(), c.tile_size(), opA, opB);
+
134 const bool isOffsetOk = multipliable_sizes(a.tile_size_of({0, 0}), b.tile_size_of({0, 0}),
+
135 c.tile_size_of({0, 0}), opA, opB);
+
136
+
137 if (local_matrix(c))
+
138 return allSameGrid && isSizeOk && isTileSizeOk && isOffsetOk;
+
139
+
140 // TODO distributed (fix offset)
+
141 return allSameGrid && isSizeOk && isTileSizeOk && isOffsetOk;
+
142}
+
+
143
+
144namespace util {
+
145namespace internal {
+
146
+
148template <class T>
+
+
149class getter_random {
+
150 static_assert(std::is_same_v<T, float> || std::is_same_v<T, double>,
+
151 "T is not compatible with random generator used.");
+
152
+
153public:
+
154 getter_random() : random_engine_(std::minstd_rand::default_seed) {}
+
155 getter_random(SizeType seed) : random_engine_(static_cast<std::size_t>(seed)) {
+
156 DLAF_ASSERT(seed >= 0, "");
+
157 }
+
158
+
159 T operator()() {
+
160 return random_sampler_(random_engine_);
+
161 }
+
162
+
163private:
+
164 std::mt19937_64 random_engine_;
+
165 std::uniform_real_distribution<T> random_sampler_{-1, 1};
+
166};
+
+
167
+
169template <class T>
+
+
170class getter_random<std::complex<T>> : private getter_random<T> {
+
171public:
+
172 using getter_random<T>::getter_random;
+
173
+
174 std::complex<T> operator()() {
+
175 return std::polar<T>(std::abs(getter_random<T>::operator()()),
+
176 static_cast<T>(M_PI) * getter_random<T>::operator()());
+
177 }
+
178};
+
+
179
+
180}
+
181
+
184template <Backend backend, class T, Device D>
+
+
185void set0(pika::execution::thread_priority priority, LocalTileIndex begin, LocalTileSize sz,
+
186 Matrix<T, D>& matrix) {
+
187 using dlaf::internal::Policy;
+
188 using pika::execution::thread_stacksize;
+
189 using pika::execution::experimental::start_detached;
+
190
+
191 for (const auto& ij_lc : iterate_range2d(begin, sz))
+
192 start_detached(matrix.readwrite(ij_lc) |
+
193 tile::set0(Policy<backend>(priority, thread_stacksize::nostack)));
+
194}
+
+
195
+
200template <Backend backend, class T, Device D>
+
201void set0(pika::execution::thread_priority priority, Matrix<T, D>& matrix) {
+
202 set0<backend>(priority, LocalTileIndex(0, 0), matrix.distribution().local_nr_tiles(), matrix);
+
203}
+
204
+
206template <Backend backend, class T, Coord axis, Device D, StoreTransposed storage>
+
+
207void set0(pika::execution::thread_priority priority, Panel<axis, T, D, storage>& panel) {
+
208 using dlaf::internal::Policy;
+
209 using pika::execution::thread_stacksize;
+
210 using pika::execution::experimental::start_detached;
+
211
+
212 for (const auto& ij_lc : panel.iteratorLocal())
+
213 start_detached(panel.readwrite(ij_lc) |
+
214 tile::set0(Policy<backend>(priority, thread_stacksize::nostack)));
+
215}
+
+
216
+
223template <class T, class ElementGetter>
+
+
224void set(Matrix<T, Device::CPU>& matrix, ElementGetter el_f) {
+
225 using pika::execution::thread_stacksize;
+
226
+
227 const Distribution& dist = matrix.distribution();
+
228 for (auto ij_lc : iterate_range2d(dist.local_nr_tiles())) {
+
229 GlobalTileIndex ij = dist.global_tile_index(ij_lc);
+
230 auto tile_origin = dist.global_element_index(ij, {0, 0});
+
231
+
232 using TileType = typename std::decay_t<decltype(matrix)>::TileType;
+
233 auto set_f = [tile_origin, el_f = el_f](const TileType& tile) {
+
234 for (auto ij_el_tl : iterate_range2d(tile.size())) {
+
235 GlobalElementIndex ij_el_gl(tile_origin.row() + ij_el_tl.row(),
+
236 tile_origin.col() + ij_el_tl.col());
+
237 tile(ij_el_tl) = el_f(ij_el_gl);
+
238 }
+
239 };
+
240
+
241 dlaf::internal::transformDetach(dlaf::internal::Policy<Backend::MC>(thread_stacksize::nostack),
+
242 std::move(set_f), matrix.readwrite(ij_lc));
+
243 }
+
244}
+
+
245
+
255template <class T, class ElementGetter>
+
+
256void set(Matrix<T, Device::CPU>& matrix, ElementGetter el_f, const blas::Op op) {
+
257 auto el_op_f = [op, el_f](const GlobalElementIndex& index) -> T {
+
258 using blas::Op;
+
259 switch (op) {
+
260 case Op::NoTrans:
+
261 return el_f(index);
+
262 case Op::Trans:
+
263 return el_f(transposed(index));
+
264 case Op::ConjTrans:
+
265 return dlaf::conj(el_f(transposed(index)));
+
266 default:
+
267 DLAF_UNIMPLEMENTED(op);
+
268 return T{};
+
269 }
+
270 };
+
271
+
272 set(matrix, el_op_f);
+
273}
+
+
274
+
278template <class T>
+
+
279void set_identity(Matrix<T, Device::CPU>& matrix) {
+
280 set(matrix, [](const GlobalElementIndex& ij_lc) {
+
281 if (ij_lc.row() == ij_lc.col())
+
282 return T{1};
+
283 return T{0};
+
284 });
+
285}
+
+
286
+
297template <class T>
+
+
298void set_random(Matrix<T, Device::CPU>& matrix) {
+
299 using pika::execution::thread_stacksize;
+
300
+
301 const Distribution& dist = matrix.distribution();
+
302 for (auto ij_lc : iterate_range2d(dist.local_nr_tiles())) {
+
303 GlobalTileIndex ij = dist.global_tile_index(ij_lc);
+
304 auto tile_origin = dist.global_element_index(ij, {0, 0});
+
305 auto seed = tile_origin.col() + tile_origin.row() * matrix.size().cols();
+
306
+
307 using TileType = typename std::decay_t<decltype(matrix)>::TileType;
+
308 auto rnd_f = [seed](TileType&& tile) {
+
309 internal::getter_random<T> random_value(seed);
+
310 for (auto ij_el_tl : iterate_range2d(tile.size())) {
+
311 tile(ij_el_tl) = random_value();
+
312 }
+
313 };
+
314
+
315 dlaf::internal::transformDetach(dlaf::internal::Policy<Backend::MC>(thread_stacksize::nostack),
+
316 std::move(rnd_f), matrix.readwrite(ij_lc));
+
317 }
+
318}
+
+
319
+
320namespace internal {
+
321
+
322template <class T>
+
323void set_diagonal_tile(const Tile<T, Device::CPU>& tile, internal::getter_random<T>& random_value,
+
324 SizeType offset_value) {
+
325 // DIAGONAL
+
326 // for diagonal tiles get just lower matrix values and set value for both
+
327 // straight and transposed indices
+
328 for (SizeType j = 0; j < tile.size().cols(); ++j) {
+
329 for (SizeType i = 0; i < j; ++i) {
+
330 auto value = random_value();
+
331
+
332 tile(TileElementIndex{i, j}) = value;
+
333 tile(TileElementIndex{j, i}) = dlaf::conj(value);
+
334 }
+
335 tile(TileElementIndex{j, j}) = std::real(random_value()) + offset_value;
+
336 }
+
337}
+
338
+
339template <class T>
+
340void set_lower_and_upper_tile(const Tile<T, Device::CPU>& tile, internal::getter_random<T>& random_value,
+
341 TileElementSize full_tile_size, GlobalTileIndex ij,
+
342 dlaf::matrix::Distribution dist,
+
343 std::optional<SizeType> band_size = std::nullopt) {
+
344 auto is_off_band = [](GlobalElementIndex ij_lc, std::optional<SizeType> band_size) {
+
345 return band_size ? ij_lc.col() < ij_lc.row() - *band_size || ij_lc.col() > ij_lc.row() + *band_size
+
346 : false;
+
347 };
+
348
+
349 // LOWER or UPPER (except DIAGONAL)
+
350 // random values are requested in the same order for both original and transposed
+
351 for (SizeType j = 0; j < full_tile_size.cols(); ++j) {
+
352 for (SizeType i = 0; i < full_tile_size.rows(); ++i) {
+
353 auto value = random_value();
+
354
+
355 // but they are set row-wise in the original tile and col-wise in the
+
356 // transposed one
+
357 if (ij.row() > ij.col()) { // LOWER
+
358 TileElementIndex index{i, j};
+
359 if (index.isIn(tile.size())) {
+
360 auto ij_lc = dist.globalElementIndex(ij, index);
+
361 if (is_off_band(ij_lc, band_size))
+
362 tile(index) = T(0);
+
363 else
+
364 tile(index) = value;
+
365 }
+
366 }
+
367 else { // UPPER
+
368 TileElementIndex index{j, i};
+
369 if (index.isIn(tile.size())) {
+
370 auto ij_lc = dist.globalElementIndex(ij, index);
+
371 if (is_off_band(ij_lc, band_size))
+
372 tile(index) = T(0);
+
373 else
+
374 tile(index) = dlaf::conj(value);
+
375 }
+
376 }
+
377 }
+
378 }
+
379}
+
380
+
397template <class T>
+
+
398void set_random_hermitian_with_offset(Matrix<T, Device::CPU>& matrix, const SizeType offset_value,
+
399 std::optional<SizeType> band_size = std::nullopt) {
+
400 using pika::execution::thread_stacksize;
+
401
+
402 // note:
+
403 // By assuming square blocksizes, it is easier to locate elements. In fact:
+
404 // - Elements on the diagonal are stored in the diagonal of the diagonal tiles
+
405 // - Tiles under the diagonal store elements of the lower triangular matrix
+
406 // - Tiles over the diagonal store elements of the upper triangular matrix
+
407
+
408 const Distribution& dist = matrix.distribution();
+
409
+
410 DLAF_ASSERT(square_size(matrix), matrix);
+
411 DLAF_ASSERT(square_blocksize(matrix), matrix);
+
412
+
413 auto full_tile_size = matrix.block_size();
+
414
+
415 for (auto ij_lc : iterate_range2d(dist.local_nr_tiles())) {
+
416 GlobalTileIndex ij = dist.global_tile_index(ij_lc);
+
417
+
418 auto tile_origin = dist.global_element_index(ij, {0, 0});
+
419
+
420 // compute the same seed for original and "transposed" tiles, so transposed ones will know the
+
421 // values of the original one without the need of accessing real values (nor communication in case
+
422 // of distributed matrices)
+
423 SizeType seed;
+
424 if (ij.row() >= ij.col()) // LOWER or DIAGONAL
+
425 seed = tile_origin.col() + tile_origin.row() * matrix.size().cols();
+
426 else
+
427 seed = tile_origin.row() + tile_origin.col() * matrix.size().rows();
+
428
+
429 using TileType = typename std::decay_t<decltype(matrix)>::TileType;
+
430 auto set_hp_f = [=](const TileType& tile) {
+
431 internal::getter_random<T> random_value(seed);
+
432 if (ij.row() == ij.col())
+
433 internal::set_diagonal_tile(tile, random_value, offset_value);
+
434 else
+
435 internal::set_lower_and_upper_tile(tile, random_value, full_tile_size, ij, dist, band_size);
+
436 };
+
437
+
438 dlaf::internal::transformDetach(dlaf::internal::Policy<Backend::MC>(thread_stacksize::nostack),
+
439 std::move(set_hp_f), matrix.readwrite(ij_lc));
+
440 }
+
441}
+
+
442
+
452template <class T, Device D>
+
453dlaf::matrix::internal::SubMatrixSpec sub_matrix_spec_slice_cols(const Matrix<T, D>& matrix,
+
454 SizeType col_begin, SizeType col_end) {
+
455 DLAF_ASSERT(col_begin >= 0, col_begin);
+
456 DLAF_ASSERT(col_begin <= col_end, col_begin, col_end);
+
457 DLAF_ASSERT(col_end <= matrix.size().cols(), col_end, matrix.size().cols());
+
458 return dlaf::matrix::internal::SubMatrixSpec({{0, col_begin},
+
459 {matrix.size().rows(), col_end - col_begin}});
+
460}
+
461
+
462}
+
463
+
477template <class T>
+
+
478void set_random_hermitian(Matrix<T, Device::CPU>& matrix) {
+
479 internal::set_random_hermitian_with_offset(matrix, 0);
+
480}
+
+
481
+
495template <class T>
+
+
496void set_random_hermitian_banded(Matrix<T, Device::CPU>& matrix, const SizeType band_size) {
+
497 internal::set_random_hermitian_with_offset(matrix, 0, band_size);
+
498}
+
+
499
+
516template <class T>
+
+
517void set_random_hermitian_positive_definite(Matrix<T, Device::CPU>& matrix) {
+
518 internal::set_random_hermitian_with_offset(matrix, 2 * matrix.size().rows());
+
519}
+
+
520
+
537template <class T>
+
+
538void set_random_non_zero_diagonal(Matrix<T, Device::CPU>& matrix) {
+
539 using pika::execution::thread_stacksize;
+
540
+
541 // note:
+
542 // By assuming square blocksizes, it is easier to locate elements. In fact:
+
543 // - Elements on the diagonal are stored in the diagonal of the diagonal tiles
+
544 // - Tiles under the diagonal store elements of the lower triangular matrix
+
545 // - Tiles over the diagonal store elements of the upper triangular matrix
+
546
+
547 const Distribution& dist = matrix.distribution();
+
548
+
549 DLAF_ASSERT(square_size(matrix), matrix);
+
550 DLAF_ASSERT(square_blocksize(matrix), matrix);
+
551
+
552 for (auto ij_lc : iterate_range2d(dist.local_nr_tiles())) {
+
553 GlobalTileIndex ij = dist.global_tile_index(ij_lc);
+
554
+
555 const SizeType seed = ij.col() + ij.row() * matrix.size().cols();
+
556 const BaseType<T> lower_limit = static_cast<BaseType<T>>(0.1);
+
557
+
558 using TileType = typename std::decay_t<decltype(matrix)>::TileType;
+
559 auto set_hp_f = [=](const TileType& tile) {
+
560 internal::getter_random<T> random_value(seed);
+
561 if (ij.row() == ij.col()) {
+
562 for (auto ij_el_tl : iterate_range2d(tile.size())) {
+
563 auto value = random_value();
+
564 if (ij_el_tl.row() == ij_el_tl.col() && std::abs(value) < lower_limit) {
+
565 if (value == T{0})
+
566 tile(ij_el_tl) = lower_limit;
+
567 else
+
568 tile(ij_el_tl) = lower_limit * value / std::abs(value);
+
569 }
+
570 else
+
571 tile(ij_el_tl) = value;
+
572 }
+
573 }
+
574 else
+
575 for (auto ij_el_tl : iterate_range2d(tile.size())) {
+
576 tile(ij_el_tl) = random_value();
+
577 }
+
578 };
+
579
+
580 dlaf::internal::transformDetach(dlaf::internal::Policy<Backend::MC>(thread_stacksize::nostack),
+
581 std::move(set_hp_f), matrix.readwrite(ij_lc));
+
582 }
+
583}
+
+
584
585}
+
586}
enum_output.h
dlaf::comm::CommunicatorGrid
Definition communicator_grid.h:37
dlaf::comm::CommunicatorPipeline
Definition communicator_pipeline.h:41
@@ -591,9 +592,9 @@
dlaf::internal::Policy
Definition policy.h:24
dlaf::matrix::Distribution
Definition distribution.h:111
-
dlaf::matrix::Matrix
Definition matrix.h:61
-
dlaf::matrix::Matrix::readwrite
ReadWriteSenderType readwrite(const LocalTileIndex &index) noexcept
Definition matrix.h:153
-
dlaf::matrix::util::internal::getter_random
Callable that returns random values in the range [-1, 1].
Definition util_matrix.h:148
+
dlaf::matrix::Matrix
Definition matrix.h:62
+
dlaf::matrix::Matrix::readwrite
ReadWriteSenderType readwrite(const LocalTileIndex &index) noexcept
Definition matrix.h:154
+
dlaf::matrix::util::internal::getter_random
Callable that returns random values in the range [-1, 1].
Definition util_matrix.h:149
@@ -602,25 +603,25 @@
dlaf::matrix::SubDistributionSpec
Contains information to create a sub-distribution.
Definition distribution.h:60
dlaf::conj
std::complex< T > conj(const std::complex< T > number)
Return complex conjugate of a complex number.
Definition types.h:166
-
dlaf::matrix::multipliable
bool multipliable(const MatrixLikeA< const T, D > &a, const MatrixLikeB< const T, D > &b, const MatrixLikeC< const T, D > &c, const blas::Op opA, const blas::Op opB) noexcept
Returns true if matrices a, b and c have matrix multipliable sizes and block sizes.
Definition util_matrix.h:124
-
dlaf::matrix::equal_blocksize
bool equal_blocksize(const Matrix< const T, D1 > &lhs, Matrix< const T, D2 > &rhs) noexcept
Returns true if matrices have equal blocksizes.
Definition util_matrix.h:66
-
dlaf::matrix::util::set
void set(Matrix< T, Device::CPU > &matrix, ElementGetter el_f)
Definition util_matrix.h:223
-
dlaf::matrix::util::set_random_hermitian_banded
void set_random_hermitian_banded(Matrix< T, Device::CPU > &matrix, const SizeType band_size)
Definition util_matrix.h:495
-
dlaf::matrix::util::set_identity
void set_identity(Matrix< T, Device::CPU > &matrix)
Definition util_matrix.h:278
-
dlaf::matrix::square_blocksize
bool square_blocksize(const MatrixLike &m) noexcept
Returns true if the matrix block size is square.
Definition util_matrix.h:48
-
dlaf::matrix::util::set_random_hermitian
void set_random_hermitian(Matrix< T, Device::CPU > &matrix)
Definition util_matrix.h:477
-
dlaf::matrix::equal_process_grid
bool equal_process_grid(const MatrixLike< const T, D > &m, const comm::CommunicatorGrid &g) noexcept
Returns true if the matrix is distributed on the communication grid.
Definition util_matrix.h:78
-
dlaf::matrix::single_tile_per_block
bool single_tile_per_block(const MatrixLike &m) noexcept
Returns true if the matrix has a single tile per block.
Definition util_matrix.h:54
-
dlaf::matrix::util::internal::set_random_hermitian_with_offset
void set_random_hermitian_with_offset(Matrix< T, Device::CPU > &matrix, const SizeType offset_value, std::optional< SizeType > band_size=std::nullopt)
Definition util_matrix.h:397
-
dlaf::matrix::same_process_grid
bool same_process_grid(const MatrixLikeA< const T, D1 > &a, const MatrixLikeB< const T, D2 > &b) noexcept
Returns true if the two matrices are distributed on the same grid.
Definition util_matrix.h:99
-
dlaf::matrix::equal_distributions
bool equal_distributions(const Matrix< const T, D1 > &lhs, const Matrix< const T, D2 > &rhs) noexcept
Returns true if the matrices are distributed the same way.
Definition util_matrix.h:105
-
dlaf::matrix::util::set_random
void set_random(Matrix< T, Device::CPU > &matrix)
Definition util_matrix.h:297
-
dlaf::matrix::local_matrix
bool local_matrix(const MatrixLike< const T, D > &m) noexcept
Returns true if the matrix is local to a process.
Definition util_matrix.h:72
-
dlaf::matrix::multipliable_sizes
bool multipliable_sizes(common::Size2D< IndexT, Tag > a, common::Size2D< IndexT, Tag > b, common::Size2D< IndexT, Tag > c, const blas::Op opA, const blas::Op opB) noexcept
Returns true if the sizes are compatible for matrix multiplication.
Definition util_matrix.h:111
-
dlaf::matrix::square_size
bool square_size(const MatrixLike &m) noexcept
Returns true if the matrix is square.
Definition util_matrix.h:42
-
dlaf::matrix::equal_size
bool equal_size(const MatrixLikeA &lhs, const MatrixLikeB &rhs) noexcept
Returns true if matrices have equal sizes.
Definition util_matrix.h:60
-
dlaf::matrix::util::set_random_hermitian_positive_definite
void set_random_hermitian_positive_definite(Matrix< T, Device::CPU > &matrix)
Definition util_matrix.h:516
-
dlaf::matrix::util::set_random_non_zero_diagonal
void set_random_non_zero_diagonal(Matrix< T, Device::CPU > &matrix)
Definition util_matrix.h:537
+
dlaf::matrix::multipliable
bool multipliable(const MatrixLikeA< const T, D > &a, const MatrixLikeB< const T, D > &b, const MatrixLikeC< const T, D > &c, const blas::Op opA, const blas::Op opB) noexcept
Returns true if matrices a, b and c have matrix multipliable sizes and block sizes.
Definition util_matrix.h:125
+
dlaf::matrix::equal_blocksize
bool equal_blocksize(const Matrix< const T, D1 > &lhs, Matrix< const T, D2 > &rhs) noexcept
Returns true if matrices have equal blocksizes.
Definition util_matrix.h:67
+
dlaf::matrix::util::set
void set(Matrix< T, Device::CPU > &matrix, ElementGetter el_f)
Definition util_matrix.h:224
+
dlaf::matrix::util::set_random_hermitian_banded
void set_random_hermitian_banded(Matrix< T, Device::CPU > &matrix, const SizeType band_size)
Definition util_matrix.h:496
+
dlaf::matrix::util::set_identity
void set_identity(Matrix< T, Device::CPU > &matrix)
Definition util_matrix.h:279
+
dlaf::matrix::square_blocksize
bool square_blocksize(const MatrixLike &m) noexcept
Returns true if the matrix block size is square.
Definition util_matrix.h:49
+
dlaf::matrix::util::set_random_hermitian
void set_random_hermitian(Matrix< T, Device::CPU > &matrix)
Definition util_matrix.h:478
+
dlaf::matrix::equal_process_grid
bool equal_process_grid(const MatrixLike< const T, D > &m, const comm::CommunicatorGrid &g) noexcept
Returns true if the matrix is distributed on the communication grid.
Definition util_matrix.h:79
+
dlaf::matrix::single_tile_per_block
bool single_tile_per_block(const MatrixLike &m) noexcept
Returns true if the matrix has a single tile per block.
Definition util_matrix.h:55
+
dlaf::matrix::util::internal::set_random_hermitian_with_offset
void set_random_hermitian_with_offset(Matrix< T, Device::CPU > &matrix, const SizeType offset_value, std::optional< SizeType > band_size=std::nullopt)
Definition util_matrix.h:398
+
dlaf::matrix::same_process_grid
bool same_process_grid(const MatrixLikeA< const T, D1 > &a, const MatrixLikeB< const T, D2 > &b) noexcept
Returns true if the two matrices are distributed on the same grid.
Definition util_matrix.h:100
+
dlaf::matrix::equal_distributions
bool equal_distributions(const Matrix< const T, D1 > &lhs, const Matrix< const T, D2 > &rhs) noexcept
Returns true if the matrices are distributed the same way.
Definition util_matrix.h:106
+
dlaf::matrix::util::set_random
void set_random(Matrix< T, Device::CPU > &matrix)
Definition util_matrix.h:298
+
dlaf::matrix::local_matrix
bool local_matrix(const MatrixLike< const T, D > &m) noexcept
Returns true if the matrix is local to a process.
Definition util_matrix.h:73
+
dlaf::matrix::multipliable_sizes
bool multipliable_sizes(common::Size2D< IndexT, Tag > a, common::Size2D< IndexT, Tag > b, common::Size2D< IndexT, Tag > c, const blas::Op opA, const blas::Op opB) noexcept
Returns true if the sizes are compatible for matrix multiplication.
Definition util_matrix.h:112
+
dlaf::matrix::square_size
bool square_size(const MatrixLike &m) noexcept
Returns true if the matrix is square.
Definition util_matrix.h:43
+
dlaf::matrix::equal_size
bool equal_size(const MatrixLikeA &lhs, const MatrixLikeB &rhs) noexcept
Returns true if matrices have equal sizes.
Definition util_matrix.h:61
+
dlaf::matrix::util::set_random_hermitian_positive_definite
void set_random_hermitian_positive_definite(Matrix< T, Device::CPU > &matrix)
Definition util_matrix.h:517
+
dlaf::matrix::util::set_random_non_zero_diagonal
void set_random_non_zero_diagonal(Matrix< T, Device::CPU > &matrix)
Definition util_matrix.h:538
diff --git a/master/util__rocblas_8h_source.html b/master/util__rocblas_8h_source.html index 22f7850a88..b35ce7b90a 100644 --- a/master/util__rocblas_8h_source.html +++ b/master/util__rocblas_8h_source.html @@ -95,110 +95,112 @@
12
13#ifdef DLAF_WITH_HIP
14
-
15#include <blas.hh>
+
15#include <complex>
16
-
17#include <dlaf/gpu/blas/api.h>
-
18#include <dlaf/gpu/lapack/api.h>
-
19
-
20namespace dlaf::util {
-
21namespace internal {
-
22
-
23template <typename T>
-
24struct BlasToRocblasType {
-
25 using type = T;
-
26};
-
27
-
28template <>
-
29struct BlasToRocblasType<std::complex<float>> {
-
30 using type = rocblas_float_complex;
-
31};
-
32
-
33template <>
-
34struct BlasToRocblasType<std::complex<double>> {
-
35 using type = rocblas_double_complex;
-
36};
-
37
-
38template <typename T>
-
39struct BlasToRocblasType<const T> {
-
40 using type = const typename BlasToRocblasType<T>::type;
-
41};
-
42
-
43template <typename T>
-
44struct BlasToRocblasType<T*> {
-
45 using type = typename BlasToRocblasType<T>::type*;
-
46};
-
47
-
48}
+
17#include <blas.hh>
+
18
+
19#include <dlaf/gpu/blas/api.h>
+
20#include <dlaf/gpu/lapack/api.h>
+
21
+
22namespace dlaf::util {
+
23namespace internal {
+
24
+
25template <typename T>
+
26struct BlasToRocblasType {
+
27 using type = T;
+
28};
+
29
+
30template <>
+
31struct BlasToRocblasType<std::complex<float>> {
+
32 using type = rocblas_float_complex;
+
33};
+
34
+
35template <>
+
36struct BlasToRocblasType<std::complex<double>> {
+
37 using type = rocblas_double_complex;
+
38};
+
39
+
40template <typename T>
+
41struct BlasToRocblasType<const T> {
+
42 using type = const typename BlasToRocblasType<T>::type;
+
43};
+
44
+
45template <typename T>
+
46struct BlasToRocblasType<T*> {
+
47 using type = typename BlasToRocblasType<T>::type*;
+
48};
49
-
50template <typename T>
-
51constexpr typename internal::BlasToRocblasType<T>::type blasToRocblasCast(T p) {
-
52 return reinterpret_cast<typename internal::BlasToRocblasType<T>::type>(p);
-
53}
-
54
-
55inline constexpr rocblas_side blasToRocblas(const blas::Side side) {
-
56 switch (side) {
-
57 case blas::Side::Left:
-
58 return rocblas_side_left;
-
59 case blas::Side::Right:
-
60 return rocblas_side_right;
-
61 default:
-
62 return {};
-
63 }
-
64}
-
65
-
66inline constexpr rocblas_fill blasToRocblas(const blas::Uplo uplo) {
-
67 switch (uplo) {
-
68 case blas::Uplo::Lower:
-
69 return rocblas_fill_lower;
-
70 case blas::Uplo::Upper:
-
71 return rocblas_fill_upper;
-
72 case blas::Uplo::General:
-
73 return rocblas_fill_full;
-
74 default:
-
75 return {};
-
76 }
-
77}
-
78
-
79inline constexpr rocblas_operation blasToRocblas(const blas::Op op) {
-
80 switch (op) {
-
81 case blas::Op::NoTrans:
-
82 return rocblas_operation_none;
-
83 case blas::Op::Trans:
-
84 return rocblas_operation_transpose;
-
85 case blas::Op::ConjTrans:
-
86 return rocblas_operation_conjugate_transpose;
-
87 default:
-
88 return {};
-
89 }
-
90}
-
91
-
92inline constexpr rocblas_diagonal blasToRocblas(const blas::Diag diag) {
-
93 switch (diag) {
-
94 case blas::Diag::Unit:
-
95 return rocblas_diagonal_unit;
-
96 case blas::Diag::NonUnit:
-
97 return rocblas_diagonal_non_unit;
-
98 default:
-
99 return {};
-
100 }
-
101}
-
102
-
103inline constexpr rocblas_eform blasToRocblas(const int eigenvalueType) {
-
104 switch (eigenvalueType) {
-
105 case 1:
-
106 return rocblas_eform_ax;
-
107 case 2:
-
108 return rocblas_eform_abx;
-
109 case 3:
-
110 return rocblas_eform_bax;
-
111 default:
-
112 return {};
-
113 }
-
114}
-
115
+
50}
+
51
+
52template <typename T>
+
53constexpr typename internal::BlasToRocblasType<T>::type blasToRocblasCast(T p) {
+
54 return reinterpret_cast<typename internal::BlasToRocblasType<T>::type>(p);
+
55}
+
56
+
57inline constexpr rocblas_side blasToRocblas(const blas::Side side) {
+
58 switch (side) {
+
59 case blas::Side::Left:
+
60 return rocblas_side_left;
+
61 case blas::Side::Right:
+
62 return rocblas_side_right;
+
63 default:
+
64 return {};
+
65 }
+
66}
+
67
+
68inline constexpr rocblas_fill blasToRocblas(const blas::Uplo uplo) {
+
69 switch (uplo) {
+
70 case blas::Uplo::Lower:
+
71 return rocblas_fill_lower;
+
72 case blas::Uplo::Upper:
+
73 return rocblas_fill_upper;
+
74 case blas::Uplo::General:
+
75 return rocblas_fill_full;
+
76 default:
+
77 return {};
+
78 }
+
79}
+
80
+
81inline constexpr rocblas_operation blasToRocblas(const blas::Op op) {
+
82 switch (op) {
+
83 case blas::Op::NoTrans:
+
84 return rocblas_operation_none;
+
85 case blas::Op::Trans:
+
86 return rocblas_operation_transpose;
+
87 case blas::Op::ConjTrans:
+
88 return rocblas_operation_conjugate_transpose;
+
89 default:
+
90 return {};
+
91 }
+
92}
+
93
+
94inline constexpr rocblas_diagonal blasToRocblas(const blas::Diag diag) {
+
95 switch (diag) {
+
96 case blas::Diag::Unit:
+
97 return rocblas_diagonal_unit;
+
98 case blas::Diag::NonUnit:
+
99 return rocblas_diagonal_non_unit;
+
100 default:
+
101 return {};
+
102 }
+
103}
+
104
+
105inline constexpr rocblas_eform blasToRocblas(const int eigenvalueType) {
+
106 switch (eigenvalueType) {
+
107 case 1:
+
108 return rocblas_eform_ax;
+
109 case 2:
+
110 return rocblas_eform_abx;
+
111 case 3:
+
112 return rocblas_eform_bax;
+
113 default:
+
114 return {};
+
115 }
116}
117
-
118#endif
+
118}
+
119
+
120#endif
diff --git a/master/util__tile_8h_source.html b/master/util__tile_8h_source.html index 8b19ffe9fd..a2200150f2 100644 --- a/master/util__tile_8h_source.html +++ b/master/util__tile_8h_source.html @@ -131,7 +131,7 @@
48}
49}
50}
-
dlaf::matrix::Tile
Definition tile.h:332
+
dlaf::matrix::Tile
Definition tile.h:333
diff --git a/master/views_8h_source.html b/master/views_8h_source.html index 9ed145ea74..a75e940876 100644 --- a/master/views_8h_source.html +++ b/master/views_8h_source.html @@ -248,7 +248,7 @@
dlaf::common::Index2D::isIn
bool isIn(const Size2D< IndexT, Tag > &boundary) const noexcept
Definition index2d.h:214
dlaf::matrix::Distribution
Definition distribution.h:111
-
dlaf::matrix::Matrix
Definition matrix.h:61
+
dlaf::matrix::Matrix
Definition matrix.h:62
@@ -259,7 +259,7 @@
dlaf::matrix::SubPanelView
Definition views.h:132
dlaf::matrix::SubPanelView::SubPanelView
SubPanelView(Distribution dist, GlobalElementIndex offset_e, const SizeType ncols)
Definition views.h:146
dlaf::matrix::SubPanelView::cols
SizeType cols() const noexcept
Return the number of columns of elements part of this panel view.
Definition views.h:175
-
dlaf::matrix::SubTileSpec
Contains the information to create a subtile.
Definition tile.h:112
+
dlaf::matrix::SubTileSpec
Contains the information to create a subtile.
Definition tile.h:113
dlaf::matrix::internal::View
Definition views.h:32
dlaf::matrix::internal::View::View
View(Distribution dist, GlobalElementIndex start_offset)
Definition views.h:45
dlaf::matrix::internal::View::offsetElement
GlobalElementIndex offsetElement() const noexcept
Return the top left corner.
Definition views.h:60
diff --git a/master/with__temporary__tile_8h_source.html b/master/with__temporary__tile_8h_source.html index 6605437d8f..88baaf3fcd 100644 --- a/master/with__temporary__tile_8h_source.html +++ b/master/with__temporary__tile_8h_source.html @@ -245,7 +245,7 @@
204}
205}
dlaf::internal::Policy
Definition policy.h:24
-
dlaf::matrix::Matrix
Definition matrix.h:61
+
dlaf::matrix::Matrix
Definition matrix.h:62
copy_tile.h
dlaf::internal::moveNonConstTile
Definition with_temporary_tile.h:37