SLATE 2024.05.31
Software for Linear Algebra Targeting Exascale
|
Functions | |
void | slate::internal::makeParallelPivot (Direction direction, std::vector< Pivot > const &pivot, std::map< Pivot, Pivot > &pivot_map) |
Converts serial pivot vector to parallel pivot map. | |
template<typename scalar_t > | |
void | slate::internal::permuteRows (internal::TargetType< Target::HostTask >, Direction direction, Matrix< scalar_t > &A, std::vector< Pivot > &pivot, Layout layout, int priority, int tag_base, int queue_index) |
Permutes rows of a general matrix according to the pivot vector. | |
template<Target target = Target::HostTask, typename scalar_t > | |
void | slate::internal::permuteRows (Direction direction, Matrix< scalar_t > &&A, std::vector< Pivot > &pivot, Layout layout, int priority, int tag_base, int queue_index) |
Permutes rows according to the pivot vector. | |
template<typename scalar_t > | |
void | slate::internal::permuteRows (internal::TargetType< Target::Devices >, Direction direction, Matrix< scalar_t > &A, std::vector< Pivot > &pivot, Layout layout, int priority, int tag_base, int queue_index) |
Permutes rows of a general matrix according to the pivot vector. | |
template<typename scalar_t > | |
void | slate::internal::swapRow (int64_t j_offset, int64_t n, HermitianMatrix< scalar_t > &A, Op op1, std::tuple< int64_t, int64_t > &&ij_tuple_1, int64_t offset_i1, Op op2, std::tuple< int64_t, int64_t > &&ij_tuple_2, int64_t offset_i2, int tag) |
Swap a partial row of two tiles, either locally or remotely. | |
template<typename scalar_t > | |
void | slate::internal::swapElement (HermitianMatrix< scalar_t > &A, std::tuple< int64_t, int64_t > &&ij_tuple_1, int64_t offset_i1, int64_t offset_j1, std::tuple< int64_t, int64_t > &&ij_tuple_2, int64_t offset_i2, int64_t offset_j2, int tag) |
Swap a single element of two tiles, either locally or remotely. | |
template<typename scalar_t > | |
void | slate::internal::permuteRowsCols (internal::TargetType< Target::HostTask >, Direction direction, HermitianMatrix< scalar_t > &A, std::vector< Pivot > &pivot, int priority, int tag) |
Permutes rows and cols, symmetrically, of a Hermitian matrix according to the pivot vector. | |
template<Target target = Target::HostTask, typename scalar_t > | |
void | slate::internal::permuteRowsCols (Direction direction, HermitianMatrix< scalar_t > &&A, std::vector< Pivot > &pivot, int priority, int tag) |
Permutes rows and columns symmetrically according to the pivot vector. | |
void slate::internal::makeParallelPivot | ( | Direction | direction, |
std::vector< Pivot > const & | pivot, | ||
std::map< Pivot, Pivot > & | pivot_map | ||
) |
Converts serial pivot vector to parallel pivot map.
[in] | direction | Direction of pivoting:
|
[in] | in_pivot | Serial (LAPACK-style) pivot vector. |
[in,out] | pivot | Parallel pivot for out-of-place pivoting. |
void slate::internal::permuteRows | ( | Direction | direction, |
Matrix< scalar_t > && | A, | ||
std::vector< Pivot > & | pivot, | ||
Layout | layout, | ||
int | priority, | ||
int | tag_base, | ||
int | queue_index | ||
) |
Permutes rows according to the pivot vector.
Dispatches to target implementations.
[in] | direction | Whether the permutation matrix should be applied from the left or right |
[in,out] | A | The matrix to permute |
[in] | pivot | The vector of rows to swap |
[in] | layout | Indicates the Layout (ColMajor/RowMajor) to operate with. Local tiles of matrix on target devices will be converted to layout. |
[in] | priority | The priority to use for internal tasks |
[in] | tag_base | The communication for the jth tile column of A uses the MPI tag tag_base+j |
[in] | queue_index | For Target::Devices, which BLAS++ queue to use |
void slate::internal::permuteRows | ( | internal::TargetType< Target::Devices > | , |
Direction | direction, | ||
Matrix< scalar_t > & | A, | ||
std::vector< Pivot > & | pivot, | ||
Layout | layout, | ||
int | priority, | ||
int | tag_base, | ||
int | queue_index | ||
) |
Permutes rows of a general matrix according to the pivot vector.
GPU device implementation. todo: Restructure similarly to Hermitian permute (use the auxiliary swap functions). todo: Just one function forwarding target.
void slate::internal::permuteRows | ( | internal::TargetType< Target::HostTask > | , |
Direction | direction, | ||
Matrix< scalar_t > & | A, | ||
std::vector< Pivot > & | pivot, | ||
Layout | layout, | ||
int | priority, | ||
int | tag_base, | ||
int | queue_index | ||
) |
Permutes rows of a general matrix according to the pivot vector.
Host implementation. todo: Restructure similarly to Hermitian permuteRowsCols (use the auxiliary swap functions).
void slate::internal::permuteRowsCols | ( | Direction | direction, |
HermitianMatrix< scalar_t > && | A, | ||
std::vector< Pivot > & | pivot, | ||
int | priority, | ||
int | tag | ||
) |
Permutes rows and columns symmetrically according to the pivot vector.
Dispatches to target implementations.
void slate::internal::permuteRowsCols | ( | internal::TargetType< Target::HostTask > | , |
Direction | direction, | ||
HermitianMatrix< scalar_t > & | A, | ||
std::vector< Pivot > & | pivot, | ||
int | priority, | ||
int | tag | ||
) |
Permutes rows and cols, symmetrically, of a Hermitian matrix according to the pivot vector.
Host implementation.
Here, lowercase & uppercase are conjugate pairs, e.g., d = conj( D ). Input is lower part of:
i1 i2 [ . A | | P | ] } i1: [ a b C | D | E F G | H ] } tile row 0 [ c . | | Q | ] } [-------+---+-------+---] [ d | . | R | ] } tile rows 1 [-------+---+-------+---] [ e | | . S | ] } i2: [ p f q | r | s t U | V ] } tile row 2 [ g | | u . | ] } [-------+---+-------+---] [ h | | v | . ] } tile rows 3
On output, rows i1, i2 and cols i1, i2 are swapped. Output is lower part of:
[ . P | | A | ] } i1: [ p t q | r | s f U | V ] } tile row 0 [ Q . | | c | ] } [-------+---+-------+---] [ R | . | d | ] } tile rows 1 [-------+---+-------+---] [ S | | . e | ] } i2: [ a F C | D | E b G | H ] } tile row 2 [ u | | g . | ] } [-------+---+-------+---] [ v | | h | . ] } tile rows 3
void slate::internal::swapElement | ( | HermitianMatrix< scalar_t > & | A, |
std::tuple< int64_t, int64_t > && | ij_tuple_1, | ||
int64_t | offset_i1, | ||
int64_t | offset_j1, | ||
std::tuple< int64_t, int64_t > && | ij_tuple_2, | ||
int64_t | offset_i2, | ||
int64_t | offset_j2, | ||
int | tag | ||
) |
Swap a single element of two tiles, either locally or remotely.
Swaps A( ij_tuple_1 )[ offset_i1, offset_j1 ] and A( ij_tuple_2 )[ offset_i2, offset_j2 ].
void slate::internal::swapRow | ( | int64_t | j_offset, |
int64_t | n, | ||
HermitianMatrix< scalar_t > & | A, | ||
Op | op1, | ||
std::tuple< int64_t, int64_t > && | ij_tuple_1, | ||
int64_t | offset_i1, | ||
Op | op2, | ||
std::tuple< int64_t, int64_t > && | ij_tuple_2, | ||
int64_t | offset_i2, | ||
int | tag | ||
) |
Swap a partial row of two tiles, either locally or remotely.
Swaps op1( A( ij_tuple_1 ) )[ offset_i1, j_offset : j_offset+n-1 ] and op2( A( ij_tuple_2 ) )[ offset_i2, j_offset : j_offset+n-1 ]. If op1 != op2, also conjugates both vectors.